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; }