source4/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 #define INIT_FIELD(C, T, E, D, F)                                       \
  38     (C)->E = krb5_config_get_ ## T ## _default ((C), NULL, (D),         \
  39                                                 "libdefaults", F, NULL)
  40
  41 #define INIT_FLAG(C, O, V, D, F)                                        \
  42     do {                                                                \
  43         if (krb5_config_get_bool_default((C), NULL, (D),"libdefaults", F, NULL)) { \
  44             (C)->O |= V;                                                \
  45         }                                                               \
  46     } while(0)
  47
  48 /*
  49  * Set the list of etypes `ret_etypes' from the configuration variable
  50  * `name'
  51  */
  52
  53 static krb5_error_code
  54 set_etypes (krb5_context context,
  55             const char *name,
  56             krb5_enctype **ret_enctypes)
  57 {
  58     char **etypes_str;
  59     krb5_enctype *etypes = NULL;
  60
  61     etypes_str = krb5_config_get_strings(context, NULL, "libdefaults",
  62                                          name, NULL);
  63     if(etypes_str){
  64         int i, j, k;
  65         for(i = 0; etypes_str[i]; i++);
  66         etypes = malloc((i+1) * sizeof(*etypes));
  67         if (etypes == NULL) {
  68             krb5_config_free_strings (etypes_str);
  69             krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", ""));
  70             return ENOMEM;
  71         }
  72         for(j = 0, k = 0; j < i; j++) {
  73             krb5_enctype e;
  74             if(krb5_string_to_enctype(context, etypes_str[j], &e) != 0)
  75                 continue;
  76             if (krb5_enctype_valid(context, e) != 0)
  77                 continue;
  78             etypes[k++] = e;
  79         }
  80         etypes[k] = ETYPE_NULL;
  81         krb5_config_free_strings(etypes_str);
  82     }
  83     *ret_enctypes = etypes;
  84     return 0;
  85 }
  86
  87 /*
  88  *
  89  */
  90
  91 static krb5_error_code
  92 copy_etypes (krb5_context context,
  93              krb5_enctype *enctypes,
  94              krb5_enctype **ret_enctypes)
  95 {
  96     unsigned int i;
  97
  98     for (i = 0; enctypes[i]; i++)
  99         ;
 100     i++;
 101
 102     *ret_enctypes = malloc(sizeof(ret_enctypes[0]) * i);
 103     if (*ret_enctypes == NULL) {
 104         krb5_set_error_message(context, ENOMEM,
 105                                N_("malloc: out of memory", ""));
 106         return ENOMEM;
 107     }
 108     memcpy(*ret_enctypes, enctypes, sizeof(ret_enctypes[0]) * i);
 109     return 0;
 110 }
 111
 112
 113 /*
 114  * read variables from the configuration file and set in `context'
 115  */
 116
 117 static krb5_error_code
 118 init_context_from_config_file(krb5_context context)
 119 {
 120     krb5_error_code ret;
 121     const char * tmp;
 122     krb5_enctype *tmptypes;
 123
 124     INIT_FIELD(context, time, max_skew, 5 * 60, "clockskew");
 125     INIT_FIELD(context, time, kdc_timeout, 3, "kdc_timeout");
 126     INIT_FIELD(context, int, max_retries, 3, "max_retries");
 127
 128     INIT_FIELD(context, string, http_proxy, NULL, "http_proxy");
 129
 130     ret = set_etypes (context, "default_etypes", &tmptypes);
 131     if(ret)
 132         return ret;
 133     free(context->etypes);
 134     context->etypes = tmptypes;
 135
 136     ret = set_etypes (context, "default_etypes_des", &tmptypes);
 137     if(ret)
 138         return ret;
 139     free(context->etypes_des);
 140     context->etypes_des = tmptypes;
 141
 142     /* default keytab name */
 143     tmp = NULL;
 144     if(!issuid())
 145         tmp = getenv("KRB5_KTNAME");
 146     if(tmp != NULL)
 147         context->default_keytab = tmp;
 148     else
 149         INIT_FIELD(context, string, default_keytab,
 150                    KEYTAB_DEFAULT, "default_keytab_name");
 151
 152     INIT_FIELD(context, string, default_keytab_modify,
 153                NULL, "default_keytab_modify_name");
 154
 155     INIT_FIELD(context, string, time_fmt,
 156                "%Y-%m-%dT%H:%M:%S", "time_format");
 157
 158     INIT_FIELD(context, string, date_fmt,
 159                "%Y-%m-%d", "date_format");
 160
 161     INIT_FIELD(context, bool, log_utc,
 162                FALSE, "log_utc");
 163
 164
 165
 166     /* init dns-proxy slime */
 167     tmp = krb5_config_get_string(context, NULL, "libdefaults",
 168                                  "dns_proxy", NULL);
 169     if(tmp)
 170         roken_gethostby_setup(context->http_proxy, tmp);
 171     krb5_free_host_realm (context, context->default_realms);
 172     context->default_realms = NULL;
 173
 174     {
 175         krb5_addresses addresses;
 176         char **adr, **a;
 177
 178         krb5_set_extra_addresses(context, NULL);
 179         adr = krb5_config_get_strings(context, NULL,
 180                                       "libdefaults",
 181                                       "extra_addresses",
 182                                       NULL);
 183         memset(&addresses, 0, sizeof(addresses));
 184         for(a = adr; a && *a; a++) {
 185             ret = krb5_parse_address(context, *a, &addresses);
 186             if (ret == 0) {
 187                 krb5_add_extra_addresses(context, &addresses);
 188                 krb5_free_addresses(context, &addresses);
 189             }
 190         }
 191         krb5_config_free_strings(adr);
 192
 193         krb5_set_ignore_addresses(context, NULL);
 194         adr = krb5_config_get_strings(context, NULL,
 195                                       "libdefaults",
 196                                       "ignore_addresses",
 197                                       NULL);
 198         memset(&addresses, 0, sizeof(addresses));
 199         for(a = adr; a && *a; a++) {
 200             ret = krb5_parse_address(context, *a, &addresses);
 201             if (ret == 0) {
 202                 krb5_add_ignore_addresses(context, &addresses);
 203                 krb5_free_addresses(context, &addresses);
 204             }
 205         }
 206         krb5_config_free_strings(adr);
 207     }
 208
 209     INIT_FIELD(context, bool, scan_interfaces, TRUE, "scan_interfaces");
 210     INIT_FIELD(context, int, fcache_vno, 0, "fcache_version");
 211     /* prefer dns_lookup_kdc over srv_lookup. */
 212     INIT_FIELD(context, bool, srv_lookup, TRUE, "srv_lookup");
 213     INIT_FIELD(context, bool, srv_lookup, context->srv_lookup, "dns_lookup_kdc");
 214     INIT_FIELD(context, int, large_msg_size, 1400, "large_message_size");
 215     INIT_FLAG(context, flags, KRB5_CTX_F_DNS_CANONICALIZE_HOSTNAME, TRUE, "dns_canonicalize_hostname");
 216     INIT_FLAG(context, flags, KRB5_CTX_F_CHECK_PAC, TRUE, "check_pac");
 217     context->default_cc_name = NULL;
 218     context->default_cc_name_set = 0;
 219
 220     ret = krb5_config_get_bool_default(context, NULL, FALSE,
 221                                        "libdefaults",
 222                                        "allow_weak_crypto", NULL);
 223     if (ret) {
 224         krb5_enctype_enable(context, ETYPE_DES_CBC_CRC);
 225         krb5_enctype_enable(context, ETYPE_DES_CBC_MD4);
 226         krb5_enctype_enable(context, ETYPE_DES_CBC_MD5);
 227         krb5_enctype_enable(context, ETYPE_DES_CBC_NONE);
 228         krb5_enctype_enable(context, ETYPE_DES_CFB64_NONE);
 229         krb5_enctype_enable(context, ETYPE_DES_PCBC_NONE);
 230     }
 231
 232     return 0;
 233 }
 234
 235 static krb5_error_code
 236 cc_ops_register(krb5_context context)
 237 {
 238     context->cc_ops = NULL;
 239     context->num_cc_ops = 0;
 240
 241     krb5_cc_register(context, &krb5_acc_ops, TRUE);
 242     krb5_cc_register(context, &krb5_fcc_ops, TRUE);
 243     krb5_cc_register(context, &krb5_mcc_ops, TRUE);
 244     krb5_cc_register(context, &krb5_scc_ops, TRUE);
 245 #ifdef HAVE_KCM
 246     krb5_cc_register(context, &krb5_kcm_ops, TRUE);
 247 #endif
 248     return 0;
 249 }
 250
 251 static krb5_error_code
 252 kt_ops_register(krb5_context context)
 253 {
 254     context->num_kt_types = 0;
 255     context->kt_types     = NULL;
 256
 257     krb5_kt_register (context, &krb5_fkt_ops);
 258     krb5_kt_register (context, &krb5_wrfkt_ops);
 259     krb5_kt_register (context, &krb5_javakt_ops);
 260     krb5_kt_register (context, &krb5_mkt_ops);
 261 #ifndef HEIMDAL_SMALLER
 262     krb5_kt_register (context, &krb5_akf_ops);
 263 #endif
 264     krb5_kt_register (context, &krb5_any_ops);
 265     return 0;
 266 }
 267
 268
 269 /**
 270  * Initializes the context structure and reads the configuration file
 271  * /etc/krb5.conf. The structure should be freed by calling
 272  * krb5_free_context() when it is no longer being used.
 273  *
 274  * @param context pointer to returned context
 275  *
 276  * @return Returns 0 to indicate success.  Otherwise an errno code is
 277  * returned.  Failure means either that something bad happened during
 278  * initialization (typically ENOMEM) or that Kerberos should not be
 279  * used ENXIO.
 280  *
 281  * @ingroup krb5
 282  */
 283
 284 krb5_error_code KRB5_LIB_FUNCTION
 285 krb5_init_context(krb5_context *context)
 286 {
 287     krb5_context p;
 288     krb5_error_code ret;
 289     char **files;
 290
 291     *context = NULL;
 292
 293     /* should have a run_once */
 294 #if defined(HEIMDAL_LOCALEDIR)
 295     bindtextdomain(HEIMDAL_TEXTDOMAIN, HEIMDAL_LOCALEDIR);
 296 #endif
 297
 298     p = calloc(1, sizeof(*p));
 299     if(!p)
 300         return ENOMEM;
 301
 302     p->mutex = malloc(sizeof(HEIMDAL_MUTEX));
 303     if (p->mutex == NULL) {
 304         free(p);
 305         return ENOMEM;
 306     }
 307     HEIMDAL_MUTEX_init(p->mutex);
 308
 309     p->flags |= KRB5_CTX_F_HOMEDIR_ACCESS;
 310
 311     ret = krb5_get_default_config_files(&files);
 312     if(ret)
 313         goto out;
 314     ret = krb5_set_config_files(p, files);
 315     krb5_free_config_files(files);
 316     if(ret)
 317         goto out;
 318
 319     /* init error tables */
 320     krb5_init_ets(p);
 321     cc_ops_register(p);
 322     kt_ops_register(p);
 323
 324 out:
 325     if(ret) {
 326         krb5_free_context(p);
 327         p = NULL;
 328     }
 329     *context = p;
 330     return ret;
 331 }
 332
 333 /**
 334  * Make a copy for the Kerberos 5 context, allocated krb5_contex shoud
 335  * be freed with krb5_free_context().
 336  *
 337  * @param context the Kerberos context to copy
 338  * @param out the copy of the Kerberos, set to NULL error.
 339  *
 340  * @return Returns 0 to indicate success.  Otherwise an kerberos et
 341  * error code is returned, see krb5_get_error_message().
 342  *
 343  * @ingroup krb5
 344  */
 345
 346 krb5_error_code KRB5_LIB_FUNCTION
 347 krb5_copy_context(krb5_context context, krb5_context *out)
 348 {
 349     krb5_error_code ret;
 350     krb5_context p;
 351
 352     *out = NULL;
 353
 354     p = calloc(1, sizeof(*p));
 355     if (p == NULL) {
 356         krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", ""));
 357         return ENOMEM;
 358     }
 359
 360     p->mutex = malloc(sizeof(HEIMDAL_MUTEX));
 361     if (p->mutex == NULL) {
 362         krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", ""));
 363         free(p);
 364         return ENOMEM;
 365     }
 366     HEIMDAL_MUTEX_init(p->mutex);
 367
 368
 369     if (context->default_cc_name)
 370         p->default_cc_name = strdup(context->default_cc_name);
 371     if (context->default_cc_name_env)
 372         p->default_cc_name_env = strdup(context->default_cc_name_env);
 373
 374     if (context->etypes) {
 375         ret = copy_etypes(context, context->etypes, &p->etypes);
 376         if (ret)
 377             goto out;
 378     }
 379     if (context->etypes_des) {
 380         ret = copy_etypes(context, context->etypes_des, &p->etypes_des);
 381         if (ret)
 382             goto out;
 383     }
 384
 385     if (context->default_realms) {
 386         ret = krb5_copy_host_realm(context,
 387                                    context->default_realms, &p->default_realms);
 388         if (ret)
 389             goto out;
 390     }
 391
 392     ret = _krb5_config_copy(context, context->cf, &p->cf);
 393     if (ret)
 394         goto out;
 395
 396     /* XXX should copy */
 397     krb5_init_ets(p);
 398     cc_ops_register(p);
 399     kt_ops_register(p);
 400
 401 #if 0 /* XXX */
 402     if(context->warn_dest != NULL)
 403         ;
 404 #endif
 405
 406     ret = krb5_set_extra_addresses(p, context->extra_addresses);
 407     if (ret)
 408         goto out;
 409     ret = krb5_set_extra_addresses(p, context->ignore_addresses);
 410     if (ret)
 411         goto out;
 412
 413     ret = _krb5_copy_send_to_kdc_func(p, context);
 414     if (ret)
 415         goto out;
 416
 417     *out = p;
 418
 419     return 0;
 420
 421  out:
 422     krb5_free_context(p);
 423     return ret;
 424 }
 425
 426 /**
 427  * Frees the krb5_context allocated by krb5_init_context().
 428  *
 429  * @param context context to be freed.
 430  *
 431  * @ingroup krb5
 432  */
 433
 434 void KRB5_LIB_FUNCTION
 435 krb5_free_context(krb5_context context)
 436 {
 437     if (context->default_cc_name)
 438         free(context->default_cc_name);
 439     if (context->default_cc_name_env)
 440         free(context->default_cc_name_env);
 441     free(context->etypes);
 442     free(context->etypes_des);
 443     krb5_free_host_realm (context, context->default_realms);
 444     krb5_config_file_free (context, context->cf);
 445     free_error_table (context->et_list);
 446     free(context->cc_ops);
 447     free(context->kt_types);
 448     krb5_clear_error_message(context);
 449     if(context->warn_dest != NULL)
 450         krb5_closelog(context, context->warn_dest);
 451     krb5_set_extra_addresses(context, NULL);
 452     krb5_set_ignore_addresses(context, NULL);
 453     krb5_set_send_to_kdc_func(context, NULL, NULL);
 454
 455     HEIMDAL_MUTEX_destroy(context->mutex);
 456     free(context->mutex);
 457
 458     memset(context, 0, sizeof(*context));
 459     free(context);
 460 }
 461
 462 /**
 463  * Reinit the context from a new set of filenames.
 464  *
 465  * @param context context to add configuration too.
 466  * @param filenames array of filenames, end of list is indicated with a NULL filename.
 467  *
 468  * @return Returns 0 to indicate success.  Otherwise an kerberos et
 469  * error code is returned, see krb5_get_error_message().
 470  *
 471  * @ingroup krb5
 472  */
 473
 474 krb5_error_code KRB5_LIB_FUNCTION
 475 krb5_set_config_files(krb5_context context, char **filenames)
 476 {
 477     krb5_error_code ret;
 478     krb5_config_binding *tmp = NULL;
 479     while(filenames != NULL && *filenames != NULL && **filenames != '\0') {
 480         ret = krb5_config_parse_file_multi(context, *filenames, &tmp);
 481         if(ret != 0 && ret != ENOENT && ret != EACCES) {
 482             krb5_config_file_free(context, tmp);
 483             return ret;
 484         }
 485         filenames++;
 486     }
 487 #if 0
 488     /* with this enabled and if there are no config files, Kerberos is
 489        considererd disabled */
 490     if(tmp == NULL)
 491         return ENXIO;
 492 #endif
 493     krb5_config_file_free(context, context->cf);
 494     context->cf = tmp;
 495     ret = init_context_from_config_file(context);
 496     return ret;
 497 }
 498
 499 static krb5_error_code
 500 add_file(char ***pfilenames, int *len, char *file)
 501 {
 502     char **pp = *pfilenames;
 503     int i;
 504
 505     for(i = 0; i < *len; i++) {
 506         if(strcmp(pp[i], file) == 0) {
 507             free(file);
 508             return 0;
 509         }
 510     }
 511
 512     pp = realloc(*pfilenames, (*len + 2) * sizeof(*pp));
 513     if (pp == NULL) {
 514         free(file);
 515         return ENOMEM;
 516     }
 517
 518     pp[*len] = file;
 519     pp[*len + 1] = NULL;
 520     *pfilenames = pp;
 521     *len += 1;
 522     return 0;
 523 }
 524
 525 /*
 526  *  `pq' isn't free, it's up the the caller
 527  */
 528
 529 krb5_error_code KRB5_LIB_FUNCTION
 530 krb5_prepend_config_files(const char *filelist, char **pq, char ***ret_pp)
 531 {
 532     krb5_error_code ret;
 533     const char *p, *q;
 534     char **pp;
 535     int len;
 536     char *fn;
 537
 538     pp = NULL;
 539
 540     len = 0;
 541     p = filelist;
 542     while(1) {
 543         ssize_t l;
 544         q = p;
 545         l = strsep_copy(&q, ":", NULL, 0);
 546         if(l == -1)
 547             break;
 548         fn = malloc(l + 1);
 549         if(fn == NULL) {
 550             krb5_free_config_files(pp);
 551             return ENOMEM;
 552         }
 553         (void)strsep_copy(&p, ":", fn, l + 1);
 554         ret = add_file(&pp, &len, fn);
 555         if (ret) {
 556             krb5_free_config_files(pp);
 557             return ret;
 558         }
 559     }
 560
 561     if (pq != NULL) {
 562         int i;
 563
 564         for (i = 0; pq[i] != NULL; i++) {
 565             fn = strdup(pq[i]);
 566             if (fn == NULL) {
 567                 krb5_free_config_files(pp);
 568                 return ENOMEM;
 569             }
 570             ret = add_file(&pp, &len, fn);
 571             if (ret) {
 572                 krb5_free_config_files(pp);
 573                 return ret;
 574             }
 575         }
 576     }
 577
 578     *ret_pp = pp;
 579     return 0;
 580 }
 581
 582 /**
 583  * Prepend the filename to the global configuration list.
 584  *
 585  * @param filelist a filename to add to the default list of filename
 586  * @param pfilenames return array of filenames, should be freed with krb5_free_config_files().
 587  *
 588  * @return Returns 0 to indicate success.  Otherwise an kerberos et
 589  * error code is returned, see krb5_get_error_message().
 590  *
 591  * @ingroup krb5
 592  */
 593
 594 krb5_error_code KRB5_LIB_FUNCTION
 595 krb5_prepend_config_files_default(const char *filelist, char ***pfilenames)
 596 {
 597     krb5_error_code ret;
 598     char **defpp, **pp = NULL;
 599
 600     ret = krb5_get_default_config_files(&defpp);
 601     if (ret)
 602         return ret;
 603
 604     ret = krb5_prepend_config_files(filelist, defpp, &pp);
 605     krb5_free_config_files(defpp);
 606     if (ret) {
 607         return ret;
 608     }
 609     *pfilenames = pp;
 610     return 0;
 611 }
 612
 613 /**
 614  * Get the global configuration list.
 615  *
 616  * @param pfilenames return array of filenames, should be freed with krb5_free_config_files().
 617  *
 618  * @return Returns 0 to indicate success.  Otherwise an kerberos et
 619  * error code is returned, see krb5_get_error_message().
 620  *
 621  * @ingroup krb5
 622  */
 623
 624 krb5_error_code KRB5_LIB_FUNCTION
 625 krb5_get_default_config_files(char ***pfilenames)
 626 {
 627     const char *files = NULL;
 628
 629     if (pfilenames == NULL)
 630         return EINVAL;
 631     if(!issuid())
 632         files = getenv("KRB5_CONFIG");
 633     if (files == NULL)
 634         files = krb5_config_file;
 635
 636     return krb5_prepend_config_files(files, NULL, pfilenames);
 637 }
 638
 639 /**
 640  * Free a list of configuration files.
 641  *
 642  * @param filenames list, terminated with a NULL pointer, to be
 643  * freed. NULL is an valid argument.
 644  *
 645  * @return Returns 0 to indicate success. Otherwise an kerberos et
 646  * error code is returned, see krb5_get_error_message().
 647  *
 648  * @ingroup krb5
 649  */
 650
 651 void KRB5_LIB_FUNCTION
 652 krb5_free_config_files(char **filenames)
 653 {
 654     char **p;
 655     for(p = filenames; p && *p != NULL; p++)
 656         free(*p);
 657     free(filenames);
 658 }
 659
 660 /**
 661  * Returns the list of Kerberos encryption types sorted in order of
 662  * most preferred to least preferred encryption type.  Note that some
 663  * encryption types might be disabled, so you need to check with
 664  * krb5_enctype_valid() before using the encryption type.
 665  *
 666  * @return list of enctypes, terminated with ETYPE_NULL. Its a static
 667  * array completed into the Kerberos library so the content doesn't
 668  * need to be freed.
 669  *
 670  * @ingroup krb5
 671  */
 672
 673 const krb5_enctype * KRB5_LIB_FUNCTION
 674 krb5_kerberos_enctypes(krb5_context context)
 675 {
 676     static const krb5_enctype p[] = {
 677         ETYPE_AES256_CTS_HMAC_SHA1_96,
 678         ETYPE_AES128_CTS_HMAC_SHA1_96,
 679         ETYPE_DES3_CBC_SHA1,
 680         ETYPE_DES3_CBC_MD5,
 681         ETYPE_ARCFOUR_HMAC_MD5,
 682         ETYPE_DES_CBC_MD5,
 683         ETYPE_DES_CBC_MD4,
 684         ETYPE_DES_CBC_CRC,
 685         ETYPE_NULL
 686     };
 687     return p;
 688 }
 689
 690 /*
 691  * set `etype' to a malloced list of the default enctypes
 692  */
 693
 694 static krb5_error_code
 695 default_etypes(krb5_context context, krb5_enctype **etype)
 696 {
 697     const krb5_enctype *p;
 698     krb5_enctype *e = NULL, *ep;
 699     int i, n = 0;
 700
 701     p = krb5_kerberos_enctypes(context);
 702
 703     for (i = 0; p[i] != ETYPE_NULL; i++) {
 704         if (krb5_enctype_valid(context, p[i]) != 0)
 705             continue;
 706         ep = realloc(e, (n + 2) * sizeof(*e));
 707         if (ep == NULL) {
 708             free(e);
 709             krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", ""));
 710             return ENOMEM;
 711         }
 712         e = ep;
 713         e[n] = p[i];
 714         e[n + 1] = ETYPE_NULL;
 715         n++;
 716     }
 717     *etype = e;
 718     return 0;
 719 }
 720
 721 /**
 722  * Set the default encryption types that will be use in communcation
 723  * with the KDC, clients and servers.
 724  *
 725  * @param context Kerberos 5 context.
 726  * @param etypes Encryption types, array terminated with ETYPE_NULL (0).
 727  *
 728  * @return Returns 0 to indicate success. Otherwise an kerberos et
 729  * error code is returned, see krb5_get_error_message().
 730  *
 731  * @ingroup krb5
 732  */
 733
 734 krb5_error_code KRB5_LIB_FUNCTION
 735 krb5_set_default_in_tkt_etypes(krb5_context context,
 736                                const krb5_enctype *etypes)
 737 {
 738     krb5_enctype *p = NULL;
 739     int i;
 740
 741     if(etypes) {
 742         for (i = 0; etypes[i]; ++i) {
 743             krb5_error_code ret;
 744             ret = krb5_enctype_valid(context, etypes[i]);
 745             if (ret)
 746                 return ret;
 747         }
 748         ++i;
 749         ALLOC(p, i);
 750         if(!p) {
 751             krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", ""));
 752             return ENOMEM;
 753         }
 754         memmove(p, etypes, i * sizeof(krb5_enctype));
 755     }
 756     if(context->etypes)
 757         free(context->etypes);
 758     context->etypes = p;
 759     return 0;
 760 }
 761
 762 /**
 763  * Get the default encryption types that will be use in communcation
 764  * with the KDC, clients and servers.
 765  *
 766  * @param context Kerberos 5 context.
 767  * @param etypes Encryption types, array terminated with
 768  * ETYPE_NULL(0), caller should free array with krb5_xfree():
 769  *
 770  * @return Returns 0 to indicate success. Otherwise an kerberos et
 771  * error code is returned, see krb5_get_error_message().
 772  *
 773  * @ingroup krb5
 774  */
 775
 776 krb5_error_code KRB5_LIB_FUNCTION
 777 krb5_get_default_in_tkt_etypes(krb5_context context,
 778                                krb5_enctype **etypes)
 779 {
 780     krb5_enctype *p;
 781     int i;
 782     krb5_error_code ret;
 783
 784     if(context->etypes) {
 785         for(i = 0; context->etypes[i]; i++);
 786         ++i;
 787         ALLOC(p, i);
 788         if(!p) {
 789             krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", ""));
 790             return ENOMEM;
 791         }
 792         memmove(p, context->etypes, i * sizeof(krb5_enctype));
 793     } else {
 794         ret = default_etypes(context, &p);
 795         if (ret)
 796             return ret;
 797     }
 798     *etypes = p;
 799     return 0;
 800 }
 801
 802 /**
 803  * Return the error string for the error code. The caller must not
 804  * free the string.
 805  *
 806  * @param context Kerberos 5 context.
 807  * @param code Kerberos error code.
 808  *
 809  * @return the error message matching code
 810  *
 811  * @ingroup krb5
 812  */
 813
 814 const char* KRB5_LIB_FUNCTION
 815 krb5_get_err_text(krb5_context context, krb5_error_code code)
 816 {
 817     const char *p = NULL;
 818     if(context != NULL)
 819         p = com_right(context->et_list, code);
 820     if(p == NULL)
 821         p = strerror(code);
 822     if (p == NULL)
 823         p = "Unknown error";
 824     return p;
 825 }
 826
 827 /**
 828  * Init the built-in ets in the Kerberos library.
 829  *
 830  * @param context kerberos context to add the ets too
 831  *
 832  * @ingroup krb5
 833  */
 834
 835 void KRB5_LIB_FUNCTION
 836 krb5_init_ets(krb5_context context)
 837 {
 838     if(context->et_list == NULL){
 839         krb5_add_et_list(context, initialize_krb5_error_table_r);
 840 #if defined(HEIMDAL_LOCALEDIR)
 841         bindtextdomain(COM_ERR_BINDDOMAIN_krb5, HEIMDAL_LOCALEDIR);
 842 #endif
 843
 844         krb5_add_et_list(context, initialize_asn1_error_table_r);
 845 #if defined(HEIMDAL_LOCALEDIR)
 846         bindtextdomain(COM_ERR_BINDDOMAIN_asn1, HEIMDAL_LOCALEDIR);
 847 #endif
 848
 849         krb5_add_et_list(context, initialize_heim_error_table_r);
 850 #if defined(HEIMDAL_LOCALEDIR)
 851         bindtextdomain(COM_ERR_BINDDOMAIN_heim, HEIMDAL_LOCALEDIR);
 852 #endif
 853
 854         krb5_add_et_list(context, initialize_k524_error_table_r);
 855 #if defined(HEIMDAL_LOCALEDIR)
 856         bindtextdomain(COM_ERR_BINDDOMAIN_k524, HEIMDAL_LOCALEDIR);
 857 #endif
 858
 859 #ifdef PKINIT
 860         krb5_add_et_list(context, initialize_hx_error_table_r);
 861 #if defined(HEIMDAL_LOCALEDIR)
 862         bindtextdomain(COM_ERR_BINDDOMAIN_hx, HEIMDAL_LOCALEDIR);
 863 #endif
 864 #endif
 865     }
 866 }
 867
 868 /**
 869  * Make the kerberos library default to the admin KDC.
 870  *
 871  * @param context Kerberos 5 context.
 872  * @param flag boolean flag to select if the use the admin KDC or not.
 873  *
 874  * @ingroup krb5
 875  */
 876
 877 void KRB5_LIB_FUNCTION
 878 krb5_set_use_admin_kdc (krb5_context context, krb5_boolean flag)
 879 {
 880     context->use_admin_kdc = flag;
 881 }
 882
 883 /**
 884  * Make the kerberos library default to the admin KDC.
 885  *
 886  * @param context Kerberos 5 context.
 887  *
 888  * @return boolean flag to telling the context will use admin KDC as the default KDC.
 889  *
 890  * @ingroup krb5
 891  */
 892
 893 krb5_boolean KRB5_LIB_FUNCTION
 894 krb5_get_use_admin_kdc (krb5_context context)
 895 {
 896     return context->use_admin_kdc;
 897 }
 898
 899 /**
 900  * Add extra address to the address list that the library will add to
 901  * the client's address list when communicating with the KDC.
 902  *
 903  * @param context Kerberos 5 context.
 904  * @param addresses addreses to add
 905  *
 906  * @return Returns 0 to indicate success. Otherwise an kerberos et
 907  * error code is returned, see krb5_get_error_message().
 908  *
 909  * @ingroup krb5
 910  */
 911
 912 krb5_error_code KRB5_LIB_FUNCTION
 913 krb5_add_extra_addresses(krb5_context context, krb5_addresses *addresses)
 914 {
 915
 916     if(context->extra_addresses)
 917         return krb5_append_addresses(context,
 918                                      context->extra_addresses, addresses);
 919     else
 920         return krb5_set_extra_addresses(context, addresses);
 921 }
 922
 923 /**
 924  * Set extra address to the address list that the library will add to
 925  * the client's address list when communicating with the KDC.
 926  *
 927  * @param context Kerberos 5 context.
 928  * @param addresses addreses to set
 929  *
 930  * @return Returns 0 to indicate success. Otherwise an kerberos et
 931  * error code is returned, see krb5_get_error_message().
 932  *
 933  * @ingroup krb5
 934  */
 935
 936 krb5_error_code KRB5_LIB_FUNCTION
 937 krb5_set_extra_addresses(krb5_context context, const krb5_addresses *addresses)
 938 {
 939     if(context->extra_addresses)
 940         krb5_free_addresses(context, context->extra_addresses);
 941
 942     if(addresses == NULL) {
 943         if(context->extra_addresses != NULL) {
 944             free(context->extra_addresses);
 945             context->extra_addresses = NULL;
 946         }
 947         return 0;
 948     }
 949     if(context->extra_addresses == NULL) {
 950         context->extra_addresses = malloc(sizeof(*context->extra_addresses));
 951         if(context->extra_addresses == NULL) {
 952             krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", ""));
 953             return ENOMEM;
 954         }
 955     }
 956     return krb5_copy_addresses(context, addresses, context->extra_addresses);
 957 }
 958
 959 /**
 960  * Get extra address to the address list that the library will add to
 961  * the client's address list when communicating with the KDC.
 962  *
 963  * @param context Kerberos 5 context.
 964  * @param addresses addreses to set
 965  *
 966  * @return Returns 0 to indicate success. Otherwise an kerberos et
 967  * error code is returned, see krb5_get_error_message().
 968  *
 969  * @ingroup krb5
 970  */
 971
 972 krb5_error_code KRB5_LIB_FUNCTION
 973 krb5_get_extra_addresses(krb5_context context, krb5_addresses *addresses)
 974 {
 975     if(context->extra_addresses == NULL) {
 976         memset(addresses, 0, sizeof(*addresses));
 977         return 0;
 978     }
 979     return krb5_copy_addresses(context,context->extra_addresses, addresses);
 980 }
 981
 982 /**
 983  * Add extra addresses to ignore when fetching addresses from the
 984  * underlaying operating system.
 985  *
 986  * @param context Kerberos 5 context.
 987  * @param addresses addreses to ignore
 988  *
 989  * @return Returns 0 to indicate success. Otherwise an kerberos et
 990  * error code is returned, see krb5_get_error_message().
 991  *
 992  * @ingroup krb5
 993  */
 994
 995 krb5_error_code KRB5_LIB_FUNCTION
 996 krb5_add_ignore_addresses(krb5_context context, krb5_addresses *addresses)
 997 {
 998
 999     if(context->ignore_addresses)
1000         return krb5_append_addresses(context,
1001                                      context->ignore_addresses, addresses);
1002     else
1003         return krb5_set_ignore_addresses(context, addresses);
1004 }
1005
1006 /**
1007  * Set extra addresses to ignore when fetching addresses from the
1008  * underlaying operating system.
1009  *
1010  * @param context Kerberos 5 context.
1011  * @param addresses addreses to ignore
1012  *
1013  * @return Returns 0 to indicate success. Otherwise an kerberos et
1014  * error code is returned, see krb5_get_error_message().
1015  *
1016  * @ingroup krb5
1017  */
1018
1019 krb5_error_code KRB5_LIB_FUNCTION
1020 krb5_set_ignore_addresses(krb5_context context, const krb5_addresses *addresses)
1021 {
1022     if(context->ignore_addresses)
1023         krb5_free_addresses(context, context->ignore_addresses);
1024     if(addresses == NULL) {
1025         if(context->ignore_addresses != NULL) {
1026             free(context->ignore_addresses);
1027             context->ignore_addresses = NULL;
1028         }
1029         return 0;
1030     }
1031     if(context->ignore_addresses == NULL) {
1032         context->ignore_addresses = malloc(sizeof(*context->ignore_addresses));
1033         if(context->ignore_addresses == NULL) {
1034             krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", ""));
1035             return ENOMEM;
1036         }
1037     }
1038     return krb5_copy_addresses(context, addresses, context->ignore_addresses);
1039 }
1040
1041 /**
1042  * Get extra addresses to ignore when fetching addresses from the
1043  * underlaying operating system.
1044  *
1045  * @param context Kerberos 5 context.
1046  * @param addresses list addreses ignored
1047  *
1048  * @return Returns 0 to indicate success. Otherwise an kerberos et
1049  * error code is returned, see krb5_get_error_message().
1050  *
1051  * @ingroup krb5
1052  */
1053
1054 krb5_error_code KRB5_LIB_FUNCTION
1055 krb5_get_ignore_addresses(krb5_context context, krb5_addresses *addresses)
1056 {
1057     if(context->ignore_addresses == NULL) {
1058         memset(addresses, 0, sizeof(*addresses));
1059         return 0;
1060     }
1061     return krb5_copy_addresses(context, context->ignore_addresses, addresses);
1062 }
1063
1064 /**
1065  * Set version of fcache that the library should use.
1066  *
1067  * @param context Kerberos 5 context.
1068  * @param version version number.
1069  *
1070  * @return Returns 0 to indicate success. Otherwise an kerberos et
1071  * error code is returned, see krb5_get_error_message().
1072  *
1073  * @ingroup krb5
1074  */
1075
1076 krb5_error_code KRB5_LIB_FUNCTION
1077 krb5_set_fcache_version(krb5_context context, int version)
1078 {
1079     context->fcache_vno = version;
1080     return 0;
1081 }
1082
1083 /**
1084  * Get version of fcache that the library should use.
1085  *
1086  * @param context Kerberos 5 context.
1087  * @param version version number.
1088  *
1089  * @return Returns 0 to indicate success. Otherwise an kerberos et
1090  * error code is returned, see krb5_get_error_message().
1091  *
1092  * @ingroup krb5
1093  */
1094
1095 krb5_error_code KRB5_LIB_FUNCTION
1096 krb5_get_fcache_version(krb5_context context, int *version)
1097 {
1098     *version = context->fcache_vno;
1099     return 0;
1100 }
1101
1102 /**
1103  * Runtime check if the Kerberos library was complied with thread support.
1104  *
1105  * @return TRUE if the library was compiled with thread support, FALSE if not.
1106  *
1107  * @ingroup krb5
1108  */
1109
1110
1111 krb5_boolean KRB5_LIB_FUNCTION
1112 krb5_is_thread_safe(void)
1113 {
1114 #ifdef ENABLE_PTHREAD_SUPPORT
1115     return TRUE;
1116 #else
1117     return FALSE;
1118 #endif
1119 }
1120
1121 /**
1122  * Set if the library should use DNS to canonicalize hostnames.
1123  *
1124  * @param context Kerberos 5 context.
1125  * @param flag if its dns canonicalizion is used or not.
1126  *
1127  * @ingroup krb5
1128  */
1129
1130 void KRB5_LIB_FUNCTION
1131 krb5_set_dns_canonicalize_hostname (krb5_context context, krb5_boolean flag)
1132 {
1133     if (flag)
1134         context->flags |= KRB5_CTX_F_DNS_CANONICALIZE_HOSTNAME;
1135     else
1136         context->flags &= ~KRB5_CTX_F_DNS_CANONICALIZE_HOSTNAME;
1137 }
1138
1139 /**
1140  * Get if the library uses DNS to canonicalize hostnames.
1141  *
1142  * @param context Kerberos 5 context.
1143  *
1144  * @return return non zero if the library uses DNS to canonicalize hostnames.
1145  *
1146  * @ingroup krb5
1147  */
1148
1149 krb5_boolean KRB5_LIB_FUNCTION
1150 krb5_get_dns_canonicalize_hostname (krb5_context context)
1151 {
1152     return (context->flags & KRB5_CTX_F_DNS_CANONICALIZE_HOSTNAME) ? 1 : 0;
1153 }
1154
1155 /**
1156  * Get current offset in time to the KDC.
1157  *
1158  * @param context Kerberos 5 context.
1159  * @param sec seconds part of offset.
1160  * @param usec micro seconds part of offset.
1161  *
1162  * @return returns zero
1163  *
1164  * @ingroup krb5
1165  */
1166
1167 krb5_error_code KRB5_LIB_FUNCTION
1168 krb5_get_kdc_sec_offset (krb5_context context, int32_t *sec, int32_t *usec)
1169 {
1170     if (sec)
1171         *sec = context->kdc_sec_offset;
1172     if (usec)
1173         *usec = context->kdc_usec_offset;
1174     return 0;
1175 }
1176
1177 /**
1178  * Set current offset in time to the KDC.
1179  *
1180  * @param context Kerberos 5 context.
1181  * @param sec seconds part of offset.
1182  * @param usec micro seconds part of offset.
1183  *
1184  * @return returns zero
1185  *
1186  * @ingroup krb5
1187  */
1188
1189 krb5_error_code KRB5_LIB_FUNCTION
1190 krb5_set_kdc_sec_offset (krb5_context context, int32_t sec, int32_t usec)
1191 {
1192     context->kdc_sec_offset = sec;
1193     if (usec >= 0)
1194         context->kdc_usec_offset = usec;
1195     return 0;
1196 }
1197
1198 /**
1199  * Get max time skew allowed.
1200  *
1201  * @param context Kerberos 5 context.
1202  *
1203  * @return timeskew in seconds.
1204  *
1205  * @ingroup krb5
1206  */
1207
1208 time_t KRB5_LIB_FUNCTION
1209 krb5_get_max_time_skew (krb5_context context)
1210 {
1211     return context->max_skew;
1212 }
1213
1214 /**
1215  * Set max time skew allowed.
1216  *
1217  * @param context Kerberos 5 context.
1218  * @param t timeskew in seconds.
1219  *
1220  * @ingroup krb5
1221  */
1222
1223 void KRB5_LIB_FUNCTION
1224 krb5_set_max_time_skew (krb5_context context, time_t t)
1225 {
1226     context->max_skew = t;
1227 }
1228
1229 /**
1230  * Init encryption types in len, val with etypes.
1231  *
1232  * @param context Kerberos 5 context.
1233  * @param len output length of val.
1234  * @param val output array of enctypes.
1235  * @param etypes etypes to set val and len to, if NULL, use default enctypes.
1236
1237  * @return Returns 0 to indicate success. Otherwise an kerberos et
1238  * error code is returned, see krb5_get_error_message().
1239  *
1240  * @ingroup krb5
1241  */
1242
1243 krb5_error_code KRB5_LIB_FUNCTION
1244 krb5_init_etype (krb5_context context,
1245                  unsigned *len,
1246                  krb5_enctype **val,
1247                  const krb5_enctype *etypes)
1248 {
1249     unsigned int i;
1250     krb5_error_code ret;
1251     krb5_enctype *tmp = NULL;
1252
1253     ret = 0;
1254     if (etypes == NULL) {
1255         ret = krb5_get_default_in_tkt_etypes(context, &tmp);
1256         if (ret)
1257             return ret;
1258         etypes = tmp;
1259     }
1260
1261     for (i = 0; etypes[i]; ++i)
1262         ;
1263     *len = i;
1264     *val = malloc(i * sizeof(**val));
1265     if (i != 0 && *val == NULL) {
1266         ret = ENOMEM;
1267         krb5_set_error_message(context, ret, N_("malloc: out of memory", ""));
1268         goto cleanup;
1269     }
1270     memmove (*val,
1271              etypes,
1272              i * sizeof(*tmp));
1273 cleanup:
1274     if (tmp != NULL)
1275         free (tmp);
1276     return ret;
1277 }
1278
1279 /*
1280  * Allow homedir accces
1281  */
1282
1283 static HEIMDAL_MUTEX homedir_mutex = HEIMDAL_MUTEX_INITIALIZER;
1284 static krb5_boolean allow_homedir = TRUE;
1285
1286 krb5_boolean
1287 _krb5_homedir_access(krb5_context context)
1288 {
1289     krb5_boolean allow;
1290
1291     /* is never allowed for root */
1292     if (geteuid() == 0)
1293         return FALSE;
1294
1295     if (context && (context->flags & KRB5_CTX_F_HOMEDIR_ACCESS) == 0)
1296         return FALSE;
1297
1298     HEIMDAL_MUTEX_lock(&homedir_mutex);
1299     allow = allow_homedir;
1300     HEIMDAL_MUTEX_unlock(&homedir_mutex);
1301     return allow;
1302 }
1303
1304 /**
1305  * Enable and disable home directory access on either the global state
1306  * or the krb5_context state. By calling krb5_set_home_dir_access()
1307  * with context set to NULL, the global state is configured otherwise
1308  * the state for the krb5_context is modified.
1309  *
1310  * For home directory access to be allowed, both the global state and
1311  * the krb5_context state have to be allowed.
1312  *
1313  * Administrator (root user), never uses the home directory.
1314  *
1315  * @param context a Kerberos 5 context or NULL
1316  * @param allow allow if TRUE home directory
1317  * @return the old value
1318  *
1319  */
1320
1321 krb5_boolean
1322 krb5_set_home_dir_access(krb5_context context, krb5_boolean allow)
1323 {
1324     krb5_boolean old;
1325     if (context) {
1326         old = (context->flags & KRB5_CTX_F_HOMEDIR_ACCESS) ? TRUE : FALSE;
1327         if (allow)
1328             context->flags |= KRB5_CTX_F_HOMEDIR_ACCESS;
1329         else
1330             context->flags &= ~KRB5_CTX_F_HOMEDIR_ACCESS;
1331     } else {
1332         HEIMDAL_MUTEX_lock(&homedir_mutex);
1333         old = allow_homedir;
1334         allow_homedir = allow;
1335         HEIMDAL_MUTEX_unlock(&homedir_mutex);
1336     }
1337
1338     return old;
1339 }