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