int main(int argc, char **argv) { nmsg_res res; /* parse command line arguments */ argv_process(args, argc, argv); if (ctx.debug < 1) ctx.debug = 1; nmsg_set_debug(ctx.debug); res = nmsg_init(); if (res != nmsg_res_success) { fprintf(stderr, "nmsgtool: unable to initialize libnmsg\n"); return (EXIT_FAILURE); } if (ctx.debug >= 2) #ifdef HAVE_LIBXS fprintf(stderr, "nmsgtool: version " VERSION "\n"); #else /* HAVE_LIBXS */ fprintf(stderr, "nmsgtool: version " VERSION " (without libxs support)\n"); #endif /* HAVE_LIBXS */ /* initialize the nmsg_io engine */ ctx.io = nmsg_io_init(); assert(ctx.io != NULL); nmsg_io_set_close_fp(ctx.io, io_close); /* process arguments and load inputs/outputs into the nmsg_io engine */ process_args(&ctx); setup_signals(); /* run the nmsg_io engine */ res = nmsg_io_loop(ctx.io); /* cleanup */ if (ctx.pidfile != NULL) { if (unlink(ctx.pidfile) != 0) { fprintf(stderr, "nmsgtool: unlink() failed: %s\n", strerror(errno)); } } nmsg_io_destroy(&ctx.io); #ifdef HAVE_LIBXS if (ctx.xs_ctx) xs_term(ctx.xs_ctx); #endif /* HAVE_LIBXS */ free(ctx.endline_str); argv_cleanup(args); return (res); }
static void process_args(int argc, char **argv) { unsigned n_inputs = 0; argv_process(args, argc, argv); n_inputs += ARGV_ARRAY_COUNT(r_chan); n_inputs += ARGV_ARRAY_COUNT(r_nmsg); n_inputs += ARGV_ARRAY_COUNT(r_sock); if (n_inputs < 1 || iface == NULL) { argv_usage(args, ARGV_USAGE_LONG); exit(EXIT_FAILURE); } if (ARGV_ARRAY_COUNT(r_chan) + ARGV_ARRAY_COUNT(r_sock) > 0) is_live = true; process_args_loop_io(r_chan, nmsg_io_add_input_channel); process_args_loop_io(r_sock, nmsg_io_add_input_sockspec); process_args_loop_io(r_nmsg, nmsg_io_add_input_fname); }
int main(int argc, char **argv) { int i = 0; int *result = (int *)malloc(sizeof(int) * argc); int *opt = (int *)malloc(sizeof(int) * argc); parameter =(int *)malloc(sizeof(int) * 256); bzero(result, sizeof(int) * argc); bzero(opt, sizeof(int) * argc); bzero(parameter, sizeof(int) * 256); set_parameter(parameter); argv_process(result, opt, argv, argc, parameter); for(i = 1; i < result[0]; ++i){ cp_select(argv[result[i]], argv[result[result[0]]]); } free(result); free(opt); free(parameter); return 0; }
int main(int argc, char **argv) { char buf[1024]; int set_b = 0; char *log_path, *loc_start_file; const char *env_str; DMALLOC_PNT addr; unsigned long inter, limit_val, loc_start_size, loc_start_iter; long addr_count; int lock_on; int loc_start_line; unsigned int flags; argv_help_string = "Sets dmalloc library env variables. Also try --usage."; argv_version_string = dmalloc_version; argv_process(args, argc, argv); if (help_b) { header(); (void)fprintf(stderr, " For a list of the command-line options enter: %s --usage\n", argv_argv[0]); exit(0); } if (usage_b) { header(); argv_usage(args, ARGV_USAGE_ALL); exit(0); } if (very_verbose_b) { verbose_b = 1; } /* try to figure out the shell we are using */ if ((! bourne_b) && (! cshell_b) && (! gdb_b) && (! rcshell_b)) { choose_shell(); } /* get the current debug information from the env variable */ env_str = getenv(OPTIONS_ENVIRON); if (env_str == NULL) { env_str = ""; } _dmalloc_environ_process(env_str, &addr, &addr_count, &flags, &inter, &lock_on, &log_path, &loc_start_file, &loc_start_line, &loc_start_iter, &loc_start_size, &limit_val); /* * So, if a tag was specified on the command line then we set the * debug from it. If it was not then we see if the debug flags were * set as a hex value from the -d. If this was not used then take * the current value. */ if (tag == NULL) { if (argv_was_used(args, DEBUG_ARG)) { set_b = 1; /* should we clear the rest? */ if (remove_auto_b && (! keep_b)) { clear_b = 1; } } else { debug = flags; } } else { if (argv_was_used(args, DEBUG_ARG)) { (void)fprintf(stderr, "%s: warning -d ignored, processing tag '%s'\n", argv_program, tag); } set_b = 1; debug = find_tag(0L, tag, NULL, 0); /* should we clear the rest? */ if (remove_auto_b && (! keep_b)) { clear_b = 1; } } if (plus.aa_entry_n > 0) { int plus_c; for (plus_c = 0; plus_c < plus.aa_entry_n; plus_c++) { BIT_SET(debug, token_to_value(ARGV_ARRAY_ENTRY(plus, char *, plus_c))); set_b = 1; } } if (minus.aa_entry_n > 0) { int minus_c; for (minus_c = 0; minus_c < minus.aa_entry_n; minus_c++) { BIT_CLEAR(debug, token_to_value(ARGV_ARRAY_ENTRY(minus, char *, minus_c))); set_b = 1; } } if (address != NULL) { _dmalloc_address_break(address, &addr, &addr_count); set_b = 1; } else if (clear_b) { addr = NULL; } if (argv_was_used(args, INTERVAL_ARG)) { inter = interval; set_b = 1; } else if (clear_b) { inter = 0; } /* * NOTE: this should be after the debug setting which this tests. */ if (argv_was_used(args, THREAD_LOCK_ON_ARG)) { lock_on = thread_lock_on; set_b = 1; } else if (clear_b) { lock_on = 0; } if (logpath != NULL) { log_path = logpath; set_b = 1; } else if (clear_b) { log_path = NULL; } if (start_file != NULL) { _dmalloc_start_break(start_file, &loc_start_file, &loc_start_line, &loc_start_iter, &loc_start_size); set_b = 1; } else if (start_iter > 0) { loc_start_file = NULL; loc_start_line = 0; loc_start_iter = start_iter; loc_start_size = 0; set_b = 1; } else if (start_size > 0) { loc_start_file = NULL; loc_start_line = 0; loc_start_iter = 0; loc_start_size = start_size; set_b = 1; } else if (clear_b) { loc_start_file = NULL; loc_start_line = 0; loc_start_iter = 0; loc_start_size = 0; } if (argv_was_used(args, LIMIT_ARG)) { limit_val = limit_arg; set_b = 1; } if (errno_to_print > 0) { (void)fprintf(stderr, "%s: dmalloc_errno value '%d' = \n", argv_program, errno_to_print); (void)fprintf(stderr, " '%s'\n", local_strerror(errno_to_print)); } if (list_tags_b) { list_tags(); } if (debug_tokens_b) { attr_t *attr_p; unsigned int left = 0x7fffffff; (void)fprintf(stderr, "Debug Tokens:\n"); for (attr_p = attributes; attr_p->at_string != NULL; attr_p++) { /* skip any disabled tokens */ if (attr_p->at_value == 0 && strcmp(attr_p->at_string, "none") != 0) { continue; } if (attr_p->at_value != 0 && (! BIT_IS_SET(left, attr_p->at_value))) { /* skip any tokens we've seen before */ continue; } if (very_verbose_b) { (void)fprintf(stderr, "%s -- %s (%#lx)\n", attr_p->at_string, attr_p->at_desc, attr_p->at_value); } else if (verbose_b) { (void)fprintf(stderr, "%s -- %s\n", attr_p->at_string, attr_p->at_desc); } else { (void)fprintf(stderr, "%s\n", attr_p->at_string); } BIT_CLEAR(left, attr_p->at_value); } } if (clear_b || set_b) { _dmalloc_environ_set(buf, sizeof(buf), long_tokens_b, addr, addr_count, debug, inter, lock_on, log_path, loc_start_file, loc_start_line, loc_start_iter, loc_start_size, limit_val); set_variable(OPTIONS_ENVIRON, buf); } else if (errno_to_print == 0 && (! list_tags_b) && (! debug_tokens_b)) { dump_current(); } argv_cleanup(args); exit(0); }