src/uss/uss_procs.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  *      Implementation of basic procedures for the AFS user account
  12  *      facility.
  13  */
  14
  15 /*
  16  * --------------------- Required definitions ---------------------
  17  */
  18 #include <afsconfig.h>
  19 #include <afs/param.h>
  20
  21 #include <roken.h>
  22
  23 #include <afs/kautils.h> /*MAXKTCREALMLEN*/
  24
  25 #include "uss_procs.h"          /*Module interface */
  26 #include "uss_common.h"         /*Common defs & operations */
  27 #include "uss_acl.h"            /*ACL-related operations */
  28
  29 #undef USS_PROCS_DB
  30 #undef USS_PROCS_DB_INSTANCE
  31 #undef USS_PROCS_DB_BUILDDIR
  32 #define uss_procs_MAX_SIZE      2048
  33 char temp[1000];
  34 extern int line;
  35
  36 static int Copy(char *a_from, char *a_to, int a_mode);
  37 static int Echo(char *a_s, char *a_f, int a_mode);
  38
  39 /*-----------------------------------------------------------------------
  40  * EXPORTED uss_procs_BuildDir
  41  *
  42  * Environment:
  43  *      Called from the code generated by the uss grammar.
  44  *
  45  * Side Effects:
  46  *      As advertised.
  47  *------------------------------------------------------------------------*/
  48
  49 afs_int32
  50 uss_procs_BuildDir(char *a_path, char *a_mode, char *a_owner, char *a_access)
  51 {                               /*uss_procs_BuildDir */
  52
  53     int m, o;
  54     char buf[1000];
  55     struct uss_subdir *new_dir;
  56     struct stat stbuf;
  57
  58     /*
  59      * Don't do anything if there's already a problem.
  60      */
  61     if (uss_syntax_err)
  62         return (1);
  63
  64     if (uss_verbose)
  65         printf("Building directory '%s'; owner: '%s', ACL: '%s'\n", a_path,
  66                a_owner, a_access);
  67
  68     /*
  69      * If we've not been given permission to overwrite things, make sure
  70      * the target doesn't exist before doing anything.
  71      */
  72     if (!uss_OverwriteThisOne) {
  73         strcpy(temp, a_path);
  74         if (!stat(temp, &stbuf)) {
  75             if (uss_verbose)
  76                 printf("\t[Directory exists, NOT overwriting it]\n");
  77             return (0);
  78         }
  79     }
  80
  81     sscanf(a_mode, "%o", &m);
  82     o = uss_procs_GetOwner(a_owner);
  83 #ifdef USS_PROCS_DB_BUILDDIR
  84     printf("DEBUGGING: Owner '%s' is uid %d\n", a_owner, o);
  85 #endif /* USS_PROCS_DB_BUILDDIR */
  86
  87     if (!uss_DryRun) {
  88         if (mkdir(a_path, m)) {
  89             /*
  90              * Can't make the directory.  Complain if the directory doesn't
  91              * already exist.
  92              */
  93             if (errno != EEXIST) {
  94                 uss_procs_PrintErr(line,
  95                                    "Failed to create directory '%s': %s\n",
  96                                    a_path, strerror(errno));
  97                 return (1);
  98             }                   /*Directory didn't exist */
  99         }                       /*Create the directory */
 100     } /*Not a dry run */
 101     else {
 102         if (uss_OverwriteThisOne)
 103             fprintf(stderr, "\t[Dry run: mkdir %s, mode %o]\n", a_path, m);
 104     }                           /*Dry run */
 105
 106     if (!uss_DryRun) {
 107         if (chmod(a_path, m)) {
 108             uss_procs_PrintErr(line,
 109                                "Can't chmod() directory '%s' to be '%s' : %s\n",
 110                                a_path, a_mode, strerror(errno));
 111             return (1);
 112         }                       /* chmod the directory */
 113         if (chown(a_path, o, -1)) {
 114             uss_procs_PrintErr(line,
 115                                "Can't chown() directory '%s' to be owned by '%s' (uid %d): %s\n",
 116                                a_path, a_owner, o, strerror(errno));
 117             return (1);
 118         }                       /*Couldn't chown */
 119     } /*Not a dry run */
 120     else {
 121         fprintf(stderr,
 122                 "\t[Dry run: chown() directory '%s' to be owned by user]\n",
 123                 a_path);
 124     }                           /*Dry run */
 125
 126     /*
 127      * Set the ACL for this new directory so that the uss_AccountCreator
 128      * is the only party that has rights.  This will be corrected as the
 129      * final action performed on the account.
 130      */
 131     sprintf(buf, "%s %s all", a_path, uss_AccountCreator);
 132     if (!uss_DryRun) {
 133         if (uss_verbose)
 134             fprintf(stderr, "Setting ACL: '%s'\n", buf);
 135         if (uss_acl_SetAccess(buf, 1, 0))
 136             return (1);
 137     } /*Not a dry run */
 138     else {
 139         fprintf(stderr, "\t[Dry run: uss_acl_SetAccess(%s) on '%s']\n", buf,
 140                 a_path);
 141     }                           /*Dry run */
 142
 143     /*
 144      * Use our linked list to remember this directory's true ACL setting so
 145      * we may set it correctly at the tail end of the account creation.
 146      */
 147     new_dir = malloc(sizeof(struct uss_subdir));
 148     new_dir->previous = uss_currentDir;
 149     new_dir->path = strdup(a_path);
 150     new_dir->finalACL = strdup(a_access);
 151     uss_currentDir = new_dir;
 152
 153     /*
 154      * Return the happy news.
 155      */
 156     return (0);
 157
 158 }                               /*uss_procs_BuildDir */
 159
 160
 161 /*-----------------------------------------------------------------------
 162  * EXPORTED uss_procs_CpFile
 163  *
 164  * Environment:
 165  *      Called from the code generated by the uss grammar.
 166  *
 167  * Side Effects:
 168  *      As advertised.
 169  *------------------------------------------------------------------------*/
 170
 171 afs_int32
 172 uss_procs_CpFile(char *a_path, char *a_mode, char *a_owner, char *a_proto)
 173 {                               /*uss_procs_CpFile */
 174
 175     int m, o;
 176     struct stat stbuf;
 177     char *cp;
 178
 179     /*
 180      * Don't do anything if something has already gone wrong.
 181      */
 182     if (uss_syntax_err)
 183         return (1);
 184
 185     if (uss_verbose)
 186         printf("Installing '%s'\n", a_path);
 187
 188     /*
 189      * If we've not been given permission to overwrite things, make sure
 190      * the target doesn't exist before doing anything.
 191      */
 192     if (!uss_OverwriteThisOne) {
 193         strcpy(temp, a_path);
 194         if (!stat(temp, &stbuf)) {
 195             if (uss_verbose)
 196                 printf("\t[Entry exists, NOT overwriting it]\n");
 197             return (0);
 198         }
 199     }
 200
 201     sscanf(a_mode, "%o", &m);
 202     o = uss_procs_GetOwner(a_owner);
 203
 204     strcpy(temp, a_proto);
 205
 206     if (stat(temp, &stbuf)) {
 207         uss_procs_PrintErr(line, "Failed to stat '%s': %s\n", a_proto,
 208                            strerror(errno));
 209         return (1);
 210     }
 211
 212     if (stbuf.st_mode & S_IFDIR) {
 213         if ((cp = strrchr(a_path, '/')) == NULL) {
 214             strcat(a_proto, "/");
 215             strcat(a_proto, a_path);
 216         } else {
 217             /*
 218              * Append the last part (file name).
 219              */
 220             strcat(a_proto, cp);
 221         }
 222     }
 223     /*Target is a directory */
 224     if (!uss_DryRun) {
 225         if (Copy(a_proto, a_path, m)) {
 226             uss_procs_PrintErr(line, "Failed to copy '%s' to '%s'\n", a_proto,
 227                                a_path);
 228             return (1);
 229         }                       /*Copy failed */
 230     } /*Not a dry run */
 231     else {
 232         fprintf(stderr, "\t[Dry run: Copying '%s' to '%s', mode %o]\n",
 233                 a_proto, a_path, m);
 234     }
 235
 236     if (!uss_DryRun) {
 237         if (chown(a_path, o, -1)) {
 238             uss_procs_PrintErr(line,
 239                                "Can't chown() file '%s' to be owned by '%s' (uid %d): %s\n",
 240                                a_path, a_owner, o, strerror(errno));
 241             return (1);
 242         }                       /*chown failed */
 243     } /*Not a dry run */
 244     else {
 245         fprintf(stderr,
 246                 "\t[Dry run: chown() file '%s' to be owned by user]\n",
 247                 a_path);
 248     }                           /*Dry run */
 249
 250     /*
 251      * Return the happy news.
 252      */
 253     return (0);
 254
 255 }                               /*uss_procs_CpFile */
 256
 257
 258 /*-----------------------------------------------------------------------
 259  * EXPORTED uss_procs_EchoToFile
 260  *
 261  * Environment:
 262  *      Called from the code generated by the uss grammar.
 263  *
 264  * Side Effects:
 265  *      As advertised.
 266  *------------------------------------------------------------------------*/
 267
 268 afs_int32
 269 uss_procs_EchoToFile(char *a_path, char *a_mode, char *a_owner,
 270                      char *a_content)
 271 {                               /*uss_procs_EchoToFile */
 272
 273     int m, o;
 274     struct stat stbuf;
 275
 276     /*
 277      * Don't do anything if something has already gone wrong.
 278      */
 279     if (uss_syntax_err)
 280         return (1);
 281
 282     if (uss_verbose)
 283         printf("Echoing to '%s'\n", a_path);
 284
 285     /*
 286      * If we've not been given permission to overwrite things, make sure
 287      * the target doesn't exist before doing anything.
 288      */
 289     if (!uss_OverwriteThisOne) {
 290         strcpy(temp, a_path);
 291         if (!stat(temp, &stbuf)) {
 292             if (uss_verbose)
 293                 printf("\t[Entry exists, NOT overwriting it]\n");
 294             return (0);
 295         }
 296     }
 297
 298     sscanf(a_mode, "%o", &m);
 299     o = uss_procs_GetOwner(a_owner);
 300
 301     if (!uss_DryRun) {
 302         if (Echo(a_content, a_path, m)) {
 303             uss_procs_PrintErr(line,
 304                                "Failed to echo string '%s' to file '%s'\n",
 305                                a_content, a_path);
 306             return (1);
 307         }
 308     } /*Not a dry run */
 309     else {
 310         fprintf(stderr, "\t[Dry run: Echoing '%s' into file '%s']\n",
 311                 a_content, a_path);
 312     }                           /*Dry run */
 313
 314     if (!uss_DryRun) {
 315         if (chown(a_path, o, -1)) {
 316             uss_procs_PrintErr(line,
 317                                "Can't chown() file '%s' to be owned by '%s' (uid %d): %s\n",
 318                                a_path, a_owner, o, strerror(errno));
 319             return (1);
 320         }
 321     } /*Not a dry run */
 322     else {
 323         fprintf(stderr,
 324                 "\t[Dry run: chown() file '%s' to be owned by user]\n",
 325                 a_path);
 326     }                           /*Dry run */
 327
 328     /*
 329      * Return the happy news.
 330      */
 331     return (0);
 332
 333 }                               /*uss_procs_EchoToFile */
 334
 335
 336 /*-----------------------------------------------------------------------
 337  * EXPORTED uss_procs_Exec
 338  *
 339  * Environment:
 340  *      Called from the code generated by the uss grammar, as well as
 341  *      from uss.c itself.
 342  *
 343  * Side Effects:
 344  *      As advertised.
 345  *------------------------------------------------------------------------*/
 346
 347 afs_int32
 348 uss_procs_Exec(char *a_command)
 349 {                               /*uss_procs_Exec */
 350
 351     if (uss_verbose)
 352         printf("Running '%s'\n", a_command);
 353
 354     if (!uss_DryRun) {
 355         if (system(a_command)) {
 356             uss_procs_PrintErr(line, "Failed to run the '%s' command: %s\n",
 357                                a_command, strerror(errno));
 358             return (1);
 359         }
 360     } /*Not a dry run */
 361     else {
 362         fprintf(stderr, "\t[Dry run: executing '%s']\n", a_command);
 363     }                           /*Dry run */
 364
 365     /*
 366      * Return the happy news.
 367      */
 368     return (0);
 369
 370 }                               /*uss_procs_Exec */
 371
 372
 373 /*-----------------------------------------------------------------------
 374  * EXPORTED uss_procs_SetLink
 375  *
 376  * Environment:
 377  *      Called from the code generated by the uss grammar.
 378  *
 379  * Side Effects:
 380  *      As advertised.
 381  *------------------------------------------------------------------------*/
 382
 383 afs_int32
 384 uss_procs_SetLink(char *a_path1, char *a_path2, char a_type)
 385 {                               /*uss_procs_SetLink */
 386
 387     struct stat stbuf;
 388
 389     if (uss_verbose)
 390         printf("Setting link '%s' to '%s'\n", a_path1, a_path2);
 391
 392     /*
 393      * If we've not been given permission to overwrite things, make sure
 394      * the target doesn't exist before doing anything.
 395      */
 396     if (!uss_OverwriteThisOne) {
 397         strcpy(temp, a_path2);
 398         if (!stat(temp, &stbuf)) {
 399             if (uss_verbose)
 400                 printf("\t[Entry exists, NOT overwriting it]\n");
 401             return (0);
 402         }
 403     }
 404
 405     if (a_type == 's') {
 406         /*
 407          * Symbolic link.
 408          */
 409         if (!uss_DryRun) {
 410             if (symlink(a_path1, a_path2)) {
 411                 uss_procs_PrintErr(line,
 412                                    "Failed to make symlink '%s' to '%s': %s\n",
 413                                    a_path1, a_path2, strerror(errno));
 414                 return (1);
 415             }
 416         } /*Dry run */
 417         else {
 418             fprintf(stderr, "\t[Dry run: Making symlink '%s' to '%s']\n",
 419                     a_path1, a_path2);
 420         }                       /*Not a dry run */
 421     } /*Symbolic link */
 422     else {
 423         /*
 424          * Hard link.
 425          */
 426         if (!uss_DryRun) {
 427             if (link(a_path1, a_path2)) {
 428                 uss_procs_PrintErr(line,
 429                                    "Failed to make hard link '%s' to '%s': %s\n",
 430                                    a_path1, a_path2, strerror(errno));
 431                 return (1);
 432             }
 433         } /*Dry run */
 434         else {
 435             fprintf(stderr, "\t[Dry run: Making hard link '%s' to '%s']\n",
 436                     a_path1, a_path2);
 437         }                       /*Not a dry run */
 438     }                           /*Hard link */
 439
 440     /*
 441      * Return the happy news.
 442      */
 443     return (0);
 444
 445 }                               /*uss_procs_SetLink */
 446
 447
 448 /*-----------------------------------------------------------------------
 449  * EXPORTED uss_procs_GetOwner
 450  *
 451  * Environment:
 452  *      Nothing interesting.
 453  *
 454  * Side Effects:
 455  *      As advertised.
 456  *------------------------------------------------------------------------*/
 457
 458 int
 459 uss_procs_GetOwner(char *a_ownerStr)
 460 {                               /*uss_procs_GetOwner */
 461
 462     struct passwd *pw;          /*Ptr to password file entry */
 463     int ownerID;                /*Numerical owner */
 464
 465     ownerID = atoi(a_ownerStr);
 466     if ((ownerID == 0) && (a_ownerStr[0] != '0')) {
 467         /*
 468          * The owner is not in numerical format
 469          */
 470         if ((pw = getpwnam(a_ownerStr)) == NULL) {
 471             uss_procs_PrintErr(line, "Owner '%s' is an unknown user\n",
 472                                a_ownerStr);
 473             return (1);
 474         }
 475         return (pw->pw_uid);
 476     } else
 477         return (ownerID);
 478
 479 }                               /*uss_procs_GetOwner */
 480
 481 /*-----------------------------------------------------------------------
 482  * static Copy
 483  *
 484  * Description:
 485  *       Copies the "from" file to the "to" file and sets the mode.
 486  *
 487  * Arguments:
 488  *      a_from : File to copy from.
 489  *      a_to   : File to copy to.
 490  *      a_mode : New Unix mode to set.
 491  *
 492  * Returns:
 493  *      0 if everything went well,
 494  *      if there was a problem.
 495  *
 496  * Environment:
 497  *      Nothing interesting.
 498  *
 499  * Side Effects:
 500  *      As advertised.
 501  *------------------------------------------------------------------------*/
 502
 503 static int
 504 Copy(char *a_from, char *a_to, int a_mode)
 505 {                               /*Copy */
 506
 507     int fd1, fd2;
 508     char buf[BUFSIZ];
 509     int rcnt, wcnt = -1, rc;
 510
 511     umask(0);
 512     fd1 = open(a_to, O_EXCL | O_CREAT | O_WRONLY, a_mode);
 513     if (fd1 < 0) {
 514         if (errno == EEXIST) {
 515             /*
 516              * The file exists.  Since we can only be called when overwriting
 517              * has been enabled, we back off and open the file normally (not
 518              * supplying O_EXCL), then continue normally.
 519              */
 520             fd1 = open(a_to, O_CREAT | O_WRONLY, a_mode);
 521             if (fd1 < 0) {
 522                 uss_procs_PrintErr(line,
 523                                    "%s: Failed to open '%s' for overwrite: %s.\n",
 524                                    uss_whoami, a_to, strerror(errno));
 525                 return (1);
 526             }
 527         } else {
 528             uss_procs_PrintErr(line, "%s: Failed to open '%s': %s.\n",
 529                                uss_whoami, a_to, strerror(errno));
 530             return (1);
 531         }
 532     }
 533
 534     if ((fd2 = open(a_from, O_RDONLY, 0)) < 0) {
 535         uss_procs_PrintErr(line, "%s: Error reading '%s': %s\n", uss_whoami,
 536                            a_from, strerror(errno));
 537         close(fd1);
 538         return (1);
 539     }
 540     do {
 541         rcnt = read(fd2, buf, BUFSIZ);
 542         if (rcnt == -1)
 543             break;
 544         wcnt = write(fd1, buf, rcnt);
 545     } while (rcnt == BUFSIZ && rcnt == wcnt);
 546     if (rcnt == -1 || wcnt != rcnt) {
 547         uss_procs_PrintErr(line, "read/write error to %s\n", a_to);
 548         close(fd1);
 549         close(fd2);
 550         return (1);
 551     }
 552     rc = close(fd1);
 553     if (rc) {
 554         uss_procs_PrintErr(line, "Failed to close '%s' %s\n", a_to,
 555                            strerror(errno));
 556         return (1);
 557     }
 558     if ((rc = close(fd2)))
 559         uss_procs_PrintErr(line, "Warning: Failed to close '%s': %s\n",
 560                            a_from, strerror(errno));
 561     return (0);
 562
 563 }                               /*Copy */
 564
 565 /*-----------------------------------------------------------------------
 566  * static Echo
 567  *
 568  * Description:
 569  *       Writes a string into a file and sets its mode.
 570  *
 571  * Arguments:
 572  *      a_s    : String to write.
 573  *      a_f    : Filename to write to.
 574  *      a_mode : New Unix mode to set.
 575  *
 576  * Returns:
 577  *      0 if everything went well,
 578  *      if there was a problem.
 579  *
 580  * Environment:
 581  *      Nothing interesting.
 582  *
 583  * Side Effects:
 584  *      As advertised.
 585  *------------------------------------------------------------------------*/
 586
 587 static int
 588 Echo(char *a_s, char *a_f, int a_mode)
 589 {                               /*Echo */
 590
 591     int fd;
 592
 593     umask(0);
 594     fd = open(a_f, O_EXCL | O_CREAT | O_WRONLY, a_mode);
 595     if (fd < 0) {
 596         if (errno == EEXIST) {
 597             /*
 598              * The file exists.  Since we can only be called when
 599              * overwriting has been enabled, we back off and open the
 600              * file normally (not supplying the O_EXCL), then continue
 601              * normally.  Notice that we must truncate the file, since
 602              * if the original file is longer than the stuff we're about
 603              * to put in, all the old data past the current write will
 604              * still be there.
 605              */
 606             fd = open(a_f, O_TRUNC | O_WRONLY, a_mode);
 607             if (fd < 0) {
 608                 uss_procs_PrintErr(line,
 609                                    "%s: Failed to open '%s' for overwrite: %s.\n",
 610                                    uss_whoami, a_f, strerror(errno));
 611                 return (1);
 612             }
 613         } else {
 614             uss_procs_PrintErr(line, "%s: Failed to open '%s': %s. \n",
 615                                uss_whoami, a_f, strerror(errno));
 616             return (1);
 617         }
 618     }
 619     if (write(fd, a_s, strlen(a_s)) != strlen(a_s) ||
 620         write(fd, "\n", 1) != 1) {
 621         uss_procs_PrintErr(line, "Short write to '%s'\n", a_f);
 622         close(fd);
 623         return (1);
 624     }
 625     if (close(fd)) {
 626         uss_procs_PrintErr(line, "Failed to close '%s': %s\n", a_f,
 627                            strerror(errno));
 628         return (1);
 629     }
 630     return (0);
 631
 632 }                               /*Echo */
 633
 634 /*-----------------------------------------------------------------------
 635  * static uss_procs_PickADir
 636  *
 637  * Description:
 638  *      Tries to replace $AUTO by a subdir.  Subdirs are given by means
 639  *      of "G" in the configuration file.  Each of the directories is
 640  *      examined, and the one with the inimum number of entries is
 641  *      picked.
 642  *
 643  * Arguments:
 644  *      a_path : ???
 645  *      a_cp   : ???
 646  *
 647  * Returns:
 648  *      0 if everything went well,
 649  *      -1 if there was a problem.
 650  *
 651  * Environment:
 652  *      Called with THREE parameters from lex.c!
 653  *
 654  * Side Effects:
 655  *      As advertised.
 656  *------------------------------------------------------------------------*/
 657
 658 afs_int32
 659 uss_procs_PickADir(char *path, char *cp)
 660 {                               /*uss_procs_PickADir */
 661
 662     char cd[uss_DirPoolLen];            /*Current  directory for search */
 663
 664     int i, count, MinIndex = 0, mina = 10000;
 665     struct dirent *dp;
 666     DIR *dirp;
 667     char dirname[uss_DirPoolLen*2];
 668
 669     if (uss_NumGroups == 0) {
 670         fprintf(stderr, "%s: No choice yet given to replace $AUTO\n",
 671                 uss_whoami);
 672         fprintf(stderr, "%s: Use the G command before $AUTO in config file\n",
 673                 uss_whoami);
 674         return (-1);
 675     }
 676
 677     if (uss_Auto[0] != '\0')
 678         return (0);             /* we have already done this for this user */
 679
 680     if (*(cp - 1) == '/') {     /*it's ..../$AUTO */
 681         for (i = 0; &path[i] != cp; i++)
 682             cd[i] = path[i];
 683         cd[i] = '\0';
 684     } else {
 685         if (path != cp) {
 686             fprintf(stderr,
 687                     "%s: $AUTO must be used to replace the whole path or the whole name of a subdirectory. Found: %s$AUTO\n",
 688                     uss_whoami, path);
 689             return (-1);
 690         }
 691         cd[0] = '/';
 692         cd[1] = '\0';
 693     }
 694
 695     /*
 696      * We now have the current dir (cd).  Search all of the given
 697      * subdirs (by G in template), count the number of entries in
 698      * each and pick the minimum.
 699      */
 700     for (i = 0; i < uss_NumGroups; i++) {
 701         snprintf(dirname, sizeof(dirname), "%s/%s", cd, uss_DirPool[i]);
 702         if ((dirp = opendir(dirname)) == NULL) {
 703             if (errno != ENOTDIR)
 704                 fprintf(stderr,
 705                         "%s: Warning: Can't open dir '%s' (errno=%d). Skipped.\n",
 706                         uss_whoami, dirname, errno);
 707             continue;           /*Skip and continue anyway */
 708         }
 709         count = 0;
 710         for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp))
 711             if (dp->d_name[0] != '.')
 712                 count++;        /* forget about files starting with . */
 713 #ifdef USS_PROCS_DB
 714         printf("debug: Dir '%s' has %d entries\n", dirname, count);
 715 #endif /* USS_PROCS_DB */
 716         if (count < mina) {
 717             mina = count;
 718             MinIndex = i;
 719         }
 720         closedir(dirp);
 721     }
 722     if (mina == 10000) {        /* We found nothing */
 723         fprintf(stderr, "%s: Warning: No valid choice to replace $AUTO\n",
 724                 uss_whoami);
 725         uss_Auto[0] = '\0';
 726     } else {
 727         strcpy(uss_Auto, uss_DirPool[MinIndex]);
 728         if (uss_verbose)
 729             printf("Picking dir w/minimum number of entries: '%s'\n",
 730                    uss_Auto);
 731     }
 732     return (0);
 733
 734 }                               /*uss_procs_PickADir */
 735
 736 /*-----------------------------------------------------------------------
 737  * EXPORTED uss_procs_AddToDirPool
 738  *
 739  * Environment:
 740  *      Called from the code generated by the uss grammar.
 741  *
 742  * Side Effects:
 743  *      As advertised.
 744  *------------------------------------------------------------------------*/
 745
 746 int
 747 uss_procs_AddToDirPool(char *a_dirToAdd)
 748 {
 749     if (uss_NumGroups > 99) {
 750         return (-1);
 751     }
 752     strcpy(uss_DirPool[uss_NumGroups++], a_dirToAdd);
 753     return 0;
 754 }
 755
 756 /*-----------------------------------------------------------------------
 757  * EXPORTED uss_procs_FindAndOpen
 758  *
 759  * Environment:
 760  *      Nothing interesting.
 761  *
 762  * Side Effects:
 763  *      As advertised.
 764  *------------------------------------------------------------------------*/
 765
 766 FILE *
 767 uss_procs_FindAndOpen(char *a_fileToOpen)
 768 {                               /*uss_procs_FindAndOpen */
 769
 770 #define NUM_TPL_PATHS 3
 771
 772     FILE *rv;                   /*Template file descriptor */
 773     int i;                      /*Loop counter */
 774     char *tmp_str;              /*Points to the name of the file */
 775                                 /* -> a_fileToOpen or -> buffer @tmp_str_free */
 776     char *tmp_str_free = NULL;  /*Dynamically built filename */
 777     static char
 778       TemplatePath[NUM_TPL_PATHS][1024];        /*Template directories */
 779     int cant_read;              /*Can't read the file? */
 780
 781     /*
 782      * If a full pathname was given, just take it as is.
 783      */
 784     if (strchr(a_fileToOpen, '/')) {
 785         tmp_str = a_fileToOpen;
 786         rv = fopen(a_fileToOpen, "r");
 787     } else {
 788         /*
 789          * A relative pathname was given.  Try to find the file in each of
 790          * the default template directories.
 791          */
 792         int mem_error = 0;
 793         cant_read = 0;
 794
 795         sprintf(TemplatePath[0], "%s", ".");
 796         sprintf(TemplatePath[1], "/afs/%s/common/uss", uss_Cell);
 797         sprintf(TemplatePath[2], "%s", "/etc");
 798
 799         for (i = 0; i < NUM_TPL_PATHS; i++) {
 800             int code;
 801             free(tmp_str_free);
 802             tmp_str_free = NULL;
 803             code = asprintf(&tmp_str_free, "%s/%s",
 804                             TemplatePath[i], a_fileToOpen);
 805             if (code == -1) {
 806                 tmp_str_free = NULL;
 807                 mem_error = 1;
 808                 rv = NULL;
 809                 break;
 810             }
 811             tmp_str = tmp_str_free;
 812
 813             if ((rv = fopen(tmp_str, "r")) != NULL)
 814                 break;
 815
 816             /*
 817              * If the file was there but couldn't be opened, we have
 818              * to report this.
 819              */
 820             if (errno != ENOENT) {
 821                 cant_read = 1;
 822                 break;
 823             }
 824         }                       /*Look in template directories */
 825
 826         /*
 827          * If we found and opened the file, we're happy.  Otherwise,
 828          * print out what went wrong.
 829          */
 830         if (rv != NULL) {
 831             if (uss_verbose)
 832                 fprintf(stderr, "Using template '%s'\n", tmp_str);
 833         } /*Got it */
 834         else {
 835             /*
 836              * Check to see if we specifically found the file but
 837              * couldn't read it.
 838              */
 839             if (mem_error) {
 840                 fprintf(stderr, "%s: Error allocating memory\n",
 841                         uss_whoami);
 842             }
 843             else if (cant_read)
 844                 fprintf(stderr, "%s: Can't open template '%s': %s\n",
 845                         uss_whoami, tmp_str, strerror(errno));
 846             else {
 847                 fprintf(stderr, "%s: Can't find template '%s' in searchlist",
 848                         uss_whoami, a_fileToOpen);
 849                 for (i = 0; i < NUM_TPL_PATHS; i++)
 850                     fprintf(stderr, " '%s'", TemplatePath[i]);
 851                 fprintf(stderr, "\n");
 852             }                   /*Can't find template */
 853         }                       /*Didn't get it */
 854     }                           /*Relative pathname given */
 855
 856     /*
 857      * Whatever happened, return what we got.
 858      */
 859     free(tmp_str_free);
 860     return (rv);
 861
 862 }                               /*uss_procs_FindAndOpen */
 863
 864
 865 /*-----------------------------------------------------------------------
 866  * EXPORTED uss_procs_PrintErr
 867  *
 868  * Environment:
 869  *      Nothing interesting.
 870  *
 871  * Side Effects:
 872  *      As advertised.
 873  *------------------------------------------------------------------------*/
 874
 875 void
 876 uss_procs_PrintErr(int a_lineNum, char *a_fmt, ... )
 877 {                               /*uss_procs_PrintErr */
 878     va_list ap;
 879
 880     va_start(ap, a_fmt);
 881     uss_syntax_err++;
 882     fprintf(stderr, "%s: Template file, line %d: ", uss_whoami, a_lineNum);
 883     vfprintf(stderr, a_fmt, ap);
 884     va_end(ap);
 885 }                               /*uss_procs_PrintErr */