afs: fix SOLARIS builds conflicting 'u' define
[openafs.git] / src / afs / afs_tokens.c
1 /*
2  * Copyright (c) 2010 Your Filesystem Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR `AS IS'' AND ANY EXPRESS OR
14  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
15  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
16  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
20  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  */
24
25 #include <afsconfig.h>
26 #include "afs/param.h"
27 #include "afs/sysincludes.h"
28 #include "afsincludes.h"
29 #include "token.h"
30
31 /* A jar for storing tokens in */
32
33 /*!
34  * Return a token of the specified type from the selected tokenjar.
35  *
36  * @param[in] tokens
37  *      The tokenjar in which to search
38  * @param[in] type
39  *      The type of token to return
40  *
41  * @return
42  *      A tokenUnion structure, from which the desired token can be
43  *      accessed using the appropriate element of the union.
44  */
45 union tokenUnion *
46 afs_FindToken(struct tokenJar *tokens, rx_securityIndex type) {
47     while (tokens != NULL) {
48         if (tokens->type == type) {
49             return &tokens->content;
50         }
51         tokens = tokens->next;
52     }
53     return NULL;
54 }
55
56 /*!
57  * Free a single token
58  *
59  * This will free the given token. No attempt is made to unlink
60  * the token from its container, and it is an error to attempt to
61  * free a token which is still linked.
62  *
63  * This performs a secure free, setting all token information to 0
64  * before returning allocated data blocks to the kernel.
65  *
66  * Intended primarily for internal use.
67  *
68  * @param[in] token
69  *      The token to free
70  */
71
72 void
73 afs_FreeOneToken(struct tokenJar *token) {
74     if (token->next != NULL)
75         osi_Panic("Freeing linked token");
76
77     switch (token->type) {
78       case RX_SECIDX_KAD:
79         if (token->content.rxkad.ticket != NULL) {
80                 memset(token->content.rxkad.ticket, 0, token->content.rxkad.ticketLen);
81                 afs_osi_Free(token->content.rxkad.ticket,
82                              token->content.rxkad.ticketLen);
83         }
84         break;
85       default:
86         break;
87     }
88     memset(token, 0, sizeof(struct tokenJar));
89     afs_osi_Free(token, sizeof(struct tokenJar));
90 }
91
92 /*!
93  * Free a token jar
94  *
95  * Free all of the tokens in a given token jar. This will also set the
96  * pointer to the jar to NULL, to indicate that it has been freed.
97  *
98  * @param[in] tokenPtr
99  *      A pointer to the address of the tokenjar to free.
100  */
101 void
102 afs_FreeTokens(struct tokenJar **tokenPtr) {
103     struct tokenJar *next, *tokens;
104
105     tokens = *tokenPtr;
106     *tokenPtr = NULL;
107     while(tokens != NULL) {
108         next = tokens->next;
109         tokens->next = NULL; /* Unlink from chain */
110         afs_FreeOneToken(tokens);
111         tokens = next;
112     }
113 }
114
115 /*!
116  * Add a token to a token jar
117  *
118  * Add a new token to a token jar. If the jar already exists,
119  * then this token becomes the first in the jar. If it doesn't
120  * exist, then a new jar is created. The contents of the new
121  * token are initialised to 0 upon creation.
122  *
123  * @param[in] tokens
124  *      A pointer to the address of the token jar to populate
125  * @param[in] type
126  *      The type of token to create
127  *
128  * @return
129  *      A pointer to the tokenUnion of the newly created token,
130  *      which may then be used to populate the token.
131  */
132 union tokenUnion *
133 afs_AddToken(struct tokenJar **tokens, rx_securityIndex type) {
134     struct tokenJar *newToken;
135
136     newToken = afs_osi_Alloc(sizeof(struct tokenJar));
137     memset(newToken, 0, sizeof(*newToken));
138
139     newToken->type = type;
140     newToken->next = *tokens;
141     *tokens = newToken;
142
143     return &newToken->content;
144 }
145
146 /*!
147  * Indicate if a single token is expired
148  *
149  * @param[in] token
150  *      The token to check
151  * @param[in] now
152  *      The time to check against for expiry (typically the results of
153  *      calling osi_Time())
154  *
155  * @returns
156  *      True if the token has expired, false otherwise
157  */
158 int
159 afs_IsTokenExpired(struct tokenJar *token, afs_int32 now) {
160     switch (token->type) {
161       case RX_SECIDX_KAD:
162         if (token->content.rxkad.clearToken.EndTimestamp < now - NOTOKTIMEOUT)
163             return 1;
164         break;
165       default:
166         return 0;
167     }
168     return 0; /* not reached, but keep gcc happy */
169 }
170
171 /*!
172  * Indicate if a token is usable by the kernel module
173  *
174  * This determines whether a token is usable. A usable token is one that
175  * has not expired, and which is otherwise suitable for use.
176  *
177  * @param[in] token
178  *      The token to check
179  * @param[in] now
180  *      The time to use for the expiry check
181  *
182  * @returns
183  *      True if the token is usable, false otherwise
184  */
185 int
186 afs_IsTokenUsable(struct tokenJar *token, afs_int32 now) {
187
188     if (afs_IsTokenExpired(token, now))
189         return 0;
190
191     switch (token->type) {
192       case RX_SECIDX_KAD:
193         /* We assume that all non-expired rxkad tokens are usable by us */
194         return 1;
195       default :
196         return 0;
197     }
198 }
199
200 /*!
201  * Discard all expired tokens from a token jar
202  *
203  * This permanently removes all tokens which have expired from the token
204  * jar. Note that tokens which are not usable, but which have not expired,
205  * will not be deleted.
206  *
207  * @param[in] tokenPtr
208  *      A pointer to the address of the token jar to check
209  * @param[in] now
210  *      The time to use for the expiry check
211  */
212
213 void
214 afs_DiscardExpiredTokens(struct tokenJar **tokenPtr, afs_int32 now) {
215     struct tokenJar *next;
216
217     while (*tokenPtr != NULL) {
218         if (afs_IsTokenExpired(*tokenPtr, now)) {
219             next = (*tokenPtr)->next;
220             (*tokenPtr)->next = NULL;
221             afs_FreeOneToken(*tokenPtr);
222             *tokenPtr = next;
223         } else {
224             tokenPtr = &(*tokenPtr)->next;
225         }
226     }
227 }
228
229 /*!
230  * Indicate whether a token jar contains one, or more usable tokens
231  *
232  * @param[in] token
233  *      The token jar to check
234  * @param[in] now
235  *      The cime to use for the expiry check
236  *
237  * @returns
238  *      True if the jar contains usable tokens, otherwise false
239  */
240 int
241 afs_HasUsableTokens(struct tokenJar *token, afs_int32 now) {
242     while (token != NULL) {
243         if (afs_IsTokenUsable(token, now))
244             return 1;
245         token = token->next;
246     }
247     return 0;
248 }
249
250 /*!
251  * Indicate whether a token jar contains a valid (non-expired) token
252  *
253  * @param[in] token
254  *      The token jar to check
255  * @param[in] now
256  *      The time to use for the expiry check
257  *
258  * @returns
259  *      True if the jar contains valid tokens, otherwise false
260  *
261  */
262 int
263 afs_HasValidTokens(struct tokenJar *token, afs_int32 now) {
264     while (token != NULL) {
265         if (!afs_IsTokenExpired(token, now))
266             return 1;
267         token = token->next;
268     }
269     return 0;
270 }
271
272 /*!
273  * Count the number of valid tokens in a jar. A valid token is
274  * one which is not expired - note that valid tokens may not be
275  * usable by the kernel.
276  *
277  * @param[in] token
278  *      The token jar to check
279  * @param[in] now
280  *      The time to use for the expiry check
281  *
282  * @returns
283  *      The number of valid tokens in the jar
284  */
285 static int
286 countValidTokens(struct tokenJar *token, time_t now) {
287     int count = 0;
288
289     while (token != NULL) {
290         if (!afs_IsTokenExpired(token, now))
291             count ++;
292         token = token->next;
293     }
294     return count;
295 }
296
297 /*!
298  * Add an rxkad token to the token jar
299  *
300  * @param[in] tokens
301  *      A pointer to the address of the jar to add the token to
302  * @param[in] ticket
303  *      A data block containing the token's opaque ticket
304  * @param[in] ticketLen
305  *      The length of the ticket data block
306  * @param[in] clearToken
307  *      The cleartext token information
308  */
309 void
310 afs_AddRxkadToken(struct tokenJar **tokens, char *ticket, int ticketLen,
311                   struct ClearToken *clearToken) {
312     union tokenUnion *tokenU;
313     struct rxkadToken *rxkad;
314
315     tokenU = afs_AddToken(tokens, RX_SECIDX_KAD);
316     rxkad = &tokenU->rxkad;
317
318     rxkad->ticket = afs_osi_Alloc(ticketLen);
319     rxkad->ticketLen = ticketLen;
320     memcpy(rxkad->ticket, ticket, ticketLen);
321     rxkad->clearToken = *clearToken;
322 }
323
324 static int
325 afs_AddRxkadTokenFromPioctl(struct tokenJar **tokens,
326                             struct ktc_tokenUnion *pioctlToken) {
327     struct ClearToken clear;
328
329     clear.AuthHandle = pioctlToken->ktc_tokenUnion_u.at_kad.rk_kvno;
330     clear.ViceId = pioctlToken->ktc_tokenUnion_u.at_kad.rk_viceid;
331     clear.BeginTimestamp = pioctlToken->ktc_tokenUnion_u.at_kad.rk_begintime;
332     clear.EndTimestamp = pioctlToken->ktc_tokenUnion_u.at_kad.rk_endtime;
333     memcpy(clear.HandShakeKey, pioctlToken->ktc_tokenUnion_u.at_kad.rk_key, 8);
334     afs_AddRxkadToken(tokens,
335                       pioctlToken->ktc_tokenUnion_u.at_kad.rk_ticket.rk_ticket_val,
336                       pioctlToken->ktc_tokenUnion_u.at_kad.rk_ticket.rk_ticket_len,
337                       &clear);
338
339     /* Security means never having to say you're sorry */
340     memset(clear.HandShakeKey, 0, 8);
341
342     return 0;
343 }
344
345 static int
346 rxkad_extractTokenForPioctl(struct tokenJar *token,
347                                struct ktc_tokenUnion *pioctlToken) {
348
349     struct token_rxkad *rxkadPioctl;
350     struct rxkadToken *rxkadInternal;
351
352     rxkadPioctl = &pioctlToken->ktc_tokenUnion_u.at_kad;
353     rxkadInternal = &token->content.rxkad;
354
355     rxkadPioctl->rk_kvno = rxkadInternal->clearToken.AuthHandle;
356     rxkadPioctl->rk_viceid = rxkadInternal->clearToken.ViceId;
357     rxkadPioctl->rk_begintime = rxkadInternal->clearToken.BeginTimestamp;
358     rxkadPioctl->rk_endtime = rxkadInternal->clearToken.EndTimestamp;
359     memcpy(rxkadPioctl->rk_key, rxkadInternal->clearToken.HandShakeKey, 8);
360
361     rxkadPioctl->rk_ticket.rk_ticket_val = xdr_alloc(rxkadInternal->ticketLen);
362     if (rxkadPioctl->rk_ticket.rk_ticket_val == NULL)
363         return ENOMEM;
364     rxkadPioctl->rk_ticket.rk_ticket_len = rxkadInternal->ticketLen;
365     memcpy(rxkadPioctl->rk_ticket.rk_ticket_val,
366            rxkadInternal->ticket, rxkadInternal->ticketLen);
367
368     return 0;
369 }
370
371 /*!
372  * Add a token to a token jar based on the input from a new-style
373  * SetToken pioctl
374  *
375  * @param[in] tokens
376  *      Pointer to the address of a token jar
377  * @param[in] pioctlToken
378  *      The token structure obtained through the pioctl (note this
379  *      is a single, XDR decoded, token)
380  *
381  * @returns
382  *      0 on success, an error code on failure
383  */
384 int
385 afs_AddTokenFromPioctl(struct tokenJar **tokens,
386                        struct ktc_tokenUnion *pioctlToken) {
387
388     switch (pioctlToken->at_type) {
389       case RX_SECIDX_KAD:
390         return afs_AddRxkadTokenFromPioctl(tokens, pioctlToken);
391     }
392
393     return EINVAL;
394 }
395
396 static int
397 extractPioctlToken(struct tokenJar *token,
398                    struct token_opaque *opaque) {
399     XDR xdrs;
400     struct ktc_tokenUnion *pioctlToken;
401     int code;
402
403     memset(opaque, 0, sizeof(token_opaque));
404
405     pioctlToken = osi_Alloc(sizeof(struct ktc_tokenUnion));
406     if (pioctlToken == NULL)
407         return ENOMEM;
408
409     pioctlToken->at_type = token->type;
410
411     switch (token->type) {
412       case RX_SECIDX_KAD:
413         code = rxkad_extractTokenForPioctl(token, pioctlToken);
414         break;
415       default:
416         code = EINVAL;;
417     }
418
419     if (code)
420         goto out;
421
422     xdrlen_create(&xdrs);
423     if (!xdr_ktc_tokenUnion(&xdrs, pioctlToken)) {
424         code = EINVAL;
425         xdr_destroy(&xdrs);
426         goto out;
427     }
428
429     opaque->token_opaque_len = xdr_getpos(&xdrs);
430     xdr_destroy(&xdrs);
431
432     opaque->token_opaque_val = osi_Alloc(opaque->token_opaque_len);
433     if (opaque->token_opaque_val == NULL) {
434         code = ENOMEM;
435         goto out;
436     }
437
438     xdrmem_create(&xdrs,
439                   opaque->token_opaque_val,
440                   opaque->token_opaque_len,
441                   XDR_ENCODE);
442     if (!xdr_ktc_tokenUnion(&xdrs, pioctlToken)) {
443         code = EINVAL;
444         xdr_destroy(&xdrs);
445         goto out;
446     }
447     xdr_destroy(&xdrs);
448
449 out:
450     xdr_free((xdrproc_t) xdr_ktc_tokenUnion, &pioctlToken);
451     osi_Free(pioctlToken, sizeof(struct ktc_tokenUnion));
452
453     if (code != 0) {
454         osi_Free(opaque->token_opaque_val, opaque->token_opaque_len);
455         opaque->token_opaque_val = NULL;
456         opaque->token_opaque_len = 0;
457     }
458     return code;
459 }
460
461 int
462 afs_ExtractTokensForPioctl(struct tokenJar *token,
463                            time_t now,
464                            struct ktc_setTokenData *tokenSet)
465 {
466     int numTokens, pos;
467     int code = 0;
468
469     numTokens = countValidTokens(token, now);
470
471     tokenSet->tokens.tokens_len = numTokens;
472     tokenSet->tokens.tokens_val
473         = xdr_alloc(sizeof(struct token_opaque) * numTokens);
474
475     if (tokenSet->tokens.tokens_val == NULL)
476         return ENOMEM;
477
478     pos = 0;
479     while (token != NULL && pos < numTokens) {
480         code = extractPioctlToken(token, &tokenSet->tokens.tokens_val[pos]);
481         if (code)
482             goto out;
483         token = token->next;
484         pos++;
485     }
486
487 out:
488     if (code)
489         xdr_free((xdrproc_t) xdr_ktc_setTokenData, tokenSet);
490
491     return code;
492 }