Commit | Line | Data |
---|---|---|
805e021f CE |
1 | /* |
2 | * Copyright 2000, International Business Machines Corporation and others. | |
3 | * All Rights Reserved. | |
4 | * | |
5 | * This software has been released under the terms of the IBM Public | |
6 | * License. For details, see the LICENSE file in the top-level source | |
7 | * directory or online at http://www.openafs.org/dl/license10.html | |
8 | */ | |
9 | ||
10 | /* ticket caching code */ | |
11 | ||
12 | #include <afsconfig.h> | |
13 | #include <afs/param.h> | |
14 | #include <afs/stds.h> | |
15 | ||
16 | #include <roken.h> | |
17 | ||
18 | #include <ctype.h> | |
19 | ||
20 | #include <afs/pthread_glock.h> | |
21 | #include <rpc.h> | |
22 | #include <afs/smb_iocons.h> | |
23 | #include <afs/pioctl_nt.h> | |
24 | #include "afs/afsrpc.h" | |
25 | #include <afs/vice.h> | |
26 | #include "auth.h" | |
27 | #include <afs/afsutil.h> | |
28 | #include "token.h" | |
29 | ||
30 | /* TBUFFERSIZE must be at least 512 larger than KTCMAXTICKETSIZE */ | |
31 | #define TBUFFERSIZE 12512 | |
32 | ||
33 | /* Forward declarations for local token cache. */ | |
34 | static int SetLocalToken(struct ktc_principal *aserver, | |
35 | struct ktc_token *atoken, | |
36 | struct ktc_principal *aclient, afs_int32 flags); | |
37 | static int GetLocalToken(struct ktc_principal *aserver, | |
38 | struct ktc_token *atoken, int atokenLen, | |
39 | struct ktc_principal *aclient); | |
40 | static int ForgetLocalTokens(); | |
41 | static int ForgetOneLocalToken(struct ktc_principal *aserver); | |
42 | ||
43 | ||
44 | static char AFSConfigKeyName[] = | |
45 | "SYSTEM\\CurrentControlSet\\Services\\TransarcAFSDaemon\\Parameters"; | |
46 | ||
47 | static char AFSGlobalKTCMutexName[] = "Global\\AFS_KTC_Mutex"; | |
48 | static char AFSKTCMutexName[] = "AFS_KTC_Mutex"; | |
49 | ||
50 | #define MAXPIOCTLTOKENLEN \ | |
51 | (3*sizeof(afs_int32)+MAXKTCTICKETLEN+sizeof(struct ClearToken)+MAXKTCREALMLEN) | |
52 | ||
53 | /* | |
54 | * Support for RPC's to send and receive session keys | |
55 | * | |
56 | * Session keys must not be sent and received in the clear. We have no | |
57 | * way to piggyback encryption on SMB, so we use a separate RPC, using | |
58 | * packet privacy (when available). In SetToken, the RPC is done first; | |
59 | * in GetToken, the pioctl is done first. | |
60 | */ | |
61 | ||
62 | char rpcErr[256]; | |
63 | ||
64 | void __RPC_FAR *__RPC_USER | |
65 | midl_user_allocate(size_t cBytes) | |
66 | { | |
67 | return malloc(cBytes); | |
68 | } | |
69 | ||
70 | void __RPC_USER | |
71 | midl_user_free(void __RPC_FAR * p) | |
72 | { | |
73 | free(p); | |
74 | } | |
75 | ||
76 | /* | |
77 | * Determine the server name to be used in the RPC binding. If it is | |
78 | * the same as the client (i.e. standalone, non-gateway), NULL can be | |
79 | * used, so it is not necessary to call gethostbyname(). | |
80 | */ | |
81 | void | |
82 | getservername(char **snp, unsigned int snSize) | |
83 | { | |
84 | HKEY parmKey; | |
85 | long code; | |
86 | ||
87 | code = | |
88 | RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSConfigKeyName, 0, KEY_QUERY_VALUE, | |
89 | &parmKey); | |
90 | if (code != ERROR_SUCCESS) | |
91 | goto nogateway; | |
92 | code = RegQueryValueEx(parmKey, "Gateway", NULL, NULL, *snp, &snSize); | |
93 | RegCloseKey(parmKey); | |
94 | if (code == ERROR_SUCCESS) | |
95 | return; | |
96 | nogateway: | |
97 | /* No gateway name in registry; use ourself */ | |
98 | *snp = NULL; | |
99 | } | |
100 | ||
101 | RPC_STATUS | |
102 | send_key(afs_uuid_t uuid, char sessionKey[8]) | |
103 | { | |
104 | RPC_STATUS status; | |
105 | char *stringBinding = NULL; | |
106 | ULONG authnLevel, authnSvc; | |
107 | char serverName[256]; | |
108 | char *serverNamep = serverName; | |
109 | char encrypt[32]; | |
110 | BOOL encryptionOff = FALSE; | |
111 | char protseq[32]; | |
112 | ||
113 | /* Encryption on by default */ | |
114 | if (GetEnvironmentVariable("AFS_RPC_ENCRYPT", encrypt, sizeof(encrypt))) | |
115 | if (!_stricmp(encrypt, "OFF")) | |
116 | encryptionOff = TRUE; | |
117 | ||
118 | /* Protocol sequence is local by default */ | |
119 | if (!GetEnvironmentVariable("AFS_RPC_PROTSEQ", protseq, sizeof(protseq))) | |
120 | strcpy(protseq, "ncalrpc"); | |
121 | ||
122 | /* Server name */ | |
123 | getservername(&serverNamep, sizeof(serverName)); | |
124 | ||
125 | status = RpcStringBindingCompose("", /* obj uuid */ | |
126 | protseq, serverNamep, "", /* endpoint */ | |
127 | "", /* protocol options */ | |
128 | &stringBinding); | |
129 | if (status != RPC_S_OK) | |
130 | goto cleanup; | |
131 | ||
132 | status = RpcBindingFromStringBinding(stringBinding, &hAfsHandle); | |
133 | if (status != RPC_S_OK) | |
134 | goto cleanup; | |
135 | ||
136 | /* | |
137 | * On Windows 95/98, we must resolve the binding before calling | |
138 | * SetAuthInfo. On Windows NT, we don't have to resolve yet, | |
139 | * but it does no harm. | |
140 | */ | |
141 | status = RpcEpResolveBinding(hAfsHandle, afsrpc_v1_0_c_ifspec); | |
142 | if (status != RPC_S_OK) | |
143 | goto cleanup; | |
144 | ||
145 | if (encryptionOff) { | |
146 | authnLevel = RPC_C_AUTHN_LEVEL_NONE; | |
147 | authnSvc = RPC_C_AUTHN_WINNT; | |
148 | } else { | |
149 | authnLevel = RPC_C_AUTHN_LEVEL_PKT_PRIVACY; | |
150 | authnSvc = RPC_C_AUTHN_WINNT; | |
151 | } | |
152 | ||
153 | status = | |
154 | RpcBindingSetAuthInfo(hAfsHandle, NULL, authnLevel, authnSvc, NULL, | |
155 | RPC_C_AUTHZ_NONE); | |
156 | if (status != RPC_S_OK) | |
157 | goto cleanup; | |
158 | ||
159 | RpcTryExcept { | |
160 | status = AFSRPC_SetToken(uuid, sessionKey); | |
161 | } | |
162 | RpcExcept(1) { | |
163 | status = RpcExceptionCode(); | |
164 | } | |
165 | RpcEndExcept cleanup:if (stringBinding) | |
166 | RpcStringFree(&stringBinding); | |
167 | ||
168 | if (hAfsHandle != NULL) | |
169 | RpcBindingFree(&hAfsHandle); | |
170 | ||
171 | return status; | |
172 | } | |
173 | ||
174 | RPC_STATUS | |
175 | receive_key(afs_uuid_t uuid, char sessionKey[8]) | |
176 | { | |
177 | RPC_STATUS status; | |
178 | char *stringBinding = NULL; | |
179 | ULONG authnLevel, authnSvc; | |
180 | char serverName[256]; | |
181 | char *serverNamep = serverName; | |
182 | char encrypt[32]; | |
183 | BOOL encryptionOff = FALSE; | |
184 | char protseq[32]; | |
185 | ||
186 | /* Encryption on by default */ | |
187 | if (GetEnvironmentVariable("AFS_RPC_ENCRYPT", encrypt, sizeof(encrypt))) | |
188 | if (!_stricmp(encrypt, "OFF")) | |
189 | encryptionOff = TRUE; | |
190 | ||
191 | /* Protocol sequence is local by default */ | |
192 | if (!GetEnvironmentVariable("AFS_RPC_PROTSEQ", protseq, sizeof(protseq))) | |
193 | strcpy(protseq, "ncalrpc"); | |
194 | ||
195 | /* Server name */ | |
196 | getservername(&serverNamep, sizeof(serverName)); | |
197 | ||
198 | status = RpcStringBindingCompose("", /* obj uuid */ | |
199 | protseq, serverNamep, "", /* endpoint */ | |
200 | "", /* protocol options */ | |
201 | &stringBinding); | |
202 | if (status != RPC_S_OK) | |
203 | goto cleanup; | |
204 | ||
205 | status = RpcBindingFromStringBinding(stringBinding, &hAfsHandle); | |
206 | if (status != RPC_S_OK) | |
207 | goto cleanup; | |
208 | ||
209 | /* | |
210 | * On Windows 95/98, we must resolve the binding before calling | |
211 | * SetAuthInfo. On Windows NT, we don't have to resolve yet, | |
212 | * but it does no harm. | |
213 | */ | |
214 | status = RpcEpResolveBinding(hAfsHandle, afsrpc_v1_0_c_ifspec); | |
215 | if (status != RPC_S_OK) | |
216 | goto cleanup; | |
217 | ||
218 | if (encryptionOff) { | |
219 | authnLevel = RPC_C_AUTHN_LEVEL_NONE; | |
220 | authnSvc = RPC_C_AUTHN_WINNT; | |
221 | } else { | |
222 | authnLevel = RPC_C_AUTHN_LEVEL_PKT_PRIVACY; | |
223 | authnSvc = RPC_C_AUTHN_WINNT; | |
224 | } | |
225 | ||
226 | status = | |
227 | RpcBindingSetAuthInfo(hAfsHandle, NULL, authnLevel, authnSvc, NULL, | |
228 | RPC_C_AUTHZ_NONE); | |
229 | if (status != RPC_S_OK) | |
230 | goto cleanup; | |
231 | ||
232 | RpcTryExcept { | |
233 | status = AFSRPC_GetToken(uuid, sessionKey); | |
234 | } | |
235 | RpcExcept(1) { | |
236 | status = RpcExceptionCode(); | |
237 | } | |
238 | RpcEndExcept cleanup:if (stringBinding) | |
239 | RpcStringFree(&stringBinding); | |
240 | ||
241 | if (hAfsHandle != NULL) | |
242 | RpcBindingFree(&hAfsHandle); | |
243 | ||
244 | return status; | |
245 | } | |
246 | ||
247 | int | |
248 | ktc_SetToken(struct ktc_principal *server, struct ktc_token *token, | |
249 | struct ktc_principal *client, int flags) | |
250 | { | |
251 | struct ViceIoctl iob; | |
252 | char tbuffer[TBUFFERSIZE]; | |
253 | int len; | |
254 | char *tp; | |
255 | struct ClearToken ct; | |
256 | int temp; | |
257 | int code; | |
258 | RPC_STATUS status; | |
259 | afs_uuid_t uuid; | |
260 | HANDLE ktcMutex = NULL; | |
261 | ||
262 | if (token->ticketLen < MINKTCTICKETLEN | |
263 | || token->ticketLen > MAXKTCTICKETLEN) | |
264 | return KTC_INVAL; | |
265 | ||
266 | if (strcmp(server->name, "afs")) { | |
267 | return SetLocalToken(server, token, client, flags); | |
268 | } | |
269 | ||
270 | tp = tbuffer; | |
271 | ||
272 | /* ticket length */ | |
273 | memcpy(tp, &token->ticketLen, sizeof(token->ticketLen)); | |
274 | tp += sizeof(token->ticketLen); | |
275 | len = sizeof(token->ticketLen); | |
276 | ||
277 | /* ticket */ | |
278 | if (len + token->ticketLen > TBUFFERSIZE) | |
279 | return KTC_INVAL; | |
280 | memcpy(tp, token->ticket, token->ticketLen); | |
281 | tp += token->ticketLen; | |
282 | len += token->ticketLen; | |
283 | ||
284 | /* clear token */ | |
285 | ct.AuthHandle = token->kvno; | |
286 | /* | |
287 | * Instead of sending the session key in the clear, we zero it, | |
288 | * and send it later, via RPC, encrypted. | |
289 | */ | |
290 | #ifndef AFS_WIN95_ENV | |
291 | /* | |
292 | * memcpy(ct.HandShakeKey, &token->sessionKey, sizeof(token->sessionKey)); | |
293 | */ | |
294 | memset(ct.HandShakeKey, 0, sizeof(ct.HandShakeKey)); | |
295 | #else | |
296 | memcpy(ct.HandShakeKey, &token->sessionKey, sizeof(token->sessionKey)); | |
297 | #endif | |
298 | ct.BeginTimestamp = token->startTime; | |
299 | ct.EndTimestamp = token->endTime; | |
300 | if (ct.BeginTimestamp == 0) | |
301 | ct.BeginTimestamp = 1; | |
302 | ||
303 | /* We don't know from Vice ID's yet */ | |
304 | ct.ViceId = 37; /* XXX */ | |
305 | if (((ct.EndTimestamp - ct.BeginTimestamp) & 1) == 1) | |
306 | ct.BeginTimestamp++; /* force lifetime to be even */ | |
307 | ||
308 | /* size of clear token */ | |
309 | if (len + sizeof(temp) > TBUFFERSIZE) | |
310 | return KTC_INVAL; | |
311 | temp = sizeof(struct ClearToken); | |
312 | memcpy(tp, &temp, sizeof(temp)); | |
313 | tp += sizeof(temp); | |
314 | len += sizeof(temp); | |
315 | ||
316 | /* clear token itself */ | |
317 | if (len + sizeof(ct) > TBUFFERSIZE) | |
318 | return KTC_INVAL; | |
319 | memcpy(tp, &ct, sizeof(ct)); | |
320 | tp += sizeof(ct); | |
321 | len += sizeof(ct); | |
322 | ||
323 | /* flags; on NT there is no setpag flag, but there is an | |
324 | * integrated logon flag */ | |
325 | if (len + sizeof(temp) > TBUFFERSIZE) | |
326 | return KTC_INVAL; | |
327 | temp = ((flags & AFS_SETTOK_LOGON) ? PIOCTL_LOGON : 0); | |
328 | memcpy(tp, &temp, sizeof(temp)); | |
329 | tp += sizeof(temp); | |
330 | len += sizeof(temp); | |
331 | ||
332 | /* cell name */ | |
333 | temp = (int)strlen(server->cell) + 1; | |
334 | if (len + temp > TBUFFERSIZE || | |
335 | temp > MAXKTCREALMLEN) | |
336 | return KTC_INVAL; | |
337 | strcpy(tp, server->cell); | |
338 | tp += temp; | |
339 | len += temp; | |
340 | ||
341 | /* user name */ | |
342 | temp = (int)strlen(client->name) + 1; | |
343 | if (len + temp > TBUFFERSIZE || | |
344 | temp > MAXKTCNAMELEN) | |
345 | return KTC_INVAL; | |
346 | strcpy(tp, client->name); | |
347 | tp += temp; | |
348 | len += temp; | |
349 | ||
350 | /* we need the SMB user name to associate the tokens with in the | |
351 | * integrated logon case. */ | |
352 | if (flags & AFS_SETTOK_LOGON) { | |
353 | if (client->smbname == NULL) | |
354 | temp = 1; | |
355 | else | |
356 | temp = (int)strlen(client->smbname) + 1; | |
357 | if (temp == 1 || | |
358 | len + temp > TBUFFERSIZE || | |
359 | temp > MAXKTCNAMELEN) | |
360 | return KTC_INVAL; | |
361 | strcpy(tp, client->smbname); | |
362 | tp += temp; | |
363 | len += temp; | |
364 | } | |
365 | ||
366 | /* uuid */ | |
367 | if (len + sizeof(uuid) > TBUFFERSIZE) | |
368 | return KTC_INVAL; | |
369 | status = UuidCreate((UUID *) & uuid); | |
370 | memcpy(tp, &uuid, sizeof(uuid)); | |
371 | tp += sizeof(uuid); | |
372 | len += sizeof(uuid); | |
373 | ||
374 | ktcMutex = CreateMutex(NULL, TRUE, AFSGlobalKTCMutexName); | |
375 | if (ktcMutex == NULL) | |
376 | return KTC_TOKEN_MUTEX_FAIL; | |
377 | if (GetLastError() == ERROR_ALREADY_EXISTS) { | |
378 | if (WaitForSingleObject(ktcMutex, INFINITE) != WAIT_OBJECT_0) { | |
379 | CloseHandle(ktcMutex); | |
380 | return KTC_TOKEN_MUTEX_FAIL; | |
381 | } | |
382 | } | |
383 | ||
384 | /* RPC to send session key */ | |
385 | status = send_key(uuid, token->sessionKey.data); | |
386 | if (status != RPC_S_OK) { | |
387 | if (status == 1) | |
388 | strcpy(rpcErr, "RPC failure in AFS gateway"); | |
389 | else | |
390 | DceErrorInqText(status, rpcErr); | |
391 | ||
392 | ReleaseMutex(ktcMutex); | |
393 | CloseHandle(ktcMutex); | |
394 | ||
395 | if (status == RPC_S_SERVER_UNAVAILABLE || | |
396 | status == EPT_S_NOT_REGISTERED) { | |
397 | return KTC_NOCMRPC; | |
398 | } else { | |
399 | return KTC_RPC; | |
400 | } | |
401 | } | |
402 | ||
403 | /* set up for pioctl */ | |
404 | iob.in = tbuffer; | |
405 | iob.in_size = (long)(tp - tbuffer); | |
406 | iob.out = tbuffer; | |
407 | iob.out_size = sizeof(tbuffer); | |
408 | ||
409 | code = pioctl(0, VIOCSETTOK, &iob, 0); | |
410 | ||
411 | ReleaseMutex(ktcMutex); | |
412 | CloseHandle(ktcMutex); | |
413 | ||
414 | if (code) { | |
415 | if (code == -1) { | |
416 | if (errno == ESRCH) | |
417 | return KTC_NOCELL; | |
418 | else if (errno == ENODEV) | |
419 | return KTC_NOCM; | |
420 | else if (errno == EINVAL) | |
421 | return KTC_INVAL; | |
422 | else | |
423 | return KTC_PIOCTLFAIL; | |
424 | } else | |
425 | return KTC_PIOCTLFAIL; | |
426 | } | |
427 | ||
428 | return 0; | |
429 | } | |
430 | ||
431 | int | |
432 | ktc_SetTokenEx(struct ktc_setTokenData *token) | |
433 | { | |
434 | /* Not yet implemented */ | |
435 | return KTC_PIOCTLFAIL; | |
436 | } | |
437 | ||
438 | int | |
439 | ktc_GetToken(struct ktc_principal *server, struct ktc_token *token, | |
440 | int tokenLen, struct ktc_principal *client) | |
441 | { | |
442 | struct ViceIoctl iob; | |
443 | char tbuffer[TBUFFERSIZE]; | |
444 | size_t len; | |
445 | char *tp, *cp; | |
446 | char *ticketP; | |
447 | int ticketLen, temp; | |
448 | struct ClearToken ct; | |
449 | char *cellName; | |
450 | int cellNameSize; | |
451 | int maxLen; | |
452 | int code; | |
453 | RPC_STATUS status; | |
454 | afs_uuid_t uuid; | |
455 | HANDLE ktcMutex = NULL; | |
456 | ||
457 | tp = tbuffer; | |
458 | ||
459 | /* check to see if the user is requesting tokens for a principal | |
460 | * other than afs. If so, check the local token cache. | |
461 | */ | |
462 | if (strcmp(server->name, "afs")) { | |
463 | return GetLocalToken(server, token, tokenLen, client); | |
464 | } | |
465 | ||
466 | /* cell name */ | |
467 | len = strlen(server->cell) + 1; | |
468 | strcpy(tp, server->cell); | |
469 | tp += len; | |
470 | ||
471 | /* uuid */ | |
472 | status = UuidCreate((UUID *) & uuid); | |
473 | memcpy(tp, &uuid, sizeof(uuid)); | |
474 | tp += sizeof(uuid); | |
475 | len += sizeof(uuid); | |
476 | ||
477 | iob.in = tbuffer; | |
478 | iob.in_size = (long)(tp - tbuffer); | |
479 | iob.out = tbuffer; | |
480 | iob.out_size = sizeof(tbuffer); | |
481 | ||
482 | ktcMutex = CreateMutex(NULL, TRUE, AFSGlobalKTCMutexName); | |
483 | if (ktcMutex == NULL) | |
484 | return KTC_TOKEN_MUTEX_FAIL; | |
485 | if (GetLastError() == ERROR_ALREADY_EXISTS) { | |
486 | if (WaitForSingleObject(ktcMutex, INFINITE) != WAIT_OBJECT_0) { | |
487 | CloseHandle(ktcMutex); | |
488 | return KTC_TOKEN_MUTEX_FAIL; | |
489 | } | |
490 | } | |
491 | ||
492 | code = pioctl(0, VIOCNEWGETTOK, &iob, 0); | |
493 | if (code) { | |
494 | ReleaseMutex(ktcMutex); | |
495 | CloseHandle(ktcMutex); | |
496 | ||
497 | if (code == -1) { | |
498 | if (errno == ESRCH) | |
499 | return KTC_NOCELL; | |
500 | else if (errno == ENODEV) | |
501 | return KTC_NOCM; | |
502 | else if (errno == EINVAL) | |
503 | return KTC_INVAL; | |
504 | else if (errno == EDOM) | |
505 | return KTC_NOENT; | |
506 | else | |
507 | return KTC_PIOCTLFAIL; | |
508 | } else | |
509 | return KTC_PIOCTLFAIL; | |
510 | } | |
511 | ||
512 | /* RPC to receive session key */ | |
513 | status = receive_key(uuid, token->sessionKey.data); | |
514 | ||
515 | ReleaseMutex(ktcMutex); | |
516 | CloseHandle(ktcMutex); | |
517 | ||
518 | if (status != RPC_S_OK) { | |
519 | if (status == 1) | |
520 | strcpy(rpcErr, "RPC failure in AFS gateway"); | |
521 | else | |
522 | DceErrorInqText(status, rpcErr); | |
523 | ||
524 | if (status == RPC_S_SERVER_UNAVAILABLE || | |
525 | status == EPT_S_NOT_REGISTERED) | |
526 | return KTC_NOCMRPC; | |
527 | else | |
528 | return KTC_RPC; | |
529 | } | |
530 | ||
531 | cp = tbuffer; | |
532 | ||
533 | /* ticket length */ | |
534 | memcpy(&ticketLen, cp, sizeof(ticketLen)); | |
535 | cp += sizeof(ticketLen); | |
536 | len = sizeof(ticketLen); | |
537 | ||
538 | /* remember where ticket is and skip over it */ | |
539 | if (len + ticketLen > TBUFFERSIZE || | |
540 | len + ticketLen > iob.out_size) | |
541 | return KTC_ERROR; | |
542 | ticketP = cp; | |
543 | cp += ticketLen; | |
544 | len += ticketLen; | |
545 | ||
546 | /* size of clear token */ | |
547 | if (len + sizeof(temp) > TBUFFERSIZE || | |
548 | len + sizeof(temp) > iob.out_size) | |
549 | return KTC_ERROR; | |
550 | memcpy(&temp, cp, sizeof(temp)); | |
551 | cp += sizeof(temp); | |
552 | len += sizeof(temp); | |
553 | if (temp != sizeof(ct)) | |
554 | return KTC_ERROR; | |
555 | ||
556 | /* clear token */ | |
557 | if (len + temp > TBUFFERSIZE || | |
558 | len + temp > iob.out_size) | |
559 | return KTC_ERROR; | |
560 | memcpy(&ct, cp, temp); | |
561 | cp += temp; | |
562 | len += temp; | |
563 | ||
564 | /* skip over primary flag */ | |
565 | if (len + sizeof(temp) > TBUFFERSIZE || | |
566 | len + sizeof(temp) > iob.out_size) | |
567 | return KTC_ERROR; | |
568 | cp += sizeof(temp); | |
569 | len += sizeof(temp); | |
570 | ||
571 | /* remember cell name and skip over it */ | |
572 | cellName = cp; | |
573 | cellNameSize = (int)strlen(cp); | |
574 | if (len + cellNameSize + 1 > TBUFFERSIZE || | |
575 | len + cellNameSize + 1 > iob.out_size) | |
576 | return KTC_ERROR; | |
577 | cp += cellNameSize + 1; | |
578 | len += cellNameSize + 1; | |
579 | ||
580 | /* user name is here */ | |
581 | ||
582 | /* check that ticket will fit | |
583 | * this compares the size of the ktc_token allocated by the app | |
584 | * which might be smaller than the current definition of MAXKTCTICKETLEN | |
585 | */ | |
586 | maxLen = tokenLen - sizeof(struct ktc_token) + MAXKTCTICKETLEN; | |
587 | if (maxLen < ticketLen) | |
588 | return KTC_TOOBIG; | |
589 | ||
590 | /* set return values */ | |
591 | memcpy(token->ticket, ticketP, ticketLen); | |
592 | token->startTime = ct.BeginTimestamp; | |
593 | token->endTime = ct.EndTimestamp; | |
594 | if (ct.AuthHandle == -1) | |
595 | ct.AuthHandle = 999; | |
596 | token->kvno = ct.AuthHandle; | |
597 | #ifndef AFS_WIN95_ENV | |
598 | /* | |
599 | * Session key has already been set via RPC | |
600 | */ | |
601 | #else | |
602 | memcpy(&token->sessionKey, ct.HandShakeKey, sizeof(ct.HandShakeKey)); | |
603 | #endif /* AFS_WIN95_ENV */ | |
604 | token->ticketLen = ticketLen; | |
605 | if (client) { | |
606 | strcpy(client->name, cp); | |
607 | client->instance[0] = '\0'; | |
608 | strcpy(client->cell, cellName); | |
609 | } | |
610 | ||
611 | return 0; | |
612 | } | |
613 | ||
614 | /*! | |
615 | * Get a token, given the cell that we need to get information for | |
616 | * | |
617 | * @param cellName | |
618 | * The name of the cell we're getting the token for - if NULL, we'll | |
619 | * get information for the primary cell | |
620 | */ | |
621 | int | |
622 | ktc_GetTokenEx(char *cellName, struct ktc_setTokenData **tokenSet) { | |
623 | struct ViceIoctl iob; | |
624 | char tbuffer[MAXPIOCTLTOKENLEN]; | |
625 | char *tp; | |
626 | afs_int32 code; | |
627 | XDR xdrs; | |
628 | HANDLE ktcMutex = NULL; | |
629 | ||
630 | tp = tbuffer; | |
631 | ||
632 | /* If we have a cellName, write it out here */ | |
633 | if (cellName) { | |
634 | memcpy(tp, cellName, strlen(cellName) +1); | |
635 | tp += strlen(cellName)+1; | |
636 | } | |
637 | ||
638 | iob.in = tbuffer; | |
639 | iob.in_size = tp - tbuffer; | |
640 | iob.out = tbuffer; | |
641 | iob.out_size = sizeof(tbuffer); | |
642 | ||
643 | ktcMutex = CreateMutex(NULL, TRUE, AFSGlobalKTCMutexName); | |
644 | if (ktcMutex == NULL) | |
645 | return KTC_TOKEN_MUTEX_FAIL; | |
646 | if (GetLastError() == ERROR_ALREADY_EXISTS) { | |
647 | if (WaitForSingleObject(ktcMutex, INFINITE) != WAIT_OBJECT_0) { | |
648 | CloseHandle(ktcMutex); | |
649 | return KTC_TOKEN_MUTEX_FAIL; | |
650 | } | |
651 | } | |
652 | ||
653 | #if 0 | |
654 | code = pioctl(0, VIOC_GETTOK2, &iob, 0); | |
655 | #else | |
656 | code = -1; /* not yet implemented */ | |
657 | errno = EINVAL; | |
658 | #endif | |
659 | ||
660 | ReleaseMutex(ktcMutex); | |
661 | CloseHandle(ktcMutex); | |
662 | ||
663 | /* If we can't use the new pioctl, the fall back to the old one. We then | |
664 | * need to convert the rxkad token we get back into the new format | |
665 | */ | |
666 | if (code == -1 && errno == EINVAL) { | |
667 | struct ktc_principal server; | |
668 | struct ktc_principal client; | |
669 | struct ktc_tokenUnion token; | |
670 | struct ktc_token *ktcToken; /* too huge for the stack */ | |
671 | ||
672 | memset(&server, 0, sizeof(server)); | |
673 | ktcToken = malloc(sizeof(struct ktc_token)); | |
674 | if (ktcToken == NULL) | |
675 | return ENOMEM; | |
676 | memset(ktcToken, 0, sizeof(struct ktc_token)); | |
677 | ||
678 | strcpy(server.name, "afs"); | |
679 | strcpy(server.cell, cellName); | |
680 | code = ktc_GetToken(&server, ktcToken, sizeof(struct ktc_token), | |
681 | &client); | |
682 | if (code == 0) { | |
683 | *tokenSet = token_buildTokenJar(cellName); | |
684 | token.at_type = AFSTOKEN_UNION_KAD; | |
685 | token.ktc_tokenUnion_u.at_kad.rk_kvno = ktcToken->kvno; | |
686 | memcpy(token.ktc_tokenUnion_u.at_kad.rk_key, | |
687 | ktcToken->sessionKey.data, 8); | |
688 | ||
689 | token.ktc_tokenUnion_u.at_kad.rk_begintime = ktcToken->startTime; | |
690 | token.ktc_tokenUnion_u.at_kad.rk_endtime = ktcToken->endTime; | |
691 | token.ktc_tokenUnion_u.at_kad.rk_ticket.rk_ticket_len | |
692 | = ktcToken->ticketLen; | |
693 | token.ktc_tokenUnion_u.at_kad.rk_ticket.rk_ticket_val | |
694 | = ktcToken->ticket; | |
695 | ||
696 | token_addToken(*tokenSet, &token); | |
697 | ||
698 | memset(ktcToken, 0, sizeof(struct ktc_token)); | |
699 | } | |
700 | free(ktcToken); | |
701 | return code; | |
702 | } | |
703 | if (code) | |
704 | return KTC_PIOCTLFAIL; | |
705 | ||
706 | *tokenSet = malloc(sizeof(struct ktc_setTokenData)); | |
707 | if (*tokenSet == NULL) | |
708 | return ENOMEM; | |
709 | memset(*tokenSet, 0, sizeof(struct ktc_setTokenData)); | |
710 | ||
711 | xdrmem_create(&xdrs, iob.out, iob.out_size, XDR_DECODE); | |
712 | if (!xdr_ktc_setTokenData(&xdrs, *tokenSet)) { | |
713 | free(*tokenSet); | |
714 | *tokenSet = NULL; | |
715 | xdr_destroy(&xdrs); | |
716 | return EINVAL; | |
717 | } | |
718 | xdr_destroy(&xdrs); | |
719 | return 0; | |
720 | } | |
721 | ||
722 | int | |
723 | ktc_ListTokens(int cellNum, int *cellNumP, struct ktc_principal *server) | |
724 | { | |
725 | struct ViceIoctl iob; | |
726 | char tbuffer[TBUFFERSIZE]; | |
727 | int len; | |
728 | char *tp, *cp; | |
729 | int newIter, ticketLen, temp; | |
730 | int code; | |
731 | HANDLE ktcMutex = NULL; | |
732 | ||
733 | ktcMutex = CreateMutex(NULL, TRUE, AFSGlobalKTCMutexName); | |
734 | if (ktcMutex == NULL) | |
735 | return KTC_TOKEN_MUTEX_FAIL; | |
736 | if (GetLastError() == ERROR_ALREADY_EXISTS) { | |
737 | if (WaitForSingleObject(ktcMutex, INFINITE) != WAIT_OBJECT_0) { | |
738 | CloseHandle(ktcMutex); | |
739 | return KTC_TOKEN_MUTEX_FAIL; | |
740 | } | |
741 | } | |
742 | ||
743 | tp = tbuffer; | |
744 | ||
745 | /* iterator */ | |
746 | memcpy(tp, &cellNum, sizeof(cellNum)); | |
747 | tp += sizeof(cellNum); | |
748 | ||
749 | /* do pioctl */ | |
750 | iob.in = tbuffer; | |
751 | iob.in_size = (long)(tp - tbuffer); | |
752 | iob.out = tbuffer; | |
753 | iob.out_size = sizeof(tbuffer); | |
754 | ||
755 | code = pioctl(0, VIOCGETTOK, &iob, 0); | |
756 | ||
757 | ReleaseMutex(ktcMutex); | |
758 | CloseHandle(ktcMutex); | |
759 | ||
760 | if (code) { | |
761 | if (code == -1) { | |
762 | if (errno == ESRCH) | |
763 | return KTC_NOCELL; | |
764 | else if (errno == ENODEV) | |
765 | return KTC_NOCM; | |
766 | else if (errno == EINVAL) | |
767 | return KTC_INVAL; | |
768 | else if (errno == EDOM) | |
769 | return KTC_NOENT; | |
770 | else | |
771 | return KTC_PIOCTLFAIL; | |
772 | } else | |
773 | return KTC_PIOCTLFAIL; | |
774 | } | |
775 | ||
776 | cp = tbuffer; | |
777 | ||
778 | /* new iterator */ | |
779 | memcpy(&newIter, cp, sizeof(newIter)); | |
780 | cp += sizeof(newIter); | |
781 | len = sizeof(newIter); | |
782 | ||
783 | /* ticket length */ | |
784 | if (len + sizeof(ticketLen) > TBUFFERSIZE || | |
785 | len + sizeof(ticketLen) > iob.out_size) | |
786 | return KTC_ERROR; | |
787 | memcpy(&ticketLen, cp, sizeof(ticketLen)); | |
788 | cp += sizeof(ticketLen); | |
789 | len += sizeof(ticketLen); | |
790 | ||
791 | /* skip over ticket */ | |
792 | cp += ticketLen; | |
793 | len += ticketLen; | |
794 | ||
795 | /* clear token size */ | |
796 | if (len + sizeof(temp) > TBUFFERSIZE || | |
797 | len + sizeof(temp) > iob.out_size) | |
798 | return KTC_ERROR; | |
799 | memcpy(&temp, cp, sizeof(temp)); | |
800 | cp += sizeof(temp); | |
801 | len += sizeof(temp); | |
802 | if (temp != sizeof(struct ClearToken)) | |
803 | return KTC_ERROR; | |
804 | ||
805 | /* skip over clear token */ | |
806 | cp += sizeof(struct ClearToken); | |
807 | len += sizeof(struct ClearToken); | |
808 | ||
809 | /* skip over primary flag */ | |
810 | cp += sizeof(temp); | |
811 | len += sizeof(temp); | |
812 | if (len > TBUFFERSIZE || | |
813 | len > iob.out_size) | |
814 | return KTC_ERROR; | |
815 | ||
816 | /* cell name is here */ | |
817 | ||
818 | /* set return values */ | |
819 | if (len + temp > TBUFFERSIZE || | |
820 | temp > MAXKTCREALMLEN) | |
821 | return KTC_ERROR; | |
822 | strcpy(server->cell, cp); | |
823 | server->instance[0] = '\0'; | |
824 | strcpy(server->name, "afs"); | |
825 | ||
826 | *cellNumP = newIter; | |
827 | return 0; | |
828 | } | |
829 | ||
830 | int | |
831 | ktc_ForgetToken(struct ktc_principal *server) | |
832 | { | |
833 | struct ViceIoctl iob; | |
834 | char tbuffer[TBUFFERSIZE]; | |
835 | char *tp; | |
836 | int code; | |
837 | HANDLE ktcMutex = NULL; | |
838 | ||
839 | if (strcmp(server->name, "afs")) { | |
840 | return ForgetOneLocalToken(server); | |
841 | } | |
842 | ktcMutex = CreateMutex(NULL, TRUE, AFSGlobalKTCMutexName); | |
843 | if (ktcMutex == NULL) | |
844 | return KTC_TOKEN_MUTEX_FAIL; | |
845 | if (GetLastError() == ERROR_ALREADY_EXISTS) { | |
846 | if (WaitForSingleObject(ktcMutex, INFINITE) != WAIT_OBJECT_0) { | |
847 | CloseHandle(ktcMutex); | |
848 | return KTC_TOKEN_MUTEX_FAIL; | |
849 | } | |
850 | } | |
851 | ||
852 | tp = tbuffer; | |
853 | ||
854 | /* cell name */ | |
855 | strcpy(tp, server->cell); | |
856 | tp += strlen(tp) + 1; | |
857 | ||
858 | /* do pioctl */ | |
859 | iob.in = tbuffer; | |
860 | iob.in_size = (long)(tp - tbuffer); | |
861 | iob.out = tbuffer; | |
862 | iob.out_size = sizeof(tbuffer); | |
863 | ||
864 | code = pioctl(0, VIOCDELTOK, &iob, 0); | |
865 | ReleaseMutex(ktcMutex); | |
866 | CloseHandle(ktcMutex); | |
867 | ||
868 | if (code) { | |
869 | if (code == -1) { | |
870 | if (errno == ESRCH) | |
871 | return KTC_NOCELL; | |
872 | else if (errno == EDOM) | |
873 | return KTC_NOENT; | |
874 | else if (errno == ENODEV) | |
875 | return KTC_NOCM; | |
876 | else | |
877 | return KTC_PIOCTLFAIL; | |
878 | } else | |
879 | return KTC_PIOCTLFAIL; | |
880 | } | |
881 | return 0; | |
882 | } | |
883 | ||
884 | int | |
885 | ktc_ForgetAllTokens() | |
886 | { | |
887 | struct ViceIoctl iob; | |
888 | char tbuffer[TBUFFERSIZE]; | |
889 | int code; | |
890 | HANDLE ktcMutex = NULL; | |
891 | ||
892 | (void)ForgetLocalTokens(); | |
893 | ||
894 | ktcMutex = CreateMutex(NULL, TRUE, AFSGlobalKTCMutexName); | |
895 | if (ktcMutex == NULL) | |
896 | return KTC_TOKEN_MUTEX_FAIL; | |
897 | if (GetLastError() == ERROR_ALREADY_EXISTS) { | |
898 | if (WaitForSingleObject(ktcMutex, INFINITE) != WAIT_OBJECT_0) { | |
899 | CloseHandle(ktcMutex); | |
900 | return KTC_TOKEN_MUTEX_FAIL; | |
901 | } | |
902 | } | |
903 | ||
904 | /* do pioctl */ | |
905 | iob.in = tbuffer; | |
906 | iob.in_size = 0; | |
907 | iob.out = tbuffer; | |
908 | iob.out_size = sizeof(tbuffer); | |
909 | ||
910 | code = pioctl(0, VIOCDELALLTOK, &iob, 0); | |
911 | ReleaseMutex(ktcMutex); | |
912 | CloseHandle(ktcMutex); | |
913 | ||
914 | if (code) { | |
915 | if (code == -1) { | |
916 | if (errno == ENODEV) | |
917 | return KTC_NOCM; | |
918 | else | |
919 | return KTC_PIOCTLFAIL; | |
920 | } else | |
921 | return KTC_PIOCTLFAIL; | |
922 | } | |
923 | return 0; | |
924 | } | |
925 | ||
926 | int | |
927 | ktc_OldPioctl() | |
928 | { | |
929 | return 1; | |
930 | } | |
931 | ||
932 | ||
933 | #define MAXLOCALTOKENS 4 | |
934 | ||
935 | static struct { | |
936 | int valid; | |
937 | struct ktc_principal server; | |
938 | struct ktc_principal client; | |
939 | struct ktc_token token; | |
940 | } local_tokens[MAXLOCALTOKENS] = { | |
941 | 0}; | |
942 | ||
943 | static int | |
944 | SetLocalToken(struct ktc_principal *aserver, struct ktc_token *atoken, | |
945 | struct ktc_principal *aclient, afs_int32 flags) | |
946 | { | |
947 | int found = -1; | |
948 | int i; | |
949 | ||
950 | LOCK_GLOBAL_MUTEX; | |
951 | for (i = 0; i < MAXLOCALTOKENS; i++) | |
952 | if (local_tokens[i].valid) { | |
953 | if ((strcmp(local_tokens[i].server.name, aserver->name) == 0) | |
954 | && (strcmp(local_tokens[i].server.instance, aserver->instance) | |
955 | == 0) | |
956 | && (strcmp(local_tokens[i].server.cell, aserver->cell) == 0)) { | |
957 | found = i; /* replace existing entry */ | |
958 | break; | |
959 | } | |
960 | } else if (found == -1) | |
961 | found = i; /* remember empty slot but keep looking for a match */ | |
962 | if (found == -1) { | |
963 | UNLOCK_GLOBAL_MUTEX; | |
964 | return KTC_NOENT; | |
965 | } | |
966 | memcpy(&local_tokens[found].token, atoken, sizeof(struct ktc_token)); | |
967 | memcpy(&local_tokens[found].server, aserver, | |
968 | sizeof(struct ktc_principal)); | |
969 | memcpy(&local_tokens[found].client, aclient, | |
970 | sizeof(struct ktc_principal)); | |
971 | local_tokens[found].valid = 1; | |
972 | UNLOCK_GLOBAL_MUTEX; | |
973 | return 0; | |
974 | } | |
975 | ||
976 | ||
977 | static int | |
978 | GetLocalToken(struct ktc_principal *aserver, struct ktc_token *atoken, | |
979 | int atokenLen, struct ktc_principal *aclient) | |
980 | { | |
981 | int i; | |
982 | ||
983 | LOCK_GLOBAL_MUTEX; | |
984 | for (i = 0; i < MAXLOCALTOKENS; i++) | |
985 | if (local_tokens[i].valid | |
986 | && (strcmp(local_tokens[i].server.name, aserver->name) == 0) | |
987 | && (strcmp(local_tokens[i].server.instance, aserver->instance) == | |
988 | 0) | |
989 | && (strcmp(local_tokens[i].server.cell, aserver->cell) == 0)) { | |
990 | memcpy(atoken, &local_tokens[i].token, | |
991 | min(atokenLen, sizeof(struct ktc_token))); | |
992 | memcpy(aclient, &local_tokens[i].client, | |
993 | sizeof(struct ktc_principal)); | |
994 | UNLOCK_GLOBAL_MUTEX; | |
995 | return 0; | |
996 | } | |
997 | UNLOCK_GLOBAL_MUTEX; | |
998 | return KTC_NOENT; | |
999 | } | |
1000 | ||
1001 | ||
1002 | static int | |
1003 | ForgetLocalTokens() | |
1004 | { | |
1005 | int i; | |
1006 | ||
1007 | LOCK_GLOBAL_MUTEX; | |
1008 | for (i = 0; i < MAXLOCALTOKENS; i++) { | |
1009 | local_tokens[i].valid = 0; | |
1010 | memset(&local_tokens[i].token.sessionKey, 0, | |
1011 | sizeof(struct ktc_encryptionKey)); | |
1012 | } | |
1013 | UNLOCK_GLOBAL_MUTEX; | |
1014 | return 0; | |
1015 | } | |
1016 | ||
1017 | ||
1018 | static int | |
1019 | ForgetOneLocalToken(struct ktc_principal *aserver) | |
1020 | { | |
1021 | int i; | |
1022 | ||
1023 | LOCK_GLOBAL_MUTEX; | |
1024 | for (i = 0; i < MAXLOCALTOKENS; i++) { | |
1025 | if (local_tokens[i].valid | |
1026 | && (strcmp(local_tokens[i].server.name, aserver->name) == 0) | |
1027 | && (strcmp(local_tokens[i].server.instance, aserver->instance) == | |
1028 | 0) | |
1029 | && (strcmp(local_tokens[i].server.cell, aserver->cell) == 0)) { | |
1030 | local_tokens[i].valid = 0; | |
1031 | memset(&local_tokens[i].token.sessionKey, 0, | |
1032 | sizeof(struct ktc_encryptionKey)); | |
1033 | UNLOCK_GLOBAL_MUTEX; | |
1034 | return 0; | |
1035 | } | |
1036 | } | |
1037 | UNLOCK_GLOBAL_MUTEX; | |
1038 | return KTC_NOENT; | |
1039 | } | |
1040 | ||
1041 | /*! | |
1042 | * An iterator which can list all cells with tokens in the cache | |
1043 | * | |
1044 | * This function may be used to list the names of all cells for which | |
1045 | * tokens exist in the current cache. The first time that it is called, | |
1046 | * prevIndex should be set to 0. On all subsequent calls, prevIndex | |
1047 | * should be set to the value returned in newIndex by the last call | |
1048 | * to the function. Note that there is no guarantee that the index value | |
1049 | * is monotonically increasing. | |
1050 | * | |
1051 | * @param prevIndex | |
1052 | * The index returned by the last call, or 0 if this is the first | |
1053 | * call in an iteration | |
1054 | * @param newIndex | |
1055 | * A pointer to an int which, upon return, will hold the next value | |
1056 | * to be used. | |
1057 | * @param cellName | |
1058 | * A pointer to a char * which, upon return, will hold a cellname. | |
1059 | * This must be freed by the caller using free() | |
1060 | */ | |
1061 | ||
1062 | int | |
1063 | ktc_ListTokensEx(int prevIndex, int *newIndex, char **cellName) { | |
1064 | struct ViceIoctl iob; | |
1065 | char tbuffer[MAXPIOCTLTOKENLEN]; | |
1066 | afs_int32 code; | |
1067 | afs_int32 index; | |
1068 | struct ktc_setTokenData tokenSet; | |
1069 | XDR xdrs; | |
1070 | HANDLE ktcMutex = NULL; | |
1071 | ||
1072 | memset(&tokenSet, 0, sizeof(tokenSet)); | |
1073 | ||
1074 | *cellName = NULL; | |
1075 | *newIndex = prevIndex; | |
1076 | ||
1077 | index = prevIndex; | |
1078 | ||
1079 | while (index<100) { /* Safety, incase of pioctl failure */ | |
1080 | memset(tbuffer, 0, sizeof(tbuffer)); | |
1081 | iob.in = tbuffer; | |
1082 | memcpy(tbuffer, &index, sizeof(afs_int32)); | |
1083 | iob.in_size = sizeof(afs_int32); | |
1084 | iob.out = tbuffer; | |
1085 | iob.out_size = sizeof(tbuffer); | |
1086 | ||
1087 | #if 0 | |
1088 | code = pioctl(0, VIOC_GETTOK2, &iob, 0); | |
1089 | #else | |
1090 | code = -1; /* not yet implemented */ | |
1091 | errno = EINVAL; | |
1092 | #endif | |
1093 | ||
1094 | /* Can't use new pioctl, so must use old one */ | |
1095 | if (code == -1 && errno == EINVAL) { | |
1096 | struct ktc_principal server; | |
1097 | ||
1098 | code = ktc_ListTokens(index, newIndex, &server); | |
1099 | if (code == 0) | |
1100 | *cellName = strdup(server.cell); | |
1101 | return code; | |
1102 | } | |
1103 | ||
1104 | if (code == 0) { | |
1105 | /* Got a token from the pioctl. Now we throw it away, | |
1106 | * so we can return just a cellname. This is rather wasteful, | |
1107 | * but it's what the old API does. Ho hum. */ | |
1108 | ||
1109 | xdrmem_create(&xdrs, iob.out, iob.out_size, XDR_DECODE); | |
1110 | if (!xdr_ktc_setTokenData(&xdrs, &tokenSet)) { | |
1111 | xdr_destroy(&xdrs); | |
1112 | return EINVAL; | |
1113 | } | |
1114 | xdr_destroy(&xdrs); | |
1115 | *cellName = strdup(tokenSet.cell); | |
1116 | xdr_free((xdrproc_t)xdr_ktc_setTokenData, &tokenSet); | |
1117 | *newIndex = index + 1; | |
1118 | return 0; | |
1119 | } | |
1120 | index++; | |
1121 | } | |
1122 | return KTC_PIOCTLFAIL; | |
1123 | } | |
1124 |