src/aklog/klog.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <afsconfig.h>
  11 #include <afs/param.h>
  12
  13 #include <afs/stds.h>
  14 #include <sys/types.h>
  15 #include <rx/xdr.h>
  16 #ifdef  AFS_AIX32_ENV
  17 #include <signal.h>
  18 #endif
  19 #include <string.h>
  20 #include <errno.h>
  21
  22 #include <lock.h>
  23 #include <ubik.h>
  24
  25 #include <stdio.h>
  26 #include <pwd.h>
  27 #include <afs/com_err.h>
  28 #include <afs/auth.h>
  29 #include <afs/afsutil.h>
  30 #include <afs/cellconfig.h>
  31 #ifdef AFS_RXK5
  32 #include "rxk5_utilafs.h"
  33 #endif
  34 #include <afs/ptclient.h>
  35 #include <afs/cmd.h>
  36 #include <krb5.h>
  37
  38 #ifdef HAVE_KRB5_CREDS_KEYBLOCK
  39 #define USING_MIT 1
  40 #endif
  41 #ifdef HAVE_KRB5_CREDS_SESSION
  42 #define USING_HEIMDAL 1
  43 #endif
  44
  45 #include "assert.h"
  46 #include "skipwrap.h"
  47
  48 /* This code borrowed heavily from the previous version of log.  Here is the
  49    intro comment for that program: */
  50
  51 /*
  52         log -- tell the Andrew Cache Manager your password
  53         5 June 1985
  54         modified
  55         February 1986
  56
  57         Further modified in August 1987 to understand cell IDs.
  58
  59         Further modified in October 2006 to understand kerberos 5.
  60  */
  61
  62 /* Current Usage:
  63      klog [principal [password]] [-t] [-c cellname] [-k <k5realm>]
  64
  65      where:
  66        principal is of the form 'name' or 'name@cell' which provides the
  67           cellname.  See the -c option below.
  68        password is the user's password.  This form is NOT recommended for
  69           interactive users.
  70        -t advises klog to write a Kerberos style ticket file in /tmp.
  71        -c identifies cellname as the cell in which authentication is to take
  72           place.
  73        -k identifies an alternate kerberos realm to use provide
  74           authentication services for the cell.
  75  */
  76
  77 #define KLOGEXIT(code) rx_Finalize(); \
  78                        (exit(!!code))
  79 static int CommandProc(struct cmd_syndesc *as, void *arock);
  80
  81 static int zero_argc;
  82 static char **zero_argv;
  83
  84 static krb5_context k5context;
  85 static struct afsconf_dir *tdir;
  86 static int always_evil = 2;     /* gcc optimizes 0 into bss.  fools. */
  87
  88 int
  89 main(int argc, char *argv[])
  90 {
  91     struct cmd_syndesc *ts;
  92     afs_int32 code;
  93 #ifdef  AFS_AIX32_ENV
  94     /*
  95      * The following signal action for AIX is necessary so that in case of a
  96      * crash (i.e. core is generated) we can include the user's data section
  97      * in the core dump. Unfortunately, by default, only a partial core is
  98      * generated which, in many cases, isn't too useful.
  99      */
 100     struct sigaction nsa;
 101
 102     sigemptyset(&nsa.sa_mask);
 103     nsa.sa_handler = SIG_DFL;
 104     nsa.sa_flags = SA_FULLDUMP;
 105     sigaction(SIGABRT, &nsa, NULL);
 106     sigaction(SIGSEGV, &nsa, NULL);
 107 #endif
 108     zero_argc = argc;
 109     zero_argv = argv;
 110
 111     ts = cmd_CreateSyntax(NULL, CommandProc, NULL,
 112                           "obtain Kerberos authentication");
 113
 114 #define aXFLAG 0
 115 #define aPRINCIPAL 1
 116 #define aPASSWORD 2
 117 #define aCELL 3
 118 #define aKRBREALM 4
 119 #define aPIPE 5
 120 #define aSILENT 6
 121 #define aLIFETIME 7
 122 #define aSETPAG 8
 123 #define aTMP 9
 124 #define aNOPRDB 10
 125 #define aUNWRAP 11
 126 #define aK5 12
 127 #define aK4 13
 128
 129     cmd_AddParm(ts, "-x", CMD_FLAG, CMD_OPTIONAL|CMD_HIDDEN, 0);
 130     cmd_Seek(ts, aPRINCIPAL);
 131     cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_OPTIONAL, "user name");
 132     cmd_AddParm(ts, "-password", CMD_SINGLE, CMD_OPTIONAL, "user's password");
 133     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
 134     cmd_AddParm(ts, "-k", CMD_SINGLE, CMD_OPTIONAL, "krb5 realm");
 135     cmd_AddParm(ts, "-pipe", CMD_FLAG, CMD_OPTIONAL,
 136                 "read password from stdin");
 137     cmd_AddParm(ts, "-silent", CMD_FLAG, CMD_OPTIONAL, "silent operation");
 138     cmd_AddParm(ts, "-lifetime", CMD_SINGLE, CMD_OPTIONAL,
 139                 "ticket lifetime in hh[:mm[:ss]]");
 140     cmd_AddParm(ts, "-setpag", CMD_FLAG, CMD_OPTIONAL,
 141                 "Create a new setpag before authenticating");
 142     cmd_AddParm(ts, "-tmp", CMD_FLAG, CMD_OPTIONAL,
 143                 "write Kerberos-style ticket file in /tmp");
 144     cmd_AddParm(ts, "-noprdb", CMD_FLAG, CMD_OPTIONAL, "don't consult pt");
 145     cmd_AddParm(ts, "-unwrap", CMD_FLAG, CMD_OPTIONAL, "perform 524d conversion");
 146 #ifdef AFS_RXK5
 147     cmd_AddParm(ts, "-k5", CMD_FLAG, CMD_OPTIONAL, "get rxk5 credentials");
 148     cmd_AddParm(ts, "-k4", CMD_FLAG, CMD_OPTIONAL, "get rxkad credentials");
 149 #else
 150     ++ts->nParms;       /* skip -k5 */
 151     cmd_AddParm(ts, "-k4", CMD_FLAG, CMD_OPTIONAL|CMD_HIDDEN, 0);
 152 #endif
 153
 154     code = cmd_Dispatch(argc, argv);
 155     KLOGEXIT(code);
 156 }
 157
 158 static char *
 159 getpipepass(void)
 160 {
 161     static char gpbuf[BUFSIZ];
 162     /* read a password from stdin, stop on \n or eof */
 163     register int i, tc;
 164     memset(gpbuf, 0, sizeof(gpbuf));
 165     for (i = 0; i < (sizeof(gpbuf) - 1); i++) {
 166         tc = fgetc(stdin);
 167         if (tc == '\n' || tc == EOF)
 168             break;
 169         gpbuf[i] = tc;
 170     }
 171     return gpbuf;
 172 }
 173
 174 void
 175 silent_errors(const char *who,
 176     afs_int32 code,
 177     const char *fmt,
 178     va_list ap)
 179 {
 180     /* ignore and don't print error */
 181 }
 182
 183 #if defined(HAVE_KRB5_PRINC_SIZE) || defined(krb5_princ_size)
 184
 185 #define get_princ_str(c, p, n) krb5_princ_component(c, p, n)->data
 186 #define get_princ_len(c, p, n) krb5_princ_component(c, p, n)->length
 187 #define num_comp(c, p) (krb5_princ_size(c, p))
 188 #define realm_data(c, p) krb5_princ_realm(c, p)->data
 189 #define realm_len(c, p) krb5_princ_realm(c, p)->length
 190
 191 #elif defined(HAVE_KRB5_PRINCIPAL_GET_COMP_STRING)
 192
 193 #define get_princ_str(c, p, n) krb5_principal_get_comp_string(c, p, n)
 194 #define get_princ_len(c, p, n) strlen(krb5_principal_get_comp_string(c, p, n))
 195 #define num_comp(c, p) ((p)->name.name_string.len)
 196 #define realm_data(c, p) krb5_realm_data(krb5_principal_get_realm(c, p))
 197 #define realm_len(c, p) krb5_realm_length(krb5_principal_get_realm(c, p))
 198
 199 #else
 200 #error "Must have either krb5_princ_size or krb5_principal_get_comp_string"
 201 #endif
 202
 203 #if defined(HAVE_KRB5_CREDS_KEYBLOCK)
 204
 205 #define get_cred_keydata(c) c->keyblock.contents
 206 #define get_cred_keylen(c) c->keyblock.length
 207 #define get_creds_enctype(c) c->keyblock.enctype
 208
 209 #elif defined(HAVE_KRB5_CREDS_SESSION)
 210
 211 #define get_cred_keydata(c) c->session.keyvalue.data
 212 #define get_cred_keylen(c) c->session.keyvalue.length
 213 #define get_creds_enctype(c) c->session.keytype
 214
 215 #else
 216 #error "Must have either keyblock or session member of krb5_creds"
 217 #endif
 218
 219 static int
 220 whoami(struct ktc_token *atoken,
 221     struct afsconf_cell *cellconfig,
 222     struct ktc_principal *aclient,
 223     int *vicep)
 224 {
 225     rx_securityIndex scIndex;
 226     int code;
 227     int i;
 228     struct ubik_client *ptconn = 0;
 229     struct rx_securityClass *sc;
 230     struct rx_connection *conns[MAXSERVERS+1];
 231     idlist lids[1];
 232     namelist lnames[1];
 233     char tempname[PR_MAXNAMELEN + 1];
 234
 235     memset(lnames, 0, sizeof *lnames);
 236     memset(lids, 0, sizeof *lids);
 237     scIndex = RX_SECIDX_KAD;
 238     sc = rxkad_NewClientSecurityObject(rxkad_auth,
 239         &atoken->sessionKey, atoken->kvno,
 240         atoken->ticketLen, atoken->ticket);
 241     for (i = 0; i < cellconfig->numServers; ++i)
 242         conns[i] = rx_NewConnection(cellconfig->hostAddr[i].sin_addr.s_addr,
 243                 cellconfig->hostAddr[i].sin_port, PRSRV, sc, scIndex);
 244     conns[i] = 0;
 245     ptconn = 0;
 246     if ((code = ubik_ClientInit(conns, &ptconn)))
 247         goto Failed;
 248     if (*aclient->instance)
 249         snprintf (tempname, sizeof tempname, "%s.%s",
 250             aclient->name, aclient->instance);
 251     else
 252         snprintf (tempname, sizeof tempname, "%s", aclient->name);
 253     lnames->namelist_len = 1;
 254     lnames->namelist_val = (prname *) tempname;
 255     code = ubik_PR_NameToID(ptconn, 0, lnames, lids);
 256     if (lids->idlist_val) {
 257         *vicep = *lids->idlist_val;
 258     }
 259 Failed:
 260     if (lids->idlist_val) free(lids->idlist_val);
 261     if (ptconn) ubik_ClientDestroy(ptconn);
 262     return code;
 263 }
 264
 265 static void
 266 k5_to_k4_name(krb5_context k5context,
 267     krb5_principal k5princ,
 268     struct ktc_principal *ktcprinc)
 269 {
 270     int i;
 271
 272     switch(num_comp(k5context, k5princ)) {
 273         default:
 274         /* case 2: */
 275             i = get_princ_len(k5context, k5princ, 1);
 276             if (i > MAXKTCNAMELEN-1) i = MAXKTCNAMELEN-1;
 277             memcpy(ktcprinc->instance, get_princ_str(k5context, k5princ, 1), i);
 278             /* fall through */
 279         case 1:
 280             i = get_princ_len(k5context, k5princ, 0);
 281             if (i > MAXKTCNAMELEN-1) i = MAXKTCNAMELEN-1;
 282             memcpy(ktcprinc->name, get_princ_str(k5context, k5princ, 0), i);
 283             /* fall through */
 284         case 0:
 285             break;
 286         }
 287 }
 288
 289 /* save and reuse password.  This is necessary to make
 290  *  "direct to service" authentication work with most
 291  *  flavors of kerberos, when the afs principal has no instance.
 292  */
 293 struct kp_arg {
 294     char **pp, *pstore;
 295     size_t allocated;
 296 };
 297 krb5_error_code
 298 klog_prompter(krb5_context context,
 299     void *a,
 300     const char *name,
 301     const char *banner,
 302     int num_prompts,
 303     krb5_prompt prompts[])
 304 {
 305     krb5_error_code code;
 306     int i, type;
 307 #if !defined(USING_HEIMDAL) && defined(HAVE_KRB5_GET_PROMPT_TYPES)
 308     krb5_prompt_type *types;
 309 #endif
 310     struct kp_arg *kparg = (struct kp_arg *) a;
 311     size_t length;
 312
 313     code = krb5_prompter_posix(context, a, name, banner, num_prompts, prompts);
 314     if (code) return code;
 315 #if !defined(USING_HEIMDAL) && defined(HAVE_KRB5_GET_PROMPT_TYPES)
 316     if ((types = krb5_get_prompt_types(context)))
 317 #endif
 318     for (i = 0; i < num_prompts; ++i) {
 319 #if !defined(USING_HEIMDAL)
 320 #if defined(HAVE_KRB5_GET_PROMPT_TYPES)
 321         type = types[i];
 322 #elif defined(HAVE_KRB5_PROMPT_TYPE)
 323         type = prompts[i].type;
 324 #else
 325         /* AIX 5.3 krb5_get_prompt_types is missing. Um... */
 326         type = ((i == 1)&&(num_prompts == 2)) ?
 327           KRB5_PROMPT_TYPE_NEW_PASSWORD_AGAIN : KRB5_PROMPT_TYPE_PASSWORD;
 328 #endif
 329 #else
 330         type = prompts[i].type;
 331 #endif
 332 #if 0
 333         printf ("i%d t%d <%.*s>\n", i, type, prompts[i].reply->length,
 334                 prompts[i].reply->data);
 335 #endif
 336         switch(type) {
 337         case KRB5_PROMPT_TYPE_PASSWORD:
 338         case KRB5_PROMPT_TYPE_NEW_PASSWORD_AGAIN:
 339             length = prompts[i].reply->length;
 340             if (length > kparg->allocated - 1)
 341                 length = kparg->allocated - 1;
 342             memcpy(kparg->pstore, prompts[i].reply->data, length);
 343             kparg->pstore[length] = 0;
 344             *kparg->pp = kparg->pstore;
 345         }
 346     }
 347     return 0;
 348 }
 349
 350 static int
 351 CommandProc(struct cmd_syndesc *as, void *arock)
 352 {
 353     krb5_principal princ = 0;
 354     char *cell, *pname, **hrealms, *service;
 355     char service_temp[MAXKTCREALMLEN + 20];
 356     krb5_creds incred[1], mcred[1], *outcred = 0, *afscred;
 357     krb5_ccache cc = 0;
 358 #ifdef HAVE_KRB5_GET_INIT_CREDS_OPT_ALLOC
 359     krb5_get_init_creds_opt *gic_opts;
 360 #else
 361     krb5_get_init_creds_opt gic_opts[1];
 362 #endif
 363     char *tofree = NULL, *outname;
 364     int code;
 365     char *what;
 366     int i, dosetpag, evil, noprdb, id;
 367 #ifdef AFS_RXK5
 368     int authtype;
 369 #endif
 370     krb5_data enc_part[1];
 371     time_t lifetime;            /* requested ticket lifetime */
 372     krb5_prompter_fct pf = NULL;
 373     char *pass = 0;
 374     void *pa = 0;
 375     struct kp_arg klog_arg[1];
 376
 377     char passwd[BUFSIZ];
 378     struct afsconf_cell cellconfig[1];
 379
 380     static char rn[] = "klog";  /*Routine name */
 381     static int Pipe = 0;        /* reading from a pipe */
 382     static int Silent = 0;      /* Don't want error messages */
 383
 384     int writeTicketFile = 0;    /* write ticket file to /tmp */
 385
 386     service = 0;
 387     memset(incred, 0, sizeof *incred);
 388     /* blow away command line arguments */
 389     for (i = 1; i < zero_argc; i++)
 390         memset(zero_argv[i], 0, strlen(zero_argv[i]));
 391     zero_argc = 0;
 392     memset(klog_arg, 0, sizeof *klog_arg);
 393
 394     /* first determine quiet flag based on -silent switch */
 395     Silent = (as->parms[aSILENT].items ? 1 : 0);
 396
 397     if (Silent) {
 398         afs_set_com_err_hook(silent_errors);
 399     }
 400
 401     if ((code = krb5_init_context(&k5context))) {
 402         afs_com_err(rn, code, "while initializing Kerberos 5 library");
 403         KLOGEXIT(code);
 404     }
 405     if ((code = rx_Init(0))) {
 406         afs_com_err(rn, code, "while initializing rx");
 407         KLOGEXIT(code);
 408     }
 409     initialize_U_error_table();
 410     /*initialize_krb5_error_table();*/
 411     initialize_RXK_error_table();
 412     initialize_KTC_error_table();
 413     initialize_ACFG_error_table();
 414     /* initialize_rx_error_table(); */
 415     if (!(tdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH))) {
 416         afs_com_err(rn, 0, "can't get afs configuration (afsconf_Open(%s))",
 417             AFSDIR_CLIENT_ETC_DIRPATH);
 418         KLOGEXIT(1);
 419     }
 420
 421     /*
 422      * Enable DES enctypes, which are currently still required for AFS.
 423      * krb5_allow_weak_crypto is MIT Kerberos 1.8.  krb5_enctype_enable is
 424      * Heimdal.
 425      */
 426 #if defined(HAVE_KRB5_ALLOW_WEAK_CRYPTO)
 427     krb5_allow_weak_crypto(k5context, 1);
 428 #elif defined(HAVE_KRB5_ENCTYPE_ENABLE)
 429     i = krb5_enctype_valid(k5context, ETYPE_DES_CBC_CRC);
 430     if (i)
 431         krb5_enctype_enable(k5context, ETYPE_DES_CBC_CRC);
 432 #endif
 433
 434     /* Parse remaining arguments. */
 435
 436     dosetpag = !! as->parms[aSETPAG].items;
 437     Pipe = !! as->parms[aPIPE].items;
 438     writeTicketFile = !! as->parms[aTMP].items;
 439     noprdb = !! as->parms[aNOPRDB].items;
 440     evil = (always_evil&1) || !! as->parms[aUNWRAP].items;
 441
 442 #ifdef AFS_RXK5
 443     authtype = 0;
 444     if (as->parms[aK5].items)
 445         authtype |= FORCE_RXK5;
 446     if (as->parms[aK4].items)
 447         authtype |= FORCE_RXKAD;
 448     if (!authtype)
 449         authtype |= env_afs_rxk5_default();
 450 #endif
 451
 452     cell = as->parms[aCELL].items ? as->parms[aCELL].items->data : 0;
 453     if ((code = afsconf_GetCellInfo(tdir, cell, "afsprot", cellconfig))) {
 454         if (cell)
 455             afs_com_err(rn, code, "Can't get cell information for '%s'", cell);
 456         else
 457             afs_com_err(rn, code, "Can't get determine local cell!");
 458         KLOGEXIT(code);
 459     }
 460
 461     if (as->parms[aKRBREALM].items) {
 462         code = krb5_set_default_realm(k5context,
 463                 as->parms[aKRBREALM].items->data);
 464         if (code) {
 465             afs_com_err(rn, code, "Can't make <%s> the default realm",
 466                 as->parms[aKRBREALM].items->data);
 467             KLOGEXIT(code);
 468         }
 469     }
 470     else if ((code = krb5_get_host_realm(k5context, cellconfig->hostName[0], &hrealms))) {
 471         afs_com_err(rn, code, "Can't get realm for host <%s> in cell <%s>\n",
 472                 cellconfig->hostName[0], cellconfig->name);
 473         KLOGEXIT(code);
 474     } else {
 475         if (hrealms && *hrealms) {
 476             code = krb5_set_default_realm(k5context,
 477                     *hrealms);
 478             if (code) {
 479                 afs_com_err(rn, code, "Can't make <%s> the default realm",
 480                     *hrealms);
 481                 KLOGEXIT(code);
 482             }
 483         }
 484         if (hrealms) krb5_free_host_realm(k5context, hrealms);
 485     }
 486
 487     id = getuid();
 488     if (as->parms[aPRINCIPAL].items) {
 489         pname = as->parms[aPRINCIPAL].items->data;
 490     } else {
 491         /* No explicit name provided: use Unix uid. */
 492         struct passwd *pw;
 493         pw = getpwuid(id);
 494         if (pw == 0) {
 495             afs_com_err(rn, 0,
 496                 "Can't figure out your name from your user id (%d).", id);
 497             if (!Silent)
 498                 fprintf(stderr, "%s: Try providing the user name.\n", rn);
 499             KLOGEXIT(1);
 500         }
 501         pname = pw->pw_name;
 502     }
 503     code = krb5_parse_name(k5context, pname, &princ);
 504     if (code) {
 505         afs_com_err(rn, code, "Can't parse principal <%s>", pname);
 506         KLOGEXIT(code);
 507     }
 508
 509     if (as->parms[aPASSWORD].items) {
 510         /*
 511          * Current argument is the desired password string.  Remember it in
 512          * our local buffer, and zero out the argument string - anyone can
 513          * see it there with ps!
 514          */
 515         strncpy(passwd, as->parms[aPASSWORD].items->data, sizeof(passwd));
 516         memset(as->parms[aPASSWORD].items->data, 0,
 517                strlen(as->parms[aPASSWORD].items->data));
 518         pass = passwd;
 519     }
 520
 521     if (as->parms[aLIFETIME].items) {
 522         char *life = as->parms[aLIFETIME].items->data;
 523         char *sp;               /* string ptr to rest of life */
 524         lifetime = 3600 * strtol(life, &sp, 0); /* hours */
 525         if (sp == life) {
 526           bad_lifetime:
 527             if (!Silent)
 528                 fprintf(stderr, "%s: translating '%s' to lifetime failed\n",
 529                         rn, life);
 530             return 1;
 531         }
 532         if (*sp == ':') {
 533             life = sp + 1;      /* skip the colon */
 534             lifetime += 60 * strtol(life, &sp, 0);      /* minutes */
 535             if (sp == life)
 536                 goto bad_lifetime;
 537             if (*sp == ':') {
 538                 life = sp + 1;
 539                 lifetime += strtol(life, &sp, 0);       /* seconds */
 540                 if (sp == life)
 541                     goto bad_lifetime;
 542                 if (*sp)
 543                     goto bad_lifetime;
 544             } else if (*sp)
 545                 goto bad_lifetime;
 546         } else if (*sp)
 547             goto bad_lifetime;
 548     } else
 549         lifetime = 0;
 550
 551     /* Get the password if it wasn't provided. */
 552     if (!pass) {
 553         if (Pipe) {
 554             strncpy(passwd, getpipepass(), sizeof(passwd));
 555             pass = passwd;
 556         } else {
 557             pf = klog_prompter;
 558             pa = klog_arg;
 559         }
 560     }
 561
 562     service = 0;
 563 #ifdef AFS_RXK5
 564     if (authtype & FORCE_RXK5) {
 565         tofree = get_afs_krb5_svc_princ(cellconfig);
 566         snprintf(service_temp, sizeof service_temp, "%s", tofree);
 567     } else
 568 #endif
 569     snprintf (service_temp, sizeof service_temp, "afs/%s", cellconfig->name);
 570     if (writeTicketFile)
 571         service = 0;
 572     else
 573         service = service_temp;
 574
 575     klog_arg->pp = &pass;
 576     klog_arg->pstore = passwd;
 577     klog_arg->allocated = sizeof(passwd);
 578     /* XXX should allow k5 to prompt in most cases -- what about expired pw?*/
 579 #ifdef HAVE_KRB5_GET_INIT_CREDS_OPT_ALLOC
 580     code = krb5_get_init_creds_opt_alloc(k5context, &gic_opts);
 581     if (code) {
 582         afs_com_err(rn, code, "Can't allocate get_init_creds options");
 583         KLOGEXIT(code);
 584     }
 585 #else
 586     krb5_get_init_creds_opt_init(gic_opts);
 587 #endif
 588     for (;;) {
 589         code = krb5_get_init_creds_password(k5context,
 590             incred,
 591             princ,
 592             pass,
 593             pf, /* prompter */
 594             pa, /* data */
 595             0,  /* start_time */
 596             service,    /* in_tkt_service */
 597             gic_opts);
 598         if (code != KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN || service != service_temp) break;
 599 #ifdef AFS_RXK5
 600         if (authtype & FORCE_RXK5) break;
 601 #endif
 602         service = "afs";
 603     }
 604     memset(passwd, 0, sizeof(passwd));
 605     if (code) {
 606         char *r = 0;
 607         if (krb5_get_default_realm(k5context, &r))
 608             r = 0;
 609         if (service)
 610             afs_com_err(rn, code, "Unable to authenticate to use %s", service);
 611         else if (r)
 612             afs_com_err(rn, code, "Unable to authenticate in realm %s", r);
 613         else
 614             afs_com_err(rn, code, "Unable to authenticate to use cell %s",
 615                 cellconfig->name);
 616         if (r) free(r);
 617         KLOGEXIT(code);
 618     }
 619
 620     if (service) {
 621         afscred = incred;
 622     } else {
 623         for (;;writeTicketFile = 0) {
 624             if (writeTicketFile) {
 625                 what = "getting default ccache";
 626                 code = krb5_cc_default(k5context, &cc);
 627             } else {
 628                 what = "krb5_cc_resolve";
 629                 code = krb5_cc_resolve(k5context, "MEMORY:core", &cc);
 630                 if (code) goto Failed;
 631             }
 632             what = "initializing ccache";
 633             code = krb5_cc_initialize(k5context, cc, princ);
 634             if (code) goto Failed;
 635             what = "writing Kerberos ticket file";
 636             code = krb5_cc_store_cred(k5context, cc, incred);
 637             if (code) goto Failed;
 638             if (writeTicketFile)
 639                 fprintf(stderr,
 640                     "Wrote ticket file to %s\n",
 641                     krb5_cc_get_name(k5context, cc));
 642             break;
 643         Failed:
 644             if (code)
 645                 afs_com_err(rn, code, "%s", what);
 646             if (writeTicketFile) {
 647                 if (cc) {
 648                     krb5_cc_close(k5context, cc);
 649                     cc = 0;
 650                 }
 651                 continue;
 652             }
 653             KLOGEXIT(code);
 654         }
 655
 656         for (service = service_temp;;service = "afs") {
 657             memset(mcred, 0, sizeof *mcred);
 658             mcred->client = princ;
 659             code = krb5_parse_name(k5context, service, &mcred->server);
 660             if (code) {
 661                 afs_com_err(rn, code, "Unable to parse service <%s>\n", service);
 662                 KLOGEXIT(code);
 663             }
 664             if (tofree) { free(tofree); tofree = 0; }
 665             if (!(code = krb5_unparse_name(k5context, mcred->server, &outname)))
 666                 tofree = outname;
 667             else outname = service;
 668             code = krb5_get_credentials(k5context, 0, cc, mcred, &outcred);
 669             krb5_free_principal(k5context, mcred->server);
 670             if (code != KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN || service != service_temp) break;
 671 #ifdef AFS_RXK5
 672             if (authtype & FORCE_RXK5) break;
 673 #endif
 674         }
 675         afscred = outcred;
 676     }
 677     if (code) {
 678         afs_com_err(rn, code, "Unable to get credentials to use %s", outname);
 679         KLOGEXIT(code);
 680     }
 681
 682 #ifdef AFS_RXK5
 683     if (authtype & FORCE_RXK5) {
 684         struct ktc_principal aserver[1];
 685         int viceid = 555;
 686
 687         memset(aserver, 0, sizeof *aserver);
 688         strncpy(aserver->cell, cellconfig->name, MAXKTCREALMLEN-1);
 689         code = ktc_SetK5Token(k5context, aserver, afscred, viceid, dosetpag);
 690         if (code) {
 691             afs_com_err(rn, code, "Unable to store tokens for cell %s\n",
 692                 cellconfig->name);
 693             KLOGEXIT(1);
 694         }
 695     } else
 696 #endif
 697     {
 698         struct ktc_principal aserver[1], aclient[1];
 699         struct ktc_token atoken[1];
 700
 701         memset(atoken, 0, sizeof *atoken);
 702         if (evil) {
 703             size_t elen = enc_part->length;
 704             atoken->kvno = RXKAD_TKT_TYPE_KERBEROS_V5_ENCPART_ONLY;
 705             if (afs_krb5_skip_ticket_wrapper(afscred->ticket.data,
 706                         afscred->ticket.length, (char **) &enc_part->data,
 707                         &elen)) {
 708                 afs_com_err(rn, 0, "Can't unwrap %s AFS credential",
 709                     cellconfig->name);
 710                 KLOGEXIT(1);
 711             }
 712         } else {
 713             atoken->kvno = RXKAD_TKT_TYPE_KERBEROS_V5;
 714             *enc_part = afscred->ticket;
 715         }
 716         atoken->startTime = afscred->times.starttime;
 717         atoken->endTime = afscred->times.endtime;
 718         memcpy(&atoken->sessionKey, get_cred_keydata(afscred),
 719             get_cred_keylen(afscred));
 720         memcpy(atoken->ticket, enc_part->data,
 721             atoken->ticketLen = enc_part->length);
 722         memset(aserver, 0, sizeof *aserver);
 723         strncpy(aserver->name, "afs", 4);
 724         strncpy(aserver->cell, cellconfig->name, MAXKTCREALMLEN-1);
 725         memset(aclient, 0, sizeof *aclient);
 726         i = realm_len(k5context, afscred->client);
 727         if (i > MAXKTCREALMLEN-1) i = MAXKTCREALMLEN-1;
 728         memcpy(aclient->cell, realm_data(k5context, afscred->client), i);
 729         if (!noprdb) {
 730             int viceid = 0;
 731             k5_to_k4_name(k5context, afscred->client, aclient);
 732             code = whoami(atoken, cellconfig, aclient, &viceid);
 733             if (code) {
 734                 afs_com_err(rn, code, "Can't get your viceid for cell %s", cellconfig->name);
 735                 *aclient->name = 0;
 736             } else
 737                 snprintf(aclient->name, MAXKTCNAMELEN-1, "AFS ID %d", viceid);
 738         }
 739         if (!*aclient->name)
 740             k5_to_k4_name(k5context, afscred->client, aclient);
 741         code = ktc_SetToken(aserver, atoken, aclient, dosetpag);
 742         if (code) {
 743             afs_com_err(rn, code, "Unable to store tokens for cell %s\n",
 744                 cellconfig->name);
 745             KLOGEXIT(1);
 746         }
 747     }
 748
 749     krb5_free_principal(k5context, princ);
 750     krb5_free_cred_contents(k5context, incred);
 751     if (outcred) krb5_free_creds(k5context, outcred);
 752     if (cc)
 753         krb5_cc_close(k5context, cc);
 754     if (tofree) free(tofree);
 755
 756     return 0;
 757 }