b887aea01508e6d8bc661d833ce37da30ffb08da
[openafs.git] / src / aklog / aklog_main.c
1 /* 
2  * $Id$
3  *
4  * Copyright 1990,1991 by the Massachusetts Institute of Technology
5  * For distribution and copying rights, see the file "mit-copyright.h"
6  */
7
8 #if !defined(lint) && !defined(SABER)
9 static char *rcsid =
10         "$Id$";
11 #endif /* lint || SABER */
12
13 #include <stdio.h>
14 #include <string.h>
15 #include <ctype.h>
16 #include <sys/types.h>
17 #ifdef HAVE_UNISTD_H
18 #include <unistd.h>
19 #endif
20 #ifdef HAVE_STDLIB_H
21 #include <stdlib.h>
22 #endif
23 #ifdef HAVE_MEMORY_H
24 #include <memory.h>
25 #endif
26 #include <errno.h>
27
28 #include <sys/stat.h>
29 #include <fcntl.h>
30
31 #ifndef WINDOWS
32 #include <sys/param.h>
33 #include <sys/errno.h>
34 #include <netdb.h>
35 #include <sys/socket.h>
36 #include <netinet/in.h>
37 #include <arpa/inet.h>
38 #include <pwd.h>
39 #endif /* WINDOWS */
40
41 /* on AIX AFS has an unresolved reference to osi_audit. We will define
42  * it here as extern. It also trys to call the ntohl and htonl routines
43  * as routines rather then macros. We need a real routine here. 
44  * We do this before the ntohl and htonl macros are defined in net/in.h
45  */
46 int osi_audit()
47     { return(0);}
48
49 #if 0
50 #ifdef _AIX
51 u_long htonl(u_long x)
52     { return(x);}
53
54 u_long ntohl(u_long x)
55     { return(x);}
56 #endif
57
58 #include <netinet/in.h>
59 /* #include <krb.h> */
60 #endif /* 0 */
61
62 #include <krb5.h>
63
64 #ifdef WINDOWS
65
66 #include <afs/stds.h>
67 #include <afs/auth.h>
68 #include <rx/rxkad.h>
69 #include <afs/dirpath.h>
70
71 #else /* !WINDOWS */
72 #include <afs/stds.h>
73 #include <afs/com_err.h>
74
75 #include <afs/param.h>
76 #ifdef AFS_SUN5_ENV
77 #include <sys/ioccom.h>
78 #endif
79 #include <afs/auth.h>
80 #include <afs/cellconfig.h>
81 #include <afs/vice.h>
82 #include <afs/venus.h>
83 #include <afs/ptserver.h>
84 #include <afs/dirpath.h>
85 #endif /* WINDOWS */
86
87 #include "aklog.h"
88 #include "linked_list.h"
89
90 #define AFSKEY "afs"
91 #define AFSINST ""
92
93 #ifndef AFS_TRY_FULL_PRINC
94 #define AFS_TRY_FULL_PRINC 1
95 #endif /* AFS_TRY_FULL_PRINC */
96
97 #define AKLOG_SUCCESS 0
98 #define AKLOG_USAGE 1
99 #define AKLOG_SOMETHINGSWRONG 2
100 #define AKLOG_AFS 3
101 #define AKLOG_KERBEROS 4
102 #define AKLOG_TOKEN 5
103 #define AKLOG_BADPATH 6
104 #define AKLOG_MISC 7
105
106 #ifndef NULL
107 #define NULL 0
108 #endif
109
110 #ifndef TRUE
111 #define TRUE 1
112 #endif
113
114 #ifndef FALSE
115 #define FALSE 0
116 #endif
117
118 #ifndef MAXSYMLINKS
119 /* RedHat 4.x doesn't seem to define this */
120 #define MAXSYMLINKS     5
121 #endif
122
123 #define DIR '/'                 /* Character that divides directories */
124 #define DIRSTRING "/"           /* String form of above */
125 #define VOLMARKER ':'           /* Character separating cellname from mntpt */
126 #define VOLMARKERSTRING ":"     /* String form of above */
127
128 typedef struct {
129     char cell[BUFSIZ];
130     char realm[REALM_SZ];
131 } cellinfo_t;
132
133 struct afsconf_cell ak_cellconfig; /* General information about the cell */
134 static char linkedcell[MAXCELLCHARS+1];
135 static char linkedcell2[MAXCELLCHARS+1];
136 static krb5_ccache  _krb425_ccache = NULL;
137
138 #ifdef WINDOWS
139
140 /* libafsconf.dll */
141 extern long cm_GetRootCellName();
142 extern long cm_SearchCellFile();
143
144 static long cm_SearchCellFile_CallBack();
145
146 #else /* !WINDOWS */
147
148 /*
149  * Why doesn't AFS provide these prototypes?
150  */
151
152 extern int pioctl(char *, afs_int32, struct ViceIoctl *, afs_int32);
153
154 /*
155  * Other prototypes
156  */
157
158 extern char *afs_realm_of_cell(krb5_context, struct afsconf_cell *);
159 static int isdir(char *, unsigned char *);
160 static krb5_error_code get_credv5(krb5_context context, char *, char *,
161                                   char *, krb5_creds **);
162 static int get_user_realm(krb5_context, char *);
163
164 #endif /* WINDOWS */
165
166 /*
167  * Provide a replacement for strerror if we don't have it
168  */
169
170 #ifndef HAVE_STRERROR
171 extern char *sys_errlist[];
172 #define strerror(x) sys_errlist[x]
173 #endif /* HAVE_STRERROR */
174
175 static char *progname = NULL;   /* Name of this program */
176 static int dflag = FALSE;       /* Give debugging information */
177 static int noauth = FALSE;      /* If true, don't try to get tokens */
178 static int zsubs = FALSE;       /* Are we keeping track of zephyr subs? */
179 static int hosts = FALSE;       /* Are we keeping track of hosts? */
180 static int noprdb = FALSE;      /* Skip resolving name to id? */
181 static int linked = FALSE;  /* try for both AFS nodes */
182 static int afssetpag = FALSE; /* setpag for AFS */
183 static int force = FALSE;       /* Bash identical tokens? */
184 static int do524 = FALSE;       /* Should we do 524 instead of rxkad2b? */
185 static linked_list zsublist;    /* List of zephyr subscriptions */
186 static linked_list hostlist;    /* List of host addresses */
187 static linked_list authedcells; /* List of cells already logged to */
188
189 /* ANL - CMU lifetime convert routine */
190 /* for K5.4.1 don't use this for now. Need to see if it is needed */
191 /* maybe needed in the krb524d module as well */
192 /* extern unsigned long krb_life_to_time(); */
193
194 static char *copy_cellinfo(cellinfo_t *cellinfo)
195 {
196     cellinfo_t *new_cellinfo;
197
198     if ((new_cellinfo = (cellinfo_t *)malloc(sizeof(cellinfo_t))))
199         memcpy(new_cellinfo, cellinfo, sizeof(cellinfo_t));
200     
201     return ((char *)new_cellinfo);
202 }
203
204
205 static char *copy_string(char *string)    
206 {
207     char *new_string;
208
209     if ((new_string = (char *)calloc(strlen(string) + 1, sizeof(char))))
210         (void) strcpy(new_string, string);
211
212     return (new_string);
213 }
214
215
216 static int get_cellconfig(char *cell, struct afsconf_cell *cellconfig, char *local_cell, char *linkedcell)
217 {
218     int status = AKLOG_SUCCESS;
219     struct afsconf_dir *configdir;
220     char *dirpath;
221
222     memset(local_cell, 0, sizeof(local_cell));
223     memset((char *)cellconfig, 0, sizeof(*cellconfig));
224
225 #ifndef WINDOWS
226
227     if (!(configdir = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH))) {
228         fprintf(stderr, 
229                 "%s: can't get afs configuration (afsconf_Open(%s))\n",
230                 progname, AFSDIR_CLIENT_ETC_DIRPATH);
231         exit(AKLOG_AFS);
232     }
233
234     if (afsconf_GetLocalCell(configdir, local_cell, MAXCELLCHARS)) {
235         fprintf(stderr, "%s: can't determine local cell.\n", progname);
236         exit(AKLOG_AFS);
237     }
238
239     if ((cell == NULL) || (cell[0] == 0))
240         cell = local_cell;
241
242         linkedcell[0] = '\0';
243     if (afsconf_GetCellInfo(configdir, cell, NULL, cellconfig)) {
244         fprintf(stderr, "%s: Can't get information about cell %s.\n",
245                 progname, cell);
246         status = AKLOG_AFS;
247     }
248         if (cellconfig->linkedCell) 
249                 strncpy(linkedcell,cellconfig->linkedCell,MAXCELLCHARS);
250
251     (void) afsconf_Close(configdir);
252
253 #else /* WINDOWS */
254     /*
255      * We'll try to mimic the GetCellInfo call here and fill in as much
256      * of the afsconf_cell structure as we can.
257      */
258     if (cm_GetRootCellName(local_cell)) {
259         fprintf(stderr, "%s: can't get local cellname\n", progname);
260         exit(AKLOG_AFS);
261     }
262
263     if ((cell == NULL) || (cell[0] == 0))
264         cell = local_cell;
265
266     strcpy(cellconfig->name, cell);
267
268     /* No way of figuring this out as far as I can tell */
269     linkedcell[0] = '\0';
270
271     /* Initialize server info */
272     cellconfig->numServers = 0;
273     cellconfig->hostName[0][0] = "\0";
274
275     /*
276      * Get servers of cell. cm_SearchCellFile_CallBack() gets call with
277      * each server.
278      */
279     status = (int) cm_SearchCellFile(cell, NULL, &cm_SearchCellFile_CallBack,
280                                      cellconfig /* rock */);
281
282     switch(status) {
283     case 0:
284         break;
285
286     case -1:
287         fprintf(stderr, "%s: GetWindowsDirectory() failed.\n", progname);
288         break;
289
290     case -2:
291         fprintf(stderr, "%s: Couldn't open afsdcells.ini for reading\n",
292                 progname);
293         break;
294
295     case -3:
296         fprintf(stderr, "%s: Couldn't find any servers for cell %s\n",
297                 progname, cell);
298         break;
299
300     case -4:
301         fprintf(stderr, "%s: Badly formatted line in afsdcells.ini (does not begin with a \">\" or contain \"#\"\n",
302                 progname);
303         break;
304
305     default:
306         fprintf(stderr, "%s cm_SearchCellFile returned unknown error %d\n",
307                 status);
308     }
309
310     if (status) {
311         exit(AKLOG_AFS);
312     }
313
314     status = AKLOG_SUCCESS;
315
316     
317 #endif /* WINDOWS */
318
319     return(status);
320 }
321
322
323 #ifdef WINDOWS
324 /*
325  * Callback function for cm_SearchCellFile() in get_cellconfig() above.
326  * This function gets called once for each server that is found for the cell.
327  */
328 static long
329 cm_SearchCellFile_CallBack(void *rock /* cellconfig */,
330                            struct sockaddr_in *addr, /* Not used */
331                            char *server)
332 {
333     struct afsconf_cell *cellconfig = rock;
334
335
336     /*
337      * Save server name and increment count of servers
338      */
339     strcpy(cellconfig->hostName[cellconfig->numServers++], server);
340     
341     return (long) 0;
342 }
343
344     
345 #endif /* WINDOWS */
346
347
348 /* 
349  * Log to a cell.  If the cell has already been logged to, return without
350  * doing anything.  Otherwise, log to it and mark that it has been logged
351  * to.
352  */
353 #ifdef __STDC__
354 static int auth_to_cell(krb5_context context, char *cell, char *realm)
355 #else
356 static int auth_to_cell(context, cell, realm)
357
358   krb5_context context;
359   char *cell;
360   char *realm;
361 #endif /* __STDC__ */
362 {
363     int status = AKLOG_SUCCESS;
364     char username[BUFSIZ];      /* To hold client username structure */
365     long viceId;                /* AFS uid of user */
366
367     char name[ANAME_SZ];        /* Name of afs key */
368     char primary_instance[INST_SZ];     /* Instance of afs key */
369     char secondary_instance[INST_SZ];   /* Backup instance to try */
370     int try_secondary = 0;              /* Flag to indicate if we try second */
371     char realm_of_user[REALM_SZ]; /* Kerberos realm of user */
372     char realm_of_cell[REALM_SZ]; /* Kerberos realm of cell */
373     char local_cell[MAXCELLCHARS+1];
374     char cell_to_use[MAXCELLCHARS+1]; /* Cell to authenticate to */
375     static char lastcell[MAXCELLCHARS+1] = { 0 };
376 #ifndef WINDOWS
377     static char confname[512] = { 0 };
378 #endif
379     krb5_creds *v5cred = NULL;
380     struct ktc_principal aserver;
381     struct ktc_principal aclient;
382     struct ktc_token atoken, btoken;
383
384 #ifdef ALLOW_REGISTER
385     afs_int32 id;
386 #endif /* ALLOW_REGISTER */
387
388     memset(name, 0, sizeof(name));
389     memset(primary_instance, 0, sizeof(primary_instance));
390     memset(secondary_instance, 0, sizeof(secondary_instance));
391     memset(realm_of_user, 0, sizeof(realm_of_user));
392     memset(realm_of_cell, 0, sizeof(realm_of_cell));
393
394 #ifndef WINDOWS
395     if (confname[0] == '\0') {
396         strncpy(confname, AFSDIR_CLIENT_ETC_DIRPATH, sizeof(confname));
397         confname[sizeof(confname) - 2] = '\0';
398     }
399 #endif /* WINDOWS */
400
401     /* NULL or empty cell returns information on local cell */
402     if ((status = get_cellconfig(cell, &ak_cellconfig,
403                          local_cell, linkedcell)))
404         return(status);
405
406     strncpy(cell_to_use, ak_cellconfig.name, MAXCELLCHARS);
407     cell_to_use[MAXCELLCHARS] = 0;
408
409     if (ll_string(&authedcells, ll_s_check, cell_to_use)) {
410         if (dflag) {
411             printf("Already authenticated to %s (or tried to)\n", 
412                    cell_to_use);
413         }
414         return(AKLOG_SUCCESS);
415     }
416
417     /* 
418      * Record that we have attempted to log to this cell.  We do this
419      * before we try rather than after so that we will not try
420      * and fail repeatedly for one cell.
421      */
422     (void)ll_string(&authedcells, ll_s_add, cell_to_use);
423
424     /* 
425      * Record this cell in the list of zephyr subscriptions.  We may
426      * want zephyr subscriptions even if authentication fails.
427      * If this is done after we attempt to get tokens, aklog -zsubs
428      * can return something different depending on whether or not we
429      * are in -noauth mode.
430      */
431     if (ll_string(&zsublist, ll_s_add, cell_to_use) == LL_FAILURE) {
432         fprintf(stderr, 
433                 "%s: failure adding cell %s to zephyr subscriptions list.\n",
434                 progname, cell_to_use);
435         exit(AKLOG_MISC);
436     }
437     if (ll_string(&zsublist, ll_s_add, local_cell) == LL_FAILURE) {
438         fprintf(stderr, 
439                 "%s: failure adding cell %s to zephyr subscriptions list.\n",
440                 progname, local_cell);
441         exit(AKLOG_MISC);
442     }
443
444     if (!noauth) {
445         if (dflag) {
446             printf("Authenticating to cell %s (server %s).\n",
447                    cell_to_use, ak_cellconfig.hostName[0]);
448         }
449
450         /*
451          * Find out which realm we're supposed to authenticate to.  If one
452          * is not included, use the kerberos realm found in the credentials
453          * cache.
454          */
455
456         if (realm && realm[0]) {
457             strcpy(realm_of_cell, realm);
458             if (dflag) {
459                 printf("We were told to authenticate to realm %s.\n", realm);
460             }
461         }
462         else {
463             char *realm = afs_realm_of_cell(context, &ak_cellconfig);
464
465             if (!realm) {
466                 fprintf(stderr, 
467                         "%s: Couldn't figure out realm for cell %s.\n",
468                         progname, cell_to_use);
469                 exit(AKLOG_MISC);
470             }
471
472             strcpy(realm_of_cell, realm);
473
474             if (dflag) {
475                 printf("We've deduced that we need to authenticate to"
476                        " realm %s.\n", realm_of_cell);
477             }
478         }
479
480         /* We use the afs.<cellname> convention here... 
481          *
482          * Doug Engert's original code had principals of the form:
483          *
484          * "afsx/cell@realm"
485          *
486          * in the KDC, so the name wouldn't conflict with DFS.  Since we're
487          * not using DFS, I changed it just to look for the following
488          * principals:
489          *
490          * afs/<cell>@<realm>
491          * afs@<realm>
492          *
493          * Because people are transitioning from afs@realm to afs/cell,
494          * we configure things so that if the first one isn't found, we
495          * try the second one.  You can select which one you prefer with
496          * a configure option.
497          */
498
499         strcpy(name, AFSKEY);
500
501         if (AFS_TRY_FULL_PRINC || strcasecmp(cell_to_use, realm_of_cell) != 0) {
502             strncpy(primary_instance, cell_to_use, sizeof(primary_instance));
503             primary_instance[sizeof(primary_instance)-1] = '\0';
504             if (strcasecmp(cell_to_use, realm_of_cell) == 0) {
505                 try_secondary = 1;
506                 secondary_instance[0] = '\0';
507             }
508         } else {
509             primary_instance[0] = '\0';
510             try_secondary = 1;
511             strncpy(secondary_instance, cell_to_use,
512                     sizeof(secondary_instance));
513             secondary_instance[sizeof(secondary_instance)-1] = '\0';
514         }
515
516         /* 
517          * Extract the session key from the ticket file and hand-frob an
518          * afs style authenticator.
519          */
520
521         /*
522          * Try to obtain AFS tickets.  Because there are two valid service
523          * names, we will try both, but trying the more specific first.
524          *
525          *      afs/<cell>@<realm> i.e. allow for single name with "."
526          *      afs@<realm>
527          */
528
529         if (dflag) {
530             printf("Getting tickets: %s/%s@%s\n", name,
531                    primary_instance, realm_of_cell);
532         }
533
534         status = get_credv5(context, name, primary_instance, realm_of_cell,
535                             &v5cred);
536
537         if (status == KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN) {
538             if (try_secondary) {
539                 if (dflag) {
540                     printf("Principal not found, trying alternate "
541                            "service name: %s/%s@%s\n", name,
542                             secondary_instance, realm_of_cell);
543                 }
544                 status = get_credv5(context, name, secondary_instance,
545                                     realm_of_cell, &v5cred);
546             }
547         }
548
549         if (status != KSUCCESS) {
550             if (dflag) {
551                 printf("Kerberos error code returned by get_cred: %d\n",
552                         status);
553             }
554             fprintf(stderr, "%s: Couldn't get %s AFS tickets:\n",
555                     progname, cell_to_use);
556                 com_err(progname, status, "while getting AFS tickets");
557             return(AKLOG_KERBEROS);
558         }
559
560         strncpy(aserver.name, AFSKEY, MAXKTCNAMELEN - 1);
561         strncpy(aserver.instance, AFSINST, MAXKTCNAMELEN - 1);
562         strncpy(aserver.cell, cell_to_use, MAXKTCREALMLEN - 1);
563
564         /*
565          * The default is to use rxkad2b, which means we put in a full
566          * V5 ticket.  If the user specifies -524, we talk to the
567          * 524 ticket converter.
568          */
569
570         if (! do524) {
571             char *p;
572             int len;
573
574             if (dflag)
575                 printf("Using Kerberos V5 ticket natively\n");
576
577             len = min(v5cred->client->data[0].length,
578                       v5cred->client->length > 1 ? MAXKTCNAMELEN - 2 :
579                       MAXKTCNAMELEN - 1);
580             strncpy(username, v5cred->client->data[0].data, len);
581             username[len] = '\0';
582
583             if (v5cred->client->length > 1) {
584                 strcat(username, ".");
585                 p = username + strlen(username);
586                 len = min(v5cred->client->data[1].length,
587                           MAXKTCNAMELEN - strlen(username) - 1);
588                 strncpy(p, v5cred->client->data[1].data, len);
589                 p[len] = '\0';
590             }
591
592             memset(&atoken, 0, sizeof(atoken));
593             atoken.kvno = RXKAD_TKT_TYPE_KERBEROS_V5;
594             atoken.startTime = v5cred->times.starttime;;
595             atoken.endTime = v5cred->times.endtime;
596             memcpy(&atoken.sessionKey, v5cred->keyblock.contents,
597                    v5cred->keyblock.length);
598             atoken.ticketLen = v5cred->ticket.length;
599             memcpy(atoken.ticket, v5cred->ticket.data, atoken.ticketLen);
600         } else {
601             CREDENTIALS cred;
602
603             if (dflag)
604                 printf("Using Kerberos 524 translator service\n");
605
606             status = krb5_524_convert_creds(context, v5cred, &cred);
607
608             if (status) {
609                 com_err(progname, status, "while converting tickets "
610                         "to Kerberos V4 format");
611                 return(AKLOG_KERBEROS);
612             }
613
614             strcpy (username, cred.pname);
615             if (cred.pinst[0]) {
616                 strcat (username, ".");
617                 strcat (username, cred.pinst);
618             }
619
620             atoken.kvno = cred.kvno;
621             atoken.startTime = cred.issue_date;
622             /*
623              * It seems silly to go through a bunch of contortions to
624              * extract the expiration time, when the v5 credentials already
625              * has the exact time!  Let's use that instead.
626              *
627              * Note that this isn't a security hole, as the expiration time
628              * is also contained in the encrypted token
629              */
630             atoken.endTime = v5cred->times.endtime;
631             memcpy(&atoken.sessionKey, cred.session, 8);
632             atoken.ticketLen = cred.ticket_st.length;
633             memcpy(atoken.ticket, cred.ticket_st.dat, atoken.ticketLen);
634         }
635         
636         if (!force &&
637             !ktc_GetToken(&aserver, &btoken, sizeof(btoken), &aclient) &&
638             atoken.kvno == btoken.kvno &&
639             atoken.ticketLen == btoken.ticketLen &&
640             !memcmp(&atoken.sessionKey, &btoken.sessionKey, sizeof(atoken.sessionKey)) &&
641             !memcmp(atoken.ticket, btoken.ticket, atoken.ticketLen)) {
642
643             if (dflag) {
644                 printf("Identical tokens already exist; skipping.\n");
645             }
646             return 0;
647         }
648
649 #ifdef FORCE_NOPRDB
650         noprdb = 1;
651 #endif
652
653 #ifndef WINDOWS
654         if (noprdb) {
655 #endif
656             if (dflag) {
657                 printf("Not resolving name %s to id (-noprdb set)\n",
658                         username);
659             }
660 #ifndef WINDOWS
661         }
662         else {
663             if ((status = get_user_realm(context, realm_of_user)) != KSUCCESS) {
664                 fprintf(stderr, "%s: Couldn't determine realm of user:)",
665                         progname);
666                 com_err(progname, status, " while getting realm");
667                 return(AKLOG_KERBEROS);
668             }
669             if (strcmp(realm_of_user, realm_of_cell)) {
670                 strcat(username, "@");
671                 strcat(username, realm_of_user);
672             }
673
674             if (dflag) {
675                 printf("About to resolve name %s to id in cell %s.\n", 
676                         username, aserver.cell);
677             }
678
679             strcpy(lastcell, aserver.cell);
680
681             if (!pr_Initialize (0, confname, aserver.cell, 0))
682                     status = pr_SNameToId (username, &viceId);
683             
684             if (dflag) {
685                 if (status) 
686                     printf("Error %d\n", status);
687                 else
688                     printf("Id %d\n", (int) viceId);
689             }
690             
691                 /*
692                  * This is a crock, but it is Transarc's crock, so
693                  * we have to play along in order to get the
694                  * functionality.  The way the afs id is stored is
695                  * as a string in the username field of the token.
696                  * Contrary to what you may think by looking at
697                  * the code for tokens, this hack (AFS ID %d) will
698                  * not work if you change %d to something else.
699                  */
700
701                 /*
702                  * This code is taken from cklog -- it lets people
703                  * automatically register with the ptserver in foreign cells
704                  */
705
706 #ifdef ALLOW_REGISTER
707         if (status == 0) {
708             if (viceId != ANONYMOUSID) {
709 #else /* ALLOW_REGISTER */
710             if ((status == 0) && (viceId != ANONYMOUSID))
711 #endif /* ALLOW_REGISTER */
712                 sprintf (username, "AFS ID %d", (int) viceId);
713 #ifdef ALLOW_REGISTER
714             } else if (strcmp(realm_of_user, realm_of_cell) != 0) {
715                 if (dflag) {
716                     printf("doing first-time registration of %s "
717                             "at %s\n", username, cell_to_use);
718                 }
719                 id = 0;
720                 strncpy(aclient.name, username, MAXKTCNAMELEN - 1);
721                 strcpy(aclient.instance, "");
722                 strncpy(aclient.cell, realm_of_user, MAXKTCREALMLEN - 1);
723                 if ((status = ktc_SetToken(&aserver, &atoken, &aclient, 0))) {
724                     fprintf(stderr, "%s: unable to obtain tokens for cell %s "
725                             "(status: %d).\n", progname, cell_to_use, status);
726                     status = AKLOG_TOKEN;
727                 }
728
729                 /*
730                  * In case you're wondering, we don't need to change the
731                  * filename here because we're still connecting to the
732                  * same cell -- we're just using a different authentication
733                  * level
734                  */
735
736                 if ((status = pr_Initialize(1L, confname, aserver.cell, 0))) {
737                     printf("Error %d\n", status);
738                 }
739
740                 if ((status = pr_CreateUser(username, &id))) {
741                     fprintf(stderr, "%s: %s so unable to create remote PTS "
742                             "user %s in cell %s (status: %d).\n", progname,
743                             error_message(status), username, cell_to_use,
744                             status);
745                 } else {
746                     printf("created cross-cell entry for %s at %s\n",
747                            username, cell_to_use);
748                     sprintf(username, "AFS ID %d", (int) id);
749                 }
750             }
751         }
752 #endif /* ALLOW_REGISTER */
753
754         }
755 #endif /* !WINDOWS */
756
757         if (dflag) {
758             fprintf(stdout, "Set username to %s\n", username);
759         }
760
761         /* Reset the "aclient" structure before we call ktc_SetToken.
762          * This structure was first set by the ktc_GetToken call when
763          * we were comparing whether identical tokens already existed.
764          */
765         strncpy(aclient.name, username, MAXKTCNAMELEN - 1);
766         strcpy(aclient.instance, "");
767         strncpy(aclient.cell, realm_of_user, MAXKTCREALMLEN - 1);
768
769         if (dflag) {
770             printf("Setting tokens. %s / %s @ %s \n",
771                     aclient.name, aclient.instance, aclient.cell );
772         }
773         /* on AIX 4.1.4 with AFS 3.4a+ if a write is not done before 
774          * this routine, it will not add the token. It is not clear what 
775          * is going on here! So we will do the following operation
776          */
777         write(2,"",0); /* dummy write */
778 #ifndef WINDOWS
779         if ((status = ktc_SetToken(&aserver, &atoken, &aclient, afssetpag))) {
780             fprintf(stderr, 
781                     "%s: unable to obtain tokens for cell %s (status: %d).\n",
782                     progname, cell_to_use, status);
783             status = AKLOG_TOKEN;
784         }
785 #else /* WINDOWS */
786         /* Note switched 2nd and 3rd args */
787         if ((status = ktc_SetToken(&aserver, &atoken, &aclient, afssetpag))) {
788             switch(status) {
789             case KTC_INVAL:
790                 fprintf(stderr, "%s: Bad ticket length", progname);
791                 break;
792             case KTC_PIOCTLFAIL:
793                 fprintf(stderr, "%s: Unknown error contacting AFS service",
794                         progname);
795                 break;
796             case KTC_NOCELL:
797                 fprintf(stderr, "%s: Cell name (%s) not recognized by AFS service",
798                         progname, realm_of_cell);
799                 break;
800             case KTC_NOCM:
801                 fprintf(stderr, "%s: AFS service is unavailable", progname);
802                 break;
803             default:
804                 fprintf(stderr, "%s: Undocumented error (%d) contacting AFS service", progname, status);
805                 break;  
806             }
807             status = AKLOG_TOKEN;           
808         }
809 #endif /* !WINDOWS */
810     }
811     else
812         if (dflag) {
813             printf("Noauth mode; not authenticating.\n");
814         }
815         
816     return(status);
817 }
818
819 #ifndef WINDOWS /* struct ViceIoctl missing */
820
821 #ifdef __STDC__
822 static int get_afs_mountpoint(char *file, char *mountpoint, int size)
823 #else
824 static int get_afs_mountpoint(file, mountpoint, size)
825   char *file;
826   char *mountpoint;
827   int size;
828 #endif /* __STDC__ */
829 {
830 #ifdef AFS_SUN_ENV
831         char V ='V'; /* AFS has problem on Sun with pioctl */
832 #endif
833     char our_file[MAXPATHLEN + 1];
834     char *parent_dir;
835     char *last_component;
836     struct ViceIoctl vio;
837     char cellname[BUFSIZ];
838
839     memset(our_file, 0, sizeof(our_file));
840     strcpy(our_file, file);
841
842     if ((last_component = strrchr(our_file, DIR))) {
843         *last_component++ = 0;
844         parent_dir = our_file;
845     }
846     else {
847         last_component = our_file;
848         parent_dir = ".";
849     }    
850     
851     memset(cellname, 0, sizeof(cellname));
852
853     vio.in = last_component;
854     vio.in_size = strlen(last_component)+1;
855     vio.out_size = size;
856     vio.out = mountpoint;
857
858     if (!pioctl(parent_dir, VIOC_AFS_STAT_MT_PT, &vio, 0)) {
859         if (strchr(mountpoint, VOLMARKER) == NULL) {
860             vio.in = file;
861             vio.in_size = strlen(file) + 1;
862             vio.out_size = sizeof(cellname);
863             vio.out = cellname;
864             
865             if (!pioctl(file, VIOC_FILE_CELL_NAME, &vio, 1)) {
866                 strcat(cellname, VOLMARKERSTRING);
867                 strcat(cellname, mountpoint + 1);
868                 memset(mountpoint + 1, 0, size - 1);
869                 strcpy(mountpoint + 1, cellname);
870             }
871         }
872         return(TRUE);
873     }
874     else
875         return(FALSE);
876 }
877
878 /* 
879  * This routine each time it is called returns the next directory 
880  * down a pathname.  It resolves all symbolic links.  The first time
881  * it is called, it should be called with the name of the path
882  * to be descended.  After that, it should be called with the arguemnt
883  * NULL.
884  */
885 #ifdef __STDC__
886 static char *next_path(char *origpath)
887 #else
888 static char *next_path(origpath)
889   char *origpath;
890 #endif /* __STDC__ */
891 {
892     static char path[MAXPATHLEN + 1];
893     static char pathtocheck[MAXPATHLEN + 1];
894
895     int link = FALSE;           /* Is this a symbolic link? */
896     char linkbuf[MAXPATHLEN + 1];
897     char tmpbuf[MAXPATHLEN + 1];
898
899     static char *last_comp;     /* last component of directory name */
900     static char *elast_comp;    /* End of last component */
901     char *t;
902     int len;
903     
904     static int symlinkcount = 0; /* We can't exceed MAXSYMLINKS */
905     
906     /* If we are given something for origpath, we are initializing only. */
907     if (origpath) {
908         memset(path, 0, sizeof(path));
909         memset(pathtocheck, 0, sizeof(pathtocheck));
910         strcpy(path, origpath);
911         last_comp = path;
912         symlinkcount = 0;
913         return(NULL);
914     }
915
916     /* We were not given origpath; find then next path to check */
917     
918     /* If we've gotten all the way through already, return NULL */
919     if (last_comp == NULL)
920         return(NULL);
921
922     do {
923         while (*last_comp == DIR)
924             strncat(pathtocheck, last_comp++, 1);
925         len = (elast_comp = strchr(last_comp, DIR)) 
926             ? elast_comp - last_comp : strlen(last_comp);
927         strncat(pathtocheck, last_comp, len);
928         memset(linkbuf, 0, sizeof(linkbuf));
929         if ((link = readlink(pathtocheck, linkbuf, 
930                                     sizeof(linkbuf))) > 0) {
931             if (++symlinkcount > MAXSYMLINKS) {
932                 fprintf(stderr, "%s: %s\n", progname, strerror(ELOOP));
933                 exit(AKLOG_BADPATH);
934             }
935             memset(tmpbuf, 0, sizeof(tmpbuf));
936             if (elast_comp)
937                 strcpy(tmpbuf, elast_comp);
938             if (linkbuf[0] == DIR) {
939                 /* 
940                  * If this is a symbolic link to an absolute path, 
941                  * replace what we have by the absolute path.
942                  */
943                 memset(path, 0, strlen(path));
944                 memcpy(path, linkbuf, sizeof(linkbuf));
945                 strcat(path, tmpbuf);
946                 last_comp = path;
947                 elast_comp = NULL;
948                 memset(pathtocheck, 0, sizeof(pathtocheck));
949             }
950             else {
951                 /* 
952                  * If this is a symbolic link to a relative path, 
953                  * replace only the last component with the link name.
954                  */
955                 strncpy(last_comp, linkbuf, strlen(linkbuf) + 1);
956                 strcat(path, tmpbuf);
957                 elast_comp = NULL;
958                 if ((t = strrchr(pathtocheck, DIR))) {
959                     t++;
960                     memset(t, 0, strlen(t));
961                 }
962                 else
963                     memset(pathtocheck, 0, sizeof(pathtocheck));
964             }
965         }
966         else
967             last_comp = elast_comp;
968     }
969     while(link);
970
971     return(pathtocheck);
972 }
973
974 #endif /* WINDOWS */
975
976 #if 0
977 /*****************************************/
978 int dee_gettokens()
979 {
980 #ifdef AFS_SUN_ENV
981         char V = 'V'; /* AFS has problem on SunOS */
982 #endif
983    struct ViceIoctl vio;
984    char outbuf[BUFSIZ];
985    long ind;
986    int fd;
987
988    memset(outbuf, 0, sizeof(outbuf));
989
990    vio.out_size = sizeof(outbuf);
991    vio.in_size = sizeof(ind);
992    vio.out = outbuf;
993    vio.in = &ind;
994
995    ind = 0;
996    fd = open("dee.tok",O_WRONLY);
997    while(!pioctl(0,VIOCGETTOK,&vio,0)) {
998         write(fd,&outbuf,sizeof(outbuf)); 
999        ind++;
1000    }
1001    close(fd);
1002 }
1003 /*****************************************/
1004 #endif
1005
1006 #ifndef WINDOWS /* struct ViceIoctl missing */
1007
1008 #ifdef __STDC__
1009 static void add_hosts(char *file)
1010 #else
1011 static void add_hosts(file)
1012   char *file;
1013 #endif /* __STDC__ */
1014 {
1015 #ifdef AFS_SUN_ENV
1016         char V = 'V'; /* AFS has problem on SunOS */
1017 #endif
1018     struct ViceIoctl vio;
1019     char outbuf[BUFSIZ];
1020     long *phosts;
1021     int i;
1022     struct hostent *hp;
1023     struct in_addr in;
1024     
1025     memset(outbuf, 0, sizeof(outbuf));
1026
1027     vio.out_size = sizeof(outbuf);
1028     vio.in_size = 0;
1029     vio.out = outbuf;
1030
1031     if (dflag) {
1032         printf("Getting list of hosts for %s\n", file);
1033     }
1034     /* Don't worry about errors. */
1035     if (!pioctl(file, VIOCWHEREIS, &vio, 1)) {
1036         phosts = (long *) outbuf;
1037
1038         /*
1039          * Lists hosts that we care about.  If ALLHOSTS is defined,
1040          * then all hosts that you ever may possible go through are
1041          * included in this list.  If not, then only hosts that are
1042          * the only ones appear.  That is, if a volume you must use
1043          * is replaced on only one server, that server is included.
1044          * If it is replicated on many servers, then none are included.
1045          * This is not perfect, but the result is that people don't
1046          * get subscribed to a lot of instances of FILSRV that they
1047          * probably won't need which reduces the instances of 
1048          * people getting messages that don't apply to them.
1049          */
1050 #ifndef ALLHOSTS
1051         if (phosts[1] != '\0')
1052             return;
1053 #endif
1054         for (i = 0; phosts[i]; i++) {
1055             if (hosts) {
1056                 in.s_addr = phosts[i];
1057                 if (dflag) {
1058                     printf("Got host %s\n", inet_ntoa(in));
1059                 }
1060                 ll_string(&hostlist, ll_s_add, (char *)inet_ntoa(in));
1061             }
1062             if (zsubs && (hp=gethostbyaddr((char *) &phosts[i],sizeof(long),AF_INET))) {
1063                 if (dflag) {
1064                     printf("Got host %s\n", hp->h_name);
1065                 }
1066                 ll_string(&zsublist, ll_s_add, hp->h_name);
1067             }
1068         }
1069     }
1070 }
1071
1072 #endif /* WINDOWS */
1073
1074 #ifndef WINDOWS /* next_path(), get_afs_mountpoint() */
1075
1076 /*
1077  * This routine descends through a path to a directory, logging to 
1078  * every cell it encounters along the way.
1079  */
1080 #ifdef __STDC__
1081 static int auth_to_path(krb5_context context, char *path)
1082 #else
1083 static int auth_to_path(context, path)
1084   krb5_context context;
1085   char *path;                   /* The path to which we try to authenticate */
1086 #endif /* __STDC__ */
1087 {
1088     int status = AKLOG_SUCCESS;
1089     int auth_to_cell_status = AKLOG_SUCCESS;
1090
1091     char *nextpath;
1092     char pathtocheck[MAXPATHLEN + 1];
1093     char mountpoint[MAXPATHLEN + 1];
1094
1095     char *cell;
1096     char *endofcell;
1097
1098     u_char isdirectory;
1099
1100     /* Initialize */
1101     if (path[0] == DIR)
1102         strcpy(pathtocheck, path);
1103     else {
1104         if (getwd(pathtocheck) == NULL) {
1105             fprintf(stderr, "Unable to find current working directory:\n");
1106             fprintf(stderr, "%s\n", pathtocheck);
1107             fprintf(stderr, "Try an absolute pathname.\n");
1108             exit(AKLOG_BADPATH);
1109         }
1110         else {
1111             strcat(pathtocheck, DIRSTRING);
1112             strcat(pathtocheck, path);
1113         }
1114     }
1115     next_path(pathtocheck);
1116
1117     /* Go on to the next level down the path */
1118     while ((nextpath = next_path(NULL))) {
1119         strcpy(pathtocheck, nextpath);
1120         if (dflag) {
1121             printf("Checking directory %s\n", pathtocheck);
1122         }
1123         /* 
1124          * If this is an afs mountpoint, determine what cell from 
1125          * the mountpoint name which is of the form 
1126          * #cellname:volumename or %cellname:volumename.
1127          */
1128         if (get_afs_mountpoint(pathtocheck, mountpoint, sizeof(mountpoint))) {
1129             /* skip over the '#' or '%' */
1130             cell = mountpoint + 1;
1131             /* Add this (cell:volumename) to the list of zsubs */
1132             if (zsubs)
1133                 ll_string(&zsublist, ll_s_add, cell);
1134             if (zsubs || hosts)
1135                 add_hosts(pathtocheck);
1136             if ((endofcell = strchr(mountpoint, VOLMARKER))) {
1137                 *endofcell = '\0';
1138                 if ((auth_to_cell_status = auth_to_cell(context, cell, NULL))) {
1139                     if (status == AKLOG_SUCCESS)
1140                         status = auth_to_cell_status;
1141                     else if (status != auth_to_cell_status)
1142                         status = AKLOG_SOMETHINGSWRONG;
1143                 }
1144             }
1145         }
1146         else {
1147             if (isdir(pathtocheck, &isdirectory) < 0) {
1148                 /*
1149                  * If we've logged and still can't stat, there's
1150                  * a problem... 
1151                  */
1152                 fprintf(stderr, "%s: stat(%s): %s\n", progname, 
1153                         pathtocheck, strerror(errno));
1154                 return(AKLOG_BADPATH);
1155             }
1156             else if (! isdirectory) {
1157                 /* Allow only directories */
1158                 fprintf(stderr, "%s: %s: %s\n", progname, pathtocheck,
1159                         strerror(ENOTDIR));
1160                 return(AKLOG_BADPATH);
1161             }
1162         }
1163     }
1164     
1165
1166     return(status);
1167 }
1168
1169 #endif /* WINDOWS */
1170
1171
1172 /* Print usage message and exit */
1173 #ifdef __STDC__
1174 static void usage(void)
1175 #else
1176 static void usage()
1177 #endif /* __STDC__ */
1178 {
1179     fprintf(stderr, "\nUsage: %s %s%s%s\n", progname,
1180             "[-d] [[-cell | -c] cell [-k krb_realm]] ",
1181             "[[-p | -path] pathname]\n",
1182             "    [-zsubs] [-hosts] [-noauth] [-noprdb] [-force] [-setpag] \n"
1183             "    [-linked] [-524]\n");
1184     fprintf(stderr, "    -d gives debugging information.\n");
1185     fprintf(stderr, "    krb_realm is the kerberos realm of a cell.\n");
1186     fprintf(stderr, "    pathname is the name of a directory to which ");
1187     fprintf(stderr, "you wish to authenticate.\n");
1188     fprintf(stderr, "    -zsubs gives zephyr subscription information.\n");
1189     fprintf(stderr, "    -hosts gives host address information.\n");
1190     fprintf(stderr, "    -noauth does not attempt to get tokens.\n");
1191     fprintf(stderr, "    -noprdb means don't try to determine AFS ID.\n");
1192     fprintf(stderr, "    -force means replace identical tickets. \n");
1193     fprintf(stderr, "    -linked means if AFS node is linked, try both. \n");
1194     fprintf(stderr, "    -setpag set the AFS process authentication group.\n");
1195     fprintf(stderr, "    -524 means use the 524 converter instead of V5 directly\n");
1196     fprintf(stderr, "    No commandline arguments means ");
1197     fprintf(stderr, "authenticate to the local cell.\n");
1198     fprintf(stderr, "\n");
1199     exit(AKLOG_USAGE);
1200 }
1201
1202 void aklog(int argc, char *argv[])
1203 {
1204         krb5_context context;
1205     int status = AKLOG_SUCCESS;
1206     int i;
1207     int somethingswrong = FALSE;
1208
1209     cellinfo_t cellinfo;
1210
1211     extern char *progname;      /* Name of this program */
1212
1213     extern int dflag;           /* Debug mode */
1214
1215     int cmode = FALSE;          /* Cellname mode */
1216     int pmode = FALSE;          /* Path name mode */
1217
1218     char realm[REALM_SZ];       /* Kerberos realm of afs server */
1219     char cell[BUFSIZ];          /* Cell to which we are authenticating */
1220     char path[MAXPATHLEN + 1];          /* Path length for path mode */
1221
1222     linked_list cells;          /* List of cells to log to */
1223     linked_list paths;          /* List of paths to log to */
1224     ll_node *cur_node;
1225
1226     memset(&cellinfo, 0, sizeof(cellinfo));
1227
1228     memset(realm, 0, sizeof(realm));
1229     memset(cell, 0, sizeof(cell));
1230     memset(path, 0, sizeof(path));
1231
1232     ll_init(&cells);
1233     ll_init(&paths);
1234
1235     ll_init(&zsublist);
1236     ll_init(&hostlist);
1237
1238     /* Store the program name here for error messages */
1239     if ((progname = strrchr(argv[0], DIR)))
1240         progname++;
1241     else
1242         progname = argv[0];
1243
1244     krb5_init_context(&context);
1245 #ifndef WINDOWS
1246         initialize_ktc_error_table ();
1247 #endif
1248
1249     /* Initialize list of cells to which we have authenticated */
1250     (void)ll_init(&authedcells);
1251
1252     /* Parse commandline arguments and make list of what to do. */
1253     for (i = 1; i < argc; i++) {
1254         if (strcmp(argv[i], "-d") == 0)
1255             dflag++;
1256         else if (strcmp(argv[i], "-noauth") == 0) 
1257             noauth++;
1258         else if (strcmp(argv[i], "-zsubs") == 0)
1259             zsubs++;
1260         else if (strcmp(argv[i], "-hosts") == 0)
1261             hosts++;
1262         else if (strcmp(argv[i], "-noprdb") == 0)
1263             noprdb++;
1264         else if (strcmp(argv[i], "-linked") == 0)
1265                 linked++;
1266         else if (strcmp(argv[i], "-force") == 0)
1267             force++;
1268         else if (strcmp(argv[i], "-524") == 0)
1269             do524++;
1270     else if (strcmp(argv[i], "-setpag") == 0)
1271             afssetpag++;
1272         else if (((strcmp(argv[i], "-cell") == 0) ||
1273                   (strcmp(argv[i], "-c") == 0)) && !pmode)
1274             if (++i < argc) {
1275                 cmode++;
1276                 strcpy(cell, argv[i]);
1277             }
1278             else
1279                 usage();
1280         else if (((strcmp(argv[i], "-path") == 0) ||
1281                   (strcmp(argv[i], "-p") == 0)) && !cmode)
1282 #ifndef WINDOWS
1283             if (++i < argc) {
1284                 pmode++;
1285                 strcpy(path, argv[i]);
1286             }
1287             else
1288                 usage();
1289 #else /* WINDOWS */
1290         {
1291             fprintf(stderr, "%s: path mode not supported.\n", progname);
1292             exit(AKLOG_MISC);
1293         }
1294 #endif /* WINDOWS */
1295             
1296         else if (argv[i][0] == '-')
1297             usage();
1298         else if (!pmode && !cmode) {
1299             if (strchr(argv[i], DIR) || (strcmp(argv[i], ".") == 0) ||
1300                 (strcmp(argv[i], "..") == 0)) {
1301 #ifndef WINDOWS
1302                 pmode++;
1303                 strcpy(path, argv[i]);
1304 #else /* WINDOWS */
1305                 fprintf(stderr, "%s: path mode not supported.\n", progname);
1306                 exit(AKLOG_MISC);
1307 #endif /* WINDOWS */
1308             }
1309             else { 
1310                 cmode++;
1311                 strcpy(cell, argv[i]);
1312             }
1313         }
1314         else
1315             usage();
1316
1317         if (cmode) {
1318             if (((i + 1) < argc) && (strcmp(argv[i + 1], "-k") == 0)) {
1319                 i+=2;
1320                 if (i < argc)
1321                     strcpy(realm, argv[i]);
1322                 else
1323                     usage();
1324             }
1325             /* Add this cell to list of cells */
1326             strcpy(cellinfo.cell, cell);
1327             strcpy(cellinfo.realm, realm);
1328             if ((cur_node = ll_add_node(&cells, ll_tail))) {
1329                 char *new_cellinfo;
1330                 if ((new_cellinfo = copy_cellinfo(&cellinfo)))
1331                     ll_add_data(cur_node, new_cellinfo);
1332                 else {
1333                     fprintf(stderr, 
1334                             "%s: failure copying cellinfo.\n", progname);
1335                     exit(AKLOG_MISC);
1336                 }
1337             }
1338             else {
1339                 fprintf(stderr, "%s: failure adding cell to cells list.\n",
1340                         progname);
1341                 exit(AKLOG_MISC);
1342             }
1343             memset(&cellinfo, 0, sizeof(cellinfo));
1344             cmode = FALSE;
1345             memset(cell, 0, sizeof(cell));
1346             memset(realm, 0, sizeof(realm));
1347         }
1348 #ifndef WINDOWS
1349         else if (pmode) {
1350             /* Add this path to list of paths */
1351             if ((cur_node = ll_add_node(&paths, ll_tail))) {
1352                 char *new_path; 
1353                 if ((new_path = copy_string(path)))
1354                     ll_add_data(cur_node, new_path);
1355                 else {
1356                     fprintf(stderr, "%s: failure copying path name.\n",
1357                             progname);
1358                     exit(AKLOG_MISC);
1359                 }
1360             }
1361             else {
1362                 fprintf(stderr, "%s: failure adding path to paths list.\n",
1363                         progname);
1364                 exit(AKLOG_MISC);
1365             }
1366             pmode = FALSE;
1367             memset(path, 0, sizeof(path));
1368         }
1369 #endif /* WINDOWS */
1370     }
1371
1372     /*
1373      * The code that _used_ to be here called setpag().  When you think
1374      * about this, doing this makes no sense!  setpag() allocates a PAG
1375      * only for the current process, so the token installed would have
1376      * not be usable in the parent!  Since ktc_SetToken() now takes a
1377      * 4th argument to control whether or not we're going to allocate
1378      * a PAG (and since when you do it _that_ way, it modifies the cred
1379      * structure of your parent)), why don't we use that instead?
1380      */
1381
1382 #if 0
1383     if (afssetpag) {
1384            status = setpag();
1385            if (dflag) { 
1386              int i,j;
1387                  int gidsetlen = 50;
1388          int gidset[50];
1389
1390                  printf("setpag %d\n",status);
1391              j = getgroups(gidsetlen,gidset);
1392          printf("Groups(%d):",j);
1393          for (i = 0; i<j; i++) {
1394            printf("%d",gidset[i]);
1395            if((i+1)<j) printf(",");
1396          }
1397          printf("\n");
1398            }
1399         }
1400 #endif
1401     /* If nothing was given, log to the local cell. */
1402     if ((cells.nelements + paths.nelements) == 0) {
1403                 struct passwd *pwd;
1404
1405                 status = auth_to_cell(context, NULL, NULL);
1406         
1407                 /* If this cell is linked to a DCE cell, and user 
1408                  * requested -linked, get tokens for both 
1409                  * This is very usefull when the AFS cell is linked to a DFS 
1410                  * cell and this system does not also have DFS. 
1411                  */
1412
1413                 if (!status && linked && linkedcell[0]) {
1414                                 strncpy(linkedcell2,linkedcell,MAXCELLCHARS);
1415                             if (dflag) {
1416                                 printf("Linked cell: %s\n", linkedcell);
1417                             }
1418                                 status = auth_to_cell(context, linkedcell2, NULL);
1419                 }
1420
1421 #ifndef WINDOWS
1422                 /*
1423                  * Local hack - if the person has a file in their home
1424                  * directory called ".xlog", read that for a list of
1425                  * extra cells to authenticate to
1426                  */
1427
1428                 if ((pwd = getpwuid(getuid())) != NULL) {
1429                     struct stat sbuf;
1430                     FILE *f;
1431                     char fcell[100], xlog_path[512];
1432
1433                     strcpy(xlog_path, pwd->pw_dir);
1434                     strcat(xlog_path, "/.xlog");
1435
1436                     if ((stat(xlog_path, &sbuf) == 0) &&
1437                         ((f = fopen(xlog_path, "r")) != NULL)) {
1438
1439                         if (dflag) {
1440                             printf("Reading %s for cells to "
1441                                     "authenticate to.\n", xlog_path);
1442                         }
1443
1444                         while (fgets(fcell, 100, f) != NULL) {
1445                             int auth_status;
1446
1447                             fcell[strlen(fcell) - 1] = '\0';
1448
1449                             if (dflag) {
1450                                 printf("Found cell %s in %s.\n",
1451                                         fcell, xlog_path);
1452                             }
1453
1454                             auth_status = auth_to_cell(context, fcell, NULL);
1455                             if (status == AKLOG_SUCCESS)
1456                                 status = auth_status;
1457                             else
1458                                 status = AKLOG_SOMETHINGSWRONG;
1459                         }
1460                     }
1461                 }
1462 #endif /* WINDOWS */
1463         }
1464     else {
1465         /* Log to all cells in the cells list first */
1466         for (cur_node = cells.first; cur_node; cur_node = cur_node->next) {
1467             memcpy((char *)&cellinfo, cur_node->data, sizeof(cellinfo));
1468             if ((status = auth_to_cell(context, cellinfo.cell, cellinfo.realm)))
1469                 somethingswrong++;
1470                 else {
1471                         if (linked && linkedcell[0]) {
1472                                 strncpy(linkedcell2,linkedcell,MAXCELLCHARS);
1473                 if (dflag) {
1474                     printf("Linked cell: %s\n",
1475                         linkedcell);
1476                 }
1477                                 if ((status = auth_to_cell(context,linkedcell2,
1478                                                          cellinfo.realm)))
1479                                 somethingswrong++;
1480                         }
1481                 }
1482         }
1483         
1484 #ifndef WINDOWS
1485         /* Then, log to all paths in the paths list */
1486         for (cur_node = paths.first; cur_node; cur_node = cur_node->next) {
1487             if ((status = auth_to_path(context, cur_node->data)))
1488                 somethingswrong++;
1489         }
1490 #endif /* WINDOWS */
1491         
1492         /* 
1493          * If only one thing was logged to, we'll return the status 
1494          * of the single call.  Otherwise, we'll return a generic
1495          * something failed status.
1496          */
1497         if (somethingswrong && ((cells.nelements + paths.nelements) > 1))
1498             status = AKLOG_SOMETHINGSWRONG;
1499     }
1500
1501     /* If we are keeping track of zephyr subscriptions, print them. */
1502     if (zsubs) 
1503         for (cur_node = zsublist.first; cur_node; cur_node = cur_node->next) {
1504             printf("zsub: %s\n", cur_node->data);
1505         }
1506
1507     /* If we are keeping track of host information, print it. */
1508     if (hosts)
1509         for (cur_node = hostlist.first; cur_node; cur_node = cur_node->next) {
1510             printf("host: %s\n", cur_node->data);
1511         }
1512
1513     exit(status);
1514 }
1515
1516 #ifndef HAVE_ADD_TO_ERROR_TABLE
1517 #include <afs/error_table.h>
1518
1519 void add_error_table (const struct error_table *);
1520
1521 void
1522 add_to_error_table(struct et_list *new_table)
1523 {
1524         add_error_table(new_table->table);
1525 }
1526 #endif /* HAVE_ADD_TO_ERROR_TABLE */
1527
1528 static int isdir(char *path, unsigned char *val)
1529 {
1530     struct stat statbuf;
1531
1532     if (lstat(path, &statbuf) < 0)
1533         return (-1);
1534     else {
1535         if ((statbuf.st_mode & S_IFMT) == S_IFDIR) 
1536             *val = TRUE;
1537         else
1538             *val = FALSE;
1539         return (0);
1540     }  
1541 }
1542
1543 static krb5_error_code get_credv5(krb5_context context, 
1544                         char *name, char *inst, char *realm,
1545                         krb5_creds **creds)
1546 {
1547     krb5_creds increds;
1548     krb5_error_code r;
1549     static krb5_principal client_principal = 0;
1550
1551     memset((char *)&increds, 0, sizeof(increds));
1552 /* ANL - instance may be ptr to a null string. Pass null then */
1553     if ((r = krb5_build_principal(context, &increds.server,
1554                      strlen(realm), realm,
1555                      name,
1556            (inst && strlen(inst)) ? inst : (void *) NULL,
1557                      (void *) NULL))) {
1558         return r;
1559     }
1560
1561     if (!_krb425_ccache) {
1562         r = krb5_cc_default(context, &_krb425_ccache);
1563         if (r)
1564             return r;
1565     }
1566     if (!client_principal) {
1567         r = krb5_cc_get_principal(context, _krb425_ccache, &client_principal);
1568         if (r)
1569             return r;
1570     }
1571
1572     increds.client = client_principal;
1573     increds.times.endtime = 0;
1574         /* Ask for DES since that is what V4 understands */
1575     increds.keyblock.enctype = ENCTYPE_DES_CBC_CRC;
1576
1577     r = krb5_get_credentials(context, 0, _krb425_ccache, &increds, creds);
1578
1579     return r;
1580 }
1581
1582
1583 static int get_user_realm(krb5_context context, char *realm)
1584 {
1585     static krb5_principal client_principal = 0;
1586     int i;
1587
1588     if (!_krb425_ccache)
1589         krb5_cc_default(context, &_krb425_ccache);
1590     if (!client_principal)
1591         krb5_cc_get_principal(context, _krb425_ccache, &client_principal);
1592
1593     i = krb5_princ_realm(context, client_principal)->length;
1594     if (i > REALM_SZ-1) i = REALM_SZ-1;
1595     strncpy(realm,krb5_princ_realm(context, client_principal)->data,i);
1596     realm[i] = 0;
1597     return(KSUCCESS);
1598 }