1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RGW_BASIC_TYPES_H
#define CEPH_RGW_BASIC_TYPES_H
#include <string>
#include "include/types.h"
struct rgw_user {
std::string tenant;
std::string id;
rgw_user() {}
// cppcheck-suppress noExplicitConstructor
rgw_user(const std::string& s) {
from_str(s);
}
rgw_user(const std::string& tenant, const std::string& id)
: tenant(tenant),
id(id) {
}
rgw_user(std::string&& tenant, std::string&& id)
: tenant(std::move(tenant)),
id(std::move(id)) {
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(tenant, bl);
encode(id, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(tenant, bl);
decode(id, bl);
DECODE_FINISH(bl);
}
void to_str(std::string& str) const {
if (!tenant.empty()) {
str = tenant + '$' + id;
} else {
str = id;
}
}
void clear() {
tenant.clear();
id.clear();
}
bool empty() const {
return id.empty();
}
string to_str() const {
string s;
to_str(s);
return s;
}
void from_str(const std::string& str) {
size_t pos = str.find('$');
if (pos != std::string::npos) {
tenant = str.substr(0, pos);
id = str.substr(pos + 1);
} else {
tenant.clear();
id = str;
}
}
rgw_user& operator=(const string& str) {
from_str(str);
return *this;
}
int compare(const rgw_user& u) const {
int r = tenant.compare(u.tenant);
if (r != 0)
return r;
return id.compare(u.id);
}
int compare(const string& str) const {
rgw_user u(str);
return compare(u);
}
bool operator!=(const rgw_user& rhs) const {
return (compare(rhs) != 0);
}
bool operator==(const rgw_user& rhs) const {
return (compare(rhs) == 0);
}
bool operator<(const rgw_user& rhs) const {
if (tenant < rhs.tenant) {
return true;
} else if (tenant > rhs.tenant) {
return false;
}
return (id < rhs.id);
}
};
WRITE_CLASS_ENCODER(rgw_user)
// Represents an identity. This is more wide-ranging than a
// 'User'. Its purposes is to be matched against by an
// IdentityApplier. The internal representation will doubtless change as
// more types are added. We may want to expose the type enum and make
// the member public so people can switch/case on it.
namespace rgw {
namespace auth {
class Principal {
enum types { User, Role, Tenant, Wildcard, OidcProvider };
types t;
rgw_user u;
string idp_url;
explicit Principal(types t)
: t(t) {}
Principal(types t, std::string&& n, std::string i)
: t(t), u(std::move(n), std::move(i)) {}
Principal(string&& idp_url)
: t(OidcProvider), idp_url(std::move(idp_url)) {}
public:
static Principal wildcard() {
return Principal(Wildcard);
}
static Principal user(std::string&& t, std::string&& u) {
return Principal(User, std::move(t), std::move(u));
}
static Principal role(std::string&& t, std::string&& u) {
return Principal(Role, std::move(t), std::move(u));
}
static Principal tenant(std::string&& t) {
return Principal(Tenant, std::move(t), {});
}
static Principal oidc_provider(string&& idp_url) {
return Principal(std::move(idp_url));
}
bool is_wildcard() const {
return t == Wildcard;
}
bool is_user() const {
return t == User;
}
bool is_role() const {
return t == Role;
}
bool is_tenant() const {
return t == Tenant;
}
bool is_oidc_provider() const {
return t == OidcProvider;
}
const std::string& get_tenant() const {
return u.tenant;
}
const std::string& get_id() const {
return u.id;
}
const string& get_idp_url() const {
return idp_url;
}
bool operator ==(const Principal& o) const {
return (t == o.t) && (u == o.u);
}
bool operator <(const Principal& o) const {
return (t < o.t) || ((t == o.t) && (u < o.u));
}
};
std::ostream& operator <<(std::ostream& m, const Principal& p);
}
}
class JSONObj;
void decode_json_obj(rgw_user& val, JSONObj *obj);
void encode_json(const char *name, const rgw_user& val, Formatter *f);
void encode_xml(const char *name, const rgw_user& val, Formatter *f);
inline ostream& operator<<(ostream& out, const rgw_user &u) {
string s;
u.to_str(s);
return out << s;
}
#endif
|
