void
usage(const char *msg) {
if (msg)
fprintf(stderr, "%s: usage error: %s\n", argv_program, msg);
nmsg_io_destroy(&ctx.io);
exit(argv_usage(args, ARGV_USAGE_DEFAULT));
}
static void argv_generic_help(FILE * fd)
{
argv_usage(fd);
fprintf(fd, "\nIf run without any parameters, spew cures cancer.\n");
fprintf(fd,
"That being said, read the individual parts of --help"
" to learn more\n");
}
/*
* Handle arguments, getopt()-style. May re-arrange argv. May also blow up.
* Kaboom.
*/
int argv_init(int argc, char **argv)
{
int c;
while (1) {
int option_index = 1;
c = getopt_long(argc, argv, short_options, long_options,
&option_index);
if (c == -1)
break;
switch (c) {
case 'h':
argv_help(optarg ? optarg : argv[optind]);
exit(0);
break;
case 'V':
argv_version(stdout);
exit(0);
break;
case 'p':
argv_param(optarg);
break;
default:
argv_usage(stderr);
exit(1);
break;
}
}
if (optind < argc) {
inform(V(CORE), "Non-option argv elements found:");
while (optind < argc)
inform(V(CORE), "%s", argv[optind++]);
argv_usage(stderr);
exit(1);
}
return 1;
}
/* Print various types of help upon request.
*
* The style is a bit ugly, perhaps, but this should result in a nice
* configuration file (among other things).
*
* XXX: strncmp is, perhaps, better?
*
* XXX: stdout is used for the param-stuff so it can be piped to a file
* without inform()-noise if necessary.
*/
static void argv_help(char *arg)
{
if (arg == NULL) {
argv_generic_help(stdout);
} else if (!strcmp(arg, "param")) {
/* *INDENT-OFF* */
fprintf(stdout,
"# spew is configured by setting parameters.\n"
"#\n"
"# Parameters can be set in a configuration file or read on the\n"
"# command line. Command line takes priority over a configuration file.\n"
"#\n"
"# To explicitly set the value of a parameter to it's default, use:\n"
"# url=default\n"
"#\n"
"# Parameter-names are case insensitive, white-space is generally stripped.\n"
"# In a configuration file, anything after a hash (#) is a comment.\n"
"#\n"
"# To make a clean configuration file, simply pipe this output to a file:\n"
"# spew --help=param > .config/spew\n"
"#\n"
"# For just the parameter-name and value, use:\n"
"# spew --help paramlist\n"
"#\n"
"# The following is the documentation on all the parameters available\n"
"# form spew. Either set them in a configuration file or override them with:\n"
"# spew -p key=value -p otherkey=othervalue\n"
"#\n"
"# If the same value is supplied multiple times, the last one is used\n"
"#\n\n");
/* *INDENT-ON* */
param_show(stdout, PARAM_ALL, P_WHAT_BIT(ALL));
} else if (!strcmp(arg, "paramlist")) {
param_show(stdout, PARAM_ALL,
P_WHAT_BIT(KEYVALUE) | P_WHAT_BIT(STATE_DEFAULTS));
} else if (!strcmp(arg, "verbosity")) {
inform_describe_verbosity(stdout, VER_ALL);
} else if (*arg == '\0') {
argv_generic_help(stdout);
} else {
inform(V(CORE), "--help without a valid argument.");
argv_usage(stderr);
}
}
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)
{
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);
}
