← Back to branch summary

~ubuntu-branches/ubuntu/maverick/krb5/maverick

« back to all changes in this revision

Viewing changes to src/ccapi/test/test_ccapi_context.c

  • Committer: Bazaar Package Importer
  • Author(s): Sam Hartman
  • Date: 2009-05-07 16:16:34 UTC
  • mfrom: (13.1.7 sid)
  • Revision ID: james.westby@ubuntu.com-20090507161634-xqyk0s9na0le4flj
Tags: 1.7dfsg~beta1-4
http://bugs.debian.org/527353
When  decrypting the TGS response fails with the subkey, try with the
session key to work around Heimdal bug, Closes: #527353 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ccapi/test/test_ccapi_context.c
 
1
#include <string.h>
 
2
#include "test_ccapi_context.h"
 
3
#include <limits.h>
 
4
#include "test_ccapi_check.h"
 
5
#include "test_ccapi_util.h"
 
6
 
 
7
int check_cc_initialize(void) {
 
8
        cc_int32 err = 0;
 
9
        cc_context_t context = NULL;
 
10
        
 
11
        BEGIN_TEST("cc_initialize");
 
12
        
 
13
        // try every api_version
 
14
        err = check_once_cc_initialize(&context, ccapi_version_2, NULL, NULL, ccNoError, "cc_initialize with ccapi_version_2");            // err == CC_BAD_API_VERSION (9) would be imported by CredentialsCache2.h
 
15
        err = check_once_cc_initialize(&context, ccapi_version_3, NULL, NULL, ccNoError, "cc_initialize with ccapi_version_3");            // !err                                    
 
16
        err = check_once_cc_initialize(&context, ccapi_version_4, NULL, NULL, ccNoError, "cc_initialize with ccapi_version_4");            //        "                                            
 
17
        err = check_once_cc_initialize(&context, ccapi_version_5, NULL, NULL, ccNoError, "cc_initialize with ccapi_version_5");            //        "                                            
 
18
        err = check_once_cc_initialize(&context, ccapi_version_6, NULL, NULL, ccNoError, "cc_initialize with ccapi_version_6");            //        "                                            
 
19
        
 
20
        // try bad api_version
 
21
        err = check_once_cc_initialize(&context, INT_MAX,         NULL, NULL, ccErrBadAPIVersion, NULL); // err == ccErrBadAPIVersion                             
 
22
        
 
23
        // try bad param
 
24
        err = check_once_cc_initialize(NULL,     ccapi_version_3, NULL, NULL, ccErrBadParam, NULL);        // err == ccErrBadParam                                
 
25
        
 
26
        END_TEST_AND_RETURN
 
27
}
 
28
 
 
29
cc_int32 check_once_cc_initialize(cc_context_t *out_context, cc_int32 in_version, cc_int32 *out_supported_version, char const **out_vendor, cc_int32 expected_err, const char *description) {
 
30
        cc_int32 err = 0;
 
31
        cc_context_t context;
 
32
        
 
33
        cc_int32 possible_return_values[4] = {
 
34
                ccNoError, 
 
35
                ccErrNoMem, 
 
36
                ccErrBadAPIVersion, 
 
37
                ccErrBadParam,
 
38
        };
 
39
 
 
40
    BEGIN_CHECK_ONCE(description);
 
41
        
 
42
        #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
 
43
        
 
44
        err = cc_initialize(out_context, in_version, out_supported_version, out_vendor);
 
45
        
 
46
        // check returned error
 
47
        check_err(err, expected_err, possible_return_values);
 
48
        
 
49
        if (out_context) { context = *out_context; }
 
50
        else { context = NULL; }
 
51
        
 
52
        // check output parameters
 
53
        if (!err) {
 
54
                check_if(context == NULL, NULL);
 
55
                if (context) { 
 
56
                        cc_context_release(context); 
 
57
                        *out_context = NULL;
 
58
                }
 
59
        } else {
 
60
                check_if(context != NULL, NULL);
 
61
        }
 
62
        
 
63
        return err;
 
64
}
 
65
 
 
66
int check_cc_context_release(void) {
 
67
        cc_int32 err = 0;
 
68
        cc_context_t context = NULL;
 
69
        
 
70
        BEGIN_TEST("cc_context_release");
 
71
        
 
72
        #ifndef cc_context_release
 
73
        log_error("cc_context_release is not implemented yet");
 
74
        failure_count++;
 
75
        #else
 
76
        
 
77
        // try with valid context
 
78
        err = check_once_cc_context_release(&context, ccNoError, NULL);
 
79
        
 
80
        // try with NULL
 
81
        //err = check_once_cc_context_release(NULL, ccErrInvalidContext);
 
82
        /* calling with NULL context crashes, because this macro expands to 
 
83
           ((NULL) -> functions -> release (NULL)) which is dereferencing NULL which is bad. */
 
84
        
 
85
        if (context) { cc_context_release(context); }
 
86
        
 
87
        #endif /* cc_context_release */
 
88
        
 
89
        END_TEST_AND_RETURN
 
90
}
 
