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); }
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); }
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[]) { Socket* serverSock, *controlSock; int c; poptContext optCon = poptGetContext(NULL, argc, argv, options, 0); poptSetOtherOptionHelp(optCon, "configFile"); while ((c = poptGetNextOpt(optCon)) >= 0) { switch (c) { case 'v': printf(V_STRING, VERSION); printf(COPYRIGHT); return 0; } } setup_logging (logfile_name, log_level); if (c < -1) { /* an error occurred during option processing */ fprintf(stderr, "%s: %s\n", poptBadOption(optCon, POPT_BADOPTION_NOALIAS), poptStrerror(c)); return -1; } loginfo (V_STRING, VERSION); loginfo (COPYRIGHT); struct sigaction new_action, old_action; new_action.sa_handler = sigpipe_handler; sigemptyset (&new_action.sa_mask); new_action.sa_flags = 0; sigaction (SIGPIPE, NULL, &old_action); if (old_action.sa_handler != SIG_IGN) sigaction (SIGPIPE, &new_action, NULL); prepare_stdin(NULL); eventloop_init(); session = (Session*) malloc(sizeof(Session)); memset(session, 0, sizeof(Session)); session->state = ProxyState_PAUSED; serverSock = socket_server_new("proxy_server", listen_port, on_connect, NULL); controlSock = socket_server_new("proxy_server_control", listen_port + 1, on_control_connect, NULL); eventloop_on_stdin(stdin_handler, session); eventloop_run(); socket_free(serverSock); socket_free(controlSock); return(0); }
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; }
int main(int argc, char *argv[]){ char errbuf[PCAP_ERRBUF_SIZE], *device="any",*output_filename="/tmp/test.dump",*filter; const char *tmp; struct bpf_program fcode; int count=0; int timer=10; int c; poptContext context; struct poptOption optionsTable[] = { {"output", 'o', POPT_ARG_STRING, &output_filename, 'o'}, {"count", 'c', POPT_ARG_INT, &count, 'c'}, {"time", 't', POPT_ARG_INT, &timer, 't'}, {NULL,0,0,NULL,0} }; context = poptGetContext(NULL, argc, (const char **) argv, optionsTable, 0); poptSetOtherOptionHelp(context, "<tcpdump filter>"); while (poptGetNextOpt(context) >= 0) {} filter = (char *)malloc(256); strcpy (filter,""); while ((tmp = poptGetArg(context))!=NULL) { if (strcmp(filter,"")) filter = strcat(filter," "); filter = strcat(filter,tmp); } if (strcmp(filter,"")==0) filter = "port 3306"; poptFreeContext(context); printf("file=%s, count=%d, time=%d, filter=%s\n",output_filename,count,timer,filter); signal(SIGTERM, cleanup); signal(SIGALRM, cleanup); signal(SIGINT, cleanup); memset(errbuf,0,PCAP_ERRBUF_SIZE); descr = pcap_open_live(device,BUFSIZ,0,100,errbuf); if (descr == NULL) { fprintf(stderr, "Couldn't open device %s: %s\n", device, errbuf); return(2); } if (pcap_compile(descr, &fcode, filter, 0, 0) < 0){ fprintf(stderr,"can not analyze filter:%s\n", filter); exit(1); } if (pcap_setfilter(descr,&fcode) == -1) { fprintf(stderr, "filter can not use: %s\n", filter); exit(1); } dumper = pcap_dump_open(descr,output_filename); alarm(timer); pcap_loop(descr,count,write_captured_packet,NULL); pcap_close(descr); pcap_dump_close(dumper); exit(0); }
/** Process command line arguements and decide how to proceed. * Includes explanatory text for inline help and self-documentation. */ int main( int argc, char *argv[] ) { int descend_flag = 0, hadoop_flag = 0, stats_flag = 0, verbose_flag = 0, json_flag = 0; int count = 0, ret_val = 0; g_dir_arg = "."; /// set the default directory argument to "here" poptContext pc; struct poptOption po[] = { {"descend", 'd', POPT_ARG_NONE, &descend_flag, 0, UNIMPL"Parallelise and descend into subdirectories.", NULL}, {"stats", 's', POPT_ARG_NONE, &stats_flag, 0, "Print detailed statistics.", NULL}, {"verbose", 'v', POPT_ARG_NONE, &verbose_flag, 0, UNIMPL"Expand statistics output for each subdirectory.", NULL}, {"json", 'j', POPT_ARG_NONE, &json_flag, 0, UNIMPL"Write output in JSON format.", NULL}, POPT_AUTOHELP POPT_TABLEEND }; pc = poptGetContext(NULL, argc, (const char **)argv, po, 0); poptSetOtherOptionHelp(pc, "[directory]"); while ( (count = poptGetNextOpt(pc) ) >= 0 ) { printf("poptGetNextOpt return val %d\n", count); } for ( count = 0 ; poptPeekArg(pc) != NULL ; ++count ) { asprintf(&g_dir_arg, (char*)poptGetArg(pc)); if ( count > 0 ) { poptPrintUsage(pc, stderr, 0); goto EXITNOW; } } if ( descend_flag + hadoop_flag + stats_flag + verbose_flag + json_flag > 5 ) { poptPrintUsage(pc, stderr, 0); goto EXITNOW; } else { if ( descend_flag != POPT_ARG_NONE ) printf("%s: %s %s\n", PROGNAME, UNIMPL, "descend"); else if ( stats_flag != POPT_ARG_NONE ) ret_val = getdirent(g_dir_arg); else if ( verbose_flag != POPT_ARG_NONE ) printf("%s: %s %s\n", PROGNAME, UNIMPL, "verbose"); else if ( json_flag != POPT_ARG_NONE ) printf("%s: %s %s\n", PROGNAME, UNIMPL, "json"); else ret_val = quickcount(g_dir_arg); } if ( ret_val == 0 ) { exit(EXIT_SUCCESS); } else { goto EXITNOW; } EXITNOW: exit(EXIT_FAILURE); }
/* 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"); }
int main(int argc, const char *argv[]) { const char *config_file = get_dyn_CONFIGFILE(); const char *sequence = ""; poptContext pc; char *buff; TALLOC_CTX *ctx = talloc_stackframe(); struct poptOption long_options[] = { POPT_AUTOHELP POPT_COMMON_VERSION POPT_TABLEEND }; load_case_tables(); pc = poptGetContext(NULL, argc, argv, long_options, POPT_CONTEXT_KEEP_FIRST); poptSetOtherOptionHelp(pc, "[OPTION...] <sequence-string>"); while(poptGetNextOpt(pc) != -1); setup_logging(poptGetArg(pc), true); sequence = poptGetArg(pc); if (sequence == NULL) { fprintf(stderr, "ERROR: missing sequence string\n"); return 1; } dbf = x_stderr; DEBUGLEVEL = 0; AllowDebugChange = false; if (!lp_load(config_file,false,true,false,true)) { fprintf(stderr,"Error loading services.\n"); return 1; } while(next_token_talloc(ctx, &sequence, &buff, NULL)) { printf("[%s]\n", buff); } talloc_free(ctx); return 0; }
int main(int argc, const char *argv[]) { int c; char *fetch = NULL, *convert = NULL; poptContext pc; struct poptOption options[] = { USERLAND_RESERVED_OPTIONS {"fetch", 'f', POPT_ARG_STRING, &fetch, 0, "Fetch all wav files or specified wav file from the Palm", "[file|all]"}, {"convert", 'c', POPT_ARG_STRING, &convert, 0, "Convert <file>.wav.pdb file to wav", "file"}, POPT_TABLEEND }; pc = poptGetContext("pilot-wav", argc, argv, options, 0); poptSetOtherOptionHelp(pc,"\n\n" " Decodes Palm Voice Memo files to wav files you can read\n\n" " Example arguments: \n" " pilot-wav -p /dev/pilot -f MyVoiceMemo.wav.pdb\n" " pilot-wav -c MyVoiceMemo.wav.pdb\n\n"); if (argc < 2 ) { poptPrintUsage(pc,stderr,0); return 1; } while ((c = poptGetNextOpt(pc)) >= 0) { fprintf(stderr," ERROR: Unhandled option %d.\n",c); return 1; } if (c < -1) { plu_badoption(pc,c); } if(convert != NULL) pdb_to_wav(convert); if(fetch != NULL) do_fetch(fetch); return 0; }
void Popt::init(int argc, char *argv[], struct poptOption *optionsTable, const char *oh) { if(_optCon != NULL) { poptFreeContext(_optCon); } _optCon = poptGetContext(NULL, argc, const_cast<const char**>(argv), optionsTable, 0); assert(_optCon != NULL); poptSetOtherOptionHelp(_optCon, oh); const int opt = poptGetNextOpt(_optCon); if(opt != -1) { throw std::runtime_error("invalid command line"); } _args.clear(); const char *arg; while((arg = poptGetArg(_optCon)) != NULL) { _args.push_back(arg); } }
AirOptionCtx *air_option_context_new( const char *helpstr, int *argc, char ***argv, AirOptionEntry *entries) { AirOptionCtx *aoctx; #if USE_GOPTION GOptionContext *octx = NULL; #elif USE_POPT poptContext octx = NULL; int i = 0; #endif aoctx = g_new0(AirOptionCtx, 1); #if USE_GOPTION octx = g_option_context_new(helpstr); if (entries) { g_option_context_add_main_entries(octx, entries, NULL); } #elif USE_POPT aoctx->options = g_array_sized_new(TRUE, TRUE, sizeof(AirOptionEntry), 64); if (entries) { for (i=0; !AF_OPTION_EMPTY(entries[i]); i++) { g_array_append_val(aoctx->options, entries[i]); } } octx = poptGetContext(NULL, *argc, (const char **) *argv, (AirOptionEntry *) aoctx->options->data, 0); poptSetOtherOptionHelp(octx, helpstr); #endif aoctx->argc = argc; aoctx->argv = argv; aoctx->octx = octx; return aoctx; }
poptContext process_options(int argc, const char **argv, struct poptOption *options, const char *help) { int c; poptContext opts = poptGetContext(NULL, argc, argv, options, 0); poptSetOtherOptionHelp(opts, help); while ((c = poptGetNextOpt(opts)) >= 0) { /* no options require explicit handling */ } if (c < -1) { fprintf(stderr, "%s: %s\n", poptBadOption(opts, POPT_BADOPTION_NOALIAS), poptStrerror(c)); poptPrintUsage(opts, stderr, 0); exit(1); } return opts; }
bool Utils::parse(const poptContext& pc) { // http://privatemisc.blogspot.com/2012/12/popt-basic-example.html poptSetOtherOptionHelp(pc, "[ARG...]"); // process options and handle each val returned int val; while ((val = poptGetNextOpt(pc)) >= 0) { } // poptGetNextOpt returns -1 when the final argument has been parsed if (val != -1) { poptPrintUsage(pc, stderr, 0); // handle error switch (val) { case POPT_ERROR_NOARG: printf("Argument expected but missing for an option.\n"); return false; case POPT_ERROR_BADOPT: printf("Failed to parse argument.\n"); return false; case POPT_ERROR_BADNUMBER: case POPT_ERROR_OVERFLOW: printf("Option could not be converted to number\n"); return false; default: printf("Unknown error in option processing\n"); return false; } } poptFreeContext(pc); return true; }
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, 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); }
int main(int argc, const char **argv) { int ret = EXIT_SUCCESS; struct tools_ctx *tctx = NULL; const char *pc_username = NULL; int pc_debug = SSSDBG_DEFAULT; int pc_remove = 0; int pc_force = 0; int pc_kick = 0; poptContext pc = NULL; struct poptOption long_options[] = { POPT_AUTOHELP { "debug", '\0', POPT_ARG_INT | POPT_ARGFLAG_DOC_HIDDEN, &pc_debug, 0, _("The debug level to run with"), NULL }, { "remove", 'r', POPT_ARG_NONE, NULL, 'r', _("Remove home directory and mail spool"), NULL }, { "no-remove", 'R', POPT_ARG_NONE, NULL, 'R', _("Do not remove home directory and mail spool"), NULL }, { "force", 'f', POPT_ARG_NONE, NULL, 'f', _("Force removal of files not owned by the user"), NULL }, { "kick", 'k', POPT_ARG_NONE, NULL, 'k', _("Kill users' processes before removing him"), NULL }, POPT_TABLEEND }; debug_prg_name = argv[0]; ret = set_locale(); if (ret != EOK) { DEBUG(1, ("set_locale failed (%d): %s\n", ret, strerror(ret))); ERROR("Error setting the locale\n"); ret = EXIT_FAILURE; goto fini; } /* parse parameters */ pc = poptGetContext(NULL, argc, argv, long_options, 0); poptSetOtherOptionHelp(pc, "USERNAME"); while ((ret = poptGetNextOpt(pc)) > 0) { switch (ret) { case 'r': pc_remove = DO_REMOVE_HOME; break; case 'R': pc_remove = DO_NOT_REMOVE_HOME; break; case 'f': pc_force = DO_FORCE_REMOVAL; break; case 'k': pc_kick = 1; break; } } debug_level = debug_convert_old_level(pc_debug); if (ret != -1) { BAD_POPT_PARAMS(pc, poptStrerror(ret), ret, fini); } pc_username = poptGetArg(pc); if (pc_username == NULL) { BAD_POPT_PARAMS(pc, _("Specify user to delete\n"), ret, fini); } CHECK_ROOT(ret, debug_prg_name); ret = init_sss_tools(&tctx); if (ret != EOK) { DEBUG(1, ("init_sss_tools failed (%d): %s\n", ret, strerror(ret))); if (ret == ENOENT) { ERROR("Error initializing the tools - no local domain\n"); } else { ERROR("Error initializing the tools\n"); } ret = EXIT_FAILURE; goto fini; } /* if the domain was not given as part of FQDN, default to local domain */ ret = parse_name_domain(tctx, pc_username); if (ret != EOK) { ERROR("Invalid domain specified in FQDN\n"); ret = EXIT_FAILURE; goto fini; } /* * Fills in defaults for ops_ctx user did not specify. */ ret = userdel_defaults(tctx, tctx->confdb, tctx->octx, pc_remove); if (ret != EOK) { ERROR("Cannot set default values\n"); ret = EXIT_FAILURE; goto fini; } ret = sysdb_getpwnam_sync(tctx, tctx->sysdb, tctx->octx->name, tctx->octx); if (ret != EOK) { /* Error message will be printed in the switch */ goto done; } if ((tctx->octx->uid < tctx->local->id_min) || (tctx->local->id_max && tctx->octx->uid > tctx->local->id_max)) { ERROR("User %1$s is outside the defined ID range for domain\n", tctx->octx->name); ret = EXIT_FAILURE; goto fini; } if (pc_kick) { ret = kick_user(tctx); if (ret != EOK) { tctx->error = ret; goto done; } } /* userdel */ ret = userdel(tctx, tctx->sysdb, tctx->octx); if (ret != EOK) { goto done; } /* Set SELinux login context - must be done after transaction is done * b/c libselinux calls getpwnam */ ret = del_seuser(tctx->octx->name); if (ret != EOK) { ERROR("Cannot reset SELinux login context\n"); ret = EXIT_FAILURE; goto fini; } if (!pc_kick) { ret = is_logged_in(tctx, tctx->octx->uid); switch(ret) { case ENOENT: break; case EOK: ERROR("WARNING: The user (uid %1$lu) was still logged in when " "deleted.\n", (unsigned long) tctx->octx->uid); break; case ENOSYS: ERROR("Cannot determine if the user was logged in on this " "platform"); break; default: ERROR("Error while checking if the user was logged in\n"); break; } } ret = run_userdel_cmd(tctx); if (ret != EOK) { ERROR("The post-delete command failed: %1$s\n", strerror(ret)); goto fini; } if (tctx->octx->remove_homedir) { ret = remove_homedir(tctx, tctx->octx->home, tctx->octx->maildir, tctx->octx->name, tctx->octx->uid, pc_force); if (ret == EPERM) { ERROR("Not removing home dir - not owned by user\n"); } else if (ret != EOK) { ERROR("Cannot remove homedir: %1$s\n", strerror(ret)); ret = EXIT_FAILURE; goto fini; } } done: if (ret) { DEBUG(1, ("sysdb operation failed (%d)[%s]\n", ret, strerror(ret))); switch (ret) { case ENOENT: ERROR("No such user in local domain. " "Removing users only allowed in local domain.\n"); break; default: ERROR("Internal error. Could not remove user.\n"); break; } ret = EXIT_FAILURE; goto fini; } ret = EXIT_SUCCESS; fini: talloc_free(tctx); poptFreeContext(pc); exit(ret); }
/* 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; }
int main(int argc, const char **argv) { NET_API_STATUS status; struct libnetapi_ctx *ctx = NULL; const char *hostname = NULL; const char *sharename = NULL; const char *comment = "NetApi generated Share comment"; uint32_t level = 1004; uint8_t *buffer = NULL; uint32_t parm_err = 0; struct SHARE_INFO_1004 i1004; 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_setinfo", argc, argv, long_options, 0); poptSetOtherOptionHelp(pc, "hostname sharename comment"); 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); if (poptPeekArg(pc)) { comment = poptGetArg(pc); } /* NetShareSetInfo */ switch (level) { case 1004: i1004.shi1004_remark = comment; buffer = (uint8_t *)&i1004; break; default: break; } status = NetShareSetInfo(hostname, sharename, level, buffer, &parm_err); if (status != 0) { printf("NetShareSetInfo failed with: %s\n", libnetapi_get_error_string(ctx, status)); goto out; } out: libnetapi_free(ctx); poptFreeContext(pc); return status; }
/**************************************************************************** main program ****************************************************************************/ int main(int argc, const char *argv[]) { int opt; unsigned int lookup_type = 0x0; fstring lookup; static bool find_master=False; static bool lookup_by_ip = False; poptContext pc = NULL; TALLOC_CTX *frame = talloc_stackframe(); int rc = 0; struct poptOption long_options[] = { POPT_AUTOHELP { "broadcast", 'B', POPT_ARG_STRING, NULL, 'B', "Specify address to use for broadcasts", "BROADCAST-ADDRESS" }, { "flags", 'f', POPT_ARG_NONE, NULL, 'f', "List the NMB flags returned" }, { "unicast", 'U', POPT_ARG_STRING, NULL, 'U', "Specify address to use for unicast" }, { "master-browser", 'M', POPT_ARG_NONE, NULL, 'M', "Search for a master browser" }, { "recursion", 'R', POPT_ARG_NONE, NULL, 'R', "Set recursion desired in package" }, { "status", 'S', POPT_ARG_NONE, NULL, 'S', "Lookup node status as well" }, { "translate", 'T', POPT_ARG_NONE, NULL, 'T', "Translate IP addresses into names" }, { "root-port", 'r', POPT_ARG_NONE, NULL, 'r', "Use root port 137 (Win95 only replies to this)" }, { "lookup-by-ip", 'A', POPT_ARG_NONE, NULL, 'A', "Do a node status on <name> as an IP Address" }, POPT_COMMON_SAMBA POPT_COMMON_CONNECTION { 0, 0, 0, 0 } }; *lookup = 0; load_case_tables(); setup_logging(argv[0], DEBUG_STDOUT); pc = poptGetContext("nmblookup", argc, argv, long_options, POPT_CONTEXT_KEEP_FIRST); poptSetOtherOptionHelp(pc, "<NODE> ..."); while ((opt = poptGetNextOpt(pc)) != -1) { switch (opt) { case 'f': give_flags = true; break; case 'M': find_master = true; break; case 'R': recursion_desired = true; break; case 'S': find_status = true; break; case 'r': RootPort = true; break; case 'A': lookup_by_ip = true; break; case 'B': if (interpret_string_addr(&bcast_addr, poptGetOptArg(pc), NI_NUMERICHOST)) { got_bcast = True; use_bcast = True; } break; case 'U': if (interpret_string_addr(&bcast_addr, poptGetOptArg(pc), 0)) { got_bcast = True; use_bcast = False; } break; case 'T': translate_addresses = !translate_addresses; break; } } poptGetArg(pc); /* Remove argv[0] */ if(!poptPeekArg(pc)) { poptPrintUsage(pc, stderr, 0); rc = 1; goto out; } if (!lp_load_global(get_dyn_CONFIGFILE())) { fprintf(stderr, "Can't load %s - run testparm to debug it\n", get_dyn_CONFIGFILE()); } load_interfaces(); if (!open_sockets()) { rc = 1; goto out; } while(poptPeekArg(pc)) { char *p; struct in_addr ip; fstrcpy(lookup,poptGetArg(pc)); if(lookup_by_ip) { struct sockaddr_storage ss; ip = interpret_addr2(lookup); in_addr_to_sockaddr_storage(&ss, ip); fstrcpy(lookup,"*"); if (!do_node_status(lookup, lookup_type, &ss)) { rc = 1; } continue; } if (find_master) { if (*lookup == '-') { fstrcpy(lookup,"\01\02__MSBROWSE__\02"); lookup_type = 1; } else { lookup_type = 0x1d; } } p = strchr_m(lookup,'#'); if (p) { *p = '\0'; sscanf(++p,"%x",&lookup_type); } if (!query_one(lookup, lookup_type)) { rc = 1; d_printf( "name_query failed to find name %s", lookup ); if( 0 != lookup_type ) { d_printf( "#%02x", lookup_type ); } d_printf( "\n" ); } } out: poptFreeContext(pc); TALLOC_FREE(frame); return rc; }
int main(int argc, const char **argv) { uid_t pc_uid = 0; const char *pc_gecos = NULL; const char *pc_home = NULL; char *pc_shell = NULL; int pc_debug = SSSDBG_DEFAULT; int pc_create_home = 0; const char *pc_username = NULL; const char *pc_skeldir = NULL; const char *pc_selinux_user = NULL; struct poptOption long_options[] = { POPT_AUTOHELP { "debug", '\0', POPT_ARG_INT | POPT_ARGFLAG_DOC_HIDDEN, &pc_debug, 0, _("The debug level to run with"), NULL }, { "uid", 'u', POPT_ARG_INT, &pc_uid, 0, _("The UID of the user"), NULL }, { "gecos", 'c', POPT_ARG_STRING, &pc_gecos, 0, _("The comment string"), NULL }, { "home", 'h', POPT_ARG_STRING, &pc_home, 0, _("Home directory"), NULL }, { "shell", 's', POPT_ARG_STRING, &pc_shell, 0, _("Login shell"), NULL }, { "groups", 'G', POPT_ARG_STRING, NULL, 'G', _("Groups"), NULL }, { "create-home", 'm', POPT_ARG_NONE, NULL, 'm', _("Create user's directory if it does not exist"), NULL }, { "no-create-home", 'M', POPT_ARG_NONE, NULL, 'M', _("Never create user's directory, overrides config"), NULL }, { "skel", 'k', POPT_ARG_STRING, &pc_skeldir, 0, _("Specify an alternative skeleton directory"), NULL }, { "selinux-user", 'Z', POPT_ARG_STRING, &pc_selinux_user, 0, _("The SELinux user for user's login"), NULL }, POPT_TABLEEND }; poptContext pc = NULL; struct tools_ctx *tctx = NULL; char *groups = NULL; char *badgroup = NULL; int ret; errno_t sret; bool in_transaction = false; debug_prg_name = argv[0]; ret = set_locale(); if (ret != EOK) { DEBUG(SSSDBG_CRIT_FAILURE, "set_locale failed (%d): %s\n", ret, strerror(ret)); ERROR("Error setting the locale\n"); ret = EXIT_FAILURE; goto fini; } /* parse parameters */ pc = poptGetContext(NULL, argc, argv, long_options, 0); poptSetOtherOptionHelp(pc, "USERNAME"); while ((ret = poptGetNextOpt(pc)) > 0) { switch (ret) { case 'G': groups = poptGetOptArg(pc); if (!groups) { BAD_POPT_PARAMS(pc, _("Specify group to add to\n"), ret, fini); } break; case 'm': pc_create_home = DO_CREATE_HOME; break; case 'M': pc_create_home = DO_NOT_CREATE_HOME; break; } } DEBUG_CLI_INIT(pc_debug); if (ret != -1) { BAD_POPT_PARAMS(pc, poptStrerror(ret), ret, fini); } /* username is an argument without --option */ pc_username = poptGetArg(pc); if (pc_username == NULL) { BAD_POPT_PARAMS(pc, _("Specify user to add\n"), ret, fini); } CHECK_ROOT(ret, debug_prg_name); ret = init_sss_tools(&tctx); if (ret != EOK) { DEBUG(SSSDBG_CRIT_FAILURE, "init_sss_tools failed (%d): %s\n", ret, strerror(ret)); if (ret == ENOENT) { ERROR("Error initializing the tools - no local domain\n"); } else { ERROR("Error initializing the tools\n"); } ret = EXIT_FAILURE; goto fini; } /* if the domain was not given as part of FQDN, default to local domain */ ret = parse_name_domain(tctx, pc_username); if (ret != EOK) { ERROR("Invalid domain specified in FQDN\n"); ret = EXIT_FAILURE; goto fini; } if (groups) { ret = parse_groups(tctx, groups, &tctx->octx->addgroups); if (ret != EOK) { DEBUG(SSSDBG_CRIT_FAILURE, "Cannot parse groups to add the user to\n"); ERROR("Internal error while parsing parameters\n"); ret = EXIT_FAILURE; goto fini; } ret = parse_group_name_domain(tctx, tctx->octx->addgroups); if (ret != EOK) { DEBUG(SSSDBG_CRIT_FAILURE, "Cannot parse FQDN groups to add the user to\n"); ERROR("Groups must be in the same domain as user\n"); ret = EXIT_FAILURE; goto fini; } /* Check group names in the LOCAL domain */ ret = check_group_names(tctx, tctx->octx->addgroups, &badgroup); if (ret != EOK) { ERROR("Cannot find group %1$s in local domain\n", badgroup); ret = EXIT_FAILURE; goto fini; } } tctx->octx->uid = pc_uid; /* * Fills in defaults for ops_ctx user did not specify. */ ret = useradd_defaults(tctx, tctx->confdb, tctx->octx, pc_gecos, pc_home, pc_shell, pc_create_home, pc_skeldir); if (ret != EOK) { ERROR("Cannot set default values\n"); ret = EXIT_FAILURE; goto fini; } /* arguments processed, go on to actual work */ if (id_in_range(tctx->octx->uid, tctx->octx->domain) != EOK) { ERROR("The selected UID is outside the allowed range\n"); ret = EXIT_FAILURE; goto fini; } tctx->error = sysdb_transaction_start(tctx->sysdb); if (tctx->error != EOK) { DEBUG(SSSDBG_CRIT_FAILURE, "Failed to start transaction\n"); goto done; } in_transaction = true; /* useradd */ tctx->error = useradd(tctx, tctx->octx); if (tctx->error) { goto done; } tctx->error = sysdb_transaction_commit(tctx->sysdb); if (tctx->error) { DEBUG(SSSDBG_CRIT_FAILURE, "Failed to commit transaction\n"); goto done; } in_transaction = false; /* Set SELinux login context - must be done after transaction is done * b/c libselinux calls getpwnam */ ret = set_seuser(tctx->octx->name, pc_selinux_user, NULL); if (ret != EOK) { ERROR("Cannot set SELinux login context\n"); ret = EXIT_FAILURE; goto fini; } /* Create user's home directory and/or mail spool */ if (tctx->octx->create_homedir) { /* We need to know the UID of the user, if * sysdb did assign it automatically, do a lookup */ if (tctx->octx->uid == 0) { ret = sysdb_getpwnam_sync(tctx, tctx->octx->name, tctx->octx); if (ret != EOK) { ERROR("Cannot get info about the user\n"); ret = EXIT_FAILURE; goto fini; } } ret = create_homedir(tctx->octx->skeldir, tctx->octx->home, tctx->octx->uid, tctx->octx->gid, tctx->octx->umask); if (ret == EEXIST) { ERROR("User's home directory already exists, not copying " "data from skeldir\n"); } else if (ret != EOK) { ERROR("Cannot create user's home directory: %1$s\n", strerror(ret)); ret = EXIT_FAILURE; goto fini; } ret = create_mail_spool(tctx, tctx->octx->name, tctx->octx->maildir, tctx->octx->uid, tctx->octx->gid); if (ret != EOK) { ERROR("Cannot create user's mail spool: %1$s\n", strerror(ret)); DEBUG(SSSDBG_CRIT_FAILURE, "Cannot create user's mail spool: [%d][%s].\n", ret, strerror(ret)); ret = EXIT_FAILURE; goto fini; } } done: if (in_transaction) { sret = sysdb_transaction_cancel(tctx->sysdb); if (sret != EOK) { DEBUG(SSSDBG_CRIT_FAILURE, "Failed to cancel transaction\n"); } } if (tctx->error) { switch (tctx->error) { case ERANGE: ERROR("Could not allocate ID for the user - domain full?\n"); break; case EEXIST: ERROR("A user or group with the same name or ID already exists\n"); break; default: DEBUG(SSSDBG_CRIT_FAILURE, "sysdb operation failed (%d)[%s]\n", tctx->error, strerror(tctx->error)); ERROR("Transaction error. Could not add user.\n"); break; } ret = EXIT_FAILURE; goto fini; } ret = EXIT_SUCCESS; fini: poptFreeContext(pc); talloc_free(tctx); free(groups); exit(ret); }
int main(int argc, const char **argv) { int i; char c; int linestoread = 1; char *outpath = NULL; char *errpath = NULL; poptContext poptcxt; const char **addl = NULL; const char *regexp = NULL; const char *command = NULL; unsigned long numaddl = 0; CDCDiscoveryResults *discovery; // I/O defaults. in = stdin; out = stdout; err = stderr; struct poptOption options[] = { // --output,-o { "output", 'o', POPT_ARG_STRING, &outpath, 0, "output file (DEFAULT=stdout)", "path|-" }, // --error,-e { "error", 'e', POPT_ARG_STRING, &errpath, 0, "error file (DEFAULT=stderr)", "path|-" }, // --lines,-l { "lines", 'l', POPT_ARG_INT, &linestoread, 0, "Number of lines to read from the serial port before exiting. Zero is the same as -r. (DEFAULT=1)" }, // --help,-? POPT_AUTOHELP // end { NULL, 0, 0, NULL, 0 } }; // Process popt options. poptcxt = poptGetContext(NULL, argc, argv, options, 0); poptSetOtherOptionHelp( poptcxt, "[OPTIONS]* <command> <regexp> (additional port)+" ); if (argc < 2) { usage(poptcxt, 0, 0, 0); } while ((c = poptGetNextOpt(poptcxt)) >= 0) { ; } if (c < -1) { // An error occurred during option processing. fprintf( stderr, "%s: %s\n", poptBadOption(poptcxt, POPT_BADOPTION_NOALIAS), poptStrerror(c) ); return 1; } // Check error file. if (errpath && strcmp(errpath, "-") != 0) { err = fopen(errpath, "a"); if (!err) { usage(poptcxt, 2, "Cannot open error file path", errpath); } } // Check output file. if (outpath && strcmp(outpath, "-") != 0) { out = fopen(outpath, "a"); if (!out) { usage(poptcxt, 3, "Cannot open output file path", outpath); } } // Get the command and regular expression query. command = poptGetArg(poptcxt); regexp = poptGetArg(poptcxt); if ((command == NULL) || (regexp == NULL)) { usage( poptcxt, 1, "Please specify", "<command> <regex>" ); } // Additional ports to check. while (poptPeekArg(poptcxt)) { addl = (const char**)realloc(addl, (++numaddl) * sizeof(char*)); addl[numaddl] = poptGetArg(poptcxt); } // Discovery. discovery = cdc_discover(command, regexp, linestoread, numaddl, addl); for (i=0; i<discovery->matches; i++) { fprintf(out, "%s\n", discovery->match[i]); } cdc_discover_free_results(discovery); // Cleanup. if (numaddl) { free(addl); } poptFreeContext(poptcxt); return 0; }
int main (int argc, const char *argv[]) { FILE *pOutputSmsFile; SMS_Data smsData; SMS_Header smsHeader; float pSoundData[SMS_MAX_WINDOW]; SMS_SndHeader soundHeader; char *pChInputSoundFile = NULL, *pChOutputSmsFile = NULL; int verbose = 0; int iDoAnalysis = 1; int iFrame = 0; long iStatus = 0, iSample = 0, sizeNewData = 0; int optc; /* switch */ poptContext pc; SMS_AnalParams analParams; sms_initAnalParams(&analParams); /* initialize arguments to defaults*/ struct poptOption options[] = { {"verbose", 'v', POPT_ARG_NONE, &verbose, 0, "verbose mode", 0}, {"debug", 'd', POPT_ARG_INT, &analParams.iDebugMode, 0, "debug mode (0)", "int"}, {"format", 'f', POPT_ARG_INT, &analParams.iFormat, 0, "analysis format (0, harmonic)", "int"}, {"sound-type", 'q', POPT_ARG_INT, &analParams.iSoundType, 0, "sound type (0, phrase)", "int"}, {"direction", 'x', POPT_ARG_INT, &analParams.iAnalysisDirection, 0, "analysis direction (0, forward)", "int"}, /* STFT Parameters: */ {"window-size", 's', POPT_ARG_FLOAT, &analParams.fSizeWindow, 0, "size of the window in f0 periods (3.5)", "float"}, {"window-type", 'i', POPT_ARG_INT, &analParams.iWindowType, 0, "window type (1, blackman harris 70 dB)", "int"}, {"frame-rate", 'r', POPT_ARG_INT, &analParams.iFrameRate, 0, "frame rate in hertz (300)", "int"}, /* Peak Detection Parameters */ {"highest-freq", 'j', POPT_ARG_FLOAT, &analParams.fHighestFreq, 0, "highest frequency to look for peaks (12000hz)", "float"}, {"min-peak-mag", 'k', POPT_ARG_FLOAT, &analParams.fMinPeakMag, 0, "minimum peak magnitude (0 normalized dB, which corresponds to -100dB)", "float"}, /*\todo check this doc*/ /* Harmonic Detection Parameters */ {"ref-harmonic", 'y', POPT_ARG_INT, &analParams.iRefHarmonic, 0, "reference harmonic number in series (1)", "int"}, {"min-ref-harm-mag", 'm', POPT_ARG_FLOAT, &analParams.fMinPeakMag, 0, "minimum reference harmonic magnitude (30 normalized dB)", "float"}, /*\todo check this doc*/ {"min-ref-harm-mag", 'z', POPT_ARG_FLOAT, &analParams.fRefHarmMagDiffFromMax, 0, " maximum dB difference between the harmonic used for reference and the maximum peak (default 30)", "float"}, /*\todo check this doc*/ {"default-fund", 'u', POPT_ARG_FLOAT, &analParams.fDefaultFundamental, 0, "default fundamental frequency (hz), used to set initial window size, or window size for entire sound if inharmonic (default 100)", "float"}, {"lowest-fund", 'l', POPT_ARG_FLOAT, &analParams.fDefaultFundamental, 0, "lowest fundamental frequency(hz), or frequency in inharmonic analysis, to search for (default 50)", "float"}, {"highest-fund", 'h', POPT_ARG_FLOAT, &analParams.fDefaultFundamental, 0, "highest fundamental frequency to search for, has no effect on inharmonic analysis (default 1000)", "float"}, /* Peak Continuation parameters */ {"guides", 'n', POPT_ARG_INT, &analParams.nGuides, 0, "number of guides to use in partial tracking (default 100)", "int"}, {"tracks", 'p', POPT_ARG_INT, &analParams.nTracks, 0, "number of output partial tracks (default 60)", "int"}, {"freq-deviation", 'w', POPT_ARG_FLOAT, &analParams.fFreqDeviation, 0, "maximum permitted frequency deviation from guide frequency (default .45)", "float"}, {"peak-cont-guide", 't', POPT_ARG_FLOAT, &analParams.fPeakContToGuide, 0, "contribution of the frequency of the previous peak of a given trajectory to the current guide frequency value (default .4).", "float"}, {"fund-cont-guide", 'o', POPT_ARG_FLOAT, &analParams.fFundContToGuide, 0, "contribution of the fundamental frequency of the previous peak of a given trajectory to the current guide frequency value (default .5).", "float"}, /* Track Cleaning parameters:\n" */ {"clean-track", 'g', POPT_ARG_INT, &analParams.iCleanTracks, 0, "turn on/off track cleaning (default is on, 1)", "int"}, {"min-track-length", 'a', POPT_ARG_FLOAT, &analParams.iMinTrackLength, 0, "minimum track length in seconds (0.1)", "float"}, {"max-sleeping-time", 'b', POPT_ARG_FLOAT, &analParams.iMaxSleepingTime, 0, "maximum time a frame can sleep in seconds (0.1)", "float"}, /* this doc is horrible */ /* Stochastic Analysis parameters */ {"stochastic", 'e', POPT_ARG_INT, &analParams.iStochasticType, 0, "turn on/off stochastic analysis (default is on, 1)", "int"}, {"stoch-coeff", 'c', POPT_ARG_INT, &analParams.nStochasticCoeff, 0, "number of stochastic coefficients in approximation (default 128)", "int"}, /* spectral enveloping parameters */ {"se",0, POPT_ARG_INT, &analParams.specEnvParams.iType, 0, "spectral enveloping type (0, off)", "int"}, {"co", 0, POPT_ARG_INT, &analParams.specEnvParams.iOrder, 0, "discrete cepstrum order (25)", "int"}, {"la", 0, POPT_ARG_FLOAT, &analParams.specEnvParams.fLambda, 0, "lambda, regularizing coefficient (0.00001)", "float"}, {"an", 0, POPT_ARG_NONE, &analParams.specEnvParams.iAnchor, 0, "turn on anchoring of spectral envelope endpoints", 0}, {"mef", 0, POPT_ARG_INT, &analParams.specEnvParams.iMaxFreq, 0, "maximum envelope frequency (default is highest-freq", "int"}, POPT_AUTOHELP POPT_TABLEEND }; pc = poptGetContext("smsAnal", argc, argv, options, 0); poptSetOtherOptionHelp(pc, help_header_text); while ((optc = poptGetNextOpt(pc)) > 0) { switch (optc) { /* specific arguments are handled here */ case 'v': verbose = 1; default: ; } } if (optc < -1) { /* an error occurred during option processing */ printf("%s: %s\n", poptBadOption(pc, POPT_BADOPTION_NOALIAS), poptStrerror(optc)); return 1; } if (argc < 3) { poptPrintUsage(pc,stderr,0); return 1; } pChInputSoundFile = (char *) poptGetArg(pc); pChOutputSmsFile = (char *) poptGetArg(pc); /* parsing done */ /* open input sound */ if (sms_openSF(pChInputSoundFile, &soundHeader)) { printf("error in sms_openSF: %s \n", sms_errorString()); exit(EXIT_FAILURE); } /* initialize everything */ sms_init(); /* TODO NExt: go from here through all the functions that need to look at specEnvParams */ sms_initAnalysis (&analParams, &soundHeader); sms_fillHeader (&smsHeader, &analParams, "smsAnal"); sms_writeHeader (pChOutputSmsFile, &smsHeader, &pOutputSmsFile); /* allocate output SMS record */ sms_allocFrameH (&smsHeader, &smsData); /* perform analysis */ if (analParams.iAnalysisDirection == SMS_DIR_REV) iSample = soundHeader.nSamples; if (analParams.iDebugMode == SMS_DBG_SYNC) sms_createDebugFile (&analParams); if(verbose) { printf("\n===sound file info===\n"); printf("samples: %d, samplerate: %d, seconds: %f \n", soundHeader.nSamples, soundHeader.iSamplingRate, soundHeader.nSamples / (float)soundHeader.iSamplingRate); printf("number of channels: %d, read channel: %d \n", soundHeader.channelCount, soundHeader.iReadChannel); printf("\n===analysis parameters===\n"); printf("sizeHop: %d, nFrames: %d \n", analParams.sizeHop, analParams.nFrames); /* \todo: print analysis window type (by name) here */ if(analParams.specEnvParams.iType != SMS_ENV_NONE) { printf("\n===spectral envelope parameters===\n"); if(analParams.specEnvParams.iType == SMS_ENV_CEP) printf("type: cepstral coefficients, "); else if(analParams.specEnvParams.iType == SMS_ENV_FBINS) printf("type: frequency bins, "); else printf("warning: unknown spectral envelope type! \n\n "); printf("order: %d, lambda: %f, max frequency: %d \n", analParams.specEnvParams.iOrder, analParams.specEnvParams.fLambda, analParams.specEnvParams.iMaxFreq); } printf("\n===header info string===\n %s", smsHeader.pChTextCharacters); printf("\n\ndoing analysis now:\n"); } while(iDoAnalysis > 0) { if (analParams.iAnalysisDirection == SMS_DIR_REV) { if ((iSample - analParams.sizeNextRead) >= 0) sizeNewData = analParams.sizeNextRead; else sizeNewData = iSample; iSample -= sizeNewData; } else { iSample += sizeNewData; if((iSample + analParams.sizeNextRead) < soundHeader.nSamples) sizeNewData = analParams.sizeNextRead; else sizeNewData = soundHeader.nSamples - iSample; } /* get one frame of sound */ if (sms_getSound(&soundHeader, sizeNewData, pSoundData, iSample, &analParams)) { printf("error: could not read sound frame %d\n", iFrame); printf("error message in sms_getSound: %s \n", sms_errorString()); break; } /* perform analysis of one frame of sound */ iStatus = sms_analyze (sizeNewData, pSoundData, &smsData, &analParams); /* if there is an output SMS record, write it */ if (iStatus == 1) { sms_writeFrame (pOutputSmsFile, &smsHeader, &smsData); if(sms_errorCheck()) { printf("error: could not write sms frame %d:\n", iFrame); printf("error message in sms_writeFrame: %s \n", sms_errorString()); break; } if(verbose) { /* if (iFrame % 10 == 0) */ /* printf ("frame: %d, %.2f \n", iFrame, iFrame / (float) smsHeader.iFrameRate); */ if (iFrame % 10 == 0) printf ("%.2f ", iFrame / (float) smsHeader.iFrameRate); } iFrame++; } else if (iStatus == -1) /* done */ { iDoAnalysis = 0; smsHeader.nFrames = iFrame; } } smsHeader.fResidualPerc = analParams.fResidualAccumPerc / iFrame; if(verbose) { printf("\n"); printf("residual percentage: %f \n", smsHeader.fResidualPerc); } if(smsHeader.nFrames != analParams.nFrames && verbose) printf("warning: wrong number of analyzed frames: analParams: %d, smsHeader: %d \n", analParams.nFrames, smsHeader.nFrames); /* write an close output files */ sms_writeFile (pOutputSmsFile, &smsHeader); if (analParams.iDebugMode == SMS_DBG_SYNC) sms_writeDebugFile (); printf("wrote %d analysis frames to %s\n", iFrame, pChOutputSmsFile); /* cleanup */ sms_freeFrame(&smsData); sms_freeAnalysis(&analParams); sms_free(); return 0; }
int parse_options(int argc, char **argv) { // there are potential memory leaks here -- it's called a second time, previously allocated strings will dangle. char *raw_service_name = NULL; /* Used to pick up the service name before possibly expanding it */ char *stuffing = NULL; /* used for picking up the stuffing option */ signed char c; /* used for argument parsing */ int i = 0; /* used for tracking options */ poptContext optCon; /* context for parsing command-line options */ struct poptOption optionsTable[] = { {"verbose", 'v', POPT_ARG_NONE, NULL, 'v', NULL}, {"disconnectFromOutput", 'D', POPT_ARG_NONE, NULL, 0, NULL}, {"reconnectToOutput", 'R', POPT_ARG_NONE, NULL, 0, NULL}, {"kill", 'k', POPT_ARG_NONE, NULL, 0, NULL}, {"daemon", 'd', POPT_ARG_NONE, &config.daemonise, 0, NULL}, {"configfile", 'c', POPT_ARG_STRING, &config.configfile, 0, NULL}, {"statistics", 0, POPT_ARG_NONE, &config.statistics_requested, 0, NULL}, {"version", 'V', POPT_ARG_NONE, NULL, 0, NULL}, {"port", 'p', POPT_ARG_INT, &config.port, 0, NULL}, {"name", 'a', POPT_ARG_STRING, &raw_service_name, 0, NULL}, {"output", 'o', POPT_ARG_STRING, &config.output_name, 0, NULL}, {"on-start", 'B', POPT_ARG_STRING, &config.cmd_start, 0, NULL}, {"on-stop", 'E', POPT_ARG_STRING, &config.cmd_stop, 0, NULL}, {"wait-cmd", 'w', POPT_ARG_NONE, &config.cmd_blocking, 0, NULL}, {"mdns", 'm', POPT_ARG_STRING, &config.mdns_name, 0, NULL}, {"latency", 'L', POPT_ARG_INT, &config.userSuppliedLatency, 0, NULL}, {"AirPlayLatency", 'A', POPT_ARG_INT, &config.AirPlayLatency, 0, NULL}, {"iTunesLatency", 'i', POPT_ARG_INT, &config.iTunesLatency, 0, NULL}, {"forkedDaapdLatency", 0, POPT_ARG_INT, &config.ForkedDaapdLatency, 0, NULL}, {"stuffing", 'S', POPT_ARG_STRING, &stuffing, 'S', NULL}, {"resync", 'r', POPT_ARG_INT, &config.resyncthreshold, 0, NULL}, {"timeout", 't', POPT_ARG_INT, &config.timeout, 't', NULL}, {"password", 0, POPT_ARG_STRING, &config.password, 0, NULL}, {"tolerance", 0, POPT_ARG_INT, &config.tolerance, 0, NULL}, #ifdef CONFIG_METADATA {"metadata-pipename", 'M', POPT_ARG_STRING, &config.metadata_pipename, 'M', NULL}, {"get-coverart", 'g', POPT_ARG_NONE, &config.get_coverart, 'g', NULL}, #endif POPT_AUTOHELP {NULL, 0, 0, NULL, 0}}; // we have to parse the command line arguments to look for a config file int optind; optind = argc; int j; for (j = 0; j < argc; j++) if (strcmp(argv[j], "--") == 0) optind = j; optCon = poptGetContext(NULL, optind, (const char **)argv, optionsTable, 0); poptSetOtherOptionHelp(optCon, "[OPTIONS]* "); /* Now do options processing just to get a debug level */ debuglev = 0; while ((c = poptGetNextOpt(optCon)) >= 0) { switch (c) { case 'v': debuglev++; break; } } if (c < -1) { die("%s: %s", poptBadOption(optCon, POPT_BADOPTION_NOALIAS), poptStrerror(c)); } config_setting_t *setting; const char *str=0; int value=0; debug(1,"Looking for the configuration file \"%s\".",config.configfile); config_init(&config_file_stuff); char *config_file_real_path = realpath(config.configfile, NULL); if (config_file_real_path==NULL) { debug(2,"Can't resolve the configuration file \"%s\".",config.configfile); } else { debug(2, "Looking for configuration file at full path \"%s\"", config_file_real_path); /* Read the file. If there is an error, report it and exit. */ if (config_read_file(&config_file_stuff, config_file_real_path)) { // make config.cfg point to it config.cfg = &config_file_stuff; /* Get the Service Name. */ if (config_lookup_string(config.cfg, "general.name", &str)) { raw_service_name = (char *)str; } /* Get the Daemonize setting. */ if (config_lookup_string(config.cfg, "general.daemonize", &str)) { if (strcasecmp(str, "no") == 0) config.daemonise = 0; else if (strcasecmp(str, "yes") == 0) config.daemonise = 1; else die("Invalid daemonize option choice \"%s\". It should be \"yes\" or \"no\""); } /* Get the mdns_backend setting. */ if (config_lookup_string(config.cfg, "general.mdns_backend", &str)) config.mdns_name = (char *)str; /* Get the output_backend setting. */ if (config_lookup_string(config.cfg, "general.output_backend", &str)) config.output_name = (char *)str; /* Get the port setting. */ if (config_lookup_int(config.cfg, "general.port", &value)) { if ((value < 0) || (value > 65535)) die("Invalid port number \"%sd\". It should be between 0 and 65535, default is 5000", value); else config.port = value; } /* Get the udp port base setting. */ if (config_lookup_int(config.cfg, "general.udp_port_base", &value)) { if ((value < 0) || (value > 65535)) die("Invalid port number \"%sd\". It should be between 0 and 65535, default is 6001", value); else config.udp_port_base = value; } /* Get the udp port range setting. This is number of ports that will be tried for free ports , starting at the port base. Only three ports are needed. */ if (config_lookup_int(config.cfg, "general.udp_port_range", &value)) { if ((value < 0) || (value > 65535)) die("Invalid port range \"%sd\". It should be between 0 and 65535, default is 100", value); else config.udp_port_range = value; } /* Get the password setting. */ if (config_lookup_string(config.cfg, "general.password", &str)) config.password = (char *)str; if (config_lookup_string(config.cfg, "general.interpolation", &str)) { if (strcasecmp(str, "basic") == 0) config.packet_stuffing = ST_basic; else if (strcasecmp(str, "soxr") == 0) config.packet_stuffing = ST_soxr; else die("Invalid interpolation option choice \"%s\". It should be \"basic\" or \"soxr\""); } /* Get the statistics setting. */ if (config_lookup_string(config.cfg, "general.statistics", &str)) { if (strcasecmp(str, "no") == 0) config.statistics_requested = 0; else if (strcasecmp(str, "yes") == 0) config.statistics_requested = 1; else die("Invalid statistics option choice \"%s\". It should be \"yes\" or \"no\""); } /* Get the drift tolerance setting. */ if (config_lookup_int(config.cfg, "general.drift", &value)) config.tolerance = value; /* Get the resync setting. */ if (config_lookup_int(config.cfg, "general.resync_threshold", &value)) config.resyncthreshold = value; /* Get the verbosity setting. */ if (config_lookup_int(config.cfg, "general.log_verbosity", &value)) { if ((value >= 0) && (value <= 3)) debuglev = value; else die("Invalid log verbosity setting option choice \"%d\". It should be between 0 and 3, " "inclusive.", value); } /* Get the ignore_volume_control setting. */ if (config_lookup_string(config.cfg, "general.ignore_volume_control", &str)) { if (strcasecmp(str, "no") == 0) config.ignore_volume_control = 0; else if (strcasecmp(str, "yes") == 0) config.ignore_volume_control = 1; else die("Invalid ignore_volume_control option choice \"%s\". It should be \"yes\" or \"no\""); } /* Get the playback_mode setting */ if (config_lookup_string(config.cfg, "general.playback_mode", &str)) { if (strcasecmp(str, "stereo") == 0) config.playback_mode = ST_stereo; else if (strcasecmp(str, "mono") == 0) config.playback_mode = ST_mono; else die("Invalid playback_mode choice \"%s\". It should be \"stereo\" (default) or \"mono\""); } /* Get the regtype -- the service type and protocol, separated by a dot. Default is "_raop._tcp" */ if (config_lookup_string(config.cfg, "general.regtype", &str)) config.regtype = strdup(str); /* Get the volume range, in dB, that should be used If not set, it means you just use the range set by the mixer. */ if (config_lookup_int(config.cfg, "general.volume_range_db", &value)) { if ((value < 30) || (value > 150)) die("Invalid volume range \"%sd\". It should be between 30 and 150 dB. Zero means use the mixer's native range", value); else config.volume_range_db = value; } /* Get the default latency. Deprecated! */ if (config_lookup_int(config.cfg, "latencies.default", &value)) config.userSuppliedLatency = value; /* Get the itunes latency. Deprecated! */ if (config_lookup_int(config.cfg, "latencies.itunes", &value)) config.iTunesLatency = value; /* Get the AirPlay latency. Deprecated! */ if (config_lookup_int(config.cfg, "latencies.airplay", &value)) config.AirPlayLatency = value; /* Get the forkedDaapd latency. Deprecated! */ if (config_lookup_int(config.cfg, "latencies.forkedDaapd", &value)) config.ForkedDaapdLatency = value; #ifdef CONFIG_METADATA /* Get the metadata setting. */ if (config_lookup_string(config.cfg, "metadata.enabled", &str)) { if (strcasecmp(str, "no") == 0) config.metadata_enabled = 0; else if (strcasecmp(str, "yes") == 0) config.metadata_enabled = 1; else die("Invalid metadata enabled option choice \"%s\". It should be \"yes\" or \"no\""); } if (config_lookup_string(config.cfg, "metadata.include_cover_art", &str)) { if (strcasecmp(str, "no") == 0) config.get_coverart = 0; else if (strcasecmp(str, "yes") == 0) config.get_coverart = 1; else die("Invalid metadata include_cover_art option choice \"%s\". It should be \"yes\" or " "\"no\""); } if (config_lookup_string(config.cfg, "metadata.pipe_name", &str)) { config.metadata_pipename = (char *)str; } if (config_lookup_string(config.cfg, "metadata.socket_address", &str)) { config.metadata_sockaddr = (char *)str; } if (config_lookup_int(config.cfg, "metadata.socket_port", &value)) { config.metadata_sockport = value; } config.metadata_sockmsglength = 500; if (config_lookup_int(config.cfg, "metadata.socket_msglength", &value)) { config.metadata_sockmsglength = value < 500 ? 500 : value > 65000 ? 65000 : value; } if (config_lookup_int(config.cfg, "metadata.pipe_timeout", &value)) { if ((value < 1) || (value > 150000)) die("Invalid timeout range \"%sd\". It should be in the range 1 to 150,000 milliseconds.", value); else config.metadata_pipe_timeout = value; } #endif if (config_lookup_string(config.cfg, "sessioncontrol.run_this_before_play_begins", &str)) { config.cmd_start = (char *)str; } if (config_lookup_string(config.cfg, "sessioncontrol.run_this_after_play_ends", &str)) { config.cmd_stop = (char *)str; } if (config_lookup_string(config.cfg, "sessioncontrol.wait_for_completion", &str)) { if (strcasecmp(str, "no") == 0) config.cmd_blocking = 0; else if (strcasecmp(str, "yes") == 0) config.cmd_blocking = 1; else die("Invalid session control wait_for_completion option choice \"%s\". It should be " "\"yes\" or \"no\""); } if (config_lookup_string(config.cfg, "sessioncontrol.allow_session_interruption", &str)) { config.dont_check_timeout = 0; // this is for legacy -- only set by -t 0 if (strcasecmp(str, "no") == 0) config.allow_session_interruption = 0; else if (strcasecmp(str, "yes") == 0) config.allow_session_interruption = 1; else die("Invalid session control allow_interruption option choice \"%s\". It should be \"yes\" " "or \"no\""); } if (config_lookup_int(config.cfg, "sessioncontrol.session_timeout", &value)) { config.timeout = value; config.dont_check_timeout = 0; // this is for legacy -- only set by -t 0 } } else { if (config_error_type(&config_file_stuff) == CONFIG_ERR_FILE_IO) debug(1, "Error reading configuration file \"%s\": \"%s\".", config_error_file(&config_file_stuff), config_error_text(&config_file_stuff)); else { die("Line %d of the configuration file \"%s\":\n%s", config_error_line(&config_file_stuff), config_error_file(&config_file_stuff), config_error_text(&config_file_stuff)); } } free(config_file_real_path); } // now, do the command line options again, but this time do them fully -- it's a unix convention that command line // arguments have precedence over configuration file settings. optind = argc; for (j = 0; j < argc; j++) if (strcmp(argv[j], "--") == 0) optind = j; optCon = poptGetContext(NULL, optind, (const char **)argv, optionsTable, 0); poptSetOtherOptionHelp(optCon, "[OPTIONS]* "); /* Now do options processing, get portname */ int tdebuglev = 0; while ((c = poptGetNextOpt(optCon)) >= 0) { switch (c) { case 'v': tdebuglev++; break; case 't': if (config.timeout == 0) { config.dont_check_timeout = 1; config.allow_session_interruption = 1; } else { config.dont_check_timeout = 0; config.allow_session_interruption = 0; } break; #ifdef CONFIG_METADATA case 'M': config.metadata_enabled = 1; break; case 'g': if (config.metadata_enabled == 0) die("If you want to get cover art, you must also select the --metadata-pipename option."); break; #endif case 'S': if (strcmp(stuffing, "basic") == 0) config.packet_stuffing = ST_basic; else if (strcmp(stuffing, "soxr") == 0) #ifdef HAVE_LIBSOXR config.packet_stuffing = ST_soxr; #else die("soxr option not available -- this version of shairport-sync was built without libsoxr " "support"); #endif else die("Illegal stuffing option \"%s\" -- must be \"basic\" or \"soxr\"", stuffing); break; } }
/** * Program entry point * * @param argc Number of argv elements * @param argv Program name and arguments * @param envp Program environment * @return <i>0</i> Success * @return <br><i>254</i> Initialization failed */ int main(int argc, char **argv, char **envp) { bk_s B = NULL; /* Baka general structure */ BK_ENTRY_MAIN(B, __FUNCTION__, __FILE__, "SIMPLE"); int c; int getopterr = 0; int debug_level = 0; char i18n_localepath[_POSIX_PATH_MAX]; char *i18n_locale; struct program_config Pconfig, *pc = NULL; poptContext optCon = NULL; struct poptOption optionsTable[] = { {"debug", 'd', POPT_ARG_NONE, NULL, 'd', N_("Turn on debugging"), NULL }, {"verbose", 'v', POPT_ARG_NONE, NULL, 'v', N_("Turn on verbose message"), NULL }, {"no-seatbelts", 0, POPT_ARG_NONE, NULL, 0x1000, N_("Sealtbelts off & speed up"), NULL }, {"seatbelts", 0, POPT_ARG_NONE, NULL, 0x1001, N_("Enable function tracing"), NULL }, {"profiling", 0, POPT_ARG_STRING, NULL, 0x1002, N_("Enable and write profiling data"), N_("filename") }, // XXX - customize here {"person", 'p', POPT_ARG_STRING, NULL, 'p', N_("Set the person to greet"), N_("person") }, {"long-arg-only", 0, POPT_ARG_NONE, NULL, 1, N_("An example of a long argument without a shortcut"), NULL }, {NULL, 's', POPT_ARG_NONE, NULL, 2, N_("An example of a short argument without a longcut"), NULL }, POPT_AUTOHELP POPT_TABLEEND }; if (!(B=bk_general_init(argc, &argv, &envp, BK_ENV_GWD(NULL, "BK_ENV_CONF_APP", BK_APP_CONF), NULL, ERRORQUEUE_DEPTH, LOG_LOCAL0, 0))) { fprintf(stderr,"Could not perform basic initialization\n"); exit(254); } bk_fun_reentry(B); // i18n stuff setlocale(LC_ALL, ""); if (!(i18n_locale = BK_GWD(B, STD_LOCALEDIR_KEY, NULL))) { i18n_locale = i18n_localepath; snprintf(i18n_localepath, sizeof(i18n_localepath), "%s/%s", BK_ENV_GWD(B, STD_LOCALEDIR_ENV,STD_LOCALEDIR_DEF), STD_LOCALEDIR_SUB); } bindtextdomain(BK_GENERAL_PROGRAM(B), i18n_locale); textdomain(BK_GENERAL_PROGRAM(B)); for (c = 0; optionsTable[c].longName || optionsTable[c].shortName; c++) { if (optionsTable[c].descrip) (*((char **)&(optionsTable[c].descrip)))=_(optionsTable[c].descrip); if (optionsTable[c].argDescrip) (*((char **)&(optionsTable[c].argDescrip)))=_(optionsTable[c].argDescrip); } pc = &Pconfig; memset(pc, 0, sizeof(*pc)); // XXX - customize here if (!(optCon = poptGetContext(NULL, argc, (const char **)argv, optionsTable, 0))) { bk_error_printf(B, BK_ERR_ERR, "Could not initialize options processing\n"); bk_exit(B, 254); } // XXX - customize here poptSetOtherOptionHelp(optCon, _("[NON-FLAG ARGUMENTS]")); while ((c = poptGetNextOpt(optCon)) >= 0) { switch (c) { case 'd': // debug if (!debug_level) { // Set up debugging, from config file bk_general_debug_config(B, stderr, BK_ERR_NONE, 0); bk_debug_printf(B, "Debugging on\n"); debug_level++; } else if (debug_level == 1) { /* * Enable output of error and higher error logs (this can be * annoying so require -dd) */ bk_error_config(B, BK_GENERAL_ERROR(B), 0, stderr, BK_ERR_NONE, BK_ERR_ERR, BK_ERROR_CONFIG_FH | BK_ERROR_CONFIG_HILO_PIVOT | BK_ERROR_CONFIG_SYSLOGTHRESHOLD); bk_debug_printf(B, "Extra debugging on\n"); debug_level++; } else if (debug_level == 2) { /* * Enable output of all levels of bk_error logs (this can be * very annoying so require -ddd) */ bk_error_config(B, BK_GENERAL_ERROR(B), 0, stderr, BK_ERR_NONE, BK_ERR_DEBUG, BK_ERROR_CONFIG_FH | BK_ERROR_CONFIG_HILO_PIVOT | BK_ERROR_CONFIG_SYSLOGTHRESHOLD); bk_debug_printf(B, "Super-extra debugging on\n"); debug_level++; } break; case 'v': // verbose BK_FLAG_SET(pc->pc_flags, PC_VERBOSE); bk_error_config(B, BK_GENERAL_ERROR(B), ERRORQUEUE_DEPTH, stderr, BK_ERR_NONE, BK_ERR_ERR, 0); break; case 0x1000: // no-seatbelts BK_FLAG_CLEAR(BK_GENERAL_FLAGS(B), BK_BGFLAGS_FUNON); break; case 0x1001: // seatbelts BK_FLAG_SET(BK_GENERAL_FLAGS(B), BK_BGFLAGS_FUNON); break; case 0x1002: // profiling bk_general_funstat_init(B, (char *)poptGetOptArg(optCon), 0); break; default: getopterr++; break; // XXX - customize here case 'p': // person pc->pc_person = poptGetOptArg(optCon); break; case 1: // long-arg-only printf("You specificed the long-arg-only option\n"); break; case 2: // s printf("You specificed the short only option\n"); break; } } /* * Reprocess so that argc and argv contain the remaining command * line arguments (note argv[0] is an argument, not the program * name). argc remains the number of elements in the argv array. */ argv = (char **)poptGetArgs(optCon); argc = 0; if (argv) for (; argv[argc]; argc++) ; // Void // XXX - customize here (argv test) if (c < -1 || getopterr) { if (c < -1) { fprintf(stderr, "%s\n", poptStrerror(c)); } poptPrintUsage(optCon, stderr, 0); bk_exit(B, 254); } if (proginit(B, pc) < 0) { bk_die(B, 254, stderr, _("Could not perform program initialization\n"), BK_FLAG_ISSET(pc->pc_flags, PC_VERBOSE)?BK_WARNDIE_WANTDETAILS:0); } progrun(B, pc); poptFreeContext(optCon); bk_exit(B, 0); return(255); // Stupid INSIGHT stuff. }
int main( int argc, char *argv[] ) { TALLOC_CTX *frame = talloc_stackframe(); int opt; REGF_FILE *infile, *outfile; REGF_NK_REC *nk; char *orig_filename, *new_filename; struct poptOption long_options[] = { POPT_AUTOHELP { "change-sid", 'c', POPT_ARG_STRING, NULL, 'c', "Provides SID to change" }, { "new-sid", 'n', POPT_ARG_STRING, NULL, 'n', "Provides SID to change to" }, { "verbose", 'v', POPT_ARG_NONE, &opt_verbose, 'v', "Verbose output" }, POPT_COMMON_SAMBA POPT_COMMON_VERSION POPT_TABLEEND }; poptContext pc; load_case_tables(); /* setup logging options */ setup_logging( "profiles", DEBUG_STDERR); pc = poptGetContext("profiles", argc, (const char **)argv, long_options, POPT_CONTEXT_KEEP_FIRST); poptSetOtherOptionHelp(pc, "<profilefile>"); /* Now, process the arguments */ while ((opt = poptGetNextOpt(pc)) != -1) { switch (opt) { case 'c': change = 1; if (!string_to_sid(&old_sid, poptGetOptArg(pc))) { fprintf(stderr, "Argument to -c should be a SID in form of S-1-5-...\n"); poptPrintUsage(pc, stderr, 0); exit(254); } break; case 'n': new_val = 1; if (!string_to_sid(&new_sid, poptGetOptArg(pc))) { fprintf(stderr, "Argument to -n should be a SID in form of S-1-5-...\n"); poptPrintUsage(pc, stderr, 0); exit(253); } break; } } poptGetArg(pc); if (!poptPeekArg(pc)) { poptPrintUsage(pc, stderr, 0); exit(1); } if ((!change && new_val) || (change && !new_val)) { fprintf(stderr, "You must specify both -c and -n if one or the other is set!\n"); poptPrintUsage(pc, stderr, 0); exit(252); } orig_filename = talloc_strdup(frame, poptPeekArg(pc)); if (!orig_filename) { exit(ENOMEM); } new_filename = talloc_asprintf(frame, "%s.new", orig_filename); if (!new_filename) { exit(ENOMEM); } if (!(infile = regfio_open( orig_filename, O_RDONLY, 0))) { fprintf( stderr, "Failed to open %s!\n", orig_filename ); fprintf( stderr, "Error was (%s)\n", strerror(errno) ); exit (1); } if ( !(outfile = regfio_open( new_filename, (O_RDWR|O_CREAT|O_TRUNC), (S_IRUSR|S_IWUSR) )) ) { fprintf( stderr, "Failed to open new file %s!\n", new_filename ); fprintf( stderr, "Error was (%s)\n", strerror(errno) ); exit (1); } /* actually do the update now */ if ((nk = regfio_rootkey( infile )) == NULL) { fprintf(stderr, "Could not get rootkey\n"); exit(3); } if (!copy_registry_tree( infile, nk, NULL, outfile, "")) { fprintf(stderr, "Failed to write updated registry file!\n"); exit(2); } /* cleanup */ regfio_close(infile); regfio_close(outfile); poptFreeContext(pc); TALLOC_FREE(frame); return 0; }
int main(int argc, const char **argv) { TALLOC_CTX *mem_ctx = NULL; int pc_debug = SSSDBG_DEFAULT; const char *pc_domain = NULL; const char *pc_user = NULL; struct poptOption long_options[] = { POPT_AUTOHELP { "debug", '\0', POPT_ARG_INT | POPT_ARGFLAG_DOC_HIDDEN, &pc_debug, 0, _("The debug level to run with"), NULL }, { "domain", 'd', POPT_ARG_STRING, &pc_domain, 0, _("The SSSD domain to use"), NULL }, POPT_TABLEEND }; poptContext pc = NULL; const char *user; struct sss_ssh_ent *ent; size_t i; char *repr; int ret; debug_prg_name = argv[0]; ret = set_locale(); if (ret != EOK) { DEBUG(SSSDBG_CRIT_FAILURE, ("set_locale() failed (%d): %s\n", ret, strerror(ret))); ERROR("Error setting the locale\n"); ret = EXIT_FAILURE; goto fini; } mem_ctx = talloc_new(NULL); if (!mem_ctx) { ERROR("Not enough memory\n"); ret = EXIT_FAILURE; goto fini; } /* parse parameters */ pc = poptGetContext(NULL, argc, argv, long_options, 0); poptSetOtherOptionHelp(pc, "USER"); while ((ret = poptGetNextOpt(pc)) > 0) ; debug_level = debug_convert_old_level(pc_debug); if (ret != -1) { BAD_POPT_PARAMS(pc, poptStrerror(ret), ret, fini); } pc_user = poptGetArg(pc); if (pc_user == NULL) { BAD_POPT_PARAMS(pc, _("User not specified\n"), ret, fini); } /* append domain to username if domain is specified */ if (pc_domain) { user = talloc_asprintf(mem_ctx, "%s@%s", pc_user, pc_domain); if (!user) { ERROR("Not enough memory\n"); ret = EXIT_FAILURE; goto fini; } } else { user = pc_user; } /* look up public keys */ ret = sss_ssh_get_ent(mem_ctx, SSS_SSH_GET_USER_PUBKEYS, user, NULL, &ent); if (ret != EOK) { DEBUG(SSSDBG_CRIT_FAILURE, ("sss_ssh_get_ent() failed (%d): %s\n", ret, strerror(ret))); ERROR("Error looking up public keys\n"); ret = EXIT_FAILURE; goto fini; } /* print results */ for (i = 0; i < ent->num_pubkeys; i++) { repr = sss_ssh_format_pubkey(mem_ctx, ent, &ent->pubkeys[i], SSS_SSH_FORMAT_OPENSSH, NULL); if (!repr) { ERROR("Not enough memory\n"); ret = EXIT_FAILURE; goto fini; } printf("%s\n", repr); } ret = EXIT_SUCCESS; fini: poptFreeContext(pc); talloc_free(mem_ctx); return ret; }
/* main program */ int main(int argc, const char *argv[]) { bool ret = true; struct interface *ifaces; struct tevent_context *ev; poptContext pc; int opt; enum { OPT_BROADCAST_ADDRESS = 1000, OPT_UNICAST_ADDRESS, OPT_FIND_MASTER, OPT_WINS_LOOKUP, OPT_NODE_STATUS, OPT_ROOT_PORT, OPT_LOOKUP_BY_IP, OPT_CASE_SENSITIVE }; struct poptOption long_options[] = { POPT_AUTOHELP { "broadcast", 'B', POPT_ARG_STRING, NULL, OPT_BROADCAST_ADDRESS, "Specify address to use for broadcasts", "BROADCAST-ADDRESS" }, { "unicast", 'U', POPT_ARG_STRING, NULL, OPT_UNICAST_ADDRESS, "Specify address to use for unicast", NULL }, { "master-browser", 'M', POPT_ARG_NONE, NULL, OPT_FIND_MASTER, "Search for a master browser", NULL }, { "wins", 'W', POPT_ARG_NONE, NULL, OPT_WINS_LOOKUP, "Do a WINS lookup", NULL }, { "status", 'S', POPT_ARG_NONE, NULL, OPT_NODE_STATUS, "Lookup node status as well", NULL }, { "root-port", 'r', POPT_ARG_NONE, NULL, OPT_ROOT_PORT, "Use root port 137 (Win95 only replies to this)", NULL }, { "lookup-by-ip", 'A', POPT_ARG_NONE, NULL, OPT_LOOKUP_BY_IP, "Do a node status on <name> as an IP Address", NULL }, { "case-sensitive", 0, POPT_ARG_NONE, NULL, OPT_CASE_SENSITIVE, "Don't uppercase the name before sending", NULL }, POPT_COMMON_SAMBA { 0, 0, 0, 0 } }; pc = poptGetContext("nmblookup", argc, argv, long_options, POPT_CONTEXT_KEEP_FIRST); poptSetOtherOptionHelp(pc, "<NODE> ..."); while ((opt = poptGetNextOpt(pc)) != -1) { switch(opt) { case OPT_BROADCAST_ADDRESS: options.broadcast_address = poptGetOptArg(pc); break; case OPT_UNICAST_ADDRESS: options.unicast_address = poptGetOptArg(pc); break; case OPT_FIND_MASTER: options.find_master = true; break; case OPT_WINS_LOOKUP: options.wins_lookup = true; break; case OPT_NODE_STATUS: options.node_status = true; break; case OPT_ROOT_PORT: options.root_port = true; break; case OPT_LOOKUP_BY_IP: options.lookup_by_ip = true; break; case OPT_CASE_SENSITIVE: options.case_sensitive = true; break; } } /* swallow argv[0] */ poptGetArg(pc); if(!poptPeekArg(pc)) { poptPrintUsage(pc, stderr, 0); exit(1); } load_interfaces(NULL, lp_interfaces(cmdline_lp_ctx), &ifaces); ev = s4_event_context_init(talloc_autofree_context()); while (poptPeekArg(pc)) { const char *name = poptGetArg(pc); ret &= process_one(cmdline_lp_ctx, ev, ifaces, name, lp_nbt_port(cmdline_lp_ctx)); } talloc_free(ev); talloc_free(ifaces); poptFreeContext(pc); if (!ret) { return 1; } return 0; }