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