src/libadmin/test/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 /*
  11  * This file implements the bos related funtions for afscp
  12  */
  13
  14 #include <afsconfig.h>
  15 #include <afs/param.h>
  16
  17 #include <roken.h>
  18
  19 #include <ctype.h>
  20
  21 #include "bos.h"
  22
  23 /*
  24  * Utility functions
  25  */
  26
  27 /*
  28  * Generic fuction for converting input string to an integer.  Pass
  29  * the error_msg you want displayed if there is an error converting
  30  * the string.
  31  */
  32
  33 static int
  34 GetIntFromString(const char *int_str, const char *error_msg)
  35 {
  36     int i;
  37     char *bad_char = NULL;
  38
  39     i = strtoul(int_str, &bad_char, 10);
  40     if ((bad_char == NULL) || (*bad_char == 0)) {
  41         return i;
  42     }
  43
  44     ERR_EXT(error_msg);
  45 }
  46
  47 /*
  48  * Functions for reading and displaying bos restart times.  These are copied
  49  * from util/ktime.c and changed to handle the bos types.
  50  */
  51
  52 struct token {
  53     struct token *next;
  54     char *key;
  55 };
  56
  57 static char *day[] = {
  58     "sun",
  59     "mon",
  60     "tue",
  61     "wed",
  62     "thu",
  63     "fri",
  64     "sat"
  65 };
  66
  67 static int
  68 LocalFreeTokens(struct token *alist)
  69 {
  70     struct token *nlist;
  71     for (; alist; alist = nlist) {
  72         nlist = alist->next;
  73         free(alist->key);
  74         free(alist);
  75     }
  76     return 0;
  77 }
  78
  79 static int
  80 space(int x)
  81 {
  82     if (x == 0 || x == ' ' || x == '\t' || x == '\n')
  83         return 1;
  84     else
  85         return 0;
  86 }
  87
  88 static int
  89 LocalParseLine(char *aline, struct token **alist)
  90 {
  91     char tbuffer[256];
  92     char *tptr = NULL;
  93     int inToken;
  94     struct token *first, *last;
  95     struct token *ttok;
  96     int tc;
  97
  98     inToken = 0;                /* not copying token chars at start */
  99     first = NULL;
 100     last = NULL;
 101     while (1) {
 102         tc = *aline++;
 103         if (tc == 0 || space(tc)) {
 104             if (inToken) {
 105                 inToken = 0;    /* end of this token */
 106                 *tptr++ = 0;
 107                 ttok = malloc(sizeof(struct token));
 108                 ttok->next = NULL;
 109                 ttok->key = strdup(tbuffer);
 110                 if (last) {
 111                     last->next = ttok;
 112                     last = ttok;
 113                 } else
 114                     last = ttok;
 115                 if (!first)
 116                     first = ttok;
 117             }
 118         } else {
 119             /* an alpha character */
 120             if (!inToken) {
 121                 tptr = tbuffer;
 122                 inToken = 1;
 123             }
 124             if (tptr - tbuffer >= sizeof(tbuffer))
 125                 return -1;
 126             *tptr++ = tc;
 127         }
 128         if (tc == 0) {
 129             /* last token flushed 'cause space(0) --> true */
 130             if (last)
 131                 last->next = NULL;
 132             *alist = first;
 133             return 0;
 134         }
 135     }
 136 }
 137
 138 /* keyword database for periodic date parsing */
 139 static struct ptemp {
 140     char *key;
 141     afs_int32 value;
 142 } ptkeys[] = {
 143         {"sun", 0x10000}, {"mon", 0x10001}, {"tue", 0x10002},
 144         {"wed", 0x10003}, {"thu", 0x10004}, {"fri", 0x10005},
 145         {"sat", 0x10006},
 146         {"sunday", 0x10000}, {"monday", 0x10001},
 147         {"tuesday", 0x10002}, {"wednesday", 0x10003},
 148         {"thursday", 0x10004}, {"thur", 0x10004},
 149         {"friday", 0x10005}, {"saturday", 0x10006},
 150         {"am", 0x20000}, {"pm", 0x20001},
 151         {"a.m.", 0x20000}, {"p.m.", 0x20001}, {0, 0}};
 152
 153 static int
 154 ParseTime(bos_RestartTime_p ak, char *astr)
 155 {
 156     int field;
 157     short temp;
 158     char *tp;
 159     int tc;
 160
 161     field = 0;                  /* 0=hour, 1=min, 2=sec */
 162     temp = 0;
 163
 164     ak->mask |=
 165         (BOS_RESTART_TIME_HOUR | BOS_RESTART_TIME_MINUTE |
 166          BOS_RESTART_TIME_SECOND);
 167     for (tp = astr;;) {
 168         tc = *tp++;
 169         if (tc == 0 || tc == ':') {
 170             if (field == 0)
 171                 ak->hour = temp;
 172             else if (field == 1)
 173                 ak->min = temp;
 174             else if (field == 2)
 175                 ak->sec = temp;
 176             temp = 0;
 177             field++;
 178             if (tc == 0)
 179                 break;
 180             continue;
 181         } else if (!isdigit(tc))
 182             return -1;          /* syntax error */
 183         else {
 184             /* digit */
 185             temp *= 10;
 186             temp += tc - '0';
 187         }
 188     }
 189     if (ak->hour >= 24 || ak->min >= 60 || ak->sec >= 60)
 190         return -1;
 191     return 0;
 192 }
 193
 194 int
 195 ktime_ParsePeriodic(char *adate, bos_RestartTime_p ak)
 196 {
 197     struct token *tt;
 198     afs_int32 code;
 199     struct ptemp *tp;
 200
 201     memset(ak, 0, sizeof(*ak));
 202     code = LocalParseLine(adate, &tt);
 203     if (code)
 204         return -1;
 205     for (; tt; tt = tt->next) {
 206         /* look at each token */
 207         if (strcmp(tt->key, "now") == 0) {
 208             ak->mask |= BOS_RESTART_TIME_NOW;
 209             LocalFreeTokens(tt);
 210             return 0;
 211         }
 212         if (strcmp(tt->key, "never") == 0) {
 213             ak->mask |= BOS_RESTART_TIME_NEVER;
 214             LocalFreeTokens(tt);
 215             return 0;
 216         }
 217         if (strcmp(tt->key, "at") == 0)
 218             continue;
 219         if (strcmp(tt->key, "every") == 0)
 220             continue;
 221         if (isdigit(tt->key[0])) {
 222             /* parse a time */
 223             code = ParseTime(ak, tt->key);
 224             if (code) {
 225                 LocalFreeTokens(tt);
 226                 return -1;
 227             }
 228             continue;
 229         }
 230         /* otherwise use keyword table */
 231         for (tp = ptkeys;; tp++) {
 232             if (tp->key == NULL) {
 233                 LocalFreeTokens(tt);
 234                 return -1;
 235             }
 236             if (strcmp(tp->key, tt->key) == 0)
 237                 break;
 238         }
 239         /* now look at tp->value to see what we've got */
 240         if ((tp->value >> 16) == 1) {
 241             /* a day */
 242             ak->mask |= BOS_RESTART_TIME_DAY;
 243             ak->day = tp->value & 0xff;
 244         }
 245         if ((tp->value >> 16) == 2) {
 246             /* am or pm token */
 247             if ((tp->value & 0xff) == 1) {
 248                 /* pm */
 249                 if (!(ak->mask & BOS_RESTART_TIME_HOUR))
 250                     return -1;
 251                 if (ak->hour < 12)
 252                     ak->hour += 12;
 253                 /* 12 is 12 PM */
 254                 else if (ak->hour != 12) {
 255                     LocalFreeTokens(tt);
 256                     return -1;
 257                 }
 258             } else {
 259                 /* am is almost a noop, except that we map 12:01 am to 0:01 */
 260                 if (ak->hour > 12) {
 261                     LocalFreeTokens(tt);
 262                     return -1;
 263                 }
 264                 if (ak->hour == 12)
 265                     ak->hour = 0;
 266             }
 267         }
 268     }
 269     LocalFreeTokens(tt);
 270     return 0;
 271 }
 272
 273 int
 274 DoBosProcessCreate(struct cmd_syndesc *as, void *arock)
 275 {
 276     enum { SERVER, PROCESS, BINARY, CRON, CRONTIME,
 277         NOTIFIER
 278     };
 279     afs_status_t st = 0;
 280     void *bos_server = NULL;
 281     const char *process = NULL;
 282     bos_ProcessType_t process_type = BOS_PROCESS_SIMPLE;
 283     const char *binary = NULL;
 284     int is_cron = 0;
 285     const char *cron_time = NULL;
 286     int has_cron_time = 0;
 287     const char *notifier = NULL;
 288
 289     if (as->parms[SERVER].items) {
 290         if (!bos_ServerOpen
 291             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 292             ERR_ST_EXT("bos_ServerOpen", st);
 293         }
 294     }
 295
 296     if (as->parms[PROCESS].items) {
 297         process = as->parms[PROCESS].items->data;
 298     }
 299
 300     if (as->parms[BINARY].items) {
 301         binary = as->parms[BINARY].items->data;
 302     }
 303
 304     if (as->parms[CRON].items) {
 305         is_cron = 1;
 306         process_type = BOS_PROCESS_CRON;
 307     }
 308
 309     if (as->parms[CRONTIME].items) {
 310         cron_time = as->parms[CRONTIME].items->data;
 311         has_cron_time = 1;
 312     }
 313
 314     if (is_cron) {
 315         if (!has_cron_time) {
 316             ERR_EXT("must specify cron time when creating a cron process");
 317         }
 318     } else {
 319         if (has_cron_time) {
 320             ERR_EXT("cron time is meaningless for non cron process");
 321         }
 322     }
 323
 324     if (as->parms[NOTIFIER].items) {
 325         notifier = as->parms[NOTIFIER].items->data;
 326     }
 327
 328     if (!bos_ProcessCreate
 329         (bos_server, (char *)process, process_type, (char *)binary, (char *)cron_time, (char *)notifier,
 330          &st)) {
 331         ERR_ST_EXT("bos_ProcessCreate", st);
 332     }
 333
 334     bos_ServerClose(bos_server, 0);
 335
 336     return 0;
 337 }
 338
 339 int
 340 DoBosFSProcessCreate(struct cmd_syndesc *as, void *arock)
 341 {
 342     enum { SERVER, PROCESS, FILESERVER, VOLSERVER, SALVAGER,
 343         NOTIFIER
 344     };
 345     afs_status_t st = 0;
 346     void *bos_server = NULL;
 347     const char *process = NULL;
 348     const char *fileserver = NULL;
 349     const char *volserver = NULL;
 350     const char *salvager = NULL;
 351     const char *notifier = NULL;
 352
 353     if (as->parms[SERVER].items) {
 354         if (!bos_ServerOpen
 355             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 356             ERR_ST_EXT("bos_ServerOpen", st);
 357         }
 358     }
 359
 360     if (as->parms[PROCESS].items) {
 361         process = as->parms[PROCESS].items->data;
 362     }
 363
 364     if (as->parms[FILESERVER].items) {
 365         fileserver = as->parms[FILESERVER].items->data;
 366     }
 367
 368     if (as->parms[VOLSERVER].items) {
 369         volserver = as->parms[VOLSERVER].items->data;
 370     }
 371
 372     if (as->parms[SALVAGER].items) {
 373         salvager = as->parms[SALVAGER].items->data;
 374     }
 375
 376     if (as->parms[NOTIFIER].items) {
 377         notifier = as->parms[NOTIFIER].items->data;
 378     }
 379
 380     if (!bos_FSProcessCreate
 381         (bos_server, (char *)process, (char *)fileserver, (char *)volserver, (char *)salvager, (char *)notifier,
 382          &st)) {
 383         ERR_ST_EXT("bos_FSProcessCreate", st);
 384     }
 385
 386     bos_ServerClose(bos_server, 0);
 387
 388     return 0;
 389 }
 390
 391 int
 392 DoBosProcessDelete(struct cmd_syndesc *as, void *arock)
 393 {
 394     enum { SERVER, PROCESS };
 395     afs_status_t st = 0;
 396     void *bos_server = NULL;
 397     const char *process = NULL;
 398
 399     if (as->parms[SERVER].items) {
 400         if (!bos_ServerOpen
 401             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 402             ERR_ST_EXT("bos_ServerOpen", st);
 403         }
 404     }
 405
 406     if (as->parms[PROCESS].items) {
 407         process = as->parms[PROCESS].items->data;
 408     }
 409
 410     if (!bos_ProcessDelete(bos_server, (char *)process, &st)) {
 411         ERR_ST_EXT("bos_ProcessDelete", st);
 412     }
 413
 414     bos_ServerClose(bos_server, 0);
 415
 416     return 0;
 417 }
 418
 419 static void
 420 Print_bos_ProcessExecutionState_p(bos_ProcessExecutionState_p state,
 421                                   const char *prefix)
 422 {
 423     printf("%sThe process executation state is: ", prefix);
 424     switch (*state) {
 425     case BOS_PROCESS_STOPPED:
 426         printf("stopped\n");
 427         break;
 428     case BOS_PROCESS_RUNNING:
 429         printf("running\n");
 430         break;
 431     case BOS_PROCESS_STOPPING:
 432         printf("stopping\n");
 433         break;
 434     case BOS_PROCESS_STARTING:
 435         printf("starting\n");
 436         break;
 437     }
 438 }
 439
 440 int
 441 DoBosProcessExecutionStateGet(struct cmd_syndesc *as, void *arock)
 442 {
 443     enum { SERVER, PROCESS };
 444     afs_status_t st = 0;
 445     void *bos_server = NULL;
 446     const char *process = NULL;
 447     bos_ProcessExecutionState_t state;
 448     char aux_status[BOS_MAX_NAME_LEN];
 449
 450     if (as->parms[SERVER].items) {
 451         if (!bos_ServerOpen
 452             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 453             ERR_ST_EXT("bos_ServerOpen", st);
 454         }
 455     }
 456
 457     if (as->parms[PROCESS].items) {
 458         process = as->parms[PROCESS].items->data;
 459     }
 460
 461     if (!bos_ProcessExecutionStateGet
 462         (bos_server, (char *)process, &state, aux_status, &st)) {
 463         ERR_ST_EXT("bos_ProcessExecutionStateGet", st);
 464     }
 465
 466     Print_bos_ProcessExecutionState_p(&state, "");
 467     if (aux_status[0] != 0) {
 468         printf("Aux process status: %s\n", aux_status);
 469     }
 470
 471     bos_ServerClose(bos_server, 0);
 472
 473     return 0;
 474 }
 475
 476 int
 477 DoBosProcessExecutionStateSet(struct cmd_syndesc *as, void *arock)
 478 {
 479     enum { SERVER, PROCESS, STOPPED,
 480         RUNNING
 481     };
 482     afs_status_t st = 0;
 483     void *bos_server = NULL;
 484     const char *process = NULL;
 485     int stop = 0;
 486     int run = 0;
 487     bos_ProcessExecutionState_t state = 0;
 488
 489     if (as->parms[SERVER].items) {
 490         if (!bos_ServerOpen
 491             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 492             ERR_ST_EXT("bos_ServerOpen", st);
 493         }
 494     }
 495
 496     if (as->parms[PROCESS].items) {
 497         process = as->parms[PROCESS].items->data;
 498     }
 499
 500     if (as->parms[STOPPED].items) {
 501         stop = 1;
 502         state = BOS_PROCESS_STOPPED;
 503     }
 504
 505     if (as->parms[RUNNING].items) {
 506         run = 1;
 507         state = BOS_PROCESS_RUNNING;
 508     }
 509
 510     if ((stop == 1) && (run == 1)) {
 511         ERR_EXT("you must specify either running or stopped, but not both");
 512     }
 513
 514     if ((stop == 0) && (run == 0)) {
 515         ERR_EXT("you must specify either running or stopped");
 516     }
 517
 518     if (!bos_ProcessExecutionStateSet(bos_server, process, state, &st)) {
 519         ERR_ST_EXT("bos_ProcessExecutionStateSet", st);
 520     }
 521
 522     bos_ServerClose(bos_server, 0);
 523
 524     return 0;
 525 }
 526
 527 int
 528 DoBosProcessExecutionStateSetTemporary(struct cmd_syndesc *as, void *arock)
 529 {
 530     enum { SERVER, PROCESS, STOPPED,
 531         RUNNING
 532     };
 533     afs_status_t st = 0;
 534     void *bos_server = NULL;
 535     const char *process = NULL;
 536     int stop = 0;
 537     int run = 0;
 538     bos_ProcessExecutionState_t state = 0;
 539
 540     if (as->parms[SERVER].items) {
 541         if (!bos_ServerOpen
 542             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 543             ERR_ST_EXT("bos_ServerOpen", st);
 544         }
 545     }
 546
 547     if (as->parms[PROCESS].items) {
 548         process = as->parms[PROCESS].items->data;
 549     }
 550
 551     if (as->parms[STOPPED].items) {
 552         stop = 1;
 553         state = BOS_PROCESS_STOPPED;
 554     }
 555
 556     if (as->parms[RUNNING].items) {
 557         run = 1;
 558         state = BOS_PROCESS_RUNNING;
 559     }
 560
 561     if ((stop == 1) && (run == 1)) {
 562         ERR_EXT("you must specify either running or stopped, but not both");
 563     }
 564
 565     if ((stop == 0) && (run == 0)) {
 566         ERR_EXT("you must specify either running or stopped");
 567     }
 568
 569     if (!bos_ProcessExecutionStateSetTemporary
 570         (bos_server, (char *)process, state, &st)) {
 571         ERR_ST_EXT("bos_ProcessExecutionStateSetTemporary", st);
 572     }
 573
 574     bos_ServerClose(bos_server, 0);
 575
 576     return 0;
 577 }
 578
 579 int
 580 DoBosProcessNameList(struct cmd_syndesc *as, void *arock)
 581 {
 582     enum { SERVER };
 583     afs_status_t st = 0;
 584     void *bos_server = NULL;
 585     void *iter = NULL;
 586     char process[BOS_MAX_NAME_LEN];
 587
 588     if (as->parms[SERVER].items) {
 589         if (!bos_ServerOpen
 590             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 591             ERR_ST_EXT("bos_ServerOpen", st);
 592         }
 593     }
 594
 595     if (!bos_ProcessNameGetBegin(bos_server, &iter, &st)) {
 596         ERR_ST_EXT("bos_ProcessNameGetBegin", st);
 597     }
 598
 599     printf("Listing processes at server %s:\n",
 600            as->parms[SERVER].items->data);
 601
 602     while (bos_ProcessNameGetNext(iter, process, &st)) {
 603         printf("\t%s\n", process);
 604     }
 605
 606     if (st != ADMITERATORDONE) {
 607         ERR_ST_EXT("bos_ProcessNameGetNext", st);
 608     }
 609
 610     if (!bos_ProcessNameGetDone(iter, &st)) {
 611         ERR_ST_EXT("bos_ProcessNameGetDone", st);
 612     }
 613
 614     return 0;
 615 }
 616
 617 static void
 618 Print_bos_ProcessType_p(bos_ProcessType_p type, const char *prefix)
 619 {
 620     printf("%sProcess type: \n", prefix);
 621     switch (*type) {
 622     case BOS_PROCESS_SIMPLE:
 623         printf("simple\n");
 624         break;
 625     case BOS_PROCESS_FS:
 626         printf("fs\n");
 627         break;
 628     case BOS_PROCESS_CRON:
 629         printf("cron\n");
 630         break;
 631     }
 632 }
 633
 634 static void
 635 Print_bos_ProcessState_p(bos_ProcessState_p state, const char *prefix)
 636 {
 637     printf("%sProcess state:\n", prefix);
 638     /* FIXME: BOS_PROCESS_OK is 0, so this test is not right */
 639     if (*state & BOS_PROCESS_OK) {
 640         printf("%s\tBOS_PROCESS_OK:\n", prefix);
 641     }
 642     if (*state & BOS_PROCESS_CORE_DUMPED) {
 643         printf("%s\tBOS_PROCESS_CORE_DUMPED:\n", prefix);
 644     }
 645     if (*state & BOS_PROCESS_TOO_MANY_ERRORS) {
 646         printf("%s\tBOS_PROCESS_TOO_MANY_ERRORS:\n", prefix);
 647     }
 648     if (*state & BOS_PROCESS_BAD_FILE_ACCESS) {
 649         printf("%s\tBOS_PROCESS_BAD_FILE_ACCESS:\n", prefix);
 650     }
 651 }
 652
 653 static void
 654 Print_bos_ProcessInfo_p(bos_ProcessInfo_p info, const char *prefix)
 655 {
 656     Print_bos_ProcessExecutionState_p(&info->processGoal, prefix);
 657     printf("%sStart time %lu\n", prefix, info->processStartTime);
 658     printf("%sNumber of process starts %lu \n", prefix,
 659            info->numberProcessStarts);
 660     printf("%sProcess exit time %lu\n", prefix, info->processExitTime);
 661     printf("%sProcess exit error time %lu\n", prefix,
 662            info->processExitErrorTime);
 663     printf("%sProcess error code %lu\n", prefix, info->processErrorCode);
 664     printf("%sProcess error signal %lu\n", prefix, info->processErrorSignal);
 665     Print_bos_ProcessState_p(&info->state, prefix);
 666 }
 667
 668 int
 669 DoBosProcessInfoGet(struct cmd_syndesc *as, void *arock)
 670 {
 671     enum { SERVER, PROCESS };
 672     afs_status_t st = 0;
 673     void *bos_server = NULL;
 674     const char *process = NULL;
 675     bos_ProcessType_t type;
 676     bos_ProcessInfo_t info;
 677
 678     if (as->parms[SERVER].items) {
 679         if (!bos_ServerOpen
 680             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 681             ERR_ST_EXT("bos_ServerOpen", st);
 682         }
 683     }
 684
 685     if (as->parms[PROCESS].items) {
 686         process = as->parms[PROCESS].items->data;
 687     }
 688
 689     if (!bos_ProcessInfoGet(bos_server, (char *)process, &type, &info, &st)) {
 690         ERR_ST_EXT("bos_ProcessInfoGet", st);
 691     }
 692
 693     Print_bos_ProcessType_p(&type, "");
 694     Print_bos_ProcessInfo_p(&info, "");
 695
 696     return 0;
 697 }
 698
 699 int
 700 DoBosProcessParameterList(struct cmd_syndesc *as, void *arock)
 701 {
 702     enum { SERVER, PROCESS };
 703     afs_status_t st = 0;
 704     void *bos_server = NULL;
 705     char *process = NULL;
 706     void *iter = NULL;
 707     char parameter[BOS_MAX_NAME_LEN];
 708
 709     if (as->parms[SERVER].items) {
 710         if (!bos_ServerOpen
 711             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 712             ERR_ST_EXT("bos_ServerOpen", st);
 713         }
 714     }
 715
 716     if (as->parms[PROCESS].items) {
 717         process = as->parms[PROCESS].items->data;
 718     }
 719
 720     if (!bos_ProcessParameterGetBegin(bos_server, process, &iter, &st)) {
 721         ERR_ST_EXT("bos_ProcessParameterGetBegin", st);
 722     }
 723
 724     printf("Getting parameters for %s\n", process);
 725
 726     while (bos_ProcessParameterGetNext(iter, parameter, &st)) {
 727         printf("\t%s\n", parameter);
 728     }
 729
 730     if (st != ADMITERATORDONE) {
 731         ERR_ST_EXT("bos_ProcessParameterGetNext", st);
 732     }
 733
 734     if (!bos_ProcessParameterGetDone(iter, &st)) {
 735         ERR_ST_EXT("bos_ProcessParameterGetDone", st);
 736     }
 737
 738     bos_ServerClose(bos_server, 0);
 739
 740     return 0;
 741 }
 742
 743 int
 744 DoBosProcessNotifierGet(struct cmd_syndesc *as, void *arock)
 745 {
 746     enum { SERVER, PROCESS };
 747     afs_status_t st = 0;
 748     void *bos_server = NULL;
 749     const char *process = NULL;
 750     char notifier[BOS_MAX_NAME_LEN];
 751
 752     if (as->parms[SERVER].items) {
 753         if (!bos_ServerOpen
 754             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 755             ERR_ST_EXT("bos_ServerOpen", st);
 756         }
 757     }
 758
 759     if (as->parms[PROCESS].items) {
 760         process = as->parms[PROCESS].items->data;
 761     }
 762
 763     if (!bos_ProcessNotifierGet(bos_server, process, notifier, &st)) {
 764         ERR_ST_EXT("bos_ProcessNotifierGet", st);
 765     }
 766
 767     if (notifier[0] == 0) {
 768         printf("%s does not have a notifier.\n", process);
 769     } else {
 770         printf("The notifier for %s is %s\n", process, notifier);
 771     }
 772
 773     bos_ServerClose(bos_server, 0);
 774
 775     return 0;
 776 }
 777
 778 int
 779 DoBosProcessRestart(struct cmd_syndesc *as, void *arock)
 780 {
 781     enum { SERVER, PROCESS };
 782     afs_status_t st = 0;
 783     void *bos_server = NULL;
 784     const char *process = NULL;
 785
 786     if (as->parms[SERVER].items) {
 787         if (!bos_ServerOpen
 788             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 789             ERR_ST_EXT("bos_ServerOpen", st);
 790         }
 791     }
 792
 793     if (as->parms[PROCESS].items) {
 794         process = as->parms[PROCESS].items->data;
 795     }
 796
 797     if (!bos_ProcessRestart(bos_server, process, &st)) {
 798         ERR_ST_EXT("bos_ProcessRestart", st);
 799     }
 800
 801     bos_ServerClose(bos_server, 0);
 802
 803     return 0;
 804 }
 805
 806 int
 807 DoBosProcessAllStop(struct cmd_syndesc *as, void *arock)
 808 {
 809     enum { SERVER };
 810     afs_status_t st = 0;
 811     void *bos_server = NULL;
 812
 813     if (as->parms[SERVER].items) {
 814         if (!bos_ServerOpen
 815             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 816             ERR_ST_EXT("bos_ServerOpen", st);
 817         }
 818     }
 819
 820     if (!bos_ProcessAllStop(bos_server, &st)) {
 821         ERR_ST_EXT("bos_ProcessAllStop", st);
 822     }
 823
 824     bos_ServerClose(bos_server, 0);
 825
 826     return 0;
 827 }
 828
 829 int
 830 DoBosProcessAllStart(struct cmd_syndesc *as, void *arock)
 831 {
 832     enum { SERVER };
 833     afs_status_t st = 0;
 834     void *bos_server = NULL;
 835
 836     if (as->parms[SERVER].items) {
 837         if (!bos_ServerOpen
 838             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 839             ERR_ST_EXT("bos_ServerOpen", st);
 840         }
 841     }
 842
 843     if (!bos_ProcessAllStart(bos_server, &st)) {
 844         ERR_ST_EXT("bos_ProcessAllStart", st);
 845     }
 846
 847     bos_ServerClose(bos_server, 0);
 848
 849     return 0;
 850 }
 851
 852 int
 853 DoBosProcessAllWaitStop(struct cmd_syndesc *as, void *arock)
 854 {
 855     enum { SERVER };
 856     afs_status_t st = 0;
 857     void *bos_server = NULL;
 858
 859     if (as->parms[SERVER].items) {
 860         if (!bos_ServerOpen
 861             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 862             ERR_ST_EXT("bos_ServerOpen", st);
 863         }
 864     }
 865
 866     if (!bos_ProcessAllWaitStop(bos_server, &st)) {
 867         ERR_ST_EXT("bos_ProcessAllWaitStop", st);
 868     }
 869
 870     bos_ServerClose(bos_server, 0);
 871
 872     return 0;
 873 }
 874
 875 int
 876 DoBosProcessAllWaitTransition(struct cmd_syndesc *as, void *arock)
 877 {
 878     enum { SERVER };
 879     afs_status_t st = 0;
 880     void *bos_server = NULL;
 881
 882     if (as->parms[SERVER].items) {
 883         if (!bos_ServerOpen
 884             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 885             ERR_ST_EXT("bos_ServerOpen", st);
 886         }
 887     }
 888
 889     if (!bos_ProcessAllWaitTransition(bos_server, &st)) {
 890         ERR_ST_EXT("bos_ProcessAllWaitTransition", st);
 891     }
 892
 893     bos_ServerClose(bos_server, 0);
 894
 895     return 0;
 896 }
 897
 898 int
 899 DoBosProcessAllStopAndRestart(struct cmd_syndesc *as, void *arock)
 900 {
 901     enum { SERVER, INCLUDEBOS };
 902     afs_status_t st = 0;
 903     void *bos_server = NULL;
 904     bos_RestartBosServer_t restart = BOS_DONT_RESTART_BOS_SERVER;
 905
 906     if (as->parms[SERVER].items) {
 907         if (!bos_ServerOpen
 908             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 909             ERR_ST_EXT("bos_ServerOpen", st);
 910         }
 911     }
 912
 913     if (as->parms[INCLUDEBOS].items) {
 914         restart = BOS_RESTART_BOS_SERVER;
 915     }
 916
 917     if (!bos_ProcessAllStopAndRestart(bos_server, restart, &st)) {
 918         ERR_ST_EXT("bos_ProcessAllStopAndRestart", st);
 919     }
 920
 921     bos_ServerClose(bos_server, 0);
 922
 923     return 0;
 924 }
 925
 926 int
 927 DoBosAdminCreate(struct cmd_syndesc *as, void *arock)
 928 {
 929     enum { SERVER, ADMIN };
 930     afs_status_t st = 0;
 931     void *bos_server = NULL;
 932     const char *admin = NULL;
 933
 934     if (as->parms[SERVER].items) {
 935         if (!bos_ServerOpen
 936             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 937             ERR_ST_EXT("bos_ServerOpen", st);
 938         }
 939     }
 940
 941     if (as->parms[ADMIN].items) {
 942         admin = as->parms[ADMIN].items->data;
 943     }
 944
 945     if (!bos_AdminCreate(bos_server, admin, &st)) {
 946         ERR_ST_EXT("bos_AdminCreate", st);
 947     }
 948
 949     bos_ServerClose(bos_server, 0);
 950
 951     return 0;
 952 }
 953
 954 int
 955 DoBosAdminDelete(struct cmd_syndesc *as, void *arock)
 956 {
 957     enum { SERVER, ADMIN };
 958     afs_status_t st = 0;
 959     void *bos_server = NULL;
 960     const char *admin = NULL;
 961
 962     if (as->parms[SERVER].items) {
 963         if (!bos_ServerOpen
 964             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 965             ERR_ST_EXT("bos_ServerOpen", st);
 966         }
 967     }
 968
 969     if (as->parms[ADMIN].items) {
 970         admin = as->parms[ADMIN].items->data;
 971     }
 972
 973     if (!bos_AdminDelete(bos_server, admin, &st)) {
 974         ERR_ST_EXT("bos_AdminDelete", st);
 975     }
 976
 977     bos_ServerClose(bos_server, 0);
 978
 979     return 0;
 980 }
 981
 982 int
 983 DoBosAdminList(struct cmd_syndesc *as, void *arock)
 984 {
 985     enum { SERVER };
 986     afs_status_t st = 0;
 987     void *bos_server = NULL;
 988     void *iter = NULL;
 989     char admin[BOS_MAX_NAME_LEN];
 990
 991     if (as->parms[SERVER].items) {
 992         if (!bos_ServerOpen
 993             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
 994             ERR_ST_EXT("bos_ServerOpen", st);
 995         }
 996     }
 997
 998     if (!bos_AdminGetBegin(bos_server, &iter, &st)) {
 999         ERR_ST_EXT("bos_AdminGetBegin", st);
1000     }
1001
1002     printf("Administrators at %s\n", as->parms[SERVER].items->data);
1003
1004     while (bos_AdminGetNext(iter, admin, &st)) {
1005         printf("%s\n", admin);
1006     }
1007
1008     if (st != ADMITERATORDONE) {
1009         ERR_ST_EXT("bos_AdminGetNext", st);
1010     }
1011
1012     if (!bos_AdminGetDone(iter, &st)) {
1013         ERR_ST_EXT("bos_AdminGetDone", st);
1014     }
1015
1016     bos_ServerClose(bos_server, 0);
1017
1018     return 0;
1019 }
1020
1021 int
1022 DoBosKeyCreate(struct cmd_syndesc *as, void *arock)
1023 {
1024     enum { SERVER, VERSIONNUMBER, KEY };
1025     afs_status_t st = 0;
1026     void *bos_server = NULL;
1027     int version_number = 0;
1028     kas_encryptionKey_t key = { {0, 0, 0, 0, 0, 0, 0, 0} };
1029     const char *cell;
1030
1031     if (as->parms[SERVER].items) {
1032         if (!bos_ServerOpen
1033             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1034             ERR_ST_EXT("bos_ServerOpen", st);
1035         }
1036     }
1037
1038     if (as->parms[VERSIONNUMBER].items) {
1039         version_number =
1040             GetIntFromString(as->parms[VERSIONNUMBER].items->data,
1041                              "invalid version number");
1042     }
1043
1044     if (as->parms[KEY].items) {
1045         const char *str = as->parms[KEY].items->data;
1046         if (!afsclient_CellNameGet(cellHandle, &cell, &st)) {
1047             ERR_ST_EXT("afsclient_CellNameGet", st);
1048         }
1049         if (!kas_StringToKey(cell, str, &key, &st)) {
1050             ERR_ST_EXT("kas_StringToKey", st);
1051         }
1052     }
1053
1054     if (!bos_KeyCreate(bos_server, version_number, &key, &st)) {
1055         ERR_ST_EXT("bos_KeyCreate", st);
1056     }
1057
1058     bos_ServerClose(bos_server, 0);
1059
1060     return 0;
1061 }
1062
1063 int
1064 DoBosKeyDelete(struct cmd_syndesc *as, void *arock)
1065 {
1066     enum { SERVER, VERSIONNUMBER };
1067     afs_status_t st = 0;
1068     void *bos_server = NULL;
1069     int version_number = 0;
1070
1071     if (as->parms[SERVER].items) {
1072         if (!bos_ServerOpen
1073             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1074             ERR_ST_EXT("bos_ServerOpen", st);
1075         }
1076     }
1077
1078     if (as->parms[VERSIONNUMBER].items) {
1079         version_number =
1080             GetIntFromString(as->parms[VERSIONNUMBER].items->data,
1081                              "invalid version number");
1082     }
1083
1084     if (!bos_KeyDelete(bos_server, version_number, &st)) {
1085         ERR_ST_EXT("bos_KeyDelete", st);
1086     }
1087
1088     bos_ServerClose(bos_server, 0);
1089
1090     return 0;
1091 }
1092
1093 static void
1094 Print_bos_KeyInfo_p(bos_KeyInfo_p key, const char *prefix)
1095 {
1096     int i;
1097     printf("%sVersion number: %d\n", prefix, key->keyVersionNumber);
1098     printf("%sLast modification date %d\n", prefix,
1099            key->keyStatus.lastModificationDate);
1100     printf("%sLast modification micro seconds %d\n", prefix,
1101            key->keyStatus.lastModificationMicroSeconds);
1102     printf("%sChecksum %u\n", prefix, key->keyStatus.checkSum);
1103
1104     printf("%sKey: \n", prefix);
1105     for (i = 0; i < KAS_ENCRYPTION_KEY_LEN; i++) {
1106         printf("%s\t%d ", prefix, key->key.key[i]);
1107     }
1108     printf("\n");
1109 }
1110
1111 int
1112 DoBosKeyList(struct cmd_syndesc *as, void *arock)
1113 {
1114     enum { SERVER };
1115     afs_status_t st = 0;
1116     void *bos_server = NULL;
1117     void *iter = NULL;
1118     bos_KeyInfo_t key;
1119
1120     if (as->parms[SERVER].items) {
1121         if (!bos_ServerOpen
1122             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1123             ERR_ST_EXT("bos_ServerOpen", st);
1124         }
1125     }
1126
1127     if (!bos_KeyGetBegin(bos_server, &iter, &st)) {
1128         ERR_ST_EXT("bos_KeyGetBegin", st);
1129     }
1130
1131     printf("Listing keys at server %s:\n", as->parms[SERVER].items->data);
1132
1133     while (bos_KeyGetNext(iter, &key, &st)) {
1134         Print_bos_KeyInfo_p(&key, "");
1135     }
1136
1137     if (st != ADMITERATORDONE) {
1138         ERR_ST_EXT("bos_KeyGetNext", st);
1139     }
1140
1141     if (!bos_KeyGetDone(iter, &st)) {
1142         ERR_ST_EXT("bos_KeyGetDone", st);
1143     }
1144
1145     bos_ServerClose(bos_server, 0);
1146
1147     return 0;
1148 }
1149
1150 int
1151 DoBosCellSet(struct cmd_syndesc *as, void *arock)
1152 {
1153     enum { SERVER, CELL };
1154     afs_status_t st = 0;
1155     void *bos_server = NULL;
1156     const char *cell = NULL;
1157
1158     if (as->parms[SERVER].items) {
1159         if (!bos_ServerOpen
1160             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1161             ERR_ST_EXT("bos_ServerOpen", st);
1162         }
1163     }
1164
1165     if (as->parms[SERVER].items) {
1166         cell = as->parms[SERVER].items->data;
1167     }
1168
1169     if (!bos_CellSet(bos_server, cell, &st)) {
1170         ERR_ST_EXT("bos_CellSet", st);
1171     }
1172
1173     bos_ServerClose(bos_server, 0);
1174
1175     return 0;
1176 }
1177
1178 int
1179 DoBosCellGet(struct cmd_syndesc *as, void *arock)
1180 {
1181     enum { SERVER };
1182     afs_status_t st = 0;
1183     void *bos_server = NULL;
1184     char cell[BOS_MAX_NAME_LEN];
1185
1186     if (as->parms[SERVER].items) {
1187         if (!bos_ServerOpen
1188             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1189             ERR_ST_EXT("bos_ServerOpen", st);
1190         }
1191     }
1192
1193     if (!bos_CellGet(bos_server, cell, &st)) {
1194         ERR_ST_EXT("bos_CellGet", st);
1195     }
1196
1197     printf("The cell name is %s\n", cell);
1198
1199     bos_ServerClose(bos_server, 0);
1200
1201     return 0;
1202 }
1203
1204 int
1205 DoBosHostCreate(struct cmd_syndesc *as, void *arock)
1206 {
1207     enum { SERVER, HOST };
1208     afs_status_t st = 0;
1209     void *bos_server = NULL;
1210     const char *host = NULL;
1211
1212     if (as->parms[SERVER].items) {
1213         if (!bos_ServerOpen
1214             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1215             ERR_ST_EXT("bos_ServerOpen", st);
1216         }
1217     }
1218
1219     if (as->parms[HOST].items) {
1220         host = as->parms[HOST].items->data;
1221     }
1222
1223     if (!bos_HostCreate(bos_server, host, &st)) {
1224         ERR_ST_EXT("bos_HostCreate", st);
1225     }
1226
1227     bos_ServerClose(bos_server, 0);
1228
1229     return 0;
1230 }
1231
1232 int
1233 DoBosHostDelete(struct cmd_syndesc *as, void *arock)
1234 {
1235     enum { SERVER, HOST };
1236     afs_status_t st = 0;
1237     void *bos_server = NULL;
1238     const char *host = NULL;
1239
1240     if (as->parms[SERVER].items) {
1241         if (!bos_ServerOpen
1242             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1243             ERR_ST_EXT("bos_ServerOpen", st);
1244         }
1245     }
1246
1247     if (as->parms[HOST].items) {
1248         host = as->parms[HOST].items->data;
1249     }
1250
1251     if (!bos_HostDelete(bos_server, host, &st)) {
1252         ERR_ST_EXT("bos_HostDelete", st);
1253     }
1254
1255     bos_ServerClose(bos_server, 0);
1256
1257     return 0;
1258 }
1259
1260 int
1261 DoBosHostList(struct cmd_syndesc *as, void *arock)
1262 {
1263     enum { SERVER };
1264     afs_status_t st = 0;
1265     void *bos_server = NULL;
1266     void *iter = NULL;
1267     char host[BOS_MAX_NAME_LEN];
1268
1269     if (as->parms[SERVER].items) {
1270         if (!bos_ServerOpen
1271             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1272             ERR_ST_EXT("bos_ServerOpen", st);
1273         }
1274
1275         printf("Listing hosts at server %s\n", as->parms[SERVER].items->data);
1276     }
1277
1278     if (!bos_HostGetBegin(bos_server, &iter, &st)) {
1279         ERR_ST_EXT("bos_HostGetBegin", st);
1280     }
1281
1282
1283     while (bos_HostGetNext(iter, host, &st)) {
1284         printf("\t%s\n", host);
1285     }
1286
1287     if (st != ADMITERATORDONE) {
1288         ERR_ST_EXT("bos_HostGetNext", st);
1289     }
1290
1291     if (!bos_HostGetDone(iter, &st)) {
1292         ERR_ST_EXT("bos_HostGetDone", st);
1293     }
1294
1295     bos_ServerClose(bos_server, 0);
1296
1297     return 0;
1298 }
1299
1300 int
1301 DoBosExecutableCreate(struct cmd_syndesc *as, void *arock)
1302 {
1303     enum { SERVER, BINARY, DEST };
1304     afs_status_t st = 0;
1305     void *bos_server = NULL;
1306     const char *binary = NULL;
1307     const char *dest = NULL;
1308
1309     if (as->parms[SERVER].items) {
1310         if (!bos_ServerOpen
1311             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1312             ERR_ST_EXT("bos_ServerOpen", st);
1313         }
1314     }
1315
1316     if (as->parms[BINARY].items) {
1317         binary = as->parms[BINARY].items->data;
1318     }
1319
1320     if (as->parms[DEST].items) {
1321         dest = as->parms[DEST].items->data;
1322     }
1323
1324     if (!bos_ExecutableCreate(bos_server, binary, dest, &st)) {
1325         ERR_ST_EXT("bos_ExecutableCreate", st);
1326     }
1327
1328     bos_ServerClose(bos_server, 0);
1329
1330     return 0;
1331 }
1332
1333 int
1334 DoBosExecutableRevert(struct cmd_syndesc *as, void *arock)
1335 {
1336     enum { SERVER, EXECUTABLE };
1337     afs_status_t st = 0;
1338     void *bos_server = NULL;
1339     const char *executable = NULL;
1340
1341     if (as->parms[SERVER].items) {
1342         if (!bos_ServerOpen
1343             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1344             ERR_ST_EXT("bos_ServerOpen", st);
1345         }
1346     }
1347
1348     if (as->parms[EXECUTABLE].items) {
1349         executable = as->parms[EXECUTABLE].items->data;
1350     }
1351
1352     if (!bos_ExecutableRevert(bos_server, executable, &st)) {
1353         ERR_ST_EXT("bos_ExecutableRevert", st);
1354     }
1355
1356     bos_ServerClose(bos_server, 0);
1357
1358     return 0;
1359 }
1360
1361 int
1362 DoBosExecutableTimestampGet(struct cmd_syndesc *as, void *arock)
1363 {
1364     enum { SERVER, EXECUTABLE };
1365     afs_status_t st = 0;
1366     void *bos_server = NULL;
1367     const char *executable = NULL;
1368     afs_int32 new_time = 0;
1369     afs_int32 old_time = 0;
1370     afs_int32 bak_time = 0;
1371
1372     if (as->parms[SERVER].items) {
1373         if (!bos_ServerOpen
1374             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1375             ERR_ST_EXT("bos_ServerOpen", st);
1376         }
1377     }
1378
1379     if (as->parms[EXECUTABLE].items) {
1380         executable = as->parms[EXECUTABLE].items->data;
1381     }
1382
1383     if (!bos_ExecutableTimestampGet
1384         (bos_server, executable, &new_time, &old_time, &bak_time, &st)) {
1385         ERR_ST_EXT("bos_ExecutableTimestampGet", st);
1386     }
1387
1388     bos_ServerClose(bos_server, 0);
1389
1390     return 0;
1391 }
1392
1393 int
1394 DoBosExecutablePrune(struct cmd_syndesc *as, void *arock)
1395 {
1396     enum { SERVER, OLDFILES, BAKFILES,
1397         COREFILES
1398     };
1399     afs_status_t st = 0;
1400     void *bos_server = NULL;
1401     bos_Prune_t old_files = BOS_DONT_PRUNE;
1402     bos_Prune_t bak_files = BOS_DONT_PRUNE;
1403     bos_Prune_t core_files = BOS_DONT_PRUNE;
1404
1405     if (as->parms[SERVER].items) {
1406         if (!bos_ServerOpen
1407             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1408             ERR_ST_EXT("bos_ServerOpen", st);
1409         }
1410     }
1411
1412     if (as->parms[OLDFILES].items) {
1413         old_files = BOS_PRUNE;
1414     }
1415
1416     if (as->parms[BAKFILES].items) {
1417         bak_files = BOS_PRUNE;
1418     }
1419
1420     if (as->parms[COREFILES].items) {
1421         core_files = BOS_PRUNE;
1422     }
1423
1424     if (!bos_ExecutablePrune
1425         (bos_server, old_files, bak_files, core_files, &st)) {
1426         ERR_ST_EXT("bos_ExecutablePrune", st);
1427     }
1428
1429     bos_ServerClose(bos_server, 0);
1430
1431     return 0;
1432 }
1433
1434 int
1435 DoBosExecutableRestartTimeSet(struct cmd_syndesc *as, void *arock)
1436 {
1437     enum { SERVER, DAILY, WEEKLY,
1438         TIME
1439     };
1440     afs_status_t st = 0;
1441     void *bos_server = NULL;
1442     bos_Restart_t type = 0;
1443     int have_daily = 0;
1444     int have_weekly = 0;
1445     bos_RestartTime_t time;
1446
1447     if (as->parms[SERVER].items) {
1448         if (!bos_ServerOpen
1449             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1450             ERR_ST_EXT("bos_ServerOpen", st);
1451         }
1452     }
1453
1454     if (as->parms[DAILY].items) {
1455         type = BOS_RESTART_DAILY;
1456         have_daily = 1;
1457     }
1458
1459     if (as->parms[WEEKLY].items) {
1460         type = BOS_RESTART_WEEKLY;
1461         have_weekly = 1;
1462     }
1463
1464     if ((have_daily == 0) && (have_weekly == 0)) {
1465         ERR_EXT("must specify either daily or weekly");
1466     }
1467
1468     if ((have_daily == 1) && (have_weekly == 1)) {
1469         ERR_EXT("must specify either daily or weekly, not both");
1470     }
1471
1472     if (as->parms[TIME].items) {
1473         if (ktime_ParsePeriodic(as->parms[TIME].items->data, &time) == -1) {
1474             ERR_EXT("error parsing time");
1475         }
1476     }
1477
1478     if (!bos_ExecutableRestartTimeSet(bos_server, type, time, &st)) {
1479         ERR_ST_EXT("bos_ExecutableRestartTimeSet", st);
1480     }
1481
1482     bos_ServerClose(bos_server, 0);
1483
1484     return 0;
1485 }
1486
1487 static void
1488 Print_bos_RestartTime_p(bos_RestartTime_p restart, const char *prefix)
1489 {
1490     char tempString[50];
1491     char astring[50];
1492
1493     astring[0] = 0;
1494     tempString[0] = 0;
1495
1496     if (restart->mask & BOS_RESTART_TIME_NEVER) {
1497         printf("%snever\n", prefix);
1498     } else if (restart->mask & BOS_RESTART_TIME_NOW) {
1499         printf("%snow\n", prefix);
1500     } else {
1501         strcpy(astring, "at");
1502         if (restart->mask & BOS_RESTART_TIME_DAY) {
1503             strcat(astring, " ");
1504             strcat(astring, day[restart->day]);
1505         }
1506         if (restart->mask & BOS_RESTART_TIME_HOUR) {
1507             if (restart->hour > 12)
1508                 sprintf(tempString, " %d", restart->hour - 12);
1509             else if (restart->hour == 0)
1510                 strcpy(tempString, " 12");
1511             else
1512                 sprintf(tempString, " %d", restart->hour);
1513             strcat(astring, tempString);
1514         }
1515         if (restart->mask & BOS_RESTART_TIME_MINUTE) {
1516             sprintf(tempString, ":%02d", restart->min);
1517             strcat(astring, tempString);
1518         }
1519         if ((restart->mask & BOS_RESTART_TIME_SECOND) && restart->sec != 0) {
1520             sprintf(tempString, ":%02d", restart->sec);
1521             strcat(astring, tempString);
1522         }
1523         if (restart->mask & BOS_RESTART_TIME_HOUR) {
1524             if (restart->hour >= 12)
1525                 strcat(astring, " pm");
1526             else
1527                 strcat(astring, " am");
1528         }
1529         printf("%s%s\n", prefix, astring);
1530     }
1531 }
1532
1533 int
1534 DoBosExecutableRestartTimeGet(struct cmd_syndesc *as, void *arock)
1535 {
1536     enum { SERVER, DAILY,
1537         WEEKLY
1538     };
1539     afs_status_t st = 0;
1540     void *bos_server = NULL;
1541     bos_Restart_t type = 0;
1542     int have_daily = 0;
1543     int have_weekly = 0;
1544     bos_RestartTime_t restart_time;
1545
1546     if (as->parms[SERVER].items) {
1547         if (!bos_ServerOpen
1548             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1549             ERR_ST_EXT("bos_ServerOpen", st);
1550         }
1551     }
1552
1553     if (as->parms[DAILY].items) {
1554         type = BOS_RESTART_DAILY;
1555         have_daily = 1;
1556     }
1557
1558     if (as->parms[WEEKLY].items) {
1559         type = BOS_RESTART_WEEKLY;
1560         have_weekly = 1;
1561     }
1562
1563     if ((have_daily == 0) && (have_weekly == 0)) {
1564         ERR_EXT("must specify either daily or weekly");
1565     }
1566
1567     if ((have_daily == 1) && (have_weekly == 1)) {
1568         ERR_EXT("must specify either daily or weekly, not both");
1569     }
1570
1571     if (!bos_ExecutableRestartTimeGet(bos_server, type, &restart_time, &st)) {
1572         ERR_ST_EXT("bos_ExecutableRestartTimeGet", st);
1573     }
1574
1575     Print_bos_RestartTime_p(&restart_time, "");
1576
1577     bos_ServerClose(bos_server, 0);
1578
1579     return 0;
1580 }
1581
1582 #define INITIAL_BUF_SIZE 4096
1583
1584 int
1585 DoBosLogGet(struct cmd_syndesc *as, void *arock)
1586 {
1587     enum { SERVER, LOGFILE };
1588     afs_status_t st = 0;
1589     void *bos_server = NULL;
1590     const char *log_file = NULL;
1591     unsigned long buf_size = INITIAL_BUF_SIZE;
1592     char *buf = NULL;
1593
1594     if (as->parms[SERVER].items) {
1595         if (!bos_ServerOpen
1596             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1597             ERR_ST_EXT("bos_ServerOpen", st);
1598         }
1599     }
1600
1601     if (as->parms[LOGFILE].items) {
1602         log_file = as->parms[LOGFILE].items->data;
1603     }
1604
1605     st = ADMMOREDATA;
1606     while (st == ADMMOREDATA) {
1607         buf = realloc(buf, buf_size);
1608         if (buf == NULL) {
1609             ERR_EXT("cannot dynamically allocate memory");
1610         }
1611         bos_LogGet(bos_server, log_file, &buf_size, buf, &st);
1612         if (st == ADMMOREDATA) {
1613             buf_size = buf_size + (unsigned long)(0.2 * buf_size);
1614         }
1615     }
1616
1617     if (st != 0) {
1618         ERR_ST_EXT("bos_LogGet", st);
1619     } else {
1620         printf("Log file:\n%s", buf);
1621     }
1622
1623     if (buf != NULL) {
1624         free(buf);
1625     }
1626
1627     bos_ServerClose(bos_server, 0);
1628
1629     return 0;
1630 }
1631
1632 int
1633 DoBosAuthSet(struct cmd_syndesc *as, void *arock)
1634 {
1635     enum { SERVER, REQUIREAUTH, DISABLEAUTH };
1636     afs_status_t st = 0;
1637     void *bos_server = NULL;
1638     bos_Auth_t auth = 0;
1639     int have_req = 0;
1640     int have_dis = 0;
1641
1642     if (as->parms[SERVER].items) {
1643         if (!bos_ServerOpen
1644             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1645             ERR_ST_EXT("bos_ServerOpen", st);
1646         }
1647     }
1648
1649     if (as->parms[REQUIREAUTH].items) {
1650         auth = BOS_AUTH_REQUIRED;
1651         have_req = 1;
1652     }
1653
1654     if (as->parms[DISABLEAUTH].items) {
1655         auth = BOS_NO_AUTH;
1656         have_dis = 1;
1657     }
1658
1659     if ((have_req == 0) && (have_dis == 0)) {
1660         ERR_EXT("must specify either requireauth or disableauth");
1661     }
1662
1663     if ((have_req == 1) && (have_dis == 1)) {
1664         ERR_EXT("must specify either requireauth or disableauth, not both");
1665     }
1666
1667     if (!bos_AuthSet(bos_server, auth, &st)) {
1668         ERR_ST_EXT("bos_AuthSet", st);
1669     }
1670
1671     bos_ServerClose(bos_server, 0);
1672
1673     return 0;
1674 }
1675
1676 int
1677 DoBosCommandExecute(struct cmd_syndesc *as, void *arock)
1678 {
1679     enum { SERVER, COMMAND };
1680     afs_status_t st = 0;
1681     void *bos_server = NULL;
1682     const char *command = NULL;
1683
1684     if (as->parms[SERVER].items) {
1685         if (!bos_ServerOpen
1686             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1687             ERR_ST_EXT("bos_ServerOpen", st);
1688         }
1689     }
1690
1691     if (as->parms[COMMAND].items) {
1692         command = as->parms[COMMAND].items->data;
1693     }
1694
1695     if (!bos_CommandExecute(bos_server, command, &st)) {
1696         ERR_ST_EXT("bos_CommandExecute", st);
1697     }
1698
1699     bos_ServerClose(bos_server, 0);
1700
1701     return 0;
1702 }
1703
1704 int
1705 DoBosSalvage(struct cmd_syndesc *as, void *arock)
1706 {
1707     enum { SERVER, PARTITION, VOLUME, NUMSALVAGERS, TMPDIR, LOGFILE,
1708         FORCE, NOWRITE, INODES, ROOTINODES, SALVAGEDIRS, BLOCKREADS
1709     };
1710     afs_status_t st = 0;
1711     void *bos_server = NULL;
1712     const char *partition = NULL;
1713     const char *volume = NULL;
1714     int num_salvagers = 1;
1715     const char *tmp_dir = NULL;
1716     const char *log_file = NULL;
1717     vos_force_t force = VOS_NORMAL;
1718     bos_SalvageDamagedVolumes_t no_write = BOS_SALVAGE_DAMAGED_VOLUMES;
1719     bos_WriteInodes_t inodes = BOS_SALVAGE_WRITE_INODES;
1720     bos_WriteRootInodes_t root_inodes = BOS_SALVAGE_WRITE_ROOT_INODES;
1721     bos_ForceDirectory_t salvage_dirs = BOS_SALVAGE_DONT_FORCE_DIRECTORIES;
1722     bos_ForceBlockRead_t block_reads = BOS_SALVAGE_DONT_FORCE_BLOCK_READS;
1723
1724
1725     if (as->parms[SERVER].items) {
1726         if (!bos_ServerOpen
1727             (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1728             ERR_ST_EXT("bos_ServerOpen", st);
1729         }
1730     }
1731
1732     if (as->parms[PARTITION].items) {
1733         partition = as->parms[PARTITION].items->data;
1734     }
1735
1736     if (as->parms[VOLUME].items) {
1737         volume = as->parms[VOLUME].items->data;
1738     }
1739
1740     if (as->parms[NUMSALVAGERS].items) {
1741         num_salvagers =
1742             GetIntFromString(as->parms[NUMSALVAGERS].items->data,
1743                              "invalid number of salvagers");
1744     }
1745
1746     if (as->parms[TMPDIR].items) {
1747         tmp_dir = as->parms[TMPDIR].items->data;
1748     }
1749
1750     if (as->parms[LOGFILE].items) {
1751         log_file = as->parms[LOGFILE].items->data;
1752     }
1753
1754     if (as->parms[FORCE].items) {
1755         force = VOS_FORCE;
1756     }
1757
1758     if (as->parms[NOWRITE].items) {
1759         no_write = BOS_DONT_SALVAGE_DAMAGED_VOLUMES;
1760     }
1761
1762     if (as->parms[INODES].items) {
1763         inodes = BOS_SALVAGE_DONT_WRITE_INODES;
1764     }
1765
1766     if (as->parms[ROOTINODES].items) {
1767         root_inodes = BOS_SALVAGE_DONT_WRITE_ROOT_INODES;
1768     }
1769
1770     if (as->parms[SALVAGEDIRS].items) {
1771         salvage_dirs = BOS_SALVAGE_FORCE_DIRECTORIES;
1772     }
1773
1774     if (as->parms[BLOCKREADS].items) {
1775         block_reads = BOS_SALVAGE_FORCE_BLOCK_READS;
1776     }
1777
1778     if (!bos_Salvage
1779         (cellHandle, bos_server, partition, volume, num_salvagers, tmp_dir,
1780          log_file, force, no_write, inodes, root_inodes, salvage_dirs,
1781          block_reads, &st)) {
1782         ERR_ST_EXT("bos_Salvage", st);
1783     }
1784
1785     bos_ServerClose(bos_server, 0);
1786
1787     return 0;
1788 }
1789
1790 #if 0
1791 static void
1792 Print_afs_RPCStatsState_p(afs_RPCStatsState_p state, const char *prefix)
1793 {
1794     printf("%sThe rpc stats state is: ", prefix);
1795     switch (*state) {
1796     case AFS_RPC_STATS_DISABLED:
1797         printf("disabled\n");
1798         break;
1799     case AFS_RPC_STATS_ENABLED:
1800         printf("enabled\n");
1801         break;
1802     }
1803 }
1804 #endif
1805
1806 void
1807 SetupBosAdminCmd(void)
1808 {
1809     struct cmd_syndesc *ts;
1810
1811     ts = cmd_CreateSyntax("BosProcessCreate", DoBosProcessCreate, NULL, 0,
1812                           "create a new bos process");
1813     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1814                 "server where process will be created");
1815     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1816                 "the name of the process");
1817     cmd_AddParm(ts, "-binary", CMD_SINGLE, CMD_REQUIRED,
1818                 "path to the process binary");
1819     cmd_AddParm(ts, "-cron", CMD_FLAG, CMD_OPTIONAL,
1820                 "this is a cron process");
1821     cmd_AddParm(ts, "-crontime", CMD_SINGLE, CMD_OPTIONAL,
1822                 "the time when the process will be run");
1823     cmd_AddParm(ts, "-notifier", CMD_SINGLE, CMD_OPTIONAL,
1824                 "path to notifier binary that is run when process terminates");
1825     SetupCommonCmdArgs(ts);
1826
1827     ts = cmd_CreateSyntax("BosFSProcessCreate", DoBosFSProcessCreate, NULL, 0,
1828                           "create a fs bos process");
1829     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1830                 "server where process will be created");
1831     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1832                 "the name of the process");
1833     cmd_AddParm(ts, "-fileserver", CMD_SINGLE, CMD_REQUIRED,
1834                 "path to the fileserver binary");
1835     cmd_AddParm(ts, "-volserver", CMD_SINGLE, CMD_REQUIRED,
1836                 "path to the volserver binary");
1837     cmd_AddParm(ts, "-salvager", CMD_SINGLE, CMD_REQUIRED,
1838                 "path to the salvager binary");
1839     cmd_AddParm(ts, "-notifier", CMD_SINGLE, CMD_OPTIONAL,
1840                 "path to notifier binary that is run when process terminates");
1841     SetupCommonCmdArgs(ts);
1842
1843     ts = cmd_CreateSyntax("BosProcessDelete", DoBosProcessDelete, NULL, 0,
1844                           "delete a bos process");
1845     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1846                 "server where process will be deleted");
1847     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1848                 "the name of the process");
1849     SetupCommonCmdArgs(ts);
1850
1851     ts = cmd_CreateSyntax("BosProcessExecutionStateGet",
1852                           DoBosProcessExecutionStateGet, NULL, 0,
1853                           "get the process execution state of a process");
1854     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1855                 "server where process exists");
1856     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1857                 "the name of the process");
1858     SetupCommonCmdArgs(ts);
1859
1860     ts = cmd_CreateSyntax("BosProcessExecutionStateSet",
1861                           DoBosProcessExecutionStateSet, NULL, 0,
1862                           "set the process execution state of a process");
1863     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1864                 "server where process exists");
1865     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1866                 "the name of the process");
1867     cmd_AddParm(ts, "-stopped", CMD_FLAG, CMD_OPTIONAL,
1868                 "set the process state to stopped");
1869     cmd_AddParm(ts, "-running", CMD_FLAG, CMD_OPTIONAL,
1870                 "set the process state to running");
1871     SetupCommonCmdArgs(ts);
1872
1873     ts = cmd_CreateSyntax("BosProcessExecutionStateSetTemporary",
1874                           DoBosProcessExecutionStateSetTemporary, NULL, 0,
1875                           "set the process execution state "
1876                           "of a process temporarily");
1877     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1878                 "server where process exists");
1879     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1880                 "the name of the process");
1881     cmd_AddParm(ts, "-stopped", CMD_FLAG, CMD_OPTIONAL,
1882                 "set the process state to stopped");
1883     cmd_AddParm(ts, "-running", CMD_FLAG, CMD_OPTIONAL,
1884                 "set the process state to running");
1885     SetupCommonCmdArgs(ts);
1886
1887     ts = cmd_CreateSyntax("BosProcessNameList", DoBosProcessNameList, NULL, 0,
1888                           "list the names of all processes at a bos server");
1889     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
1890     SetupCommonCmdArgs(ts);
1891
1892     ts = cmd_CreateSyntax("BosProcessInfoGet", DoBosProcessInfoGet, NULL, 0,
1893                           "get information about a process");
1894     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1895                 "server where process exists");
1896     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1897                 "the name of the process");
1898     SetupCommonCmdArgs(ts);
1899
1900     ts = cmd_CreateSyntax("BosProcessParameterList",
1901                           DoBosProcessParameterList, NULL, 0,
1902                           "list the parameters of a process");
1903     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1904                 "server where process exists");
1905     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1906                 "the name of the process");
1907     SetupCommonCmdArgs(ts);
1908
1909     ts = cmd_CreateSyntax("BosProcessNotifierGet", DoBosProcessNotifierGet, NULL, 0,
1910                           "get the notifier for a process");
1911     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1912                 "server where process exists");
1913     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1914                 "the name of the process");
1915     SetupCommonCmdArgs(ts);
1916
1917     ts = cmd_CreateSyntax("BosProcessRestart", DoBosProcessRestart, NULL, 0,
1918                           "restart a process");
1919     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1920                 "server where process exists");
1921     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1922                 "the name of the process");
1923     SetupCommonCmdArgs(ts);
1924
1925     ts = cmd_CreateSyntax("BosProcessAllStop", DoBosProcessAllStop, NULL, 0,
1926                           "stop all processes at a bos server");
1927     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1928                 "server where processes exists");
1929     SetupCommonCmdArgs(ts);
1930
1931     ts = cmd_CreateSyntax("BosProcessAllWaitStop", DoBosProcessAllWaitStop, NULL, 0,
1932                           "stop all processes at a bos server and block "
1933                           "until they all exit");
1934     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1935                 "server where processes exists");
1936     SetupCommonCmdArgs(ts);
1937
1938     ts = cmd_CreateSyntax("BosProcessAllWaitTransition",
1939                           DoBosProcessAllWaitTransition, NULL, 0,
1940                           "wait until all processes have transitioned to "
1941                           "their desired state");
1942     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1943                 "server where processes exists");
1944     SetupCommonCmdArgs(ts);
1945
1946     ts = cmd_CreateSyntax("BosProcessAllStopAndRestart",
1947                           DoBosProcessAllStopAndRestart, NULL, 0,
1948                           "stop all processes at a bos server and "
1949                           "then restart them");
1950     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1951                 "server where processes exists");
1952     cmd_AddParm(ts, "-includebos", CMD_FLAG, CMD_OPTIONAL,
1953                 "include the bos server in the processes to be restarted");
1954     SetupCommonCmdArgs(ts);
1955
1956     ts = cmd_CreateSyntax("BosAdminCreate", DoBosAdminCreate, NULL, 0,
1957                           "create an admin user at a bos server");
1958     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1959                 "server where admin will be created");
1960     cmd_AddParm(ts, "-admin", CMD_SINGLE, CMD_REQUIRED,
1961                 "the name of the administrator to add");
1962     SetupCommonCmdArgs(ts);
1963
1964     ts = cmd_CreateSyntax("BosAdminDelete", DoBosAdminDelete, NULL, 0,
1965                           "delete an admin user at a bos server");
1966     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1967                 "server where admin will be deleted");
1968     cmd_AddParm(ts, "-admin", CMD_SINGLE, CMD_REQUIRED,
1969                 "the name of the administrator to delete");
1970     SetupCommonCmdArgs(ts);
1971
1972     ts = cmd_CreateSyntax("BosAdminList", DoBosAdminList, NULL, 0,
1973                           "list all admin users at a bos server");
1974     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1975                 "server where admins will be listed");
1976     SetupCommonCmdArgs(ts);
1977
1978     ts = cmd_CreateSyntax("BosKeyCreate", DoBosKeyCreate, NULL, 0,
1979                           "create a key at a bos server");
1980     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1981                 "server where key will be created");
1982     cmd_AddParm(ts, "-versionnumber", CMD_SINGLE, CMD_REQUIRED,
1983                 "version number of new key");
1984     cmd_AddParm(ts, "-key", CMD_SINGLE, CMD_REQUIRED, "new encryption key");
1985     SetupCommonCmdArgs(ts);
1986
1987     ts = cmd_CreateSyntax("BosKeyDelete", DoBosKeyDelete, NULL, 0,
1988                           "delete a key at a bos server");
1989     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1990                 "server where key will be deleted");
1991     cmd_AddParm(ts, "-versionnumber", CMD_SINGLE, CMD_REQUIRED,
1992                 "version number of the key");
1993     SetupCommonCmdArgs(ts);
1994
1995     ts = cmd_CreateSyntax("BosKeyList", DoBosKeyList, NULL, 0,
1996                           "list keys at a bos server");
1997     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1998                 "server where keys exist");
1999     SetupCommonCmdArgs(ts);
2000
2001     ts = cmd_CreateSyntax("BosCellSet", DoBosCellSet, NULL, 0,
2002                           "set the cell at a bos server");
2003     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2004     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_REQUIRED, "new cell");
2005     SetupCommonCmdArgs(ts);
2006
2007     ts = cmd_CreateSyntax("BosCellGet", DoBosCellGet, NULL, 0,
2008                           "get the cell at a bos server");
2009     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
2010     SetupCommonCmdArgs(ts);
2011
2012     ts = cmd_CreateSyntax("BosHostCreate", DoBosHostCreate, NULL, 0,
2013                           "add a host entry to the server CellServDB");
2014     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2015     cmd_AddParm(ts, "-host", CMD_SINGLE, CMD_REQUIRED, "host to add");
2016     SetupCommonCmdArgs(ts);
2017
2018     ts = cmd_CreateSyntax("BosHostDelete", DoBosHostDelete, NULL, 0,
2019                           "delete a host entry from the server CellServDB");
2020     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2021     cmd_AddParm(ts, "-host", CMD_SINGLE, CMD_REQUIRED, "host to delete");
2022     SetupCommonCmdArgs(ts);
2023
2024     ts = cmd_CreateSyntax("BosHostList", DoBosHostList, NULL, 0,
2025                           "list all host entries from the server CellServDB");
2026     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
2027     SetupCommonCmdArgs(ts);
2028
2029     ts = cmd_CreateSyntax("BosExecutableCreate", DoBosExecutableCreate, NULL, 0,
2030                           "create a new binary at a bos server");
2031     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2032     cmd_AddParm(ts, "-binary", CMD_SINGLE, CMD_REQUIRED,
2033                 "path to the binary to create");
2034     cmd_AddParm(ts, "-dest", CMD_SINGLE, CMD_REQUIRED,
2035                 "path where the binary will be stored");
2036     SetupCommonCmdArgs(ts);
2037
2038     ts = cmd_CreateSyntax("BosExecutableRevert", DoBosExecutableRevert, NULL, 0,
2039                           "revert a binary at a bos server");
2040     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2041     cmd_AddParm(ts, "-executable", CMD_SINGLE, CMD_REQUIRED,
2042                 "path to the binary to revert");
2043     SetupCommonCmdArgs(ts);
2044
2045     ts = cmd_CreateSyntax("BosExecutableTimestampGet",
2046                           DoBosExecutableTimestampGet, NULL, 0,
2047                           "get the timestamps for a binary at bos server");
2048     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
2049     cmd_AddParm(ts, "-executable", CMD_SINGLE, CMD_REQUIRED,
2050                 "path to the binary to revert");
2051     SetupCommonCmdArgs(ts);
2052
2053     ts = cmd_CreateSyntax("BosExecutablePrune", DoBosExecutablePrune, NULL, 0,
2054                           "prune various files at bos server");
2055     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2056     cmd_AddParm(ts, "-oldfiles", CMD_FLAG, CMD_OPTIONAL, "prune .old files");
2057     cmd_AddParm(ts, "-bakfiles", CMD_FLAG, CMD_OPTIONAL, "prune .bak files");
2058     cmd_AddParm(ts, "-corefiles", CMD_FLAG, CMD_OPTIONAL, "prune core files");
2059     SetupCommonCmdArgs(ts);
2060
2061     ts = cmd_CreateSyntax("BosExecutableRestartTimeSet",
2062                           DoBosExecutableRestartTimeSet, NULL, 0,
2063                           "set the restart times at a bos server");
2064     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2065     cmd_AddParm(ts, "-daily", CMD_FLAG, CMD_OPTIONAL,
2066                 "set daily restart time");
2067     cmd_AddParm(ts, "-weekly", CMD_FLAG, CMD_OPTIONAL,
2068                 "set weekly restart time");
2069     cmd_AddParm(ts, "-time", CMD_SINGLE, CMD_REQUIRED,
2070                 "the new restart time");
2071     SetupCommonCmdArgs(ts);
2072
2073     ts = cmd_CreateSyntax("BosExecutableRestartTimeGet",
2074                           DoBosExecutableRestartTimeGet, NULL, 0,
2075                           "get the restart times at a bos server");
2076     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
2077     cmd_AddParm(ts, "-daily", CMD_FLAG, CMD_OPTIONAL,
2078                 "get daily restart time");
2079     cmd_AddParm(ts, "-weekly", CMD_FLAG, CMD_OPTIONAL,
2080                 "get weekly restart time");
2081     SetupCommonCmdArgs(ts);
2082
2083     ts = cmd_CreateSyntax("BosLogGet", DoBosLogGet, NULL, 0,
2084                           "get a log file from the bos server");
2085     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
2086     cmd_AddParm(ts, "-logfile", CMD_SINGLE, CMD_REQUIRED,
2087                 "path to the log file to retrieve");
2088     SetupCommonCmdArgs(ts);
2089
2090     ts = cmd_CreateSyntax("BosAuthSet", DoBosAuthSet, NULL, 0,
2091                           "set the authorization level at a bos server");
2092     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2093     cmd_AddParm(ts, "-requireauth", CMD_FLAG, CMD_OPTIONAL,
2094                 "require authorization");
2095     cmd_AddParm(ts, "-disableauth", CMD_FLAG, CMD_OPTIONAL,
2096                 "don't require authorization");
2097     SetupCommonCmdArgs(ts);
2098
2099     ts = cmd_CreateSyntax("BosCommandExecute", DoBosCommandExecute, 0, 0,
2100                           "execute a command at a bos server");
2101     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2102                 "server where command will execute");
2103     cmd_AddParm(ts, "-command", CMD_SINGLE, CMD_REQUIRED,
2104                 "command to execute");
2105     SetupCommonCmdArgs(ts);
2106
2107     ts = cmd_CreateSyntax("BosSalvage", DoBosSalvage, NULL, 0,
2108                           "execute a salvage command at a bos server");
2109     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2110                 "server where salvager will execute");
2111     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
2112                 "partition to salvage");
2113     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_OPTIONAL, "volume to salvage");
2114     cmd_AddParm(ts, "-numsalvagers", CMD_SINGLE, CMD_REQUIRED,
2115                 "number of salvagers to run in parallel");
2116     cmd_AddParm(ts, "-tmpdir", CMD_SINGLE, CMD_OPTIONAL,
2117                 "directory to place temporary files");
2118     cmd_AddParm(ts, "-logfile", CMD_SINGLE, CMD_OPTIONAL,
2119                 "file where salvager log will be written");
2120     cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL, "run salvager -force");
2121     cmd_AddParm(ts, "-nowrite", CMD_FLAG, CMD_OPTIONAL,
2122                 "run salvager -nowrite");
2123     cmd_AddParm(ts, "-inodes", CMD_FLAG, CMD_OPTIONAL,
2124                 "run salvager -inodes");
2125     cmd_AddParm(ts, "-rootinodes", CMD_FLAG, CMD_OPTIONAL,
2126                 "run salvager -rootinodes");
2127     cmd_AddParm(ts, "-salvagedirs", CMD_FLAG, CMD_OPTIONAL,
2128                 "run salvager -salvagedirs");
2129     cmd_AddParm(ts, "-blockreads", CMD_FLAG, CMD_OPTIONAL,
2130                 "run salvager -blockreads");
2131     SetupCommonCmdArgs(ts);
2132 }