blob: 9f46de2ba7a7d58214fc63d457b0087108632c43 [file] [log] [blame]
Sage Weil4e7a5dc2009-11-18 16:19:57 -08001#include "ceph_debug.h"
2
3#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09004#include <linux/slab.h>
Sage Weil4e7a5dc2009-11-18 16:19:57 -08005#include <linux/err.h>
Sage Weild45d0d92010-04-20 15:20:33 -07006#include <linux/slab.h>
Sage Weil4e7a5dc2009-11-18 16:19:57 -08007
8#include "types.h"
9#include "auth_none.h"
Sage Weilec0994e2010-02-02 16:25:35 -080010#include "auth_x.h"
Sage Weil4e7a5dc2009-11-18 16:19:57 -080011#include "decode.h"
12#include "super.h"
13
14#include "messenger.h"
15
16/*
17 * get protocol handler
18 */
19static u32 supported_protocols[] = {
Sage Weilec0994e2010-02-02 16:25:35 -080020 CEPH_AUTH_NONE,
21 CEPH_AUTH_CEPHX
Sage Weil4e7a5dc2009-11-18 16:19:57 -080022};
23
24int ceph_auth_init_protocol(struct ceph_auth_client *ac, int protocol)
25{
26 switch (protocol) {
27 case CEPH_AUTH_NONE:
28 return ceph_auth_none_init(ac);
Sage Weilec0994e2010-02-02 16:25:35 -080029 case CEPH_AUTH_CEPHX:
30 return ceph_x_init(ac);
Sage Weil4e7a5dc2009-11-18 16:19:57 -080031 default:
32 return -ENOENT;
33 }
34}
35
36/*
37 * setup, teardown.
38 */
39struct ceph_auth_client *ceph_auth_init(const char *name, const char *secret)
40{
41 struct ceph_auth_client *ac;
42 int ret;
43
44 dout("auth_init name '%s' secret '%s'\n", name, secret);
45
46 ret = -ENOMEM;
47 ac = kzalloc(sizeof(*ac), GFP_NOFS);
48 if (!ac)
49 goto out;
50
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 secret %s\n", ac->name, secret);
57 ac->secret = secret;
58 return ac;
59
60out:
61 return ERR_PTR(ret);
62}
63
64void 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 */
75void ceph_auth_reset(struct ceph_auth_client *ac)
76{
77 dout("auth_reset %p\n", ac);
78 if (ac->ops && !ac->negotiating)
79 ac->ops->reset(ac);
80 ac->negotiating = true;
81}
82
83int ceph_entity_name_encode(const char *name, void **p, void *end)
84{
85 int len = strlen(name);
86
87 if (*p + 2*sizeof(u32) + len > end)
88 return -ERANGE;
89 ceph_encode_32(p, CEPH_ENTITY_TYPE_CLIENT);
90 ceph_encode_32(p, len);
91 ceph_encode_copy(p, name, len);
92 return 0;
93}
94
95/*
96 * Initiate protocol negotiation with monitor. Include entity name
97 * and list supported protocols.
98 */
99int ceph_auth_build_hello(struct ceph_auth_client *ac, void *buf, size_t len)
100{
101 struct ceph_mon_request_header *monhdr = buf;
102 void *p = monhdr + 1, *end = buf + len, *lenp;
103 int i, num;
104 int ret;
105
106 dout("auth_build_hello\n");
107 monhdr->have_version = 0;
108 monhdr->session_mon = cpu_to_le16(-1);
109 monhdr->session_mon_tid = 0;
110
111 ceph_encode_32(&p, 0); /* no protocol, yet */
112
113 lenp = p;
114 p += sizeof(u32);
115
Sage Weil07c87392010-02-04 09:42:20 -0800116 ceph_decode_need(&p, end, 1 + sizeof(u32), bad);
117 ceph_encode_8(&p, 1);
Sage Weil4e7a5dc2009-11-18 16:19:57 -0800118 num = ARRAY_SIZE(supported_protocols);
119 ceph_encode_32(&p, num);
Sage Weil07c87392010-02-04 09:42:20 -0800120 ceph_decode_need(&p, end, num * sizeof(u32), bad);
Sage Weil4e7a5dc2009-11-18 16:19:57 -0800121 for (i = 0; i < num; i++)
122 ceph_encode_32(&p, supported_protocols[i]);
123
124 ret = ceph_entity_name_encode(ac->name, &p, end);
125 if (ret < 0)
126 return ret;
127 ceph_decode_need(&p, end, sizeof(u64), bad);
128 ceph_encode_64(&p, ac->global_id);
129
130 ceph_encode_32(&lenp, p - lenp - sizeof(u32));
131 return p - buf;
132
133bad:
134 return -ERANGE;
135}
136
Sage Weil9bd2e6f2010-02-02 16:21:06 -0800137int ceph_build_auth_request(struct ceph_auth_client *ac,
138 void *msg_buf, size_t msg_len)
139{
140 struct ceph_mon_request_header *monhdr = msg_buf;
141 void *p = monhdr + 1;
142 void *end = msg_buf + msg_len;
143 int ret;
144
145 monhdr->have_version = 0;
146 monhdr->session_mon = cpu_to_le16(-1);
147 monhdr->session_mon_tid = 0;
148
149 ceph_encode_32(&p, ac->protocol);
150
151 ret = ac->ops->build_request(ac, p + sizeof(u32), end);
152 if (ret < 0) {
Sage Weil559c1e02010-05-14 09:55:18 -0700153 pr_err("error %d building auth method %s request\n", ret,
154 ac->ops->name);
Sage Weil9bd2e6f2010-02-02 16:21:06 -0800155 return ret;
156 }
157 dout(" built request %d bytes\n", ret);
158 ceph_encode_32(&p, ret);
159 return p + ret - msg_buf;
160}
161
Sage Weil4e7a5dc2009-11-18 16:19:57 -0800162/*
163 * Handle auth message from monitor.
164 */
165int ceph_handle_auth_reply(struct ceph_auth_client *ac,
166 void *buf, size_t len,
167 void *reply_buf, size_t reply_len)
168{
169 void *p = buf;
170 void *end = buf + len;
171 int protocol;
172 s32 result;
173 u64 global_id;
174 void *payload, *payload_end;
175 int payload_len;
176 char *result_msg;
177 int result_msg_len;
178 int ret = -EINVAL;
179
180 dout("handle_auth_reply %p %p\n", p, end);
181 ceph_decode_need(&p, end, sizeof(u32) * 3 + sizeof(u64), bad);
182 protocol = ceph_decode_32(&p);
183 result = ceph_decode_32(&p);
184 global_id = ceph_decode_64(&p);
185 payload_len = ceph_decode_32(&p);
186 payload = p;
187 p += payload_len;
188 ceph_decode_need(&p, end, sizeof(u32), bad);
189 result_msg_len = ceph_decode_32(&p);
190 result_msg = p;
191 p += result_msg_len;
192 if (p != end)
193 goto bad;
194
195 dout(" result %d '%.*s' gid %llu len %d\n", result, result_msg_len,
196 result_msg, global_id, payload_len);
197
198 payload_end = payload + payload_len;
199
200 if (global_id && ac->global_id != global_id) {
201 dout(" set global_id %lld -> %lld\n", ac->global_id, global_id);
202 ac->global_id = global_id;
203 }
204
205 if (ac->negotiating) {
Yehuda Sadehdc146572009-11-20 13:59:13 -0800206 /* server does not support our protocols? */
207 if (!protocol && result < 0) {
208 ret = result;
209 goto out;
210 }
Sage Weil4e7a5dc2009-11-18 16:19:57 -0800211 /* set up (new) protocol handler? */
212 if (ac->protocol && ac->protocol != protocol) {
213 ac->ops->destroy(ac);
214 ac->protocol = 0;
215 ac->ops = NULL;
216 }
217 if (ac->protocol != protocol) {
218 ret = ceph_auth_init_protocol(ac, protocol);
219 if (ret) {
Sage Weil559c1e02010-05-14 09:55:18 -0700220 pr_err("error %d on auth method %s init\n",
221 ret, ac->ops->name);
Sage Weil4e7a5dc2009-11-18 16:19:57 -0800222 goto out;
223 }
224 }
Sage Weil9bd2e6f2010-02-02 16:21:06 -0800225
226 ac->negotiating = false;
Sage Weil4e7a5dc2009-11-18 16:19:57 -0800227 }
228
229 ret = ac->ops->handle_reply(ac, result, payload, payload_end);
230 if (ret == -EAGAIN) {
Sage Weil9bd2e6f2010-02-02 16:21:06 -0800231 return ceph_build_auth_request(ac, reply_buf, reply_len);
Sage Weil4e7a5dc2009-11-18 16:19:57 -0800232 } else if (ret) {
Sage Weil559c1e02010-05-14 09:55:18 -0700233 pr_err("auth method '%s' error %d\n", ac->ops->name, ret);
Sage Weil4e7a5dc2009-11-18 16:19:57 -0800234 return ret;
235 }
236 return 0;
237
238bad:
239 pr_err("failed to decode auth msg\n");
240out:
241 return ret;
242}
243
Sage Weil9bd2e6f2010-02-02 16:21:06 -0800244int ceph_build_auth(struct ceph_auth_client *ac,
245 void *msg_buf, size_t msg_len)
246{
247 if (!ac->protocol)
248 return ceph_auth_build_hello(ac, msg_buf, msg_len);
249 BUG_ON(!ac->ops);
250 if (!ac->ops->is_authenticated(ac))
251 return ceph_build_auth_request(ac, msg_buf, msg_len);
252 return 0;
253}
Sage Weil4e7a5dc2009-11-18 16:19:57 -0800254
Sage Weil9bd2e6f2010-02-02 16:21:06 -0800255int ceph_auth_is_authenticated(struct ceph_auth_client *ac)
256{
257 if (!ac->ops)
258 return 0;
259 return ac->ops->is_authenticated(ac);
260}