src/WINNT/aklog/aklog.c

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