source4/heimdal/lib/krb5/cache.c

   1 /*
   2  * Copyright (c) 1997 - 2005 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "krb5_locl.h"
  35
  36 RCSID("$Id: cache.c,v 1.76 2005/11/29 09:10:47 lha Exp $");
  37
  38 /*
  39  * Add a new ccache type with operations `ops', overwriting any
  40  * existing one if `override'.
  41  * Return an error code or 0.
  42  */
  43
  44 krb5_error_code KRB5_LIB_FUNCTION
  45 krb5_cc_register(krb5_context context,
  46                  const krb5_cc_ops *ops,
  47                  krb5_boolean override)
  48 {
  49     int i;
  50
  51     for(i = 0; i < context->num_cc_ops && context->cc_ops[i].prefix; i++) {
  52         if(strcmp(context->cc_ops[i].prefix, ops->prefix) == 0) {
  53             if(!override) {
  54                 krb5_set_error_string(context,
  55                                       "ccache type %s already exists",
  56                                       ops->prefix);
  57                 return KRB5_CC_TYPE_EXISTS;
  58             }
  59             break;
  60         }
  61     }
  62     if(i == context->num_cc_ops) {
  63         krb5_cc_ops *o = realloc(context->cc_ops,
  64                                  (context->num_cc_ops + 1) *
  65                                  sizeof(*context->cc_ops));
  66         if(o == NULL) {
  67             krb5_set_error_string(context, "malloc: out of memory");
  68             return KRB5_CC_NOMEM;
  69         }
  70         context->num_cc_ops++;
  71         context->cc_ops = o;
  72         memset(context->cc_ops + i, 0,
  73                (context->num_cc_ops - i) * sizeof(*context->cc_ops));
  74     }
  75     memcpy(&context->cc_ops[i], ops, sizeof(context->cc_ops[i]));
  76     return 0;
  77 }
  78
  79 /*
  80  * Allocate the memory for a `id' and the that function table to
  81  * `ops'. Returns 0 or and error code.
  82  */
  83
  84 krb5_error_code
  85 _krb5_cc_allocate(krb5_context context,
  86                   const krb5_cc_ops *ops,
  87                   krb5_ccache *id)
  88 {
  89     krb5_ccache p;
  90
  91     p = malloc (sizeof(*p));
  92     if(p == NULL) {
  93         krb5_set_error_string(context, "malloc: out of memory");
  94         return KRB5_CC_NOMEM;
  95     }
  96     p->ops = ops;
  97     *id = p;
  98
  99     return 0;
 100 }
 101
 102 /*
 103  * Allocate memory for a new ccache in `id' with operations `ops'
 104  * and name `residual'.
 105  * Return 0 or an error code.
 106  */
 107
 108 static krb5_error_code
 109 allocate_ccache (krb5_context context,
 110                  const krb5_cc_ops *ops,
 111                  const char *residual,
 112                  krb5_ccache *id)
 113 {
 114     krb5_error_code ret;
 115
 116     ret = _krb5_cc_allocate(context, ops, id);
 117     if (ret)
 118         return ret;
 119     ret = (*id)->ops->resolve(context, id, residual);
 120     if(ret)
 121         free(*id);
 122     return ret;
 123 }
 124
 125 /*
 126  * Find and allocate a ccache in `id' from the specification in `residual'.
 127  * If the ccache name doesn't contain any colon, interpret it as a file name.
 128  * Return 0 or an error code.
 129  */
 130
 131 krb5_error_code KRB5_LIB_FUNCTION
 132 krb5_cc_resolve(krb5_context context,
 133                 const char *name,
 134                 krb5_ccache *id)
 135 {
 136     int i;
 137
 138     for(i = 0; i < context->num_cc_ops && context->cc_ops[i].prefix; i++) {
 139         size_t prefix_len = strlen(context->cc_ops[i].prefix);
 140
 141         if(strncmp(context->cc_ops[i].prefix, name, prefix_len) == 0
 142            && name[prefix_len] == ':') {
 143             return allocate_ccache (context, &context->cc_ops[i],
 144                                     name + prefix_len + 1,
 145                                     id);
 146         }
 147     }
 148     if (strchr (name, ':') == NULL)
 149         return allocate_ccache (context, &krb5_fcc_ops, name, id);
 150     else {
 151         krb5_set_error_string(context, "unknown ccache type %s", name);
 152         return KRB5_CC_UNKNOWN_TYPE;
 153     }
 154 }
 155
 156 /*
 157  * Generate a new ccache of type `ops' in `id'.
 158  * Return 0 or an error code.
 159  */
 160
 161 krb5_error_code KRB5_LIB_FUNCTION
 162 krb5_cc_gen_new(krb5_context context,
 163                 const krb5_cc_ops *ops,
 164                 krb5_ccache *id)
 165 {
 166     krb5_error_code ret;
 167
 168     ret = _krb5_cc_allocate(context, ops, id);
 169     if (ret)
 170         return ret;
 171     return (*id)->ops->gen_new(context, id);
 172 }
 173
 174 /*
 175  * Generates a new unique ccache of `type` in `id'. If `type' is NULL,
 176  * the library chooses the default credential cache type. The supplied
 177  * `hint' (that can be NULL) is a string that the credential cache
 178  * type can use to base the name of the credential on, this is to make
 179  * its easier for the user to differentiate the credentials.
 180  *
 181  *  Returns 0 or an error code.
 182  */
 183
 184 krb5_error_code KRB5_LIB_FUNCTION
 185 krb5_cc_new_unique(krb5_context context, const char *type,
 186                    const char *hint, krb5_ccache *id)
 187 {
 188     const krb5_cc_ops *ops;
 189
 190     if (type == NULL)
 191         type = "FILE";
 192
 193     ops = krb5_cc_get_prefix_ops(context, type);
 194     if (ops == NULL) {
 195         krb5_set_error_string(context, "Credential cache type %s is unknown",
 196                               type);
 197         return KRB5_CC_UNKNOWN_TYPE;
 198     }
 199
 200     return krb5_cc_gen_new(context, ops, id);
 201 }
 202
 203 /*
 204  * Return the name of the ccache `id'
 205  */
 206
 207 const char* KRB5_LIB_FUNCTION
 208 krb5_cc_get_name(krb5_context context,
 209                  krb5_ccache id)
 210 {
 211     return id->ops->get_name(context, id);
 212 }
 213
 214 /*
 215  * Return the type of the ccache `id'.
 216  */
 217
 218 const char* KRB5_LIB_FUNCTION
 219 krb5_cc_get_type(krb5_context context,
 220                  krb5_ccache id)
 221 {
 222     return id->ops->prefix;
 223 }
 224
 225 /*
 226  * Return the complete resolvable name the ccache `id' in `str´.
 227  * `str` should be freed with free(3).
 228  * Returns 0 or an error (and then *str is set to NULL).
 229  */
 230
 231 krb5_error_code KRB5_LIB_FUNCTION
 232 krb5_cc_get_full_name(krb5_context context,
 233                       krb5_ccache id,
 234                       char **str)
 235 {
 236     const char *type, *name;
 237
 238     *str = NULL;
 239
 240     type = krb5_cc_get_type(context, id);
 241     if (type == NULL) {
 242         krb5_set_error_string(context, "cache have no name of type");
 243         return KRB5_CC_UNKNOWN_TYPE;
 244     }
 245
 246     name = krb5_cc_get_name(context, id);
 247     if (name == NULL) {
 248         krb5_set_error_string(context, "cache of type %s have no name", type);
 249         return KRB5_CC_BADNAME;
 250     }
 251
 252     if (asprintf(str, "%s:%s", type, name) == -1) {
 253         krb5_set_error_string(context, "malloc - out of memory");
 254         *str = NULL;
 255         return ENOMEM;
 256     }
 257     return 0;
 258 }
 259
 260 /*
 261  * Return krb5_cc_ops of a the ccache `id'.
 262  */
 263
 264 const krb5_cc_ops *
 265 krb5_cc_get_ops(krb5_context context, krb5_ccache id)
 266 {
 267     return id->ops;
 268 }
 269
 270 /*
 271  * Expand variables in `str' into `res'
 272  */
 273
 274 krb5_error_code
 275 _krb5_expand_default_cc_name(krb5_context context, const char *str, char **res)
 276 {
 277     size_t tlen, len = 0;
 278     char *tmp, *tmp2, *append;
 279
 280     *res = NULL;
 281
 282     while (str && *str) {
 283         tmp = strstr(str, "%{");
 284         if (tmp && tmp != str) {
 285             append = malloc((tmp - str) + 1);
 286             if (append) {
 287                 memcpy(append, str, tmp - str);
 288                 append[tmp - str] = '\0';
 289             }
 290             str = tmp;
 291         } else if (tmp) {
 292             tmp2 = strchr(tmp, '}');
 293             if (tmp2 == NULL) {
 294                 free(*res);
 295                 *res = NULL;
 296                 krb5_set_error_string(context, "variable missing }");
 297                 return KRB5_CONFIG_BADFORMAT;
 298             }
 299             if (strncasecmp(tmp, "%{uid}", 6) == 0)
 300                 asprintf(&append, "%u", (unsigned)getuid());
 301             else if (strncasecmp(tmp, "%{null}", 7) == 0)
 302                 append = strdup("");
 303             else {
 304                 free(*res);
 305                 *res = NULL;
 306                 krb5_set_error_string(context,
 307                                       "expand default cache unknown "
 308                                       "variable \"%.*s\"",
 309                                       (int)(tmp2 - tmp) - 2, tmp + 2);
 310                 return KRB5_CONFIG_BADFORMAT;
 311             }
 312             str = tmp2 + 1;
 313         } else {
 314             append = strdup(str);
 315             str = NULL;
 316         }
 317         if (append == NULL) {
 318             free(*res);
 319             res = NULL;
 320             krb5_set_error_string(context, "malloc - out of memory");
 321             return ENOMEM;
 322         }
 323
 324         tlen = strlen(append);
 325         tmp = realloc(*res, len + tlen + 1);
 326         if (tmp == NULL) {
 327             free(*res);
 328             *res = NULL;
 329             krb5_set_error_string(context, "malloc - out of memory");
 330             return ENOMEM;
 331         }
 332         *res = tmp;
 333         memcpy(*res + len, append, tlen + 1);
 334         len = len + tlen;
 335         free(append);
 336     }
 337     return 0;
 338 }
 339
 340 /*
 341  * Set the default cc name for `context' to `name'.
 342  */
 343
 344 krb5_error_code KRB5_LIB_FUNCTION
 345 krb5_cc_set_default_name(krb5_context context, const char *name)
 346 {
 347     krb5_error_code ret = 0;
 348     char *p;
 349
 350     if (name == NULL) {
 351         const char *e = NULL;
 352
 353         if(!issuid()) {
 354             e = getenv("KRB5CCNAME");
 355             if (e)
 356                 p = strdup(e);
 357         }
 358         if (e == NULL) {
 359             e = krb5_config_get_string(context, NULL, "libdefaults",
 360                                        "default_cc_name", NULL);
 361             if (e) {
 362                 ret = _krb5_expand_default_cc_name(context, e, &p);
 363                 if (ret)
 364                     return ret;
 365             }
 366         }
 367         if (e == NULL)
 368             asprintf(&p,"FILE:/tmp/krb5cc_%u", (unsigned)getuid());
 369     } else
 370         p = strdup(name);
 371
 372     if (p == NULL) {
 373         krb5_set_error_string(context, "malloc - out of memory");
 374         return ENOMEM;
 375     }
 376
 377     if (context->default_cc_name)
 378         free(context->default_cc_name);
 379
 380     context->default_cc_name = p;
 381
 382     return ret;
 383 }
 384
 385 /*
 386  * Return a pointer to a context static string containing the default
 387  * ccache name.
 388  */
 389
 390 const char* KRB5_LIB_FUNCTION
 391 krb5_cc_default_name(krb5_context context)
 392 {
 393     if (context->default_cc_name == NULL)
 394         krb5_cc_set_default_name(context, NULL);
 395
 396     return context->default_cc_name;
 397 }
 398
 399 /*
 400  * Open the default ccache in `id'.
 401  * Return 0 or an error code.
 402  */
 403
 404 krb5_error_code KRB5_LIB_FUNCTION
 405 krb5_cc_default(krb5_context context,
 406                 krb5_ccache *id)
 407 {
 408     const char *p = krb5_cc_default_name(context);
 409
 410     if (p == NULL) {
 411         krb5_set_error_string(context, "malloc - out of memory");
 412         return ENOMEM;
 413     }
 414     return krb5_cc_resolve(context, p, id);
 415 }
 416
 417 /*
 418  * Create a new ccache in `id' for `primary_principal'.
 419  * Return 0 or an error code.
 420  */
 421
 422 krb5_error_code KRB5_LIB_FUNCTION
 423 krb5_cc_initialize(krb5_context context,
 424                    krb5_ccache id,
 425                    krb5_principal primary_principal)
 426 {
 427     return id->ops->init(context, id, primary_principal);
 428 }
 429
 430
 431 /*
 432  * Remove the ccache `id'.
 433  * Return 0 or an error code.
 434  */
 435
 436 krb5_error_code KRB5_LIB_FUNCTION
 437 krb5_cc_destroy(krb5_context context,
 438                 krb5_ccache id)
 439 {
 440     krb5_error_code ret;
 441
 442     ret = id->ops->destroy(context, id);
 443     krb5_cc_close (context, id);
 444     return ret;
 445 }
 446
 447 /*
 448  * Stop using the ccache `id' and free the related resources.
 449  * Return 0 or an error code.
 450  */
 451
 452 krb5_error_code KRB5_LIB_FUNCTION
 453 krb5_cc_close(krb5_context context,
 454               krb5_ccache id)
 455 {
 456     krb5_error_code ret;
 457     ret = id->ops->close(context, id);
 458     free(id);
 459     return ret;
 460 }
 461
 462 /*
 463  * Store `creds' in the ccache `id'.
 464  * Return 0 or an error code.
 465  */
 466
 467 krb5_error_code KRB5_LIB_FUNCTION
 468 krb5_cc_store_cred(krb5_context context,
 469                    krb5_ccache id,
 470                    krb5_creds *creds)
 471 {
 472     return id->ops->store(context, id, creds);
 473 }
 474
 475 /*
 476  * Retrieve the credential identified by `mcreds' (and `whichfields')
 477  * from `id' in `creds'.
 478  * Return 0 or an error code.
 479  */
 480
 481 krb5_error_code KRB5_LIB_FUNCTION
 482 krb5_cc_retrieve_cred(krb5_context context,
 483                       krb5_ccache id,
 484                       krb5_flags whichfields,
 485                       const krb5_creds *mcreds,
 486                       krb5_creds *creds)
 487 {
 488     krb5_error_code ret;
 489     krb5_cc_cursor cursor;
 490
 491     if (id->ops->retrieve != NULL) {
 492         return id->ops->retrieve(context, id, whichfields,
 493                                  mcreds, creds);
 494     }
 495
 496     krb5_cc_start_seq_get(context, id, &cursor);
 497     while((ret = krb5_cc_next_cred(context, id, &cursor, creds)) == 0){
 498         if(krb5_compare_creds(context, whichfields, mcreds, creds)){
 499             ret = 0;
 500             break;
 501         }
 502         krb5_free_cred_contents (context, creds);
 503     }
 504     krb5_cc_end_seq_get(context, id, &cursor);
 505     return ret;
 506 }
 507
 508 /*
 509  * Return the principal of `id' in `principal'.
 510  * Return 0 or an error code.
 511  */
 512
 513 krb5_error_code KRB5_LIB_FUNCTION
 514 krb5_cc_get_principal(krb5_context context,
 515                       krb5_ccache id,
 516                       krb5_principal *principal)
 517 {
 518     return id->ops->get_princ(context, id, principal);
 519 }
 520
 521 /*
 522  * Start iterating over `id', `cursor' is initialized to the
 523  * beginning.
 524  * Return 0 or an error code.
 525  */
 526
 527 krb5_error_code KRB5_LIB_FUNCTION
 528 krb5_cc_start_seq_get (krb5_context context,
 529                        const krb5_ccache id,
 530                        krb5_cc_cursor *cursor)
 531 {
 532     return id->ops->get_first(context, id, cursor);
 533 }
 534
 535 /*
 536  * Retrieve the next cred pointed to by (`id', `cursor') in `creds'
 537  * and advance `cursor'.
 538  * Return 0 or an error code.
 539  */
 540
 541 krb5_error_code KRB5_LIB_FUNCTION
 542 krb5_cc_next_cred (krb5_context context,
 543                    const krb5_ccache id,
 544                    krb5_cc_cursor *cursor,
 545                    krb5_creds *creds)
 546 {
 547     return id->ops->get_next(context, id, cursor, creds);
 548 }
 549
 550 /* like krb5_cc_next_cred, but allow for selective retrieval */
 551
 552 krb5_error_code KRB5_LIB_FUNCTION
 553 krb5_cc_next_cred_match(krb5_context context,
 554                         const krb5_ccache id,
 555                         krb5_cc_cursor * cursor,
 556                         krb5_creds * creds,
 557                         krb5_flags whichfields,
 558                         const krb5_creds * mcreds)
 559 {
 560     krb5_error_code ret;
 561     while (1) {
 562         ret = krb5_cc_next_cred(context, id, cursor, creds);
 563         if (ret)
 564             return ret;
 565         if (mcreds == NULL || krb5_compare_creds(context, whichfields, mcreds, creds))
 566             return 0;
 567         krb5_free_cred_contents(context, creds);
 568     }
 569 }
 570
 571 /*
 572  * Destroy the cursor `cursor'.
 573  */
 574
 575 krb5_error_code KRB5_LIB_FUNCTION
 576 krb5_cc_end_seq_get (krb5_context context,
 577                      const krb5_ccache id,
 578                      krb5_cc_cursor *cursor)
 579 {
 580     return id->ops->end_get(context, id, cursor);
 581 }
 582
 583 /*
 584  * Remove the credential identified by `cred', `which' from `id'.
 585  */
 586
 587 krb5_error_code KRB5_LIB_FUNCTION
 588 krb5_cc_remove_cred(krb5_context context,
 589                     krb5_ccache id,
 590                     krb5_flags which,
 591                     krb5_creds *cred)
 592 {
 593     if(id->ops->remove_cred == NULL) {
 594         krb5_set_error_string(context,
 595                               "ccache %s does not support remove_cred",
 596                               id->ops->prefix);
 597         return EACCES; /* XXX */
 598     }
 599     return (*id->ops->remove_cred)(context, id, which, cred);
 600 }
 601
 602 /*
 603  * Set the flags of `id' to `flags'.
 604  */
 605
 606 krb5_error_code KRB5_LIB_FUNCTION
 607 krb5_cc_set_flags(krb5_context context,
 608                   krb5_ccache id,
 609                   krb5_flags flags)
 610 {
 611     return id->ops->set_flags(context, id, flags);
 612 }
 613
 614 /*
 615  * Copy the contents of `from' to `to'.
 616  */
 617
 618 krb5_error_code KRB5_LIB_FUNCTION
 619 krb5_cc_copy_cache_match(krb5_context context,
 620                          const krb5_ccache from,
 621                          krb5_ccache to,
 622                          krb5_flags whichfields,
 623                          const krb5_creds * mcreds,
 624                          unsigned int *matched)
 625 {
 626     krb5_error_code ret;
 627     krb5_cc_cursor cursor;
 628     krb5_creds cred;
 629     krb5_principal princ;
 630
 631     ret = krb5_cc_get_principal(context, from, &princ);
 632     if (ret)
 633         return ret;
 634     ret = krb5_cc_initialize(context, to, princ);
 635     if (ret) {
 636         krb5_free_principal(context, princ);
 637         return ret;
 638     }
 639     ret = krb5_cc_start_seq_get(context, from, &cursor);
 640     if (ret) {
 641         krb5_free_principal(context, princ);
 642         return ret;
 643     }
 644     if (matched)
 645         *matched = 0;
 646     while (ret == 0 &&
 647            krb5_cc_next_cred_match(context, from, &cursor, &cred,
 648                                    whichfields, mcreds) == 0) {
 649         if (matched)
 650             (*matched)++;
 651         ret = krb5_cc_store_cred(context, to, &cred);
 652         krb5_free_cred_contents(context, &cred);
 653     }
 654     krb5_cc_end_seq_get(context, from, &cursor);
 655     krb5_free_principal(context, princ);
 656     return ret;
 657 }
 658
 659 krb5_error_code KRB5_LIB_FUNCTION
 660 krb5_cc_copy_cache(krb5_context context,
 661                    const krb5_ccache from,
 662                    krb5_ccache to)
 663 {
 664     return krb5_cc_copy_cache_match(context, from, to, 0, NULL, NULL);
 665 }
 666
 667 /*
 668  * Return the version of `id'.
 669  */
 670
 671 krb5_error_code KRB5_LIB_FUNCTION
 672 krb5_cc_get_version(krb5_context context,
 673                     const krb5_ccache id)
 674 {
 675     if(id->ops->get_version)
 676         return id->ops->get_version(context, id);
 677     else
 678         return 0;
 679 }
 680
 681 /*
 682  * Clear `mcreds' so it can be used with krb5_cc_retrieve_cred
 683  */
 684
 685 void KRB5_LIB_FUNCTION
 686 krb5_cc_clear_mcred(krb5_creds *mcred)
 687 {
 688     memset(mcred, 0, sizeof(*mcred));
 689 }
 690
 691 /*
 692  * Get the cc ops that is registered in `context' to handle the
 693  * `prefix'. `prefix' can be a complete credential cache name or a
 694  * prefix, the function will only use part up to the first colon (:)
 695  * if there is one.  Returns NULL if ops not found.
 696  */
 697
 698 const krb5_cc_ops *
 699 krb5_cc_get_prefix_ops(krb5_context context, const char *prefix)
 700 {
 701     char *p, *p1;
 702     int i;
 703
 704     if (prefix[0] == '/')
 705         return &krb5_fcc_ops;
 706
 707     p = strdup(prefix);
 708     if (p == NULL) {
 709         krb5_set_error_string(context, "malloc - out of memory");
 710         return NULL;
 711     }
 712     p1 = strchr(p, ':');
 713     if (p1)
 714         *p1 = '\0';
 715
 716     for(i = 0; i < context->num_cc_ops && context->cc_ops[i].prefix; i++) {
 717         if(strcmp(context->cc_ops[i].prefix, p) == 0) {
 718             free(p);
 719             return &context->cc_ops[i];
 720         }
 721     }
 722     free(p);
 723     return NULL;
 724 }
 725
 726 struct krb5_cc_cache_cursor_data {
 727     const krb5_cc_ops *ops;
 728     krb5_cc_cursor cursor;
 729 };
 730
 731 /*
 732  * Start iterating over all caches of `type'. If `type' is NULL, the
 733  * default type is * used. `cursor' is initialized to the beginning.
 734  * Return 0 or an error code.
 735  */
 736
 737 krb5_error_code KRB5_LIB_FUNCTION
 738 krb5_cc_cache_get_first (krb5_context context,
 739                          const char *type,
 740                          krb5_cc_cache_cursor *cursor)
 741 {
 742     const krb5_cc_ops *ops;
 743     krb5_error_code ret;
 744
 745     if (type == NULL)
 746         type = krb5_cc_default_name(context);
 747
 748     ops = krb5_cc_get_prefix_ops(context, type);
 749     if (ops == NULL) {
 750         krb5_set_error_string(context, "Unknown type \"%s\" when iterating "
 751                               "trying to iterate the credential caches", type);
 752         return KRB5_CC_UNKNOWN_TYPE;
 753     }
 754
 755     if (ops->get_cache_first == NULL) {
 756         krb5_set_error_string(context, "Credential cache type %s doesn't support "
 757                               "iterations over caches", ops->prefix);
 758         return KRB5_CC_NOSUPP;
 759     }
 760
 761     *cursor = calloc(1, sizeof(**cursor));
 762     if (*cursor == NULL) {
 763         krb5_set_error_string(context, "malloc - out of memory");
 764         return ENOMEM;
 765     }
 766
 767     (*cursor)->ops = ops;
 768
 769     ret = ops->get_cache_first(context, &(*cursor)->cursor);
 770     if (ret) {
 771         free(*cursor);
 772         *cursor = NULL;
 773     }
 774     return ret;
 775 }
 776
 777 /*
 778  * Retrieve the next cache pointed to by (`cursor') in `id'
 779  * and advance `cursor'.
 780  * Return 0 or an error code.
 781  */
 782
 783 krb5_error_code KRB5_LIB_FUNCTION
 784 krb5_cc_cache_next (krb5_context context,
 785                    krb5_cc_cache_cursor cursor,
 786                    krb5_ccache *id)
 787 {
 788     return cursor->ops->get_cache_next(context, cursor->cursor, id);
 789 }
 790
 791 /*
 792  * Destroy the cursor `cursor'.
 793  */
 794
 795 krb5_error_code KRB5_LIB_FUNCTION
 796 krb5_cc_cache_end_seq_get (krb5_context context,
 797                            krb5_cc_cache_cursor cursor)
 798 {
 799     krb5_error_code ret;
 800     ret = cursor->ops->end_cache_get(context, cursor->cursor);
 801     cursor->ops = NULL;
 802     free(cursor);
 803     return ret;
 804 }
 805
 806 /*
 807  * Search for a matching credential cache of type `type' that have the
 808  * `principal' as the default principal. If NULL is used for `type',
 809  * the default type is used. On success, `id' needs to be freed with
 810  * krb5_cc_close or krb5_cc_destroy. On failure, error code is
 811  * returned and `id' is set to NULL.
 812  */
 813
 814 krb5_error_code KRB5_LIB_FUNCTION
 815 krb5_cc_cache_match (krb5_context context,
 816                      krb5_principal client,
 817                      const char *type,
 818                      krb5_ccache *id)
 819 {
 820     krb5_cc_cache_cursor cursor;
 821     krb5_error_code ret;
 822     krb5_ccache cache = NULL;
 823
 824     *id = NULL;
 825
 826     ret = krb5_cc_cache_get_first (context, type, &cursor);
 827     if (ret)
 828         return ret;
 829
 830     while ((ret = krb5_cc_cache_next (context, cursor, &cache)) == 0) {
 831         krb5_principal principal;
 832
 833         ret = krb5_cc_get_principal(context, cache, &principal);
 834         if (ret == 0) {
 835             krb5_boolean match;
 836
 837             match = krb5_principal_compare(context, principal, client);
 838             krb5_free_principal(context, principal);
 839             if (match)
 840                 break;
 841         }
 842
 843         krb5_cc_close(context, cache);
 844         cache = NULL;
 845     }
 846
 847     krb5_cc_cache_end_seq_get(context, cursor);
 848
 849     if (cache == NULL) {
 850         char *str;
 851
 852         krb5_unparse_name(context, client, &str);
 853
 854         krb5_set_error_string(context, "Principal %s not found in a "
 855                           "credential cache", str ? str : "<out of memory>");
 856         if (str)
 857             free(str);
 858         return KRB5_CC_NOTFOUND;
 859     }
 860     *id = cache;
 861
 862     return 0;
 863 }
 864