source4/heimdal/lib/krb5/principal.c

   1 /*
   2  * Copyright (c) 1997-2007 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 /**
  35  * @page krb5_principal_intro The principal handing functions.
  36  *
  37  * A Kerberos principal is a email address looking string that
  38  * contains to parts separeted by a @.  The later part is the kerbero
  39  * realm the principal belongs to and the former is a list of 0 or
  40  * more components. For example
  41  * @verbatim
  42 lha@SU.SE
  43 host/hummel.it.su.se@SU.SE
  44 host/admin@H5L.ORG
  45 @endverbatim
  46  *
  47  * See the library functions here: @ref krb5_principal
  48  */
  49
  50 #include "krb5_locl.h"
  51 #ifdef HAVE_RES_SEARCH
  52 #define USE_RESOLVER
  53 #endif
  54 #ifdef HAVE_ARPA_NAMESER_H
  55 #include <arpa/nameser.h>
  56 #endif
  57 #include <fnmatch.h>
  58 #include "resolve.h"
  59
  60 #define princ_num_comp(P) ((P)->name.name_string.len)
  61 #define princ_type(P) ((P)->name.name_type)
  62 #define princ_comp(P) ((P)->name.name_string.val)
  63 #define princ_ncomp(P, N) ((P)->name.name_string.val[(N)])
  64 #define princ_realm(P) ((P)->realm)
  65
  66 /**
  67  * Frees a Kerberos principal allocated by the library with
  68  * krb5_parse_name(), krb5_make_principal() or any other related
  69  * principal functions.
  70  *
  71  * @param context A Kerberos context.
  72  * @param p a principal to free.
  73  *
  74  * @return An krb5 error code, see krb5_get_error_message().
  75  *
  76  * @ingroup krb5_principal
  77  */
  78
  79 void KRB5_LIB_FUNCTION
  80 krb5_free_principal(krb5_context context,
  81                     krb5_principal p)
  82 {
  83     if(p){
  84         free_Principal(p);
  85         free(p);
  86     }
  87 }
  88
  89 /**
  90  * Set the type of the principal
  91  *
  92  * @param context A Kerberos context.
  93  * @param principal principal to set the type for
  94  * @param type the new type
  95  *
  96  * @return An krb5 error code, see krb5_get_error_message().
  97  *
  98  * @ingroup krb5_principal
  99  */
 100
 101 void KRB5_LIB_FUNCTION
 102 krb5_principal_set_type(krb5_context context,
 103                         krb5_principal principal,
 104                         int type)
 105 {
 106     princ_type(principal) = type;
 107 }
 108
 109 int KRB5_LIB_FUNCTION
 110 krb5_principal_get_type(krb5_context context,
 111                         krb5_const_principal principal)
 112 {
 113     return princ_type(principal);
 114 }
 115
 116 const char* KRB5_LIB_FUNCTION
 117 krb5_principal_get_realm(krb5_context context,
 118                          krb5_const_principal principal)
 119 {
 120     return princ_realm(principal);
 121 }
 122
 123 const char* KRB5_LIB_FUNCTION
 124 krb5_principal_get_comp_string(krb5_context context,
 125                                krb5_const_principal principal,
 126                                unsigned int component)
 127 {
 128     if(component >= princ_num_comp(principal))
 129        return NULL;
 130     return princ_ncomp(principal, component);
 131 }
 132
 133 /**
 134  * Get number of component is principal.
 135  *
 136  * @param context Kerberos 5 context
 137  * @param principal principal to query
 138  *
 139  * @return number of components in string
 140  *
 141  * @ingroup krb5_principal
 142  */
 143
 144 unsigned int KRB5_LIB_FUNCTION
 145 krb5_principal_get_num_comp(krb5_context context,
 146                             krb5_const_principal principal)
 147 {
 148     return princ_num_comp(principal);
 149 }
 150
 151 krb5_error_code KRB5_LIB_FUNCTION
 152 krb5_parse_name_flags(krb5_context context,
 153                       const char *name,
 154                       int flags,
 155                       krb5_principal *principal)
 156 {
 157     krb5_error_code ret;
 158     heim_general_string *comp;
 159     heim_general_string realm = NULL;
 160     int ncomp;
 161
 162     const char *p;
 163     char *q;
 164     char *s;
 165     char *start;
 166
 167     int n;
 168     char c;
 169     int got_realm = 0;
 170     int first_at = 1;
 171     int enterprise = (flags & KRB5_PRINCIPAL_PARSE_ENTERPRISE);
 172
 173     *principal = NULL;
 174
 175 #define RFLAGS (KRB5_PRINCIPAL_PARSE_NO_REALM|KRB5_PRINCIPAL_PARSE_REQUIRE_REALM)
 176
 177     if ((flags & RFLAGS) == RFLAGS) {
 178         krb5_set_error_message(context, KRB5_ERR_NO_SERVICE,
 179                                N_("Can't require both realm and "
 180                                   "no realm at the same time", ""));
 181         return KRB5_ERR_NO_SERVICE;
 182     }
 183 #undef RFLAGS
 184
 185     /* count number of component,
 186      * enterprise names only have one component
 187      */
 188     ncomp = 1;
 189     if (!enterprise) {
 190         for(p = name; *p; p++){
 191             if(*p=='\\'){
 192                 if(!p[1]) {
 193                     krb5_set_error_message(context, KRB5_PARSE_MALFORMED,
 194                                            N_("trailing \\ in principal name", ""));
 195                     return KRB5_PARSE_MALFORMED;
 196                 }
 197                 p++;
 198             } else if(*p == '/')
 199                 ncomp++;
 200             else if(*p == '@')
 201                 break;
 202         }
 203     }
 204     comp = calloc(ncomp, sizeof(*comp));
 205     if (comp == NULL) {
 206         krb5_set_error_message(context, ENOMEM,
 207                                N_("malloc: out of memory", ""));
 208         return ENOMEM;
 209     }
 210
 211     n = 0;
 212     p = start = q = s = strdup(name);
 213     if (start == NULL) {
 214         free (comp);
 215         krb5_set_error_message(context, ENOMEM,
 216                                N_("malloc: out of memory", ""));
 217         return ENOMEM;
 218     }
 219     while(*p){
 220         c = *p++;
 221         if(c == '\\'){
 222             c = *p++;
 223             if(c == 'n')
 224                 c = '\n';
 225             else if(c == 't')
 226                 c = '\t';
 227             else if(c == 'b')
 228                 c = '\b';
 229             else if(c == '0')
 230                 c = '\0';
 231             else if(c == '\0') {
 232                 ret = KRB5_PARSE_MALFORMED;
 233                 krb5_set_error_message(context, ret,
 234                                        N_("trailing \\ in principal name", ""));
 235                 goto exit;
 236             }
 237         }else if(enterprise && first_at) {
 238             if (c == '@')
 239                 first_at = 0;
 240         }else if((c == '/' && !enterprise) || c == '@'){
 241             if(got_realm){
 242                 ret = KRB5_PARSE_MALFORMED;
 243                 krb5_set_error_message(context, ret,
 244                                        N_("part after realm in principal name", ""));
 245                 goto exit;
 246             }else{
 247                 comp[n] = malloc(q - start + 1);
 248                 if (comp[n] == NULL) {
 249                     ret = ENOMEM;
 250                     krb5_set_error_message(context, ret,
 251                                            N_("malloc: out of memory", ""));
 252                     goto exit;
 253                 }
 254                 memcpy(comp[n], start, q - start);
 255                 comp[n][q - start] = 0;
 256                 n++;
 257             }
 258             if(c == '@')
 259                 got_realm = 1;
 260             start = q;
 261             continue;
 262         }
 263         if(got_realm && (c == '/' || c == '\0')) {
 264             ret = KRB5_PARSE_MALFORMED;
 265             krb5_set_error_message(context, ret,
 266                                    N_("part after realm in principal name", ""));
 267             goto exit;
 268         }
 269         *q++ = c;
 270     }
 271     if(got_realm){
 272         if (flags & KRB5_PRINCIPAL_PARSE_NO_REALM) {
 273             ret = KRB5_PARSE_MALFORMED;
 274             krb5_set_error_message(context, ret,
 275                                    N_("realm found in 'short' principal "
 276                                       "expected to be without one", ""));
 277             goto exit;
 278         }
 279         realm = malloc(q - start + 1);
 280         if (realm == NULL) {
 281             ret = ENOMEM;
 282             krb5_set_error_message(context, ret,
 283                                    N_("malloc: out of memory", ""));
 284             goto exit;
 285         }
 286         memcpy(realm, start, q - start);
 287         realm[q - start] = 0;
 288     }else{
 289         if (flags & KRB5_PRINCIPAL_PARSE_REQUIRE_REALM) {
 290             ret = KRB5_PARSE_MALFORMED;
 291             krb5_set_error_message(context, ret,
 292                                    N_("realm NOT found in principal "
 293                                       "expected to be with one", ""));
 294             goto exit;
 295         } else if (flags & KRB5_PRINCIPAL_PARSE_NO_REALM) {
 296             realm = NULL;
 297         } else {
 298             ret = krb5_get_default_realm (context, &realm);
 299             if (ret)
 300                 goto exit;
 301         }
 302
 303         comp[n] = malloc(q - start + 1);
 304         if (comp[n] == NULL) {
 305             ret = ENOMEM;
 306             krb5_set_error_message(context, ret,
 307                                    N_("malloc: out of memory", ""));
 308             goto exit;
 309         }
 310         memcpy(comp[n], start, q - start);
 311         comp[n][q - start] = 0;
 312         n++;
 313     }
 314     *principal = malloc(sizeof(**principal));
 315     if (*principal == NULL) {
 316         ret = ENOMEM;
 317         krb5_set_error_message(context, ret,
 318                                N_("malloc: out of memory", ""));
 319         goto exit;
 320     }
 321     if (enterprise)
 322         (*principal)->name.name_type = KRB5_NT_ENTERPRISE_PRINCIPAL;
 323     else
 324         (*principal)->name.name_type = KRB5_NT_PRINCIPAL;
 325     (*principal)->name.name_string.val = comp;
 326     princ_num_comp(*principal) = n;
 327     (*principal)->realm = realm;
 328     free(s);
 329     return 0;
 330 exit:
 331     while(n>0){
 332         free(comp[--n]);
 333     }
 334     free(comp);
 335     free(realm);
 336     free(s);
 337     return ret;
 338 }
 339
 340 krb5_error_code KRB5_LIB_FUNCTION
 341 krb5_parse_name(krb5_context context,
 342                 const char *name,
 343                 krb5_principal *principal)
 344 {
 345     return krb5_parse_name_flags(context, name, 0, principal);
 346 }
 347
 348 static const char quotable_chars[] = " \n\t\b\\/@";
 349 static const char replace_chars[] = " ntb\\/@";
 350 static const char nq_chars[] = "    \\/@";
 351
 352 #define add_char(BASE, INDEX, LEN, C) do { if((INDEX) < (LEN)) (BASE)[(INDEX)++] = (C); }while(0);
 353
 354 static size_t
 355 quote_string(const char *s, char *out, size_t idx, size_t len, int display)
 356 {
 357     const char *p, *q;
 358     for(p = s; *p && idx < len; p++){
 359         q = strchr(quotable_chars, *p);
 360         if (q && display) {
 361             add_char(out, idx, len, replace_chars[q - quotable_chars]);
 362         } else if (q) {
 363             add_char(out, idx, len, '\\');
 364             add_char(out, idx, len, replace_chars[q - quotable_chars]);
 365         }else
 366             add_char(out, idx, len, *p);
 367     }
 368     if(idx < len)
 369         out[idx] = '\0';
 370     return idx;
 371 }
 372
 373
 374 static krb5_error_code
 375 unparse_name_fixed(krb5_context context,
 376                    krb5_const_principal principal,
 377                    char *name,
 378                    size_t len,
 379                    int flags)
 380 {
 381     size_t idx = 0;
 382     int i;
 383     int short_form = (flags & KRB5_PRINCIPAL_UNPARSE_SHORT) != 0;
 384     int no_realm = (flags & KRB5_PRINCIPAL_UNPARSE_NO_REALM) != 0;
 385     int display = (flags & KRB5_PRINCIPAL_UNPARSE_DISPLAY) != 0;
 386
 387     if (!no_realm && princ_realm(principal) == NULL) {
 388         krb5_set_error_message(context, ERANGE,
 389                                N_("Realm missing from principal, "
 390                                   "can't unparse", ""));
 391         return ERANGE;
 392     }
 393
 394     for(i = 0; i < princ_num_comp(principal); i++){
 395         if(i)
 396             add_char(name, idx, len, '/');
 397         idx = quote_string(princ_ncomp(principal, i), name, idx, len, display);
 398         if(idx == len) {
 399             krb5_set_error_message(context, ERANGE,
 400                                    N_("Out of space printing principal", ""));
 401             return ERANGE;
 402         }
 403     }
 404     /* add realm if different from default realm */
 405     if(short_form && !no_realm) {
 406         krb5_realm r;
 407         krb5_error_code ret;
 408         ret = krb5_get_default_realm(context, &r);
 409         if(ret)
 410             return ret;
 411         if(strcmp(princ_realm(principal), r) != 0)
 412             short_form = 0;
 413         free(r);
 414     }
 415     if(!short_form && !no_realm) {
 416         add_char(name, idx, len, '@');
 417         idx = quote_string(princ_realm(principal), name, idx, len, display);
 418         if(idx == len) {
 419             krb5_set_error_message(context, ERANGE,
 420                                    N_("Out of space printing "
 421                                       "realm of principal", ""));
 422             return ERANGE;
 423         }
 424     }
 425     return 0;
 426 }
 427
 428 /**
 429  * Unparse the principal name to a fixed buffer
 430  *
 431  * @param context A Kerberos context.
 432  * @param principal principal to unparse
 433  * @param name buffer to write name to
 434  * @param len length of buffer
 435  *
 436  * @return An krb5 error code, see krb5_get_error_message().
 437  *
 438  * @ingroup krb5_principal
 439  */
 440
 441 krb5_error_code KRB5_LIB_FUNCTION
 442 krb5_unparse_name_fixed(krb5_context context,
 443                         krb5_const_principal principal,
 444                         char *name,
 445                         size_t len)
 446 {
 447     return unparse_name_fixed(context, principal, name, len, 0);
 448 }
 449
 450 /**
 451  * Unparse the principal name to a fixed buffer. The realm is skipped
 452  * if its a default realm.
 453  *
 454  * @param context A Kerberos context.
 455  * @param principal principal to unparse
 456  * @param name buffer to write name to
 457  * @param len length of buffer
 458  *
 459  * @return An krb5 error code, see krb5_get_error_message().
 460  *
 461  * @ingroup krb5_principal
 462  */
 463
 464 krb5_error_code KRB5_LIB_FUNCTION
 465 krb5_unparse_name_fixed_short(krb5_context context,
 466                               krb5_const_principal principal,
 467                               char *name,
 468                               size_t len)
 469 {
 470     return unparse_name_fixed(context, principal, name, len,
 471                               KRB5_PRINCIPAL_UNPARSE_SHORT);
 472 }
 473
 474 /**
 475  * Unparse the principal name with unparse flags to a fixed buffer.
 476  *
 477  * @param context A Kerberos context.
 478  * @param principal principal to unparse
 479  * @param flags unparse flags
 480  * @param name buffer to write name to
 481  * @param len length of buffer
 482  *
 483  * @return An krb5 error code, see krb5_get_error_message().
 484  *
 485  * @ingroup krb5_principal
 486  */
 487
 488 krb5_error_code KRB5_LIB_FUNCTION
 489 krb5_unparse_name_fixed_flags(krb5_context context,
 490                               krb5_const_principal principal,
 491                               int flags,
 492                               char *name,
 493                               size_t len)
 494 {
 495     return unparse_name_fixed(context, principal, name, len, flags);
 496 }
 497
 498 static krb5_error_code
 499 unparse_name(krb5_context context,
 500              krb5_const_principal principal,
 501              char **name,
 502              int flags)
 503 {
 504     size_t len = 0, plen;
 505     int i;
 506     krb5_error_code ret;
 507     /* count length */
 508     if (princ_realm(principal)) {
 509         plen = strlen(princ_realm(principal));
 510
 511         if(strcspn(princ_realm(principal), quotable_chars) == plen)
 512             len += plen;
 513         else
 514             len += 2*plen;
 515         len++; /* '@' */
 516     }
 517     for(i = 0; i < princ_num_comp(principal); i++){
 518         plen = strlen(princ_ncomp(principal, i));
 519         if(strcspn(princ_ncomp(principal, i), quotable_chars) == plen)
 520             len += plen;
 521         else
 522             len += 2*plen;
 523         len++;
 524     }
 525     len++; /* '\0' */
 526     *name = malloc(len);
 527     if(*name == NULL) {
 528         krb5_set_error_message(context, ENOMEM,
 529                                N_("malloc: out of memory", ""));
 530         return ENOMEM;
 531     }
 532     ret = unparse_name_fixed(context, principal, *name, len, flags);
 533     if(ret) {
 534         free(*name);
 535         *name = NULL;
 536     }
 537     return ret;
 538 }
 539
 540 /**
 541  * Unparse the Kerberos name into a string
 542  *
 543  * @param context Kerberos 5 context
 544  * @param principal principal to query
 545  * @param name resulting string, free with krb5_xfree()
 546  *
 547  * @return An krb5 error code, see krb5_get_error_message().
 548  *
 549  * @ingroup krb5_principal
 550  */
 551
 552 krb5_error_code KRB5_LIB_FUNCTION
 553 krb5_unparse_name(krb5_context context,
 554                   krb5_const_principal principal,
 555                   char **name)
 556 {
 557     return unparse_name(context, principal, name, 0);
 558 }
 559
 560 /**
 561  * Unparse the Kerberos name into a string
 562  *
 563  * @param context Kerberos 5 context
 564  * @param principal principal to query
 565  * @param flags flag to determine the behavior
 566  * @param name resulting string, free with krb5_xfree()
 567  *
 568  * @return An krb5 error code, see krb5_get_error_message().
 569  *
 570  * @ingroup krb5_principal
 571  */
 572
 573 krb5_error_code KRB5_LIB_FUNCTION
 574 krb5_unparse_name_flags(krb5_context context,
 575                         krb5_const_principal principal,
 576                         int flags,
 577                         char **name)
 578 {
 579     return unparse_name(context, principal, name, flags);
 580 }
 581
 582 /**
 583  * Unparse the principal name to a allocated buffer. The realm is
 584  * skipped if its a default realm.
 585  *
 586  * @param context A Kerberos context.
 587  * @param principal principal to unparse
 588  * @param name returned buffer, free with krb5_xfree()
 589  *
 590  * @return An krb5 error code, see krb5_get_error_message().
 591  *
 592  * @ingroup krb5_principal
 593  */
 594
 595 krb5_error_code KRB5_LIB_FUNCTION
 596 krb5_unparse_name_short(krb5_context context,
 597                         krb5_const_principal principal,
 598                         char **name)
 599 {
 600     return unparse_name(context, principal, name, KRB5_PRINCIPAL_UNPARSE_SHORT);
 601 }
 602
 603 /**
 604  * Set a new realm for a principal, and as a side-effect free the
 605  * previous realm.
 606  *
 607  * @param context A Kerberos context.
 608  * @param principal principal set the realm for
 609  * @param realm the new realm to set
 610  *
 611  * @return An krb5 error code, see krb5_get_error_message().
 612  *
 613  * @ingroup krb5_principal
 614  */
 615
 616 krb5_error_code KRB5_LIB_FUNCTION
 617 krb5_principal_set_realm(krb5_context context,
 618                          krb5_principal principal,
 619                          krb5_const_realm realm)
 620 {
 621     if (princ_realm(principal))
 622         free(princ_realm(principal));
 623
 624     princ_realm(principal) = strdup(realm);
 625     if (princ_realm(principal) == NULL) {
 626         krb5_set_error_message(context, ENOMEM,
 627                                N_("malloc: out of memory", ""));
 628         return ENOMEM;
 629     }
 630     return 0;
 631 }
 632
 633
 634 krb5_error_code KRB5_LIB_FUNCTION
 635 krb5_build_principal(krb5_context context,
 636                      krb5_principal *principal,
 637                      int rlen,
 638                      krb5_const_realm realm,
 639                      ...)
 640 {
 641     krb5_error_code ret;
 642     va_list ap;
 643     va_start(ap, realm);
 644     ret = krb5_build_principal_va(context, principal, rlen, realm, ap);
 645     va_end(ap);
 646     return ret;
 647 }
 648
 649 static krb5_error_code
 650 append_component(krb5_context context, krb5_principal p,
 651                  const char *comp,
 652                  size_t comp_len)
 653 {
 654     heim_general_string *tmp;
 655     size_t len = princ_num_comp(p);
 656
 657     tmp = realloc(princ_comp(p), (len + 1) * sizeof(*tmp));
 658     if(tmp == NULL) {
 659         krb5_set_error_message(context, ENOMEM,
 660                                N_("malloc: out of memory", ""));
 661         return ENOMEM;
 662     }
 663     princ_comp(p) = tmp;
 664     princ_ncomp(p, len) = malloc(comp_len + 1);
 665     if (princ_ncomp(p, len) == NULL) {
 666         krb5_set_error_message(context, ENOMEM,
 667                                N_("malloc: out of memory", ""));
 668         return ENOMEM;
 669     }
 670     memcpy (princ_ncomp(p, len), comp, comp_len);
 671     princ_ncomp(p, len)[comp_len] = '\0';
 672     princ_num_comp(p)++;
 673     return 0;
 674 }
 675
 676 static void
 677 va_ext_princ(krb5_context context, krb5_principal p, va_list ap)
 678 {
 679     while(1){
 680         const char *s;
 681         int len;
 682         len = va_arg(ap, int);
 683         if(len == 0)
 684             break;
 685         s = va_arg(ap, const char*);
 686         append_component(context, p, s, len);
 687     }
 688 }
 689
 690 static void
 691 va_princ(krb5_context context, krb5_principal p, va_list ap)
 692 {
 693     while(1){
 694         const char *s;
 695         s = va_arg(ap, const char*);
 696         if(s == NULL)
 697             break;
 698         append_component(context, p, s, strlen(s));
 699     }
 700 }
 701
 702 static krb5_error_code
 703 build_principal(krb5_context context,
 704                 krb5_principal *principal,
 705                 int rlen,
 706                 krb5_const_realm realm,
 707                 void (*func)(krb5_context, krb5_principal, va_list),
 708                 va_list ap)
 709 {
 710     krb5_principal p;
 711
 712     p = calloc(1, sizeof(*p));
 713     if (p == NULL) {
 714         krb5_set_error_message(context, ENOMEM,
 715                                N_("malloc: out of memory", ""));
 716         return ENOMEM;
 717     }
 718     princ_type(p) = KRB5_NT_PRINCIPAL;
 719
 720     princ_realm(p) = strdup(realm);
 721     if(p->realm == NULL){
 722         free(p);
 723         krb5_set_error_message(context, ENOMEM,
 724                                N_("malloc: out of memory", ""));
 725         return ENOMEM;
 726     }
 727
 728     (*func)(context, p, ap);
 729     *principal = p;
 730     return 0;
 731 }
 732
 733 krb5_error_code KRB5_LIB_FUNCTION
 734 krb5_make_principal(krb5_context context,
 735                     krb5_principal *principal,
 736                     krb5_const_realm realm,
 737                     ...)
 738 {
 739     krb5_error_code ret;
 740     krb5_realm r = NULL;
 741     va_list ap;
 742     if(realm == NULL) {
 743         ret = krb5_get_default_realm(context, &r);
 744         if(ret)
 745             return ret;
 746         realm = r;
 747     }
 748     va_start(ap, realm);
 749     ret = krb5_build_principal_va(context, principal, strlen(realm), realm, ap);
 750     va_end(ap);
 751     if(r)
 752         free(r);
 753     return ret;
 754 }
 755
 756 krb5_error_code KRB5_LIB_FUNCTION
 757 krb5_build_principal_va(krb5_context context,
 758                         krb5_principal *principal,
 759                         int rlen,
 760                         krb5_const_realm realm,
 761                         va_list ap)
 762 {
 763     return build_principal(context, principal, rlen, realm, va_princ, ap);
 764 }
 765
 766 krb5_error_code KRB5_LIB_FUNCTION
 767 krb5_build_principal_va_ext(krb5_context context,
 768                             krb5_principal *principal,
 769                             int rlen,
 770                             krb5_const_realm realm,
 771                             va_list ap)
 772 {
 773     return build_principal(context, principal, rlen, realm, va_ext_princ, ap);
 774 }
 775
 776
 777 krb5_error_code KRB5_LIB_FUNCTION
 778 krb5_build_principal_ext(krb5_context context,
 779                          krb5_principal *principal,
 780                          int rlen,
 781                          krb5_const_realm realm,
 782                          ...)
 783 {
 784     krb5_error_code ret;
 785     va_list ap;
 786     va_start(ap, realm);
 787     ret = krb5_build_principal_va_ext(context, principal, rlen, realm, ap);
 788     va_end(ap);
 789     return ret;
 790 }
 791
 792
 793 krb5_error_code KRB5_LIB_FUNCTION
 794 krb5_copy_principal(krb5_context context,
 795                     krb5_const_principal inprinc,
 796                     krb5_principal *outprinc)
 797 {
 798     krb5_principal p = malloc(sizeof(*p));
 799     if (p == NULL) {
 800         krb5_set_error_message(context, ENOMEM,
 801                                N_("malloc: out of memory", ""));
 802         return ENOMEM;
 803     }
 804     if(copy_Principal(inprinc, p)) {
 805         free(p);
 806         krb5_set_error_message(context, ENOMEM,
 807                                N_("malloc: out of memory", ""));
 808         return ENOMEM;
 809     }
 810     *outprinc = p;
 811     return 0;
 812 }
 813
 814 /**
 815  * Return TRUE iff princ1 == princ2 (without considering the realm)
 816  *
 817  * @param context Kerberos 5 context
 818  * @param princ1 first principal to compare
 819  * @param princ2 second principal to compare
 820  *
 821  * @return non zero if equal, 0 if not
 822  *
 823  * @ingroup krb5_principal
 824  */
 825
 826 krb5_boolean KRB5_LIB_FUNCTION
 827 krb5_principal_compare_any_realm(krb5_context context,
 828                                  krb5_const_principal princ1,
 829                                  krb5_const_principal princ2)
 830 {
 831     int i;
 832     if(princ_num_comp(princ1) != princ_num_comp(princ2))
 833         return FALSE;
 834     for(i = 0; i < princ_num_comp(princ1); i++){
 835         if(strcmp(princ_ncomp(princ1, i), princ_ncomp(princ2, i)) != 0)
 836             return FALSE;
 837     }
 838     return TRUE;
 839 }
 840
 841 krb5_boolean KRB5_LIB_FUNCTION
 842 _krb5_principal_compare_PrincipalName(krb5_context context,
 843                                       krb5_const_principal princ1,
 844                                       PrincipalName *princ2)
 845 {
 846     int i;
 847     if (princ_num_comp(princ1) != princ2->name_string.len)
 848         return FALSE;
 849     for(i = 0; i < princ_num_comp(princ1); i++){
 850         if(strcmp(princ_ncomp(princ1, i), princ2->name_string.val[i]) != 0)
 851             return FALSE;
 852     }
 853     return TRUE;
 854 }
 855
 856
 857 /*
 858  * return TRUE iff princ1 == princ2
 859  */
 860
 861 krb5_boolean KRB5_LIB_FUNCTION
 862 krb5_principal_compare(krb5_context context,
 863                        krb5_const_principal princ1,
 864                        krb5_const_principal princ2)
 865 {
 866     if(!krb5_realm_compare(context, princ1, princ2))
 867         return FALSE;
 868     return krb5_principal_compare_any_realm(context, princ1, princ2);
 869 }
 870
 871 /*
 872  * return TRUE iff realm(princ1) == realm(princ2)
 873  */
 874
 875 krb5_boolean KRB5_LIB_FUNCTION
 876 krb5_realm_compare(krb5_context context,
 877                    krb5_const_principal princ1,
 878                    krb5_const_principal princ2)
 879 {
 880     return strcmp(princ_realm(princ1), princ_realm(princ2)) == 0;
 881 }
 882
 883 /*
 884  * return TRUE iff princ matches pattern
 885  */
 886
 887 krb5_boolean KRB5_LIB_FUNCTION
 888 krb5_principal_match(krb5_context context,
 889                      krb5_const_principal princ,
 890                      krb5_const_principal pattern)
 891 {
 892     int i;
 893     if(princ_num_comp(princ) != princ_num_comp(pattern))
 894         return FALSE;
 895     if(fnmatch(princ_realm(pattern), princ_realm(princ), 0) != 0)
 896         return FALSE;
 897     for(i = 0; i < princ_num_comp(princ); i++){
 898         if(fnmatch(princ_ncomp(pattern, i), princ_ncomp(princ, i), 0) != 0)
 899             return FALSE;
 900     }
 901     return TRUE;
 902 }
 903
 904 #if defined(KRB4) || !defined(HEIMDAL_SMALLER)
 905
 906 static struct v4_name_convert {
 907     const char *from;
 908     const char *to;
 909 } default_v4_name_convert[] = {
 910     { "ftp",    "ftp" },
 911     { "hprop",  "hprop" },
 912     { "pop",    "pop" },
 913     { "imap",   "imap" },
 914     { "rcmd",   "host" },
 915     { "smtp",   "smtp" },
 916     { NULL, NULL }
 917 };
 918
 919 #endif
 920
 921 #ifdef KRB4
 922
 923 /*
 924  * return the converted instance name of `name' in `realm'.
 925  * look in the configuration file and then in the default set above.
 926  * return NULL if no conversion is appropriate.
 927  */
 928
 929 static const char*
 930 get_name_conversion(krb5_context context, const char *realm, const char *name)
 931 {
 932     struct v4_name_convert *q;
 933     const char *p;
 934
 935     p = krb5_config_get_string(context, NULL, "realms", realm,
 936                                "v4_name_convert", "host", name, NULL);
 937     if(p == NULL)
 938         p = krb5_config_get_string(context, NULL, "libdefaults",
 939                                    "v4_name_convert", "host", name, NULL);
 940     if(p)
 941         return p;
 942
 943     /* XXX should be possible to override default list */
 944     p = krb5_config_get_string(context, NULL,
 945                                "realms",
 946                                realm,
 947                                "v4_name_convert",
 948                                "plain",
 949                                name,
 950                                NULL);
 951     if(p)
 952         return NULL;
 953     p = krb5_config_get_string(context, NULL,
 954                                "libdefaults",
 955                                "v4_name_convert",
 956                                "plain",
 957                                name,
 958                                NULL);
 959     if(p)
 960         return NULL;
 961     for(q = default_v4_name_convert; q->from; q++)
 962         if(strcmp(q->from, name) == 0)
 963             return q->to;
 964     return NULL;
 965 }
 966
 967 /*
 968  * convert the v4 principal `name.instance@realm' to a v5 principal in `princ'.
 969  * if `resolve', use DNS.
 970  * if `func', use that function for validating the conversion
 971  */
 972
 973 krb5_error_code KRB5_LIB_FUNCTION
 974 krb5_425_conv_principal_ext2(krb5_context context,
 975                              const char *name,
 976                              const char *instance,
 977                              const char *realm,
 978                              krb5_boolean (*func)(krb5_context,
 979                                                   void *, krb5_principal),
 980                              void *funcctx,
 981                              krb5_boolean resolve,
 982                              krb5_principal *princ)
 983 {
 984     const char *p;
 985     krb5_error_code ret;
 986     krb5_principal pr;
 987     char host[MAXHOSTNAMELEN];
 988     char local_hostname[MAXHOSTNAMELEN];
 989
 990     /* do the following: if the name is found in the
 991        `v4_name_convert:host' part, is assumed to be a `host' type
 992        principal, and the instance is looked up in the
 993        `v4_instance_convert' part. if not found there the name is
 994        (optionally) looked up as a hostname, and if that doesn't yield
 995        anything, the `default_domain' is appended to the instance
 996        */
 997
 998     if(instance == NULL)
 999         goto no_host;
1000     if(instance[0] == 0){
1001         instance = NULL;
1002         goto no_host;
1003     }
1004     p = get_name_conversion(context, realm, name);
1005     if(p == NULL)
1006         goto no_host;
1007     name = p;
1008     p = krb5_config_get_string(context, NULL, "realms", realm,
1009                                "v4_instance_convert", instance, NULL);
1010     if(p){
1011         instance = p;
1012         ret = krb5_make_principal(context, &pr, realm, name, instance, NULL);
1013         if (ret)
1014             return ret;
1015         if(func == NULL || (*func)(context, funcctx, pr)){
1016             *princ = pr;
1017             return 0;
1018         }
1019         krb5_free_principal(context, pr);
1020         *princ = NULL;
1021         krb5_clear_error_message (context);
1022         return HEIM_ERR_V4_PRINC_NO_CONV;
1023     }
1024     if(resolve){
1025         krb5_boolean passed = FALSE;
1026         char *inst = NULL;
1027 #ifdef USE_RESOLVER
1028         struct rk_dns_reply *r;
1029
1030         r = rk_dns_lookup(instance, "aaaa");
1031         if (r) {
1032             if (r->head && r->head->type == rk_ns_t_aaaa) {
1033                 inst = strdup(r->head->domain);
1034                 passed = TRUE;
1035             }
1036             rk_dns_free_data(r);
1037         } else {
1038             r = rk_dns_lookup(instance, "a");
1039             if (r) {
1040                 if(r->head && r->head->type == rk_ns_t_a) {
1041                     inst = strdup(r->head->domain);
1042                     passed = TRUE;
1043                 }
1044                 rk_dns_free_data(r);
1045             }
1046         }
1047 #else
1048         struct addrinfo hints, *ai;
1049
1050         memset (&hints, 0, sizeof(hints));
1051         hints.ai_flags = AI_CANONNAME;
1052         ret = getaddrinfo(instance, NULL, &hints, &ai);
1053         if (ret == 0) {
1054             const struct addrinfo *a;
1055             for (a = ai; a != NULL; a = a->ai_next) {
1056                 if (a->ai_canonname != NULL) {
1057                     inst = strdup (a->ai_canonname);
1058                     passed = TRUE;
1059                     break;
1060                 }
1061             }
1062             freeaddrinfo (ai);
1063         }
1064 #endif
1065         if (passed) {
1066             if (inst == NULL) {
1067                 krb5_set_error_message(context, ENOMEM,
1068                                        N_("malloc: out of memory", ""));
1069                 return ENOMEM;
1070             }
1071             strlwr(inst);
1072             ret = krb5_make_principal(context, &pr, realm, name, inst,
1073                                       NULL);
1074             free (inst);
1075             if(ret == 0) {
1076                 if(func == NULL || (*func)(context, funcctx, pr)){
1077                     *princ = pr;
1078                     return 0;
1079                 }
1080                 krb5_free_principal(context, pr);
1081             }
1082         }
1083     }
1084     if(func != NULL) {
1085         snprintf(host, sizeof(host), "%s.%s", instance, realm);
1086         strlwr(host);
1087         ret = krb5_make_principal(context, &pr, realm, name, host, NULL);
1088         if (ret)
1089             return ret;
1090         if((*func)(context, funcctx, pr)){
1091             *princ = pr;
1092             return 0;
1093         }
1094         krb5_free_principal(context, pr);
1095     }
1096
1097     /*
1098      * if the instance is the first component of the local hostname,
1099      * the converted host should be the long hostname.
1100      */
1101
1102     if (func == NULL &&
1103         gethostname (local_hostname, sizeof(local_hostname)) == 0 &&
1104         strncmp(instance, local_hostname, strlen(instance)) == 0 &&
1105         local_hostname[strlen(instance)] == '.') {
1106         strlcpy(host, local_hostname, sizeof(host));
1107         goto local_host;
1108     }
1109
1110     {
1111         char **domains, **d;
1112         domains = krb5_config_get_strings(context, NULL, "realms", realm,
1113                                           "v4_domains", NULL);
1114         for(d = domains; d && *d; d++){
1115             snprintf(host, sizeof(host), "%s.%s", instance, *d);
1116             ret = krb5_make_principal(context, &pr, realm, name, host, NULL);
1117             if (ret) {
1118                 krb5_config_free_strings(domains);
1119                 return ret;
1120             }
1121             if(func == NULL || (*func)(context, funcctx, pr)){
1122                 *princ = pr;
1123                 krb5_config_free_strings(domains);
1124                 return 0;
1125             }
1126             krb5_free_principal(context, pr);
1127         }
1128         krb5_config_free_strings(domains);
1129     }
1130
1131
1132     p = krb5_config_get_string(context, NULL, "realms", realm,
1133                                "default_domain", NULL);
1134     if(p == NULL){
1135         /* this should be an error, just faking a name is not good */
1136         krb5_clear_error_message (context);
1137         return HEIM_ERR_V4_PRINC_NO_CONV;
1138     }
1139
1140     if (*p == '.')
1141         ++p;
1142     snprintf(host, sizeof(host), "%s.%s", instance, p);
1143 local_host:
1144     ret = krb5_make_principal(context, &pr, realm, name, host, NULL);
1145     if (ret)
1146         return ret;
1147     if(func == NULL || (*func)(context, funcctx, pr)){
1148         *princ = pr;
1149         return 0;
1150     }
1151     krb5_free_principal(context, pr);
1152     krb5_clear_error_message (context);
1153     return HEIM_ERR_V4_PRINC_NO_CONV;
1154 no_host:
1155     p = krb5_config_get_string(context, NULL,
1156                                "realms",
1157                                realm,
1158                                "v4_name_convert",
1159                                "plain",
1160                                name,
1161                                NULL);
1162     if(p == NULL)
1163         p = krb5_config_get_string(context, NULL,
1164                                    "libdefaults",
1165                                    "v4_name_convert",
1166                                    "plain",
1167                                    name,
1168                                    NULL);
1169     if(p)
1170         name = p;
1171
1172     ret = krb5_make_principal(context, &pr, realm, name, instance, NULL);
1173     if (ret)
1174         return ret;
1175     if(func == NULL || (*func)(context, funcctx, pr)){
1176         *princ = pr;
1177         return 0;
1178     }
1179     krb5_free_principal(context, pr);
1180     krb5_clear_error_message (context);
1181     return HEIM_ERR_V4_PRINC_NO_CONV;
1182 }
1183
1184 #endif /* KRB4 */
1185
1186 #ifndef HEIMDAL_SMALLER
1187
1188 static int
1189 check_list(const krb5_config_binding *l, const char *name, const char **out)
1190 {
1191     while(l){
1192         if (l->type != krb5_config_string)
1193             continue;
1194         if(strcmp(name, l->u.string) == 0) {
1195             *out = l->name;
1196             return 1;
1197         }
1198         l = l->next;
1199     }
1200     return 0;
1201 }
1202
1203 static int
1204 name_convert(krb5_context context, const char *name, const char *realm,
1205              const char **out)
1206 {
1207     const krb5_config_binding *l;
1208     l = krb5_config_get_list (context,
1209                               NULL,
1210                               "realms",
1211                               realm,
1212                               "v4_name_convert",
1213                               "host",
1214                               NULL);
1215     if(l && check_list(l, name, out))
1216         return KRB5_NT_SRV_HST;
1217     l = krb5_config_get_list (context,
1218                               NULL,
1219                               "libdefaults",
1220                               "v4_name_convert",
1221                               "host",
1222                               NULL);
1223     if(l && check_list(l, name, out))
1224         return KRB5_NT_SRV_HST;
1225     l = krb5_config_get_list (context,
1226                               NULL,
1227                               "realms",
1228                               realm,
1229                               "v4_name_convert",
1230                               "plain",
1231                               NULL);
1232     if(l && check_list(l, name, out))
1233         return KRB5_NT_UNKNOWN;
1234     l = krb5_config_get_list (context,
1235                               NULL,
1236                               "libdefaults",
1237                               "v4_name_convert",
1238                               "host",
1239                               NULL);
1240     if(l && check_list(l, name, out))
1241         return KRB5_NT_UNKNOWN;
1242
1243     /* didn't find it in config file, try built-in list */
1244 #ifdef KRB4
1245     {
1246         struct v4_name_convert *q;
1247         for(q = default_v4_name_convert; q->from; q++) {
1248             if(strcmp(name, q->to) == 0) {
1249                 *out = q->from;
1250                 return KRB5_NT_SRV_HST;
1251             }
1252         }
1253     }
1254 #endif
1255     return -1;
1256 }
1257
1258 /*
1259  * convert the v5 principal in `principal' into a v4 corresponding one
1260  * in `name, instance, realm'
1261  * this is limited interface since there's no length given for these
1262  * three parameters.  They have to be 40 bytes each (ANAME_SZ).
1263  */
1264
1265 krb5_error_code KRB5_LIB_FUNCTION
1266 krb5_524_conv_principal(krb5_context context,
1267                         const krb5_principal principal,
1268                         char *name,
1269                         char *instance,
1270                         char *realm)
1271 {
1272     const char *n, *i, *r;
1273     char tmpinst[40];
1274     int type = princ_type(principal);
1275     const int aname_sz = 40;
1276
1277     r = principal->realm;
1278
1279     switch(principal->name.name_string.len){
1280     case 1:
1281         n = principal->name.name_string.val[0];
1282         i = "";
1283         break;
1284     case 2:
1285         n = principal->name.name_string.val[0];
1286         i = principal->name.name_string.val[1];
1287         break;
1288     default:
1289         krb5_set_error_message(context, KRB5_PARSE_MALFORMED,
1290                                N_("cannot convert a %d "
1291                                   "component principal", ""),
1292                                principal->name.name_string.len);
1293         return KRB5_PARSE_MALFORMED;
1294     }
1295
1296     {
1297         const char *tmp;
1298         int t = name_convert(context, n, r, &tmp);
1299         if(t >= 0) {
1300             type = t;
1301             n = tmp;
1302         }
1303     }
1304
1305     if(type == KRB5_NT_SRV_HST){
1306         char *p;
1307
1308         strlcpy (tmpinst, i, sizeof(tmpinst));
1309         p = strchr(tmpinst, '.');
1310         if(p)
1311             *p = 0;
1312         i = tmpinst;
1313     }
1314
1315     if (strlcpy (name, n, aname_sz) >= aname_sz) {
1316         krb5_set_error_message(context, KRB5_PARSE_MALFORMED,
1317                                N_("too long name component to convert", ""));
1318         return KRB5_PARSE_MALFORMED;
1319     }
1320     if (strlcpy (instance, i, aname_sz) >= aname_sz) {
1321         krb5_set_error_message(context, KRB5_PARSE_MALFORMED,
1322                                N_("too long instance component to convert", ""));
1323         return KRB5_PARSE_MALFORMED;
1324     }
1325     if (strlcpy (realm, r, aname_sz) >= aname_sz) {
1326         krb5_set_error_message(context, KRB5_PARSE_MALFORMED,
1327                                N_("too long realm component to convert", ""));
1328         return KRB5_PARSE_MALFORMED;
1329     }
1330     return 0;
1331 }
1332
1333 #endif /* !HEIMDAL_SMALLER */
1334
1335 /**
1336  * Create a principal for the service running on hostname. If
1337  * KRB5_NT_SRV_HST is used, the hostname is canonization using DNS (or
1338  * some other service), this is potentially insecure.
1339  *
1340  * @param context A Kerberos context.
1341  * @param hostname hostname to use
1342  * @param sname Service name to use
1343  * @param type name type of pricipal, use KRB5_NT_SRV_HST or KRB5_NT_UNKNOWN.
1344  * @param ret_princ return principal, free with krb5_free_principal().
1345  *
1346  * @return An krb5 error code, see krb5_get_error_message().
1347  *
1348  * @ingroup krb5_principal
1349  */
1350
1351 krb5_error_code KRB5_LIB_FUNCTION
1352 krb5_sname_to_principal (krb5_context context,
1353                          const char *hostname,
1354                          const char *sname,
1355                          int32_t type,
1356                          krb5_principal *ret_princ)
1357 {
1358     krb5_error_code ret;
1359     char localhost[MAXHOSTNAMELEN];
1360     char **realms, *host = NULL;
1361
1362     if(type != KRB5_NT_SRV_HST && type != KRB5_NT_UNKNOWN) {
1363         krb5_set_error_message(context, KRB5_SNAME_UNSUPP_NAMETYPE,
1364                                N_("unsupported name type %d", ""),
1365                                (int)type);
1366         return KRB5_SNAME_UNSUPP_NAMETYPE;
1367     }
1368     if(hostname == NULL) {
1369         ret = gethostname(localhost, sizeof(localhost) - 1);
1370         if (ret != 0) {
1371             ret = errno;
1372             krb5_set_error_message(context, ret,
1373                                    N_("Failed to get local hostname", ""));
1374             return ret;
1375         }
1376         localhost[sizeof(localhost) - 1] = '\0';
1377         hostname = localhost;
1378     }
1379     if(sname == NULL)
1380         sname = "host";
1381     if(type == KRB5_NT_SRV_HST) {
1382         ret = krb5_expand_hostname_realms (context, hostname,
1383                                            &host, &realms);
1384         if (ret)
1385             return ret;
1386         strlwr(host);
1387         hostname = host;
1388     } else {
1389         ret = krb5_get_host_realm(context, hostname, &realms);
1390         if(ret)
1391             return ret;
1392     }
1393
1394     ret = krb5_make_principal(context, ret_princ, realms[0], sname,
1395                               hostname, NULL);
1396     if(host)
1397         free(host);
1398     krb5_free_host_realm(context, realms);
1399     return ret;
1400 }
1401
1402 static const struct {
1403     const char *type;
1404     int32_t value;
1405 } nametypes[] = {
1406     { "UNKNOWN", KRB5_NT_UNKNOWN },
1407     { "PRINCIPAL", KRB5_NT_PRINCIPAL },
1408     { "SRV_INST", KRB5_NT_SRV_INST },
1409     { "SRV_HST", KRB5_NT_SRV_HST },
1410     { "SRV_XHST", KRB5_NT_SRV_XHST },
1411     { "UID", KRB5_NT_UID },
1412     { "X500_PRINCIPAL", KRB5_NT_X500_PRINCIPAL },
1413     { "SMTP_NAME", KRB5_NT_SMTP_NAME },
1414     { "ENTERPRISE_PRINCIPAL", KRB5_NT_ENTERPRISE_PRINCIPAL },
1415     { "ENT_PRINCIPAL_AND_ID", KRB5_NT_ENT_PRINCIPAL_AND_ID },
1416     { "MS_PRINCIPAL", KRB5_NT_MS_PRINCIPAL },
1417     { "MS_PRINCIPAL_AND_ID", KRB5_NT_MS_PRINCIPAL_AND_ID },
1418     { NULL }
1419 };
1420
1421 krb5_error_code
1422 krb5_parse_nametype(krb5_context context, const char *str, int32_t *nametype)
1423 {
1424     size_t i;
1425
1426     for(i = 0; nametypes[i].type; i++) {
1427         if (strcasecmp(nametypes[i].type, str) == 0) {
1428             *nametype = nametypes[i].value;
1429             return 0;
1430         }
1431     }
1432     krb5_set_error_message(context, KRB5_PARSE_MALFORMED,
1433                            N_("Failed to find name type %s", ""), str);
1434     return KRB5_PARSE_MALFORMED;
1435 }