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