lib/krb5/cache.c

   1 /*
   2  * Copyright (c) 1997 - 2007 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$");
  37
  38 /**
  39  * Add a new ccache type with operations `ops', overwriting any
  40  * existing one if `override'.
  41  *
  42  * @param context a Keberos context
  43  * @param ops type of plugin symbol
  44  * @param override flag to select if the registration is to overide
  45  * an existing ops with the same name.
  46  *
  47  * @return Return an error code or 0.
  48  *
  49  * @ingroup krb5_ccache
  50  */
  51
  52 krb5_error_code KRB5_LIB_FUNCTION
  53 krb5_cc_register(krb5_context context,
  54                  const krb5_cc_ops *ops,
  55                  krb5_boolean override)
  56 {
  57     int i;
  58
  59     for(i = 0; i < context->num_cc_ops && context->cc_ops[i].prefix; i++) {
  60         if(strcmp(context->cc_ops[i].prefix, ops->prefix) == 0) {
  61             if(!override) {
  62                 krb5_set_error_string(context,
  63                                       "ccache type %s already exists",
  64                                       ops->prefix);
  65                 return KRB5_CC_TYPE_EXISTS;
  66             }
  67             break;
  68         }
  69     }
  70     if(i == context->num_cc_ops) {
  71         krb5_cc_ops *o = realloc(context->cc_ops,
  72                                  (context->num_cc_ops + 1) *
  73                                  sizeof(*context->cc_ops));
  74         if(o == NULL) {
  75             krb5_set_error_string(context, "malloc: out of memory");
  76             return KRB5_CC_NOMEM;
  77         }
  78         context->num_cc_ops++;
  79         context->cc_ops = o;
  80         memset(context->cc_ops + i, 0,
  81                (context->num_cc_ops - i) * sizeof(*context->cc_ops));
  82     }
  83     memcpy(&context->cc_ops[i], ops, sizeof(context->cc_ops[i]));
  84     return 0;
  85 }
  86
  87 /*
  88  * Allocate the memory for a `id' and the that function table to
  89  * `ops'. Returns 0 or and error code.
  90  */
  91
  92 krb5_error_code
  93 _krb5_cc_allocate(krb5_context context,
  94                   const krb5_cc_ops *ops,
  95                   krb5_ccache *id)
  96 {
  97     krb5_ccache p;
  98
  99     p = malloc (sizeof(*p));
 100     if(p == NULL) {
 101         krb5_set_error_string(context, "malloc: out of memory");
 102         return KRB5_CC_NOMEM;
 103     }
 104     p->ops = ops;
 105     *id = p;
 106
 107     return 0;
 108 }
 109
 110 /*
 111  * Allocate memory for a new ccache in `id' with operations `ops'
 112  * and name `residual'. Return 0 or an error code.
 113  */
 114
 115 static krb5_error_code
 116 allocate_ccache (krb5_context context,
 117                  const krb5_cc_ops *ops,
 118                  const char *residual,
 119                  krb5_ccache *id)
 120 {
 121     krb5_error_code ret;
 122
 123     ret = _krb5_cc_allocate(context, ops, id);
 124     if (ret)
 125         return ret;
 126     ret = (*id)->ops->resolve(context, id, residual);
 127     if(ret)
 128         free(*id);
 129     return ret;
 130 }
 131
 132 /**
 133  * Find and allocate a ccache in `id' from the specification in `residual'.
 134  * If the ccache name doesn't contain any colon, interpret it as a file name.
 135  *
 136  * @param context a Keberos context.
 137  * @param name string name of a credential cache.
 138  * @param id return pointer to a found credential cache.
 139  *
 140  * @return Return 0 or an error code. In case of an error, id is set
 141  * to NULL.
 142  *
 143  * @ingroup krb5_ccache
 144  */
 145
 146
 147 krb5_error_code KRB5_LIB_FUNCTION
 148 krb5_cc_resolve(krb5_context context,
 149                 const char *name,
 150                 krb5_ccache *id)
 151 {
 152     int i;
 153
 154     *id = NULL;
 155
 156     for(i = 0; i < context->num_cc_ops && context->cc_ops[i].prefix; i++) {
 157         size_t prefix_len = strlen(context->cc_ops[i].prefix);
 158
 159         if(strncmp(context->cc_ops[i].prefix, name, prefix_len) == 0
 160            && name[prefix_len] == ':') {
 161             return allocate_ccache (context, &context->cc_ops[i],
 162                                     name + prefix_len + 1,
 163                                     id);
 164         }
 165     }
 166     if (strchr (name, ':') == NULL)
 167         return allocate_ccache (context, &krb5_fcc_ops, name, id);
 168     else {
 169         krb5_set_error_string(context, "unknown ccache type %s", name);
 170         return KRB5_CC_UNKNOWN_TYPE;
 171     }
 172 }
 173
 174 /**
 175  * Generate a new ccache of type `ops' in `id'.
 176  *
 177  * @return Return 0 or an error code.
 178  *
 179  * @ingroup krb5_ccache
 180  */
 181
 182
 183 krb5_error_code KRB5_LIB_FUNCTION
 184 krb5_cc_gen_new(krb5_context context,
 185                 const krb5_cc_ops *ops,
 186                 krb5_ccache *id)
 187 {
 188     return krb5_cc_new_unique(context, ops->prefix, NULL, id);
 189 }
 190
 191 /**
 192  * Generates a new unique ccache of `type` in `id'. If `type' is NULL,
 193  * the library chooses the default credential cache type. The supplied
 194  * `hint' (that can be NULL) is a string that the credential cache
 195  * type can use to base the name of the credential on, this is to make
 196  * it easier for the user to differentiate the credentials.
 197  *
 198  * @return Returns 0 or an error code.
 199  *
 200  * @ingroup krb5_ccache
 201  */
 202
 203 krb5_error_code KRB5_LIB_FUNCTION
 204 krb5_cc_new_unique(krb5_context context, const char *type,
 205                    const char *hint, krb5_ccache *id)
 206 {
 207     const krb5_cc_ops *ops = KRB5_DEFAULT_CCTYPE;
 208     krb5_error_code ret;
 209
 210     if (type) {
 211         ops = krb5_cc_get_prefix_ops(context, type);
 212         if (ops == NULL) {
 213             krb5_set_error_string(context,
 214                                   "Credential cache type %s is unknown", type);
 215             return KRB5_CC_UNKNOWN_TYPE;
 216         }
 217     }
 218
 219     ret = _krb5_cc_allocate(context, ops, id);
 220     if (ret)
 221         return ret;
 222     return (*id)->ops->gen_new(context, id);
 223 }
 224
 225 /**
 226  * Return the name of the ccache `id'
 227  *
 228  * @ingroup krb5_ccache
 229  */
 230
 231
 232 const char* KRB5_LIB_FUNCTION
 233 krb5_cc_get_name(krb5_context context,
 234                  krb5_ccache id)
 235 {
 236     return id->ops->get_name(context, id);
 237 }
 238
 239 /**
 240  * Return the type of the ccache `id'.
 241  *
 242  * @ingroup krb5_ccache
 243  */
 244
 245
 246 const char* KRB5_LIB_FUNCTION
 247 krb5_cc_get_type(krb5_context context,
 248                  krb5_ccache id)
 249 {
 250     return id->ops->prefix;
 251 }
 252
 253 /**
 254  * Return the complete resolvable name the ccache `id' in `str´.
 255  * `str` should be freed with free(3).
 256  * Returns 0 or an error (and then *str is set to NULL).
 257  *
 258  * @ingroup krb5_ccache
 259  */
 260
 261
 262 krb5_error_code KRB5_LIB_FUNCTION
 263 krb5_cc_get_full_name(krb5_context context,
 264                       krb5_ccache id,
 265                       char **str)
 266 {
 267     const char *type, *name;
 268
 269     *str = NULL;
 270
 271     type = krb5_cc_get_type(context, id);
 272     if (type == NULL) {
 273         krb5_set_error_string(context, "cache have no name of type");
 274         return KRB5_CC_UNKNOWN_TYPE;
 275     }
 276
 277     name = krb5_cc_get_name(context, id);
 278     if (name == NULL) {
 279         krb5_set_error_string(context, "cache of type %s have no name", type);
 280         return KRB5_CC_BADNAME;
 281     }
 282
 283     if (asprintf(str, "%s:%s", type, name) == -1) {
 284         krb5_set_error_string(context, "malloc - out of memory");
 285         *str = NULL;
 286         return ENOMEM;
 287     }
 288     return 0;
 289 }
 290
 291 /**
 292  * Return krb5_cc_ops of a the ccache `id'.
 293  *
 294  * @ingroup krb5_ccache
 295  */
 296
 297
 298 const krb5_cc_ops *
 299 krb5_cc_get_ops(krb5_context context, krb5_ccache id)
 300 {
 301     return id->ops;
 302 }
 303
 304 /*
 305  * Expand variables in `str' into `res'
 306  */
 307
 308 krb5_error_code
 309 _krb5_expand_default_cc_name(krb5_context context, const char *str, char **res)
 310 {
 311     size_t tlen, len = 0;
 312     char *tmp, *tmp2, *append;
 313
 314     *res = NULL;
 315
 316     while (str && *str) {
 317         tmp = strstr(str, "%{");
 318         if (tmp && tmp != str) {
 319             append = malloc((tmp - str) + 1);
 320             if (append) {
 321                 memcpy(append, str, tmp - str);
 322                 append[tmp - str] = '\0';
 323             }
 324             str = tmp;
 325         } else if (tmp) {
 326             tmp2 = strchr(tmp, '}');
 327             if (tmp2 == NULL) {
 328                 free(*res);
 329                 *res = NULL;
 330                 krb5_set_error_string(context, "variable missing }");
 331                 return KRB5_CONFIG_BADFORMAT;
 332             }
 333             if (strncasecmp(tmp, "%{uid}", 6) == 0)
 334                 asprintf(&append, "%u", (unsigned)getuid());
 335             else if (strncasecmp(tmp, "%{null}", 7) == 0)
 336                 append = strdup("");
 337             else {
 338                 free(*res);
 339                 *res = NULL;
 340                 krb5_set_error_string(context,
 341                                       "expand default cache unknown "
 342                                       "variable \"%.*s\"",
 343                                       (int)(tmp2 - tmp) - 2, tmp + 2);
 344                 return KRB5_CONFIG_BADFORMAT;
 345             }
 346             str = tmp2 + 1;
 347         } else {
 348             append = strdup(str);
 349             str = NULL;
 350         }
 351         if (append == NULL) {
 352             free(*res);
 353             *res = NULL;
 354             krb5_set_error_string(context, "malloc - out of memory");
 355             return ENOMEM;
 356         }
 357
 358         tlen = strlen(append);
 359         tmp = realloc(*res, len + tlen + 1);
 360         if (tmp == NULL) {
 361             free(append);
 362             free(*res);
 363             *res = NULL;
 364             krb5_set_error_string(context, "malloc - out of memory");
 365             return ENOMEM;
 366         }
 367         *res = tmp;
 368         memcpy(*res + len, append, tlen + 1);
 369         len = len + tlen;
 370         free(append);
 371     }
 372     return 0;
 373 }
 374
 375 /*
 376  * Return non-zero if envirnoment that will determine default krb5cc
 377  * name has changed.
 378  */
 379
 380 static int
 381 environment_changed(krb5_context context)
 382 {
 383     const char *e;
 384
 385     /* if the cc name was set, don't change it */
 386     if (context->default_cc_name_set)
 387         return 0;
 388
 389     if(issuid())
 390         return 0;
 391
 392     e = getenv("KRB5CCNAME");
 393     if (e == NULL) {
 394         if (context->default_cc_name_env) {
 395             free(context->default_cc_name_env);
 396             context->default_cc_name_env = NULL;
 397             return 1;
 398         }
 399     } else {
 400         if (context->default_cc_name_env == NULL)
 401             return 1;
 402         if (strcmp(e, context->default_cc_name_env) != 0)
 403             return 1;
 404     }
 405     return 0;
 406 }
 407
 408 /**
 409  * Switch the default default credential cache for a specific
 410  * credcache type (and name for some implementations).
 411  *
 412  * @return Returns 0 or an error code.
 413  *
 414  * @ingroup krb5_ccache
 415  */
 416
 417 krb5_error_code
 418 krb5_cc_switch(krb5_context context, krb5_ccache id)
 419 {
 420
 421     if (id->ops->set_default == NULL)
 422         return 0;
 423
 424     return (*id->ops->set_default)(context, id);
 425 }
 426
 427 /**
 428  * Set the default cc name for `context' to `name'.
 429  *
 430  * @ingroup krb5_ccache
 431  */
 432
 433 krb5_error_code KRB5_LIB_FUNCTION
 434 krb5_cc_set_default_name(krb5_context context, const char *name)
 435 {
 436     krb5_error_code ret = 0;
 437     char *p;
 438
 439     if (name == NULL) {
 440         const char *e = NULL;
 441
 442         if(!issuid()) {
 443             e = getenv("KRB5CCNAME");
 444             if (e) {
 445                 p = strdup(e);
 446                 if (context->default_cc_name_env)
 447                     free(context->default_cc_name_env);
 448                 context->default_cc_name_env = strdup(e);
 449             }
 450         }
 451         if (e == NULL) {
 452             e = krb5_config_get_string(context, NULL, "libdefaults",
 453                                        "default_cc_name", NULL);
 454             if (e) {
 455                 ret = _krb5_expand_default_cc_name(context, e, &p);
 456                 if (ret)
 457                     return ret;
 458             }
 459             if (e == NULL) {
 460                 const krb5_cc_ops *ops = KRB5_DEFAULT_CCTYPE;
 461                 ret = (*ops->get_default_name)(context, &p);
 462                 if (ret)
 463                     return ret;
 464             }
 465         }
 466         context->default_cc_name_set = 0;
 467     } else {
 468         p = strdup(name);
 469         context->default_cc_name_set = 1;
 470     }
 471
 472     if (p == NULL) {
 473         krb5_set_error_string(context, "malloc - out of memory");
 474         return ENOMEM;
 475     }
 476
 477     if (context->default_cc_name)
 478         free(context->default_cc_name);
 479
 480     context->default_cc_name = p;
 481
 482     return ret;
 483 }
 484
 485 /**
 486  * Return a pointer to a context static string containing the default
 487  * ccache name.
 488  *
 489  * @return String to the default credential cache name.
 490  *
 491  * @ingroup krb5_ccache
 492  */
 493
 494
 495 const char* KRB5_LIB_FUNCTION
 496 krb5_cc_default_name(krb5_context context)
 497 {
 498     if (context->default_cc_name == NULL || environment_changed(context))
 499         krb5_cc_set_default_name(context, NULL);
 500
 501     return context->default_cc_name;
 502 }
 503
 504 /**
 505  * Open the default ccache in `id'.
 506  *
 507  * @return Return 0 or an error code.
 508  *
 509  * @ingroup krb5_ccache
 510  */
 511
 512
 513 krb5_error_code KRB5_LIB_FUNCTION
 514 krb5_cc_default(krb5_context context,
 515                 krb5_ccache *id)
 516 {
 517     const char *p = krb5_cc_default_name(context);
 518
 519     if (p == NULL) {
 520         krb5_set_error_string(context, "malloc - out of memory");
 521         return ENOMEM;
 522     }
 523     return krb5_cc_resolve(context, p, id);
 524 }
 525
 526 /**
 527  * Create a new ccache in `id' for `primary_principal'.
 528  *
 529  * @return Return 0 or an error code.
 530  *
 531  * @ingroup krb5_ccache
 532  */
 533
 534
 535 krb5_error_code KRB5_LIB_FUNCTION
 536 krb5_cc_initialize(krb5_context context,
 537                    krb5_ccache id,
 538                    krb5_principal primary_principal)
 539 {
 540     return (*id->ops->init)(context, id, primary_principal);
 541 }
 542
 543
 544 /**
 545  * Remove the ccache `id'.
 546  *
 547  * @return Return 0 or an error code.
 548  *
 549  * @ingroup krb5_ccache
 550  */
 551
 552
 553 krb5_error_code KRB5_LIB_FUNCTION
 554 krb5_cc_destroy(krb5_context context,
 555                 krb5_ccache id)
 556 {
 557     krb5_error_code ret;
 558
 559     ret = (*id->ops->destroy)(context, id);
 560     krb5_cc_close (context, id);
 561     return ret;
 562 }
 563
 564 /**
 565  * Stop using the ccache `id' and free the related resources.
 566  *
 567  * @return Return 0 or an error code.
 568  *
 569  * @ingroup krb5_ccache
 570  */
 571
 572
 573 krb5_error_code KRB5_LIB_FUNCTION
 574 krb5_cc_close(krb5_context context,
 575               krb5_ccache id)
 576 {
 577     krb5_error_code ret;
 578     ret = (*id->ops->close)(context, id);
 579     free(id);
 580     return ret;
 581 }
 582
 583 /**
 584  * Store `creds' in the ccache `id'.
 585  *
 586  * @return Return 0 or an error code.
 587  *
 588  * @ingroup krb5_ccache
 589  */
 590
 591
 592 krb5_error_code KRB5_LIB_FUNCTION
 593 krb5_cc_store_cred(krb5_context context,
 594                    krb5_ccache id,
 595                    krb5_creds *creds)
 596 {
 597     return (*id->ops->store)(context, id, creds);
 598 }
 599
 600 /**
 601  * Retrieve the credential identified by `mcreds' (and `whichfields')
 602  * from `id' in `creds'. 'creds' must be free by the caller using
 603  * krb5_free_cred_contents.
 604  *
 605  * @return Return 0 or an error code.
 606  *
 607  * @ingroup krb5_ccache
 608  */
 609
 610
 611 krb5_error_code KRB5_LIB_FUNCTION
 612 krb5_cc_retrieve_cred(krb5_context context,
 613                       krb5_ccache id,
 614                       krb5_flags whichfields,
 615                       const krb5_creds *mcreds,
 616                       krb5_creds *creds)
 617 {
 618     krb5_error_code ret;
 619     krb5_cc_cursor cursor;
 620
 621     if (id->ops->retrieve != NULL) {
 622         return (*id->ops->retrieve)(context, id, whichfields,
 623                                     mcreds, creds);
 624     }
 625
 626     ret = krb5_cc_start_seq_get(context, id, &cursor);
 627     if (ret)
 628         return ret;
 629     while((ret = krb5_cc_next_cred(context, id, &cursor, creds)) == 0){
 630         if(krb5_compare_creds(context, whichfields, mcreds, creds)){
 631             ret = 0;
 632             break;
 633         }
 634         krb5_free_cred_contents (context, creds);
 635     }
 636     krb5_cc_end_seq_get(context, id, &cursor);
 637     return ret;
 638 }
 639
 640 /**
 641  * Return the principal of `id' in `principal'.
 642  *
 643  * @return Return 0 or an error code.
 644  *
 645  * @ingroup krb5_ccache
 646  */
 647
 648
 649 krb5_error_code KRB5_LIB_FUNCTION
 650 krb5_cc_get_principal(krb5_context context,
 651                       krb5_ccache id,
 652                       krb5_principal *principal)
 653 {
 654     return (*id->ops->get_princ)(context, id, principal);
 655 }
 656
 657 /**
 658  * Start iterating over `id', `cursor' is initialized to the
 659  * beginning.
 660  *
 661  * @return Return 0 or an error code.
 662  *
 663  * @ingroup krb5_ccache
 664  */
 665
 666
 667 krb5_error_code KRB5_LIB_FUNCTION
 668 krb5_cc_start_seq_get (krb5_context context,
 669                        const krb5_ccache id,
 670                        krb5_cc_cursor *cursor)
 671 {
 672     return (*id->ops->get_first)(context, id, cursor);
 673 }
 674
 675 /**
 676  * Retrieve the next cred pointed to by (`id', `cursor') in `creds'
 677  * and advance `cursor'.
 678  *
 679  * @return Return 0 or an error code.
 680  *
 681  * @ingroup krb5_ccache
 682  */
 683
 684
 685 krb5_error_code KRB5_LIB_FUNCTION
 686 krb5_cc_next_cred (krb5_context context,
 687                    const krb5_ccache id,
 688                    krb5_cc_cursor *cursor,
 689                    krb5_creds *creds)
 690 {
 691     return (*id->ops->get_next)(context, id, cursor, creds);
 692 }
 693
 694 /**
 695  * Like krb5_cc_next_cred, but allow for selective retrieval
 696  *
 697  * @ingroup krb5_ccache
 698  */
 699
 700
 701 krb5_error_code KRB5_LIB_FUNCTION
 702 krb5_cc_next_cred_match(krb5_context context,
 703                         const krb5_ccache id,
 704                         krb5_cc_cursor * cursor,
 705                         krb5_creds * creds,
 706                         krb5_flags whichfields,
 707                         const krb5_creds * mcreds)
 708 {
 709     krb5_error_code ret;
 710     while (1) {
 711         ret = krb5_cc_next_cred(context, id, cursor, creds);
 712         if (ret)
 713             return ret;
 714         if (mcreds == NULL || krb5_compare_creds(context, whichfields, mcreds, creds))
 715             return 0;
 716         krb5_free_cred_contents(context, creds);
 717     }
 718 }
 719
 720 /**
 721  * Destroy the cursor `cursor'.
 722  *
 723  * @ingroup krb5_ccache
 724  */
 725
 726
 727 krb5_error_code KRB5_LIB_FUNCTION
 728 krb5_cc_end_seq_get (krb5_context context,
 729                      const krb5_ccache id,
 730                      krb5_cc_cursor *cursor)
 731 {
 732     return (*id->ops->end_get)(context, id, cursor);
 733 }
 734
 735 /**
 736  * Remove the credential identified by `cred', `which' from `id'.
 737  *
 738  * @ingroup krb5_ccache
 739  */
 740
 741
 742 krb5_error_code KRB5_LIB_FUNCTION
 743 krb5_cc_remove_cred(krb5_context context,
 744                     krb5_ccache id,
 745                     krb5_flags which,
 746                     krb5_creds *cred)
 747 {
 748     if(id->ops->remove_cred == NULL) {
 749         krb5_set_error_string(context,
 750                               "ccache %s does not support remove_cred",
 751                               id->ops->prefix);
 752         return EACCES; /* XXX */
 753     }
 754     return (*id->ops->remove_cred)(context, id, which, cred);
 755 }
 756
 757 /**
 758  * Set the flags of `id' to `flags'.
 759  *
 760  * @ingroup krb5_ccache
 761  */
 762
 763
 764 krb5_error_code KRB5_LIB_FUNCTION
 765 krb5_cc_set_flags(krb5_context context,
 766                   krb5_ccache id,
 767                   krb5_flags flags)
 768 {
 769     return (*id->ops->set_flags)(context, id, flags);
 770 }
 771
 772 /**
 773  * Copy the contents of `from' to `to'.
 774  *
 775  * @ingroup krb5_ccache
 776  */
 777
 778
 779 krb5_error_code KRB5_LIB_FUNCTION
 780 krb5_cc_copy_cache_match(krb5_context context,
 781                          const krb5_ccache from,
 782                          krb5_ccache to,
 783                          krb5_flags whichfields,
 784                          const krb5_creds * mcreds,
 785                          unsigned int *matched)
 786 {
 787     krb5_error_code ret;
 788     krb5_cc_cursor cursor;
 789     krb5_creds cred;
 790     krb5_principal princ;
 791
 792     ret = krb5_cc_get_principal(context, from, &princ);
 793     if (ret)
 794         return ret;
 795     ret = krb5_cc_initialize(context, to, princ);
 796     if (ret) {
 797         krb5_free_principal(context, princ);
 798         return ret;
 799     }
 800     ret = krb5_cc_start_seq_get(context, from, &cursor);
 801     if (ret) {
 802         krb5_free_principal(context, princ);
 803         return ret;
 804     }
 805     if (matched)
 806         *matched = 0;
 807     while (ret == 0 &&
 808            krb5_cc_next_cred_match(context, from, &cursor, &cred,
 809                                    whichfields, mcreds) == 0) {
 810         if (matched)
 811             (*matched)++;
 812         ret = krb5_cc_store_cred(context, to, &cred);
 813         krb5_free_cred_contents(context, &cred);
 814     }
 815     krb5_cc_end_seq_get(context, from, &cursor);
 816     krb5_free_principal(context, princ);
 817     return ret;
 818 }
 819
 820 /**
 821  * Just like krb5_cc_copy_cache_match, but copy everything.
 822  *
 823  * @ingroup krb5_ccache
 824  */
 825
 826
 827 krb5_error_code KRB5_LIB_FUNCTION
 828 krb5_cc_copy_cache(krb5_context context,
 829                    const krb5_ccache from,
 830                    krb5_ccache to)
 831 {
 832     return krb5_cc_copy_cache_match(context, from, to, 0, NULL, NULL);
 833 }
 834
 835 /**
 836  * Return the version of `id'.
 837  *
 838  * @ingroup krb5_ccache
 839  */
 840
 841
 842 krb5_error_code KRB5_LIB_FUNCTION
 843 krb5_cc_get_version(krb5_context context,
 844                     const krb5_ccache id)
 845 {
 846     if(id->ops->get_version)
 847         return (*id->ops->get_version)(context, id);
 848     else
 849         return 0;
 850 }
 851
 852 /**
 853  * Clear `mcreds' so it can be used with krb5_cc_retrieve_cred
 854  *
 855  * @ingroup krb5_ccache
 856  */
 857
 858
 859 void KRB5_LIB_FUNCTION
 860 krb5_cc_clear_mcred(krb5_creds *mcred)
 861 {
 862     memset(mcred, 0, sizeof(*mcred));
 863 }
 864
 865 /**
 866  * Get the cc ops that is registered in `context' to handle the
 867  * `prefix'. `prefix' can be a complete credential cache name or a
 868  * prefix, the function will only use part up to the first colon (:)
 869  * if there is one.
 870  * Returns NULL if ops not found.
 871  *
 872  * @ingroup krb5_ccache
 873  */
 874
 875
 876 const krb5_cc_ops *
 877 krb5_cc_get_prefix_ops(krb5_context context, const char *prefix)
 878 {
 879     char *p, *p1;
 880     int i;
 881
 882     if (prefix[0] == '/')
 883         return &krb5_fcc_ops;
 884
 885     p = strdup(prefix);
 886     if (p == NULL) {
 887         krb5_set_error_string(context, "malloc - out of memory");
 888         return NULL;
 889     }
 890     p1 = strchr(p, ':');
 891     if (p1)
 892         *p1 = '\0';
 893
 894     for(i = 0; i < context->num_cc_ops && context->cc_ops[i].prefix; i++) {
 895         if(strcmp(context->cc_ops[i].prefix, p) == 0) {
 896             free(p);
 897             return &context->cc_ops[i];
 898         }
 899     }
 900     free(p);
 901     return NULL;
 902 }
 903
 904 struct krb5_cc_cache_cursor_data {
 905     const krb5_cc_ops *ops;
 906     krb5_cc_cursor cursor;
 907 };
 908
 909 /**
 910  * Start iterating over all caches of `type'. If `type' is NULL, the
 911  * default type is * used. `cursor' is initialized to the beginning.
 912  *
 913  * @return Return 0 or an error code.
 914  *
 915  * @ingroup krb5_ccache
 916  */
 917
 918
 919 krb5_error_code KRB5_LIB_FUNCTION
 920 krb5_cc_cache_get_first (krb5_context context,
 921                          const char *type,
 922                          krb5_cc_cache_cursor *cursor)
 923 {
 924     const krb5_cc_ops *ops;
 925     krb5_error_code ret;
 926
 927     if (type == NULL)
 928         type = krb5_cc_default_name(context);
 929
 930     ops = krb5_cc_get_prefix_ops(context, type);
 931     if (ops == NULL) {
 932         krb5_set_error_string(context, "Unknown type \"%s\" when iterating "
 933                               "trying to iterate the credential caches", type);
 934         return KRB5_CC_UNKNOWN_TYPE;
 935     }
 936
 937     if (ops->get_cache_first == NULL) {
 938         krb5_set_error_string(context, "Credential cache type %s doesn't support "
 939                               "iterations over caches", ops->prefix);
 940         return KRB5_CC_NOSUPP;
 941     }
 942
 943     *cursor = calloc(1, sizeof(**cursor));
 944     if (*cursor == NULL) {
 945         krb5_set_error_string(context, "malloc - out of memory");
 946         return ENOMEM;
 947     }
 948
 949     (*cursor)->ops = ops;
 950
 951     ret = ops->get_cache_first(context, &(*cursor)->cursor);
 952     if (ret) {
 953         free(*cursor);
 954         *cursor = NULL;
 955     }
 956     return ret;
 957 }
 958
 959 /**
 960  * Retrieve the next cache pointed to by (`cursor') in `id'
 961  * and advance `cursor'.
 962  *
 963  * @return Return 0 or an error code.
 964  *
 965  * @ingroup krb5_ccache
 966  */
 967
 968
 969 krb5_error_code KRB5_LIB_FUNCTION
 970 krb5_cc_cache_next (krb5_context context,
 971                    krb5_cc_cache_cursor cursor,
 972                    krb5_ccache *id)
 973 {
 974     return cursor->ops->get_cache_next(context, cursor->cursor, id);
 975 }
 976
 977 /**
 978  * Destroy the cursor `cursor'.
 979  *
 980  * @return Return 0 or an error code.
 981  *
 982  * @ingroup krb5_ccache
 983  */
 984
 985
 986 krb5_error_code KRB5_LIB_FUNCTION
 987 krb5_cc_cache_end_seq_get (krb5_context context,
 988                            krb5_cc_cache_cursor cursor)
 989 {
 990     krb5_error_code ret;
 991     ret = cursor->ops->end_cache_get(context, cursor->cursor);
 992     cursor->ops = NULL;
 993     free(cursor);
 994     return ret;
 995 }
 996
 997 /**
 998  * Search for a matching credential cache of type `type' that have the
 999  * `principal' as the default principal. If NULL is used for `type',
1000  * the default type is used. On success, `id' needs to be freed with
1001  * krb5_cc_close or krb5_cc_destroy.
1002  *
1003  * @return On failure, error code is returned and `id' is set to NULL.
1004  *
1005  * @ingroup krb5_ccache
1006  */
1007
1008
1009 krb5_error_code KRB5_LIB_FUNCTION
1010 krb5_cc_cache_match (krb5_context context,
1011                      krb5_principal client,
1012                      const char *type,
1013                      krb5_ccache *id)
1014 {
1015     krb5_cc_cache_cursor cursor;
1016     krb5_error_code ret;
1017     krb5_ccache cache = NULL;
1018
1019     *id = NULL;
1020
1021     ret = krb5_cc_cache_get_first (context, type, &cursor);
1022     if (ret)
1023         return ret;
1024
1025     while ((ret = krb5_cc_cache_next (context, cursor, &cache)) == 0) {
1026         krb5_principal principal;
1027
1028         ret = krb5_cc_get_principal(context, cache, &principal);
1029         if (ret == 0) {
1030             krb5_boolean match;
1031
1032             match = krb5_principal_compare(context, principal, client);
1033             krb5_free_principal(context, principal);
1034             if (match)
1035                 break;
1036         }
1037
1038         krb5_cc_close(context, cache);
1039         cache = NULL;
1040     }
1041
1042     krb5_cc_cache_end_seq_get(context, cursor);
1043
1044     if (cache == NULL) {
1045         char *str;
1046
1047         krb5_unparse_name(context, client, &str);
1048
1049         krb5_set_error_string(context, "Principal %s not found in a "
1050                           "credential cache", str ? str : "<out of memory>");
1051         if (str)
1052             free(str);
1053         return KRB5_CC_NOTFOUND;
1054     }
1055     *id = cache;
1056
1057     return 0;
1058 }
1059
1060 /**
1061  * Move the content from one credential cache to another. The
1062  * operation is an atomic switch.
1063  *
1064  * @param context a Keberos context
1065  * @param from the credential cache to move the content from
1066  * @param to the credential cache to move the content to
1067
1068  * @return On sucess, from is freed. On failure, error code is
1069  * returned and from and to are both still allocated.
1070  *
1071  * @ingroup krb5_ccache
1072  */
1073
1074 krb5_error_code
1075 krb5_cc_move(krb5_context context, krb5_ccache from, krb5_ccache to)
1076 {
1077     krb5_error_code ret;
1078
1079     if (strcmp(from->ops->prefix, to->ops->prefix) != 0) {
1080         krb5_set_error_string(context, "Moving credentials between diffrent "
1081                               "types not yet supported");
1082         return KRB5_CC_NOSUPP;
1083     }
1084
1085     ret = (*to->ops->move)(context, from, to);
1086     if (ret == 0) {
1087         memset(from, 0, sizeof(*from));
1088         free(from);
1089     }
1090     return ret;
1091 }