Fix shlibafsrpc des.c hp-ux special case
[openafs.git] / 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 }