xref: /freebsd/crypto/heimdal/lib/krb5/acache.c (revision 81ad6265) 
1 /*
2  * Copyright (c) 2004 - 2007 Kungliga Tekniska Högskolan
3  * (Royal Institute of Technology, Stockholm, Sweden).
4  * All rights reserved.
5  *
6  * Portions Copyright (c) 2009 Apple Inc. All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  *
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  *
19  * 3. Neither the name of the Institute nor the names of its contributors
20  *    may be used to endorse or promote products derived from this software
21  *    without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  */
35 
36 #include "krb5_locl.h"
37 #include <krb5_ccapi.h>
38 #ifdef HAVE_DLFCN_H
39 #include <dlfcn.h>
40 #endif
41 
42 #ifndef KCM_IS_API_CACHE
43 
44 static HEIMDAL_MUTEX acc_mutex = HEIMDAL_MUTEX_INITIALIZER;
45 static cc_initialize_func init_func;
46 static void (KRB5_CALLCONV *set_target_uid)(uid_t);
47 static void (KRB5_CALLCONV *clear_target)(void);
48 
49 #ifdef HAVE_DLOPEN
50 static void *cc_handle;
51 #endif
52 
53 typedef struct krb5_acc {
54     char *cache_name;
55     cc_context_t context;
56     cc_ccache_t ccache;
57 } krb5_acc;
58 
59 static krb5_error_code KRB5_CALLCONV acc_close(krb5_context, krb5_ccache);
60 
61 #define ACACHE(X) ((krb5_acc *)(X)->data.data)
62 
63 static const struct {
64     cc_int32 error;
65     krb5_error_code ret;
66 } cc_errors[] = {
67     { ccErrBadName,		KRB5_CC_BADNAME },
68     { ccErrCredentialsNotFound,	KRB5_CC_NOTFOUND },
69     { ccErrCCacheNotFound,	KRB5_FCC_NOFILE },
70     { ccErrContextNotFound,	KRB5_CC_NOTFOUND },
71     { ccIteratorEnd,		KRB5_CC_END },
72     { ccErrNoMem,		KRB5_CC_NOMEM },
73     { ccErrServerUnavailable,	KRB5_CC_NOSUPP },
74     { ccErrInvalidCCache,	KRB5_CC_BADNAME },
75     { ccNoError,		0 }
76 };
77 
78 static krb5_error_code
79 translate_cc_error(krb5_context context, cc_int32 error)
80 {
81     size_t i;
82     krb5_clear_error_message(context);
83     for(i = 0; i < sizeof(cc_errors)/sizeof(cc_errors[0]); i++)
84 	if (cc_errors[i].error == error)
85 	    return cc_errors[i].ret;
86     return KRB5_FCC_INTERNAL;
87 }
88 
89 static krb5_error_code
90 init_ccapi(krb5_context context)
91 {
92     const char *lib = NULL;
93 
94     HEIMDAL_MUTEX_lock(&acc_mutex);
95     if (init_func) {
96 	HEIMDAL_MUTEX_unlock(&acc_mutex);
97 	if (context)
98 	    krb5_clear_error_message(context);
99 	return 0;
100     }
101 
102     if (context)
103 	lib = krb5_config_get_string(context, NULL,
104 				     "libdefaults", "ccapi_library",
105 				     NULL);
106     if (lib == NULL) {
107 #ifdef __APPLE__
108 	lib = "/System/Library/Frameworks/Kerberos.framework/Kerberos";
109 #elif defined(KRB5_USE_PATH_TOKENS) && defined(_WIN32)
110 	lib = "%{LIBDIR}/libkrb5_cc.dll";
111 #else
112 	lib = "/usr/lib/libkrb5_cc.so";
113 #endif
114     }
115 
116 #ifdef HAVE_DLOPEN
117 
118 #ifndef RTLD_LAZY
119 #define RTLD_LAZY 0
120 #endif
121 #ifndef RTLD_LOCAL
122 #define RTLD_LOCAL 0
123 #endif
124 
125 #ifdef KRB5_USE_PATH_TOKENS
126     {
127       char * explib = NULL;
128       if (_krb5_expand_path_tokens(context, lib, &explib) == 0) {
129 	cc_handle = dlopen(explib, RTLD_LAZY|RTLD_LOCAL);
130 	free(explib);
131       }
132     }
133 #else
134     cc_handle = dlopen(lib, RTLD_LAZY|RTLD_LOCAL);
135 #endif
136 
137     if (cc_handle == NULL) {
138 	HEIMDAL_MUTEX_unlock(&acc_mutex);
139 	if (context)
140 	    krb5_set_error_message(context, KRB5_CC_NOSUPP,
141 				   N_("Failed to load API cache module %s", "file"),
142 				   lib);
143 	return KRB5_CC_NOSUPP;
144     }
145 
146     init_func = (cc_initialize_func)dlsym(cc_handle, "cc_initialize");
147     set_target_uid = (void (KRB5_CALLCONV *)(uid_t))
148 	dlsym(cc_handle, "krb5_ipc_client_set_target_uid");
149     clear_target = (void (KRB5_CALLCONV *)(void))
150 	dlsym(cc_handle, "krb5_ipc_client_clear_target");
151     HEIMDAL_MUTEX_unlock(&acc_mutex);
152     if (init_func == NULL) {
153 	if (context)
154 	    krb5_set_error_message(context, KRB5_CC_NOSUPP,
155 				   N_("Failed to find cc_initialize"
156 				      "in %s: %s", "file, error"), lib, dlerror());
157 	dlclose(cc_handle);
158 	return KRB5_CC_NOSUPP;
159     }
160 
161     return 0;
162 #else
163     HEIMDAL_MUTEX_unlock(&acc_mutex);
164     if (context)
165 	krb5_set_error_message(context, KRB5_CC_NOSUPP,
166 			       N_("no support for shared object", ""));
167     return KRB5_CC_NOSUPP;
168 #endif
169 }
170 
171 void
172 _heim_krb5_ipc_client_set_target_uid(uid_t uid)
173 {
174     init_ccapi(NULL);
175     if (set_target_uid != NULL)
176         (*set_target_uid)(uid);
177 }
178 
179 void
180 _heim_krb5_ipc_client_clear_target(void)
181 {
182     init_ccapi(NULL);
183     if (clear_target != NULL)
184         (*clear_target)();
185 }
186 
187 static krb5_error_code
188 make_cred_from_ccred(krb5_context context,
189 		     const cc_credentials_v5_t *incred,
190 		     krb5_creds *cred)
191 {
192     krb5_error_code ret;
193     unsigned int i;
194 
195     memset(cred, 0, sizeof(*cred));
196 
197     ret = krb5_parse_name(context, incred->client, &cred->client);
198     if (ret)
199 	goto fail;
200 
201     ret = krb5_parse_name(context, incred->server, &cred->server);
202     if (ret)
203 	goto fail;
204 
205     cred->session.keytype = incred->keyblock.type;
206     cred->session.keyvalue.length = incred->keyblock.length;
207     cred->session.keyvalue.data = malloc(incred->keyblock.length);
208     if (cred->session.keyvalue.data == NULL)
209 	goto nomem;
210     memcpy(cred->session.keyvalue.data, incred->keyblock.data,
211 	   incred->keyblock.length);
212 
213     cred->times.authtime = incred->authtime;
214     cred->times.starttime = incred->starttime;
215     cred->times.endtime = incred->endtime;
216     cred->times.renew_till = incred->renew_till;
217 
218     ret = krb5_data_copy(&cred->ticket,
219 			 incred->ticket.data,
220 			 incred->ticket.length);
221     if (ret)
222 	goto nomem;
223 
224     ret = krb5_data_copy(&cred->second_ticket,
225 			 incred->second_ticket.data,
226 			 incred->second_ticket.length);
227     if (ret)
228 	goto nomem;
229 
230     cred->authdata.val = NULL;
231     cred->authdata.len = 0;
232 
233     cred->addresses.val = NULL;
234     cred->addresses.len = 0;
235 
236     for (i = 0; incred->authdata && incred->authdata[i]; i++)
237 	;
238 
239     if (i) {
240 	cred->authdata.val = calloc(i, sizeof(cred->authdata.val[0]));
241 	if (cred->authdata.val == NULL)
242 	    goto nomem;
243 	cred->authdata.len = i;
244 	for (i = 0; i < cred->authdata.len; i++) {
245 	    cred->authdata.val[i].ad_type = incred->authdata[i]->type;
246 	    ret = krb5_data_copy(&cred->authdata.val[i].ad_data,
247 				 incred->authdata[i]->data,
248 				 incred->authdata[i]->length);
249 	    if (ret)
250 		goto nomem;
251 	}
252     }
253 
254     for (i = 0; incred->addresses && incred->addresses[i]; i++)
255 	;
256 
257     if (i) {
258 	cred->addresses.val = calloc(i, sizeof(cred->addresses.val[0]));
259 	if (cred->addresses.val == NULL)
260 	    goto nomem;
261 	cred->addresses.len = i;
262 
263 	for (i = 0; i < cred->addresses.len; i++) {
264 	    cred->addresses.val[i].addr_type = incred->addresses[i]->type;
265 	    ret = krb5_data_copy(&cred->addresses.val[i].address,
266 				 incred->addresses[i]->data,
267 				 incred->addresses[i]->length);
268 	    if (ret)
269 		goto nomem;
270 	}
271     }
272 
273     cred->flags.i = 0;
274     if (incred->ticket_flags & KRB5_CCAPI_TKT_FLG_FORWARDABLE)
275 	cred->flags.b.forwardable = 1;
276     if (incred->ticket_flags & KRB5_CCAPI_TKT_FLG_FORWARDED)
277 	cred->flags.b.forwarded = 1;
278     if (incred->ticket_flags & KRB5_CCAPI_TKT_FLG_PROXIABLE)
279 	cred->flags.b.proxiable = 1;
280     if (incred->ticket_flags & KRB5_CCAPI_TKT_FLG_PROXY)
281 	cred->flags.b.proxy = 1;
282     if (incred->ticket_flags & KRB5_CCAPI_TKT_FLG_MAY_POSTDATE)
283 	cred->flags.b.may_postdate = 1;
284     if (incred->ticket_flags & KRB5_CCAPI_TKT_FLG_POSTDATED)
285 	cred->flags.b.postdated = 1;
286     if (incred->ticket_flags & KRB5_CCAPI_TKT_FLG_INVALID)
287 	cred->flags.b.invalid = 1;
288     if (incred->ticket_flags & KRB5_CCAPI_TKT_FLG_RENEWABLE)
289 	cred->flags.b.renewable = 1;
290     if (incred->ticket_flags & KRB5_CCAPI_TKT_FLG_INITIAL)
291 	cred->flags.b.initial = 1;
292     if (incred->ticket_flags & KRB5_CCAPI_TKT_FLG_PRE_AUTH)
293 	cred->flags.b.pre_authent = 1;
294     if (incred->ticket_flags & KRB5_CCAPI_TKT_FLG_HW_AUTH)
295 	cred->flags.b.hw_authent = 1;
296     if (incred->ticket_flags & KRB5_CCAPI_TKT_FLG_TRANSIT_POLICY_CHECKED)
297 	cred->flags.b.transited_policy_checked = 1;
298     if (incred->ticket_flags & KRB5_CCAPI_TKT_FLG_OK_AS_DELEGATE)
299 	cred->flags.b.ok_as_delegate = 1;
300     if (incred->ticket_flags & KRB5_CCAPI_TKT_FLG_ANONYMOUS)
301 	cred->flags.b.anonymous = 1;
302 
303     return 0;
304 
305 nomem:
306     ret = ENOMEM;
307     krb5_set_error_message(context, ret, N_("malloc: out of memory", "malloc"));
308 
309 fail:
310     krb5_free_cred_contents(context, cred);
311     return ret;
312 }
313 
314 static void
315 free_ccred(cc_credentials_v5_t *cred)
316 {
317     int i;
318 
319     if (cred->addresses) {
320 	for (i = 0; cred->addresses[i] != 0; i++) {
321 	    if (cred->addresses[i]->data)
322 		free(cred->addresses[i]->data);
323 	    free(cred->addresses[i]);
324 	}
325 	free(cred->addresses);
326     }
327     if (cred->server)
328 	free(cred->server);
329     if (cred->client)
330 	free(cred->client);
331     memset(cred, 0, sizeof(*cred));
332 }
333 
334 static krb5_error_code
335 make_ccred_from_cred(krb5_context context,
336 		     const krb5_creds *incred,
337 		     cc_credentials_v5_t *cred)
338 {
339     krb5_error_code ret;
340     size_t i;
341 
342     memset(cred, 0, sizeof(*cred));
343 
344     ret = krb5_unparse_name(context, incred->client, &cred->client);
345     if (ret)
346 	goto fail;
347 
348     ret = krb5_unparse_name(context, incred->server, &cred->server);
349     if (ret)
350 	goto fail;
351 
352     cred->keyblock.type = incred->session.keytype;
353     cred->keyblock.length = incred->session.keyvalue.length;
354     cred->keyblock.data = incred->session.keyvalue.data;
355 
356     cred->authtime = incred->times.authtime;
357     cred->starttime = incred->times.starttime;
358     cred->endtime = incred->times.endtime;
359     cred->renew_till = incred->times.renew_till;
360 
361     cred->ticket.length = incred->ticket.length;
362     cred->ticket.data = incred->ticket.data;
363 
364     cred->second_ticket.length = incred->second_ticket.length;
365     cred->second_ticket.data = incred->second_ticket.data;
366 
367     /* XXX this one should also be filled in */
368     cred->authdata = NULL;
369 
370     cred->addresses = calloc(incred->addresses.len + 1,
371 			     sizeof(cred->addresses[0]));
372     if (cred->addresses == NULL) {
373 
374 	ret = ENOMEM;
375 	goto fail;
376     }
377 
378     for (i = 0; i < incred->addresses.len; i++) {
379 	cc_data *addr;
380 	addr = malloc(sizeof(*addr));
381 	if (addr == NULL) {
382 	    ret = ENOMEM;
383 	    goto fail;
384 	}
385 	addr->type = incred->addresses.val[i].addr_type;
386 	addr->length = incred->addresses.val[i].address.length;
387 	addr->data = malloc(addr->length);
388 	if (addr->data == NULL) {
389 	    free(addr);
390 	    ret = ENOMEM;
391 	    goto fail;
392 	}
393 	memcpy(addr->data, incred->addresses.val[i].address.data,
394 	       addr->length);
395 	cred->addresses[i] = addr;
396     }
397     cred->addresses[i] = NULL;
398 
399     cred->ticket_flags = 0;
400     if (incred->flags.b.forwardable)
401 	cred->ticket_flags |= KRB5_CCAPI_TKT_FLG_FORWARDABLE;
402     if (incred->flags.b.forwarded)
403 	cred->ticket_flags |= KRB5_CCAPI_TKT_FLG_FORWARDED;
404     if (incred->flags.b.proxiable)
405 	cred->ticket_flags |= KRB5_CCAPI_TKT_FLG_PROXIABLE;
406     if (incred->flags.b.proxy)
407 	cred->ticket_flags |= KRB5_CCAPI_TKT_FLG_PROXY;
408     if (incred->flags.b.may_postdate)
409 	cred->ticket_flags |= KRB5_CCAPI_TKT_FLG_MAY_POSTDATE;
410     if (incred->flags.b.postdated)
411 	cred->ticket_flags |= KRB5_CCAPI_TKT_FLG_POSTDATED;
412     if (incred->flags.b.invalid)
413 	cred->ticket_flags |= KRB5_CCAPI_TKT_FLG_INVALID;
414     if (incred->flags.b.renewable)
415 	cred->ticket_flags |= KRB5_CCAPI_TKT_FLG_RENEWABLE;
416     if (incred->flags.b.initial)
417 	cred->ticket_flags |= KRB5_CCAPI_TKT_FLG_INITIAL;
418     if (incred->flags.b.pre_authent)
419 	cred->ticket_flags |= KRB5_CCAPI_TKT_FLG_PRE_AUTH;
420     if (incred->flags.b.hw_authent)
421 	cred->ticket_flags |= KRB5_CCAPI_TKT_FLG_HW_AUTH;
422     if (incred->flags.b.transited_policy_checked)
423 	cred->ticket_flags |= KRB5_CCAPI_TKT_FLG_TRANSIT_POLICY_CHECKED;
424     if (incred->flags.b.ok_as_delegate)
425 	cred->ticket_flags |= KRB5_CCAPI_TKT_FLG_OK_AS_DELEGATE;
426     if (incred->flags.b.anonymous)
427 	cred->ticket_flags |= KRB5_CCAPI_TKT_FLG_ANONYMOUS;
428 
429     return 0;
430 
431 fail:
432     free_ccred(cred);
433 
434     krb5_clear_error_message(context);
435     return ret;
436 }
437 
438 static cc_int32
439 get_cc_name(krb5_acc *a)
440 {
441     cc_string_t name;
442     cc_int32 error;
443 
444     error = (*a->ccache->func->get_name)(a->ccache, &name);
445     if (error)
446 	return error;
447 
448     a->cache_name = strdup(name->data);
449     (*name->func->release)(name);
450     if (a->cache_name == NULL)
451 	return ccErrNoMem;
452     return ccNoError;
453 }
454 
455 
456 static const char* KRB5_CALLCONV
457 acc_get_name(krb5_context context,
458 	     krb5_ccache id)
459 {
460     krb5_acc *a = ACACHE(id);
461     int32_t error;
462 
463     if (a->cache_name == NULL) {
464 	krb5_error_code ret;
465 	krb5_principal principal;
466 	char *name;
467 
468 	ret = _krb5_get_default_principal_local(context, &principal);
469 	if (ret)
470 	    return NULL;
471 
472 	ret = krb5_unparse_name(context, principal, &name);
473 	krb5_free_principal(context, principal);
474 	if (ret)
475 	    return NULL;
476 
477 	error = (*a->context->func->create_new_ccache)(a->context,
478 						       cc_credentials_v5,
479 						       name,
480 						       &a->ccache);
481 	krb5_xfree(name);
482 	if (error)
483 	    return NULL;
484 
485 	error = get_cc_name(a);
486 	if (error)
487 	    return NULL;
488     }
489 
490     return a->cache_name;
491 }
492 
493 static krb5_error_code KRB5_CALLCONV
494 acc_alloc(krb5_context context, krb5_ccache *id)
495 {
496     krb5_error_code ret;
497     cc_int32 error;
498     krb5_acc *a;
499 
500     ret = init_ccapi(context);
501     if (ret)
502 	return ret;
503 
504     ret = krb5_data_alloc(&(*id)->data, sizeof(*a));
505     if (ret) {
506 	krb5_clear_error_message(context);
507 	return ret;
508     }
509 
510     a = ACACHE(*id);
511 
512     error = (*init_func)(&a->context, ccapi_version_3, NULL, NULL);
513     if (error) {
514 	krb5_data_free(&(*id)->data);
515 	return translate_cc_error(context, error);
516     }
517 
518     a->cache_name = NULL;
519 
520     return 0;
521 }
522 
523 static krb5_error_code KRB5_CALLCONV
524 acc_resolve(krb5_context context, krb5_ccache *id, const char *res)
525 {
526     krb5_error_code ret;
527     cc_int32 error;
528     krb5_acc *a;
529 
530     ret = acc_alloc(context, id);
531     if (ret)
532 	return ret;
533 
534     a = ACACHE(*id);
535 
536     error = (*a->context->func->open_ccache)(a->context, res, &a->ccache);
537     if (error == ccNoError) {
538 	cc_time_t offset;
539 	error = get_cc_name(a);
540 	if (error != ccNoError) {
541 	    acc_close(context, *id);
542 	    *id = NULL;
543 	    return translate_cc_error(context, error);
544 	}
545 
546 	error = (*a->ccache->func->get_kdc_time_offset)(a->ccache,
547 							cc_credentials_v5,
548 							&offset);
549 	if (error == 0)
550 	    context->kdc_sec_offset = offset;
551 
552     } else if (error == ccErrCCacheNotFound) {
553 	a->ccache = NULL;
554 	a->cache_name = NULL;
555     } else {
556 	*id = NULL;
557 	return translate_cc_error(context, error);
558     }
559 
560     return 0;
561 }
562 
563 static krb5_error_code KRB5_CALLCONV
564 acc_gen_new(krb5_context context, krb5_ccache *id)
565 {
566     krb5_error_code ret;
567     krb5_acc *a;
568 
569     ret = acc_alloc(context, id);
570     if (ret)
571 	return ret;
572 
573     a = ACACHE(*id);
574 
575     a->ccache = NULL;
576     a->cache_name = NULL;
577 
578     return 0;
579 }
580 
581 static krb5_error_code KRB5_CALLCONV
582 acc_initialize(krb5_context context,
583 	       krb5_ccache id,
584 	       krb5_principal primary_principal)
585 {
586     krb5_acc *a = ACACHE(id);
587     krb5_error_code ret;
588     int32_t error;
589     char *name;
590 
591     ret = krb5_unparse_name(context, primary_principal, &name);
592     if (ret)
593 	return ret;
594 
595     if (a->cache_name == NULL) {
596 	error = (*a->context->func->create_new_ccache)(a->context,
597 						       cc_credentials_v5,
598 						       name,
599 						       &a->ccache);
600 	free(name);
601 	if (error == ccNoError)
602 	    error = get_cc_name(a);
603     } else {
604 	cc_credentials_iterator_t iter;
605 	cc_credentials_t ccred;
606 
607 	error = (*a->ccache->func->new_credentials_iterator)(a->ccache, &iter);
608 	if (error) {
609 	    free(name);
610 	    return translate_cc_error(context, error);
611 	}
612 
613 	while (1) {
614 	    error = (*iter->func->next)(iter, &ccred);
615 	    if (error)
616 		break;
617 	    (*a->ccache->func->remove_credentials)(a->ccache, ccred);
618 	    (*ccred->func->release)(ccred);
619 	}
620 	(*iter->func->release)(iter);
621 
622 	error = (*a->ccache->func->set_principal)(a->ccache,
623 						  cc_credentials_v5,
624 						  name);
625     }
626 
627     if (error == 0 && context->kdc_sec_offset)
628 	error = (*a->ccache->func->set_kdc_time_offset)(a->ccache,
629 							cc_credentials_v5,
630 							context->kdc_sec_offset);
631 
632     return translate_cc_error(context, error);
633 }
634 
635 static krb5_error_code KRB5_CALLCONV
636 acc_close(krb5_context context,
637 	  krb5_ccache id)
638 {
639     krb5_acc *a = ACACHE(id);
640 
641     if (a->ccache) {
642 	(*a->ccache->func->release)(a->ccache);
643 	a->ccache = NULL;
644     }
645     if (a->cache_name) {
646 	free(a->cache_name);
647 	a->cache_name = NULL;
648     }
649     if (a->context) {
650 	(*a->context->func->release)(a->context);
651 	a->context = NULL;
652     }
653     krb5_data_free(&id->data);
654     return 0;
655 }
656 
657 static krb5_error_code KRB5_CALLCONV
658 acc_destroy(krb5_context context,
659 	    krb5_ccache id)
660 {
661     krb5_acc *a = ACACHE(id);
662     cc_int32 error = 0;
663 
664     if (a->ccache) {
665 	error = (*a->ccache->func->destroy)(a->ccache);
666 	a->ccache = NULL;
667     }
668     if (a->context) {
669 	error = (a->context->func->release)(a->context);
670 	a->context = NULL;
671     }
672     return translate_cc_error(context, error);
673 }
674 
675 static krb5_error_code KRB5_CALLCONV
676 acc_store_cred(krb5_context context,
677 	       krb5_ccache id,
678 	       krb5_creds *creds)
679 {
680     krb5_acc *a = ACACHE(id);
681     cc_credentials_union cred;
682     cc_credentials_v5_t v5cred;
683     krb5_error_code ret;
684     cc_int32 error;
685 
686     if (a->ccache == NULL) {
687 	krb5_set_error_message(context, KRB5_CC_NOTFOUND,
688 			       N_("No API credential found", ""));
689 	return KRB5_CC_NOTFOUND;
690     }
691 
692     cred.version = cc_credentials_v5;
693     cred.credentials.credentials_v5 = &v5cred;
694 
695     ret = make_ccred_from_cred(context,
696 			       creds,
697 			       &v5cred);
698     if (ret)
699 	return ret;
700 
701     error = (*a->ccache->func->store_credentials)(a->ccache, &cred);
702     if (error)
703 	ret = translate_cc_error(context, error);
704 
705     free_ccred(&v5cred);
706 
707     return ret;
708 }
709 
710 static krb5_error_code KRB5_CALLCONV
711 acc_get_principal(krb5_context context,
712 		  krb5_ccache id,
713 		  krb5_principal *principal)
714 {
715     krb5_acc *a = ACACHE(id);
716     krb5_error_code ret;
717     int32_t error;
718     cc_string_t name;
719 
720     if (a->ccache == NULL) {
721 	krb5_set_error_message(context, KRB5_CC_NOTFOUND,
722 			       N_("No API credential found", ""));
723 	return KRB5_CC_NOTFOUND;
724     }
725 
726     error = (*a->ccache->func->get_principal)(a->ccache,
727 					      cc_credentials_v5,
728 					      &name);
729     if (error)
730 	return translate_cc_error(context, error);
731 
732     ret = krb5_parse_name(context, name->data, principal);
733 
734     (*name->func->release)(name);
735     return ret;
736 }
737 
738 static krb5_error_code KRB5_CALLCONV
739 acc_get_first (krb5_context context,
740 	       krb5_ccache id,
741 	       krb5_cc_cursor *cursor)
742 {
743     cc_credentials_iterator_t iter;
744     krb5_acc *a = ACACHE(id);
745     int32_t error;
746 
747     if (a->ccache == NULL) {
748 	krb5_set_error_message(context, KRB5_CC_NOTFOUND,
749 			       N_("No API credential found", ""));
750 	return KRB5_CC_NOTFOUND;
751     }
752 
753     error = (*a->ccache->func->new_credentials_iterator)(a->ccache, &iter);
754     if (error) {
755 	krb5_clear_error_message(context);
756 	return ENOENT;
757     }
758     *cursor = iter;
759     return 0;
760 }
761 
762 
763 static krb5_error_code KRB5_CALLCONV
764 acc_get_next (krb5_context context,
765 	      krb5_ccache id,
766 	      krb5_cc_cursor *cursor,
767 	      krb5_creds *creds)
768 {
769     cc_credentials_iterator_t iter = *cursor;
770     cc_credentials_t cred;
771     krb5_error_code ret;
772     int32_t error;
773 
774     while (1) {
775 	error = (*iter->func->next)(iter, &cred);
776 	if (error)
777 	    return translate_cc_error(context, error);
778 	if (cred->data->version == cc_credentials_v5)
779 	    break;
780 	(*cred->func->release)(cred);
781     }
782 
783     ret = make_cred_from_ccred(context,
784 			       cred->data->credentials.credentials_v5,
785 			       creds);
786     (*cred->func->release)(cred);
787     return ret;
788 }
789 
790 static krb5_error_code KRB5_CALLCONV
791 acc_end_get (krb5_context context,
792 	     krb5_ccache id,
793 	     krb5_cc_cursor *cursor)
794 {
795     cc_credentials_iterator_t iter = *cursor;
796     (*iter->func->release)(iter);
797     return 0;
798 }
799 
800 static krb5_error_code KRB5_CALLCONV
801 acc_remove_cred(krb5_context context,
802 		krb5_ccache id,
803 		krb5_flags which,
804 		krb5_creds *cred)
805 {
806     cc_credentials_iterator_t iter;
807     krb5_acc *a = ACACHE(id);
808     cc_credentials_t ccred;
809     krb5_error_code ret;
810     cc_int32 error;
811     char *client, *server;
812 
813     if (a->ccache == NULL) {
814 	krb5_set_error_message(context, KRB5_CC_NOTFOUND,
815 			       N_("No API credential found", ""));
816 	return KRB5_CC_NOTFOUND;
817     }
818 
819     if (cred->client) {
820 	ret = krb5_unparse_name(context, cred->client, &client);
821 	if (ret)
822 	    return ret;
823     } else
824 	client = NULL;
825 
826     ret = krb5_unparse_name(context, cred->server, &server);
827     if (ret) {
828 	free(client);
829 	return ret;
830     }
831 
832     error = (*a->ccache->func->new_credentials_iterator)(a->ccache, &iter);
833     if (error) {
834 	free(server);
835 	free(client);
836 	return translate_cc_error(context, error);
837     }
838 
839     ret = KRB5_CC_NOTFOUND;
840     while (1) {
841 	cc_credentials_v5_t *v5cred;
842 
843 	error = (*iter->func->next)(iter, &ccred);
844 	if (error)
845 	    break;
846 
847 	if (ccred->data->version != cc_credentials_v5)
848 	    goto next;
849 
850 	v5cred = ccred->data->credentials.credentials_v5;
851 
852 	if (client && strcmp(v5cred->client, client) != 0)
853 	    goto next;
854 
855 	if (strcmp(v5cred->server, server) != 0)
856 	    goto next;
857 
858 	(*a->ccache->func->remove_credentials)(a->ccache, ccred);
859 	ret = 0;
860     next:
861 	(*ccred->func->release)(ccred);
862     }
863 
864     (*iter->func->release)(iter);
865 
866     if (ret)
867 	krb5_set_error_message(context, ret,
868 			       N_("Can't find credential %s in cache",
869 				 "principal"), server);
870     free(server);
871     free(client);
872 
873     return ret;
874 }
875 
876 static krb5_error_code KRB5_CALLCONV
877 acc_set_flags(krb5_context context,
878 	      krb5_ccache id,
879 	      krb5_flags flags)
880 {
881     return 0;
882 }
883 
884 static int KRB5_CALLCONV
885 acc_get_version(krb5_context context,
886 		krb5_ccache id)
887 {
888     return 0;
889 }
890 
891 struct cache_iter {
892     cc_context_t context;
893     cc_ccache_iterator_t iter;
894 };
895 
896 static krb5_error_code KRB5_CALLCONV
897 acc_get_cache_first(krb5_context context, krb5_cc_cursor *cursor)
898 {
899     struct cache_iter *iter;
900     krb5_error_code ret;
901     cc_int32 error;
902 
903     ret = init_ccapi(context);
904     if (ret)
905 	return ret;
906 
907     iter = calloc(1, sizeof(*iter));
908     if (iter == NULL) {
909 	krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
910 	return ENOMEM;
911     }
912 
913     error = (*init_func)(&iter->context, ccapi_version_3, NULL, NULL);
914     if (error) {
915 	free(iter);
916 	return translate_cc_error(context, error);
917     }
918 
919     error = (*iter->context->func->new_ccache_iterator)(iter->context,
920 							&iter->iter);
921     if (error) {
922 	free(iter);
923 	krb5_clear_error_message(context);
924 	return ENOENT;
925     }
926     *cursor = iter;
927     return 0;
928 }
929 
930 static krb5_error_code KRB5_CALLCONV
931 acc_get_cache_next(krb5_context context, krb5_cc_cursor cursor, krb5_ccache *id)
932 {
933     struct cache_iter *iter = cursor;
934     cc_ccache_t cache;
935     krb5_acc *a;
936     krb5_error_code ret;
937     int32_t error;
938 
939     error = (*iter->iter->func->next)(iter->iter, &cache);
940     if (error)
941 	return translate_cc_error(context, error);
942 
943     ret = _krb5_cc_allocate(context, &krb5_acc_ops, id);
944     if (ret) {
945 	(*cache->func->release)(cache);
946 	return ret;
947     }
948 
949     ret = acc_alloc(context, id);
950     if (ret) {
951 	(*cache->func->release)(cache);
952 	free(*id);
953 	return ret;
954     }
955 
956     a = ACACHE(*id);
957     a->ccache = cache;
958 
959     error = get_cc_name(a);
960     if (error) {
961 	acc_close(context, *id);
962 	*id = NULL;
963 	return translate_cc_error(context, error);
964     }
965     return 0;
966 }
967 
968 static krb5_error_code KRB5_CALLCONV
969 acc_end_cache_get(krb5_context context, krb5_cc_cursor cursor)
970 {
971     struct cache_iter *iter = cursor;
972 
973     (*iter->iter->func->release)(iter->iter);
974     iter->iter = NULL;
975     (*iter->context->func->release)(iter->context);
976     iter->context = NULL;
977     free(iter);
978     return 0;
979 }
980 
981 static krb5_error_code KRB5_CALLCONV
982 acc_move(krb5_context context, krb5_ccache from, krb5_ccache to)
983 {
984     krb5_acc *afrom = ACACHE(from);
985     krb5_acc *ato = ACACHE(to);
986     int32_t error;
987 
988     if (ato->ccache == NULL) {
989 	cc_string_t name;
990 
991 	error = (*afrom->ccache->func->get_principal)(afrom->ccache,
992 						      cc_credentials_v5,
993 						      &name);
994 	if (error)
995 	    return translate_cc_error(context, error);
996 
997 	error = (*ato->context->func->create_new_ccache)(ato->context,
998 							 cc_credentials_v5,
999 							 name->data,
1000 							 &ato->ccache);
1001 	(*name->func->release)(name);
1002 	if (error)
1003 	    return translate_cc_error(context, error);
1004     }
1005 
1006     error = (*ato->ccache->func->move)(afrom->ccache, ato->ccache);
1007 
1008     acc_destroy(context, from);
1009 
1010     return translate_cc_error(context, error);
1011 }
1012 
1013 static krb5_error_code KRB5_CALLCONV
1014 acc_get_default_name(krb5_context context, char **str)
1015 {
1016     krb5_error_code ret;
1017     cc_context_t cc;
1018     cc_string_t name;
1019     int32_t error;
1020 
1021     ret = init_ccapi(context);
1022     if (ret)
1023 	return ret;
1024 
1025     error = (*init_func)(&cc, ccapi_version_3, NULL, NULL);
1026     if (error)
1027 	return translate_cc_error(context, error);
1028 
1029     error = (*cc->func->get_default_ccache_name)(cc, &name);
1030     if (error) {
1031 	(*cc->func->release)(cc);
1032 	return translate_cc_error(context, error);
1033     }
1034 
1035     error = asprintf(str, "API:%s", name->data);
1036     (*name->func->release)(name);
1037     (*cc->func->release)(cc);
1038 
1039     if (error < 0 || *str == NULL) {
1040 	krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", ""));
1041 	return ENOMEM;
1042     }
1043     return 0;
1044 }
1045 
1046 static krb5_error_code KRB5_CALLCONV
1047 acc_set_default(krb5_context context, krb5_ccache id)
1048 {
1049     krb5_acc *a = ACACHE(id);
1050     cc_int32 error;
1051 
1052     if (a->ccache == NULL) {
1053 	krb5_set_error_message(context, KRB5_CC_NOTFOUND,
1054 			       N_("No API credential found", ""));
1055 	return KRB5_CC_NOTFOUND;
1056     }
1057 
1058     error = (*a->ccache->func->set_default)(a->ccache);
1059     if (error)
1060 	return translate_cc_error(context, error);
1061 
1062     return 0;
1063 }
1064 
1065 static krb5_error_code KRB5_CALLCONV
1066 acc_lastchange(krb5_context context, krb5_ccache id, krb5_timestamp *mtime)
1067 {
1068     krb5_acc *a = ACACHE(id);
1069     cc_int32 error;
1070     cc_time_t t;
1071 
1072     if (a->ccache == NULL) {
1073 	krb5_set_error_message(context, KRB5_CC_NOTFOUND,
1074 			       N_("No API credential found", ""));
1075 	return KRB5_CC_NOTFOUND;
1076     }
1077 
1078     error = (*a->ccache->func->get_change_time)(a->ccache, &t);
1079     if (error)
1080 	return translate_cc_error(context, error);
1081 
1082     *mtime = t;
1083 
1084     return 0;
1085 }
1086 
1087 /**
1088  * Variable containing the API based credential cache implemention.
1089  *
1090  * @ingroup krb5_ccache
1091  */
1092 
1093 KRB5_LIB_VARIABLE const krb5_cc_ops krb5_acc_ops = {
1094     KRB5_CC_OPS_VERSION,
1095     "API",
1096     acc_get_name,
1097     acc_resolve,
1098     acc_gen_new,
1099     acc_initialize,
1100     acc_destroy,
1101     acc_close,
1102     acc_store_cred,
1103     NULL, /* acc_retrieve */
1104     acc_get_principal,
1105     acc_get_first,
1106     acc_get_next,
1107     acc_end_get,
1108     acc_remove_cred,
1109     acc_set_flags,
1110     acc_get_version,
1111     acc_get_cache_first,
1112     acc_get_cache_next,
1113     acc_end_cache_get,
1114     acc_move,
1115     acc_get_default_name,
1116     acc_set_default,
1117     acc_lastchange,
1118     NULL,
1119     NULL,
1120 };
1121 
1122 #endif
1123