int
wmain(int argc, wchar_t **wargv)
{
afs_int32 code;
struct cmd_syndesc *ts;
char ** argv;
WSADATA WSAjunk;
WSAStartup(0x0101, &WSAjunk);
fs_SetProcessName(pn);
/* try to find volume location information */
argv = fs_MakeUtf8Cmdline(argc, wargv);
osi_Init();
ts = cmd_CreateSyntax("list", ListLinkCmd, NULL, 0, "list symlink");
cmd_AddParm(ts, "-name", CMD_LIST, 0, "name");
ts = cmd_CreateSyntax("make", MakeLinkCmd, NULL, 0, "make symlink");
cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "name");
cmd_AddParm(ts, "-to", CMD_SINGLE, 0, "target");
ts = cmd_CreateSyntax("remove", RemoveLinkCmd, NULL, 0, "remove symlink");
cmd_AddParm(ts, "-name", CMD_LIST, 0, "name");
cmd_CreateAlias(ts, "rm");
code = cmd_Dispatch(argc, argv);
fs_FreeUtf8CmdLine(argc, argv);
return code;
}
int
main(int argc, char *argv[])
{ /*Main routine */
struct cmd_syndesc *ts;
register afs_int32 code;
#ifdef AFS_AIX32_ENV
/*
* The following signal action for AIX is necessary so that in case of a
* crash (i.e. core is generated) we can include the user's data section
* in the core dump. Unfortunately, by default, only a partial core is
* generated which, in many cases, isn't too useful.
*/
struct sigaction nsa;
sigemptyset(&nsa.sa_mask);
nsa.sa_handler = SIG_DFL;
nsa.sa_flags = SA_FULLDUMP;
sigaction(SIGSEGV, &nsa, NULL);
#endif
ts = cmd_CreateSyntax(NULL, CommandProc, NULL,
"Release Kerberos authentication");
cmd_AddParm(ts, "-cell", CMD_LIST, CMD_OPTIONAL, "cell name");
code = cmd_Dispatch(argc, argv);
exit(code != 0);
} /*Main routine */
int
main(int argc, char **argv)
{
struct cmd_syndesc *ts;
#ifdef AFS_AIX32_ENV
/*
* The following signal action for AIX is necessary so that in case of a
* crash (i.e. core is generated) we can include the user's data section
* in the core dump. Unfortunately, by default, only a partial core is
* generated which, in many cases, isn't too useful.
*/
struct sigaction nsa;
sigemptyset(&nsa.sa_mask);
nsa.sa_handler = SIG_DFL;
nsa.sa_flags = SA_FULLDUMP;
sigaction(SIGSEGV, &nsa, NULL);
#endif
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");
cmd_Dispatch(argc, argv);
exit(0);
}
int
main(int argc, char **argv)
{
struct cmd_syndesc *cs; /*Command line syntax descriptor */
afs_int32 code; /*Return code */
cs = cmd_CreateSyntax(NULL, CommandProc, NULL, 0,
"access protection database");
cmd_AddParm(cs, "-w", CMD_FLAG, CMD_OPTIONAL,
"update prdb with contents of data file");
cmd_AddParm(cs, "-user", CMD_FLAG, CMD_OPTIONAL, "display users");
cmd_AddParm(cs, "-group", CMD_FLAG, CMD_OPTIONAL, "display groups");
cmd_AddParm(cs, "-members", CMD_FLAG, CMD_OPTIONAL,
"display group members");
cmd_AddParm(cs, "-name", CMD_FLAG, CMD_OPTIONAL,
"follow name hash chains (not id hashes)");
cmd_AddParm(cs, "-system", CMD_FLAG, CMD_OPTIONAL,
"display only system data");
cmd_AddParm(cs, "-xtra", CMD_FLAG, CMD_OPTIONAL,
"display extra users/groups");
cmd_AddParm(cs, "-prdb", CMD_SINGLE, CMD_OPTIONAL, "prdb file");
cmd_AddParm(cs, "-datafile", CMD_SINGLE, CMD_OPTIONAL, "data file");
code = cmd_Dispatch(argc, argv);
exit(code);
}
int
main(int argc, char **argv)
{
struct cmd_syndesc *ts;
afs_int32 code;
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");
cmd_AddParm(ts, "-date", CMD_FLAG, CMD_OPTIONAL,
"Also dump vnode's mod date");
cmd_AddParm(ts, "-inode", CMD_FLAG, CMD_OPTIONAL,
"Dump vnode's inode number");
cmd_AddParm(ts, "-itime", CMD_FLAG, CMD_OPTIONAL,
"Dump special inode's mod times");
cmd_AddParm(ts, "-part", CMD_LIST, CMD_OPTIONAL,
"AFS partition name (default current partition)");
cmd_AddParm(ts, "-volumeid", CMD_LIST, CMD_OPTIONAL, "Volume id");
cmd_AddParm(ts, "-header", CMD_FLAG, CMD_OPTIONAL,
"Dump volume's header info");
cmd_AddParm(ts, "-sizeOnly", CMD_FLAG, CMD_OPTIONAL,
"Dump volume's size");
cmd_AddParm(ts, "-fixheader", CMD_FLAG, CMD_OPTIONAL,
"Try to fix header");
cmd_AddParm(ts, "-saveinodes", CMD_FLAG, CMD_OPTIONAL,
"Try to save all inodes");
cmd_AddParm(ts, "-orphaned", CMD_FLAG, CMD_OPTIONAL,
"List all dir/files without a parent");
#if defined(AFS_NAMEI_ENV)
cmd_AddParm(ts, "-filenames", CMD_FLAG, CMD_OPTIONAL, "Print filenames");
#endif
code = cmd_Dispatch(argc, argv);
return code;
}
int
main(int argc, char **argv)
{
struct cmd_syndesc *ts;
afs_int32 code;
#ifdef AFS_AIX32_ENV
/*
* The following signal action for AIX is necessary so that in case of a
* crash (i.e. core is generated) we can include the user's data section
* in the core dump. Unfortunately, by default, only a partial core is
* generated which, in many cases, isn't too useful.
*/
struct sigaction nsa;
sigemptyset(&nsa.sa_mask);
nsa.sa_handler = SIG_DFL;
nsa.sa_flags = SA_FULLDUMP;
sigaction(SIGABRT, &nsa, NULL);
sigaction(SIGSEGV, &nsa, NULL);
#endif
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,
"host's '@sys' value");
cmd_AddParm(ts, "-unlog", CMD_FLAG, CMD_OPTIONAL, "unlog remote user");
cmd_AddParm(ts, "-tokens", CMD_FLAG, CMD_OPTIONAL,
"display all tokens for remote [host,id]");
code = cmd_Dispatch(argc, argv);
return code;
}
int
main(int argc, char *argv[])
{
struct cmd_syndesc *ts;
afs_int32 code;
#ifdef AFS_AIX32_ENV
/*
* The following signal action for AIX is necessary so that in case of a
* crash (i.e. core is generated) we can include the user's data section
* in the core dump. Unfortunately, by default, only a partial core is
* generated which, in many cases, isn't too useful.
*/
struct sigaction nsa;
sigemptyset(&nsa.sa_mask);
nsa.sa_handler = SIG_DFL;
nsa.sa_flags = SA_FULLDUMP;
sigaction(SIGABRT, &nsa, NULL);
sigaction(SIGSEGV, &nsa, NULL);
#endif
zero_argc = argc;
zero_argv = argv;
ts = cmd_CreateSyntax(NULL, CommandProc, NULL,
"obtain Kerberos authentication");
#define aXFLAG 0
#define aPRINCIPAL 1
#define aPASSWORD 2
#define aCELL 3
#define aSERVERS 4
#define aPIPE 5
#define aSILENT 6
#define aLIFETIME 7
#define aSETPAG 8
#define aTMP 9
cmd_AddParm(ts, "-x", CMD_FLAG, CMD_OPTIONAL, "(obsolete, noop)");
cmd_Seek(ts, aPRINCIPAL);
cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_OPTIONAL, "user name");
cmd_AddParm(ts, "-password", CMD_SINGLE, CMD_OPTIONAL, "user's password");
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
cmd_AddParm(ts, "-servers", CMD_LIST, CMD_OPTIONAL,
"explicit list of servers");
cmd_AddParm(ts, "-pipe", CMD_FLAG, CMD_OPTIONAL,
"read password from stdin");
cmd_AddParm(ts, "-silent", CMD_FLAG, CMD_OPTIONAL, "silent operation");
cmd_AddParm(ts, "-lifetime", CMD_SINGLE, CMD_OPTIONAL,
"ticket lifetime in hh[:mm[:ss]]");
cmd_AddParm(ts, "-setpag", CMD_FLAG, CMD_OPTIONAL,
"Create a new setpag before authenticating");
cmd_AddParm(ts, "-tmp", CMD_FLAG, CMD_OPTIONAL,
"write Kerberos-style ticket file in /tmp");
code = cmd_Dispatch(argc, argv);
KLOGEXIT(code);
}
int
main(int argc, char **argv)
{
struct cmd_syndesc *ts;
ts = cmd_CreateSyntax(NULL, cproc, NULL, 0, "describe pear");
cmd_AddParm(ts, "-num", CMD_SINGLE, 0, "number of pears");
cmd_AddParm(ts, "-noauth", CMD_FLAG, CMD_OPTIONAL, "don't authenticate");
cmd_AddParm(ts, "-spotpos", CMD_LIST, CMD_OPTIONAL, 0);
return cmd_Dispatch(argc, argv);
}
int
main(int argc, char **argv)
{
struct cmd_syndesc *ts;
#ifdef AFS_AIX32_ENV
/*
* The following signal action for AIX is necessary so that in case of a
* crash (i.e. core is generated) we can include the user's data section
* in the core dump. Unfortunately, by default, only a partial core is
* generated which, in many cases, isn't too useful.
*/
struct sigaction nsa;
sigemptyset(&nsa.sa_mask);
nsa.sa_handler = SIG_DFL;
nsa.sa_flags = SA_FULLDUMP;
sigaction(SIGSEGV, &nsa, NULL);
#endif
#ifdef AFS_NT40_ENV
if (afs_winsockInit() < 0) {
printf("%s: Couldn't initialize winsock. Exiting...\n", argv[0]);
return 1;
}
#endif
rx_Init(0);
ts = cmd_CreateSyntax(NULL, CommandProc, NULL, "query afs cache manager");
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");
cmd_AddParm(ts, "-refcounts", CMD_FLAG, CMD_OPTIONAL,
"print only cache entries with positive reference counts");
cmd_AddParm(ts, "-callbacks", CMD_FLAG, CMD_OPTIONAL,
"print only cache entries with callbacks");
cmd_AddParm(ts, "-ctime", CMD_FLAG, CMD_OPTIONAL,
"print human readable expiration time");
cmd_AddParm(ts, "-addrs", CMD_FLAG, CMD_OPTIONAL,
"print only host interfaces");
cmd_AddParm(ts, "-cache", CMD_FLAG, CMD_OPTIONAL,
"print only cache configuration");
cmd_AddParm(ts, "-cellservdb", CMD_FLAG, CMD_OPTIONAL,
"print only cellservdb info");
cmd_Dispatch(argc, argv);
exit(0);
}
int
main(int argc, char **argv)
{
register struct cmd_syndesc *ts;
afs_int32 code;
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");
cmd_AddParm(ts, "-nofssync", CMD_FLAG, CMD_OPTIONAL,
"Don't communicate with running fileserver");
code = cmd_Dispatch(argc, argv);
return code;
}
int
main(int argc, char *argv[], char **envp)
{
struct cmd_syndesc *ts;
afs_int32 code;
#ifdef AFS_AIX32_ENV
/*
* The following signal action for AIX is necessary so that in case of a
* crash (i.e. core is generated) we can include the user's data section
* in the core dump. Unfortunately, by default, only a partial core is
* generated which, in many cases, isn't too useful.
*/
struct sigaction nsa;
sigemptyset(&nsa.sa_mask);
nsa.sa_handler = SIG_DFL;
nsa.sa_flags = SA_FULLDUMP;
sigaction(SIGSEGV, &nsa, NULL);
#endif
zero_argc = argc;
zero_argv = argv;
init_child(*argv);
ts = cmd_CreateSyntax(NULL, CommandProc, 0, "change user's password");
#define aXFLAG 0
#define aPRINCIPAL 1
#define aPASSWORD 2
#define aNEWPASSWORD 3
#define aCELL 4
#define aSERVERS 5
#define aPIPE 6
cmd_AddParm(ts, "-x", CMD_FLAG, CMD_OPTIONAL, "(obsolete, noop)");
cmd_AddParm(ts, "-principal", CMD_SINGLE, CMD_OPTIONAL, "user name");
cmd_AddParm(ts, "-password", CMD_SINGLE, CMD_OPTIONAL, "user's password");
cmd_AddParm(ts, "-newpassword", CMD_SINGLE, CMD_OPTIONAL,
"user's new password");
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
cmd_AddParm(ts, "-servers", CMD_LIST, CMD_OPTIONAL,
"explicit list of servers");
cmd_AddParm(ts, "-pipe", CMD_FLAG, CMD_OPTIONAL, "silent operation");
code = cmd_Dispatch(argc, argv);
exit(code != 0);
}
int
main(int argc, char **argv)
{
struct cmd_syndesc *ts;
ts = cmd_CreateSyntax("apple", cproc1, NULL, 0, "describe apple");
cmd_CreateAlias(ts, "appl");
ts = cmd_CreateSyntax("pear", cproc2, NULL, 0, "describe pear");
cmd_AddParm(ts, "-num", CMD_LIST, 0, "number of pears");
cmd_AddParm(ts, "-noauth", CMD_FLAG, CMD_OPTIONAL, "don't authenticate");
cmd_AddParm(ts, "-spotpos", CMD_LIST, CMD_OPTIONAL | CMD_EXPANDS, 0);
cmd_Seek(ts, 8);
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
cmd_CreateAlias(ts, "alias");
return cmd_Dispatch(argc, argv);
}
int
main(int argc, char **argv)
{
struct cmd_syndesc *ts;
#ifdef RXDEBUG
rxi_DebugInit();
#endif
#ifdef AFS_NT40_ENV
if (afs_winsockInit() < 0) {
printf("%s: Couldn't initialize winsock. Exiting...\n", argv[0]);
return 1;
}
#endif
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,
"don't show dallying conns");
cmd_AddParm(ts, "-allconnections", CMD_FLAG, CMD_OPTIONAL,
"don't filter out uninteresting connections on server");
cmd_AddParm(ts, "-rxstats", CMD_FLAG, CMD_OPTIONAL, "show Rx statistics");
cmd_AddParm(ts, "-onlyserver", CMD_FLAG, CMD_OPTIONAL,
"only show server conns");
cmd_AddParm(ts, "-onlyclient", CMD_FLAG, CMD_OPTIONAL,
"only show client conns");
cmd_AddParm(ts, "-onlyport", CMD_SINGLE, CMD_OPTIONAL,
"show only <port>");
cmd_AddParm(ts, "-onlyhost", CMD_SINGLE, CMD_OPTIONAL,
"show only <host>");
cmd_AddParm(ts, "-onlyauth", CMD_SINGLE, CMD_OPTIONAL,
"show only <auth level>");
cmd_AddParm(ts, "-version", CMD_FLAG, CMD_OPTIONAL,
"show AFS version id");
cmd_AddParm(ts, "-noconns", CMD_FLAG, CMD_OPTIONAL,
"show no connections");
cmd_AddParm(ts, "-peers", CMD_FLAG, CMD_OPTIONAL, "show peers");
cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL, "detailed output");
cmd_Dispatch(argc, argv);
exit(0);
}
int
main(int argc, char **argv)
{
register struct cmd_syndesc *ts;
afs_int32 code;
VInitVolumePackage(volumeUtility, 5, 5, DONT_CONNECT_FS, 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");
cmd_AddParm(ts, "-file", CMD_LIST, CMD_OPTIONAL, "Dump filename");
cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL,
"Trace dump progress (very verbose)");
cmd_AddParm(ts, "-time", CMD_SINGLE, CMD_OPTIONAL, "dump from time");
code = cmd_Dispatch(argc, argv);
return code;
}
/**
* volinfo program entry
*/
int
main(int argc, char **argv)
{
afs_int32 code;
struct cmd_syndesc *ts;
ts = cmd_CreateSyntax(NULL, VolInfo, NULL, 0,
"Dump volume's internal state");
cmd_AddParmAtOffset(ts, P_CHECKOUT, "-checkout", CMD_FLAG, CMD_OPTIONAL,
"Checkout volumes from running fileserver");
cmd_AddParmAtOffset(ts, P_VNODE, "-vnode", CMD_FLAG, CMD_OPTIONAL,
"Dump vnode info");
cmd_AddParmAtOffset(ts, P_DATE, "-date", CMD_FLAG, CMD_OPTIONAL,
"Also dump vnode's mod date");
cmd_AddParmAtOffset(ts, P_INODE, "-inode", CMD_FLAG, CMD_OPTIONAL,
"Also dump vnode's inode number");
cmd_AddParmAtOffset(ts, P_ITIME, "-itime", CMD_FLAG, CMD_OPTIONAL,
"Dump special inode's mod times");
cmd_AddParmAtOffset(ts, P_PART, "-part", CMD_LIST, CMD_OPTIONAL,
"AFS partition name or id (default current partition)");
cmd_AddParmAtOffset(ts, P_VOLUMEID, "-volumeid", CMD_LIST, CMD_OPTIONAL,
"Volume id");
cmd_AddParmAtOffset(ts, P_HEADER, "-header", CMD_FLAG, CMD_OPTIONAL,
"Dump volume's header info");
cmd_AddParmAtOffset(ts, P_SIZEONLY, "-sizeonly", CMD_FLAG, CMD_OPTIONAL,
"Dump volume's size");
cmd_AddParmAtOffset(ts, P_FIXHEADER, "-fixheader", CMD_FLAG,
CMD_OPTIONAL, "Try to fix header");
cmd_AddParmAtOffset(ts, P_SAVEINODES, "-saveinodes", CMD_FLAG,
CMD_OPTIONAL, "Try to save all inodes");
cmd_AddParmAtOffset(ts, P_ORPHANED, "-orphaned", CMD_FLAG, CMD_OPTIONAL,
"List all dir/files without a parent");
#if defined(AFS_NAMEI_ENV)
cmd_AddParmAtOffset(ts, P_FILENAMES, "-filenames", CMD_FLAG,
CMD_OPTIONAL, "Also dump vnode's namei filename");
#endif
/* For compatibility with older versions. */
cmd_AddParmAlias(ts, P_SIZEONLY, "-sizeOnly");
code = cmd_Dispatch(argc, argv);
return code;
}
int
main(int argc, char **argv)
{
struct cmd_syndesc *ts;
afs_int32 code;
char dbmfile_help[AFSDIR_PATH_MAX];
sprintf(dbmfile_help, "dbmfile to use (default %s)",
AFSDIR_SERVER_KALOGDB_FILEPATH);
dbmfile = AFSDIR_SERVER_KALOGDB_FILEPATH;
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");
cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL, "print long info for each entry");
cmd_AddParm(ts, "-numeric", CMD_FLAG, CMD_OPTIONAL, "addresses only");
code = cmd_Dispatch(argc, argv);
return code;
}
int
main(int argc, char **argv)
{
struct sigaction intaction, oldaction;
struct cmd_syndesc *cptr;
memset(&intaction, 0, sizeof(intaction));
intaction.sa_handler = quitFms;
sigaction(SIGINT, &intaction, &oldaction);
cptr =
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);
return 0;
}
int
main(int argc, char **argv)
{
struct cmd_syndesc *ts;
setlinebuf(stdout);
ts = cmd_CreateSyntax(NULL, WorkerBee, NULL, "KADB check");
cmd_AddParm(ts, "-database", CMD_SINGLE, CMD_REQUIRED, "kadb_file");
cmd_AddParm(ts, "-uheader", CMD_FLAG, CMD_OPTIONAL,
"Display UBIK header");
cmd_AddParm(ts, "-kheader", CMD_FLAG, CMD_OPTIONAL,
"Display KADB header");
cmd_AddParm(ts, "-entries", CMD_FLAG, CMD_OPTIONAL, "Display entries");
cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, "verbose");
cmd_AddParm(ts, "-rebuild", CMD_SINGLE, CMD_OPTIONAL, "out_file");
return cmd_Dispatch(argc, argv);
}
int
main(int argc, char **argv)
{
struct cmd_syndesc *ts;
char tline[1000];
afs_int32 tc;
char *tp;
long code;
char *tv[100];
initialize_CMD_error_table();
ts = cmd_CreateSyntax("apple", cproc1, NULL, 0, "describe apple");
ts = cmd_CreateSyntax("pear", cproc2, NULL, 0, "describe pear");
cmd_AddParm(ts, "-num", CMD_LIST, 0, "number of pears");
cmd_AddParm(ts, "-noauth", CMD_FLAG, CMD_OPTIONAL, "don't authenticate");
cmd_AddParm(ts, "-spotpos", CMD_LIST, CMD_OPTIONAL | CMD_EXPANDS, 0);
cmd_Seek(ts, 8);
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
cmd_CreateAlias(ts, "alias");
ts = cmd_CreateSyntax("quit", cproc3, 0, 0, "quit");
while (1) {
printf("> ");
tp = gets(tline);
if (tp == NULL)
break;
code = cmd_ParseLine(tline, tv, &tc, 100);
if (code) {
printf("itest: parsing failure: %s\n", afs_error_message(code));
exit(1);
}
code = cmd_Dispatch(tc, tv);
cmd_FreeArgv(tv);
if (code) {
printf("itest: execution failed: %s\n", afs_error_message(code));
}
}
return 0;
}
int
main(int argc, char **argv)
{
struct cmd_syndesc *ts;
int err = 0;
/* Initialize directory paths */
if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
#ifdef AFS_NT40_ENV
ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
#endif
fprintf(stderr, "%s: Unable to obtain AFS server directory.\n",
argv[0]);
exit(2);
}
ts = cmd_CreateSyntax("stats", OpStats, NULL, 0, "get salvageserver statistics (SALVSYNC_NOP opcode)");
COMMON_PARMS_DECL(ts);
cmd_CreateAlias(ts, "nop");
ts = cmd_CreateSyntax("salvage", OpSalvage, NULL, 0, "schedule a salvage (SALVSYNC_SALVAGE opcode)");
SALV_PARMS_DECL(ts);
ts = cmd_CreateSyntax("cancel", OpCancel, NULL, 0, "cancel a salvage (SALVSYNC_CANCEL opcode)");
SALV_PARMS_DECL(ts);
ts = cmd_CreateSyntax("raiseprio", OpRaisePrio, NULL, 0, "raise a salvage priority (SALVSYNC_RAISEPRIO opcode)");
SALV_PARMS_DECL(ts);
cmd_CreateAlias(ts, "rp");
ts = cmd_CreateSyntax("query", OpQuery, NULL, 0, "query salvage status (SALVSYNC_QUERY opcode)");
SALV_PARMS_DECL(ts);
cmd_CreateAlias(ts, "qry");
ts = cmd_CreateSyntax("kill", OpCancelAll, NULL, 0, "cancel all scheduled salvages (SALVSYNC_CANCELALL opcode)");
COMMON_PARMS_DECL(ts);
err = cmd_Dispatch(argc, argv);
exit(err);
}
int
main(int argc, char **argv)
{
afs_int32 code;
struct cmd_syndesc *ts;
#ifdef AFS_AIX32_ENV
/*
* The following signal action for AIX is necessary so that in case of a
* crash (i.e. core is generated) we can include the user's data section
* in the core dump. Unfortunately, by default, only a partial core is
* generated which, in many cases, isn't too useful.
*/
struct sigaction nsa;
sigemptyset(&nsa.sa_mask);
nsa.sa_handler = SIG_DFL;
nsa.sa_flags = SA_FULLDUMP;
sigaction(SIGSEGV, &nsa, NULL);
#endif
/* try to find volume location information */
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");
cmd_AddParm(ts, "-maxSendWindow ", CMD_SINGLE, CMD_OPTIONAL, "16");
cmd_AddParm(ts, "-nSendFrags ", CMD_SINGLE, CMD_OPTIONAL, "4");
cmd_AddParm(ts, "-nRecvFrags ", CMD_SINGLE, CMD_OPTIONAL, "4");
cmd_AddParm(ts, "-OrphanFragSize ", CMD_SINGLE, CMD_OPTIONAL, "512");
cmd_AddParm(ts, "-maxReceiveSize ", CMD_SINGLE, CMD_OPTIONAL, "");
cmd_AddParm(ts, "-MyMaxSendSize ", CMD_SINGLE, CMD_OPTIONAL, "");
code = cmd_Dispatch(argc, argv);
if (rxInitDone)
rx_Finalize();
exit(code);
}
int
main(int argc, char **argv)
{ /*Main routine */
static char rn[] = "xstat_cm_test"; /*Routine name */
afs_int32 code; /*Return code */
struct cmd_syndesc *ts; /*Ptr to cmd line syntax desc */
/*
* Set up the commands we understand.
*/
ts = cmd_CreateSyntax("initcmd", RunTheTest, NULL, 0, "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,
"Collection(s) to fetch");
cmd_AddParm(ts, "-onceonly", CMD_FLAG, CMD_OPTIONAL,
"Collect results exactly once, then quit");
cmd_AddParm(ts, "-frequency", CMD_SINGLE, CMD_OPTIONAL,
"poll frequency, in seconds");
cmd_AddParm(ts, "-period", CMD_SINGLE, CMD_OPTIONAL,
"data collection time, in minutes");
cmd_AddParm(ts, "-debug", CMD_FLAG, CMD_OPTIONAL,
"turn on debugging output");
/*
* Parse command-line switches & execute the test, then get the
* heck out of here.
*/
code = cmd_Dispatch(argc, argv);
if (code) {
fprintf(stderr, "[%s] Call to cmd_Dispatch() failed; code is %d\n",
rn, code);
}
exit(code);
} /*Main routine */
int
main(int argc, char **argv)
{
struct cmd_syndesc *ts;
setlinebuf(stdout);
ts = cmd_CreateSyntax(NULL, WorkerBee, NULL,
"Restore volumes from backup tape");
cmd_AddParm(ts, "-tape", CMD_SINGLE, CMD_REQUIRED, "tape device");
cmd_AddParm(ts, "-restore", CMD_SINGLE, CMD_OPTIONAL,
"# volumes to restore");
cmd_AddParm(ts, "-skip", CMD_SINGLE, CMD_OPTIONAL, "# volumes to skip");
cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_OPTIONAL, "filename");
cmd_AddParm(ts, "-scan", CMD_FLAG, CMD_OPTIONAL, "Scan the tape");
cmd_AddParm(ts, "-noask", CMD_FLAG, CMD_OPTIONAL,
"Prompt for each volume");
cmd_AddParm(ts, "-label", CMD_FLAG, CMD_OPTIONAL, "Display dump label");
cmd_AddParm(ts, "-vheaders", CMD_FLAG, CMD_OPTIONAL,
"Display volume headers");
cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, "verbose");
return cmd_Dispatch(argc, argv);
}
/*
* Split arguments into FUSE and afsd/libcmd arguments. To determine whether an
* argument is meant for FUSE or for the cmd interface, we pass the given
* argument to cmd_Dispatch, and see if our beforeProc is run (which we set to
* fuafsd_cmd_check). If it was run, the argument is acceptable to cmd; if it
* was not run, cmd doesn't know what to do with the argument, so we assume the
* argument is meant for FUSE. We can tell if fuafsd_cmd_check was run by the
* global fuafsd_cmd_accept bool, which is set to true when fuafsd_cmd_check is
* run.
*/
static void
split_args(const struct fuse_args *args)
{
int i;
cmd_SetBeforeProc(fuafsd_cmd_check, NULL);
nullfd = open("/dev/null", O_WRONLY);
stderr_save = dup(2);
if (nullfd < 0 || stderr_save < 0) {
perror("open/dup");
exit(1);
}
for (i = 0; args->argv[i]; ++i) {
int code;
char *arg = args->argv[i];
char *argv[3] = {args->argv[0], arg, NULL};
if (fuafsd_cmd_accept) {
fuse_opt_add_arg(&afsd_args, arg);
fuafsd_cmd_accept = 0;
continue;
}
/* redirect stderr to null, so libcmd doesn't print out
* an error message for unknown options */
if (dup2(nullfd, 2) < 0) {
perror("dup2");
exit(1);
}
code = cmd_Dispatch(2, argv);
if (dup2(stderr_save, 2) < 0) {
perror("dup2");
exit(1);
}
/* fuafsd_cmd_check should prevent the dispatch from succeeding;
* the only way we should be able to succeed is if -help was
* specified, so just exit */
if (code == 0) {
exit(1);
}
if (fuafsd_cmd_accept || code == CMD_TOOFEW) {
/* libcmd accepted the argument; must go to afsd */
fuse_opt_add_arg(&afsd_args, arg);
if (code == CMD_TOOFEW) {
/* flag takes another argument; get the next one, too */
fuafsd_cmd_accept = 1;
} else {
fuafsd_cmd_accept = 0;
}
} else {
/* libcmd doesn't recognize the argument; give it to FUSE */
fuse_opt_add_arg(&fuse_args, arg);
}
}
if (close(nullfd) < 0) {
perror("close");
}
if (close(stderr_save) < 0) {
perror("close");
}
cmd_SetBeforeProc(NULL, NULL);
}
int
main(int argc, char **argv)
{
struct cmd_syndesc *ts;
int err = 0;
int i;
extern char cml_version_number[];
/* Initialize directory paths */
if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
#ifdef AFS_NT40_ENV
ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
#endif
fprintf(stderr, "%s: Unable to obtain AFS server directory.\n",
argv[0]);
exit(2);
}
ts = cmd_CreateSyntax("online", VolOnline, NULL, "bring a volume online (FSYNC_VOL_ON opcode)");
VOLOP_PARMS_DECL(ts);
ts = cmd_CreateSyntax("offline", VolOffline, NULL, "take a volume offline (FSYNC_VOL_OFF opcode)");
VOLOP_PARMS_DECL(ts);
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, NULL, "detach a volume (FSYNC_VOL_DONE opcode)");
VOLOP_PARMS_DECL(ts);
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, NULL, "set volume moved flag (FSYNC_VOL_MOVE opcode)");
VOLOP_PARMS_DECL(ts);
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("leaveoff", VolLeaveOff, 0, "leave volume offline (FSYNC_VOL_LEAVE_OFF opcode)");
VOLOP_PARMS_DECL(ts);
ts = cmd_CreateSyntax("attach", VolForceAttach, 0, "force full attachment (FSYNC_VOL_ATTACH opcode)");
VOLOP_PARMS_DECL(ts);
ts = cmd_CreateSyntax("error", VolForceError, 0, "force into hard error state (FSYNC_VOL_FORCE_ERROR opcode)");
VOLOP_PARMS_DECL(ts);
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, NULL, "get volume disk data structure (FSYNC_VOL_QUERY_HDR opcode)");
VOLOP_PARMS_DECL(ts);
cmd_CreateAlias(ts, "hdr");
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("vnode", VnQuery, NULL, "get vnode structure (FSYNC_VOL_QUERY_VNODE opcode)");
cmd_Seek(ts, CUSTOM_PARMS_OFFSET);
cmd_AddParm(ts, "-volumeid", CMD_SINGLE, 0, "volume id");
cmd_AddParm(ts, "-vnodeid", CMD_SINGLE, 0, "vnode id");
cmd_AddParm(ts, "-unique", CMD_SINGLE, 0, "uniquifier");
cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "paritition name");
COMMON_PARMS_DECL(ts);
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");
cmd_AddParm(ts, "-arg2", CMD_SINGLE, CMD_OPTIONAL, "arg2");
COMMON_PARMS_DECL(ts);
err = cmd_Dispatch(argc, argv);
exit(err);
}
int
main(int argc, char **argv)
{
struct cmd_syndesc *ts;
struct cmd_item *ti;
#ifdef AFS_AIX32_ENV
/*
* The following signal action for AIX is necessary so that in case of a
* crash (i.e. core is generated) we can include the user's data section
* in the core dump. Unfortunately, by default, only a partial core is
* generated which, in many cases, isn't too useful.
*/
struct sigaction nsa;
sigemptyset(&nsa.sa_mask);
nsa.sa_handler = SIG_DFL;
nsa.sa_flags = SA_FULLDUMP;
sigaction(SIGSEGV, &nsa, NULL);
sigaction(SIGABRT, &nsa, NULL);
#endif
setlinebuf(stdout);
ts = cmd_CreateSyntax(NULL, WorkerBee, NULL, "tape coordinator");
cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "port offset");
cmd_AddParm(ts, "-debuglevel", CMD_SINGLE, CMD_OPTIONAL, "0 | 1 | 2");
cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
cmd_AddParm(ts, "-device", CMD_SINGLE, (CMD_OPTIONAL | CMD_HIDE),
"tape device path");
cmd_AddParm(ts, "-noautoquery", CMD_FLAG, CMD_OPTIONAL,
"do not query operator for first tape");
cmd_AddParm(ts, "-localauth", CMD_FLAG, CMD_OPTIONAL,
"create tickets from KeyFile");
cmd_AddParm(ts, "-restoretofile", CMD_SINGLE, (CMD_OPTIONAL | CMD_HIDE),
"file to restore to");
cmd_AddParm(ts, "-xbsaforcemultiple", CMD_FLAG, (CMD_OPTIONAL | CMD_HIDE),
"Force multiple XBSA server support");
cmd_AddParm(ts, "-rxbind", CMD_FLAG, CMD_OPTIONAL,
"bind Rx socket");
/* Initialize dirpaths */
if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
#ifdef AFS_NT40_ENV
ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
#endif
fprintf(stderr, "Unable to obtain AFS server directory.\n");
exit(2);
}
/* setup the file paths */
strcompose(eFile, AFSDIR_PATH_MAX, AFSDIR_SERVER_BACKUP_DIRPATH, "/",
TE_PREFIX, NULL);
strcompose(lFile, AFSDIR_PATH_MAX, AFSDIR_SERVER_BACKUP_DIRPATH, "/",
TL_PREFIX, NULL);
strcompose(pFile, AFSDIR_PATH_MAX, AFSDIR_SERVER_BACKUP_DIRPATH, "/",
CFG_PREFIX, NULL);
strcpy(tapeConfigFile, AFSDIR_SERVER_TAPECONFIG_FILEPATH);
/* special case "no args" case since cmd_dispatch gives help message
* instead
*/
if (argc == 1) {
ts = (struct cmd_syndesc *)malloc(sizeof(struct cmd_syndesc));
memset(ts, 0, sizeof(*ts));
ti = (struct cmd_item *)malloc(sizeof(struct cmd_item));
ti->next = 0;
ti->data = "0";
ts->parms[0].items = ti;
ti = (struct cmd_item *)malloc(sizeof(struct cmd_item));
ti->next = 0;
ti->data = "0";
ts->parms[1].items = ti;
ts->parms[2].items = (struct cmd_item *)NULL;
ts->parms[3].items = (struct cmd_item *)NULL;
ts->parms[4].items = (struct cmd_item *)NULL;
ts->parms[5].items = (struct cmd_item *)NULL;
return WorkerBee(ts, NULL);
} else
return cmd_Dispatch(argc, argv);
}
int
main(int argc, char **argv)
{
struct cmd_syndesc *ts;
int err = 0;
int i;
#ifdef AFS_AIX32_ENV
/*
* The following signal action for AIX is necessary so that in case of a
* crash (i.e. core is generated) we can include the user's data section
* in the core dump. Unfortunately, by default, only a partial core is
* generated which, in many cases, isn't too useful.
*/
struct sigaction nsa;
sigemptyset(&nsa.sa_mask);
nsa.sa_handler = SIG_DFL;
nsa.sa_flags = SA_FULLDUMP;
sigaction(SIGABRT, &nsa, NULL);
sigaction(SIGSEGV, &nsa, NULL);
#endif
/* Initialize directory paths */
if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
#ifdef AFS_NT40_ENV
ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
#endif
fprintf(stderr, "%s: Unable to obtain AFS server directory.\n",
argv[0]);
exit(2);
}
#ifdef AFS_NT40_ENV
main_thread = pthread_self();
if (spawnDatap && spawnDataLen) {
/* This is a child per partition salvager. Don't setup log or
* try to lock the salvager lock.
*/
if (nt_SetupPartitionSalvage(spawnDatap, spawnDataLen) < 0)
exit(3);
} else {
#endif
for (commandLine[0] = '\0', i = 0; i < argc; i++) {
if (i > 0)
strlcat(commandLine, " ", sizeof(commandLine));
strlcat(commandLine, argv[i], sizeof(commandLine));
}
#ifndef AFS_NT40_ENV
if (geteuid() != 0) {
printf("Salvager must be run as root.\n");
fflush(stdout);
Exit(0);
}
#endif
/* bad for normal help flag processing, but can do nada */
#ifdef AFS_NT40_ENV
}
#endif
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,
"Volume Id to salvage");
cmd_AddParm(ts, "-debug", CMD_FLAG, CMD_OPTIONAL,
"Run in Debugging mode");
cmd_AddParm(ts, "-nowrite", CMD_FLAG, CMD_OPTIONAL,
"Run readonly/test mode");
cmd_AddParm(ts, "-inodes", CMD_FLAG, CMD_OPTIONAL,
"Just list affected afs inodes - debugging flag");
cmd_AddParm(ts, "-oktozap", CMD_FLAG, CMD_OPTIONAL,
"Give permission to destroy bogus inodes/volumes - debugging flag");
cmd_AddParm(ts, "-rootinodes", CMD_FLAG, CMD_OPTIONAL,
"Show inodes owned by root - debugging flag");
cmd_AddParm(ts, "-salvagedirs", CMD_FLAG, CMD_OPTIONAL,
"Force rebuild/salvage of all directories");
cmd_AddParm(ts, "-blockreads", CMD_FLAG, CMD_OPTIONAL,
"Read smaller blocks to handle IO/bad blocks");
cmd_AddParm(ts, "-parallel", CMD_SINGLE, CMD_OPTIONAL,
"# of max parallel partition salvaging");
cmd_AddParm(ts, "-tmpdir", CMD_SINGLE, CMD_OPTIONAL,
"Name of dir to place tmp files ");
cmd_AddParm(ts, "-showlog", CMD_FLAG, CMD_OPTIONAL,
"Show log file upon completion");
cmd_AddParm(ts, "-orphans", CMD_SINGLE, CMD_OPTIONAL,
"ignore | remove | attach");
/* note - syslog isn't avail on NT, but if we make it conditional, have
* to deal with screwy offsets for cmd params */
cmd_AddParm(ts, "-syslog", CMD_FLAG, CMD_OPTIONAL,
"Write salvage log to syslogs");
cmd_AddParm(ts, "-syslogfacility", CMD_SINGLE, CMD_OPTIONAL,
"Syslog facility number to use");
cmd_AddParm(ts, "-datelogs", CMD_FLAG, CMD_OPTIONAL,
"Include timestamp in logfile filename");
cmd_AddParm(ts, "-client", CMD_FLAG, CMD_OPTIONAL,
"Use SALVSYNC to ask salvageserver to salvage a volume");
err = cmd_Dispatch(argc, argv);
Exit(err);
return 0; /* not reached */
}
int
main(int argc, char **argv)
{
char *whoami = argv[0];
char *dbNamePtr = 0;
struct afsconf_cell cellinfo;
time_t currentTime;
afs_int32 code = 0;
afs_uint32 host = ntohl(INADDR_ANY);
char clones[MAXHOSTSPERCELL];
struct rx_service *tservice;
struct rx_securityClass **securityClasses;
afs_int32 numClasses;
extern int rx_stackSize;
#ifdef AFS_NT40_ENV
/* initialize winsock */
if (afs_winsockInit() < 0) {
ReportErrorEventAlt(AFSEVT_SVR_WINSOCK_INIT_FAILED, 0, argv[0], 0);
fprintf(stderr, "%s: Couldn't initialize winsock.\n", whoami);
exit(1);
}
#endif
#ifdef AFS_AIX32_ENV
/*
* The following signal action for AIX is necessary so that in case of a
* crash (i.e. core is generated) we can include the user's data section
* in the core dump. Unfortunately, by default, only a partial core is
* generated which, in many cases, isn't too useful.
*/
struct sigaction nsa;
sigemptyset(&nsa.sa_mask);
nsa.sa_handler = SIG_DFL;
nsa.sa_flags = SA_FULLDUMP;
sigaction(SIGSEGV, &nsa, NULL);
sigaction(SIGABRT, &nsa, NULL);
#endif
osi_audit_init();
osi_audit(BUDB_StartEvent, 0, AUD_END);
initialize_BUDB_error_table();
initializeArgHandler();
/* Initialize dirpaths */
if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
#ifdef AFS_NT40_ENV
ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
#endif
afs_com_err(whoami, errno, "; Unable to obtain AFS server directory.");
exit(2);
}
memset(globalConfPtr, 0, sizeof(*globalConfPtr));
/* set default configuration values */
strcpy(dbDir, AFSDIR_SERVER_DB_DIRPATH);
strcat(dbDir, "/");
globalConfPtr->databaseDirectory = dbDir;
globalConfPtr->databaseName = DEFAULT_DBPREFIX;
strcpy(cellConfDir, AFSDIR_SERVER_ETC_DIRPATH);
globalConfPtr->cellConfigdir = cellConfDir;
/* open the log file */
/*
globalConfPtr->log = fopen(DEFAULT_LOGNAME,"a");
if ( globalConfPtr->log == NULL )
{
printf("Can't open log file %s - aborting\n", DEFAULT_LOGNAME);
BUDB_EXIT(-1);
}
*/
srandom(1);
#ifdef AFS_PTHREAD_ENV
SetLogThreadNumProgram( rx_GetThreadNum );
#endif
/* process the user supplied args */
helpOption = 1;
code = cmd_Dispatch(argc, argv);
if (code)
ERROR(code);
/* exit if there was a help option */
if (helpOption)
BUDB_EXIT(0);
/* open the log file */
globalConfPtr->log = fopen(AFSDIR_SERVER_BUDBLOG_FILEPATH, "a");
if (globalConfPtr->log == NULL) {
printf("Can't open log file %s - aborting\n",
AFSDIR_SERVER_BUDBLOG_FILEPATH);
BUDB_EXIT(-1);
}
/* keep log closed so can remove it */
fclose(globalConfPtr->log);
/* open the cell's configuration directory */
LogDebug(4, "opening %s\n", globalConfPtr->cellConfigdir);
BU_conf = afsconf_Open(globalConfPtr->cellConfigdir);
if (BU_conf == 0) {
LogError(code, "Failed getting cell info\n");
afs_com_err(whoami, code, "Failed getting cell info");
ERROR(BUDB_NOCELLS);
}
code = afsconf_GetLocalCell(BU_conf, lcell, sizeof(lcell));
if (code) {
LogError(0, "** Can't determine local cell name!\n");
ERROR(code);
}
if (globalConfPtr->myHost == 0) {
/* if user hasn't supplied a list of servers, extract server
* list from the cell's database
*/
LogDebug(1, "Using server list from %s cell database.\n", lcell);
code = afsconf_GetExtendedCellInfo (BU_conf, lcell, 0, &cellinfo,
clones);
code =
convert_cell_to_ubik(&cellinfo, &globalConfPtr->myHost,
globalConfPtr->serverList);
if (code)
ERROR(code);
}
/* initialize audit user check */
osi_audit_set_user_check(BU_conf, BU_IsLocalRealmMatch);
/* initialize ubik */
ubik_SetClientSecurityProcs(afsconf_ClientAuth, afsconf_UpToDate, BU_conf);
ubik_SetServerSecurityProcs(afsconf_BuildServerSecurityObjects,
afsconf_CheckAuth, BU_conf);
if (ubik_nBuffers == 0)
ubik_nBuffers = 400;
LogError(0, "Will allocate %d ubik buffers\n", ubik_nBuffers);
asprintf(&dbNamePtr, "%s%s", globalConfPtr->databaseDirectory,
globalConfPtr->databaseName);
if (dbNamePtr == 0)
ERROR(-1);
rx_SetRxDeadTime(60); /* 60 seconds inactive before timeout */
if (rxBind) {
afs_int32 ccode;
if (AFSDIR_SERVER_NETRESTRICT_FILEPATH ||
AFSDIR_SERVER_NETINFO_FILEPATH) {
char reason[1024];
ccode = afsconf_ParseNetFiles(SHostAddrs, NULL, NULL,
ADDRSPERSITE, reason,
AFSDIR_SERVER_NETINFO_FILEPATH,
AFSDIR_SERVER_NETRESTRICT_FILEPATH);
} else
{
ccode = rx_getAllAddr(SHostAddrs, ADDRSPERSITE);
}
if (ccode == 1) {
host = SHostAddrs[0];
rx_InitHost(host, htons(AFSCONF_BUDBPORT));
}
}
/* Disable jumbograms */
rx_SetNoJumbo();
code = ubik_ServerInitByInfo (globalConfPtr->myHost,
htons(AFSCONF_BUDBPORT),
&cellinfo,
clones,
dbNamePtr, /* name prefix */
&BU_dbase);
if (code) {
LogError(code, "Ubik init failed\n");
afs_com_err(whoami, code, "Ubik init failed");
ERROR(code);
}
afsconf_BuildServerSecurityObjects(BU_conf, &securityClasses, &numClasses);
tservice =
rx_NewServiceHost(host, 0, BUDB_SERVICE, "BackupDatabase",
securityClasses, numClasses, BUDB_ExecuteRequest);
if (tservice == (struct rx_service *)0) {
LogError(0, "Could not create backup database rx service\n");
printf("Could not create backup database rx service\n");
BUDB_EXIT(3);
}
rx_SetMinProcs(tservice, 1);
rx_SetMaxProcs(tservice, lwps);
rx_SetStackSize(tservice, 10000);
/* allow super users to manage RX statistics */
rx_SetRxStatUserOk(BU_rxstat_userok);
/* misc. initialization */
/* database dump synchronization */
memset(dumpSyncPtr, 0, sizeof(*dumpSyncPtr));
Lock_Init(&dumpSyncPtr->ds_lock);
rx_StartServer(0); /* start handling requests */
code = InitProcs();
if (code)
ERROR(code);
currentTime = time(0);
LogError(0, "Ready to process requests at %s\n", ctime(¤tTime));
rx_ServerProc(NULL); /* donate this LWP */
error_exit:
osi_audit(BUDB_FinishEvent, code, AUD_END);
return (code);
}
afs_int32
doDispatch(afs_int32 targc,
char *targv[MAXV],
afs_int32 dispatchCount) /* to prevent infinite recursion */
{
char *sargv[MAXV];
afs_int32 sargc;
afs_int32 code, c;
FILE *fd;
int i;
int lineNumber;
int noExecute; /* local capy of global variable */
char *internalLoadFile;
lock_Dispatch();
loadFile = NULL;
code = cmd_Dispatch(targc, targv);
internalLoadFile = loadFile;
unlock_Dispatch();
if (internalLoadFile) { /* Load a file in */
if (dispatchCount > MAXRECURSION) { /* Beware recursive loops. */
afs_com_err(whoami, 0, "Potential recursion: will not load file %s",
internalLoadFile);
code = -1;
goto done;
}
fd = fopen(internalLoadFile, "r"); /* Open the load file */
if (!fd) {
afs_com_err(whoami, errno, "; Cannot open file %s", internalLoadFile);
code = -1;
goto done;
}
noExecute = dontExecute;
if (noExecute)
printf("Would have executed the following commands:\n");
lineNumber = 0;
while (fgets(lineBuffer, sizeof(lineBuffer) - 1, fd)) { /* Get commands from file */
lineNumber++;
i = strlen(lineBuffer) - 1;
if (lineBuffer[i] == '\n') /* Drop return at end of line */
lineBuffer[i] = '\0';
if (noExecute)
printf(" %s\n", lineBuffer); /* echo */
else
printf("------> %s\n", lineBuffer); /* echo */
if (!LineIsBlank(lineBuffer) && /* Skip if blank line */
(lineBuffer[0] != '#') && /* or comment */
(!noExecute)) { /* or no execute */
c = cmd_ParseLine(lineBuffer, sargv, &sargc, MAXV);
if (c) {
afs_com_err(whoami, c, "; Can't parse line");
} else {
doDispatch(sargc, sargv, dispatchCount + 1); /* Recursive - ignore error */
cmd_FreeArgv(sargv); /* Free up arguments */
}
}
}
fclose(fd);
}
done:
if (internalLoadFile)
free(internalLoadFile);
return (code);
}
int
main(int argc, char **argv)
{
struct CmdLine cmdline;
struct cmd_syndesc *ts;
int err = 0;
#ifdef AFS_AIX32_ENV
/*
* The following signal action for AIX is necessary so that in case of a
* crash (i.e. core is generated) we can include the user's data section
* in the core dump. Unfortunately, by default, only a partial core is
* generated which, in many cases, isn't too useful.
*/
struct sigaction nsa;
sigemptyset(&nsa.sa_mask);
nsa.sa_handler = SIG_DFL;
nsa.sa_flags = SA_FULLDUMP;
sigaction(SIGABRT, &nsa, NULL);
sigaction(SIGSEGV, &nsa, NULL);
#endif
/* Initialize directory paths */
if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
#ifdef AFS_NT40_ENV
ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
#endif
fprintf(stderr, "%s: Unable to obtain AFS server directory.\n",
argv[0]);
exit(2);
}
#ifdef AFS_NT40_ENV
/* Default to binary mode for fopen() */
_set_fmode(_O_BINARY);
main_thread = pthread_self();
if (spawnDatap && spawnDataLen) {
/* This is a child per partition salvager. Don't setup log or
* try to lock the salvager lock.
*/
if (nt_SetupPartitionSalvage(spawnDatap, spawnDataLen) < 0)
exit(3);
} else {
#endif
#ifndef AFS_NT40_ENV
if (geteuid() != 0) {
printf("Salvager must be run as root.\n");
fflush(stdout);
Exit(0);
}
#endif
/* Get and hold a lock for the duration of the salvage to make sure
* that no other salvage runs at the same time. The routine
* VInitVolumePackage2 (called below) makes sure that a file server or
* other volume utilities don't interfere with the salvage.
*/
get_salvage_lock = 1;
#ifdef AFS_NT40_ENV
}
#endif
cmdline.argc = argc;
cmdline.argv = argv;
ts = cmd_CreateSyntax("initcmd", handleit, &cmdline, 0, "initialize the program");
cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
"Name of partition to salvage");
cmd_AddParm(ts, "-volumeid", CMD_SINGLE, CMD_OPTIONAL,
"Volume Id to salvage");
cmd_AddParm(ts, "-debug", CMD_FLAG, CMD_OPTIONAL,
"Run in Debugging mode");
cmd_AddParm(ts, "-nowrite", CMD_FLAG, CMD_OPTIONAL,
"Run readonly/test mode");
cmd_AddParm(ts, "-inodes", CMD_FLAG, CMD_OPTIONAL,
"Just list affected afs inodes - debugging flag");
cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL, "Force full salvaging");
cmd_AddParm(ts, "-oktozap", CMD_FLAG, CMD_OPTIONAL,
"Give permission to destroy bogus inodes/volumes - debugging flag");
cmd_AddParm(ts, "-rootinodes", CMD_FLAG, CMD_OPTIONAL,
"Show inodes owned by root - debugging flag");
cmd_AddParm(ts, "-salvagedirs", CMD_FLAG, CMD_OPTIONAL,
"Force rebuild/salvage of all directories");
cmd_AddParm(ts, "-blockreads", CMD_FLAG, CMD_OPTIONAL,
"Read smaller blocks to handle IO/bad blocks");
cmd_AddParm(ts, "-parallel", CMD_SINGLE, CMD_OPTIONAL,
"# of max parallel partition salvaging");
cmd_AddParm(ts, "-tmpdir", CMD_SINGLE, CMD_OPTIONAL,
"Name of dir to place tmp files ");
cmd_AddParm(ts, "-showlog", CMD_FLAG, CMD_OPTIONAL,
"Show log file upon completion");
cmd_AddParm(ts, "-showsuid", CMD_FLAG, CMD_OPTIONAL,
"Report on suid/sgid files");
cmd_AddParm(ts, "-showmounts", CMD_FLAG, CMD_OPTIONAL,
"Report on mountpoints");
cmd_AddParm(ts, "-orphans", CMD_SINGLE, CMD_OPTIONAL,
"ignore | remove | attach");
/* note - syslog isn't avail on NT, but if we make it conditional, have
* to deal with screwy offsets for cmd params */
cmd_AddParm(ts, "-syslog", CMD_FLAG, CMD_OPTIONAL,
"Write salvage log to syslogs");
cmd_AddParm(ts, "-syslogfacility", CMD_SINGLE, CMD_OPTIONAL,
"Syslog facility number to use");
cmd_AddParm(ts, "-datelogs", CMD_FLAG, CMD_OPTIONAL,
"Include timestamp in logfile filename");
#ifdef FAST_RESTART
cmd_AddParm(ts, "-DontSalvage", CMD_FLAG, CMD_OPTIONAL,
"Don't salvage. This my be set in BosConfig to let the fileserver restart immediately after a crash. Bad volumes will be taken offline");
#elif defined(AFS_DEMAND_ATTACH_FS)
cmd_Seek(ts, 20); /* skip DontSalvage */
cmd_AddParm(ts, "-forceDAFS", CMD_FLAG, CMD_OPTIONAL,
"For Demand Attach Fileserver, permit a manual volume salvage outside of the salvageserver");
#endif /* FAST_RESTART */
cmd_Seek(ts, 21); /* skip DontSalvage and forceDAFS if needed */
cmd_AddParm(ts, "-f", CMD_FLAG, CMD_OPTIONAL, "Alias for -force");
err = cmd_Dispatch(argc, argv);
Exit(err);
return 0; /* not reached */
}
