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