xref: /freebsd/crypto/krb5/src/ccapi/test/test_ccapi_ccache.c (revision b670c9bafc0e31c7609969bf374b2e80bdc00211) 
1 #include <string.h>
2 #include <stdlib.h>
3 #include <errno.h>
4 #include <limits.h>
5 #include "test_ccapi_check.h"
6 #include "test_ccapi_util.h"
7 #include "test_ccapi_context.h"
8 #include "test_ccapi_ccache.h"
9 
10 // ---------------------------------------------------------------------------
11 
12 
13 int check_cc_ccache_release(void) {
14 	cc_int32 err = 0;
15 	cc_context_t context = NULL;
16 	cc_ccache_t ccache = NULL;
17 
18 	BEGIN_TEST("cc_ccache_release");
19 
20 	#ifndef cc_ccache_release
21 	log_error("cc_ccache_release is not implemented yet");
22 	failure_count++;
23 	#else
24 
25 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
26 
27 	if (!err) {
28 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
29 	}
30 
31 
32 
33 	if (!err) {
34 		check_once_cc_ccache_release(context, ccache, ccNoError, NULL);
35 		ccache = NULL;
36 	}
37 
38 	if (context) { cc_context_release(context); }
39 
40 	#endif /* cc_ccache_release */
41 
42 	END_TEST_AND_RETURN
43 }
44 
45 cc_int32 check_once_cc_ccache_release(cc_context_t context, cc_ccache_t ccache, cc_int32 expected_err, const char *description) {
46 	cc_int32 err = ccNoError;
47 
48 	cc_int32 possible_return_values[2] = {
49 		ccNoError,
50 		ccErrInvalidCCache,
51 	};
52 
53 	cc_string_t name = NULL;
54 
55 	err = cc_ccache_get_name(ccache, &name);
56 	err = cc_ccache_release(ccache);
57 	ccache = NULL;
58 
59     BEGIN_CHECK_ONCE(description);
60 
61 	#ifdef cc_ccache_release
62 
63 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
64 
65 	// check returned error
66 	check_err(err, expected_err, possible_return_values);
67 
68 	if (!err && name) { // try opening released ccache to make sure it still exists
69 		err = cc_context_open_ccache(context, name->data, &ccache);
70 	}
71 	check_if(err == ccErrCCacheNotFound, "released ccache was actually destroyed instead");
72 
73 	if (ccache) { cc_ccache_destroy(ccache); }
74 	if (name) { cc_string_release(name); }
75 
76 	#endif /* cc_ccache_release */
77 
78 	END_CHECK_ONCE;
79 
80 	return err;
81 }
82 
83 
84 // ---------------------------------------------------------------------------
85 
86 
87 int check_cc_ccache_destroy(void) {
88 	cc_int32 err = 0;
89 	cc_context_t context = NULL;
90 	cc_ccache_t ccache = NULL;
91 
92 	BEGIN_TEST("cc_ccache_destroy");
93 
94 	#ifndef cc_ccache_destroy
95 	log_error("cc_ccache_destroy is not implemented yet");
96 	failure_count++;
97 	#else
98 
99 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
100 
101 	if (!err) {
102 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
103 	}
104 
105 
106 
107 	if (!err) {
108 		check_once_cc_ccache_destroy(context, ccache, ccNoError, NULL);
109 		ccache = NULL;
110 	}
111 
112 	if (context) { cc_context_release(context); }
113 
114 	#endif /* cc_ccache_destroy */
115 
116 	END_TEST_AND_RETURN
117 }
118 
119 cc_int32 check_once_cc_ccache_destroy(cc_context_t context, cc_ccache_t ccache, cc_int32 expected_err, const char *description) {
120 	cc_int32 err = ccNoError;
121 
122 	cc_int32 possible_return_values[2] = {
123 		ccNoError,
124 		ccErrInvalidCCache,
125 	};
126 
127 	cc_string_t name = NULL;
128 
129     BEGIN_CHECK_ONCE(description);
130 
131 	#ifdef cc_ccache_destroy
132 
133 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
134 
135 	err = cc_ccache_get_name(ccache, &name);
136 	err = cc_ccache_destroy(ccache);
137 	ccache = NULL;
138 
139 	// check returned error
140 	check_err(err, expected_err, possible_return_values);
141 
142 	if (!err && name) { // try opening released ccache to make sure it still exists
143 		err = cc_context_open_ccache(context, name->data, &ccache);
144 	}
145 	check_if(err != ccErrCCacheNotFound, "destroyed ccache was actually released instead");
146 
147 	if (ccache) { cc_ccache_destroy(ccache); }
148 	if (name) { cc_string_release(name); }
149 
150 	#endif /* cc_ccache_destroy */
151 
152 	END_CHECK_ONCE;
153 
154 	return err;
155 }
156 
157 
158 // ---------------------------------------------------------------------------
159 
160 
161 int check_cc_ccache_set_default(void) {
162 	cc_int32 err = 0;
163 	cc_context_t context = NULL;
164 	cc_ccache_t ccache = NULL;
165 
166 	BEGIN_TEST("cc_ccache_set_default");
167 
168 	#ifndef cc_ccache_set_default
169 	log_error("cc_ccache_set_default is not implemented yet");
170 	failure_count++;
171 	#else
172 
173 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
174 
175 	// try when it's the only ccache (already default)
176 	if (!err) {
177 		err = destroy_all_ccaches(context);
178 	}
179 	if (!err) {
180 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
181 	}
182 	if (!err) {
183 		check_once_cc_ccache_set_default(context, ccache, ccNoError, "when it's the only ccache (already default)");
184 	}
185 	if (ccache) {
186 		err = cc_ccache_release(ccache);
187 		ccache = NULL;
188 	}
189 
190 	// try when it's not the only ccache (and not default)
191 	if (!err) {
192 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "baz@BAR.ORG", &ccache);
193 	}
194 	if (!err) {
195 		check_once_cc_ccache_set_default(context, ccache, ccNoError, "when it's not the only ccache (and not default)");
196 	}
197 	if (ccache) {
198 		err = cc_ccache_release(ccache);
199 		ccache = NULL;
200 	}
201 
202 	// try when it's not the only ccache (and already default)
203 	if (!err) {
204 		err = cc_context_open_default_ccache(context, &ccache);
205 	}
206 	if (!err) {
207 		check_once_cc_ccache_set_default(context, ccache, ccNoError, "when it's not the only ccache (and already default)");
208 	}
209 	if (ccache) {
210 		err = cc_ccache_release(ccache);
211 		ccache = NULL;
212 	}
213 
214 	if (!err) {
215 		err = destroy_all_ccaches(context);
216 	}
217 
218 	if (context) { cc_context_release(context); }
219 
220 	#endif /* cc_ccache_set_default */
221 
222 	END_TEST_AND_RETURN
223 }
224 
225 cc_int32 check_once_cc_ccache_set_default(cc_context_t context, cc_ccache_t ccache, cc_int32 expected_err, const char *description) {
226 	cc_int32 err = ccNoError;
227 
228 	cc_int32 possible_return_values[3] = {
229 		ccNoError,
230 		ccErrInvalidCCache,
231 		ccErrCCacheNotFound,
232 	};
233 
234 	cc_ccache_t default_ccache = NULL;
235 	cc_string_t name = NULL;
236 	cc_string_t default_name = NULL;
237 
238     BEGIN_CHECK_ONCE(description);
239 
240 	#ifdef cc_ccache_set_default
241 
242 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
243 
244 	err = cc_ccache_set_default(ccache);
245 	// check returned error
246 	check_err(err, expected_err, possible_return_values);
247 
248 	if (!err) {
249 		err = cc_ccache_get_name(ccache, &name);
250 	}
251 	if (!err) {
252 		err = cc_context_open_default_ccache(context, &default_ccache);
253 	}
254 	if (!err) {
255 		err = cc_ccache_get_name(default_ccache, &default_name);
256 	}
257 	if (name && default_name) {
258 		check_if(strcmp(name->data, default_name->data), NULL);
259 	}
260 	else {
261 		check_if(1, "cc_ccache_get_name failed");
262 	}
263 
264 	if (default_ccache) { cc_ccache_release(default_ccache); }
265 	//if (ccache) { cc_ccache_destroy(ccache); } // ccache is released by the caller
266 	if (default_name) { cc_string_release(default_name); }
267 	if (name) { cc_string_release(name); }
268 
269 	#endif /* cc_ccache_set_default */
270 
271 	END_CHECK_ONCE;
272 
273 	return err;
274 }
275 
276 
277 // ---------------------------------------------------------------------------
278 
279 
280 int check_cc_ccache_get_credentials_version(void) {
281 	cc_int32 err = 0;
282 	cc_context_t context = NULL;
283 	cc_ccache_t ccache = NULL;
284 
285 	BEGIN_TEST("cc_ccache_get_credentials_version");
286 
287 	#ifndef cc_ccache_get_credentials_version
288 	log_error("cc_ccache_get_credentials_version is not implemented yet");
289 	failure_count++;
290 	#else
291 
292 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
293 
294 	// try one created with v5 creds
295 	if (!err) {
296 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
297 	}
298 	if (!err) {
299 		check_once_cc_ccache_get_credentials_version(ccache, cc_credentials_v5, ccNoError, "v5 creds");
300 	}
301 	else {
302 		log_error("cc_context_create_new_ccache failed, can't complete test");
303 		failure_count++;
304 	}
305 
306 	if (ccache) {
307 		cc_ccache_destroy(ccache);
308 		ccache = NULL;
309 	}
310 
311 	err = ccNoError;
312 
313 	if (context) { cc_context_release(context); }
314 
315 	#endif /* cc_ccache_get_credentials_version */
316 
317 	END_TEST_AND_RETURN
318 }
319 
320 cc_int32 check_once_cc_ccache_get_credentials_version(cc_ccache_t ccache, cc_uint32 expected_cred_vers, cc_int32 expected_err, const char *description) {
321 	cc_int32 err = ccNoError;
322 
323 	cc_int32 possible_return_values[4] = {
324 		ccNoError,
325 		ccErrInvalidCCache,
326 		ccErrBadParam,
327 		ccErrCCacheNotFound,
328 	};
329 
330 	cc_uint32 stored_cred_vers = 0;
331 
332     BEGIN_CHECK_ONCE(description);
333 
334 	#ifdef cc_ccache_get_credentials_version
335 
336 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
337 
338 	err = cc_ccache_get_credentials_version(ccache, &stored_cred_vers);
339 
340 	// check returned error
341 	check_err(err, expected_err, possible_return_values);
342 
343 	if (!err) {
344 		check_if(stored_cred_vers != expected_cred_vers, NULL);
345 	}
346 
347 	#endif /* cc_ccache_get_credentials_version */
348 
349 	END_CHECK_ONCE;
350 
351 	return err;
352 }
353 
354 
355 // ---------------------------------------------------------------------------
356 
357 
358 int check_cc_ccache_get_name(void) {
359 	cc_int32 err = 0;
360 	cc_context_t context = NULL;
361 	cc_ccache_t ccache = NULL;
362 
363 	BEGIN_TEST("cc_ccache_get_name");
364 
365 	#ifndef cc_ccache_get_name
366 	log_error("cc_ccache_get_name is not implemented yet");
367 	failure_count++;
368 	#else
369 
370 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
371 
372 	if (!err) {
373 		err = destroy_all_ccaches(context);
374 	}
375 
376 	// try with unique ccache (which happens to be default)
377 	if (!err) {
378 		err = cc_context_create_ccache(context, "0", cc_credentials_v5, "foo@BAR.ORG", &ccache);
379 	}
380 	if (!err) {
381 		check_once_cc_ccache_get_name(ccache, "0", ccNoError, "unique ccache (which happens to be default)");
382 	}
383 	else {
384 		log_error("cc_context_create_ccache failed, can't complete test");
385 		failure_count++;
386 	}
387 	if (ccache) {
388 		cc_ccache_release(ccache);
389 		ccache = NULL;
390 	}
391 
392 	// try with unique ccache (which is not default)
393 	if (!err) {
394 		err = cc_context_create_ccache(context, "1", cc_credentials_v5, "foo@BAR.ORG", &ccache);
395 	}
396 	if (!err) {
397 		check_once_cc_ccache_get_name(ccache, "1", ccNoError, "unique ccache (which is not default)");
398 	}
399 	else {
400 		log_error("cc_context_create_ccache failed, can't complete test");
401 		failure_count++;
402 	}
403 
404 	// try with bad param
405 	if (!err) {
406 		check_once_cc_ccache_get_name(ccache, NULL, ccErrBadParam, "NULL param");
407 	}
408 	if (ccache) {
409 		cc_ccache_release(ccache);
410 		ccache = NULL;
411 	}
412 
413 	if (context) {
414 		err = destroy_all_ccaches(context);
415 		cc_context_release(context);
416 	}
417 
418 	#endif /* cc_ccache_get_name */
419 
420 	END_TEST_AND_RETURN
421 }
422 
423 cc_int32 check_once_cc_ccache_get_name(cc_ccache_t ccache, const char *expected_name, cc_int32 expected_err, const char *description) {
424 	cc_int32 err = ccNoError;
425 
426 	cc_int32 possible_return_values[4] = {
427 		ccNoError,
428 		ccErrInvalidCCache,
429 		ccErrBadParam,
430 		ccErrCCacheNotFound,
431 	};
432 
433 	cc_string_t stored_name = NULL;
434 
435     BEGIN_CHECK_ONCE(description);
436 
437 	#ifdef cc_ccache_get_name
438 
439 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
440 
441 	if (expected_name == NULL) { // we want to try with a NULL param
442 		err = cc_ccache_get_name(ccache, NULL);
443 	}
444 	else {
445 		err = cc_ccache_get_name(ccache, &stored_name);
446 	}
447 
448 	// check returned error
449 	check_err(err, expected_err, possible_return_values);
450 
451 	if (!err) {
452 		check_if(strcmp(stored_name->data, expected_name), NULL);
453 	}
454 
455 	if (stored_name) { cc_string_release(stored_name); }
456 
457 	#endif /* cc_ccache_get_name */
458 
459 	END_CHECK_ONCE;
460 
461 	return err;
462 }
463 
464 
465 // ---------------------------------------------------------------------------
466 
467 cc_int32 check_once_cc_ccache_get_principal(cc_ccache_t ccache,
468                                             cc_uint32 cred_vers,
469                                             const char *expected_principal,
470                                             cc_int32 expected_err,
471                                             const char *description) {
472 	cc_int32 err = ccNoError;
473 	cc_string_t stored_principal = NULL;
474 
475 	cc_int32 possible_return_values[6] = {
476 		ccNoError,
477 		ccErrNoMem,
478 		ccErrBadCredentialsVersion,
479 		ccErrBadParam,
480 		ccErrInvalidCCache,
481 		ccErrCCacheNotFound,
482 	};
483 
484     BEGIN_CHECK_ONCE(description);
485 
486 	#ifdef cc_ccache_get_principal
487 
488 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
489 
490 	if (expected_principal == NULL) { // we want to try with a NULL param
491 		err = cc_ccache_get_principal(ccache, cred_vers, NULL);
492 	}
493 	else {
494 		err = cc_ccache_get_principal(ccache, cred_vers, &stored_principal);
495 	}
496 
497 	// check returned error
498 	check_err(err, expected_err, possible_return_values);
499 
500 	if (!err) {
501 		check_if(strcmp(stored_principal->data, expected_principal), "expected princ == \"%s\" stored princ == \"%s\"", expected_principal, stored_principal->data);
502 	}
503 
504 	if (stored_principal) { cc_string_release(stored_principal); }
505 
506 	#endif /* cc_ccache_get_principal */
507 
508 	END_CHECK_ONCE;
509 
510 	return err;
511 }
512 
513 // ---------------------------------------------------------------------------
514 
515 int check_cc_ccache_get_principal(void) {
516 	cc_int32 err = 0;
517 	cc_context_t context = NULL;
518 	cc_ccache_t ccache = NULL;
519 
520 	BEGIN_TEST("cc_ccache_get_principal");
521 
522 	#ifndef cc_ccache_get_principal
523 	log_error("cc_ccache_get_principal is not implemented yet");
524 	failure_count++;
525 	#else
526 
527 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
528 
529 	if (!err) {
530 		err = destroy_all_ccaches(context);
531 	}
532 
533 	// try with krb5 principal
534 	if (!err) {
535 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo/BAR@BAZ.ORG", &ccache);
536 	}
537 	if (!err) {
538 		check_once_cc_ccache_get_principal(ccache, cc_credentials_v5, "foo/BAR@BAZ.ORG", ccNoError, "trying to get krb5 princ for krb5 ccache");
539 	}
540 	else {
541 		log_error("cc_context_create_new_ccache failed, can't complete test");
542 		failure_count++;
543 	}
544 
545         // try with bad param
546         if (!err) {
547             check_once_cc_ccache_get_principal(ccache, cc_credentials_v5,
548                                                NULL, ccErrBadParam,
549                                                "passed null out param");
550         }
551 
552 	if (ccache) {
553 		cc_ccache_release(ccache);
554 		ccache = NULL;
555 	}
556 
557 	if (context) {
558 		err = destroy_all_ccaches(context);
559 		cc_context_release(context);
560 	}
561 
562 	#endif /* cc_ccache_get_principal */
563 
564 	END_TEST_AND_RETURN
565 }
566 
567 // ---------------------------------------------------------------------------
568 
569 int check_cc_ccache_set_principal(void) {
570 	cc_int32 err = 0;
571 	cc_context_t context = NULL;
572 	cc_ccache_t ccache = NULL;
573 
574 	BEGIN_TEST("cc_ccache_set_principal");
575 
576 	#ifndef cc_ccache_set_principal
577 	log_error("cc_ccache_set_principal is not implemented yet");
578 	failure_count++;
579 	#else
580 
581 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
582 
583 	if (!err) {
584 		err = destroy_all_ccaches(context);
585 	}
586 
587         // replace v5 only ccache's principal
588         if (!err) {
589             err = cc_context_create_new_ccache(context, cc_credentials_v5,
590                                                "foo@BAZ.ORG", &ccache);
591         }
592         if (!err) {
593             check_once_cc_ccache_set_principal(
594                 ccache, cc_credentials_v5, "foo/BAZ@BAR.ORG", ccNoError,
595                 "replace v5 only ccache's principal (empty ccache)");
596         }
597         else {
598             log_error(
599                 "cc_context_create_new_ccache failed, can't complete test");
600             failure_count++;
601         }
602 
603         // bad params
604         if (!err) {
605             check_once_cc_ccache_set_principal(ccache, cc_credentials_v5,
606                                                NULL, ccErrBadParam,
607                                                "NULL principal");
608         }
609 
610         if (ccache) {
611             cc_ccache_destroy(ccache);
612             ccache = NULL;
613         }
614 
615 	if (context) {
616 		err = destroy_all_ccaches(context);
617 		cc_context_release(context);
618 	}
619 
620 	#endif /* cc_ccache_set_principal */
621 
622 	END_TEST_AND_RETURN
623 }
624 
625 cc_int32 check_once_cc_ccache_set_principal(cc_ccache_t ccache, cc_uint32 cred_vers, const char *in_principal, cc_int32 expected_err, const char *description) {
626 	cc_int32 err = ccNoError;
627 	cc_string_t stored_principal = NULL;
628 
629 	cc_int32 possible_return_values[6] = {
630 		ccNoError,
631 		ccErrNoMem,
632 		ccErrInvalidCCache,
633 		ccErrBadCredentialsVersion,
634 		ccErrBadParam,
635 		ccErrCCacheNotFound,
636 	};
637 
638     BEGIN_CHECK_ONCE(description);
639 
640 	#ifdef cc_ccache_set_principal
641 
642 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
643 
644 	err = cc_ccache_set_principal(ccache, cred_vers, in_principal);
645 
646 	// check returned error
647 	check_err(err, expected_err, possible_return_values);
648 
649 	if (!err) {
650 		err = cc_ccache_get_principal(ccache, cred_vers, &stored_principal);
651 	}
652 
653 	// compare stored with input
654 	if (!err) {
655 		check_if(strcmp(stored_principal->data, in_principal), "expected princ == \"%s\" stored princ == \"%s\"", in_principal, stored_principal->data);
656 	}
657 
658 	if (stored_principal) { cc_string_release(stored_principal); }
659 
660 	#endif /* cc_ccache_set_principal */
661 
662 	END_CHECK_ONCE;
663 
664 	return err;
665 }
666 
667 
668 // ---------------------------------------------------------------------------
669 
670 
671 int check_cc_ccache_store_credentials(void) {
672 	cc_int32 err = 0;
673 	cc_context_t context = NULL;
674 	cc_ccache_t ccache = NULL;
675 	cc_ccache_t dup_ccache = NULL;
676 	cc_credentials_union creds_union;
677 	cc_string_t name = NULL;
678 
679 	BEGIN_TEST("cc_ccache_store_credentials");
680 
681 	#ifndef cc_ccache_store_credentials
682 	log_error("cc_ccache_store_credentials is not implemented yet");
683 	failure_count++;
684 	#else
685 
686 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
687 
688 	if (!err) {
689 		err = destroy_all_ccaches(context);
690 	}
691 
692 	if (!err) {
693 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
694 	}
695 
696 	// cred with matching version and realm
697 	if (!err) {
698 		err = new_v5_creds_union(&creds_union, "BAR.ORG");
699 	}
700 
701 	if (!err) {
702 		check_once_cc_ccache_store_credentials(ccache, &creds_union, ccNoError, "ok creds");
703 	}
704 
705 	if (&creds_union) { release_v5_creds_union(&creds_union); }
706 
707 	// try with bad params
708 	check_once_cc_ccache_store_credentials(ccache, NULL, ccErrBadParam, "NULL creds param");
709 
710 	// invalid creds
711 	if (!err) {
712 		err = new_v5_creds_union(&creds_union, "BAR.ORG");
713 	}
714 
715 	if (!err) {
716 		if (creds_union.credentials.credentials_v5->client) {
717 			free(creds_union.credentials.credentials_v5->client);
718 			creds_union.credentials.credentials_v5->client = NULL;
719 		}
720 		check_once_cc_ccache_store_credentials(ccache, &creds_union, ccErrBadParam, "invalid creds (NULL client string)");
721 	}
722 
723 	if (&creds_union) { release_v5_creds_union(&creds_union); }
724 
725 	// non-existent ccache
726 	if (ccache) {
727 		err = cc_ccache_get_name(ccache, &name);
728 		if (!err) {
729 			err = cc_context_open_ccache(context, name->data, &dup_ccache);
730 		}
731 		if (name) { cc_string_release(name); }
732 		if (dup_ccache) { cc_ccache_destroy(dup_ccache); }
733 	}
734 
735 	if (!err) {
736 		err = new_v5_creds_union(&creds_union, "BAR.ORG");
737 	}
738 
739 	if (!err) {
740 		check_once_cc_ccache_store_credentials(ccache, &creds_union, ccErrInvalidCCache, "invalid ccache");
741 	}
742 
743 	if (&creds_union) { release_v5_creds_union(&creds_union); }
744 	if (ccache) { cc_ccache_release(ccache); }
745 	if (context) {
746 		destroy_all_ccaches(context);
747 		cc_context_release(context);
748 	}
749 
750 	#endif /* cc_ccache_store_credentials */
751 
752 	END_TEST_AND_RETURN
753 }
754 
755 cc_int32 check_once_cc_ccache_store_credentials(cc_ccache_t ccache, const cc_credentials_union *credentials, cc_int32 expected_err, const char *description) {
756 	cc_int32 err = ccNoError;
757 	cc_credentials_iterator_t creds_iterator = NULL;
758 	cc_credentials_t creds = NULL;
759 
760 	cc_int32 possible_return_values[6] = {
761 		ccNoError,
762 		ccErrBadParam,
763 		ccErrInvalidCCache,
764 		ccErrInvalidCredentials,
765 		ccErrBadCredentialsVersion,
766 		ccErrCCacheNotFound,
767 	};
768 
769     BEGIN_CHECK_ONCE(description);
770 
771 	#ifdef cc_ccache_store_credentials
772 
773 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
774 
775 	err = cc_ccache_store_credentials(ccache, credentials);
776 
777 	// check returned error
778 	check_err(err, expected_err, possible_return_values);
779 
780 	// make sure credentials were truly stored
781 	if (!err) {
782 		err = cc_ccache_new_credentials_iterator(ccache, &creds_iterator);
783 	}
784 	while (!err) {
785 		err = cc_credentials_iterator_next(creds_iterator, &creds);
786 		if (creds) {
787 			if (compare_v5_creds_unions(credentials, creds->data) == 0) {
788 				break;
789 			}
790 			cc_credentials_release(creds);
791 			creds = NULL;
792 		}
793 	}
794 
795 	if (err == ccIteratorEnd) {
796 		check_if((creds != NULL), "stored credentials not found in ccache");
797 		err = ccNoError;
798 	}
799 	if (creds) { cc_credentials_release(creds); }
800 
801 	#endif /* cc_ccache_store_credentials */
802 
803 	END_CHECK_ONCE;
804 
805 	return err;
806 }
807 
808 
809 // ---------------------------------------------------------------------------
810 
811 
812 int check_cc_ccache_remove_credentials(void) {
813 	cc_int32 err = 0;
814 	cc_context_t context = NULL;
815 	cc_ccache_t ccache = NULL;
816 	cc_ccache_t dup_ccache = NULL;
817 	cc_credentials_t creds_array[10];
818 	cc_credentials_t creds = NULL;
819 	cc_credentials_union creds_union;
820 	cc_credentials_iterator_t creds_iterator = NULL;
821 	cc_string_t name = NULL;
822 	unsigned int i;
823 
824 	BEGIN_TEST("cc_ccache_remove_credentials");
825 
826 	#ifndef cc_ccache_remove_credentials
827 	log_error("cc_ccache_remove_credentials is not implemented yet");
828 	failure_count++;
829 	#else
830 
831 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
832 
833 	if (!err) {
834 		err = destroy_all_ccaches(context);
835 	}
836 
837 	if (!err) {
838 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
839 	}
840 
841 	// store 10 creds and retrieve their cc_credentials_t representations
842 	for(i = 0; !err && (i < 10); i++) {
843 		new_v5_creds_union(&creds_union, "BAR.ORG");
844 		err = cc_ccache_store_credentials(ccache, &creds_union);
845 		if (&creds_union) { release_v5_creds_union(&creds_union); }
846 	}
847 	if (err) {
848 		log_error("failure to store creds_union in remove_creds test");
849 	}
850 	if (!err) {
851 		err = cc_ccache_new_credentials_iterator(ccache, &creds_iterator);
852 	}
853 	i = 0;
854 	while (!err && i < 10) {
855 		err = cc_credentials_iterator_next(creds_iterator, &creds);
856 		if (creds) {
857 			creds_array[i++] = creds;
858 			creds = NULL;
859 		}
860 	}
861 	if (err == ccIteratorEnd) { err = ccNoError; }
862 
863 	// remove 10 valid creds
864 	for (i = 0; !err && (i < 8); i++) {
865 		check_once_cc_ccache_remove_credentials(ccache, creds_array[i], ccNoError, "10 ok creds");
866 	}
867 
868 	// NULL param
869 	check_once_cc_ccache_remove_credentials(ccache, NULL, ccErrBadParam, "NULL creds in param");
870 
871 	// non-existent creds (remove same one twice)
872 	check_once_cc_ccache_remove_credentials(ccache, creds_array[0], ccErrInvalidCredentials, "removed same creds twice");
873 
874 	// non-existent ccache
875 	if (ccache) {
876 		err = cc_ccache_get_name(ccache, &name);
877 		if (!err) {
878 			err = cc_context_open_ccache(context, name->data, &dup_ccache);
879 		}
880 		if (name) { cc_string_release(name); }
881 		if (dup_ccache) { cc_ccache_destroy(dup_ccache); }
882 	}
883 
884 	if (!err) {
885 		err = new_v5_creds_union(&creds_union, "BAR.ORG");
886 	}
887 
888 	if (!err) {
889 		check_once_cc_ccache_remove_credentials(ccache, creds_array[8], ccErrInvalidCCache, "invalid ccache");
890 	}
891 
892 	for(i = 0; i < 10; i++) {
893 		if (creds_array[i]) { cc_credentials_release(creds_array[i]); }
894 	}
895 
896 	if (ccache) { cc_ccache_release(ccache); }
897 	if (context) {
898 		destroy_all_ccaches(context);
899 		cc_context_release(context);
900 	}
901 
902 	#endif /* cc_ccache_remove_credentials */
903 
904 	END_TEST_AND_RETURN
905 }
906 
907 cc_int32 check_once_cc_ccache_remove_credentials(cc_ccache_t ccache, cc_credentials_t in_creds, cc_int32 expected_err, const char *description) {
908 	cc_int32 err = ccNoError;
909 	cc_credentials_iterator_t creds_iterator = NULL;
910 	cc_credentials_t creds = NULL;
911 
912 	cc_int32 possible_return_values[6] = {
913 		ccNoError,
914 		ccErrBadParam,
915 		ccErrInvalidCCache,
916 		ccErrInvalidCredentials,
917 		ccErrCredentialsNotFound,
918 		ccErrCCacheNotFound,
919 	};
920 
921     BEGIN_CHECK_ONCE(description);
922 
923 	#ifdef cc_ccache_remove_credentials
924 
925 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
926 
927 	err = cc_ccache_remove_credentials(ccache, in_creds);
928 
929 	// check returned error
930 	check_err(err, expected_err, possible_return_values);
931 
932 	// make sure credentials were truly removed
933 	if (!err) {
934 		err = cc_ccache_new_credentials_iterator(ccache, &creds_iterator);
935 	}
936 	while (!err) {
937 		err = cc_credentials_iterator_next(creds_iterator, &creds);
938 		if (creds) {
939 			if (compare_v5_creds_unions(in_creds->data, creds->data) == 0) {
940 				break;
941 			}
942 			cc_credentials_release(creds);
943 			creds = NULL;
944 		}
945 	}
946 
947 	if (err == ccIteratorEnd) {
948 		err = ccNoError;
949 	}
950 	else {
951 		check_if((creds != NULL), "credentials not removed from ccache");
952 	}
953 	if (creds) { cc_credentials_release(creds); }
954 
955 	#endif /* cc_ccache_remove_credentials */
956 
957 	END_CHECK_ONCE;
958 
959 	return err;
960 }
961 
962 
963 // ---------------------------------------------------------------------------
964 
965 
966 int check_cc_ccache_new_credentials_iterator(void) {
967 	cc_int32 err = 0;
968 	cc_context_t context = NULL;
969 	cc_ccache_t ccache = NULL;
970 	cc_ccache_t dup_ccache = NULL;
971 	cc_credentials_iterator_t creds_iterator = NULL;
972 	cc_string_t name = NULL;
973 
974 	BEGIN_TEST("cc_ccache_new_credentials_iterator");
975 
976 	#ifndef cc_ccache_new_credentials_iterator
977 	log_error("cc_ccache_new_credentials_iterator is not implemented yet");
978 	failure_count++;
979 	#else
980 
981 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
982 
983 	if (!err) {
984 		err = destroy_all_ccaches(context);
985 	}
986 
987 	if (!err) {
988 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
989 	}
990 
991 	// valid params
992 	if (!err) {
993 		check_once_cc_ccache_new_credentials_iterator(ccache, &creds_iterator, ccNoError, "valid params");
994 	}
995 	if (creds_iterator) {
996 		cc_credentials_iterator_release(creds_iterator);
997 		creds_iterator = NULL;
998 	}
999 
1000 	// NULL out param
1001 	if (!err) {
1002 		check_once_cc_ccache_new_credentials_iterator(ccache, NULL, ccErrBadParam, "NULL out iterator param");
1003 	}
1004 	if (creds_iterator) {
1005 		cc_credentials_iterator_release(creds_iterator);
1006 		creds_iterator = NULL;
1007 	}
1008 
1009 	// non-existent ccache
1010 	if (ccache) {
1011 		err = cc_ccache_get_name(ccache, &name);
1012 		if (!err) {
1013 			err = cc_context_open_ccache(context, name->data, &dup_ccache);
1014 		}
1015 		if (name) { cc_string_release(name); }
1016 		if (dup_ccache) { cc_ccache_destroy(dup_ccache); }
1017 	}
1018 
1019 	if (!err) {
1020 		check_once_cc_ccache_new_credentials_iterator(ccache, &creds_iterator, ccErrInvalidCCache, "invalid ccache");
1021 	}
1022 
1023 	if (creds_iterator) {
1024 		cc_credentials_iterator_release(creds_iterator);
1025 		creds_iterator = NULL;
1026 	}
1027 	if (ccache) { cc_ccache_release(ccache); }
1028 	if (context) {
1029 		destroy_all_ccaches(context);
1030 		cc_context_release(context);
1031 	}
1032 
1033 	#endif /* cc_ccache_new_credentials_iterator */
1034 
1035 	END_TEST_AND_RETURN
1036 }
1037 
1038 
1039 cc_int32 check_once_cc_ccache_new_credentials_iterator(cc_ccache_t ccache, cc_credentials_iterator_t *iterator, cc_int32 expected_err, const char *description) {
1040 	cc_int32 err = ccNoError;
1041 
1042 	cc_int32 possible_return_values[5] = {
1043 		ccNoError,
1044 		ccErrBadParam,
1045 		ccErrNoMem,
1046 		ccErrCCacheNotFound,
1047 		ccErrInvalidCCache,
1048 	};
1049 
1050     BEGIN_CHECK_ONCE(description);
1051 
1052 	#ifdef cc_ccache_new_credentials_iterator
1053 
1054 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
1055 
1056 	err = cc_ccache_new_credentials_iterator(ccache, iterator);
1057 
1058 	// check returned error
1059 	check_err(err, expected_err, possible_return_values);
1060 
1061 	#endif /* cc_ccache_new_credentials_iterator */
1062 
1063 	END_CHECK_ONCE;
1064 
1065 	return err;
1066 }
1067 
1068 
1069 // ---------------------------------------------------------------------------
1070 
1071 cc_int32 check_once_cc_ccache_get_change_time(cc_ccache_t ccache, cc_time_t *last_time, cc_int32 expected_err, const char *description) {
1072 	cc_int32 err = ccNoError;
1073 	cc_time_t this_time = 0;
1074 
1075 	cc_int32 possible_return_values[4] = {
1076 		ccNoError,
1077 		ccErrInvalidCCache,
1078 		ccErrBadParam,
1079 		ccErrCCacheNotFound,
1080 	};
1081 
1082     BEGIN_CHECK_ONCE(description);
1083 
1084 	#ifdef cc_ccache_get_change_time
1085 
1086 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
1087 
1088 	if (last_time == NULL) {
1089 		err = cc_ccache_get_change_time(ccache, NULL); // passed NULL to compare against because intention is actually to pass bad param instead
1090 	} else {
1091 		err = cc_ccache_get_change_time(ccache, &this_time);
1092 	}
1093 
1094 	// check returned error
1095 	check_err(err, expected_err, possible_return_values);
1096 
1097 	if ((!err) && last_time) {
1098 		check_if(this_time <= *last_time, "change time didn't increase when expected");
1099 		*last_time = this_time;
1100 	}
1101 
1102 	#endif /* cc_ccache_get_change_time */
1103 
1104 	END_CHECK_ONCE;
1105 
1106 	return err;
1107 }
1108 
1109 // ---------------------------------------------------------------------------
1110 
1111 int check_cc_ccache_get_change_time(void) {
1112 	cc_int32 err = 0;
1113 	cc_context_t context = NULL;
1114 	cc_ccache_t dummy_ccache = NULL;
1115 	cc_ccache_t ccache = NULL;
1116 	cc_credentials_union creds_union;
1117 	cc_credentials_iterator_t creds_iterator = NULL;
1118 	cc_credentials_t credentials = NULL;
1119 	cc_time_t last_time = 0;
1120 
1121     BEGIN_TEST("cc_ccache_get_change_time");
1122 
1123 	#ifndef cc_ccache_get_change_time
1124 	log_error("cc_ccache_get_change_time is not implemented yet");
1125 	failure_count++;
1126 	#else
1127 
1128 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
1129 
1130 	if (!err) {
1131 		err = destroy_all_ccaches(context);
1132 	}
1133 
1134 	// create some ccaches (so that the one we keep around as 'ccache' is not default)
1135 	if (!err) {
1136 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
1137 	}
1138 	if (ccache) {
1139 		cc_ccache_release(ccache);
1140 	}
1141 	if (!err) {
1142 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAZ.ORG", &ccache);
1143 	}
1144 
1145 	// change it in all the ways it can change, checking after each
1146 
1147 	// the ccache is created
1148 	if (!err) {
1149 		check_once_cc_ccache_get_change_time(ccache, &last_time, ccNoError, "new ccache (change time should be > 0)");
1150 	}
1151 
1152 	// the ccache is made default
1153 	if (!err) {
1154 		err = cc_ccache_set_default(ccache);
1155 	}
1156 	if (!err) {
1157 		check_once_cc_ccache_get_change_time(ccache, &last_time, ccNoError, "non-default ccache became default");
1158 	}
1159 
1160 	// the ccache is made not-default
1161 	if (!err) {
1162 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "something@ELSE.COM", &dummy_ccache);
1163 	}
1164 	if (!err) {
1165 		err = cc_ccache_set_default(dummy_ccache);
1166 	}
1167 	if (dummy_ccache) {
1168 		cc_ccache_release(dummy_ccache);
1169 	}
1170 	if (!err) {
1171 		check_once_cc_ccache_get_change_time(ccache, &last_time, ccNoError, "default ccache became non-default");
1172 	}
1173 
1174 	// try with bad params
1175 
1176 	// NULL out param
1177 	if (!err) {
1178 		check_once_cc_ccache_get_change_time(ccache, NULL, ccErrBadParam, "NULL out param for time");
1179 	}
1180 
1181 	// store a credential
1182 	if (!err) {
1183 		new_v5_creds_union(&creds_union, "BAR.ORG");
1184 		err = cc_ccache_store_credentials(ccache, &creds_union);
1185 		release_v5_creds_union(&creds_union);
1186 	}
1187 	check_once_cc_ccache_get_change_time(ccache, &last_time, ccNoError, "stored new credential");
1188 
1189 	if (!err) {
1190 		// change principal (fails with ccErrBadInternalMessage)
1191 		err = cc_ccache_set_principal(ccache, cc_credentials_v5, "foo@BAR.ORG");
1192 		if (err) {
1193 			log_error("failed to change ccache's principal - %s (%d)", translate_ccapi_error(err), err);
1194 			failure_count++;
1195 			err = ccNoError;
1196 		}
1197 	}
1198 	check_once_cc_context_get_change_time(context, &last_time, ccNoError, "after changing a principle");
1199 
1200 	// remove a credential
1201 	if (!err) {
1202 		err = cc_ccache_new_credentials_iterator(ccache, &creds_iterator);
1203 	}
1204 	if (!err) {
1205 		err = cc_credentials_iterator_next(creds_iterator, &credentials);
1206 	}
1207 	if (err == ccIteratorEnd) {
1208 		err = ccNoError;
1209 	}
1210 	if (!err) {
1211 		err = cc_ccache_remove_credentials(ccache, credentials);
1212 	}
1213 	check_once_cc_context_get_change_time(context, &last_time, ccNoError, "after removing a credential");
1214 
1215 
1216 	// invalid ccache
1217 	if (!err) {
1218 		err = destroy_all_ccaches(context);
1219 	}
1220 	if (!err) {
1221 		check_once_cc_ccache_get_change_time(ccache, &last_time, ccErrInvalidCCache, "getting change time on destroyed ccache");
1222 	}
1223 
1224 	if (ccache) { cc_ccache_release(ccache); }
1225 	if (context) {
1226 		destroy_all_ccaches(context);
1227 		cc_context_release(context);
1228 	}
1229 
1230 	#endif /* cc_ccache_get_change_time */
1231 
1232 	END_TEST_AND_RETURN
1233 }
1234 
1235 
1236 // ---------------------------------------------------------------------------
1237 
1238 cc_int32 check_once_cc_ccache_get_last_default_time(cc_ccache_t ccache, cc_time_t *last_time, cc_int32 expected_err, const char *description) {
1239 	cc_int32 err = ccNoError;
1240 	cc_time_t this_time = 0;
1241 
1242 	cc_int32 possible_return_values[5] = {
1243 		ccNoError,
1244 		ccErrInvalidCCache,
1245 		ccErrBadParam,
1246 		ccErrNeverDefault,
1247 		ccErrCCacheNotFound,
1248 	};
1249 
1250     BEGIN_CHECK_ONCE(description);
1251 
1252 	#ifdef cc_ccache_get_last_default_time
1253 
1254 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
1255 
1256 	if (last_time == NULL) {
1257 		err = cc_ccache_get_last_default_time(ccache, NULL); // passed NULL to compare against because intention is actually to pass bad param instead
1258 	} else {
1259 		err = cc_ccache_get_last_default_time(ccache, &this_time);
1260 	}
1261 
1262 	// check returned error
1263 	check_err(err, expected_err, possible_return_values);
1264 
1265 	if (!err && last_time) {
1266 		check_if(this_time > *last_time, "last default time isn't as expected");
1267 		*last_time = this_time;
1268 	}
1269 
1270 	#endif /* cc_ccache_get_last_default_time */
1271 
1272 	END_CHECK_ONCE;
1273 
1274 	return err;
1275 }
1276 
1277 // ---------------------------------------------------------------------------
1278 
1279 int check_cc_ccache_get_last_default_time(void) {
1280 	cc_int32 err = 0;
1281 	cc_context_t context = NULL;
1282 	cc_ccache_t ccache_1 = NULL;
1283 	cc_ccache_t ccache_2 = NULL;
1284 	cc_time_t last_time_1 = 0;
1285 	cc_time_t last_time_2 = 0;
1286 	cc_string_t name = NULL;
1287 
1288 	BEGIN_TEST("cc_ccache_get_last_default_time");
1289 
1290 	#ifndef cc_ccache_get_last_default_time
1291 	log_error("cc_ccache_get_last_default_time is not implemented yet");
1292 	failure_count++;
1293 	#else
1294 
1295 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
1296 
1297 	if (!err) {
1298 		err = destroy_all_ccaches(context);
1299 	}
1300 
1301 	// create 2 ccaches
1302 	if (!err) {
1303 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@ONE.ORG", &ccache_1);
1304 	}
1305 	if (!err) {
1306 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@TWO.ORG", &ccache_2);
1307 	}
1308 
1309 	if (!err) {
1310 		err = cc_ccache_get_change_time(ccache_1, &last_time_1);
1311 	}
1312 
1313 	// since we destroyed all ccaches before creating these two,
1314 	// ccache_1 should be default and ccache_2 should never have been default
1315 	if (!err) {
1316 		check_once_cc_ccache_get_last_default_time(ccache_1, &last_time_1, ccNoError, "ccache_1 default at creation");
1317 		check_once_cc_ccache_get_last_default_time(ccache_2, &last_time_2, ccErrNeverDefault, "ccache_2 never default");
1318 	}
1319 
1320 	// make ccache_2 default and check each of their times again
1321 	if (!err) {
1322 		err = cc_ccache_set_default(ccache_2);
1323 	}
1324 	if (!err) {
1325 		err = cc_ccache_get_change_time(ccache_2, &last_time_2);
1326 	}
1327 	if (!err) {
1328 		check_once_cc_ccache_get_last_default_time(ccache_1, &last_time_1, ccNoError, "ccache_1 no longer default");
1329 		check_once_cc_ccache_get_last_default_time(ccache_2, &last_time_2, ccNoError, "ccache_2 newly default");
1330 	}
1331 
1332 	// NULL param
1333 	if (!err) {
1334 		check_once_cc_ccache_get_last_default_time(ccache_1, NULL, ccErrBadParam, "NULL out param");
1335 	}
1336 
1337 	// non-existent ccache
1338 	if (ccache_2) {
1339 		cc_ccache_release(ccache_2);
1340 		ccache_2 = NULL;
1341 	}
1342 	if (!err) {
1343 		err = cc_ccache_get_name(ccache_1, &name);
1344 	}
1345 	if (!err) {
1346 		err = cc_context_open_ccache(context, name->data, &ccache_2);
1347 	}
1348 	if (!err) {
1349 		cc_ccache_destroy(ccache_2);
1350 		ccache_2 = NULL;
1351 	}
1352 
1353 	if (!err) {
1354 		check_once_cc_ccache_get_last_default_time(ccache_1, &last_time_1, ccErrInvalidCCache, "destroyed ccache");
1355 	}
1356 
1357 	if (ccache_1) { cc_ccache_release(ccache_1); }
1358 
1359 	if (context) {
1360 		destroy_all_ccaches(context);
1361 		cc_context_release(context);
1362 	}
1363 
1364 	#endif /* cc_ccache_get_last_default_time */
1365 
1366 	END_TEST_AND_RETURN
1367 }
1368 
1369 // ---------------------------------------------------------------------------
1370 
1371 int check_cc_ccache_move(void) {
1372 	cc_int32 err = 0;
1373 	cc_context_t context = NULL;
1374 	cc_ccache_t source = NULL;
1375 	cc_ccache_t destination = NULL;
1376 
1377 	cc_credentials_union creds_union;
1378 	unsigned int i = 0;
1379 
1380 	BEGIN_TEST("cc_ccache_move");
1381 
1382 	#ifndef cc_ccache_move
1383 	log_error("cc_ccache_move is not implemented yet");
1384 	failure_count++;
1385 	#else
1386 
1387 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
1388 
1389 	if (!err) {
1390 		err = destroy_all_ccaches(context);
1391 	}
1392 
1393 	// create 2 ccaches
1394 	if (!err) {
1395 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@ONE.ORG", &source);
1396 	}
1397 	if (!err) {
1398 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@TWO.ORG", &destination);
1399 	}
1400 
1401 	// store credentials in each
1402 	for (i = 0; !err && (i < 10); i++) {
1403 		new_v5_creds_union(&creds_union, "ONE.ORG");
1404 		err = cc_ccache_store_credentials(source, &creds_union);
1405 	}
1406 	for (i = 0; !err && (i < 10); i++) {
1407 		new_v5_creds_union(&creds_union, "TWO.ORG");
1408 		err = cc_ccache_store_credentials(destination, &creds_union);
1409 	}
1410 
1411 	// move source into destination
1412 	if (!err) {
1413 		check_once_cc_ccache_move(source, destination, ccNoError, "valid params");
1414 	}
1415 
1416 	// NULL param
1417 	if (!err) {
1418 		check_once_cc_ccache_move(destination, NULL, ccErrBadParam, "NULL destination param");
1419 	}
1420 
1421 	// non-existent ccache
1422 	if (!err) {
1423 		check_once_cc_ccache_move(destination, source, ccErrInvalidCCache, "recently moved source as destination param");
1424 	}
1425 
1426 	if (source) { cc_ccache_release(source); }
1427 	if (destination) { cc_ccache_release(destination); }
1428 
1429 	if (context) {
1430 		destroy_all_ccaches(context);
1431 		cc_context_release(context);
1432 	}
1433 
1434 	#endif /* cc_ccache_move */
1435 
1436 	END_TEST_AND_RETURN
1437 
1438 
1439 }
1440 
1441 cc_int32 check_once_cc_ccache_move(cc_ccache_t source, cc_ccache_t destination, cc_int32 expected_err, const char *description) {
1442 	cc_int32 err = ccNoError;
1443 	cc_credentials_t dst_creds[10] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, };
1444 	cc_credentials_t creds = NULL;
1445 	cc_credentials_iterator_t cred_iterator = NULL;
1446 	unsigned int i = 0;
1447 
1448 	cc_string_t src_principal = NULL;
1449 	cc_string_t dst_principal = NULL;
1450 
1451 	cc_int32 possible_return_values[4] = {
1452 		ccNoError,
1453 		ccErrBadParam,
1454 		ccErrInvalidCCache,
1455 		ccErrCCacheNotFound,
1456 	};
1457 
1458     BEGIN_CHECK_ONCE(description);
1459 
1460 	#ifdef cc_ccache_move
1461 
1462 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
1463 
1464 	if (destination) {
1465 		// verify all of destination's credentials are no longer there (save a list and call remove_cred for each, expecting an err in response)
1466 		if (!err) {
1467 			err = cc_ccache_new_credentials_iterator(destination, &cred_iterator);
1468 		}
1469 		while (!err && (i < 10)) {
1470 			err = cc_credentials_iterator_next(cred_iterator, &creds);
1471 			if (creds) {
1472 				dst_creds[i++] = creds;
1473 			}
1474 		}
1475 		if (err == ccIteratorEnd) {
1476 			err = ccNoError;
1477 		}
1478 		if (cred_iterator) {
1479 			cc_credentials_iterator_release(cred_iterator);
1480 			cred_iterator = NULL;
1481 		}
1482 
1483 		// verify that destination's principal has changed to source's (strcmp)
1484 		if (!err) {
1485 			err = cc_ccache_get_principal(source, cc_credentials_v5, &src_principal);
1486 		}
1487 	}
1488 
1489 
1490 	if (!err) {
1491 		err = cc_ccache_move(source, destination);
1492 	}
1493 
1494 	// check returned error
1495 	check_err(err, expected_err, possible_return_values);
1496 
1497 
1498 	if (!err) {
1499 		// verify all of destination's credentials are no longer there (save a list and call remove_cred for each, expecting an err in response)
1500 		i = 0;
1501 		while (dst_creds[i] && (i < 10)) {
1502 			err = cc_ccache_remove_credentials(destination, dst_creds[i]);
1503 			check_if(!(!err || err == ccErrCredentialsNotFound || ccErrInvalidCredentials), "credentials in destination not removed as promised");
1504 			cc_credentials_release(dst_creds[i]);
1505 			i++;
1506 		}
1507 		err = ccNoError;
1508 	}
1509 
1510 		// verify that destination's principal has changed to source's (strcmp)
1511 		if (!err) {
1512 			err = cc_ccache_get_principal(destination, cc_credentials_v5, &dst_principal);
1513 		}
1514 		if (!err) {
1515 			check_if(strcmp(src_principal->data, dst_principal->data), "destination principal not overwritten by source");
1516 		}
1517 
1518 		// verify that handles for source are no longer valid (get_change_time)
1519 		if (src_principal) {
1520 			cc_string_release(src_principal);
1521 			src_principal = NULL;
1522 		}
1523 		if (!err) {
1524 			err = cc_ccache_get_principal(source, cc_credentials_v5, &src_principal);
1525 			check_if(err != ccErrInvalidCCache, "source ccache was not invalidated after move");
1526 		}
1527 
1528 
1529 	if (cred_iterator) { cc_credentials_iterator_release(cred_iterator); }
1530 	if (src_principal) { cc_string_release(src_principal); }
1531 	if (dst_principal) { cc_string_release(dst_principal); }
1532 
1533 	#endif /* cc_ccache_move */
1534 
1535 	END_CHECK_ONCE;
1536 
1537 	return err;
1538 }
1539 
1540 
1541 // ---------------------------------------------------------------------------
1542 
1543 int check_cc_ccache_compare(void) {
1544 	cc_int32 err = 0;
1545 	cc_context_t context = NULL;
1546 	cc_ccache_t ccache_a = NULL;
1547 	cc_ccache_t ccache_b = NULL;
1548 	cc_uint32 equal = 0;
1549 
1550 	BEGIN_TEST("cc_ccache_compare");
1551 
1552 	#ifndef cc_ccache_compare
1553 	log_error("cc_ccache_compare is not implemented yet");
1554 	failure_count++;
1555 	#else
1556 
1557 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
1558 
1559 	if (!err) {
1560 		err = destroy_all_ccaches(context);
1561 	}
1562 	if (!err) {
1563 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache_a);
1564 	}
1565 	if (!err) {
1566 		err = cc_context_open_default_ccache(context, &ccache_b);
1567 	}
1568 
1569 	equal = 1;
1570 	check_once_cc_ccache_compare(ccache_a, ccache_a, &equal, ccNoError, "compare ccache with same pointer");
1571 	equal = 1;
1572 	check_once_cc_ccache_compare(ccache_a, ccache_b, &equal, ccNoError, "compare different handles to same ccache");
1573 
1574 	if (ccache_b) {
1575 		cc_ccache_release(ccache_b);
1576 		ccache_b = NULL;
1577 	}
1578 	if (!err) {
1579 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "baz@BAR.ORG", &ccache_b);
1580 	}
1581 	equal = 0;
1582 	check_once_cc_ccache_compare(ccache_a, ccache_b, &equal, ccNoError, "compare different ccaches");
1583 	check_once_cc_ccache_compare(ccache_a, NULL, &equal, ccErrBadParam, "NULL compare_to ccache");
1584 	check_once_cc_ccache_compare(ccache_a, ccache_b, NULL, ccErrBadParam, "NULL out param");
1585 
1586 	if (ccache_a) { cc_ccache_release(ccache_a); }
1587 	if (ccache_b) { cc_ccache_release(ccache_b); }
1588 
1589 	if (context) {
1590 		err = destroy_all_ccaches(context);
1591 		cc_context_release(context);
1592 	}
1593 
1594 	#endif /* cc_ccache_compare */
1595 
1596 	END_TEST_AND_RETURN
1597 }
1598 
1599 cc_int32 check_once_cc_ccache_compare(cc_ccache_t ccache, cc_ccache_t compare_to, cc_uint32 *equal, cc_int32 expected_err, const char *description) {
1600 	cc_int32 err = ccNoError;
1601 	cc_uint32 actually_equal = 0;
1602 
1603 	cc_int32 possible_return_values[4] = {
1604 		ccNoError,
1605 		ccErrInvalidContext,
1606 		ccErrBadParam,
1607 		ccErrServerUnavailable,
1608 	};
1609 
1610     BEGIN_CHECK_ONCE(description);
1611 
1612 	#ifdef cc_ccache_compare
1613 
1614 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
1615 
1616 	if (equal) {
1617 		actually_equal = *equal;
1618 	}
1619 
1620 	err = cc_ccache_compare(ccache, compare_to, equal);
1621 
1622 	if (!err && equal) {
1623 		if (actually_equal) {
1624 			check_if(actually_equal != *equal, "equal ccaches not considered equal");
1625 		}
1626 		else {
1627 			check_if(actually_equal != *equal, "non-equal ccaches considered equal");
1628 		}
1629 	}
1630 
1631 	// check returned error
1632 	check_err(err, expected_err, possible_return_values);
1633 
1634 	#endif /* cc_ccache_compare */
1635 
1636 	return err;
1637 }
1638 
1639 
1640 // ---------------------------------------------------------------------------
1641 
1642 int check_cc_ccache_get_kdc_time_offset(void) {
1643 	cc_int32 err = 0;
1644 	cc_context_t context = NULL;
1645 	cc_ccache_t ccache = NULL;
1646 	cc_time_t time_offset = 0;
1647 
1648 	BEGIN_TEST("cc_ccache_get_kdc_time_offset");
1649 
1650 	#ifndef cc_ccache_get_kdc_time_offset
1651 	log_error("cc_ccache_get_kdc_time_offset is not implemented yet");
1652 	failure_count++;
1653 	#else
1654 
1655 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
1656 
1657 	if (!err) {
1658 		err = destroy_all_ccaches(context);
1659 	}
1660 	if (!err) {
1661 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
1662 	}
1663 
1664 	time_offset = 0;
1665 	check_once_cc_ccache_get_kdc_time_offset(ccache, cc_credentials_v5, &time_offset, ccErrTimeOffsetNotSet, "brand new ccache (offset not yet set)");
1666 
1667 	time_offset = 10;
1668 	if (!err) {
1669 		err = cc_ccache_set_kdc_time_offset(ccache, cc_credentials_v5, time_offset);
1670 	}
1671 	if (!err) {
1672 		check_once_cc_ccache_get_kdc_time_offset(ccache, cc_credentials_v5, &time_offset, ccNoError, "offset set for v5");
1673 	}
1674 
1675 	check_once_cc_ccache_get_kdc_time_offset(ccache, cc_credentials_v5, NULL, ccErrBadParam, "NULL time_offset out param");
1676 
1677 	if (ccache) { cc_ccache_release(ccache); }
1678 
1679 	if (context) {
1680 		err = destroy_all_ccaches(context);
1681 		cc_context_release(context);
1682 	}
1683 
1684 	#endif /* cc_ccache_get_kdc_time_offset */
1685 
1686 	END_TEST_AND_RETURN
1687 }
1688 
1689 cc_int32 check_once_cc_ccache_get_kdc_time_offset(cc_ccache_t ccache, cc_int32 credentials_version, cc_time_t *time_offset, cc_int32 expected_err, const char *description) {
1690 	cc_int32 err = ccNoError;
1691 	cc_time_t expected_offset;
1692 
1693 	cc_int32 possible_return_values[7] = {
1694 		ccNoError,
1695 		ccErrTimeOffsetNotSet,
1696 		ccErrCCacheNotFound,
1697 		ccErrInvalidCCache,
1698 		ccErrBadParam,
1699 		ccErrServerUnavailable,
1700 		ccErrBadCredentialsVersion,
1701 	};
1702 
1703     BEGIN_CHECK_ONCE(description);
1704 
1705 	#ifdef cc_ccache_get_kdc_time_offset
1706 
1707 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
1708 
1709 	if (time_offset) {
1710 		expected_offset = *time_offset;
1711 	}
1712 
1713 	err = cc_ccache_get_kdc_time_offset(ccache, credentials_version, time_offset);
1714 
1715 	// check returned error
1716 	check_err(err, expected_err, possible_return_values);
1717 
1718 	if (!err && time_offset) {
1719 		check_if(*time_offset != expected_offset, "kdc time offset doesn't match expected value");
1720 	}
1721 
1722 	#endif /* cc_ccache_get_kdc_time_offset */
1723 
1724 	return err;
1725 }
1726 
1727 
1728 // ---------------------------------------------------------------------------
1729 
1730 int check_cc_ccache_set_kdc_time_offset(void) {
1731 	cc_int32 err = 0;
1732 	cc_context_t context = NULL;
1733 	cc_ccache_t ccache = NULL;
1734 
1735 	BEGIN_TEST("cc_ccache_set_kdc_time_offset");
1736 
1737 	#ifndef cc_ccache_set_kdc_time_offset
1738 	log_error("cc_ccache_set_kdc_time_offset is not implemented yet");
1739 	failure_count++;
1740 	#else
1741 
1742 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
1743 
1744 	if (!err) {
1745 		err = destroy_all_ccaches(context);
1746 	}
1747 	if (!err) {
1748 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
1749 	}
1750 
1751 	check_once_cc_ccache_set_kdc_time_offset(ccache, cc_credentials_v5, 0, ccNoError, "first time setting offset (v5)");
1752 
1753 	if (ccache) { cc_ccache_release(ccache); }
1754 
1755 	if (context) {
1756 		err = destroy_all_ccaches(context);
1757 		cc_context_release(context);
1758 	}
1759 
1760 	#endif /* cc_ccache_set_kdc_time_offset */
1761 
1762 	END_TEST_AND_RETURN
1763 }
1764 
1765 cc_int32 check_once_cc_ccache_set_kdc_time_offset(cc_ccache_t ccache, cc_int32 credentials_version, cc_time_t time_offset, cc_int32 expected_err, const char *description) {
1766 	cc_int32 err = ccNoError;
1767 	cc_time_t stored_offset = 0;
1768 
1769 	cc_int32 possible_return_values[6] = {
1770 		ccNoError,
1771 		ccErrCCacheNotFound,
1772 		ccErrInvalidCCache,
1773 		ccErrBadParam,
1774 		ccErrServerUnavailable,
1775 		ccErrBadCredentialsVersion,
1776 	};
1777 
1778     BEGIN_CHECK_ONCE(description);
1779 
1780 	#ifdef cc_ccache_set_kdc_time_offset
1781 
1782 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
1783 
1784 	err = cc_ccache_set_kdc_time_offset(ccache, credentials_version, time_offset);
1785 
1786 	// check returned error
1787 	check_err(err, expected_err, possible_return_values);
1788 
1789 	if (!err) {
1790 		err = cc_ccache_get_kdc_time_offset(ccache, credentials_version, &stored_offset);
1791 	}
1792 
1793 	if (!err) {
1794 		check_if(time_offset != stored_offset, "kdc time offset doesn't match expected value");
1795 	}
1796 
1797 	#endif /* cc_ccache_set_kdc_time_offset */
1798 
1799 	return err;
1800 }
1801 
1802 
1803 // ---------------------------------------------------------------------------
1804 
1805 int check_cc_ccache_clear_kdc_time_offset(void) {
1806 	cc_int32 err = 0;
1807 	cc_context_t context = NULL;
1808 	cc_ccache_t ccache = NULL;
1809 
1810 	BEGIN_TEST("cc_ccache_clear_kdc_time_offset");
1811 
1812 	#ifndef cc_ccache_clear_kdc_time_offset
1813 	log_error("cc_ccache_clear_kdc_time_offset is not implemented yet");
1814 	failure_count++;
1815 	#else
1816 
1817 	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
1818 
1819 	if (!err) {
1820 		err = destroy_all_ccaches(context);
1821 	}
1822 	if (!err) {
1823 		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
1824 	}
1825 
1826 	check_once_cc_ccache_clear_kdc_time_offset(ccache, cc_credentials_v5, ccNoError, "clearing an offset that was never set (v5)");
1827 
1828 	err = cc_ccache_set_kdc_time_offset(ccache, cc_credentials_v5, 0);
1829 
1830 	check_once_cc_ccache_clear_kdc_time_offset(ccache, cc_credentials_v5, ccNoError, "clearing v5");
1831 
1832 	if (ccache) { cc_ccache_release(ccache); }
1833 
1834 	if (context) {
1835 		err = destroy_all_ccaches(context);
1836 		cc_context_release(context);
1837 	}
1838 
1839 	#endif /* cc_ccache_clear_kdc_time_offset */
1840 
1841 	END_TEST_AND_RETURN
1842 }
1843 
1844 cc_int32 check_once_cc_ccache_clear_kdc_time_offset(cc_ccache_t ccache, cc_int32 credentials_version, cc_int32 expected_err, const char *description) {
1845 	cc_int32 err = ccNoError;
1846 	cc_time_t stored_offset = 0;
1847 
1848 	cc_int32 possible_return_values[6] = {
1849 		ccNoError,
1850 		ccErrCCacheNotFound,
1851 		ccErrInvalidCCache,
1852 		ccErrBadParam,
1853 		ccErrServerUnavailable,
1854 		ccErrBadCredentialsVersion,
1855 	};
1856 	BEGIN_CHECK_ONCE(description);
1857 
1858 	#ifdef cc_ccache_clear_kdc_time_offset
1859 
1860 	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
1861 
1862 	err = cc_ccache_clear_kdc_time_offset(ccache, credentials_version);
1863 
1864 	// check returned error
1865 	check_err(err, expected_err, possible_return_values);
1866 
1867 	if (!err) {
1868 		err = cc_ccache_get_kdc_time_offset(ccache, credentials_version, &stored_offset);
1869 		check_if(err != ccErrTimeOffsetNotSet, "time offset not cleared");
1870 	}
1871 
1872 	#endif /* cc_ccache_clear_kdc_time_offset */
1873 
1874 	return err;
1875 }
1876