91
 
 
92
cc_int32 check_once_cc_context_release(cc_context_t *out_context, cc_int32 expected_err, const char *description) {
 
93
        cc_int32 err = 0;
 
94
        cc_context_t context = NULL;
 
95
                
 
96
        cc_int32 possible_return_values[2] = {
 
97
                ccNoError, 
 
98
                ccErrInvalidContext, 
 
99
        };
 
100
 
 
101
    BEGIN_CHECK_ONCE(description);
 
102
        
 
103
        #ifdef cc_context_release
 
104
        
 
105
        #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
 
106
        
 
107
        if (out_context) {
 
108
                err = cc_initialize(out_context, ccapi_version_3, NULL, NULL);
 
109
                if (!err) { 
 
110
                        context = *out_context; 
 
111
                }
 
112
        }
 
113
        
 
114
        if (err != ccNoError) {
 
115
                log_error("failure in cc_initialize, unable to perform check");
 
116
                return err;
 
117
        }
 
118
        else {
 
119
                err = cc_context_release(context);
 
120
                // check returned error
 
121
                check_err(err, expected_err, possible_return_values);
 
122
        }
 
123
        
 
124
        *out_context = NULL;
 
125
        
 
126
        #endif /* cc_context_release */
 
127
        
 
128
        END_CHECK_ONCE;
 
129
        
 
130
        return err;
 
131
}
 
132
 
 
133
int check_cc_context_get_change_time(void) {
 
134
        cc_int32 err = 0;
 
135
        cc_context_t context = NULL;
 
136
        cc_time_t last_change_time = 0;
 
137
        cc_ccache_t ccache = NULL;
 
138
        cc_credentials_union creds_union;
 
139
        cc_credentials_iterator_t creds_iterator = NULL;
 
140
        cc_credentials_t credentials = NULL;
 
141
        
 
142
        BEGIN_TEST("cc_context_get_change_time");
 
143
        
 
144
        #ifndef cc_context_get_change_time
 
145
        log_error("cc_context_get_change_time is not implemented yet");
 
146
        failure_count++;
 
147
        #else
 
148
        
 
149
        /*
 
150
         * Make a context
 
151
         * make sure the change time changes after:
 
152
         *      a ccache is created  
 
153
         *      a ccache is destroyed  
 
154
         *      a credential is stored  
 
155
         *      a credential is removed  
 
156
         *      a ccache principal is changed  
 
157
         *      the default ccache is changed
 
158
         * clean up memory
 
159
         */
 
160
        
 
161
        err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
 
162
        if (!err) {
 
163
                
 
164
                // try bad parameters first
 
165
                err = check_once_cc_context_get_change_time(context, NULL, ccErrBadParam, "NULL param, should fail");
 
166
                
 
167
                // make sure we have a default ccache
 
168
                err = cc_context_open_default_ccache(context, &ccache);
 
169
                if (err == ccErrCCacheNotFound) {
 
170
                        err = cc_context_create_default_ccache(context, cc_credentials_v5, "foo/bar@BAZ.ORG", &ccache);
 
171
                }
 
172
                if (!err) {
 
173
                        err = cc_ccache_release(ccache);
 
174
                }
 
175
                // either the default ccache already existed or we just created it
 
176
                // either way, the get_change_time should now give something > 0
 
177
                check_once_cc_context_get_change_time(context, &last_change_time, ccNoError, "first-run, should be > 0");
 
178
                
 
179
                // create a ccache
 
180
                err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
 
181
                check_once_cc_context_get_change_time(context, &last_change_time, ccNoError, "after creating a new ccache");
 
182
                
 
183
                // store a credential
 
184
                if (!err) {
 
185
                        new_v5_creds_union(&creds_union, "BAR.ORG");
 
186
                        err = cc_ccache_store_credentials(ccache, &creds_union);
 
187
                        release_v5_creds_union(&creds_union);
 
188
                }
 
189
                check_once_cc_context_get_change_time(context, &last_change_time, ccNoError, "after storing a credential");
 
190
                
 
191
                if (!err) {
 
192
                        // change principal (fails with ccErrBadInternalMessage)
 
193
                        err = cc_ccache_set_principal(ccache, cc_credentials_v5, "foo@BAR.ORG");
 
194
                        if (err) {
 
195
                                log_error("failed to change ccache's principal - %s (%d)", translate_ccapi_error(err), err);
 
196
                                failure_count++;
 
197
                                err = ccNoError;
 
198
                        }
 
199
                }
 
200
                check_once_cc_context_get_change_time(context, &last_change_time, ccNoError, "after changing a principle");
 
201
                
 
202
                // remove a credential
 
203
                if (!err) {
 
204
                        err = cc_ccache_new_credentials_iterator(ccache, &creds_iterator);
 
205
                }
 
206
                if (!err) {
 
207
                        err = cc_credentials_iterator_next(creds_iterator, &credentials);
 
208
                }
 
209
                if (err == ccIteratorEnd) {
 
210
                        err = ccNoError;
 
211
                }
 
212
                if (!err) {
 
213
                        err = cc_ccache_remove_credentials(ccache, credentials);
 
214
                }
 
215
                check_once_cc_context_get_change_time(context, &last_change_time, ccNoError, "after removing a credential");            
 
216
                
 
217
                if (!err) {
 
218
                        // change default ccache
 
219
                        err = cc_ccache_set_default(ccache);
 
220
                        check_once_cc_context_get_change_time(context, &last_change_time, ccNoError, "after changing default ccache");
 
221
                }
 
222
                
 
223
                if (ccache) {
 
224
                        // destroy a ccache
 
225
                        err = cc_ccache_destroy(ccache);
 
226
                        check_once_cc_context_get_change_time(context, &last_change_time, ccNoError, "after destroying a ccache");
 
227
                }
 
228
        }
 
229
        
 
230
        if (context) { cc_context_release(context); }
 
231
        
 
232
        #endif /* cc_get_change_time */
 
233
        
 
234
        END_TEST_AND_RETURN
 
235
}
 
