#include <afsconfig.h>
#include <afs/param.h>
-RCSID
- ("$Header$");
+#include <roken.h>
+
+#include <ctype.h>
#include "bos.h"
"sat"
};
-static
+static int
LocalFreeTokens(struct token *alist)
{
- register struct token *nlist;
+ struct token *nlist;
for (; alist; alist = nlist) {
nlist = alist->next;
free(alist->key);
return 0;
}
-static
+static int
space(int x)
{
if (x == 0 || x == ' ' || x == '\t' || x == '\n')
return 0;
}
-static
+static int
LocalParseLine(char *aline, struct token **alist)
{
char tbuffer[256];
- register char *tptr;
+ char *tptr = NULL;
int inToken;
struct token *first, *last;
- register struct token *ttok;
- register int tc;
+ struct token *ttok;
+ int tc;
inToken = 0; /* not copying token chars at start */
first = NULL;
if (inToken) {
inToken = 0; /* end of this token */
*tptr++ = 0;
- ttok = (struct token *)malloc(sizeof(struct token));
+ ttok = malloc(sizeof(struct token));
ttok->next = NULL;
- ttok->key = (char *)malloc(strlen(tbuffer) + 1);
- strcpy(ttok->key, tbuffer);
+ ttok->key = strdup(tbuffer);
if (last) {
last->next = ttok;
last = ttok;
char *key;
afs_int32 value;
} ptkeys[] = {
-"sun", 0x10000, "mon", 0x10001, "tue", 0x10002, "wed", 0x10003, "thu",
- 0x10004, "fri", 0x10005, "sat", 0x10006, "sunday", 0x10000,
- "monday", 0x10001, "tuesday", 0x10002, "wednesday", 0x10003,
- "thursday", 0x10004, "thur", 0x10004, "friday", 0x10005,
- "saturday", 0x10006, "am", 0x20000, "pm", 0x20001, "a.m.",
- 0x20000, "p.m.", 0x20001, 0, 0,};
-
-static
+ {"sun", 0x10000}, {"mon", 0x10001}, {"tue", 0x10002},
+ {"wed", 0x10003}, {"thu", 0x10004}, {"fri", 0x10005},
+ {"sat", 0x10006},
+ {"sunday", 0x10000}, {"monday", 0x10001},
+ {"tuesday", 0x10002}, {"wednesday", 0x10003},
+ {"thursday", 0x10004}, {"thur", 0x10004},
+ {"friday", 0x10005}, {"saturday", 0x10006},
+ {"am", 0x20000}, {"pm", 0x20001},
+ {"a.m.", 0x20000}, {"p.m.", 0x20001}, {0, 0}};
+
+static int
ParseTime(bos_RestartTime_p ak, char *astr)
{
int field;
short temp;
- register char *tp;
- register int tc;
+ char *tp;
+ int tc;
field = 0; /* 0=hour, 1=min, 2=sec */
temp = 0;
ktime_ParsePeriodic(char *adate, bos_RestartTime_p ak)
{
struct token *tt;
- register afs_int32 code;
+ afs_int32 code;
struct ptemp *tp;
memset(ak, 0, sizeof(*ak));
}
int
-DoBosProcessCreate(struct cmd_syndesc *as, char *arock)
+DoBosProcessCreate(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, PROCESS, BINARY, CRON, CRONTIME,
+ enum { SERVER, PROCESS, BINARY, CRON, CRONTIME,
NOTIFIER
- } DoBosProcessCreate_parm_t;
+ };
afs_status_t st = 0;
void *bos_server = NULL;
const char *process = NULL;
}
if (!bos_ProcessCreate
- (bos_server, process, process_type, binary, cron_time, notifier,
+ (bos_server, (char *)process, process_type, (char *)binary, (char *)cron_time, (char *)notifier,
&st)) {
ERR_ST_EXT("bos_ProcessCreate", st);
}
}
int
-DoBosFSProcessCreate(struct cmd_syndesc *as, char *arock)
+DoBosFSProcessCreate(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, PROCESS, FILESERVER, VOLSERVER, SALVAGER,
+ enum { SERVER, PROCESS, FILESERVER, VOLSERVER, SALVAGER,
NOTIFIER
- } DoBosFSProcessCreate_parm_t;
+ };
afs_status_t st = 0;
void *bos_server = NULL;
const char *process = NULL;
}
if (!bos_FSProcessCreate
- (bos_server, process, fileserver, volserver, salvager, notifier,
+ (bos_server, (char *)process, (char *)fileserver, (char *)volserver, (char *)salvager, (char *)notifier,
&st)) {
ERR_ST_EXT("bos_FSProcessCreate", st);
}
}
int
-DoBosProcessDelete(struct cmd_syndesc *as, char *arock)
+DoBosProcessDelete(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, PROCESS } DoBosProcessDelete_parm_t;
+ enum { SERVER, PROCESS };
afs_status_t st = 0;
void *bos_server = NULL;
const char *process = NULL;
process = as->parms[PROCESS].items->data;
}
- if (!bos_ProcessDelete(bos_server, process, &st)) {
+ if (!bos_ProcessDelete(bos_server, (char *)process, &st)) {
ERR_ST_EXT("bos_ProcessDelete", st);
}
}
int
-DoBosProcessExecutionStateGet(struct cmd_syndesc *as, char *arock)
+DoBosProcessExecutionStateGet(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, PROCESS } DoBosProcessExecutionStateGet_parm_t;
+ enum { SERVER, PROCESS };
afs_status_t st = 0;
void *bos_server = NULL;
const char *process = NULL;
}
if (!bos_ProcessExecutionStateGet
- (bos_server, process, &state, aux_status, &st)) {
+ (bos_server, (char *)process, &state, aux_status, &st)) {
ERR_ST_EXT("bos_ProcessExecutionStateGet", st);
}
}
int
-DoBosProcessExecutionStateSet(struct cmd_syndesc *as, char *arock)
+DoBosProcessExecutionStateSet(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, PROCESS, STOPPED,
+ enum { SERVER, PROCESS, STOPPED,
RUNNING
- } DoBosProcessExecutionStateSet_parm_t;
+ };
afs_status_t st = 0;
void *bos_server = NULL;
const char *process = NULL;
int stop = 0;
int run = 0;
- bos_ProcessExecutionState_t state;
+ bos_ProcessExecutionState_t state = 0;
if (as->parms[SERVER].items) {
if (!bos_ServerOpen
}
int
-DoBosProcessExecutionStateSetTemporary(struct cmd_syndesc *as, char *arock)
+DoBosProcessExecutionStateSetTemporary(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, PROCESS, STOPPED,
+ enum { SERVER, PROCESS, STOPPED,
RUNNING
- } DoBosProcessExecutionStateSetTemporary_parm_t;
+ };
afs_status_t st = 0;
void *bos_server = NULL;
const char *process = NULL;
int stop = 0;
int run = 0;
- bos_ProcessExecutionState_t state;
+ bos_ProcessExecutionState_t state = 0;
if (as->parms[SERVER].items) {
if (!bos_ServerOpen
}
if (!bos_ProcessExecutionStateSetTemporary
- (bos_server, process, state, &st)) {
+ (bos_server, (char *)process, state, &st)) {
ERR_ST_EXT("bos_ProcessExecutionStateSetTemporary", st);
}
}
int
-DoBosProcessNameList(struct cmd_syndesc *as, char *arock)
+DoBosProcessNameList(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER } DoBosProcessNameList_parm_t;
+ enum { SERVER };
afs_status_t st = 0;
void *bos_server = NULL;
void *iter = NULL;
}
int
-DoBosProcessInfoGet(struct cmd_syndesc *as, char *arock)
+DoBosProcessInfoGet(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, PROCESS } DoBosProcessInfoGet_parm_t;
+ enum { SERVER, PROCESS };
afs_status_t st = 0;
void *bos_server = NULL;
const char *process = NULL;
process = as->parms[PROCESS].items->data;
}
- if (!bos_ProcessInfoGet(bos_server, process, &type, &info, &st)) {
+ if (!bos_ProcessInfoGet(bos_server, (char *)process, &type, &info, &st)) {
ERR_ST_EXT("bos_ProcessInfoGet", st);
}
}
int
-DoBosProcessParameterList(struct cmd_syndesc *as, char *arock)
+DoBosProcessParameterList(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, PROCESS } DoBosProcessParameterList_parm_t;
+ enum { SERVER, PROCESS };
afs_status_t st = 0;
void *bos_server = NULL;
char *process = NULL;
}
int
-DoBosProcessNotifierGet(struct cmd_syndesc *as, char *arock)
+DoBosProcessNotifierGet(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, PROCESS } DoBosProcessNotifierGet_parm_t;
+ enum { SERVER, PROCESS };
afs_status_t st = 0;
void *bos_server = NULL;
const char *process = NULL;
}
int
-DoBosProcessRestart(struct cmd_syndesc *as, char *arock)
+DoBosProcessRestart(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, PROCESS } DoBosProcessRestart_parm_t;
+ enum { SERVER, PROCESS };
afs_status_t st = 0;
void *bos_server = NULL;
const char *process = NULL;
}
int
-DoBosProcessAllStop(struct cmd_syndesc *as, char *arock)
+DoBosProcessAllStop(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER } DoBosProcessAllStop_parm_t;
+ enum { SERVER };
afs_status_t st = 0;
void *bos_server = NULL;
}
int
-DoBosProcessAllStart(struct cmd_syndesc *as, char *arock)
+DoBosProcessAllStart(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER } DoBosProcessAllStart_parm_t;
+ enum { SERVER };
afs_status_t st = 0;
void *bos_server = NULL;
}
int
-DoBosProcessAllWaitStop(struct cmd_syndesc *as, char *arock)
+DoBosProcessAllWaitStop(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER } DoBosProcessAllWaitStop_parm_t;
+ enum { SERVER };
afs_status_t st = 0;
void *bos_server = NULL;
}
int
-DoBosProcessAllWaitTransition(struct cmd_syndesc *as, char *arock)
+DoBosProcessAllWaitTransition(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER } DoBosProcessAllWaitTransition_parm_t;
+ enum { SERVER };
afs_status_t st = 0;
void *bos_server = NULL;
}
int
-DoBosProcessAllStopAndRestart(struct cmd_syndesc *as, char *arock)
+DoBosProcessAllStopAndRestart(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, INCLUDEBOS } DoBosProcessAllStopAndRestart_parm_t;
+ enum { SERVER, INCLUDEBOS };
afs_status_t st = 0;
void *bos_server = NULL;
bos_RestartBosServer_t restart = BOS_DONT_RESTART_BOS_SERVER;
}
int
-DoBosAdminCreate(struct cmd_syndesc *as, char *arock)
+DoBosAdminCreate(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, ADMIN } DoBosAdminCreate_parm_t;
+ enum { SERVER, ADMIN };
afs_status_t st = 0;
void *bos_server = NULL;
- const char *admin;
+ const char *admin = NULL;
if (as->parms[SERVER].items) {
if (!bos_ServerOpen
}
int
-DoBosAdminDelete(struct cmd_syndesc *as, char *arock)
+DoBosAdminDelete(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, ADMIN } DoBosAdminDelete_parm_t;
+ enum { SERVER, ADMIN };
afs_status_t st = 0;
void *bos_server = NULL;
- const char *admin;
+ const char *admin = NULL;
if (as->parms[SERVER].items) {
if (!bos_ServerOpen
}
int
-DoBosAdminList(struct cmd_syndesc *as, char *arock)
+DoBosAdminList(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER } DoBosAdminList_parm_t;
+ enum { SERVER };
afs_status_t st = 0;
void *bos_server = NULL;
void *iter = NULL;
}
int
-DoBosKeyCreate(struct cmd_syndesc *as, char *arock)
+DoBosKeyCreate(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, VERSIONNUMBER, KEY } DoBosKeyCreate_parm_t;
+ enum { SERVER, VERSIONNUMBER, KEY };
afs_status_t st = 0;
void *bos_server = NULL;
- int version_number;
+ int version_number = 0;
kas_encryptionKey_t key = { {0, 0, 0, 0, 0, 0, 0, 0} };
const char *cell;
}
int
-DoBosKeyDelete(struct cmd_syndesc *as, char *arock)
+DoBosKeyDelete(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, VERSIONNUMBER } DoBosKeyDelete_parm_t;
+ enum { SERVER, VERSIONNUMBER };
afs_status_t st = 0;
void *bos_server = NULL;
- int version_number;
+ int version_number = 0;
if (as->parms[SERVER].items) {
if (!bos_ServerOpen
}
int
-DoBosKeyList(struct cmd_syndesc *as, char *arock)
+DoBosKeyList(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER } DoBosKeyList_parm_t;
+ enum { SERVER };
afs_status_t st = 0;
void *bos_server = NULL;
void *iter = NULL;
}
int
-DoBosCellSet(struct cmd_syndesc *as, char *arock)
+DoBosCellSet(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, CELL } DoBosCellSet_parm_t;
+ enum { SERVER, CELL };
afs_status_t st = 0;
void *bos_server = NULL;
- const char *cell;
+ const char *cell = NULL;
if (as->parms[SERVER].items) {
if (!bos_ServerOpen
}
int
-DoBosCellGet(struct cmd_syndesc *as, char *arock)
+DoBosCellGet(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER } DoBosCellGet_parm_t;
+ enum { SERVER };
afs_status_t st = 0;
void *bos_server = NULL;
char cell[BOS_MAX_NAME_LEN];
}
int
-DoBosHostCreate(struct cmd_syndesc *as, char *arock)
+DoBosHostCreate(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, HOST } DoBosHostCreate_parm_t;
+ enum { SERVER, HOST };
afs_status_t st = 0;
void *bos_server = NULL;
- const char *host;
+ const char *host = NULL;
if (as->parms[SERVER].items) {
if (!bos_ServerOpen
}
int
-DoBosHostDelete(struct cmd_syndesc *as, char *arock)
+DoBosHostDelete(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, HOST } DoBosHostDelete_parm_t;
+ enum { SERVER, HOST };
afs_status_t st = 0;
void *bos_server = NULL;
- const char *host;
+ const char *host = NULL;
if (as->parms[SERVER].items) {
if (!bos_ServerOpen
}
int
-DoBosHostList(struct cmd_syndesc *as, char *arock)
+DoBosHostList(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER } DoBosHostList_parm_t;
+ enum { SERVER };
afs_status_t st = 0;
void *bos_server = NULL;
void *iter = NULL;
(cellHandle, as->parms[SERVER].items->data, &bos_server, &st)) {
ERR_ST_EXT("bos_ServerOpen", st);
}
+
+ printf("Listing hosts at server %s\n", as->parms[SERVER].items->data);
}
if (!bos_HostGetBegin(bos_server, &iter, &st)) {
ERR_ST_EXT("bos_HostGetBegin", st);
}
- printf("Listing hosts at server %s\n", as->parms[SERVER].items->data);
while (bos_HostGetNext(iter, host, &st)) {
printf("\t%s\n", host);
}
int
-DoBosExecutableCreate(struct cmd_syndesc *as, char *arock)
+DoBosExecutableCreate(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, BINARY, DEST } DoBosExecutableCreate_parm_t;
+ enum { SERVER, BINARY, DEST };
afs_status_t st = 0;
void *bos_server = NULL;
const char *binary = NULL;
}
int
-DoBosExecutableRevert(struct cmd_syndesc *as, char *arock)
+DoBosExecutableRevert(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, EXECUTABLE } DoBosExecutableRevert_parm_t;
+ enum { SERVER, EXECUTABLE };
afs_status_t st = 0;
void *bos_server = NULL;
const char *executable = NULL;
}
int
-DoBosExecutableTimestampGet(struct cmd_syndesc *as, char *arock)
+DoBosExecutableTimestampGet(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, EXECUTABLE } DoBosExecutableTimestampGet_parm_t;
+ enum { SERVER, EXECUTABLE };
afs_status_t st = 0;
void *bos_server = NULL;
const char *executable = NULL;
- unsigned long new_time = 0;
- unsigned long old_time = 0;
- unsigned long bak_time = 0;
+ afs_int32 new_time = 0;
+ afs_int32 old_time = 0;
+ afs_int32 bak_time = 0;
if (as->parms[SERVER].items) {
if (!bos_ServerOpen
}
int
-DoBosExecutablePrune(struct cmd_syndesc *as, char *arock)
+DoBosExecutablePrune(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, OLDFILES, BAKFILES,
+ enum { SERVER, OLDFILES, BAKFILES,
COREFILES
- } DoBosExecutablePrune_parm_t;
+ };
afs_status_t st = 0;
void *bos_server = NULL;
bos_Prune_t old_files = BOS_DONT_PRUNE;
}
int
-DoBosExecutableRestartTimeSet(struct cmd_syndesc *as, char *arock)
+DoBosExecutableRestartTimeSet(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, DAILY, WEEKLY,
+ enum { SERVER, DAILY, WEEKLY,
TIME
- } DoBosExecutableRestartTimeSet_parm_t;
+ };
afs_status_t st = 0;
void *bos_server = NULL;
- bos_Restart_t type;
+ bos_Restart_t type = 0;
int have_daily = 0;
int have_weekly = 0;
bos_RestartTime_t time;
if (ktime_ParsePeriodic(as->parms[TIME].items->data, &time) == -1) {
ERR_EXT("error parsing time");
}
+ } else {
+ ERR_EXT("Mandatory time argument not supplied");
}
if (!bos_ExecutableRestartTimeSet(bos_server, type, time, &st)) {
}
int
-DoBosExecutableRestartTimeGet(struct cmd_syndesc *as, char *arock)
+DoBosExecutableRestartTimeGet(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, DAILY,
+ enum { SERVER, DAILY,
WEEKLY
- } DoBosExecutableRestartTimeGet_parm_t;
+ };
afs_status_t st = 0;
void *bos_server = NULL;
- bos_Restart_t type;
+ bos_Restart_t type = 0;
int have_daily = 0;
int have_weekly = 0;
bos_RestartTime_t restart_time;
#define INITIAL_BUF_SIZE 4096
int
-DoBosLogGet(struct cmd_syndesc *as, char *arock)
+DoBosLogGet(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, LOGFILE } DoBosLogGet_parm_t;
+ enum { SERVER, LOGFILE };
afs_status_t st = 0;
void *bos_server = NULL;
- const char *log_file;
+ const char *log_file = NULL;
unsigned long buf_size = INITIAL_BUF_SIZE;
char *buf = NULL;
}
int
-DoBosAuthSet(struct cmd_syndesc *as, char *arock)
+DoBosAuthSet(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, REQUIREAUTH, DISABLEAUTH } DoBosAuthSet_parm_t;
+ enum { SERVER, REQUIREAUTH, DISABLEAUTH };
afs_status_t st = 0;
void *bos_server = NULL;
- bos_Auth_t auth;
+ bos_Auth_t auth = 0;
int have_req = 0;
int have_dis = 0;
}
int
-DoBosCommandExecute(struct cmd_syndesc *as, char *arock)
+DoBosCommandExecute(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, COMMAND } DoBosCommandExecute_parm_t;
+ enum { SERVER, COMMAND };
afs_status_t st = 0;
void *bos_server = NULL;
- const char *command;
+ const char *command = NULL;
if (as->parms[SERVER].items) {
if (!bos_ServerOpen
}
int
-DoBosSalvage(struct cmd_syndesc *as, char *arock)
+DoBosSalvage(struct cmd_syndesc *as, void *arock)
{
- typedef enum { SERVER, PARTITION, VOLUME, NUMSALVAGERS, TMPDIR, LOGFILE,
+ enum { SERVER, PARTITION, VOLUME, NUMSALVAGERS, TMPDIR, LOGFILE,
FORCE, NOWRITE, INODES, ROOTINODES, SALVAGEDIRS, BLOCKREADS
- } DoBosSalvage_parm_t;
+ };
afs_status_t st = 0;
void *bos_server = NULL;
const char *partition = NULL;
return 0;
}
+#if 0
static void
Print_afs_RPCStatsState_p(afs_RPCStatsState_p state, const char *prefix)
{
break;
}
}
+#endif
void
SetupBosAdminCmd(void)
{
struct cmd_syndesc *ts;
- ts = cmd_CreateSyntax("BosProcessCreate", DoBosProcessCreate, 0,
+ ts = cmd_CreateSyntax("BosProcessCreate", DoBosProcessCreate, NULL, 0,
"create a new bos process");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where process will be created");
"path to notifier binary that is run when process terminates");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosFSProcessCreate", DoBosFSProcessCreate, 0,
+ ts = cmd_CreateSyntax("BosFSProcessCreate", DoBosFSProcessCreate, NULL, 0,
"create a fs bos process");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where process will be created");
"path to notifier binary that is run when process terminates");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosProcessDelete", DoBosProcessDelete, 0,
+ ts = cmd_CreateSyntax("BosProcessDelete", DoBosProcessDelete, NULL, 0,
"delete a bos process");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where process will be deleted");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("BosProcessExecutionStateGet",
- DoBosProcessExecutionStateGet, 0,
+ DoBosProcessExecutionStateGet, NULL, 0,
"get the process execution state of a process");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where process exists");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("BosProcessExecutionStateSet",
- DoBosProcessExecutionStateSet, 0,
+ DoBosProcessExecutionStateSet, NULL, 0,
"set the process execution state of a process");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where process exists");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("BosProcessExecutionStateSetTemporary",
- DoBosProcessExecutionStateSetTemporary, 0,
+ DoBosProcessExecutionStateSetTemporary, NULL, 0,
"set the process execution state "
"of a process temporarily");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"set the process state to running");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosProcessNameList", DoBosProcessNameList, 0,
+ ts = cmd_CreateSyntax("BosProcessNameList", DoBosProcessNameList, NULL, 0,
"list the names of all processes at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosProcessInfoGet", DoBosProcessInfoGet, 0,
+ ts = cmd_CreateSyntax("BosProcessInfoGet", DoBosProcessInfoGet, NULL, 0,
"get information about a process");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where process exists");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("BosProcessParameterList",
- DoBosProcessParameterList, 0,
+ DoBosProcessParameterList, NULL, 0,
"list the parameters of a process");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where process exists");
"the name of the process");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosProcessNotifierGet", DoBosProcessNotifierGet, 0,
+ ts = cmd_CreateSyntax("BosProcessNotifierGet", DoBosProcessNotifierGet, NULL, 0,
"get the notifier for a process");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where process exists");
"the name of the process");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosProcessRestart", DoBosProcessRestart, 0,
+ ts = cmd_CreateSyntax("BosProcessRestart", DoBosProcessRestart, NULL, 0,
"restart a process");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where process exists");
"the name of the process");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosProcessAllStop", DoBosProcessAllStop, 0,
+ ts = cmd_CreateSyntax("BosProcessAllStop", DoBosProcessAllStop, NULL, 0,
"stop all processes at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where processes exists");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosProcessAllWaitStop", DoBosProcessAllWaitStop, 0,
+ ts = cmd_CreateSyntax("BosProcessAllWaitStop", DoBosProcessAllWaitStop, NULL, 0,
"stop all processes at a bos server and block "
"until they all exit");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("BosProcessAllWaitTransition",
- DoBosProcessAllWaitTransition, 0,
+ DoBosProcessAllWaitTransition, NULL, 0,
"wait until all processes have transitioned to "
"their desired state");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("BosProcessAllStopAndRestart",
- DoBosProcessAllStopAndRestart, 0,
+ DoBosProcessAllStopAndRestart, NULL, 0,
"stop all processes at a bos server and "
"then restart them");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"include the bos server in the processes to be restarted");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosAdminCreate", DoBosAdminCreate, 0,
+ ts = cmd_CreateSyntax("BosAdminCreate", DoBosAdminCreate, NULL, 0,
"create an admin user at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where admin will be created");
"the name of the administrator to add");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosAdminDelete", DoBosAdminDelete, 0,
+ ts = cmd_CreateSyntax("BosAdminDelete", DoBosAdminDelete, NULL, 0,
"delete an admin user at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where admin will be deleted");
"the name of the administrator to delete");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosAdminList", DoBosAdminList, 0,
+ ts = cmd_CreateSyntax("BosAdminList", DoBosAdminList, NULL, 0,
"list all admin users at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where admins will be listed");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosKeyCreate", DoBosKeyCreate, 0,
+ ts = cmd_CreateSyntax("BosKeyCreate", DoBosKeyCreate, NULL, 0,
"create a key at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where key will be created");
cmd_AddParm(ts, "-key", CMD_SINGLE, CMD_REQUIRED, "new encryption key");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosKeyDelete", DoBosKeyDelete, 0,
+ ts = cmd_CreateSyntax("BosKeyDelete", DoBosKeyDelete, NULL, 0,
"delete a key at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where key will be deleted");
"version number of the key");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosKeyList", DoBosKeyList, 0,
+ ts = cmd_CreateSyntax("BosKeyList", DoBosKeyList, NULL, 0,
"list keys at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where keys exist");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosCellSet", DoBosCellSet, 0,
+ ts = cmd_CreateSyntax("BosCellSet", DoBosCellSet, NULL, 0,
"set the cell at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_REQUIRED, "new cell");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosCellGet", DoBosCellGet, 0,
+ ts = cmd_CreateSyntax("BosCellGet", DoBosCellGet, NULL, 0,
"get the cell at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosHostCreate", DoBosHostCreate, 0,
+ ts = cmd_CreateSyntax("BosHostCreate", DoBosHostCreate, NULL, 0,
"add a host entry to the server CellServDB");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
cmd_AddParm(ts, "-host", CMD_SINGLE, CMD_REQUIRED, "host to add");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosHostDelete", DoBosHostDelete, 0,
+ ts = cmd_CreateSyntax("BosHostDelete", DoBosHostDelete, NULL, 0,
"delete a host entry from the server CellServDB");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
cmd_AddParm(ts, "-host", CMD_SINGLE, CMD_REQUIRED, "host to delete");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosHostList", DoBosHostList, 0,
+ ts = cmd_CreateSyntax("BosHostList", DoBosHostList, NULL, 0,
"list all host entries from the server CellServDB");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosExecutableCreate", DoBosExecutableCreate, 0,
+ ts = cmd_CreateSyntax("BosExecutableCreate", DoBosExecutableCreate, NULL, 0,
"create a new binary at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
cmd_AddParm(ts, "-binary", CMD_SINGLE, CMD_REQUIRED,
"path where the binary will be stored");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosExecutableRevert", DoBosExecutableRevert, 0,
+ ts = cmd_CreateSyntax("BosExecutableRevert", DoBosExecutableRevert, NULL, 0,
"revert a binary at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
cmd_AddParm(ts, "-executable", CMD_SINGLE, CMD_REQUIRED,
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("BosExecutableTimestampGet",
- DoBosExecutableTimestampGet, 0,
+ DoBosExecutableTimestampGet, NULL, 0,
"get the timestamps for a binary at bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
cmd_AddParm(ts, "-executable", CMD_SINGLE, CMD_REQUIRED,
"path to the binary to revert");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosExecutablePrune", DoBosExecutablePrune, 0,
+ ts = cmd_CreateSyntax("BosExecutablePrune", DoBosExecutablePrune, NULL, 0,
"prune various files at bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
cmd_AddParm(ts, "-oldfiles", CMD_FLAG, CMD_OPTIONAL, "prune .old files");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("BosExecutableRestartTimeSet",
- DoBosExecutableRestartTimeSet, 0,
+ DoBosExecutableRestartTimeSet, NULL, 0,
"set the restart times at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
cmd_AddParm(ts, "-daily", CMD_FLAG, CMD_OPTIONAL,
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("BosExecutableRestartTimeGet",
- DoBosExecutableRestartTimeGet, 0,
+ DoBosExecutableRestartTimeGet, NULL, 0,
"get the restart times at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
cmd_AddParm(ts, "-daily", CMD_FLAG, CMD_OPTIONAL,
"get weekly restart time");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosLogGet", DoBosLogGet, 0,
+ ts = cmd_CreateSyntax("BosLogGet", DoBosLogGet, NULL, 0,
"get a log file from the bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
cmd_AddParm(ts, "-logfile", CMD_SINGLE, CMD_REQUIRED,
"path to the log file to retrieve");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosAuthSet", DoBosAuthSet, 0,
+ ts = cmd_CreateSyntax("BosAuthSet", DoBosAuthSet, NULL, 0,
"set the authorization level at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to modify");
cmd_AddParm(ts, "-requireauth", CMD_FLAG, CMD_OPTIONAL,
"don't require authorization");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosCommandExecute", DoBosCommandExecute, 0,
+ ts = cmd_CreateSyntax("BosCommandExecute", DoBosCommandExecute, 0, 0,
"execute a command at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where command will execute");
"command to execute");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosSalvage", DoBosSalvage, 0,
+ ts = cmd_CreateSyntax("BosSalvage", DoBosSalvage, NULL, 0,
"execute a salvage command at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where salvager will execute");
git://git.openafs.org / openafs.git / blobdiff