source/heimdal/lib/krb5/context.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 #include <com_err.h>
  36
  37 RCSID("$Id: context.c 23420 2008-07-26 18:37:48Z lha $");
  38
  39 #define INIT_FIELD(C, T, E, D, F)                                       \
  40     (C)->E = krb5_config_get_ ## T ## _default ((C), NULL, (D),         \
  41                                                 "libdefaults", F, NULL)
  42
  43 #define INIT_FLAG(C, O, V, D, F)                                        \
  44     do {                                                                \
  45         if (krb5_config_get_bool_default((C), NULL, (D),"libdefaults", F, NULL)) { \
  46             (C)->O |= V;                                                \
  47         }                                                               \
  48     } while(0)
  49
  50 /*
  51  * Set the list of etypes `ret_etypes' from the configuration variable
  52  * `name'
  53  */
  54
  55 static krb5_error_code
  56 set_etypes (krb5_context context,
  57             const char *name,
  58             krb5_enctype **ret_enctypes)
  59 {
  60     char **etypes_str;
  61     krb5_enctype *etypes = NULL;
  62
  63     etypes_str = krb5_config_get_strings(context, NULL, "libdefaults",
  64                                          name, NULL);
  65     if(etypes_str){
  66         int i, j, k;
  67         for(i = 0; etypes_str[i]; i++);
  68         etypes = malloc((i+1) * sizeof(*etypes));
  69         if (etypes == NULL) {
  70             krb5_config_free_strings (etypes_str);
  71             krb5_set_error_message (context, ENOMEM, "malloc: out of memory");
  72             return ENOMEM;
  73         }
  74         for(j = 0, k = 0; j < i; j++) {
  75             krb5_enctype e;
  76             if(krb5_string_to_enctype(context, etypes_str[j], &e) != 0)
  77                 continue;
  78             if (krb5_enctype_valid(context, e) != 0)
  79                 continue;
  80             etypes[k++] = e;
  81         }
  82         etypes[k] = ETYPE_NULL;
  83         krb5_config_free_strings(etypes_str);
  84     }
  85     *ret_enctypes = etypes;
  86     return 0;
  87 }
  88
  89 /*
  90  * read variables from the configuration file and set in `context'
  91  */
  92
  93 static krb5_error_code
  94 init_context_from_config_file(krb5_context context)
  95 {
  96     krb5_error_code ret;
  97     const char * tmp;
  98     krb5_enctype *tmptypes;
  99
 100     INIT_FIELD(context, time, max_skew, 5 * 60, "clockskew");
 101     INIT_FIELD(context, time, kdc_timeout, 3, "kdc_timeout");
 102     INIT_FIELD(context, int, max_retries, 3, "max_retries");
 103
 104     INIT_FIELD(context, string, http_proxy, NULL, "http_proxy");
 105
 106     ret = set_etypes (context, "default_etypes", &tmptypes);
 107     if(ret)
 108         return ret;
 109     free(context->etypes);
 110     context->etypes = tmptypes;
 111
 112     ret = set_etypes (context, "default_etypes_des", &tmptypes);
 113     if(ret)
 114         return ret;
 115     free(context->etypes_des);
 116     context->etypes_des = tmptypes;
 117
 118     /* default keytab name */
 119     tmp = NULL;
 120     if(!issuid())
 121         tmp = getenv("KRB5_KTNAME");
 122     if(tmp != NULL)
 123         context->default_keytab = tmp;
 124     else
 125         INIT_FIELD(context, string, default_keytab,
 126                    KEYTAB_DEFAULT, "default_keytab_name");
 127
 128     INIT_FIELD(context, string, default_keytab_modify,
 129                NULL, "default_keytab_modify_name");
 130
 131     INIT_FIELD(context, string, time_fmt,
 132                "%Y-%m-%dT%H:%M:%S", "time_format");
 133
 134     INIT_FIELD(context, string, date_fmt,
 135                "%Y-%m-%d", "date_format");
 136
 137     INIT_FIELD(context, bool, log_utc,
 138                FALSE, "log_utc");
 139
 140
 141
 142     /* init dns-proxy slime */
 143     tmp = krb5_config_get_string(context, NULL, "libdefaults",
 144                                  "dns_proxy", NULL);
 145     if(tmp)
 146         roken_gethostby_setup(context->http_proxy, tmp);
 147     krb5_free_host_realm (context, context->default_realms);
 148     context->default_realms = NULL;
 149
 150     {
 151         krb5_addresses addresses;
 152         char **adr, **a;
 153
 154         krb5_set_extra_addresses(context, NULL);
 155         adr = krb5_config_get_strings(context, NULL,
 156                                       "libdefaults",
 157                                       "extra_addresses",
 158                                       NULL);
 159         memset(&addresses, 0, sizeof(addresses));
 160         for(a = adr; a && *a; a++) {
 161             ret = krb5_parse_address(context, *a, &addresses);
 162             if (ret == 0) {
 163                 krb5_add_extra_addresses(context, &addresses);
 164                 krb5_free_addresses(context, &addresses);
 165             }
 166         }
 167         krb5_config_free_strings(adr);
 168
 169         krb5_set_ignore_addresses(context, NULL);
 170         adr = krb5_config_get_strings(context, NULL,
 171                                       "libdefaults",
 172                                       "ignore_addresses",
 173                                       NULL);
 174         memset(&addresses, 0, sizeof(addresses));
 175         for(a = adr; a && *a; a++) {
 176             ret = krb5_parse_address(context, *a, &addresses);
 177             if (ret == 0) {
 178                 krb5_add_ignore_addresses(context, &addresses);
 179                 krb5_free_addresses(context, &addresses);
 180             }
 181         }
 182         krb5_config_free_strings(adr);
 183     }
 184
 185     INIT_FIELD(context, bool, scan_interfaces, TRUE, "scan_interfaces");
 186     INIT_FIELD(context, int, fcache_vno, 0, "fcache_version");
 187     /* prefer dns_lookup_kdc over srv_lookup. */
 188     INIT_FIELD(context, bool, srv_lookup, TRUE, "srv_lookup");
 189     INIT_FIELD(context, bool, srv_lookup, context->srv_lookup, "dns_lookup_kdc");
 190     INIT_FIELD(context, int, large_msg_size, 1400, "large_message_size");
 191     INIT_FLAG(context, flags, KRB5_CTX_F_DNS_CANONICALIZE_HOSTNAME, TRUE, "dns_canonicalize_hostname");
 192     INIT_FLAG(context, flags, KRB5_CTX_F_CHECK_PAC, TRUE, "check_pac");
 193     context->default_cc_name = NULL;
 194     context->default_cc_name_set = 0;
 195     return 0;
 196 }
 197
 198 /**
 199  * Initializes the context structure and reads the configuration file
 200  * /etc/krb5.conf. The structure should be freed by calling
 201  * krb5_free_context() when it is no longer being used.
 202  *
 203  * @param context pointer to returned context
 204  *
 205  * @return Returns 0 to indicate success.  Otherwise an errno code is
 206  * returned.  Failure means either that something bad happened during
 207  * initialization (typically ENOMEM) or that Kerberos should not be
 208  * used ENXIO.
 209  *
 210  * @ingroup krb5
 211  */
 212
 213 krb5_error_code KRB5_LIB_FUNCTION
 214 krb5_init_context(krb5_context *context)
 215 {
 216     krb5_context p;
 217     krb5_error_code ret;
 218     char **files;
 219
 220     *context = NULL;
 221
 222     p = calloc(1, sizeof(*p));
 223     if(!p)
 224         return ENOMEM;
 225
 226     p->mutex = malloc(sizeof(HEIMDAL_MUTEX));
 227     if (p->mutex == NULL) {
 228         free(p);
 229         return ENOMEM;
 230     }
 231     HEIMDAL_MUTEX_init(p->mutex);
 232
 233     ret = krb5_get_default_config_files(&files);
 234     if(ret)
 235         goto out;
 236     ret = krb5_set_config_files(p, files);
 237     krb5_free_config_files(files);
 238     if(ret)
 239         goto out;
 240
 241     /* init error tables */
 242     krb5_init_ets(p);
 243
 244     p->cc_ops = NULL;
 245     p->num_cc_ops = 0;
 246     krb5_cc_register(p, &krb5_acc_ops, TRUE);
 247     krb5_cc_register(p, &krb5_fcc_ops, TRUE);
 248     krb5_cc_register(p, &krb5_mcc_ops, TRUE);
 249     krb5_cc_register(p, &krb5_scc_ops, TRUE);
 250 #ifdef HAVE_KCM
 251     krb5_cc_register(p, &krb5_kcm_ops, TRUE);
 252 #endif
 253
 254     p->num_kt_types = 0;
 255     p->kt_types     = NULL;
 256     krb5_kt_register (p, &krb5_fkt_ops);
 257     krb5_kt_register (p, &krb5_wrfkt_ops);
 258     krb5_kt_register (p, &krb5_javakt_ops);
 259     krb5_kt_register (p, &krb5_mkt_ops);
 260     krb5_kt_register (p, &krb5_akf_ops);
 261     krb5_kt_register (p, &krb5_any_ops);
 262
 263 out:
 264     if(ret) {
 265         krb5_free_context(p);
 266         p = NULL;
 267     }
 268     *context = p;
 269     return ret;
 270 }
 271
 272 /**
 273  * Frees the krb5_context allocated by krb5_init_context().
 274  *
 275  * @param context context to be freed.
 276  *
 277  *  @ingroup krb5
 278 */
 279
 280 void KRB5_LIB_FUNCTION
 281 krb5_free_context(krb5_context context)
 282 {
 283     if (context->default_cc_name)
 284         free(context->default_cc_name);
 285     if (context->default_cc_name_env)
 286         free(context->default_cc_name_env);
 287     free(context->etypes);
 288     free(context->etypes_des);
 289     krb5_free_host_realm (context, context->default_realms);
 290     krb5_config_file_free (context, context->cf);
 291     free_error_table (context->et_list);
 292     free(context->cc_ops);
 293     free(context->kt_types);
 294     krb5_clear_error_string(context);
 295     if(context->warn_dest != NULL)
 296         krb5_closelog(context, context->warn_dest);
 297     krb5_set_extra_addresses(context, NULL);
 298     krb5_set_ignore_addresses(context, NULL);
 299     krb5_set_send_to_kdc_func(context, NULL, NULL);
 300     if (context->mutex != NULL) {
 301         HEIMDAL_MUTEX_destroy(context->mutex);
 302         free(context->mutex);
 303     }
 304     memset(context, 0, sizeof(*context));
 305     free(context);
 306 }
 307
 308 /**
 309  * Reinit the context from a new set of filenames.
 310  *
 311  * @param context context to add configuration too.
 312  * @param filenames array of filenames, end of list is indicated with a NULL filename.
 313  *
 314  * @return Returns 0 to indicate success.  Otherwise an kerberos et
 315  * error code is returned, see krb5_get_error_message().
 316  *
 317  * @ingroup krb5
 318  */
 319
 320 krb5_error_code KRB5_LIB_FUNCTION
 321 krb5_set_config_files(krb5_context context, char **filenames)
 322 {
 323     krb5_error_code ret;
 324     krb5_config_binding *tmp = NULL;
 325     while(filenames != NULL && *filenames != NULL && **filenames != '\0') {
 326         ret = krb5_config_parse_file_multi(context, *filenames, &tmp);
 327         if(ret != 0 && ret != ENOENT && ret != EACCES) {
 328             krb5_config_file_free(context, tmp);
 329             return ret;
 330         }
 331         filenames++;
 332     }
 333 #if 0
 334     /* with this enabled and if there are no config files, Kerberos is
 335        considererd disabled */
 336     if(tmp == NULL)
 337         return ENXIO;
 338 #endif
 339     krb5_config_file_free(context, context->cf);
 340     context->cf = tmp;
 341     ret = init_context_from_config_file(context);
 342     return ret;
 343 }
 344
 345 static krb5_error_code
 346 add_file(char ***pfilenames, int *len, char *file)
 347 {
 348     char **pp = *pfilenames;
 349     int i;
 350
 351     for(i = 0; i < *len; i++) {
 352         if(strcmp(pp[i], file) == 0) {
 353             free(file);
 354             return 0;
 355         }
 356     }
 357
 358     pp = realloc(*pfilenames, (*len + 2) * sizeof(*pp));
 359     if (pp == NULL) {
 360         free(file);
 361         return ENOMEM;
 362     }
 363
 364     pp[*len] = file;
 365     pp[*len + 1] = NULL;
 366     *pfilenames = pp;
 367     *len += 1;
 368     return 0;
 369 }
 370
 371 /*
 372  *  `pq' isn't free, it's up the the caller
 373  */
 374
 375 krb5_error_code KRB5_LIB_FUNCTION
 376 krb5_prepend_config_files(const char *filelist, char **pq, char ***ret_pp)
 377 {
 378     krb5_error_code ret;
 379     const char *p, *q;
 380     char **pp;
 381     int len;
 382     char *fn;
 383
 384     pp = NULL;
 385
 386     len = 0;
 387     p = filelist;
 388     while(1) {
 389         ssize_t l;
 390         q = p;
 391         l = strsep_copy(&q, ":", NULL, 0);
 392         if(l == -1)
 393             break;
 394         fn = malloc(l + 1);
 395         if(fn == NULL) {
 396             krb5_free_config_files(pp);
 397             return ENOMEM;
 398         }
 399         l = strsep_copy(&p, ":", fn, l + 1);
 400         ret = add_file(&pp, &len, fn);
 401         if (ret) {
 402             krb5_free_config_files(pp);
 403             return ret;
 404         }
 405     }
 406
 407     if (pq != NULL) {
 408         int i;
 409
 410         for (i = 0; pq[i] != NULL; i++) {
 411             fn = strdup(pq[i]);
 412             if (fn == NULL) {
 413                 krb5_free_config_files(pp);
 414                 return ENOMEM;
 415             }
 416             ret = add_file(&pp, &len, fn);
 417             if (ret) {
 418                 krb5_free_config_files(pp);
 419                 return ret;
 420             }
 421         }
 422     }
 423
 424     *ret_pp = pp;
 425     return 0;
 426 }
 427
 428 /**
 429  * Prepend the filename to the global configuration list.
 430  *
 431  * @param filelist a filename to add to the default list of filename
 432  * @param pfilenames return array of filenames, should be freed with krb5_free_config_files().
 433  *
 434  * @return Returns 0 to indicate success.  Otherwise an kerberos et
 435  * error code is returned, see krb5_get_error_message().
 436  *
 437  * @ingroup krb5
 438  */
 439
 440 krb5_error_code KRB5_LIB_FUNCTION
 441 krb5_prepend_config_files_default(const char *filelist, char ***pfilenames)
 442 {
 443     krb5_error_code ret;
 444     char **defpp, **pp = NULL;
 445
 446     ret = krb5_get_default_config_files(&defpp);
 447     if (ret)
 448         return ret;
 449
 450     ret = krb5_prepend_config_files(filelist, defpp, &pp);
 451     krb5_free_config_files(defpp);
 452     if (ret) {
 453         return ret;
 454     }
 455     *pfilenames = pp;
 456     return 0;
 457 }
 458
 459 /**
 460  * Get the global configuration list.
 461  *
 462  * @param pfilenames return array of filenames, should be freed with krb5_free_config_files().
 463  *
 464  * @return Returns 0 to indicate success.  Otherwise an kerberos et
 465  * error code is returned, see krb5_get_error_message().
 466  *
 467  * @ingroup krb5
 468  */
 469
 470 krb5_error_code KRB5_LIB_FUNCTION
 471 krb5_get_default_config_files(char ***pfilenames)
 472 {
 473     const char *files = NULL;
 474
 475     if (pfilenames == NULL)
 476         return EINVAL;
 477     if(!issuid())
 478         files = getenv("KRB5_CONFIG");
 479     if (files == NULL)
 480         files = krb5_config_file;
 481
 482     return krb5_prepend_config_files(files, NULL, pfilenames);
 483 }
 484
 485 /**
 486  * Free a list of configuration files.
 487  *
 488  * @param filenames list to be freed.
 489  *
 490  * @return Returns 0 to indicate success. Otherwise an kerberos et
 491  * error code is returned, see krb5_get_error_message().
 492  *
 493  * @ingroup krb5
 494  */
 495
 496 void KRB5_LIB_FUNCTION
 497 krb5_free_config_files(char **filenames)
 498 {
 499     char **p;
 500     for(p = filenames; *p != NULL; p++)
 501         free(*p);
 502     free(filenames);
 503 }
 504
 505 /**
 506  * Returns the list of Kerberos encryption types sorted in order of
 507  * most preferred to least preferred encryption type.  Note that some
 508  * encryption types might be disabled, so you need to check with
 509  * krb5_enctype_valid() before using the encryption type.
 510  *
 511  * @return list of enctypes, terminated with ETYPE_NULL. Its a static
 512  * array completed into the Kerberos library so the content doesn't
 513  * need to be freed.
 514  *
 515  * @ingroup krb5
 516  */
 517
 518 const krb5_enctype * KRB5_LIB_FUNCTION
 519 krb5_kerberos_enctypes(krb5_context context)
 520 {
 521     static const krb5_enctype p[] = {
 522         ETYPE_AES256_CTS_HMAC_SHA1_96,
 523         ETYPE_AES128_CTS_HMAC_SHA1_96,
 524         ETYPE_DES3_CBC_SHA1,
 525         ETYPE_DES3_CBC_MD5,
 526         ETYPE_ARCFOUR_HMAC_MD5,
 527         ETYPE_DES_CBC_MD5,
 528         ETYPE_DES_CBC_MD4,
 529         ETYPE_DES_CBC_CRC,
 530         ETYPE_NULL
 531     };
 532     return p;
 533 }
 534
 535 /*
 536  * set `etype' to a malloced list of the default enctypes
 537  */
 538
 539 static krb5_error_code
 540 default_etypes(krb5_context context, krb5_enctype **etype)
 541 {
 542     const krb5_enctype *p;
 543     krb5_enctype *e = NULL, *ep;
 544     int i, n = 0;
 545
 546     p = krb5_kerberos_enctypes(context);
 547
 548     for (i = 0; p[i] != ETYPE_NULL; i++) {
 549         if (krb5_enctype_valid(context, p[i]) != 0)
 550             continue;
 551         ep = realloc(e, (n + 2) * sizeof(*e));
 552         if (ep == NULL) {
 553             free(e);
 554             krb5_set_error_message (context, ENOMEM, "malloc: out of memory");
 555             return ENOMEM;
 556         }
 557         e = ep;
 558         e[n] = p[i];
 559         e[n + 1] = ETYPE_NULL;
 560         n++;
 561     }
 562     *etype = e;
 563     return 0;
 564 }
 565
 566 /**
 567  * Set the default encryption types that will be use in communcation
 568  * with the KDC, clients and servers.
 569  *
 570  * @param context Kerberos 5 context.
 571  * @param etypes Encryption types, array terminated with ETYPE_NULL (0).
 572  *
 573  * @return Returns 0 to indicate success. Otherwise an kerberos et
 574  * error code is returned, see krb5_get_error_message().
 575  *
 576  * @ingroup krb5
 577  */
 578
 579 krb5_error_code KRB5_LIB_FUNCTION
 580 krb5_set_default_in_tkt_etypes(krb5_context context,
 581                                const krb5_enctype *etypes)
 582 {
 583     krb5_enctype *p = NULL;
 584     int i;
 585
 586     if(etypes) {
 587         for (i = 0; etypes[i]; ++i) {
 588             krb5_error_code ret;
 589             ret = krb5_enctype_valid(context, etypes[i]);
 590             if (ret)
 591                 return ret;
 592         }
 593         ++i;
 594         ALLOC(p, i);
 595         if(!p) {
 596             krb5_set_error_message (context, ENOMEM, "malloc: out of memory");
 597             return ENOMEM;
 598         }
 599         memmove(p, etypes, i * sizeof(krb5_enctype));
 600     }
 601     if(context->etypes)
 602         free(context->etypes);
 603     context->etypes = p;
 604     return 0;
 605 }
 606
 607 /**
 608  * Get the default encryption types that will be use in communcation
 609  * with the KDC, clients and servers.
 610  *
 611  * @param context Kerberos 5 context.
 612  * @param etypes Encryption types, array terminated with
 613  * ETYPE_NULL(0), caller should free array with krb5_xfree():
 614  *
 615  * @return Returns 0 to indicate success. Otherwise an kerberos et
 616  * error code is returned, see krb5_get_error_message().
 617  *
 618  * @ingroup krb5
 619  */
 620
 621 krb5_error_code KRB5_LIB_FUNCTION
 622 krb5_get_default_in_tkt_etypes(krb5_context context,
 623                                krb5_enctype **etypes)
 624 {
 625     krb5_enctype *p;
 626     int i;
 627     krb5_error_code ret;
 628
 629     if(context->etypes) {
 630         for(i = 0; context->etypes[i]; i++);
 631         ++i;
 632         ALLOC(p, i);
 633         if(!p) {
 634             krb5_set_error_message (context, ENOMEM, "malloc: out of memory");
 635             return ENOMEM;
 636         }
 637         memmove(p, context->etypes, i * sizeof(krb5_enctype));
 638     } else {
 639         ret = default_etypes(context, &p);
 640         if (ret)
 641             return ret;
 642     }
 643     *etypes = p;
 644     return 0;
 645 }
 646
 647 /**
 648  * Return the error string for the error code. The caller must not
 649  * free the string.
 650  *
 651  * @param context Kerberos 5 context.
 652  * @param code Kerberos error code.
 653  *
 654  * @return the error message matching code
 655  *
 656  * @ingroup krb5
 657  */
 658
 659 const char* KRB5_LIB_FUNCTION
 660 krb5_get_err_text(krb5_context context, krb5_error_code code)
 661 {
 662     const char *p = NULL;
 663     if(context != NULL)
 664         p = com_right(context->et_list, code);
 665     if(p == NULL)
 666         p = strerror(code);
 667     if (p == NULL)
 668         p = "Unknown error";
 669     return p;
 670 }
 671
 672 /**
 673  * Init the built-in ets in the Kerberos library.
 674  *
 675  * @param context kerberos context to add the ets too
 676  *
 677  * @ingroup krb5
 678  */
 679
 680 void KRB5_LIB_FUNCTION
 681 krb5_init_ets(krb5_context context)
 682 {
 683     if(context->et_list == NULL){
 684         krb5_add_et_list(context, initialize_krb5_error_table_r);
 685         krb5_add_et_list(context, initialize_asn1_error_table_r);
 686         krb5_add_et_list(context, initialize_heim_error_table_r);
 687         krb5_add_et_list(context, initialize_k524_error_table_r);
 688 #ifdef PKINIT
 689         krb5_add_et_list(context, initialize_hx_error_table_r);
 690 #endif
 691     }
 692 }
 693
 694 /**
 695  * Make the kerberos library default to the admin KDC.
 696  *
 697  * @param context Kerberos 5 context.
 698  * @param flag boolean flag to select if the use the admin KDC or not.
 699  *
 700  * @ingroup krb5
 701  */
 702
 703 void KRB5_LIB_FUNCTION
 704 krb5_set_use_admin_kdc (krb5_context context, krb5_boolean flag)
 705 {
 706     context->use_admin_kdc = flag;
 707 }
 708
 709 /**
 710  * Make the kerberos library default to the admin KDC.
 711  *
 712  * @param context Kerberos 5 context.
 713  *
 714  * @return boolean flag to telling the context will use admin KDC as the default KDC.
 715  *
 716  * @ingroup krb5
 717  */
 718
 719 krb5_boolean KRB5_LIB_FUNCTION
 720 krb5_get_use_admin_kdc (krb5_context context)
 721 {
 722     return context->use_admin_kdc;
 723 }
 724
 725 /**
 726  * Add extra address to the address list that the library will add to
 727  * the client's address list when communicating with the KDC.
 728  *
 729  * @param context Kerberos 5 context.
 730  * @param addresses addreses to add
 731  *
 732  * @return Returns 0 to indicate success. Otherwise an kerberos et
 733  * error code is returned, see krb5_get_error_message().
 734  *
 735  * @ingroup krb5
 736  */
 737
 738 krb5_error_code KRB5_LIB_FUNCTION
 739 krb5_add_extra_addresses(krb5_context context, krb5_addresses *addresses)
 740 {
 741
 742     if(context->extra_addresses)
 743         return krb5_append_addresses(context,
 744                                      context->extra_addresses, addresses);
 745     else
 746         return krb5_set_extra_addresses(context, addresses);
 747 }
 748
 749 /**
 750  * Set extra address to the address list that the library will add to
 751  * the client's address list when communicating with the KDC.
 752  *
 753  * @param context Kerberos 5 context.
 754  * @param addresses addreses to set
 755  *
 756  * @return Returns 0 to indicate success. Otherwise an kerberos et
 757  * error code is returned, see krb5_get_error_message().
 758  *
 759  * @ingroup krb5
 760  */
 761
 762 krb5_error_code KRB5_LIB_FUNCTION
 763 krb5_set_extra_addresses(krb5_context context, const krb5_addresses *addresses)
 764 {
 765     if(context->extra_addresses)
 766         krb5_free_addresses(context, context->extra_addresses);
 767
 768     if(addresses == NULL) {
 769         if(context->extra_addresses != NULL) {
 770             free(context->extra_addresses);
 771             context->extra_addresses = NULL;
 772         }
 773         return 0;
 774     }
 775     if(context->extra_addresses == NULL) {
 776         context->extra_addresses = malloc(sizeof(*context->extra_addresses));
 777         if(context->extra_addresses == NULL) {
 778             krb5_set_error_message (context, ENOMEM, "malloc: out of memory");
 779             return ENOMEM;
 780         }
 781     }
 782     return krb5_copy_addresses(context, addresses, context->extra_addresses);
 783 }
 784
 785 /**
 786  * Get extra address to the address list that the library will add to
 787  * the client's address list when communicating with the KDC.
 788  *
 789  * @param context Kerberos 5 context.
 790  * @param addresses addreses to set
 791  *
 792  * @return Returns 0 to indicate success. Otherwise an kerberos et
 793  * error code is returned, see krb5_get_error_message().
 794  *
 795  * @ingroup krb5
 796  */
 797
 798 krb5_error_code KRB5_LIB_FUNCTION
 799 krb5_get_extra_addresses(krb5_context context, krb5_addresses *addresses)
 800 {
 801     if(context->extra_addresses == NULL) {
 802         memset(addresses, 0, sizeof(*addresses));
 803         return 0;
 804     }
 805     return krb5_copy_addresses(context,context->extra_addresses, addresses);
 806 }
 807
 808 /**
 809  * Add extra addresses to ignore when fetching addresses from the
 810  * underlaying operating system.
 811  *
 812  * @param context Kerberos 5 context.
 813  * @param addresses addreses to ignore
 814  *
 815  * @return Returns 0 to indicate success. Otherwise an kerberos et
 816  * error code is returned, see krb5_get_error_message().
 817  *
 818  * @ingroup krb5
 819  */
 820
 821 krb5_error_code KRB5_LIB_FUNCTION
 822 krb5_add_ignore_addresses(krb5_context context, krb5_addresses *addresses)
 823 {
 824
 825     if(context->ignore_addresses)
 826         return krb5_append_addresses(context,
 827                                      context->ignore_addresses, addresses);
 828     else
 829         return krb5_set_ignore_addresses(context, addresses);
 830 }
 831
 832 /**
 833  * Set extra addresses to ignore when fetching addresses from the
 834  * underlaying operating system.
 835  *
 836  * @param context Kerberos 5 context.
 837  * @param addresses addreses to ignore
 838  *
 839  * @return Returns 0 to indicate success. Otherwise an kerberos et
 840  * error code is returned, see krb5_get_error_message().
 841  *
 842  * @ingroup krb5
 843  */
 844
 845 krb5_error_code KRB5_LIB_FUNCTION
 846 krb5_set_ignore_addresses(krb5_context context, const krb5_addresses *addresses)
 847 {
 848     if(context->ignore_addresses)
 849         krb5_free_addresses(context, context->ignore_addresses);
 850     if(addresses == NULL) {
 851         if(context->ignore_addresses != NULL) {
 852             free(context->ignore_addresses);
 853             context->ignore_addresses = NULL;
 854         }
 855         return 0;
 856     }
 857     if(context->ignore_addresses == NULL) {
 858         context->ignore_addresses = malloc(sizeof(*context->ignore_addresses));
 859         if(context->ignore_addresses == NULL) {
 860             krb5_set_error_message (context, ENOMEM, "malloc: out of memory");
 861             return ENOMEM;
 862         }
 863     }
 864     return krb5_copy_addresses(context, addresses, context->ignore_addresses);
 865 }
 866
 867 /**
 868  * Get extra addresses to ignore when fetching addresses from the
 869  * underlaying operating system.
 870  *
 871  * @param context Kerberos 5 context.
 872  * @param addresses list addreses ignored
 873  *
 874  * @return Returns 0 to indicate success. Otherwise an kerberos et
 875  * error code is returned, see krb5_get_error_message().
 876  *
 877  * @ingroup krb5
 878  */
 879
 880 krb5_error_code KRB5_LIB_FUNCTION
 881 krb5_get_ignore_addresses(krb5_context context, krb5_addresses *addresses)
 882 {
 883     if(context->ignore_addresses == NULL) {
 884         memset(addresses, 0, sizeof(*addresses));
 885         return 0;
 886     }
 887     return krb5_copy_addresses(context, context->ignore_addresses, addresses);
 888 }
 889
 890 /**
 891  * Set version of fcache that the library should use.
 892  *
 893  * @param context Kerberos 5 context.
 894  * @param version version number.
 895  *
 896  * @return Returns 0 to indicate success. Otherwise an kerberos et
 897  * error code is returned, see krb5_get_error_message().
 898  *
 899  * @ingroup krb5
 900  */
 901
 902 krb5_error_code KRB5_LIB_FUNCTION
 903 krb5_set_fcache_version(krb5_context context, int version)
 904 {
 905     context->fcache_vno = version;
 906     return 0;
 907 }
 908
 909 /**
 910  * Get version of fcache that the library should use.
 911  *
 912  * @param context Kerberos 5 context.
 913  * @param version version number.
 914  *
 915  * @return Returns 0 to indicate success. Otherwise an kerberos et
 916  * error code is returned, see krb5_get_error_message().
 917  *
 918  * @ingroup krb5
 919  */
 920
 921 krb5_error_code KRB5_LIB_FUNCTION
 922 krb5_get_fcache_version(krb5_context context, int *version)
 923 {
 924     *version = context->fcache_vno;
 925     return 0;
 926 }
 927
 928 /**
 929  * Runtime check if the Kerberos library was complied with thread support.
 930  *
 931  * @return TRUE if the library was compiled with thread support, FALSE if not.
 932  *
 933  * @ingroup krb5
 934  */
 935
 936
 937 krb5_boolean KRB5_LIB_FUNCTION
 938 krb5_is_thread_safe(void)
 939 {
 940 #ifdef ENABLE_PTHREAD_SUPPORT
 941     return TRUE;
 942 #else
 943     return FALSE;
 944 #endif
 945 }
 946
 947 /**
 948  * Set if the library should use DNS to canonicalize hostnames.
 949  *
 950  * @param context Kerberos 5 context.
 951  * @param flag if its dns canonicalizion is used or not.
 952  *
 953  * @ingroup krb5
 954  */
 955
 956 void KRB5_LIB_FUNCTION
 957 krb5_set_dns_canonicalize_hostname (krb5_context context, krb5_boolean flag)
 958 {
 959     if (flag)
 960         context->flags |= KRB5_CTX_F_DNS_CANONICALIZE_HOSTNAME;
 961     else
 962         context->flags &= ~KRB5_CTX_F_DNS_CANONICALIZE_HOSTNAME;
 963 }
 964
 965 /**
 966  * Get if the library uses DNS to canonicalize hostnames.
 967  *
 968  * @param context Kerberos 5 context.
 969  *
 970  * @return return non zero if the library uses DNS to canonicalize hostnames.
 971  *
 972  * @ingroup krb5
 973  */
 974
 975 krb5_boolean KRB5_LIB_FUNCTION
 976 krb5_get_dns_canonicalize_hostname (krb5_context context)
 977 {
 978     return (context->flags & KRB5_CTX_F_DNS_CANONICALIZE_HOSTNAME) ? 1 : 0;
 979 }
 980
 981 /**
 982  * Get current offset in time to the KDC.
 983  *
 984  * @param context Kerberos 5 context.
 985  * @param sec seconds part of offset.
 986  * @param usec micro seconds part of offset.
 987  *
 988  * @return returns zero
 989  *
 990  * @ingroup krb5
 991  */
 992
 993 krb5_error_code KRB5_LIB_FUNCTION
 994 krb5_get_kdc_sec_offset (krb5_context context, int32_t *sec, int32_t *usec)
 995 {
 996     if (sec)
 997         *sec = context->kdc_sec_offset;
 998     if (usec)
 999         *usec = context->kdc_usec_offset;
1000     return 0;
1001 }
1002
1003 /**
1004  * Set current offset in time to the KDC.
1005  *
1006  * @param context Kerberos 5 context.
1007  * @param sec seconds part of offset.
1008  * @param usec micro seconds part of offset.
1009  *
1010  * @return returns zero
1011  *
1012  * @ingroup krb5
1013  */
1014
1015 krb5_error_code KRB5_LIB_FUNCTION
1016 krb5_set_kdc_sec_offset (krb5_context context, int32_t sec, int32_t usec)
1017 {
1018     context->kdc_sec_offset = sec;
1019     if (usec >= 0)
1020         context->kdc_usec_offset = usec;
1021     return 0;
1022 }
1023
1024 /**
1025  * Get max time skew allowed.
1026  *
1027  * @param context Kerberos 5 context.
1028  *
1029  * @return timeskew in seconds.
1030  *
1031  * @ingroup krb5
1032  */
1033
1034 time_t KRB5_LIB_FUNCTION
1035 krb5_get_max_time_skew (krb5_context context)
1036 {
1037     return context->max_skew;
1038 }
1039
1040 /**
1041  * Set max time skew allowed.
1042  *
1043  * @param context Kerberos 5 context.
1044  * @param t timeskew in seconds.
1045  *
1046  * @ingroup krb5
1047  */
1048
1049 void KRB5_LIB_FUNCTION
1050 krb5_set_max_time_skew (krb5_context context, time_t t)
1051 {
1052     context->max_skew = t;
1053 }