]> git.karo-electronics.de Git - karo-tx-linux.git/blob - net/ceph/auth.c
Merge git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf
[karo-tx-linux.git] / net / ceph / auth.c
1 #include <linux/ceph/ceph_debug.h>
2
3 #include <linux/module.h>
4 #include <linux/err.h>
5 #include <linux/slab.h>
6
7 #include <linux/ceph/types.h>
8 #include <linux/ceph/decode.h>
9 #include <linux/ceph/libceph.h>
10 #include <linux/ceph/messenger.h>
11 #include "auth_none.h"
12 #include "auth_x.h"
13
14
15 /*
16  * get protocol handler
17  */
18 static u32 supported_protocols[] = {
19         CEPH_AUTH_NONE,
20         CEPH_AUTH_CEPHX
21 };
22
23 static int ceph_auth_init_protocol(struct ceph_auth_client *ac, int protocol)
24 {
25         switch (protocol) {
26         case CEPH_AUTH_NONE:
27                 return ceph_auth_none_init(ac);
28         case CEPH_AUTH_CEPHX:
29                 return ceph_x_init(ac);
30         default:
31                 return -ENOENT;
32         }
33 }
34
35 /*
36  * setup, teardown.
37  */
38 struct ceph_auth_client *ceph_auth_init(const char *name, const struct ceph_crypto_key *key)
39 {
40         struct ceph_auth_client *ac;
41         int ret;
42
43         dout("auth_init name '%s'\n", name);
44
45         ret = -ENOMEM;
46         ac = kzalloc(sizeof(*ac), GFP_NOFS);
47         if (!ac)
48                 goto out;
49
50         mutex_init(&ac->mutex);
51         ac->negotiating = true;
52         if (name)
53                 ac->name = name;
54         else
55                 ac->name = CEPH_AUTH_NAME_DEFAULT;
56         dout("auth_init name %s\n", ac->name);
57         ac->key = key;
58         return ac;
59
60 out:
61         return ERR_PTR(ret);
62 }
63
64 void ceph_auth_destroy(struct ceph_auth_client *ac)
65 {
66         dout("auth_destroy %p\n", ac);
67         if (ac->ops)
68                 ac->ops->destroy(ac);
69         kfree(ac);
70 }
71
72 /*
73  * Reset occurs when reconnecting to the monitor.
74  */
75 void ceph_auth_reset(struct ceph_auth_client *ac)
76 {
77         mutex_lock(&ac->mutex);
78         dout("auth_reset %p\n", ac);
79         if (ac->ops && !ac->negotiating)
80                 ac->ops->reset(ac);
81         ac->negotiating = true;
82         mutex_unlock(&ac->mutex);
83 }
84
85 int ceph_entity_name_encode(const char *name, void **p, void *end)
86 {
87         int len = strlen(name);
88
89         if (*p + 2*sizeof(u32) + len > end)
90                 return -ERANGE;
91         ceph_encode_32(p, CEPH_ENTITY_TYPE_CLIENT);
92         ceph_encode_32(p, len);
93         ceph_encode_copy(p, name, len);
94         return 0;
95 }
96
97 /*
98  * Initiate protocol negotiation with monitor.  Include entity name
99  * and list supported protocols.
100  */
101 int ceph_auth_build_hello(struct ceph_auth_client *ac, void *buf, size_t len)
102 {
103         struct ceph_mon_request_header *monhdr = buf;
104         void *p = monhdr + 1, *end = buf + len, *lenp;
105         int i, num;
106         int ret;
107
108         mutex_lock(&ac->mutex);
109         dout("auth_build_hello\n");
110         monhdr->have_version = 0;
111         monhdr->session_mon = cpu_to_le16(-1);
112         monhdr->session_mon_tid = 0;
113
114         ceph_encode_32(&p, 0);  /* no protocol, yet */
115
116         lenp = p;
117         p += sizeof(u32);
118
119         ceph_decode_need(&p, end, 1 + sizeof(u32), bad);
120         ceph_encode_8(&p, 1);
121         num = ARRAY_SIZE(supported_protocols);
122         ceph_encode_32(&p, num);
123         ceph_decode_need(&p, end, num * sizeof(u32), bad);
124         for (i = 0; i < num; i++)
125                 ceph_encode_32(&p, supported_protocols[i]);
126
127         ret = ceph_entity_name_encode(ac->name, &p, end);
128         if (ret < 0)
129                 goto out;
130         ceph_decode_need(&p, end, sizeof(u64), bad);
131         ceph_encode_64(&p, ac->global_id);
132
133         ceph_encode_32(&lenp, p - lenp - sizeof(u32));
134         ret = p - buf;
135 out:
136         mutex_unlock(&ac->mutex);
137         return ret;
138
139 bad:
140         ret = -ERANGE;
141         goto out;
142 }
143
144 static int ceph_build_auth_request(struct ceph_auth_client *ac,
145                                    void *msg_buf, size_t msg_len)
146 {
147         struct ceph_mon_request_header *monhdr = msg_buf;
148         void *p = monhdr + 1;
149         void *end = msg_buf + msg_len;
150         int ret;
151
152         monhdr->have_version = 0;
153         monhdr->session_mon = cpu_to_le16(-1);
154         monhdr->session_mon_tid = 0;
155
156         ceph_encode_32(&p, ac->protocol);
157
158         ret = ac->ops->build_request(ac, p + sizeof(u32), end);
159         if (ret < 0) {
160                 pr_err("error %d building auth method %s request\n", ret,
161                        ac->ops->name);
162                 goto out;
163         }
164         dout(" built request %d bytes\n", ret);
165         ceph_encode_32(&p, ret);
166         ret = p + ret - msg_buf;
167 out:
168         return ret;
169 }
170
171 /*
172  * Handle auth message from monitor.
173  */
174 int ceph_handle_auth_reply(struct ceph_auth_client *ac,
175                            void *buf, size_t len,
176                            void *reply_buf, size_t reply_len)
177 {
178         void *p = buf;
179         void *end = buf + len;
180         int protocol;
181         s32 result;
182         u64 global_id;
183         void *payload, *payload_end;
184         int payload_len;
185         char *result_msg;
186         int result_msg_len;
187         int ret = -EINVAL;
188
189         mutex_lock(&ac->mutex);
190         dout("handle_auth_reply %p %p\n", p, end);
191         ceph_decode_need(&p, end, sizeof(u32) * 3 + sizeof(u64), bad);
192         protocol = ceph_decode_32(&p);
193         result = ceph_decode_32(&p);
194         global_id = ceph_decode_64(&p);
195         payload_len = ceph_decode_32(&p);
196         payload = p;
197         p += payload_len;
198         ceph_decode_need(&p, end, sizeof(u32), bad);
199         result_msg_len = ceph_decode_32(&p);
200         result_msg = p;
201         p += result_msg_len;
202         if (p != end)
203                 goto bad;
204
205         dout(" result %d '%.*s' gid %llu len %d\n", result, result_msg_len,
206              result_msg, global_id, payload_len);
207
208         payload_end = payload + payload_len;
209
210         if (global_id && ac->global_id != global_id) {
211                 dout(" set global_id %lld -> %lld\n", ac->global_id, global_id);
212                 ac->global_id = global_id;
213         }
214
215         if (ac->negotiating) {
216                 /* server does not support our protocols? */
217                 if (!protocol && result < 0) {
218                         ret = result;
219                         goto out;
220                 }
221                 /* set up (new) protocol handler? */
222                 if (ac->protocol && ac->protocol != protocol) {
223                         ac->ops->destroy(ac);
224                         ac->protocol = 0;
225                         ac->ops = NULL;
226                 }
227                 if (ac->protocol != protocol) {
228                         ret = ceph_auth_init_protocol(ac, protocol);
229                         if (ret) {
230                                 pr_err("error %d on auth protocol %d init\n",
231                                        ret, protocol);
232                                 goto out;
233                         }
234                 }
235
236                 ac->negotiating = false;
237         }
238
239         ret = ac->ops->handle_reply(ac, result, payload, payload_end);
240         if (ret == -EAGAIN) {
241                 ret = ceph_build_auth_request(ac, reply_buf, reply_len);
242         } else if (ret) {
243                 pr_err("auth method '%s' error %d\n", ac->ops->name, ret);
244         }
245
246 out:
247         mutex_unlock(&ac->mutex);
248         return ret;
249
250 bad:
251         pr_err("failed to decode auth msg\n");
252         ret = -EINVAL;
253         goto out;
254 }
255
256 int ceph_build_auth(struct ceph_auth_client *ac,
257                     void *msg_buf, size_t msg_len)
258 {
259         int ret = 0;
260
261         mutex_lock(&ac->mutex);
262         if (!ac->protocol)
263                 ret = ceph_auth_build_hello(ac, msg_buf, msg_len);
264         else if (ac->ops->should_authenticate(ac))
265                 ret = ceph_build_auth_request(ac, msg_buf, msg_len);
266         mutex_unlock(&ac->mutex);
267         return ret;
268 }
269
270 int ceph_auth_is_authenticated(struct ceph_auth_client *ac)
271 {
272         int ret = 0;
273
274         mutex_lock(&ac->mutex);
275         if (ac->ops)
276                 ret = ac->ops->is_authenticated(ac);
277         mutex_unlock(&ac->mutex);
278         return ret;
279 }
280 EXPORT_SYMBOL(ceph_auth_is_authenticated);
281
282 int ceph_auth_create_authorizer(struct ceph_auth_client *ac,
283                                 int peer_type,
284                                 struct ceph_auth_handshake *auth)
285 {
286         int ret = 0;
287
288         mutex_lock(&ac->mutex);
289         if (ac->ops && ac->ops->create_authorizer)
290                 ret = ac->ops->create_authorizer(ac, peer_type, auth);
291         mutex_unlock(&ac->mutex);
292         return ret;
293 }
294 EXPORT_SYMBOL(ceph_auth_create_authorizer);
295
296 void ceph_auth_destroy_authorizer(struct ceph_auth_client *ac,
297                                   struct ceph_authorizer *a)
298 {
299         mutex_lock(&ac->mutex);
300         if (ac->ops && ac->ops->destroy_authorizer)
301                 ac->ops->destroy_authorizer(ac, a);
302         mutex_unlock(&ac->mutex);
303 }
304 EXPORT_SYMBOL(ceph_auth_destroy_authorizer);
305
306 int ceph_auth_update_authorizer(struct ceph_auth_client *ac,
307                                 int peer_type,
308                                 struct ceph_auth_handshake *a)
309 {
310         int ret = 0;
311
312         mutex_lock(&ac->mutex);
313         if (ac->ops && ac->ops->update_authorizer)
314                 ret = ac->ops->update_authorizer(ac, peer_type, a);
315         mutex_unlock(&ac->mutex);
316         return ret;
317 }
318 EXPORT_SYMBOL(ceph_auth_update_authorizer);
319
320 int ceph_auth_verify_authorizer_reply(struct ceph_auth_client *ac,
321                                       struct ceph_authorizer *a, size_t len)
322 {
323         int ret = 0;
324
325         mutex_lock(&ac->mutex);
326         if (ac->ops && ac->ops->verify_authorizer_reply)
327                 ret = ac->ops->verify_authorizer_reply(ac, a, len);
328         mutex_unlock(&ac->mutex);
329         return ret;
330 }
331 EXPORT_SYMBOL(ceph_auth_verify_authorizer_reply);
332
333 void ceph_auth_invalidate_authorizer(struct ceph_auth_client *ac, int peer_type)
334 {
335         mutex_lock(&ac->mutex);
336         if (ac->ops && ac->ops->invalidate_authorizer)
337                 ac->ops->invalidate_authorizer(ac, peer_type);
338         mutex_unlock(&ac->mutex);
339 }
340 EXPORT_SYMBOL(ceph_auth_invalidate_authorizer);