static
void parse_opt(int argc, char **argv)
{
int c;
poptContext optCon;
const char *no_arg;
struct poptOption optionsTable[] = {
{ "loops" , 'n', POPT_ARGFLAG_SHOW_DEFAULT | POPT_ARG_INT,
&arg_loops , 0, "pp loops", "count" },
{ "time" , 't', POPT_ARGFLAG_SHOW_DEFAULT | POPT_ARG_INT,
&arg_maxtime, 0, "max time", "ms" },
{ "maxsize" , 0, POPT_ARGFLAG_SHOW_DEFAULT | POPT_ARG_INT,
&arg_maxmsize , 0, "maximal messagesize", "size" },
{ "once" , '1', POPT_ARGFLAG_OR | POPT_ARG_VAL,
&arg_run_once, 1, "stop after one client", NULL },
{ "verbose" , 'v', POPT_ARG_NONE,
NULL , 'v', "increase verbosity", NULL },
POPT_AUTOHELP
POPT_TABLEEND
};
optCon = poptGetContext(NULL, argc, (const char **) argv, optionsTable, 0);
poptSetOtherOptionHelp(optCon, "[serveraddr]");
while ((c = poptGetNextOpt(optCon)) >= 0) {
switch (c) { // c = poptOption.val;
case 'v': arg_verbose++; break;
//default: fprintf(stderr, "unhandled popt value %d\n", c); break;
}
}
if (c < -1) { /* an error occurred during option processing */
fprintf(stderr, "%s: %s\n",
poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
poptStrerror(c));
poptPrintHelp(optCon, stderr, 0);
exit(1);
}
// arg_1 = poptGetArg(optCon);
// arg_2 = poptGetArg(optCon);
/* if (arg_client)*/ {
const char *server = poptGetArg(optCon);
if (server) arg_server_addr = server;
}
no_arg = poptGetArg(optCon); // should return NULL
if (no_arg) {
fprintf(stderr, "%s: %s\n",
no_arg, poptStrerror(POPT_ERROR_BADOPT));
poptPrintHelp(optCon, stderr, 0);
exit(1);
}
poptFreeContext(optCon);
}
static
void parse_opt(int argc, char **argv)
{
int c;
poptContext optCon;
const char *no_arg;
struct poptOption optionsTable[] = {
{ "loops" , 'n', POPT_ARGFLAG_SHOW_DEFAULT | POPT_ARG_INT,
&arg_loops , 0, "pp loops", "count" },
{ "time" , 't', POPT_ARGFLAG_SHOW_DEFAULT | POPT_ARG_INT,
&arg_maxtime, 0, "max time", "ms" },
{ "maxsize" , 0, POPT_ARGFLAG_SHOW_DEFAULT | POPT_ARG_INT,
&arg_maxmsize , 0, "maximal messagesize", "size" },
{ "nokill" , 'k', POPT_ARGFLAG_OR | POPT_ARG_VAL,
&arg_nokill, 1, "Dont kill the server afterwards", NULL },
{ "port" , 'p', POPT_ARGFLAG_SHOW_DEFAULT | POPT_ARG_STRING,
&arg_port, 0, "server port to use", "port" },
{ "verbose" , 'v', POPT_ARG_NONE,
NULL , 'v', "increase verbosity", NULL },
POPT_AUTOHELP
POPT_TABLEEND
};
optCon = poptGetContext(NULL, argc, (const char **) argv, optionsTable, 0);
poptSetOtherOptionHelp(optCon, "[serveraddr]");
while ((c = poptGetNextOpt(optCon)) >= 0) {
switch (c) { // c = poptOption.val;
case 'v': arg_verbose++; break;
}
}
if (c < -1) { /* an error occurred during option processing */
fprintf(stderr, "%s: %s\n",
poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
poptStrerror(c));
poptPrintHelp(optCon, stderr, 0);
exit(1);
}
// arg_1 = poptGetArg(optCon);
// arg_2 = poptGetArg(optCon);
arg_servername = poptGetArg(optCon);
is_server = !arg_servername;
no_arg = poptGetArg(optCon); // should return NULL
if (no_arg) {
fprintf(stderr, "%s: %s\n",
no_arg, poptStrerror(POPT_ERROR_BADOPT));
poptPrintHelp(optCon, stderr, 0);
exit(1);
}
poptFreeContext(optCon);
}
void parse_opt(int argc, char **argv)
{
int c;
poptContext optCon;
const char *no_arg;
struct poptOption optionsTable[] = {
{ "send" , 's', POPT_ARGFLAG_OR | POPT_ARG_VAL,
&arg_send, 1, "first send", NULL },
{ "lport" , 'l', POPT_ARGFLAG_SHOW_DEFAULT | POPT_ARG_INT,
&arg_listenport, 0, "listen on port", "port" },
{ "lname" , 'n', POPT_ARGFLAG_SHOW_DEFAULT | POPT_ARG_STRING,
&arg_listenname, 0, "listen on name", "name" },
{ "verbose" , 'v', POPT_ARG_NONE,
NULL , 'v', "increase verbosity", NULL },
POPT_AUTOHELP
POPT_TABLEEND
};
optCon = poptGetContext(NULL, argc, (const char **) argv, optionsTable, 0);
poptSetOtherOptionHelp(optCon, "[peer address]");
while ((c = poptGetNextOpt(optCon)) >= 0) {
switch (c) { // c = poptOption.val;
case 'v': arg_verbose++; break;
//default: fprintf(stderr, "unhandled popt value %d\n", c); break;
}
}
if (c < -1) { /* an error occurred during option processing */
fprintf(stderr, "%s: %s\n",
poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
poptStrerror(c));
poptPrintHelp(optCon, stderr, 0);
exit(1);
}
{
const char *s;
s = poptGetArg(optCon);
if (s) {
arg_peer_str = s;
}
}
no_arg = poptGetArg(optCon); // should return NULL
if (no_arg) {
fprintf(stderr, "%s: %s\n",
no_arg, poptStrerror(POPT_ERROR_BADOPT));
poptPrintHelp(optCon, stderr, 0);
exit(1);
}
poptFreeContext(optCon);
}
int main(int argc, const char **argv)
{
NET_API_STATUS status;
struct libnetapi_ctx *ctx = NULL;
const char *hostname = NULL;
const char *domain = NULL;
uint8_t *buffer = NULL;
poptContext pc;
int opt;
struct poptOption long_options[] = {
POPT_AUTOHELP
POPT_COMMON_LIBNETAPI_EXAMPLES
POPT_TABLEEND
};
status = libnetapi_init(&ctx);
if (status != 0) {
return status;
}
pc = poptGetContext("getdc", argc, argv, long_options, 0);
poptSetOtherOptionHelp(pc, "hostname domainname");
while((opt = poptGetNextOpt(pc)) != -1) {
}
if (!poptPeekArg(pc)) {
poptPrintHelp(pc, stderr, 0);
goto out;
}
hostname = poptGetArg(pc);
if (!poptPeekArg(pc)) {
poptPrintHelp(pc, stderr, 0);
goto out;
}
domain = poptGetArg(pc);
/* NetGetDCName */
status = NetGetDCName(hostname, domain, &buffer);
if (status != 0) {
printf("GetDcName failed with: %s\n", libnetapi_errstr(status));
} else {
printf("%s\n", (char *)buffer);
}
out:
NetApiBufferFree(buffer);
libnetapi_free(ctx);
poptFreeContext(pc);
return status;
}
int main(int argc, const char **argv)
{
NET_API_STATUS status;
struct libnetapi_ctx *ctx = NULL;
const char *hostname = NULL;
const char *sharename = NULL;
poptContext pc;
int opt;
struct poptOption long_options[] = {
POPT_AUTOHELP
POPT_COMMON_LIBNETAPI_EXAMPLES
POPT_TABLEEND
};
status = libnetapi_init(&ctx);
if (status != 0) {
return status;
}
pc = poptGetContext("share_del", argc, argv, long_options, 0);
poptSetOtherOptionHelp(pc, "hostname sharename");
while((opt = poptGetNextOpt(pc)) != -1) {
}
if (!poptPeekArg(pc)) {
poptPrintHelp(pc, stderr, 0);
goto out;
}
hostname = poptGetArg(pc);
if (!poptPeekArg(pc)) {
poptPrintHelp(pc, stderr, 0);
goto out;
}
sharename = poptGetArg(pc);
/* NetShareDel */
status = NetShareDel(hostname,
sharename,
0);
if (status != 0) {
printf("NetShareDel failed with: %s\n",
libnetapi_get_error_string(ctx, status));
goto out;
}
out:
libnetapi_free(ctx);
poptFreeContext(pc);
return status;
}
void ldb_cmdline_help(const char *cmdname, FILE *f)
{
poptContext pc;
pc = poptGetContext(cmdname, 0, NULL, popt_options,
POPT_CONTEXT_KEEP_FIRST);
poptPrintHelp(pc, f, 0);
}
static void rmdPrintAndExit(poptContext con,
enum poptCallbackReason reason,
const struct poptOption *opt,
const char *arg,
const void *data)
{
if (strcmp(opt->longName, "version") == 0) {
fprintf(stderr,"recordMyDesktop v%s\n\n",VERSION);
}
else if (strcmp(opt->longName, "help") == 0) {
poptPrintHelp(con, stdout, 0);
fprintf(stdout,
"\n"
"\tIf no other options are specified, filename can be given without the -o switch.\n"
"\n"
"\n");
}
else if (strcmp(opt->longName, "print-config") == 0) {
fprintf(stdout,
"\n"
"recordMyDesktop was compiled with the following options:\n"
"\n"
"Jack:\t\t\t" RMD_LIBJACK_STATUS "\n"
"Default Audio Backend:\t" RMD_LIBASOUND_STATUS "\n"
"\n"
"\n");
}
exit(0);
}
void ldb_cmdline_help(struct ldb_context *ldb, const char *cmdname, FILE *f)
{
poptContext pc;
struct poptOption **popt_options = ldb_module_popt_options(ldb);
pc = poptGetContext(cmdname, 0, NULL, *popt_options,
POPT_CONTEXT_KEEP_FIRST);
poptPrintHelp(pc, f, 0);
}
static void displayArgs(poptContext con, enum poptCallbackReason foo,
struct poptOption * key,
const char * arg, void * data) {
if (key->shortName== '?')
poptPrintHelp(con, stdout, 0);
else
poptPrintUsage(con, stdout, 0);
exit(0);
}
static void printUsage(poptContext con, FILE * fp, int flags)
/*@globals rpmEVR, fileSystem, internalState @*/
/*@modifies *fp, fileSystem, internalState @*/
{
printVersion(fp);
fprintf(fp, "\n");
if (rpmIsVerbose())
poptPrintHelp(con, fp, flags);
else
poptPrintUsage(con, fp, flags);
}
/**
* Display arguments.
* @param con context
* @param foo (unused)
* @param key option(s)
* @param arg (unused)
* @param data (unused)
*/
static void displayArgs(poptContext con,
/*@unused@*/ enum poptCallbackReason foo,
struct poptOption * key,
/*@unused@*/ const char * arg, /*@unused@*/ void * data)
/*@globals fileSystem@*/
/*@modifies fileSystem@*/
{
if (key->shortName == '?')
poptPrintHelp(con, stdout, 0);
else
poptPrintUsage(con, stdout, 0);
exit(0);
}
/* Show program help. */
static void show_help (poptContext ctx)
{
size_t ix;
show_banner ();
poptSetOtherOptionHelp (ctx, mocp_summary);
poptPrintHelp (ctx, stdout, 0);
printf ("\nEnvironment variables:\n\n");
for (ix = 0; ix < ARRAY_SIZE(environment_variables); ix += 1)
printf (" %-34s%s\n", environment_variables[ix].name,
environment_variables[ix].desc);
printf ("\n");
}
void parse_opt(int argc, char **argv)
{
int c; /* used for argument parsing */
poptContext optCon; /* context for parsing command-line options */
struct poptOption optionsTable[] = {
{ "server" , 's', POPT_ARGFLAG_OR, &arg_ppserver , 0,
"run as server", "" },
{ "serverport" , 'p', POPT_ARG_INT, &arg_serverport , 0,
"server port to listen on", "port" },
{ "servernode" , 'n', POPT_ARG_INT, &arg_servernode , 0,
"host of the server(IP as integer)", "node" },
{ "clientport" , 'c', POPT_ARG_INT, &arg_clientport , 0,
"client use port", "port" },
{ "cnt" , 0, POPT_ARG_INT, &arg_cnt , 0,
"No of packets for pp", "count" },
{ "size" , 0, POPT_ARG_INT, &arg_size , 0,
"Size of packets for pp", "size" },
{ "verbose" , 'v', POPT_ARG_INT, &arg_verbose , 0,
"be more verbose", "level" },
/* { "flag" , 'f', POPT_ARGFLAG_OR, &arg_flag, 0,
"flag description", "" },*/
POPT_AUTOHELP
{ NULL, 0, 0, NULL, 0, NULL, NULL }
};
optCon = poptGetContext(NULL, argc,(const char **) argv, optionsTable, 0);
if (argc < 2) {
poptPrintUsage(optCon, stderr, 0);
exit(1);
}
/* Now do options processing, get portname */
while ((c = poptGetNextOpt(optCon)) >= 0) {
}
if (c < -1) {
/* an error occurred during option processing */
fprintf(stderr, "%s: %s\n",
poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
poptStrerror(c));
poptPrintHelp(optCon, stderr, 0);
exit(1);
}
poptFreeContext(optCon);
}
void print_help(const poptContext popt, const int ret) {
poptPrintHelp(popt, ret == 0 ? stdout : stderr, 0);
printf("\nStyles:\n");
int i;
for (i = 0; style_table[i].name; i++) {
printf(" %-14s %s\n", style_table[i].name, style_table[i].description);
}
printf("\n\
Examples:\n\
nordlicht video.mp4 generate video.mp4.nordlicht.png of default size\n\
nordlicht video.mp4 -s vertical compress individual frames to columns\n\
nordlicht video.mp4 -w 1000 -h 1000 -o barcode.png override size and name of the output file\n");
exit(ret);
}
/*@exits@*/
static void displayArgs(poptContext con,
/*@unused@*/ UNUSED(enum poptCallbackReason foo),
struct poptOption * key,
/*@unused@*/ UNUSED(const char * arg),
/*@unused@*/ UNUSED(void * data))
/*@globals fileSystem@*/
/*@modifies fileSystem@*/
{
if (key->shortName == '?')
poptPrintHelp(con, stdout, 0);
else
poptPrintUsage(con, stdout, 0);
#if !defined(__LCLINT__) /* XXX keep both splint & valgrind happy */
con = poptFreeContext(con);
#endif
exit(0);
}
/* first parse all options, and save arguments in the sessions struct
* exit on any error encountered, if none present, proceed and return */
void setOptions(int argc, const char * argv[]) {
int ret;
bool printVersion = false;
poptContext optCon = poptGetContext(NULL, argc, argv, options, 0);
options[0].arg = elbowOptionsTable;
while ((ret = poptGetNextOpt(optCon)) > 0) {
switch (ret) {
case PR_EOL:
settings.eol = getEndOfLine(settings.eol);
break;
case PR_BAUDRATE:
settings.rate = getBaudrate(settings.rate);
break;
case PR_VERSION:
printVersion = true;
break;
}
}
/* report parsing error if present and exit */
if (ret < -1) {
printf("\n%s: %s\n\n", poptStrerror(ret), poptBadOption(optCon, 0));
poptPrintHelp(optCon, stdout, 0);
exit(EXIT_FAILURE);
}
/* print version information and exit */
if (printVersion) {
printf("Elbow version %s\n", VERSION);
printf("Copyright (C) %s %s\n", YEAR, AUTHOR);
printf("Released under the %s license.\n", LICENSE);
printf("\n%s\n", DISCLAIMER);
}
optCon = poptFreeContext(optCon);
}
static void usage(poptContext *pc)
{
int i;
poptPrintHelp(*pc, stderr, 0);
fprintf(stderr, "\n");
fprintf(stderr, "<destination> is one of \"nmbd\", \"smbd\" or a "
"process ID\n");
fprintf(stderr, "\n");
fprintf(stderr, "<message-type> is one of:\n");
for (i = 0; msg_types[i].name; i++)
fprintf(stderr, "\t%-30s%s\n", msg_types[i].name,
msg_types[i].help);
fprintf(stderr, "\n");
exit(1);
}
void air_option_context_usage(
AirOptionCtx *aoctx)
{
g_assert(aoctx != NULL);
g_assert(aoctx->octx != NULL);
#if USE_GOPTION
/* Grr. GLib has a g_option_context_get_help() function, but it's new as
* of GLib 2.14, which almost nobody has. So, we timidly tell the user
* to get the usage for themselves instead of printing it for them.
* GLib--
*
* g_fprintf(stderr, g_option_context_get_help(aoctx->octx, FALSE, NULL));
*/
g_fprintf(stderr, "Use --help for usage.");
#elif USE_POPT
poptPrintHelp(aoctx->octx, stderr, 0);
#endif
return;
}
void parse_opt(int argc, char **argv)
{
int c; /* used for argument parsing */
poptContext optCon; /* context for parsing command-line options */
struct poptOption optionsTable[] = {
{ "verbose" , 'v', POPT_ARG_INT, &arg_verbose , 0,
"be more verbose", "level" },
{ "sock" , 's', POPT_ARGFLAG_OR, &arg_dumpsockets, 0,
"dump all sockets", "" },
{ "net" , 'n', POPT_ARGFLAG_OR, &arg_dumpnet, 0,
"dump all network ci's", "" },
POPT_AUTOHELP
{ NULL, 0, 0, NULL, 0, NULL, NULL }
};
optCon = poptGetContext(NULL, argc,(const char **) argv, optionsTable, 0);
if (argc < 2) {
poptPrintUsage(optCon, stderr, 0);
exit(1);
}
/* Now do options processing, get portname */
while ((c = poptGetNextOpt(optCon)) >= 0) {
}
if (c < -1) {
/* an error occurred during option processing */
fprintf(stderr, "%s: %s\n",
poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
poptStrerror(c));
poptPrintHelp(optCon, stderr, 0);
exit(1);
}
poptFreeContext(optCon);
}
static void cifsdd_help_message(poptContext pctx,
enum poptCallbackReason preason,
struct poptOption * poption,
const char * parg,
void * pdata)
{
static const char notes[] =
"FILE can be a local filename or a UNC path of the form //server/share/path.\n";
char prefix[24];
int i;
if (poption->shortName != '?') {
poptPrintUsage(pctx, stdout, 0);
fprintf(stdout, " [dd options]\n");
exit(0);
}
poptPrintHelp(pctx, stdout, 0);
fprintf(stdout, "\nCIFS dd options:\n");
for (i = 0; i < ARRAY_SIZE(args); ++i) {
if (args[i].arg_name == NULL) {
break;
}
snprintf(prefix, sizeof(prefix), "%s=%-*s",
args[i].arg_name,
(int)(sizeof(prefix) - strlen(args[i].arg_name) - 2),
argtype_str(args[i].arg_type));
prefix[sizeof(prefix) - 1] = '\0';
fprintf(stdout, " %s%s\n", prefix, args[i].arg_help);
}
fprintf(stdout, "\n%s\n", notes);
exit(0);
}
int main(int argc, const char **argv)
{
poptContext pc;
int opt;
static struct poptOption wbinfo_options[] = {
{ "timeout", 't', POPT_ARG_INT, &timeout, 't',
"Set timeout value in seconds", "TIMEOUT" },
{ "configfile", 's', POPT_ARG_STRING, NULL, 's',
"Use alternative configuration file", "CONFIGFILE" },
POPT_TABLEEND
};
struct poptOption options[] = {
{ NULL, 0, POPT_ARG_INCLUDE_TABLE, wbinfo_options, 0,
"Options" },
POPT_AUTOHELP
POPT_COMMON_VERSION
POPT_TABLEEND
};
setup_logging(argv[0],True);
/* Parse command line arguments using popt */
pc = poptGetContext(
"smbcontrol", argc, (const char **)argv, options, 0);
poptSetOtherOptionHelp(pc, "[OPTION...] <destination> <message-type> "
"<parameters>");
if (argc == 1)
usage(&pc);
while ((opt = poptGetNextOpt(pc)) != -1) {
switch(opt) {
case 't': /* --timeout */
argc -= 2;
break;
case 's': /* --configfile */
pstrcpy(dyn_CONFIGFILE, poptGetOptArg(pc));
argc -= 2;
break;
default:
fprintf(stderr, "Invalid option\n");
poptPrintHelp(pc, stderr, 0);
break;
}
}
/* We should now have the remaining command line arguments in
argv. The argc parameter should have been decremented to the
correct value in the above switch statement. */
argv = (const char **)poptGetArgs(pc);
argc--; /* Don't forget about argv[0] */
if (argc == 1)
usage(&pc);
lp_load(dyn_CONFIGFILE,False,False,False);
/* Need to invert sense of return code -- samba
* routines mostly return True==1 for success, but
* shell needs 0. */
return !do_command(argc, argv);
}
/**
* First half of the command line parsing. Also see ParseCommandLine()
* below. The parameters here are needed early in the boot process,
* while the ones in ParseCommandLine can benefit from debugging being
* set up first.
* \param argc number of arguments given
* \param argv string array of the arguments
* \return Returns true on success, false on error */
bool ParseCommandLineEarly(int argc, const char **argv)
{
poptContext poptCon = poptGetContext(NULL, argc, argv, getOptionsTable(), 0);
int iOption;
#if defined(WZ_OS_MAC) && defined(DEBUG)
debug_enable_switch("all");
#endif /* WZ_OS_MAC && DEBUG */
/* loop through command line */
while ((iOption = poptGetNextOpt(poptCon)) > 0 || iOption == POPT_ERROR_BADOPT)
{
CLI_OPTIONS option = (CLI_OPTIONS)iOption;
const char *token;
if (iOption == POPT_ERROR_BADOPT)
{
qFatal("Unrecognized option: %s", poptBadOption(poptCon, 0));
}
switch (option)
{
case CLI_DEBUG:
// retrieve the debug section name
token = poptGetOptArg(poptCon);
if (token == NULL)
{
qFatal("Usage: --debug=<flag>");
}
// Attempt to enable the given debug section
if (!debug_enable_switch(token))
{
qFatal("Debug flag \"%s\" not found!", token);
}
break;
case CLI_DEBUGFILE:
// find the file name
token = poptGetOptArg(poptCon);
if (token == NULL)
{
qFatal("Missing debugfile filename?");
}
debug_register_callback(debug_callback_file, debug_callback_file_init, debug_callback_file_exit, (void *)token);
customDebugfile = true;
break;
case CLI_FLUSHDEBUGSTDERR:
// Tell the debug stderr output callback to always flush its output
debugFlushStderr();
break;
case CLI_CONFIGDIR:
// retrieve the configuration directory
token = poptGetOptArg(poptCon);
if (token == NULL)
{
qFatal("Unrecognised configuration directory");
}
sstrcpy(configdir, token);
break;
case CLI_HELP:
poptPrintHelp(poptCon, stdout, 0);
return false;
case CLI_VERSION:
printf("Warzone 2100 - %s\n", version_getFormattedVersionString());
return false;
default:
break;
};
}
return true;
}
int main(int argc, const char ** argv)
/*@globals pass2, fileSystem, internalState @*/
/*@modifies pass2, fileSystem, internalState @*/
{
int rc;
int ec = 0;
poptContext optCon;
const char ** rest;
int help = 0;
int usage = 0;
#if defined(HAVE_MCHECK_H) && defined(HAVE_MTRACE)
/*@-moduncon -noeffectuncon@*/
mtrace(); /* Trace malloc only if MALLOC_TRACE=mtrace-output-file. */
/*@=moduncon =noeffectuncon@*/
#endif
/*@-modobserver@*/
resetVars();
/*@=modobserver@*/
/*@-temptrans@*/
optCon = poptGetContext("test1", argc, argv, options, 0);
/*@=temptrans@*/
(void) poptReadConfigFile(optCon, "./test-poptrc");
#if 1
while ((rc = poptGetNextOpt(optCon)) > 0) /* Read all the options ... */
{};
poptResetContext(optCon); /* ... and then start over. */
/*@-modobserver@*/
resetVars();
/*@=modobserver@*/
#endif
pass2 = 1;
if ((rc = poptGetNextOpt(optCon)) < -1) {
fprintf(stderr, "test1: bad argument %s: %s\n",
poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
poptStrerror(rc));
ec = 2;
goto exit;
}
if (help) {
poptPrintHelp(optCon, stdout, 0);
goto exit;
}
if (usage) {
poptPrintUsage(optCon, stdout, 0);
goto exit;
}
fprintf(stdout, "arg1: %d arg2: %s", arg1, arg2);
if (arg3)
fprintf(stdout, " arg3: %d", arg3);
if (inc)
fprintf(stdout, " inc: %d", inc);
if (shortopt)
fprintf(stdout, " short: %d", shortopt);
if (aVal != bVal)
fprintf(stdout, " aVal: %d", aVal);
if (aFlag != bFlag)
fprintf(stdout, " aFlag: %d", aFlag);
if (aInt != bInt)
fprintf(stdout, " aInt: %d", aInt);
if (aLong != bLong)
fprintf(stdout, " aLong: %ld", aLong);
/*@-realcompare@*/
if (aFloat != bFloat)
fprintf(stdout, " aFloat: %g", (double)aFloat);
if (aDouble != bDouble)
fprintf(stdout, " aDouble: %g", aDouble);
/*@=realcompare@*/
if (oStr != (char *)-1)
fprintf(stdout, " oStr: %s", (oStr ? oStr : "(none)"));
if (singleDash)
fprintf(stdout, " -");
rest = poptGetArgs(optCon);
if (rest) {
fprintf(stdout, " rest:");
while (*rest) {
fprintf(stdout, " %s", *rest);
rest++;
}
}
fprintf(stdout, "\n");
exit:
optCon = poptFreeContext(optCon);
#if defined(HAVE_MCHECK_H) && defined(HAVE_MTRACE)
/*@-moduncon -noeffectuncon@*/
muntrace(); /* Trace malloc only if MALLOC_TRACE=mtrace-output-file. */
/*@=moduncon =noeffectuncon@*/
#endif
return ec;
}
int main(int argc, const char **argv)
{
static int list_users = False;
static int verbose = False;
static int spstyle = False;
static int machine = False;
static int add_user = False;
static int delete_user = False;
static int modify_user = False;
uint32_t setparms, checkparms;
int opt;
static char *full_name = NULL;
static char *acct_desc = NULL;
static const char *user_name = NULL;
static char *home_dir = NULL;
static char *home_drive = NULL;
static const char *backend = NULL;
static char *backend_in = NULL;
static char *backend_out = NULL;
static int transfer_groups = False;
static int transfer_account_policies = False;
static int reset_account_policies = False;
static int force_initialised_password = False;
static char *logon_script = NULL;
static char *profile_path = NULL;
static char *user_domain = NULL;
static char *account_control = NULL;
static char *account_policy = NULL;
static char *user_sid = NULL;
static char *machine_sid = NULL;
static long int account_policy_value = 0;
bool account_policy_value_set = False;
static int badpw_reset = False;
static int hours_reset = False;
static char *pwd_time_format = NULL;
static int pw_from_stdin = False;
struct pdb_methods *bin, *bout;
static char *kickoff_time = NULL;
TALLOC_CTX *frame = talloc_stackframe();
NTSTATUS status;
poptContext pc;
struct poptOption long_options[] = {
POPT_AUTOHELP
{"list", 'L', POPT_ARG_NONE, &list_users, 0, "list all users", NULL},
{"verbose", 'v', POPT_ARG_NONE, &verbose, 0, "be verbose", NULL },
{"smbpasswd-style", 'w',POPT_ARG_NONE, &spstyle, 0, "give output in smbpasswd style", NULL},
{"user", 'u', POPT_ARG_STRING, &user_name, 0, "use username", "USER" },
{"account-desc", 'N', POPT_ARG_STRING, &acct_desc, 0, "set account description", NULL},
{"fullname", 'f', POPT_ARG_STRING, &full_name, 0, "set full name", NULL},
{"homedir", 'h', POPT_ARG_STRING, &home_dir, 0, "set home directory", NULL},
{"drive", 'D', POPT_ARG_STRING, &home_drive, 0, "set home drive", NULL},
{"script", 'S', POPT_ARG_STRING, &logon_script, 0, "set logon script", NULL},
{"profile", 'p', POPT_ARG_STRING, &profile_path, 0, "set profile path", NULL},
{"domain", 'I', POPT_ARG_STRING, &user_domain, 0, "set a users' domain", NULL},
{"user SID", 'U', POPT_ARG_STRING, &user_sid, 0, "set user SID or RID", NULL},
{"machine SID", 'M', POPT_ARG_STRING, &machine_sid, 0, "set machine SID or RID", NULL},
{"create", 'a', POPT_ARG_NONE, &add_user, 0, "create user", NULL},
{"modify", 'r', POPT_ARG_NONE, &modify_user, 0, "modify user", NULL},
{"machine", 'm', POPT_ARG_NONE, &machine, 0, "account is a machine account", NULL},
{"delete", 'x', POPT_ARG_NONE, &delete_user, 0, "delete user", NULL},
{"backend", 'b', POPT_ARG_STRING, &backend, 0, "use different passdb backend as default backend", NULL},
{"import", 'i', POPT_ARG_STRING, &backend_in, 0, "import user accounts from this backend", NULL},
{"export", 'e', POPT_ARG_STRING, &backend_out, 0, "export user accounts to this backend", NULL},
{"group", 'g', POPT_ARG_NONE, &transfer_groups, 0, "use -i and -e for groups", NULL},
{"policies", 'y', POPT_ARG_NONE, &transfer_account_policies, 0, "use -i and -e to move account policies between backends", NULL},
{"policies-reset", 0, POPT_ARG_NONE, &reset_account_policies, 0, "restore default policies", NULL},
{"account-policy", 'P', POPT_ARG_STRING, &account_policy, 0,"value of an account policy (like maximum password age)",NULL},
{"value", 'C', POPT_ARG_LONG, &account_policy_value, 'C',"set the account policy to this value", NULL},
{"account-control", 'c', POPT_ARG_STRING, &account_control, 0, "Values of account control", NULL},
{"force-initialized-passwords", 0, POPT_ARG_NONE, &force_initialised_password, 0, "Force initialization of corrupt password strings in a passdb backend", NULL},
{"bad-password-count-reset", 'z', POPT_ARG_NONE, &badpw_reset, 0, "reset bad password count", NULL},
{"logon-hours-reset", 'Z', POPT_ARG_NONE, &hours_reset, 0, "reset logon hours", NULL},
{"time-format", 0, POPT_ARG_STRING, &pwd_time_format, 0, "The time format for time parameters", NULL },
{"password-from-stdin", 't', POPT_ARG_NONE, &pw_from_stdin, 0, "get password from standard in", NULL},
{"kickoff-time", 'K', POPT_ARG_STRING, &kickoff_time, 0, "set the kickoff time", NULL},
POPT_COMMON_SAMBA
POPT_TABLEEND
};
bin = bout = NULL;
smb_init_locale();
setup_logging("pdbedit", DEBUG_STDOUT);
pc = poptGetContext(NULL, argc, argv, long_options,
POPT_CONTEXT_KEEP_FIRST);
while((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case 'C':
account_policy_value_set = True;
break;
}
}
poptGetArg(pc); /* Drop argv[0], the program name */
if (user_name == NULL)
user_name = poptGetArg(pc);
if (!lp_load_global(get_dyn_CONFIGFILE())) {
fprintf(stderr, "Can't load %s - run testparm to debug it\n", get_dyn_CONFIGFILE());
exit(1);
}
if (!init_names())
exit(1);
setparms = (backend ? BIT_BACKEND : 0) +
(verbose ? BIT_VERBOSE : 0) +
(spstyle ? BIT_SPSTYLE : 0) +
(full_name ? BIT_FULLNAME : 0) +
(home_dir ? BIT_HOMEDIR : 0) +
(home_drive ? BIT_HDIRDRIVE : 0) +
(logon_script ? BIT_LOGSCRIPT : 0) +
(profile_path ? BIT_PROFILE : 0) +
(user_domain ? BIT_USERDOMAIN : 0) +
(machine ? BIT_MACHINE : 0) +
(user_name ? BIT_USER : 0) +
(list_users ? BIT_LIST : 0) +
(force_initialised_password ? BIT_FIX_INIT : 0) +
(user_sid ? BIT_USERSIDS : 0) +
(machine_sid ? BIT_USERSIDS : 0) +
(modify_user ? BIT_MODIFY : 0) +
(add_user ? BIT_CREATE : 0) +
(delete_user ? BIT_DELETE : 0) +
(account_control ? BIT_ACCTCTRL : 0) +
(account_policy ? BIT_ACCPOLICY : 0) +
(account_policy_value_set ? BIT_ACCPOLVAL : 0) +
(backend_in ? BIT_IMPORT : 0) +
(backend_out ? BIT_EXPORT : 0) +
(badpw_reset ? BIT_BADPWRESET : 0) +
(hours_reset ? BIT_LOGONHOURS : 0) +
(kickoff_time ? BIT_KICKOFFTIME : 0) +
(acct_desc ? BIT_DESCRIPTION : 0);
if (setparms & BIT_BACKEND) {
/* HACK: set the global passdb backend by overwriting globals.
* This way we can use regular pdb functions for default
* operations that do not involve passdb migrations */
lp_set_cmdline("passdb backend", backend);
} else {
backend = lp_passdb_backend();
}
if (!initialize_password_db(False, NULL)) {
fprintf(stderr, "Can't initialize passdb backend.\n");
exit(1);
}
/* the lowest bit options are always accepted */
checkparms = setparms & ~MASK_ALWAYS_GOOD;
if (checkparms & BIT_FIX_INIT) {
return fix_users_list();
}
/* account policy operations */
if ((checkparms & BIT_ACCPOLICY) && !(checkparms & ~(BIT_ACCPOLICY + BIT_ACCPOLVAL))) {
uint32_t value;
enum pdb_policy_type field = account_policy_name_to_typenum(account_policy);
if (field == 0) {
const char **names;
int count;
int i;
account_policy_names_list(talloc_tos(), &names, &count);
fprintf(stderr, "No account policy by that name!\n");
if (count !=0) {
fprintf(stderr, "Account policy names are:\n");
for (i = 0; i < count ; i++) {
d_fprintf(stderr, "%s\n", names[i]);
}
}
TALLOC_FREE(names);
exit(1);
}
if (!pdb_get_account_policy(field, &value)) {
fprintf(stderr, "valid account policy, but unable to fetch value!\n");
if (!account_policy_value_set)
exit(1);
}
printf("account policy \"%s\" description: %s\n", account_policy, account_policy_get_desc(field));
if (account_policy_value_set) {
printf("account policy \"%s\" value was: %u\n", account_policy, value);
if (!pdb_set_account_policy(field, account_policy_value)) {
fprintf(stderr, "valid account policy, but unable to set value!\n");
exit(1);
}
printf("account policy \"%s\" value is now: %lu\n", account_policy, account_policy_value);
exit(0);
} else {
printf("account policy \"%s\" value is: %u\n", account_policy, value);
exit(0);
}
}
if (reset_account_policies) {
if (reinit_account_policies()) {
exit(1);
}
exit(0);
}
/* import and export operations */
if (((checkparms & BIT_IMPORT) ||
(checkparms & BIT_EXPORT)) &&
!(checkparms & ~(BIT_IMPORT +BIT_EXPORT +BIT_USER))) {
if (backend_in) {
status = make_pdb_method_name(&bin, backend_in);
} else {
status = make_pdb_method_name(&bin, backend);
}
if (!NT_STATUS_IS_OK(status)) {
fprintf(stderr, "Unable to initialize %s.\n",
backend_in ? backend_in : backend);
return 1;
}
if (backend_out) {
status = make_pdb_method_name(&bout, backend_out);
} else {
status = make_pdb_method_name(&bout, backend);
}
if (!NT_STATUS_IS_OK(status)) {
fprintf(stderr, "Unable to initialize %s.\n",
backend_out ? backend_out : backend);
return 1;
}
if (transfer_account_policies) {
if (!(checkparms & BIT_USER)) {
return export_account_policies(bin, bout);
}
} else if (transfer_groups) {
if (!(checkparms & BIT_USER)) {
return export_groups(bin, bout);
}
} else {
return export_database(bin, bout,
(checkparms & BIT_USER) ? user_name : NULL);
}
}
/* if BIT_USER is defined but nothing else then threat it as -l -u for compatibility */
/* fake up BIT_LIST if only BIT_USER is defined */
if ((checkparms & BIT_USER) && !(checkparms & ~BIT_USER)) {
checkparms += BIT_LIST;
}
/* modify flag is optional to maintain backwards compatibility */
/* fake up BIT_MODIFY if BIT_USER and at least one of MASK_USER_GOOD is defined */
if (!((checkparms & ~MASK_USER_GOOD) & ~BIT_USER) && (checkparms & MASK_USER_GOOD)) {
checkparms += BIT_MODIFY;
}
/* list users operations */
if (checkparms & BIT_LIST) {
if (!(checkparms & ~BIT_LIST)) {
return print_users_list(verbose, spstyle);
}
if (!(checkparms & ~(BIT_USER + BIT_LIST))) {
return print_user_info(user_name, verbose, spstyle);
}
}
/* mask out users options */
checkparms &= ~MASK_USER_GOOD;
/* if bad password count is reset, we must be modifying */
if (checkparms & BIT_BADPWRESET) {
checkparms |= BIT_MODIFY;
checkparms &= ~BIT_BADPWRESET;
}
/* if logon hours is reset, must modify */
if (checkparms & BIT_LOGONHOURS) {
checkparms |= BIT_MODIFY;
checkparms &= ~BIT_LOGONHOURS;
}
/* account operation */
if ((checkparms & BIT_CREATE) || (checkparms & BIT_MODIFY) || (checkparms & BIT_DELETE)) {
/* check use of -u option */
if (!(checkparms & BIT_USER)) {
fprintf (stderr, "Username not specified! (use -u option)\n");
return -1;
}
/* account creation operations */
if (!(checkparms & ~(BIT_CREATE + BIT_USER + BIT_MACHINE))) {
if (checkparms & BIT_MACHINE) {
return new_machine(user_name, machine_sid);
} else {
return new_user(user_name, full_name,
home_dir, home_drive,
logon_script, profile_path,
user_sid, pw_from_stdin);
}
}
/* account deletion operations */
if (!(checkparms & ~(BIT_DELETE + BIT_USER + BIT_MACHINE))) {
if (checkparms & BIT_MACHINE) {
return delete_machine_entry(user_name);
} else {
return delete_user_entry(user_name);
}
}
/* account modification operations */
if (!(checkparms & ~(BIT_MODIFY + BIT_USER + BIT_MACHINE))) {
if (checkparms & BIT_MACHINE) {
return set_machine_info(user_name,
account_control,
machine_sid);
} else {
return set_user_info(user_name, full_name,
home_dir, acct_desc,
home_drive, logon_script,
profile_path, account_control,
user_sid, user_domain,
badpw_reset, hours_reset,
kickoff_time);
}
}
}
if (setparms >= 0x20) {
fprintf (stderr, "Incompatible or insufficient options on command line!\n");
}
poptPrintHelp(pc, stderr, 0);
TALLOC_FREE(frame);
return 1;
}
/* int segs2name (poptContext *optCon, char **filename, int *seg_list); */
int main (int argc, char **argv)
{
int i, ret;
LorsExnode *exnode;
char *s;
char *output_filename = "-";
char *filename;
int same_name=0;
int v;
int file_cnt = 0;
int opts = LORS_MANAGE_CAP;
XndRc xndrc;
poptContext optCon; /* context for parsing command-line options */
struct poptOption optionsTable[] = {
{ "samename", 'f', POPT_ARG_NONE, 0, SAME_OUTPUTNAME,
"Save the modified exNode to the original exNode filename.", NULL },
{ "outputfile", 'o', POPT_ARG_STRING, &output_filename, OUTPUTNAME,
"Specify the name for the output exNode file.", NULL},
{ "read-cap", 'r', POPT_ARG_NONE, 0, LORS_READ_CAP,
"Delete the read capabilities from the exNode.", NULL},
{ "write-cap", 'w', POPT_ARG_NONE, 0, LORS_WRITE_CAP,
"Delete the write capabilities from the exNode.", NULL},
{ "manage-cap", 'm', POPT_ARG_NONE, 0, LORS_MANAGE_CAP,
"Delete the manage capabilities from the exNode.", NULL},
{ "version", 'v', POPT_ARG_NONE, 0, LORS_VERSION,
"Display Version information about this package.", NULL},
{ "verbose", 'V', POPT_ARG_INT, &xndrc.verbose, VERBOSE,
"Modify the level or mode of Verbosity in output messages.", "0"},
/* { "demo", 'D', POPT_ARG_NONE, 0, LORS_ARG_DEMO,
"Add the messages understood by the LoRS View visualization.", NULL}, */
POPT_AUTOHELP
{ NULL, 0, 0, NULL, 0 }
};
parse_xndrc_files(&xndrc);
g_lors_demo = xndrc.demo;
optCon = poptGetContext(NULL, argc, (const char **)argv, optionsTable, 0);
poptSetOtherOptionHelp(optCon, "<filename>");
if ( argc < 2 )
{
poptPrintUsage(optCon, stderr, 0);
poptPrintHelp(optCon, stderr, 0);
exit(EXIT_FAILURE);
}
while ( (v=poptGetNextOpt(optCon)) >= 0)
{
switch(v)
{
case LORS_READ_CAP:
case LORS_WRITE_CAP:
case LORS_MANAGE_CAP:
opts |= v;
break;
case SAME_OUTPUTNAME:
same_name = 1;
break;
case LORS_ARG_DEMO:
g_lors_demo = (!g_lors_demo);
break;
case LORS_VERSION:
{
const char *package;
double version;
lorsGetLibraryVersion(&package, &version);
fprintf(stderr, "Version: %s %f\n", package, version);
exit(EXIT_FAILURE);
break;
}
default:
/*fprintf(stderr, "Unsupported option: %d\n", v);*/
break;
}
}
g_db_level = xndrc.verbose;
if ( v < -1 )
{
fprintf(stderr, "error: %d\n", v);
fprintf(stderr, "%s: %s\n",
poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
poptStrerror(v));
}
while ( (filename = (char *)poptGetArg(optCon)) != NULL )
{
file_cnt++;
/* output_filename= NULL;*/
if (same_name == 1) output_filename = filename;
ret = lorsModifyFile(filename, output_filename, opts);
if ( ret != LORS_SUCCESS )
{
fprintf(stderr, "An error occured during modify: %d\n", ret);
}
}
if ( file_cnt == 0 )
{
fprintf(stderr, "Error. You must also provide a filename on "
"which lors_modify operates.\n");
poptPrintHelp(optCon, stderr, 0);
exit(EXIT_FAILURE);
}
free_xndrc(&xndrc);
poptFreeContext(optCon);
return 0;
}
int main(int argc, const char **argv)
{
NET_API_STATUS status;
struct libnetapi_ctx *ctx = NULL;
const char *hostname = NULL;
uint32_t level = 0;
uint8_t *buffer = NULL;
uint32_t entries_read = 0;
uint32_t total_entries = 0;
uint32_t resume_handle = 0;
int i;
struct SHARE_INFO_0 *i0 = NULL;
struct SHARE_INFO_1 *i1 = NULL;
struct SHARE_INFO_2 *i2 = NULL;
poptContext pc;
int opt;
struct poptOption long_options[] = {
POPT_AUTOHELP
POPT_COMMON_LIBNETAPI_EXAMPLES
POPT_TABLEEND
};
status = libnetapi_init(&ctx);
if (status != 0) {
return status;
}
pc = poptGetContext("share_enum", argc, argv, long_options, 0);
poptSetOtherOptionHelp(pc, "hostname level");
while((opt = poptGetNextOpt(pc)) != -1) {
}
if (!poptPeekArg(pc)) {
poptPrintHelp(pc, stderr, 0);
goto out;
}
hostname = poptGetArg(pc);
if (poptPeekArg(pc)) {
level = atoi(poptGetArg(pc));
}
/* NetShareEnum */
do {
status = NetShareEnum(hostname,
level,
&buffer,
(uint32_t)-1,
&entries_read,
&total_entries,
&resume_handle);
if (status == 0 || status == ERROR_MORE_DATA) {
printf("total entries: %d\n", total_entries);
switch (level) {
case 0:
i0 = (struct SHARE_INFO_0 *)buffer;
break;
case 1:
i1 = (struct SHARE_INFO_1 *)buffer;
break;
case 2:
i2 = (struct SHARE_INFO_2 *)buffer;
break;
default:
break;
}
for (i=0; i<entries_read; i++) {
switch (level) {
case 0:
printf("#%d netname: %s\n", i, i0->shi0_netname);
i0++;
break;
case 1:
printf("#%d netname: %s\n", i, i1->shi1_netname);
printf("#%d type: %d\n", i, i1->shi1_type);
printf("#%d remark: %s\n", i, i1->shi1_remark);
i1++;
break;
case 2:
printf("#%d netname: %s\n", i, i2->shi2_netname);
printf("#%d type: %d\n", i, i2->shi2_type);
printf("#%d remark: %s\n", i, i2->shi2_remark);
printf("#%d permissions: %d\n", i, i2->shi2_permissions);
printf("#%d max users: %d\n", i, i2->shi2_max_uses);
printf("#%d current users: %d\n", i, i2->shi2_current_uses);
printf("#%d path: %s\n", i, i2->shi2_path);
printf("#%d password: %s\n", i, i2->shi2_passwd);
i2++;
break;
default:
break;
}
}
NetApiBufferFree(buffer);
}
} while (status == ERROR_MORE_DATA);
if (status != 0) {
printf("NetShareEnum failed with: %s\n",
libnetapi_get_error_string(ctx, status));
}
out:
libnetapi_free(ctx);
poptFreeContext(pc);
return status;
}
static WERROR cmd_witness_RegisterEx(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
static char hostname[MAXHOSTNAMELEN] = {'\0'};
NTSTATUS status;
WERROR result = WERR_OK;
TALLOC_CTX *frame = talloc_stackframe();
struct policy_handle hnd;
const char *net_name = NULL;
const char *ip_addr = NULL;
const char *share_name = NULL;
const char *client_name = hostname;
long version = WITNESS_V2;
long flags = 0;
long timeout = 0;
int c;
poptContext optCon;
struct poptOption optionsTable[] = {
{"version", 'v', POPT_ARG_LONG|POPT_ARGFLAG_SHOW_DEFAULT, &version, WITNESS_V2, "witness version", "version"},
{"V1", '1', POPT_ARG_LONG|POPT_ARG_VAL, &version, WITNESS_V1, "witness version 1", NULL},
{"V2", '2', POPT_ARG_LONG|POPT_ARG_VAL, &version, WITNESS_V2, "witness version 2", NULL},
{"net", 'n', POPT_ARG_STRING|POPT_ARGFLAG_SHOW_DEFAULT, &net_name, 0, "net name", NULL},
{"ip", 'i', POPT_ARG_STRING|POPT_ARGFLAG_SHOW_DEFAULT, &ip_addr, 0, "ip address", NULL},
{"share", 's', POPT_ARG_STRING|POPT_ARGFLAG_SHOW_DEFAULT, &share_name, 0, "share name", NULL},
{"client", 'c', POPT_ARG_STRING|POPT_ARGFLAG_SHOW_DEFAULT|POPT_ARGFLAG_OPTIONAL, &client_name, 0, "client name", NULL},
{"flags", 'f', POPT_ARG_LONG|POPT_ARGFLAG_OR|POPT_ARGFLAG_SHOW_DEFAULT, &flags, 0, "flags", NULL},
{"timeout", 't', POPT_ARG_LONG|POPT_ARGFLAG_SHOW_DEFAULT, &timeout, 0, "timeout", NULL},
{ NULL, 0, 0, NULL, 0 }
};
use_only_one_rpc_pipe_hack(cli);
if (hostname[0] == '\0') {
gethostname (hostname, sizeof(hostname));
}
optCon = poptGetContext(NULL, argc, argv, optionsTable, 0);
while ((c = poptGetNextOpt(optCon)) >= 0) { }
if (c < -1) {
/* an error occurred during option processing */
d_fprintf(stderr, "%s: %s\n",
poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
poptStrerror(c));
goto done;
}
if (argc < 2 || poptPeekArg(optCon) != NULL) {
poptPrintHelp(optCon, stderr, 0);
goto done;
}
status = dcerpc_witness_RegisterEx(cli->binding_handle, frame,
&hnd,
version,
net_name, share_name, ip_addr, client_name,
flags, timeout,
&result);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("dcerpc_witness_RegisterEx failed, status: %s\n", nt_errstr(status)));
result = ntstatus_to_werror(status);
goto done;
}
if (!W_ERROR_IS_OK(result)) {
DEBUG(0, ("dcerpc_witness_RegisterEx failed, error: %s\n", win_errstr(result)));
goto done;
}
d_printf("%x:%s\n", hnd.handle_type, GUID_string(frame, &hnd.uuid));
done:
poptFreeContext(optCon);
talloc_free(frame);
return result;
}
int main(int argc, const char **argv)
{
poptContext pc;
int opt;
struct tevent_context *evt_ctx;
struct messaging_context *msg_ctx;
static struct poptOption long_options[] = {
/* POPT_AUTOHELP */
{ NULL, '\0', POPT_ARG_INCLUDE_TABLE, help_options,
0, "Help options:", NULL },
{ "timeout", 't', POPT_ARG_INT, &timeout, 't',
"Set timeout value in seconds", "TIMEOUT" },
POPT_COMMON_SAMBA
POPT_TABLEEND
};
TALLOC_CTX *frame = talloc_stackframe();
int ret = 0;
load_case_tables();
setup_logging(argv[0], DEBUG_STDOUT);
/* Parse command line arguments using popt */
pc = poptGetContext(
"smbcontrol", argc, (const char **)argv, long_options, 0);
poptSetOtherOptionHelp(pc, "[OPTION...] <destination> <message-type> "
"<parameters>");
if (argc == 1)
usage(pc);
while ((opt = poptGetNextOpt(pc)) != -1) {
switch(opt) {
case 't': /* --timeout */
break;
default:
fprintf(stderr, "Invalid option\n");
poptPrintHelp(pc, stderr, 0);
break;
}
}
/* We should now have the remaining command line arguments in
argv. The argc parameter should have been decremented to the
correct value in the above switch statement. */
argv = (const char **)poptGetArgs(pc);
argc = 0;
if (argv != NULL) {
while (argv[argc] != NULL) {
argc++;
}
}
if (argc <= 1)
usage(pc);
lp_load_global(get_dyn_CONFIGFILE());
/* Need to invert sense of return code -- samba
* routines mostly return True==1 for success, but
* shell needs 0. */
if (!(evt_ctx = tevent_context_init(NULL)) ||
!(msg_ctx = messaging_init(NULL, evt_ctx))) {
fprintf(stderr, "could not init messaging context\n");
TALLOC_FREE(frame);
exit(1);
}
ret = !do_command(evt_ctx, msg_ctx, argc, argv);
TALLOC_FREE(frame);
return ret;
}
int main(int argc, char **argv, char **envp)
{
int opt;
TALLOC_CTX *frame = talloc_stackframe();
poptContext pc;
static char *string_arg;
static char *opt_domain_name;
static int int_arg;
int result = 1;
bool verbose = false;
struct poptOption long_options[] = {
POPT_AUTOHELP
/* longName, shortName, argInfo, argPtr, value, descrip,
argDesc */
{ "domain-users", 'u', POPT_ARG_NONE, 0, 'u', "Lists all domain users", "domain"},
{ "domain-groups", 'g', POPT_ARG_NONE, 0, 'g', "Lists all domain groups", "domain" },
{ "WINS-by-name", 'N', POPT_ARG_STRING, &string_arg, 'N', "Converts NetBIOS name to IP", "NETBIOS-NAME" },
{ "WINS-by-ip", 'I', POPT_ARG_STRING, &string_arg, 'I', "Converts IP address to NetBIOS name", "IP" },
{ "name-to-sid", 'n', POPT_ARG_STRING, &string_arg, 'n', "Converts name to sid", "NAME" },
{ "sid-to-name", 's', POPT_ARG_STRING, &string_arg, 's', "Converts sid to name", "SID" },
{ "lookup-rids", 'R', POPT_ARG_STRING, &string_arg, 'R', "Converts RIDs to names", "RIDs" },
{ "uid-to-sid", 'U', POPT_ARG_INT, &int_arg, 'U', "Converts uid to sid" , "UID" },
{ "gid-to-sid", 'G', POPT_ARG_INT, &int_arg, 'G', "Converts gid to sid", "GID" },
{ "sid-to-uid", 'S', POPT_ARG_STRING, &string_arg, 'S', "Converts sid to uid", "SID" },
{ "sid-to-gid", 'Y', POPT_ARG_STRING, &string_arg, 'Y', "Converts sid to gid", "SID" },
{ "allocate-uid", 0, POPT_ARG_NONE, 0, OPT_ALLOCATE_UID,
"Get a new UID out of idmap" },
{ "allocate-gid", 0, POPT_ARG_NONE, 0, OPT_ALLOCATE_GID,
"Get a new GID out of idmap" },
{ "check-secret", 't', POPT_ARG_NONE, 0, 't', "Check shared secret" },
{ "trusted-domains", 'm', POPT_ARG_NONE, 0, 'm', "List trusted domains" },
{ "all-domains", 0, POPT_ARG_NONE, 0, OPT_LIST_ALL_DOMAINS, "List all domains (trusted and own domain)" },
{ "own-domain", 0, POPT_ARG_NONE, 0, OPT_LIST_OWN_DOMAIN, "List own domain" },
{ "sequence", 0, POPT_ARG_NONE, 0, OPT_SEQUENCE, "Show sequence numbers of all domains" },
{ "online-status", 0, POPT_ARG_NONE, 0, OPT_ONLINESTATUS, "Show whether domains are marked as online or offline"},
{ "domain-info", 'D', POPT_ARG_STRING, &string_arg, 'D', "Show most of the info we have about the domain" },
{ "user-info", 'i', POPT_ARG_STRING, &string_arg, 'i', "Get user info", "USER" },
{ "uid-info", 0, POPT_ARG_INT, &int_arg, OPT_UID_INFO, "Get user info from uid", "UID" },
{ "group-info", 0, POPT_ARG_STRING, &string_arg, OPT_GROUP_INFO, "Get group info", "GROUP" },
{ "user-groups", 'r', POPT_ARG_STRING, &string_arg, 'r', "Get user groups", "USER" },
{ "user-domgroups", 0, POPT_ARG_STRING, &string_arg,
OPT_USERDOMGROUPS, "Get user domain groups", "SID" },
{ "user-sids", 0, POPT_ARG_STRING, &string_arg, OPT_USERSIDS, "Get user group sids for user SID", "SID" },
{ "authenticate", 'a', POPT_ARG_STRING, &string_arg, 'a', "authenticate user", "user%password" },
{ "set-auth-user", 0, POPT_ARG_STRING, &string_arg, OPT_SET_AUTH_USER, "Store user and password used by winbindd (root only)", "user%password" },
{ "getdcname", 0, POPT_ARG_STRING, &string_arg, OPT_GETDCNAME,
"Get a DC name for a foreign domain", "domainname" },
{ "dsgetdcname", 0, POPT_ARG_STRING, &string_arg, OPT_DSGETDCNAME, "Find a DC for a domain", "domainname" },
{ "get-auth-user", 0, POPT_ARG_NONE, NULL, OPT_GET_AUTH_USER, "Retrieve user and password used by winbindd (root only)", NULL },
{ "ping", 'p', POPT_ARG_NONE, 0, 'p', "Ping winbindd to see if it is alive" },
{ "domain", 0, POPT_ARG_STRING, &opt_domain_name, OPT_DOMAIN_NAME, "Define to the domain to restrict operation", "domain" },
#ifdef WITH_FAKE_KASERVER
{ "klog", 'k', POPT_ARG_STRING, &string_arg, 'k', "set an AFS token from winbind", "user%password" },
#endif
#ifdef HAVE_KRB5
{ "krb5auth", 'K', POPT_ARG_STRING, &string_arg, 'K', "authenticate user using Kerberos", "user%password" },
/* destroys wbinfo --help output */
/* "user%password,DOM\\user%password,[email protected],EXAMPLE.COM\\user%password" }, */
#endif
{ "separator", 0, POPT_ARG_NONE, 0, OPT_SEPARATOR, "Get the active winbind separator", NULL },
{ "verbose", 0, POPT_ARG_NONE, 0, OPT_VERBOSE, "Print additional information per command", NULL },
POPT_COMMON_CONFIGFILE
POPT_COMMON_VERSION
POPT_TABLEEND
};
/* Samba client initialisation */
load_case_tables();
/* Parse options */
pc = poptGetContext("wbinfo", argc, (const char **)argv, long_options, 0);
/* Parse command line options */
if (argc == 1) {
poptPrintHelp(pc, stderr, 0);
return 1;
}
while((opt = poptGetNextOpt(pc)) != -1) {
/* get the generic configuration parameters like --domain */
switch (opt) {
case OPT_VERBOSE:
verbose = True;
break;
}
}
poptFreeContext(pc);
if (!lp_load(get_dyn_CONFIGFILE(), true, false, false, true)) {
d_fprintf(stderr, "wbinfo: error opening config file %s. Error was %s\n",
get_dyn_CONFIGFILE(), strerror(errno));
exit(1);
}
if (!init_names())
return 1;
load_interfaces();
pc = poptGetContext(NULL, argc, (const char **)argv, long_options,
POPT_CONTEXT_KEEP_FIRST);
while((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case 'u':
if (!print_domain_users(opt_domain_name)) {
d_fprintf(stderr, "Error looking up domain users\n");
goto done;
}
break;
case 'g':
if (!print_domain_groups(opt_domain_name)) {
d_fprintf(stderr, "Error looking up domain groups\n");
goto done;
}
break;
case 's':
if (!wbinfo_lookupsid(string_arg)) {
d_fprintf(stderr, "Could not lookup sid %s\n", string_arg);
goto done;
}
break;
case 'R':
if (!wbinfo_lookuprids(opt_domain_name, string_arg)) {
d_fprintf(stderr, "Could not lookup RIDs %s\n", string_arg);
goto done;
}
break;
case 'n':
if (!wbinfo_lookupname(string_arg)) {
d_fprintf(stderr, "Could not lookup name %s\n", string_arg);
goto done;
}
break;
case 'N':
if (!wbinfo_wins_byname(string_arg)) {
d_fprintf(stderr, "Could not lookup WINS by name %s\n", string_arg);
goto done;
}
break;
case 'I':
if (!wbinfo_wins_byip(string_arg)) {
d_fprintf(stderr, "Could not lookup WINS by IP %s\n", string_arg);
goto done;
}
break;
case 'U':
if (!wbinfo_uid_to_sid(int_arg)) {
d_fprintf(stderr, "Could not convert uid %d to sid\n", int_arg);
goto done;
}
break;
case 'G':
if (!wbinfo_gid_to_sid(int_arg)) {
d_fprintf(stderr, "Could not convert gid %d to sid\n",
int_arg);
goto done;
}
break;
case 'S':
if (!wbinfo_sid_to_uid(string_arg)) {
d_fprintf(stderr, "Could not convert sid %s to uid\n",
string_arg);
goto done;
}
break;
case 'Y':
if (!wbinfo_sid_to_gid(string_arg)) {
d_fprintf(stderr, "Could not convert sid %s to gid\n",
string_arg);
goto done;
}
break;
case OPT_ALLOCATE_UID:
if (!wbinfo_allocate_uid()) {
d_fprintf(stderr, "Could not allocate a uid\n");
goto done;
}
break;
case OPT_ALLOCATE_GID:
if (!wbinfo_allocate_gid()) {
d_fprintf(stderr, "Could not allocate a gid\n");
goto done;
}
break;
case 't':
if (!wbinfo_check_secret()) {
d_fprintf(stderr, "Could not check secret\n");
goto done;
}
break;
case 'm':
if (!wbinfo_list_domains(false, verbose)) {
d_fprintf(stderr, "Could not list trusted domains\n");
goto done;
}
break;
case OPT_SEQUENCE:
if (!wbinfo_show_sequence(opt_domain_name)) {
d_fprintf(stderr, "Could not show sequence numbers\n");
goto done;
}
break;
case OPT_ONLINESTATUS:
if (!wbinfo_show_onlinestatus(opt_domain_name)) {
d_fprintf(stderr, "Could not show online-status\n");
goto done;
}
break;
case 'D':
if (!wbinfo_domain_info(string_arg)) {
d_fprintf(stderr, "Could not get domain info\n");
goto done;
}
break;
case 'i':
if (!wbinfo_get_userinfo(string_arg)) {
d_fprintf(stderr, "Could not get info for user %s\n",
string_arg);
goto done;
}
break;
case OPT_UID_INFO:
if ( !wbinfo_get_uidinfo(int_arg)) {
d_fprintf(stderr, "Could not get info for uid "
"%d\n", int_arg);
goto done;
}
break;
case OPT_GROUP_INFO:
if ( !wbinfo_get_groupinfo(string_arg)) {
d_fprintf(stderr, "Could not get info for "
"group %s\n", string_arg);
goto done;
}
break;
case 'r':
if (!wbinfo_get_usergroups(string_arg)) {
d_fprintf(stderr, "Could not get groups for user %s\n",
string_arg);
goto done;
}
break;
case OPT_USERSIDS:
if (!wbinfo_get_usersids(string_arg)) {
d_fprintf(stderr, "Could not get group SIDs for user SID %s\n",
string_arg);
goto done;
}
break;
case OPT_USERDOMGROUPS:
if (!wbinfo_get_userdomgroups(string_arg)) {
d_fprintf(stderr, "Could not get user's domain groups "
"for user SID %s\n", string_arg);
goto done;
}
break;
case 'a': {
bool got_error = false;
char *pass;
if ((pass = strchr(string_arg, '%')) != NULL) {
*pass = 0;
pass++;
} else {
pass = (char *)"";
}
if (!wbinfo_auth(string_arg, pass)) {
d_fprintf(stderr, "Could not authenticate user %s with "
"plaintext password\n", string_arg);
got_error = true;
}
if (!wbinfo_auth_crap(string_arg, pass)) {
d_fprintf(stderr, "Could not authenticate user %s with "
"challenge/response\n", string_arg);
got_error = true;
}
if (got_error)
goto done;
break;
}
case 'K': {
uint32 flags = WBFLAG_PAM_KRB5 |
WBFLAG_PAM_CACHED_LOGIN |
WBFLAG_PAM_FALLBACK_AFTER_KRB5 |
WBFLAG_PAM_INFO3_TEXT;
char *pass;
if ((pass = strchr(string_arg, '%')) != NULL) {
*pass = 0;
pass++;
} else {
pass = (char *)"";
}
if (!wbinfo_auth_krb5(string_arg, pass, "FILE", flags)) {
d_fprintf(stderr, "Could not authenticate user [%s] with "
"Kerberos (ccache: %s)\n", string_arg, "FILE");
goto done;
}
break;
}
case 'k':
if (!wbinfo_klog(string_arg)) {
d_fprintf(stderr, "Could not klog user\n");
goto done;
}
break;
case 'p':
if (!wbinfo_ping()) {
d_fprintf(stderr, "could not ping winbindd!\n");
goto done;
}
break;
case OPT_SET_AUTH_USER:
if (!wbinfo_set_auth_user(string_arg)) {
goto done;
}
break;
case OPT_GET_AUTH_USER:
wbinfo_get_auth_user();
break;
case OPT_GETDCNAME:
if (!wbinfo_getdcname(string_arg)) {
goto done;
}
break;
case OPT_DSGETDCNAME:
if (!wbinfo_dsgetdcname(string_arg, 0)) {
goto done;
}
break;
case OPT_SEPARATOR: {
const char sep = winbind_separator_int(true);
if ( !sep ) {
goto done;
}
d_printf("%c\n", sep);
break;
}
case OPT_LIST_ALL_DOMAINS:
if (!wbinfo_list_domains(true, verbose)) {
goto done;
}
break;
case OPT_LIST_OWN_DOMAIN:
if (!wbinfo_list_own_domain()) {
goto done;
}
break;
/* generic configuration options */
case OPT_DOMAIN_NAME:
break;
case OPT_VERBOSE:
break;
default:
d_fprintf(stderr, "Invalid option\n");
poptPrintHelp(pc, stderr, 0);
goto done;
}
}
result = 0;
/* Exit code */
done:
talloc_destroy(frame);
poptFreeContext(pc);
return result;
}
static int nbglHandleVisArguments(int argc, const char** argv, VisArgs* visOut)
{
poptContext context;
int failed = FALSE;
static int copyright = FALSE;
static VisArgs visArgs;
static const struct poptOption options[] =
{
{
"fullscreen", 'f',
POPT_ARG_NONE, &visArgs.fullscreen,
0, "Start in screensaver mode", NULL
},
/* Since BOINC passes --fullscreen to start as a screensaver,
* and we might want to start as fullscreen but without any
* keys/moving quitting */
{
"plain-fullscreen", '\0',
POPT_ARG_NONE, &visArgs.plainFullscreen,
0, "Start as fullscreen, but without quitting on any motion", NULL
},
{
"instance-id", 'i',
POPT_ARG_INT, &visArgs.instanceId,
0, "Instance id of main process to attach", NULL
},
{
"static-input", 's',
POPT_ARG_STRING, &visArgs.file,
0, "Load from an output file (in Cartesian coordinates) and statically display", NULL
},
{
"width", 'w',
POPT_ARG_INT, &visArgs.width,
0, "Starting width of window", NULL
},
{
"height", 'h',
POPT_ARG_INT, &visArgs.height,
0, "Starting height of window", NULL
},
{
"block-simulation", 'b',
POPT_ARG_NONE, &visArgs.blockSimulation,
0, "Make simulation wait for graphics so every frame is drawn", NULL
},
{
"quit-on-complete", 'q',
POPT_ARG_NONE, &visArgs.quitOnComplete,
0, "Graphics should quit when the simulation completes", NULL
},
{
"no-float", 'r',
POPT_ARG_NONE, &visArgs.noFloat,
0, "By default do not float view around randomly", NULL
},
{
"untextured-points", 'T',
POPT_ARG_NONE, &visArgs.untexturedPoints,
0, "Use faster but possibly uglier drawing of points", NULL
},
{
"monochromatic", 'm',
POPT_ARG_NONE, &visArgs.monochromatic,
0, "All particles have same color", NULL
},
{
"origin-centered", 'o',
POPT_ARG_NONE, &visArgs.originCentered,
0, "Focus on the galactic center instead of system's center of mass", NULL
},
{
"no-show-info", 'I',
POPT_ARG_NONE, &visArgs.noDrawInfo,
0, "Disable displaying basic information about simulation", NULL
},
{
"show-axes", 'a',
POPT_ARG_NONE, &visArgs.drawAxes,
0, "Display simple axes for reference", NULL
},
{
"show-orbit-trace", 't',
POPT_ARG_NONE, &visArgs.drawOrbitTrace,
0, "Show path of center of mass", NULL
},
{
"copyright", '\0',
POPT_ARG_NONE, ©right,
0, "Print copyright information and exit", NULL
},
POPT_AUTOHELP
POPT_TABLEEND
};
/* TODO: Check project prefs */
visArgs = defaultVisArgs;
if (BOINC_APPLICATION)
{
nbglReadPreferences(&visArgs);
}
context = poptGetContext(argv[0], argc, argv, options, 0);
if (mwReadArguments(context) < 0)
{
poptPrintHelp(context, stderr, 0);
failed = TRUE;
}
poptFreeContext(context);
if (visArgs.instanceId < 0) /* Default to first */
{
visArgs.instanceId = 0;
}
if (copyright)
{
nbglPrintCopyright();
exit(0);
}
*visOut = visArgs;
return failed;
}
