www.project-moonshot.org Git - mech_eap.orig/blob - util_name.c

   1 /*
   2  * Copyright (c) 2011, JANET(UK)
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * 3. Neither the name of JANET(UK) nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32 /*
  33  * Portions Copyright 2009 by the Massachusetts Institute of Technology.
  34  * All Rights Reserved.
  35  *
  36  * Export of this software from the United States of America may
  37  *   require a specific license from the United States Government.
  38  *   It is the responsibility of any person or organization contemplating
  39  *   export to obtain such a license before exporting.
  40  *
  41  * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
  42  * distribute this software and its documentation for any purpose and
  43  * without fee is hereby granted, provided that the above copyright
  44  * notice appear in all copies and that both that copyright notice and
  45  * this permission notice appear in supporting documentation, and that
  46  * the name of M.I.T. not be used in advertising or publicity pertaining
  47  * to distribution of the software without specific, written prior
  48  * permission.  Furthermore if you modify this software you must label
  49  * your software as modified software and not distribute it in such a
  50  * fashion that it might be confused with the original M.I.T. software.
  51  * M.I.T. makes no representations about the suitability of
  52  * this software for any purpose.  It is provided "as is" without express
  53  * or implied warranty.
  54  */
  55
  56 /*
  57  * Name utility routines.
  58  */
  59
  60 #include "gssapiP_eap.h"
  61
  62 static gss_OID_desc gssEapNtEapName = {
  63     /* 1.3.6.1.4.1.5322.22.2.1  */
  64     10, "\x2B\x06\x01\x04\x01\xA9\x4A\x16\x02\x01"
  65 };
  66
  67 gss_OID GSS_EAP_NT_EAP_NAME = &gssEapNtEapName;
  68
  69 OM_uint32
  70 gssEapAllocName(OM_uint32 *minor, gss_name_t *pName)
  71 {
  72     OM_uint32 tmpMinor;
  73     gss_name_t name;
  74
  75     *pName = GSS_C_NO_NAME;
  76
  77     name = (gss_name_t)GSSEAP_CALLOC(1, sizeof(*name));
  78     if (name == NULL) {
  79         *minor = ENOMEM;
  80         return GSS_S_FAILURE;
  81     }
  82
  83     if (GSSEAP_MUTEX_INIT(&name->mutex) != 0) {
  84         *minor = errno;
  85         gssEapReleaseName(&tmpMinor, &name);
  86         return GSS_S_FAILURE;
  87     }
  88
  89     *pName = name;
  90
  91     return GSS_S_COMPLETE;
  92 }
  93
  94 OM_uint32
  95 gssEapReleaseName(OM_uint32 *minor, gss_name_t *pName)
  96 {
  97     gss_name_t name;
  98     krb5_context krbContext = NULL;
  99     OM_uint32 tmpMinor;
 100
 101     *minor = 0;
 102
 103     if (pName == NULL) {
 104         return GSS_S_COMPLETE;
 105     }
 106
 107     name = *pName;
 108     if (name == GSS_C_NO_NAME) {
 109         return GSS_S_COMPLETE;
 110     }
 111
 112     GSSEAP_KRB_INIT(&krbContext);
 113     krb5_free_principal(krbContext, name->krbPrincipal);
 114     gssEapReleaseOid(&tmpMinor, &name->mechanismUsed);
 115
 116     gssEapReleaseAttrContext(&tmpMinor, name);
 117
 118     GSSEAP_MUTEX_DESTROY(&name->mutex);
 119     GSSEAP_FREE(name);
 120     *pName = NULL;
 121
 122     return GSS_S_COMPLETE;
 123 }
 124
 125 static OM_uint32
 126 krbPrincipalToName(OM_uint32 *minor,
 127                    krb5_principal *principal,
 128                    gss_name_t *pName)
 129 {
 130     OM_uint32 major;
 131     gss_name_t name;
 132
 133     major = gssEapAllocName(minor, &name);
 134     if (GSS_ERROR(major))
 135         return major;
 136
 137     name->krbPrincipal = *principal;
 138     *principal = NULL;
 139
 140     if (KRB_PRINC_LENGTH(name->krbPrincipal) > 1) {
 141         name->flags |= NAME_FLAG_SERVICE;
 142     } else {
 143         name->flags |= NAME_FLAG_NAI;
 144     }
 145
 146     *pName = name;
 147     *minor = 0;
 148
 149     return GSS_S_COMPLETE;
 150 }
 151
 152 static krb5_error_code
 153 gssEapGetDefaultRealm(krb5_context krbContext, char **defaultRealm)
 154 {
 155     *defaultRealm = NULL;
 156
 157     krb5_appdefault_string(krbContext, "eap_gss",
 158                            NULL, "default_realm", "", defaultRealm);
 159
 160     if (*defaultRealm != NULL && (*defaultRealm)[0] == '\0') {
 161         GSSEAP_FREE(*defaultRealm);
 162         *defaultRealm = NULL;
 163     }
 164
 165     return (*defaultRealm != NULL) ? 0 : KRB5_CONFIG_NODEFREALM;
 166 }
 167
 168 static OM_uint32
 169 importServiceName(OM_uint32 *minor,
 170                   const gss_buffer_t nameBuffer,
 171                   gss_name_t *pName)
 172 {
 173     OM_uint32 major;
 174     krb5_error_code code;
 175     krb5_context krbContext;
 176     krb5_principal krbPrinc;
 177     char *service, *host, *realm = NULL;
 178
 179     GSSEAP_KRB_INIT(&krbContext);
 180
 181     major = bufferToString(minor, nameBuffer, &service);
 182     if (GSS_ERROR(major))
 183         return major;
 184
 185     host = strchr(service, '@');
 186     if (host != NULL) {
 187         *host = '\0';
 188         host++;
 189     }
 190
 191     gssEapGetDefaultRealm(krbContext, &realm);
 192
 193     code = krb5_build_principal(krbContext,
 194                                 &krbPrinc,
 195                                 realm != NULL ? strlen(realm) : 0,
 196                                 realm != NULL ? realm : "",
 197                                 service,
 198                                 host,
 199                                 NULL);
 200
 201     if (code == 0) {
 202         KRB_PRINC_TYPE(krbPrinc) = KRB5_NT_SRV_HST;
 203
 204         major = krbPrincipalToName(minor, &krbPrinc, pName);
 205         if (GSS_ERROR(major))
 206             krb5_free_principal(krbContext, krbPrinc);
 207     } else {
 208         major = GSS_S_FAILURE;
 209         *minor = GSSEAP_BAD_SERVICE_NAME;
 210     }
 211
 212     if (realm != NULL)
 213         GSSEAP_FREE(realm);
 214     GSSEAP_FREE(service);
 215
 216     return major;
 217 }
 218
 219 static OM_uint32
 220 importUserName(OM_uint32 *minor,
 221                const gss_buffer_t nameBuffer,
 222                gss_name_t *pName)
 223 {
 224     OM_uint32 major;
 225     krb5_context krbContext;
 226     krb5_principal krbPrinc = NULL;
 227     krb5_error_code code;
 228
 229     GSSEAP_KRB_INIT(&krbContext);
 230
 231     if (nameBuffer == GSS_C_NO_BUFFER) {
 232         code = krb5_copy_principal(krbContext,
 233                                    krbAnonymousPrincipal(), &krbPrinc);
 234         if (code != 0) {
 235             *minor = code;
 236             return GSS_S_FAILURE;
 237         }
 238     } else {
 239         char *nameString;
 240
 241         major = bufferToString(minor, nameBuffer, &nameString);
 242         if (GSS_ERROR(major))
 243             return major;
 244
 245         /*
 246          * First, attempt to parse the name on the assumption that it includes
 247          * a qualifying realm.
 248          */
 249         code = krb5_parse_name_flags(krbContext, nameString,
 250                                      KRB5_PRINCIPAL_PARSE_REQUIRE_REALM, &krbPrinc);
 251         if (code == KRB5_PARSE_MALFORMED) {
 252             char *defaultRealm = NULL;
 253             int flags = 0;
 254
 255             /*
 256              * We need an explicit appdefaults check because, at least with MIT
 257              * Kerberos, setting the context realm to NULL will reset it to the
 258              * default Kerberos realm after the second call to get_default_realm.
 259              * We want to make sure that the default Kerberos realm does not end
 260              * up accidentally appended to an unqualified name.
 261              */
 262             gssEapGetDefaultRealm(krbContext, &defaultRealm);
 263
 264             if (defaultRealm == NULL)
 265                 flags |= KRB5_PRINCIPAL_PARSE_NO_REALM;
 266
 267             code = krb5_parse_name_flags(krbContext, nameString, flags, &krbPrinc);
 268
 269             if (defaultRealm != NULL)
 270                 GSSEAP_FREE(defaultRealm);
 271         }
 272
 273         GSSEAP_FREE(nameString);
 274
 275         if (code != 0) {
 276             *minor = code;
 277             return GSS_S_FAILURE;
 278         }
 279     }
 280
 281     assert(krbPrinc != NULL);
 282
 283     major = krbPrincipalToName(minor, &krbPrinc, pName);
 284     if (GSS_ERROR(major))
 285         krb5_free_principal(krbContext, krbPrinc);
 286
 287     return major;
 288 }
 289
 290 static OM_uint32
 291 importAnonymousName(OM_uint32 *minor,
 292                     const gss_buffer_t nameBuffer GSSEAP_UNUSED,
 293                     gss_name_t *pName)
 294 {
 295     return importUserName(minor, GSS_C_NO_BUFFER, pName);
 296 }
 297
 298 #define UPDATE_REMAIN(n)    do {            \
 299         p += (n);                           \
 300         remain -= (n);                      \
 301     } while (0)
 302
 303 #define CHECK_REMAIN(n)     do {        \
 304         if (remain < (n)) {             \
 305             major = GSS_S_BAD_NAME;     \
 306             *minor = GSSEAP_TOK_TRUNC;  \
 307             goto cleanup;               \
 308         }                               \
 309     } while (0)
 310
 311 OM_uint32
 312 gssEapImportNameInternal(OM_uint32 *minor,
 313                          const gss_buffer_t nameBuffer,
 314                          gss_name_t *pName,
 315                          unsigned int flags)
 316 {
 317     OM_uint32 major, tmpMinor;
 318     krb5_context krbContext;
 319     unsigned char *p;
 320     size_t len, remain;
 321     gss_buffer_desc buf;
 322     enum gss_eap_token_type tokType;
 323     gss_name_t name = GSS_C_NO_NAME;
 324     gss_OID mechanismUsed = GSS_C_NO_OID;
 325
 326     GSSEAP_KRB_INIT(&krbContext);
 327
 328     p = (unsigned char *)nameBuffer->value;
 329     remain = nameBuffer->length;
 330
 331     if (flags & EXPORT_NAME_FLAG_OID) {
 332         gss_OID_desc mech;
 333
 334         /* TOK_ID || MECH_OID_LEN || MECH_OID */
 335         if (remain < 6)
 336             return GSS_S_BAD_NAME;
 337
 338         if (flags & EXPORT_NAME_FLAG_COMPOSITE)
 339             tokType = TOK_TYPE_EXPORT_NAME_COMPOSITE;
 340         else
 341             tokType = TOK_TYPE_EXPORT_NAME;
 342
 343         /* TOK_ID */
 344         if (load_uint16_be(p) != tokType)
 345             return GSS_S_BAD_NAME;
 346         UPDATE_REMAIN(2);
 347
 348         /* MECH_OID_LEN */
 349         len = load_uint16_be(p);
 350         if (len < 2)
 351             return GSS_S_BAD_NAME;
 352         UPDATE_REMAIN(2);
 353
 354         /* MECH_OID */
 355         if (p[0] != 0x06)
 356             return GSS_S_BAD_NAME;
 357
 358         mech.length = p[1];
 359         mech.elements = &p[2];
 360
 361         CHECK_REMAIN(mech.length);
 362
 363         major = gssEapCanonicalizeOid(minor,
 364                                       &mech,
 365                                       OID_FLAG_FAMILY_MECH_VALID |
 366                                         OID_FLAG_MAP_FAMILY_MECH_TO_NULL,
 367                                       &mechanismUsed);
 368         if (GSS_ERROR(major))
 369             goto cleanup;
 370
 371         UPDATE_REMAIN(2 + mech.length);
 372     }
 373
 374     /* NAME_LEN */
 375     CHECK_REMAIN(4);
 376     len = load_uint32_be(p);
 377     UPDATE_REMAIN(4);
 378
 379     /* NAME */
 380     CHECK_REMAIN(len);
 381     buf.length = len;
 382     buf.value = p;
 383     UPDATE_REMAIN(len);
 384
 385     major = importUserName(minor, &buf, &name);
 386     if (GSS_ERROR(major))
 387         goto cleanup;
 388
 389     name->mechanismUsed = mechanismUsed;
 390     mechanismUsed = GSS_C_NO_OID;
 391
 392     if (flags & EXPORT_NAME_FLAG_COMPOSITE) {
 393         gss_buffer_desc buf;
 394
 395         buf.length = remain;
 396         buf.value = p;
 397
 398         major = gssEapImportAttrContext(minor, &buf, name);
 399         if (GSS_ERROR(major))
 400             goto cleanup;
 401     }
 402
 403     major = GSS_S_COMPLETE;
 404     *minor = 0;
 405
 406 cleanup:
 407     if (GSS_ERROR(major)) {
 408         gssEapReleaseOid(&tmpMinor, &mechanismUsed);
 409         gssEapReleaseName(&tmpMinor, &name);
 410     } else {
 411         *pName = name;
 412     }
 413
 414     return major;
 415 }
 416
 417 static OM_uint32
 418 importExportName(OM_uint32 *minor,
 419                  const gss_buffer_t nameBuffer,
 420                  gss_name_t *name)
 421 {
 422     return gssEapImportNameInternal(minor, nameBuffer, name,
 423                                     EXPORT_NAME_FLAG_OID);
 424 }
 425
 426 #ifdef HAVE_GSS_C_NT_COMPOSITE_EXPORT
 427 static OM_uint32
 428 importCompositeExportName(OM_uint32 *minor,
 429                           const gss_buffer_t nameBuffer,
 430                           gss_name_t *name)
 431 {
 432     return gssEapImportNameInternal(minor, nameBuffer, name,
 433                                     EXPORT_NAME_FLAG_OID |
 434                                     EXPORT_NAME_FLAG_COMPOSITE);
 435 }
 436 #endif
 437
 438 struct gss_eap_name_import_provider {
 439     gss_const_OID oid;
 440     OM_uint32 (*import)(OM_uint32 *, const gss_buffer_t, gss_name_t *);
 441 };
 442
 443 OM_uint32
 444 gssEapImportName(OM_uint32 *minor,
 445                  const gss_buffer_t nameBuffer,
 446                  const gss_OID nameType,
 447                  const gss_OID mechType,
 448                  gss_name_t *pName)
 449 {
 450     struct gss_eap_name_import_provider nameTypes[] = {
 451         { GSS_EAP_NT_EAP_NAME,              importUserName              },
 452         { GSS_C_NT_USER_NAME,               importUserName              },
 453         { GSS_C_NT_HOSTBASED_SERVICE,       importServiceName           },
 454         { GSS_C_NT_HOSTBASED_SERVICE_X,     importServiceName           },
 455         { GSS_C_NT_ANONYMOUS,               importAnonymousName         },
 456         { GSS_C_NT_EXPORT_NAME,             importExportName            },
 457         { GSS_KRB5_NT_PRINCIPAL_NAME,       importUserName              },
 458 #ifdef HAVE_GSS_C_NT_COMPOSITE_EXPORT
 459         { GSS_C_NT_COMPOSITE_EXPORT,        importCompositeExportName   },
 460 #endif
 461     };
 462     size_t i;
 463     OM_uint32 major = GSS_S_BAD_NAMETYPE;
 464     OM_uint32 tmpMinor;
 465     gss_name_t name = GSS_C_NO_NAME;
 466
 467     for (i = 0; i < sizeof(nameTypes) / sizeof(nameTypes[0]); i++) {
 468         if (oidEqual(nameTypes[i].oid,
 469                      nameType == GSS_C_NO_OID ? GSS_EAP_NT_EAP_NAME : nameType)) {
 470             major = nameTypes[i].import(minor, nameBuffer, &name);
 471             break;
 472         }
 473     }
 474
 475     if (major == GSS_S_COMPLETE &&
 476         mechType != GSS_C_NO_OID) {
 477         assert(gssEapIsConcreteMechanismOid(mechType));
 478         assert(name->mechanismUsed == GSS_C_NO_OID);
 479
 480         major = gssEapCanonicalizeOid(minor, mechType, 0, &name->mechanismUsed);
 481     }
 482
 483     if (GSS_ERROR(major))
 484         gssEapReleaseName(&tmpMinor, &name);
 485     else
 486         *pName = name;
 487
 488     return major;
 489 }
 490
 491 OM_uint32
 492 gssEapExportName(OM_uint32 *minor,
 493                  const gss_name_t name,
 494                  gss_buffer_t exportedName)
 495 {
 496     return gssEapExportNameInternal(minor, name, exportedName,
 497                                     EXPORT_NAME_FLAG_OID);
 498 }
 499
 500 OM_uint32
 501 gssEapExportNameInternal(OM_uint32 *minor,
 502                          const gss_name_t name,
 503                          gss_buffer_t exportedName,
 504                          unsigned int flags)
 505 {
 506     OM_uint32 major = GSS_S_FAILURE, tmpMinor;
 507     krb5_context krbContext;
 508     char *krbName = NULL;
 509     size_t krbNameLen, exportedNameLen;
 510     unsigned char *p;
 511     gss_buffer_desc attrs = GSS_C_EMPTY_BUFFER;
 512     gss_OID mech;
 513
 514     exportedName->length = 0;
 515     exportedName->value = NULL;
 516
 517     if (name->mechanismUsed != GSS_C_NO_OID)
 518         mech = name->mechanismUsed;
 519     else
 520         mech = GSS_EAP_MECHANISM;
 521
 522     GSSEAP_KRB_INIT(&krbContext);
 523
 524     *minor = krb5_unparse_name(krbContext, name->krbPrincipal, &krbName);
 525     if (*minor != 0) {
 526         major = GSS_S_FAILURE;
 527         goto cleanup;
 528     }
 529     krbNameLen = strlen(krbName);
 530
 531     exportedNameLen = 0;
 532     if (flags & EXPORT_NAME_FLAG_OID) {
 533         exportedNameLen += 6 + mech->length;
 534     }
 535     exportedNameLen += 4 + krbNameLen;
 536     if (flags & EXPORT_NAME_FLAG_COMPOSITE) {
 537         major = gssEapExportAttrContext(minor, name, &attrs);
 538         if (GSS_ERROR(major))
 539             goto cleanup;
 540         exportedNameLen += attrs.length;
 541     }
 542
 543     exportedName->value = GSSEAP_MALLOC(exportedNameLen);
 544     if (exportedName->value == NULL) {
 545         major = GSS_S_FAILURE;
 546         *minor = ENOMEM;
 547         goto cleanup;
 548     }
 549     exportedName->length = exportedNameLen;
 550
 551     p = (unsigned char *)exportedName->value;
 552
 553     if (flags & EXPORT_NAME_FLAG_OID) {
 554         /* TOK | MECH_OID_LEN */
 555         store_uint16_be((flags & EXPORT_NAME_FLAG_COMPOSITE)
 556                         ? TOK_TYPE_EXPORT_NAME_COMPOSITE
 557                         : TOK_TYPE_EXPORT_NAME,
 558                         p);
 559         p += 2;
 560         store_uint16_be(mech->length + 2, p);
 561         p += 2;
 562
 563         /* MECH_OID */
 564         *p++ = 0x06;
 565         *p++ = mech->length & 0xff;
 566         memcpy(p, mech->elements, mech->length);
 567         p += mech->length;
 568     }
 569
 570     /* NAME_LEN */
 571     store_uint32_be(krbNameLen, p);
 572     p += 4;
 573
 574     /* NAME */
 575     memcpy(p, krbName, krbNameLen);
 576     p += krbNameLen;
 577
 578     if (flags & EXPORT_NAME_FLAG_COMPOSITE) {
 579         memcpy(p, attrs.value, attrs.length);
 580         p += attrs.length;
 581     }
 582
 583     assert(p == (unsigned char *)exportedName->value + exportedNameLen);
 584
 585     major = GSS_S_COMPLETE;
 586     *minor = 0;
 587
 588 cleanup:
 589     gss_release_buffer(&tmpMinor, &attrs);
 590     if (GSS_ERROR(major))
 591         gss_release_buffer(&tmpMinor, exportedName);
 592     krb5_free_unparsed_name(krbContext, krbName);
 593
 594     return major;
 595 }
 596
 597 OM_uint32
 598 gssEapCanonicalizeName(OM_uint32 *minor,
 599                        const gss_name_t input_name,
 600                        const gss_OID mech_type,
 601                        gss_name_t *dest_name)
 602 {
 603     OM_uint32 major, tmpMinor;
 604     krb5_context krbContext;
 605     gss_name_t name;
 606     gss_OID mech_used;
 607
 608     if (input_name == GSS_C_NO_NAME) {
 609         *minor = EINVAL;
 610         return GSS_S_CALL_INACCESSIBLE_READ | GSS_S_BAD_NAME;
 611     }
 612
 613     GSSEAP_KRB_INIT(&krbContext);
 614
 615     major = gssEapAllocName(minor, &name);
 616     if (GSS_ERROR(major)) {
 617         return major;
 618     }
 619
 620     if (mech_type != GSS_C_NO_OID)
 621         mech_used = mech_type;
 622     else
 623         mech_used = input_name->mechanismUsed;
 624
 625     major = gssEapCanonicalizeOid(minor,
 626                                   mech_used,
 627                                   OID_FLAG_NULL_VALID,
 628                                   &name->mechanismUsed);
 629     if (GSS_ERROR(major))
 630         goto cleanup;
 631
 632     name->flags = input_name->flags;
 633
 634     *minor = krb5_copy_principal(krbContext, input_name->krbPrincipal,
 635                                  &name->krbPrincipal);
 636     if (*minor != 0) {
 637         major = GSS_S_FAILURE;
 638         goto cleanup;
 639     }
 640
 641     if (input_name->attrCtx != NULL) {
 642         major = gssEapDuplicateAttrContext(minor, input_name, name);
 643         if (GSS_ERROR(major))
 644             goto cleanup;
 645     }
 646
 647     *dest_name = name;
 648
 649 cleanup:
 650     if (GSS_ERROR(major)) {
 651         gssEapReleaseName(&tmpMinor, &name);
 652     }
 653
 654     return major;
 655 }
 656
 657 OM_uint32
 658 gssEapDuplicateName(OM_uint32 *minor,
 659                     const gss_name_t input_name,
 660                     gss_name_t *dest_name)
 661 {
 662     return gssEapCanonicalizeName(minor, input_name,
 663                                   GSS_C_NO_OID, dest_name);
 664 }
 665
 666 OM_uint32
 667 gssEapDisplayName(OM_uint32 *minor,
 668                   gss_name_t name,
 669                   gss_buffer_t output_name_buffer,
 670                   gss_OID *output_name_type)
 671 {
 672     OM_uint32 major;
 673     krb5_context krbContext;
 674     char *krbName;
 675     gss_OID name_type;
 676     int flags = 0;
 677
 678     GSSEAP_KRB_INIT(&krbContext);
 679
 680     output_name_buffer->length = 0;
 681     output_name_buffer->value = NULL;
 682
 683     if (name == GSS_C_NO_NAME) {
 684         *minor = EINVAL;
 685         return GSS_S_CALL_INACCESSIBLE_READ | GSS_S_BAD_NAME;
 686     }
 687
 688     /*
 689      * According to draft-ietf-abfab-gss-eap-01, when the realm is
 690      * absent the trailing '@' is not included.
 691      */
 692 #ifdef HAVE_HEIMDAL_VERSION
 693     if (KRB_PRINC_REALM(name->krbPrincipal) == NULL ||
 694         KRB_PRINC_REALM(name->krBPrincipal)[0] == '\0')
 695 #else
 696     if (KRB_PRINC_REALM(name->krbPrincipal)->length == 0)
 697 #endif
 698         flags |= KRB5_PRINCIPAL_UNPARSE_NO_REALM;
 699
 700     *minor = krb5_unparse_name_flags(krbContext, name->krbPrincipal,
 701                                      flags, &krbName);
 702     if (*minor != 0) {
 703         return GSS_S_FAILURE;
 704     }
 705
 706     major = makeStringBuffer(minor, krbName, output_name_buffer);
 707     if (GSS_ERROR(major)) {
 708         krb5_free_unparsed_name(krbContext, krbName);
 709         return major;
 710     }
 711
 712     krb5_free_unparsed_name(krbContext, krbName);
 713
 714     if (KRB_PRINC_TYPE(name->krbPrincipal) == KRB5_NT_WELLKNOWN &&
 715         krb5_principal_compare(krbContext,
 716                                name->krbPrincipal, krbAnonymousPrincipal())) {
 717         name_type = GSS_C_NT_ANONYMOUS;
 718     } else {
 719         name_type = GSS_EAP_NT_EAP_NAME;
 720     }
 721
 722     if (output_name_type != NULL)
 723         *output_name_type = name_type;
 724
 725     return GSS_S_COMPLETE;
 726 }