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