236
 
 
237
cc_int32 check_once_cc_context_get_change_time(cc_context_t context, cc_time_t *time, cc_int32 expected_err, const char *description) {
 
238
        cc_int32 err = 0;
 
239
        cc_time_t last_change_time;
 
240
        cc_time_t current_change_time = 0;
 
241
                
 
242
        cc_int32 possible_return_values[3] = {
 
243
                ccNoError, 
 
244
                ccErrInvalidContext, 
 
245
                ccErrBadParam,
 
246
        };
 
247
 
 
248
    BEGIN_CHECK_ONCE(description);
 
249
        
 
250
        #ifdef cc_context_get_change_time
 
251
        
 
252
        #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
 
253
        
 
254
        if (time != NULL) { // if we were passed NULL, then we're looking to pass a bad param
 
255
                err = cc_context_get_change_time(context, &current_change_time);
 
256
        } else {
 
257
                err = cc_context_get_change_time(context, NULL);
 
258
        }
 
259
        
 
260
        check_err(err, expected_err, possible_return_values);
 
261
        
 
262
        if (!err) {
 
263
                last_change_time = *time;
 
264
                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);
 
265
                *time = current_change_time;
 
266
        }
 
267
        
 
268
        #endif /* cc_context_get_change_time */
 
269
        
 
270
        END_CHECK_ONCE;
 
271
        
 
272
        return err;
 
273
}
 
274
 
 
275
int check_cc_context_get_default_ccache_name(void) {
 
276
        cc_int32 err = 0;
 
277
        cc_context_t context = NULL;
 
278
        cc_ccache_t ccache = NULL;
 
279
        cc_string_t name = NULL;
 
280
        
 
281
        BEGIN_TEST("cc_context_get_default_ccache_name");
 
282
        
 
283
        #ifndef cc_context_get_default_ccache_name
 
284
        log_error("cc_context_get_default_ccache_name is not implemented yet");
 
285
        failure_count++;
 
286
        #else
 
287
        
 
288
        err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
 
289
        if (!err) {     
 
290
                // try bad parameters first
 
291
                err = check_once_cc_context_get_default_ccache_name(context, NULL, ccErrBadParam, NULL);
 
292
                
 
293
                // try with no default
 
294
                err = destroy_all_ccaches(context);
 
295
                err = cc_context_open_default_ccache(context, &ccache);
 
296
                if (err != ccErrCCacheNotFound) {
 
297
                        log_error("didn't remove all ccaches");
 
298
                }
 
299
                err = check_once_cc_context_get_default_ccache_name(context, &name, ccNoError, NULL);
 
300
                
 
301
                // try normally
 
302
                err = cc_context_create_default_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
 
303
                if (ccache) { cc_ccache_release(ccache); }
 
304
                err = check_once_cc_context_get_default_ccache_name(context, &name, ccNoError, NULL);
 
305
                
 
306
        }
 
307
        
 
308
        if (context) { cc_context_release(context); }
 
309
        
 
310
        #endif /* cc_context_get_default_ccache_name */
 
311
        
 
312
        END_TEST_AND_RETURN     
 
313
}
 
314
 
 
315
cc_int32 check_once_cc_context_get_default_ccache_name(cc_context_t context, cc_string_t *name, cc_int32 expected_err, const char *description) {
 
316
        cc_int32 err = 0;
 
317
        
 
318
        cc_int32 possible_return_values[4] = {
 
319
                ccNoError, 
 
320
                ccErrInvalidContext, 
 
321
                ccErrBadParam, 
 
322
                ccErrNoMem, 
 
323
        };
 
324
 
 
325
    BEGIN_CHECK_ONCE(description);
 
326
        
 
327
        #ifdef cc_context_get_default_ccache_name
 
328
        
 
329
        #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
 
330
                
 
331
        if (name != NULL) { // if we were passed NULL, then we're looking to pass a bad param
 
332
                err = cc_context_get_default_ccache_name(context, name);
 
333
        } else {
 
334
                err = cc_context_get_default_ccache_name(context, NULL);
 
335
        }
 
336
        
 
337
        // check returned error
 
338
        check_err(err, expected_err, possible_return_values);
 
339
        
 
340
        // not really anything else to check
 
341
        
 
342
        if (name && *name) { cc_string_release(*name); }
 
343
        
 
344
        #endif /* cc_context_get_default_ccache_name */
 
345
        
 
346
        END_CHECK_ONCE;
 
347
        
 
348
        return err;
 
349
}
 
350
 
 
351
int check_cc_context_open_ccache(void) {
 
352
        cc_int32 err = 0;
 
353
        cc_context_t context = NULL;
 
354
        cc_ccache_t ccache = NULL;
 
355
        cc_string_t name = NULL;
 
356
        
 
357
        BEGIN_TEST("cc_context_open_ccache");
 
358
        
 
359
        #ifndef cc_context_open_ccache
 
360
        log_error("cc_context_open_ccache is not implemented yet");
 
361
        failure_count++;
 
362
        #else
 
363
        
 
364
        err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
 
365
        if (!err) {     
 
366
                // make sure we have a default ccache
 
367
                err = cc_context_open_default_ccache(context, &ccache);
 
368
                if (err == ccErrCCacheNotFound) {
 
369
                        err = cc_context_create_default_ccache(context, cc_credentials_v5, "foo/bar@BAZ.ORG", &ccache);
 
370
                }
 
371
                if (!err) {
 
372
                        err = cc_ccache_release(ccache);
 
373
                        ccache = NULL;
 
374
                }
 
375
                
 
376
                // try default ccache
 
377
                err = cc_context_get_default_ccache_name(context, &name);
 
378
                if (!err) {
 
379
                        err = check_once_cc_context_open_ccache(context, name->data, &ccache, ccNoError, NULL);
 
380
                }
 
381
 
 
382
                // try bad parameters
 
383
                err = check_once_cc_context_open_ccache(context, NULL, &ccache, ccErrBadParam, NULL);
 
384
                err = check_once_cc_context_open_ccache(context, name->data, NULL, ccErrBadParam, NULL);
 
385
                
 
386
                // try a ccache that doesn't exist (create one and then destroy it)
 
387
                err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
 
388
                if (!err) {
 
389
                        err = cc_ccache_get_name(ccache, &name);
 
390
                }
 
391
                if (!err) {
 
392
                        err = cc_ccache_destroy(ccache);
 
393
                        ccache = NULL;
 
394
                }
 
395
                
 
396
                err = check_once_cc_context_open_ccache(context, name->data, &ccache, ccErrCCacheNotFound, NULL);
 
397
        }
 
398
        
 
399
        if (context) { cc_context_release(context); }
 
400
        
 
401
        #endif /* cc_context_open_ccache */
 
402
        
 
403
        END_TEST_AND_RETURN     
 
404
}
 
