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,v 1.110 2006/11/04 03:27:47 lha Exp $");
  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 /*
  44  * Set the list of etypes `ret_etypes' from the configuration variable
  45  * `name'
  46  */
  47
  48 static krb5_error_code
  49 set_etypes (krb5_context context,
  50             const char *name,
  51             krb5_enctype **ret_enctypes)
  52 {
  53     char **etypes_str;
  54     krb5_enctype *etypes = NULL;
  55
  56     etypes_str = krb5_config_get_strings(context, NULL, "libdefaults",
  57                                          name, NULL);
  58     if(etypes_str){
  59         int i, j, k;
  60         for(i = 0; etypes_str[i]; i++);
  61         etypes = malloc((i+1) * sizeof(*etypes));
  62         if (etypes == NULL) {
  63             krb5_config_free_strings (etypes_str);
  64             krb5_set_error_string (context, "malloc: out of memory");
  65             return ENOMEM;
  66         }
  67         for(j = 0, k = 0; j < i; j++) {
  68             krb5_enctype e;
  69             if(krb5_string_to_enctype(context, etypes_str[j], &e) != 0)
  70                 continue;
  71             if (krb5_enctype_valid(context, e) != 0)
  72                 continue;
  73             etypes[k++] = e;
  74         }
  75         etypes[k] = ETYPE_NULL;
  76         krb5_config_free_strings(etypes_str);
  77     }
  78     *ret_enctypes = etypes;
  79     return 0;
  80 }
  81
  82 /*
  83  * read variables from the configuration file and set in `context'
  84  */
  85
  86 static krb5_error_code
  87 init_context_from_config_file(krb5_context context)
  88 {
  89     krb5_error_code ret;
  90     const char * tmp;
  91     krb5_enctype *tmptypes;
  92
  93     INIT_FIELD(context, time, max_skew, 5 * 60, "clockskew");
  94     INIT_FIELD(context, time, kdc_timeout, 3, "kdc_timeout");
  95     INIT_FIELD(context, int, max_retries, 3, "max_retries");
  96
  97     INIT_FIELD(context, string, http_proxy, NULL, "http_proxy");
  98
  99     ret = set_etypes (context, "default_etypes", &tmptypes);
 100     if(ret)
 101         return ret;
 102     free(context->etypes);
 103     context->etypes = tmptypes;
 104
 105     ret = set_etypes (context, "default_etypes_des", &tmptypes);
 106     if(ret)
 107         return ret;
 108     free(context->etypes_des);
 109     context->etypes_des = tmptypes;
 110
 111     /* default keytab name */
 112     tmp = NULL;
 113     if(!issuid())
 114         tmp = getenv("KRB5_KTNAME");
 115     if(tmp != NULL)
 116         context->default_keytab = tmp;
 117     else
 118         INIT_FIELD(context, string, default_keytab,
 119                    KEYTAB_DEFAULT, "default_keytab_name");
 120
 121     INIT_FIELD(context, string, default_keytab_modify,
 122                NULL, "default_keytab_modify_name");
 123
 124     INIT_FIELD(context, string, time_fmt,
 125                "%Y-%m-%dT%H:%M:%S", "time_format");
 126
 127     INIT_FIELD(context, string, date_fmt,
 128                "%Y-%m-%d", "date_format");
 129
 130     INIT_FIELD(context, bool, log_utc,
 131                FALSE, "log_utc");
 132
 133
 134
 135     /* init dns-proxy slime */
 136     tmp = krb5_config_get_string(context, NULL, "libdefaults",
 137                                  "dns_proxy", NULL);
 138     if(tmp)
 139         roken_gethostby_setup(context->http_proxy, tmp);
 140     krb5_free_host_realm (context, context->default_realms);
 141     context->default_realms = NULL;
 142
 143     {
 144         krb5_addresses addresses;
 145         char **adr, **a;
 146
 147         krb5_set_extra_addresses(context, NULL);
 148         adr = krb5_config_get_strings(context, NULL,
 149                                       "libdefaults",
 150                                       "extra_addresses",
 151                                       NULL);
 152         memset(&addresses, 0, sizeof(addresses));
 153         for(a = adr; a && *a; a++) {
 154             ret = krb5_parse_address(context, *a, &addresses);
 155             if (ret == 0) {
 156                 krb5_add_extra_addresses(context, &addresses);
 157                 krb5_free_addresses(context, &addresses);
 158             }
 159         }
 160         krb5_config_free_strings(adr);
 161
 162         krb5_set_ignore_addresses(context, NULL);
 163         adr = krb5_config_get_strings(context, NULL,
 164                                       "libdefaults",
 165                                       "ignore_addresses",
 166                                       NULL);
 167         memset(&addresses, 0, sizeof(addresses));
 168         for(a = adr; a && *a; a++) {
 169             ret = krb5_parse_address(context, *a, &addresses);
 170             if (ret == 0) {
 171                 krb5_add_ignore_addresses(context, &addresses);
 172                 krb5_free_addresses(context, &addresses);
 173             }
 174         }
 175         krb5_config_free_strings(adr);
 176     }
 177
 178     INIT_FIELD(context, bool, scan_interfaces, TRUE, "scan_interfaces");
 179     INIT_FIELD(context, int, fcache_vno, 0, "fcache_version");
 180     /* prefer dns_lookup_kdc over srv_lookup. */
 181     INIT_FIELD(context, bool, srv_lookup, TRUE, "srv_lookup");
 182     INIT_FIELD(context, bool, srv_lookup, context->srv_lookup, "dns_lookup_kdc");
 183     INIT_FIELD(context, int, large_msg_size, 6000, "large_message_size");
 184     INIT_FIELD(context, bool, dns_canonicalize_hostname, TRUE, "dns_canonicalize_hostname");
 185     context->default_cc_name = NULL;
 186     return 0;
 187 }
 188
 189 krb5_error_code KRB5_LIB_FUNCTION
 190 krb5_init_context(krb5_context *context)
 191 {
 192     krb5_context p;
 193     krb5_error_code ret;
 194     char **files;
 195
 196     *context = NULL;
 197
 198     p = calloc(1, sizeof(*p));
 199     if(!p)
 200         return ENOMEM;
 201
 202     p->mutex = malloc(sizeof(HEIMDAL_MUTEX));
 203     if (p->mutex == NULL) {
 204         free(p);
 205         return ENOMEM;
 206     }
 207     HEIMDAL_MUTEX_init(p->mutex);
 208
 209     ret = krb5_get_default_config_files(&files);
 210     if(ret)
 211         goto out;
 212     ret = krb5_set_config_files(p, files);
 213     krb5_free_config_files(files);
 214     if(ret)
 215         goto out;
 216
 217     /* init error tables */
 218     krb5_init_ets(p);
 219
 220     p->cc_ops = NULL;
 221     p->num_cc_ops = 0;
 222     krb5_cc_register(p, &krb5_acc_ops, TRUE);
 223     krb5_cc_register(p, &krb5_fcc_ops, TRUE);
 224     krb5_cc_register(p, &krb5_mcc_ops, TRUE);
 225 #ifdef HAVE_KCM
 226     krb5_cc_register(p, &krb5_kcm_ops, TRUE);
 227 #endif
 228
 229     p->num_kt_types = 0;
 230     p->kt_types     = NULL;
 231     krb5_kt_register (p, &krb5_fkt_ops);
 232     krb5_kt_register (p, &krb5_wrfkt_ops);
 233     krb5_kt_register (p, &krb5_javakt_ops);
 234     krb5_kt_register (p, &krb5_mkt_ops);
 235     krb5_kt_register (p, &krb5_akf_ops);
 236     krb5_kt_register (p, &krb4_fkt_ops);
 237     krb5_kt_register (p, &krb5_srvtab_fkt_ops);
 238     krb5_kt_register (p, &krb5_any_ops);
 239
 240 out:
 241     if(ret) {
 242         krb5_free_context(p);
 243         p = NULL;
 244     }
 245     *context = p;
 246     return ret;
 247 }
 248
 249 void KRB5_LIB_FUNCTION
 250 krb5_free_context(krb5_context context)
 251 {
 252     if (context->default_cc_name)
 253         free(context->default_cc_name);
 254     free(context->etypes);
 255     free(context->etypes_des);
 256     krb5_free_host_realm (context, context->default_realms);
 257     krb5_config_file_free (context, context->cf);
 258     free_error_table (context->et_list);
 259     free(context->cc_ops);
 260     free(context->kt_types);
 261     krb5_clear_error_string(context);
 262     if(context->warn_dest != NULL)
 263         krb5_closelog(context, context->warn_dest);
 264     krb5_set_extra_addresses(context, NULL);
 265     krb5_set_ignore_addresses(context, NULL);
 266     krb5_set_send_to_kdc_func(context, NULL, NULL);
 267     if (context->mutex != NULL) {
 268         HEIMDAL_MUTEX_destroy(context->mutex);
 269         free(context->mutex);
 270     }
 271     memset(context, 0, sizeof(*context));
 272     free(context);
 273 }
 274
 275 krb5_error_code KRB5_LIB_FUNCTION
 276 krb5_set_config_files(krb5_context context, char **filenames)
 277 {
 278     krb5_error_code ret;
 279     krb5_config_binding *tmp = NULL;
 280     while(filenames != NULL && *filenames != NULL && **filenames != '\0') {
 281         ret = krb5_config_parse_file_multi(context, *filenames, &tmp);
 282         if(ret != 0 && ret != ENOENT && ret != EACCES) {
 283             krb5_config_file_free(context, tmp);
 284             return ret;
 285         }
 286         filenames++;
 287     }
 288 #if 0
 289     /* with this enabled and if there are no config files, Kerberos is
 290        considererd disabled */
 291     if(tmp == NULL)
 292         return ENXIO;
 293 #endif
 294     krb5_config_file_free(context, context->cf);
 295     context->cf = tmp;
 296     ret = init_context_from_config_file(context);
 297     return ret;
 298 }
 299
 300 static krb5_error_code
 301 add_file(char ***pfilenames, int *len, char *file)
 302 {
 303     char **pp = *pfilenames;
 304     int i;
 305
 306     for(i = 0; i < *len; i++) {
 307         if(strcmp(pp[i], file) == 0) {
 308             free(file);
 309             return 0;
 310         }
 311     }
 312
 313     pp = realloc(*pfilenames, (*len + 2) * sizeof(*pp));
 314     if (pp == NULL) {
 315         free(file);
 316         return ENOMEM;
 317     }
 318
 319     pp[*len] = file;
 320     pp[*len + 1] = NULL;
 321     *pfilenames = pp;
 322     *len += 1;
 323     return 0;
 324 }
 325
 326 /*
 327  *  `pq' isn't free, its up the the caller
 328  */
 329
 330 krb5_error_code KRB5_LIB_FUNCTION
 331 krb5_prepend_config_files(const char *filelist, char **pq, char ***ret_pp)
 332 {
 333     krb5_error_code ret;
 334     const char *p, *q;
 335     char **pp;
 336     int len;
 337     char *fn;
 338
 339     pp = NULL;
 340
 341     len = 0;
 342     p = filelist;
 343     while(1) {
 344         ssize_t l;
 345         q = p;
 346         l = strsep_copy(&q, ":", NULL, 0);
 347         if(l == -1)
 348             break;
 349         fn = malloc(l + 1);
 350         if(fn == NULL) {
 351             krb5_free_config_files(pp);
 352             return ENOMEM;
 353         }
 354         l = strsep_copy(&p, ":", fn, l + 1);
 355         ret = add_file(&pp, &len, fn);
 356         if (ret) {
 357             krb5_free_config_files(pp);
 358             return ret;
 359         }
 360     }
 361
 362     if (pq != NULL) {
 363         int i;
 364
 365         for (i = 0; pq[i] != NULL; i++) {
 366             fn = strdup(pq[i]);
 367             if (fn == NULL) {
 368                 krb5_free_config_files(pp);
 369                 return ENOMEM;
 370             }
 371             ret = add_file(&pp, &len, fn);
 372             if (ret) {
 373                 krb5_free_config_files(pp);
 374                 return ret;
 375             }
 376         }
 377     }
 378
 379     *ret_pp = pp;
 380     return 0;
 381 }
 382
 383 krb5_error_code KRB5_LIB_FUNCTION
 384 krb5_prepend_config_files_default(const char *filelist, char ***pfilenames)
 385 {
 386     krb5_error_code ret;
 387     char **defpp, **pp = NULL;
 388
 389     ret = krb5_get_default_config_files(&defpp);
 390     if (ret)
 391         return ret;
 392
 393     ret = krb5_prepend_config_files(filelist, defpp, &pp);
 394     krb5_free_config_files(defpp);
 395     if (ret) {
 396         return ret;
 397     }
 398     *pfilenames = pp;
 399     return 0;
 400 }
 401
 402 krb5_error_code KRB5_LIB_FUNCTION
 403 krb5_get_default_config_files(char ***pfilenames)
 404 {
 405     const char *files = NULL;
 406
 407     if (pfilenames == NULL)
 408         return EINVAL;
 409     if(!issuid())
 410         files = getenv("KRB5_CONFIG");
 411     if (files == NULL)
 412         files = krb5_config_file;
 413
 414     return krb5_prepend_config_files(files, NULL, pfilenames);
 415 }
 416
 417 void KRB5_LIB_FUNCTION
 418 krb5_free_config_files(char **filenames)
 419 {
 420     char **p;
 421     for(p = filenames; *p != NULL; p++)
 422         free(*p);
 423     free(filenames);
 424 }
 425
 426 /*
 427  * Returns the list of Kerberos encryption types sorted in order of
 428  * most preferred to least preferred encryption type.  The array ends
 429  * with ETYPE_NULL.  Note that some encryption types might be
 430  * disabled, so you need to check with krb5_enctype_valid() before
 431  * using the encryption type.
 432  */
 433
 434 const krb5_enctype * KRB5_LIB_FUNCTION
 435 krb5_kerberos_enctypes(krb5_context context)
 436 {
 437     static const krb5_enctype p[] = {
 438         ETYPE_AES256_CTS_HMAC_SHA1_96,
 439         ETYPE_AES128_CTS_HMAC_SHA1_96,
 440         ETYPE_DES3_CBC_SHA1,
 441         ETYPE_DES3_CBC_MD5,
 442         ETYPE_ARCFOUR_HMAC_MD5,
 443         ETYPE_DES_CBC_MD5,
 444         ETYPE_DES_CBC_MD4,
 445         ETYPE_DES_CBC_CRC,
 446         ETYPE_NULL
 447     };
 448     return p;
 449 }
 450
 451 /*
 452  * set `etype' to a malloced list of the default enctypes
 453  */
 454
 455 static krb5_error_code
 456 default_etypes(krb5_context context, krb5_enctype **etype)
 457 {
 458     const krb5_enctype *p;
 459     krb5_enctype *e = NULL, *ep;
 460     int i, n = 0;
 461
 462     p = krb5_kerberos_enctypes(context);
 463
 464     for (i = 0; p[i] != ETYPE_NULL; i++) {
 465         if (krb5_enctype_valid(context, p[i]) != 0)
 466             continue;
 467         ep = realloc(e, (n + 2) * sizeof(*e));
 468         if (ep == NULL) {
 469             free(e);
 470             krb5_set_error_string (context, "malloc: out of memory");
 471             return ENOMEM;
 472         }
 473         e = ep;
 474         e[n] = p[i];
 475         e[n + 1] = ETYPE_NULL;
 476         n++;
 477     }
 478     *etype = e;
 479     return 0;
 480 }
 481
 482 krb5_error_code KRB5_LIB_FUNCTION
 483 krb5_set_default_in_tkt_etypes(krb5_context context,
 484                                const krb5_enctype *etypes)
 485 {
 486     krb5_enctype *p = NULL;
 487     int i;
 488
 489     if(etypes) {
 490         for (i = 0; etypes[i]; ++i) {
 491             krb5_error_code ret;
 492             ret = krb5_enctype_valid(context, etypes[i]);
 493             if (ret)
 494                 return ret;
 495         }
 496         ++i;
 497         ALLOC(p, i);
 498         if(!p) {
 499             krb5_set_error_string (context, "malloc: out of memory");
 500             return ENOMEM;
 501         }
 502         memmove(p, etypes, i * sizeof(krb5_enctype));
 503     }
 504     if(context->etypes)
 505         free(context->etypes);
 506     context->etypes = p;
 507     return 0;
 508 }
 509
 510
 511 krb5_error_code KRB5_LIB_FUNCTION
 512 krb5_get_default_in_tkt_etypes(krb5_context context,
 513                                krb5_enctype **etypes)
 514 {
 515   krb5_enctype *p;
 516   int i;
 517   krb5_error_code ret;
 518
 519   if(context->etypes) {
 520     for(i = 0; context->etypes[i]; i++);
 521     ++i;
 522     ALLOC(p, i);
 523     if(!p) {
 524       krb5_set_error_string (context, "malloc: out of memory");
 525       return ENOMEM;
 526     }
 527     memmove(p, context->etypes, i * sizeof(krb5_enctype));
 528   } else {
 529     ret = default_etypes(context, &p);
 530     if (ret)
 531       return ret;
 532   }
 533   *etypes = p;
 534   return 0;
 535 }
 536
 537 const char* KRB5_LIB_FUNCTION
 538 krb5_get_err_text(krb5_context context, krb5_error_code code)
 539 {
 540     const char *p = NULL;
 541     if(context != NULL)
 542         p = com_right(context->et_list, code);
 543     if(p == NULL)
 544         p = strerror(code);
 545     if (p == NULL)
 546         p = "Unknown error";
 547     return p;
 548 }
 549
 550 void KRB5_LIB_FUNCTION
 551 krb5_init_ets(krb5_context context)
 552 {
 553     if(context->et_list == NULL){
 554         krb5_add_et_list(context, initialize_krb5_error_table_r);
 555         krb5_add_et_list(context, initialize_asn1_error_table_r);
 556         krb5_add_et_list(context, initialize_heim_error_table_r);
 557         krb5_add_et_list(context, initialize_k524_error_table_r);
 558 #ifdef PKINIT
 559         krb5_add_et_list(context, initialize_hx_error_table_r);
 560 #endif
 561     }
 562 }
 563
 564 void KRB5_LIB_FUNCTION
 565 krb5_set_use_admin_kdc (krb5_context context, krb5_boolean flag)
 566 {
 567     context->use_admin_kdc = flag;
 568 }
 569
 570 krb5_boolean KRB5_LIB_FUNCTION
 571 krb5_get_use_admin_kdc (krb5_context context)
 572 {
 573     return context->use_admin_kdc;
 574 }
 575
 576 krb5_error_code KRB5_LIB_FUNCTION
 577 krb5_add_extra_addresses(krb5_context context, krb5_addresses *addresses)
 578 {
 579
 580     if(context->extra_addresses)
 581         return krb5_append_addresses(context,
 582                                      context->extra_addresses, addresses);
 583     else
 584         return krb5_set_extra_addresses(context, addresses);
 585 }
 586
 587 krb5_error_code KRB5_LIB_FUNCTION
 588 krb5_set_extra_addresses(krb5_context context, const krb5_addresses *addresses)
 589 {
 590     if(context->extra_addresses)
 591         krb5_free_addresses(context, context->extra_addresses);
 592
 593     if(addresses == NULL) {
 594         if(context->extra_addresses != NULL) {
 595             free(context->extra_addresses);
 596             context->extra_addresses = NULL;
 597         }
 598         return 0;
 599     }
 600     if(context->extra_addresses == NULL) {
 601         context->extra_addresses = malloc(sizeof(*context->extra_addresses));
 602         if(context->extra_addresses == NULL) {
 603             krb5_set_error_string (context, "malloc: out of memory");
 604             return ENOMEM;
 605         }
 606     }
 607     return krb5_copy_addresses(context, addresses, context->extra_addresses);
 608 }
 609
 610 krb5_error_code KRB5_LIB_FUNCTION
 611 krb5_get_extra_addresses(krb5_context context, krb5_addresses *addresses)
 612 {
 613     if(context->extra_addresses == NULL) {
 614         memset(addresses, 0, sizeof(*addresses));
 615         return 0;
 616     }
 617     return krb5_copy_addresses(context,context->extra_addresses, addresses);
 618 }
 619
 620 krb5_error_code KRB5_LIB_FUNCTION
 621 krb5_add_ignore_addresses(krb5_context context, krb5_addresses *addresses)
 622 {
 623
 624     if(context->ignore_addresses)
 625         return krb5_append_addresses(context,
 626                                      context->ignore_addresses, addresses);
 627     else
 628         return krb5_set_ignore_addresses(context, addresses);
 629 }
 630
 631 krb5_error_code KRB5_LIB_FUNCTION
 632 krb5_set_ignore_addresses(krb5_context context, const krb5_addresses *addresses)
 633 {
 634     if(context->ignore_addresses)
 635         krb5_free_addresses(context, context->ignore_addresses);
 636     if(addresses == NULL) {
 637         if(context->ignore_addresses != NULL) {
 638             free(context->ignore_addresses);
 639             context->ignore_addresses = NULL;
 640         }
 641         return 0;
 642     }
 643     if(context->ignore_addresses == NULL) {
 644         context->ignore_addresses = malloc(sizeof(*context->ignore_addresses));
 645         if(context->ignore_addresses == NULL) {
 646             krb5_set_error_string (context, "malloc: out of memory");
 647             return ENOMEM;
 648         }
 649     }
 650     return krb5_copy_addresses(context, addresses, context->ignore_addresses);
 651 }
 652
 653 krb5_error_code KRB5_LIB_FUNCTION
 654 krb5_get_ignore_addresses(krb5_context context, krb5_addresses *addresses)
 655 {
 656     if(context->ignore_addresses == NULL) {
 657         memset(addresses, 0, sizeof(*addresses));
 658         return 0;
 659     }
 660     return krb5_copy_addresses(context, context->ignore_addresses, addresses);
 661 }
 662
 663 krb5_error_code KRB5_LIB_FUNCTION
 664 krb5_set_fcache_version(krb5_context context, int version)
 665 {
 666     context->fcache_vno = version;
 667     return 0;
 668 }
 669
 670 krb5_error_code KRB5_LIB_FUNCTION
 671 krb5_get_fcache_version(krb5_context context, int *version)
 672 {
 673     *version = context->fcache_vno;
 674     return 0;
 675 }
 676
 677 krb5_boolean KRB5_LIB_FUNCTION
 678 krb5_is_thread_safe(void)
 679 {
 680 #ifdef ENABLE_PTHREAD_SUPPORT
 681     return TRUE;
 682 #else
 683     return FALSE;
 684 #endif
 685 }
 686
 687 void KRB5_LIB_FUNCTION
 688 krb5_set_dns_canonicalize_hostname (krb5_context context, krb5_boolean flag)
 689 {
 690     context->dns_canonicalize_hostname = flag;
 691 }
 692
 693 krb5_boolean KRB5_LIB_FUNCTION
 694 krb5_get_dns_canonicalize_hostname (krb5_context context)
 695 {
 696     return context->dns_canonicalize_hostname;
 697 }
 698
 699 krb5_error_code KRB5_LIB_FUNCTION
 700 krb5_get_kdc_sec_offset (krb5_context context, int32_t *sec, int32_t *usec)
 701 {
 702     if (sec)
 703         *sec = context->kdc_sec_offset;
 704     if (usec)
 705         *usec = context->kdc_usec_offset;
 706     return 0;
 707 }
 708
 709 time_t KRB5_LIB_FUNCTION
 710 krb5_get_time_wrap (krb5_context context)
 711 {
 712     return context->max_skew;
 713 }
 714
 715 void KRB5_LIB_FUNCTION
 716 krb5_set_time_wrap (krb5_context context, time_t t)
 717 {
 718     context->max_skew = t;
 719 }