int main(int argc, char *argv[]) { int retval; struct uuid_result result; struct Options opt; progname = argv[0]; retval = parse_options(&opt, argc, argv); if (retval != EXIT_SUCCESS) { fprintf(stderr, "%s: Option error\n", progname); return EXIT_FAILURE; } msg(3, "Using verbose level %d", verbose_level(0)); if (opt.help) return usage(EXIT_SUCCESS); if (opt.self_test) return run_self_tests(); if (opt.version) return print_version(); if (opt.license) return print_license(); #ifdef TEST_FUNC /* * Send non-option command line arguments to various functions for * testing. This doesn't break anything, as the program only checks for * options. Non-option arguments are ignored. */ if (optind < argc) { int i; for (i = optind; i < argc; i++) { char *a = argv[i]; char buf[1000]; msg(3, "Checking arg %d \"%s\"", i, a); memset(buf, 0, 1000); strncpy(buf, a, 999); printf("squeeze_chars(\"%s\", \",\") = \"%s\"\n", a, squeeze_chars(buf, "e")); } return EXIT_SUCCESS; } #endif result = create_and_log_uuids(&opt); if (!result.success) retval = EXIT_FAILURE; msg(3, "Returning from main() with value %d", retval); return retval; }
int parse_options(struct Options *dest, const int argc, char * const argv[]) { int retval = EXIT_SUCCESS; int c; assert(dest); assert(argv); init_opt(dest); while (retval == EXIT_SUCCESS) { int option_index = 0; static struct option long_options[] = { {"comment", required_argument, 0, 'c'}, {"count", required_argument, 0, 'n'}, {"help", no_argument, 0, 'h'}, {"license", no_argument, 0, 0}, {"logdir", required_argument, 0, 'l'}, {"quiet", no_argument, 0, 'q'}, {"random-mac", no_argument, 0, 'm'}, {"raw", no_argument, 0, 0}, {"rcfile", required_argument, 0, 0}, {"self-test", no_argument, 0, 0}, {"tag", required_argument, 0, 't'}, {"verbose", no_argument, 0, 'v'}, {"version", no_argument, 0, 0}, {"whereto", required_argument, 0, 'w'}, {0, 0, 0, 0} }; c = getopt_long(argc, argv, "c:" /* --comment */ "h" /* --help */ "l:" /* --logdir */ "m" /* --random-mac */ "n:" /* --count */ "q" /* --quiet */ "t:" /* --tag */ "v" /* --verbose */ "w:" /* --whereto */ , long_options, &option_index); if (c == -1) break; retval = choose_opt_action(dest, c, &long_options[option_index]); } verbose_level(1, dest->verbose); return retval; }
int msg(const int verbose, const char *format, ...) { va_list ap; int retval = 0; assert(format); assert(strlen(format)); if (verbose_level(0) >= verbose) { va_start(ap, format); retval = fprintf(stddebug, "%s: ", progname); retval += vfprintf(stddebug, format, ap); retval += fprintf(stddebug, "\n"); va_end(ap); } return retval; }
void print_log(int level, const char *file, int line, int dm_errno_or_class, const char *format, ...) { va_list ap; char buf[1024], message[4096]; int bufused, n; const char *trformat; /* Translated format string */ char *newbuf; int use_stderr = level & _LOG_STDERR; int log_once = level & _LOG_ONCE; int fatal_internal_error = 0; size_t msglen; const char *indent_spaces = ""; FILE *stream; static int _abort_on_internal_errors_env_present = -1; static int _abort_on_internal_errors_env = 0; char *env_str; level &= ~(_LOG_STDERR|_LOG_ONCE); if (_abort_on_internal_errors_env_present < 0) { if ((env_str = getenv("DM_ABORT_ON_INTERNAL_ERRORS"))) { _abort_on_internal_errors_env_present = 1; /* Set when env DM_ABORT_ON_INTERNAL_ERRORS is not "0" */ _abort_on_internal_errors_env = strcmp(env_str, "0"); } else _abort_on_internal_errors_env_present = 0; } /* Use value from environment if present, otherwise use value from config. */ if (((_abort_on_internal_errors_env_present && _abort_on_internal_errors_env) || (!_abort_on_internal_errors_env_present && _abort_on_internal_errors_config)) && !strncmp(format, INTERNAL_ERROR, sizeof(INTERNAL_ERROR) - 1)) { fatal_internal_error = 1; /* Internal errors triggering abort cannot be suppressed. */ _log_suppress = 0; level = _LOG_FATAL; } if (level <= _LOG_ERR) init_error_message_produced(1); trformat = _(format); if (level < _LOG_DEBUG && dm_errno_or_class && !_lvm_errno) _lvm_errno = dm_errno_or_class; if (_lvm2_log_fn || (_store_errmsg && (level <= _LOG_ERR)) || log_once) { va_start(ap, format); n = vsnprintf(message, sizeof(message), trformat, ap); va_end(ap); /* When newer glibc returns >= sizeof(locn), we will just log what * has fit into buffer, it's '\0' terminated string */ if (n < 0) { fprintf(stderr, _("vsnprintf failed: skipping external " "logging function")); goto log_it; } } /* FIXME Avoid pointless use of message buffer when it'll never be read! */ if (_store_errmsg && (level <= _LOG_ERR) && _lvm_errmsg_len < MAX_ERRMSG_LEN) { msglen = strlen(message); if ((_lvm_errmsg_len + msglen + 1) >= _lvm_errmsg_size) { _lvm_errmsg_size = 2 * (_lvm_errmsg_len + msglen + 1); if ((newbuf = dm_realloc(_lvm_errmsg, _lvm_errmsg_size))) _lvm_errmsg = newbuf; else _lvm_errmsg_size = _lvm_errmsg_len; } if (_lvm_errmsg && (_lvm_errmsg_len + msglen + 2) < _lvm_errmsg_size) { /* prepend '\n' and copy with '\0' but do not count in */ if (_lvm_errmsg_len) _lvm_errmsg[_lvm_errmsg_len++] = '\n'; memcpy(_lvm_errmsg + _lvm_errmsg_len, message, msglen + 1); _lvm_errmsg_len += msglen; } } if (log_once) { if (!_duplicated) _duplicated = dm_hash_create(128); if (_duplicated) { if (dm_hash_lookup(_duplicated, message)) level = _LOG_NOTICE; else (void) dm_hash_insert(_duplicated, message, (void*)1); } } if (_lvm2_log_fn) { _lvm2_log_fn(level, file, line, 0, message); if (fatal_internal_error) abort(); return; } log_it: if ((verbose_level() >= level) && !_log_suppress) { if (verbose_level() > _LOG_DEBUG) { (void) dm_snprintf(buf, sizeof(buf), "#%s:%d ", file, line); } else buf[0] = '\0'; if (_indent) switch (level) { case _LOG_NOTICE: indent_spaces = " "; break; case _LOG_INFO: indent_spaces = " "; break; case _LOG_DEBUG: indent_spaces = " "; break; default: /* nothing to do */; } va_start(ap, format); switch (level) { case _LOG_DEBUG: if (verbose_level() < _LOG_DEBUG) break; if (!debug_class_is_logged(dm_errno_or_class)) break; if ((verbose_level() == level) && (strcmp("<backtrace>", format) == 0)) break; /* fall through */ default: /* Typically only log_warn goes to stdout */ stream = (use_stderr || (level != _LOG_WARN)) ? stderr : stdout; if (stream == stderr) fflush(stdout); fprintf(stream, "%s%s%s%s", buf, log_command_name(), _msg_prefix, indent_spaces); vfprintf(stream, trformat, ap); fputc('\n', stream); } va_end(ap); } if ((level > debug_level()) || (level >= _LOG_DEBUG && !debug_class_is_logged(dm_errno_or_class))) { if (fatal_internal_error) abort(); return; } if (_log_to_file && (_log_while_suspended || !critical_section())) { fprintf(_log_file, "%s:%d %s%s", file, line, log_command_name(), _msg_prefix); va_start(ap, format); vfprintf(_log_file, trformat, ap); va_end(ap); fputc('\n', _log_file); fflush(_log_file); } if (_syslog && (_log_while_suspended || !critical_section())) { va_start(ap, format); vsyslog(level, trformat, ap); va_end(ap); } if (fatal_internal_error) abort(); /* FIXME This code is unfinished - pre-extend & condense. */ if (!_already_logging && _log_direct && critical_section()) { _already_logging = 1; memset(&buf, ' ', sizeof(buf)); bufused = 0; if ((n = dm_snprintf(buf, sizeof(buf), "%s:%d %s%s", file, line, log_command_name(), _msg_prefix)) == -1) goto done; bufused += n; /* n does not include '\0' */ va_start(ap, format); n = vsnprintf(buf + bufused, sizeof(buf) - bufused, trformat, ap); va_end(ap); if (n < 0) goto done; bufused += n; if (n >= sizeof(buf)) bufused = sizeof(buf) - 1; done: buf[bufused] = '\n'; buf[sizeof(buf) - 1] = '\n'; /* FIXME real size bufused */ dev_append(&_log_dev, sizeof(buf), buf); _already_logging = 0; } }
void print_log(int level, const char *file, int line, int dm_errno, const char *format, ...) { va_list ap; char buf[1024], locn[4096]; int bufused, n; const char *message; const char *trformat; /* Translated format string */ char *newbuf; int use_stderr = level & _LOG_STDERR; int log_once = level & _LOG_ONCE; int fatal_internal_error = 0; size_t msglen; level &= ~(_LOG_STDERR|_LOG_ONCE); if (_abort_on_internal_errors && !strncmp(format, INTERNAL_ERROR, strlen(INTERNAL_ERROR))) { fatal_internal_error = 1; /* Internal errors triggering abort cannot be suppressed. */ _log_suppress = 0; level = _LOG_FATAL; } if (_log_suppress == 2) return; if (level <= _LOG_ERR) init_error_message_produced(1); trformat = _(format); if (dm_errno && !_lvm_errno) _lvm_errno = dm_errno; if (_lvm2_log_fn || (_store_errmsg && (level <= _LOG_ERR)) || log_once) { va_start(ap, format); n = vsnprintf(locn, sizeof(locn) - 1, trformat, ap); va_end(ap); if (n < 0) { fprintf(stderr, _("vsnprintf failed: skipping external " "logging function")); goto log_it; } locn[sizeof(locn) - 1] = '\0'; message = locn; } /* FIXME Avoid pointless use of message buffer when it'll never be read! */ if (_store_errmsg && (level <= _LOG_ERR) && _lvm_errmsg_len < MAX_ERRMSG_LEN) { msglen = strlen(message); if ((_lvm_errmsg_len + msglen + 1) >= _lvm_errmsg_size) { _lvm_errmsg_size = 2 * (_lvm_errmsg_len + msglen + 1); if ((newbuf = dm_realloc(_lvm_errmsg, _lvm_errmsg_size))) _lvm_errmsg = newbuf; else _lvm_errmsg_size = _lvm_errmsg_len; } if (_lvm_errmsg && (_lvm_errmsg_len + msglen + 2) < _lvm_errmsg_size) { /* prepend '\n' and copy with '\0' but do not count in */ if (_lvm_errmsg_len) _lvm_errmsg[_lvm_errmsg_len++] = '\n'; memcpy(_lvm_errmsg + _lvm_errmsg_len, message, msglen + 1); _lvm_errmsg_len += msglen; } } if (log_once) { if (!_duplicated) _duplicated = dm_hash_create(128); if (_duplicated) { if (dm_hash_lookup(_duplicated, message)) level = _LOG_NOTICE; (void) dm_hash_insert(_duplicated, message, (void*)1); } } if (_lvm2_log_fn) { _lvm2_log_fn(level, file, line, 0, message); if (fatal_internal_error) abort(); return; } log_it: if (!_log_suppress) { if (verbose_level() > _LOG_DEBUG) (void) dm_snprintf(locn, sizeof(locn), "#%s:%d ", file, line); else locn[0] = '\0'; va_start(ap, format); switch (level) { case _LOG_DEBUG: if (!strcmp("<backtrace>", format) && verbose_level() <= _LOG_DEBUG) break; if (verbose_level() >= _LOG_DEBUG) { fprintf(stderr, "%s%s%s", locn, log_command_name(), _msg_prefix); if (_indent) fprintf(stderr, " "); vfprintf(stderr, trformat, ap); fputc('\n', stderr); } break; case _LOG_INFO: if (verbose_level() >= _LOG_INFO) { fprintf(stderr, "%s%s%s", locn, log_command_name(), _msg_prefix); if (_indent) fprintf(stderr, " "); vfprintf(stderr, trformat, ap); fputc('\n', stderr); } break; case _LOG_NOTICE: if (verbose_level() >= _LOG_NOTICE) { fprintf(stderr, "%s%s%s", locn, log_command_name(), _msg_prefix); if (_indent) fprintf(stderr, " "); vfprintf(stderr, trformat, ap); fputc('\n', stderr); } break; case _LOG_WARN: if (verbose_level() >= _LOG_WARN) { fprintf(use_stderr ? stderr : stdout, "%s%s", log_command_name(), _msg_prefix); vfprintf(use_stderr ? stderr : stdout, trformat, ap); fputc('\n', use_stderr ? stderr : stdout); } break; case _LOG_ERR: if (verbose_level() >= _LOG_ERR) { fprintf(stderr, "%s%s%s", locn, log_command_name(), _msg_prefix); vfprintf(stderr, trformat, ap); fputc('\n', stderr); } break; case _LOG_FATAL: default: if (verbose_level() >= _LOG_FATAL) { fprintf(stderr, "%s%s%s", locn, log_command_name(), _msg_prefix); vfprintf(stderr, trformat, ap); fputc('\n', stderr); } break; } va_end(ap); } if (level > debug_level()) return; if (_log_to_file && (_log_while_suspended || !critical_section())) { fprintf(_log_file, "%s:%d %s%s", file, line, log_command_name(), _msg_prefix); va_start(ap, format); vfprintf(_log_file, trformat, ap); va_end(ap); fprintf(_log_file, "\n"); fflush(_log_file); } if (_syslog && (_log_while_suspended || !critical_section())) { va_start(ap, format); vsyslog(level, trformat, ap); va_end(ap); } if (fatal_internal_error) abort(); /* FIXME This code is unfinished - pre-extend & condense. */ if (!_already_logging && _log_direct && critical_section()) { _already_logging = 1; memset(&buf, ' ', sizeof(buf)); bufused = 0; if ((n = dm_snprintf(buf, sizeof(buf) - 1, "%s:%d %s%s", file, line, log_command_name(), _msg_prefix)) == -1) goto done; bufused += n; va_start(ap, format); n = vsnprintf(buf + bufused - 1, sizeof(buf) - bufused - 1, trformat, ap); va_end(ap); bufused += n; buf[bufused - 1] = '\n'; done: buf[bufused] = '\n'; buf[sizeof(buf) - 1] = '\n'; /* FIXME real size bufused */ dev_append(&_log_dev, sizeof(buf), buf); _already_logging = 0; } }
int usage(const int retval) { char *logdir; if (retval != EXIT_SUCCESS) { fprintf(stderr, "\nType \"%s --help\" for help screen. " "Returning with value %d.\n", progname, retval); return retval; } logdir = get_logdir(NULL); puts(""); if (verbose_level(0) >= 1) { print_version(); puts(""); } printf("Usage: %s [options]\n", progname); printf("\n"); printf("Generates one or more UUIDs and stores it to a log file with " "optional \n" "comment or tag/category.\n"); printf("\n"); printf("Options:\n"); printf("\n"); printf(" -c x, --comment x\n" " Store comment x in the log file. If \"-\" is specified as " "comment, the \n" " program will read the comment from stdin. Two hyphens " "(\"--\") as a \n" " comment opens the editor defined in the environment " "variable \n" " %s to edit the message. If %s is " "not defined, \n" " EDITOR is read, if not defined, \"%s\" is called, it " "should exist \n" " everywhere. It may not, but it should.\n", ENV_EDITOR, ENV_EDITOR, STD_EDITOR); printf(" -h, --help\n" " Show this help.\n"); printf(" --license\n" " Print the software license.\n"); printf(" -l x, --logdir x\n" " Store log files in directory x.\n" " If the %s environment variable is defined, " "that value is \n" " used. Otherwise the value \"$HOME/uuids\" is used.\n" " Current default: %s\n", ENV_LOGDIR, logdir); printf(" -m, --random-mac\n" " Don't use the hardware MAC address, generate a random " "address field.\n"); printf(" -n x, --count x\n" " Print and store x UUIDs.\n"); printf(" -q, --quiet\n" " Be more quiet. Can be repeated to increase silence.\n"); printf(" --raw\n" " Don't convert <txt> element to XML. When using this " "option, it is \n" " expected that the value of the -c/--comment option is " "valid XML, \n" " otherwise it will create corrupted log files.\n"); printf(" --rcfile X\n" " Use file X instead of '%s/%s'.\n", getenv("HOME"), STD_RCFILE); printf(" --self-test\n" " Run various internal self tests and exit.\n"); printf(" -t x, --tag x\n" " Use x as tag (category).\n"); printf(" -v, --verbose\n" " Increase level of verbosity. Can be repeated.\n"); printf(" --version\n" " Print version information.\n"); printf(" -w x, --whereto x\n" " x is a string which decides where the UUID will be " "written:\n" " The string contains 'e' - stderr\n" " The string contains 'o' - stdout\n" " All other characters will be ignored. Examples:\n" " e\n" " Send to stderr.\n" " eo\n" " Send to both stdout and stderr.\n" " a\n" " Synonym for eo.\n" " n\n" " Don't output anything.\n" " Default: \"o\"\n"); printf("\n"); printf("If the %s environment variable is defined by " "sess(1) or another \n" "program, the value is logged if it is an UUID.\n", ENV_SESS); printf("\n"); printf("A different hostname can be specified in the environment " "variable \n" "%s, or in the rc file %s/%s with the format \n" "\"hostname = xxx\".\n", ENV_HOSTNAME, getenv("HOME"), STD_RCFILE); printf("To use a specific MAC address all the time, add it to the rc " "file using \n" "the format \"macaddr = xxxxxxxxxxxx\".\n"); printf("\n"); free(logdir); return retval; }
int sphere_eval_data_d::setup(SphereConfiguration & config, const WitnessSet & W, SolverConfiguration & solve_options) { SLP_memory = config.SLP_memory; // set up the vectors to hold the two linears. mp_to_d(radius, config.radius); vec_mp_to_d(center, config.center); if (this->center->size < W.num_variables()) { int old_size = this->center->size; increase_size_vec_d(this->center, W.num_variables()); this->center->size = W.num_variables(); for (int ii=old_size; ii<W.num_variables(); ii++) { set_zero_d(&this->center->coord[ii]); } } if (this->num_static_linears==0) { static_linear = (vec_d *) br_malloc(W.num_linears()*sizeof(vec_d)); } else { static_linear = (vec_d *) br_realloc(static_linear, W.num_linears()*sizeof(vec_d)); } for (unsigned int ii=0; ii<W.num_linears(); ii++) { init_vec_d(static_linear[ii],0); vec_mp_to_d(static_linear[ii],W.linear(ii)); } num_static_linears = W.num_linears(); num_natural_vars = W.num_natural_variables(); num_variables = W.num_variables(); for (int ii=0; ii<2; ii++) { vec_mp_to_d(starting_linear[ii],config.starting_linear[ii]); } verbose_level(solve_options.verbose_level()); SolverDoublePrecision::setup(config.SLP, config.randomizer()); generic_setup_patch(&patch,W); if (solve_options.use_gamma_trick==1) get_comp_rand_d(this->gamma); // set gamma to be random complex value else set_one_d(this->gamma); if (this->MPType==2) { this->BED_mp->setup(config, W, solve_options); rat_to_d(this->gamma, this->BED_mp->gamma_rat); } return 0; }
int sphere_eval_data_mp::setup(SphereConfiguration & config, const WitnessSet & W, SolverConfiguration & solve_options) { if (config.randomizer().use_count()==0) { std::cout << "don't have randomizer set up!" << std::endl; br_exit(-97621); } if (!config.have_mem) { std::cout << "don't have memory!" << std::endl; br_exit(-3231); } this->SLP_memory = config.SLP_memory; num_natural_vars = W.num_natural_variables(); num_variables = W.num_variables(); // set up the vectors to hold the linears. if (this->num_static_linears==0) { static_linear = (vec_mp *) br_malloc(W.num_linears()*sizeof(vec_mp)); } else { static_linear = (vec_mp *) br_realloc(static_linear, W.num_linears()*sizeof(vec_mp)); } for (unsigned int ii=0; ii<W.num_linears(); ii++) { init_vec_mp(static_linear[ii],0); vec_cp_mp(static_linear[ii],W.linear(ii)); } set_mp(this->radius, config.radius); vec_cp_mp(this->center, config.center); if (this->center->size < W.num_variables()) { int old_size = this->center->size; increase_size_vec_mp(this->center, W.num_variables()); this->center->size = W.num_variables(); for (int ii=old_size; ii<W.num_variables(); ii++) { set_zero_mp(&this->center->coord[ii]); } } if (this->MPType==2) { set_mp(this->radius_full_prec, config.radius); vec_cp_mp(this->center_full_prec, config.center); if (this->center_full_prec->size < W.num_variables()) { int old_size = this->center_full_prec->size; increase_size_vec_mp(this->center_full_prec, W.num_variables()); this->center_full_prec->size = W.num_variables(); for (int ii=old_size; ii<W.num_variables(); ii++) { set_zero_mp(&this->center_full_prec->coord[ii]); } } if (this->num_static_linears==0) { static_linear_full_prec = (vec_mp *) br_malloc(W.num_linears()*sizeof(vec_mp)); } else { static_linear_full_prec = (vec_mp *) br_realloc(static_linear_full_prec, W.num_linears()*sizeof(vec_mp)); } for (unsigned int ii=0; ii<W.num_linears(); ii++) { init_vec_mp2(static_linear_full_prec[ii],0,1024); vec_cp_mp(static_linear_full_prec[ii], W.linear(ii)); } } this->num_static_linears = W.num_linears(); for (int ii=0; ii<2; ii++) { vec_cp_mp( this->starting_linear[ii], config.starting_linear[ii]); if (MPType==2) { vec_cp_mp(this->starting_linear_full_prec[ii], config.starting_linear[ii]); } } // the usual verbose_level(solve_options.verbose_level()); SolverMultiplePrecision::setup(config.SLP, config.randomizer()); generic_setup_patch(&patch,W); if (solve_options.use_gamma_trick==1) get_comp_rand_mp(this->gamma); // set gamma to be random complex value else{ set_one_mp(this->gamma); } comp_d temp; if (this->MPType==2) { if (solve_options.use_gamma_trick==1){ get_comp_rand_rat(temp, this->gamma, this->gamma_rat, 64, solve_options.T.AMP_max_prec, 0, 0); } else{ set_one_mp(this->gamma); set_one_rat(this->gamma_rat); } } return 0; }