405
 
 
406
cc_int32 check_once_cc_context_open_ccache(cc_context_t context, const char *name, cc_ccache_t *ccache, cc_int32 expected_err, const char *description) {
 
407
        cc_int32 err = 0;
 
408
        cc_string_t stored_name = NULL;
 
409
        
 
410
        cc_int32 possible_return_values[6] = {
 
411
                ccNoError, 
 
412
                ccErrBadName, 
 
413
                ccErrInvalidContext, 
 
414
                ccErrNoMem, 
 
415
                ccErrCCacheNotFound, 
 
416
                ccErrBadParam, 
 
417
        };
 
418
 
 
419
    BEGIN_CHECK_ONCE(description);
 
420
        
 
421
        #ifdef cc_context_open_ccache
 
422
        
 
423
        #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
 
424
                
 
425
        if (ccache != NULL) { // if we were passed NULL, then we're looking to pass a bad param
 
426
                err = cc_context_open_ccache(context, name, ccache);
 
427
        } else {
 
428
                err = cc_context_open_ccache(context, name, NULL);
 
429
        }
 
430
        
 
431
        // check returned error
 
432
        check_err(err, expected_err, possible_return_values);
 
433
        
 
434
        if (!err) {
 
435
                check_if(*ccache == NULL, NULL);
 
436
                
 
437
                if (!err) {
 
438
                        err = cc_ccache_get_name(*ccache, &stored_name);
 
439
                }
 
440
                if (!err) { 
 
441
                        check_if(strcmp(stored_name->data, name), NULL); 
 
442
                }
 
443
                if (stored_name) { cc_string_release(stored_name); }
 
444
                
 
445
                
 
446
                if (ccache && *ccache) {
 
447
                        cc_ccache_release(*ccache);
 
448
                        *ccache = NULL;
 
449
                }
 
450
        }
 
451
        
 
452
        #endif /* cc_context_open_ccache */
 
453
        
 
454
        END_CHECK_ONCE;
 
455
        
 
456
        return err;
 
457
}
 
458
 
 
459
int check_cc_context_open_default_ccache(void) {
 
460
        cc_int32 err = 0;
 
461
        cc_context_t context = NULL;
 
462
        cc_ccache_t ccache = NULL;
 
463
        
 
464
        BEGIN_TEST("cc_context_open_default_ccache");
 
465
        
 
466
        #ifndef cc_context_open_default_ccache
 
467
        log_error("cc_context_open_default_ccache is not implemented yet");
 
468
        failure_count++;
 
469
        #else
 
470
        
 
471
        err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
 
472
        if (!err) {     
 
473
                // make sure we have a default ccache
 
474
                err = cc_context_create_default_ccache(context, cc_credentials_v5, "foo/bar@BAZ.ORG", &ccache);
 
475
                if (ccache) { cc_ccache_release(ccache); }
 
476
                
 
477
                // try default ccache
 
478
                if (!err) {
 
479
                        err = check_once_cc_context_open_default_ccache(context, &ccache, ccNoError, NULL);
 
480
                }
 
481
                
 
482
                // try bad parameters
 
483
                err = check_once_cc_context_open_default_ccache(context, NULL, ccErrBadParam, NULL);
 
484
                
 
485
                // try with no default ccache (destroy all ccaches first)
 
486
                err = destroy_all_ccaches(context);
 
487
                
 
488
                err = check_once_cc_context_open_default_ccache(context, &ccache, ccErrCCacheNotFound, NULL);
 
489
        }
 
490
        
 
491
        if (context) { cc_context_release(context); }
 
492
        
 
493
        #endif /* cc_context_open_default_ccache */
 
494
        
 
495
        END_TEST_AND_RETURN
 
496
}
 
