#include "forceremove.h"
-static int DoClient34(struct cmd_syndesc *as, char *arock)
+static int DoClient34(struct cmd_syndesc *as, void *arock)
{
DWORD status = Client34Eradicate(FALSE);
{
struct cmd_syndesc *ts;
- ts = cmd_CreateSyntax("client34", DoClient34, 0,
+ ts = cmd_CreateSyntax("client34", DoClient34, NULL,
"remove AFS 3.4a client");
}
#define BAD_ARGUMENT 1
#define KLOGEXIT(code) exit(code)
-int CommandProc();
+static int CommandProc(struct cmd_syndesc *, void *);
static int zero_argc;
static char **zero_argv;
/* Start up sockets */
WSAStartup(0x0101, &WSAjunk);
- ts = cmd_CreateSyntax((char *) 0, CommandProc, 0, "obtain Kerberos authentication");
+ ts = cmd_CreateSyntax(NULL, CommandProc, NULL, "obtain Kerberos authentication");
#define aXFLAG 0
#define aPRINCIPAL 1
return !ok;
}
-CommandProc (as, arock)
- char *arock;
- struct cmd_syndesc *as;
+static int
+CommandProc (struct cmd_syndesc *as, void *arock)
{
char name[MAXKTCNAMELEN];
char instance[MAXKTCNAMELEN];
#include <afsint.h>
#include <winsock2.h>
-CommandProc (as, arock)
- char *arock;
- struct cmd_syndesc *as;
+static int
+CommandProc (struct cmd_syndesc *as, void *arock)
{
afs_int32 code, ecode=0;
struct ktc_principal server;
WSAStartup(0x0101, &WSAjunk);
- ts = cmd_CreateSyntax((char *) 0, CommandProc, 0, "Release Kerberos authentication");
+ ts = cmd_CreateSyntax(NULL, CommandProc, NULL, "Release Kerberos authentication");
cmd_AddParm(ts, "-cell", CMD_LIST, CMD_OPTIONAL, "cell name");
code = cmd_Dispatch(argc, argv);
static struct ubik_client *uclient;
-static int GetClientAddrsCmd(struct cmd_syndesc *asp, char *arock);
-static int SetClientAddrsCmd(struct cmd_syndesc *asp, char *arock);
-static int FlushMountCmd(struct cmd_syndesc *asp, char *arock);
-static int RxStatProcCmd(struct cmd_syndesc *asp, char *arock);
-static int RxStatPeerCmd(struct cmd_syndesc *asp, char *arock);
+static int GetClientAddrsCmd(struct cmd_syndesc *asp, void *arock);
+static int SetClientAddrsCmd(struct cmd_syndesc *asp, void *arock);
+static int FlushMountCmd(struct cmd_syndesc *asp, void *arock);
+static int RxStatProcCmd(struct cmd_syndesc *asp, void *arock);
+static int RxStatPeerCmd(struct cmd_syndesc *asp, void *arock);
extern struct cmd_syndesc *cmd_CreateSyntax();
-static int MemDumpCmd(struct cmd_syndesc *asp, char *arock);
-static int CSCPolicyCmd(struct cmd_syndesc *asp, char *arock);
-static int MiniDumpCmd(struct cmd_syndesc *asp, char *arock);
+static int MemDumpCmd(struct cmd_syndesc *asp, void *arock);
+static int CSCPolicyCmd(struct cmd_syndesc *asp, void *arock);
+static int MiniDumpCmd(struct cmd_syndesc *asp, void *arock);
static char pn[] = "fs";
static int rxInitDone = 0;
}
static int
-SetACLCmd(struct cmd_syndesc *as, char *arock)
+SetACLCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-CopyACLCmd(struct cmd_syndesc *as, char *arock)
+CopyACLCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
/* clean up an acl to not have bogus entries */
static int
-CleanACLCmd(struct cmd_syndesc *as, char *arock)
+CleanACLCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct Acl *ta = 0;
}
static int
-ListACLCmd(struct cmd_syndesc *as, char *arock)
+ListACLCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct Acl *ta = 0;
}
static int
-FlushAllCmd(struct cmd_syndesc *as, char *arock)
+FlushAllCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-FlushVolumeCmd(struct cmd_syndesc *as, char *arock)
+FlushVolumeCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-FlushCmd(struct cmd_syndesc *as, char *arock)
+FlushCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
/* all this command does is repackage its args and call SetVolCmd */
static int
-SetQuotaCmd(struct cmd_syndesc *as, char *arock) {
+SetQuotaCmd(struct cmd_syndesc *as, void *arock) {
struct cmd_syndesc ts;
/* copy useful stuff from our command slot; we may later have to reorder */
}
static int
-SetVolCmd(struct cmd_syndesc *as, char *arock) {
+SetVolCmd(struct cmd_syndesc *as, void *arock) {
afs_int32 code;
struct ViceIoctl blob;
struct cmd_item *ti;
#endif /* WIN32 */
static int
-ExamineCmd(struct cmd_syndesc *as, char *arock)
+ExamineCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-ListQuotaCmd(struct cmd_syndesc *as, char *arock)
+ListQuotaCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-WhereIsCmd(struct cmd_syndesc *as, char *arock)
+WhereIsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
static int
-DiskFreeCmd(struct cmd_syndesc *as, char *arock)
+DiskFreeCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-QuotaCmd(struct cmd_syndesc *as, char *arock)
+QuotaCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-ListMountCmd(struct cmd_syndesc *as, char *arock)
+ListMountCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-MakeMountCmd(struct cmd_syndesc *as, char *arock)
+MakeMountCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
char *cellName, *volName, *tmpName;
* tp: Set to point to the actual name of the mount point to nuke.
*/
static int
-RemoveMountCmd(struct cmd_syndesc *as, char *arock) {
+RemoveMountCmd(struct cmd_syndesc *as, void *arock) {
afs_int32 code=0;
struct ViceIoctl blob;
struct cmd_item *ti;
*/
static int
-CheckServersCmd(struct cmd_syndesc *as, char *arock)
+CheckServersCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-MessagesCmd(struct cmd_syndesc *as, char *arock)
+MessagesCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code=0;
struct ViceIoctl blob;
}
static int
-CheckVolumesCmd(struct cmd_syndesc *as, char *arock)
+CheckVolumesCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-SetCacheSizeCmd(struct cmd_syndesc *as, char *arock)
+SetCacheSizeCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-GetCacheParmsCmd(struct cmd_syndesc *as, char *arock)
+GetCacheParmsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-ListCellsCmd(struct cmd_syndesc *as, char *arock)
+ListCellsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
afs_int32 i, j, *lp, magic, size;
#ifndef WIN32
static int
-ListAliasesCmd(struct cmd_syndesc *as, char *arock)
+ListAliasesCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code, i;
char *tp, *aliasName, *realName;
}
static int
-CallBackRxConnCmd(struct cmd_syndesc *as, char *arock)
+CallBackRxConnCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
#endif /* WIN32 */
static int
-NewCellCmd(struct cmd_syndesc *as, char *arock)
+NewCellCmd(struct cmd_syndesc *as, void *arock)
{
#ifndef WIN32
afs_int32 code, linkedstate=0, size=0, *lp;
#ifndef WIN32
static int
-NewAliasCmd(struct cmd_syndesc *as, char *arock)
+NewAliasCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
#endif /* WIN32 */
static int
-WhichCellCmd(struct cmd_syndesc *as, char *arock)
+WhichCellCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct cmd_item *ti;
}
static int
-WSCellCmd(struct cmd_syndesc *as, char *arock)
+WSCellCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
/*
static int
-PrimaryCellCmd(struct cmd_syndesc *as, char *arock)
+PrimaryCellCmd(struct cmd_syndesc *as, void *arock)
{
fprintf(stderr,"This command is obsolete, as is the concept of a primary token.\n");
return 0;
*/
static int
-MonitorCmd(struct cmd_syndesc *as, char *arock)
+MonitorCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-SysNameCmd(struct cmd_syndesc *as, char *arock)
+SysNameCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static char *exported_types[] = {"null", "nfs", ""};
-static int ExportAfsCmd(struct cmd_syndesc *as, char *arock)
+static int ExportAfsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
static int
-GetCellCmd(struct cmd_syndesc *as, char *arock)
+GetCellCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
return error;
}
-static int SetCellCmd(struct cmd_syndesc *as, char *arock)
+static int SetCellCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
#ifdef WIN32
static int
-SetPrefCmd(struct cmd_syndesc *as, char * arock)
+SetPrefCmd(struct cmd_syndesc *as, void * arock)
{
FILE *infd;
afs_int32 code;
}
#else
static int
-SetPrefCmd(struct cmd_syndesc *as, char *arock)
+SetPrefCmd(struct cmd_syndesc *as, void *arock)
{
FILE *infd;
afs_int32 code;
#ifdef WIN32
static int
-GetPrefCmd(struct cmd_syndesc *as, char *arock)
+GetPrefCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct cmd_item *ti;
}
#else
static int
-GetPrefCmd(struct cmd_syndesc *as, char *arock)
+GetPrefCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct cmd_item *ti;
#endif /* WIN32 */
static int
-UuidCmd(struct cmd_syndesc *asp, char *arock)
+UuidCmd(struct cmd_syndesc *asp, void *arock)
{
long code;
long inValue;
}
static int
-TraceCmd(struct cmd_syndesc *asp, char *arock)
+TraceCmd(struct cmd_syndesc *asp, void *arock)
{
long code;
struct ViceIoctl blob;
/* fs sb -kbytes 9999 -files *.o -default 64 */
static int
-StoreBehindCmd(struct cmd_syndesc *as, char *arock)
+StoreBehindCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code = 0;
struct ViceIoctl blob;
}
static afs_int32
-SetCryptCmd(struct cmd_syndesc *as, char *arock)
+SetCryptCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code = 0, flag;
struct ViceIoctl blob;
}
static afs_int32
-GetCryptCmd(struct cmd_syndesc *as, char *arock)
+GetCryptCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code = 0, flag;
struct ViceIoctl blob;
}
static int
-MemDumpCmd(struct cmd_syndesc *asp, char *arock)
+MemDumpCmd(struct cmd_syndesc *asp, void *arock)
{
long code;
struct ViceIoctl blob;
}
static int
-MiniDumpCmd(struct cmd_syndesc *asp, char *arock)
+MiniDumpCmd(struct cmd_syndesc *asp, void *arock)
{
BOOL success = 0;
SERVICE_STATUS status;
}
static int
-CSCPolicyCmd(struct cmd_syndesc *asp, char *arock)
+CSCPolicyCmd(struct cmd_syndesc *asp, void *arock)
{
struct cmd_item *ti;
char *share = NULL;
#ifndef WIN32
/* get clients interface addresses */
static int
-GetClientAddrsCmd(struct cmd_syndesc *as, char *arock)
+GetClientAddrsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct cmd_item *ti;
}
static int
-SetClientAddrsCmd(struct cmd_syndesc *as, char *arock)
+SetClientAddrsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code, addr;
struct cmd_item *ti;
}
static int
-FlushMountCmd(struct cmd_syndesc *as, char *arock)
+FlushMountCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
#endif /* WIN32 */
static int
-RxStatProcCmd(struct cmd_syndesc *as, char *arock)
+RxStatProcCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
afs_int32 flags = 0;
}
static int
-RxStatPeerCmd(struct cmd_syndesc *as, char *arock)
+RxStatPeerCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
afs_int32 flags = 0;
osi_Init();
#ifndef WIN32
- ts = cmd_CreateSyntax("getclientaddrs", GetClientAddrsCmd, 0,
+ ts = cmd_CreateSyntax("getclientaddrs", GetClientAddrsCmd, NULL,
"get client network interface addresses");
cmd_CreateAlias(ts, "gc");
- ts = cmd_CreateSyntax("setclientaddrs", SetClientAddrsCmd, 0,
+ ts = cmd_CreateSyntax("setclientaddrs", SetClientAddrsCmd, NULL,
"set client network interface addresses");
cmd_AddParm(ts, "-address", CMD_LIST, CMD_OPTIONAL | CMD_EXPANDS,
"client network interfaces");
cmd_CreateAlias(ts, "sc");
#endif /* WIN32 */
- ts = cmd_CreateSyntax("setserverprefs", SetPrefCmd, 0, "set server ranks");
+ ts = cmd_CreateSyntax("setserverprefs", SetPrefCmd, NULL, "set server ranks");
cmd_AddParm(ts, "-servers", CMD_LIST, CMD_OPTIONAL|CMD_EXPANDS, "fileserver names and ranks");
cmd_AddParm(ts, "-vlservers", CMD_LIST, CMD_OPTIONAL|CMD_EXPANDS, "VL server names and ranks");
cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_OPTIONAL, "input from named file");
cmd_AddParm(ts, "-stdin", CMD_FLAG, CMD_OPTIONAL, "input from stdin");
cmd_CreateAlias(ts, "sp");
- ts = cmd_CreateSyntax("getserverprefs", GetPrefCmd, 0, "get server ranks");
+ ts = cmd_CreateSyntax("getserverprefs", GetPrefCmd, NULL, "get server ranks");
cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_OPTIONAL, "output to named file");
cmd_AddParm(ts, "-numeric", CMD_FLAG, CMD_OPTIONAL, "addresses only");
cmd_AddParm(ts, "-vlservers", CMD_FLAG, CMD_OPTIONAL, "VL servers");
/* cmd_AddParm(ts, "-cell", CMD_FLAG, CMD_OPTIONAL, "cellname"); */
cmd_CreateAlias(ts, "gp");
- ts = cmd_CreateSyntax("setacl", SetACLCmd, 0, "set access control list");
+ ts = cmd_CreateSyntax("setacl", SetACLCmd, NULL, "set access control list");
cmd_AddParm(ts, "-dir", CMD_LIST, 0, "directory");
cmd_AddParm(ts, "-acl", CMD_LIST, 0, "access list entries");
cmd_AddParm(ts, "-clear", CMD_FLAG, CMD_OPTIONAL, "clear access list");
cmd_AddParm(ts, "-if", CMD_FLAG, CMD_OPTIONAL, "initial file acl (DFS only)");
cmd_CreateAlias(ts, "sa");
- ts = cmd_CreateSyntax("listacl", ListACLCmd, 0, "list access control list");
+ ts = cmd_CreateSyntax("listacl", ListACLCmd, NULL, "list access control list");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
parm_listacl_id = ts->nParms;
cmd_AddParm(ts, "-id", CMD_FLAG, CMD_OPTIONAL, "initial directory acl");
cmd_AddParm(ts, "-if", CMD_FLAG, CMD_OPTIONAL, "initial file acl");
cmd_CreateAlias(ts, "la");
- ts = cmd_CreateSyntax("cleanacl", CleanACLCmd, 0, "clean up access control list");
+ ts = cmd_CreateSyntax("cleanacl", CleanACLCmd, NULL, "clean up access control list");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
- ts = cmd_CreateSyntax("copyacl", CopyACLCmd, 0, "copy access control list");
+ ts = cmd_CreateSyntax("copyacl", CopyACLCmd, NULL, "copy access control list");
cmd_AddParm(ts, "-fromdir", CMD_SINGLE, 0, "source directory (or DFS file)");
cmd_AddParm(ts, "-todir", CMD_LIST, 0, "destination directory (or DFS file)");
cmd_AddParm(ts, "-clear", CMD_FLAG, CMD_OPTIONAL, "first clear dest access list");
cmd_CreateAlias(ts, "ca");
- ts = cmd_CreateSyntax("flush", FlushCmd, 0, "flush file from cache");
+ ts = cmd_CreateSyntax("flush", FlushCmd, NULL, "flush file from cache");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
#ifndef WIN32
- ts = cmd_CreateSyntax("flushmount", FlushMountCmd, 0,
+ ts = cmd_CreateSyntax("flushmount", FlushMountCmd, NULL,
"flush mount symlink from cache");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
#endif
- ts = cmd_CreateSyntax("setvol", SetVolCmd, 0, "set volume status");
+ ts = cmd_CreateSyntax("setvol", SetVolCmd, NULL, "set volume status");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
cmd_AddParm(ts, "-max", CMD_SINGLE, CMD_OPTIONAL, "disk space quota in 1K units");
#ifdef notdef
cmd_AddParm(ts, "-offlinemsg", CMD_SINGLE, CMD_OPTIONAL, "offline message");
cmd_CreateAlias(ts, "sv");
- ts = cmd_CreateSyntax("messages", MessagesCmd, 0, "control Cache Manager messages");
+ ts = cmd_CreateSyntax("messages", MessagesCmd, NULL, "control Cache Manager messages");
cmd_AddParm(ts, "-show", CMD_SINGLE, CMD_OPTIONAL, "[user|console|all|none]");
- ts = cmd_CreateSyntax("examine", ExamineCmd, 0, "display file/volume status");
+ ts = cmd_CreateSyntax("examine", ExamineCmd, NULL, "display file/volume status");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
cmd_CreateAlias(ts, "lv");
cmd_CreateAlias(ts, "listvol");
- ts = cmd_CreateSyntax("listquota", ListQuotaCmd, 0, "list volume quota");
+ ts = cmd_CreateSyntax("listquota", ListQuotaCmd, NULL, "list volume quota");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
cmd_CreateAlias(ts, "lq");
- ts = cmd_CreateSyntax("diskfree", DiskFreeCmd, 0, "show server disk space usage");
+ ts = cmd_CreateSyntax("diskfree", DiskFreeCmd, NULL, "show server disk space usage");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
cmd_CreateAlias(ts, "df");
- ts = cmd_CreateSyntax("quota", QuotaCmd, 0, "show volume quota usage");
+ ts = cmd_CreateSyntax("quota", QuotaCmd, NULL, "show volume quota usage");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
- ts = cmd_CreateSyntax("lsmount", ListMountCmd, 0, "list mount point");
+ ts = cmd_CreateSyntax("lsmount", ListMountCmd, NULL, "list mount point");
cmd_AddParm(ts, "-dir", CMD_LIST, 0, "directory");
- ts = cmd_CreateSyntax("mkmount", MakeMountCmd, 0, "make mount point");
+ ts = cmd_CreateSyntax("mkmount", MakeMountCmd, NULL, "make mount point");
cmd_AddParm(ts, "-dir", CMD_SINGLE, 0, "directory");
cmd_AddParm(ts, "-vol", CMD_SINGLE, 0, "volume name");
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
*/
- ts = cmd_CreateSyntax("rmmount", RemoveMountCmd, 0, "remove mount point");
+ ts = cmd_CreateSyntax("rmmount", RemoveMountCmd, NULL, "remove mount point");
cmd_AddParm(ts, "-dir", CMD_LIST, 0, "directory");
- ts = cmd_CreateSyntax("checkservers", CheckServersCmd, 0, "check local cell's servers");
+ ts = cmd_CreateSyntax("checkservers", CheckServersCmd, NULL, "check local cell's servers");
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell to check");
cmd_AddParm(ts, "-all", CMD_FLAG, CMD_OPTIONAL, "check all cells");
cmd_AddParm(ts, "-fast", CMD_FLAG, CMD_OPTIONAL, "just list, don't check");
cmd_AddParm(ts,"-interval",CMD_SINGLE,CMD_OPTIONAL,"seconds between probes");
- ts = cmd_CreateSyntax("checkvolumes", CheckVolumesCmd,0, "check volumeID/name mappings");
+ ts = cmd_CreateSyntax("checkvolumes", CheckVolumesCmd, NULL, "check volumeID/name mappings");
cmd_CreateAlias(ts, "checkbackups");
- ts = cmd_CreateSyntax("setcachesize", SetCacheSizeCmd, 0, "set cache size");
+ ts = cmd_CreateSyntax("setcachesize", SetCacheSizeCmd, NULL, "set cache size");
cmd_AddParm(ts, "-blocks", CMD_SINGLE, CMD_OPTIONAL, "size in 1K byte blocks (0 => reset)");
cmd_CreateAlias(ts, "cachesize");
cmd_AddParm(ts, "-reset", CMD_FLAG, CMD_OPTIONAL, "reset size back to boot value");
- ts = cmd_CreateSyntax("getcacheparms", GetCacheParmsCmd, 0, "get cache usage info");
+ ts = cmd_CreateSyntax("getcacheparms", GetCacheParmsCmd, NULL, "get cache usage info");
- ts = cmd_CreateSyntax("listcells", ListCellsCmd, 0, "list configured cells");
+ ts = cmd_CreateSyntax("listcells", ListCellsCmd, NULL, "list configured cells");
cmd_AddParm(ts, "-numeric", CMD_FLAG, CMD_OPTIONAL, "addresses only");
- ts = cmd_CreateSyntax("setquota", SetQuotaCmd, 0, "set volume quota");
+ ts = cmd_CreateSyntax("setquota", SetQuotaCmd, NULL, "set volume quota");
cmd_AddParm(ts, "-path", CMD_SINGLE, CMD_OPTIONAL, "dir/file path");
cmd_AddParm(ts, "-max", CMD_SINGLE, 0, "max quota in kbytes");
#ifdef notdef
#endif
cmd_CreateAlias(ts, "sq");
- ts = cmd_CreateSyntax("newcell", NewCellCmd, 0, "configure new cell");
+ ts = cmd_CreateSyntax("newcell", NewCellCmd, NULL, "configure new cell");
#ifndef WIN32
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "cell name");
cmd_AddParm(ts, "-servers", CMD_LIST, CMD_REQUIRED, "primary servers");
cmd_AddParm(ts, "-vlport", CMD_SINGLE, CMD_OPTIONAL, "cell's vldb server port");
#endif
- ts = cmd_CreateSyntax("newalias", NewAliasCmd, 0,
+ ts = cmd_CreateSyntax("newalias", NewAliasCmd, NULL,
"configure new cell alias");
cmd_AddParm(ts, "-alias", CMD_SINGLE, 0, "alias name");
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "real name of cell");
#endif
- ts = cmd_CreateSyntax("whichcell", WhichCellCmd, 0, "list file's cell");
+ ts = cmd_CreateSyntax("whichcell", WhichCellCmd, NULL, "list file's cell");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
- ts = cmd_CreateSyntax("whereis", WhereIsCmd, 0, "list file's location");
+ ts = cmd_CreateSyntax("whereis", WhereIsCmd, NULL, "list file's location");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
- ts = cmd_CreateSyntax("wscell", WSCellCmd, 0, "list workstation's cell");
+ ts = cmd_CreateSyntax("wscell", WSCellCmd, NULL, "list workstation's cell");
/*
ts = cmd_CreateSyntax("primarycell", PrimaryCellCmd, 0, "obsolete (listed primary cell)");
*/
- ts = cmd_CreateSyntax("monitor", MonitorCmd, 0, "set cache monitor host address");
+ ts = cmd_CreateSyntax("monitor", MonitorCmd, NULL, "set cache monitor host address");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL, "host name or 'off'");
cmd_CreateAlias(ts, "mariner");
- ts = cmd_CreateSyntax("getcellstatus", GetCellCmd, 0, "get cell status");
+ ts = cmd_CreateSyntax("getcellstatus", GetCellCmd, NULL, "get cell status");
cmd_AddParm(ts, "-cell", CMD_LIST, 0, "cell name");
- ts = cmd_CreateSyntax("setcell", SetCellCmd, 0, "set cell status");
+ ts = cmd_CreateSyntax("setcell", SetCellCmd, NULL, "set cell status");
cmd_AddParm(ts, "-cell", CMD_LIST, 0, "cell name");
cmd_AddParm(ts, "-suid", CMD_FLAG, CMD_OPTIONAL, "allow setuid programs");
cmd_AddParm(ts, "-nosuid", CMD_FLAG, CMD_OPTIONAL, "disallow setuid programs");
- ts = cmd_CreateSyntax("flushall", FlushAllCmd, 0, "flush all data");
+ ts = cmd_CreateSyntax("flushall", FlushAllCmd, NULL, "flush all data");
- ts = cmd_CreateSyntax("flushvolume", FlushVolumeCmd, 0, "flush all data in volume");
+ ts = cmd_CreateSyntax("flushvolume", FlushVolumeCmd, NULL, "flush all data in volume");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
- ts = cmd_CreateSyntax("sysname", SysNameCmd, 0, "get/set sysname (i.e. @sys) value");
+ ts = cmd_CreateSyntax("sysname", SysNameCmd, NULL, "get/set sysname (i.e. @sys) value");
cmd_AddParm(ts, "-newsys", CMD_LIST, CMD_OPTIONAL, "new sysname");
- ts = cmd_CreateSyntax("exportafs", ExportAfsCmd, 0, "enable/disable translators to AFS");
+ ts = cmd_CreateSyntax("exportafs", ExportAfsCmd, NULL, "enable/disable translators to AFS");
cmd_AddParm(ts, "-type", CMD_SINGLE, 0, "exporter name");
cmd_AddParm(ts, "-start", CMD_SINGLE, CMD_OPTIONAL, "start/stop translator ('on' or 'off')");
cmd_AddParm(ts, "-convert", CMD_SINGLE, CMD_OPTIONAL, "convert from afs to unix mode ('on or 'off')");
cmd_AddParm(ts, "-submounts", CMD_SINGLE, CMD_OPTIONAL, "allow nfs mounts to subdirs of /afs/.. ('on' or 'off')");
- ts = cmd_CreateSyntax("storebehind", StoreBehindCmd, 0,
+ ts = cmd_CreateSyntax("storebehind", StoreBehindCmd, NULL,
"store to server after file close");
cmd_AddParm(ts, "-kbytes", CMD_SINGLE, CMD_OPTIONAL, "asynchrony for specified names");
cmd_AddParm(ts, "-files", CMD_LIST, CMD_OPTIONAL, "specific pathnames");
cmd_AddParm(ts, "-allfiles", CMD_SINGLE, CMD_OPTIONAL, "new default (KB)");
cmd_CreateAlias(ts, "sb");
- ts = cmd_CreateSyntax("setcrypt", SetCryptCmd, 0, "set cache manager encryption flag");
+ ts = cmd_CreateSyntax("setcrypt", SetCryptCmd, NULL, "set cache manager encryption flag");
cmd_AddParm(ts, "-crypt", CMD_SINGLE, 0, "on or off");
- ts = cmd_CreateSyntax("getcrypt", GetCryptCmd, 0, "get cache manager encryption flag");
+ ts = cmd_CreateSyntax("getcrypt", GetCryptCmd, NULL, "get cache manager encryption flag");
- ts = cmd_CreateSyntax("rxstatproc", RxStatProcCmd, 0,
+ ts = cmd_CreateSyntax("rxstatproc", RxStatProcCmd, NULL,
"Manage per process RX statistics");
cmd_AddParm(ts, "-enable", CMD_FLAG, CMD_OPTIONAL, "Enable RX stats");
cmd_AddParm(ts, "-disable", CMD_FLAG, CMD_OPTIONAL, "Disable RX stats");
cmd_AddParm(ts, "-clear", CMD_FLAG, CMD_OPTIONAL, "Clear RX stats");
- ts = cmd_CreateSyntax("rxstatpeer", RxStatPeerCmd, 0,
+ ts = cmd_CreateSyntax("rxstatpeer", RxStatPeerCmd, NULL,
"Manage per peer RX statistics");
cmd_AddParm(ts, "-enable", CMD_FLAG, CMD_OPTIONAL, "Enable RX stats");
cmd_AddParm(ts, "-disable", CMD_FLAG, CMD_OPTIONAL, "Disable RX stats");
cmd_AddParm(ts, "-clear", CMD_FLAG, CMD_OPTIONAL, "Clear RX stats");
#ifndef WIN32
- ts = cmd_CreateSyntax("setcbaddr", CallBackRxConnCmd, 0, "configure callback connection address");
+ ts = cmd_CreateSyntax("setcbaddr", CallBackRxConnCmd, NULL, "configure callback connection address");
cmd_AddParm(ts, "-addr", CMD_SINGLE, CMD_OPTIONAL, "host name or address");
#endif
- ts = cmd_CreateSyntax("trace", TraceCmd, 0, "enable or disable CM tracing");
+ ts = cmd_CreateSyntax("trace", TraceCmd, NULL, "enable or disable CM tracing");
cmd_AddParm(ts, "-on", CMD_FLAG, CMD_OPTIONAL, "enable tracing");
cmd_AddParm(ts, "-off", CMD_FLAG, CMD_OPTIONAL, "disable tracing");
cmd_AddParm(ts, "-reset", CMD_FLAG, CMD_OPTIONAL, "reset log contents");
cmd_AddParm(ts, "-dump", CMD_FLAG, CMD_OPTIONAL, "dump log contents");
cmd_CreateAlias(ts, "tr");
- ts = cmd_CreateSyntax("uuid", UuidCmd, 0, "manage the UUID for the cache manager");
+ ts = cmd_CreateSyntax("uuid", UuidCmd, NULL, "manage the UUID for the cache manager");
cmd_AddParm(ts, "-generate", CMD_FLAG, CMD_OPTIONAL, "generate a new UUID");
- ts = cmd_CreateSyntax("memdump", MemDumpCmd, 0, "dump memory allocs in debug builds");
+ ts = cmd_CreateSyntax("memdump", MemDumpCmd, NULL, "dump memory allocs in debug builds");
cmd_AddParm(ts, "-begin", CMD_FLAG, CMD_OPTIONAL, "set a memory checkpoint");
cmd_AddParm(ts, "-end", CMD_FLAG, CMD_OPTIONAL, "dump memory allocs");
- ts = cmd_CreateSyntax("cscpolicy", CSCPolicyCmd, 0, "change client side caching policy for AFS shares");
+ ts = cmd_CreateSyntax("cscpolicy", CSCPolicyCmd, NULL, "change client side caching policy for AFS shares");
cmd_AddParm(ts, "-share", CMD_SINGLE, CMD_OPTIONAL, "AFS share");
cmd_AddParm(ts, "-manual", CMD_FLAG, CMD_OPTIONAL, "manual caching of documents");
cmd_AddParm(ts, "-programs", CMD_FLAG, CMD_OPTIONAL, "automatic caching of programs and documents");
cmd_AddParm(ts, "-documents", CMD_FLAG, CMD_OPTIONAL, "automatic caching of documents");
cmd_AddParm(ts, "-disable", CMD_FLAG, CMD_OPTIONAL, "disable caching");
- ts = cmd_CreateSyntax("minidump", MiniDumpCmd, 0, "Generate MiniDump of current service state");
+ ts = cmd_CreateSyntax("minidump", MiniDumpCmd, NULL, "Generate MiniDump of current service state");
code = cmd_Dispatch(argc, argv);
#define KABADARGUMENT 1
#define KLOGEXIT(code) exit(code)
-int CommandProc();
+int CommandProc(struct cmd_syndesc *, void *);
static int zero_argc;
static char **zero_argv;
/* Start up sockets */
WSAStartup(0x0101, &WSAjunk);
- ts = cmd_CreateSyntax((char *) 0, CommandProc, 0, "obtain Kerberos authentication");
+ ts = cmd_CreateSyntax(NULL, CommandProc, NULL, "obtain Kerberos authentication");
#define aXFLAG 0
#define aPRINCIPAL 1
return !ok;
}
-CommandProc (as, arock)
- char *arock;
- struct cmd_syndesc *as;
+int
+CommandProc (struct cmd_syndesc *as, void *arock)
{
char name[MAXKTCNAMELEN];
char defaultCell[256];
}
-static ListLinkCmd(as)
-register struct cmd_syndesc *as; {
+static ListLinkCmd(register struct cmd_syndesc *as, void *arock)
+{
register afs_int32 code;
struct ViceIoctl blob;
int error;
return error;
}
-static MakeLinkCmd(as)
-register struct cmd_syndesc *as; {
+static MakeLinkCmd(register struct cmd_syndesc *as, void *arock)
+{
register afs_int32 code;
struct ViceIoctl blob;
char * parent;
* symlink (or ``.'' if none is provided)
* tp: Set to point to the actual name of the symlink to nuke.
*/
-static RemoveLinkCmd(as)
-register struct cmd_syndesc *as; {
+static RemoveLinkCmd(register struct cmd_syndesc *as, void *arock)
+{
register afs_int32 code=0;
struct ViceIoctl blob;
register struct cmd_item *ti;
osi_Init();
- ts = cmd_CreateSyntax("list", ListLinkCmd, 0, "list symlink");
+ ts = cmd_CreateSyntax("list", ListLinkCmd, NULL, "list symlink");
cmd_AddParm(ts, "-name", CMD_LIST, 0, "name");
- ts = cmd_CreateSyntax("make", MakeLinkCmd, 0, "make symlink");
+ ts = cmd_CreateSyntax("make", MakeLinkCmd, NULL, "make symlink");
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "name");
cmd_AddParm(ts, "-to", CMD_SINGLE, 0, "target");
- ts = cmd_CreateSyntax("remove", RemoveLinkCmd, 0, "remove symlink");
+ ts = cmd_CreateSyntax("remove", RemoveLinkCmd, NULL, "remove symlink");
cmd_AddParm(ts, "-name", CMD_LIST, 0, "name");
cmd_CreateAlias(ts, "rm");
static char* whoami;
-static int DoVptList(struct cmd_syndesc *as, char *arock)
+static int DoVptList(struct cmd_syndesc *as, void *arock)
{
struct vpt_iter vpiter;
struct vptab vpentry;
return 0;
}
-static int DoVptAdd(struct cmd_syndesc *as, char *arock)
+static int DoVptAdd(struct cmd_syndesc *as, void *arock)
{
char *vpName, *vpDev;
struct vptab vpentry;
return 0;
}
-static int DoVptDel(struct cmd_syndesc *as, char *arock)
+static int DoVptDel(struct cmd_syndesc *as, void *arock)
{
char *vpName;
}
-static int DoDirGet(struct cmd_syndesc *as, char *arock)
+static int DoDirGet(struct cmd_syndesc *as, void *arock)
{
char *buf;
}
-static int DoDirSet(struct cmd_syndesc *as, char *arock)
+static int DoDirSet(struct cmd_syndesc *as, void *arock)
{
long status;
HKEY key;
}
-static int DoBosCfg(struct cmd_syndesc *as, char *arock)
+static int DoBosCfg(struct cmd_syndesc *as, void *arock)
{
char bosSvcPath[AFSDIR_PATH_MAX];
SC_HANDLE scmHandle, svcHandle;
}
-static int DoBosDel(struct cmd_syndesc *as, char *arock)
+static int DoBosDel(struct cmd_syndesc *as, void *arock)
{
int rc = 0;
SC_HANDLE scmHandle, svcHandle;
return (rc);
}
-static int DoVersionGet(struct cmd_syndesc *as, char *arock)
+static int DoVersionGet(struct cmd_syndesc *as, void *arock)
{
unsigned major, minor, patch;
{
struct cmd_syndesc *ts;
- ts = cmd_CreateSyntax("vptlist", DoVptList, 0,
+ ts = cmd_CreateSyntax("vptlist", DoVptList, NULL,
"list vice partition table");
- ts = cmd_CreateSyntax("vptadd", DoVptAdd, 0,
+ ts = cmd_CreateSyntax("vptadd", DoVptAdd, NULL,
"add entry to vice partition table");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED, "partition name");
cmd_AddParm(ts, "-dev", CMD_SINGLE, CMD_REQUIRED, "device name");
- ts = cmd_CreateSyntax("vptdel", DoVptDel, 0,
+ ts = cmd_CreateSyntax("vptdel", DoVptDel, NULL,
"remove entry from vice partition table");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED, "partition name");
}
{
struct cmd_syndesc *ts;
- ts = cmd_CreateSyntax("dirget", DoDirGet, 0,
+ ts = cmd_CreateSyntax("dirget", DoDirGet, NULL,
"display the AFS server installation directory");
- ts = cmd_CreateSyntax("dirset", DoDirSet, 0,
+ ts = cmd_CreateSyntax("dirset", DoDirSet, NULL,
"set the AFS server installation directory");
cmd_AddParm(ts, "-path", CMD_SINGLE, CMD_REQUIRED, "directory path");
}
{
struct cmd_syndesc *ts;
- ts = cmd_CreateSyntax("boscfg", DoBosCfg, 0,
+ ts = cmd_CreateSyntax("boscfg", DoBosCfg, NULL,
"configure the AFS BOS control service");
cmd_AddParm(ts, "-path", CMD_SINGLE, CMD_OPTIONAL, "service binary path");
- ts = cmd_CreateSyntax("bosdel", DoBosDel, 0,
+ ts = cmd_CreateSyntax("bosdel", DoBosDel, NULL,
"delete (unconfigure) the AFS BOS control service");
}
{
struct cmd_syndesc *ts;
- ts = cmd_CreateSyntax("version", DoVersionGet, 0,
+ ts = cmd_CreateSyntax("version", DoVersionGet, NULL,
"display AFS version information");
}
#endif
#endif
-mainproc(struct cmd_syndesc *as, char *arock)
+mainproc(struct cmd_syndesc *as, void *arock)
{
static char rn[] = "afsd"; /*Name of this routine */
afs_int32 code; /*Result of fork() */
*----------------------------------------------------------------------*/
int
-afsmonInit(as)
- struct cmd_syndesc *as;
+afsmonInit(struct cmd_syndesc *as, void *arock)
{ /* afsmonInit() */
static char rn[] = "afsmonInit"; /* Routine name */
/*
* Set up the commands we understand.
*/
- ts = cmd_CreateSyntax("initcmd", afsmonInit, 0, "initialize the program");
+ ts = cmd_CreateSyntax("initcmd", afsmonInit, NULL, "initialize the program");
cmd_AddParm(ts, "-config", CMD_SINGLE, CMD_OPTIONAL,
"configuration file");
cmd_AddParm(ts, "-frequency", CMD_SINGLE, CMD_OPTIONAL,
zero_argc = argc;
zero_argv = argv;
- ts = cmd_CreateSyntax(NULL, CommandProc, 0,
+ ts = cmd_CreateSyntax(NULL, CommandProc, NULL,
"obtain Kerberos authentication for web servers");
/* define the command line arguments */
* arrive through a pipe from the httpds, authenticates the user and
* returns a token (or a failure message) over the pipe
*/
-CommandProc(as, arock)
- char *arock;
- struct cmd_syndesc *as;
-
+static int
+CommandProc(struct cmd_syndesc *as, void *arock)
{
char name[MAXKTCNAMELEN];
char cell[MAXKTCREALMLEN];
#define KLOGEXIT(code) rx_Finalize(); \
(exit(!!code))
-extern int CommandProc(struct cmd_syndesc *as, char *arock);
+static int CommandProc(struct cmd_syndesc *as, void *arock);
static int zero_argc;
static char **zero_argv;
zero_argc = argc;
zero_argv = argv;
- ts = cmd_CreateSyntax(NULL, CommandProc, 0,
+ ts = cmd_CreateSyntax(NULL, CommandProc, NULL,
"obtain Kerberos authentication");
#define aXFLAG 0
return 0;
}
-int
-CommandProc(struct cmd_syndesc *as, char *arock)
+static int
+CommandProc(struct cmd_syndesc *as, void *arock)
{
krb5_principal princ = 0;
char *cell, *pname, **hrealms, *service;
return tconn;
}
-static
-SetAuth(as)
- struct cmd_syndesc *as;
+static int
+SetAuth(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
register struct rx_connection *tconn;
}
}
-static
-Prune(as)
- register struct cmd_syndesc *as;
+static int
+Prune(register struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
register struct rx_connection *tconn;
return code;
}
-static
-Exec(as)
- register struct cmd_syndesc *as;
+static int
+Exec(register struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return code;
}
-static
-GetDate(as)
- register struct cmd_syndesc *as;
+static int
+GetDate(register struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
char tbuffer[256];
return 0;
}
-static
-UnInstall(as)
- register struct cmd_syndesc *as;
+static int
+UnInstall(register struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
char tbuffer[256];
return BSTAT_NORMAL;
}
-static
-Install(as)
- struct cmd_syndesc *as;
+static int
+Install(struct cmd_syndesc *as, void *arock)
{
struct rx_connection *tconn;
register afs_int32 code;
return 0;
}
-static
-Shutdown(as)
- struct cmd_syndesc *as;
+static int
+Shutdown(struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return 0;
}
-static
-BlockScannerCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+static int
+BlockScannerCmd(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
struct rx_connection *tconn;
return 0;
}
-static
-UnBlockScannerCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+static int
+UnBlockScannerCmd(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
struct rx_connection *tconn;
return 0;
}
-static
-GetRestartCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+static int
+GetRestartCmd(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
struct ktime generalTime, newBinaryTime;
return 0;
}
-static
-SetRestartCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+static int
+SetRestartCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 count;
register afs_int32 code;
return 0;
}
-static
-Startup(as)
- struct cmd_syndesc *as;
+static int
+Startup(struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return 0;
}
-static
-Restart(as)
- struct cmd_syndesc *as;
+static int
+Restart(struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return 0;
}
-static
-SetCellName(as)
- struct cmd_syndesc *as;
+static int
+SetCellName(struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return 0;
}
-static
-AddHost(as)
- register struct cmd_syndesc *as;
+static int
+AddHost(register struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return 0;
}
-static
-RemoveHost(as)
- register struct cmd_syndesc *as;
+static int
+RemoveHost(register struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return 0;
}
-static
-ListHosts(as)
- register struct cmd_syndesc *as;
+static int
+ListHosts(register struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return 0;
}
-static
-AddKey(as)
- register struct cmd_syndesc *as;
+static int
+AddKey(register struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return 0;
}
-static
-RemoveKey(as)
- register struct cmd_syndesc *as;
+static int
+RemoveKey(register struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return 0;
}
-static
-ListKeys(as)
- IN register struct cmd_syndesc *as;
+static int
+ListKeys(register struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return 0;
}
-static
-AddSUser(as)
- register struct cmd_syndesc *as;
+static int
+AddSUser(register struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return failed;
}
-static
-RemoveSUser(as)
- register struct cmd_syndesc *as;
+static int
+RemoveSUser(register struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register struct cmd_item *ti;
}
#define NPERLINE 10 /* dudes to print per line */
-static
-ListSUsers(as)
- register struct cmd_syndesc *as;
+static int
+ListSUsers(register struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register int i;
return 0;
}
-static
-StatServer(as)
- register struct cmd_syndesc *as;
+static int
+StatServer(register struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return 0;
}
-static
-CreateServer(as)
- register struct cmd_syndesc *as;
+static int
+CreateServer(register struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return code;
}
-static
-DeleteServer(as)
- register struct cmd_syndesc *as;
+static int
+DeleteServer(register struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return code;
}
-static
-StartServer(as)
- register struct cmd_syndesc *as;
+static int
+StartServer(register struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return code;
}
-static
-StopServer(as)
- register struct cmd_syndesc *as;
+static int
+StopServer(register struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code;
return code;
}
-static
-GetLogCmd(as)
- register struct cmd_syndesc *as;
+static int
+GetLogCmd(register struct cmd_syndesc *as, void *arock)
{
struct rx_connection *tconn;
register struct rx_call *tcall;
return code;
}
-static
-SalvageCmd(as)
- struct cmd_syndesc *as;
+static int
+SalvageCmd(struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
register afs_int32 code, rc, i;
}
#ifdef BOS_RESTRICTED_MODE
-static
-GetRestrict(as)
- struct cmd_syndesc *as;
+static int
+GetRestrict(struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
afs_int32 code, val;
return 0;
}
-static
-SetRestrict(as)
- struct cmd_syndesc *as;
+static int
+SetRestrict(struct cmd_syndesc *as, void *arock)
{
register struct rx_connection *tconn;
afs_int32 code, val;
initialize_CMD_error_table();
initialize_BZ_error_table();
- ts = cmd_CreateSyntax("start", StartServer, 0, "start running a server");
+ ts = cmd_CreateSyntax("start", StartServer, NULL, "start running a server");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-instance", CMD_LIST, 0, "server process name");
add_std_args(ts);
- ts = cmd_CreateSyntax("stop", StopServer, 0, "halt a server instance");
+ ts = cmd_CreateSyntax("stop", StopServer, NULL, "halt a server instance");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-instance", CMD_LIST, 0, "server process name");
cmd_Seek(ts, 8);
"wait for process to stop");
add_std_args(ts);
- ts = cmd_CreateSyntax("status", StatServer, 0,
+ ts = cmd_CreateSyntax("status", StatServer, NULL,
"show server instance status");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-instance", CMD_LIST, CMD_OPTIONAL,
cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL, "long status");
add_std_args(ts);
- ts = cmd_CreateSyntax("shutdown", Shutdown, 0, "shutdown all processes");
+ ts = cmd_CreateSyntax("shutdown", Shutdown, NULL, "shutdown all processes");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-instance", CMD_LIST, CMD_OPTIONAL, "instances");
cmd_Seek(ts, 8);
"wait for process to stop");
add_std_args(ts);
- ts = cmd_CreateSyntax("startup", Startup, 0, "start all processes");
+ ts = cmd_CreateSyntax("startup", Startup, NULL, "start all processes");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-instance", CMD_LIST, CMD_OPTIONAL, "instances");
add_std_args(ts);
- ts = cmd_CreateSyntax("restart", Restart, 0, "restart processes");
+ ts = cmd_CreateSyntax("restart", Restart, NULL, "restart processes");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-instance", CMD_LIST, CMD_OPTIONAL, "instances");
cmd_AddParm(ts, "-bosserver", CMD_FLAG, CMD_OPTIONAL,
#ifndef OPBOS
- ts = cmd_CreateSyntax("create", CreateServer, 0,
+ ts = cmd_CreateSyntax("create", CreateServer, NULL,
"create a new server instance");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-instance", CMD_SINGLE, 0, "server process name");
"Notifier program");
add_std_args(ts);
- ts = cmd_CreateSyntax("delete", DeleteServer, 0,
+ ts = cmd_CreateSyntax("delete", DeleteServer, NULL,
"delete a server instance");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-instance", CMD_LIST, 0, "server process name");
add_std_args(ts);
- ts = cmd_CreateSyntax("adduser", AddSUser, 0,
+ ts = cmd_CreateSyntax("adduser", AddSUser, NULL,
"add users to super-user list");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-user", CMD_LIST, 0, "user names");
add_std_args(ts);
- ts = cmd_CreateSyntax("removeuser", RemoveSUser, 0,
+ ts = cmd_CreateSyntax("removeuser", RemoveSUser, NULL,
"remove users from super-user list");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-user", CMD_LIST, 0, "user names");
add_std_args(ts);
- ts = cmd_CreateSyntax("listusers", ListSUsers, 0, "list super-users");
+ ts = cmd_CreateSyntax("listusers", ListSUsers, NULL, "list super-users");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
add_std_args(ts);
- ts = cmd_CreateSyntax("addkey", AddKey, 0,
+ ts = cmd_CreateSyntax("addkey", AddKey, NULL,
"add keys to key dbase (kvno 999 is bcrypt)");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-key", CMD_SINGLE, CMD_OPTIONAL, "key");
cmd_AddParm(ts, "-kvno", CMD_SINGLE, 0, "key version number");
add_std_args(ts);
- ts = cmd_CreateSyntax("removekey", RemoveKey, 0,
+ ts = cmd_CreateSyntax("removekey", RemoveKey, NULL,
"remove keys from key dbase");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-kvno", CMD_LIST, 0, "key version number");
add_std_args(ts);
- ts = cmd_CreateSyntax("listkeys", ListKeys, 0, "list keys");
+ ts = cmd_CreateSyntax("listkeys", ListKeys, NULL, "list keys");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-showkey", CMD_FLAG, CMD_OPTIONAL,
"show the actual key rather than the checksum");
add_std_args(ts);
- ts = cmd_CreateSyntax("listhosts", ListHosts, 0, "get cell host list");
+ ts = cmd_CreateSyntax("listhosts", ListHosts, NULL, "get cell host list");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
add_std_args(ts);
cmd_CreateAlias(ts, "getcell");
- ts = cmd_CreateSyntax("setcellname", SetCellName, 0, "set cell name");
+ ts = cmd_CreateSyntax("setcellname", SetCellName, NULL, "set cell name");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "cell name");
add_std_args(ts);
- ts = cmd_CreateSyntax("addhost", AddHost, 0, "add host to cell dbase");
+ ts = cmd_CreateSyntax("addhost", AddHost, NULL, "add host to cell dbase");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-host", CMD_LIST, 0, "host name");
cmd_AddParm(ts, "-clone", CMD_FLAG, CMD_OPTIONAL, "vote doesn't count");
add_std_args(ts);
- ts = cmd_CreateSyntax("removehost", RemoveHost, 0,
+ ts = cmd_CreateSyntax("removehost", RemoveHost, NULL,
"remove host from cell dbase");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-host", CMD_LIST, 0, "host name");
add_std_args(ts);
- ts = cmd_CreateSyntax("setauth", SetAuth, 0,
+ ts = cmd_CreateSyntax("setauth", SetAuth, NULL,
"set authentication required flag");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-authrequired", CMD_SINGLE, 0,
"on or off: authentication required for admin requests");
add_std_args(ts);
- ts = cmd_CreateSyntax("install", Install, 0, "install program");
+ ts = cmd_CreateSyntax("install", Install, NULL, "install program");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-file", CMD_LIST, 0, "files to install");
cmd_AddParm(ts, "-dir", CMD_SINGLE, CMD_OPTIONAL, "destination dir");
add_std_args(ts);
- ts = cmd_CreateSyntax("uninstall", UnInstall, 0, "uninstall program");
+ ts = cmd_CreateSyntax("uninstall", UnInstall, NULL, "uninstall program");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-file", CMD_LIST, 0, "files to uninstall");
cmd_AddParm(ts, "-dir", CMD_SINGLE, CMD_OPTIONAL, "destination dir");
add_std_args(ts);
- ts = cmd_CreateSyntax("getlog", GetLogCmd, 0, "examine log file");
+ ts = cmd_CreateSyntax("getlog", GetLogCmd, NULL, "examine log file");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-file", CMD_SINGLE, 0, "log file to examine");
add_std_args(ts);
- ts = cmd_CreateSyntax("getdate", GetDate, 0, "get dates for programs");
+ ts = cmd_CreateSyntax("getdate", GetDate, NULL, "get dates for programs");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-file", CMD_LIST, 0, "files to check");
cmd_AddParm(ts, "-dir", CMD_SINGLE, CMD_OPTIONAL, "destination dir");
add_std_args(ts);
- ts = cmd_CreateSyntax("exec", Exec, 0, "execute shell command on server");
+ ts = cmd_CreateSyntax("exec", Exec, NULL, "execute shell command on server");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-cmd", CMD_SINGLE, 0, "command to execute");
add_std_args(ts);
- ts = cmd_CreateSyntax("prune", Prune, 0, "prune server files");
+ ts = cmd_CreateSyntax("prune", Prune, NULL, "prune server files");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-bak", CMD_FLAG, CMD_OPTIONAL, "delete .BAK files");
cmd_AddParm(ts, "-old", CMD_FLAG, CMD_OPTIONAL, "delete .OLD files");
cmd_AddParm(ts, "-all", CMD_FLAG, CMD_OPTIONAL, "delete all junk files");
add_std_args(ts);
- ts = cmd_CreateSyntax("setrestart", SetRestartCmd, 0,
+ ts = cmd_CreateSyntax("setrestart", SetRestartCmd, NULL,
"set restart times");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "machine name");
cmd_AddParm(ts, "-time", CMD_SINGLE, CMD_REQUIRED,
"set new binary restart time");
add_std_args(ts);
- ts = cmd_CreateSyntax("getrestart", GetRestartCmd, 0,
+ ts = cmd_CreateSyntax("getrestart", GetRestartCmd, NULL,
"get restart times");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "machine name");
add_std_args(ts);
- ts = cmd_CreateSyntax("salvage", SalvageCmd, 0,
+ ts = cmd_CreateSyntax("salvage", SalvageCmd, NULL,
"salvage partition or volumes");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
"(MR-AFS) Numeric mask of residencies to be included in the salvage. Do not use with -SalvageRemote or -SalvageArchival");
add_std_args(ts);
- ts = cmd_CreateSyntax("blockscanner", BlockScannerCmd, 0,
+ ts = cmd_CreateSyntax("blockscanner", BlockScannerCmd, NULL,
"block scanner daemon from making migration requests");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "machine name");
add_std_args(ts);
- ts = cmd_CreateSyntax("unblockscanner", UnBlockScannerCmd, 0,
+ ts = cmd_CreateSyntax("unblockscanner", UnBlockScannerCmd, NULL,
"allow scanner daemon to make migration requests again");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "machine name");
add_std_args(ts);
#ifdef BOS_RESTRICTED_MODE
- ts = cmd_CreateSyntax("getrestricted", GetRestrict, 0,
+ ts = cmd_CreateSyntax("getrestricted", GetRestrict, NULL,
"get restrict mode");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
add_std_args(ts);
- ts = cmd_CreateSyntax("setrestricted", SetRestrict, 0,
+ ts = cmd_CreateSyntax("setrestricted", SetRestrict, NULL,
"set restrict mode");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-mode", CMD_SINGLE, 0, "mode to set");
/* prototypes */
int fileMark(usd_handle_t hTape);
int fileMarkSize(char *tapeDevice);
-void tt_fileMarkSize(struct cmd_syndesc *as, char *arock);
+static int tt_fileMarkSize(struct cmd_syndesc *as, void *arock);
#define ERROR(evalue) \
{ \
sigaction(SIGINT, &intaction, &oldaction);
cptr =
- cmd_CreateSyntax(NULL, tt_fileMarkSize, 0,
+ cmd_CreateSyntax(NULL, tt_fileMarkSize, NULL,
"write a tape full of file marks");
cmd_AddParm(cptr, "-tape", CMD_SINGLE, CMD_REQUIRED, "tape special file");
cmd_Dispatch(argc, argv);
}
-void
-tt_fileMarkSize(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+static int
+tt_fileMarkSize(struct cmd_syndesc *as, void *arock)
{
char *tapeDevice;
tapeDevice = as->parms[0].items->data;
fileMarkSize(tapeDevice);
+
+ return 0;
}
/* bc_GetTapeStatusCmd
* display status of all tasks on a particular tape coordinator
*/
-
-bc_GetTapeStatusCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_GetTapeStatusCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct rx_connection *tconn;
* parameters
* ignored - a null "as" prints only jobs.
*/
-
-bc_JobsCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_JobsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 prevTime;
dlqlinkP ptr;
return 0;
}
-bc_KillCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_KillCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 i;
afs_int32 slot;
}
/* restore a volume or volumes */
-bc_VolRestoreCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_VolRestoreCmd(struct cmd_syndesc *as, void *arock)
{
/*
* parm 0 is the new server to restore to
* various optional
*/
-bc_DiskRestoreCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_DiskRestoreCmd(struct cmd_syndesc *as, void *arock)
{
struct bc_volumeSet tvolumeSet; /* temporary volume set for EvalVolumeSet call */
struct bc_volumeEntry tvolumeEntry; /* entry within the volume set */
* restore a volumeset or list of volumes.
*/
-bc_VolsetRestoreCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_VolsetRestoreCmd(struct cmd_syndesc *as, void *arock)
{
int oldFlag;
long fromDate;
int dontExecute;
int
-bc_DumpCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+bc_DumpCmd(struct cmd_syndesc *as, void *arock)
{ /*bc_DumpCmd */
static char rn[] = "bc_DumpCmd"; /*Routine name */
char *dumpPath, *vsName; /*Ptrs to various names */
* parameters:
* ignored
*/
-
-bc_QuitCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_QuitCmd(struct cmd_syndesc *as, void *arock)
{
int i;
struct bc_dumpTask *td;
* Labels a tape i.e. request the tape coordinator to perform this
* operation
*/
-
-bc_LabelTapeCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_LabelTapeCmd(struct cmd_syndesc *as, void *arock)
{
char *tapename = 0, *pname = 0;
afs_int32 size;
* params:
* optional port number
*/
-
-bc_ReadLabelCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_ReadLabelCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
afs_int32 port = 0;
* read content information from dump tapes, and if user desires,
* add it to the database
*/
-
-bc_ScanDumpsCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_ScanDumpsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 port = 0;
afs_int32 dbAddFlag = 0;
* Currently a single option, volumename to search for. Reports
* all dumps containing the specified volume
*/
-
-bc_dblookupCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_dblookupCmd(struct cmd_syndesc *as, void *arock)
{
struct cmd_item *ciptr;
afs_int32 code;
/* for ubik version */
-
-bc_dbVerifyCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_dbVerifyCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 status;
afs_int32 orphans;
* entry:
* dump id - single required arg as param 0.
*/
-
-bc_deleteDumpCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_deleteDumpCmd(struct cmd_syndesc *as, void *arock)
{
afs_uint32 dumpid;
afs_int32 code = 0;
return (rcode);
}
-bc_saveDbCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_saveDbCmd(struct cmd_syndesc *as, void *arock)
{
struct rx_connection *tconn;
afs_int32 portOffset = 0;
return (code);
}
-bc_restoreDbCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_restoreDbCmd(struct cmd_syndesc *as, void *arock)
{
struct rx_connection *tconn;
afs_int32 portOffset = 0;
* as - name of tape
* arock -
*/
-bc_dumpInfoCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_dumpInfoCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 dumpid;
afs_int32 detailFlag;
* parm 1: expiration date (list)
*/
-afs_int32
-bc_AddDumpCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_AddDumpCmd(struct cmd_syndesc *as, void *arock)
{
register char *dname; /* dump schedule name */
- register afs_int32 code;
+ register int code;
afs_int32 expType, expDate;
register struct cmd_item *ti;
udbClientTextP ctPtr;
* delete a dump schedule
*/
-afs_int32
-bc_DeleteDumpCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_DeleteDumpCmd(struct cmd_syndesc *as, void *arock)
{
/* parm 0 is vol set name
* parm 1 is dump schedule name
*/
register char *dname;
- register afs_int32 code;
+ register int code;
udbClientTextP ctPtr;
/* lock schedules and check validity */
* ignored
*/
-afs_int32
-bc_ListDumpScheduleCmd(struct cmd_syndesc *as, char *arock)
+int
+bc_ListDumpScheduleCmd(struct cmd_syndesc *as, void *arock)
{
/* no parms */
- afs_int32 code;
+ int code;
register struct bc_dumpSchedule *tdump;
/* first check to see if schedules must be updated */
* parm 1: expiration date (list)
*/
-afs_int32
-bc_SetExpCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_SetExpCmd(struct cmd_syndesc *as, void *arock)
{
register char *dname; /* dump schedule name */
register struct cmd_item *ti;
struct bc_dumpSchedule *node, *parent;
afs_int32 expType, expDate;
udbClientTextP ctPtr;
- register afs_int32 code;
+ register int code;
afs_int32 bc_ParseExpiration();
*/
static int
-MyBeforeProc(as)
- register struct cmd_syndesc *as;
+MyBeforeProc(register struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
}
int
-bc_interactCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+bc_interactCmd(struct cmd_syndesc *as, void *arock)
{
interact = 1;
return 0;
cmd_SetBeforeProc(MyBeforeProc, NULL);
- ts = cmd_CreateSyntax("dump", bc_DumpCmd, 0, "start dump");
+ ts = cmd_CreateSyntax("dump", bc_DumpCmd, NULL, "start dump");
cmd_AddParm(ts, "-volumeset", CMD_SINGLE, CMD_OPTIONAL,
"volume set name");
cmd_AddParm(ts, "-dump", CMD_SINGLE, CMD_OPTIONAL, "dump level name");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("volrestore", bc_VolRestoreCmd, 0,
+ ts = cmd_CreateSyntax("volrestore", bc_VolRestoreCmd, NULL,
"restore volume");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"destination machine");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("diskrestore", bc_DiskRestoreCmd, 0,
+ ts = cmd_CreateSyntax("diskrestore", bc_DiskRestoreCmd, NULL,
"restore partition");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"machine to restore");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("quit", bc_QuitCmd, 0, "leave the program");
+ ts = cmd_CreateSyntax("quit", bc_QuitCmd, NULL, "leave the program");
- ts = cmd_CreateSyntax("volsetrestore", bc_VolsetRestoreCmd, 0,
+ ts = cmd_CreateSyntax("volsetrestore", bc_VolsetRestoreCmd, NULL,
"restore a set of volumes");
cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_OPTIONAL, "volume set name");
cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_OPTIONAL, "file name");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("addhost", bc_AddHostCmd, 0, "add host to config");
+ ts = cmd_CreateSyntax("addhost", bc_AddHostCmd, NULL, "add host to config");
cmd_AddParm(ts, "-tapehost", CMD_SINGLE, CMD_REQUIRED,
"tape machine name");
cmd_AddParm(ts, "-portoffset", CMD_SINGLE, CMD_OPTIONAL,
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("delhost", bc_DeleteHostCmd, 0,
+ ts = cmd_CreateSyntax("delhost", bc_DeleteHostCmd, NULL,
"delete host to config");
cmd_AddParm(ts, "-tapehost", CMD_SINGLE, CMD_REQUIRED,
"tape machine name");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("listhosts", bc_ListHostsCmd, 0,
+ ts = cmd_CreateSyntax("listhosts", bc_ListHostsCmd, NULL,
"list config hosts");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("jobs", bc_JobsCmd, 0, "list running jobs");
+ ts = cmd_CreateSyntax("jobs", bc_JobsCmd, NULL, "list running jobs");
- ts = cmd_CreateSyntax("kill", bc_KillCmd, 0, "kill running job");
+ ts = cmd_CreateSyntax("kill", bc_KillCmd, NULL, "kill running job");
cmd_AddParm(ts, "-id", CMD_SINGLE, CMD_REQUIRED,
"job ID or dump set name");
- ts = cmd_CreateSyntax("listvolsets", bc_ListVolSetCmd, 0,
+ ts = cmd_CreateSyntax("listvolsets", bc_ListVolSetCmd, NULL,
"list volume sets");
cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_OPTIONAL, "volume set name");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("listdumps", bc_ListDumpScheduleCmd, 0,
+ ts = cmd_CreateSyntax("listdumps", bc_ListDumpScheduleCmd, NULL,
"list dump schedules");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("addvolset", bc_AddVolSetCmd, 0,
+ ts = cmd_CreateSyntax("addvolset", bc_AddVolSetCmd, NULL,
"create a new volume set");
cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED, "volume set name");
cmd_AddParm(ts, "-temporary", CMD_FLAG, CMD_OPTIONAL,
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("status", bc_GetTapeStatusCmd, 0,
+ ts = cmd_CreateSyntax("status", bc_GetTapeStatusCmd, NULL,
"get tape coordinator status");
cmd_AddParm(ts, "-portoffset", CMD_SINGLE, CMD_OPTIONAL,
"TC port offset");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("delvolset", bc_DeleteVolSetCmd, 0,
+ ts = cmd_CreateSyntax("delvolset", bc_DeleteVolSetCmd, NULL,
"delete a volume set");
cmd_AddParm(ts, "-name", CMD_LIST, CMD_REQUIRED, "volume set name");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("addvolentry", bc_AddVolEntryCmd, 0,
+ ts = cmd_CreateSyntax("addvolentry", bc_AddVolEntryCmd, NULL,
"add a new volume entry");
cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED, "volume set name");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "machine name");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("delvolentry", bc_DeleteVolEntryCmd, 0,
+ ts = cmd_CreateSyntax("delvolentry", bc_DeleteVolEntryCmd, NULL,
"delete a volume set sub-entry");
cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED, "volume set name");
cmd_AddParm(ts, "-entry", CMD_SINGLE, CMD_REQUIRED, "volume set index");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("adddump", bc_AddDumpCmd, 0, "add dump schedule");
+ ts = cmd_CreateSyntax("adddump", bc_AddDumpCmd, NULL, "add dump schedule");
cmd_AddParm(ts, "-dump", CMD_LIST, CMD_REQUIRED, "dump level name");
cmd_AddParm(ts, "-expires", CMD_LIST, CMD_OPTIONAL, "expiration date");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("deldump", bc_DeleteDumpCmd, 0,
+ ts = cmd_CreateSyntax("deldump", bc_DeleteDumpCmd, NULL,
"delete dump schedule");
cmd_AddParm(ts, "-dump", CMD_SINGLE, CMD_REQUIRED, "dump level name");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("labeltape", bc_LabelTapeCmd, 0, "label a tape");
+ ts = cmd_CreateSyntax("labeltape", bc_LabelTapeCmd, NULL, "label a tape");
cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_OPTIONAL,
"AFS tape name, defaults to NULL");
cmd_AddParm(ts, "-size", CMD_SINGLE, CMD_OPTIONAL,
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("readlabel", bc_ReadLabelCmd, 0,
+ ts = cmd_CreateSyntax("readlabel", bc_ReadLabelCmd, NULL,
"read the label on tape");
cmd_AddParm(ts, "-portoffset", CMD_SINGLE, CMD_OPTIONAL,
"TC port offset");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("scantape", bc_ScanDumpsCmd, 0,
+ ts = cmd_CreateSyntax("scantape", bc_ScanDumpsCmd, NULL,
"dump information recovery from tape");
cmd_AddParm(ts, "-dbadd", CMD_FLAG, CMD_OPTIONAL,
"add information to the database");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("volinfo", bc_dblookupCmd, 0,
+ ts = cmd_CreateSyntax("volinfo", bc_dblookupCmd, NULL,
"query the backup database");
cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume name");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("setexp", bc_SetExpCmd, 0,
+ ts = cmd_CreateSyntax("setexp", bc_SetExpCmd, NULL,
"set/clear dump expiration dates");
cmd_AddParm(ts, "-dump", CMD_LIST, CMD_REQUIRED, "dump level name");
cmd_AddParm(ts, "-expires", CMD_LIST, CMD_OPTIONAL, "expiration date");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("savedb", bc_saveDbCmd, 0, "save backup database");
+ ts = cmd_CreateSyntax("savedb", bc_saveDbCmd, NULL, "save backup database");
cmd_AddParm(ts, "-portoffset", CMD_SINGLE, CMD_OPTIONAL,
"TC port offset");
cmd_AddParm(ts, "-archive", CMD_LIST, CMD_OPTIONAL, "date time");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("restoredb", bc_restoreDbCmd, 0,
+ ts = cmd_CreateSyntax("restoredb", bc_restoreDbCmd, NULL,
"restore backup database");
cmd_AddParm(ts, "-portoffset", CMD_SINGLE, CMD_OPTIONAL,
"TC port offset");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("dumpinfo", bc_dumpInfoCmd, 0,
+ ts = cmd_CreateSyntax("dumpinfo", bc_dumpInfoCmd, NULL,
"provide information about a dump in the database");
cmd_AddParm(ts, "-ndumps", CMD_SINGLE, CMD_OPTIONAL, "no. of dumps");
cmd_AddParm(ts, "-id", CMD_SINGLE, CMD_OPTIONAL, "dump id");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("dbverify", bc_dbVerifyCmd, 0,
+ ts = cmd_CreateSyntax("dbverify", bc_dbVerifyCmd, NULL,
"check ubik database integrity");
cmd_AddParm(ts, "-detail", CMD_FLAG, CMD_OPTIONAL, "additional details");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("deletedump", bc_deleteDumpCmd, 0,
+ ts = cmd_CreateSyntax("deletedump", bc_deleteDumpCmd, NULL,
"delete dumps from the database");
cmd_AddParm(ts, "-dumpid", CMD_LIST, CMD_OPTIONAL, "dump id");
cmd_AddParm(ts, "-from", CMD_LIST, CMD_OPTIONAL, "date time");
if (!interact)
add_std_args(ts);
- ts = cmd_CreateSyntax("interactive", bc_interactCmd, 0,
+ ts = cmd_CreateSyntax("interactive", bc_interactCmd, NULL,
"enter interactive mode");
add_std_args(ts);
* Add a host to the tape hosts
*/
-afs_int32
-bc_AddHostCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_AddHostCmd(struct cmd_syndesc *as, void *arock)
{
struct cmd_item *ti;
udbClientTextP ctPtr;
return (code);
}
-afs_int32
-bc_DeleteHostCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_DeleteHostCmd(struct cmd_syndesc *as, void *arock)
{
struct cmd_item *ti;
afs_int32 port = 0;
* ignored
*/
-afs_int32
-bc_ListHostsCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_ListHostsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
register struct bc_hostEntry *tentry;
* parm 3 is volume regexp
*/
-bc_AddVolEntryCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_AddVolEntryCmd(struct cmd_syndesc *as, void *arock)
{
- register afs_int32 code;
+ register int code;
char *volSetName, *serverName, *partitionName, *volRegExp;
udbClientTextP ctPtr;
struct bc_volumeSet *tset;
* name of new volume set
*/
-afs_int32
-bc_AddVolSetCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_AddVolSetCmd(struct cmd_syndesc *as, void *arock)
{
/* parm 0 is vol set name */
- register afs_int32 code;
+ register int code;
register struct cmd_item *ti;
udbClientTextP ctPtr;
afs_int32 flags;
* parm 1 is entry # (integer, 1 based)
*/
-afs_int32
-bc_DeleteVolEntryCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_DeleteVolEntryCmd(struct cmd_syndesc *as, void *arock)
{
- register afs_int32 code;
+ register int code;
afs_int32 entry;
char *vsname;
udbClientTextP ctPtr;
* name of volumeset to delete
*/
-afs_int32
-bc_DeleteVolSetCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_DeleteVolSetCmd(struct cmd_syndesc *as, void *arock)
{
/* parm 0 is vol set name */
- register afs_int32 code;
+ register int code;
register struct cmd_item *ti;
udbClientTextP ctPtr;
afs_int32 c;
* optional parameter specifies a volumeset name
*/
-afs_int32
-bc_ListVolSetCmd(struct cmd_syndesc *as, char *arock)
+int
+bc_ListVolSetCmd(struct cmd_syndesc *as, void *arock)
{
/* parm 0 is optional volume set to display */
register struct bc_volumeSet *tset;
register struct cmd_item *ti;
- afs_int32 code = 0;
+ int code = 0;
code = bc_UpdateVolumeSet();
if (code) {
struct ubik_dbase *BU_dbase;
struct afsconf_dir *BU_conf; /* for getting cell info */
+int argHandler(struct cmd_syndesc *, void *);
+
char lcell[MAXKTCREALMLEN];
afs_int32 myHost = 0;
int helpOption;
* If it were, this routine would never have been called.
*/
static int
-MyBeforeProc(as)
- register struct cmd_syndesc *as;
+MyBeforeProc(register struct cmd_syndesc *as, void *arock)
{
helpOption = 0;
return 0;
{
struct cmd_syndesc *cptr;
- int argHandler();
-
cmd_SetBeforeProc(MyBeforeProc, NULL);
cptr = cmd_CreateSyntax(NULL, argHandler, NULL, "Backup database server");
}
int
-argHandler(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+argHandler(struct cmd_syndesc *as, void *arock)
{
/* globalConfPtr provides the handle for the configuration information */
return 0;
}
-WorkerBee(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+static int
+WorkerBee(struct cmd_syndesc *as, void *arock)
{
char *tapedev;
struct tapeLabel *label;
}
static int
-WorkerBee(struct cmd_syndesc *as, char *arock)
+WorkerBee(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
struct rx_securityClass *(securityObjects[3]);
}
-static
-PerformDump(as)
- register struct cmd_syndesc *as;
+static int
+PerformDump(register struct cmd_syndesc *as, void *arock)
{
struct rx_connection *aconn;
afs_int32 server;
exit(1);
}
printf("dumpid returned %u\n", tdumpID);
+
+ return 0;
}
-static
-PerformRestore(as)
- register struct cmd_syndesc *as;
+static int
+PerformRestore(register struct cmd_syndesc *as, void *arock)
{
struct rx_connection *aconn;
afs_int32 server;
exit(1);
}
printf("dumpid returned %u\n", tdumpID);
+ return 0;
}
-static
-CheckDump(as)
- register struct cmd_syndesc *as;
+static int
+CheckDump(register struct cmd_syndesc *as, void *arock)
{
struct rx_connection *aconn;
afs_int32 server;
printf("call to TC_CheckDump failed %u\n", code);
exit(1);
}
+ return 0;
}
-static
-AbortDump(as)
- register struct cmd_syndesc *as;
+static int
+AbortDump(register struct cmd_syndesc *as, void *arock)
{
struct rx_connection *aconn;
afs_int32 server;
printf("call to TC_AbortDump failed %u\n", code);
exit(1);
}
+ return 0;
}
-static
-WaitForDump(as)
- register struct cmd_syndesc *as;
+static int
+WaitForDump(register struct cmd_syndesc *as, void *arock)
{
struct rx_connection *aconn;
afs_int32 server;
printf("call to TC_WaitForDump failed %u\n", code);
exit(1);
}
+ return 0;
}
-static
-EndDump(as)
- register struct cmd_syndesc *as;
+static int
+EndDump(register struct cmd_syndesc *as, void *arock)
{
struct rx_connection *aconn;
afs_int32 server;
printf("call to TC_EndDump failed %u\n", code);
exit(1);
}
+ return 0;
}
-static
-MyBeforeProc(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+static int
+MyBeforeProc(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
#endif
cmd_SetBeforeProc(MyBeforeProc, NULL);
- ts = cmd_CreateSyntax("dump", PerformDump, 0, "perform a dump");
+ ts = cmd_CreateSyntax("dump", PerformDump, NULL, "perform a dump");
- ts = cmd_CreateSyntax("restore", PerformRestore, 0, "perform a restore");
+ ts = cmd_CreateSyntax("restore", PerformRestore, NULL, "perform a restore");
- ts = cmd_CreateSyntax("check", CheckDump, 0, "check a dump");
+ ts = cmd_CreateSyntax("check", CheckDump, NULL, "check a dump");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
- ts = cmd_CreateSyntax("abort", AbortDump, 0, "abort a dump");
+ ts = cmd_CreateSyntax("abort", AbortDump, NULL, "abort a dump");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
- ts = cmd_CreateSyntax("wait", WaitForDump, 0, "wait for a dump");
+ ts = cmd_CreateSyntax("wait", WaitForDump, NULL, "wait for a dump");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
- ts = cmd_CreateSyntax("end", EndDump, 0, "end a dump");
+ ts = cmd_CreateSyntax("end", EndDump, NULL, "end a dump");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "dump id");
code = cmd_Dispatch(argc, argv);
static int dummy; /* non-null ptr used for flag existence */
static struct cmd_syndesc *allSyntax = 0;
static int noOpcodes = 0;
-static int (*beforeProc) (struct cmd_syndesc * ts, char *beforeRock) =
- 0, (*afterProc) (struct cmd_syndesc * ts, char *afterRock) = 0;
-static char *beforeRock, *afterRock;
+static int (*beforeProc) (struct cmd_syndesc * ts, void *beforeRock) = NULL;
+static int (*afterProc) (struct cmd_syndesc * ts, void *afterRock) = NULL;
+static void *beforeRock, *afterRock;
static char initcmd_opcode[] = "initcmd"; /*Name of initcmd opcode */
/* take name and string, and return null string if name is empty, otherwise return
extern char *AFSVersion;
static int
-VersionProc(register struct cmd_syndesc *as, char *arock)
+VersionProc(register struct cmd_syndesc *as, void *arock)
{
printf("%s\n", AFSVersion);
return 0;
}
static int
-AproposProc(register struct cmd_syndesc *as, char *arock)
+AproposProc(register struct cmd_syndesc *as, void *arock)
{
register struct cmd_syndesc *ts;
char *tsub;
}
static int
-HelpProc(register struct cmd_syndesc *as, char *arock)
+HelpProc(register struct cmd_syndesc *as, void *arock)
{
register struct cmd_syndesc *ts;
register struct cmd_item *ti;
}
int
-cmd_SetBeforeProc(int (*aproc) (struct cmd_syndesc * ts, char *beforeRock),
- char *arock)
+cmd_SetBeforeProc(int (*aproc) (struct cmd_syndesc * ts, void *beforeRock),
+ void *arock)
{
beforeProc = aproc;
beforeRock = arock;
}
int
-cmd_SetAfterProc(int (*aproc) (struct cmd_syndesc * ts, char *afterRock),
- char *arock)
+cmd_SetAfterProc(int (*aproc) (struct cmd_syndesc * ts, void *afterRock),
+ void *arock)
{
afterProc = aproc;
afterRock = arock;
struct cmd_syndesc *
cmd_CreateSyntax(char *aname,
- int (*aproc) (struct cmd_syndesc * ts, char *arock),
- char *arock, char *ahelp)
+ int (*aproc) (struct cmd_syndesc * ts, void *arock),
+ void *arock, char *ahelp)
{
register struct cmd_syndesc *td;
strcpy(tp->name, aname);
tp->type = atype;
tp->flags = aflags;
- tp->items = (struct cmd_item *)0;
+ tp->items = NULL;
if (ahelp) {
tp->help = (char *)malloc(strlen(ahelp) + 1);
assert(tp->help);
default:
break;
}
- tp->items = (struct cmd_item *)0;
+ tp->items = NULL;
}
}
char *name; /* subcommand name */
char *a0name; /* command name from argv[0] */
char *help; /* help description */
- int (*proc) (struct cmd_syndesc * ts, char *arock);
- char *rock;
+ int (*proc) (struct cmd_syndesc * ts, void *arock);
+ void *rock;
int nParms; /* number of parms */
afs_int32 flags; /* random flags */
struct cmd_parmdesc parms[CMD_MAXPARMS]; /* parms themselves */
extern struct cmd_syndesc *cmd_CreateSyntax(char *namep,
int (*aprocp) (struct cmd_syndesc
- * ts, char *arock),
- char *rockp, char *helpp);
+ * ts, void *arock),
+ void *rockp, char *helpp);
extern int
- cmd_SetBeforeProc(int (*aproc) (struct cmd_syndesc * ts, char *beforeRock),
- char *arock);
+ cmd_SetBeforeProc(int (*aproc) (struct cmd_syndesc * ts, void *beforeRock),
+ void *arock);
extern int
- cmd_SetAfterProc(int (*aproc) (struct cmd_syndesc * ts, char *afterRock),
- char *arock);
+ cmd_SetAfterProc(int (*aproc) (struct cmd_syndesc * ts, void *afterRock),
+ void *arock);
extern int cmd_CreateAlias(struct cmd_syndesc *as, char *aname);
extern int cmd_Seek(struct cmd_syndesc *as, int apos);
extern int cmd_AddParm(struct cmd_syndesc *as, char *aname, int atype,
#include "cmd.h"
#include <stdio.h>
-static
-cproc1(as, arock)
- char *arock;
- struct cmd_syndesc *as;
+static int
+cproc1(struct cmd_syndesc *as, void *arock)
{
printf("in the apple command\n");
return 0;
}
-static
-cproc2(as, arock)
- char *arock;
- struct cmd_syndesc *as;
+static int
+cproc2(struct cmd_syndesc *as, void *arock)
{
register struct cmd_item *ti;
printf("in the pear command\n");
return 0;
}
-main(argc, argv)
- int argc;
- char **argv;
+int
+main(int argc, char **argv)
{
register struct cmd_syndesc *ts;
#include "cmd.h"
#include <stdio.h>
-static
-cproc(as, arock)
- char *arock;
- struct cmd_syndesc *as;
+static int
+cproc(struct cmd_syndesc *as, void *arock)
{
register struct cmd_item *ti;
printf("in the pear command\n");
return 0;
}
-main(argc, argv)
- int argc;
- char **argv;
+int
+main(int argc, char **argv)
{
register struct cmd_syndesc *ts;
#include <stdio.h>
#include <com_err.h>
-static
-cproc1(as, arock)
- char *arock;
- struct cmd_syndesc *as;
+static int
+cproc1(struct cmd_syndesc *as, void *arock)
{
printf("in the apple command\n");
return 0;
}
-static
-cproc2(as, arock)
- char *arock;
- struct cmd_syndesc *as;
+static int
+cproc2(struct cmd_syndesc *as, void *arock)
{
register struct cmd_item *ti;
printf("in the pear command\n");
return 0;
}
-static void
-cproc3(as, arock)
- char *arock;
- struct cmd_syndesc *as;
+static int
+cproc3(struct cmd_syndesc *as, void *arock)
{
exit(0);
}
-main(argc, argv)
- int argc;
- char **argv;
+int
+main(int argc, char **argv)
{
register struct cmd_syndesc *ts;
char tline[1000];
*------------------------------------------------------------------------*/
static int
-object_testInit(as, arock)
- struct cmd_syndesc *as;
- char *arock;
-
+object_testInit(struct cmd_syndesc *as, void *arock)
{ /*object_testInit */
static char rn[] = "object_testInit"; /*Routine name */
/*
* Set up the commands we understand.
*/
- ts = cmd_CreateSyntax("initcmd", object_testInit, 0,
+ ts = cmd_CreateSyntax("initcmd", object_testInit, NULL,
"Initialize the program");
cmd_AddParm(ts, "-package", CMD_SINGLE, CMD_REQUIRED,
"Graphics package to use");
*--------------------------------------------------------------------------------*/
static int
-screen_testInit(as, arock)
- struct cmd_syndesc *as;
- char *arock;
-
+screen_testInit(struct cmd_syndesc *as, void *arock)
{ /*screen_testInit */
static char rn[] = "screen_testInit"; /*Routine name */
* There really aren't any opcodes here, but we do want to interpret switches
* from the command line. So, all we need do is set up the initcmd ``opcode''.
*/
- ts = cmd_CreateSyntax("initcmd", screen_testInit, 0,
+ ts = cmd_CreateSyntax("initcmd", screen_testInit, NULL,
"Initialize, interpret command line");
cmd_AddParm(ts, "-package", CMD_SINGLE, CMD_REQUIRED,
"Graphics package to use");
}
int
-ListUsers(struct cmd_syndesc *as, char *arock)
+ListUsers(struct cmd_syndesc *as, void *arock)
{
struct kaident name;
afs_int32 index;
int
-ExamineUser(struct cmd_syndesc *as, char *arock)
+ExamineUser(struct cmd_syndesc *as, void *arock)
{
int showkey = (as->parms[1].items != NULL);
return DumpUser(as->parms[0].items->data, arock, 0, showkey, NULL);
}
int
-CreateUser(struct cmd_syndesc *as, char *arock)
+CreateUser(struct cmd_syndesc *as, void *arock)
{
int code;
char name[MAXKTCNAMELEN];
}
int
-DeleteUser(struct cmd_syndesc *as, char *arock)
+DeleteUser(struct cmd_syndesc *as, void *arock)
{
int code;
char name[MAXKTCNAMELEN];
}
int
-Unlock(struct cmd_syndesc *as, char *arock)
+Unlock(struct cmd_syndesc *as, void *arock)
{
afs_int32 code, rcode = 0;
afs_int32 count;
}
int
-SetFields(struct cmd_syndesc *as, char *arock)
+SetFields(struct cmd_syndesc *as, void *arock)
{
int code;
char name[MAXKTCNAMELEN];
}
int
-StringToKey(struct cmd_syndesc *as, char *arock)
+StringToKey(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
char realm[MAXKTCREALMLEN];
}
int
-SetPassword(struct cmd_syndesc *as, char *arock)
+SetPassword(struct cmd_syndesc *as, void *arock)
{
int code;
char name[MAXKTCNAMELEN];
}
static
-GetTicket(struct cmd_syndesc *as, char *arock)
+GetTicket(struct cmd_syndesc *as, void *arock)
{
int code;
struct ktc_principal server;
}
static
-GetPassword(struct cmd_syndesc *as, char *arock)
+GetPassword(struct cmd_syndesc *as, void *arock)
{
int code;
char name[MAXKTCNAMELEN];
}
int
-GetRandomKey(struct cmd_syndesc *as, char *arock)
+GetRandomKey(struct cmd_syndesc *as, void *arock)
{
int code;
struct ktc_encryptionKey key;
}
int
-Statistics(struct cmd_syndesc *as, char *arock)
+Statistics(struct cmd_syndesc *as, void *arock)
{
int code;
kasstats statics;
}
int
-DebugInfo(struct cmd_syndesc *as, char *arock)
+DebugInfo(struct cmd_syndesc *as, void *arock)
{
int code;
struct ka_debugInfo info;
}
int
-Interactive(struct cmd_syndesc *as, char *arock)
+Interactive(struct cmd_syndesc *as, void *arock)
{
finished = 0;
return 0;
}
int
-Quit(struct cmd_syndesc *as, char *arock)
+Quit(struct cmd_syndesc *as, void *arock)
{
finished = 1;
return 0;
}
int
-MyAfterProc(struct cmd_syndesc *as)
+MyAfterProc(struct cmd_syndesc *as, void *arock)
{
if (!strcmp(as->name, "help"))
return 0;
afs_int32 serverList[MAXSERVERS];
int
-NoAuth(struct cmd_syndesc *as, char *arock)
+NoAuth(struct cmd_syndesc *as, void *arock)
{
noauth = 1;
return 0;
}
static int
-MyBeforeProc(struct cmd_syndesc *as, char *arock)
+MyBeforeProc(struct cmd_syndesc *as, void *arock)
{
extern struct passwd *getpwuid();
struct ktc_encryptionKey key;
/* These are some helpful command that deal with the cache managers tokens. */
static
-ForgetTicket(struct cmd_syndesc *as, char *arock)
+ForgetTicket(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
}
static
-ListTickets(struct cmd_syndesc *as, char *arock)
+ListTickets(struct cmd_syndesc *as, void *arock)
{
afs_int32 code = 0;
int index, newIndex;
cmd_SetBeforeProc(MyBeforeProc, NULL);
cmd_SetAfterProc(MyAfterProc, NULL);
- ts = cmd_CreateSyntax("interactive", Interactive, 0,
+ ts = cmd_CreateSyntax("interactive", Interactive, NULL,
"enter interactive mode");
add_std_args(ts);
- ts = cmd_CreateSyntax("noauthentication", NoAuth, 0,
+ ts = cmd_CreateSyntax("noauthentication", NoAuth, NULL,
"connect to AuthServer w/o using token");
- ts = cmd_CreateSyntax("list", ListUsers, 0, "list all users in database");
+ ts = cmd_CreateSyntax("list", ListUsers, NULL,
+ "list all users in database");
cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL,
"show detailed info about each user");
cmd_AddParm(ts, "-showadmin", CMD_FLAG, CMD_OPTIONAL,
add_std_args(ts);
cmd_CreateAlias(ts, "ls");
- ts = cmd_CreateSyntax("examine", ExamineUser, 0,
+ ts = cmd_CreateSyntax("examine", ExamineUser, NULL,
"examine the entry for a user");
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "name of user");
cmd_AddParm(ts, "-showkey", CMD_FLAG, CMD_OPTIONAL,
"show the user's actual key rather than the checksum");
add_std_args(ts);
- ts = cmd_CreateSyntax("create", CreateUser, 0,
+ ts = cmd_CreateSyntax("create", CreateUser, NULL,
"create an entry for a user");
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "name of user");
cmd_AddParm(ts, "-initial_password", CMD_SINGLE, CMD_OPTIONAL,
"initial password");
add_std_args(ts);
- ts = cmd_CreateSyntax("delete", DeleteUser, 0, "delete a user");
+ ts = cmd_CreateSyntax("delete", DeleteUser, NULL, "delete a user");
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "name of user");
add_std_args(ts);
cmd_CreateAlias(ts, "rm");
- ts = cmd_CreateSyntax("setfields", SetFields, 0,
+ ts = cmd_CreateSyntax("setfields", SetFields, NULL,
"set various fields in a user's entry");
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "name of user");
cmd_AddParm(ts, "-flags", CMD_SINGLE, CMD_OPTIONAL,
cmd_CreateAlias(ts, "sf");
- ts = cmd_CreateSyntax("unlock", Unlock, 0,
+ ts = cmd_CreateSyntax("unlock", Unlock, NULL,
"Enable authentication ID after max failed attempts exceeded");
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "authentication ID");
add_std_args(ts);
- ts = cmd_CreateSyntax("stringtokey", StringToKey, 0,
+ ts = cmd_CreateSyntax("stringtokey", StringToKey, NULL,
"convert a string to a key");
cmd_AddParm(ts, "-string", CMD_SINGLE, 0, "password string");
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
- ts = cmd_CreateSyntax("setpassword", SetPassword, 0,
+ ts = cmd_CreateSyntax("setpassword", SetPassword, NULL,
"set a user's password");
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "name of user");
cmd_AddParm(ts, "-new_password", CMD_SINGLE, CMD_OPTIONAL,
#endif
/* set a user's key */
- ts = cmd_CreateSyntax("setkey", SetPassword, 0, (char *)CMD_HIDDEN);
+ ts = cmd_CreateSyntax("setkey", SetPassword, NULL, (char *)CMD_HIDDEN);
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "name of user");
cmd_Seek(ts, 2);
cmd_AddParm(ts, "-new_key", CMD_SINGLE, 0, "eight byte new key");
add_std_args(ts);
/* get a user's password */
- ts = cmd_CreateSyntax("getpassword", GetPassword, 0, (char *)CMD_HIDDEN);
+ ts = cmd_CreateSyntax("getpassword", GetPassword, NULL, (char *)CMD_HIDDEN);
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "name of user");
/* don't take standard args */
/* add_std_args (ts); */
#endif
/* get a random key */
- ts = cmd_CreateSyntax("getrandomkey", GetRandomKey, 0,
+ ts = cmd_CreateSyntax("getrandomkey", GetRandomKey, NULL,
(char *)CMD_HIDDEN);
add_std_args(ts);
/* get a ticket for a specific server */
- ts = cmd_CreateSyntax("getticket", GetTicket, 0, (char *)CMD_HIDDEN);
+ ts = cmd_CreateSyntax("getticket", GetTicket, NULL, (char *)CMD_HIDDEN);
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "name of server");
cmd_AddParm(ts, "-lifetime", CMD_SINGLE, CMD_OPTIONAL, "ticket lifetime");
add_std_args(ts);
- ts = cmd_CreateSyntax("statistics", Statistics, 0,
+ ts = cmd_CreateSyntax("statistics", Statistics, NULL,
"show statistics for AuthServer");
add_std_args(ts);
/* show debugging info from AuthServer */
- ts = cmd_CreateSyntax("debuginfo", DebugInfo, 0, (char *)CMD_HIDDEN);
+ ts = cmd_CreateSyntax("debuginfo", DebugInfo, NULL, (char *)CMD_HIDDEN);
cmd_AddParm(ts, "-hostname", CMD_SINGLE, CMD_OPTIONAL,
"authentication server host name");
add_std_args(ts);
- ts = cmd_CreateSyntax("forgetticket", ForgetTicket, 0,
+ ts = cmd_CreateSyntax("forgetticket", ForgetTicket, NULL,
"delete user's tickets");
#ifdef notdef
cmd_AddParm(ts, "-name", CMD_SINGLE, (CMD_OPTIONAL | CMD_HIDE),
#endif
cmd_AddParm(ts, "-all", CMD_FLAG, CMD_OPTIONAL, "delete all tickets");
- ts = cmd_CreateSyntax("listtickets", ListTickets, 0,
+ ts = cmd_CreateSyntax("listtickets", ListTickets, NULL,
"show all cache manager tickets");
cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_OPTIONAL, "name of server");
cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL,
"show session key and ticket");
- ts = cmd_CreateSyntax("quit", Quit, 0, "exit program");
+ ts = cmd_CreateSyntax("quit", Quit, NULL, "exit program");
finished = 1;
conn = 0; /* no connection yet */
char *dbmfile;
-static
-cmdproc(register struct cmd_syndesc *as, afs_int32 arock)
+static int
+cmdproc(register struct cmd_syndesc *as, void * arock)
{
DBM *kdb;
datum key, data;
}
}
dbm_close(kdb);
+ return 0;
}
sprintf(dbmfile_help, "dbmfile to use (default %s)",
AFSDIR_SERVER_KALOGDB_FILEPATH);
dbmfile = AFSDIR_SERVER_KALOGDB_FILEPATH;
- ts = cmd_CreateSyntax(NULL, cmdproc, 0, "Dump contents of dbm database");
+ ts = cmd_CreateSyntax(NULL, cmdproc, NULL, "Dump contents of dbm database");
cmd_AddParm(ts, "-dbmfile", CMD_SINGLE, CMD_OPTIONAL, dbmfile_help);
cmd_AddParm(ts, "-key", CMD_SINGLE, CMD_OPTIONAL,
"extract entries that match specified key");
#define KLOGEXIT(code) assert(!code || code >= KAMINERROR); \
rx_Finalize(); \
(!code ? exit(0) : exit((code)-KAMINERROR+1))
-extern int CommandProc(struct cmd_syndesc *as, char *arock);
+int CommandProc(struct cmd_syndesc *as, void *arock);
static int zero_argc;
static char **zero_argv;
zero_argc = argc;
zero_argv = argv;
- ts = cmd_CreateSyntax(NULL, CommandProc, 0,
+ ts = cmd_CreateSyntax(NULL, CommandProc, NULL,
"obtain Kerberos authentication");
#define aXFLAG 0
}
int
-CommandProc(struct cmd_syndesc *as, char *arock)
+CommandProc(struct cmd_syndesc *as, void *arock)
{
char name[MAXKTCNAMELEN];
char instance[MAXKTCNAMELEN];
#include <afs/auth.h>
#include <afs/afsutil.h>
-
-extern struct cmd_syndesc *cmd_CreateSyntax();
-
/*
Modifications:
return code;
}
-static
-cmdproc(as, arock)
- register struct cmd_syndesc *as;
- afs_int32 arock;
+static int
+cmdproc(register struct cmd_syndesc *as, void *arock)
{
register struct hostent *the;
char *tp, *sysname = 0;
sigaction(SIGSEGV, &nsa, NULL);
#endif
- ts = cmd_CreateSyntax(NULL, cmdproc, 0, "copy tickets for NFS");
+ ts = cmd_CreateSyntax(NULL, cmdproc, NULL, "copy tickets for NFS");
cmd_AddParm(ts, "-host", CMD_SINGLE, CMD_REQUIRED, "host name");
cmd_AddParm(ts, "-id", CMD_SINGLE, CMD_OPTIONAL, "user ID (decimal)");
cmd_AddParm(ts, "-sysname", CMD_SINGLE, CMD_OPTIONAL,
/* The following code to make use of libcmd.a also stolen from klog.c. */
-int CommandProc();
+int CommandProc(struct cmd_syndesc *, void *);
static int zero_argc;
static char **zero_argv;
#endif
char passwd[BUFSIZ], npasswd[BUFSIZ], verify[BUFSIZ];
-CommandProc(as, arock)
- char *arock;
- struct cmd_syndesc *as;
+CommandProc(struct cmd_syndesc *as, void *arock)
{
char name[MAXKTCNAMELEN] = "";
char instance[MAXKTCNAMELEN] = "";
#define KLOGEXIT(code) assert(!code || code >= KAMINERROR); \
rx_Finalize(); \
(!code ? exit(0) : exit((code)-KAMINERROR+1))
-int CommandProc();
+static int CommandProc(struct cmd_syndesc *, void *);
static int zero_argc;
static char **zero_argv;
zero_argc = argc;
zero_argv = argv;
- ts = cmd_CreateSyntax(NULL, CommandProc, 0,
+ ts = cmd_CreateSyntax(NULL, CommandProc, NULL,
"obtain Kerberos authentication");
#define aXFLAG 0
return gpbuf;
}
-CommandProc(as, arock)
- char *arock;
- struct cmd_syndesc *as;
+static int
+CommandProc(struct cmd_syndesc *as, void *arock)
{
char name[MAXKTCNAMELEN];
char instance[MAXKTCNAMELEN];
#include "AFS_component_version_number.c"
-WorkerBee(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+static int
+WorkerBee(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
char *dbFile;
-repeat is the number of times to iterate over the authentication
*/
-int CommandProc();
+static int CommandProc(struct cmd_syndesc *, void *);
static int zero_argc;
static char **zero_argv;
zero_argc = argc;
zero_argv = argv;
- ts = cmd_CreateSyntax(NULL, CommandProc, 0,
+ ts = cmd_CreateSyntax(NULL, CommandProc, NULL,
"obtain Kerberos authentication");
#define aXFLAG 0
return gpbuf;
}
-CommandProc(as, arock)
- char *arock;
- struct cmd_syndesc *as;
+static int
+CommandProc(struct cmd_syndesc *as, void *arock)
{
char name[MAXKTCNAMELEN];
char instance[MAXKTCNAMELEN];
CheckLife(t.endTime, t.startTime, expectedLife, match);
}
-static long
-Main(as, arock)
- IN struct cmd_syndesc *as;
- IN char *arock;
+static int
+Main(struct cmd_syndesc *as, void *arock)
{
- long code;
+ int code;
char name[MAXKTCNAMELEN];
char instance[MAXKTCNAMELEN];
char newCell[MAXKTCREALMLEN];
initialize_ACFG_error_table();
initialize_KA_error_table();
- ts = cmd_CreateSyntax(0, Main, 0, "Main program");
+ ts = cmd_CreateSyntax(NULL, Main, NULL, "Main program");
/* 0 */ cmd_AddParm(ts, "-patient", CMD_FLAG, CMD_OPTIONAL,
"wait for TGS ticket to age");
cmd_Seek(ts, 12);
rxkad_stats.destroyUnauth);
}
-static long
-Main(as, arock)
- IN struct cmd_syndesc *as;
- IN char *arock;
+static int
+Main(struct cmd_syndesc *as, void *arock)
{
- long code;
+ int code;
char name[MAXKTCNAMELEN];
char instance[MAXKTCNAMELEN];
char newCell[MAXKTCREALMLEN];
initialize_ACFG_error_table();
initialize_KA_error_table();
- ts = cmd_CreateSyntax(0, Main, 0, "Main program");
+ ts = cmd_CreateSyntax(NULL, Main, NULL, "Main program");
/* 0 */ cmd_AddParm(ts, "-number", CMD_SINGLE, CMD_OPTIONAL,
"number of iterations");
/* 1 */ cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL,
static int
-DoCellServDbAddHost(struct cmd_syndesc *as, char *arock)
+DoCellServDbAddHost(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
int maxUpdates;
static int
-DoCellServDbRemoveHost(struct cmd_syndesc *as, char *arock)
+DoCellServDbRemoveHost(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
int maxUpdates;
static int
-DoCellServDbEnumerate(struct cmd_syndesc *as, char *arock)
+DoCellServDbEnumerate(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
char *fsDbHost = as->parms[0].items->data;
{
struct cmd_syndesc *ts;
- ts = cmd_CreateSyntax("CellServDbAddHost", DoCellServDbAddHost, 0,
+ ts = cmd_CreateSyntax("CellServDbAddHost", DoCellServDbAddHost, NULL,
"add configuration target to server CellServDB");
cmd_AddParm(ts, "-cfghost", CMD_SINGLE, CMD_REQUIRED,
"configuration host");
cmd_AddParm(ts, "-syshost", CMD_SINGLE, CMD_OPTIONAL,
"system control host");
- ts = cmd_CreateSyntax("CellServDbRemoveHost", DoCellServDbRemoveHost, 0,
+ ts = cmd_CreateSyntax("CellServDbRemoveHost", DoCellServDbRemoveHost, NULL,
"remove configuration target from server CellServDB");
cmd_AddParm(ts, "-cfghost", CMD_SINGLE, CMD_REQUIRED,
"configuration host");
cmd_AddParm(ts, "-syshost", CMD_SINGLE, CMD_OPTIONAL,
"system control host");
- ts = cmd_CreateSyntax("CellServDbEnumerate", DoCellServDbEnumerate, 0,
+ ts = cmd_CreateSyntax("CellServDbEnumerate", DoCellServDbEnumerate, NULL,
"enumerate server CellServDB from specified host");
cmd_AddParm(ts, "-host", CMD_SINGLE, CMD_REQUIRED, "host name");
static int
-DoDbServersWaitForQuorum(struct cmd_syndesc *as, char *arock)
+DoDbServersWaitForQuorum(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
void *hostHandle;
static int
-DoFileServerStop(struct cmd_syndesc *as, char *arock)
+DoFileServerStop(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
void *hostHandle;
}
static int
-DoFileServerStart(struct cmd_syndesc *as, char *arock)
+DoFileServerStart(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
void *hostHandle;
struct cmd_syndesc *ts;
ts = cmd_CreateSyntax("DbServersWaitForQuorum", DoDbServersWaitForQuorum,
- 0, "wait for database servers to achieve quorum");
+ NULL, "wait for database servers to achieve quorum");
cmd_AddParm(ts, "-cfghost", CMD_SINGLE, CMD_REQUIRED,
"configuration host");
cmd_AddParm(ts, "-timeout", CMD_SINGLE, CMD_OPTIONAL,
"timeout in seconds");
- ts = cmd_CreateSyntax("FileServerStop", DoFileServerStop, 0,
+ ts = cmd_CreateSyntax("FileServerStop", DoFileServerStop, NULL,
"stop and unconfigure fileserver on specified host");
cmd_AddParm(ts, "-cfghost", CMD_SINGLE, CMD_REQUIRED,
"configuration host");
- ts = cmd_CreateSyntax("FileServerStart", DoFileServerStart, 0,
+ ts = cmd_CreateSyntax("FileServerStart", DoFileServerStart, NULL,
"start the fileserver on specified host");
cmd_AddParm(ts, "-cfghost", CMD_SINGLE, CMD_REQUIRED,
"configuration host");
static int
-DoHostPartitionTableEnumerate(struct cmd_syndesc *as, char *arock)
+DoHostPartitionTableEnumerate(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
cfg_partitionEntry_t *vptable;
struct cmd_syndesc *ts;
ts = cmd_CreateSyntax("HostPartitionTableEnumerate",
- DoHostPartitionTableEnumerate, 0,
+ DoHostPartitionTableEnumerate, NULL,
"enumerate vice partition table");
cmd_AddParm(ts, "-cfghost", CMD_SINGLE, CMD_REQUIRED,
"configuration host");
static int
-DoClientCellServDbAdd(struct cmd_syndesc *as, char *arock)
+DoClientCellServDbAdd(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
void *hostHandle;
static int
-DoClientCellServDbRemove(struct cmd_syndesc *as, char *arock)
+DoClientCellServDbRemove(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
void *hostHandle;
static int
-DoClientStart(struct cmd_syndesc *as, char *arock)
+DoClientStart(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
void *hostHandle;
static int
-DoClientStop(struct cmd_syndesc *as, char *arock)
+DoClientStop(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
void *hostHandle;
static int
-DoClientSetCell(struct cmd_syndesc *as, char *arock)
+DoClientSetCell(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
void *hostHandle;
static int
-DoClientQueryStatus(struct cmd_syndesc *as, char *arock)
+DoClientQueryStatus(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
char *cfgHost = as->parms[0].items->data;
static int
-DoHostQueryStatus(struct cmd_syndesc *as, char *arock)
+DoHostQueryStatus(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
char *cfgHost = as->parms[0].items->data;
{
struct cmd_syndesc *ts;
- ts = cmd_CreateSyntax("ClientCellServDbAdd", DoClientCellServDbAdd, 0,
+ ts = cmd_CreateSyntax("ClientCellServDbAdd", DoClientCellServDbAdd, NULL,
"add host entry to client CellServDB");
cmd_AddParm(ts, "-cfghost", CMD_SINGLE, CMD_REQUIRED,
"configuration host");
cmd_AddParm(ts, "-dbhost", CMD_SINGLE, CMD_REQUIRED, "host to add");
ts = cmd_CreateSyntax("ClientCellServDbRemove", DoClientCellServDbRemove,
- 0, "remove host entry from client CellServDB");
+ NULL, "remove host entry from client CellServDB");
cmd_AddParm(ts, "-cfghost", CMD_SINGLE, CMD_REQUIRED,
"configuration host");
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_REQUIRED, "cell name");
cmd_AddParm(ts, "-dbhost", CMD_SINGLE, CMD_REQUIRED, "host to remove");
- ts = cmd_CreateSyntax("ClientSetCell", DoClientSetCell, 0,
+ ts = cmd_CreateSyntax("ClientSetCell", DoClientSetCell, NULL,
"set default client cell");
cmd_AddParm(ts, "-cfghost", CMD_SINGLE, CMD_REQUIRED,
"configuration host");
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_REQUIRED, "cell name");
cmd_AddParm(ts, "-dbhosts", CMD_LIST, CMD_REQUIRED, "database hosts");
- ts = cmd_CreateSyntax("ClientQueryStatus", DoClientQueryStatus, 0,
+ ts = cmd_CreateSyntax("ClientQueryStatus", DoClientQueryStatus, NULL,
"query status of client on host");
cmd_AddParm(ts, "-cfghost", CMD_SINGLE, CMD_REQUIRED,
"configuration host");
- ts = cmd_CreateSyntax("HostQueryStatus", DoHostQueryStatus, 0,
+ ts = cmd_CreateSyntax("HostQueryStatus", DoHostQueryStatus, NULL,
"query status of server on host");
cmd_AddParm(ts, "-cfghost", CMD_SINGLE, CMD_REQUIRED,
"configuration host");
- ts = cmd_CreateSyntax("ClientStart", DoClientStart, 0,
+ ts = cmd_CreateSyntax("ClientStart", DoClientStart, NULL,
"start the client");
cmd_AddParm(ts, "-cfghost", CMD_SINGLE, CMD_REQUIRED,
"configuration host");
cmd_AddParm(ts, "-timeout", CMD_SINGLE, CMD_REQUIRED, "wait timeout");
- ts = cmd_CreateSyntax("ClientStop", DoClientStop, 0, "stop the client");
+ ts = cmd_CreateSyntax("ClientStop", DoClientStop, NULL, "stop the client");
cmd_AddParm(ts, "-cfghost", CMD_SINGLE, CMD_REQUIRED,
"configuration host");
cmd_AddParm(ts, "-timeout", CMD_SINGLE, CMD_REQUIRED, "wait timeout");
*/
static int
-MyBeforeProc(struct cmd_syndesc *as, char *arock)
+MyBeforeProc(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
int no_auth = 0;
}
static int
-MyAfterProc(struct cmd_syndesc *as)
+MyAfterProc(struct cmd_syndesc *as,void *arock)
{
afsclient_CellClose(cellHandle, (afs_status_p) 0);
}
int
-DoBosProcessCreate(struct cmd_syndesc *as, char *arock)
+DoBosProcessCreate(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS, BINARY, CRON, CRONTIME,
NOTIFIER
}
int
-DoBosFSProcessCreate(struct cmd_syndesc *as, char *arock)
+DoBosFSProcessCreate(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS, FILESERVER, VOLSERVER, SALVAGER,
NOTIFIER
}
int
-DoBosProcessDelete(struct cmd_syndesc *as, char *arock)
+DoBosProcessDelete(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS } DoBosProcessDelete_parm_t;
afs_status_t st = 0;
}
int
-DoBosProcessExecutionStateGet(struct cmd_syndesc *as, char *arock)
+DoBosProcessExecutionStateGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS } DoBosProcessExecutionStateGet_parm_t;
afs_status_t st = 0;
}
int
-DoBosProcessExecutionStateSet(struct cmd_syndesc *as, char *arock)
+DoBosProcessExecutionStateSet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS, STOPPED,
RUNNING
}
int
-DoBosProcessExecutionStateSetTemporary(struct cmd_syndesc *as, char *arock)
+DoBosProcessExecutionStateSetTemporary(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS, STOPPED,
RUNNING
}
int
-DoBosProcessNameList(struct cmd_syndesc *as, char *arock)
+DoBosProcessNameList(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER } DoBosProcessNameList_parm_t;
afs_status_t st = 0;
}
int
-DoBosProcessInfoGet(struct cmd_syndesc *as, char *arock)
+DoBosProcessInfoGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS } DoBosProcessInfoGet_parm_t;
afs_status_t st = 0;
}
int
-DoBosProcessParameterList(struct cmd_syndesc *as, char *arock)
+DoBosProcessParameterList(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS } DoBosProcessParameterList_parm_t;
afs_status_t st = 0;
}
int
-DoBosProcessNotifierGet(struct cmd_syndesc *as, char *arock)
+DoBosProcessNotifierGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS } DoBosProcessNotifierGet_parm_t;
afs_status_t st = 0;
}
int
-DoBosProcessRestart(struct cmd_syndesc *as, char *arock)
+DoBosProcessRestart(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS } DoBosProcessRestart_parm_t;
afs_status_t st = 0;
}
int
-DoBosProcessAllStop(struct cmd_syndesc *as, char *arock)
+DoBosProcessAllStop(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER } DoBosProcessAllStop_parm_t;
afs_status_t st = 0;
}
int
-DoBosProcessAllStart(struct cmd_syndesc *as, char *arock)
+DoBosProcessAllStart(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER } DoBosProcessAllStart_parm_t;
afs_status_t st = 0;
}
int
-DoBosProcessAllWaitStop(struct cmd_syndesc *as, char *arock)
+DoBosProcessAllWaitStop(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER } DoBosProcessAllWaitStop_parm_t;
afs_status_t st = 0;
}
int
-DoBosProcessAllWaitTransition(struct cmd_syndesc *as, char *arock)
+DoBosProcessAllWaitTransition(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER } DoBosProcessAllWaitTransition_parm_t;
afs_status_t st = 0;
}
int
-DoBosProcessAllStopAndRestart(struct cmd_syndesc *as, char *arock)
+DoBosProcessAllStopAndRestart(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, INCLUDEBOS } DoBosProcessAllStopAndRestart_parm_t;
afs_status_t st = 0;
}
int
-DoBosAdminCreate(struct cmd_syndesc *as, char *arock)
+DoBosAdminCreate(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, ADMIN } DoBosAdminCreate_parm_t;
afs_status_t st = 0;
}
int
-DoBosAdminDelete(struct cmd_syndesc *as, char *arock)
+DoBosAdminDelete(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, ADMIN } DoBosAdminDelete_parm_t;
afs_status_t st = 0;
}
int
-DoBosAdminList(struct cmd_syndesc *as, char *arock)
+DoBosAdminList(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER } DoBosAdminList_parm_t;
afs_status_t st = 0;
}
int
-DoBosKeyCreate(struct cmd_syndesc *as, char *arock)
+DoBosKeyCreate(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, VERSIONNUMBER, KEY } DoBosKeyCreate_parm_t;
afs_status_t st = 0;
}
int
-DoBosKeyDelete(struct cmd_syndesc *as, char *arock)
+DoBosKeyDelete(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, VERSIONNUMBER } DoBosKeyDelete_parm_t;
afs_status_t st = 0;
}
int
-DoBosKeyList(struct cmd_syndesc *as, char *arock)
+DoBosKeyList(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER } DoBosKeyList_parm_t;
afs_status_t st = 0;
}
int
-DoBosCellSet(struct cmd_syndesc *as, char *arock)
+DoBosCellSet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, CELL } DoBosCellSet_parm_t;
afs_status_t st = 0;
}
int
-DoBosCellGet(struct cmd_syndesc *as, char *arock)
+DoBosCellGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER } DoBosCellGet_parm_t;
afs_status_t st = 0;
}
int
-DoBosHostCreate(struct cmd_syndesc *as, char *arock)
+DoBosHostCreate(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, HOST } DoBosHostCreate_parm_t;
afs_status_t st = 0;
}
int
-DoBosHostDelete(struct cmd_syndesc *as, char *arock)
+DoBosHostDelete(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, HOST } DoBosHostDelete_parm_t;
afs_status_t st = 0;
}
int
-DoBosHostList(struct cmd_syndesc *as, char *arock)
+DoBosHostList(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER } DoBosHostList_parm_t;
afs_status_t st = 0;
}
int
-DoBosExecutableCreate(struct cmd_syndesc *as, char *arock)
+DoBosExecutableCreate(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, BINARY, DEST } DoBosExecutableCreate_parm_t;
afs_status_t st = 0;
}
int
-DoBosExecutableRevert(struct cmd_syndesc *as, char *arock)
+DoBosExecutableRevert(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, EXECUTABLE } DoBosExecutableRevert_parm_t;
afs_status_t st = 0;
}
int
-DoBosExecutableTimestampGet(struct cmd_syndesc *as, char *arock)
+DoBosExecutableTimestampGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, EXECUTABLE } DoBosExecutableTimestampGet_parm_t;
afs_status_t st = 0;
}
int
-DoBosExecutablePrune(struct cmd_syndesc *as, char *arock)
+DoBosExecutablePrune(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, OLDFILES, BAKFILES,
COREFILES
}
int
-DoBosExecutableRestartTimeSet(struct cmd_syndesc *as, char *arock)
+DoBosExecutableRestartTimeSet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, DAILY, WEEKLY,
TIME
}
int
-DoBosExecutableRestartTimeGet(struct cmd_syndesc *as, char *arock)
+DoBosExecutableRestartTimeGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, DAILY,
WEEKLY
#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;
afs_status_t st = 0;
}
int
-DoBosAuthSet(struct cmd_syndesc *as, char *arock)
+DoBosAuthSet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, REQUIREAUTH, DISABLEAUTH } DoBosAuthSet_parm_t;
afs_status_t st = 0;
}
int
-DoBosCommandExecute(struct cmd_syndesc *as, char *arock)
+DoBosCommandExecute(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, COMMAND } DoBosCommandExecute_parm_t;
afs_status_t st = 0;
}
int
-DoBosSalvage(struct cmd_syndesc *as, char *arock)
+DoBosSalvage(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION, VOLUME, NUMSALVAGERS, TMPDIR, LOGFILE,
FORCE, NOWRITE, INODES, ROOTINODES, SALVAGEDIRS, BLOCKREADS
{
struct cmd_syndesc *ts;
- ts = cmd_CreateSyntax("BosProcessCreate", DoBosProcessCreate, 0,
+ ts = cmd_CreateSyntax("BosProcessCreate", DoBosProcessCreate, NULL,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"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,
"command to execute");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("BosSalvage", DoBosSalvage, 0,
+ ts = cmd_CreateSyntax("BosSalvage", DoBosSalvage, NULL,
"execute a salvage command at a bos server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where salvager will execute");
*/
int
-DoClientLocalCellGet(struct cmd_syndesc *as, char *arock)
+DoClientLocalCellGet(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
char cellName[MAXCELLCHARS];
}
int
-DoClientMountPointCreate(struct cmd_syndesc *as, char *arock)
+DoClientMountPointCreate(struct cmd_syndesc *as, void *arock)
{
typedef enum { DIRECTORY, VOLUME, READWRITE,
CHECK
}
int
-DoClientAFSServerGet(struct cmd_syndesc *as, char *arock)
+DoClientAFSServerGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER } DoClientAFSServerGet_parm_t;
afs_status_t st = 0;
}
int
-DoClientAFSServerList(struct cmd_syndesc *as, char *arock)
+DoClientAFSServerList(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
afs_serverEntry_t entry;
}
int
-DoClientRPCStatsStateGet(struct cmd_syndesc *as, char *arock)
+DoClientRPCStatsStateGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS,
STAT_TYPE
}
int
-DoClientRPCStatsStateEnable(struct cmd_syndesc *as, char *arock)
+DoClientRPCStatsStateEnable(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS, STAT_TYPE } DoClientRPCStatsEnable_parm_t;
afs_status_t st = 0;
}
int
-DoClientRPCStatsStateDisable(struct cmd_syndesc *as, char *arock)
+DoClientRPCStatsStateDisable(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS,
STAT_TYPE
}
int
-DoClientRPCStatsList(struct cmd_syndesc *as, char *arock)
+DoClientRPCStatsList(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS, STAT_TYPE } DoClientRPCStatsList_parm_t;
afs_status_t st = 0;
}
int
-DoClientRPCStatsClear(struct cmd_syndesc *as, char *arock)
+DoClientRPCStatsClear(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS, STAT_TYPE, CLEAR_ALL, CLEAR_INVOCATIONS,
CLEAR_BYTES_SENT, CLEAR_BYTES_RCVD,
}
int
-DoClientRPCStatsVersionGet(struct cmd_syndesc *as, char *arock)
+DoClientRPCStatsVersionGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PROCESS } DoClientRPCStatsVersionGet_parm_t;
afs_status_t st = 0;
}
int
-DoClientCMGetServerPrefs(struct cmd_syndesc *as, char *arock)
+DoClientCMGetServerPrefs(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
typedef enum { SERVER, PORT } DoClientCMGetServerPrefs_parm_t;
}
int
-DoClientCMListCells(struct cmd_syndesc *as, char *arock)
+DoClientCMListCells(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
typedef enum { SERVER, PORT } DoClientCMListCells_parm_t;
}
int
-DoClientCMLocalCell(struct cmd_syndesc *as, char *arock)
+DoClientCMLocalCell(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
typedef enum { SERVER, PORT } DoClientCMLocalCell_parm_t;
}
int
-DoClientCMClientConfig(struct cmd_syndesc *as, char *arock)
+DoClientCMClientConfig(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
typedef enum { SERVER, PORT } DoClientCMLocalCell_parm_t;
{
struct cmd_syndesc *ts;
- ts = cmd_CreateSyntax("ClientLocalCellGet", DoClientLocalCellGet, 0,
+ ts = cmd_CreateSyntax("ClientLocalCellGet", DoClientLocalCellGet, NULL,
"get the name of this machine's cell");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("ClientMountPointCreate", DoClientMountPointCreate,
- 0, "create a mount point");
+ NULL, "create a mount point");
cmd_AddParm(ts, "-directory", CMD_SINGLE, CMD_REQUIRED,
"directory where mount point will be created");
cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
"check that the volume exists before mounting");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("ClientAFSServerGet", DoClientAFSServerGet, 0,
+ ts = cmd_CreateSyntax("ClientAFSServerGet", DoClientAFSServerGet, NULL,
"retrieve information about an afs server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("ClientAFSServerList", DoClientAFSServerList, 0,
+ ts = cmd_CreateSyntax("ClientAFSServerList", DoClientAFSServerList, NULL,
"retrieve information about all afs "
"servers in a cell");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("ClientRPCStatsStateGet", DoClientRPCStatsStateGet,
- 0, "retrieve the rpc stat collection state");
+ NULL, "retrieve the rpc stat collection state");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where command will execute");
cmd_AddParm(ts, "-process", CMD_SINGLE, CMD_REQUIRED,
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("ClientRPCStatsStateEnable",
- DoClientRPCStatsStateEnable, 0,
+ DoClientRPCStatsStateEnable, NULL,
"set the rpc stat collection state to on");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where command will execute");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("ClientRPCStatsStateDisable",
- DoClientRPCStatsStateDisable, 0,
+ DoClientRPCStatsStateDisable, NULL,
"set the rpc stat collection state to off");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where command will execute");
"stats to retrieve <peer or process>");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("ClientRPCStatsList", DoClientRPCStatsList, 0,
+ ts = cmd_CreateSyntax("ClientRPCStatsList", DoClientRPCStatsList, NULL,
"list the rpc stats");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where command will execute");
"stats to retrieve <peer or process>");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("ClientRPCStatsClear", DoClientRPCStatsClear, 0,
+ ts = cmd_CreateSyntax("ClientRPCStatsClear", DoClientRPCStatsClear, NULL,
"reset rpc stat counters");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where command will execute");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("ClientRPCStatsVersionGet",
- DoClientRPCStatsVersionGet, 0,
+ DoClientRPCStatsVersionGet, NULL,
"list the server's rpc stats version");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where command will execute");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("ClientCMGetServerPrefs", DoClientCMGetServerPrefs,
- 0, "list a client's server preferences ");
+ NULL, "list a client's server preferences ");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where command will execute");
cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "UDP port to query");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("ClientCMListCells", DoClientCMListCells, 0,
+ ts = cmd_CreateSyntax("ClientCMListCells", DoClientCMListCells, NULL,
"list a client's CellServDB ");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where command will execute");
cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "UDP port to query");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("ClientCMLocalCell", DoClientCMLocalCell, 0,
+ ts = cmd_CreateSyntax("ClientCMLocalCell", DoClientCMLocalCell, NULL,
"get the name of the client's local cell");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where command will execute");
cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "UDP port to query");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("ClientCMClientConfig", DoClientCMClientConfig, 0,
+ ts = cmd_CreateSyntax("ClientCMClientConfig", DoClientCMClientConfig, NULL,
"get the client's cache configuration");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where command will execute");
}
int
-DoKasPrincipalCreate(struct cmd_syndesc *as, char *arock)
+DoKasPrincipalCreate(struct cmd_syndesc *as, void *arock)
{
typedef enum { PRINCIPAL, INSTANCE,
PASSWORD
}
int
-DoKasPrincipalDelete(struct cmd_syndesc *as, char *arock)
+DoKasPrincipalDelete(struct cmd_syndesc *as, void *arock)
{
typedef enum { PRINCIPAL, INSTANCE } DoKasPrincipalGet_parm_t;
afs_status_t st = 0;
}
int
-DoKasPrincipalGet(struct cmd_syndesc *as, char *arock)
+DoKasPrincipalGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { PRINCIPAL, INSTANCE } DoKasPrincipalGet_parm_t;
afs_status_t st = 0;
}
int
-DoKasPrincipalList(struct cmd_syndesc *as, char *arock)
+DoKasPrincipalList(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
void *iter;
}
int
-DoKasPrincipalKeySet(struct cmd_syndesc *as, char *arock)
+DoKasPrincipalKeySet(struct cmd_syndesc *as, void *arock)
{
typedef enum { PRINCIPAL, INSTANCE, PASSWORD,
KEYVERSION
}
int
-DoKasPrincipalLockStatusGet(struct cmd_syndesc *as, char *arock)
+DoKasPrincipalLockStatusGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { PRINCIPAL, INSTANCE } DoKasPrincipalLockStatusGet_parm_t;
afs_status_t st = 0;
}
int
-DoKasPrincipalUnlock(struct cmd_syndesc *as, char *arock)
+DoKasPrincipalUnlock(struct cmd_syndesc *as, void *arock)
{
typedef enum { PRINCIPAL, INSTANCE } DoKasPrincipalUnlock_parm_t;
afs_status_t st = 0;
}
int
-DoKasPrincipalFieldsSet(struct cmd_syndesc *as, char *arock)
+DoKasPrincipalFieldsSet(struct cmd_syndesc *as, void *arock)
{
typedef enum { PRINCIPAL, INSTANCE, ADMIN, NOADMIN, GRANTTICKET,
NOGRANTTICKET, ENCRYPT2, NOENCRYPT, CHANGEPASSWORD,
}
int
-DoKasServerStatsGet(struct cmd_syndesc *as, char *arock)
+DoKasServerStatsGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER } DoKasServerStatsGet_parm_t;
afs_status_t st = 0;
}
int
-DoKasServerDebugGet(struct cmd_syndesc *as, char *arock)
+DoKasServerDebugGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER } DoKasServerDebugGet_parm_t;
afs_status_t st = 0;
}
int
-DoKasServerRandomKeyGet(struct cmd_syndesc *as, char *arock)
+DoKasServerRandomKeyGet(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
kas_encryptionKey_t key;
{
struct cmd_syndesc *ts;
- ts = cmd_CreateSyntax("KasPrincipalCreate", DoKasPrincipalCreate, 0,
+ ts = cmd_CreateSyntax("KasPrincipalCreate", DoKasPrincipalCreate, NULL,
"create a new principal");
cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_REQUIRED,
"principal to create");
"initial principal password");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("KasPrincipalDelete", DoKasPrincipalDelete, 0,
+ ts = cmd_CreateSyntax("KasPrincipalDelete", DoKasPrincipalDelete, NULL,
"delete a principal");
cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_REQUIRED,
"principal to delete");
"principal instance");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("KasPrincipalGet", DoKasPrincipalGet, 0,
+ ts = cmd_CreateSyntax("KasPrincipalGet", DoKasPrincipalGet, NULL,
"get information about a principal");
cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_REQUIRED,
"principal to get");
"principal instance");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("KasPrincipalList", DoKasPrincipalList, 0,
+ ts = cmd_CreateSyntax("KasPrincipalList", DoKasPrincipalList, NULL,
"list all principals");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("KasPrincipalKeySet", DoKasPrincipalKeySet, 0,
+ ts = cmd_CreateSyntax("KasPrincipalKeySet", DoKasPrincipalKeySet, NULL,
"set the password for a principal");
cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_REQUIRED,
"principal to modify");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("KasPrincipalLockStatusGet",
- DoKasPrincipalLockStatusGet, 0,
+ DoKasPrincipalLockStatusGet, NULL,
"get the lock status of a principal");
cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_REQUIRED,
"principal to query");
"principal instance");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("KasPrincipalUnlock", DoKasPrincipalUnlock, 0,
+ ts = cmd_CreateSyntax("KasPrincipalUnlock", DoKasPrincipalUnlock, NULL,
"unlock a principal");
cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_REQUIRED,
"principal to unlock");
"principal instance");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("KasPrincipalFieldsSet", DoKasPrincipalFieldsSet, 0,
+ ts = cmd_CreateSyntax("KasPrincipalFieldsSet", DoKasPrincipalFieldsSet, NULL,
"modify a principal");
cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_REQUIRED,
"principal to modify");
"maximum failed password attempts is exceeded");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("KasServerStatsGet", DoKasServerStatsGet, 0,
+ ts = cmd_CreateSyntax("KasServerStatsGet", DoKasServerStatsGet, NULL,
"get stats on a kaserver");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("KasServerDebugGet", DoKasServerDebugGet, 0,
+ ts = cmd_CreateSyntax("KasServerDebugGet", DoKasServerDebugGet, NULL,
"get debug info from a kaserver");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("KasServerRandomKeyGet", DoKasServerRandomKeyGet, 0,
+ ts = cmd_CreateSyntax("KasServerRandomKeyGet", DoKasServerRandomKeyGet, NULL,
"create a random key");
SetupCommonCmdArgs(ts);
}
int
-DoPtsGroupMemberAdd(struct cmd_syndesc *as, char *arock)
+DoPtsGroupMemberAdd(struct cmd_syndesc *as, void *arock)
{
typedef enum { USER, GROUP } DoPtsGroupMemberAdd_parm_t;
afs_status_t st = 0;
}
int
-DoPtsGroupOwnerChange(struct cmd_syndesc *as, char *arock)
+DoPtsGroupOwnerChange(struct cmd_syndesc *as, void *arock)
{
typedef enum { OWNER, GROUP } DoPtsGroupOwnerChange_parm_t;
afs_status_t st = 0;
}
int
-DoPtsGroupCreate(struct cmd_syndesc *as, char *arock)
+DoPtsGroupCreate(struct cmd_syndesc *as, void *arock)
{
typedef enum { OWNER, GROUP } DoPtsGroupCreate_parm_t;
afs_status_t st = 0;
}
int
-DoPtsGroupGet(struct cmd_syndesc *as, char *arock)
+DoPtsGroupGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { GROUP } DoPtsGroupGet_parm_t;
afs_status_t st = 0;
}
int
-DoPtsGroupDelete(struct cmd_syndesc *as, char *arock)
+DoPtsGroupDelete(struct cmd_syndesc *as, void *arock)
{
typedef enum { GROUP } DoPtsGroupDelete_parm_t;
afs_status_t st = 0;
}
int
-DoPtsGroupMaxGet(struct cmd_syndesc *as, char *arock)
+DoPtsGroupMaxGet(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
int max_group_id;
}
int
-DoPtsGroupMaxSet(struct cmd_syndesc *as, char *arock)
+DoPtsGroupMaxSet(struct cmd_syndesc *as, void *arock)
{
typedef enum { MAX } DoPtsGroupMaxSet_parm_t;
afs_status_t st = 0;
}
int
-DoPtsGroupMemberList(struct cmd_syndesc *as, char *arock)
+DoPtsGroupMemberList(struct cmd_syndesc *as, void *arock)
{
typedef enum { GROUP } DoPtsGroupMemberList_parm_t;
afs_status_t st = 0;
}
int
-DoPtsGroupMemberRemove(struct cmd_syndesc *as, char *arock)
+DoPtsGroupMemberRemove(struct cmd_syndesc *as, void *arock)
{
typedef enum { USER, GROUP } DoPtsGroupMemberRemove_parm_t;
afs_status_t st = 0;
}
int
-DoPtsGroupRename(struct cmd_syndesc *as, char *arock)
+DoPtsGroupRename(struct cmd_syndesc *as, void *arock)
{
typedef enum { GROUP, NEWNAME } DoPtsGroupRename_parm_t;
afs_status_t st = 0;
}
int
-DoPtsGroupModify(struct cmd_syndesc *as, char *arock)
+DoPtsGroupModify(struct cmd_syndesc *as, void *arock)
{
typedef enum { GROUP, LISTSTATUS, LISTGROUPSOWNED, LISTMEMBERSHIP,
LISTADD, LISTDELTE
}
int
-DoPtsUserCreate(struct cmd_syndesc *as, char *arock)
+DoPtsUserCreate(struct cmd_syndesc *as, void *arock)
{
typedef enum { USER } DoPtsUserCreate_parm_t;
afs_status_t st = 0;
}
int
-DoPtsUserDelete(struct cmd_syndesc *as, char *arock)
+DoPtsUserDelete(struct cmd_syndesc *as, void *arock)
{
typedef enum { USER } DoPtsUserDelete_parm_t;
afs_status_t st = 0;
}
int
-DoPtsUserGet(struct cmd_syndesc *as, char *arock)
+DoPtsUserGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { USER } DoPtsUserGet_parm_t;
afs_status_t st = 0;
}
int
-DoPtsUserRename(struct cmd_syndesc *as, char *arock)
+DoPtsUserRename(struct cmd_syndesc *as, void *arock)
{
typedef enum { USER, NEWNAME } DoPtsUserRename_parm_t;
afs_status_t st = 0;
}
int
-DoPtsUserModify(struct cmd_syndesc *as, char *arock)
+DoPtsUserModify(struct cmd_syndesc *as, void *arock)
{
typedef enum { USER, GROUPQUOTA, LISTSTATUS, LISTGROUPSOWNED,
LISTMEMBERSHIP
}
int
-DoPtsUserMaxGet(struct cmd_syndesc *as, char *arock)
+DoPtsUserMaxGet(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
int max_user_id;
}
int
-DoPtsUserMaxSet(struct cmd_syndesc *as, char *arock)
+DoPtsUserMaxSet(struct cmd_syndesc *as, void *arock)
{
typedef enum { MAX } DoPtsUserMaxSet_parm_t;
afs_status_t st = 0;
}
int
-DoPtsUserMemberList(struct cmd_syndesc *as, char *arock)
+DoPtsUserMemberList(struct cmd_syndesc *as, void *arock)
{
typedef enum { USER } DoPtsUserMemberList_parm_t;
afs_status_t st = 0;
}
int
-DoPtsOwnedGroupList(struct cmd_syndesc *as, char *arock)
+DoPtsOwnedGroupList(struct cmd_syndesc *as, void *arock)
{
typedef enum { USER } DoPtsOwnedGroupList_parm_t;
afs_status_t st = 0;
{
struct cmd_syndesc *ts;
- ts = cmd_CreateSyntax("PtsGroupMemberAdd", DoPtsGroupMemberAdd, 0,
+ ts = cmd_CreateSyntax("PtsGroupMemberAdd", DoPtsGroupMemberAdd, NULL,
"add a user to a group");
cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to add");
cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to modify");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsGroupOwnerChange", DoPtsGroupOwnerChange, 0,
+ ts = cmd_CreateSyntax("PtsGroupOwnerChange", DoPtsGroupOwnerChange, NULL,
"change the owner of a group");
cmd_AddParm(ts, "-owner", CMD_SINGLE, CMD_REQUIRED, "new owner");
cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to modify");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsGroupCreate", DoPtsGroupCreate, 0,
+ ts = cmd_CreateSyntax("PtsGroupCreate", DoPtsGroupCreate, NULL,
"create a new group");
cmd_AddParm(ts, "-owner", CMD_SINGLE, CMD_REQUIRED, "owner of group");
cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to create");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsGroupGet", DoPtsGroupGet, 0,
+ ts = cmd_CreateSyntax("PtsGroupGet", DoPtsGroupGet, NULL,
"get information about a group");
cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to query");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsGroupDelete", DoPtsGroupDelete, 0,
+ ts = cmd_CreateSyntax("PtsGroupDelete", DoPtsGroupDelete, NULL,
"delete a group");
cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to delete");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsGroupMaxGet", DoPtsGroupMaxGet, 0,
+ ts = cmd_CreateSyntax("PtsGroupMaxGet", DoPtsGroupMaxGet, NULL,
"get the maximum group id");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsGroupMaxSet", DoPtsGroupMaxSet, 0,
+ ts = cmd_CreateSyntax("PtsGroupMaxSet", DoPtsGroupMaxSet, NULL,
"set the maximum group id");
cmd_AddParm(ts, "-max", CMD_SINGLE, CMD_REQUIRED, "new max group id");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsGroupMemberList", DoPtsGroupMemberList, 0,
+ ts = cmd_CreateSyntax("PtsGroupMemberList", DoPtsGroupMemberList, NULL,
"list members of a group");
cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to query");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsGroupMemberRemove", DoPtsGroupMemberRemove, 0,
+ ts = cmd_CreateSyntax("PtsGroupMemberRemove", DoPtsGroupMemberRemove, NULL,
"remove a member from a group");
cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to remove");
cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to modify");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsGroupRename", DoPtsGroupRename, 0,
+ ts = cmd_CreateSyntax("PtsGroupRename", DoPtsGroupRename, NULL,
"rename a group");
cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to modify");
cmd_AddParm(ts, "-newname", CMD_SINGLE, CMD_REQUIRED, "new group name");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsGroupModify", DoPtsGroupModify, 0,
+ ts = cmd_CreateSyntax("PtsGroupModify", DoPtsGroupModify, NULL,
"modify a group");
cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_REQUIRED, "group to modify");
cmd_AddParm(ts, "-liststatus", CMD_SINGLE, CMD_REQUIRED,
"list delete permission <owner | group>");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsUserCreate", DoPtsUserCreate, 0,
+ ts = cmd_CreateSyntax("PtsUserCreate", DoPtsUserCreate, NULL,
"create a new user");
cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to create");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsUserDelete", DoPtsUserDelete, 0,
+ ts = cmd_CreateSyntax("PtsUserDelete", DoPtsUserDelete, NULL,
"delete a user");
cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to delete");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsUserGet", DoPtsUserGet, 0,
+ ts = cmd_CreateSyntax("PtsUserGet", DoPtsUserGet, NULL,
"get information about a user");
cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to query");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsUserRename", DoPtsUserRename, 0,
+ ts = cmd_CreateSyntax("PtsUserRename", DoPtsUserRename, NULL,
"rename a user");
cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to modify");
cmd_AddParm(ts, "-newname", CMD_SINGLE, CMD_REQUIRED, "new user name");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsUserModify", DoPtsUserModify, 0,
+ ts = cmd_CreateSyntax("PtsUserModify", DoPtsUserModify, NULL,
"change a user");
cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to modify");
cmd_AddParm(ts, "-groupquota", CMD_SINGLE, CMD_OPTIONAL,
"list membership permission <owner | any>");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsUserMaxGet", DoPtsUserMaxGet, 0,
+ ts = cmd_CreateSyntax("PtsUserMaxGet", DoPtsUserMaxGet, NULL,
"get the max user id");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsUserMaxSet", DoPtsUserMaxSet, 0,
+ ts = cmd_CreateSyntax("PtsUserMaxSet", DoPtsUserMaxSet, NULL,
"set the max user id");
cmd_AddParm(ts, "-max", CMD_SINGLE, CMD_REQUIRED, "max user id");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsUserMemberList", DoPtsUserMemberList, 0,
+ ts = cmd_CreateSyntax("PtsUserMemberList", DoPtsUserMemberList, NULL,
"list group membership for a user");
cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to query");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("PtsOwnedGroupList", DoPtsOwnedGroupList, 0,
+ ts = cmd_CreateSyntax("PtsOwnedGroupList", DoPtsOwnedGroupList, NULL,
"list groups owned by a user");
cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_REQUIRED, "user to query");
SetupCommonCmdArgs(ts);
#include "util.h"
int
-DoUtilErrorTranslate(struct cmd_syndesc *as, char *arock)
+DoUtilErrorTranslate(struct cmd_syndesc *as, void *arock)
{
typedef enum { ERROR_CODE } DoUtilErrorTranslate_parm_t;
afs_status_t st = 0;
}
int
-DoUtilDatabaseServerList(struct cmd_syndesc *as, char *arock)
+DoUtilDatabaseServerList(struct cmd_syndesc *as, void *arock)
{
typedef enum { CELL_NAME } DoUtilDatabaseServerList_parm_t;
afs_status_t st = 0;
}
int
-DoUtilNameToAddress(struct cmd_syndesc *as, char *arock)
+DoUtilNameToAddress(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER_NAME } DoUtilNameToAddress_parm_t;
afs_status_t st = 0;
{
struct cmd_syndesc *ts;
- ts = cmd_CreateSyntax("UtilErrorTranslate", DoUtilErrorTranslate, 0,
+ ts = cmd_CreateSyntax("UtilErrorTranslate", DoUtilErrorTranslate, NULL,
"translate an error code");
cmd_AddParm(ts, "-error", CMD_SINGLE, CMD_REQUIRED, "error code");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("UtilDatabaseServerList", DoUtilDatabaseServerList,
- 0, "list the database servers in a cell");
+ NULL, "list the database servers in a cell");
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_REQUIRED, "cell to list");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("UtilNameToAddress", DoUtilNameToAddress, 0,
+ ts = cmd_CreateSyntax("UtilNameToAddress", DoUtilNameToAddress, NULL,
"translate a host name to an address");
cmd_AddParm(ts, "-host", CMD_SINGLE, CMD_REQUIRED, "host name");
SetupCommonCmdArgs(ts);
#include "common.h"
int
- DoUtilErrorTranslate(struct cmd_syndesc *as, char *arock);
+ DoUtilErrorTranslate(struct cmd_syndesc *as, void *arock);
int
- DoUtilDatabaseServerList(struct cmd_syndesc *as, char *arock);
+ DoUtilDatabaseServerList(struct cmd_syndesc *as, void *arock);
int
- DoUtilNameToAddress(struct cmd_syndesc *as, char *arock);
+ DoUtilNameToAddress(struct cmd_syndesc *as, void *arock);
void
SetupUtilAdminCmd(void);
}
int
-DoVosBackupVolumeCreate(struct cmd_syndesc *as, char *arock)
+DoVosBackupVolumeCreate(struct cmd_syndesc *as, void *arock)
{
typedef enum { VOLUME } DoVosBackupVolumeCreate_parm_t;
afs_status_t st = 0;
}
int
-DoVosBackupVolumeCreateMultiple(struct cmd_syndesc *as, char *arock)
+DoVosBackupVolumeCreateMultiple(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION, PREFIX,
EXCLUDE
}
int
-DoVosPartitionGet(struct cmd_syndesc *as, char *arock)
+DoVosPartitionGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION } DoVosPartitionGet_parm_t;
afs_status_t st = 0;
}
int
-DoVosPartitionList(struct cmd_syndesc *as, char *arock)
+DoVosPartitionList(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER } DoVosPartitionGet_parm_t;
afs_status_t st = 0;
}
int
-DoVosServerSync(struct cmd_syndesc *as, char *arock)
+DoVosServerSync(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION } DoVosServerSync_parm_t;
afs_status_t st = 0;
}
int
-DoVosFileServerAddressChange(struct cmd_syndesc *as, char *arock)
+DoVosFileServerAddressChange(struct cmd_syndesc *as, void *arock)
{
typedef enum { OLDADDRESS,
NEWADDRESS
}
int
-DoVosFileServerAddressRemove(struct cmd_syndesc *as, char *arock)
+DoVosFileServerAddressRemove(struct cmd_syndesc *as, void *arock)
{
typedef enum { ADDRESS } DoVosFileServerAddressRemove_parm_t;
afs_status_t st = 0;
}
int
-DoVosFileServerList(struct cmd_syndesc *as, char *arock)
+DoVosFileServerList(struct cmd_syndesc *as, void *arock)
{
afs_status_t st = 0;
void *iter;
}
int
-DoVosServerTransactionStatusList(struct cmd_syndesc *as, char *arock)
+DoVosServerTransactionStatusList(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER } DoVosServerTransactionStatusList_parm_t;
afs_status_t st = 0;
}
int
-DoVosVLDBGet(struct cmd_syndesc *as, char *arock)
+DoVosVLDBGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { VOLUME } DoVosVLDBGet_parm_t;
afs_status_t st = 0;
}
int
-DoVosVLDBList(struct cmd_syndesc *as, char *arock)
+DoVosVLDBList(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION } DoVosVLDBList_parm_t;
afs_status_t st = 0;
}
int
-DoVosVLDBEntryRemove(struct cmd_syndesc *as, char *arock)
+DoVosVLDBEntryRemove(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION, VOLUME } DoVosVLDBEntryRemove_parm_t;
afs_status_t st = 0;
}
int
-DoVosVLDBUnlock(struct cmd_syndesc *as, char *arock)
+DoVosVLDBUnlock(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION } DoVosVLDBUnlock_parm_t;
afs_status_t st = 0;
}
int
-DoVosVLDBEntryLock(struct cmd_syndesc *as, char *arock)
+DoVosVLDBEntryLock(struct cmd_syndesc *as, void *arock)
{
typedef enum { VOLUME } DoVosVLDBEntryLoc_parm_tk;
afs_status_t st = 0;
}
int
-DoVosVLDBEntryUnlock(struct cmd_syndesc *as, char *arock)
+DoVosVLDBEntryUnlock(struct cmd_syndesc *as, void *arock)
{
typedef enum { VOLUME } DoVosVLDBEntryUnlock_parm_t;
afs_status_t st = 0;
}
int
-DoVosVLDBReadOnlySiteCreate(struct cmd_syndesc *as, char *arock)
+DoVosVLDBReadOnlySiteCreate(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION,
VOLUME
}
int
-DoVosVLDBReadOnlySiteDelete(struct cmd_syndesc *as, char *arock)
+DoVosVLDBReadOnlySiteDelete(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION,
VOLUME
}
int
-DoVosVLDBSync(struct cmd_syndesc *as, char *arock)
+DoVosVLDBSync(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION, FORCE } DoVosVLDBSync_parm_t;
afs_status_t st = 0;
}
int
-DoVosVolumeCreate(struct cmd_syndesc *as, char *arock)
+DoVosVolumeCreate(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION, VOLUME,
QUOTA
}
int
-DoVosVolumeDelete(struct cmd_syndesc *as, char *arock)
+DoVosVolumeDelete(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeDelete_parm_t;
afs_status_t st = 0;
}
int
-DoVosVolumeRename(struct cmd_syndesc *as, char *arock)
+DoVosVolumeRename(struct cmd_syndesc *as, void *arock)
{
typedef enum { OLDVOLUME, NEWVOLUME } DoVosVolumeRename_parm_t;
afs_status_t st = 0;
}
int
-DoVosVolumeDump(struct cmd_syndesc *as, char *arock)
+DoVosVolumeDump(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION, VOLUME, STARTTIME,
DUMPFILE
}
int
-DoVosVolumeRestore(struct cmd_syndesc *as, char *arock)
+DoVosVolumeRestore(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION, ID, VOLUME, DUMPFILE,
FULL
}
int
-DoVosVolumeOnline(struct cmd_syndesc *as, char *arock)
+DoVosVolumeOnline(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION, VOLUME, SLEEP,
BUSY
}
int
-DoVosVolumeOffline(struct cmd_syndesc *as, char *arock)
+DoVosVolumeOffline(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeOffline_parm_t;
afs_status_t st = 0;
}
int
-DoVosVolumeGet(struct cmd_syndesc *as, char *arock)
+DoVosVolumeGet(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeGet_parm_t;
afs_status_t st = 0;
}
int
-DoVosVolumeList(struct cmd_syndesc *as, char *arock)
+DoVosVolumeList(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION } DoVosVolumeList_parm_t;
afs_status_t st = 0;
}
int
-DoVosVolumeMove(struct cmd_syndesc *as, char *arock)
+DoVosVolumeMove(struct cmd_syndesc *as, void *arock)
{
typedef enum { VOLUME, FROMSERVER, FROMPARTITION, TOSERVER,
TOPARTITION
}
int
-DoVosVolumeRelease(struct cmd_syndesc *as, char *arock)
+DoVosVolumeRelease(struct cmd_syndesc *as, void *arock)
{
typedef enum { VOLUME, FORCE } DoVosVolumeRelease_parm_t;
afs_status_t st = 0;
}
int
-DoVosVolumeZap(struct cmd_syndesc *as, char *arock)
+DoVosVolumeZap(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION, VOLUME, FORCE } DoVosVolumeZap_parm_t;
afs_status_t st = 0;
}
int
-DoVosPartitionNameToId(struct cmd_syndesc *as, char *arock)
+DoVosPartitionNameToId(struct cmd_syndesc *as, void *arock)
{
typedef enum { PARTITION } DoVosPartitionNameToId_parm_t;
afs_status_t st = 0;
}
int
-DoVosPartitionIdToName(struct cmd_syndesc *as, char *arock)
+DoVosPartitionIdToName(struct cmd_syndesc *as, void *arock)
{
typedef enum { PARTITIONID } DoVosPartitionIdToName_parm_t;
afs_status_t st = 0;
}
int
-DoVosVolumeQuotaChange(struct cmd_syndesc *as, char *arock)
+DoVosVolumeQuotaChange(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION, VOLUME,
QUOTA
}
int
-DoVosVolumeGet2(struct cmd_syndesc *as, char *arock)
+DoVosVolumeGet2(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeGet_parm_t;
afs_status_t st = 0;
int
-DoVos_ClearVolUpdateCounter(struct cmd_syndesc *as, char *arock)
+DoVos_ClearVolUpdateCounter(struct cmd_syndesc *as, void *arock)
{
typedef enum { SERVER, PARTITION, VOLUME } DoVosVolumeGet_parm_t;
afs_status_t st = 0;
{
struct cmd_syndesc *ts;
- ts = cmd_CreateSyntax("VosBackupVolumeCreate", DoVosBackupVolumeCreate, 0,
+ ts = cmd_CreateSyntax("VosBackupVolumeCreate", DoVosBackupVolumeCreate, NULL,
"create a backup volume");
cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to back up");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("VosBackupVolumeCreateMultiple",
- DoVosBackupVolumeCreateMultiple, 0,
+ DoVosBackupVolumeCreateMultiple, NULL,
"create a backup volume");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
"server housing volumes to back up");
"exclude volumes from backup that match prefix");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosPartitionGet", DoVosPartitionGet, 0,
+ ts = cmd_CreateSyntax("VosPartitionGet", DoVosPartitionGet, NULL,
"get information about a partition");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server housing partition of interest");
"partition to query");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosPartitionList", DoVosPartitionList, 0,
+ ts = cmd_CreateSyntax("VosPartitionList", DoVosPartitionList, NULL,
"list information about all partitions at a server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server housing partitions of interest");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosServerSync", DoVosServerSync, 0,
+ ts = cmd_CreateSyntax("VosServerSync", DoVosServerSync, NULL,
"sync server with vldb");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to sync");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("VosFileServerAddressChange",
- DoVosFileServerAddressChange, 0,
+ DoVosFileServerAddressChange, NULL,
"change a server's address in the vldb");
cmd_AddParm(ts, "-oldaddress", CMD_SINGLE, CMD_REQUIRED,
"old address to change");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("VosFileServerAddressRemove",
- DoVosFileServerAddressRemove, 0,
+ DoVosFileServerAddressRemove, NULL,
"remove a server's address from the vldb");
cmd_AddParm(ts, "-address", CMD_SINGLE, CMD_REQUIRED,
"address to remove");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosFileServerList", DoVosFileServerList, 0,
+ ts = cmd_CreateSyntax("VosFileServerList", DoVosFileServerList, NULL,
"list the file servers in a cell");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("VosServerTransactionStatusList",
- DoVosServerTransactionStatusList, 0,
+ DoVosServerTransactionStatusList, NULL,
"list the active transactions at a server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to query");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVLDBGet", DoVosVLDBGet, 0,
+ ts = cmd_CreateSyntax("VosVLDBGet", DoVosVLDBGet, NULL,
"get a vldb entry for a volume");
cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
"volume to retrieve");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVLDBList", DoVosVLDBList, 0,
+ ts = cmd_CreateSyntax("VosVLDBList", DoVosVLDBList, NULL,
"list a group of vldb entries");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
"limit entries to a particular server");
"limit entries to a particular partition");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVLDBEntryRemove", DoVosVLDBEntryRemove, 0,
+ ts = cmd_CreateSyntax("VosVLDBEntryRemove", DoVosVLDBEntryRemove, NULL,
"remove vldb entries");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
"limit entries to a particular server");
cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_OPTIONAL, "volume to remove");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVLDBUnlock", DoVosVLDBUnlock, 0,
+ ts = cmd_CreateSyntax("VosVLDBUnlock", DoVosVLDBUnlock, NULL,
"unlock a group of vldb entries");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
"limit entries to a particular server");
"limit entries to a particular partition");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVLDBEntryLock", DoVosVLDBList, 0,
+ ts = cmd_CreateSyntax("VosVLDBEntryLock", DoVosVLDBList, NULL,
"lock a single vldb entry");
cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to lock");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVLDBEntryUnlock", DoVosVLDBEntryUnlock, 0,
+ ts = cmd_CreateSyntax("VosVLDBEntryUnlock", DoVosVLDBEntryUnlock, NULL,
"unlock a single vldb entry");
cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to unlock");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("VosVLDBReadOnlySiteCreate",
- DoVosVLDBReadOnlySiteCreate, 0,
+ DoVosVLDBReadOnlySiteCreate, NULL,
"create a read only site");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where read only will be created");
SetupCommonCmdArgs(ts);
ts = cmd_CreateSyntax("VosVLDBReadOnlySiteDelete",
- DoVosVLDBReadOnlySiteDelete, 0,
+ DoVosVLDBReadOnlySiteDelete, NULL,
"delete a read only site before initial replication");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
"server where read only will be deleted");
cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to delete");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVLDBSync", DoVosVLDBSync, 0,
+ ts = cmd_CreateSyntax("VosVLDBSync", DoVosVLDBSync, NULL,
"sync vldb with server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server to sync");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL, "force sync to occur");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVolumeCreate", DoVosVolumeCreate, 0,
+ ts = cmd_CreateSyntax("VosVolumeCreate", DoVosVolumeCreate, NULL,
"create a read write volume");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where volume will be created");
"size quota of new volume in 1kb units");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVolumeDelete", DoVosVolumeDelete, 0,
+ ts = cmd_CreateSyntax("VosVolumeDelete", DoVosVolumeDelete, NULL,
"delete a volume");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server where volume exists");
cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to delete");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVolumeRename", DoVosVolumeRename, 0,
+ ts = cmd_CreateSyntax("VosVolumeRename", DoVosVolumeRename, NULL,
"rename a volume");
cmd_AddParm(ts, "-oldname", CMD_SINGLE, CMD_REQUIRED, "old volume name");
cmd_AddParm(ts, "-newname", CMD_SINGLE, CMD_REQUIRED, "new volume name");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVolumeDump", DoVosVolumeDump, 0,
+ ts = cmd_CreateSyntax("VosVolumeDump", DoVosVolumeDump, NULL,
"dump a volume to a file");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
"dump volume at a particular server");
"file to contain dump results");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVolumeRestore", DoVosVolumeRestore, 0,
+ ts = cmd_CreateSyntax("VosVolumeRestore", DoVosVolumeRestore, NULL,
"restore a volume from a dumpfile");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server that houses volume to restore");
"does a full restore of volume");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVolumeOnline", DoVosVolumeOnline, 0,
+ ts = cmd_CreateSyntax("VosVolumeOnline", DoVosVolumeOnline, NULL,
"bring a volume online");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server that houses volume");
cmd_AddParm(ts, "-busy", CMD_FLAG, CMD_OPTIONAL, "mark volume busy");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVolumeOffline", DoVosVolumeOffline, 0,
+ ts = cmd_CreateSyntax("VosVolumeOffline", DoVosVolumeOffline, NULL,
"take a volume offline");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server that houses volume");
"volume to bring offline");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVolumeGet", DoVosVolumeGet, 0,
+ ts = cmd_CreateSyntax("VosVolumeGet", DoVosVolumeGet, NULL,
"get a volume entry");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server that houses volume");
"volume to retrieve");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVolumeList", DoVosVolumeList, 0,
+ ts = cmd_CreateSyntax("VosVolumeList", DoVosVolumeList, NULL,
"list a group of volumes");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"limit volumes to a particular server");
"limit volumes to a particular partition");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVolumeMove", DoVosVolumeMove, 0,
+ ts = cmd_CreateSyntax("VosVolumeMove", DoVosVolumeMove, NULL,
"move a volume");
cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume to move");
cmd_AddParm(ts, "-fromserver", CMD_SINGLE, CMD_REQUIRED, "source server");
"destination partition");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVolumeRelease", DoVosVolumeRelease, 0,
+ ts = cmd_CreateSyntax("VosVolumeRelease", DoVosVolumeRelease, NULL,
"release updates to read only");
cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED,
"volume to replicate");
"force release to occur");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVolumeZap", DoVosVolumeZap, 0, "zap a volume");
+ ts = cmd_CreateSyntax("VosVolumeZap", DoVosVolumeZap, NULL, "zap a volume");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server that houses the volume to zap");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL, "force zap");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosPartitionNameToId", DoVosPartitionNameToId, 0,
+ ts = cmd_CreateSyntax("VosPartitionNameToId", DoVosPartitionNameToId, NULL,
"convert a partition name to a number");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
"partition to convert");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosPartitionIdToName", DoVosPartitionIdToName, 0,
+ ts = cmd_CreateSyntax("VosPartitionIdToName", DoVosPartitionIdToName, NULL,
"convert a number to a partition");
cmd_AddParm(ts, "-id", CMD_SINGLE, CMD_REQUIRED, "number to convert");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVolumeQuotaChange", DoVosVolumeQuotaChange, 0,
+ ts = cmd_CreateSyntax("VosVolumeQuotaChange", DoVosVolumeQuotaChange, NULL,
"change the quota for a partition");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server that houses the volume");
"new quota in 1kb units");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("VosVolumeGet2", DoVosVolumeGet2, 0,
+ ts = cmd_CreateSyntax("VosVolumeGet2", DoVosVolumeGet2, NULL,
"get a volume entry");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server that houses volume");
"volume to retrieve");
SetupCommonCmdArgs(ts);
- ts = cmd_CreateSyntax("ClearVolUpdateCounter", DoVos_ClearVolUpdateCounter, 0,
+ ts = cmd_CreateSyntax("ClearVolUpdateCounter", DoVos_ClearVolUpdateCounter, NULL,
"clear volUpdateCounter");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
"server that houses volume");
int
-CommandProc(struct cmd_syndesc *as, char *arock)
+CommandProc(struct cmd_syndesc *as, void *arock)
{
#define MAXCELLS 20 /* XXX */
struct cmd_item *itp;
sigaction(SIGSEGV, &nsa, NULL);
#endif
- ts = cmd_CreateSyntax(NULL, CommandProc, 0,
+ ts = cmd_CreateSyntax(NULL, CommandProc, NULL,
"Release Kerberos authentication");
cmd_AddParm(ts, "-cell", CMD_LIST, CMD_OPTIONAL, "cell name");
#define ROOTINODE 2
int force = 0, verbose = 0, unconv = 0;
-static
-ConvCmd(as)
- struct cmd_syndesc *as;
+static int
+ConvCmd(struct cmd_syndesc *as, void *arock)
{
unconv = 0;
handleit(as);
}
-static
-UnConvCmd(as)
- struct cmd_syndesc *as;
+static int
+UnConvCmd(struct cmd_syndesc *as, void *arock)
{
unconv = 1;
handleit(as);
}
-static
-handleit(as)
- struct cmd_syndesc *as;
+static int
+handleit(struct cmd_syndesc *as)
{
register struct cmd_item *ti;
char *dname;
printf("must be run as root; sorry\n");
exit(1);
}
- ts = cmd_CreateSyntax("convert", ConvCmd, 0,
+ ts = cmd_CreateSyntax("convert", ConvCmd, NULL,
"Convert to AFS SunOS 5.6 format");
cmd_AddParm(ts, "-part", CMD_LIST, CMD_OPTIONAL, "AFS partition name");
cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, "verbose mode");
cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL,
"Safeguard enforce switch");
cmd_AddParm(ts, "-device", CMD_LIST, CMD_OPTIONAL, "AFS raw device name");
- ts = cmd_CreateSyntax("unconvert", UnConvCmd, 0,
+ ts = cmd_CreateSyntax("unconvert", UnConvCmd, NULL,
"Convert back from AFS SunOS 5.6 to earlier formats");
cmd_AddParm(ts, "-part", CMD_LIST, CMD_OPTIONAL, "AFS partition name");
cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, "verbose mode");
#include "AFS_component_version_number.c"
int
-WorkerBee(struct cmd_syndesc *as, char *arock)
+WorkerBee(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
char *recreateFile;
char *checkin();
char *check_core();
char *id_to_name();
-int CommandProc(struct cmd_syndesc *);
+int CommandProc(struct cmd_syndesc *, void *);
struct hash_entry {
char h_name[PR_MAXNAMELEN];
register struct cmd_syndesc *cs; /*Command line syntax descriptor */
register afs_int32 code; /*Return code */
- cs = cmd_CreateSyntax((char *)0, CommandProc, 0,
+ cs = cmd_CreateSyntax(NULL, CommandProc, NULL,
"access protection database");
cmd_AddParm(cs, "-w", CMD_FLAG, CMD_OPTIONAL,
"update prdb with contents of data file");
}
int
-CommandProc(register struct cmd_syndesc *a_as)
+CommandProc(register struct cmd_syndesc *a_as, void *arock)
{
register int i;
register long code;
} *shead;
int
-pts_Interactive(struct cmd_syndesc *as, char *arock)
+pts_Interactive(struct cmd_syndesc *as, void *arock)
{
finished = 0;
return 0;
}
int
-pts_Quit(struct cmd_syndesc *as, char *arock)
+pts_Quit(struct cmd_syndesc *as, void *arock)
{
finished = 1;
return 0;
}
int
-pts_Source(struct cmd_syndesc *as, char *arock)
+pts_Source(struct cmd_syndesc *as, void *arock)
{
FILE *fd;
struct sourcestack *sp;
}
int
-pts_Sleep(struct cmd_syndesc *as, char *arock)
+pts_Sleep(struct cmd_syndesc *as, void *arock)
{
int delay;
if (!as->parms[0].items) {
}
int
-GetGlobals(struct cmd_syndesc *as, char *arock)
+GetGlobals(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
char *cell;
}
int
-CleanUp(struct cmd_syndesc *as, char *arock)
+CleanUp(struct cmd_syndesc *as, void *arock)
{
if (as && !strcmp(as->name, "help"))
return 0;
}
int
-CreateGroup(struct cmd_syndesc *as, char *arock)
+CreateGroup(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
afs_int32 id;
}
int
-CreateUser(struct cmd_syndesc *as, char *arock)
+CreateUser(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
afs_int32 id;
int
-AddToGroup(struct cmd_syndesc *as, char *arock)
+AddToGroup(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
struct cmd_item *u, *g;
}
int
-RemoveFromGroup(struct cmd_syndesc *as, char *arock)
+RemoveFromGroup(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
struct cmd_item *u, *g;
}
int
-ListMembership(struct cmd_syndesc *as, char *arock)
+ListMembership(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
idlist ids;
}
int
-Delete(struct cmd_syndesc *as, char *arock)
+Delete(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
idlist ids;
int flags_shift[5] = { 2, 1, 2, 2, 1 }; /* bits for each */
int
-CheckEntry(struct cmd_syndesc *as, char *arock)
+CheckEntry(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
afs_int32 rcode = 1;
}
int
-ListEntries(struct cmd_syndesc *as, char *arock)
+ListEntries(struct cmd_syndesc *as, void *arock)
{
afs_int32 code = 0;
afs_int32 flag, startindex, nentries, nextstartindex;
}
int
-ChownGroup(struct cmd_syndesc *as, char *arock)
+ChownGroup(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
char *name;
}
int
-ChangeName(struct cmd_syndesc *as, char *arock)
+ChangeName(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
char *oldname;
}
int
-ListMax(struct cmd_syndesc *as, char *arock)
+ListMax(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
afs_int32 maxUser, maxGroup;
}
int
-SetMax(struct cmd_syndesc *as, char *arock)
+SetMax(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
afs_int32 maxid;
}
int
-SetFields(struct cmd_syndesc *as, char *arock)
+SetFields(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
idlist ids;
}
int
-ListOwned(struct cmd_syndesc *as, char *arock)
+ListOwned(struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
idlist ids;
sigaction(SIGSEGV, &nsa, NULL);
#endif
- ts = cmd_CreateSyntax("creategroup", CreateGroup, 0,
+ ts = cmd_CreateSyntax("creategroup", CreateGroup, NULL,
"create a new group");
cmd_AddParm(ts, "-name", CMD_LIST, 0, "group name");
cmd_AddParm(ts, "-owner", CMD_SINGLE, CMD_OPTIONAL, "owner of the group");
add_std_args(ts);
cmd_CreateAlias(ts, "cg");
- ts = cmd_CreateSyntax("createuser", CreateUser, 0, "create a new user");
+ ts = cmd_CreateSyntax("createuser", CreateUser, NULL, "create a new user");
cmd_AddParm(ts, "-name", CMD_LIST, 0, "user name");
cmd_AddParm(ts, "-id", CMD_LIST, CMD_OPTIONAL, "user id");
add_std_args(ts);
cmd_CreateAlias(ts, "cu");
- ts = cmd_CreateSyntax("adduser", AddToGroup, 0, "add a user to a group");
+ ts = cmd_CreateSyntax("adduser", AddToGroup, NULL, "add a user to a group");
cmd_AddParm(ts, "-user", CMD_LIST, 0, "user name");
cmd_AddParm(ts, "-group", CMD_LIST, 0, "group name");
add_std_args(ts);
- ts = cmd_CreateSyntax("removeuser", RemoveFromGroup, 0,
+ ts = cmd_CreateSyntax("removeuser", RemoveFromGroup, NULL,
"remove a user from a group");
cmd_AddParm(ts, "-user", CMD_LIST, 0, "user name");
cmd_AddParm(ts, "-group", CMD_LIST, 0, "group name");
add_std_args(ts);
- ts = cmd_CreateSyntax("membership", ListMembership, 0,
+ ts = cmd_CreateSyntax("membership", ListMembership, NULL,
"list membership of a user or group");
cmd_AddParm(ts, "-nameorid", CMD_LIST, 0, "user or group name or id");
add_std_args(ts);
cmd_CreateAlias(ts, "groups");
- ts = cmd_CreateSyntax("delete", Delete, 0,
+ ts = cmd_CreateSyntax("delete", Delete, NULL,
"delete a user or group from database");
cmd_AddParm(ts, "-nameorid", CMD_LIST, 0, "user or group name or id");
add_std_args(ts);
- ts = cmd_CreateSyntax("examine", CheckEntry, 0, "examine an entry");
+ ts = cmd_CreateSyntax("examine", CheckEntry, NULL, "examine an entry");
cmd_AddParm(ts, "-nameorid", CMD_LIST, 0, "user or group name or id");
add_std_args(ts);
cmd_CreateAlias(ts, "check");
- ts = cmd_CreateSyntax("chown", ChownGroup, 0,
+ ts = cmd_CreateSyntax("chown", ChownGroup, NULL,
"change ownership of a group");
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "group name");
cmd_AddParm(ts, "-owner", CMD_SINGLE, 0, "new owner");
add_std_args(ts);
- ts = cmd_CreateSyntax("rename", ChangeName, 0, "rename user or group");
+ ts = cmd_CreateSyntax("rename", ChangeName, NULL, "rename user or group");
cmd_AddParm(ts, "-oldname", CMD_SINGLE, 0, "old name");
cmd_AddParm(ts, "-newname", CMD_SINGLE, 0, "new name");
add_std_args(ts);
cmd_CreateAlias(ts, "chname");
- ts = cmd_CreateSyntax("listmax", ListMax, 0, "list max id");
+ ts = cmd_CreateSyntax("listmax", ListMax, NULL, "list max id");
add_std_args(ts);
- ts = cmd_CreateSyntax("setmax", SetMax, 0, "set max id");
+ ts = cmd_CreateSyntax("setmax", SetMax, NULL, "set max id");
cmd_AddParm(ts, "-group", CMD_SINGLE, CMD_OPTIONAL, "group max");
cmd_AddParm(ts, "-user", CMD_SINGLE, CMD_OPTIONAL, "user max");
add_std_args(ts);
- ts = cmd_CreateSyntax("setfields", SetFields, 0,
+ ts = cmd_CreateSyntax("setfields", SetFields, NULL,
"set fields for an entry");
cmd_AddParm(ts, "-nameorid", CMD_LIST, 0, "user or group name or id");
cmd_AddParm(ts, "-access", CMD_SINGLE, CMD_OPTIONAL, "set privacy flags");
#endif
add_std_args(ts);
- ts = cmd_CreateSyntax("listowned", ListOwned, 0,
+ ts = cmd_CreateSyntax("listowned", ListOwned, NULL,
"list groups owned by an entry or zero id gets orphaned groups");
cmd_AddParm(ts, "-nameorid", CMD_LIST, 0, "user or group name or id");
add_std_args(ts);
- ts = cmd_CreateSyntax("listentries", ListEntries, 0,
+ ts = cmd_CreateSyntax("listentries", ListEntries, NULL,
"list users/groups in the protection database");
cmd_AddParm(ts, "-users", CMD_FLAG, CMD_OPTIONAL, "list user entries");
cmd_AddParm(ts, "-groups", CMD_FLAG, CMD_OPTIONAL, "list group entries");
add_std_args(ts);
- ts = cmd_CreateSyntax("interactive", pts_Interactive, 0,
+ ts = cmd_CreateSyntax("interactive", pts_Interactive, NULL,
"enter interactive mode");
add_std_args(ts);
cmd_CreateAlias(ts, "in");
- ts = cmd_CreateSyntax("quit", pts_Quit, 0, "exit program");
+ ts = cmd_CreateSyntax("quit", pts_Quit, NULL, "exit program");
add_std_args(ts);
- ts = cmd_CreateSyntax("source", pts_Source, 0, "read commands from file");
+ ts = cmd_CreateSyntax("source", pts_Source, NULL, "read commands from file");
cmd_AddParm(ts, "-file", CMD_SINGLE, 0, "filename");
add_std_args(ts);
- ts = cmd_CreateSyntax("sleep", pts_Sleep, 0, "pause for a bit");
+ ts = cmd_CreateSyntax("sleep", pts_Sleep, NULL, "pause for a bit");
cmd_AddParm(ts, "-delay", CMD_SINGLE, 0, "seconds");
add_std_args(ts);
static char lcell[MAXCELLCHARS];
int
-ListUsedIds(struct cmd_syndesc *as, char *arock)
+ListUsedIds(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
namelist lnames;
}
int
-TestManyMembers(struct cmd_syndesc *as, char *arock)
+TestManyMembers(struct cmd_syndesc *as, void *arock)
{
char *filled; /* users filled up */
char *cleaned; /* users cleaned up */
*/
int
-TestPrServ(struct cmd_syndesc *as, char *arock)
+TestPrServ(struct cmd_syndesc *as, void *arock)
{
afs_int32 id;
char name[PR_MAXNAMELEN + 1];
static char tmp_noauth_file[128] = "";
static int
-MyAfterProc(struct cmd_syndesc *as, char *arock)
+MyAfterProc(struct cmd_syndesc *as, void *arock)
{
if (strlen(tmp_conf_file))
unlink(tmp_conf_file);
}
static int
-MyBeforeProc(struct cmd_syndesc *as, char *arock)
+MyBeforeProc(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
int i;
cmd_SetBeforeProc(MyBeforeProc, NULL);
cmd_SetAfterProc(MyAfterProc, NULL);
- ts = cmd_CreateSyntax("usedIds", ListUsedIds, 0,
+ ts = cmd_CreateSyntax("usedIds", ListUsedIds, NULL,
"Find used (or unused) user (or group) ids");
cmd_AddParm(ts, "-startId", CMD_SINGLE, CMD_OPTIONAL,
"id to start checking");
cmd_AddParm(ts, "-unused", CMD_FLAG, CMD_OPTIONAL, "print unused ids");
add_std_args(ts);
- ts = cmd_CreateSyntax("initcmd", TestPrServ, 0, "test the prserver");
+ ts = cmd_CreateSyntax("initcmd", TestPrServ, NULL, "test the prserver");
add_std_args(ts);
- ts = cmd_CreateSyntax("testmanymembers", TestManyMembers, 0,
+ ts = cmd_CreateSyntax("testmanymembers", TestManyMembers, NULL,
"test creating users and groups w/ many members");
cmd_AddParm(ts, "-number", CMD_SINGLE, 0,
"number of users/groups to create");
fprintf(itl_h, "}\n");
fprintf(itl_h,
- "\n\nstatic void DoRun(struct cmd_syndesc *as, char *arock) {\n");
+ "\n\nstatic void DoRun(struct cmd_syndesc *as, void *arock) {\n");
if (threadModel == PTHREADS) {
fprintf(itl_h, "\tpthread_t *tid;\n");
fprintf(itl_h,
"static void SetupRunCmd(void) {\n" "\tstruct cmd_syndesc *ts;\n"
- "\tts = cmd_CreateSyntax(NULL,DoRun, 0, \"run the test client program\");\n"
+ "\tts = cmd_CreateSyntax(NULL,DoRun, NULL, \"run the test client program\");\n"
"\tcmd_AddParm(ts, \"-threadCount\", CMD_SINGLE, CMD_REQUIRED, \"number of threads to spawn\");\n"
"\tcmd_AddParm(ts, \"-iterationCount\", CMD_SINGLE, CMD_REQUIRED, \"number of iterations to make over entire interface for each thread\");\n"
"\tcmd_AddParm(ts, \"-secType\", CMD_SINGLE, CMD_REQUIRED, \"security level to use (1 -> unauthenticated, 2 -> authenticated)\");\n"
"\nstatic long GetKey (char *rock, long kvno, struct ktc_encryptionKey *key) {\n"
"\tmemcpy ((void *) key, (void *) &serviceKey, sizeof(*key));\n"
"\treturn 0;\n" "}\n\n"
- "static void DoRun(struct cmd_syndesc *as, char *arock) {\n"
+ "static void DoRun(struct cmd_syndesc *as, void *arock) {\n"
"\tstruct rx_service *serv;\n"
"\tstruct rx_securityClass *sc[3];\n\n"
"\tint port=0, errflg=0;\n" "\tint lowThreads=4, highThreads=8;\n"
"\t\trx_SetMaxProcs(serv,highThreads);\n"
"\t\trx_StartServer(1);\n" "\t}\n" "\texit(0);\n" "}\n\n"
"static void SetupRunCmd(void) {\n" "\tstruct cmd_syndesc *ts;\n"
- "\tts = cmd_CreateSyntax(NULL,DoRun, 0, \"run the test server program\");\n"
+ "\tts = cmd_CreateSyntax(NULL,DoRun, NULL, \"run the test server program\");\n"
"\tcmd_AddParm(ts, \"-lowThreadCount\", CMD_SINGLE, CMD_REQUIRED, \"minimum number of threads to spawn\");\n"
"\tcmd_AddParm(ts, \"-highThreadCount\", CMD_SINGLE, CMD_REQUIRED, \"maximum number of threads to spawn\");\n"
"\tcmd_AddParm(ts, \"-serverPort\", CMD_SINGLE, CMD_REQUIRED, \"port that server is using\");\n"
}
int
-MainCommand(as, arock)
- char *arock;
- struct cmd_syndesc *as;
+MainCommand(struct cmd_syndesc *as, void *arock)
{
register int i;
osi_socket s;
}
#endif
- ts = cmd_CreateSyntax(NULL, MainCommand, 0, "probe RX server");
+ ts = cmd_CreateSyntax(NULL, MainCommand, NULL, "probe RX server");
cmd_AddParm(ts, "-servers", CMD_SINGLE, CMD_REQUIRED, "server machine");
cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "IP port");
cmd_AddParm(ts, "-nodally", CMD_FLAG, CMD_OPTIONAL,
#define aKEYFILE 26
static int
-CommandProc(as, arock)
- char *arock;
- struct cmd_syndesc *as;
+CommandProc(struct cmd_syndesc *as, void *arock)
{
long code;
int startServer = (as->parms[aSERVER].items != 0);
exit(1);
}
#endif
- ts = cmd_CreateSyntax(NULL, CommandProc, 0,
+ ts = cmd_CreateSyntax(NULL, CommandProc, NULL,
"run Rx authentication stress test");
cmd_AddParm(ts, "-server", CMD_FLAG, CMD_OPTIONAL, "start server");
cmd_AddParm(ts, "-client", CMD_SINGLE, CMD_OPTIONAL, "start client");
* Initializes this program.
*------------------------------------------------------------------------*/
-static int scoutInit(as, arock)
- struct cmd_syndesc *as;
- char *arock;
-
+static int scoutInit(struct cmd_syndesc *as, void *arock)
{ /*scoutInit */
static char rn[] = "scoutInit"; /*Routine name */
/*
* Set up the commands we understand.
*/
- ts = cmd_CreateSyntax("initcmd", scoutInit, 0, "initialize the program");
+ ts = cmd_CreateSyntax("initcmd", scoutInit, NULL, "initialize the program");
cmd_AddParm(ts, "-server", CMD_LIST, CMD_REQUIRED,
"FileServer name(s) to monitor");
cmd_AddParm(ts, "-basename", CMD_SINGLE, CMD_OPTIONAL,
static char * state_code_to_string(afs_int32);
-static int OpStats(struct cmd_syndesc * as, char * rock);
-static int OpSalvage(struct cmd_syndesc * as, char * rock);
-static int OpCancel(struct cmd_syndesc * as, char * rock);
-static int OpCancelAll(struct cmd_syndesc * as, char * rock);
-static int OpRaisePrio(struct cmd_syndesc * as, char * rock);
-static int OpQuery(struct cmd_syndesc * as, char * rock);
+static int OpStats(struct cmd_syndesc * as, void * rock);
+static int OpSalvage(struct cmd_syndesc * as, void * rock);
+static int OpCancel(struct cmd_syndesc * as, void * rock);
+static int OpCancelAll(struct cmd_syndesc * as, void * rock);
+static int OpRaisePrio(struct cmd_syndesc * as, void * rock);
+static int OpQuery(struct cmd_syndesc * as, void * rock);
#ifndef AFS_NT40_ENV
}
- ts = cmd_CreateSyntax("stats", OpStats, 0, "get salvageserver statistics (SALVSYNC_NOP opcode)");
+ ts = cmd_CreateSyntax("stats", OpStats, NULL, "get salvageserver statistics (SALVSYNC_NOP opcode)");
COMMON_PARMS_DECL(ts);
cmd_CreateAlias(ts, "nop");
- ts = cmd_CreateSyntax("salvage", OpSalvage, 0, "schedule a salvage (SALVSYNC_SALVAGE opcode)");
+ ts = cmd_CreateSyntax("salvage", OpSalvage, NULL, "schedule a salvage (SALVSYNC_SALVAGE opcode)");
SALV_PARMS_DECL(ts);
- ts = cmd_CreateSyntax("cancel", OpCancel, 0, "cancel a salvage (SALVSYNC_CANCEL opcode)");
+ ts = cmd_CreateSyntax("cancel", OpCancel, NULL, "cancel a salvage (SALVSYNC_CANCEL opcode)");
SALV_PARMS_DECL(ts);
- ts = cmd_CreateSyntax("raiseprio", OpRaisePrio, 0, "raise a salvage priority (SALVSYNC_RAISEPRIO opcode)");
+ ts = cmd_CreateSyntax("raiseprio", OpRaisePrio, NULL, "raise a salvage priority (SALVSYNC_RAISEPRIO opcode)");
SALV_PARMS_DECL(ts);
cmd_CreateAlias(ts, "rp");
- ts = cmd_CreateSyntax("query", OpQuery, 0, "query salvage status (SALVSYNC_QUERY opcode)");
+ ts = cmd_CreateSyntax("query", OpQuery, NULL, "query salvage status (SALVSYNC_QUERY opcode)");
SALV_PARMS_DECL(ts);
cmd_CreateAlias(ts, "qry");
- ts = cmd_CreateSyntax("kill", OpCancelAll, 0, "cancel all scheduled salvages (SALVSYNC_CANCELALL opcode)");
+ ts = cmd_CreateSyntax("kill", OpCancelAll, NULL, "cancel all scheduled salvages (SALVSYNC_CANCELALL opcode)");
COMMON_PARMS_DECL(ts);
err = cmd_Dispatch(argc, argv);
}
static int
-OpStats(struct cmd_syndesc * as, char * rock)
+OpStats(struct cmd_syndesc * as, void * rock)
{
struct state state;
}
static int
-OpSalvage(struct cmd_syndesc * as, char * rock)
+OpSalvage(struct cmd_syndesc * as, void * rock)
{
struct state state;
}
static int
-OpCancel(struct cmd_syndesc * as, char * rock)
+OpCancel(struct cmd_syndesc * as, void * rock)
{
struct state state;
}
static int
-OpCancelAll(struct cmd_syndesc * as, char * rock)
+OpCancelAll(struct cmd_syndesc * as, void * rock)
{
struct state state;
}
static int
-OpRaisePrio(struct cmd_syndesc * as, char * rock)
+OpRaisePrio(struct cmd_syndesc * as, void * rock)
{
struct state state;
}
static int
-OpQuery(struct cmd_syndesc * as, char * rock)
+OpQuery(struct cmd_syndesc * as, void * rock)
{
struct state state;
}
static int
-CommandProc(struct cmd_syndesc *as, char *arock)
+CommandProc(struct cmd_syndesc *as, void *arock)
{
char *hostName, *portName, *times;
afs_int32 hostAddr;
nsa.sa_flags = SA_FULLDUMP;
sigaction(SIGSEGV, &nsa, NULL);
#endif
- ts = cmd_CreateSyntax(NULL, CommandProc, 0, "probe ubik server");
+ ts = cmd_CreateSyntax(NULL, CommandProc, NULL, "probe ubik server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "server machine");
cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "IP port");
cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL, "print all info");
* As advertised.
*------------------------------------------------------------------------*/
-static afs_int32
-GetCommon(a_as)
- register struct cmd_syndesc *a_as;
-
+static int
+GetCommon(register struct cmd_syndesc *a_as, void *arock)
{ /*GetCommon */
int code; /*Result of ka_LocalCell */
*------------------------------------------------------------------------*/
static int
-DelUser(a_as, a_rock)
- struct cmd_syndesc *a_as;
- char *a_rock;
-
+DelUser(struct cmd_syndesc *a_as, void *a_rock)
{ /*DelUser */
int code;
*------------------------------------------------------------------------*/
static int
-PurgeVolumes(a_as, a_rock)
- struct cmd_syndesc *a_as;
- char *a_rock;
-
+PurgeVolumes(struct cmd_syndesc *a_as, void *a_rock)
{ /*PurgeVolumes */
fprintf(stderr, "Sorry, purgevolumes has not yet been implemented.\n");
*------------------------------------------------------------------------*/
static int
-RestoreUser(a_as, a_rock)
- struct cmd_syndesc *a_as;
- char *a_rock;
-
+RestoreUser(struct cmd_syndesc *a_as, void *a_rock)
{ /*RestoreUser */
fprintf(stderr, "Sorry, restoreuser has not yet been implemented.\n");
*------------------------------------------------------------------------*/
extern int Pipe;
static int
-HandleBulk(a_as, a_rock)
- register struct cmd_syndesc *a_as;
- char *a_rock;
-
+HandleBulk(register struct cmd_syndesc *a_as, void *a_rock)
{ /*HandleBulk */
#define USS_BULK_CMD_CHARS 128
*------------------------------------------------------------------------*/
static int
-AddUser(a_as, a_rock)
- register struct cmd_syndesc *a_as;
- char *a_rock;
-
+AddUser(register struct cmd_syndesc *a_as, void *a_rock)
{ /*AddUser */
int i;
/* ----------------------------- add ----------------------------- */
- cs = cmd_CreateSyntax("add", AddUser, 0, "create a new user account");
+ cs = cmd_CreateSyntax("add", AddUser, NULL, "create a new user account");
cmd_AddParm(cs, "-user", CMD_SINGLE, 0, "login name");
cmd_AddParm(cs, "-realname", CMD_SINGLE, CMD_OPTIONAL,
"full name in quotes");
/* ---------------------------- bulk ----------------------------- */
- cs = cmd_CreateSyntax("bulk", HandleBulk, 0, "bulk input mode");
+ cs = cmd_CreateSyntax("bulk", HandleBulk, NULL, "bulk input mode");
cmd_AddParm(cs, "-file", CMD_SINGLE, 0, "bulk input file");
cmd_Seek(cs, AUSS_TEMPLATE);
cmd_AddParm(cs, "-template", CMD_SINGLE, CMD_OPTIONAL,
/* ---------------------------- delete --------------------------- */
- cs = cmd_CreateSyntax("delete", DelUser, 0, "delete a user account");
+ cs = cmd_CreateSyntax("delete", DelUser, NULL, "delete a user account");
cmd_AddParm(cs, "-user", CMD_SINGLE, 0, "login name");
cmd_AddParm(cs, "-mountpoint", CMD_SINGLE, CMD_OPTIONAL,
"mountpoint for user's volume");
#if USS_DONT_HIDE_SOME_FEATURES
/* ------------------------- purgevolumes ------------------------ */
- cs = cmd_CreateSyntax("purgevolumes", PurgeVolumes, 0,
+ cs = cmd_CreateSyntax("purgevolumes", PurgeVolumes, NULL,
"destroy a deleted user's volume");
cmd_AddParm(cs, "-volname", CMD_LIST, CMD_OPTIONAL | CMD_EXPANDS,
"Name(s) of volume(s) to destroy");
#if USS_DONT_HIDE_SOME_FEATURES
/* ---------------------------- restore -------------------------- */
- cs = cmd_CreateSyntax("restore", RestoreUser, 0,
+ cs = cmd_CreateSyntax("restore", RestoreUser, NULL,
"restore a deleted user account");
cmd_AddParm(cs, "-user", CMD_SINGLE, 0, "login name to restore");
cmd_AddParm(cs, "-uid", CMD_SINGLE, 0, "user id number");
extern int VL_GetAddrs();
-afs_int32
-InvalidateCache(as)
- struct cmd_syndesc *as;
+static int
+InvalidateCache(struct cmd_syndesc *as, void *arock)
{
afs_int32 code = 0;
struct cmd_item *u;
return code;
}
-afs_int32
-GetServerList()
+static int
+GetServerList(struct cmd_syndesc *as, void *arock)
{
- afs_int32 code;
+ int code;
int i;
code = ListServers();
Command is executed in user's cell.
*/
-static
-MyBeforeProc(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+static int
+MyBeforeProc(struct cmd_syndesc *as, void *arock)
{
register char *tcell = NULL;
char confdir[200];
cmd_SetBeforeProc(MyBeforeProc, NULL);
ts = cmd_CreateSyntax("initcmd" /*"invalidatecache" */ , InvalidateCache,
- 0, "invalidate server ACL cache");
+ NULL, "invalidate server ACL cache");
cmd_AddParm(ts, "-id", CMD_LIST, CMD_OPTIONAL, "user identifier");
cmd_AddParm(ts, "-ip", CMD_LIST, CMD_OPTIONAL, "IP address");
cmd_CreateAlias(ts, "ic");
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
- ts = cmd_CreateSyntax("listservers", GetServerList, 0,
+ ts = cmd_CreateSyntax("listservers", GetServerList, NULL,
"list servers in the cell");
cmd_CreateAlias(ts, "ls");
}
int
-CommandProc(struct cmd_syndesc *as, char *arock)
+CommandProc(struct cmd_syndesc *as, void *arock)
{
struct rx_connection *conn;
register char *hostName;
rx_Init(0);
- ts = cmd_CreateSyntax(NULL, CommandProc, 0, "probe unik server");
+ ts = cmd_CreateSyntax(NULL, CommandProc, NULL, "probe unik server");
cmd_AddParm(ts, "-servers", CMD_SINGLE, CMD_REQUIRED, "server machine");
cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "IP port");
cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL, "print all info");
return 0;
}
-static CommandProc(as)
-struct cmd_syndesc *as; {
+static int
+CommandProc(struct cmd_syndesc *as, void *arock)
+{
struct rx_connection *conn;
register char *hostName;
register struct hostent *thp;
#endif
rx_Init(0);
- ts = cmd_CreateSyntax((char *) 0, CommandProc, 0, "probe unik server");
+ ts = cmd_CreateSyntax(NULL, CommandProc, NULL, "probe unik server");
cmd_AddParm(ts, "-servers", CMD_SINGLE, CMD_REQUIRED, "server machine");
cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "IP port");
cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL, "print all info");
extern struct hostent *hostutil_GetHostByName();
-extern struct cmd_syndesc *cmd_CreateSyntax();
static char pn[] = "fs";
static int rxInitDone = 0;
static void ZapList();
static int PruneList();
static CleanAcl();
-static SetVolCmd();
+static int SetVolCmd(struct cmd_syndesc *as, void *arock);
static GetCellName();
static VLDBInit();
static void Die();
}
static int
-SetACLCmd(struct cmd_syndesc *as, char *arock)
+SetACLCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
static int
-CopyACLCmd(struct cmd_syndesc *as, char *arock)
+CopyACLCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
/* clean up an acl to not have bogus entries */
static int
-CleanACLCmd(struct cmd_syndesc *as, char *arock)
+CleanACLCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct Acl *ta = 0;
}
static int
-ListACLCmd(struct cmd_syndesc *as, char *arock)
+ListACLCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct Acl *ta;
}
static int
-GetCallerAccess(struct cmd_syndesc *as, char *arock)
+GetCallerAccess(struct cmd_syndesc *as, void *arock)
{
struct cmd_item *ti;
int error = 0;
}
static int
-FlushVolumeCmd(struct cmd_syndesc *as, char *arock)
+FlushVolumeCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
* CMD_OPTIONAL in the cmd_AddParam(-generate) call
*/
static int
-UuidCmd(struct cmd_syndesc *as, char *arock)
+UuidCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-FlushCmd(struct cmd_syndesc *as, char *arock)
+FlushCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
/* all this command does is repackage its args and call SetVolCmd */
static int
-SetQuotaCmd(struct cmd_syndesc *as, char *arock)
+SetQuotaCmd(struct cmd_syndesc *as, void *arock)
{
struct cmd_syndesc ts;
/* copy useful stuff from our command slot; we may later have to reorder */
memcpy(&ts, as, sizeof(ts)); /* copy whole thing */
- return SetVolCmd(&ts);
+ return SetVolCmd(&ts, arock);
}
static int
-SetVolCmd(struct cmd_syndesc *as, char *arock)
+SetVolCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
};
static int
-ExamineCmd(struct cmd_syndesc *as, char *arock)
+ExamineCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-ListQuotaCmd(struct cmd_syndesc *as, char *arock)
+ListQuotaCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-WhereIsCmd(struct cmd_syndesc *as, char *arock)
+WhereIsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
static int
-DiskFreeCmd(struct cmd_syndesc *as, char *arock)
+DiskFreeCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-QuotaCmd(struct cmd_syndesc *as, char *arock)
+QuotaCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-ListMountCmd(struct cmd_syndesc *as, char *arock)
+ListMountCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
return error;
}
-static
-MakeMountCmd(struct cmd_syndesc *as, char *arock)
+static int
+MakeMountCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
char *cellName, *volName, *tmpName;
* tp: Set to point to the actual name of the mount point to nuke.
*/
static int
-RemoveMountCmd(struct cmd_syndesc *as, char *arock)
+RemoveMountCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code = 0;
struct ViceIoctl blob;
*/
static int
-CheckServersCmd(struct cmd_syndesc *as, char *arock)
+CheckServersCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-MessagesCmd(struct cmd_syndesc *as, char *arock)
+MessagesCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code = 0;
struct ViceIoctl blob;
}
static int
-CheckVolumesCmd(struct cmd_syndesc *as, char *arock)
+CheckVolumesCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-SetCacheSizeCmd(struct cmd_syndesc *as, char *arock)
+SetCacheSizeCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
#define MAXGCSIZE 16
static int
-GetCacheParmsCmd(struct cmd_syndesc *as, char *arock)
+GetCacheParmsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code, filesUsed;
struct ViceIoctl blob;
}
static int
-ListCellsCmd(struct cmd_syndesc *as, char *arock)
+ListCellsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
afs_int32 i, j;
}
static int
-ListAliasesCmd(struct cmd_syndesc *as, char *arock)
+ListAliasesCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code, i;
char *tp, *aliasName, *realName;
}
static int
-CallBackRxConnCmd(struct cmd_syndesc *as, char *arock)
+CallBackRxConnCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-NukeNFSCredsCmd(struct cmd_syndesc *as, char *arock)
+NukeNFSCredsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-NewCellCmd(struct cmd_syndesc *as, char *arock)
+NewCellCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code, linkedstate = 0, size = 0, *lp;
struct ViceIoctl blob;
}
static int
-NewAliasCmd(struct cmd_syndesc *as, char *arock)
+NewAliasCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-WhichCellCmd(struct cmd_syndesc *as, char *arock)
+WhichCellCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct cmd_item *ti;
}
static int
-WSCellCmd(struct cmd_syndesc *as, char *arock)
+WSCellCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
*/
static int
-MonitorCmd(struct cmd_syndesc *as, char *arock)
+MonitorCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-SysNameCmd(struct cmd_syndesc *as, char *arock)
+SysNameCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
static char *exported_types[] = { "null", "nfs", "" };
static int
-ExportAfsCmd(struct cmd_syndesc *as, char *arock)
+ExportAfsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
static int
-GetCellCmd(struct cmd_syndesc *as, char *arock)
+GetCellCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-SetCellCmd(struct cmd_syndesc *as, char *arock)
+SetCellCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
static int
-SetPrefCmd(struct cmd_syndesc *as, char *arock)
+SetPrefCmd(struct cmd_syndesc *as, void *arock)
{
FILE *infd;
afs_int32 code;
static int
-GetPrefCmd(struct cmd_syndesc *as, char *arock)
+GetPrefCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct cmd_item *ti;
}
static int
-StoreBehindCmd(struct cmd_syndesc *as, char *arock)
+StoreBehindCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code = 0;
struct ViceIoctl blob;
}
-static afs_int32
-SetCryptCmd(struct cmd_syndesc *as, char *arock)
+static int
+SetCryptCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code = 0, flag;
struct ViceIoctl blob;
}
-static afs_int32
-GetCryptCmd(struct cmd_syndesc *as, char *arock)
+static int
+GetCryptCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code = 0, flag;
struct ViceIoctl blob;
NULL
};
-static afs_int32
-DisconCmd(struct cmd_syndesc *as, char *arock)
+static int
+DisconCmd(struct cmd_syndesc *as, void *arock)
{
struct cmd_item *ti;
char *modename;
#endif
/* try to find volume location information */
- ts = cmd_CreateSyntax("getclientaddrs", GetClientAddrsCmd, 0,
+ ts = cmd_CreateSyntax("getclientaddrs", GetClientAddrsCmd, NULL,
"get client network interface addresses");
cmd_CreateAlias(ts, "gc");
- ts = cmd_CreateSyntax("setclientaddrs", SetClientAddrsCmd, 0,
+ ts = cmd_CreateSyntax("setclientaddrs", SetClientAddrsCmd, NULL,
"set client network interface addresses");
cmd_AddParm(ts, "-address", CMD_LIST, CMD_OPTIONAL | CMD_EXPANDS,
"client network interfaces");
cmd_CreateAlias(ts, "sc");
- ts = cmd_CreateSyntax("setserverprefs", SetPrefCmd, 0,
+ ts = cmd_CreateSyntax("setserverprefs", SetPrefCmd, NULL,
"set server ranks");
cmd_AddParm(ts, "-servers", CMD_LIST, CMD_OPTIONAL | CMD_EXPANDS,
"fileserver names and ranks");
cmd_AddParm(ts, "-stdin", CMD_FLAG, CMD_OPTIONAL, "input from stdin");
cmd_CreateAlias(ts, "sp");
- ts = cmd_CreateSyntax("getserverprefs", GetPrefCmd, 0,
+ ts = cmd_CreateSyntax("getserverprefs", GetPrefCmd, NULL,
"get server ranks");
cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_OPTIONAL,
"output to named file");
/* cmd_AddParm(ts, "-cell", CMD_FLAG, CMD_OPTIONAL, "cellname"); */
cmd_CreateAlias(ts, "gp");
- ts = cmd_CreateSyntax("setacl", SetACLCmd, 0, "set access control list");
+ ts = cmd_CreateSyntax("setacl", SetACLCmd, NULL, "set access control list");
cmd_AddParm(ts, "-dir", CMD_LIST, 0, "directory");
cmd_AddParm(ts, "-acl", CMD_LIST, 0, "access list entries");
cmd_AddParm(ts, "-clear", CMD_FLAG, CMD_OPTIONAL, "clear access list");
"initial file acl (DFS only)");
cmd_CreateAlias(ts, "sa");
- ts = cmd_CreateSyntax("listacl", ListACLCmd, 0,
+ ts = cmd_CreateSyntax("listacl", ListACLCmd, NULL,
"list access control list");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
parm_listacl_id = ts->nParms;
cmd_AddParm(ts, "-if", CMD_FLAG, CMD_OPTIONAL, "initial file acl");
cmd_CreateAlias(ts, "la");
- ts = cmd_CreateSyntax("getcalleraccess", GetCallerAccess, 0,
+ ts = cmd_CreateSyntax("getcalleraccess", GetCallerAccess, NULL,
"list callers access");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
cmd_CreateAlias(ts, "gca");
- ts = cmd_CreateSyntax("cleanacl", CleanACLCmd, 0,
+ ts = cmd_CreateSyntax("cleanacl", CleanACLCmd, NULL,
"clean up access control list");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
- ts = cmd_CreateSyntax("copyacl", CopyACLCmd, 0,
+ ts = cmd_CreateSyntax("copyacl", CopyACLCmd, NULL,
"copy access control list");
cmd_AddParm(ts, "-fromdir", CMD_SINGLE, 0,
"source directory (or DFS file)");
cmd_CreateAlias(ts, "ca");
- ts = cmd_CreateSyntax("flush", FlushCmd, 0, "flush file from cache");
+ ts = cmd_CreateSyntax("flush", FlushCmd, NULL, "flush file from cache");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
- ts = cmd_CreateSyntax("flushmount", FlushMountCmd, 0,
+ ts = cmd_CreateSyntax("flushmount", FlushMountCmd, NULL,
"flush mount symlink from cache");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
- ts = cmd_CreateSyntax("setvol", SetVolCmd, 0, "set volume status");
+ ts = cmd_CreateSyntax("setvol", SetVolCmd, NULL, "set volume status");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
cmd_AddParm(ts, "-max", CMD_SINGLE, CMD_OPTIONAL,
"disk space quota in 1K units");
"offline message");
cmd_CreateAlias(ts, "sv");
- ts = cmd_CreateSyntax("messages", MessagesCmd, 0,
+ ts = cmd_CreateSyntax("messages", MessagesCmd, NULL,
"control Cache Manager messages");
cmd_AddParm(ts, "-show", CMD_SINGLE, CMD_OPTIONAL,
"[user|console|all|none]");
- ts = cmd_CreateSyntax("examine", ExamineCmd, 0, "display file/volume status");
+ ts = cmd_CreateSyntax("examine", ExamineCmd, NULL, "display file/volume status");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
cmd_CreateAlias(ts, "lv");
cmd_CreateAlias(ts, "listvol");
- ts = cmd_CreateSyntax("listquota", ListQuotaCmd, 0, "list volume quota");
+ ts = cmd_CreateSyntax("listquota", ListQuotaCmd, NULL, "list volume quota");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
cmd_CreateAlias(ts, "lq");
- ts = cmd_CreateSyntax("diskfree", DiskFreeCmd, 0,
+ ts = cmd_CreateSyntax("diskfree", DiskFreeCmd, NULL,
"show server disk space usage");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
cmd_CreateAlias(ts, "df");
- ts = cmd_CreateSyntax("quota", QuotaCmd, 0, "show volume quota usage");
+ ts = cmd_CreateSyntax("quota", QuotaCmd, NULL, "show volume quota usage");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
- ts = cmd_CreateSyntax("lsmount", ListMountCmd, 0, "list mount point");
+ ts = cmd_CreateSyntax("lsmount", ListMountCmd, NULL, "list mount point");
cmd_AddParm(ts, "-dir", CMD_LIST, 0, "directory");
- ts = cmd_CreateSyntax("mkmount", MakeMountCmd, 0, "make mount point");
+ ts = cmd_CreateSyntax("mkmount", MakeMountCmd, NULL, "make mount point");
cmd_AddParm(ts, "-dir", CMD_SINGLE, 0, "directory");
cmd_AddParm(ts, "-vol", CMD_SINGLE, 0, "volume name");
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
*/
- ts = cmd_CreateSyntax("rmmount", RemoveMountCmd, 0, "remove mount point");
+ ts = cmd_CreateSyntax("rmmount", RemoveMountCmd, NULL, "remove mount point");
cmd_AddParm(ts, "-dir", CMD_LIST, 0, "directory");
- ts = cmd_CreateSyntax("checkservers", CheckServersCmd, 0,
+ ts = cmd_CreateSyntax("checkservers", CheckServersCmd, NULL,
"check local cell's servers");
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell to check");
cmd_AddParm(ts, "-all", CMD_FLAG, CMD_OPTIONAL, "check all cells");
cmd_AddParm(ts, "-interval", CMD_SINGLE, CMD_OPTIONAL,
"seconds between probes");
- ts = cmd_CreateSyntax("checkvolumes", CheckVolumesCmd, 0,
+ ts = cmd_CreateSyntax("checkvolumes", CheckVolumesCmd, NULL,
"check volumeID/name mappings");
cmd_CreateAlias(ts, "checkbackups");
- ts = cmd_CreateSyntax("setcachesize", SetCacheSizeCmd, 0,
+ ts = cmd_CreateSyntax("setcachesize", SetCacheSizeCmd, NULL,
"set cache size");
cmd_AddParm(ts, "-blocks", CMD_SINGLE, CMD_OPTIONAL,
"size in 1K byte blocks (0 => reset)");
cmd_AddParm(ts, "-reset", CMD_FLAG, CMD_OPTIONAL,
"reset size back to boot value");
- ts = cmd_CreateSyntax("getcacheparms", GetCacheParmsCmd, 0,
+ ts = cmd_CreateSyntax("getcacheparms", GetCacheParmsCmd, NULL,
"get cache usage info");
cmd_AddParm(ts, "-files", CMD_FLAG, CMD_OPTIONAL, "Show cach files used as well");
cmd_AddParm(ts, "-excessive", CMD_FLAG, CMD_OPTIONAL, "excessively verbose cache stats");
- ts = cmd_CreateSyntax("listcells", ListCellsCmd, 0,
+ ts = cmd_CreateSyntax("listcells", ListCellsCmd, NULL,
"list configured cells");
cmd_AddParm(ts, "-numeric", CMD_FLAG, CMD_OPTIONAL, "addresses only");
- ts = cmd_CreateSyntax("listaliases", ListAliasesCmd, 0,
+ ts = cmd_CreateSyntax("listaliases", ListAliasesCmd, NULL,
"list configured cell aliases");
- ts = cmd_CreateSyntax("setquota", SetQuotaCmd, 0, "set volume quota");
+ ts = cmd_CreateSyntax("setquota", SetQuotaCmd, NULL, "set volume quota");
cmd_AddParm(ts, "-path", CMD_SINGLE, CMD_OPTIONAL, "dir/file path");
cmd_AddParm(ts, "-max", CMD_SINGLE, 0, "max quota in kbytes");
#ifdef notdef
#endif
cmd_CreateAlias(ts, "sq");
- ts = cmd_CreateSyntax("newcell", NewCellCmd, 0, "configure new cell");
+ ts = cmd_CreateSyntax("newcell", NewCellCmd, NULL, "configure new cell");
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "cell name");
cmd_AddParm(ts, "-servers", CMD_LIST, CMD_REQUIRED, "primary servers");
cmd_AddParm(ts, "-linkedcell", CMD_SINGLE, CMD_OPTIONAL,
"linked cell name");
- ts = cmd_CreateSyntax("newalias", NewAliasCmd, 0,
+ ts = cmd_CreateSyntax("newalias", NewAliasCmd, NULL,
"configure new cell alias");
cmd_AddParm(ts, "-alias", CMD_SINGLE, 0, "alias name");
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "real name of cell");
"cell's vldb server port");
#endif
- ts = cmd_CreateSyntax("whichcell", WhichCellCmd, 0, "list file's cell");
+ ts = cmd_CreateSyntax("whichcell", WhichCellCmd, NULL, "list file's cell");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
- ts = cmd_CreateSyntax("whereis", WhereIsCmd, 0, "list file's location");
+ ts = cmd_CreateSyntax("whereis", WhereIsCmd, NULL, "list file's location");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
- ts = cmd_CreateSyntax("wscell", WSCellCmd, 0, "list workstation's cell");
+ ts = cmd_CreateSyntax("wscell", WSCellCmd, NULL, "list workstation's cell");
/*
- ts = cmd_CreateSyntax("primarycell", PrimaryCellCmd, 0, "obsolete (listed primary cell)");
+ ts = cmd_CreateSyntax("primarycell", PrimaryCellCmd, NULL, "obsolete (listed primary cell)");
*/
/* set cache monitor host address */
- ts = cmd_CreateSyntax("monitor", MonitorCmd, 0, (char *)CMD_HIDDEN);
+ ts = cmd_CreateSyntax("monitor", MonitorCmd, NULL, (char *)CMD_HIDDEN);
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL,
"host name or 'off'");
cmd_CreateAlias(ts, "mariner");
- ts = cmd_CreateSyntax("getcellstatus", GetCellCmd, 0, "get cell status");
+ ts = cmd_CreateSyntax("getcellstatus", GetCellCmd, NULL, "get cell status");
cmd_AddParm(ts, "-cell", CMD_LIST, 0, "cell name");
- ts = cmd_CreateSyntax("setcell", SetCellCmd, 0, "set cell status");
+ ts = cmd_CreateSyntax("setcell", SetCellCmd, NULL, "set cell status");
cmd_AddParm(ts, "-cell", CMD_LIST, 0, "cell name");
cmd_AddParm(ts, "-suid", CMD_FLAG, CMD_OPTIONAL, "allow setuid programs");
cmd_AddParm(ts, "-nosuid", CMD_FLAG, CMD_OPTIONAL,
"disallow setuid programs");
- ts = cmd_CreateSyntax("flushvolume", FlushVolumeCmd, 0,
+ ts = cmd_CreateSyntax("flushvolume", FlushVolumeCmd, NULL,
"flush all data in volume");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
- ts = cmd_CreateSyntax("sysname", SysNameCmd, 0,
+ ts = cmd_CreateSyntax("sysname", SysNameCmd, NULL,
"get/set sysname (i.e. @sys) value");
cmd_AddParm(ts, "-newsys", CMD_LIST, CMD_OPTIONAL, "new sysname");
- ts = cmd_CreateSyntax("exportafs", ExportAfsCmd, 0,
+ ts = cmd_CreateSyntax("exportafs", ExportAfsCmd, NULL,
"enable/disable translators to AFS");
cmd_AddParm(ts, "-type", CMD_SINGLE, 0, "exporter name");
cmd_AddParm(ts, "-start", CMD_SINGLE, CMD_OPTIONAL,
"enable callbacks to get creds from new clients (on | off)");
- ts = cmd_CreateSyntax("storebehind", StoreBehindCmd, 0,
+ ts = cmd_CreateSyntax("storebehind", StoreBehindCmd, NULL,
"store to server after file close");
cmd_AddParm(ts, "-kbytes", CMD_SINGLE, CMD_OPTIONAL,
"asynchrony for specified names");
cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, "show status");
cmd_CreateAlias(ts, "sb");
- ts = cmd_CreateSyntax("setcrypt", SetCryptCmd, 0,
+ ts = cmd_CreateSyntax("setcrypt", SetCryptCmd, NULL,
"set cache manager encryption flag");
cmd_AddParm(ts, "-crypt", CMD_SINGLE, 0, "on or off");
- ts = cmd_CreateSyntax("getcrypt", GetCryptCmd, 0,
+ ts = cmd_CreateSyntax("getcrypt", GetCryptCmd, NULL,
"get cache manager encryption flag");
- ts = cmd_CreateSyntax("rxstatproc", RxStatProcCmd, 0,
+ ts = cmd_CreateSyntax("rxstatproc", RxStatProcCmd, NULL,
"Manage per process RX statistics");
cmd_AddParm(ts, "-enable", CMD_FLAG, CMD_OPTIONAL, "Enable RX stats");
cmd_AddParm(ts, "-disable", CMD_FLAG, CMD_OPTIONAL, "Disable RX stats");
cmd_AddParm(ts, "-clear", CMD_FLAG, CMD_OPTIONAL, "Clear RX stats");
- ts = cmd_CreateSyntax("rxstatpeer", RxStatPeerCmd, 0,
+ ts = cmd_CreateSyntax("rxstatpeer", RxStatPeerCmd, NULL,
"Manage per peer RX statistics");
cmd_AddParm(ts, "-enable", CMD_FLAG, CMD_OPTIONAL, "Enable RX stats");
cmd_AddParm(ts, "-disable", CMD_FLAG, CMD_OPTIONAL, "Disable RX stats");
cmd_AddParm(ts, "-clear", CMD_FLAG, CMD_OPTIONAL, "Clear RX stats");
- ts = cmd_CreateSyntax("setcbaddr", CallBackRxConnCmd, 0, "configure callback connection address");
+ ts = cmd_CreateSyntax("setcbaddr", CallBackRxConnCmd, NULL, "configure callback connection address");
cmd_AddParm(ts, "-addr", CMD_SINGLE, CMD_OPTIONAL, "host name or address");
/* try to find volume location information */
- ts = cmd_CreateSyntax("getfid", GetFidCmd, 0,
+ ts = cmd_CreateSyntax("getfid", GetFidCmd, NULL,
"get fid for file(s)");
cmd_AddParm(ts, "-path", CMD_LIST, CMD_OPTIONAL, "dir/file path");
#ifdef AFS_DISCON_ENV
- ts = cmd_CreateSyntax("discon", DisconCmd, 0,
+ ts = cmd_CreateSyntax("discon", DisconCmd, NULL,
"disconnection mode");
cmd_AddParm(ts, "-mode", CMD_SINGLE, CMD_OPTIONAL, "nat | full");
#endif
- ts = cmd_CreateSyntax("nukenfscreds", NukeNFSCredsCmd, 0, "nuke credentials for NFS client");
+ ts = cmd_CreateSyntax("nukenfscreds", NukeNFSCredsCmd, NULL, "nuke credentials for NFS client");
cmd_AddParm(ts, "-addr", CMD_SINGLE, 0, "host name or address");
- ts = cmd_CreateSyntax("uuid", UuidCmd, 0, "manage the UUID for the cache manager");
+ ts = cmd_CreateSyntax("uuid", UuidCmd, NULL, "manage the UUID for the cache manager");
cmd_AddParm(ts, "-generate", CMD_FLAG, CMD_REQUIRED, "generate a new UUID");
code = cmd_Dispatch(argc, argv);
/* get clients interface addresses */
static int
-GetClientAddrsCmd(struct cmd_syndesc *as, char *arock)
+GetClientAddrsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct cmd_item *ti;
}
static int
-SetClientAddrsCmd(struct cmd_syndesc *as, char *arock)
+SetClientAddrsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code, addr;
struct cmd_item *ti;
}
static int
-FlushMountCmd(struct cmd_syndesc *as, char *arock)
+FlushMountCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
}
static int
-RxStatProcCmd(struct cmd_syndesc *as, char *arock)
+RxStatProcCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
afs_int32 flags = 0;
}
static int
-RxStatPeerCmd(struct cmd_syndesc *as, char *arock)
+RxStatPeerCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
afs_int32 flags = 0;
}
static int
-GetFidCmd(struct cmd_syndesc *as, char *arock)
+GetFidCmd(struct cmd_syndesc *as, void *arock)
{
struct ViceIoctl blob;
struct cmd_item *ti;
}
-static
-DoDump(as, arock)
- register struct cmd_syndesc *as;
- char *arock;
+static int
+DoDump(struct cmd_syndesc *as, void *arock)
{
afs_int32 code = 0;
afs_int32 tcode;
struct cmd_syndesc *dumpSyntax;
dumpSyntax =
- cmd_CreateSyntax("dump", DoDump, (char *)NULL, "dump AFS trace logs");
+ cmd_CreateSyntax("dump", DoDump, NULL, "dump AFS trace logs");
(void)cmd_AddParm(dumpSyntax, "-set", CMD_LIST, CMD_OPTIONAL, "set_name");
(void)cmd_AddParm(dumpSyntax, "-follow", CMD_SINGLE, CMD_OPTIONAL,
"log_name");
"seconds_between_reads");
}
-static
-DoShowLog(as, arock)
- register struct cmd_syndesc *as;
- char *arock;
+static int
+DoShowLog(register struct cmd_syndesc *as, void *arock)
{
afs_int32 retVal = 0;
afs_int32 code = 0;
struct cmd_syndesc *showSyntax;
showSyntax =
- cmd_CreateSyntax("lslog", DoShowLog, (char *)NULL,
+ cmd_CreateSyntax("lslog", DoShowLog, NULL,
"list available logs");
(void)cmd_AddParm(showSyntax, "-set", CMD_LIST, CMD_OPTIONAL, "set_name");
(void)cmd_AddParm(showSyntax, "-log", CMD_LIST, CMD_OPTIONAL, "log_name");
(void)cmd_AddParm(showSyntax, "-long", CMD_FLAG, CMD_OPTIONAL, "");
}
-static
-DoShowSet(as, arock)
- register struct cmd_syndesc *as;
- char *arock;
+static int
+DoShowSet(register struct cmd_syndesc *as, void *arock)
{
afs_int32 retVal = 0;
afs_int32 code = 0;
struct cmd_syndesc *showSyntax;
showSyntax =
- cmd_CreateSyntax("lsset", DoShowSet, (char *)NULL,
+ cmd_CreateSyntax("lsset", DoShowSet, NULL,
"list available event sets");
(void)cmd_AddParm(showSyntax, "-set", CMD_LIST, CMD_OPTIONAL, "set_name");
}
-static
-DoClear(as, arock)
- register struct cmd_syndesc *as;
- char *arock;
+static int
+DoClear(register struct cmd_syndesc *as, void *arock)
{
afs_int32 retVal = 0;
afs_int32 code = 0;
struct cmd_syndesc *clearSyntax;
clearSyntax =
- cmd_CreateSyntax("clear", DoClear, (char *)NULL,
+ cmd_CreateSyntax("clear", DoClear, NULL,
"clear logs by logname or by event set");
(void)cmd_AddParm(clearSyntax, "-set", CMD_LIST, CMD_OPTIONAL,
"set_name");
"log_name");
}
-static
-DoSet(as, arock)
- register struct cmd_syndesc *as;
- char *arock;
+static int
+DoSet(register struct cmd_syndesc *as, void *arock)
{
afs_int32 retVal = 0;
afs_int32 code = 0;
struct cmd_syndesc *setSyntax;
setSyntax =
- cmd_CreateSyntax("setset", DoSet, (char *)NULL,
+ cmd_CreateSyntax("setset", DoSet, NULL,
"set state of event sets");
(void)cmd_AddParm(setSyntax, "-set", CMD_LIST, CMD_OPTIONAL, "set_name");
(void)cmd_AddParm(setSyntax, "-active", CMD_FLAG, CMD_OPTIONAL, "");
(void)cmd_AddParm(setSyntax, "-dormant", CMD_FLAG, CMD_OPTIONAL, "");
}
-static
-DoResize(as, arock)
- register struct cmd_syndesc *as;
- char *arock;
+static int
+DoResize(register struct cmd_syndesc *as, void *arock)
{
afs_int32 retVal = 0;
afs_int32 code = 0;
struct cmd_syndesc *setsizeSyntax;
setsizeSyntax =
- cmd_CreateSyntax("setlog", DoResize, (char *)NULL,
+ cmd_CreateSyntax("setlog", DoResize, NULL,
"set the size of a log");
(void)cmd_AddParm(setsizeSyntax, "-log", CMD_LIST, CMD_OPTIONAL,
"log_name");
-#ifndef AFS_KDUMP_LIB
-extern struct cmd_syndesc *cmd_CreateSyntax();
-#endif
int opencore();
#if defined(AFS_HPUX_ENV) && defined(__LP64__)
#ifndef AFS_KDUMP_LIB
-static
-cmdproc(as, arock)
- register struct cmd_syndesc *as;
- afs_int32 arock;
+static int
+cmdproc(register struct cmd_syndesc *as, void *arock)
{
register afs_int32 code = 0;
sigaction(SIGSEGV, &nsa, NULL);
#endif
- ts = cmd_CreateSyntax(NULL, cmdproc, 0,
+ ts = cmd_CreateSyntax(NULL, cmdproc, NULL,
"Read internal cache manager structs");
cmd_AddParm(ts, "-kobj", CMD_SINGLE, CMD_OPTIONAL,
"kernel object (default /vmunix)");
int
-GetInitParamsCmd(struct cmd_syndesc *as)
+GetInitParamsCmd(struct cmd_syndesc *as, void *arock)
{
struct cm_initparams cm_initParams;
struct ViceIoctl blob;
#undef VICE
#include "afs/prs_fs.h"
#include <afs/afsint.h>
-#include <errno.h
+#include <errno.h>
#include <afs/cellconfig.h>
#include <afs/cmd.h>
#include <strings.h>
static struct ubik_client *uclient;
-extern struct cmd_syndesc *cmd_CreateSyntax();
static char pn[] = "fs";
static int rxInitDone = 0;
-static
-Twiddle(as)
- struct cmd_syndesc *as;
+static int
+Twiddle(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
struct ViceIoctl blob;
/* try to find volume location information */
- ts = cmd_CreateSyntax(NULL, Twiddle, 0, "adjust rx parms");
+ ts = cmd_CreateSyntax(NULL, Twiddle, NULL, "adjust rx parms");
cmd_AddParm(ts, "-initReceiveWindow ", CMD_SINGLE, CMD_OPTIONAL, "16");
cmd_AddParm(ts, "-maxReceiveWindow ", CMD_SINGLE, CMD_OPTIONAL, "16");
cmd_AddParm(ts, "-initSendWindow ", CMD_SINGLE, CMD_OPTIONAL, "8");
int WhatFidCmd_FileParm;
int WhatFidCmd_FollowLinkParm;
int
-WhatFidCmd(as)
- register struct cmd_syndesc *as;
+WhatFidCmd(register struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
struct ViceIoctl blob;
pn = argv[0];
- ts = cmd_CreateSyntax("initcmd", WhatFidCmd, 0, "list fid for file(s)");
+ ts = cmd_CreateSyntax("initcmd", WhatFidCmd, NULL, "list fid for file(s)");
WhatFidCmd_FileParm = cmd_AddParm(ts, "-path", CMD_LIST, 0, "pathnames");
WhatFidCmd_FollowLinkParm =
cmd_AddParm(ts, "-link", CMD_FLAG, CMD_OPTIONAL,
#define BADSERVERID 255 /* XXX */
-extern struct cmd_syndesc *cmd_CreateSyntax();
static char pn[] = "cnvldb";
static char tempname[] = "XXnewvldb";
static char space[MAXSIZE];
char *pathname = NULL;
const char *dbPath;
-static
-handleit(as)
- struct cmd_syndesc *as;
+static int
+handleit(struct cmd_syndesc *as, void *arock)
{
register struct cmd_item *ti;
register afs_int32 code;
register struct cmd_syndesc *ts;
afs_int32 code;
- ts = cmd_CreateSyntax("initcmd", handleit, 0, "optional");
+ ts = cmd_CreateSyntax("initcmd", handleit, NULL, "optional");
cmd_AddParm(ts, "-to", CMD_SINGLE, CMD_OPTIONAL, "goal version");
cmd_AddParm(ts, "-from", CMD_SINGLE, CMD_OPTIONAL, "current version");
cmd_AddParm(ts, "-path", CMD_SINGLE, CMD_OPTIONAL, "pathname");
#include "cnvldb.h" /* CHANGEME! */
#include <netinet/in.h>
#include <afs/venus.h>
+#include <afs/cmd.h>
#ifdef notdef
#include <afs/vice.h>
#define MAXSIZE 2048 /* most I'll get back from PIOCTL */
-extern struct cmd_syndesc *cmd_CreateSyntax();
static char pn[] = "cnvldb";
static char tempname[] = "XXnewvldb";
static char space[MAXSIZE];
}
-static
-ListQuotaCmd(as)
- register struct cmd_syndesc *as;
+static int
+ListQuotaCmd(register struct cmd_syndesc *as, void *arock)
{
register afs_int32 code;
struct ViceIoctl blob;
}
-static
-handleit(as)
- struct cmd_syndesc *as;
+static int
+handleit(struct cmd_syndesc *as, void *arock)
{
register struct cmd_item *ti;
register afs_int32 code, server = 0, sawserver = 0;
afs_int32 code;
strcpy(confdir, AFSDIR_CLIENT_ETC_DIRPATH);
- ts = cmd_CreateSyntax("initcmd", handleit, 0, "initialize the program");
+ ts = cmd_CreateSyntax("initcmd", handleit, NULL, "initialize the program");
cmd_AddParm(ts, "-cellpath", CMD_LIST, CMD_OPTIONAL,
"Cell configuration directory");
cmd_AddParm(ts, "-server", CMD_LIST, CMD_OPTIONAL,
}
int
-WorkerBee(struct cmd_syndesc *as, char *arock)
+WorkerBee(struct cmd_syndesc *as, void *arock)
{
char *dbfile;
afs_int32 maxentries, type, tmp;
static char * reason_code_to_string(afs_int32);
static char * program_type_to_string(afs_int32);
-static int VolOnline(struct cmd_syndesc * as, char * rock);
-static int VolOffline(struct cmd_syndesc * as, char * rock);
-static int VolMode(struct cmd_syndesc * as, char * rock);
-static int VolDetach(struct cmd_syndesc * as, char * rock);
-static int VolBreakCBKs(struct cmd_syndesc * as, char * rock);
-static int VolMove(struct cmd_syndesc * as, char * rock);
-static int VolList(struct cmd_syndesc * as, char * rock);
-static int VolQuery(struct cmd_syndesc * as, char * rock);
-static int VolHdrQuery(struct cmd_syndesc * as, char * rock);
-static int VolOpQuery(struct cmd_syndesc * as, char * rock);
-static int StatsQuery(struct cmd_syndesc * as, char * rock);
+static int VolOnline(struct cmd_syndesc * as, void * rock);
+static int VolOffline(struct cmd_syndesc * as, void * rock);
+static int VolMode(struct cmd_syndesc * as, void * rock);
+static int VolDetach(struct cmd_syndesc * as, void * rock);
+static int VolBreakCBKs(struct cmd_syndesc * as, void * rock);
+static int VolMove(struct cmd_syndesc * as, void * rock);
+static int VolList(struct cmd_syndesc * as, void * rock);
+static int VolQuery(struct cmd_syndesc * as, void * rock);
+static int VolHdrQuery(struct cmd_syndesc * as, void * rock);
+static int VolOpQuery(struct cmd_syndesc * as, void * rock);
+static int StatsQuery(struct cmd_syndesc * as, void * rock);
static void print_vol_stats_general(VolPkgStats * stats);
}
- ts = cmd_CreateSyntax("online", VolOnline, 0, "bring a volume online (FSYNC_VOL_ON opcode)");
+ ts = cmd_CreateSyntax("online", VolOnline, NULL, "bring a volume online (FSYNC_VOL_ON opcode)");
VOLOP_PARMS_DECL(ts);
- ts = cmd_CreateSyntax("offline", VolOffline, 0, "take a volume offline (FSYNC_VOL_OFF opcode)");
+ ts = cmd_CreateSyntax("offline", VolOffline, NULL, "take a volume offline (FSYNC_VOL_OFF opcode)");
VOLOP_PARMS_DECL(ts);
- ts = cmd_CreateSyntax("mode", VolMode, 0, "change volume attach mode (FSYNC_VOL_NEEDVOLUME opcode)");
+ ts = cmd_CreateSyntax("mode", VolMode, NULL, "change volume attach mode (FSYNC_VOL_NEEDVOLUME opcode)");
VOLOP_PARMS_DECL(ts);
cmd_CreateAlias(ts, "needvolume");
- ts = cmd_CreateSyntax("detach", VolDetach, 0, "detach a volume (FSYNC_VOL_DONE opcode)");
+ ts = cmd_CreateSyntax("detach", VolDetach, NULL, "detach a volume (FSYNC_VOL_DONE opcode)");
VOLOP_PARMS_DECL(ts);
- ts = cmd_CreateSyntax("callback", VolBreakCBKs, 0, "break callbacks for volume (FSYNC_VOL_BREAKCBKS opcode)");
+ ts = cmd_CreateSyntax("callback", VolBreakCBKs, NULL, "break callbacks for volume (FSYNC_VOL_BREAKCBKS opcode)");
VOLOP_PARMS_DECL(ts);
cmd_CreateAlias(ts, "cbk");
- ts = cmd_CreateSyntax("move", VolMove, 0, "set volume moved flag (FSYNC_VOL_MOVE opcode)");
+ ts = cmd_CreateSyntax("move", VolMove, NULL, "set volume moved flag (FSYNC_VOL_MOVE opcode)");
VOLOP_PARMS_DECL(ts);
- ts = cmd_CreateSyntax("list", VolList, 0, "sync local volume list (FSYNC_VOL_LISTVOLUMES opcode)");
+ ts = cmd_CreateSyntax("list", VolList, NULL, "sync local volume list (FSYNC_VOL_LISTVOLUMES opcode)");
VOLOP_PARMS_DECL(ts);
cmd_CreateAlias(ts, "ls");
- ts = cmd_CreateSyntax("query", VolQuery, 0, "get volume structure (FSYNC_VOL_QUERY opcode)");
+ ts = cmd_CreateSyntax("query", VolQuery, NULL, "get volume structure (FSYNC_VOL_QUERY opcode)");
VOLOP_PARMS_DECL(ts);
cmd_CreateAlias(ts, "qry");
- ts = cmd_CreateSyntax("header", VolHdrQuery, 0, "get volume disk data structure (FSYNC_VOL_QUERY_HDR opcode)");
+ ts = cmd_CreateSyntax("header", VolHdrQuery, NULL, "get volume disk data structure (FSYNC_VOL_QUERY_HDR opcode)");
VOLOP_PARMS_DECL(ts);
cmd_CreateAlias(ts, "hdr");
- ts = cmd_CreateSyntax("volop", VolOpQuery, 0, "get pending volume operation info (FSYNC_VOL_QUERY_VOP opcode)");
+ ts = cmd_CreateSyntax("volop", VolOpQuery, NULL, "get pending volume operation info (FSYNC_VOL_QUERY_VOP opcode)");
VOLOP_PARMS_DECL(ts);
cmd_CreateAlias(ts, "vop");
- ts = cmd_CreateSyntax("stats", StatsQuery, 0, "see 'stats help' for more information");
+ ts = cmd_CreateSyntax("stats", StatsQuery, NULL, "see 'stats help' for more information");
cmd_Seek(ts, CUSTOM_PARMS_OFFSET);
cmd_AddParm(ts, "-cmd", CMD_SINGLE, 0, "subcommand");
cmd_AddParm(ts, "-arg1", CMD_SINGLE, CMD_OPTIONAL, "arg1");
}
static int
-VolOnline(struct cmd_syndesc * as, char * rock)
+VolOnline(struct cmd_syndesc * as, void * rock)
{
struct state state;
}
static int
-VolOffline(struct cmd_syndesc * as, char * rock)
+VolOffline(struct cmd_syndesc * as, void * rock)
{
struct state state;
}
static int
-VolMode(struct cmd_syndesc * as, char * rock)
+VolMode(struct cmd_syndesc * as, void * rock)
{
struct state state;
}
static int
-VolDetach(struct cmd_syndesc * as, char * rock)
+VolDetach(struct cmd_syndesc * as, void * rock)
{
struct state state;
}
static int
-VolBreakCBKs(struct cmd_syndesc * as, char * rock)
+VolBreakCBKs(struct cmd_syndesc * as, void * rock)
{
struct state state;
}
static int
-VolMove(struct cmd_syndesc * as, char * rock)
+VolMove(struct cmd_syndesc * as, void * rock)
{
struct state state;
}
static int
-VolList(struct cmd_syndesc * as, char * rock)
+VolList(struct cmd_syndesc * as, void * rock)
{
struct state state;
#endif
static int
-VolQuery(struct cmd_syndesc * as, char * rock)
+VolQuery(struct cmd_syndesc * as, void * rock)
{
struct state state;
SYNC_PROTO_BUF_DECL(res_buf);
}
static int
-VolHdrQuery(struct cmd_syndesc * as, char * rock)
+VolHdrQuery(struct cmd_syndesc * as, void * rock)
{
struct state state;
SYNC_PROTO_BUF_DECL(res_buf);
}
static int
-VolOpQuery(struct cmd_syndesc * as, char * rock)
+VolOpQuery(struct cmd_syndesc * as, void * rock)
{
struct state state;
SYNC_PROTO_BUF_DECL(res_buf);
}
static int
-StatsQuery(struct cmd_syndesc * as, char * rock)
+StatsQuery(struct cmd_syndesc * as, void * rock)
{
afs_int32 code;
int command;
#define DEFAULT_PARALLELISM 4 /* allow 4 parallel salvage workers by default */
static int
-handleit(struct cmd_syndesc *as)
+handleit(struct cmd_syndesc *as, void *arock)
{
register struct cmd_item *ti;
char pname[100], *temp;
}
#endif
- ts = cmd_CreateSyntax("initcmd", handleit, 0, "initialize the program");
+ ts = cmd_CreateSyntax("initcmd", handleit, NULL, "initialize the program");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
"Name of partition to salvage");
cmd_AddParm(ts, "-volumeid", CMD_SINGLE, CMD_OPTIONAL,
static int
-handleit(struct cmd_syndesc *as)
+handleit(struct cmd_syndesc *as, void *arock)
{
register struct cmd_item *ti;
char pname[100], *temp;
}
#endif
- ts = cmd_CreateSyntax("initcmd", handleit, 0, "initialize the program");
+ ts = cmd_CreateSyntax("initcmd", handleit, NULL, "initialize the program");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
"Name of partition to salvage");
cmd_AddParm(ts, "-volumeid", CMD_SINGLE, CMD_OPTIONAL,
int VolumeChanged; /* to keep physio happy */
static int
-handleit(struct cmd_syndesc *as, char *arock)
+handleit(struct cmd_syndesc *as, void *arock)
{
Volume *vp;
Error ec;
register struct cmd_syndesc *ts;
afs_int32 code;
- ts = cmd_CreateSyntax(NULL, handleit, 0, "Manipulate volume blessed bit");
+ ts = cmd_CreateSyntax(NULL, handleit, NULL, "Manipulate volume blessed bit");
cmd_AddParm(ts, "-id", CMD_SINGLE, CMD_REQUIRED, "Volume id");
cmd_AddParm(ts, "-bless", CMD_FLAG, CMD_OPTIONAL, "Set blessed bit");
cmd_AddParm(ts, "-unbless", CMD_FLAG, CMD_OPTIONAL, "Clear blessed bit");
static int
-handleit(struct cmd_syndesc *as)
+handleit(struct cmd_syndesc *as, void *arock)
{
register struct cmd_item *ti;
int err = 0;
register struct cmd_syndesc *ts;
afs_int32 code;
- ts = cmd_CreateSyntax(NULL, handleit, 0, "Dump volume's internal state");
+ ts = cmd_CreateSyntax(NULL, handleit, NULL, "Dump volume's internal state");
cmd_AddParm(ts, "-online", CMD_FLAG, CMD_OPTIONAL,
"Get info from running fileserver");
cmd_AddParm(ts, "-vnode", CMD_FLAG, CMD_OPTIONAL, "Dump vnode info");
return ((afs_int32) tag);
}
-WorkerBee(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+static int
+WorkerBee(struct cmd_syndesc *as, void *arock)
{
int code = 0, c, len;
afs_int32 type, count, vcount;
static int
-handleit(struct cmd_syndesc *as, char *arock)
+handleit(struct cmd_syndesc *as, void *arock)
{
register struct cmd_item *ti;
int err = 0;
VInitVolumePackage(volumeUtility, 5, 5, DONT_CONNECT_FS, 0);
- ts = cmd_CreateSyntax(NULL, handleit, 0,
+ ts = cmd_CreateSyntax(NULL, handleit, NULL,
"Dump a volume to a 'vos dump' format file without using volserver");
cmd_AddParm(ts, "-part", CMD_LIST, CMD_OPTIONAL, "AFS partition name");
cmd_AddParm(ts, "-volumeid", CMD_LIST, CMD_OPTIONAL, "Volume id");
}
/* command to forcibly remove a volume */
-static
-NukeVolume(as)
- register struct cmd_syndesc *as;
+static int
+NukeVolume(register struct cmd_syndesc *as)
{
register afs_int32 code;
afs_int32 volID, err;
* As advertised.
*------------------------------------------------------------------------
*/
-static
-ExamineVolume(as)
- register struct cmd_syndesc *as;
+static int
+ExamineVolume(register struct cmd_syndesc *as, void *arock)
{
struct nvldbentry entry;
afs_int32 vcode = 0;
* As advertised.
*------------------------------------------------------------------------
*/
-static
-SetFields(as)
- register struct cmd_syndesc *as;
+static int
+SetFields(register struct cmd_syndesc *as, void *arock)
{
struct nvldbentry entry;
afs_int32 vcode = 0;
* As advertised.
*------------------------------------------------------------------------
*/
-static
-volOnline(as)
- register struct cmd_syndesc *as;
+static int
+volOnline(register struct cmd_syndesc *as, void *arock)
{
afs_int32 server, partition, volid;
afs_int32 code, err = 0;
*------------------------------------------------------------------------
*/
static int
-volOffline(register struct cmd_syndesc *as)
+volOffline(register struct cmd_syndesc *as, void *arock)
{
afs_int32 server, partition, volid;
afs_int32 code, err = 0;
}
static int
-CreateVolume(register struct cmd_syndesc *as)
+CreateVolume(register struct cmd_syndesc *as, void *arock)
{
afs_int32 pnum;
char part[10];
return error;
}
-static
-DeleteVolume(as)
- struct cmd_syndesc *as;
+static int
+DeleteVolume(struct cmd_syndesc *as, void *arock)
{
afs_int32 err, code = 0;
afs_int32 server = 0, partition = -1, volid;
#define TESTM 0 /* set for move space tests, clear for production */
static
-MoveVolume(as)
- register struct cmd_syndesc *as;
+MoveVolume(register struct cmd_syndesc *as, void *arock)
{
afs_int32 volid, fromserver, toserver, frompart, topart;
return 0;
}
-static
-CopyVolume(as)
- register struct cmd_syndesc *as;
+static int
+CopyVolume(register struct cmd_syndesc *as, void *arock)
{
afs_int32 volid, fromserver, toserver, frompart, topart, code, err, flags;
char fromPartName[10], toPartName[10], *tovolume;
}
-static
-ShadowVolume(as)
- register struct cmd_syndesc *as;
+static int
+ShadowVolume(register struct cmd_syndesc *as, void *arock)
{
afs_int32 volid, fromserver, toserver, frompart, topart, tovolid;
afs_int32 code, err, flags;
}
-static
-CloneVolume(as)
- register struct cmd_syndesc *as;
+static int
+CloneVolume(register struct cmd_syndesc *as, void *arock)
{
afs_int32 server, part, volid, cloneid, voltype;
char partName[10], *volname;
}
-static
-BackupVolume(as)
- register struct cmd_syndesc *as;
+static int
+BackupVolume(register struct cmd_syndesc *as, void *arock)
{
afs_int32 avolid, aserver, apart, vtype, code, err;
struct nvldbentry entry;
return 0;
}
-static
-ReleaseVolume(as)
- register struct cmd_syndesc *as;
+static int
+ReleaseVolume(register struct cmd_syndesc *as, void *arock)
{
struct nvldbentry entry;
}
static
-DumpVolume(as)
- register struct cmd_syndesc *as;
-
+DumpVolume(register struct cmd_syndesc *as, void *arock)
{
afs_int32 avolid, aserver, apart, voltype, fromdate = 0, code, err, i, flags;
char filename[MAXPATHLEN];
#define TS_KEEP 2
#define TS_NEW 3
-static
-RestoreVolume(as)
- register struct cmd_syndesc *as;
-
+static int
+RestoreVolume(register struct cmd_syndesc *as, void *arock)
{
afs_int32 avolid, aparentid, aserver, apart, code, vcode, err;
afs_int32 aoverwrite = ASK;
return 0;
}
-static
-LockReleaseCmd(as)
- register struct cmd_syndesc *as;
-
+static int
+LockReleaseCmd(register struct cmd_syndesc *as, void *arock)
{
afs_int32 avolid, code, err;
return 0;
}
-static
-AddSite(as)
- register struct cmd_syndesc *as;
+static int
+AddSite(register struct cmd_syndesc *as, void *arock)
{
afs_int32 avolid, aserver, apart, code, err;
char apartName[10], avolname[VOLSER_MAXVOLNAME + 1];
return 0;
}
-static
-RemoveSite(as)
- register struct cmd_syndesc *as;
+static int
+RemoveSite(register struct cmd_syndesc *as, void *arock)
{
afs_int32 avolid, aserver, apart, code, err;
return 0;
}
-static
-ChangeLocation(as)
- register struct cmd_syndesc *as;
+static int
+ChangeLocation(register struct cmd_syndesc *as, void *arock)
{
afs_int32 avolid, aserver, apart, code, err;
char apartName[10];
return 0;
}
-static
-ListPartitions(as)
- register struct cmd_syndesc *as;
+static int
+ListPartitions(register struct cmd_syndesc *as, void *arock)
{
afs_int32 aserver, code;
struct partList dummyPartList;
*------------------------------------------------------------------------*/
static
-ListVolumes(as)
- register struct cmd_syndesc *as;
+ListVolumes(register struct cmd_syndesc *as, void *arock)
{
afs_int32 apart, int32list, fast;
afs_int32 aserver, code;
return 0;
}
-static
-SyncVldb(as)
- register struct cmd_syndesc *as;
+static int
+SyncVldb(register struct cmd_syndesc *as, void *arock)
{
afs_int32 pnum = 0, code; /* part name */
char part[10];
return 0;
}
-static
-SyncServer(as)
- register struct cmd_syndesc *as;
-
+static int
+SyncServer(register struct cmd_syndesc *as, void *arock)
{
afs_int32 pnum, code; /* part name */
char part[10];
return 0;
}
-static
-VolumeZap(as)
- register struct cmd_syndesc *as;
-
+static int
+VolumeZap(register struct cmd_syndesc *as, void *arock)
{
struct nvldbentry entry;
afs_int32 volid, code, server, part, zapbackupid = 0, backupid = 0, err;
return 0;
}
-static
-VolserStatus(as)
- register struct cmd_syndesc *as;
-
+static int
+VolserStatus(register struct cmd_syndesc *as, void *arock)
{
afs_int32 server, code;
transDebugInfo *pntr, *oldpntr;
return 0;
}
-static
-RenameVolume(as)
- register struct cmd_syndesc *as;
+static int
+RenameVolume(register struct cmd_syndesc *as, void *arock)
{
afs_int32 code1, code2, code;
struct nvldbentry entry;
return -1;
}
-static
-DeleteEntry(as)
- register struct cmd_syndesc *as;
-
+static int
+DeleteEntry(register struct cmd_syndesc *as, void *arock)
{
afs_int32 apart;
afs_int32 avolid;
}
*/
-static
-ListVLDB(as)
- struct cmd_syndesc *as;
+static int
+ListVLDB(struct cmd_syndesc *as, void *arock)
{
afs_int32 apart;
afs_int32 aserver, code;
return 0;
}
-static
-BackSys(as)
- register struct cmd_syndesc *as;
+static int
+BackSys(register struct cmd_syndesc *as, void *arock)
{
afs_int32 apart = 0, avolid;
afs_int32 aserver = 0, code, aserver1, apart1;
return 0;
}
-static
-UnlockVLDB(as)
- register struct cmd_syndesc *as;
+static int
+UnlockVLDB(register struct cmd_syndesc *as, void *arock)
{
afs_int32 apart;
afs_int32 aserver, code;
return output;
}
-static
-PartitionInfo(as)
- register struct cmd_syndesc *as;
+static int
+PartitionInfo(register struct cmd_syndesc *as, void *arock)
{
afs_int32 apart;
afs_int32 aserver, code;
return 0;
}
-static
-ChangeAddr(as)
- register struct cmd_syndesc *as;
-
+static int
+ChangeAddr(register struct cmd_syndesc *as, void *arock)
{
afs_int32 ip1, ip2, vcode;
int remove = 0;
return;
}
-static
-ListAddrs(as)
- register struct cmd_syndesc *as;
+static int
+ListAddrs(register struct cmd_syndesc *as, void *arock)
{
afs_int32 vcode;
afs_int32 i, noresolve = 0, printuuid = 0;
return 0;
}
-static
-LockEntry(as)
- register struct cmd_syndesc *as;
-
+static int
+LockEntry(register struct cmd_syndesc *as, void *arock)
{
afs_int32 avolid, vcode, err;
return 0;
}
-static
-ConvertRO(as)
- register struct cmd_syndesc *as;
-
+static int
+ConvertRO(register struct cmd_syndesc *as, void *arock)
{
afs_int32 partition = -1;
afs_int32 server, volid, code, i, same;
return code;
}
-static
-Sizes(as)
- register struct cmd_syndesc *as;
+static int
+Sizes(register struct cmd_syndesc *as, void *arock)
{
afs_int32 avolid, aserver, apart, voltype, fromdate = 0, code, err, i;
struct nvldbentry entry;
}
-static
-MyBeforeProc(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+static int
+MyBeforeProc(struct cmd_syndesc *as, void *arock)
{
register char *tcell;
register afs_int32 code;
cmd_SetBeforeProc(MyBeforeProc, NULL);
- ts = cmd_CreateSyntax("create", CreateVolume, 0, "create a new volume");
+ ts = cmd_CreateSyntax("create", CreateVolume, NULL, "create a new volume");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "volume name");
#endif
COMMONPARMS;
- ts = cmd_CreateSyntax("remove", DeleteVolume, 0, "delete a volume");
+ ts = cmd_CreateSyntax("remove", DeleteVolume, NULL, "delete a volume");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL, "machine name");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL, "partition name");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
COMMONPARMS;
- ts = cmd_CreateSyntax("move", MoveVolume, 0, "move a volume");
+ ts = cmd_CreateSyntax("move", MoveVolume, NULL, "move a volume");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
cmd_AddParm(ts, "-fromserver", CMD_SINGLE, 0, "machine name on source");
cmd_AddParm(ts, "-frompartition", CMD_SINGLE, 0,
"copy live volume without cloning");
COMMONPARMS;
- ts = cmd_CreateSyntax("copy", CopyVolume, 0, "copy a volume");
+ ts = cmd_CreateSyntax("copy", CopyVolume, NULL, "copy a volume");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID on source");
cmd_AddParm(ts, "-fromserver", CMD_SINGLE, 0, "machine name on source");
cmd_AddParm(ts, "-frompartition", CMD_SINGLE, 0,
"copy live volume without cloning");
COMMONPARMS;
- ts = cmd_CreateSyntax("shadow", ShadowVolume, 0,
+ ts = cmd_CreateSyntax("shadow", ShadowVolume, NULL,
"make or update a shadow volume");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID on source");
cmd_AddParm(ts, "-fromserver", CMD_SINGLE, 0, "machine name on source");
"do incremental update if target exists");
COMMONPARMS;
- ts = cmd_CreateSyntax("backup", BackupVolume, 0,
+ ts = cmd_CreateSyntax("backup", BackupVolume, NULL,
"make backup of a volume");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
COMMONPARMS;
- ts = cmd_CreateSyntax("clone", CloneVolume, 0,
+ ts = cmd_CreateSyntax("clone", CloneVolume, NULL,
"make clone of a volume");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL, "server");
"make clone volume read-only, not readwrite");
COMMONPARMS;
- ts = cmd_CreateSyntax("release", ReleaseVolume, 0, "release a volume");
+ ts = cmd_CreateSyntax("release", ReleaseVolume, NULL, "release a volume");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL,
"force a complete release");
COMMONPARMS;
- ts = cmd_CreateSyntax("dump", DumpVolume, 0, "dump a volume");
+ ts = cmd_CreateSyntax("dump", DumpVolume, NULL, "dump a volume");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
cmd_AddParm(ts, "-time", CMD_SINGLE, CMD_OPTIONAL, "dump from time");
cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_OPTIONAL, "dump file");
"omit unchanged directories from an incremental dump");
COMMONPARMS;
- ts = cmd_CreateSyntax("restore", RestoreVolume, 0, "restore a volume");
+ ts = cmd_CreateSyntax("restore", RestoreVolume, NULL, "restore a volume");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "name of volume to be restored");
"dump | keep | new");
COMMONPARMS;
- ts = cmd_CreateSyntax("unlock", LockReleaseCmd, 0,
+ ts = cmd_CreateSyntax("unlock", LockReleaseCmd, NULL,
"release lock on VLDB entry for a volume");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
COMMONPARMS;
- ts = cmd_CreateSyntax("changeloc", ChangeLocation, 0,
+ ts = cmd_CreateSyntax("changeloc", ChangeLocation, NULL,
"change an RW volume's location in the VLDB");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0,
"machine name for new location");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
COMMONPARMS;
- ts = cmd_CreateSyntax("addsite", AddSite, 0, "add a replication site");
+ ts = cmd_CreateSyntax("addsite", AddSite, NULL, "add a replication site");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name for new site");
cmd_AddParm(ts, "-partition", CMD_SINGLE, 0,
"partition name for new site");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
COMMONPARMS;
- ts = cmd_CreateSyntax("remsite", RemoveSite, 0,
+ ts = cmd_CreateSyntax("remsite", RemoveSite, NULL,
"remove a replication site");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
COMMONPARMS;
- ts = cmd_CreateSyntax("listpart", ListPartitions, 0, "list partitions");
+ ts = cmd_CreateSyntax("listpart", ListPartitions, NULL, "list partitions");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
COMMONPARMS;
- ts = cmd_CreateSyntax("listvol", ListVolumes, 0,
+ ts = cmd_CreateSyntax("listvol", ListVolumes, NULL,
"list volumes on server (bypass VLDB)");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL, "partition name");
#endif /* FULL_LISTVOL_SWITCH */
COMMONPARMS;
- ts = cmd_CreateSyntax("syncvldb", SyncVldb, 0,
+ ts = cmd_CreateSyntax("syncvldb", SyncVldb, NULL,
"synchronize VLDB with server");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL, "machine name");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL, "partition name");
cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_OPTIONAL, "volume name or ID");
COMMONPARMS;
- ts = cmd_CreateSyntax("syncserv", SyncServer, 0,
+ ts = cmd_CreateSyntax("syncserv", SyncServer, NULL,
"synchronize server with VLDB");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL, "partition name");
COMMONPARMS;
- ts = cmd_CreateSyntax("examine", ExamineVolume, 0,
+ ts = cmd_CreateSyntax("examine", ExamineVolume, NULL,
"everything about the volume");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
cmd_AddParm(ts, "-extended", CMD_FLAG, CMD_OPTIONAL,
COMMONPARMS;
cmd_CreateAlias(ts, "volinfo");
- ts = cmd_CreateSyntax("setfields", SetFields, 0,
+ ts = cmd_CreateSyntax("setfields", SetFields, NULL,
"change volume info fields");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
cmd_AddParm(ts, "-maxquota", CMD_SINGLE, CMD_OPTIONAL, "quota (KB)");
cmd_AddParm(ts, "-clearVolUpCounter", CMD_FLAG, CMD_OPTIONAL, "clear volUpdateCounter");
COMMONPARMS;
- ts = cmd_CreateSyntax("offline", volOffline, 0, (char *)CMD_HIDDEN);
+ ts = cmd_CreateSyntax("offline", volOffline, NULL, (char *)CMD_HIDDEN);
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "server name");
cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
cmd_AddParm(ts, "-busy", CMD_FLAG, CMD_OPTIONAL, "busy volume");
COMMONPARMS;
- ts = cmd_CreateSyntax("online", volOnline, 0, (char *)CMD_HIDDEN);
+ ts = cmd_CreateSyntax("online", volOnline, NULL, (char *)CMD_HIDDEN);
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "server name");
cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
COMMONPARMS;
- ts = cmd_CreateSyntax("zap", VolumeZap, 0,
+ ts = cmd_CreateSyntax("zap", VolumeZap, NULL,
"delete the volume, don't bother with VLDB");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
"also delete backup volume if one is found");
COMMONPARMS;
- ts = cmd_CreateSyntax("status", VolserStatus, 0,
+ ts = cmd_CreateSyntax("status", VolserStatus, NULL,
"report on volser status");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
COMMONPARMS;
- ts = cmd_CreateSyntax("rename", RenameVolume, 0, "rename a volume");
+ ts = cmd_CreateSyntax("rename", RenameVolume, NULL, "rename a volume");
cmd_AddParm(ts, "-oldname", CMD_SINGLE, 0, "old volume name ");
cmd_AddParm(ts, "-newname", CMD_SINGLE, 0, "new volume name ");
COMMONPARMS;
- ts = cmd_CreateSyntax("listvldb", ListVLDB, 0,
+ ts = cmd_CreateSyntax("listvldb", ListVLDB, NULL,
"list volumes in the VLDB");
cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_OPTIONAL, "volume name or ID");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL, "machine name");
"do not alphabetically sort the volume names");
COMMONPARMS;
- ts = cmd_CreateSyntax("backupsys", BackSys, 0, "en masse backups");
+ ts = cmd_CreateSyntax("backupsys", BackSys, NULL, "en masse backups");
cmd_AddParm(ts, "-prefix", CMD_LIST, CMD_OPTIONAL,
"common prefix on volume(s)");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL, "machine name");
cmd_AddParm(ts, "-dryrun", CMD_FLAG, CMD_OPTIONAL, "no action");
COMMONPARMS;
- ts = cmd_CreateSyntax("delentry", DeleteEntry, 0,
+ ts = cmd_CreateSyntax("delentry", DeleteEntry, NULL,
"delete VLDB entry for a volume");
cmd_AddParm(ts, "-id", CMD_LIST, CMD_OPTIONAL, "volume name or ID");
cmd_AddParm(ts, "-prefix", CMD_SINGLE, CMD_OPTIONAL,
"no execute");
COMMONPARMS;
- ts = cmd_CreateSyntax("partinfo", PartitionInfo, 0,
+ ts = cmd_CreateSyntax("partinfo", PartitionInfo, NULL,
"list partition information");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL, "partition name");
"print storage summary");
COMMONPARMS;
- ts = cmd_CreateSyntax("unlockvldb", UnlockVLDB, 0,
+ ts = cmd_CreateSyntax("unlockvldb", UnlockVLDB, NULL,
"unlock all the locked entries in the VLDB");
cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_OPTIONAL, "machine name");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL, "partition name");
COMMONPARMS;
- ts = cmd_CreateSyntax("lock", LockEntry, 0,
+ ts = cmd_CreateSyntax("lock", LockEntry, NULL,
"lock VLDB entry for a volume");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
COMMONPARMS;
- ts = cmd_CreateSyntax("changeaddr", ChangeAddr, 0,
+ ts = cmd_CreateSyntax("changeaddr", ChangeAddr, NULL,
"change the IP address of a file server");
cmd_AddParm(ts, "-oldaddr", CMD_SINGLE, 0, "original IP address");
cmd_AddParm(ts, "-newaddr", CMD_SINGLE, CMD_OPTIONAL, "new IP address");
"remove the IP address from the VLDB");
COMMONPARMS;
- ts = cmd_CreateSyntax("listaddrs", ListAddrs, 0,
+ ts = cmd_CreateSyntax("listaddrs", ListAddrs, NULL,
"list the IP address of all file servers registered in the VLDB");
cmd_AddParm(ts, "-uuid", CMD_SINGLE, CMD_OPTIONAL, "uuid of server");
cmd_AddParm(ts, "-host", CMD_SINGLE, CMD_OPTIONAL, "address of host");
"print uuid of hosts");
COMMONPARMS;
- ts = cmd_CreateSyntax("convertROtoRW", ConvertRO, 0,
+ ts = cmd_CreateSyntax("convertROtoRW", ConvertRO, NULL,
"convert a RO volume into a RW volume (after loss of old RW volume)");
cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL, "don't ask");
COMMONPARMS;
- ts = cmd_CreateSyntax("size", Sizes, 0,
+ ts = cmd_CreateSyntax("size", Sizes, NULL,
"obtain various sizes of the volume.");
cmd_AddParm(ts, "-id", CMD_SINGLE, 0, "volume name or ID");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL, "partition name");
*------------------------------------------------------------------------*/
int
-RunTheTest(a_s)
- struct cmd_syndesc *a_s;
-
+RunTheTest(struct cmd_syndesc *a_s, void *arock)
{ /*RunTheTest */
static char rn[] = "RunTheTest"; /*Routine name */
/*
* Set up the commands we understand.
*/
- ts = cmd_CreateSyntax("initcmd", RunTheTest, 0, "initialize the program");
+ ts = cmd_CreateSyntax("initcmd", RunTheTest, NULL, "initialize the program");
cmd_AddParm(ts, "-cmname", CMD_LIST, CMD_REQUIRED,
"Cache Manager name(s) to monitor");
cmd_AddParm(ts, "-collID", CMD_LIST, CMD_REQUIRED,
git://git.openafs.org / openafs.git / commitdiff