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