497
 
 
498
cc_int32 check_once_cc_context_open_default_ccache(cc_context_t context, cc_ccache_t *ccache, cc_int32 expected_err, const char *description) {
 
499
        cc_int32 err = 0;
 
500
        cc_string_t given_name = NULL;
 
501
        cc_string_t default_name = NULL;
 
502
        
 
503
        cc_int32 possible_return_values[5] = {
 
504
                ccNoError, 
 
505
                ccErrInvalidContext, 
 
506
                ccErrNoMem, 
 
507
                ccErrCCacheNotFound, 
 
508
                ccErrBadParam, 
 
509
        };
 
510
 
 
511
    BEGIN_CHECK_ONCE(description);
 
512
        
 
513
        #ifdef cc_context_open_default_ccache
 
514
        
 
515
        #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
 
516
                
 
517
        if (ccache != NULL) { // if we were passed NULL, then we're looking to pass a bad param
 
518
                err = cc_context_open_default_ccache(context, ccache);
 
519
        } else {
 
520
                err = cc_context_open_default_ccache(context, NULL);
 
521
        }
 
522
        
 
523
        // check returned error
 
524
        check_err(err, expected_err, possible_return_values);
 
525
        
 
526
        if (!err) {
 
527
                check_if(*ccache == NULL, NULL);
 
528
                
 
529
                // make sure this ccache is the one we were looking to get back (compare name with cc_context_get_default_ccache_name)
 
530
                err = cc_ccache_get_name(*ccache, &given_name);
 
531
                err = cc_context_get_default_ccache_name(context, &default_name);
 
532
                if (given_name && default_name) {
 
533
                        check_if(strcmp(given_name->data, default_name->data), "name of ccache returned by cc_context_open_default_ccache doesn't match name returned by cc_context_get_default_ccache_name");
 
534
                }
 
535
                if (given_name) { cc_string_release(given_name); }
 
536
                if (default_name) { cc_string_release(default_name); }
 
537
                
 
538
                if (ccache && *ccache) {
 
539
                        cc_ccache_release(*ccache);
 
540
                        *ccache = NULL;
 
541
                }
 
542
        }
 
543
        
 
544
        #endif /* cc_context_open_default_ccache */
 
545
        
 
546
        END_CHECK_ONCE;
 
547
        
 
548
        return err;
 
549
}
 
550
 
 
551
int check_cc_context_create_ccache(void) {
 
552
        cc_int32 err = 0;
 
553
        cc_context_t context = NULL;
 
554
        cc_ccache_t ccache = NULL;
 
555
        cc_string_t name = NULL;
 
556
        
 
557
        BEGIN_TEST("cc_context_create_ccache");
 
558
        
 
559
        #ifndef cc_context_create_ccache
 
560
        log_error("cc_context_create_ccache is not implemented yet");
 
561
        failure_count++;
 
562
        #else
 
563
        
 
564
        err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
 
565
        if (!err) {     
 
566
                // try making a ccache with a non-unique name (the existing default's name)
 
567
                if (!err) {
 
568
                        err = cc_context_create_default_ccache(context, cc_credentials_v5, "foo/bar@BAZ.ORG", &ccache);
 
569
                }
 
570
                if (!err) {
 
571
                        err = cc_ccache_get_name(ccache, &name);
 
572
                }
 
573
                if (ccache) { cc_ccache_release(ccache); }
 
574
                if (!err) {
 
575
                        err = check_once_cc_context_create_ccache(context, name->data, cc_credentials_v5, "foo@BAR.ORG", &ccache, ccNoError, NULL);
 
576
                }
 
577
                
 
578
                // try making a ccache with a unique name (the now destroyed default's name)
 
579
                if (ccache) { cc_ccache_destroy(ccache); }
 
580
                if (!err) {
 
581
                        err = check_once_cc_context_create_ccache(context, name->data, cc_credentials_v5, "foo/baz@BAR.ORG", &ccache, ccNoError, NULL);
 
582
                }
 
583
                                
 
584
                // try bad parameters
 
585
                err = check_once_cc_context_create_ccache(context, NULL, cc_credentials_v5, "foo@BAR.ORG", &ccache, ccErrBadParam, "NULL name");                    // NULL name
 
586
                err = check_once_cc_context_create_ccache(context, "name", cc_credentials_v4_v5, "foo@BAR.ORG", &ccache, ccErrBadCredentialsVersion, "invalid creds_vers"); // invalid creds_vers
 
587
                err = check_once_cc_context_create_ccache(context, "name", cc_credentials_v5, NULL, &ccache, ccErrBadParam, "NULL principal");                          // NULL principal
 
588
                err = check_once_cc_context_create_ccache(context, "name", cc_credentials_v5, "foo@BAR.ORG", NULL, ccErrBadParam, "NULL ccache");                    // NULL ccache
 
589
        }
 
590
        
 
591
        if (name) { cc_string_release(name); }
 
592
        if (ccache) { cc_ccache_destroy(ccache); }
 
593
        if (context) { cc_context_release(context); }
 
594
        
 
595
        #endif /* cc_context_create_ccache */
 
596
        
 
597
        END_TEST_AND_RETURN
 
598
}
 
599
 
 
600
cc_int32 check_once_cc_context_create_ccache(cc_context_t context, const char *name, cc_uint32 cred_vers, const char *principal, cc_ccache_t *ccache, cc_int32 expected_err, const char *description) {
 
601
        cc_int32 err = 0;
 
602
        cc_string_t stored_name = NULL;
 
603
        cc_string_t stored_principal = NULL;
 
604
        cc_uint32 stored_creds_vers = 0;
 
605
 
 
606
        cc_int32 possible_return_values[6] = {
 
607
                ccNoError, 
 
608
                ccErrBadName, 
 
609
                ccErrBadParam, 
 
610
                ccErrInvalidContext, 
 
611
                ccErrNoMem, 
 
612
                ccErrBadCredentialsVersion, 
 
613
        };
 
614
        BEGIN_CHECK_ONCE(description);
 
615
        
 
616
        #ifdef cc_context_create_ccache
 
617
        
 
618
        #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
 
619
                
 
620
        err = cc_context_create_ccache(context, name, cred_vers, principal, ccache);
 
621
        
 
622
        // check returned error
 
623
        check_err(err, expected_err, possible_return_values);
 
624
        
 
625
        if (!err) {
 
626
                check_if(*ccache == NULL, NULL);
 
627
                
 
628
                // make sure all of the ccache's info matches what we gave it
 
629
                // name
 
630
                err = cc_ccache_get_name(*ccache, &stored_name);
 
631
                if (!err) { check_if(strcmp(stored_name->data, name), NULL); }
 
632
                if (stored_name) { cc_string_release(stored_name); }
 
633
                // cred_vers
 
634
                // FIXME Documented function name of cc_ccache_get_credentials_version is a typo.
 
635
                // FIXME Documented type of creds param the wrong signedness (should be unsigned) for cc_ccache_get_credentials_version, cc_context_create_ccache, cc_context_create_default_ccache, cc_context_create_new_ccache
 
636
                err = cc_ccache_get_credentials_version(*ccache, &stored_creds_vers);
 
637
                if (!err) { check_if(stored_creds_vers != cred_vers, NULL); }
 
638
                // principal
 
639
                err = cc_ccache_get_principal(*ccache, cc_credentials_v5, &stored_principal);
 
640
                if (!err) { check_if(strcmp(stored_principal->data, principal), NULL); }
 
641
                if (stored_principal) { cc_string_release(stored_principal); }
 
642
                                
 
643
                if (ccache && *ccache) {
 
644
                        cc_ccache_destroy(*ccache);
 
645
                        *ccache = NULL;
 
646
                }
 
647
        }
 
648
        
 
649
        #endif /* cc_context_create_ccache */
 
650
        
 
651
        END_CHECK_ONCE;
 
652
        
 
653
        return err;
 
654
}
 
