xref: /freebsd/crypto/krb5/src/ccapi/test/test_ccapi_v2.c (revision b670c9bafc0e31c7609969bf374b2e80bdc00211) 
1 #include <string.h>
2 #include "k5-platform.h"	/* pull in asprintf decl/defn */
3 #include "test_ccapi_v2.h"
4 #include <limits.h>
5 #include <time.h>
6 #include "test_ccapi_check.h"
7 #include "test_ccapi_util.h"
8 
9 // ---------------------------------------------------------------------------
10 
11 static cc_result destroy_all_ccaches_v2(apiCB *context) {
12     cc_result err = CC_NOERROR;
13     infoNC **info = NULL;
14     int i = 0;
15 
16     err = cc_get_NC_info(context, &info);
17 
18     for (i = 0; !err && info[i]; i++) {
19         ccache_p *ccache = NULL;
20 
21         err = cc_open(context, info[i]->name, info[i]->vers, 0, &ccache);
22 
23         if (!err) { cc_destroy(context, &ccache); }
24     }
25 
26     if (info) { cc_free_NC_info(context, &info); }
27 
28     if (err) {
29         log_error("cc_get_NC_info or cc_open failed with %s (%d)", translate_ccapi_error(err), err);
30     }
31 
32     return err;
33 }
34 
35 // ---------------------------------------------------------------------------
36 // return zero when both unions are considered equal, non-zero when not
37 
38 static int compare_v5_creds_unions_compat(const cred_union *a, const cred_union *b) {
39     int retval = -1;
40 
41     if (a && b && a->cred_type == b->cred_type) {
42         if (a->cred_type == CC_CRED_V5) {
43             if (!strcmp(a->cred.pV5Cred->client, b->cred.pV5Cred->client) &&
44                 !strcmp(a->cred.pV5Cred->server, b->cred.pV5Cred->server) &&
45                 a->cred.pV5Cred->starttime == b->cred.pV5Cred->starttime) {
46                 retval = 0;
47             }
48         }
49     }
50 
51     return retval;
52 }
53 
54 // ---------------------------------------------------------------------------
55 
56 static cc_result new_v5_creds_union_compat (cred_union *out_union, const char *realm)
57 {
58     cc_result err = CC_NOERROR;
59     cred_union *creds_union = NULL;
60     cc_credentials_v5_compat *v5creds = NULL;
61     static int num_runs = 1;
62     char *client = NULL;
63     char *server = NULL;
64 
65     if (!out_union) { err = CC_BAD_PARM; }
66 
67     if (!err) {
68         v5creds = malloc (sizeof (*v5creds));
69         if (!v5creds) {
70             err = CC_NOMEM;
71         }
72     }
73 
74     if (!err) {
75         asprintf(&client, "client@%s", realm);
76         asprintf(&server, "host/%d%s@%s", num_runs++, realm, realm);
77         if (!client || !server) {
78             err = CC_NOMEM;
79         }
80     }
81 
82     if (!err) {
83         v5creds->client = client;
84         v5creds->server = server;
85         v5creds->keyblock.type = 1;
86         v5creds->keyblock.length = 0;
87         v5creds->keyblock.data = NULL;
88         v5creds->authtime = time (NULL);
89         v5creds->starttime = time (NULL);
90         v5creds->endtime = time(NULL) + 1000;
91         v5creds->renew_till = time(NULL) + 10000;
92         v5creds->is_skey = 0;
93         v5creds->ticket_flags = TKT_FLG_FORWARDABLE | TKT_FLG_PROXIABLE | TKT_FLG_RENEWABLE | TKT_FLG_INITIAL;
94         v5creds->addresses = NULL;
95         v5creds->ticket.type = 0;
96         v5creds->ticket.length = 0;
97         v5creds->ticket.data = NULL;
98         v5creds->second_ticket.type = 0;
99         v5creds->second_ticket.length = 0;
100         v5creds->second_ticket.data = NULL;
101         v5creds->authdata = NULL;
102     }
103 
104 
105     if (!err) {
106         creds_union = malloc (sizeof (*creds_union));
107         if (creds_union) {
108             creds_union->cred_type = CC_CRED_V5;
109             creds_union->cred.pV5Cred = v5creds;
110         } else {
111             err = CC_NOMEM;
112         }
113     }
114     if (!err) {
115         *out_union = *creds_union;
116         creds_union = NULL;
117     }
118 
119     return err;
120 }
121 
122 // ---------------------------------------------------------------------------
123 
124 static void release_v5_creds_union_compat(cred_union *creds_union) {
125     cc_credentials_v5_compat *v5creds = NULL;
126 
127     if (creds_union) {
128         if (creds_union->cred.pV5Cred) {
129             v5creds = creds_union->cred.pV5Cred;
130             if (v5creds->client) { free(v5creds->client); }
131             if (v5creds->server) { free(v5creds->server); }
132             if (v5creds->keyblock.data) { free(v5creds->keyblock.data); }
133             if (v5creds->ticket.data) { free(v5creds->ticket.data); }
134             if (v5creds->second_ticket.data) { free(v5creds->second_ticket.data); }
135             free(v5creds);
136         }
137     }
138 }
139 
140 // ---------------------------------------------------------------------------
141 
142 int check_cc_shutdown(void) {
143     cc_result err = 0;
144     apiCB *context = NULL;
145 
146     BEGIN_TEST("cc_shutdown");
147 
148     // try with valid context
149     err = check_once_cc_shutdown(&context, CC_NOERROR, NULL);
150 
151     // try with NULL
152     err = check_once_cc_shutdown(NULL, CC_BAD_PARM, NULL);
153 
154     if (context) { cc_shutdown(&context); }
155 
156     END_TEST_AND_RETURN
157 }
158 
159 cc_result check_once_cc_shutdown(apiCB **out_context, cc_result expected_err, const char *description) {
160     cc_result err = 0;
161     apiCB *context = NULL;
162 
163     cc_result possible_return_values[2] = {
164         CC_NOERROR,
165         CC_BAD_PARM,
166     };
167 
168     BEGIN_CHECK_ONCE(description);
169 
170 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
171 
172     if (out_context) {
173         err = cc_initialize(out_context, ccapi_version_2, NULL, NULL);
174         if (!err) {
175             context = *out_context;
176         } else {
177             log_error("failure in cc_initialize, unable to perform check");
178             return err;
179         }
180     }
181 
182     if (!err) {
183         err = cc_shutdown(&context);
184         // check returned error
185         check_err(err, expected_err, possible_return_values);
186 
187     }
188 
189     if (out_context) {
190         *out_context = NULL;
191     }
192 
193     END_CHECK_ONCE;
194 
195     return err;
196 }
197 
198 // ---------------------------------------------------------------------------
199 
200 int check_cc_get_change_time(void) {
201     cc_result err = 0;
202     apiCB *context = NULL;
203     cc_time_t last_change_time = 0;
204     ccache_p *ccache = NULL;
205     cred_union creds_union;
206 
207     BEGIN_TEST("cc_get_change_time");
208 
209     /*
210      * Make a context
211      * make sure the change time changes after:
212      * 	a ccache is created
213      * 	a ccache is destroyed
214      * 	a credential is stored
215      * 	a credential is removed
216      * 	a ccache principal is changed
217      * clean up memory
218      */
219 
220     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
221     if (!err) {
222 
223         // try bad parameters first
224         err = check_once_cc_get_change_time(context, NULL, CC_BAD_PARM, "NULL param, should fail");
225 
226         // get_change_time should always give something > 0
227         check_once_cc_get_change_time(context, &last_change_time, CC_NOERROR, "first-run, should be > 0");
228 
229         // create a ccache
230         err = cc_create(context, "TEST_CCACHE", "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
231         if (err) {
232             log_error("failed to create a ccache - %s (%d)", translate_ccapi_error(err), err);
233             failure_count++;
234         }
235         check_once_cc_get_change_time(context, &last_change_time, CC_NOERROR, "after creating a new ccache");
236 
237         if (!err) {
238             // change principal
239             err = cc_set_principal(context, ccache, CC_CRED_V5, "foo@BAR.ORG");
240             if (err) {
241                 log_error("failed to change ccache's principal - %s (%d)", translate_ccapi_error(err), err);
242                 failure_count++;
243                 err = CC_NOERROR;
244             }
245         }
246         check_once_cc_get_change_time(context, &last_change_time, CC_NOERROR, "after changing a principle");
247 
248         new_v5_creds_union_compat(&creds_union, "BAR.ORG");
249 
250         // store a credential
251         if (!err) {
252             err = cc_store(context, ccache, creds_union);
253             if (err) {
254                 log_error("failed to store a credential - %s (%d)", translate_ccapi_error(err), err);
255                 failure_count++;
256                 err = CC_NOERROR;
257             }
258         }
259         check_once_cc_get_change_time(context, &last_change_time, CC_NOERROR, "after storing a credential");
260 
261         // remove a credential
262         if (!err) {
263             err = cc_remove_cred(context, ccache, creds_union);
264             if (err) {
265                 log_error("failed to remove a credential - %s (%d)", translate_ccapi_error(err), err);
266                 failure_count++;
267                 err = CC_NOERROR;
268             }
269         }
270         check_once_cc_get_change_time(context, &last_change_time, CC_NOERROR, "after removing a credential");
271 
272         release_v5_creds_union_compat(&creds_union);
273 
274         if (ccache) {
275             // destroy a ccache
276             err = cc_destroy(context, &ccache);
277             check_once_cc_get_change_time(context, &last_change_time, CC_NOERROR, "after destroying a ccache");
278         }
279     }
280 
281     if (context) { cc_shutdown(&context); }
282 
283     END_TEST_AND_RETURN
284 }
285 
286 // ---------------------------------------------------------------------------
287 
288 cc_int32 check_once_cc_get_change_time(apiCB *context, cc_time_t *last_time, cc_result expected_err, const char *description) {
289     cc_result err = 0;
290     cc_time_t last_change_time;
291     cc_time_t current_change_time = 0;
292 
293     cc_result possible_return_values[3] = {
294         CC_NOERROR,
295         CC_BAD_PARM,
296         CC_NO_EXIST,
297     };
298 
299     BEGIN_CHECK_ONCE(description);
300 
301 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
302 
303     if (last_time != NULL) { // if we were passed NULL, then we're looking to pass a bad param
304         err = cc_get_change_time(context, &current_change_time);
305     } else {
306         err = cc_get_change_time(context, NULL);
307     }
308 
309     check_err(err, expected_err, possible_return_values);
310 
311     if (!err) {
312         last_change_time = *last_time;
313         check_if(current_change_time <= last_change_time, "context change time did not increase when it was supposed to (%d <= %d)", current_change_time, last_change_time);
314         *last_time = current_change_time;
315     }
316 
317     END_CHECK_ONCE;
318 
319     return err;
320 }
321 
322 // ---------------------------------------------------------------------------
323 
324 int check_cc_open(void) {
325     cc_result err = 0;
326     apiCB *context = NULL;
327     ccache_p *ccache = NULL;
328     char *name = "TEST_OPEN_CCACHE";
329 
330     BEGIN_TEST("cc_open");
331 
332     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
333     if (!err) {
334         // create a ccache
335         err = cc_create(context, name, "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
336         if (err) {
337             log_error("failed to create a ccache - %s (%d)", translate_ccapi_error(err), err);
338             failure_count++;
339         }
340         if (!err) {
341             err = cc_close(context, &ccache);
342             ccache = NULL;
343         }
344 
345         // try default ccache
346         if (!err) {
347             err = check_once_cc_open(context, name, CC_CRED_V5, &ccache, CC_NOERROR, NULL);
348         }
349 
350         // try bad parameters
351         err = check_once_cc_open(context, NULL, CC_CRED_V5, &ccache, CC_BAD_PARM, NULL);
352         err = check_once_cc_open(context, name, CC_CRED_V5, NULL, CC_BAD_PARM, NULL);
353         err = check_once_cc_open(context, name, CC_CRED_UNKNOWN, &ccache, CC_ERR_CRED_VERSION, NULL);
354      }
355 
356     if (context) { cc_shutdown(&context); }
357 
358     END_TEST_AND_RETURN
359 }
360 
361 // ---------------------------------------------------------------------------
362 
363 cc_result check_once_cc_open(apiCB *context, const char *name, cc_int32 version, ccache_p **ccache, cc_result expected_err, const char *description) {
364     cc_result err = 0;
365     char *stored_name = NULL;
366 
367     cc_result possible_return_values[5] = {
368         CC_NOERROR,
369         CC_BAD_PARM,
370         CC_NO_EXIST,
371         CC_NOMEM,
372         CC_ERR_CRED_VERSION
373     };
374 
375     BEGIN_CHECK_ONCE(description);
376 
377 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
378 
379     if (ccache != NULL) { // if we were passed NULL, then we're looking to pass a bad param
380         err = cc_open(context, name, version, 0, ccache);
381     } else {
382         err = cc_open(context, name, version, 0, NULL);
383     }
384 
385     // check returned error
386     check_err(err, expected_err, possible_return_values);
387 
388     if (!err) {
389         check_if(*ccache == NULL, NULL);
390 
391         if (!err) {
392             err = cc_get_name(context, *ccache, &stored_name);
393         }
394         if (!err) {
395             check_if(strcmp(stored_name, name), NULL);
396         }
397         if (stored_name) { cc_free_name(context, &stored_name); }
398 
399 
400         if (ccache && *ccache) {
401             cc_ccache_release(*ccache);
402             *ccache = NULL;
403         }
404     }
405 
406     END_CHECK_ONCE;
407 
408     return err;
409 }
410 
411 // ---------------------------------------------------------------------------
412 
413 int check_cc_create(void) {
414     cc_result err = 0;
415     apiCB *context = NULL;
416     ccache_p *ccache = NULL;
417     char *name = "TEST_CC_CREATE";
418 
419     BEGIN_TEST("cc_create");
420 
421     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
422     if (!err) {
423         if (!err) {
424             err = cc_open(context, name, CC_CRED_V5, 0, &ccache);
425             if (!err) {
426                 err = cc_destroy (context, &ccache);
427             } else {
428                 err = CC_NOERROR;  /* ccache does not exist */
429             }
430         }
431         // try making a ccache with a unique name (the now destroyed cache's name)
432         if (!err) {
433             err = check_once_cc_create(context, name, CC_CRED_V5, "foo@BAR.ORG", &ccache, CC_NOERROR, NULL);
434         }
435 
436         // try making a ccache with a non-unique name (the existing cache's name)
437         if (!err) {
438             err = check_once_cc_create(context, name, CC_CRED_V5, "foo/baz@BAR.ORG", &ccache, CC_NOERROR, NULL);
439         }
440 
441         // try bad parameters
442         err = check_once_cc_create(context, NULL, CC_CRED_V5, "foo@BAR.ORG", &ccache, CC_BAD_PARM, "NULL name");                    // NULL name
443         err = check_once_cc_create(context, "name", CC_CRED_MAX, "foo@BAR.ORG", &ccache, CC_ERR_CRED_VERSION, "invalid creds_vers"); // invalid creds_vers
444         err = check_once_cc_create(context, "name", CC_CRED_V5, NULL, &ccache, CC_BAD_PARM, "NULL principal");                          // NULL principal
445         err = check_once_cc_create(context, "name", CC_CRED_V5, "foo@BAR.ORG", NULL, CC_BAD_PARM, "NULL ccache");                    // NULL ccache
446     }
447 
448     if (ccache) { cc_destroy(context, &ccache); }
449     if (context) { cc_shutdown(&context); }
450 
451     END_TEST_AND_RETURN
452 }
453 
454 // ---------------------------------------------------------------------------
455 
456 cc_result check_once_cc_create(apiCB  *context, const char *name, cc_int32 cred_vers, const char *principal, ccache_p **ccache, cc_int32 expected_err, const char *description) {
457     cc_result err = 0;
458     char *stored_name = NULL;
459     char *stored_principal = NULL;
460     cc_int32 stored_creds_vers = 0;
461 
462     cc_result possible_return_values[6] = {
463         CC_NOERROR,
464         CC_BADNAME,
465         CC_BAD_PARM,
466         CC_NO_EXIST,
467         CC_NOMEM,
468         CC_ERR_CRED_VERSION,
469     };
470     BEGIN_CHECK_ONCE(description);
471 
472 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
473 
474     err = cc_create(context, name, principal, cred_vers, 0, ccache);
475 
476     // check returned error
477     check_err(err, expected_err, possible_return_values);
478 
479     if (!err) {
480         check_if(*ccache == NULL, NULL);
481 
482         // make sure all of the ccache's info matches what we gave it
483         // name
484         err = cc_get_name(context, *ccache, &stored_name);
485         if (!err) { check_if(strcmp(stored_name, name), NULL); }
486         if (stored_name) { cc_free_name(context, &stored_name); }
487         // cred_vers
488         err = cc_get_cred_version(context, *ccache, &stored_creds_vers);
489         if (!err) { check_if(stored_creds_vers != cred_vers, NULL); }
490         // principal
491         err = cc_get_principal(context, *ccache, &stored_principal);
492         if (!err) { check_if(strcmp(stored_principal, principal), NULL); }
493         if (stored_principal) { cc_free_principal(context, &stored_principal); }
494 
495         if (ccache && *ccache) {
496             cc_destroy(context, ccache);
497             *ccache = NULL;
498         }
499     }
500 
501     END_CHECK_ONCE;
502 
503     return err;
504 }
505 
506 // ---------------------------------------------------------------------------
507 
508 int check_cc_close(void) {
509     cc_result err = 0;
510     apiCB *context = NULL;
511     ccache_p *ccache = NULL;
512     char *name = "TEST_CC_CLOSE";
513 
514     BEGIN_TEST("cc_close");
515 
516     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
517 
518     if (!err) {
519         err = cc_create(context, name, "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
520     }
521 
522     if (!err) {
523         check_once_cc_close(context, ccache, CC_NOERROR, NULL);
524         ccache = NULL;
525     }
526 
527     if (context) { cc_shutdown(&context); }
528 
529     END_TEST_AND_RETURN
530 }
531 
532 // ---------------------------------------------------------------------------
533 
534 cc_result check_once_cc_close(apiCB *context, ccache_p *ccache, cc_result expected_err, const char *description) {
535     cc_result err = CC_NOERROR;
536 
537     cc_result possible_return_values[2] = {
538         CC_NOERROR,
539         CC_BAD_PARM
540     };
541 
542     char *name = NULL;
543 
544     err = cc_get_name(context, ccache, &name);
545     err = cc_close(context, &ccache);
546     ccache = NULL;
547 
548     BEGIN_CHECK_ONCE(description);
549 
550 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
551 
552     // check returned error
553     check_err(err, expected_err, possible_return_values);
554 
555     if (!err && name) { // try opening released ccache to make sure it still exists
556         err = cc_open(context, name, CC_CRED_V5, 0, &ccache);
557     }
558     check_if(err == CC_NO_EXIST, "released ccache was actually destroyed instead");
559     check_if(err != CC_NOERROR, "released ccache cannot be opened");
560 
561     if (ccache) { cc_destroy(context, &ccache); }
562     if (name) { cc_free_name(context, &name); }
563 
564     END_CHECK_ONCE;
565 
566     return err;
567 }
568 
569 // ---------------------------------------------------------------------------
570 
571 int check_cc_destroy(void) {
572     cc_result err = 0;
573     apiCB *context = NULL;
574     ccache_p *ccache = NULL;
575     char *name = "TEST_CC_DESTROY";
576 
577     BEGIN_TEST("cc_destroy");
578 
579     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
580 
581     if (!err) {
582         err = cc_create(context, name, "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
583     }
584 
585     if (!err) {
586         check_once_cc_destroy(context, ccache, CC_NOERROR, NULL);
587         ccache = NULL;
588     }
589 
590     if (context) { cc_shutdown(&context); }
591 
592     END_TEST_AND_RETURN
593 }
594 
595 // ---------------------------------------------------------------------------
596 
597 cc_result check_once_cc_destroy(apiCB *context, ccache_p *ccache, cc_int32 expected_err, const char *description) {
598     cc_result err = CC_NOERROR;
599 
600     cc_result possible_return_values[2] = {
601         CC_NOERROR,
602         CC_BAD_PARM,
603     };
604 
605     char *name = NULL;
606 
607     BEGIN_CHECK_ONCE(description);
608 
609 #ifdef cc_ccache_destroy
610 
611 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
612 
613     err = cc_get_name(context, ccache, &name);
614     err = cc_destroy(context, &ccache);
615     ccache = NULL;
616 
617     // check returned error
618     check_err(err, expected_err, possible_return_values);
619 
620     if (!err && name) { // try opening released ccache to make sure it still exists
621         err = cc_open(context, name, CC_CRED_V5, 0, &ccache);
622     }
623     check_if(err != CC_NO_EXIST, "destroyed ccache was actually released instead");
624 
625     if (ccache) { cc_destroy(context, &ccache); }
626     if (name) { cc_free_name(context, &name); }
627 
628 #endif /* cc_ccache_destroy */
629 
630     END_CHECK_ONCE;
631 
632     return err;
633 }
634 
635 // ---------------------------------------------------------------------------
636 
637 int check_cc_get_cred_version(void) {
638     cc_result err = 0;
639     apiCB *context = NULL;
640     ccache_p *ccache = NULL;
641     char *name = "TEST_CC_GET_CRED_VERSION_V5";
642 
643     BEGIN_TEST("cc_get_cred_version");
644 
645     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
646 
647     // try one created with v5 creds
648     if (!err) {
649         err = cc_create(context, name, "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
650     }
651     if (!err) {
652         check_once_cc_get_cred_version(context, ccache, CC_CRED_V5, CC_NOERROR, "v5 creds");
653     }
654     else {
655         log_error("cc_context_create_new_ccache failed, can't complete test");
656         failure_count++;
657     }
658 
659     if (ccache) {
660         cc_destroy(context, &ccache);
661         ccache = NULL;
662     }
663 
664     err = CC_NOERROR;
665 
666     if (ccache) {
667         cc_destroy(context, &ccache);
668         ccache = NULL;
669     }
670 
671     if (context) { cc_shutdown(&context); }
672 
673     END_TEST_AND_RETURN
674 }
675 
676 // ---------------------------------------------------------------------------
677 
678 cc_result check_once_cc_get_cred_version(apiCB *context, ccache_p *ccache, cc_int32 expected_cred_vers, cc_int32 expected_err, const char *description) {
679     cc_result err = CC_NOERROR;
680 
681     cc_result possible_return_values[3] = {
682         CC_NOERROR,
683         CC_BAD_PARM,
684         CC_NO_EXIST,
685     };
686 
687     cc_int32 stored_cred_vers = 0;
688 
689     BEGIN_CHECK_ONCE(description);
690 
691 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
692 
693     err = cc_get_cred_version(context, ccache, &stored_cred_vers);
694 
695     // check returned error
696     check_err(err, expected_err, possible_return_values);
697 
698     if (!err) {
699         check_if(stored_cred_vers != expected_cred_vers, NULL);
700     }
701 
702     END_CHECK_ONCE;
703 
704     return err;
705 }
706 
707 // ---------------------------------------------------------------------------
708 
709 int check_cc_get_name(void) {
710     cc_result err = 0;
711     apiCB *context = NULL;
712     ccache_p *ccache = NULL;
713 
714     BEGIN_TEST("cc_get_name");
715 
716     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
717 
718     if (!err) {
719         err = destroy_all_ccaches_v2(context);
720     }
721 
722     // try with unique ccache (which happens to be default)
723     if (!err) {
724         err = cc_create(context, "0", "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
725     }
726     if (!err) {
727         check_once_cc_get_name(context, ccache, "0", CC_NOERROR, "unique ccache (which happens to be default)");
728     }
729     else {
730         log_error("cc_context_create_ccache failed, can't complete test");
731         failure_count++;
732     }
733     if (ccache) {
734         cc_close(context, &ccache);
735         ccache = NULL;
736     }
737 
738     // try with unique ccache (which is not default)
739     if (!err) {
740         err = cc_context_create_ccache(context, "1", CC_CRED_V5, "foo@BAR.ORG", &ccache);
741     }
742     if (!err) {
743         check_once_cc_get_name(context, ccache, "1", CC_NOERROR, "unique ccache (which is not default)");
744     }
745     else {
746         log_error("cc_context_create_ccache failed, can't complete test");
747         failure_count++;
748     }
749 
750     // try with bad param
751     if (!err) {
752         check_once_cc_get_name(context, ccache, NULL, CC_BAD_PARM, "NULL param");
753     }
754     if (ccache) {
755         cc_close(context, &ccache);
756         ccache = NULL;
757     }
758 
759     if (context) {
760         err = destroy_all_ccaches_v2(context);
761         cc_shutdown(&context);
762     }
763 
764     END_TEST_AND_RETURN
765 }
766 
767 // ---------------------------------------------------------------------------
768 
769 cc_int32 check_once_cc_get_name(apiCB *context, ccache_p *ccache, const char *expected_name, cc_int32 expected_err, const char *description) {
770     cc_result err = CC_NOERROR;
771 
772     cc_result possible_return_values[4] = {
773         CC_NOERROR,
774         CC_NOMEM,
775         CC_BAD_PARM,
776         CC_NO_EXIST,
777     };
778 
779     char *stored_name = NULL;
780 
781     BEGIN_CHECK_ONCE(description);
782 
783 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
784 
785     if (expected_name == NULL) { // we want to try with a NULL param
786         err = cc_get_name(context, ccache, NULL);
787     }
788     else {
789         err = cc_get_name(context, ccache, &stored_name);
790     }
791 
792     // check returned error
793     check_err(err, expected_err, possible_return_values);
794 
795     if (!err) {
796         check_if(strcmp(stored_name, expected_name), NULL);
797     }
798 
799     if (stored_name) { cc_free_name(context, &stored_name); }
800 
801     END_CHECK_ONCE;
802 
803     return err;
804 }
805 
806 
807 // ---------------------------------------------------------------------------
808 
809 int check_cc_get_principal(void) {
810     cc_result err = 0;
811     apiCB *context = NULL;
812     ccache_p *ccache = NULL;
813     char *name_v5 = "TEST_CC_GET_PRINCIPAL_V5";
814 
815     BEGIN_TEST("cc_get_principal");
816 
817     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
818 
819     if (!err) {
820         err = destroy_all_ccaches_v2(context);
821     }
822 
823     // try with krb5 principal
824     if (!err) {
825         err = cc_create(context, name_v5, "foo/BAR@BAZ.ORG", CC_CRED_V5, 0, &ccache);
826     }
827     if (!err) {
828         check_once_cc_get_principal(context, ccache, "foo/BAR@BAZ.ORG", CC_NOERROR, "trying to get krb5 princ for krb5 ccache");
829     }
830     else {
831         log_error("cc_create failed, can't complete test");
832         failure_count++;
833     }
834     if (ccache) {
835         cc_close(context, &ccache);
836         ccache = NULL;
837     }
838 
839     // try with bad param
840     if (!err) {
841         check_once_cc_get_principal(context, ccache, NULL, CC_BAD_PARM, "passed null out param");
842     }
843 
844     if (ccache) {
845         cc_close(context, &ccache);
846         ccache = NULL;
847     }
848 
849     if (context) {
850         err = destroy_all_ccaches_v2(context);
851         cc_shutdown(&context);
852     }
853 
854     END_TEST_AND_RETURN
855 }
856 
857 // ---------------------------------------------------------------------------
858 
859 cc_result check_once_cc_get_principal(apiCB *context,
860                                       ccache_p *ccache,
861                                       const char *expected_principal,
862                                       cc_int32 expected_err,
863                                       const char *description) {
864     cc_result err = CC_NOERROR;
865     char *stored_principal = NULL;
866 
867     cc_result possible_return_values[4] = {
868         CC_NOERROR,
869         CC_NOMEM,
870         CC_NO_EXIST,
871         CC_BAD_PARM
872     };
873 
874     BEGIN_CHECK_ONCE(description);
875 
876 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
877 
878     if (expected_principal == NULL) { // we want to try with a NULL param
879         err = cc_get_principal(context, ccache, NULL);
880     }
881     else {
882         err = cc_get_principal(context, ccache, &stored_principal);
883     }
884 
885     // check returned error
886     check_err(err, expected_err, possible_return_values);
887 
888     if (!err) {
889         check_if(strcmp(stored_principal, expected_principal), "expected princ == \"%s\" stored princ == \"%s\"", expected_principal, stored_principal);
890     }
891 
892     if (stored_principal) { cc_free_principal(context, &stored_principal); }
893 
894     END_CHECK_ONCE;
895 
896     return err;
897 }
898 
899 // ---------------------------------------------------------------------------
900 
901 int check_cc_set_principal(void) {
902     cc_result err = 0;
903     apiCB *context = NULL;
904     ccache_p *ccache = NULL;
905     char *name_v5 = "TEST_CC_GET_PRINCIPAL_V5";
906 
907     BEGIN_TEST("cc_set_principal");
908 
909     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
910 
911     if (!err) {
912         err = destroy_all_ccaches_v2(context);
913     }
914 
915     // bad params
916     if (!err) {
917         err = cc_create(context, name_v5, "foo@BAZ.ORG", CC_CRED_V5, 0, &ccache);
918     }
919     if (!err) {
920         check_once_cc_set_principal(context, ccache, CC_CRED_MAX, "foo/BAZ@BAR.ORG", CC_ERR_CRED_VERSION, "CC_CRED_MAX (not allowed)");
921         check_once_cc_set_principal(context, ccache, CC_CRED_V5, NULL, CC_BAD_PARM, "NULL principal");
922     }
923     else {
924         log_error("cc_create failed, can't complete test");
925         failure_count++;
926     }
927     if (ccache) {
928         cc_destroy(context, &ccache);
929         ccache = NULL;
930     }
931 
932     if (ccache) {
933         cc_destroy(context, &ccache);
934         ccache = NULL;
935     }
936 
937     if (context) {
938         err = destroy_all_ccaches_v2(context);
939         cc_shutdown(&context);
940     }
941 
942     END_TEST_AND_RETURN
943 }
944 
945 // ---------------------------------------------------------------------------
946 
947 cc_int32 check_once_cc_set_principal(apiCB *context, ccache_p *ccache, cc_int32 cred_vers, const char *in_principal, cc_int32 expected_err, const char *description) {
948     cc_result err = CC_NOERROR;
949     char *stored_principal = NULL;
950 
951     cc_result possible_return_values[5] = {
952         CC_NOERROR,
953         CC_NOMEM,
954         CC_NO_EXIST,
955         CC_ERR_CRED_VERSION,
956         CC_BAD_PARM
957     };
958 
959     BEGIN_CHECK_ONCE(description);
960 
961 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
962 
963     err = cc_set_principal(context, ccache, cred_vers, (char *) in_principal);
964 
965     // check returned error
966     check_err(err, expected_err, possible_return_values);
967 
968     if (!err) {
969         err = cc_get_principal(context, ccache, &stored_principal);
970     }
971 
972     // compare stored with input
973     if (!err) {
974         check_if(strcmp(stored_principal, in_principal), "expected princ == \"%s\" stored princ == \"%s\"", in_principal, stored_principal);
975     }
976 
977     if (stored_principal) { cc_free_principal(context, &stored_principal); }
978 
979     END_CHECK_ONCE;
980 
981     return err;
982 }
983 
984 // ---------------------------------------------------------------------------
985 
986 int check_cc_store(void) {
987     cc_result err = 0;
988     apiCB *context = NULL;
989     ccache_p *ccache = NULL;
990     ccache_p *dup_ccache = NULL;
991     cred_union creds_union;
992     char *name = NULL;
993 
994     BEGIN_TEST("cc_store");
995 
996     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
997 
998     if (!err) {
999         err = destroy_all_ccaches_v2(context);
1000     }
1001 
1002     if (!err) {
1003         err = cc_create(context, "TEST_CC_STORE", "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
1004     }
1005 
1006     // cred with matching version and realm
1007     if (!err) {
1008         err = new_v5_creds_union_compat(&creds_union, "BAR.ORG");
1009 
1010         if (!err) {
1011             check_once_cc_store(context, ccache, creds_union, CC_NOERROR, "ok creds");
1012             release_v5_creds_union_compat(&creds_union);
1013         }
1014     }
1015 
1016     // invalid creds
1017     if (!err) {
1018         err = new_v5_creds_union_compat(&creds_union, "BAR.ORG");
1019 
1020         if (!err) {
1021             if (creds_union.cred.pV5Cred->client) {
1022                 free(creds_union.cred.pV5Cred->client);
1023                 creds_union.cred.pV5Cred->client = NULL;
1024             }
1025             check_once_cc_store(context, ccache, creds_union, CC_BAD_PARM, "invalid creds (NULL client string)");
1026 
1027             release_v5_creds_union_compat(&creds_union);
1028         }
1029     }
1030 
1031     // non-existent ccache
1032     if (ccache) {
1033         err = cc_get_name(context, ccache, &name);
1034         if (!err) {
1035             err = cc_open(context, name, CC_CRED_V5, 0, &dup_ccache);
1036         }
1037         if (name) { cc_free_name(context, &name); }
1038         if (dup_ccache) { cc_destroy(context, &dup_ccache); }
1039     }
1040 
1041     if (!err) {
1042         err = new_v5_creds_union_compat(&creds_union, "BAR.ORG");
1043 
1044         if (!err) {
1045             check_once_cc_store(context, ccache, creds_union, CC_NO_EXIST, "invalid ccache");
1046 
1047             release_v5_creds_union_compat(&creds_union);
1048         }
1049     }
1050 
1051     if (ccache) { cc_close(context, &ccache); }
1052     if (context) {
1053         destroy_all_ccaches_v2(context);
1054         cc_shutdown(&context);
1055     }
1056 
1057     END_TEST_AND_RETURN
1058 }
1059 
1060 // ---------------------------------------------------------------------------
1061 
1062 cc_result check_once_cc_store(apiCB *context, ccache_p *ccache, const cred_union in_creds, cc_int32 expected_err, const char *description) {
1063     cc_result err = CC_NOERROR;
1064     ccache_cit *iterator = NULL;
1065     int found = 0;
1066 
1067     cc_result possible_return_values[5] = {
1068         CC_NOERROR,
1069         CC_BAD_PARM,
1070         CC_ERR_CACHE_FULL,
1071         CC_ERR_CRED_VERSION,
1072         CC_NO_EXIST
1073     };
1074 
1075     BEGIN_CHECK_ONCE(description);
1076 
1077 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
1078 
1079     err = cc_store(context, ccache, in_creds);
1080 
1081     // check returned error
1082     check_err(err, expected_err, possible_return_values);
1083 
1084     // make sure credentials were truly stored
1085     if (!err) {
1086         err = cc_seq_fetch_creds_begin(context, ccache, &iterator);
1087     }
1088     while (!err && !found) {
1089         cred_union *creds = NULL;
1090 
1091         err = cc_seq_fetch_creds_next(context, &creds, iterator);
1092         if (!err) {
1093             found = !compare_v5_creds_unions_compat(&in_creds, creds);
1094         }
1095 
1096         if (creds) { cc_free_creds(context, &creds); }
1097     }
1098 
1099     if (err == CC_END) {
1100         check_if(found, "stored credentials not found in ccache");
1101         err = CC_NOERROR;
1102     }
1103 
1104     if (iterator) { cc_seq_fetch_creds_end(context, &iterator); }
1105 
1106     END_CHECK_ONCE;
1107 
1108     return err;
1109 }
1110 
1111 // ---------------------------------------------------------------------------
1112 
1113 int check_cc_remove_cred(void) {
1114     cc_result err = 0;
1115     apiCB *context = NULL;
1116     ccache_p *ccache = NULL;
1117     cred_union *creds_array[10];
1118     ccache_cit *iterator = NULL;
1119     char *name = NULL;
1120     unsigned int i;
1121 
1122     BEGIN_TEST("cc_remove_cred");
1123 
1124     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
1125 
1126     if (!err) {
1127         err = destroy_all_ccaches_v2(context);
1128     }
1129 
1130     if (!err) {
1131         err = cc_create(context, "TEST_CC_REMOVE_CRED", "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
1132     }
1133 
1134     // store 10 creds and retrieve their cc_credentials_t representations
1135     for(i = 0; !err && (i < 10); i++) {
1136         cred_union creds;
1137 
1138         new_v5_creds_union_compat(&creds, "BAR.ORG");
1139         err = cc_store(context, ccache, creds);
1140         if (err) {
1141             log_error("failure to store creds_union in remove_creds test");
1142         }
1143         release_v5_creds_union_compat(&creds);
1144     }
1145 
1146     if (!err) {
1147         err = cc_seq_fetch_creds_begin(context, ccache, &iterator);
1148     }
1149 
1150     for (i = 0; !err && i < 10; i++) {
1151         creds_array[i] = NULL;
1152         err = cc_seq_fetch_creds_next(context, &creds_array[i], iterator);
1153     }
1154     if (err == CC_END) { err = CC_NOERROR; }
1155 
1156     // remove 10 valid creds
1157     for (i = 0; !err && (i < 10); i++) {
1158         check_once_cc_remove_cred(context, ccache, *creds_array[i], CC_NOERROR, "10 ok creds");
1159     }
1160 
1161     // non-existent creds (remove same one twice)
1162     check_once_cc_remove_cred(context, ccache, *creds_array[0], CC_NOTFOUND, "removed same creds twice");
1163 
1164     // non-existent ccache
1165     if (ccache) {
1166         ccache_p *dup_ccache = NULL;
1167 
1168         err = cc_get_name(context, ccache, &name);
1169 
1170         if (!err) {
1171             err = cc_open(context, name, CC_CRED_V5, 0, &dup_ccache);
1172         }
1173 
1174         if (!err) {
1175             err = cc_destroy(context, &dup_ccache);
1176             check_once_cc_remove_cred(context, ccache, *creds_array[0], CC_NO_EXIST, "invalid ccache");
1177         }
1178 
1179         if (name) { cc_free_name(context, &name); }
1180     }
1181 
1182      for(i = 0; i < 10 && creds_array[i]; i++) {
1183         cc_free_creds(context, &creds_array[i]);
1184     }
1185 
1186 
1187     if (iterator) { cc_seq_fetch_creds_end(context, &iterator); iterator = NULL; }
1188     if (ccache) { cc_close(context, &ccache); }
1189     if (context) {
1190         destroy_all_ccaches_v2(context);
1191         cc_shutdown(&context);
1192     }
1193 
1194     END_TEST_AND_RETURN
1195 }
1196 
1197 // ---------------------------------------------------------------------------
1198 
1199 cc_result check_once_cc_remove_cred(apiCB *context, ccache_p *ccache, cred_union in_creds, cc_int32 expected_err, const char *description) {
1200     cc_result err = CC_NOERROR;
1201     ccache_cit *iterator = NULL;
1202     int found = 0;
1203 
1204     cc_result possible_return_values[5] = {
1205         CC_NOERROR,
1206         CC_BAD_PARM,
1207         CC_ERR_CRED_VERSION,
1208         CC_NOTFOUND,
1209         CC_NO_EXIST
1210     };
1211 
1212     BEGIN_CHECK_ONCE(description);
1213 
1214 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
1215 
1216     err = cc_remove_cred(context, ccache, in_creds);
1217 
1218     // check returned error
1219     check_err(err, expected_err, possible_return_values);
1220 
1221     // make sure credentials were truly stored
1222     if (!err) {
1223         err = cc_seq_fetch_creds_begin(context, ccache, &iterator);
1224     }
1225 
1226     while (!err && !found) {
1227         cred_union *creds = NULL;
1228 
1229         err = cc_seq_fetch_creds_next(context, &creds, iterator);
1230         if (!err) {
1231             found = !compare_v5_creds_unions_compat(&in_creds, creds);
1232         }
1233 
1234         if (creds) { cc_free_creds(context, &creds); }
1235     }
1236 
1237     if (err == CC_END) {
1238         check_if(found, "credentials not removed from ccache");
1239         err = CC_NOERROR;
1240     }
1241 
1242     if (iterator) { cc_seq_fetch_creds_end(context, &iterator); }
1243 
1244     END_CHECK_ONCE;
1245 
1246     return err;
1247 }
1248 
1249 // ---------------------------------------------------------------------------
1250 
1251 int check_cc_seq_fetch_NCs_begin(void) {
1252     cc_result err = 0;
1253     apiCB *context = NULL;
1254     ccache_p *ccache = NULL;
1255     ccache_cit *iterator = NULL;
1256 
1257     BEGIN_TEST("cc_seq_fetch_NCs_begin");
1258 
1259     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
1260     if (!err) {
1261         err = destroy_all_ccaches_v2(context);
1262     }
1263     if (!err) {
1264         // try making when there are no existing ccaches (shouldn't make a difference, but just in case)
1265         check_once_cc_seq_fetch_NCs_begin(context, &iterator, CC_NOERROR, "when there are no existing ccaches");
1266 
1267         err = cc_create(context, "TEST_CC_SEQ_FETCH_NCS_BEGIN", "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
1268     }
1269     if (!err) {
1270         // try making when at least one ccache already exists (just to cover all our bases)
1271         check_once_cc_seq_fetch_NCs_begin(context, &iterator, CC_NOERROR, "when at least one ccache already exists");
1272 
1273         // try bad parameters
1274         check_once_cc_seq_fetch_NCs_begin(context, NULL, CC_BAD_PARM, "NULL param"); // NULL iterator
1275     }
1276     // we'll do a comprehensive test of cc_ccache_iterator related functions later in the test suite
1277 
1278     if (ccache ) { cc_close(context, &ccache); }
1279     if (context) { cc_shutdown(&context); }
1280 
1281     END_TEST_AND_RETURN
1282 }
1283 
1284 // ---------------------------------------------------------------------------
1285 
1286 cc_result check_once_cc_seq_fetch_NCs_begin(apiCB *context, ccache_cit **iterator, cc_result expected_err, const char *description) {
1287     cc_result err = CC_NOERROR;
1288 
1289     cc_result possible_return_values[4] = {
1290         CC_NOERROR,
1291         CC_BAD_PARM,
1292         CC_NOMEM,
1293         CC_NO_EXIST
1294     };
1295 
1296     BEGIN_CHECK_ONCE(description);
1297 
1298 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
1299 
1300      err = cc_seq_fetch_NCs_begin(context, iterator);
1301 
1302     // check returned error
1303     check_err(err, expected_err, possible_return_values);
1304 
1305     // we'll do a comprehensive test of cc_ccache_iterator related functions later
1306 
1307     return err;
1308 }
1309 
1310 // ---------------------------------------------------------------------------
1311 
1312 int check_cc_seq_fetch_NCs_next(void) {
1313     cc_result err = 0;
1314     apiCB *context = NULL;
1315     ccache_p *ccache = NULL;
1316     ccache_cit *iterator = NULL;
1317     unsigned int i;
1318 
1319     BEGIN_TEST("cc_seq_fetch_NCs_next");
1320 
1321     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
1322 
1323     if (!err) {
1324         err = destroy_all_ccaches_v2(context);
1325     }
1326 
1327     // iterate with no ccaches
1328     if (!err) {
1329         err = cc_seq_fetch_NCs_begin(context, &iterator);
1330     }
1331     check_once_cc_seq_fetch_NCs_next(context, iterator, 0, CC_NOERROR, "iterating over an empty collection");
1332     if (iterator) {
1333         cc_seq_fetch_creds_end(context, &iterator);
1334         iterator = NULL;
1335     }
1336 
1337     // iterate with one ccache
1338     if (!err) {
1339         destroy_all_ccaches_v2(context);
1340         err = cc_create(context, "TEST_CC_SEQ_FETCH_NCS_NEXT", "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
1341     }
1342     if (ccache) {
1343         cc_close(context, &ccache);
1344         ccache = NULL;
1345     }
1346     if (!err) {
1347         err = cc_seq_fetch_NCs_begin(context, &iterator);
1348     }
1349     check_once_cc_seq_fetch_NCs_next(context, iterator, 1, CC_NOERROR, "iterating over a collection of 1 ccache");
1350     if (iterator) {
1351         cc_seq_fetch_creds_end(context, &iterator);
1352         iterator = NULL;
1353     }
1354 
1355     // iterate with several ccaches
1356     if (!err) {
1357         destroy_all_ccaches_v2(context);
1358     }
1359     for(i = 0; !err && (i < 1000); i++)
1360     {
1361         char *name = NULL;
1362 
1363         if (i%100 == 0) fprintf(stdout, ".");
1364         asprintf (&name, "TEST_CC_SEQ_FETCH_NCS_NEXT_%d", i);
1365         err = cc_create(context, name, "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
1366         if (ccache) {
1367             cc_close(context, &ccache);
1368             ccache = NULL;
1369         }
1370         free (name);
1371     }
1372     if (!err) {
1373         err = cc_seq_fetch_NCs_begin(context, &iterator);
1374     }
1375     check_once_cc_seq_fetch_NCs_next(context, iterator, 1000, CC_NOERROR, "iterating over a collection of 1000 ccache");
1376     if (iterator) {
1377         cc_seq_fetch_creds_end(context, &iterator);
1378         iterator = NULL;
1379     }
1380 
1381 
1382     if (ccache) { cc_close(context, &ccache); }
1383     if (iterator) { cc_seq_fetch_creds_end(context, &iterator); }
1384     if (context) {
1385         destroy_all_ccaches_v2(context);
1386         cc_shutdown(&context);
1387     }
1388 
1389     END_TEST_AND_RETURN
1390 }
1391 
1392 // ---------------------------------------------------------------------------
1393 
1394 cc_result check_once_cc_seq_fetch_NCs_next(apiCB *context, ccache_cit *iterator, cc_uint32 expected_count, cc_result expected_err, const char *description) {
1395     cc_result err = CC_NOERROR;
1396 
1397     cc_result possible_return_values[5] = {
1398         CC_NOERROR,
1399         CC_END,
1400         CC_BAD_PARM,
1401         CC_NOMEM,
1402         CC_NO_EXIST
1403     };
1404 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
1405 
1406     ccache_p *ccache = NULL;
1407     cc_uint32 actual_count = 0;
1408 
1409     BEGIN_CHECK_ONCE(description);
1410 
1411     while (!err) {
1412         err = cc_seq_fetch_NCs_next(context, &ccache, iterator);
1413         if (ccache) {
1414             actual_count++;
1415             cc_close(context, &ccache);
1416             ccache = NULL;
1417         }
1418     }
1419     if (err == CC_END) {
1420         err = CC_NOERROR;
1421     }
1422 
1423     // check returned error
1424     check_err(err, expected_err, possible_return_values);
1425 
1426     check_if(actual_count != expected_count, "iterator didn't iterate over all ccaches");
1427 
1428     END_CHECK_ONCE;
1429 
1430     return err;
1431 }
1432 
1433 // ---------------------------------------------------------------------------
1434 
1435 int check_cc_get_NC_info(void) {
1436     cc_result err = 0;
1437     apiCB *context = NULL;
1438     ccache_p *ccache = NULL;
1439     unsigned int i;
1440 
1441     BEGIN_TEST("cc_get_NC_info");
1442 
1443     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
1444 
1445     if (!err) {
1446         err = destroy_all_ccaches_v2(context);
1447     }
1448 
1449     // iterate with no ccaches
1450     check_once_cc_get_NC_info(context, "", "", CC_CRED_MAX, 0, CC_NOERROR, "iterating over an empty collection");
1451 
1452     // iterate with one ccache
1453     if (!err) {
1454         destroy_all_ccaches_v2(context);
1455         err = cc_create(context, "TEST_CC_GET_NC_INFO", "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
1456     }
1457     if (ccache) {
1458         cc_close(context, &ccache);
1459         ccache = NULL;
1460     }
1461     check_once_cc_get_NC_info(context, "TEST_CC_GET_NC_INFO", "foo@BAR.ORG", CC_CRED_V5, 1, CC_NOERROR, "iterating over a collection of 1 ccache");
1462 
1463     // iterate with several ccaches
1464     if (!err) {
1465         destroy_all_ccaches_v2(context);
1466     }
1467     for(i = 0; !err && (i < 1000); i++)
1468     {
1469         char *name = NULL;
1470 
1471         if (i%100 == 0) fprintf(stdout, ".");
1472         asprintf (&name, "TEST_CC_GET_NC_INFO_%d", i);
1473         err = cc_create(context, name, "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
1474         if (ccache) {
1475             cc_close(context, &ccache);
1476             ccache = NULL;
1477         }
1478         free (name);
1479     }
1480     check_once_cc_get_NC_info(context, "TEST_CC_GET_NC_INFO", "foo@BAR.ORG", CC_CRED_V5, 1000, CC_NOERROR, "iterating over a collection of 1000 ccache");
1481 
1482     if (ccache) { cc_close(context, &ccache); }
1483     if (context) {
1484         destroy_all_ccaches_v2(context);
1485         cc_shutdown(&context);
1486     }
1487 
1488     END_TEST_AND_RETURN
1489 }
1490 
1491 // ---------------------------------------------------------------------------
1492 
1493 cc_result check_once_cc_get_NC_info(apiCB *context,
1494                                     const char *expected_name_prefix,
1495                                     const char *expected_principal,
1496                                     cc_int32 expected_version,
1497                                     cc_uint32 expected_count,
1498                                     cc_result expected_err,
1499                                     const char *description) {
1500     cc_result err = CC_NOERROR;
1501     infoNC **info = NULL;
1502 
1503     cc_result possible_return_values[4] = {
1504         CC_NOERROR,
1505         CC_BAD_PARM,
1506         CC_NOMEM,
1507         CC_NO_EXIST
1508     };
1509 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
1510 
1511     cc_uint32 actual_count = 0;
1512 
1513     BEGIN_CHECK_ONCE(description);
1514 
1515     err = cc_get_NC_info(context, &info);
1516 
1517     for (actual_count = 0; !err && info[actual_count]; actual_count++) {
1518         check_if(strncmp(info[actual_count]->name, expected_name_prefix, strlen(expected_name_prefix)), "got incorrect ccache name");
1519         check_if(strcmp(info[actual_count]->principal, expected_principal), "got incorrect principal name");
1520         check_if(info[actual_count]->vers != expected_version, "got incorrect cred version");
1521     }
1522 
1523     // check returned error
1524     check_err(err, expected_err, possible_return_values);
1525 
1526     check_if(actual_count != expected_count, "NC info didn't list all ccaches");
1527 
1528     if (info) { cc_free_NC_info (context, &info); }
1529     END_CHECK_ONCE;
1530 
1531     return err;
1532 }
1533 
1534 // ---------------------------------------------------------------------------
1535 
1536 int check_cc_seq_fetch_creds_begin(void) {
1537     cc_result err = 0;
1538     apiCB *context = NULL;
1539     ccache_p *ccache = NULL;
1540     ccache_p *dup_ccache = NULL;
1541     ccache_cit *creds_iterator = NULL;
1542     char *name = NULL;
1543 
1544     BEGIN_TEST("cc_seq_fetch_creds_begin");
1545 
1546     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
1547 
1548     if (!err) {
1549         err = destroy_all_ccaches_v2(context);
1550     }
1551 
1552     if (!err) {
1553         err = cc_create(context, "TEST_CC_SEQ_FETCH_CREDS_BEGIN", "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
1554     }
1555 
1556     // valid params
1557     if (!err) {
1558         check_once_cc_seq_fetch_creds_begin(context, ccache, &creds_iterator, CC_NOERROR, "valid params");
1559     }
1560     if (creds_iterator) {
1561         cc_seq_fetch_creds_end(context, &creds_iterator);
1562         creds_iterator = NULL;
1563     }
1564 
1565     // NULL out param
1566     if (!err) {
1567         check_once_cc_seq_fetch_creds_begin(context, ccache, NULL, CC_BAD_PARM, "NULL out iterator param");
1568     }
1569     if (creds_iterator) {
1570         cc_seq_fetch_creds_end(context, &creds_iterator);
1571         creds_iterator = NULL;
1572     }
1573 
1574     // non-existent ccache
1575     if (ccache) {
1576         err = cc_get_name(context, ccache, &name);
1577         if (!err) {
1578             err = cc_open(context, name, CC_CRED_V5, 0, &dup_ccache);
1579         }
1580         if (name) { cc_free_name(context, &name); }
1581         if (dup_ccache) { cc_destroy(context, &dup_ccache); }
1582     }
1583 
1584     if (!err) {
1585         check_once_cc_seq_fetch_creds_begin(context, ccache, &creds_iterator, CC_NO_EXIST, "invalid ccache");
1586     }
1587 
1588     if (creds_iterator) {
1589         cc_seq_fetch_creds_end(context, &creds_iterator);
1590         creds_iterator = NULL;
1591     }
1592     if (ccache) { cc_close(context, &ccache); }
1593     if (context) {
1594         destroy_all_ccaches_v2(context);
1595         cc_shutdown(&context);
1596     }
1597 
1598     END_TEST_AND_RETURN
1599 }
1600 
1601 // ---------------------------------------------------------------------------
1602 
1603 cc_result check_once_cc_seq_fetch_creds_begin(apiCB *context, ccache_p *ccache, ccache_cit **iterator, cc_result expected_err, const char *description) {
1604     cc_result err = CC_NOERROR;
1605 
1606     cc_result possible_return_values[5] = {
1607         CC_NOERROR,
1608         CC_BAD_PARM,
1609         CC_NOMEM,
1610         CC_NO_EXIST
1611     };
1612 
1613     BEGIN_CHECK_ONCE(description);
1614 
1615 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
1616 
1617     err = cc_seq_fetch_creds_begin(context, ccache, iterator);
1618 
1619     // check returned error
1620     check_err(err, expected_err, possible_return_values);
1621 
1622     END_CHECK_ONCE;
1623 
1624     return err;
1625 }
1626 
1627 // ---------------------------------------------------------------------------
1628 
1629 int check_cc_seq_fetch_creds_next(void) {
1630     cc_result err = 0;
1631     apiCB *context = NULL;
1632     ccache_p *ccache = NULL;
1633     cred_union creds_union;
1634     ccache_cit *iterator = NULL;
1635     unsigned int i;
1636 
1637     BEGIN_TEST("cc_seq_fetch_creds_next");
1638 
1639     err = cc_initialize(&context, ccapi_version_2, NULL, NULL);
1640 
1641     if (!err) {
1642         err = destroy_all_ccaches_v2(context);
1643     }
1644 
1645     // iterate with no creds
1646     if (!err) {
1647         err = cc_create(context, "TEST_CC_SEQ_FETCH_CREDS_NEXT", "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
1648     }
1649     if (!err) {
1650         err = cc_seq_fetch_creds_begin(context, ccache, &iterator);
1651     }
1652     check_once_cc_seq_fetch_creds_next(context, iterator, 0, CC_NOERROR, "iterating over an empty ccache");
1653     if (iterator) {
1654         cc_seq_fetch_creds_end(context, &iterator);
1655         iterator = NULL;
1656     }
1657     if (ccache) {
1658         cc_close(context, &ccache);
1659         ccache = NULL;
1660     }
1661 
1662     // iterate with one cred
1663     if (!err) {
1664         destroy_all_ccaches_v2(context);
1665         err = cc_create(context, "TEST_CC_SEQ_FETCH_CREDS_NEXT", "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
1666     }
1667     if (!err) {
1668         new_v5_creds_union_compat(&creds_union, "BAR.ORG");
1669         err = cc_store(context, ccache, creds_union);
1670         release_v5_creds_union_compat(&creds_union);
1671     }
1672     if (!err) {
1673         err = cc_seq_fetch_creds_begin(context, ccache, &iterator);
1674     }
1675     check_once_cc_seq_fetch_creds_next(context, iterator, 1, CC_NOERROR, "iterating over a ccache with 1 cred");
1676     if (iterator) {
1677         cc_seq_fetch_creds_end(context, &iterator);
1678         iterator = NULL;
1679     }
1680     if (ccache) {
1681         cc_close(context, &ccache);
1682         ccache = NULL;
1683     }
1684 
1685     // iterate with several creds
1686     if (!err) {
1687         destroy_all_ccaches_v2(context);
1688         err = cc_create(context, "TEST_CC_SEQ_FETCH_CREDS_NEXT", "foo@BAR.ORG", CC_CRED_V5, 0, &ccache);
1689     }
1690     for(i = 0; !err && (i < 1000); i++) {
1691         if (i%100 == 0) fprintf(stdout, ".");
1692         new_v5_creds_union_compat(&creds_union, "BAR.ORG");
1693         err = cc_store(context, ccache, creds_union);
1694         release_v5_creds_union_compat(&creds_union);
1695     }
1696     if (!err) {
1697         err = cc_seq_fetch_creds_begin(context, ccache, &iterator);
1698     }
1699     check_once_cc_seq_fetch_creds_next(context, iterator, 1000, CC_NOERROR, "iterating over a ccache with 1000 creds");
1700 
1701     if (ccache) { cc_close(context, &ccache); }
1702     if (iterator) { cc_seq_fetch_creds_end(context, &iterator); }
1703     if (context) {
1704         destroy_all_ccaches_v2(context);
1705         cc_shutdown(&context);
1706     }
1707 
1708     END_TEST_AND_RETURN
1709 }
1710 
1711 // ---------------------------------------------------------------------------
1712 
1713 cc_result check_once_cc_seq_fetch_creds_next(apiCB *context, ccache_cit *iterator, cc_uint32 expected_count, cc_result expected_err, const char *description) {
1714     cc_result   err             = CC_NOERROR;
1715     cred_union *creds           = NULL;
1716     cc_uint32   actual_count    = 0;
1717 
1718     cc_result possible_return_values[5] = {
1719         CC_NOERROR,
1720         CC_END,
1721         CC_BAD_PARM,
1722         CC_NOMEM,
1723         CC_NO_EXIST,
1724     };
1725 
1726     BEGIN_CHECK_ONCE(description);
1727 
1728 #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
1729 
1730     while (!err) {
1731         err = cc_seq_fetch_creds_next(context, &creds, iterator);
1732         if (creds) {
1733             actual_count++;
1734             cc_free_creds(context, &creds);
1735             creds = NULL;
1736         }
1737     }
1738     if (err == CC_END) {
1739         err = CC_NOERROR;
1740     }
1741 
1742     // check returned error
1743     check_err(err, expected_err, possible_return_values);
1744 
1745     check_if(actual_count != expected_count, "iterator didn't iterate over all ccaches");
1746 
1747     END_CHECK_ONCE;
1748 
1749     return err;
1750 }
1751