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