655
 
 
656
int check_cc_context_create_default_ccache(void) {
 
657
        cc_int32 err = 0;
 
658
        cc_context_t context = NULL;
 
659
        cc_ccache_t ccache = NULL;
 
660
        cc_string_t name = NULL;
 
661
        
 
662
        BEGIN_TEST("cc_context_create_default_ccache");
 
663
        
 
664
        #ifndef cc_context_create_default_ccache
 
665
        log_error("cc_context_create_default_ccache is not implemented yet");
 
666
        failure_count++;
 
667
        #else
 
668
        
 
669
        err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
 
670
        if (!err) {     
 
671
                // try making the default when there are no existing ccaches
 
672
                err = destroy_all_ccaches(context);
 
673
                if (!err) {
 
674
                        err = check_once_cc_context_create_default_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache, ccNoError, NULL);
 
675
                }
 
676
                if (ccache) { cc_ccache_release(ccache); }
 
677
                
 
678
                // try making a new default when one already exists
 
679
                if (!err) {
 
680
                        err = check_once_cc_context_create_default_ccache(context, cc_credentials_v5, "foo/baz@BAR.ORG", &ccache, ccNoError, NULL);
 
681
                }
 
682
                
 
683
                // try bad parameters
 
684
                err = check_once_cc_context_create_default_ccache(context, cc_credentials_v4_v5, "foo@BAR.ORG", &ccache, ccErrBadCredentialsVersion, "invalid creds_vers"); // invalid creds_vers
 
685
                err = check_once_cc_context_create_default_ccache(context, cc_credentials_v5, NULL, &ccache, ccErrBadParam, "NULL principal");                          // NULL principal
 
686
                err = check_once_cc_context_create_default_ccache(context, cc_credentials_v5, "foo@BAR.ORG", NULL, ccErrBadParam, "NULL ccache");                    // NULL ccache
 
687
        }
 
688
        
 
689
        if (name) { cc_string_release(name); }
 
690
        if (ccache) { cc_ccache_destroy(ccache); }
 
691
        if (context) { cc_context_release(context); }
 
692
        
 
693
        #endif /* cc_context_create_default_ccache */
 
694
        
 
695
        END_TEST_AND_RETURN     
 
696
}
 
697
 
 
698
cc_int32 check_once_cc_context_create_default_ccache(cc_context_t context, cc_uint32 cred_vers, const char *principal, cc_ccache_t *ccache, cc_int32 expected_err, const char *description) {
 
699
        cc_int32 err = 0;
 
700
        cc_string_t stored_principal = NULL;
 
701
        cc_uint32 stored_creds_vers = 0;
 
702
 
 
703
        cc_int32 possible_return_values[6] = {
 
704
                ccNoError, 
 
705
                ccErrBadName, // how can this be possible when the name isn't a parameter?
 
706
                ccErrBadParam, 
 
707
                ccErrInvalidContext, 
 
708
                ccErrNoMem, 
 
709
                ccErrBadCredentialsVersion, 
 
710
        };
 
711
 
 
712
    BEGIN_CHECK_ONCE(description);
 
713
        
 
714
        #ifdef cc_context_create_default_ccache
 
715
        
 
716
        #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
 
717
                
 
718
        err = cc_context_create_default_ccache(context, cred_vers, principal, ccache);
 
719
        
 
720
        // check returned error
 
721
        check_err(err, expected_err, possible_return_values);
 
722
        
 
723
        if (!err) {
 
724
                if (ccache) { check_if(*ccache == NULL, NULL); }
 
725
                // make sure all of the ccache's info matches what we gave it
 
726
                // cred_vers
 
727
                err = cc_ccache_get_credentials_version(*ccache, &stored_creds_vers);
 
728
                if (!err) { check_if(stored_creds_vers != cred_vers, NULL); }
 
729
                // principal
 
730
                err = cc_ccache_get_principal(*ccache, cc_credentials_v5, &stored_principal);
 
731
                if (!err) { check_if(strcmp(stored_principal->data, principal), NULL); }
 
732
                if (stored_principal) { cc_string_release(stored_principal); }
 
733
                                
 
734
                if (ccache && *ccache) {
 
735
                        cc_ccache_release(*ccache);
 
736
                        *ccache = NULL;
 
737
                }
 
738
        }
 
739
        
 
740
        #endif /* cc_context_create_default_ccache */
 
741
        
 
742
        END_CHECK_ONCE;
 
743
        
 
744
        return err;
 
745
}
 
