src/bozo/bos.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 #include <afsconfig.h>
  11 #include <afs/param.h>
  12
  13 RCSID
  14     ("$Header$");
  15
  16 #include <afs/stds.h>
  17 #include <stdlib.h>
  18 #include <stddef.h>
  19 #include <sys/types.h>
  20 #ifdef AFS_NT40_ENV
  21 #include <winsock2.h>
  22 #include <io.h>
  23 #include <fcntl.h>
  24 #else
  25 #include <sys/file.h>
  26 #include <netinet/in.h>
  27 #include <netdb.h>
  28 #include <sys/socket.h>
  29 #include <strings.h>
  30 #endif /* AFS_NT40_ENV */
  31 #include <string.h>
  32 #include <afs/procmgmt.h>       /* signal(), kill(), wait(), etc. */
  33 #include <time.h>
  34 #include "bnode.h"
  35 #include <errno.h>
  36 #include <afs/afsutil.h>
  37 #include <afs/cellconfig.h>
  38 #include <rx/rx.h>
  39 #include <sys/stat.h>
  40 #include <rx/xdr.h>
  41 #include <afs/auth.h>
  42 #include <rx/rxkad.h>
  43 #include <afs/cellconfig.h>
  44 #include <stdio.h>
  45 #include <afs/cmd.h>
  46 #include <afs/com_err.h>
  47 #include <ubik.h>
  48 #include <afs/ktime.h>
  49
  50
  51
  52 extern char *volutil_PartitionName();
  53 extern struct rx_call *rx_NewCall();
  54 extern char *volutil_PartitionName();
  55 extern struct hostent *hostutil_GetHostByName();
  56
  57 static IStatServer();
  58 static DoStat();
  59
  60 #include "bosint.h"
  61
  62 #define MRAFS_OFFSET  9
  63 #define ADDPARMOFFSET 26
  64
  65 static struct SalvageParms {
  66     afs_int32 Optdebug;
  67     afs_int32 Optnowrite;
  68     afs_int32 Optforce;
  69     afs_int32 Optoktozap;
  70     afs_int32 Optrootfiles;
  71     afs_int32 Optsalvagedirs;
  72     afs_int32 Optblockreads;
  73     afs_int32 OptListResidencies;
  74     afs_int32 OptSalvageRemote;
  75     afs_int32 OptSalvageArchival;
  76     afs_int32 OptIgnoreCheck;
  77     afs_int32 OptForceOnLine;
  78     afs_int32 OptUseRootDirACL;
  79     afs_int32 OptTraceBadLinkCounts;
  80     afs_int32 OptDontAskFS;
  81     afs_int32 OptLogLevel;
  82     afs_int32 OptRxDebug;
  83     afs_uint32 OptResidencies;
  84 } mrafsParm;
  85
  86 /* dummy routine for the audit work.  It should do nothing since audits */
  87 /* occur at the server level and bos is not a server. */
  88 osi_audit()
  89 {
  90     return 0;
  91 }
  92
  93 /* keep those lines small */
  94 static char *
  95 em(acode)
  96      afs_int32 acode;
  97 {
  98     if (acode == -1)
  99         return "communications failure (-1)";
 100     else if (acode == -3)
 101         return "communications timeout (-3)";
 102     else
 103         return (char *)error_message(acode);
 104 }
 105
 106 /* get partition id from a name */
 107 static afs_int32
 108 GetPartitionID(aname)
 109      char *aname;
 110 {
 111     register char tc;
 112     char ascii[3];
 113
 114     tc = *aname;
 115     if (tc == 0)
 116         return -1;              /* unknown */
 117     /* numbers go straight through */
 118     if (tc >= '0' && tc <= '9') {
 119         return atoi(aname);
 120     }
 121     /* otherwise check for vicepa or /vicepa, or just plain "a" */
 122     ascii[2] = 0;
 123     if (strlen(aname) <= 2) {
 124         strcpy(ascii, aname);
 125     } else if (!strncmp(aname, "/vicep", 6)) {
 126         strncpy(ascii, aname + 6, 2);
 127     } else if (!strncmp(aname, "vicep", 5)) {
 128         strncpy(ascii, aname + 5, 2);
 129     } else
 130         return -1;              /* bad partition name */
 131     /* now partitions are named /vicepa ... /vicepz, /vicepaa, /vicepab,
 132      * .../vicepzz, and are numbered from 0.  Do the appropriate conversion */
 133     if (ascii[1] == 0) {
 134         /* one char name, 0..25 */
 135         if (ascii[0] < 'a' || ascii[0] > 'z')
 136             return -1;          /* wrongo */
 137         return ascii[0] - 'a';
 138     } else {
 139         /* two char name, 26 .. <whatever> */
 140         if (ascii[0] < 'a' || ascii[0] > 'z')
 141             return -1;          /* wrongo */
 142         if (ascii[1] < 'a' || ascii[1] > 'z')
 143             return -1;          /* just as bad */
 144         return (ascii[0] - 'a') * 26 + (ascii[1] - 'a') + 26;
 145     }
 146 }
 147
 148 /* make ctime easier to use */
 149 static char *
 150 DateOf(atime)
 151      afs_int32 atime;
 152 {
 153     static char tbuffer[30];
 154     register char *tp;
 155     tp = ctime((time_t *) & atime);
 156     if (tp) {
 157         strcpy(tbuffer, tp);
 158         tbuffer[24] = 0;        /* get rid of new line */
 159     } else
 160         strcpy(tbuffer, "BAD TIME");
 161     return tbuffer;
 162 }
 163
 164 /* global stuff from main for communicating with GetConn */
 165 static struct rx_securityClass *sc[3];
 166 static int scIndex;
 167
 168 /* use the syntax descr to get a connection, authenticated appropriately.
 169  * aencrypt is set if we want to encrypt the data on the wire.
 170  */
 171 static struct rx_connection *
 172 GetConn(as, aencrypt)
 173      int aencrypt;
 174      struct cmd_syndesc *as;
 175 {
 176     struct hostent *th;
 177     char *hostname;
 178     register afs_int32 code;
 179     register struct rx_connection *tconn;
 180     afs_int32 addr;
 181     register struct afsconf_dir *tdir;
 182     int encryptLevel;
 183     struct ktc_principal sname;
 184     struct ktc_token ttoken;
 185     int localauth;
 186     const char *confdir;
 187
 188     hostname = as->parms[0].items->data;
 189     th = hostutil_GetHostByName(hostname);
 190     if (!th) {
 191         printf("bos: can't find address for host '%s'\n", hostname);
 192         exit(1);
 193     }
 194     memcpy(&addr, th->h_addr, sizeof(afs_int32));
 195
 196     /* get tokens for making authenticated connections */
 197     localauth = (as->parms[ADDPARMOFFSET + 2].items != 0);
 198     confdir =
 199         (localauth ? AFSDIR_SERVER_ETC_DIRPATH : AFSDIR_CLIENT_ETC_DIRPATH);
 200     tdir = afsconf_Open(confdir);
 201     if (tdir) {
 202         struct afsconf_cell info;
 203         char *tname;
 204
 205         if (as->parms[ADDPARMOFFSET].items)
 206             tname = as->parms[ADDPARMOFFSET].items->data;
 207         else
 208             tname = NULL;
 209         /* next call expands cell name abbrevs for us and handles looking up
 210          * local cell */
 211         code = afsconf_GetCellInfo(tdir, tname, NULL, &info);
 212         if (code) {
 213             com_err("bos", code, "(can't find cell '%s' in cell database)",
 214                     (tname ? tname : "<default>"));
 215             exit(1);
 216         } else
 217             strcpy(sname.cell, info.name);
 218     } else {
 219         printf("bos: can't open cell database (%s)\n", confdir);
 220         exit(1);
 221     }
 222     sname.instance[0] = 0;
 223     strcpy(sname.name, "afs");
 224     sc[0] = rxnull_NewClientSecurityObject();
 225     sc[1] = 0;
 226     sc[2] = 0;
 227     scIndex = 0;
 228
 229     if (!as->parms[ADDPARMOFFSET + 1].items) {  /* not -noauth */
 230         if (as->parms[ADDPARMOFFSET + 2].items) {       /* -localauth */
 231             code = afsconf_GetLatestKey(tdir, 0, 0);
 232             if (code)
 233                 com_err("bos", code, "(getting key from local KeyFile)");
 234             else {
 235                 if (aencrypt)
 236                     code = afsconf_ClientAuthSecure(tdir, &sc[2], &scIndex);
 237                 else
 238                     code = afsconf_ClientAuth(tdir, &sc[2], &scIndex);
 239                 if (code)
 240                     com_err("bos", code, "(calling ClientAuth)");
 241                 else if (scIndex != 2)  /* this shouldn't happen */
 242                     sc[scIndex] = sc[2];
 243             }
 244         } else {                /* not -localauth, check for tickets */
 245             code = ktc_GetToken(&sname, &ttoken, sizeof(ttoken), NULL);
 246             if (code == 0) {
 247                 /* have tickets, will travel */
 248                 if (ttoken.kvno >= 0 && ttoken.kvno <= 255);
 249                 else {
 250                     fprintf(stderr,
 251                             "bos: funny kvno (%d) in ticket, proceeding\n",
 252                             ttoken.kvno);
 253                 }
 254                 /* kerberos tix */
 255                 if (aencrypt)
 256                     encryptLevel = rxkad_crypt;
 257                 else
 258                     encryptLevel = rxkad_clear;
 259                 sc[2] = (struct rx_securityClass *)
 260                     rxkad_NewClientSecurityObject(encryptLevel,
 261                                                   &ttoken.sessionKey,
 262                                                   ttoken.kvno,
 263                                                   ttoken.ticketLen,
 264                                                   ttoken.ticket);
 265                 scIndex = 2;
 266             } else
 267                 com_err("bos", code, "(getting tickets)");
 268         }
 269         if ((scIndex == 0) || (sc[scIndex] == 0)) {
 270             fprintf(stderr, "bos: running unauthenticated\n");
 271             scIndex = 0;
 272         }
 273     }
 274     tconn =
 275         rx_NewConnection(addr, htons(AFSCONF_NANNYPORT), 1, sc[scIndex],
 276                          scIndex);
 277     if (!tconn) {
 278         fprintf(stderr, "bos: could not create rx connection\n");
 279         exit(1);
 280     }
 281     rxs_Release(sc[scIndex]);
 282
 283     return tconn;
 284 }
 285
 286 static
 287 SetAuth(as)
 288      struct cmd_syndesc *as;
 289 {
 290     register afs_int32 code;
 291     register struct rx_connection *tconn;
 292     afs_int32 flag;
 293     register char *tp;
 294
 295     tconn = GetConn(as, 0);
 296     tp = as->parms[1].items->data;
 297     if (strcmp(tp, "on") == 0)
 298         flag = 0;               /* auth req.: noauthflag is false */
 299     else if (strcmp(tp, "off") == 0)
 300         flag = 1;
 301     else {
 302         printf
 303             ("bos: illegal authentication specifier '%s', must be 'off' or 'on'.\n",
 304              tp);
 305         return 1;
 306     }
 307     code = BOZO_SetNoAuthFlag(tconn, flag);
 308     if (code)
 309         com_err("bos", code, "(failed to set authentication flag)");
 310     return 0;
 311 }
 312
 313 /* take a name (e.g. foo/bar, and a dir e.g. /usr/afs/bin, and construct
 314  * /usr/afs/bin/bar */
 315 static
 316 ComputeDestDir(aname, adir, aresult, alen)
 317      char *aname, *adir, *aresult;
 318      afs_int32 alen;
 319 {
 320     register char *tp;
 321
 322     strcpy(aresult, adir);
 323     tp = strrchr(aname, '/');
 324     if (!tp) {
 325         /* no '/' in name */
 326         strcat(aresult, "/");
 327         strcat(aresult, aname);
 328     } else {
 329         /* tp points at the / character */
 330         strcat(aresult, tp);
 331     }
 332     return 0;
 333 }
 334
 335 /* copy data from fd afd to rx call acall */
 336 static
 337 CopyBytes(afd, acall)
 338      int afd;
 339      register struct rx_call *acall;
 340 {
 341     register afs_int32 code;
 342     register afs_int32 len;
 343     char tbuffer[256];
 344
 345     while (1) {
 346         len = read(afd, tbuffer, sizeof(tbuffer));
 347         if (len < 0)
 348             return errno;
 349         if (len == 0)
 350             return 0;           /* all done */
 351         code = rx_Write(acall, tbuffer, len);
 352         if (code != len)
 353             return -1;
 354     }
 355 }
 356
 357 static
 358 Prune(as)
 359      register struct cmd_syndesc *as;
 360 {
 361     register afs_int32 code;
 362     register struct rx_connection *tconn;
 363     register afs_int32 flags;
 364
 365     tconn = GetConn(as, 0);
 366     flags = 0;
 367     if (as->parms[1].items)
 368         flags |= BOZO_PRUNEBAK;
 369     if (as->parms[2].items)
 370         flags |= BOZO_PRUNEOLD;
 371     if (as->parms[3].items)
 372         flags |= BOZO_PRUNECORE;
 373     if (as->parms[4].items)
 374         flags |= 0xff;
 375     code = BOZO_Prune(tconn, flags);
 376     if (code)
 377         com_err("bos", code, "(failed to prune server files)");
 378     return code;
 379 }
 380
 381 static
 382 Exec(as)
 383      register struct cmd_syndesc *as;
 384 {
 385     register struct rx_connection *tconn;
 386     register afs_int32 code;
 387
 388     tconn = GetConn(as, 0);
 389     code = BOZO_Exec(tconn, as->parms[1].items->data);
 390     if (code)
 391         printf("bos: failed to execute command (%s)\n", em(code));
 392     return code;
 393 }
 394
 395 static
 396 GetDate(as)
 397      register struct cmd_syndesc *as;
 398 {
 399     register afs_int32 code;
 400     char tbuffer[256];
 401     char destDir[256];
 402     afs_int32 time, bakTime, oldTime;
 403     register struct rx_connection *tconn;
 404     register struct cmd_item *ti;
 405
 406     tconn = GetConn(as, 0);
 407     if (!as->parms[1].items) {
 408         printf("bos: no files to check\n");
 409         return 1;
 410     }
 411
 412     /* compute dest dir or file; default MUST be canonical form of dir path */
 413     if (as->parms[2].items)
 414         strcpy(destDir, as->parms[2].items->data);
 415     else
 416         strcpy(destDir, AFSDIR_CANONICAL_SERVER_BIN_DIRPATH);
 417
 418     for (ti = as->parms[1].items; ti; ti = ti->next) {
 419         /* check date for each file */
 420         ComputeDestDir(ti->data, destDir, tbuffer, sizeof(tbuffer));
 421         code = BOZO_GetDates(tconn, tbuffer, &time, &bakTime, &oldTime);
 422         if (code) {
 423             printf("bos: failed to check date on %s (%s)\n", ti->data,
 424                    em(code));
 425             return 1;
 426         } else {
 427             printf("File %s ", tbuffer);
 428             if (time == 0)
 429                 printf("does not exist, ");
 430             else
 431                 printf("dated %s, ", DateOf(time));
 432             if (bakTime == 0)
 433                 printf("no .BAK file, ");
 434             else
 435                 printf(".BAK file dated %s, ", DateOf(bakTime));
 436             if (oldTime == 0)
 437                 printf("no .OLD file.");
 438             else
 439                 printf(".OLD file dated %s.", DateOf(oldTime));
 440             printf("\n");
 441         }
 442     }
 443     return 0;
 444 }
 445
 446 static
 447 UnInstall(as)
 448      register struct cmd_syndesc *as;
 449 {
 450     register afs_int32 code;
 451     char tbuffer[256];
 452     char destDir[256];
 453     register struct cmd_item *ti;
 454     register struct rx_connection *tconn;
 455
 456     tconn = GetConn(as, 0);
 457     if (!as->parms[1].items) {
 458         printf("bos: no files to uninstall\n");
 459         return 1;
 460     }
 461
 462     /* compute dest dir or file; default MUST be canonical form of dir path */
 463     if (as->parms[2].items)
 464         strcpy(destDir, as->parms[2].items->data);
 465     else
 466         strcpy(destDir, AFSDIR_CANONICAL_SERVER_BIN_DIRPATH);
 467
 468     for (ti = as->parms[1].items; ti; ti = ti->next) {
 469         /* uninstall each file */
 470         ComputeDestDir(ti->data, destDir, tbuffer, sizeof(tbuffer));
 471         code = BOZO_UnInstall(tconn, tbuffer);
 472         if (code) {
 473             printf("bos: failed to uninstall %s (%s)\n", ti->data, em(code));
 474             return 1;
 475         } else
 476             printf("bos: uninstalled file %s\n", ti->data);
 477     }
 478     return 0;
 479 }
 480
 481 static afs_int32
 482 GetServerGoal(aconn, aname)
 483      char *aname;
 484      struct rx_connection *aconn;
 485 {
 486     char buffer[500];
 487     char *tp;
 488     register afs_int32 code;
 489     struct bozo_status istatus;
 490
 491     tp = buffer;
 492     code = BOZO_GetInstanceInfo(aconn, aname, &tp, &istatus);
 493     if (code) {
 494         printf("bos: failed to get instance info for '%s' (%s)\n", aname,
 495                em(code));
 496         /* if we can't get the answer, assume its running */
 497         return BSTAT_NORMAL;
 498     }
 499     if (istatus.goal == 0)
 500         return BSTAT_SHUTDOWN;
 501     else
 502         return BSTAT_NORMAL;
 503 }
 504
 505 static
 506 Install(as)
 507      struct cmd_syndesc *as;
 508 {
 509     struct rx_connection *tconn;
 510     register afs_int32 code;
 511     register struct cmd_item *ti;
 512     struct stat tstat;
 513     char tbuffer[256];
 514     int fd;
 515     struct rx_call *tcall;
 516     char destDir[256];
 517
 518     tconn = GetConn(as, 0);
 519     if (!as->parms[1].items) {
 520         printf("bos: no files to install\n");
 521         return 1;
 522     }
 523
 524     /* compute dest dir or file; default MUST be canonical form of dir path */
 525     if (as->parms[2].items)
 526         strcpy(destDir, as->parms[2].items->data);
 527     else
 528         strcpy(destDir, AFSDIR_CANONICAL_SERVER_BIN_DIRPATH);
 529
 530     for (ti = as->parms[1].items; ti; ti = ti->next) {
 531         /* install each file */
 532         fd = open(ti->data, O_RDONLY);
 533         if (fd < 0) {
 534             /* better to quit on error than continue for install command */
 535             printf("bos: can't find file '%s', quitting\n", ti->data);
 536             return 1;
 537         }
 538         code = fstat(fd, &tstat);
 539         if (code) {
 540             printf("bos: failed to stat file %s, errno is %d\n", ti->data,
 541                    errno);
 542             return 1;
 543         }
 544         /* compute destination dir */
 545         ComputeDestDir(ti->data, destDir, tbuffer, sizeof(tbuffer));
 546         tcall = rx_NewCall(tconn);
 547         code =
 548             StartBOZO_Install(tcall, tbuffer, tstat.st_size,
 549                               (afs_int32) tstat.st_mode, tstat.st_mtime);
 550         if (code == 0) {
 551             code = CopyBytes(fd, tcall);
 552         }
 553         code = rx_EndCall(tcall, code);
 554         if (code) {
 555             printf("bos: failed to install %s (%s)\n", ti->data, em(code));
 556             return 1;
 557         } else
 558             printf("bos: installed file %s\n", ti->data);
 559     }
 560     return 0;
 561 }
 562
 563 static
 564 Shutdown(as)
 565      struct cmd_syndesc *as;
 566 {
 567     register struct rx_connection *tconn;
 568     register afs_int32 code;
 569     register struct cmd_item *ti;
 570
 571     tconn = GetConn(as, 0);
 572     if (as->parms[1].items == 0) {
 573         code = BOZO_ShutdownAll(tconn);
 574         if (code)
 575             printf("bos: failed to shutdown servers (%s)\n", em(code));
 576     } else {
 577         for (ti = as->parms[1].items; ti; ti = ti->next) {
 578             code = BOZO_SetTStatus(tconn, ti->data, BSTAT_SHUTDOWN);
 579             if (code)
 580                 printf("bos: failed to shutdown instance %s (%s)\n", ti->data,
 581                        em(code));
 582         }
 583     }
 584     if (as->parms[8].items) {
 585         code = BOZO_WaitAll(tconn);
 586         if (code)
 587             printf("bos: can't wait for processes to shutdown (%s)\n",
 588                    em(code));
 589     }
 590     return 0;
 591 }
 592
 593 static
 594 BlockScannerCmd(as, arock)
 595      struct cmd_syndesc *as;
 596      char *arock;
 597 {
 598     register afs_int32 code;
 599     struct rx_connection *tconn;
 600     char BlockCommand[] = "/usr/afs/bin/scanner -block";
 601
 602     tconn = GetConn(as, 0);
 603     code = BOZO_Exec(tconn, BlockCommand);
 604     if (code)
 605         printf
 606             ("bos: failed to block scanner from making migration requests (%s)\n",
 607              em(code));
 608     return 0;
 609 }
 610
 611 static
 612 UnBlockScannerCmd(as, arock)
 613      struct cmd_syndesc *as;
 614      char *arock;
 615 {
 616     register afs_int32 code;
 617     struct rx_connection *tconn;
 618     char UnBlockCommand[] = "/usr/afs/bin/scanner -unblock";
 619
 620     tconn = GetConn(as, 0);
 621     code = BOZO_Exec(tconn, UnBlockCommand);
 622     if (code)
 623         printf
 624             ("bos: failed to allow scanner daemon to make migration requests again (%s)\n",
 625              em(code));
 626     return 0;
 627 }
 628
 629 static
 630 GetRestartCmd(as, arock)
 631      struct cmd_syndesc *as;
 632      char *arock;
 633 {
 634     register afs_int32 code;
 635     struct ktime generalTime, newBinaryTime;
 636     char messageBuffer[256];
 637     struct rx_connection *tconn;
 638     char *hostp;
 639
 640     hostp = as->parms[0].items->data;   /* host name for messages */
 641     tconn = GetConn(as, 0);
 642
 643     code = BOZO_GetRestartTime(tconn, 1, &generalTime);
 644     if (code) {
 645         printf("bos: failed to retrieve restart information (%s)\n",
 646                em(code));
 647         return code;
 648     }
 649     code = BOZO_GetRestartTime(tconn, 2, &newBinaryTime);
 650     if (code) {
 651         printf("bos: failed to retrieve restart information (%s)\n",
 652                em(code));
 653         return code;
 654     }
 655
 656     code = ktime_DisplayString(&generalTime, messageBuffer);
 657     if (code) {
 658         printf("bos: failed to decode restart time (%s)\n", em(code));
 659         return code;
 660     }
 661     printf("Server %s restarts %s\n", hostp, messageBuffer);
 662
 663     code = ktime_DisplayString(&newBinaryTime, messageBuffer);
 664     if (code) {
 665         printf("bos: failed to decode restart time (%s)\n", em(code));
 666         return code;
 667     }
 668     printf("Server %s restarts for new binaries %s\n", hostp, messageBuffer);
 669
 670     /* all done now */
 671     return 0;
 672 }
 673
 674 static
 675 SetRestartCmd(as, arock)
 676      struct cmd_syndesc *as;
 677      char *arock;
 678 {
 679     afs_int32 count;
 680     register afs_int32 code;
 681     struct ktime restartTime;
 682     afs_int32 type;
 683     struct rx_connection *tconn;
 684
 685     count = 0;
 686     tconn = GetConn(as, 0);
 687     if (as->parms[2].items) {
 688         count++;
 689         type = 1;
 690     }
 691     if (as->parms[3].items) {
 692         count++;
 693         type = 2;
 694     }
 695     if (count > 1) {
 696         printf("bos: can't specify more than one restart time at a time\n");
 697         return -1;
 698     }
 699     if (count == 0)
 700         type = 1;               /* by default set general restart time */
 701
 702     if (code = ktime_ParsePeriodic(as->parms[1].items->data, &restartTime)) {
 703         printf("bos: failed to parse '%s' as periodic restart time(%s)\n",
 704                as->parms[1].items->data, em(code));
 705         return code;
 706     }
 707
 708     code = BOZO_SetRestartTime(tconn, type, &restartTime);
 709     if (code) {
 710         printf("bos: failed to set restart time at server (%s)\n", em(code));
 711         return code;
 712     }
 713     return 0;
 714 }
 715
 716 static
 717 Startup(as)
 718      struct cmd_syndesc *as;
 719 {
 720     register struct rx_connection *tconn;
 721     register afs_int32 code;
 722     register struct cmd_item *ti;
 723
 724     tconn = GetConn(as, 0);
 725     if (as->parms[1].items == 0) {
 726         code = BOZO_StartupAll(tconn);
 727         if (code)
 728             printf("bos: failed to startup servers (%s)\n", em(code));
 729     } else {
 730         for (ti = as->parms[1].items; ti; ti = ti->next) {
 731             code = BOZO_SetTStatus(tconn, ti->data, BSTAT_NORMAL);
 732             if (code)
 733                 printf("bos: failed to start instance %s (%s)\n", ti->data,
 734                        em(code));
 735         }
 736     }
 737     return 0;
 738 }
 739
 740 static
 741 Restart(as)
 742      struct cmd_syndesc *as;
 743 {
 744     register struct rx_connection *tconn;
 745     register afs_int32 code;
 746     register struct cmd_item *ti;
 747
 748     tconn = GetConn(as, 0);
 749     if (as->parms[2].items) {
 750         /* this is really a rebozo command */
 751         if (as->parms[1].items) {
 752             /* specified specific things to restart, can't do this at the same
 753              * time */
 754             printf
 755                 ("bos: can't specify both '-bos' and specific servers to restart.\n");
 756             return 1;
 757         }
 758         /* otherwise do a rebozo */
 759         code = BOZO_ReBozo(tconn);
 760         if (code)
 761             printf("bos: failed to restart bosserver (%s)\n", em(code));
 762         return code;
 763     }
 764     if (as->parms[1].items == 0) {
 765         if (as->parms[3].items) {       /* '-all' */
 766             code = BOZO_RestartAll(tconn);
 767             if (code)
 768                 printf("bos: failed to restart servers (%s)\n", em(code));
 769         } else
 770             printf("bos: To restart all processes please specify '-all'\n");
 771     } else {
 772         if (as->parms[3].items) {
 773             printf("bos: Can't use '-all' along with individual instances\n");
 774         } else {
 775             for (ti = as->parms[1].items; ti; ti = ti->next) {
 776                 code = BOZO_Restart(tconn, ti->data);
 777                 if (code)
 778                     printf("bos: failed to restart instance %s (%s)\n",
 779                            ti->data, em(code));
 780             }
 781         }
 782     }
 783     return 0;
 784 }
 785
 786 static
 787 SetCellName(as)
 788      struct cmd_syndesc *as;
 789 {
 790     register struct rx_connection *tconn;
 791     register afs_int32 code;
 792
 793     tconn = GetConn(as, 0);
 794     code = BOZO_SetCellName(tconn, as->parms[1].items->data);
 795     if (code)
 796         printf("bos: failed to set cell (%s)\n", em(code));
 797     return 0;
 798 }
 799
 800 static
 801 AddHost(as)
 802      register struct cmd_syndesc *as;
 803 {
 804     register struct rx_connection *tconn;
 805     register afs_int32 code;
 806     register struct cmd_item *ti;
 807     char name[MAXHOSTCHARS];
 808
 809     tconn = GetConn(as, 0);
 810     for (ti = as->parms[1].items; ti; ti = ti->next) {
 811         if (as->parms[2].items) {
 812             if (strlen(ti->data) > MAXHOSTCHARS - 3) {
 813                 fprintf(stderr, "bos: host name too long\n");
 814                 return E2BIG;
 815             }
 816             name[0] = '[';
 817             strcpy(&name[1], ti->data);
 818             strcat((char *)&name, "]");
 819             code = BOZO_AddCellHost(tconn, name);
 820         } else
 821             code = BOZO_AddCellHost(tconn, ti->data);
 822         if (code)
 823             printf("bos: failed to add host %s (%s)\n", ti->data, em(code));
 824     }
 825     return 0;
 826 }
 827
 828 static
 829 RemoveHost(as)
 830      register struct cmd_syndesc *as;
 831 {
 832     register struct rx_connection *tconn;
 833     register afs_int32 code;
 834     register struct cmd_item *ti;
 835
 836     tconn = GetConn(as, 0);
 837     for (ti = as->parms[1].items; ti; ti = ti->next) {
 838         code = BOZO_DeleteCellHost(tconn, ti->data);
 839         if (code)
 840             printf("bos: failed to delete host %s (%s)\n", ti->data,
 841                    em(code));
 842     }
 843     return 0;
 844 }
 845
 846 static
 847 ListHosts(as)
 848      register struct cmd_syndesc *as;
 849 {
 850     register struct rx_connection *tconn;
 851     register afs_int32 code;
 852     char tbuffer[256];
 853     char *tp;
 854     register afs_int32 i;
 855
 856     tp = tbuffer;
 857     tconn = GetConn(as, 0);
 858     code = BOZO_GetCellName(tconn, &tp);
 859     if (code) {
 860         printf("bos: failed to get cell name (%s)\n", em(code));
 861         exit(1);
 862     }
 863     printf("Cell name is %s\n", tbuffer);
 864     for (i = 0;; i++) {
 865         code = BOZO_GetCellHost(tconn, i, &tp);
 866         if (code == BZDOM)
 867             break;
 868         if (code != 0) {
 869             printf("bos: failed to get cell host %d (%s)\n", i, em(code));
 870             exit(1);
 871         }
 872         printf("    Host %d is %s\n", i + 1, tbuffer);
 873     }
 874     return 0;
 875 }
 876
 877 static
 878 AddKey(as)
 879      register struct cmd_syndesc *as;
 880 {
 881     register struct rx_connection *tconn;
 882     register afs_int32 code;
 883     struct ktc_encryptionKey tkey;
 884     afs_int32 temp;
 885     char *tcell;
 886     char cellBuffer[256];
 887     char buf[BUFSIZ], ver[BUFSIZ];
 888
 889     tconn = GetConn(as, 1);
 890     memset(&tkey, 0, sizeof(struct ktc_encryptionKey));
 891
 892     if (as->parms[1].items)
 893         strcpy(buf, as->parms[1].items->data);
 894     else {
 895         /* prompt for key */
 896         code = des_read_pw_string(buf, sizeof(buf), "input key: ", 0);
 897         if (code || strlen(buf) == 0) {
 898             fprintf(stderr, "Bad key: \n");
 899             exit(1);
 900         }
 901         code = des_read_pw_string(ver, sizeof(ver), "Retype input key: ", 0);
 902         if (code || strlen(ver) == 0) {
 903             fprintf(stderr, "Bad key: \n");
 904             exit(1);
 905         }
 906         if (strcmp(ver, buf) != 0) {
 907             fprintf(stderr, "\nInput key mismatch\n");
 908             exit(1);
 909         }
 910
 911     }
 912
 913     temp = atoi(as->parms[2].items->data);
 914     if (temp == 999) {
 915         /* bcrypt key */
 916 /*
 917         strcpy((char *)&tkey, as->parms[1].items->data);
 918 */
 919         strcpy((char *)&tkey, buf);
 920     } else {                    /* kerberos key */
 921         if (as->parms[ADDPARMOFFSET].items) {
 922             strcpy(cellBuffer, as->parms[ADDPARMOFFSET].items->data);
 923
 924             /* string to key needs upper-case cell names */
 925
 926             /* I don't believe this is true.  The string to key function
 927              * actually expands the cell name, then LOWER-CASES it.  Perhaps it
 928              * didn't use to??? */
 929             ucstring(cellBuffer, cellBuffer, strlen(cellBuffer));
 930             tcell = cellBuffer;
 931         } else
 932             tcell = NULL;       /* no cell specified, use current */
 933 /*
 934         ka_StringToKey(as->parms[1].items->data, tcell, &tkey);
 935 */
 936         ka_StringToKey(buf, tcell, &tkey);
 937     }
 938     tconn = GetConn(as, 1);
 939     code = BOZO_AddKey(tconn, temp, &tkey);
 940     if (code) {
 941         printf("bos: failed to set key %d (%s)\n", temp, em(code));
 942         exit(1);
 943     }
 944     return 0;
 945 }
 946
 947 static
 948 RemoveKey(as)
 949      register struct cmd_syndesc *as;
 950 {
 951     register struct rx_connection *tconn;
 952     register afs_int32 code;
 953     afs_int32 temp;
 954     register struct cmd_item *ti;
 955
 956     tconn = GetConn(as, 0);
 957     for (ti = as->parms[1].items; ti; ti = ti->next) {
 958         temp = atoi(ti->data);
 959         code = BOZO_DeleteKey(tconn, temp);
 960         if (code) {
 961             printf("bos: failed to delete key %d (%s)\n", temp, em(code));
 962             exit(1);
 963         }
 964     }
 965     return 0;
 966 }
 967
 968 static
 969 ListKeys(as)
 970      IN register struct cmd_syndesc *as;
 971 {
 972     register struct rx_connection *tconn;
 973     register afs_int32 code;
 974     struct ktc_encryptionKey tkey;
 975     afs_int32 kvno;
 976     struct bozo_keyInfo keyInfo;
 977     int everWorked;
 978     register afs_int32 i;
 979
 980     tconn = GetConn(as, 1);
 981     everWorked = 0;
 982     for (i = 0;; i++) {
 983         code = BOZO_ListKeys(tconn, i, &kvno, &tkey, &keyInfo);
 984         if (code)
 985             break;
 986         everWorked = 1;
 987         /* first check if key is returned */
 988         if ((!ka_KeyIsZero(&tkey, sizeof(tkey))) && (as->parms[1].items)) {
 989             printf("key %d is '", kvno);
 990             ka_PrintBytes(&tkey, sizeof(tkey));
 991             printf("'\n");
 992         } else {
 993             if (keyInfo.keyCheckSum == 0)       /* shouldn't happen */
 994                 printf("key version is %d\n", kvno);
 995             else
 996                 printf("key %d has cksum %u\n", kvno, keyInfo.keyCheckSum);
 997         }
 998     }
 999     if (everWorked) {
1000         printf("Keys last changed on %s.\n", DateOf(keyInfo.mod_sec));
1001     }
1002     if (code != BZDOM)
1003         printf("bos: %s error encountered while listing keys\n", em(code));
1004     else
1005         printf("All done.\n");
1006     return 0;
1007 }
1008
1009 static
1010 AddSUser(as)
1011      register struct cmd_syndesc *as;
1012 {
1013     register struct rx_connection *tconn;
1014     register afs_int32 code;
1015     int failed;
1016     register struct cmd_item *ti;
1017
1018     failed = 0;
1019     tconn = GetConn(as, 0);
1020     for (ti = as->parms[1].items; ti; ti = ti->next) {
1021         code = BOZO_AddSUser(tconn, ti->data);
1022         if (code) {
1023             printf("bos: failed to add user '%s' (%s)\n", ti->data, em(code));
1024             failed = 1;
1025         }
1026     }
1027     return failed;
1028 }
1029
1030 static
1031 RemoveSUser(as)
1032      register struct cmd_syndesc *as;
1033 {
1034     register struct rx_connection *tconn;
1035     register struct cmd_item *ti;
1036     register afs_int32 code;
1037     int failed;
1038
1039     failed = 0;
1040     tconn = GetConn(as, 0);
1041     for (ti = as->parms[1].items; ti; ti = ti->next) {
1042         code = BOZO_DeleteSUser(tconn, ti->data);
1043         if (code) {
1044             printf("bos: failed to delete user '%s', ", ti->data);
1045             if (code == ENOENT)
1046                 printf("(no such user)\n");
1047             else
1048                 printf("(%s)\n", em(code));
1049             failed = 1;
1050         }
1051     }
1052     return failed;
1053 }
1054
1055 #define NPERLINE    10          /* dudes to print per line */
1056 static
1057 ListSUsers(as)
1058      register struct cmd_syndesc *as;
1059 {
1060     register struct rx_connection *tconn;
1061     register int i;
1062     register afs_int32 code;
1063     char tbuffer[256];
1064     char *tp;
1065     int lastNL, printGreeting;
1066
1067     tconn = GetConn(as, 0);
1068     lastNL = 0;
1069     printGreeting = 1;
1070     for (i = 0;; i++) {
1071         tp = tbuffer;
1072         code = BOZO_ListSUsers(tconn, i, &tp);
1073         if (code)
1074             break;
1075         if (printGreeting) {
1076             printGreeting = 0;  /* delay until after first call succeeds */
1077             printf("SUsers are: ");
1078         }
1079         printf("%s ", tbuffer);
1080         if ((i % NPERLINE) == NPERLINE - 1) {
1081             printf("\n");
1082             lastNL = 1;
1083         } else
1084             lastNL = 0;
1085     }
1086     if (code != 1) {
1087         /* a real error code, instead of scanned past end */
1088         printf("bos: failed to retrieve super-user list (%s)\n", em(code));
1089         return code;
1090     }
1091     if (lastNL == 0)
1092         printf("\n");
1093     return 0;
1094 }
1095
1096 static
1097 StatServer(as)
1098      register struct cmd_syndesc *as;
1099 {
1100     register struct rx_connection *tconn;
1101     register afs_int32 code;
1102     register int i;
1103     char ibuffer[BOZO_BSSIZE];
1104     char *tp;
1105     int int32p;
1106
1107     /* int32p==1 is obsolete, smaller, printout */
1108     int32p = (as->parms[2].items != 0 ? 2 : 0);
1109
1110     /* no parms does something pretty different */
1111     if (as->parms[1].items)
1112         return IStatServer(as, int32p);
1113
1114     tconn = GetConn(as, 0);
1115     for (i = 0;; i++) {
1116         /* for each instance */
1117         tp = ibuffer;
1118         code = BOZO_EnumerateInstance(tconn, i, &tp);
1119         if (code == BZDOM)
1120             break;
1121         if (code) {
1122             printf("bos: failed to contact host's bosserver (%s).\n",
1123                    em(code));
1124             break;
1125         }
1126         DoStat(ibuffer, tconn, int32p, (i == 0));       /* print status line */
1127     }
1128     return 0;
1129 }
1130
1131 static
1132 CreateServer(as)
1133      register struct cmd_syndesc *as;
1134 {
1135     register struct rx_connection *tconn;
1136     register afs_int32 code;
1137     char *parms[6];
1138     register struct cmd_item *ti;
1139     register int i;
1140     char *type, *name, *notifier = NONOTIFIER;
1141
1142     tconn = GetConn(as, 0);
1143     for (i = 0; i < 6; i++)
1144         parms[i] = "";
1145     for (i = 0, ti = as->parms[3].items; (ti && i < 6); ti = ti->next, i++) {
1146         parms[i] = ti->data;
1147     }
1148     name = as->parms[1].items->data;
1149     type = as->parms[2].items->data;
1150     if (ti = as->parms[4].items) {
1151         notifier = ti->data;
1152     }
1153     code =
1154         BOZO_CreateBnode(tconn, type, name, parms[0], parms[1], parms[2],
1155                          parms[3], parms[4], notifier);
1156     if (code) {
1157         printf
1158             ("bos: failed to create new server instance %s of type '%s' (%s)\n",
1159              name, type, em(code));
1160     }
1161     return code;
1162 }
1163
1164 static
1165 DeleteServer(as)
1166      register struct cmd_syndesc *as;
1167 {
1168     register struct rx_connection *tconn;
1169     register afs_int32 code;
1170     register struct cmd_item *ti;
1171
1172     code = 0;
1173     tconn = GetConn(as, 0);
1174     for (ti = as->parms[1].items; ti; ti = ti->next) {
1175         code = BOZO_DeleteBnode(tconn, ti->data);
1176         if (code) {
1177             if (code == BZBUSY)
1178                 printf("bos: can't delete running instance '%s'\n", ti->data);
1179             else
1180                 printf("bos: failed to delete instance '%s' (%s)\n", ti->data,
1181                        em(code));
1182         }
1183     }
1184     return code;
1185 }
1186
1187 static
1188 StartServer(as)
1189      register struct cmd_syndesc *as;
1190 {
1191     register struct rx_connection *tconn;
1192     register afs_int32 code;
1193     register struct cmd_item *ti;
1194
1195     code = 0;
1196     tconn = GetConn(as, 0);
1197     for (ti = as->parms[1].items; ti; ti = ti->next) {
1198         code = BOZO_SetStatus(tconn, ti->data, BSTAT_NORMAL);
1199         if (code)
1200             printf("bos: failed to start instance '%s' (%s)\n", ti->data,
1201                    em(code));
1202     }
1203     return code;
1204 }
1205
1206 static
1207 StopServer(as)
1208      register struct cmd_syndesc *as;
1209 {
1210     register struct rx_connection *tconn;
1211     register afs_int32 code;
1212     register struct cmd_item *ti;
1213
1214     code = 0;
1215     tconn = GetConn(as, 0);
1216     for (ti = as->parms[1].items; ti; ti = ti->next) {
1217         code = BOZO_SetStatus(tconn, ti->data, BSTAT_SHUTDOWN);
1218         if (code)
1219             printf("bos: failed to change stop instance '%s' (%s)\n",
1220                    ti->data, em(code));
1221     }
1222     if (as->parms[8].items) {
1223         code = BOZO_WaitAll(tconn);
1224         if (code)
1225             printf("bos: can't wait for processes to shutdown (%s)\n",
1226                    em(code));
1227     }
1228     return code;
1229 }
1230
1231 #define PARMBUFFERSSIZE 32
1232
1233 static
1234 DoSalvage(aconn, aparm1, aparm2, aoutName, showlog, parallel, atmpDir,
1235           orphans)
1236      struct rx_connection *aconn;
1237      char *aoutName;
1238      char *aparm1;
1239      char *aparm2;
1240      afs_int32 showlog;
1241      char *parallel;
1242      char *atmpDir;
1243      char *orphans;
1244 {
1245     register afs_int32 code;
1246     char *parms[6];
1247     char buffer;
1248     char tbuffer[BOZO_BSSIZE];
1249     struct bozo_status istatus;
1250     struct rx_call *tcall;
1251     char *tp;
1252     FILE *outFile;
1253     int closeIt;
1254     char partName[20];          /* canonical name for partition */
1255     char pbuffer[PARMBUFFERSSIZE];
1256     afs_int32 partNumber;
1257     char *notifier = NONOTIFIER;
1258
1259     /* if a partition was specified, canonicalize the name, since
1260      * the salvager has a stupid partition ID parser */
1261     if (aparm1) {
1262         partNumber = volutil_GetPartitionID(aparm1);
1263         if (partNumber < 0) {
1264             printf("bos: could not parse partition ID '%s'\n", aparm1);
1265             return EINVAL;
1266         }
1267         tp = volutil_PartitionName(partNumber);
1268         if (!tp) {
1269             printf("bos: internal error parsing partition ID '%s'\n", aparm1);
1270             return EINVAL;
1271         }
1272         strcpy(partName, tp);
1273     } else
1274         partName[0] = 0;
1275
1276     /* open the file name */
1277     if (aoutName) {
1278         outFile = fopen(aoutName, "w");
1279         if (!outFile) {
1280             printf("bos: can't open specified SalvageLog file '%s'\n",
1281                    aoutName);
1282             return ENOENT;
1283         }
1284         closeIt = 1;            /* close this file later */
1285     } else {
1286         outFile = stdout;
1287         closeIt = 0;            /* don't close this file later */
1288     }
1289
1290     for (code = 2; code < 6; code++)
1291         parms[code] = "";
1292     if (!aparm2)
1293         aparm2 = "";
1294     /* MUST pass canonical (wire-format) salvager path to bosserver */
1295     strncpy(tbuffer, AFSDIR_CANONICAL_SERVER_SALVAGER_FILEPATH, BOZO_BSSIZE);
1296     if (*aparm2 != 0) {
1297         if ((strlen(tbuffer) + 1 + strlen(partName) + 1 + strlen(aparm2) +
1298              1) > BOZO_BSSIZE) {
1299             printf("bos: command line too big\n");
1300             return (E2BIG);
1301         }
1302         strcat(tbuffer, " ");
1303         strcat(tbuffer, partName);
1304         strcat(tbuffer, " ");
1305         strcat(tbuffer, aparm2);
1306     } else {
1307         if ((strlen(tbuffer) + 4 + strlen(partName) + 1) > BOZO_BSSIZE) {
1308             printf("bos: command line too big\n");
1309             return (E2BIG);
1310         }
1311         strcat(tbuffer, " -f ");
1312         strcat(tbuffer, partName);
1313     }
1314
1315     /* add the parallel option if given */
1316     if (parallel != NULL) {
1317         if ((strlen(tbuffer) + 11 + strlen(parallel) + 1) > BOZO_BSSIZE) {
1318             printf("bos: command line too big\n");
1319             return (E2BIG);
1320         }
1321         strcat(tbuffer, " -parallel ");
1322         strcat(tbuffer, parallel);
1323     }
1324
1325     /* add the tmpdir option if given */
1326     if (atmpDir != NULL) {
1327         if ((strlen(tbuffer) + 9 + strlen(atmpDir) + 1) > BOZO_BSSIZE) {
1328             printf("bos: command line too big\n");
1329             return (E2BIG);
1330         }
1331         strcat(tbuffer, " -tmpdir ");
1332         strcat(tbuffer, atmpDir);
1333     }
1334
1335     /* add the orphans option if given */
1336     if (orphans != NULL) {
1337         if ((strlen(tbuffer) + 10 + strlen(orphans) + 1) > BOZO_BSSIZE) {
1338             printf("bos: command line too big\n");
1339             return (E2BIG);
1340         }
1341         strcat(tbuffer, " -orphans ");
1342         strcat(tbuffer, orphans);
1343     }
1344
1345     if (mrafsParm.Optdebug)
1346         strcat(tbuffer, " -debug");
1347     if (mrafsParm.Optnowrite)
1348         strcat(tbuffer, " -nowrite");
1349     if (mrafsParm.Optforce)
1350         strcat(tbuffer, " -force");
1351     if (mrafsParm.Optoktozap)
1352         strcat(tbuffer, " -oktozap");
1353     if (mrafsParm.Optrootfiles)
1354         strcat(tbuffer, " -rootfiles");
1355     if (mrafsParm.Optsalvagedirs)
1356         strcat(tbuffer, " -salvagedirs");
1357     if (mrafsParm.Optblockreads)
1358         strcat(tbuffer, " -blockreads");
1359     if (mrafsParm.OptListResidencies)
1360         strcat(tbuffer, " -ListResidencies");
1361     if (mrafsParm.OptSalvageRemote)
1362         strcat(tbuffer, " -SalvageRemote");
1363     if (mrafsParm.OptSalvageArchival)
1364         strcat(tbuffer, " -SalvageArchival");
1365     if (mrafsParm.OptIgnoreCheck)
1366         strcat(tbuffer, " -IgnoreCheck");
1367     if (mrafsParm.OptForceOnLine)
1368         strcat(tbuffer, " -ForceOnLine");
1369     if (mrafsParm.OptUseRootDirACL)
1370         strcat(tbuffer, " -UseRootDirACL");
1371     if (mrafsParm.OptTraceBadLinkCounts)
1372         strcat(tbuffer, " -TraceBadLinkCounts");
1373     if (mrafsParm.OptDontAskFS)
1374         strcat(tbuffer, " -DontAskFS");
1375     if (mrafsParm.OptLogLevel) {
1376         sprintf(pbuffer, " -LogLevel %ld", mrafsParm.OptLogLevel);
1377         strcat(tbuffer, pbuffer);
1378     }
1379     if (mrafsParm.OptRxDebug)
1380         strcat(tbuffer, " -rxdebug");
1381     if (mrafsParm.OptResidencies) {
1382         sprintf(pbuffer, " -Residencies %lu", mrafsParm.OptResidencies);
1383         strcat(tbuffer, pbuffer);
1384     }
1385
1386     parms[0] = tbuffer;
1387     parms[1] = "now";           /* when to do it */
1388     code =
1389         BOZO_CreateBnode(aconn, "cron", "salvage-tmp", parms[0], parms[1],
1390                          parms[2], parms[3], parms[4], notifier);
1391     if (code) {
1392         printf("bos: failed to start 'salvager' (%s)\n", em(code));
1393         goto done;
1394     }
1395     /* now wait for bnode to disappear */
1396     while (1) {
1397         IOMGR_Sleep(5);
1398         tp = tbuffer;
1399         code = BOZO_GetInstanceInfo(aconn, "salvage-tmp", &tp, &istatus);
1400         if (code)
1401             break;
1402         printf("bos: waiting for salvage to complete.\n");
1403     }
1404     if (code != BZNOENT) {
1405         printf("bos: salvage failed (%s)\n", em(code));
1406         goto done;
1407     }
1408     code = 0;
1409
1410     /* now print the log file to the output file */
1411     printf("bos: salvage completed\n");
1412     if (aoutName || showlog) {
1413         fprintf(outFile, "SalvageLog:\n");
1414         tcall = rx_NewCall(aconn);
1415         /* MUST pass canonical (wire-format) salvager log path to bosserver */
1416         code =
1417             StartBOZO_GetLog(tcall, AFSDIR_CANONICAL_SERVER_SLVGLOG_FILEPATH);
1418         if (code) {
1419             rx_EndCall(tcall, code);
1420             goto done;
1421         }
1422         /* copy data */
1423         while (1) {
1424             code = rx_Read(tcall, &buffer, 1);
1425             if (code != 1)
1426                 break;
1427             putc(buffer, outFile);
1428             if (buffer == 0)
1429                 break;          /* the end delimeter */
1430         }
1431         code = rx_EndCall(tcall, 0);
1432         /* fall through into cleanup code */
1433     }
1434
1435   done:
1436     if (closeIt && outFile)
1437         fclose(outFile);
1438     return code;
1439 }
1440
1441 static
1442 GetLogCmd(as)
1443      register struct cmd_syndesc *as;
1444 {
1445     struct rx_connection *tconn;
1446     register struct rx_call *tcall;
1447     register afs_int32 code;
1448     char buffer;
1449     int error;
1450
1451     printf("Fetching log file '%s'...\n", as->parms[1].items->data);
1452     tconn = GetConn(as, 0);
1453     tcall = rx_NewCall(tconn);
1454     code = StartBOZO_GetLog(tcall, as->parms[1].items->data);
1455     if (code) {
1456         rx_EndCall(tcall, code);
1457         goto done;
1458     }
1459     /* copy data */
1460     error = 0;
1461     while (1) {
1462         code = rx_Read(tcall, &buffer, 1);
1463         if (code != 1) {
1464             error = EIO;
1465             break;
1466         }
1467         if (buffer == 0)
1468             break;              /* the end delimeter */
1469         putchar(buffer);
1470     }
1471     code = rx_EndCall(tcall, error);
1472     /* fall through into cleanup code */
1473
1474   done:
1475     if (code)
1476         com_err("bos", code, "(while reading log)");
1477     return code;
1478 }
1479
1480 static
1481 SalvageCmd(as)
1482      struct cmd_syndesc *as;
1483 {
1484     register struct rx_connection *tconn;
1485     register afs_int32 code, rc, i;
1486     char *outName;
1487     char tname[BOZO_BSSIZE];
1488     afs_int32 newID;
1489     extern struct ubik_client *cstruct;
1490     afs_int32 curGoal, showlog = 0, mrafs = 0;
1491     char *parallel;
1492     char *tmpDir;
1493     char *orphans;
1494     char *tp;
1495
1496     memset(&mrafsParm, 0, sizeof(mrafsParm));
1497
1498     /* parm 0 is machine name, 1 is partition, 2 is volume, 3 is -all flag */
1499     tconn = GetConn(as, 0);
1500
1501     /* Find out whether fileserver is running MR-AFS (has a scanner instance) */
1502     /* XXX this should really be done some other way, potentially by RPC */
1503     tp = &tname;
1504     if (code = BOZO_GetInstanceParm(tconn, "fs", 3, &tp) == 0)
1505         mrafs = 1;
1506
1507     /* we can do a volume, a partition or the whole thing, but not mixtures
1508      * thereof */
1509     if (!as->parms[1].items && as->parms[2].items) {
1510         printf("bos: must specify partition to salvage individual volume.\n");
1511         return -1;
1512     }
1513     if (as->parms[5].items && as->parms[3].items) {
1514         printf("bos: can not specify both -file and -showlog.\n");
1515         return -1;
1516     }
1517     if (as->parms[4].items && (as->parms[1].items || as->parms[2].items)) {
1518         printf("bos: can not specify -all with other flags.\n");
1519         return -1;
1520     }
1521
1522     /* get the output file name, if any */
1523     if (as->parms[3].items)
1524         outName = as->parms[3].items->data;
1525     else
1526         outName = NULL;
1527
1528     if (as->parms[5].items)
1529         showlog = 1;
1530
1531     /* parallel option */
1532     parallel = NULL;
1533     if (as->parms[6].items)
1534         parallel = as->parms[6].items->data;
1535
1536     /* get the tmpdir filename if any */
1537     tmpDir = NULL;
1538     if (as->parms[7].items)
1539         tmpDir = as->parms[7].items->data;
1540
1541     /* -orphans option */
1542     orphans = NULL;
1543     if (as->parms[8].items) {
1544         if (mrafs) {
1545             printf("Can't specify -orphans for MR-AFS fileserver\n");
1546             return EINVAL;
1547         }
1548         orphans = as->parms[8].items->data;
1549     }
1550
1551     if (mrafs) {
1552         if (as->parms[MRAFS_OFFSET].items)
1553             mrafsParm.Optdebug = 1;
1554         if (as->parms[MRAFS_OFFSET + 1].items)
1555             mrafsParm.Optnowrite = 1;
1556         if (as->parms[MRAFS_OFFSET + 2].items)
1557             mrafsParm.Optforce = 1;
1558         if (as->parms[MRAFS_OFFSET + 3].items)
1559             mrafsParm.Optoktozap = 1;
1560         if (as->parms[MRAFS_OFFSET + 4].items)
1561             mrafsParm.Optrootfiles = 1;
1562         if (as->parms[MRAFS_OFFSET + 5].items)
1563             mrafsParm.Optsalvagedirs = 1;
1564         if (as->parms[MRAFS_OFFSET + 6].items)
1565             mrafsParm.Optblockreads = 1;
1566         if (as->parms[MRAFS_OFFSET + 7].items)
1567             mrafsParm.OptListResidencies = 1;
1568         if (as->parms[MRAFS_OFFSET + 8].items)
1569             mrafsParm.OptSalvageRemote = 1;
1570         if (as->parms[MRAFS_OFFSET + 9].items)
1571             mrafsParm.OptSalvageArchival = 1;
1572         if (as->parms[MRAFS_OFFSET + 10].items)
1573             mrafsParm.OptIgnoreCheck = 1;
1574         if (as->parms[MRAFS_OFFSET + 11].items)
1575             mrafsParm.OptForceOnLine = 1;
1576         if (as->parms[MRAFS_OFFSET + 12].items)
1577             mrafsParm.OptUseRootDirACL = 1;
1578         if (as->parms[MRAFS_OFFSET + 13].items)
1579             mrafsParm.OptTraceBadLinkCounts = 1;
1580         if (as->parms[MRAFS_OFFSET + 14].items)
1581             mrafsParm.OptDontAskFS = 1;
1582         if (as->parms[MRAFS_OFFSET + 15].items)
1583             mrafsParm.OptLogLevel =
1584                 atoi(as->parms[MRAFS_OFFSET + 15].items->data);
1585         if (as->parms[MRAFS_OFFSET + 16].items)
1586             mrafsParm.OptRxDebug = 1;
1587         if (as->parms[MRAFS_OFFSET + 17].items) {
1588             if (as->parms[MRAFS_OFFSET + 8].items
1589                 || as->parms[MRAFS_OFFSET + 9].items) {
1590                 printf
1591                     ("Can't specify -Residencies with -SalvageRemote or -SalvageArchival\n");
1592                 return EINVAL;
1593             }
1594             code =
1595                 util_GetUInt32(as->parms[MRAFS_OFFSET + 17].items->data,
1596                                &mrafsParm.OptResidencies);
1597             if (code) {
1598                 printf("bos: '%s' is not a valid residency mask.\n",
1599                        as->parms[MRAFS_OFFSET + 13].items->data);
1600                 return code;
1601             }
1602         }
1603     } else {
1604         int stop = 0;
1605
1606         for (i = 9; i < ADDPARMOFFSET; i++) {
1607             if (as->parms[i].items) {
1608                 printf(" %s only possible for MR-AFS fileserver.\n",
1609                        as->parms[i].name);
1610                 stop = 1;
1611             }
1612         }
1613         if (stop)
1614             exit(1);
1615     }
1616
1617     if (as->parms[4].items) {
1618         /* salvage whole enchilada */
1619         curGoal = GetServerGoal(tconn, "fs");
1620         if (curGoal == BSTAT_NORMAL) {
1621             printf("bos: shutting down fs.\n");
1622             code = BOZO_SetTStatus(tconn, "fs", BSTAT_SHUTDOWN);
1623             if (code) {
1624                 printf("bos: failed to stop 'fs' (%s)\n", em(code));
1625                 return code;
1626             }
1627             code = BOZO_WaitAll(tconn); /* wait for shutdown to complete */
1628             if (code)
1629                 printf
1630                     ("bos: failed to wait for file server shutdown, continuing.\n");
1631         }
1632         /* now do the salvage operation */
1633         printf("Starting salvage.\n");
1634         rc = DoSalvage(tconn, NULL, NULL, outName, showlog, parallel, tmpDir,
1635                        orphans);
1636         if (curGoal == BSTAT_NORMAL) {
1637             printf("bos: restarting fs.\n");
1638             code = BOZO_SetTStatus(tconn, "fs", BSTAT_NORMAL);
1639             if (code) {
1640                 printf("bos: failed to restart 'fs' (%s)\n", em(code));
1641                 return code;
1642             }
1643         }
1644         if (rc)
1645             return rc;
1646     } else if (!as->parms[2].items) {
1647         if (!as->parms[1].items) {
1648             printf
1649                 ("bos: must specify -all switch to salvage all partitions.\n");
1650             return -1;
1651         }
1652         if (volutil_GetPartitionID(as->parms[1].items->data) < 0) {
1653             /* can't parse volume ID, so complain before shutting down
1654              * file server.
1655              */
1656             printf("bos: can't interpret %s as partition ID.\n",
1657                    as->parms[1].items->data);
1658             return -1;
1659         }
1660         curGoal = GetServerGoal(tconn, "fs");
1661         /* salvage a whole partition (specified by parms[1]) */
1662         if (curGoal == BSTAT_NORMAL) {
1663             printf("bos: shutting down fs.\n");
1664             code = BOZO_SetTStatus(tconn, "fs", BSTAT_SHUTDOWN);
1665             if (code) {
1666                 printf("bos: can't stop 'fs' (%s)\n", em(code));
1667                 return code;
1668             }
1669             code = BOZO_WaitAll(tconn); /* wait for shutdown to complete */
1670             if (code)
1671                 printf
1672                     ("bos: failed to wait for file server shutdown, continuing.\n");
1673         }
1674         /* now do the salvage operation */
1675         printf("Starting salvage.\n");
1676         rc = DoSalvage(tconn, as->parms[1].items->data, NULL, outName,
1677                        showlog, parallel, tmpDir, orphans);
1678         if (curGoal == BSTAT_NORMAL) {
1679             printf("bos: restarting fs.\n");
1680             code = BOZO_SetTStatus(tconn, "fs", BSTAT_NORMAL);
1681             if (code) {
1682                 printf("bos: failed to restart 'fs' (%s)\n", em(code));
1683                 return code;
1684             }
1685         }
1686         if (rc)
1687             return rc;
1688     } else {
1689         /* salvage individual volume (don't shutdown fs first), just use
1690          * single-shot cron bnode.  Must leave server running when using this
1691          * option, since salvager will ask file server for the volume */
1692         char *tmpname;
1693         afs_int32 err;
1694         const char *confdir;
1695         int localauth;
1696
1697         if (as->parms[ADDPARMOFFSET].items)
1698             tmpname = as->parms[ADDPARMOFFSET].items->data;
1699         else
1700             tmpname = NULL;
1701
1702         localauth = (as->parms[ADDPARMOFFSET + 2].items != 0);
1703         confdir =
1704             (localauth ? AFSDIR_SERVER_ETC_DIRPATH :
1705              AFSDIR_CLIENT_ETC_DIRPATH);
1706         code = vsu_ClientInit( /* noauth */ 1, confdir, tmpname,
1707                               /* server auth */ 0, &cstruct, (int (*)())0);
1708         if (code == 0) {
1709             newID = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err);
1710             if (newID == 0) {
1711                 printf("bos: can't interpret %s as volume name or ID\n",
1712                        as->parms[2].items->data);
1713                 return -1;
1714             }
1715             sprintf(tname, "%u", newID);
1716         } else {
1717             printf
1718                 ("bos: can't initialize volume system client (code %d), trying anyway.\n",
1719                  code);
1720             strncpy(tname, as->parms[2].items->data, sizeof(tname));
1721         }
1722         if (volutil_GetPartitionID(as->parms[1].items->data) < 0) {
1723             /* can't parse volume ID, so complain before shutting down
1724              * file server.
1725              */
1726             printf("bos: can't interpret %s as partition ID.\n",
1727                    as->parms[1].items->data);
1728             return -1;
1729         }
1730         printf("Starting salvage.\n");
1731         rc = DoSalvage(tconn, as->parms[1].items->data, tname, outName,
1732                        showlog, parallel, tmpDir, orphans);
1733         if (rc)
1734             return rc;
1735     }
1736     return 0;
1737 }
1738
1739 static
1740 IStatServer(as, int32p)
1741      int int32p;
1742      register struct cmd_syndesc *as;
1743 {
1744     register struct rx_connection *tconn;
1745     register struct cmd_item *ti;
1746     int firstTime = 1;
1747
1748     tconn = GetConn(as, 0);
1749     for (ti = as->parms[1].items; ti; ti = ti->next) {
1750         DoStat(ti->data, tconn, int32p, firstTime);
1751         firstTime = 0;
1752     }
1753     return 0;
1754 }
1755
1756 static
1757 DoStat(aname, aconn, aint32p, firstTime)
1758      IN char *aname;
1759      IN register struct rx_connection *aconn;
1760      IN int aint32p;
1761      IN int firstTime;          /* true iff first instance in cmd */
1762 {
1763     afs_int32 temp;
1764     char buffer[500];
1765     register afs_int32 code;
1766     register afs_int32 i;
1767     struct bozo_status istatus;
1768     char *tp;
1769     char *is1, *is2, *is3, *is4;        /* instance strings */
1770
1771     tp = buffer;
1772     code = BOZO_GetInstanceInfo(aconn, aname, &tp, &istatus);
1773     if (code) {
1774         printf("bos: failed to get instance info for '%s' (%s)\n", aname,
1775                em(code));
1776         return -1;
1777     }
1778     if (firstTime && aint32p && (istatus.flags & BOZO_BADDIRACCESS))
1779         printf
1780             ("Bosserver reports inappropriate access on server directories\n");
1781     printf("Instance %s, ", aname);
1782     if (aint32p)
1783         printf("(type is %s) ", buffer);
1784     if (istatus.fileGoal == istatus.goal) {
1785         if (!istatus.goal)
1786             printf("disabled, ");
1787     } else {
1788         if (istatus.fileGoal)
1789             printf("temporarily disabled, ");
1790         else
1791             printf("temporarily enabled, ");
1792     }
1793
1794     if (istatus.flags & BOZO_ERRORSTOP)
1795         printf("stopped for too many errors, ");
1796     if (istatus.flags & BOZO_HASCORE)
1797         printf("has core file, ");
1798
1799     tp = buffer;
1800     code = BOZO_GetStatus(aconn, aname, &temp, &tp);
1801     if (code)
1802         printf("bos: failed to get status for instance '%s' (%s)\n", aname,
1803                em(code));
1804     else {
1805         printf("currently ");
1806         if (temp == BSTAT_NORMAL)
1807             printf("running normally.\n");
1808         else if (temp == BSTAT_SHUTDOWN)
1809             printf("shutdown.\n");
1810         else if (temp == BSTAT_STARTINGUP)
1811             printf("starting up.\n");
1812         else if (temp == BSTAT_SHUTTINGDOWN)
1813             printf("shutting down.\n");
1814         if (buffer[0] != 0) {
1815             printf("    Auxiliary status is: %s.\n", buffer);
1816         }
1817     }
1818
1819     /* are we done yet? */
1820     if (!aint32p)
1821         return 0;
1822
1823     if (istatus.procStartTime)
1824         printf("    Process last started at %s (%d proc starts)\n",
1825                DateOf(istatus.procStartTime), istatus.procStarts);
1826     if (istatus.lastAnyExit) {
1827         printf("    Last exit at %s\n", DateOf(istatus.lastAnyExit));
1828     }
1829     if (istatus.lastErrorExit) {
1830         is1 = is2 = is3 = is4 = NULL;
1831         printf("    Last error exit at %s, ", DateOf(istatus.lastErrorExit));
1832         code = BOZO_GetInstanceStrings(aconn, aname, &is1, &is2, &is3, &is4);
1833         /* don't complain about failing call, since could simply mean
1834          * interface mismatch.
1835          */
1836         if (code == 0) {
1837             if (*is1 != 0) {
1838                 /* non-null instance string */
1839                 printf("by %s, ", is1);
1840             }
1841             free(is1);
1842             free(is2);
1843             free(is3);
1844             free(is4);
1845         }
1846         if (istatus.errorSignal) {
1847             if (istatus.errorSignal == SIGTERM)
1848                 printf("due to shutdown request\n");
1849             else
1850                 printf("due to signal %d\n", istatus.errorSignal);
1851         } else
1852             printf("by exiting with code %d\n", istatus.errorCode);
1853     }
1854
1855     if (aint32p > 1) {
1856         /* try to display all the parms */
1857         for (i = 0;; i++) {
1858             tp = buffer;
1859             code = BOZO_GetInstanceParm(aconn, aname, i, &tp);
1860             if (code)
1861                 break;
1862             printf("    Command %d is '%s'\n", i + 1, buffer);
1863         }
1864         tp = buffer;
1865         code = BOZO_GetInstanceParm(aconn, aname, 999, &tp);
1866         if (!code) {
1867             /* Any type of failure is treated as not having a notifier program */
1868             printf("    Notifier  is '%s'\n", buffer);
1869         }
1870         printf("\n");
1871     }
1872     return 0;
1873 }
1874
1875 #ifdef BOS_RESTRICTED_MODE
1876 static
1877 GetRestrict(as)
1878      struct cmd_syndesc *as;
1879 {
1880     register struct rx_connection *tconn;
1881     afs_int32 code, val;
1882
1883     tconn = GetConn(as, 0);
1884     code = BOZO_GetRestrictedMode(tconn, &val);
1885     if (code)
1886         printf("bos: failed to get restricted mode (%s)\n", em(code));
1887     else
1888         printf("Restricted mode is %s\n", val ? "on" : "off");
1889
1890     return 0;
1891 }
1892
1893 static
1894 SetRestrict(as)
1895      struct cmd_syndesc *as;
1896 {
1897     register struct rx_connection *tconn;
1898     afs_int32 code, val;
1899
1900     tconn = GetConn(as, 0);
1901     util_GetInt32(as->parms[1].items->data, &val);
1902     code = BOZO_SetRestrictedMode(tconn, val);
1903     if (code)
1904         printf("bos: failed to set restricted mode (%s)\n", em(code));
1905     return 0;
1906 }
1907 #endif
1908
1909 static void
1910 add_std_args(ts)
1911      register struct cmd_syndesc *ts;
1912 {
1913     cmd_Seek(ts, ADDPARMOFFSET);
1914     /* + 0 */ cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
1915     /* + 1 */ cmd_AddParm(ts, "-noauth", CMD_FLAG, CMD_OPTIONAL,
1916                           "don't authenticate");
1917     /* + 2 */ cmd_AddParm(ts, "-localauth", CMD_FLAG, CMD_OPTIONAL,
1918                           "create tickets from KeyFile");
1919 }
1920
1921 #include "AFS_component_version_number.c"
1922
1923 main(argc, argv)
1924      int argc;
1925      char **argv;
1926 {
1927     register afs_int32 code;
1928     register struct cmd_syndesc *ts;
1929     extern int afsconf_SawCell;
1930
1931 #ifdef  AFS_AIX32_ENV
1932     /*
1933      * The following signal action for AIX is necessary so that in case of a
1934      * crash (i.e. core is generated) we can include the user's data section
1935      * in the core dump. Unfortunately, by default, only a partial core is
1936      * generated which, in many cases, isn't too useful.
1937      */
1938     struct sigaction nsa;
1939
1940     sigemptyset(&nsa.sa_mask);
1941     nsa.sa_handler = SIG_DFL;
1942     nsa.sa_flags = SA_FULLDUMP;
1943     sigaction(SIGSEGV, &nsa, NULL);
1944     sigaction(SIGABRT, &nsa, NULL);
1945 #endif
1946
1947     /* start up rx */
1948     code = rx_Init(0);
1949     if (code) {
1950         printf("bos: could not initialize rx (%s)\n", em(code));
1951         exit(1);
1952     }
1953
1954     /* To resolve a AFSCELL environment "Note: ..." problem: Because bos calls ka_Init (why?) before any
1955      * checkup on the existance of a "-cell" option on the particular bos command we don't print the
1956      * message if a cell is passed in. Luckily the rest of the programs don't call these adhoc routines
1957      * and things work fine. Note that if the "-cell" isn't passed then we're still ok since later on
1958      * the proper routine (afsconf_GetCellInfo) is going to be called to do the right thing.
1959      */
1960     afsconf_SawCell = 1;        /* Means don't print warning if AFSCELL is set */
1961     ka_Init(0);
1962     afsconf_SawCell = 0;        /* Reset it */
1963     /* don't check error code, since fails sometimes when we're setting up a
1964      * system */
1965     initialize_CMD_error_table();
1966     initialize_BZ_error_table();
1967
1968     ts = cmd_CreateSyntax("start", StartServer, 0, "start running a server");
1969     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
1970     cmd_AddParm(ts, "-instance", CMD_LIST, 0, "server process name");
1971     add_std_args(ts);
1972
1973     ts = cmd_CreateSyntax("stop", StopServer, 0, "halt a server instance");
1974     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
1975     cmd_AddParm(ts, "-instance", CMD_LIST, 0, "server process name");
1976     cmd_Seek(ts, 8);
1977     cmd_AddParm(ts, "-wait", CMD_FLAG, CMD_OPTIONAL,
1978                 "wait for process to stop");
1979     add_std_args(ts);
1980
1981     ts = cmd_CreateSyntax("status", StatServer, 0,
1982                           "show server instance status");
1983     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
1984     cmd_AddParm(ts, "-instance", CMD_LIST, CMD_OPTIONAL,
1985                 "server process name");
1986     cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL, "long status");
1987     add_std_args(ts);
1988
1989     ts = cmd_CreateSyntax("shutdown", Shutdown, 0, "shutdown all processes");
1990     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
1991     cmd_AddParm(ts, "-instance", CMD_LIST, CMD_OPTIONAL, "instances");
1992     cmd_Seek(ts, 8);
1993     cmd_AddParm(ts, "-wait", CMD_FLAG, CMD_OPTIONAL,
1994                 "wait for process to stop");
1995     add_std_args(ts);
1996
1997     ts = cmd_CreateSyntax("startup", Startup, 0, "start all processes");
1998     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
1999     cmd_AddParm(ts, "-instance", CMD_LIST, CMD_OPTIONAL, "instances");
2000     add_std_args(ts);
2001
2002     ts = cmd_CreateSyntax("restart", Restart, 0, "restart processes");
2003     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2004     cmd_AddParm(ts, "-instance", CMD_LIST, CMD_OPTIONAL, "instances");
2005     cmd_AddParm(ts, "-bosserver", CMD_FLAG, CMD_OPTIONAL,
2006                 "restart bosserver");
2007     cmd_AddParm(ts, "-all", CMD_FLAG, CMD_OPTIONAL, "restart all processes");
2008     add_std_args(ts);
2009
2010 #ifndef OPBOS
2011
2012     ts = cmd_CreateSyntax("create", CreateServer, 0,
2013                           "create a new server instance");
2014     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2015     cmd_AddParm(ts, "-instance", CMD_SINGLE, 0, "server process name");
2016     cmd_AddParm(ts, "-type", CMD_SINGLE, 0, "server type");
2017     cmd_AddParm(ts, "-cmd", CMD_LIST, 0, "command lines");
2018     cmd_AddParm(ts, "-notifier", CMD_SINGLE, CMD_OPTIONAL,
2019                 "Notifier program");
2020     add_std_args(ts);
2021
2022     ts = cmd_CreateSyntax("delete", DeleteServer, 0,
2023                           "delete a server instance");
2024     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2025     cmd_AddParm(ts, "-instance", CMD_LIST, 0, "server process name");
2026     add_std_args(ts);
2027
2028     ts = cmd_CreateSyntax("adduser", AddSUser, 0,
2029                           "add users to super-user list");
2030     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2031     cmd_AddParm(ts, "-user", CMD_LIST, 0, "user names");
2032     add_std_args(ts);
2033
2034     ts = cmd_CreateSyntax("removeuser", RemoveSUser, 0,
2035                           "remove users from super-user list");
2036     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2037     cmd_AddParm(ts, "-user", CMD_LIST, 0, "user names");
2038     add_std_args(ts);
2039
2040     ts = cmd_CreateSyntax("listusers", ListSUsers, 0, "list super-users");
2041     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2042     add_std_args(ts);
2043
2044     ts = cmd_CreateSyntax("addkey", AddKey, 0,
2045                           "add keys to key dbase (kvno 999 is bcrypt)");
2046     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2047     cmd_AddParm(ts, "-key", CMD_SINGLE, CMD_OPTIONAL, "key");
2048     cmd_AddParm(ts, "-kvno", CMD_SINGLE, 0, "key version number");
2049     add_std_args(ts);
2050
2051     ts = cmd_CreateSyntax("removekey", RemoveKey, 0,
2052                           "remove keys from key dbase");
2053     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2054     cmd_AddParm(ts, "-kvno", CMD_LIST, 0, "key version number");
2055     add_std_args(ts);
2056
2057     ts = cmd_CreateSyntax("listkeys", ListKeys, 0, "list keys");
2058     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2059     cmd_AddParm(ts, "-showkey", CMD_FLAG, CMD_OPTIONAL,
2060                 "show the actual key rather than the checksum");
2061     add_std_args(ts);
2062
2063     ts = cmd_CreateSyntax("listhosts", ListHosts, 0, "get cell host list");
2064     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2065     add_std_args(ts);
2066     cmd_CreateAlias(ts, "getcell");
2067
2068     ts = cmd_CreateSyntax("setcellname", SetCellName, 0, "set cell name");
2069     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2070     cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "cell name");
2071     add_std_args(ts);
2072
2073     ts = cmd_CreateSyntax("addhost", AddHost, 0, "add host to cell dbase");
2074     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2075     cmd_AddParm(ts, "-host", CMD_LIST, 0, "host name");
2076     cmd_AddParm(ts, "-clone", CMD_FLAG, CMD_OPTIONAL, "vote doesn't count");
2077     add_std_args(ts);
2078
2079     ts = cmd_CreateSyntax("removehost", RemoveHost, 0,
2080                           "remove host from cell dbase");
2081     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2082     cmd_AddParm(ts, "-host", CMD_LIST, 0, "host name");
2083     add_std_args(ts);
2084
2085     ts = cmd_CreateSyntax("setauth", SetAuth, 0,
2086                           "set authentication required flag");
2087     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2088     cmd_AddParm(ts, "-authrequired", CMD_SINGLE, 0,
2089                 "on or off: authentication required for admin requests");
2090     add_std_args(ts);
2091
2092     ts = cmd_CreateSyntax("install", Install, 0, "install program");
2093     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2094     cmd_AddParm(ts, "-file", CMD_LIST, 0, "files to install");
2095     cmd_AddParm(ts, "-dir", CMD_SINGLE, CMD_OPTIONAL, "destination dir");
2096     add_std_args(ts);
2097
2098     ts = cmd_CreateSyntax("uninstall", UnInstall, 0, "uninstall program");
2099     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2100     cmd_AddParm(ts, "-file", CMD_LIST, 0, "files to uninstall");
2101     cmd_AddParm(ts, "-dir", CMD_SINGLE, CMD_OPTIONAL, "destination dir");
2102     add_std_args(ts);
2103
2104     ts = cmd_CreateSyntax("getlog", GetLogCmd, 0, "examine log file");
2105     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2106     cmd_AddParm(ts, "-file", CMD_SINGLE, 0, "log file to examine");
2107     add_std_args(ts);
2108
2109     ts = cmd_CreateSyntax("getdate", GetDate, 0, "get dates for programs");
2110     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2111     cmd_AddParm(ts, "-file", CMD_LIST, 0, "files to check");
2112     cmd_AddParm(ts, "-dir", CMD_SINGLE, CMD_OPTIONAL, "destination dir");
2113     add_std_args(ts);
2114
2115     ts = cmd_CreateSyntax("exec", Exec, 0, "execute shell command on server");
2116     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2117     cmd_AddParm(ts, "-cmd", CMD_SINGLE, 0, "command to execute");
2118     add_std_args(ts);
2119
2120     ts = cmd_CreateSyntax("prune", Prune, 0, "prune server files");
2121     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2122     cmd_AddParm(ts, "-bak", CMD_FLAG, CMD_OPTIONAL, "delete .BAK files");
2123     cmd_AddParm(ts, "-old", CMD_FLAG, CMD_OPTIONAL, "delete .OLD files");
2124     cmd_AddParm(ts, "-core", CMD_FLAG, CMD_OPTIONAL, "delete core files");
2125     cmd_AddParm(ts, "-all", CMD_FLAG, CMD_OPTIONAL, "delete all junk files");
2126     add_std_args(ts);
2127
2128     ts = cmd_CreateSyntax("setrestart", SetRestartCmd, 0,
2129                           "set restart times");
2130     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "machine name");
2131     cmd_AddParm(ts, "-time", CMD_SINGLE, CMD_REQUIRED,
2132                 "time to restart server");
2133     cmd_AddParm(ts, "-general", CMD_FLAG, CMD_OPTIONAL,
2134                 "set general restart time");
2135     cmd_AddParm(ts, "-newbinary", CMD_FLAG, CMD_OPTIONAL,
2136                 "set new binary restart time");
2137     add_std_args(ts);
2138
2139     ts = cmd_CreateSyntax("getrestart", GetRestartCmd, 0,
2140                           "get restart times");
2141     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "machine name");
2142     add_std_args(ts);
2143
2144     ts = cmd_CreateSyntax("salvage", SalvageCmd, 0,
2145                           "salvage partition or volumes");
2146     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2147     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
2148                 "salvage partition");
2149     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_OPTIONAL,
2150                 "salvage volume number or volume name");
2151     cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_OPTIONAL,
2152                 "salvage log output file");
2153     cmd_AddParm(ts, "-all", CMD_FLAG, CMD_OPTIONAL, "salvage whole server");
2154     cmd_AddParm(ts, "-showlog", CMD_FLAG, CMD_OPTIONAL,
2155                 "display salvage log");
2156     cmd_AddParm(ts, "-parallel", CMD_SINGLE, CMD_OPTIONAL,
2157                 "# of max parallel partition salvaging");
2158     cmd_AddParm(ts, "-tmpdir", CMD_SINGLE, CMD_OPTIONAL,
2159                 "directory to place tmp files");
2160     cmd_AddParm(ts, "-orphans", CMD_SINGLE, CMD_OPTIONAL,
2161                 "ignore | remove | attach");
2162     cmd_AddParm(ts, "-debug", CMD_FLAG, CMD_OPTIONAL,
2163                 "(MR-AFS) Run in Debugging mode");
2164     cmd_AddParm(ts, "-nowrite", CMD_FLAG, CMD_OPTIONAL,
2165                 "(MR-AFS) Run readonly/test mode");
2166     cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL,
2167                 "(MR-AFS) Force full salvaging");
2168     cmd_AddParm(ts, "-oktozap", CMD_FLAG, CMD_OPTIONAL,
2169                 "(MR-AFS) Give permission to destroy bogus file residencies/volumes - debugging flag");
2170     cmd_AddParm(ts, "-rootfiles", CMD_FLAG, CMD_OPTIONAL,
2171                 "(MR-AFS) Show files owned by root - debugging flag");
2172     cmd_AddParm(ts, "-salvagedirs", CMD_FLAG, CMD_OPTIONAL,
2173                 "(MR-AFS) Force rebuild/salvage of all directories");
2174     cmd_AddParm(ts, "-blockreads", CMD_FLAG, CMD_OPTIONAL,
2175                 "(MR-AFS) Read smaller blocks to handle IO/bad blocks");
2176     cmd_AddParm(ts, "-ListResidencies", CMD_FLAG, CMD_OPTIONAL,
2177                 "(MR-AFS) Just list affected file residencies - debugging flag");
2178     cmd_AddParm(ts, "-SalvageRemote", CMD_FLAG, CMD_OPTIONAL,
2179                 "(MR-AFS) Salvage storage systems that are not directly attached");
2180     cmd_AddParm(ts, "-SalvageArchival", CMD_FLAG, CMD_OPTIONAL,
2181                 "(MR-AFS) Salvage HSM storage systems");
2182     cmd_AddParm(ts, "-IgnoreCheck", CMD_FLAG, CMD_OPTIONAL,
2183                 "(MR-AFS) Don't perform VLDB safety check when deleting unreferenced files.  Only a good idea in single server cell.");
2184     cmd_AddParm(ts, "-ForceOnLine", CMD_FLAG, CMD_OPTIONAL,
2185                 "(MR-AFS) Force the volume to come online, even if it hasn't salvaged cleanly.");
2186     cmd_AddParm(ts, "-UseRootDirACL", CMD_FLAG, CMD_OPTIONAL,
2187                 "(MR-AFS) Use the root directory ACL for lost+found directory if it is created.");
2188     cmd_AddParm(ts, "-TraceBadLinkCounts", CMD_FLAG, CMD_OPTIONAL,
2189                 "(MR-AFS) Print out lines about volume reference count changes.");
2190     cmd_AddParm(ts, "-DontAskFS", CMD_FLAG, CMD_OPTIONAL,
2191                 "(MR-AFS) Don't ask fileserver to take volume offline.  THIS IS VERY DANGEROUS.");
2192     cmd_AddParm(ts, "-LogLevel", CMD_SINGLE, CMD_OPTIONAL,
2193                 "(MR-AFS) log level");
2194     cmd_AddParm(ts, "-rxdebug", CMD_FLAG, CMD_OPTIONAL,
2195                 "(MR-AFS) Write out rx debug information.");
2196     cmd_AddParm(ts, "-Residencies", CMD_SINGLE, CMD_OPTIONAL,
2197                 "(MR-AFS) Numeric mask of residencies to be included in the salvage.  Do not use with -SalvageRemote or -SalvageArchival");
2198     add_std_args(ts);
2199
2200     ts = cmd_CreateSyntax("blockscanner", BlockScannerCmd, 0,
2201                           "block scanner daemon from making migration requests");
2202     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "machine name");
2203     add_std_args(ts);
2204
2205     ts = cmd_CreateSyntax("unblockscanner", UnBlockScannerCmd, 0,
2206                           "allow scanner daemon to make migration requests again");
2207     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "machine name");
2208     add_std_args(ts);
2209
2210 #ifdef BOS_RESTRICTED_MODE
2211     ts = cmd_CreateSyntax("getrestricted", GetRestrict, 0,
2212                           "get restrict mode");
2213     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2214     add_std_args(ts);
2215
2216     ts = cmd_CreateSyntax("setrestricted", SetRestrict, 0,
2217                           "set restrict mode");
2218     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2219     cmd_AddParm(ts, "-mode", CMD_SINGLE, 0, "mode to set");
2220     add_std_args(ts);
2221 #endif
2222 #endif
2223
2224     code = cmd_Dispatch(argc, argv);
2225     rx_Finalize();
2226     exit(code);
2227 }