2 * Copyright 2000, International Business Machines Corporation and others.
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
11 * This file implements the bos related funtions for afscp
14 #include <afsconfig.h>
15 #include <afs/param.h>
28 * Generic fuction for converting input string to an integer. Pass
29 * the error_msg you want displayed if there is an error converting
34 GetIntFromString(const char *int_str, const char *error_msg)
37 char *bad_char = NULL;
39 i = strtoul(int_str, &bad_char, 10);
40 if ((bad_char == NULL) || (*bad_char == 0)) {
48 * Functions for reading and displaying bos restart times. These are copied
49 * from util/ktime.c and changed to handle the bos types.
57 static char *day[] = {
68 LocalFreeTokens(struct token *alist)
71 for (; alist; alist = nlist) {
82 if (x == 0 || x == ' ' || x == '\t' || x == '\n')
89 LocalParseLine(char *aline, struct token **alist)
94 struct token *first, *last;
98 inToken = 0; /* not copying token chars at start */
103 if (tc == 0 || space(tc)) {
105 inToken = 0; /* end of this token */
107 ttok = malloc(sizeof(struct token));
109 ttok->key = strdup(tbuffer);
119 /* an alpha character */
124 if (tptr - tbuffer >= sizeof(tbuffer))
129 /* last token flushed 'cause space(0) --> true */
138 /* keyword database for periodic date parsing */
139 static struct ptemp {
143 {"sun", 0x10000}, {"mon", 0x10001}, {"tue", 0x10002},
144 {"wed", 0x10003}, {"thu", 0x10004}, {"fri", 0x10005},
146 {"sunday", 0x10000}, {"monday", 0x10001},
147 {"tuesday", 0x10002}, {"wednesday", 0x10003},
148 {"thursday", 0x10004}, {"thur", 0x10004},
149 {"friday", 0x10005}, {"saturday", 0x10006},
150 {"am", 0x20000}, {"pm", 0x20001},
151 {"a.m.", 0x20000}, {"p.m.", 0x20001}, {0, 0}};
154 ParseTime(bos_RestartTime_p ak, char *astr)
161 field = 0; /* 0=hour, 1=min, 2=sec */
165 (BOS_RESTART_TIME_HOUR | BOS_RESTART_TIME_MINUTE |
166 BOS_RESTART_TIME_SECOND);
169 if (tc == 0 || tc == ':') {
181 } else if (!isdigit(tc))
182 return -1; /* syntax error */
189 if (ak->hour >= 24 || ak->min >= 60 || ak->sec >= 60)
195 ktime_ParsePeriodic(char *adate, bos_RestartTime_p ak)
201 memset(ak, 0, sizeof(*ak));
202 code = LocalParseLine(adate, &tt);
205 for (; tt; tt = tt->next) {
206 /* look at each token */
207 if (strcmp(tt->key, "now") == 0) {
208 ak->mask |= BOS_RESTART_TIME_NOW;
212 if (strcmp(tt->key, "never") == 0) {
213 ak->mask |= BOS_RESTART_TIME_NEVER;
217 if (strcmp(tt->key, "at") == 0)
219 if (strcmp(tt->key, "every") == 0)
221 if (isdigit(tt->key[0])) {
223 code = ParseTime(ak, tt->key);
230 /* otherwise use keyword table */
231 for (tp = ptkeys;; tp++) {
232 if (tp->key == NULL) {
236 if (strcmp(tp->key, tt->key) == 0)
239 /* now look at tp->value to see what we've got */
240 if ((tp->value >> 16) == 1) {
242 ak->mask |= BOS_RESTART_TIME_DAY;
243 ak->day = tp->value & 0xff;
245 if ((tp->value >> 16) == 2) {
247 if ((tp->value & 0xff) == 1) {
249 if (!(ak->mask & BOS_RESTART_TIME_HOUR))
254 else if (ak->hour != 12) {
259 /* am is almost a noop, except that we map 12:01 am to 0:01 */
274 DoBosProcessCreate(struct cmd_syndesc *as, void *arock)
276 typedef enum { SERVER, PROCESS, BINARY, CRON, CRONTIME,
278 } DoBosProcessCreate_parm_t;
280 void *bos_server = NULL;
281 const char *process = NULL;
282 bos_ProcessType_t process_type = BOS_PROCESS_SIMPLE;
283 const char *binary = NULL;
285 const char *cron_time = NULL;
286 int has_cron_time = 0;
287 const char *notifier = NULL;
289 if (as->parms[SERVER].items) {
291 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
292 ERR_ST_EXT("bos_ServerOpen", st);
296 if (as->parms[PROCESS].items) {
297 process = as->parms[PROCESS].items->data;
300 if (as->parms[BINARY].items) {
301 binary = as->parms[BINARY].items->data;
304 if (as->parms[CRON].items) {
306 process_type = BOS_PROCESS_CRON;
309 if (as->parms[CRONTIME].items) {
310 cron_time = as->parms[CRONTIME].items->data;
315 if (!has_cron_time) {
316 ERR_EXT("must specify cron time when creating a cron process");
320 ERR_EXT("cron time is meaningless for non cron process");
324 if (as->parms[NOTIFIER].items) {
325 notifier = as->parms[NOTIFIER].items->data;
328 if (!bos_ProcessCreate
329 (bos_server, (char *)process, process_type, (char *)binary, (char *)cron_time, (char *)notifier,
331 ERR_ST_EXT("bos_ProcessCreate", st);
334 bos_ServerClose(bos_server, 0);
340 DoBosFSProcessCreate(struct cmd_syndesc *as, void *arock)
342 typedef enum { SERVER, PROCESS, FILESERVER, VOLSERVER, SALVAGER,
344 } DoBosFSProcessCreate_parm_t;
346 void *bos_server = NULL;
347 const char *process = NULL;
348 const char *fileserver = NULL;
349 const char *volserver = NULL;
350 const char *salvager = NULL;
351 const char *notifier = NULL;
353 if (as->parms[SERVER].items) {
355 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
356 ERR_ST_EXT("bos_ServerOpen", st);
360 if (as->parms[PROCESS].items) {
361 process = as->parms[PROCESS].items->data;
364 if (as->parms[FILESERVER].items) {
365 fileserver = as->parms[FILESERVER].items->data;
368 if (as->parms[VOLSERVER].items) {
369 volserver = as->parms[VOLSERVER].items->data;
372 if (as->parms[SALVAGER].items) {
373 salvager = as->parms[SALVAGER].items->data;
376 if (as->parms[NOTIFIER].items) {
377 notifier = as->parms[NOTIFIER].items->data;
380 if (!bos_FSProcessCreate
381 (bos_server, (char *)process, (char *)fileserver, (char *)volserver, (char *)salvager, (char *)notifier,
383 ERR_ST_EXT("bos_FSProcessCreate", st);
386 bos_ServerClose(bos_server, 0);
392 DoBosProcessDelete(struct cmd_syndesc *as, void *arock)
394 typedef enum { SERVER, PROCESS } DoBosProcessDelete_parm_t;
396 void *bos_server = NULL;
397 const char *process = NULL;
399 if (as->parms[SERVER].items) {
401 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
402 ERR_ST_EXT("bos_ServerOpen", st);
406 if (as->parms[PROCESS].items) {
407 process = as->parms[PROCESS].items->data;
410 if (!bos_ProcessDelete(bos_server, (char *)process, &st)) {
411 ERR_ST_EXT("bos_ProcessDelete", st);
414 bos_ServerClose(bos_server, 0);
420 Print_bos_ProcessExecutionState_p(bos_ProcessExecutionState_p state,
423 printf("%sThe process executation state is: ", prefix);
425 case BOS_PROCESS_STOPPED:
428 case BOS_PROCESS_RUNNING:
431 case BOS_PROCESS_STOPPING:
432 printf("stopping\n");
434 case BOS_PROCESS_STARTING:
435 printf("starting\n");
441 DoBosProcessExecutionStateGet(struct cmd_syndesc *as, void *arock)
443 typedef enum { SERVER, PROCESS } DoBosProcessExecutionStateGet_parm_t;
445 void *bos_server = NULL;
446 const char *process = NULL;
447 bos_ProcessExecutionState_t state;
448 char aux_status[BOS_MAX_NAME_LEN];
450 if (as->parms[SERVER].items) {
452 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
453 ERR_ST_EXT("bos_ServerOpen", st);
457 if (as->parms[PROCESS].items) {
458 process = as->parms[PROCESS].items->data;
461 if (!bos_ProcessExecutionStateGet
462 (bos_server, (char *)process, &state, aux_status, &st)) {
463 ERR_ST_EXT("bos_ProcessExecutionStateGet", st);
466 Print_bos_ProcessExecutionState_p(&state, "");
467 if (aux_status[0] != 0) {
468 printf("Aux process status: %s\n", aux_status);
471 bos_ServerClose(bos_server, 0);
477 DoBosProcessExecutionStateSet(struct cmd_syndesc *as, void *arock)
479 typedef enum { SERVER, PROCESS, STOPPED,
481 } DoBosProcessExecutionStateSet_parm_t;
483 void *bos_server = NULL;
484 const char *process = NULL;
487 bos_ProcessExecutionState_t state = 0;
489 if (as->parms[SERVER].items) {
491 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
492 ERR_ST_EXT("bos_ServerOpen", st);
496 if (as->parms[PROCESS].items) {
497 process = as->parms[PROCESS].items->data;
500 if (as->parms[STOPPED].items) {
502 state = BOS_PROCESS_STOPPED;
505 if (as->parms[RUNNING].items) {
507 state = BOS_PROCESS_RUNNING;
510 if ((stop == 1) && (run == 1)) {
511 ERR_EXT("you must specify either running or stopped, but not both");
514 if ((stop == 0) && (run == 0)) {
515 ERR_EXT("you must specify either running or stopped");
518 if (!bos_ProcessExecutionStateSet(bos_server, process, state, &st)) {
519 ERR_ST_EXT("bos_ProcessExecutionStateSet", st);
522 bos_ServerClose(bos_server, 0);
528 DoBosProcessExecutionStateSetTemporary(struct cmd_syndesc *as, void *arock)
530 typedef enum { SERVER, PROCESS, STOPPED,
532 } DoBosProcessExecutionStateSetTemporary_parm_t;
534 void *bos_server = NULL;
535 const char *process = NULL;
538 bos_ProcessExecutionState_t state = 0;
540 if (as->parms[SERVER].items) {
542 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
543 ERR_ST_EXT("bos_ServerOpen", st);
547 if (as->parms[PROCESS].items) {
548 process = as->parms[PROCESS].items->data;
551 if (as->parms[STOPPED].items) {
553 state = BOS_PROCESS_STOPPED;
556 if (as->parms[RUNNING].items) {
558 state = BOS_PROCESS_RUNNING;
561 if ((stop == 1) && (run == 1)) {
562 ERR_EXT("you must specify either running or stopped, but not both");
565 if ((stop == 0) && (run == 0)) {
566 ERR_EXT("you must specify either running or stopped");
569 if (!bos_ProcessExecutionStateSetTemporary
570 (bos_server, (char *)process, state, &st)) {
571 ERR_ST_EXT("bos_ProcessExecutionStateSetTemporary", st);
574 bos_ServerClose(bos_server, 0);
580 DoBosProcessNameList(struct cmd_syndesc *as, void *arock)
582 typedef enum { SERVER } DoBosProcessNameList_parm_t;
584 void *bos_server = NULL;
586 char process[BOS_MAX_NAME_LEN];
588 if (as->parms[SERVER].items) {
590 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
591 ERR_ST_EXT("bos_ServerOpen", st);
595 if (!bos_ProcessNameGetBegin(bos_server, &iter, &st)) {
596 ERR_ST_EXT("bos_ProcessNameGetBegin", st);
599 printf("Listing processes at server %s:\n",
600 as->parms[SERVER].items->data);
602 while (bos_ProcessNameGetNext(iter, process, &st)) {
603 printf("\t%s\n", process);
606 if (st != ADMITERATORDONE) {
607 ERR_ST_EXT("bos_ProcessNameGetNext", st);
610 if (!bos_ProcessNameGetDone(iter, &st)) {
611 ERR_ST_EXT("bos_ProcessNameGetDone", st);
618 Print_bos_ProcessType_p(bos_ProcessType_p type, const char *prefix)
620 printf("%sProcess type: \n", prefix);
622 case BOS_PROCESS_SIMPLE:
628 case BOS_PROCESS_CRON:
635 Print_bos_ProcessState_p(bos_ProcessState_p state, const char *prefix)
637 printf("%sProcess state:\n", prefix);
638 /* FIXME: BOS_PROCESS_OK is 0, so this test is not right */
639 if (*state & BOS_PROCESS_OK) {
640 printf("%s\tBOS_PROCESS_OK:\n", prefix);
642 if (*state & BOS_PROCESS_CORE_DUMPED) {
643 printf("%s\tBOS_PROCESS_CORE_DUMPED:\n", prefix);
645 if (*state & BOS_PROCESS_TOO_MANY_ERRORS) {
646 printf("%s\tBOS_PROCESS_TOO_MANY_ERRORS:\n", prefix);
648 if (*state & BOS_PROCESS_BAD_FILE_ACCESS) {
649 printf("%s\tBOS_PROCESS_BAD_FILE_ACCESS:\n", prefix);
654 Print_bos_ProcessInfo_p(bos_ProcessInfo_p info, const char *prefix)
656 Print_bos_ProcessExecutionState_p(&info->processGoal, prefix);
657 printf("%sStart time %lu\n", prefix, info->processStartTime);
658 printf("%sNumber of process starts %lu \n", prefix,
659 info->numberProcessStarts);
660 printf("%sProcess exit time %lu\n", prefix, info->processExitTime);
661 printf("%sProcess exit error time %lu\n", prefix,
662 info->processExitErrorTime);
663 printf("%sProcess error code %lu\n", prefix, info->processErrorCode);
664 printf("%sProcess error signal %lu\n", prefix, info->processErrorSignal);
665 Print_bos_ProcessState_p(&info->state, prefix);
669 DoBosProcessInfoGet(struct cmd_syndesc *as, void *arock)
671 typedef enum { SERVER, PROCESS } DoBosProcessInfoGet_parm_t;
673 void *bos_server = NULL;
674 const char *process = NULL;
675 bos_ProcessType_t type;
676 bos_ProcessInfo_t info;
678 if (as->parms[SERVER].items) {
680 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
681 ERR_ST_EXT("bos_ServerOpen", st);
685 if (as->parms[PROCESS].items) {
686 process = as->parms[PROCESS].items->data;
689 if (!bos_ProcessInfoGet(bos_server, (char *)process, &type, &info, &st)) {
690 ERR_ST_EXT("bos_ProcessInfoGet", st);
693 Print_bos_ProcessType_p(&type, "");
694 Print_bos_ProcessInfo_p(&info, "");
700 DoBosProcessParameterList(struct cmd_syndesc *as, void *arock)
702 typedef enum { SERVER, PROCESS } DoBosProcessParameterList_parm_t;
704 void *bos_server = NULL;
705 char *process = NULL;
707 char parameter[BOS_MAX_NAME_LEN];
709 if (as->parms[SERVER].items) {
711 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
712 ERR_ST_EXT("bos_ServerOpen", st);
716 if (as->parms[PROCESS].items) {
717 process = as->parms[PROCESS].items->data;
720 if (!bos_ProcessParameterGetBegin(bos_server, process, &iter, &st)) {
721 ERR_ST_EXT("bos_ProcessParameterGetBegin", st);
724 printf("Getting parameters for %s\n", process);
726 while (bos_ProcessParameterGetNext(iter, parameter, &st)) {
727 printf("\t%s\n", parameter);
730 if (st != ADMITERATORDONE) {
731 ERR_ST_EXT("bos_ProcessParameterGetNext", st);
734 if (!bos_ProcessParameterGetDone(iter, &st)) {
735 ERR_ST_EXT("bos_ProcessParameterGetDone", st);
738 bos_ServerClose(bos_server, 0);
744 DoBosProcessNotifierGet(struct cmd_syndesc *as, void *arock)
746 typedef enum { SERVER, PROCESS } DoBosProcessNotifierGet_parm_t;
748 void *bos_server = NULL;
749 const char *process = NULL;
750 char notifier[BOS_MAX_NAME_LEN];
752 if (as->parms[SERVER].items) {
754 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
755 ERR_ST_EXT("bos_ServerOpen", st);
759 if (as->parms[PROCESS].items) {
760 process = as->parms[PROCESS].items->data;
763 if (!bos_ProcessNotifierGet(bos_server, process, notifier, &st)) {
764 ERR_ST_EXT("bos_ProcessNotifierGet", st);
767 if (notifier[0] == 0) {
768 printf("%s does not have a notifier.\n", process);
770 printf("The notifier for %s is %s\n", process, notifier);
773 bos_ServerClose(bos_server, 0);
779 DoBosProcessRestart(struct cmd_syndesc *as, void *arock)
781 typedef enum { SERVER, PROCESS } DoBosProcessRestart_parm_t;
783 void *bos_server = NULL;
784 const char *process = NULL;
786 if (as->parms[SERVER].items) {
788 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
789 ERR_ST_EXT("bos_ServerOpen", st);
793 if (as->parms[PROCESS].items) {
794 process = as->parms[PROCESS].items->data;
797 if (!bos_ProcessRestart(bos_server, process, &st)) {
798 ERR_ST_EXT("bos_ProcessRestart", st);
801 bos_ServerClose(bos_server, 0);
807 DoBosProcessAllStop(struct cmd_syndesc *as, void *arock)
809 typedef enum { SERVER } DoBosProcessAllStop_parm_t;
811 void *bos_server = NULL;
813 if (as->parms[SERVER].items) {
815 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
816 ERR_ST_EXT("bos_ServerOpen", st);
820 if (!bos_ProcessAllStop(bos_server, &st)) {
821 ERR_ST_EXT("bos_ProcessAllStop", st);
824 bos_ServerClose(bos_server, 0);
830 DoBosProcessAllStart(struct cmd_syndesc *as, void *arock)
832 typedef enum { SERVER } DoBosProcessAllStart_parm_t;
834 void *bos_server = NULL;
836 if (as->parms[SERVER].items) {
838 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
839 ERR_ST_EXT("bos_ServerOpen", st);
843 if (!bos_ProcessAllStart(bos_server, &st)) {
844 ERR_ST_EXT("bos_ProcessAllStart", st);
847 bos_ServerClose(bos_server, 0);
853 DoBosProcessAllWaitStop(struct cmd_syndesc *as, void *arock)
855 typedef enum { SERVER } DoBosProcessAllWaitStop_parm_t;
857 void *bos_server = NULL;
859 if (as->parms[SERVER].items) {
861 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
862 ERR_ST_EXT("bos_ServerOpen", st);
866 if (!bos_ProcessAllWaitStop(bos_server, &st)) {
867 ERR_ST_EXT("bos_ProcessAllWaitStop", st);
870 bos_ServerClose(bos_server, 0);
876 DoBosProcessAllWaitTransition(struct cmd_syndesc *as, void *arock)
878 typedef enum { SERVER } DoBosProcessAllWaitTransition_parm_t;
880 void *bos_server = NULL;
882 if (as->parms[SERVER].items) {
884 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
885 ERR_ST_EXT("bos_ServerOpen", st);
889 if (!bos_ProcessAllWaitTransition(bos_server, &st)) {
890 ERR_ST_EXT("bos_ProcessAllWaitTransition", st);
893 bos_ServerClose(bos_server, 0);
899 DoBosProcessAllStopAndRestart(struct cmd_syndesc *as, void *arock)
901 typedef enum { SERVER, INCLUDEBOS } DoBosProcessAllStopAndRestart_parm_t;
903 void *bos_server = NULL;
904 bos_RestartBosServer_t restart = BOS_DONT_RESTART_BOS_SERVER;
906 if (as->parms[SERVER].items) {
908 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
909 ERR_ST_EXT("bos_ServerOpen", st);
913 if (as->parms[INCLUDEBOS].items) {
914 restart = BOS_RESTART_BOS_SERVER;
917 if (!bos_ProcessAllStopAndRestart(bos_server, restart, &st)) {
918 ERR_ST_EXT("bos_ProcessAllStopAndRestart", st);
921 bos_ServerClose(bos_server, 0);
927 DoBosAdminCreate(struct cmd_syndesc *as, void *arock)
929 typedef enum { SERVER, ADMIN } DoBosAdminCreate_parm_t;
931 void *bos_server = NULL;
932 const char *admin = NULL;
934 if (as->parms[SERVER].items) {
936 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
937 ERR_ST_EXT("bos_ServerOpen", st);
941 if (as->parms[ADMIN].items) {
942 admin = as->parms[ADMIN].items->data;
945 if (!bos_AdminCreate(bos_server, admin, &st)) {
946 ERR_ST_EXT("bos_AdminCreate", st);
949 bos_ServerClose(bos_server, 0);
955 DoBosAdminDelete(struct cmd_syndesc *as, void *arock)
957 typedef enum { SERVER, ADMIN } DoBosAdminDelete_parm_t;
959 void *bos_server = NULL;
960 const char *admin = NULL;
962 if (as->parms[SERVER].items) {
964 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
965 ERR_ST_EXT("bos_ServerOpen", st);
969 if (as->parms[ADMIN].items) {
970 admin = as->parms[ADMIN].items->data;
973 if (!bos_AdminDelete(bos_server, admin, &st)) {
974 ERR_ST_EXT("bos_AdminDelete", st);
977 bos_ServerClose(bos_server, 0);
983 DoBosAdminList(struct cmd_syndesc *as, void *arock)
985 typedef enum { SERVER } DoBosAdminList_parm_t;
987 void *bos_server = NULL;
989 char admin[BOS_MAX_NAME_LEN];
991 if (as->parms[SERVER].items) {
993 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
994 ERR_ST_EXT("bos_ServerOpen", st);
998 if (!bos_AdminGetBegin(bos_server, &iter, &st)) {
999 ERR_ST_EXT("bos_AdminGetBegin", st);
1002 printf("Administrators at %s\n", as->parms[SERVER].items->data);
1004 while (bos_AdminGetNext(iter, admin, &st)) {
1005 printf("%s\n", admin);
1008 if (st != ADMITERATORDONE) {
1009 ERR_ST_EXT("bos_AdminGetNext", st);
1012 if (!bos_AdminGetDone(iter, &st)) {
1013 ERR_ST_EXT("bos_AdminGetDone", st);
1016 bos_ServerClose(bos_server, 0);
1022 DoBosKeyCreate(struct cmd_syndesc *as, void *arock)
1024 typedef enum { SERVER, VERSIONNUMBER, KEY } DoBosKeyCreate_parm_t;
1025 afs_status_t st = 0;
1026 void *bos_server = NULL;
1027 int version_number = 0;
1028 kas_encryptionKey_t key = { {0, 0, 0, 0, 0, 0, 0, 0} };
1031 if (as->parms[SERVER].items) {
1033 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1034 ERR_ST_EXT("bos_ServerOpen", st);
1038 if (as->parms[VERSIONNUMBER].items) {
1040 GetIntFromString(as->parms[VERSIONNUMBER].items->data,
1041 "invalid version number");
1044 if (as->parms[KEY].items) {
1045 const char *str = as->parms[KEY].items->data;
1046 if (!afsclient_CellNameGet(cellHandle, &cell, &st)) {
1047 ERR_ST_EXT("afsclient_CellNameGet", st);
1049 if (!kas_StringToKey(cell, str, &key, &st)) {
1050 ERR_ST_EXT("kas_StringToKey", st);
1054 if (!bos_KeyCreate(bos_server, version_number, &key, &st)) {
1055 ERR_ST_EXT("bos_KeyCreate", st);
1058 bos_ServerClose(bos_server, 0);
1064 DoBosKeyDelete(struct cmd_syndesc *as, void *arock)
1066 typedef enum { SERVER, VERSIONNUMBER } DoBosKeyDelete_parm_t;
1067 afs_status_t st = 0;
1068 void *bos_server = NULL;
1069 int version_number = 0;
1071 if (as->parms[SERVER].items) {
1073 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1074 ERR_ST_EXT("bos_ServerOpen", st);
1078 if (as->parms[VERSIONNUMBER].items) {
1080 GetIntFromString(as->parms[VERSIONNUMBER].items->data,
1081 "invalid version number");
1084 if (!bos_KeyDelete(bos_server, version_number, &st)) {
1085 ERR_ST_EXT("bos_KeyDelete", st);
1088 bos_ServerClose(bos_server, 0);
1094 Print_bos_KeyInfo_p(bos_KeyInfo_p key, const char *prefix)
1097 printf("%sVersion number: %d\n", prefix, key->keyVersionNumber);
1098 printf("%sLast modification date %d\n", prefix,
1099 key->keyStatus.lastModificationDate);
1100 printf("%sLast modification micro seconds %d\n", prefix,
1101 key->keyStatus.lastModificationMicroSeconds);
1102 printf("%sChecksum %u\n", prefix, key->keyStatus.checkSum);
1104 printf("%sKey: \n", prefix);
1105 for (i = 0; i < KAS_ENCRYPTION_KEY_LEN; i++) {
1106 printf("%s\t%d ", prefix, key->key.key[i]);
1112 DoBosKeyList(struct cmd_syndesc *as, void *arock)
1114 typedef enum { SERVER } DoBosKeyList_parm_t;
1115 afs_status_t st = 0;
1116 void *bos_server = NULL;
1120 if (as->parms[SERVER].items) {
1122 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1123 ERR_ST_EXT("bos_ServerOpen", st);
1127 if (!bos_KeyGetBegin(bos_server, &iter, &st)) {
1128 ERR_ST_EXT("bos_KeyGetBegin", st);
1131 printf("Listing keys at server %s:\n", as->parms[SERVER].items->data);
1133 while (bos_KeyGetNext(iter, &key, &st)) {
1134 Print_bos_KeyInfo_p(&key, "");
1137 if (st != ADMITERATORDONE) {
1138 ERR_ST_EXT("bos_KeyGetNext", st);
1141 if (!bos_KeyGetDone(iter, &st)) {
1142 ERR_ST_EXT("bos_KeyGetDone", st);
1145 bos_ServerClose(bos_server, 0);
1151 DoBosCellSet(struct cmd_syndesc *as, void *arock)
1153 typedef enum { SERVER, CELL } DoBosCellSet_parm_t;
1154 afs_status_t st = 0;
1155 void *bos_server = NULL;
1156 const char *cell = NULL;
1158 if (as->parms[SERVER].items) {
1160 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1161 ERR_ST_EXT("bos_ServerOpen", st);
1165 if (as->parms[SERVER].items) {
1166 cell = as->parms[SERVER].items->data;
1169 if (!bos_CellSet(bos_server, cell, &st)) {
1170 ERR_ST_EXT("bos_CellSet", st);
1173 bos_ServerClose(bos_server, 0);
1179 DoBosCellGet(struct cmd_syndesc *as, void *arock)
1181 typedef enum { SERVER } DoBosCellGet_parm_t;
1182 afs_status_t st = 0;
1183 void *bos_server = NULL;
1184 char cell[BOS_MAX_NAME_LEN];
1186 if (as->parms[SERVER].items) {
1188 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1189 ERR_ST_EXT("bos_ServerOpen", st);
1193 if (!bos_CellGet(bos_server, cell, &st)) {
1194 ERR_ST_EXT("bos_CellGet", st);
1197 printf("The cell name is %s\n", cell);
1199 bos_ServerClose(bos_server, 0);
1205 DoBosHostCreate(struct cmd_syndesc *as, void *arock)
1207 typedef enum { SERVER, HOST } DoBosHostCreate_parm_t;
1208 afs_status_t st = 0;
1209 void *bos_server = NULL;
1210 const char *host = NULL;
1212 if (as->parms[SERVER].items) {
1214 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1215 ERR_ST_EXT("bos_ServerOpen", st);
1219 if (as->parms[HOST].items) {
1220 host = as->parms[HOST].items->data;
1223 if (!bos_HostCreate(bos_server, host, &st)) {
1224 ERR_ST_EXT("bos_HostCreate", st);
1227 bos_ServerClose(bos_server, 0);
1233 DoBosHostDelete(struct cmd_syndesc *as, void *arock)
1235 typedef enum { SERVER, HOST } DoBosHostDelete_parm_t;
1236 afs_status_t st = 0;
1237 void *bos_server = NULL;
1238 const char *host = NULL;
1240 if (as->parms[SERVER].items) {
1242 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1243 ERR_ST_EXT("bos_ServerOpen", st);
1247 if (as->parms[HOST].items) {
1248 host = as->parms[HOST].items->data;
1251 if (!bos_HostDelete(bos_server, host, &st)) {
1252 ERR_ST_EXT("bos_HostDelete", st);
1255 bos_ServerClose(bos_server, 0);
1261 DoBosHostList(struct cmd_syndesc *as, void *arock)
1263 typedef enum { SERVER } DoBosHostList_parm_t;
1264 afs_status_t st = 0;
1265 void *bos_server = NULL;
1267 char host[BOS_MAX_NAME_LEN];
1269 if (as->parms[SERVER].items) {
1271 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1272 ERR_ST_EXT("bos_ServerOpen", st);
1275 printf("Listing hosts at server %s\n", as->parms[SERVER].items->data);
1278 if (!bos_HostGetBegin(bos_server, &iter, &st)) {
1279 ERR_ST_EXT("bos_HostGetBegin", st);
1283 while (bos_HostGetNext(iter, host, &st)) {
1284 printf("\t%s\n", host);
1287 if (st != ADMITERATORDONE) {
1288 ERR_ST_EXT("bos_HostGetNext", st);
1291 if (!bos_HostGetDone(iter, &st)) {
1292 ERR_ST_EXT("bos_HostGetDone", st);
1295 bos_ServerClose(bos_server, 0);
1301 DoBosExecutableCreate(struct cmd_syndesc *as, void *arock)
1303 typedef enum { SERVER, BINARY, DEST } DoBosExecutableCreate_parm_t;
1304 afs_status_t st = 0;
1305 void *bos_server = NULL;
1306 const char *binary = NULL;
1307 const char *dest = NULL;
1309 if (as->parms[SERVER].items) {
1311 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1312 ERR_ST_EXT("bos_ServerOpen", st);
1316 if (as->parms[BINARY].items) {
1317 binary = as->parms[BINARY].items->data;
1320 if (as->parms[DEST].items) {
1321 dest = as->parms[DEST].items->data;
1324 if (!bos_ExecutableCreate(bos_server, binary, dest, &st)) {
1325 ERR_ST_EXT("bos_ExecutableCreate", st);
1328 bos_ServerClose(bos_server, 0);
1334 DoBosExecutableRevert(struct cmd_syndesc *as, void *arock)
1336 typedef enum { SERVER, EXECUTABLE } DoBosExecutableRevert_parm_t;
1337 afs_status_t st = 0;
1338 void *bos_server = NULL;
1339 const char *executable = NULL;
1341 if (as->parms[SERVER].items) {
1343 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1344 ERR_ST_EXT("bos_ServerOpen", st);
1348 if (as->parms[EXECUTABLE].items) {
1349 executable = as->parms[EXECUTABLE].items->data;
1352 if (!bos_ExecutableRevert(bos_server, executable, &st)) {
1353 ERR_ST_EXT("bos_ExecutableRevert", st);
1356 bos_ServerClose(bos_server, 0);
1362 DoBosExecutableTimestampGet(struct cmd_syndesc *as, void *arock)
1364 typedef enum { SERVER, EXECUTABLE } DoBosExecutableTimestampGet_parm_t;
1365 afs_status_t st = 0;
1366 void *bos_server = NULL;
1367 const char *executable = NULL;
1368 afs_int32 new_time = 0;
1369 afs_int32 old_time = 0;
1370 afs_int32 bak_time = 0;
1372 if (as->parms[SERVER].items) {
1374 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1375 ERR_ST_EXT("bos_ServerOpen", st);
1379 if (as->parms[EXECUTABLE].items) {
1380 executable = as->parms[EXECUTABLE].items->data;
1383 if (!bos_ExecutableTimestampGet
1384 (bos_server, executable, &new_time, &old_time, &bak_time, &st)) {
1385 ERR_ST_EXT("bos_ExecutableTimestampGet", st);
1388 bos_ServerClose(bos_server, 0);
1394 DoBosExecutablePrune(struct cmd_syndesc *as, void *arock)
1396 typedef enum { SERVER, OLDFILES, BAKFILES,
1398 } DoBosExecutablePrune_parm_t;
1399 afs_status_t st = 0;
1400 void *bos_server = NULL;
1401 bos_Prune_t old_files = BOS_DONT_PRUNE;
1402 bos_Prune_t bak_files = BOS_DONT_PRUNE;
1403 bos_Prune_t core_files = BOS_DONT_PRUNE;
1405 if (as->parms[SERVER].items) {
1407 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1408 ERR_ST_EXT("bos_ServerOpen", st);
1412 if (as->parms[OLDFILES].items) {
1413 old_files = BOS_PRUNE;
1416 if (as->parms[BAKFILES].items) {
1417 bak_files = BOS_PRUNE;
1420 if (as->parms[COREFILES].items) {
1421 core_files = BOS_PRUNE;
1424 if (!bos_ExecutablePrune
1425 (bos_server, old_files, bak_files, core_files, &st)) {
1426 ERR_ST_EXT("bos_ExecutablePrune", st);
1429 bos_ServerClose(bos_server, 0);
1435 DoBosExecutableRestartTimeSet(struct cmd_syndesc *as, void *arock)
1437 typedef enum { SERVER, DAILY, WEEKLY,
1439 } DoBosExecutableRestartTimeSet_parm_t;
1440 afs_status_t st = 0;
1441 void *bos_server = NULL;
1442 bos_Restart_t type = 0;
1444 int have_weekly = 0;
1445 bos_RestartTime_t time;
1447 if (as->parms[SERVER].items) {
1449 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1450 ERR_ST_EXT("bos_ServerOpen", st);
1454 if (as->parms[DAILY].items) {
1455 type = BOS_RESTART_DAILY;
1459 if (as->parms[WEEKLY].items) {
1460 type = BOS_RESTART_WEEKLY;
1464 if ((have_daily == 0) && (have_weekly == 0)) {
1465 ERR_EXT("must specify either daily or weekly");
1468 if ((have_daily == 1) && (have_weekly == 1)) {
1469 ERR_EXT("must specify either daily or weekly, not both");
1472 if (as->parms[TIME].items) {
1473 if (ktime_ParsePeriodic(as->parms[TIME].items->data, &time) == -1) {
1474 ERR_EXT("error parsing time");
1478 if (!bos_ExecutableRestartTimeSet(bos_server, type, time, &st)) {
1479 ERR_ST_EXT("bos_ExecutableRestartTimeSet", st);
1482 bos_ServerClose(bos_server, 0);
1488 Print_bos_RestartTime_p(bos_RestartTime_p restart, const char *prefix)
1490 char tempString[50];
1496 if (restart->mask & BOS_RESTART_TIME_NEVER) {
1497 printf("%snever\n", prefix);
1498 } else if (restart->mask & BOS_RESTART_TIME_NOW) {
1499 printf("%snow\n", prefix);
1501 strcpy(astring, "at");
1502 if (restart->mask & BOS_RESTART_TIME_DAY) {
1503 strcat(astring, " ");
1504 strcat(astring, day[restart->day]);
1506 if (restart->mask & BOS_RESTART_TIME_HOUR) {
1507 if (restart->hour > 12)
1508 sprintf(tempString, " %d", restart->hour - 12);
1509 else if (restart->hour == 0)
1510 strcpy(tempString, " 12");
1512 sprintf(tempString, " %d", restart->hour);
1513 strcat(astring, tempString);
1515 if (restart->mask & BOS_RESTART_TIME_MINUTE) {
1516 sprintf(tempString, ":%02d", restart->min);
1517 strcat(astring, tempString);
1519 if ((restart->mask & BOS_RESTART_TIME_SECOND) && restart->sec != 0) {
1520 sprintf(tempString, ":%02d", restart->sec);
1521 strcat(astring, tempString);
1523 if (restart->mask & BOS_RESTART_TIME_HOUR) {
1524 if (restart->hour >= 12)
1525 strcat(astring, " pm");
1527 strcat(astring, " am");
1529 printf("%s%s\n", prefix, astring);
1534 DoBosExecutableRestartTimeGet(struct cmd_syndesc *as, void *arock)
1536 typedef enum { SERVER, DAILY,
1538 } DoBosExecutableRestartTimeGet_parm_t;
1539 afs_status_t st = 0;
1540 void *bos_server = NULL;
1541 bos_Restart_t type = 0;
1543 int have_weekly = 0;
1544 bos_RestartTime_t restart_time;
1546 if (as->parms[SERVER].items) {
1548 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1549 ERR_ST_EXT("bos_ServerOpen", st);
1553 if (as->parms[DAILY].items) {
1554 type = BOS_RESTART_DAILY;
1558 if (as->parms[WEEKLY].items) {
1559 type = BOS_RESTART_WEEKLY;
1563 if ((have_daily == 0) && (have_weekly == 0)) {
1564 ERR_EXT("must specify either daily or weekly");
1567 if ((have_daily == 1) && (have_weekly == 1)) {
1568 ERR_EXT("must specify either daily or weekly, not both");
1571 if (!bos_ExecutableRestartTimeGet(bos_server, type, &restart_time, &st)) {
1572 ERR_ST_EXT("bos_ExecutableRestartTimeGet", st);
1575 Print_bos_RestartTime_p(&restart_time, "");
1577 bos_ServerClose(bos_server, 0);
1582 #define INITIAL_BUF_SIZE 4096
1585 DoBosLogGet(struct cmd_syndesc *as, void *arock)
1587 typedef enum { SERVER, LOGFILE } DoBosLogGet_parm_t;
1588 afs_status_t st = 0;
1589 void *bos_server = NULL;
1590 const char *log_file = NULL;
1591 unsigned long buf_size = INITIAL_BUF_SIZE;
1594 if (as->parms[SERVER].items) {
1596 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1597 ERR_ST_EXT("bos_ServerOpen", st);
1601 if (as->parms[LOGFILE].items) {
1602 log_file = as->parms[LOGFILE].items->data;
1606 while (st == ADMMOREDATA) {
1607 buf = realloc(buf, buf_size);
1609 ERR_EXT("cannot dynamically allocate memory");
1611 bos_LogGet(bos_server, log_file, &buf_size, buf, &st);
1612 if (st == ADMMOREDATA) {
1613 buf_size = buf_size + (unsigned long)(0.2 * buf_size);
1618 ERR_ST_EXT("bos_LogGet", st);
1620 printf("Log file:\n%s", buf);
1627 bos_ServerClose(bos_server, 0);
1633 DoBosAuthSet(struct cmd_syndesc *as, void *arock)
1635 typedef enum { SERVER, REQUIREAUTH, DISABLEAUTH } DoBosAuthSet_parm_t;
1636 afs_status_t st = 0;
1637 void *bos_server = NULL;
1638 bos_Auth_t auth = 0;
1642 if (as->parms[SERVER].items) {
1644 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1645 ERR_ST_EXT("bos_ServerOpen", st);
1649 if (as->parms[REQUIREAUTH].items) {
1650 auth = BOS_AUTH_REQUIRED;
1654 if (as->parms[DISABLEAUTH].items) {
1659 if ((have_req == 0) && (have_dis == 0)) {
1660 ERR_EXT("must specify either requireauth or disableauth");
1663 if ((have_req == 1) && (have_dis == 1)) {
1664 ERR_EXT("must specify either requireauth or disableauth, not both");
1667 if (!bos_AuthSet(bos_server, auth, &st)) {
1668 ERR_ST_EXT("bos_AuthSet", st);
1671 bos_ServerClose(bos_server, 0);
1677 DoBosCommandExecute(struct cmd_syndesc *as, void *arock)
1679 typedef enum { SERVER, COMMAND } DoBosCommandExecute_parm_t;
1680 afs_status_t st = 0;
1681 void *bos_server = NULL;
1682 const char *command = NULL;
1684 if (as->parms[SERVER].items) {
1686 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1687 ERR_ST_EXT("bos_ServerOpen", st);
1691 if (as->parms[COMMAND].items) {
1692 command = as->parms[COMMAND].items->data;
1695 if (!bos_CommandExecute(bos_server, command, &st)) {
1696 ERR_ST_EXT("bos_CommandExecute", st);
1699 bos_ServerClose(bos_server, 0);
1705 DoBosSalvage(struct cmd_syndesc *as, void *arock)
1707 typedef enum { SERVER, PARTITION, VOLUME, NUMSALVAGERS, TMPDIR, LOGFILE,
1708 FORCE, NOWRITE, INODES, ROOTINODES, SALVAGEDIRS, BLOCKREADS
1709 } DoBosSalvage_parm_t;
1710 afs_status_t st = 0;
1711 void *bos_server = NULL;
1712 const char *partition = NULL;
1713 const char *volume = NULL;
1714 int num_salvagers = 1;
1715 const char *tmp_dir = NULL;
1716 const char *log_file = NULL;
1717 vos_force_t force = VOS_NORMAL;
1718 bos_SalvageDamagedVolumes_t no_write = BOS_SALVAGE_DAMAGED_VOLUMES;
1719 bos_WriteInodes_t inodes = BOS_SALVAGE_WRITE_INODES;
1720 bos_WriteRootInodes_t root_inodes = BOS_SALVAGE_WRITE_ROOT_INODES;
1721 bos_ForceDirectory_t salvage_dirs = BOS_SALVAGE_DONT_FORCE_DIRECTORIES;
1722 bos_ForceBlockRead_t block_reads = BOS_SALVAGE_DONT_FORCE_BLOCK_READS;
1725 if (as->parms[SERVER].items) {
1727 (cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
1728 ERR_ST_EXT("bos_ServerOpen", st);
1732 if (as->parms[PARTITION].items) {
1733 partition = as->parms[PARTITION].items->data;
1736 if (as->parms[VOLUME].items) {
1737 volume = as->parms[VOLUME].items->data;
1740 if (as->parms[NUMSALVAGERS].items) {
1742 GetIntFromString(as->parms[NUMSALVAGERS].items->data,
1743 "invalid number of salvagers");
1746 if (as->parms[TMPDIR].items) {
1747 tmp_dir = as->parms[TMPDIR].items->data;
1750 if (as->parms[LOGFILE].items) {
1751 log_file = as->parms[LOGFILE].items->data;
1754 if (as->parms[FORCE].items) {
1758 if (as->parms[NOWRITE].items) {
1759 no_write = BOS_DONT_SALVAGE_DAMAGED_VOLUMES;
1762 if (as->parms[INODES].items) {
1763 inodes = BOS_SALVAGE_DONT_WRITE_INODES;
1766 if (as->parms[ROOTINODES].items) {
1767 root_inodes = BOS_SALVAGE_DONT_WRITE_ROOT_INODES;
1770 if (as->parms[SALVAGEDIRS].items) {
1771 salvage_dirs = BOS_SALVAGE_FORCE_DIRECTORIES;
1774 if (as->parms[BLOCKREADS].items) {
1775 block_reads = BOS_SALVAGE_FORCE_BLOCK_READS;
1779 (cellHandle, bos_server, partition, volume, num_salvagers, tmp_dir,
1780 log_file, force, no_write, inodes, root_inodes, salvage_dirs,
1781 block_reads, &st)) {
1782 ERR_ST_EXT("bos_Salvage", st);
1785 bos_ServerClose(bos_server, 0);
1792 Print_afs_RPCStatsState_p(afs_RPCStatsState_p state, const char *prefix)
1794 printf("%sThe rpc stats state is: ", prefix);
1796 case AFS_RPC_STATS_DISABLED:
1797 printf("disabled\n");
1799 case AFS_RPC_STATS_ENABLED:
1800 printf("enabled\n");
1807 SetupBosAdminCmd(void)
1809 struct cmd_syndesc *ts;
1811 ts = cmd_CreateSyntax("BosProcessCreate", DoBosProcessCreate, NULL,
1812 "create a new bos process");
1813 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1814 "server where process will be created");
1815 cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1816 "the name of the process");
1817 cmd_AddParm(ts, "-binary", CMD_SINGLE, CMD_REQUIRED,
1818 "path to the process binary");
1819 cmd_AddParm(ts, "-cron", CMD_FLAG, CMD_OPTIONAL,
1820 "this is a cron process");
1821 cmd_AddParm(ts, "-crontime", CMD_SINGLE, CMD_OPTIONAL,
1822 "the time when the process will be run");
1823 cmd_AddParm(ts, "-notifier", CMD_SINGLE, CMD_OPTIONAL,
1824 "path to notifier binary that is run when process terminates");
1825 SetupCommonCmdArgs(ts);
1827 ts = cmd_CreateSyntax("BosFSProcessCreate", DoBosFSProcessCreate, NULL,
1828 "create a fs bos process");
1829 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1830 "server where process will be created");
1831 cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1832 "the name of the process");
1833 cmd_AddParm(ts, "-fileserver", CMD_SINGLE, CMD_REQUIRED,
1834 "path to the fileserver binary");
1835 cmd_AddParm(ts, "-volserver", CMD_SINGLE, CMD_REQUIRED,
1836 "path to the volserver binary");
1837 cmd_AddParm(ts, "-salvager", CMD_SINGLE, CMD_REQUIRED,
1838 "path to the salvager binary");
1839 cmd_AddParm(ts, "-notifier", CMD_SINGLE, CMD_OPTIONAL,
1840 "path to notifier binary that is run when process terminates");
1841 SetupCommonCmdArgs(ts);
1843 ts = cmd_CreateSyntax("BosProcessDelete", DoBosProcessDelete, NULL,
1844 "delete a bos process");
1845 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1846 "server where process will be deleted");
1847 cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1848 "the name of the process");
1849 SetupCommonCmdArgs(ts);
1851 ts = cmd_CreateSyntax("BosProcessExecutionStateGet",
1852 DoBosProcessExecutionStateGet, NULL,
1853 "get the process execution state of a process");
1854 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1855 "server where process exists");
1856 cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1857 "the name of the process");
1858 SetupCommonCmdArgs(ts);
1860 ts = cmd_CreateSyntax("BosProcessExecutionStateSet",
1861 DoBosProcessExecutionStateSet, NULL,
1862 "set the process execution state of a process");
1863 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1864 "server where process exists");
1865 cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1866 "the name of the process");
1867 cmd_AddParm(ts, "-stopped", CMD_FLAG, CMD_OPTIONAL,
1868 "set the process state to stopped");
1869 cmd_AddParm(ts, "-running", CMD_FLAG, CMD_OPTIONAL,
1870 "set the process state to running");
1871 SetupCommonCmdArgs(ts);
1873 ts = cmd_CreateSyntax("BosProcessExecutionStateSetTemporary",
1874 DoBosProcessExecutionStateSetTemporary, NULL,
1875 "set the process execution state "
1876 "of a process temporarily");
1877 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1878 "server where process exists");
1879 cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1880 "the name of the process");
1881 cmd_AddParm(ts, "-stopped", CMD_FLAG, CMD_OPTIONAL,
1882 "set the process state to stopped");
1883 cmd_AddParm(ts, "-running", CMD_FLAG, CMD_OPTIONAL,
1884 "set the process state to running");
1885 SetupCommonCmdArgs(ts);
1887 ts = cmd_CreateSyntax("BosProcessNameList", DoBosProcessNameList, NULL,
1888 "list the names of all processes at a bos server");
1889 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
1890 SetupCommonCmdArgs(ts);
1892 ts = cmd_CreateSyntax("BosProcessInfoGet", DoBosProcessInfoGet, NULL,
1893 "get information about a process");
1894 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1895 "server where process exists");
1896 cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1897 "the name of the process");
1898 SetupCommonCmdArgs(ts);
1900 ts = cmd_CreateSyntax("BosProcessParameterList",
1901 DoBosProcessParameterList, NULL,
1902 "list the parameters of a process");
1903 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1904 "server where process exists");
1905 cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1906 "the name of the process");
1907 SetupCommonCmdArgs(ts);
1909 ts = cmd_CreateSyntax("BosProcessNotifierGet", DoBosProcessNotifierGet, NULL,
1910 "get the notifier for a process");
1911 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1912 "server where process exists");
1913 cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1914 "the name of the process");
1915 SetupCommonCmdArgs(ts);
1917 ts = cmd_CreateSyntax("BosProcessRestart", DoBosProcessRestart, NULL,
1918 "restart a process");
1919 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1920 "server where process exists");
1921 cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED,
1922 "the name of the process");
1923 SetupCommonCmdArgs(ts);
1925 ts = cmd_CreateSyntax("BosProcessAllStop", DoBosProcessAllStop, NULL,
1926 "stop all processes at a bos server");
1927 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1928 "server where processes exists");
1929 SetupCommonCmdArgs(ts);
1931 ts = cmd_CreateSyntax("BosProcessAllWaitStop", DoBosProcessAllWaitStop, NULL,
1932 "stop all processes at a bos server and block "
1933 "until they all exit");
1934 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1935 "server where processes exists");
1936 SetupCommonCmdArgs(ts);
1938 ts = cmd_CreateSyntax("BosProcessAllWaitTransition",
1939 DoBosProcessAllWaitTransition, NULL,
1940 "wait until all processes have transitioned to "
1941 "their desired state");
1942 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1943 "server where processes exists");
1944 SetupCommonCmdArgs(ts);
1946 ts = cmd_CreateSyntax("BosProcessAllStopAndRestart",
1947 DoBosProcessAllStopAndRestart, NULL,
1948 "stop all processes at a bos server and "
1949 "then restart them");
1950 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1951 "server where processes exists");
1952 cmd_AddParm(ts, "-includebos", CMD_FLAG, CMD_OPTIONAL,
1953 "include the bos server in the processes to be restarted");
1954 SetupCommonCmdArgs(ts);
1956 ts = cmd_CreateSyntax("BosAdminCreate", DoBosAdminCreate, NULL,
1957 "create an admin user at a bos server");
1958 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1959 "server where admin will be created");
1960 cmd_AddParm(ts, "-admin", CMD_SINGLE, CMD_REQUIRED,
1961 "the name of the administrator to add");
1962 SetupCommonCmdArgs(ts);
1964 ts = cmd_CreateSyntax("BosAdminDelete", DoBosAdminDelete, NULL,
1965 "delete an admin user at a bos server");
1966 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1967 "server where admin will be deleted");
1968 cmd_AddParm(ts, "-admin", CMD_SINGLE, CMD_REQUIRED,
1969 "the name of the administrator to delete");
1970 SetupCommonCmdArgs(ts);
1972 ts = cmd_CreateSyntax("BosAdminList", DoBosAdminList, NULL,
1973 "list all admin users at a bos server");
1974 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1975 "server where admins will be listed");
1976 SetupCommonCmdArgs(ts);
1978 ts = cmd_CreateSyntax("BosKeyCreate", DoBosKeyCreate, NULL,
1979 "create a key at a bos server");
1980 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1981 "server where key will be created");
1982 cmd_AddParm(ts, "-versionnumber", CMD_SINGLE, CMD_REQUIRED,
1983 "version number of new key");
1984 cmd_AddParm(ts, "-key", CMD_SINGLE, CMD_REQUIRED, "new encryption key");
1985 SetupCommonCmdArgs(ts);
1987 ts = cmd_CreateSyntax("BosKeyDelete", DoBosKeyDelete, NULL,
1988 "delete a key at a bos server");
1989 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1990 "server where key will be deleted");
1991 cmd_AddParm(ts, "-versionnumber", CMD_SINGLE, CMD_REQUIRED,
1992 "version number of the key");
1993 SetupCommonCmdArgs(ts);
1995 ts = cmd_CreateSyntax("BosKeyList", DoBosKeyList, NULL,
1996 "list keys at a bos server");
1997 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
1998 "server where keys exist");
1999 SetupCommonCmdArgs(ts);
2001 ts = cmd_CreateSyntax("BosCellSet", DoBosCellSet, NULL,
2002 "set the cell at a bos server");
2003 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2004 cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_REQUIRED, "new cell");
2005 SetupCommonCmdArgs(ts);
2007 ts = cmd_CreateSyntax("BosCellGet", DoBosCellGet, NULL,
2008 "get the cell at a bos server");
2009 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
2010 SetupCommonCmdArgs(ts);
2012 ts = cmd_CreateSyntax("BosHostCreate", DoBosHostCreate, NULL,
2013 "add a host entry to the server CellServDB");
2014 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2015 cmd_AddParm(ts, "-host", CMD_SINGLE, CMD_REQUIRED, "host to add");
2016 SetupCommonCmdArgs(ts);
2018 ts = cmd_CreateSyntax("BosHostDelete", DoBosHostDelete, NULL,
2019 "delete a host entry from the server CellServDB");
2020 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2021 cmd_AddParm(ts, "-host", CMD_SINGLE, CMD_REQUIRED, "host to delete");
2022 SetupCommonCmdArgs(ts);
2024 ts = cmd_CreateSyntax("BosHostList", DoBosHostList, NULL,
2025 "list all host entries from the server CellServDB");
2026 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
2027 SetupCommonCmdArgs(ts);
2029 ts = cmd_CreateSyntax("BosExecutableCreate", DoBosExecutableCreate, NULL,
2030 "create a new binary at a bos server");
2031 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2032 cmd_AddParm(ts, "-binary", CMD_SINGLE, CMD_REQUIRED,
2033 "path to the binary to create");
2034 cmd_AddParm(ts, "-dest", CMD_SINGLE, CMD_REQUIRED,
2035 "path where the binary will be stored");
2036 SetupCommonCmdArgs(ts);
2038 ts = cmd_CreateSyntax("BosExecutableRevert", DoBosExecutableRevert, NULL,
2039 "revert a binary at a bos server");
2040 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2041 cmd_AddParm(ts, "-executable", CMD_SINGLE, CMD_REQUIRED,
2042 "path to the binary to revert");
2043 SetupCommonCmdArgs(ts);
2045 ts = cmd_CreateSyntax("BosExecutableTimestampGet",
2046 DoBosExecutableTimestampGet, NULL,
2047 "get the timestamps for a binary at bos server");
2048 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
2049 cmd_AddParm(ts, "-executable", CMD_SINGLE, CMD_REQUIRED,
2050 "path to the binary to revert");
2051 SetupCommonCmdArgs(ts);
2053 ts = cmd_CreateSyntax("BosExecutablePrune", DoBosExecutablePrune, NULL,
2054 "prune various files at bos server");
2055 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2056 cmd_AddParm(ts, "-oldfiles", CMD_FLAG, CMD_OPTIONAL, "prune .old files");
2057 cmd_AddParm(ts, "-bakfiles", CMD_FLAG, CMD_OPTIONAL, "prune .bak files");
2058 cmd_AddParm(ts, "-corefiles", CMD_FLAG, CMD_OPTIONAL, "prune core files");
2059 SetupCommonCmdArgs(ts);
2061 ts = cmd_CreateSyntax("BosExecutableRestartTimeSet",
2062 DoBosExecutableRestartTimeSet, NULL,
2063 "set the restart times at a bos server");
2064 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2065 cmd_AddParm(ts, "-daily", CMD_FLAG, CMD_OPTIONAL,
2066 "set daily restart time");
2067 cmd_AddParm(ts, "-weekly", CMD_FLAG, CMD_OPTIONAL,
2068 "set weekly restart time");
2069 cmd_AddParm(ts, "-time", CMD_SINGLE, CMD_REQUIRED,
2070 "the new restart time");
2071 SetupCommonCmdArgs(ts);
2073 ts = cmd_CreateSyntax("BosExecutableRestartTimeGet",
2074 DoBosExecutableRestartTimeGet, NULL,
2075 "get the restart times at a bos server");
2076 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
2077 cmd_AddParm(ts, "-daily", CMD_FLAG, CMD_OPTIONAL,
2078 "get daily restart time");
2079 cmd_AddParm(ts, "-weekly", CMD_FLAG, CMD_OPTIONAL,
2080 "get weekly restart time");
2081 SetupCommonCmdArgs(ts);
2083 ts = cmd_CreateSyntax("BosLogGet", DoBosLogGet, NULL,
2084 "get a log file from the bos server");
2085 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
2086 cmd_AddParm(ts, "-logfile", CMD_SINGLE, CMD_REQUIRED,
2087 "path to the log file to retrieve");
2088 SetupCommonCmdArgs(ts);
2090 ts = cmd_CreateSyntax("BosAuthSet", DoBosAuthSet, NULL,
2091 "set the authorization level at a bos server");
2092 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
2093 cmd_AddParm(ts, "-requireauth", CMD_FLAG, CMD_OPTIONAL,
2094 "require authorization");
2095 cmd_AddParm(ts, "-disableauth", CMD_FLAG, CMD_OPTIONAL,
2096 "don't require authorization");
2097 SetupCommonCmdArgs(ts);
2099 ts = cmd_CreateSyntax("BosCommandExecute", DoBosCommandExecute, 0,
2100 "execute a command at a bos server");
2101 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2102 "server where command will execute");
2103 cmd_AddParm(ts, "-command", CMD_SINGLE, CMD_REQUIRED,
2104 "command to execute");
2105 SetupCommonCmdArgs(ts);
2107 ts = cmd_CreateSyntax("BosSalvage", DoBosSalvage, NULL,
2108 "execute a salvage command at a bos server");
2109 cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
2110 "server where salvager will execute");
2111 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
2112 "partition to salvage");
2113 cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_OPTIONAL, "volume to salvage");
2114 cmd_AddParm(ts, "-numsalvagers", CMD_SINGLE, CMD_REQUIRED,
2115 "number of salvagers to run in parallel");
2116 cmd_AddParm(ts, "-tmpdir", CMD_SINGLE, CMD_OPTIONAL,
2117 "directory to place temporary files");
2118 cmd_AddParm(ts, "-logfile", CMD_SINGLE, CMD_OPTIONAL,
2119 "file where salvager log will be written");
2120 cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL, "run salvager -force");
2121 cmd_AddParm(ts, "-nowrite", CMD_FLAG, CMD_OPTIONAL,
2122 "run salvager -nowrite");
2123 cmd_AddParm(ts, "-inodes", CMD_FLAG, CMD_OPTIONAL,
2124 "run salvager -inodes");
2125 cmd_AddParm(ts, "-rootinodes", CMD_FLAG, CMD_OPTIONAL,
2126 "run salvager -rootinodes");
2127 cmd_AddParm(ts, "-salvagedirs", CMD_FLAG, CMD_OPTIONAL,
2128 "run salvager -salvagedirs");
2129 cmd_AddParm(ts, "-blockreads", CMD_FLAG, CMD_OPTIONAL,
2130 "run salvager -blockreads");
2131 SetupCommonCmdArgs(ts);