746
 
 
747
int check_cc_context_create_new_ccache(void) {
 
748
        cc_int32 err = 0;
 
749
        cc_context_t context = NULL;
 
750
        cc_ccache_t ccache = NULL;
 
751
        cc_string_t name = NULL;
 
752
        
 
753
        BEGIN_TEST("cc_context_create_new_ccache");
 
754
        
 
755
        #ifndef cc_context_create_new_ccache
 
756
        log_error("cc_context_create_new_ccache is not implemented yet");
 
757
        failure_count++;
 
758
        #else
 
759
        
 
760
        err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
 
761
        if (!err) {     
 
762
                // try making when there are no existing ccaches (should have name of default)
 
763
                err = destroy_all_ccaches(context);
 
764
                if (!err) {
 
765
                        err = check_once_cc_context_create_new_ccache(context, 1, cc_credentials_v5, "foo@BAR.ORG", &ccache, ccNoError, NULL);
 
766
                }
 
767
                if (ccache) { cc_ccache_release(ccache); }
 
768
                
 
769
                // try making a new ccache when one already exists (should not have name of default)
 
770
                if (!err) {
 
771
                        err = check_once_cc_context_create_new_ccache(context, 0, cc_credentials_v5, "foo/baz@BAR.ORG", &ccache, ccNoError, NULL);
 
772
                }
 
773
                if (ccache) { cc_ccache_release(ccache); }
 
774
                
 
775
                // try bad parameters
 
776
                err = check_once_cc_context_create_new_ccache(context, 1, cc_credentials_v4_v5, "foo@BAR.ORG", &ccache, ccErrBadCredentialsVersion, "invalid creds_vers"); // invalid creds_vers
 
777
                err = check_once_cc_context_create_new_ccache(context, 1, cc_credentials_v5, NULL, &ccache, ccErrBadParam, "NULL principal");                          // NULL principal
 
778
                err = check_once_cc_context_create_new_ccache(context, 1, cc_credentials_v5, "foo@BAR.ORG", NULL, ccErrBadParam, "NULL ccache");                    // NULL ccache
 
779
        }
 
780
        
 
781
        if (name) { cc_string_release(name); }
 
782
        if (ccache) { cc_ccache_destroy(ccache); }
 
783
        if (context) { cc_context_release(context); }
 
784
        
 
785
        #endif /* cc_context_create_new_ccache */
 
786
        
 
787
        END_TEST_AND_RETURN
 
788
}
 
789
 
 
790
cc_int32 check_once_cc_context_create_new_ccache(cc_context_t context, cc_int32 should_be_default, cc_uint32 cred_vers, const char *principal, cc_ccache_t *ccache, cc_int32 expected_err, const char *description) {
 
791
        cc_int32 err = 0;
 
792
        cc_string_t name = NULL;
 
793
        cc_string_t stored_name = NULL;
 
794
        cc_string_t stored_principal = NULL;
 
795
        cc_uint32 stored_creds_vers = 0;
 
796
        
 
797
        cc_int32 possible_return_values[6] = {
 
798
                ccNoError, 
 
799
                ccErrBadName, // how can this be possible when the name isn't a parameter?
 
800
                ccErrBadParam, 
 
801
                ccErrInvalidContext, 
 
802
                ccErrNoMem, 
 
803
                ccErrBadCredentialsVersion, 
 
804
        };
 
805
 
 
806
    BEGIN_CHECK_ONCE(description);
 
807
        
 
808
        #ifdef cc_context_create_new_ccache
 
809
        
 
810
        #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
 
811
                
 
812
        err = cc_context_create_new_ccache(context, cred_vers, principal, ccache);
 
813
        
 
814
        // check returned error
 
815
        check_err(err, expected_err, possible_return_values);
 
816
        
 
817
        if (!err) {
 
818
                if (ccache) { check_if(*ccache == NULL, NULL); }
 
819
                // make sure all of the ccache's info matches what we gave it
 
820
                if (!err) {
 
821
                        err = cc_context_get_default_ccache_name(context, &name);
 
822
                }
 
823
                if (!err) {
 
824
                        err = cc_ccache_get_name(*ccache, &stored_name);
 
825
                }
 
826
                if (!err) { 
 
827
                        if (should_be_default) {
 
828
                                check_if(strcmp(stored_name->data, name->data), "new ccache does not have name of default"); 
 
829
                        }
 
830
                        else {
 
831
                                check_if((strcmp(stored_name->data, name->data) == 0), "new cache has name of default"); 
 
832
                        }       
 
833
                }
 
834
                if (name) { cc_string_release(name); }
 
835
                if (stored_name) { cc_string_release(stored_name); }
 
836
                
 
837
                // cred_vers
 
838
                err = cc_ccache_get_credentials_version(*ccache, &stored_creds_vers);
 
839
                if (!err) { check_if(stored_creds_vers != cred_vers, NULL); }
 
840
                // principal
 
841
                err = cc_ccache_get_principal(*ccache, cc_credentials_v5, &stored_principal);
 
842
                if (!err) { check_if(strcmp(stored_principal->data, principal), NULL); }
 
843
                if (stored_principal) { cc_string_release(stored_principal); }
 
844
                                
 
845
                if (ccache && *ccache) {
 
846
                        cc_ccache_release(*ccache);
 
847
                        *ccache = NULL;
 
848
                }
 
849
        }
 
850
        
 
851
        #endif /* cc_context_create_new_ccache */
 
852
        
 
853
        END_CHECK_ONCE;
 
854
        
 
855
        return err;
 
856
}
 
