RPCSEC_GSS remove all qop parameters
[linux-3.10.git] / net / sunrpc / auth_gss / gss_mech_switch.c
1 /*
2  *  linux/net/sunrpc/gss_mech_switch.c
3  *
4  *  Copyright (c) 2001 The Regents of the University of Michigan.
5  *  All rights reserved.
6  *
7  *  J. Bruce Fields   <bfields@umich.edu>
8  *
9  *  Redistribution and use in source and binary forms, with or without 
10  *  modification, are permitted provided that the following conditions
11  *  are met:
12  *
13  *  1. Redistributions of source code must retain the above copyright
14  *     notice, this list of conditions and the following disclaimer.
15  *  2. Redistributions in binary form must reproduce the above copyright
16  *     notice, this list of conditions and the following disclaimer in the 
17  *     documentation and/or other materials provided with the distribution.
18  *  3. Neither the name of the University nor the names of its
19  *     contributors may be used to endorse or promote products derived
20  *     from this software without specific prior written permission.
21  *
22  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
23  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
24  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
25  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
29  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
30  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  *
34  */
35
36 #include <linux/types.h>
37 #include <linux/slab.h>
38 #include <linux/module.h>
39 #include <linux/sunrpc/msg_prot.h>
40 #include <linux/sunrpc/gss_asn1.h>
41 #include <linux/sunrpc/auth_gss.h>
42 #include <linux/sunrpc/svcauth_gss.h>
43 #include <linux/sunrpc/gss_err.h>
44 #include <linux/sunrpc/sched.h>
45 #include <linux/sunrpc/gss_api.h>
46 #include <linux/sunrpc/clnt.h>
47
48 #ifdef RPC_DEBUG
49 # define RPCDBG_FACILITY        RPCDBG_AUTH
50 #endif
51
52 static LIST_HEAD(registered_mechs);
53 static DEFINE_SPINLOCK(registered_mechs_lock);
54
55 static void
56 gss_mech_free(struct gss_api_mech *gm)
57 {
58         struct pf_desc *pf;
59         int i;
60
61         for (i = 0; i < gm->gm_pf_num; i++) {
62                 pf = &gm->gm_pfs[i];
63                 if (pf->auth_domain_name)
64                         kfree(pf->auth_domain_name);
65                 pf->auth_domain_name = NULL;
66         }
67 }
68
69 static inline char *
70 make_auth_domain_name(char *name)
71 {
72         static char     *prefix = "gss/";
73         char            *new;
74
75         new = kmalloc(strlen(name) + strlen(prefix) + 1, GFP_KERNEL);
76         if (new) {
77                 strcpy(new, prefix);
78                 strcat(new, name);
79         }
80         return new;
81 }
82
83 static int
84 gss_mech_svc_setup(struct gss_api_mech *gm)
85 {
86         struct pf_desc *pf;
87         int i, status;
88
89         for (i = 0; i < gm->gm_pf_num; i++) {
90                 pf = &gm->gm_pfs[i];
91                 pf->auth_domain_name = make_auth_domain_name(pf->name);
92                 status = -ENOMEM;
93                 if (pf->auth_domain_name == NULL)
94                         goto out;
95                 status = svcauth_gss_register_pseudoflavor(pf->pseudoflavor,
96                                                         pf->auth_domain_name);
97                 if (status)
98                         goto out;
99         }
100         return 0;
101 out:
102         gss_mech_free(gm);
103         return status;
104 }
105
106 int
107 gss_mech_register(struct gss_api_mech *gm)
108 {
109         int status;
110
111         status = gss_mech_svc_setup(gm);
112         if (status)
113                 return status;
114         spin_lock(&registered_mechs_lock);
115         list_add(&gm->gm_list, &registered_mechs);
116         spin_unlock(&registered_mechs_lock);
117         dprintk("RPC:      registered gss mechanism %s\n", gm->gm_name);
118         return 0;
119 }
120
121 EXPORT_SYMBOL(gss_mech_register);
122
123 void
124 gss_mech_unregister(struct gss_api_mech *gm)
125 {
126         spin_lock(&registered_mechs_lock);
127         list_del(&gm->gm_list);
128         spin_unlock(&registered_mechs_lock);
129         dprintk("RPC:      unregistered gss mechanism %s\n", gm->gm_name);
130         gss_mech_free(gm);
131 }
132
133 EXPORT_SYMBOL(gss_mech_unregister);
134
135 struct gss_api_mech *
136 gss_mech_get(struct gss_api_mech *gm)
137 {
138         __module_get(gm->gm_owner);
139         return gm;
140 }
141
142 EXPORT_SYMBOL(gss_mech_get);
143
144 struct gss_api_mech *
145 gss_mech_get_by_name(const char *name)
146 {
147         struct gss_api_mech     *pos, *gm = NULL;
148
149         spin_lock(&registered_mechs_lock);
150         list_for_each_entry(pos, &registered_mechs, gm_list) {
151                 if (0 == strcmp(name, pos->gm_name)) {
152                         if (try_module_get(pos->gm_owner))
153                                 gm = pos;
154                         break;
155                 }
156         }
157         spin_unlock(&registered_mechs_lock);
158         return gm;
159
160 }
161
162 EXPORT_SYMBOL(gss_mech_get_by_name);
163
164 static inline int
165 mech_supports_pseudoflavor(struct gss_api_mech *gm, u32 pseudoflavor)
166 {
167         int i;
168
169         for (i = 0; i < gm->gm_pf_num; i++) {
170                 if (gm->gm_pfs[i].pseudoflavor == pseudoflavor)
171                         return 1;
172         }
173         return 0;
174 }
175
176 struct gss_api_mech *
177 gss_mech_get_by_pseudoflavor(u32 pseudoflavor)
178 {
179         struct gss_api_mech *pos, *gm = NULL;
180
181         spin_lock(&registered_mechs_lock);
182         list_for_each_entry(pos, &registered_mechs, gm_list) {
183                 if (!mech_supports_pseudoflavor(pos, pseudoflavor)) {
184                         module_put(pos->gm_owner);
185                         continue;
186                 }
187                 if (try_module_get(pos->gm_owner))
188                         gm = pos;
189                 break;
190         }
191         spin_unlock(&registered_mechs_lock);
192         return gm;
193 }
194
195 EXPORT_SYMBOL(gss_mech_get_by_pseudoflavor);
196
197 u32
198 gss_pseudoflavor_to_service(struct gss_api_mech *gm, u32 pseudoflavor)
199 {
200         int i;
201
202         for (i = 0; i < gm->gm_pf_num; i++) {
203                 if (gm->gm_pfs[i].pseudoflavor == pseudoflavor)
204                         return gm->gm_pfs[i].service;
205         }
206         return 0;
207 }
208
209 EXPORT_SYMBOL(gss_pseudoflavor_to_service);
210
211 char *
212 gss_service_to_auth_domain_name(struct gss_api_mech *gm, u32 service)
213 {
214         int i;
215
216         for (i = 0; i < gm->gm_pf_num; i++) {
217                 if (gm->gm_pfs[i].service == service)
218                         return gm->gm_pfs[i].auth_domain_name;
219         }
220         return NULL;
221 }
222
223 EXPORT_SYMBOL(gss_service_to_auth_domain_name);
224
225 void
226 gss_mech_put(struct gss_api_mech * gm)
227 {
228         module_put(gm->gm_owner);
229 }
230
231 EXPORT_SYMBOL(gss_mech_put);
232
233 /* The mech could probably be determined from the token instead, but it's just
234  * as easy for now to pass it in. */
235 int
236 gss_import_sec_context(const void *input_token, size_t bufsize,
237                        struct gss_api_mech      *mech,
238                        struct gss_ctx           **ctx_id)
239 {
240         if (!(*ctx_id = kmalloc(sizeof(**ctx_id), GFP_KERNEL)))
241                 return GSS_S_FAILURE;
242         memset(*ctx_id, 0, sizeof(**ctx_id));
243         (*ctx_id)->mech_type = gss_mech_get(mech);
244
245         return mech->gm_ops
246                 ->gss_import_sec_context(input_token, bufsize, *ctx_id);
247 }
248
249 /* gss_get_mic: compute a mic over message and return mic_token. */
250
251 u32
252 gss_get_mic(struct gss_ctx      *context_handle,
253             struct xdr_buf      *message,
254             struct xdr_netobj   *mic_token)
255 {
256          return context_handle->mech_type->gm_ops
257                 ->gss_get_mic(context_handle,
258                               message,
259                               mic_token);
260 }
261
262 /* gss_verify_mic: check whether the provided mic_token verifies message. */
263
264 u32
265 gss_verify_mic(struct gss_ctx           *context_handle,
266                struct xdr_buf           *message,
267                struct xdr_netobj        *mic_token)
268 {
269         return context_handle->mech_type->gm_ops
270                 ->gss_verify_mic(context_handle,
271                                  message,
272                                  mic_token);
273 }
274
275 u32
276 gss_wrap(struct gss_ctx *ctx_id,
277          int            offset,
278          struct xdr_buf *buf,
279          struct page    **inpages)
280 {
281         return ctx_id->mech_type->gm_ops
282                 ->gss_wrap(ctx_id, offset, buf, inpages);
283 }
284
285 u32
286 gss_unwrap(struct gss_ctx       *ctx_id,
287            int                  offset,
288            struct xdr_buf       *buf)
289 {
290         return ctx_id->mech_type->gm_ops
291                 ->gss_unwrap(ctx_id, offset, buf);
292 }
293
294
295 /* gss_delete_sec_context: free all resources associated with context_handle.
296  * Note this differs from the RFC 2744-specified prototype in that we don't
297  * bother returning an output token, since it would never be used anyway. */
298
299 u32
300 gss_delete_sec_context(struct gss_ctx   **context_handle)
301 {
302         dprintk("RPC:      gss_delete_sec_context deleting %p\n",
303                         *context_handle);
304
305         if (!*context_handle)
306                 return(GSS_S_NO_CONTEXT);
307         if ((*context_handle)->internal_ctx_id != 0)
308                 (*context_handle)->mech_type->gm_ops
309                         ->gss_delete_sec_context((*context_handle)
310                                                         ->internal_ctx_id);
311         if ((*context_handle)->mech_type)
312                 gss_mech_put((*context_handle)->mech_type);
313         kfree(*context_handle);
314         *context_handle=NULL;
315         return GSS_S_COMPLETE;
316 }