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 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, N_("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  *
  91  */
  92
  93 static krb5_error_code
  94 copy_etypes (krb5_context context,
  95              krb5_enctype *enctypes,
  96              krb5_enctype **ret_enctypes)
  97 {
  98     unsigned int i;
  99
 100     for (i = 0; enctypes[i]; i++)
 101         ;
 102     i++;
 103
 104     *ret_enctypes = malloc(sizeof(ret_enctypes[0]) * i);
 105     if (*ret_enctypes == NULL) {
 106         krb5_set_error_message(context, ENOMEM,
 107                                N_("malloc: out of memory", ""));
 108         return ENOMEM;
 109     }
 110     memcpy(*ret_enctypes, enctypes, sizeof(ret_enctypes[0]) * i);
 111     return 0;
 112 }
 113
 114
 115 /*
 116  * read variables from the configuration file and set in `context'
 117  */
 118
 119 static krb5_error_code
 120 init_context_from_config_file(krb5_context context)
 121 {
 122     krb5_error_code ret;
 123     const char * tmp;
 124     krb5_enctype *tmptypes;
 125
 126     INIT_FIELD(context, time, max_skew, 5 * 60, "clockskew");
 127     INIT_FIELD(context, time, kdc_timeout, 3, "kdc_timeout");
 128     INIT_FIELD(context, int, max_retries, 3, "max_retries");
 129
 130     INIT_FIELD(context, string, http_proxy, NULL, "http_proxy");
 131
 132     ret = set_etypes (context, "default_etypes", &tmptypes);
 133     if(ret)
 134         return ret;
 135     free(context->etypes);
 136     context->etypes = tmptypes;
 137
 138     ret = set_etypes (context, "default_etypes_des", &tmptypes);
 139     if(ret)
 140         return ret;
 141     free(context->etypes_des);
 142     context->etypes_des = tmptypes;
 143
 144     /* default keytab name */
 145     tmp = NULL;
 146     if(!issuid())
 147         tmp = getenv("KRB5_KTNAME");
 148     if(tmp != NULL)
 149         context->default_keytab = tmp;
 150     else
 151         INIT_FIELD(context, string, default_keytab,
 152                    KEYTAB_DEFAULT, "default_keytab_name");
 153
 154     INIT_FIELD(context, string, default_keytab_modify,
 155                NULL, "default_keytab_modify_name");
 156
 157     INIT_FIELD(context, string, time_fmt,
 158                "%Y-%m-%dT%H:%M:%S", "time_format");
 159
 160     INIT_FIELD(context, string, date_fmt,
 161                "%Y-%m-%d", "date_format");
 162
 163     INIT_FIELD(context, bool, log_utc,
 164                FALSE, "log_utc");
 165
 166
 167
 168     /* init dns-proxy slime */
 169     tmp = krb5_config_get_string(context, NULL, "libdefaults",
 170                                  "dns_proxy", NULL);
 171     if(tmp)
 172         roken_gethostby_setup(context->http_proxy, tmp);
 173     krb5_free_host_realm (context, context->default_realms);
 174     context->default_realms = NULL;
 175
 176     {
 177         krb5_addresses addresses;
 178         char **adr, **a;
 179
 180         krb5_set_extra_addresses(context, NULL);
 181         adr = krb5_config_get_strings(context, NULL,
 182                                       "libdefaults",
 183                                       "extra_addresses",
 184                                       NULL);
 185         memset(&addresses, 0, sizeof(addresses));
 186         for(a = adr; a && *a; a++) {
 187             ret = krb5_parse_address(context, *a, &addresses);
 188             if (ret == 0) {
 189                 krb5_add_extra_addresses(context, &addresses);
 190                 krb5_free_addresses(context, &addresses);
 191             }
 192         }
 193         krb5_config_free_strings(adr);
 194
 195         krb5_set_ignore_addresses(context, NULL);
 196         adr = krb5_config_get_strings(context, NULL,
 197                                       "libdefaults",
 198                                       "ignore_addresses",
 199                                       NULL);
 200         memset(&addresses, 0, sizeof(addresses));
 201         for(a = adr; a && *a; a++) {
 202             ret = krb5_parse_address(context, *a, &addresses);
 203             if (ret == 0) {
 204                 krb5_add_ignore_addresses(context, &addresses);
 205                 krb5_free_addresses(context, &addresses);
 206             }
 207         }
 208         krb5_config_free_strings(adr);
 209     }
 210
 211     INIT_FIELD(context, bool, scan_interfaces, TRUE, "scan_interfaces");
 212     INIT_FIELD(context, int, fcache_vno, 0, "fcache_version");
 213     /* prefer dns_lookup_kdc over srv_lookup. */
 214     INIT_FIELD(context, bool, srv_lookup, TRUE, "srv_lookup");
 215     INIT_FIELD(context, bool, srv_lookup, context->srv_lookup, "dns_lookup_kdc");
 216     INIT_FIELD(context, int, large_msg_size, 1400, "large_message_size");
 217     INIT_FLAG(context, flags, KRB5_CTX_F_DNS_CANONICALIZE_HOSTNAME, TRUE, "dns_canonicalize_hostname");
 218     INIT_FLAG(context, flags, KRB5_CTX_F_CHECK_PAC, TRUE, "check_pac");
 219     context->default_cc_name = NULL;
 220     context->default_cc_name_set = 0;
 221
 222     ret = krb5_config_get_bool_default(context, NULL, FALSE,
 223                                        "libdefaults",
 224                                        "allow_weak_crypto", NULL);
 225     if (ret) {
 226         krb5_enctype_enable(context, ETYPE_DES_CBC_CRC);
 227         krb5_enctype_enable(context, ETYPE_DES_CBC_MD4);
 228         krb5_enctype_enable(context, ETYPE_DES_CBC_MD5);
 229         krb5_enctype_enable(context, ETYPE_DES_CBC_NONE);
 230         krb5_enctype_enable(context, ETYPE_DES_CFB64_NONE);
 231         krb5_enctype_enable(context, ETYPE_DES_PCBC_NONE);
 232     }
 233
 234     return 0;
 235 }
 236
 237 static krb5_error_code
 238 cc_ops_register(krb5_context context)
 239 {
 240     context->cc_ops = NULL;
 241     context->num_cc_ops = 0;
 242
 243     krb5_cc_register(context, &krb5_acc_ops, TRUE);
 244     krb5_cc_register(context, &krb5_fcc_ops, TRUE);
 245     krb5_cc_register(context, &krb5_mcc_ops, TRUE);
 246 #ifdef HAVE_SQLITE
 247     krb5_cc_register(context, &krb5_scc_ops, TRUE);
 248 #endif
 249 #ifdef HAVE_KCM
 250     krb5_cc_register(context, &krb5_kcm_ops, TRUE);
 251 #endif
 252     return 0;
 253 }
 254
 255 static krb5_error_code
 256 kt_ops_register(krb5_context context)
 257 {
 258     context->num_kt_types = 0;
 259     context->kt_types     = NULL;
 260
 261     krb5_kt_register (context, &krb5_fkt_ops);
 262     krb5_kt_register (context, &krb5_wrfkt_ops);
 263     krb5_kt_register (context, &krb5_javakt_ops);
 264     krb5_kt_register (context, &krb5_mkt_ops);
 265 #ifndef HEIMDAL_SMALLER
 266     krb5_kt_register (context, &krb5_akf_ops);
 267 #endif
 268     krb5_kt_register (context, &krb5_any_ops);
 269     return 0;
 270 }
 271
 272
 273 /**
 274  * Initializes the context structure and reads the configuration file
 275  * /etc/krb5.conf. The structure should be freed by calling
 276  * krb5_free_context() when it is no longer being used.
 277  *
 278  * @param context pointer to returned context
 279  *
 280  * @return Returns 0 to indicate success.  Otherwise an errno code is
 281  * returned.  Failure means either that something bad happened during
 282  * initialization (typically ENOMEM) or that Kerberos should not be
 283  * used ENXIO.
 284  *
 285  * @ingroup krb5
 286  */
 287
 288 krb5_error_code KRB5_LIB_FUNCTION
 289 krb5_init_context(krb5_context *context)
 290 {
 291     krb5_context p;
 292     krb5_error_code ret;
 293     char **files;
 294
 295     *context = NULL;
 296
 297     /* should have a run_once */
 298     bindtextdomain(HEIMDAL_TEXTDOMAIN, HEIMDAL_LOCALEDIR);
 299
 300     p = calloc(1, sizeof(*p));
 301     if(!p)
 302         return ENOMEM;
 303
 304     p->mutex = malloc(sizeof(HEIMDAL_MUTEX));
 305     if (p->mutex == NULL) {
 306         free(p);
 307         return ENOMEM;
 308     }
 309     HEIMDAL_MUTEX_init(p->mutex);
 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 in 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     if (context->mutex != NULL) {
 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         l = 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 to be freed.
 643  *
 644  * @return Returns 0 to indicate success. Otherwise an kerberos et
 645  * error code is returned, see krb5_get_error_message().
 646  *
 647  * @ingroup krb5
 648  */
 649
 650 void KRB5_LIB_FUNCTION
 651 krb5_free_config_files(char **filenames)
 652 {
 653     char **p;
 654     for(p = filenames; *p != NULL; p++)
 655         free(*p);
 656     free(filenames);
 657 }
 658
 659 /**
 660  * Returns the list of Kerberos encryption types sorted in order of
 661  * most preferred to least preferred encryption type.  Note that some
 662  * encryption types might be disabled, so you need to check with
 663  * krb5_enctype_valid() before using the encryption type.
 664  *
 665  * @return list of enctypes, terminated with ETYPE_NULL. Its a static
 666  * array completed into the Kerberos library so the content doesn't
 667  * need to be freed.
 668  *
 669  * @ingroup krb5
 670  */
 671
 672 const krb5_enctype * KRB5_LIB_FUNCTION
 673 krb5_kerberos_enctypes(krb5_context context)
 674 {
 675     static const krb5_enctype p[] = {
 676         ETYPE_AES256_CTS_HMAC_SHA1_96,
 677         ETYPE_AES128_CTS_HMAC_SHA1_96,
 678         ETYPE_DES3_CBC_SHA1,
 679         ETYPE_DES3_CBC_MD5,
 680         ETYPE_ARCFOUR_HMAC_MD5,
 681         ETYPE_DES_CBC_MD5,
 682         ETYPE_DES_CBC_MD4,
 683         ETYPE_DES_CBC_CRC,
 684         ETYPE_NULL
 685     };
 686     return p;
 687 }
 688
 689 /*
 690  * set `etype' to a malloced list of the default enctypes
 691  */
 692
 693 static krb5_error_code
 694 default_etypes(krb5_context context, krb5_enctype **etype)
 695 {
 696     const krb5_enctype *p;
 697     krb5_enctype *e = NULL, *ep;
 698     int i, n = 0;
 699
 700     p = krb5_kerberos_enctypes(context);
 701
 702     for (i = 0; p[i] != ETYPE_NULL; i++) {
 703         if (krb5_enctype_valid(context, p[i]) != 0)
 704             continue;
 705         ep = realloc(e, (n + 2) * sizeof(*e));
 706         if (ep == NULL) {
 707             free(e);
 708             krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", ""));
 709             return ENOMEM;
 710         }
 711         e = ep;
 712         e[n] = p[i];
 713         e[n + 1] = ETYPE_NULL;
 714         n++;
 715     }
 716     *etype = e;
 717     return 0;
 718 }
 719
 720 /**
 721  * Set the default encryption types that will be use in communcation
 722  * with the KDC, clients and servers.
 723  *
 724  * @param context Kerberos 5 context.
 725  * @param etypes Encryption types, array terminated with ETYPE_NULL (0).
 726  *
 727  * @return Returns 0 to indicate success. Otherwise an kerberos et
 728  * error code is returned, see krb5_get_error_message().
 729  *
 730  * @ingroup krb5
 731  */
 732
 733 krb5_error_code KRB5_LIB_FUNCTION
 734 krb5_set_default_in_tkt_etypes(krb5_context context,
 735                                const krb5_enctype *etypes)
 736 {
 737     krb5_enctype *p = NULL;
 738     int i;
 739
 740     if(etypes) {
 741         for (i = 0; etypes[i]; ++i) {
 742             krb5_error_code ret;
 743             ret = krb5_enctype_valid(context, etypes[i]);
 744             if (ret)
 745                 return ret;
 746         }
 747         ++i;
 748         ALLOC(p, i);
 749         if(!p) {
 750             krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", ""));
 751             return ENOMEM;
 752         }
 753         memmove(p, etypes, i * sizeof(krb5_enctype));
 754     }
 755     if(context->etypes)
 756         free(context->etypes);
 757     context->etypes = p;
 758     return 0;
 759 }
 760
 761 /**
 762  * Get the default encryption types that will be use in communcation
 763  * with the KDC, clients and servers.
 764  *
 765  * @param context Kerberos 5 context.
 766  * @param etypes Encryption types, array terminated with
 767  * ETYPE_NULL(0), caller should free array with krb5_xfree():
 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_get_default_in_tkt_etypes(krb5_context context,
 777                                krb5_enctype **etypes)
 778 {
 779     krb5_enctype *p;
 780     int i;
 781     krb5_error_code ret;
 782
 783     if(context->etypes) {
 784         for(i = 0; context->etypes[i]; i++);
 785         ++i;
 786         ALLOC(p, i);
 787         if(!p) {
 788             krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", ""));
 789             return ENOMEM;
 790         }
 791         memmove(p, context->etypes, i * sizeof(krb5_enctype));
 792     } else {
 793         ret = default_etypes(context, &p);
 794         if (ret)
 795             return ret;
 796     }
 797     *etypes = p;
 798     return 0;
 799 }
 800
 801 /**
 802  * Return the error string for the error code. The caller must not
 803  * free the string.
 804  *
 805  * @param context Kerberos 5 context.
 806  * @param code Kerberos error code.
 807  *
 808  * @return the error message matching code
 809  *
 810  * @ingroup krb5
 811  */
 812
 813 const char* KRB5_LIB_FUNCTION
 814 krb5_get_err_text(krb5_context context, krb5_error_code code)
 815 {
 816     const char *p = NULL;
 817     if(context != NULL)
 818         p = com_right(context->et_list, code);
 819     if(p == NULL)
 820         p = strerror(code);
 821     if (p == NULL)
 822         p = "Unknown error";
 823     return p;
 824 }
 825
 826 /**
 827  * Init the built-in ets in the Kerberos library.
 828  *
 829  * @param context kerberos context to add the ets too
 830  *
 831  * @ingroup krb5
 832  */
 833
 834 void KRB5_LIB_FUNCTION
 835 krb5_init_ets(krb5_context context)
 836 {
 837     if(context->et_list == NULL){
 838         krb5_add_et_list(context, initialize_krb5_error_table_r);
 839         bindtextdomain(COM_ERR_BINDDOMAIN_krb5, HEIMDAL_LOCALEDIR);
 840
 841         krb5_add_et_list(context, initialize_asn1_error_table_r);
 842         bindtextdomain(COM_ERR_BINDDOMAIN_asn1, HEIMDAL_LOCALEDIR);
 843
 844         krb5_add_et_list(context, initialize_heim_error_table_r);
 845         bindtextdomain(COM_ERR_BINDDOMAIN_heim, HEIMDAL_LOCALEDIR);
 846
 847         krb5_add_et_list(context, initialize_k524_error_table_r);
 848         bindtextdomain(COM_ERR_BINDDOMAIN_k524, HEIMDAL_LOCALEDIR);
 849
 850 #ifdef PKINIT
 851         krb5_add_et_list(context, initialize_hx_error_table_r);
 852         bindtextdomain(COM_ERR_BINDDOMAIN_hx, HEIMDAL_LOCALEDIR);
 853 #endif
 854     }
 855 }
 856
 857 /**
 858  * Make the kerberos library default to the admin KDC.
 859  *
 860  * @param context Kerberos 5 context.
 861  * @param flag boolean flag to select if the use the admin KDC or not.
 862  *
 863  * @ingroup krb5
 864  */
 865
 866 void KRB5_LIB_FUNCTION
 867 krb5_set_use_admin_kdc (krb5_context context, krb5_boolean flag)
 868 {
 869     context->use_admin_kdc = flag;
 870 }
 871
 872 /**
 873  * Make the kerberos library default to the admin KDC.
 874  *
 875  * @param context Kerberos 5 context.
 876  *
 877  * @return boolean flag to telling the context will use admin KDC as the default KDC.
 878  *
 879  * @ingroup krb5
 880  */
 881
 882 krb5_boolean KRB5_LIB_FUNCTION
 883 krb5_get_use_admin_kdc (krb5_context context)
 884 {
 885     return context->use_admin_kdc;
 886 }
 887
 888 /**
 889  * Add extra address to the address list that the library will add to
 890  * the client's address list when communicating with the KDC.
 891  *
 892  * @param context Kerberos 5 context.
 893  * @param addresses addreses to add
 894  *
 895  * @return Returns 0 to indicate success. Otherwise an kerberos et
 896  * error code is returned, see krb5_get_error_message().
 897  *
 898  * @ingroup krb5
 899  */
 900
 901 krb5_error_code KRB5_LIB_FUNCTION
 902 krb5_add_extra_addresses(krb5_context context, krb5_addresses *addresses)
 903 {
 904
 905     if(context->extra_addresses)
 906         return krb5_append_addresses(context,
 907                                      context->extra_addresses, addresses);
 908     else
 909         return krb5_set_extra_addresses(context, addresses);
 910 }
 911
 912 /**
 913  * Set extra address to the address list that the library will add to
 914  * the client's address list when communicating with the KDC.
 915  *
 916  * @param context Kerberos 5 context.
 917  * @param addresses addreses to set
 918  *
 919  * @return Returns 0 to indicate success. Otherwise an kerberos et
 920  * error code is returned, see krb5_get_error_message().
 921  *
 922  * @ingroup krb5
 923  */
 924
 925 krb5_error_code KRB5_LIB_FUNCTION
 926 krb5_set_extra_addresses(krb5_context context, const krb5_addresses *addresses)
 927 {
 928     if(context->extra_addresses)
 929         krb5_free_addresses(context, context->extra_addresses);
 930
 931     if(addresses == NULL) {
 932         if(context->extra_addresses != NULL) {
 933             free(context->extra_addresses);
 934             context->extra_addresses = NULL;
 935         }
 936         return 0;
 937     }
 938     if(context->extra_addresses == NULL) {
 939         context->extra_addresses = malloc(sizeof(*context->extra_addresses));
 940         if(context->extra_addresses == NULL) {
 941             krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", ""));
 942             return ENOMEM;
 943         }
 944     }
 945     return krb5_copy_addresses(context, addresses, context->extra_addresses);
 946 }
 947
 948 /**
 949  * Get extra address to the address list that the library will add to
 950  * the client's address list when communicating with the KDC.
 951  *
 952  * @param context Kerberos 5 context.
 953  * @param addresses addreses to set
 954  *
 955  * @return Returns 0 to indicate success. Otherwise an kerberos et
 956  * error code is returned, see krb5_get_error_message().
 957  *
 958  * @ingroup krb5
 959  */
 960
 961 krb5_error_code KRB5_LIB_FUNCTION
 962 krb5_get_extra_addresses(krb5_context context, krb5_addresses *addresses)
 963 {
 964     if(context->extra_addresses == NULL) {
 965         memset(addresses, 0, sizeof(*addresses));
 966         return 0;
 967     }
 968     return krb5_copy_addresses(context,context->extra_addresses, addresses);
 969 }
 970
 971 /**
 972  * Add extra addresses to ignore when fetching addresses from the
 973  * underlaying operating system.
 974  *
 975  * @param context Kerberos 5 context.
 976  * @param addresses addreses to ignore
 977  *
 978  * @return Returns 0 to indicate success. Otherwise an kerberos et
 979  * error code is returned, see krb5_get_error_message().
 980  *
 981  * @ingroup krb5
 982  */
 983
 984 krb5_error_code KRB5_LIB_FUNCTION
 985 krb5_add_ignore_addresses(krb5_context context, krb5_addresses *addresses)
 986 {
 987
 988     if(context->ignore_addresses)
 989         return krb5_append_addresses(context,
 990                                      context->ignore_addresses, addresses);
 991     else
 992         return krb5_set_ignore_addresses(context, addresses);
 993 }
 994
 995 /**
 996  * Set extra addresses to ignore when fetching addresses from the
 997  * underlaying operating system.
 998  *
 999  * @param context Kerberos 5 context.
1000  * @param addresses addreses to ignore
1001  *
1002  * @return Returns 0 to indicate success. Otherwise an kerberos et
1003  * error code is returned, see krb5_get_error_message().
1004  *
1005  * @ingroup krb5
1006  */
1007
1008 krb5_error_code KRB5_LIB_FUNCTION
1009 krb5_set_ignore_addresses(krb5_context context, const krb5_addresses *addresses)
1010 {
1011     if(context->ignore_addresses)
1012         krb5_free_addresses(context, context->ignore_addresses);
1013     if(addresses == NULL) {
1014         if(context->ignore_addresses != NULL) {
1015             free(context->ignore_addresses);
1016             context->ignore_addresses = NULL;
1017         }
1018         return 0;
1019     }
1020     if(context->ignore_addresses == NULL) {
1021         context->ignore_addresses = malloc(sizeof(*context->ignore_addresses));
1022         if(context->ignore_addresses == NULL) {
1023             krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", ""));
1024             return ENOMEM;
1025         }
1026     }
1027     return krb5_copy_addresses(context, addresses, context->ignore_addresses);
1028 }
1029
1030 /**
1031  * Get extra addresses to ignore when fetching addresses from the
1032  * underlaying operating system.
1033  *
1034  * @param context Kerberos 5 context.
1035  * @param addresses list addreses ignored
1036  *
1037  * @return Returns 0 to indicate success. Otherwise an kerberos et
1038  * error code is returned, see krb5_get_error_message().
1039  *
1040  * @ingroup krb5
1041  */
1042
1043 krb5_error_code KRB5_LIB_FUNCTION
1044 krb5_get_ignore_addresses(krb5_context context, krb5_addresses *addresses)
1045 {
1046     if(context->ignore_addresses == NULL) {
1047         memset(addresses, 0, sizeof(*addresses));
1048         return 0;
1049     }
1050     return krb5_copy_addresses(context, context->ignore_addresses, addresses);
1051 }
1052
1053 /**
1054  * Set version of fcache that the library should use.
1055  *
1056  * @param context Kerberos 5 context.
1057  * @param version version number.
1058  *
1059  * @return Returns 0 to indicate success. Otherwise an kerberos et
1060  * error code is returned, see krb5_get_error_message().
1061  *
1062  * @ingroup krb5
1063  */
1064
1065 krb5_error_code KRB5_LIB_FUNCTION
1066 krb5_set_fcache_version(krb5_context context, int version)
1067 {
1068     context->fcache_vno = version;
1069     return 0;
1070 }
1071
1072 /**
1073  * Get version of fcache that the library should use.
1074  *
1075  * @param context Kerberos 5 context.
1076  * @param version version number.
1077  *
1078  * @return Returns 0 to indicate success. Otherwise an kerberos et
1079  * error code is returned, see krb5_get_error_message().
1080  *
1081  * @ingroup krb5
1082  */
1083
1084 krb5_error_code KRB5_LIB_FUNCTION
1085 krb5_get_fcache_version(krb5_context context, int *version)
1086 {
1087     *version = context->fcache_vno;
1088     return 0;
1089 }
1090
1091 /**
1092  * Runtime check if the Kerberos library was complied with thread support.
1093  *
1094  * @return TRUE if the library was compiled with thread support, FALSE if not.
1095  *
1096  * @ingroup krb5
1097  */
1098
1099
1100 krb5_boolean KRB5_LIB_FUNCTION
1101 krb5_is_thread_safe(void)
1102 {
1103 #ifdef ENABLE_PTHREAD_SUPPORT
1104     return TRUE;
1105 #else
1106     return FALSE;
1107 #endif
1108 }
1109
1110 /**
1111  * Set if the library should use DNS to canonicalize hostnames.
1112  *
1113  * @param context Kerberos 5 context.
1114  * @param flag if its dns canonicalizion is used or not.
1115  *
1116  * @ingroup krb5
1117  */
1118
1119 void KRB5_LIB_FUNCTION
1120 krb5_set_dns_canonicalize_hostname (krb5_context context, krb5_boolean flag)
1121 {
1122     if (flag)
1123         context->flags |= KRB5_CTX_F_DNS_CANONICALIZE_HOSTNAME;
1124     else
1125         context->flags &= ~KRB5_CTX_F_DNS_CANONICALIZE_HOSTNAME;
1126 }
1127
1128 /**
1129  * Get if the library uses DNS to canonicalize hostnames.
1130  *
1131  * @param context Kerberos 5 context.
1132  *
1133  * @return return non zero if the library uses DNS to canonicalize hostnames.
1134  *
1135  * @ingroup krb5
1136  */
1137
1138 krb5_boolean KRB5_LIB_FUNCTION
1139 krb5_get_dns_canonicalize_hostname (krb5_context context)
1140 {
1141     return (context->flags & KRB5_CTX_F_DNS_CANONICALIZE_HOSTNAME) ? 1 : 0;
1142 }
1143
1144 /**
1145  * Get current offset in time to the KDC.
1146  *
1147  * @param context Kerberos 5 context.
1148  * @param sec seconds part of offset.
1149  * @param usec micro seconds part of offset.
1150  *
1151  * @return returns zero
1152  *
1153  * @ingroup krb5
1154  */
1155
1156 krb5_error_code KRB5_LIB_FUNCTION
1157 krb5_get_kdc_sec_offset (krb5_context context, int32_t *sec, int32_t *usec)
1158 {
1159     if (sec)
1160         *sec = context->kdc_sec_offset;
1161     if (usec)
1162         *usec = context->kdc_usec_offset;
1163     return 0;
1164 }
1165
1166 /**
1167  * Set current offset in time to the KDC.
1168  *
1169  * @param context Kerberos 5 context.
1170  * @param sec seconds part of offset.
1171  * @param usec micro seconds part of offset.
1172  *
1173  * @return returns zero
1174  *
1175  * @ingroup krb5
1176  */
1177
1178 krb5_error_code KRB5_LIB_FUNCTION
1179 krb5_set_kdc_sec_offset (krb5_context context, int32_t sec, int32_t usec)
1180 {
1181     context->kdc_sec_offset = sec;
1182     if (usec >= 0)
1183         context->kdc_usec_offset = usec;
1184     return 0;
1185 }
1186
1187 /**
1188  * Get max time skew allowed.
1189  *
1190  * @param context Kerberos 5 context.
1191  *
1192  * @return timeskew in seconds.
1193  *
1194  * @ingroup krb5
1195  */
1196
1197 time_t KRB5_LIB_FUNCTION
1198 krb5_get_max_time_skew (krb5_context context)
1199 {
1200     return context->max_skew;
1201 }
1202
1203 /**
1204  * Set max time skew allowed.
1205  *
1206  * @param context Kerberos 5 context.
1207  * @param t timeskew in seconds.
1208  *
1209  * @ingroup krb5
1210  */
1211
1212 void KRB5_LIB_FUNCTION
1213 krb5_set_max_time_skew (krb5_context context, time_t t)
1214 {
1215     context->max_skew = t;
1216 }