857
 
 
858
int check_cc_context_new_ccache_iterator(void) {
 
859
        cc_int32 err = 0;
 
860
        cc_context_t context = NULL;
 
861
        cc_ccache_t ccache = NULL;
 
862
        cc_string_t name = NULL;
 
863
        cc_ccache_iterator_t iterator = NULL;
 
864
        
 
865
        BEGIN_TEST("cc_context_new_ccache_iterator");
 
866
        
 
867
        #ifndef cc_context_new_ccache_iterator
 
868
        log_error("cc_context_new_ccache_iterator is not implemented yet");
 
869
        failure_count++;
 
870
        #else
 
871
        
 
872
        err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
 
873
        if (!err) {     
 
874
                err = destroy_all_ccaches(context);
 
875
        }
 
876
        if (!err) {     
 
877
                // try making when there are no existing ccaches (shouldn't make a difference, but just in case)
 
878
                check_once_cc_context_new_ccache_iterator(context, &iterator, ccNoError, "when there are no existing ccaches");
 
879
        
 
880
                err = cc_context_create_default_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
 
881
        }
 
882
        if (!err) {     
 
883
                // try making when at least one ccache already exists (just to cover all our bases)
 
884
                check_once_cc_context_new_ccache_iterator(context, &iterator, ccNoError, "when at least one ccache already exists");
 
885
                
 
886
                // try bad parameters
 
887
                check_once_cc_context_new_ccache_iterator(context, NULL, ccErrBadParam, "NULL param"); // NULL iterator
 
888
        }
 
889
                // we'll do a comprehensive test of cc_ccache_iterator related functions later in the test suite
 
890
        
 
891
        if (name) { cc_string_release(name); }
 
892
        if (ccache) { cc_ccache_destroy(ccache); }
 
893
        if (context) { cc_context_release(context); }
 
894
        
 
895
        #endif /* cc_context_new_ccache_iterator */
 
896
        
 
897
        END_TEST_AND_RETURN
 
898
}
 
899
 
 
900
cc_int32 check_once_cc_context_new_ccache_iterator(cc_context_t context, cc_ccache_iterator_t *iterator, cc_int32 expected_err, const char *description) {
 
901
        cc_int32 err = ccNoError;
 
902
 
 
903
        cc_int32 possible_return_values[4] = {
 
904
                ccNoError, 
 
905
                ccErrBadParam, 
 
906
                ccErrNoMem, 
 
907
                ccErrInvalidContext, 
 
908
        };
 
909
 
 
910
    BEGIN_CHECK_ONCE(description);
 
911
 
 
912
        #ifdef cc_context_create_new_ccache
 
913
        
 
914
        #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
 
915
        
 
916
        err = cc_context_new_ccache_iterator(context, iterator);
 
917
                
 
918
        // check returned error
 
919
        check_err(err, expected_err, possible_return_values);
 
920
        
 
921
        // we'll do a comprehensive test of cc_ccache_iterator related functions later
 
922
        
 
923
        #endif /* cc_context_create_new_ccache */
 
924
        
 
925
        return err;
 
926
}
 
927
 
 
928
 
 
929
// ---------------------------------------------------------------------------
 
930
 
 
931
int check_cc_context_compare(void) {
 
932
        cc_int32 err = 0;
 
933
        cc_context_t context_a = NULL;
 
934
        cc_context_t context_b = NULL;
 
935
        cc_uint32 equal = 0;
 
936
        
 
937
        BEGIN_TEST("cc_context_compare");
 
938
        
 
939
        #ifndef cc_context_compare
 
940
        log_error("cc_context_compare is not implemented yet");
 
941
        failure_count++;
 
942
        #else
 
943
        
 
944
        err = cc_initialize(&context_a, ccapi_version_3, NULL, NULL);
 
945
        if (!err) {
 
946
                err = cc_initialize(&context_b, ccapi_version_3, NULL, NULL);
 
947
        }
 
948
 
 
949
        check_once_cc_context_compare(context_a, context_a, &equal, ccNoError, "valid params, same contexts");
 
950
        check_once_cc_context_compare(context_a, context_b, &equal, ccNoError, "valid params, different contexts");
 
951
        check_once_cc_context_compare(context_a, NULL, &equal, ccErrBadParam, "NULL compare_to context");
 
952
        check_once_cc_context_compare(context_a, context_b, NULL, ccErrBadParam, "NULL out param");
 
953
 
 
954
        if (context_a) { cc_context_release(context_a); }
 
955
        if (context_b) { cc_context_release(context_b); }
 
956
        
 
957
        #endif /* cc_context_compare */
 
958
        
 
959
        END_TEST_AND_RETURN
 
960
}
 
961
 
 
962
cc_int32 check_once_cc_context_compare(cc_context_t context, cc_context_t compare_to, cc_uint32 *equal, cc_int32 expected_err, const char *description) {
 
963
        cc_int32 err = ccNoError;
 
964
 
 
965
        cc_int32 possible_return_values[4] = {
 
966
                ccNoError, 
 
967
                ccErrInvalidContext, 
 
968
                ccErrBadParam, 
 
969
                ccErrServerUnavailable,
 
970
        };
 
971
 
 
972
    BEGIN_CHECK_ONCE(description);
 
973
 
 
974
        #ifdef cc_context_compare
 
975
        
 
976
        #define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
 
977
        
 
978
        err = cc_context_compare(context, compare_to, equal);
 
979
        
 
980
        if (!err) {
 
981
                *equal = 0;
 
982
        }
 
983
        
 
984
        // check returned error
 
985
        check_err(err, expected_err, possible_return_values);
 
986
        
 
987
        #endif /* cc_context_compare */
 
988
        
 
989
        return err;
 
990
}