d714714356df12bccbe0c2c52900f87afdc750b4
[openafs.git] / src / WINNT / aklog / aklog.c
1 /* 
2  *  Copyright (C) 1989,2004 by the Massachusetts Institute of Technology
3  * 
4  * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
5  * distribute this software and its documentation for any purpose and
6  * without fee is hereby granted, provided that the above copyright
7  * notice appear in all copies and that both that copyright notice and
8  * this permission notice appear in supporting documentation, and that
9  * the name of M.I.T. not be used in advertising or publicity pertaining
10  * to distribution of the software without specific, written prior
11  * permission.  M.I.T. makes no representations about the suitability of
12  * this software for any purpose.  It is provided "as is" without express
13  * or implied warranty.
14  */
15
16 /*
17  * Copyright (c) 2007 Secure Endpoints Inc.
18  *
19  * All rights reserved.
20  *
21  * Redistribution and use in source and binary forms, with or without
22  * modification, are permitted provided that the following conditions
23  * are met:
24  *
25  *     * Redistributions of source code must retain the above copyright
26  *       notice, this list of conditions and the following disclaimer.
27  *     * Neither the name of the Secure Endpoints Inc. nor the names of its
28  *       contributors may be used to endorse or promote products derived
29  *       from this software without specific prior written permission.
30  *
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
35  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
36  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
37  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
38  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
39  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
40  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
41  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42  */
43
44 #ifndef _WIN64
45 #define HAVE_KRB4
46 #endif
47
48 #include <stdio.h>
49 #include <stdlib.h>
50 #include <string.h>
51 #include <ctype.h>
52 #include <sys/types.h>
53 #include <sys/stat.h>
54 #include <errno.h>
55 #include <afs/stds.h>
56 #ifdef HAVE_KRB4
57 #include <krb.h>
58 #else
59 #define REALM_SZ 64
60 #define ANAME_SZ 64
61 #define INST_SZ  64
62 #define KSUCCESS 0
63
64 #define CREDENTIALS void
65 #endif
66 #include <krb5.h>
67 #include <afs/ptserver.h>
68 #include <afs/ptuser.h>
69
70 #ifdef WIN32
71 #include <windows.h>
72
73 #include <cm_config.h>
74 #include <auth.h>
75 #include <cellconfig.h>
76 #include <pioctl_nt.h>
77 #include <smb_iocons.h>
78
79 #define stat _stat
80 #define lstat stat
81 #define __S_ISTYPE(mode, mask) (((mode) & _S_IFMT) == (mask))
82 #define S_ISDIR(mode)          __S_ISTYPE((mode), _S_IFDIR)
83
84 #define DONT_HAVE_GET_AD_TKT
85 #define MAXSYMLINKS 255
86
87 #ifdef HAVE_KRB4
88 /* Win32 uses get_krb_err_txt_entry(status) instead of krb_err_txt[status],
89 * so we use a bit of indirection like the GNU CVS sources.
90 */
91 #define krb_err_text(status) get_krb_err_txt_entry(status)
92 #endif
93
94 #define DRIVECOLON ':'          /* Drive letter separator */
95 #define BDIR '\\'               /* Other character that divides directories */
96
97 static int 
98 readlink(char *path, char *buf, int buffers)
99 {
100         return -1;
101 }
102
103 char * getcwd(char*, size_t);
104
105 static long 
106 get_cellconfig_callback(void *cellconfig, struct sockaddr_in *addrp, char *namep)
107 {
108         struct afsconf_cell *cc = (struct afsconf_cell *) cellconfig;
109
110         cc->hostAddr[cc->numServers] = *addrp;
111         strcpy(cc->hostName[cc->numServers], namep);
112         cc->numServers++;
113         return 0;
114 }
115
116 #else /* WIN32 */
117 #include <sys/param.h>
118 #include <netdb.h>
119 #include <arpa/inet.h>
120 #include <sys/socket.h>
121 #include <unistd.h>
122
123 #include <afs/param.h>
124 #include <afs/auth.h>
125 #include <afs/cellconfig.h>
126 #include <afs/vice.h>
127 #include <afs/venus.h>
128 #include <afs/ptserver.h>
129
130 #define krb_err_text(status) krb_err_txt[status]
131
132 /* Cheesy test for determining AFS 3.5. */
133 #ifndef AFSCONF_CLIENTNAME
134 #define AFS35
135 #endif
136
137 #ifdef AFS35
138 #include <afs/dirpath.h>
139 #else
140 #define AFSDIR_CLIENT_ETC_DIRPATH AFSCONF_CLIENTNAME
141 #endif
142
143 #endif /* WIN32 */
144
145 #include "linked_list.h"
146
147 #define AFSKEY "afs"
148 #define AFSINST ""
149
150 #define AKLOG_SUCCESS 0
151 #define AKLOG_USAGE 1
152 #define AKLOG_SOMETHINGSWRONG 2
153 #define AKLOG_AFS 3
154 #define AKLOG_KERBEROS 4
155 #define AKLOG_TOKEN 5
156 #define AKLOG_BADPATH 6
157 #define AKLOG_MISC 7
158 #define AKLOG_KFW_NOT_INSTALLED 8
159
160 #ifndef NULL
161 #define NULL 0
162 #endif
163
164 #ifndef TRUE
165 #define TRUE 1
166 #endif
167
168 #ifndef FALSE
169 #define FALSE 0
170 #endif
171
172 #ifndef MAXSYMLINKS
173 #define MAXSYMLINKS 15
174 #endif
175
176 #define DIR '/'                 /* Character that divides directories */
177 #define DIRSTRING "/"           /* String form of above */
178 #define VOLMARKER ':'           /* Character separating cellname from mntpt */
179 #define VOLMARKERSTRING ":"     /* String form of above */
180
181 typedef struct {
182     char cell[BUFSIZ];
183     char realm[REALM_SZ];
184 } cellinfo_t;
185
186
187 struct afsconf_cell ak_cellconfig; /* General information about the cell */
188
189 static char *progname = NULL;   /* Name of this program */
190 static int dflag = FALSE;       /* Give debugging information */
191 static int noprdb = FALSE;      /* Skip resolving name to id? */
192 static int force = FALSE;       /* Bash identical tokens? */
193 static linked_list authedcells; /* List of cells already logged to */
194
195 static int usev5 = TRUE;   /* use kerberos 5? */
196 static int use524 = FALSE;  /* use krb524? */
197 static krb5_ccache _krb425_ccache;
198
199 long GetLocalCell(struct afsconf_dir **pconfigdir, char *local_cell)
200 {
201     if (!(*pconfigdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH)))
202     {
203         fprintf(stderr, "%s: can't get afs configuration (afsconf_Open(%s))\n",
204                  progname, AFSDIR_CLIENT_ETC_DIRPATH);
205         exit(AKLOG_AFS);
206     }
207
208     return afsconf_GetLocalCell(*pconfigdir, local_cell, MAXCELLCHARS);
209 }
210
211 long GetCellInfo(struct afsconf_dir **pconfigdir, char* cell, 
212 struct afsconf_cell **pcellconfig)
213 {
214     return afsconf_GetCellInfo(*pconfigdir, cell, NULL, *pcellconfig);
215 }
216
217 void CloseConf(struct afsconf_dir **pconfigdir)
218 {       
219     (void) afsconf_Close(*pconfigdir);
220 }
221
222 #define ALLOW_REGISTER 1
223 void ViceIDToUsername(char *username, char *realm_of_user, char *realm_of_cell,
224                       char * cell_to_use, CREDENTIALS *c,
225                       int *status, 
226                       struct ktc_principal *aclient, struct ktc_principal *aserver, struct ktc_token *atoken)
227 {
228     static char lastcell[MAXCELLCHARS+1] = { 0 };
229     static char confname[512] = { 0 };
230     char username_copy[BUFSIZ];
231     afs_int32 viceId;                   /* AFS uid of user */
232 #ifdef ALLOW_REGISTER
233     afs_int32 id;
234 #endif /* ALLOW_REGISTER */
235
236     if (confname[0] == '\0') {
237         strncpy(confname, AFSDIR_CLIENT_ETC_DIRPATH, sizeof(confname));
238         confname[sizeof(confname) - 2] = '\0';
239     }
240
241     if (dflag)
242         printf("About to resolve name %s to id\n", username);
243
244     strcpy(lastcell, aserver->cell);
245
246     if (!pr_Initialize (0, confname, aserver->cell)) {
247         char sname[PR_MAXNAMELEN], *at;
248
249         strncpy(sname, username, PR_MAXNAMELEN);
250         sname[PR_MAXNAMELEN-1] = '\0';
251
252         at = strchr(sname, '@');
253         if (at && !stricmp(at+1, realm_of_cell))
254             *at = '\0';
255         *status = pr_SNameToId (sname, &viceId);
256     }
257
258     if (dflag)
259     {
260         if (*status)
261             printf("Error %d\n", *status);
262         else
263             printf("Id %d\n", viceId);
264     }       
265
266     /*
267      * This code is taken from cklog -- it lets people
268      * automatically register with the ptserver in foreign cells
269      */
270
271 #ifdef ALLOW_REGISTER
272     if (*status == 0) {
273         if (viceId != ANONYMOUSID) {
274 #else /* ALLOW_REGISTER */
275             if ((*status == 0) && (viceId != ANONYMOUSID))
276 #endif /* ALLOW_REGISTER */
277             {
278 #ifdef AFS_ID_TO_NAME
279                 strncpy(username_copy, username, BUFSIZ);
280                 snprintf (username, BUFSIZ, "%s (AFS ID %d)", username_copy, (int) viceId);
281 #endif /* AFS_ID_TO_NAME */
282             }
283 #ifdef ALLOW_REGISTER
284         } else if (strcmp(realm_of_user, realm_of_cell) != 0) {
285             int i;
286             if (dflag) {
287                 printf("doing first-time registration of %s "
288                         "at %s\n", username, cell_to_use);
289             }
290             id = 0;
291             strncpy(aclient->name, username, MAXKTCNAMELEN - 1);
292             aclient->name[MAXKTCNAMELEN - 1] = '\0';
293             strcpy(aclient->instance, "");
294             strncpy(aclient->cell, cell_to_use, MAXKTCREALMLEN - 1);
295             aclient->cell[MAXKTCREALMLEN - 1] = '\0';
296
297             for ( i=0; aclient->cell[i]; i++ ) {
298                 if ( islower(aclient->cell[i]) )
299                     aclient->cell[i] = toupper(aclient->cell[i]);
300             }
301
302             if ((*status = ktc_SetToken(aserver, atoken, aclient, 0))) {
303                 printf("%s: unable to set tokens for cell %s "
304                         "(status: %d).\n", progname, cell_to_use, *status);
305                 *status = AKLOG_TOKEN;
306                 return ;
307             }
308
309             /*
310              * In case you're wondering, we don't need to change the
311              * filename here because we're still connecting to the
312              * same cell -- we're just using a different authentication
313              * level
314              */
315
316             if ((*status = pr_Initialize(1L, confname, aserver->cell))) {
317                 printf("Error %d\n", *status);
318                 return;
319             }
320
321             /* copy the name because pr_CreateUser lowercases the realm */
322             strncpy(username_copy, username, BUFSIZ);
323
324             *status = pr_CreateUser(username, &id);
325
326             /* and restore the name to the original state */
327             strncpy(username, username_copy, BUFSIZ);
328
329             if (*status) {
330                 printf("%s: unable to create remote PTS "
331                         "user %s in cell %s (status: %d).\n", progname,
332                         username, cell_to_use, *status);
333             } else {
334                 printf("created cross-cell entry for %s (Id %d) at %s\n",
335                         username, viceId, cell_to_use);
336 #ifdef AFS_ID_TO_NAME
337                 snprintf (username, BUFSIZ, "%s (AFS ID %d)", username_copy, (int) viceId);
338 #endif /* AFS_ID_TO_NAME */
339             }
340         }
341     }
342 #endif /* ALLOW_REGISTER */
343 }
344
345 char *LastComponent(char *str)
346 {
347     char *ret = strrchr(str, DIR);
348
349 #ifdef WIN32
350     if (!ret)
351         ret = strrchr(str, BDIR);
352 #endif
353     return ret;
354 }
355
356 int FirstComponent(char *str)
357 {
358     return (int)(
359 #ifdef WIN32
360                 strchr(str, BDIR) ||
361 #endif
362                 strchr(str, DIR));
363 }
364
365 void CopyPathColon(char *origpath, char *path, char *pathtocheck)
366 {
367 #ifdef WIN32
368     if (origpath[1] == DRIVECOLON)
369     {
370         strncpy(pathtocheck, origpath, 2);
371         strcpy(path, origpath+2);
372     }
373     else
374 #endif
375         strcpy(path, origpath);
376 }
377
378 int BeginsWithDir(char *str, int colon)
379 {
380     return (str[0] == DIR) ||
381 #ifdef WIN32
382         ((str[0] == BDIR) || (colon && str[1] == DRIVECOLON));
383 #else
384     FALSE;
385 #endif
386 }
387
388
389 /* This is a pretty gross hack.  Linking against the Transarc
390 * libraries pulls in some rxkad functions which use des.  (I don't
391 * think they ever get called.)  With Transarc-supplied libraries this
392 * creates a reliance on the symbol des_pcbc_init() which is only in
393 * Transarc's DES libraries (it's an exportability symbol-hiding
394 * thing), which we don't want to use because they don't work with
395 * MIT's krb4 routines.  So export a des_pcbc_init() symbol here so we
396 * don't have to link against Transarc's des library.
397 */
398 int des_pcbc_init()
399 {
400     abort();
401 }
402
403 #ifdef HAVE_KRB4
404 static int get_cred(char *name, char *inst, char *realm, CREDENTIALS *c)
405 {
406     int status;
407
408     status = krb_get_cred(name, inst, realm, c);
409     if (status != KSUCCESS)
410     {
411 #ifdef DONT_HAVE_GET_AD_TKT
412         KTEXT_ST ticket;
413         status = krb_mk_req(&ticket, name, inst, realm, 0);
414 #else
415         status = get_ad_tkt(name, inst, realm, 255);
416 #endif
417         if (status == KSUCCESS)
418             status = krb_get_cred(name, inst, realm, c);
419     }       
420
421     return (status);
422 }
423 #endif
424
425 static int get_v5cred(krb5_context context, 
426                       char *name, char *inst, char *realm, CREDENTIALS *c,
427                       krb5_creds **creds)
428 {
429     krb5_creds increds;
430     krb5_error_code r;
431     static krb5_principal client_principal = 0;
432
433     memset((char *)&increds, 0, sizeof(increds));
434
435     if ((r = krb5_build_principal(context, &increds.server,
436                                   (int)strlen(realm), realm,
437                                   name,
438                                   (inst && strlen(inst)) ? inst : 0,
439                                   0))) {
440         return((int)r);
441     }
442
443     if (!_krb425_ccache)
444         krb5_cc_default(context, &_krb425_ccache);
445     if (!client_principal)
446         krb5_cc_get_principal(context, _krb425_ccache, &client_principal);
447
448     increds.client = client_principal;
449     increds.times.endtime = 0;
450         /* Ask for DES since that is what V4 understands */
451     increds.keyblock.enctype = ENCTYPE_DES_CBC_CRC;
452
453     r = krb5_get_credentials(context, 0, _krb425_ccache, &increds, creds);
454     if (r)
455         return((int)r);
456
457     /* This requires krb524d to be running with the KDC */
458     if (c != NULL)
459         r = krb5_524_convert_creds(context, *creds, c);
460     return((int)r);
461 }
462
463 #ifdef HAVE_KRB4
464 /* There is no header for this function.  It is supposed to be private */
465 int krb_get_admhst(char *h,char *r, int n);
466
467 static char *afs_realm_of_cell(struct afsconf_cell *cellconfig)
468 {
469     char krbhst[MAX_HSTNM];
470     static char krbrlm[REALM_SZ+1];
471
472     if (!cellconfig)
473         return 0;
474
475     strcpy(krbrlm, (char *) krb_realmofhost(cellconfig->hostName[0]));
476
477     if (krb_get_admhst(krbhst, krbrlm, 1) != KSUCCESS)
478     {
479         char *s = krbrlm;
480         char *t = cellconfig->name;
481         int c;
482
483         while (c = *t++)
484         {
485             if (islower(c))
486                 c = toupper(c);
487             *s++ = c;
488         }
489         *s++ = 0;
490     }
491     return krbrlm;
492 }
493 #endif
494
495 /* As of MIT Kerberos 1.6, krb5_get_host_realm() will return the NUL-string 
496  * if there is no domain_realm mapping for the hostname's domain.  This is 
497  * used as a trigger indicating that referrals should be used within the
498  * krb5_get_credentials() call.  However, if the KDC does not support referrals
499  * that will result in a KRB5_ERR_HOST_REALM_UNKNOWN error and we will have
500  * to manually fallback to mapping the domain of the host as a realm name.
501  * Hence, the new fallback parameter.
502  */
503 static char *afs_realm_of_cell5(krb5_context context, struct afsconf_cell *cellconfig, int fallback)
504 {
505     char ** krbrlms = 0;
506     static char krbrlm[REALM_SZ+1];
507     krb5_error_code status;
508
509     if (!cellconfig)
510         return 0;
511
512     if (fallback) {
513         char * p;
514         p = strchr(cellconfig->hostName[0], '.');
515         if (p++)
516             strcpy(krbrlm, p);
517         else
518             strcpy(krbrlm, cellconfig->name);
519         strupr(krbrlm);
520     } else {
521         status = krb5_get_host_realm( context, cellconfig->hostName[0], &krbrlms );
522         if (status == 0 && krbrlms && krbrlms[0]) {
523             strcpy(krbrlm, krbrlms[0]);
524         } else {
525             strcpy(krbrlm, cellconfig->name);
526             strupr(krbrlm);
527         }
528
529         if (krbrlms)
530             krb5_free_host_realm( context, krbrlms );
531     }
532     return krbrlm;
533 }       
534
535 static char *copy_cellinfo(cellinfo_t *cellinfo)
536 {
537     cellinfo_t *new_cellinfo;
538
539     if (new_cellinfo = (cellinfo_t *)malloc(sizeof(cellinfo_t)))
540         memcpy(new_cellinfo, cellinfo, sizeof(cellinfo_t));
541
542     return ((char *)new_cellinfo);
543 }
544
545
546 static char *copy_string(char *string)
547 {
548     char *new_string;
549
550     if (new_string = (char *)calloc(strlen(string) + 1, sizeof(char)))
551         (void) strcpy(new_string, string);
552
553     return (new_string);
554 }       
555
556
557 static int get_cellconfig(char *cell, struct afsconf_cell *cellconfig,
558                                                   char *local_cell)
559 {
560     int status = AKLOG_SUCCESS;
561     struct afsconf_dir *configdir = 0;
562
563     memset(local_cell, 0, sizeof(local_cell));
564     memset(cellconfig, 0, sizeof(*cellconfig));
565
566     if (GetLocalCell(&configdir, local_cell))
567     {
568         fprintf(stderr, "%s: can't determine local cell.\n", progname);
569         exit(AKLOG_AFS);
570     }
571
572     if ((cell == NULL) || (cell[0] == 0))
573         cell = local_cell;
574
575     if (GetCellInfo(&configdir, cell, &cellconfig))
576     {
577         fprintf(stderr, "%s: Can't get information about cell %s.\n",
578                 progname, cell);
579         status = AKLOG_AFS;
580     }
581
582
583     CloseConf(&configdir);
584
585     return(status);
586 }
587
588 static int get_v5_user_realm(krb5_context context,char *realm)
589 {
590     static krb5_principal client_principal = 0;
591     int i;
592
593     if (!_krb425_ccache)
594         krb5_cc_default(context, &_krb425_ccache);
595     if (!client_principal)
596         krb5_cc_get_principal(context, _krb425_ccache, &client_principal);
597
598     i = krb5_princ_realm(context, client_principal)->length;
599     if (i < REALM_SZ-1) i = REALM_SZ-1;
600     strncpy(realm,krb5_princ_realm(context, client_principal)->data,i);
601     realm[i] = 0;
602     return(KSUCCESS);
603 }
604
605 /*
606 * Log to a cell.  If the cell has already been logged to, return without
607 * doing anything.  Otherwise, log to it and mark that it has been logged
608 * to.  */
609 static int auth_to_cell(krb5_context context, char *cell, char *realm)
610 {
611     int status = AKLOG_SUCCESS;
612     char username[BUFSIZ];        /* To hold client username structure */
613
614     char name[ANAME_SZ];          /* Name of afs key */
615     char instance[INST_SZ];       /* Instance of afs key */
616     char realm_of_user[REALM_SZ]; /* Kerberos realm of user */
617     char realm_of_cell[REALM_SZ]; /* Kerberos realm of cell */
618     char local_cell[MAXCELLCHARS+1];
619     char cell_to_use[MAXCELLCHARS+1]; /* Cell to authenticate to */
620
621     krb5_creds *v5cred = NULL;
622 #ifdef HAVE_KRB4
623     CREDENTIALS c;
624 #endif
625     struct ktc_principal aserver;
626     struct ktc_principal aclient;
627     struct ktc_token atoken, btoken;
628     int i;
629
630     /* try to avoid an expensive call to get_cellconfig */
631     if (cell && ll_string_check(&authedcells, cell))
632     {
633         if (dflag)
634             printf("Already authenticated to %s (or tried to)\n", cell);
635         return(AKLOG_SUCCESS);
636     }
637
638     memset(name, 0, sizeof(name));
639     memset(instance, 0, sizeof(instance));
640     memset(realm_of_user, 0, sizeof(realm_of_user));
641     memset(realm_of_cell, 0, sizeof(realm_of_cell));
642
643     /* NULL or empty cell returns information on local cell */
644     if (status = get_cellconfig(cell, &ak_cellconfig, local_cell))
645         return(status);
646
647     strncpy(cell_to_use, ak_cellconfig.name, MAXCELLCHARS);
648     cell_to_use[MAXCELLCHARS] = 0;
649
650     if (ll_string_check(&authedcells, cell_to_use))
651     {
652         if (dflag)
653             printf("Already authenticated to %s (or tried to)\n", cell_to_use);
654         return(AKLOG_SUCCESS);
655     }
656
657     /*
658      * Record that we have attempted to log to this cell.  We do this
659      * before we try rather than after so that we will not try
660      * and fail repeatedly for one cell.
661      */
662     (void)ll_add_string(&authedcells, cell_to_use);
663
664     if (dflag)
665         printf("Authenticating to cell %s.\n", cell_to_use);
666
667     /* We use the afs.<cellname> convention here... */
668     strcpy(name, AFSKEY);
669     strncpy(instance, cell_to_use, sizeof(instance));
670     instance[sizeof(instance)-1] = '\0';
671
672     /*
673      * Extract the session key from the ticket file and hand-frob an
674      * afs style authenticator.
675      */
676
677     if (usev5) 
678     { /* using krb5 */
679         int retry = 1;
680         int realm_fallback = 0;
681
682         if ( strchr(name,'.') != NULL ) {
683             fprintf(stderr, "%s: Can't support principal names including a dot.\n",
684                     progname);
685             return(AKLOG_MISC);
686         }
687
688       try_v5:
689         if (realm && realm[0])
690             strcpy(realm_of_cell, realm);
691         else
692             strcpy(realm_of_cell,
693                     afs_realm_of_cell5(context, &ak_cellconfig, realm_fallback));
694
695         if (dflag)
696             printf("Getting v5 tickets: %s/%s@%s\n", name, instance, realm_of_cell);
697         status = get_v5cred(context, name, instance, realm_of_cell, 
698 #ifdef HAVE_KRB4
699                             use524 ? &c : NULL, 
700 #else
701                             NULL,
702 #endif
703                             &v5cred);
704
705         if (status == 0 && strcmp(realm_of_cell, "") == 0) {
706             krb5_error_code code;
707             krb5_ticket *ticket;
708
709             code = krb5_decode_ticket(&v5cred->ticket, &ticket);
710
711             if (code != 0) {
712                 fprintf(stderr,
713                          "%s: Couldn't decode ticket to determine realm for "
714                          "cell %s.\n",
715                          progname, cell_to_use);
716             } else {
717                 int len = krb5_princ_realm(context, ticket->server)->length;
718                 /* This really shouldn't happen. */
719                 if (len > REALM_SZ-1)
720                     len = REALM_SZ-1;
721
722                 strncpy(realm_of_cell, krb5_princ_realm(context, ticket->server)->data, len);
723                 realm_of_cell[len] = 0;
724
725                 krb5_free_ticket(context, ticket);
726             }
727         }
728
729         if (status == KRB5_ERR_HOST_REALM_UNKNOWN) {
730             realm_fallback = 1;
731             goto try_v5;
732         } else if (status == KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN) {
733             if (!realm_of_cell[0]) {
734                 realm_fallback = 1;
735                 goto try_v5;
736             }
737             if (dflag)
738                 printf("Getting v5 tickets: %s@%s\n", name, realm_of_cell);
739             status = get_v5cred(context, name, "", realm_of_cell, 
740 #ifdef HAVE_KRB4
741                                 use524 ? &c : NULL, 
742 #else
743                                 NULL,
744 #endif
745                                 &v5cred);
746         }
747         if ( status == KRB5KRB_AP_ERR_MSG_TYPE && retry ) {
748             retry = 0;
749             realm_fallback = 0;
750             goto try_v5;
751         }       
752     }       
753     else 
754     {
755 #ifdef HAVE_KRB4
756         if (realm && realm[0])
757             strcpy(realm_of_cell, realm);
758         else
759             strcpy(realm_of_cell, afs_realm_of_cell(&ak_cellconfig));
760
761         /*
762          * Try to obtain AFS tickets.  Because there are two valid service
763          * names, we will try both, but trying the more specific first.
764          *
765          *      afs.<cell>@<realm>
766          *      afs@<realm>
767          */
768         if (dflag)
769             printf("Getting tickets: %s.%s@%s\n", name, instance, realm_of_cell);
770         status = get_cred(name, instance, realm_of_cell, &c);
771         if (status == KDC_PR_UNKNOWN)
772         {
773             if (dflag)
774                 printf("Getting tickets: %s@%s\n", name, realm_of_cell);
775             status = get_cred(name, "", realm_of_cell, &c);
776         }
777 #else
778         return(AKLOG_MISC);
779 #endif
780     } 
781
782     /* TODO: get k5 error text */
783     if (status != KSUCCESS)
784     {
785         if (dflag)
786             printf("Kerberos error code returned by get_cred: %d\n", status);
787         fprintf(stderr, "%s: Couldn't get %s AFS tickets: %s\n",
788                  progname, cell_to_use, 
789 #ifdef HAVE_KRB4
790                  (usev5)?"":krb_err_text(status)
791 #else
792                  ""
793 #endif
794                  );
795         return(AKLOG_KERBEROS);
796     }
797
798     strncpy(aserver.name, AFSKEY, MAXKTCNAMELEN - 1);
799     strncpy(aserver.instance, AFSINST, MAXKTCNAMELEN - 1);
800     strncpy(aserver.cell, cell_to_use, MAXKTCREALMLEN - 1);
801
802     if (usev5 && !use524) {
803         /* This code inserts the entire K5 ticket into the token
804          * No need to perform a krb524 translation which is
805          * commented out in the code below
806          */
807         char * p;
808         int len;
809         
810         len = min(v5cred->client->data[0].length,MAXKTCNAMELEN - 1);
811         strncpy(username, v5cred->client->data[0].data, len);
812         username[len] = '\0';
813
814         if ( v5cred->client->length > 1 ) {
815             strcat(username, ".");
816             p = username + strlen(username);
817             len = min(v5cred->client->data[1].length,MAXKTCNAMELEN - strlen(username) - 1);
818             strncpy(p, v5cred->client->data[1].data, len);
819             p[len] = '\0';
820         }
821
822         memset(&atoken, '\0', sizeof(atoken));
823         atoken.kvno = RXKAD_TKT_TYPE_KERBEROS_V5;
824         atoken.startTime = v5cred->times.starttime;
825         atoken.endTime = v5cred->times.endtime;
826         memcpy(&atoken.sessionKey, v5cred->keyblock.contents, v5cred->keyblock.length);
827         atoken.ticketLen = v5cred->ticket.length;
828         memcpy(atoken.ticket, v5cred->ticket.data, atoken.ticketLen);
829     } else {
830 #ifdef HAVE_KRB4
831         strcpy (username, c.pname);
832         if (c.pinst[0])
833         {
834             strcat(username, ".");
835             strcat(username, c.pinst);
836         }
837
838         atoken.kvno = c.kvno;
839         atoken.startTime = c.issue_date;
840         /* ticket lifetime is in five-minutes blocks. */
841         atoken.endTime = c.issue_date + ((unsigned char)c.lifetime * 5 * 60);
842
843         memcpy(&atoken.sessionKey, c.session, 8);
844         atoken.ticketLen = c.ticket_st.length;
845         memcpy(atoken.ticket, c.ticket_st.dat, atoken.ticketLen);
846 #else
847         return(AKLOG_MISC);
848 #endif
849     }
850
851     if (!force &&
852          !ktc_GetToken(&aserver, &btoken, sizeof(btoken), &aclient) &&
853          atoken.kvno == btoken.kvno &&
854          atoken.ticketLen == btoken.ticketLen &&
855          !memcmp(&atoken.sessionKey, &btoken.sessionKey, sizeof(atoken.sessionKey)) &&
856          !memcmp(atoken.ticket, btoken.ticket, atoken.ticketLen))
857     {       
858         if (dflag)
859             printf("Identical tokens already exist; skipping.\n");
860         return 0;
861     }
862
863     if (noprdb)
864     {
865         if (dflag)
866             printf("Not resolving name %s to id (-noprdb set)\n", username);
867     }       
868     else    
869     {
870         if (usev5) {
871             if((status = get_v5_user_realm(context, realm_of_user)) != KSUCCESS) {
872                 fprintf(stderr, "%s: Couldn't determine realm of user: %d\n",
873                          progname, status);
874                 return(AKLOG_KERBEROS);
875             }
876         } else {
877 #ifdef HAVE_KRB4
878             if ((status = krb_get_tf_realm(TKT_FILE, realm_of_user)) != KSUCCESS)
879             {
880                 fprintf(stderr, "%s: Couldn't determine realm of user: %s)",
881                          progname, krb_err_text(status));
882                 return(AKLOG_KERBEROS);
883             }
884 #else
885             return(AKLOG_MISC);
886 #endif
887         }
888
889         /* For Khimaira we want to always append the realm to the name */
890         if (1 /* strcmp(realm_of_user, realm_of_cell) */)
891         {
892             strcat(username, "@");
893             strcat(username, realm_of_user);
894         }
895
896         ViceIDToUsername(username, realm_of_user, realm_of_cell, cell_to_use, 
897 #ifdef HAVE_KRB4
898                           &c, 
899 #else
900                           NULL,
901 #endif
902                           &status, &aclient, &aserver, &atoken);
903     }
904
905     if (dflag)
906         printf("Set username to %s\n", username);
907
908     /* Reset the "aclient" structure before we call ktc_SetToken.
909      * This structure was first set by the ktc_GetToken call when
910      * we were comparing whether identical tokens already existed.
911      */
912     strncpy(aclient.name, username, MAXKTCNAMELEN - 1);
913     strcpy(aclient.instance, "");
914     
915     if (usev5 && !use524) {
916         int len = min(v5cred->client->realm.length,MAXKTCNAMELEN - 1);
917         strncpy(aclient.cell, v5cred->client->realm.data, len);
918         aclient.cell[len] = '\0';
919     } 
920 #ifdef HAVE_KRB4
921     else
922         strncpy(aclient.cell, c.realm, MAXKTCREALMLEN - 1);
923 #endif
924
925     for ( i=0; aclient.cell[i]; i++ ) {
926         if ( islower(aclient.cell[i]) )
927             aclient.cell[i] = toupper(aclient.cell[i]);
928     }
929
930     if (dflag)
931         printf("Getting tokens.\n");
932     if (status = ktc_SetToken(&aserver, &atoken, &aclient, 0))
933     {
934         fprintf(stderr,
935                  "%s: unable to obtain tokens for cell %s (status: %d).\n",
936                  progname, cell_to_use, status);
937         status = AKLOG_TOKEN;
938     }
939
940     return(status);
941 }
942
943 static int get_afs_mountpoint(char *file, char *mountpoint, int size)
944 {
945     char our_file[MAXPATHLEN + 1];
946     char *parent_dir;
947     char *last_component;
948     struct ViceIoctl vio;
949     char cellname[BUFSIZ];
950
951     memset(our_file, 0, sizeof(our_file));
952     strcpy(our_file, file);
953
954     if (last_component = LastComponent(our_file))
955     {
956         *last_component++ = 0;
957         parent_dir = our_file;
958     }
959     else
960     {
961         last_component = our_file;
962         parent_dir = ".";
963     }
964
965     memset(cellname, 0, sizeof(cellname));
966
967     vio.in = last_component;
968     vio.in_size = strlen(last_component)+1;
969     vio.out_size = size;
970     vio.out = mountpoint;
971
972     if (!pioctl(parent_dir, VIOC_AFS_STAT_MT_PT, &vio, 0))
973     {
974         if (strchr(mountpoint, VOLMARKER) == NULL)
975         {
976             vio.in = file;
977             vio.in_size = strlen(file) + 1;
978             vio.out_size = sizeof(cellname);
979             vio.out = cellname;
980
981             if (!pioctl(file, VIOC_FILE_CELL_NAME, &vio, 1))
982             {
983                 strcat(cellname, VOLMARKERSTRING);
984                 strcat(cellname, mountpoint + 1);
985                 memset(mountpoint + 1, 0, size - 1);
986                 strcpy(mountpoint + 1, cellname);
987             }
988         }
989         return(TRUE);
990     }
991     else {
992         return(FALSE);
993     }
994 }       
995
996 /*
997 * This routine each time it is called returns the next directory
998 * down a pathname.  It resolves all symbolic links.  The first time
999 * it is called, it should be called with the name of the path
1000 * to be descended.  After that, it should be called with the arguemnt
1001 * NULL.
1002 */
1003 static char *next_path(char *origpath)
1004 {
1005     static char path[MAXPATHLEN + 1];
1006     static char pathtocheck[MAXPATHLEN + 1];
1007
1008     int link = FALSE;           /* Is this a symbolic link? */
1009     char linkbuf[MAXPATHLEN + 1];
1010     char tmpbuf[MAXPATHLEN + 1];
1011
1012     static char *last_comp;     /* last component of directory name */
1013     static char *elast_comp;    /* End of last component */
1014     char *t;
1015     int len;
1016
1017     static int symlinkcount = 0;        /* We can't exceed MAXSYMLINKS */
1018
1019     /* If we are given something for origpath, we are initializing only. */
1020     if (origpath)
1021     {
1022         memset(path, 0, sizeof(path));
1023         memset(pathtocheck, 0, sizeof(pathtocheck));
1024         CopyPathColon(origpath, path, pathtocheck);
1025         last_comp = path;
1026         symlinkcount = 0;
1027         return(NULL);
1028     }
1029
1030     /* We were not given origpath; find then next path to check */
1031
1032     /* If we've gotten all the way through already, return NULL */
1033     if (last_comp == NULL)
1034         return(NULL);
1035
1036     do
1037     {
1038         while (BeginsWithDir(last_comp, FALSE))
1039             strncat(pathtocheck, last_comp++, 1);
1040         len = (elast_comp = LastComponent(last_comp))
1041             ? elast_comp - last_comp : strlen(last_comp);
1042         strncat(pathtocheck, last_comp, len);
1043         memset(linkbuf, 0, sizeof(linkbuf));
1044         if (link = (readlink(pathtocheck, linkbuf, sizeof(linkbuf)) > 0))
1045         {
1046             if (++symlinkcount > MAXSYMLINKS)
1047             {
1048                 fprintf(stderr, "%s: %s\n", progname, strerror(ELOOP));
1049                 exit(AKLOG_BADPATH);
1050             }
1051             memset(tmpbuf, 0, sizeof(tmpbuf));
1052             if (elast_comp)
1053                 strcpy(tmpbuf, elast_comp);
1054             if (BeginsWithDir(linkbuf, FALSE))
1055             {
1056                 /*
1057                 * If this is a symbolic link to an absolute path,
1058                 * replace what we have by the absolute path.
1059                 */
1060                 memset(path, 0, strlen(path));
1061                 memcpy(path, linkbuf, sizeof(linkbuf));
1062                 strcat(path, tmpbuf);
1063                 last_comp = path;
1064                 elast_comp = NULL;
1065                 memset(pathtocheck, 0, sizeof(pathtocheck));
1066             }
1067             else
1068             {
1069                 /*
1070                 * If this is a symbolic link to a relative path,
1071                 * replace only the last component with the link name.
1072                 */
1073                 strncpy(last_comp, linkbuf, strlen(linkbuf) + 1);
1074                 strcat(path, tmpbuf);
1075                 elast_comp = NULL;
1076                 if (t = LastComponent(pathtocheck))
1077                 {
1078                     t++;
1079                     memset(t, 0, strlen(t));
1080                 }
1081                 else
1082                     memset(pathtocheck, 0, sizeof(pathtocheck));
1083             }
1084         }
1085         else
1086             last_comp = elast_comp;
1087     }       
1088     while(link);
1089
1090     return(pathtocheck);
1091 }
1092
1093 /*
1094 * This routine descends through a path to a directory, logging to
1095 * every cell it encounters along the way.
1096 */
1097 static int auth_to_path(krb5_context context, char *path)
1098 {
1099     int status = AKLOG_SUCCESS;
1100     int auth_to_cell_status = AKLOG_SUCCESS;
1101
1102     char *nextpath;
1103     char pathtocheck[MAXPATHLEN + 1];
1104     char mountpoint[MAXPATHLEN + 1];
1105
1106     char *cell;
1107     char *endofcell;
1108
1109     /* Initialize */
1110     if (BeginsWithDir(path, TRUE))
1111         strcpy(pathtocheck, path);
1112     else
1113     {
1114         if (getcwd(pathtocheck, sizeof(pathtocheck)) == NULL)
1115         {
1116             fprintf(stderr, "Unable to find current working directory:\n");
1117             fprintf(stderr, "%s\n", pathtocheck);
1118             fprintf(stderr, "Try an absolute pathname.\n");
1119             exit(AKLOG_BADPATH);
1120         }
1121         else
1122         {
1123             /* in WIN32, if getcwd returns a root dir (eg: c:\), the returned string
1124             * will already have a trailing slash ('\'). Otherwise, the string will
1125             * end in the last directory name */
1126 #ifdef WIN32    
1127             if(pathtocheck[strlen(pathtocheck) - 1] != BDIR)
1128 #endif  
1129                 strcat(pathtocheck, DIRSTRING);
1130             strcat(pathtocheck, path);
1131         }
1132     }
1133     next_path(pathtocheck);
1134
1135     /* Go on to the next level down the path */
1136     while (nextpath = next_path(NULL))
1137     {
1138         strcpy(pathtocheck, nextpath);
1139         if (dflag)
1140             printf("Checking directory [%s]\n", pathtocheck);
1141         /*
1142         * If this is an afs mountpoint, determine what cell from
1143         * the mountpoint name which is of the form
1144         * #cellname:volumename or %cellname:volumename.
1145         */
1146         if (get_afs_mountpoint(pathtocheck, mountpoint, sizeof(mountpoint)))
1147         {
1148             if(dflag)
1149                 printf("Found mount point [%s]\n", mountpoint);
1150             /* skip over the '#' or '%' */
1151             cell = mountpoint + 1;
1152             if (endofcell = strchr(mountpoint, VOLMARKER))
1153             {
1154                 *endofcell = '\0';
1155                 if (auth_to_cell_status = auth_to_cell(context, cell, NULL))
1156                 {
1157                     if (status == AKLOG_SUCCESS)
1158                         status = auth_to_cell_status;
1159                     else if (status != auth_to_cell_status)
1160                         status = AKLOG_SOMETHINGSWRONG;
1161                 }
1162             }
1163         }
1164         else
1165         {
1166             struct stat st;
1167
1168             if (lstat(pathtocheck, &st) < 0)
1169             {
1170                 /*
1171                 * If we've logged and still can't stat, there's
1172                 * a problem...
1173                 */
1174                 fprintf(stderr, "%s: stat(%s): %s\n", progname,
1175                          pathtocheck, strerror(errno));
1176                 return(AKLOG_BADPATH);
1177             }
1178             else if (!S_ISDIR(st.st_mode))
1179             {
1180                 /* Allow only directories */
1181                 fprintf(stderr, "%s: %s: %s\n", progname, pathtocheck,
1182                          strerror(ENOTDIR));
1183                 return(AKLOG_BADPATH);
1184             }
1185         }
1186     }
1187
1188     return(status);
1189 }
1190
1191 /* Print usage message and exit */
1192 static void usage(void)
1193 {
1194     fprintf(stderr, "\nUsage: %s %s%s%s%s\n", progname,
1195              "[-d] [[-cell | -c] cell [-k krb_realm]] ",
1196              "[[-p | -path] pathname]\n",
1197              "    [-noprdb] [-force]\n",
1198 #ifdef HAVE_KRB4
1199              "    [-5 [-m]| -4]\n"
1200 #else
1201              "    [-5]\n"
1202 #endif
1203              );
1204     fprintf(stderr, "    -d gives debugging information.\n");
1205     fprintf(stderr, "    krb_realm is the kerberos realm of a cell.\n");
1206     fprintf(stderr, "    pathname is the name of a directory to which ");
1207     fprintf(stderr, "you wish to authenticate.\n");
1208     fprintf(stderr, "    -noprdb means don't try to determine AFS ID.\n");
1209 #ifdef HAVE_KRB4
1210     fprintf(stderr, "    -5 or -4 selects whether to use Kerberos v5 or Kerberos v4.\n"
1211                     "       (default is Kerberos v5)\n");
1212     fprintf(stderr, "       -m means use krb524d to convert Kerberos v5 tickets.\n");
1213 #else
1214     fprintf(stderr, "    -5 use Kerberos v5.\n"
1215                     "       (only Kerberos v5 is available)\n");
1216 #endif
1217     fprintf(stderr, "    No commandline arguments means ");
1218     fprintf(stderr, "authenticate to the local cell.\n");
1219     fprintf(stderr, "\n");
1220     exit(AKLOG_USAGE);
1221 }
1222
1223 void
1224 validate_krb5_availability(void)
1225 {
1226 #ifndef _WIN64
1227 #define KRB5LIB "krb5_32.dll"
1228 #else
1229 #define KRB5LIB "krb5_64.dll"
1230 #endif
1231     HINSTANCE h = LoadLibrary(KRB5LIB);
1232     if (h) 
1233         FreeLibrary(h);
1234     else {
1235         fprintf(stderr, "Kerberos for Windows library %s is not available.\n", KRB5LIB);
1236         exit(AKLOG_KFW_NOT_INSTALLED);
1237     }
1238 }
1239
1240 void
1241 validate_krb4_availability(void)
1242 {
1243 #ifdef HAVE_KRB4
1244     HINSTANCE h = LoadLibrary("krbv4w32.dll");
1245     if (h) 
1246         FreeLibrary(h);
1247     else {
1248         fprintf(stderr, "Kerberos for Windows library krbv4w32.dll is not available.\n");
1249         exit(AKLOG_KFW_NOT_INSTALLED);
1250     }
1251 #else
1252     fprintf(stderr, "Kerberos v4 is not available in this build of aklog.\n");
1253     exit(AKLOG_USAGE);
1254 #endif
1255 }
1256
1257 int main(int argc, char *argv[])
1258 {
1259     int status = AKLOG_SUCCESS;
1260     int i;
1261     int somethingswrong = FALSE;
1262
1263     cellinfo_t cellinfo;
1264
1265     extern char *progname;      /* Name of this program */
1266
1267     extern int dflag;           /* Debug mode */
1268
1269     int cmode = FALSE;          /* Cellname mode */
1270     int pmode = FALSE;          /* Path name mode */
1271
1272     char realm[REALM_SZ];               /* Kerberos realm of afs server */
1273     char cell[BUFSIZ];          /* Cell to which we are authenticating */
1274     char path[MAXPATHLEN + 1];  /* Path length for path mode */
1275
1276     linked_list cells;          /* List of cells to log to */
1277     linked_list paths;          /* List of paths to log to */
1278     ll_node *cur_node;
1279
1280     krb5_context context = 0;
1281
1282     memset(&cellinfo, 0, sizeof(cellinfo));
1283
1284     memset(realm, 0, sizeof(realm));
1285     memset(cell, 0, sizeof(cell));
1286     memset(path, 0, sizeof(path));
1287
1288     ll_init(&cells);
1289     ll_init(&paths);
1290
1291     /* Store the program name here for error messages */
1292     if (progname = LastComponent(argv[0]))
1293         progname++;
1294     else
1295         progname = argv[0];
1296
1297     /* Initialize list of cells to which we have authenticated */
1298     (void)ll_init(&authedcells);
1299
1300     /* Parse commandline arguments and make list of what to do. */
1301     for (i = 1; i < argc; i++)
1302     {
1303         if (strcmp(argv[i], "-d") == 0)
1304             dflag++;
1305         else if (strcmp(argv[i], "-5") == 0)
1306             usev5++;
1307 #ifdef HAVE_KRB4
1308         else if (strcmp(argv[i], "-m") == 0)
1309             use524++;
1310         else if (strcmp(argv[i], "-4") == 0)
1311             usev5 = 0;
1312 #endif
1313         else if (strcmp(argv[i], "-noprdb") == 0)
1314             noprdb++;
1315         else if (strcmp(argv[i], "-force") == 0)
1316             force++;
1317         else if (((strcmp(argv[i], "-cell") == 0) ||
1318                    (strcmp(argv[i], "-c") == 0)) && !pmode)
1319         {       
1320             if (++i < argc)
1321             {
1322                 cmode++;
1323                 strcpy(cell, argv[i]);
1324             }
1325             else
1326                 usage();
1327         }
1328         else if (((strcmp(argv[i], "-path") == 0) ||
1329                    (strcmp(argv[i], "-p") == 0)) && !cmode)
1330         {       
1331             if (++i < argc)
1332             {
1333                 pmode++;
1334                 strcpy(path, argv[i]);
1335             }
1336             else
1337                 usage();
1338         }
1339         else if (argv[i][0] == '-')
1340             usage();
1341         else if (!pmode && !cmode)
1342         {
1343             if (FirstComponent(argv[i]) || (strcmp(argv[i], ".") == 0) ||
1344                  (strcmp(argv[i], "..") == 0))
1345             {
1346                 pmode++;
1347                 strcpy(path, argv[i]);
1348             }
1349             else
1350             {
1351                 cmode++;
1352                 strcpy(cell, argv[i]);
1353             }
1354         }
1355         else
1356             usage();
1357
1358         if (cmode)
1359         {
1360             if (((i + 1) < argc) && (strcmp(argv[i + 1], "-k") == 0))
1361             {
1362                 i += 2;
1363                 if (i < argc)
1364                     strcpy(realm, argv[i]);
1365                 else
1366                     usage();
1367             }
1368             /* Add this cell to list of cells */
1369             strcpy(cellinfo.cell, cell);
1370             strcpy(cellinfo.realm, realm);
1371             if (cur_node = ll_add_node(&cells, ll_tail))
1372             {
1373                 char *new_cellinfo;
1374                 if (new_cellinfo = copy_cellinfo(&cellinfo))
1375                     ll_add_data(cur_node, new_cellinfo);
1376                 else
1377                 {
1378                     fprintf(stderr, "%s: failure copying cellinfo.\n", progname);
1379                     exit(AKLOG_MISC);
1380                 }
1381             }
1382             else
1383             {
1384                 fprintf(stderr, "%s: failure adding cell to cells list.\n",
1385                          progname);
1386                 exit(AKLOG_MISC);
1387             }
1388             memset(&cellinfo, 0, sizeof(cellinfo));
1389             cmode = FALSE;
1390             memset(cell, 0, sizeof(cell));
1391             memset(realm, 0, sizeof(realm));
1392         }
1393         else if (pmode)
1394         {
1395             /* Add this path to list of paths */
1396             if (cur_node = ll_add_node(&paths, ll_tail))
1397             {
1398                 char *new_path;
1399                 if (new_path = copy_string(path))
1400                     ll_add_data(cur_node, new_path);
1401                 else
1402                 {
1403                     fprintf(stderr, "%s: failure copying path name.\n",
1404                              progname);
1405                     exit(AKLOG_MISC);
1406                 }
1407             }
1408             else
1409             {
1410                 fprintf(stderr, "%s: failure adding path to paths list.\n",
1411                          progname);
1412                 exit(AKLOG_MISC);
1413             }
1414             pmode = FALSE;
1415             memset(path, 0, sizeof(path));
1416         }
1417     }
1418
1419     if (usev5)
1420         validate_krb5_availability();
1421     else 
1422         validate_krb4_availability();
1423
1424     if(usev5)
1425         krb5_init_context(&context);
1426
1427     /* If nothing was given, log to the local cell. */
1428     if ((cells.nelements + paths.nelements) == 0)
1429         status = auth_to_cell(context, NULL, NULL);
1430     else
1431     {
1432         /* Log to all cells in the cells list first */
1433         for (cur_node = cells.first; cur_node; cur_node = cur_node->next)
1434         {
1435             memcpy(&cellinfo, cur_node->data, sizeof(cellinfo));
1436             if (status = auth_to_cell(context, 
1437                                        cellinfo.cell, cellinfo.realm))
1438                 somethingswrong++;
1439         }       
1440
1441         /* Then, log to all paths in the paths list */
1442         for (cur_node = paths.first; cur_node; cur_node = cur_node->next)
1443         {
1444             if (status = auth_to_path(context, 
1445                                        cur_node->data))
1446                 somethingswrong++;
1447         }
1448
1449         /*
1450         * If only one thing was logged to, we'll return the status
1451         * of the single call.  Otherwise, we'll return a generic
1452         * something failed status.
1453         */
1454         if (somethingswrong && ((cells.nelements + paths.nelements) > 1))
1455             status = AKLOG_SOMETHINGSWRONG;
1456     }       
1457
1458     if(usev5)
1459         krb5_free_context(context);
1460
1461     exit(status);
1462 }