/*
* opt_args() : set options via commandline args and getopt_long
*/
static void _opt_args(int argc, char **argv)
{
int opt_char;
int option_index;
static struct option long_options[] = {
{"account", required_argument, 0, 'A'},
{"batch", no_argument, 0, 'b'},
{"ctld", no_argument, 0, OPT_LONG_CTLD},
{"help", no_argument, 0, OPT_LONG_HELP},
{"interactive", no_argument, 0, 'i'},
{"cluster", required_argument, 0, 'M'},
{"clusters", required_argument, 0, 'M'},
{"name", required_argument, 0, 'n'},
{"nodelist", required_argument, 0, 'w'},
{"partition", required_argument, 0, 'p'},
{"qos", required_argument, 0, 'q'},
{"quiet", no_argument, 0, 'Q'},
{"reservation", required_argument, 0, 'R'},
{"signal", required_argument, 0, 's'},
{"state", required_argument, 0, 't'},
{"usage", no_argument, 0, OPT_LONG_USAGE},
{"user", required_argument, 0, 'u'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"wckey", required_argument, 0, OPT_LONG_WCKEY},
{NULL, 0, 0, 0}
};
while((opt_char = getopt_long(argc, argv, "A:biM:n:p:Qq:R:s:t:u:vVw:",
long_options, &option_index)) != -1) {
switch (opt_char) {
case (int)'?':
fprintf(stderr,
"Try \"scancel --help\" for more "
"information\n");
exit(1);
break;
case (int)'A':
opt.account = xstrtolower(xstrdup(optarg));
break;
case (int)'b':
opt.batch = true;
break;
case OPT_LONG_CTLD:
opt.ctld = true;
break;
case (int)'i':
opt.interactive = true;
break;
case (int)'M':
opt.ctld = true;
if (opt.clusters)
list_destroy(opt.clusters);
opt.clusters = slurmdb_get_info_cluster(optarg);
if (!opt.clusters) {
print_db_notok(optarg, 0);
exit(1);
}
working_cluster_rec = list_peek(opt.clusters);
break;
case (int)'n':
opt.job_name = xstrdup(optarg);
break;
case (int)'p':
opt.partition = xstrdup(optarg);
break;
case (int)'Q':
opt.verbose = -1;
break;
case (int)'q':
opt.qos = xstrtolower(xstrdup(optarg));
break;
case (int)'R':
opt.reservation = xstrdup(optarg);
break;
case (int)'s':
opt.signal = _xlate_signal_name(optarg);
break;
case (int)'t':
opt.state = _xlate_state_name(optarg, false);
break;
case (int)'u':
opt.user_name = xstrdup(optarg);
break;
case (int)'v':
opt.verbose++;
break;
case (int)'V':
print_slurm_version ();
exit(0);
case (int)'w':
opt.nodelist = xstrdup(optarg);
break;
case OPT_LONG_WCKEY:
opt.wckey = xstrdup(optarg);
break;
case OPT_LONG_HELP:
_help();
exit(0);
case OPT_LONG_USAGE:
_usage();
exit(0);
}
}
if (optind < argc) {
char **rest = argv + optind;
opt.job_list = rest;
_xlate_job_step_ids(rest);
}
if (!_opt_verify())
exit(1);
}
static int parse_args(int argc, char * argv[])
{
int i, c;
long n;
while ((c = getopt_long(argc, argv,
opt_string, long_options, &i)) != -1) {
switch (c) {
case 'v':
verbose = 1;
break;
case 'p':
report_progress = 1;
break;
case 'h':
help = 1;
break;
case 'f':
if (strlen(optarg) == 0) {
printf("invalid root directory\n");
return 1;
}
benchmark_root_dir = optarg;
break;
case 'c':
n = atol(optarg);
if (n <= 32) {
printf("cachesize shouldn't be less than 32mb\n");
return 1;
}
cachesize = n * 1024 * 1024L;
break;
case 'n':
n = atol(optarg);
if (n <= 0) {
printf("need to operate on at least one file\n");
return 1;
}
num_files = n;
break;
case 'd':
n = atol(optarg);
if (n <= 0) {
printf("need at least one file per directory\n");
return 1;
}
directory_max_children = n;
break;
case 'm':
n = atol(optarg);
if (n <= 0) {
printf("need to use at least one thread\n");
return 1;
}
num_threads = n;
break;
case 'b':
n = atol(optarg);
if (n <= 0) {
printf("io size needs to be > 0\n");
return 1;
}
iosize = n;
break;
case 'x':
n = atol(optarg);
if (n < 0) {
printf("number of operations needs to be >= 0.\n"
"0 means only open and close files\n");
return 1;
}
num_operations = n;
break;
case 0:
break;
case '?':
printf("?\n");
default:
return 1;
}
}
return 0;
}
void hack_handle_opts (int argc, char **argv)
{
dIons = 1500;
dSize = 10;
dEmitters = 3;
dAttracters = 3;
dSpeed = 10;
dCameraspeed = 10;
dSurface = 1;
dWireframe = 0;
dBlur = 10;
while (1) {
int c;
#ifdef HAVE_GETOPT_H
static struct option long_options[] = {
{"help", 0, 0, 'h'},
DRIVER_OPTIONS_LONG {"ions", 1, 0, 'i'},
{"size", 1, 0, 's'},
{"emitters", 1, 0, 'e'},
{"attracters", 1, 0, 'a'},
{"speed", 1, 0, 'S'},
{"cameraspeed", 1, 0, 'c'},
{"surface", 0, 0, 'u'},
{"no-surface", 0, 0, 'U'},
{"blur", 1, 0, 'b'},
{"wireframe", 0, 0, 'w'},
{"no-wireframe", 0, 0, 'W'},
{0, 0, 0, 0}
};
c = getopt_long (argc, argv, DRIVER_OPTIONS_SHORT "hi:s:e:a:S:c:uUb:wW", long_options, NULL);
#else
c = getopt (argc, argv, DRIVER_OPTIONS_SHORT "hi:s:e:a:S:c:uUb:wW");
#endif
if (c == -1)
break;
switch (c) {
DRIVER_OPTIONS_CASES case 'h':printf ("%s:"
#ifndef HAVE_GETOPT_H
" Not built with GNU getopt.h, long options *NOT* enabled."
#endif
"\n" DRIVER_OPTIONS_HELP "\t--ions/-i <arg>\n" "\t--size/-s <arg>\n" "\t--emitters/-e <arg>\n"
"\t--attracters/-a <arg>\n" "\t--speed/-S <arg>\n" "\t--cameraspeed/-c <arg>\n" "\t--surface/-u\n"
"\t--no-surface/-U\n" "\t--blur/-b <arg>\n" "\t--wireframe/-w\n" "\t--no-wireframe/-W\n", argv[0]);
exit (1);
case 'i':
dIons = strtol_minmaxdef (optarg, 10, 0, 30000, 1, 1500, "--ions: ");
break;
case 's':
dSize = strtol_minmaxdef (optarg, 10, 1, 100, 1, 10, "--size: ");
break;
case 'e':
dEmitters = strtol_minmaxdef (optarg, 10, 1, 10, 1, 3, "--emitters: ");
break;
case 'a':
dAttracters = strtol_minmaxdef (optarg, 10, 1, 10, 1, 3, "--attracters: ");
break;
case 'S':
dSpeed = strtol_minmaxdef (optarg, 10, 1, 100, 1, 10, "--speed: ");
break;
case 'c':
dCameraspeed = strtol_minmaxdef (optarg, 10, 0, 100, 1, 10, "--cameraspeed: ");
break;
case 'u':
dSurface = 1;
break;
case 'U':
dSurface = 0;
break;
case 'b':
dBlur = strtol_minmaxdef (optarg, 10, 0, 100, 1, 10, "--blur: ");
break;
case 'w':
dWireframe = 1;
break;
case 'W':
dWireframe = 0;
break;
}
}
}
int
main(int argc, char* argv[])
{
bool add = false, create = false, destroy = false, erase = false, header = false;
bool list = false, lvcreate = false, lvdestroy = false, lvlist = false, lvmodify = false, lvresize = false, lvsnap = false;
bool modify = false, remove = false, spare = false, watch = false;
char * setLevel = 0, * setName = 0;
/* options descriptor */
static struct option longopts[] = {
{ "add", required_argument, 0, 'a' },
{ "create", no_argument, 0, 'c' },
{ "destroy", required_argument, 0, 'd' },
{ "erase", no_argument, 0, 'e' },
{ "header", no_argument, 0, 'h' },
{ "list", no_argument, 0, 'l' },
{ "modify", required_argument, 0, 'm' },
{ "remove", required_argument, 0, 'r' },
{ "spare", required_argument, 0, 's' },
{ "watch", no_argument, 0, 'w' },
{ "lvcreate", required_argument, 0, 'C' },
{ "lvdestroy", required_argument, 0, 'D' },
{ "lvlist", no_argument, 0, 'L' },
{ "lvmodify", required_argument, 0, 'M' },
{ "lvresize", required_argument, 0, 'R' },
{ "lvsnap", required_argument, 0, 'S' },
{ "auto-rebuild",required_argument, 0, 'A' },
{ "block-size", required_argument, 0, 'B' },
{ "extents", no_argument, 0, 'E' },
{ "hint", required_argument, 0, 'H' },
{ "level", required_argument, 0, 'V' },
{ "name", required_argument, 0, 'N' },
{ "quick-rebuild",required_argument, 0, 'Q' },
{ "size", required_argument, 0, 'Z' },
{ "timeout", required_argument, 0, 'T' },
{ "verbose", no_argument, 0, 'v' },
{ "help", no_argument, 0, '?' },
{ 0, 0, 0, 0 }
};
int ch;
while ((ch = getopt_long(argc, argv, "a:cd:ehlm:r:s:wC:D:LM:R:S:A:B:EH:V:N:Q:Z:T:v?", longopts, NULL)) != -1) {
switch(ch) {
case 'a':
add = true;
setName = strdup(optarg);
break;
case 'c':
create = true;
break;
case 'd':
destroy = true;
setName = strdup(optarg);
break;
case 'e':
erase = true;
break;
case 'h':
header = true;
break;
case 'l':
list = true;
break;
case 'm':
modify = true;
setName = strdup(optarg);
break;
case 'r':
remove = true;
setName = strdup(optarg);
break;
case 's':
spare = true;
setName = strdup(optarg);
break;
case 'w':
watch = true;
break;
case 'C':
lvcreate = true;
setName = strdup(optarg);
break;
case 'D':
lvdestroy = true;
setName = strdup(optarg);
break;
case 'L':
lvlist = true;
break;
case 'M':
lvmodify = true;
setName = strdup(optarg);
break;
case 'R':
lvresize = true;
setName = strdup(optarg);
break;
case 'S':
lvsnap = true;
setName = strdup(optarg);
break;
case 'A':
autoRebuild = ((optarg[0] == 'Y') || (optarg[0] == 'y')) ? AUTO_YES : AUTO_NO;
break;
case 'B':
sscanf(optarg, "%lli", &blockSize);
break;
case 'E':
extents = true;
break;
case 'H':
hint = strdup(optarg);
break;
case 'V':
setLevel = strdup(optarg);
break;
case 'N':
nickname = strdup(optarg);
break;
case 'Q':
quickRebuild = ((optarg[0] == 'Y') || (optarg[0] == 'y')) ? AUTO_YES : AUTO_NO;
break;
case 'Z':
sscanf(optarg, "%lli", &volSize);
break;
case 'T':
sscanf(optarg, "%lli", &timeout);
break;
case 'v':
verbose = true;
break;
case 0:
case '?':
default:
usage();
exit(0);
}
}
argc -= optind;
argv += optind;
if (!add && !create && !destroy && !erase && !header && !list && !modify && !remove && !spare && !watch &&
!lvcreate && !lvdestroy && !lvlist && !lvmodify && !lvresize && !lvsnap) {
usage();
exit(0);
}
if (list) {
listRAIDSets();
exit(0);
}
if (lvlist) {
listLogicalVolumes(NULL, argc, argv);
exit(0);
}
if (geteuid()) {
printf("ERROR: you must be super user for this operation.\n");
exit(1);
}
if (erase) {
erasePartition(argc, argv);
exit(0);
};
if (header) {
dumpHeader(argc, argv);
exit(0);
};
if (watch) {
CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(),
NULL, // const void *observer
callBack,
CFSTR(kAppleRAIDNotificationSetDiscovered),
NULL, // const void *object
CFNotificationSuspensionBehaviorHold);
CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(),
NULL, // const void *observer
callBack,
CFSTR(kAppleRAIDNotificationSetTerminated),
NULL, // const void *object
CFNotificationSuspensionBehaviorHold);
CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(),
NULL, // const void *observer
callBack,
CFSTR(kAppleRAIDNotificationSetChanged),
NULL, // const void *object
CFNotificationSuspensionBehaviorHold);
CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(),
NULL, // const void *observer
callBack,
CFSTR(kAppleLVMNotificationVolumeDiscovered),
NULL, // const void *object
CFNotificationSuspensionBehaviorHold);
CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(),
NULL, // const void *observer
callBack,
CFSTR(kAppleLVMNotificationVolumeTerminated),
NULL, // const void *object
CFNotificationSuspensionBehaviorHold);
CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(),
NULL, // const void *observer
callBack,
CFSTR(kAppleLVMNotificationVolumeChanged),
NULL, // const void *object
CFNotificationSuspensionBehaviorHold);
// this will not fail if there is no raid controller, ie, if AppleRAID class is not instantiated in the kernel
AppleRAIDEnableNotifications();
}
if (add) addMember(setName, CFSTR(kAppleRAIDMembersKey), argc, argv);
if (create) createSet(setLevel, nickname, argc, argv);
if (destroy) destroySet(setName, argc, argv);
if (modify) modifySet(setName, argc, argv);
if (remove) removeMember(setName, argc, argv);
if (spare) addMember(setName, CFSTR(kAppleRAIDSparesKey), argc, argv);
if (lvcreate) createLogicalVolume(setName, setLevel, argc, argv);
if (lvdestroy) destroyLogicalVolume(setName, argc, argv);
if (lvmodify) modifyLogicalVolume(setName, argc, argv);
if (lvresize) resizeLogicalVolume(setName, argc, argv);
if (lvsnap) snapshotLogicalVolume(setName, setLevel, argc, argv);
if (watch) {
printf("watching...\n");
// Set up a signal handler so we can clean up when we're interrupted from the command line
// Otherwise we stay in our run loop forever.
sig_t oldHandler = signal(SIGINT, signalHandler);
if (oldHandler == SIG_ERR) {
printf("Could not establish new signal handler");
exit(1);
}
// Start the run loop. Now we'll receive notifications.
//
printf("Starting run loop.\n");
CFRunLoopRun();
printf("Unexpectedly back from CFRunLoopRun()!\n");
}
return 0;
}
static void
parse_psql_options(int argc, char *argv[], struct adhoc_opts * options)
{
static struct option long_options[] =
{
{"echo-all", no_argument, NULL, 'a'},
{"no-align", no_argument, NULL, 'A'},
{"command", required_argument, NULL, 'c'},
{"dbname", required_argument, NULL, 'd'},
{"echo-queries", no_argument, NULL, 'e'},
{"echo-errors", no_argument, NULL, 'b'},
{"echo-hidden", no_argument, NULL, 'E'},
{"file", required_argument, NULL, 'f'},
{"field-separator", required_argument, NULL, 'F'},
{"field-separator-zero", no_argument, NULL, 'z'},
{"host", required_argument, NULL, 'h'},
{"html", no_argument, NULL, 'H'},
{"list", no_argument, NULL, 'l'},
{"log-file", required_argument, NULL, 'L'},
{"no-readline", no_argument, NULL, 'n'},
{"single-transaction", no_argument, NULL, '1'},
{"output", required_argument, NULL, 'o'},
{"port", required_argument, NULL, 'p'},
{"pset", required_argument, NULL, 'P'},
{"quiet", no_argument, NULL, 'q'},
{"record-separator", required_argument, NULL, 'R'},
{"record-separator-zero", no_argument, NULL, '0'},
{"single-step", no_argument, NULL, 's'},
{"single-line", no_argument, NULL, 'S'},
{"tuples-only", no_argument, NULL, 't'},
{"table-attr", required_argument, NULL, 'T'},
{"username", required_argument, NULL, 'U'},
{"set", required_argument, NULL, 'v'},
{"variable", required_argument, NULL, 'v'},
{"version", no_argument, NULL, 'V'},
{"no-password", no_argument, NULL, 'w'},
{"password", no_argument, NULL, 'W'},
{"expanded", no_argument, NULL, 'x'},
{"no-psqlrc", no_argument, NULL, 'X'},
{"help", optional_argument, NULL, 1},
{NULL, 0, NULL, 0}
};
int optindex;
int c;
memset(options, 0, sizeof *options);
while ((c = getopt_long(argc, argv, "aAbc:d:eEf:F:h:HlL:no:p:P:qR:sStT:U:v:VwWxXz?01",
long_options, &optindex)) != -1)
{
switch (c)
{
case 'a':
SetVariable(pset.vars, "ECHO", "all");
break;
case 'A':
pset.popt.topt.format = PRINT_UNALIGNED;
break;
case 'b':
SetVariable(pset.vars, "ECHO", "errors");
break;
case 'c':
if (optarg[0] == '\\')
simple_action_list_append(&options->actions,
ACT_SINGLE_SLASH,
optarg + 1);
else
simple_action_list_append(&options->actions,
ACT_SINGLE_QUERY,
optarg);
break;
case 'd':
options->dbname = pg_strdup(optarg);
break;
case 'e':
SetVariable(pset.vars, "ECHO", "queries");
break;
case 'E':
SetVariableBool(pset.vars, "ECHO_HIDDEN");
break;
case 'f':
simple_action_list_append(&options->actions,
ACT_FILE,
optarg);
break;
case 'F':
pset.popt.topt.fieldSep.separator = pg_strdup(optarg);
pset.popt.topt.fieldSep.separator_zero = false;
break;
case 'h':
options->host = pg_strdup(optarg);
break;
case 'H':
pset.popt.topt.format = PRINT_HTML;
break;
case 'l':
options->list_dbs = true;
break;
case 'L':
options->logfilename = pg_strdup(optarg);
break;
case 'n':
options->no_readline = true;
break;
case 'o':
if (!setQFout(optarg))
exit(EXIT_FAILURE);
break;
case 'p':
options->port = pg_strdup(optarg);
break;
case 'P':
{
char *value;
char *equal_loc;
bool result;
value = pg_strdup(optarg);
equal_loc = strchr(value, '=');
if (!equal_loc)
result = do_pset(value, NULL, &pset.popt, true);
else
{
*equal_loc = '\0';
result = do_pset(value, equal_loc + 1, &pset.popt, true);
}
if (!result)
{
fprintf(stderr, _("%s: could not set printing parameter \"%s\"\n"), pset.progname, value);
exit(EXIT_FAILURE);
}
free(value);
break;
}
case 'q':
SetVariableBool(pset.vars, "QUIET");
break;
case 'R':
pset.popt.topt.recordSep.separator = pg_strdup(optarg);
pset.popt.topt.recordSep.separator_zero = false;
break;
case 's':
SetVariableBool(pset.vars, "SINGLESTEP");
break;
case 'S':
SetVariableBool(pset.vars, "SINGLELINE");
break;
case 't':
pset.popt.topt.tuples_only = true;
break;
case 'T':
pset.popt.topt.tableAttr = pg_strdup(optarg);
break;
case 'U':
options->username = pg_strdup(optarg);
break;
case 'v':
{
char *value;
char *equal_loc;
value = pg_strdup(optarg);
equal_loc = strchr(value, '=');
if (!equal_loc)
{
if (!DeleteVariable(pset.vars, value))
{
fprintf(stderr, _("%s: could not delete variable \"%s\"\n"),
pset.progname, value);
exit(EXIT_FAILURE);
}
}
else
{
*equal_loc = '\0';
if (!SetVariable(pset.vars, value, equal_loc + 1))
{
fprintf(stderr, _("%s: could not set variable \"%s\"\n"),
pset.progname, value);
exit(EXIT_FAILURE);
}
}
free(value);
break;
}
case 'V':
showVersion();
exit(EXIT_SUCCESS);
case 'w':
pset.getPassword = TRI_NO;
break;
case 'W':
pset.getPassword = TRI_YES;
break;
case 'x':
pset.popt.topt.expanded = true;
break;
case 'X':
options->no_psqlrc = true;
break;
case 'z':
pset.popt.topt.fieldSep.separator_zero = true;
break;
case '0':
pset.popt.topt.recordSep.separator_zero = true;
break;
case '1':
options->single_txn = true;
break;
case '?':
/* Actual help option given */
if (strcmp(argv[optind - 1], "-?") == 0)
{
usage(NOPAGER);
exit(EXIT_SUCCESS);
}
/* unknown option reported by getopt */
else
goto unknown_option;
break;
case 1:
{
if (!optarg || strcmp(optarg, "options") == 0)
usage(NOPAGER);
else if (optarg && strcmp(optarg, "commands") == 0)
slashUsage(NOPAGER);
else if (optarg && strcmp(optarg, "variables") == 0)
helpVariables(NOPAGER);
else
goto unknown_option;
exit(EXIT_SUCCESS);
}
break;
default:
unknown_option:
fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
pset.progname);
exit(EXIT_FAILURE);
break;
}
}
/*
* if we still have arguments, use it as the database name and username
*/
while (argc - optind >= 1)
{
if (!options->dbname)
options->dbname = argv[optind];
else if (!options->username)
options->username = argv[optind];
else if (!pset.quiet)
fprintf(stderr, _("%s: warning: extra command-line argument \"%s\" ignored\n"),
pset.progname, argv[optind]);
optind++;
}
}
int
main(int argc, char **argv)
{
RestoreOptions *opts;
int c;
int exit_code;
int numWorkers = 1;
Archive *AH;
char *inputFileSpec;
static int disable_triggers = 0;
static int enable_row_security = 0;
static int if_exists = 0;
static int no_data_for_failed_tables = 0;
static int outputNoTablespaces = 0;
static int use_setsessauth = 0;
static int no_security_labels = 0;
struct option cmdopts[] = {
{"clean", 0, NULL, 'c'},
{"create", 0, NULL, 'C'},
{"data-only", 0, NULL, 'a'},
{"dbname", 1, NULL, 'd'},
{"exit-on-error", 0, NULL, 'e'},
{"file", 1, NULL, 'f'},
{"format", 1, NULL, 'F'},
{"function", 1, NULL, 'P'},
{"host", 1, NULL, 'h'},
{"index", 1, NULL, 'I'},
{"jobs", 1, NULL, 'j'},
{"list", 0, NULL, 'l'},
{"no-privileges", 0, NULL, 'x'},
{"no-acl", 0, NULL, 'x'},
{"no-owner", 0, NULL, 'O'},
{"no-reconnect", 0, NULL, 'R'},
{"port", 1, NULL, 'p'},
{"no-password", 0, NULL, 'w'},
{"password", 0, NULL, 'W'},
{"schema", 1, NULL, 'n'},
{"schema-only", 0, NULL, 's'},
{"superuser", 1, NULL, 'S'},
{"table", 1, NULL, 't'},
{"trigger", 1, NULL, 'T'},
{"use-list", 1, NULL, 'L'},
{"username", 1, NULL, 'U'},
{"verbose", 0, NULL, 'v'},
{"single-transaction", 0, NULL, '1'},
/*
* the following options don't have an equivalent short option letter
*/
{"disable-triggers", no_argument, &disable_triggers, 1},
{"enable-row-security", no_argument, &enable_row_security, 1},
{"if-exists", no_argument, &if_exists, 1},
{"no-data-for-failed-tables", no_argument, &no_data_for_failed_tables, 1},
{"no-tablespaces", no_argument, &outputNoTablespaces, 1},
{"role", required_argument, NULL, 2},
{"section", required_argument, NULL, 3},
{"use-set-session-authorization", no_argument, &use_setsessauth, 1},
{"no-security-labels", no_argument, &no_security_labels, 1},
{NULL, 0, NULL, 0}
};
set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_dump"));
init_parallel_dump_utils();
opts = NewRestoreOptions();
progname = get_progname(argv[0]);
if (argc > 1)
{
if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
{
usage(progname);
exit_nicely(0);
}
if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
{
puts("pg_restore (PostgreSQL) " PG_VERSION);
exit_nicely(0);
}
}
while ((c = getopt_long(argc, argv, "acCd:ef:F:h:I:j:lL:n:Op:P:RsS:t:T:U:vwWx1",
cmdopts, NULL)) != -1)
{
switch (c)
{
case 'a': /* Dump data only */
opts->dataOnly = 1;
break;
case 'c': /* clean (i.e., drop) schema prior to create */
opts->dropSchema = 1;
break;
case 'C':
opts->createDB = 1;
break;
case 'd':
opts->dbname = pg_strdup(optarg);
break;
case 'e':
opts->exit_on_error = true;
break;
case 'f': /* output file name */
opts->filename = pg_strdup(optarg);
break;
case 'F':
if (strlen(optarg) != 0)
opts->formatName = pg_strdup(optarg);
break;
case 'h':
if (strlen(optarg) != 0)
opts->pghost = pg_strdup(optarg);
break;
case 'j': /* number of restore jobs */
numWorkers = atoi(optarg);
break;
case 'l': /* Dump the TOC summary */
opts->tocSummary = 1;
break;
case 'L': /* input TOC summary file name */
opts->tocFile = pg_strdup(optarg);
break;
case 'n': /* Dump data for this schema only */
simple_string_list_append(&opts->schemaNames, optarg);
break;
case 'O':
opts->noOwner = 1;
break;
case 'p':
if (strlen(optarg) != 0)
opts->pgport = pg_strdup(optarg);
break;
case 'R':
/* no-op, still accepted for backwards compatibility */
break;
case 'P': /* Function */
opts->selTypes = 1;
opts->selFunction = 1;
simple_string_list_append(&opts->functionNames, optarg);
break;
case 'I': /* Index */
opts->selTypes = 1;
opts->selIndex = 1;
simple_string_list_append(&opts->indexNames, optarg);
break;
case 'T': /* Trigger */
opts->selTypes = 1;
opts->selTrigger = 1;
simple_string_list_append(&opts->triggerNames, optarg);
break;
case 's': /* dump schema only */
opts->schemaOnly = 1;
break;
case 'S': /* Superuser username */
if (strlen(optarg) != 0)
opts->superuser = pg_strdup(optarg);
break;
case 't': /* Dump data for this table only */
opts->selTypes = 1;
opts->selTable = 1;
simple_string_list_append(&opts->tableNames, optarg);
break;
case 'U':
opts->username = pg_strdup(optarg);
break;
case 'v': /* verbose */
opts->verbose = 1;
break;
case 'w':
opts->promptPassword = TRI_NO;
break;
case 'W':
opts->promptPassword = TRI_YES;
break;
case 'x': /* skip ACL dump */
opts->aclsSkip = 1;
break;
case '1': /* Restore data in a single transaction */
opts->single_txn = true;
opts->exit_on_error = true;
break;
case 0:
/*
* This covers the long options without a short equivalent.
*/
break;
case 2: /* SET ROLE */
opts->use_role = pg_strdup(optarg);
break;
case 3: /* section */
set_dump_section(optarg, &(opts->dumpSections));
break;
default:
fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
exit_nicely(1);
}
}
/* Get file name from command line */
if (optind < argc)
inputFileSpec = argv[optind++];
else
inputFileSpec = NULL;
/* Complain if any arguments remain */
if (optind < argc)
{
fprintf(stderr, _("%s: too many command-line arguments (first is \"%s\")\n"),
progname, argv[optind]);
fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
progname);
exit_nicely(1);
}
/* Should get at most one of -d and -f, else user is confused */
if (opts->dbname)
{
if (opts->filename)
{
fprintf(stderr, _("%s: options -d/--dbname and -f/--file cannot be used together\n"),
progname);
fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
progname);
exit_nicely(1);
}
opts->useDB = 1;
}
if (opts->dataOnly && opts->schemaOnly)
{
fprintf(stderr, _("%s: options -s/--schema-only and -a/--data-only cannot be used together\n"),
progname);
exit_nicely(1);
}
if (opts->dataOnly && opts->dropSchema)
{
fprintf(stderr, _("%s: options -c/--clean and -a/--data-only cannot be used together\n"),
progname);
exit_nicely(1);
}
/* Can't do single-txn mode with multiple connections */
if (opts->single_txn && numWorkers > 1)
{
fprintf(stderr, _("%s: cannot specify both --single-transaction and multiple jobs\n"),
progname);
exit_nicely(1);
}
opts->disable_triggers = disable_triggers;
opts->enable_row_security = enable_row_security;
opts->noDataForFailedTables = no_data_for_failed_tables;
opts->noTablespace = outputNoTablespaces;
opts->use_setsessauth = use_setsessauth;
opts->no_security_labels = no_security_labels;
if (if_exists && !opts->dropSchema)
{
fprintf(stderr, _("%s: option --if-exists requires option -c/--clean\n"),
progname);
exit_nicely(1);
}
opts->if_exists = if_exists;
if (opts->formatName)
{
switch (opts->formatName[0])
{
case 'c':
case 'C':
opts->format = archCustom;
break;
case 'd':
case 'D':
opts->format = archDirectory;
break;
case 't':
case 'T':
opts->format = archTar;
break;
default:
write_msg(NULL, "unrecognized archive format \"%s\"; please specify \"c\", \"d\", or \"t\"\n",
opts->formatName);
exit_nicely(1);
}
}
AH = OpenArchive(inputFileSpec, opts->format);
/*
* We don't have a connection yet but that doesn't matter. The connection
* is initialized to NULL and if we terminate through exit_nicely() while
* it's still NULL, the cleanup function will just be a no-op.
*/
on_exit_close_archive(AH);
/* Let the archiver know how noisy to be */
AH->verbose = opts->verbose;
/*
* Whether to keep submitting sql commands as "pg_restore ... | psql ... "
*/
AH->exit_on_error = opts->exit_on_error;
if (opts->tocFile)
SortTocFromFile(AH, opts);
/* See comments in pg_dump.c */
#ifdef WIN32
if (numWorkers > MAXIMUM_WAIT_OBJECTS)
{
fprintf(stderr, _("%s: maximum number of parallel jobs is %d\n"),
progname, MAXIMUM_WAIT_OBJECTS);
exit(1);
}
#endif
AH->numWorkers = numWorkers;
if (opts->tocSummary)
PrintTOCSummary(AH, opts);
else
{
SetArchiveRestoreOptions(AH, opts);
RestoreArchive(AH);
}
/* done, print a summary of ignored errors */
if (AH->n_errors)
fprintf(stderr, _("WARNING: errors ignored on restore: %d\n"),
AH->n_errors);
/* AH may be freed in CloseArchive? */
exit_code = AH->n_errors ? 1 : 0;
CloseArchive(AH, NULL);
return exit_code;
}
int main (int argc, char *argv[])
{
enum {
OPT_SERVER,
OPT_MUTLI_SERVER,
OPT_DAEMON,
OPT_VERBOSE,
OPT_QUIET,
OPT_SH,
OPT_CSH,
OPT_OPTIONS,
OPT_NO_DETACH,
OPT_LOG_FILE,
OPT_VERSION,
OPT_HELP
};
static struct option long_options[] = {
{ "server", no_argument, NULL, OPT_SERVER },
{ "multi-server", no_argument, NULL, OPT_MUTLI_SERVER },
{ "daemon", no_argument, NULL, OPT_DAEMON },
{ "verbose", no_argument, NULL, OPT_VERBOSE },
{ "quiet", no_argument, NULL, OPT_QUIET },
{ "sh", no_argument, NULL, OPT_SH },
{ "csh", no_argument, NULL, OPT_CSH },
{ "options", required_argument, NULL, OPT_OPTIONS },
{ "no-detach", no_argument, NULL, OPT_NO_DETACH },
{ "log-file", required_argument, NULL, OPT_LOG_FILE },
{ "version", no_argument, NULL, OPT_VERSION },
{ "help", no_argument, NULL, OPT_HELP },
{ NULL, 0, NULL, 0 }
};
int long_options_ret;
int base_argc = 1;
int usage_ok = 1;
enum {
RUN_MODE_NONE,
RUN_MODE_SERVER,
RUN_MODE_MULTI_SERVER,
RUN_MODE_DAEMON
} run_mode = RUN_MODE_NONE;
int env_is_csh = 0;
int log_verbose = 0;
int log_quiet = 0;
int no_detach = 0;
char *config_file = NULL;
char *log_file = NULL;
char *home_dir = NULL;
int have_at_least_one_provider=0;
FILE *fp_log = NULL;
int i;
CK_RV rv;
dconfig_data_t config;
const char * CONFIG_SUFFIX = ".conf";
char *default_config_file = NULL;
#if !defined(HAVE_W32_SYSTEM)
s_parent_pid = getpid ();
#endif
if ((default_config_file = (char *)malloc (strlen (PACKAGE)+strlen (CONFIG_SUFFIX)+1)) == NULL) {
common_log (LOG_FATAL, "malloc failed");
}
sprintf (default_config_file, "%s%s", PACKAGE, CONFIG_SUFFIX);
common_set_log_stream (stderr);
while ((long_options_ret = getopt_long (argc, argv, "vqsc", long_options, NULL)) != -1) {
base_argc++;
switch (long_options_ret) {
case OPT_SERVER:
run_mode = RUN_MODE_SERVER;
break;
case OPT_MUTLI_SERVER:
run_mode = RUN_MODE_MULTI_SERVER;
break;
case OPT_DAEMON:
run_mode = RUN_MODE_DAEMON;
break;
case OPT_VERBOSE:
case 'v':
log_verbose = 1;
break;
case OPT_QUIET:
case 'q':
log_quiet = 1;
break;
case OPT_SH:
case 's':
break;
case OPT_CSH:
case 'c':
env_is_csh = 1;
break;
case OPT_OPTIONS:
base_argc++;
config_file = strdup (optarg);
break;
case OPT_NO_DETACH:
no_detach = 1;
break;
case OPT_LOG_FILE:
base_argc++;
log_file = strdup (optarg);
break;
case OPT_VERSION:
printf (
"%s %s\n"
"\n"
"Copyright (c) 2006-2007 Zeljko Vrba <*****@*****.**>\n"
"Copyright (c) 2006-2011 Alon Bar-Lev <*****@*****.**>\n"
"\n"
"This is free software; see the source for copying conditions.\n"
"There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n",
PACKAGE,
PACKAGE_VERSION
);
exit (1);
break;
case OPT_HELP:
usage_ok = 0;
break;
default:
usage_ok = 0;
break;
}
}
if (base_argc < argc) {
if (!strcmp (argv[base_argc], "--")) {
base_argc++;
}
}
if (!usage_ok) {
usage (argv[0]);
}
if (run_mode == RUN_MODE_NONE) {
common_log (LOG_FATAL, "please use the option `--daemon' to run the program in the background");
}
#if defined(HAVE_W32_SYSTEM)
if (run_mode == RUN_MODE_DAEMON) {
common_log (LOG_FATAL, "daemon mode is not supported");
}
#endif
home_dir = get_home_dir ();
if (config_file == NULL) {
if ((config_file = (char *)malloc (strlen (home_dir) + strlen (default_config_file)+2)) == NULL) {
common_log (LOG_FATAL, "malloc failed");
}
sprintf (config_file, "%s%c%s", home_dir, CONFIG_PATH_SEPARATOR, default_config_file);
}
if (
!dconfig_read (config_file, &config) &&
!dconfig_read (CONFIG_SYSTEM_CONFIG, &config)
) {
common_log (LOG_FATAL, "Cannot open configuration file");
}
if (log_file != NULL) {
if (config.log_file != NULL) {
free (config.log_file);
}
if ((config.log_file = strdup (log_file)) == NULL) {
common_log (LOG_FATAL, "strdup failed");
}
}
if (log_verbose) {
config.verbose = 1;
}
#if !defined(HAVE_W32_SYSTEM)
signal (SIGPIPE, SIG_IGN);
signal (SIGINT, on_signal);
signal (SIGTERM, on_signal);
signal (SIGABRT, on_signal);
signal (SIGHUP, on_signal);
#endif
if (log_file != NULL) {
if (strcmp (log_file, "stderr")) {
if ((fp_log = fopen (log_file, "a")) != NULL) {
common_set_log_stream (fp_log);
}
}
}
else if (config.log_file != NULL) {
if (strcmp (config.log_file, "stderr")) {
if ((fp_log = fopen (config.log_file, "a")) != NULL) {
common_set_log_stream (fp_log);
}
}
}
if (config.debug) {
common_log (LOG_DEBUG, "version: %s", PACKAGE_VERSION);
dconfig_print (&config);
common_log (LOG_DEBUG, "run_mode: %d", run_mode);
common_log (LOG_DEBUG, "crypto: %s",
#if defined(ENABLE_OPENSSL)
"openssl"
#elif defined(ENABLE_GNUTLS)
"gnutls"
#else
"invalid"
#endif
);
}
#if !defined(HAVE_W32_SYSTEM)
if (run_mode == RUN_MODE_DAEMON || run_mode == RUN_MODE_MULTI_SERVER) {
server_socket_create_name ();
}
/*
* fork before doing PKCS#11 stuff
* some providers don't behave well
*/
if (run_mode == RUN_MODE_DAEMON) {
pid_t pid;
pid = fork ();
if (pid == -1) {
common_log (LOG_FATAL, "fork failed");
}
if (pid != 0) {
static const char *key = "SCDAEMON_INFO";
char env[1024];
snprintf (env, sizeof (env), "%s:%lu:1", s_socket_name, (unsigned long)pid);
if (argc - base_argc > 0) {
setenv(key, env, 1);
execvp (argv[base_argc], &(argv[base_argc]));
kill (pid, SIGTERM);
exit (1);
}
else {
if (env_is_csh) {
*strchr (env, '=') = ' ';
printf ("setenv %s %s\n", key, env);
}
else {
printf ("%s=%s; export %s\n", key, env, key);
}
exit (0);
}
}
if (!no_detach) {
int i;
for (i=0;i<3;i++) {
if (fileno (common_get_log_stream ()) != i) {
close (i);
}
}
if (setsid () == -1) {
common_log (LOG_FATAL, "setsid failed");
}
}
if (chdir ("/") == -1) {
common_log (LOG_FATAL, "chdir failed");
}
if (argc - base_argc > 0) {
struct sigaction sa;
memset (&sa, 0, sizeof (sa));
sigemptyset (&sa.sa_mask);
#if defined(SA_INTERRUPT)
sa.sa_flags |= SA_INTERRUPT;
#endif
sa.sa_handler = on_alarm;
sigaction (SIGALRM, &sa, NULL);
alarm (10);
}
}
#endif /* HAVE_W32_SYSTEM */
assuan_set_assuan_log_prefix (PACKAGE);
assuan_set_assuan_log_stream (common_get_log_stream ());
#if defined(USE_GNUTLS)
if (gnutls_global_init () != GNUTLS_E_SUCCESS) {
common_log (LOG_FATAL, "Cannot initialize gnutls");
}
#endif
if ((rv = pkcs11h_initialize ()) != CKR_OK) {
common_log (LOG_FATAL, "Cannot initialize PKCS#11: %s", pkcs11h_getMessage (rv));
}
pkcs11h_setLogLevel (config.verbose ? PKCS11H_LOG_DEBUG2 : PKCS11H_LOG_INFO);
pkcs11h_setLogHook (pkcs11_log_hook, NULL);
pkcs11h_setTokenPromptHook (pkcs11_token_prompt_hook, NULL);
pkcs11h_setPINPromptHook (pkcs11_pin_prompt_hook, NULL);
pkcs11h_setProtectedAuthentication (TRUE);
for (i=0;i<DCONFIG_MAX_PROVIDERS;i++) {
if (
config.providers[i].name != NULL &&
config.providers[i].library != NULL
) {
if (
(rv = pkcs11h_addProvider (
config.providers[i].name,
config.providers[i].library,
config.providers[i].allow_protected,
config.providers[i].private_mask,
PKCS11H_SLOTEVENT_METHOD_POLL,
0,
config.providers[i].cert_is_private
)) != CKR_OK
) {
common_log (LOG_WARNING, "Cannot add PKCS#11 provider '%s': %ld-'%s'", config.providers[i].name, rv, pkcs11h_getMessage (rv));
}
else {
have_at_least_one_provider = 1;
}
}
}
if (!have_at_least_one_provider) {
common_log (LOG_FATAL, "Could not load any provider");
}
#if defined(HAVE_W32_SYSTEM)
command_handler (-1, &config);
#else
{
pthread_t accept_thread = 0;
int accept_socket = -1;
if (run_mode == RUN_MODE_DAEMON || run_mode == RUN_MODE_MULTI_SERVER) {
accept_socket = server_socket_create ();
server_socket_accept (accept_socket, &accept_thread, &config);
}
if (run_mode == RUN_MODE_DAEMON) {
/*
* Emulate assuan behavior
*/
int fds[2];
char c;
if (pipe (fds)==-1) {
common_log (LOG_FATAL, "Could not create pipe");
}
close (0);
dup2 (fds[0], 0);
close (fds[0]);
while (read (0, &c, 1) == -1 && errno == EINTR);
close (fds[1]);
}
else {
command_handler (-1, &config);
}
if (run_mode == RUN_MODE_DAEMON || run_mode == RUN_MODE_MULTI_SERVER) {
server_socket_accept_terminate (accept_thread);
server_socket_close (accept_socket);
}
}
#endif
pkcs11h_terminate ();
#if defined(USE_GNUTLS)
gnutls_global_deinit ();
#endif
dconfig_free (&config);
if (log_file != NULL) {
free (log_file);
log_file = NULL;
}
if (config_file != NULL) {
free (config_file);
config_file = NULL;
}
if (default_config_file != NULL) {
free (default_config_file);
default_config_file = NULL;
}
if (home_dir != NULL) {
free (home_dir);
home_dir = NULL;
}
if (fp_log != NULL) {
fclose (fp_log);
fp_log = NULL;
}
return 0;
}
static void
process_parameters (int argc, char **argv)
{
ret_t ret;
int c;
cherokee_boolean_t error = false;
struct option long_options[] = {
{"help", no_argument, NULL, 'h'},
{"version", no_argument, NULL, 'V'},
{"debug", no_argument, NULL, 'x'},
{"unsecure", no_argument, NULL, 'u'},
{"internal-tcp", no_argument, NULL, 't'},
{"disable-iocache", no_argument, NULL, 'i'},
{"bind", optional_argument, NULL, 'b'},
{"appdir", required_argument, NULL, 'd'},
{"port", required_argument, NULL, 'p'},
{"target", required_argument, NULL, 'C'},
{"threads", required_argument, NULL, 'T'},
{NULL, 0, NULL, 0}
};
while ((c = getopt_long(argc, argv, "hVxutib::d:p:C:T:", long_options, NULL)) != -1) {
switch(c) {
case 'b':
free (bind_to);
if (optarg) {
bind_to = strdup(optarg);
} else if (argv[optind] && argv[optind][0] != '-') {
bind_to = strdup(argv[optind]);
optind++;
} else {
bind_to = NULL;
}
break;
case 'p':
ret = cherokee_atoi (optarg, &port);
if (ret != ret_ok) {
error = true;
}
break;
case 'T':
ret = cherokee_atoi (optarg, &thread_num);
if (ret != ret_ok) {
error = true;
}
break;
case 'd':
free (document_root);
document_root = strdup(optarg);
break;
case 'C':
free (config_file);
config_file = strdup(optarg);
break;
case 'x':
debug = 1;
iocache = 0;
break;
case 'u':
unsecure = 1;
break;
case 'i':
iocache = 0;
break;
case 't':
scgi_port = 0;
break;
case 'V':
printf (APP_NAME " " PACKAGE_VERSION "\n" APP_COPY_NOTICE);
exit(0);
case 'h':
case '?':
default:
error = true;
}
if (error) {
print_help();
exit (1);
}
}
/* Check for trailing parameters
*/
for (c = optind; c < argc; c++) {
if ((argv[c] != NULL) && (strlen(argv[c]) > 0)) {
print_help();
exit (1);
}
}
}
int
main(int argc, char **argv)
{
int c, opt_index;
int verbose = 0;
int opt_e = 0, opt_r = 0, opt_s = 0, opt_u = 0;
char *server;
while ((c=getopt_long(argc, argv, "hersuv", opts, &opt_index)) != -1) {
switch (c) {
case 'h':
print_help(argv[0]);
exit(0);
break;
case 'e':
opt_e = 1;
break;
case 'r':
opt_r = 1;
break;
case 's':
opt_s = 1;
break;
case 'u':
opt_u = 1;
break;
case 'v':
verbose++;
break;
default:
print_help(argv[0]);
exit(1);
break;
}
}
if (optind == argc) {
fprintf(stderr, "no server given!\n");
return -1;
}
server = argv[optind];
if (!is_alive(server)) {
printf("%s is not responding.\n", server);
return 1;
}
printf("%s is alive.\n", server);
if (cmyth_conn_block_shutdown(control) < 0) {
printf("Failed to block backend shutdown!\n");
}
if (verbose) {
int version, count;
cmyth_proglist_t list;
long long total, used;
printf("libcmyth version %s\n", cmyth_version());
printf("librefmem version %s\n", ref_version());
version = cmyth_conn_get_protocol_version(control);
printf("\tprotocol version: %d\n", version);
list = cmyth_proglist_get_all_recorded(control);
count = cmyth_proglist_get_count(list);
printf("\trecordings: %d\n", count);
if (cmyth_conn_get_freespace(control, &total, &used) == 0) {
printf("\ttotal space: %lld bytes\n", total);
printf("\tused space: %lld bytes\n", used);
}
get_event(server);
ref_release(list);
}
if (opt_e) {
get_recordings(verbose);
}
if (opt_r) {
get_recorders(verbose);
}
if (opt_s) {
get_scheduled(verbose);
}
if (opt_u) {
get_upcoming(verbose);
}
if (cmyth_conn_allow_shutdown(control) < 0) {
printf("Failed to allow backend shutdown!\n");
}
ref_release(control);
if (verbose > 1) {
unsigned int refs, bytes;
ref_get_usage(&refs, &bytes);
printf("Refmem: refs %d\n", refs);
printf("Refmem: bytes %d\n", bytes);
if (refs > 0) {
ref_alloc_show();
}
}
return 0;
}
int processOptions(int argc, char *argv[], options *opts)
{
int c;
int index;
bool scalling = false;
while( (c = getopt_long(argc, argv, "a:b:c:d:D:ef:gGhHk:K:l:Ln:o:rs:S:Vw:x:y:z", long_options, &index)) != -1 )
{
switch(c)
{
case 'a':
#if RENDERING
if (strcmp(optarg, "dot") && strcmp(optarg, "neato") && strcmp(optarg, "fdp") && strcmp(optarg, "sfdp") && strcmp(optarg, "twopi") && strcmp(optarg, "circo")) {
std::cerr<<PACKAGE_NAME<<" [WARNING]: '"<<optarg<<"' is not a recognised layout algorithm. Please choose from the following:"<<std::endl;
#ifdef HAVE_NEATO
std::cerr<<"\tneato"<<std::endl;
#endif
#ifdef HAVE_DOT
std::cerr<<"\tdot"<<std::endl;
#endif
#ifdef HAVE_FDP
std::cerr<<"\tfdp"<<std::endl;
#endif
#ifdef HAVE_SFDP
std::cerr<<"\tsfdp"<<std::endl;
#endif
#ifdef HAVE_CIRCO
std::cerr<<"\tcirco"<<std::endl;
#endif
#ifdef HAVE_TWOPI
std::cerr<<"\ttwopi"<<std::endl;
#endif
} else {
opts->layoutAlgorithm = optarg;
}
#else
std::cerr<<PACKAGE_NAME<<" [WARNING]: Not compiled with the correct options to allow rendering of graphs.\nEither use the --enable-rendering option during ./configure and make sure that the graphviz layout programs are in your PATH"<<std::endl;
#endif
break;
case 'b':
from_string<int>(opts->coverageBins, optarg, std::dec);
if (opts->coverageBins < 1)
{
std::cerr<<PACKAGE_NAME<<" [ERROR]: The number of bins for coverage cannot be less than 1"<<std::endl;
usage();
exit(1);
}
break;
case 'c':
if (strcmp(optarg, "red-blue") == 0)
{
opts->graphColourType = RED_BLUE;
}
else if(strcmp(optarg, "read-blue-green") == 0)
{
opts->graphColourType = RED_BLUE_GREEN;
}
else if(strcmp(optarg, "blue-red") == 0)
{
opts->graphColourType = BLUE_RED;
}
else if(strcmp(optarg, "green-blue-red") == 0)
{
opts->graphColourType = GREEN_BLUE_RED;
}
else
{
std::cerr<<PACKAGE_NAME<<" [WARNING]: Unknown graph colour type "<<optarg<<" changing to default colour type (red-blue)"<<std::endl;
opts->graphColourType = RED_BLUE;
}
break;
case 'd':
from_string<unsigned int>(opts->lowDRsize, optarg, std::dec);
if (opts->lowDRsize < 8)
{
std::cerr<<PACKAGE_NAME<<" [WARNING]: The lower bound for direct repeat sizes cannot be "<<opts->lowDRsize<<" changing to "<<CRASS_DEF_MIN_DR_SIZE<<std::endl;
opts->lowDRsize = CRASS_DEF_MIN_DR_SIZE;
}
break;
case 'D':
from_string<unsigned int>(opts->highDRsize, optarg, std::dec);
break;
case 'e':
#ifdef DEBUG
opts->noDebugGraph = true;
#endif
break;
case 'f':
from_string<int>(opts->covCutoff, optarg, std::dec);
break;
case 'g':
opts->logToScreen = true;
break;
case 'G':
opts->showSingles= true;
break;
case 'h':
versionInfo();
usage();
exit(1);
break;
case 'H':
opts->removeHomopolymers = true;
break;
case 'k':
from_string<int>(opts->kmer_clust_size, optarg, std::dec);
if (opts->kmer_clust_size < 4)
{
std::cerr<<PACKAGE_NAME<<" [WARNING]: Minimum value for kmer clustering size is: "<<4<<" changing to "<<CRASS_DEF_K_CLUST_MIN<<std::endl;
opts->kmer_clust_size = CRASS_DEF_K_CLUST_MIN;
}
break;
case 'K':
from_string<int>(opts->cNodeKmerLength, optarg, std::dec);
break;
case 'l':
from_string<int>(opts->logLevel, optarg, std::dec);
if(opts->logLevel > CRASS_DEF_MAX_LOGGING)
{
std::cerr<<PACKAGE_NAME<<" [WARNING]: Specified log level higher than max. Changing log level to "<<CRASS_DEF_MAX_LOGGING<<" instead of "<<opts->logLevel<<std::endl;
opts->logLevel = CRASS_DEF_MAX_LOGGING;
}
break;
case 'L':
opts->longDescription = true;
break;
case 'n':
from_string<unsigned int>(opts->minNumRepeats, optarg, std::dec);
if (opts->minNumRepeats < 2)
{
std::cerr<<PACKAGE_NAME<<" [ERROR]: The mininum number of repeats cannot be less than 2"<<std::endl;
usage();
exit(1);
}
break;
case 'o':
opts->output_fastq = optarg;
// just in case the user put '.' or '..' or '~' as the output directory
if (opts->output_fastq[opts->output_fastq.length() - 1] != '/')
{
opts->output_fastq += '/';
}
// check if our output folder exists
struct stat file_stats;
if (0 != stat(opts->output_fastq.c_str(),&file_stats))
{
RecursiveMkdir(opts->output_fastq);
}
// check that the directory is writable
else if(access(optarg, W_OK))
{
std::cerr<<PACKAGE_NAME<<" [ERROR]: You do not have permission to write to "<<optarg<<std::endl;
exit(1);
}
break;
case 'r':
#ifdef RENDERING
opts->noRendering = true;
#endif
break;
case 's':
from_string<unsigned int>(opts->lowSpacerSize, optarg, std::dec);
if (opts->lowSpacerSize < 8)
{
std::cerr<<PACKAGE_NAME<<" [WARNING]: The lower bound for spacer sizes cannot be "<<opts->lowSpacerSize<<" changing to "<<CRASS_DEF_MIN_SPACER_SIZE<<std::endl;
opts->lowSpacerSize = CRASS_DEF_MIN_SPACER_SIZE;
}
break;
case 'S':
from_string<unsigned int>(opts->highSpacerSize, optarg, std::dec);
break;
case 'V':
versionInfo();
exit(1);
break;
case 'w':
from_string<unsigned int>(opts->searchWindowLength, optarg, std::dec);
if ((opts->searchWindowLength < CRASS_DEF_MIN_SEARCH_WINDOW_LENGTH) || (opts->searchWindowLength > CRASS_DEF_MAX_SEARCH_WINDOW_LENGTH))
{
std::cerr<<PACKAGE_NAME<<" [WARNING]: Specified window length higher than max. Changing window length to " << CRASS_DEF_OPTIMAL_SEARCH_WINDOW_LENGTH << " instead of " << opts->searchWindowLength<<std::endl;
// Change window length
opts->searchWindowLength = CRASS_DEF_OPTIMAL_SEARCH_WINDOW_LENGTH;
}
break;
case 'x':
from_string<double>(opts->averageSpacerScalling, optarg, std::dec);
if (isNotDecimal(opts->averageSpacerScalling))
{
std::cerr<<PACKAGE_NAME<<" [WARNING]: The average spacer scalling must be a decimal number. Changing to "<<CRASS_DEF_HOMOPOLYMER_SCALLING<<" instead of "<<opts->averageSpacerScalling<<std::endl;
opts->averageSpacerScalling = CRASS_DEF_HOMOPOLYMER_SCALLING;
}
scalling = true;
break;
case 'y':
from_string<double>(opts->averageDrScalling, optarg, std::dec);
if (isNotDecimal(opts->averageDrScalling))
{
std::cerr<<PACKAGE_NAME<<" [WARNING]: The average spacer scalling must be a decimal number. Changing to "<<CRASS_DEF_HOMOPOLYMER_SCALLING<<" instead of "<<opts->averageDrScalling<<std::endl;
opts->averageDrScalling = CRASS_DEF_HOMOPOLYMER_SCALLING;
}
scalling = true;
break;
case 'z':
opts->dontPerformScalling = true;
break;
case 0:
#ifdef SEARCH_SINGLETON
if (strcmp("searchChecker", long_options[index].name) == 0) opts->searchChecker = optarg;
#endif
break;
default:
versionInfo();
usage();
exit(1);
break;
}
}
// Sanity checks for the high and low dr size
if (opts->lowDRsize >= opts->highDRsize)
{
std::cerr<<PACKAGE_NAME<<" [ERROR]: The lower direct repeat bound is bigger than the higher bound ("<<opts->lowDRsize<<" >= "<<opts->highDRsize<<")"<<std::endl;
usage();
exit(1);
}
// Sanity checks for the high and low spacer size
if (opts->lowSpacerSize >= opts->highSpacerSize)
{
std::cerr<<PACKAGE_NAME<<" [ERROR]: The lower spacer bound is bigger than the higher bound ("<<opts->lowSpacerSize<<" >= "<<opts->highSpacerSize<<")"<<std::endl;
usage();
exit(1);
}
// sanity check so that the user doesn't specify scalling and no scalling simultaneously
if (scalling & opts->dontPerformScalling) {
std::cerr<<PACKAGE_NAME<<" [ERROR]: Cannot use scalling (-x -y) in conjunction with --noScalling"<<std::endl;
usage();
exit(1);
}
// warn them if they try to scale without specifying to remove homopolymers
if (scalling && !opts->removeHomopolymers)
{
std::cerr<<PACKAGE_NAME<<" [ERROR]: scalling (-x -y) can only be used in conjunction with --removeHomopolymers"<<std::endl;
usage();
exit(1);
}
// scale the direct repeat and spacer lengths if we should
if (opts->removeHomopolymers && !opts->dontPerformScalling)
{
opts->lowDRsize *= opts->averageDrScalling;
opts->highDRsize *= opts->averageDrScalling;
opts->lowSpacerSize *= opts->averageSpacerScalling;
opts->highSpacerSize *= opts->averageSpacerScalling;
}
return optind;
}
int main(int argc, char* argv[])
{
int opt_reader = -1;
int opt_wait = 0;
const char *opt_pin = NULL;
int opt_key = 0;
int opt_is_iv = 0;
u8 opt_keytype = SC_RUTOKEN_OPTIONS_GOST_CRYPT_PZ;
const char *opt_input = NULL;
const char *opt_output = NULL;
int opt_operation = OP_NONE;
int opt_debug = 0;
char IV[IV_SIZE];
int err = 0;
sc_context_t *ctx = NULL;
sc_context_param_t ctx_param;
sc_card_t *card = NULL;
int c, long_optind, r, tries_left;
while (1) {
c = getopt_long(argc, argv, "r:wp:k:I:t:i:o:sgedmv",
options, &long_optind);
if (c == -1)
break;
switch (c) {
case '?':
util_print_usage_and_die(app_name, options, option_help);
case 'r':
opt_reader = atoi(optarg);
break;
case 'w':
opt_wait = 1;
break;
case 'p':
opt_pin = optarg;
break;
case 'k':
opt_key = atoi(optarg);
if (opt_key <= 0 || opt_key < SC_RUTOKEN_DO_ALL_MIN_ID
|| opt_key > SC_RUTOKEN_DO_NOCHV_MAX_ID) {
fprintf(stderr, "Error: Key ID is invalid"
" (%d <= ID <= %d)\n",
SC_RUTOKEN_DO_ALL_MIN_ID > 0 ?
SC_RUTOKEN_DO_ALL_MIN_ID : 1,
SC_RUTOKEN_DO_NOCHV_MAX_ID);
return -1;
}
break;
case 'I':
opt_is_iv = 1;
strncpy(IV, optarg, sizeof(IV));
break;
case 't':
if (strcmp(optarg, "CFB") == 0)
opt_keytype = SC_RUTOKEN_OPTIONS_GOST_CRYPT_GAMMOS;
else if (strcmp(optarg, "SM") == 0)
opt_keytype = SC_RUTOKEN_OPTIONS_GOST_CRYPT_GAMM;
else if (strcmp(optarg, "ECB") != 0) {
fprintf(stderr, "Error: Key type must be either"
" ECB, SM or CFB\n");
return -1;
}
break;
case 'i':
opt_input = optarg;
break;
case 'o':
opt_output = optarg;
break;
case 's':
opt_operation = OP_GET_INFO;
break;
case 'g':
opt_operation = OP_GEN_KEY;
break;
case 'e':
opt_operation = OP_ENCRYPT;
break;
case 'd':
opt_operation = OP_DECRYPT;
break;
case 'm':
opt_operation = OP_MAC;
break;
case 'v':
opt_debug++;
break;
}
}
memset(&ctx_param, 0, sizeof(ctx_param));
ctx_param.app_name = app_name;
r = sc_context_create(&ctx, &ctx_param);
if (r) {
fprintf(stderr, "Error: Failed to establish context: %s\n",
sc_strerror(r));
return -1;
}
ctx->debug = opt_debug;
if (util_connect_card(ctx, &card, opt_reader, 0, opt_wait, opt_debug) != 0)
err = -1;
if (err == 0 && opt_pin) {
/* verify */
r = sc_verify(card, SC_AC_CHV, SC_RUTOKEN_DEF_ID_GCHV_USER,
(u8*)opt_pin, strlen(opt_pin), &tries_left);
if (r) {
fprintf(stderr, "Error: PIN verification failed: %s",
sc_strerror(r));
if (r == SC_ERROR_PIN_CODE_INCORRECT)
fprintf(stderr, " (tries left %d)\n", tries_left);
else
putc('\n', stderr);
err = 1;
}
}
if (err == 0) {
err = -1;
switch (opt_operation) {
case OP_GET_INFO:
err = rutoken_info(card);
break;
case OP_DECRYPT:
case OP_ENCRYPT:
case OP_MAC:
if (!opt_input) {
fprintf(stderr, "Error: No input file specified\n");
break;
}
if (opt_operation != OP_MAC && !opt_output) {
fprintf(stderr, "Error: No output file specified\n");
break;
}
case OP_GEN_KEY:
if (opt_key == 0) {
fprintf(stderr, "Error: You must set key ID\n");
break;
}
if (opt_operation == OP_GEN_KEY)
err = generate_gostkey(card, (u8)opt_key, opt_keytype);
else if (opt_operation == OP_MAC)
err = gostmac(card, (u8)opt_key, opt_input);
else
err = gostchiper(card, (u8)opt_key, opt_input,opt_output,
IV, opt_is_iv, opt_operation);
break;
default:
fprintf(stderr, "Error: No operation specified\n");
break;
}
}
if (card) {
/* sc_lock and sc_connect_card in util_connect_card */
sc_unlock(card);
sc_disconnect_card(card, 0);
}
if (ctx)
sc_release_context(ctx);
return err;
}
static void parse_args(int argc, char **argv)
{
while (1)
{
int c;
/* getopt_long stores the option index here. */
int option_index = 0;
static struct option long_options[] =
{
{"verbose", no_argument, 0, 'v'},
{"quiet", no_argument, 0, 'q'},
{"daemonize", no_argument, 0, 'd'},
{"log-file", required_argument, 0, 'l'},
{"diode-off", no_argument, 0, 'o'},
{"detach-dvd", no_argument, 0, 'f'},
{"device", required_argument, 0, 1},
{"exact-device", required_argument, 0, 2},
{"version", no_argument, 0, 'V'},
{"ssid", required_argument, 0, 3},
{"event-script", required_argument, 0, 'e'},
{"help", no_argument, 0, 'h'},
{"debug", no_argument, 0, 'D'},
{0, 0, 0, 0}
};
c = getopt_long(argc, argv, "vqdl:ofVe:hD", long_options, &option_index);
/* detect the end of the options. */
if (c == -1)
break;
switch (c)
{
case 'D': {
set_wmlog_level(2);
break;
}
case 'v': {
inc_wmlog_level();
break;
}
case 'q': {
set_wmlog_level(-1);
break;
}
case 'd': {
daemonize = 1;
break;
}
case 'l': {
logfile = fopen(optarg, "a");
if (logfile == NULL) {
fprintf(stderr, "Error opening log file '%s': ", optarg);
perror(NULL);
exit(1);
}
break;
}
case 'o': {
diode_on = 0;
break;
}
case 'f': {
detach_dvd = 1;
break;
}
case 'V': {
version();
exit(0);
break;
}
case 'h': {
usage(argv[0]);
exit(0);
break;
}
case 1: {
char *delim = strchr(optarg, ':');
if (delim != NULL) {
unsigned long int vid, pid;
char *c1, *c2;
*delim = 0;
vid = strtoul(optarg, &c1, 16);
pid = strtoul(delim + 1, &c2, 16);
if (!*c1 && !*c2 && vid < 0x10000 && pid < 0x10000) {
match_method = MATCH_BY_VID_PID;
match_params.vid = vid;
match_params.pid = pid;
break;
}
}
fprintf(stderr, "Error parsing VID:PID combination.\n");
exit(1);
break;
}
case 2: {
char *delim = strchr(optarg, '/');
if (delim != NULL) {
unsigned long int bus, dev;
char *c1, *c2;
*delim = 0;
bus = strtoul(optarg, &c1, 10);
dev = strtoul(delim + 1, &c2, 10);
if (!*c1 && !*c2) {
match_method = MATCH_BY_BUS_DEV;
match_params.bus = bus;
match_params.dev = dev;
break;
}
}
fprintf(stderr, "Error parsing BUS/DEV combination.\n");
exit(1);
break;
}
case 3: {
ssid = optarg;
break;
}
case 'e': {
event_script = optarg;
break;
}
case '?': {
/* getopt_long already printed an error message. */
usage(argv[0]);
exit(1);
break;
}
default: {
exit(1);
}
}
}
}
int main(int argc, char *argv[]) {
FILE *prob_f;
char c;
int opt_idx, i, nlines = 0, ngaps = 0;
unsigned idx;
PbsCode *code;
List *fields = lst_new_ptr(10);
double error, tot_error = 0, prob;
Vector *v;
String *line = str_new(STR_MED_LEN);
struct option long_opts[] = {
{"discard-gaps", 0, 0, 'G'},
{"help", 0, 0, 'h'},
{0, 0, 0, 0}
};
/* variables for options, with defaults */
int discard_gaps = FALSE;
set_seed(-1);
while ((c = (char)getopt_long(argc, argv, "Gh", long_opts, &opt_idx)) != -1) {
switch (c) {
case 'G':
discard_gaps = TRUE;
break;
case 'h':
printf("%s", HELP);
exit(0);
case '?':
die("Bad argument. Try 'pbsEncode -h'.\n");
}
}
if (optind != argc - 2)
die("Two arguments required. Try 'pbsEncode -h'.\n");
prob_f = phast_fopen(argv[optind], "r");
code = pbs_new_from_file(phast_fopen(argv[optind+1], "r"));
v = vec_new(code->sg->d);
while (str_readline(line, prob_f) != EOF) {
if (line->length == 0 || line->chars[0] == '#') continue;
str_split(line, NULL, fields);
if (lst_size(fields) == 1 && str_equals_charstr(lst_get_ptr(fields, 0), "-")) {
ngaps++;
if (!discard_gaps)
pbs_write_binary(code, code->gap_code, stdout);
}
else { /* ordinary prob vector */
if (lst_size(fields) != code->sg->d)
die("ERROR: number of columns must equal dimension of code (%d).\n",
code->sg->d);
for (i = 0; i < code->sg->d; i++) {
if (str_as_dbl(lst_get_ptr(fields, i), &prob) != 0 || prob < 0 || prob > 1)
die("ERROR: bad value ('%s')\n", lst_get_ptr(fields, i));
vec_set(v, i, prob);
}
idx = pbs_get_index(code, v, &error);
tot_error += error;
pbs_write_binary(code, idx, stdout);
nlines++;
}
lst_free_strings(fields);
}
fprintf(stderr, "Dimensions: %d\n\
Rows per dimension: %d\n\
Code size: %d\n\
Bytes per vector: %d\n\
Vectors processed: %d\n\
Gaps: %d%s\n\
Average approximation error: %f bits\n",
code->sg->d, code->sg->nrows, code->code_size, code->nbytes,
nlines, ngaps, discard_gaps ? " (discarded)" : "", tot_error/nlines);
return 0;
}
static int adm_hwdb(struct udev *udev, int argc, char *argv[]) {
static const struct option options[] = {
{ "update", no_argument, NULL, 'u' },
{ "root", required_argument, NULL, 'r' },
{ "test", required_argument, NULL, 't' },
{ "help", no_argument, NULL, 'h' },
{}
};
const char *test = NULL;
const char *root = "";
bool update = false;
struct trie *trie = NULL;
int err;
int rc = EXIT_SUCCESS;
for (;;) {
int option;
option = getopt_long(argc, argv, "ut:r:h", options, NULL);
if (option == -1)
break;
switch (option) {
case 'u':
update = true;
break;
case 't':
test = optarg;
break;
case 'r':
root = optarg;
break;
case 'h':
help();
return EXIT_SUCCESS;
}
}
if (!update && !test) {
help();
return EXIT_SUCCESS;
}
if (update) {
char **files, **f;
_cleanup_free_ char *hwdb_bin = NULL;
trie = calloc(sizeof(struct trie), 1);
if (!trie) {
rc = EXIT_FAILURE;
goto out;
}
/* string store */
trie->strings = strbuf_new();
if (!trie->strings) {
rc = EXIT_FAILURE;
goto out;
}
/* index */
trie->root = calloc(sizeof(struct trie_node), 1);
if (!trie->root) {
rc = EXIT_FAILURE;
goto out;
}
trie->nodes_count++;
err = conf_files_list_strv(&files, ".hwdb", root, conf_file_dirs);
if (err < 0) {
log_error("failed to enumerate hwdb files: %s\n", strerror(-err));
rc = EXIT_FAILURE;
goto out;
}
STRV_FOREACH(f, files) {
log_debug("reading file '%s'", *f);
import_file(udev, trie, *f);
}
strv_free(files);
strbuf_complete(trie->strings);
log_debug("=== trie in-memory ===\n");
log_debug("nodes: %8zu bytes (%8zu)\n",
trie->nodes_count * sizeof(struct trie_node), trie->nodes_count);
log_debug("children arrays: %8zu bytes (%8zu)\n",
trie->children_count * sizeof(struct trie_child_entry), trie->children_count);
log_debug("values arrays: %8zu bytes (%8zu)\n",
trie->values_count * sizeof(struct trie_value_entry), trie->values_count);
log_debug("strings: %8zu bytes\n",
trie->strings->len);
log_debug("strings incoming: %8zu bytes (%8zu)\n",
trie->strings->in_len, trie->strings->in_count);
log_debug("strings dedup'ed: %8zu bytes (%8zu)\n",
trie->strings->dedup_len, trie->strings->dedup_count);
if (asprintf(&hwdb_bin, "%s/" UDEVLIBEXECDIR "/hwdb.bin", root) < 0) {
rc = EXIT_FAILURE;
goto out;
}
mkdir_parents(hwdb_bin, 0755);
err = trie_store(trie, hwdb_bin);
if (err < 0) {
log_error("Failure writing database %s: %s", hwdb_bin, strerror(-err));
rc = EXIT_FAILURE;
}
}
int
main (int argc, char **argv)
{
int verbose = 0;
int sort = 0;
int i;
FcFontSet *fs;
FcPattern *pat;
FcResult result;
#if HAVE_GETOPT_LONG || HAVE_GETOPT
int c;
#if HAVE_GETOPT_LONG
while ((c = getopt_long (argc, argv, "Vv?", longopts, NULL)) != -1)
#else
while ((c = getopt (argc, argv, "sVv?")) != -1)
#endif
{
switch (c) {
case 's':
sort = 1;
break;
case 'V':
fprintf (stderr, "fontconfig version %d.%d.%d\n",
FC_MAJOR, FC_MINOR, FC_REVISION);
exit (0);
case 'v':
verbose = 1;
break;
default:
usage (argv[0]);
}
}
i = optind;
#else
i = 1;
#endif
if (!FcInit ())
{
fprintf (stderr, "Can't init font config library\n");
return 1;
}
if (argv[i])
pat = FcNameParse ((FcChar8 *) argv[i]);
else
pat = FcPatternCreate ();
FcConfigSubstitute (0, pat, FcMatchPattern);
FcDefaultSubstitute (pat);
if (sort)
fs = FcFontSort (0, pat, FcTrue, 0, &result);
else
{
FcPattern *match;
fs = FcFontSetCreate ();
match = FcFontMatch (0, pat, &result);
if (match)
FcFontSetAdd (fs, match);
}
if (pat)
FcPatternDestroy (pat);
if (fs)
{
int j;
for (j = 0; j < fs->nfont; j++)
{
if (verbose)
{
FcPatternPrint (fs->fonts[j]);
}
else
{
FcChar8 *family;
FcChar8 *style;
FcChar8 *file;
if (FcPatternGetString (fs->fonts[j], FC_FILE, 0, &file) != FcResultMatch)
file = "<unknown filename>";
else
{
FcChar8 *slash = strrchr (file, '/');
if (slash)
file = slash+1;
}
if (FcPatternGetString (fs->fonts[j], FC_FAMILY, 0, &family) != FcResultMatch)
family = "<unknown family>";
if (FcPatternGetString (fs->fonts[j], FC_STYLE, 0, &style) != FcResultMatch)
file = "<unknown style>";
printf ("%s: \"%s\" \"%s\"\n", file, family, style);
}
}
FcFontSetDestroy (fs);
}
return 0;
}
int main(int argc, char *argv[])
{
static const char short_options[] = "hVlp:";
static const struct option long_options[] = {
{"help", 0, NULL, 'h'},
{"version", 0, NULL, 'V'},
{"list", 0, NULL, 'l'},
{"port", 1, NULL, 'p'},
{ }
};
int do_list = 0;
struct pollfd *pfds;
int npfds;
int c, err;
init_seq();
while ((c = getopt_long(argc, argv, short_options,
long_options, NULL)) != -1) {
switch (c) {
case 'h':
help(argv[0]);
return 0;
case 'V':
version();
return 0;
case 'l':
do_list = 1;
break;
case 'p':
parse_ports(optarg);
break;
default:
help(argv[0]);
return 1;
}
}
if (optind < argc) {
help(argv[0]);
return 1;
}
if (do_list) {
list_ports();
return 0;
}
create_port();
connect_ports();
err = snd_seq_nonblock(seq, 1);
check_snd("set nonblock mode", err);
if (port_count > 0)
printf("Waiting for data.");
else
printf("Waiting for data at port %d:0.",
snd_seq_client_id(seq));
printf(" Press Ctrl+C to end.\n");
printf("Source Event Ch Data\n");
signal(SIGINT, sighandler);
signal(SIGTERM, sighandler);
npfds = snd_seq_poll_descriptors_count(seq, POLLIN);
pfds = alloca(sizeof(*pfds) * npfds);
for (;;) {
snd_seq_poll_descriptors(seq, pfds, npfds, POLLIN);
if (poll(pfds, npfds, -1) < 0)
break;
do {
snd_seq_event_t *event;
err = snd_seq_event_input(seq, &event);
if (err < 0)
break;
if (event)
dump_event(event);
} while (err > 0);
fflush(stdout);
if (stop)
break;
}
snd_seq_close(seq);
return 0;
}
int main(int argc, char **argv)
{
int permission = 0644;
int opt;
size_t size = 0;
int nsems = 0;
int ask_shm = 0, ask_msg = 0, ask_sem = 0;
static const struct option longopts[] = {
{"shmem", required_argument, NULL, 'M'},
{"semaphore", required_argument, NULL, 'S'},
{"queue", no_argument, NULL, 'Q'},
{"mode", required_argument, NULL, 'p'},
{"version", no_argument, NULL, 'V'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0}
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while((opt = getopt_long(argc, argv, "hM:QS:p:Vh", longopts, NULL)) != -1) {
switch(opt) {
case 'M':
size = strtou64_or_err(optarg, _("failed to parse size"));
ask_shm = 1;
break;
case 'Q':
ask_msg = 1;
break;
case 'S':
nsems = strtos32_or_err(optarg, _("failed to parse elements"));
ask_sem = 1;
break;
case 'p':
permission = strtoul(optarg, NULL, 8);
break;
case 'h':
usage(stdout);
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
default:
ask_shm = ask_msg = ask_sem = 0;
break;
}
}
if(!ask_shm && !ask_msg && !ask_sem)
usage(stderr);
if (ask_shm) {
int shmid;
if (-1 == (shmid = create_shm(size, permission)))
err(EXIT_FAILURE, _("create share memory failed"));
else
printf(_("Shared memory id: %d\n"), shmid);
}
if (ask_msg) {
int msgid;
if (-1 == (msgid = create_msg(permission)))
err(EXIT_FAILURE, _("create message queue failed"));
else
printf(_("Message queue id: %d\n"), msgid);
}
if (ask_sem) {
int semid;
if (-1 == (semid = create_sem(nsems, permission)))
err(EXIT_FAILURE, _("create semaphore failed"));
else
printf(_("Semaphore id: %d\n"), semid);
}
return EXIT_SUCCESS;
}
/*
* @mrule Rule structure.
*
* @return -1: Error. 0: Output help. 1: Add rule. 2: Delete rule. 3: List
* rules. 4: Flush rules.
*
*/
int parse_args(int argc, char **argv, struct mer_rule *mrule)
{
int opt, arg_index;
/* Command-line options. */
struct option mer_options[] = {
{ "index", required_argument, NULL, 'x' },
{ "delete", required_argument, NULL, 'd' },
{ "action", required_argument, NULL, 'c' },
{ "direction", required_argument, NULL, 'e' },
{ "proto", required_argument, NULL, 'r' },
{ "srcip", required_argument, NULL, 'i' },
{ "dstip", required_argument, NULL, 'I' },
{ "srcport", required_argument, NULL, 'p' },
{ "dstport", required_argument, NULL, 'P' },
{ "list", no_argument, NULL, 'l' },
{ "flush", no_argument, NULL, 'f' },
{ "help", no_argument, NULL, 'h' },
{ 0, 0, 0, 0 }
};
if (!argv || !mrule || argc < 2)
return -1;
/* Parse arguments */
opt = getopt_long(argc, argv, "lh", mer_options, &arg_index);
while (opt != -1) {
int port, index;
__u32 ip;
switch (opt) {
/* --index */
case 'x':
index = atoi(optarg);
if (index < 0)
return -1;
mrule->index = index;
break;
/* --direction */
case 'e':
if (!strcasecmp(optarg, DIRECTION_ALL_STR))
mrule->direction = DIRECTION_ALL;
else if (!strcasecmp(optarg, DIRECTION_IN_STR))
mrule->direction = DIRECTION_IN;
else if (!strcasecmp(optarg, DIRECTION_OUT_STR))
mrule->direction = DIRECTION_OUT;
else
return -1;
break;
/* --proto */
case 'r':
if (!strcasecmp(optarg, PROTO_ALL_STR))
mrule->proto = PROTO_ALL;
else if (!strcasecmp(optarg, PROTO_TCP_STR))
mrule->proto = PROTO_TCP;
else if (!strcasecmp(optarg, PROTO_UDP_STR))
mrule->proto = PROTO_UDP;
else
return -1;
break;
/* --srcip */
case 'i':
if (inet_pton(AF_INET, optarg, &ip) <= 0)
return -1;
mrule->srcip = ip;
break;
/* --dstip */
case 'I':
if (inet_pton(AF_INET, optarg, &ip) <= 0)
return -1;
mrule->dstip = ip;
break;
/* --srcport */
case 'p':
port = atoi(optarg);
if (port < 0 || port > PORT_MAX)
return -1;
mrule->srcport = port;
break;
/* --dstport */
case 'P':
port = atoi(optarg);
if (port < 0 || port > PORT_MAX)
return -1;
mrule->dstport = port;
break;
/* --action */
case 'c':
if (!strcasecmp(optarg, ACT_DROP_STR))
mrule->action = ACT_DROP;
else if (!strcasecmp(optarg, ACT_PASS_STR))
mrule->action = ACT_PASS;
else if (!strcasecmp(optarg, ACT_LOG_STR))
mrule->action = ACT_LOG;
else
return -1;
break;
/* --delete */
case 'd':
index = atoi(optarg);
if (index < 0)
return -1;
mrule->index = index;
return 2;
/* --list */
case 'l':
return 3;
/* --flush */
case 'f':
return 4;
/* --help */
case 'h':
return 0;
/* Error */
case '?':
default:
return -1;
}
opt = getopt_long(argc, argv, "lh", mer_options, &arg_index);
}
/* Default: Add rule */
return 1;
}
int main(int argc, char **argv)
{
int i, c;
int pid_flags = 0;
char *user = NULL;
char *password = NULL;
char *timeout = NULL;
char *method = NULL;
char *pid_path = NULL;
char *conf_path = NULL;
char *iface = NULL;
int server_num = 0;
const char *server_host[MAX_REMOTE_NUM];
const char *server_port = NULL;
char * nameservers[MAX_DNS_NUM + 1];
int nameserver_num = 0;
int option_index = 0;
static struct option long_options[] =
{
{ "fast-open", no_argument, 0, 0 },
{ "acl", required_argument, 0, 0 },
{ 0, 0, 0, 0 }
};
opterr = 0;
USE_TTY();
while ((c = getopt_long(argc, argv, "f:s:p:l:k:t:m:c:i:d:a:uv",
long_options, &option_index)) != -1) {
switch (c) {
case 0:
if (option_index == 0) {
fast_open = 1;
} else if (option_index == 1) {
LOGI("initialize acl...");
acl = !init_acl(optarg);
}
break;
case 's':
if (server_num < MAX_REMOTE_NUM) {
server_host[server_num++] = optarg;
}
break;
case 'p':
server_port = optarg;
break;
case 'k':
password = optarg;
break;
case 'f':
pid_flags = 1;
pid_path = optarg;
break;
case 't':
timeout = optarg;
break;
case 'm':
method = optarg;
break;
case 'c':
conf_path = optarg;
break;
case 'i':
iface = optarg;
break;
case 'd':
if (nameserver_num < MAX_DNS_NUM) {
nameservers[nameserver_num++] = optarg;
}
break;
case 'a':
user = optarg;
break;
case 'u':
udprelay = 1;
break;
case 'v':
verbose = 1;
break;
}
}
if (opterr) {
usage();
exit(EXIT_FAILURE);
}
if (argc == 1) {
if (conf_path == NULL) {
conf_path = DEFAULT_CONF_PATH;
}
}
if (conf_path != NULL) {
jconf_t *conf = read_jconf(conf_path);
if (server_num == 0) {
server_num = conf->remote_num;
for (i = 0; i < server_num; i++) {
server_host[i] = conf->remote_addr[i].host;
}
}
if (server_port == NULL) {
server_port = conf->remote_port;
}
if (password == NULL) {
password = conf->password;
}
if (method == NULL) {
method = conf->method;
}
if (timeout == NULL) {
timeout = conf->timeout;
}
#ifdef TCP_FASTOPEN
if (fast_open == 0) {
fast_open = conf->fast_open;
}
#endif
#ifdef HAVE_SETRLIMIT
if (nofile == 0) {
nofile = conf->nofile;
}
/*
* no need to check the return value here since we will show
* the user an error message if setrlimit(2) fails
*/
if (nofile) {
if (verbose) {
LOGI("setting NOFILE to %d", nofile);
}
set_nofile(nofile);
}
#endif
if (conf->nameserver != NULL) {
nameservers[nameserver_num++] = conf->nameserver;
}
}
if (server_num == 0) {
server_host[server_num++] = NULL;
}
if (server_num == 0 || server_port == NULL || password == NULL) {
usage();
exit(EXIT_FAILURE);
}
if (method == NULL) {
method = "table";
}
if (timeout == NULL) {
timeout = "60";
}
if (pid_flags) {
USE_SYSLOG(argv[0]);
daemonize(pid_path);
}
if (fast_open == 1) {
#ifdef TCP_FASTOPEN
LOGI("using tcp fast open");
#else
LOGE("tcp fast open is not supported by this environment");
#endif
}
#ifdef __MINGW32__
winsock_init();
#else
// ignore SIGPIPE
signal(SIGPIPE, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
signal(SIGABRT, SIG_IGN);
#endif
struct ev_signal sigint_watcher;
struct ev_signal sigterm_watcher;
ev_signal_init(&sigint_watcher, signal_cb, SIGINT);
ev_signal_init(&sigterm_watcher, signal_cb, SIGTERM);
ev_signal_start(EV_DEFAULT, &sigint_watcher);
ev_signal_start(EV_DEFAULT, &sigterm_watcher);
// setup keys
LOGI("initialize ciphers... %s", method);
int m = enc_init(password, method);
// inilitialize ev loop
struct ev_loop *loop = EV_DEFAULT;
// setup udns
if (nameserver_num == 0) {
#ifdef __MINGW32__
nameservers[nameserver_num++] = "8.8.8.8";
resolv_init(loop, nameservers, nameserver_num);
#else
resolv_init(loop, NULL, 0);
#endif
} else {
resolv_init(loop, nameservers, nameserver_num);
}
for (int i = 0; i < nameserver_num; i++) {
LOGI("using nameserver: %s", nameservers[i]);
}
// inilitialize listen context
struct listen_ctx listen_ctx_list[server_num];
// bind to each interface
while (server_num > 0) {
int index = --server_num;
const char * host = server_host[index];
// Bind to port
int listenfd;
listenfd = create_and_bind(host, server_port);
if (listenfd < 0) {
FATAL("bind() error");
}
if (listen(listenfd, SSMAXCONN) == -1) {
FATAL("listen() error");
}
setnonblocking(listenfd);
LOGI("listening at %s:%s", host ? host : "*", server_port);
struct listen_ctx *listen_ctx = &listen_ctx_list[index];
// Setup proxy context
listen_ctx->timeout = atoi(timeout);
listen_ctx->fd = listenfd;
listen_ctx->method = m;
listen_ctx->iface = iface;
listen_ctx->loop = loop;
ev_io_init(&listen_ctx->io, accept_cb, listenfd, EV_READ);
ev_io_start(loop, &listen_ctx->io);
// Setup UDP
if (udprelay) {
init_udprelay(server_host[index], server_port, m, atoi(timeout),
iface);
}
}
if (udprelay) {
LOGI("udprelay enabled");
}
// setuid
if (user != NULL) {
run_as(user);
}
// Init connections
cork_dllist_init(&connections);
// start ev loop
ev_run(loop, 0);
if (verbose) {
LOGI("closed gracefully");
}
// Clean up
for (int i = 0; i <= server_num; i++) {
struct listen_ctx *listen_ctx = &listen_ctx_list[i];
ev_io_stop(loop, &listen_ctx->io);
close(listen_ctx->fd);
}
free_connections(loop);
if (udprelay) {
free_udprelay();
}
resolv_shutdown(loop);
#ifdef __MINGW32__
winsock_cleanup();
#endif
ev_signal_stop(EV_DEFAULT, &sigint_watcher);
ev_signal_stop(EV_DEFAULT, &sigterm_watcher);
return 0;
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c;
char *rv[2];
int option = 0;
static struct option longopts[] = {
{"hostname", required_argument, 0, 'H'},
{"sourceip", required_argument, 0, 'S'},
{"sourceif", required_argument, 0, 'I'},
{"critical", required_argument, 0, 'c'},
{"warning", required_argument, 0, 'w'},
{"bytes", required_argument, 0, 'b'},
{"number", required_argument, 0, 'n'},
{"target-timeout", required_argument, 0, 'T'},
{"interval", required_argument, 0, 'i'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{"use-ipv4", no_argument, 0, '4'},
{"use-ipv6", no_argument, 0, '6'},
{0, 0, 0, 0}
};
rv[PL] = NULL;
rv[RTA] = NULL;
if (argc < 2)
return ERROR;
if (!is_option (argv[1])) {
server_name = argv[1];
argv[1] = argv[0];
argv = &argv[1];
argc--;
}
while (1) {
c = getopt_long (argc, argv, "+hVvH:S:c:w:b:n:T:i:I:46", longopts, &option);
if (c == -1 || c == EOF || c == 1)
break;
switch (c) {
case '?': /* print short usage statement if args not parsable */
usage5 ();
case 'h': /* help */
print_help ();
exit (STATE_UNKNOWN);
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_UNKNOWN);
case 'v': /* verbose mode */
verbose = TRUE;
break;
case 'H': /* hostname */
if (is_host (optarg) == FALSE) {
usage2 (_("Invalid hostname/address"), optarg);
}
server_name = strscpy (server_name, optarg);
break;
case 'S': /* sourceip */
if (is_host (optarg) == FALSE) {
usage2 (_("Invalid hostname/address"), optarg);
}
sourceip = strscpy (sourceip, optarg);
break;
case 'I': /* sourceip */
sourceif = strscpy (sourceif, optarg);
case '4': /* IPv4 only */
address_family = AF_INET;
break;
case '6': /* IPv6 only */
#ifdef USE_IPV6
address_family = AF_INET6;
#else
usage (_("IPv6 support not available\n"));
#endif
break;
case 'c':
get_threshold (optarg, rv);
if (rv[RTA]) {
crta = strtod (rv[RTA], NULL);
crta_p = TRUE;
rv[RTA] = NULL;
}
if (rv[PL]) {
cpl = atoi (rv[PL]);
cpl_p = TRUE;
rv[PL] = NULL;
}
break;
case 'w':
get_threshold (optarg, rv);
if (rv[RTA]) {
wrta = strtod (rv[RTA], NULL);
wrta_p = TRUE;
rv[RTA] = NULL;
}
if (rv[PL]) {
wpl = atoi (rv[PL]);
wpl_p = TRUE;
rv[PL] = NULL;
}
break;
case 'b': /* bytes per packet */
if (is_intpos (optarg))
packet_size = atoi (optarg);
else
usage (_("Packet size must be a positive integer"));
break;
case 'n': /* number of packets */
if (is_intpos (optarg))
packet_count = atoi (optarg);
else
usage (_("Packet count must be a positive integer"));
break;
case 'T': /* timeout in msec */
if (is_intpos (optarg))
target_timeout = atoi (optarg);
else
usage (_("Target timeout must be a positive integer"));
break;
case 'i': /* interval in msec */
if (is_intpos (optarg))
packet_interval = atoi (optarg);
else
usage (_("Interval must be a positive integer"));
break;
}
}
if (server_name == NULL)
usage4 (_("Hostname was not supplied"));
return OK;
}
int
main (int argc, char **argv)
{
int c, err;
bool verbose = false;
unsigned int tcp_flags = TCP_UNSET;
char *critical = NULL, *warning = NULL;
nagstatus status = STATE_OK;
thresholds *my_threshold = NULL;
struct proc_tcptable *tcptable = NULL;
unsigned long tcp_established;
unsigned long tcp_syn_sent;
unsigned long tcp_syn_recv;
unsigned long tcp_fin_wait1;
unsigned long tcp_fin_wait2;
unsigned long tcp_time_wait;
unsigned long tcp_close;
unsigned long tcp_close_wait;
unsigned long tcp_last_ack;
unsigned long tcp_listen;
unsigned long tcp_closing;
set_program_name (argv[0]);
while ((c = getopt_long (argc, argv,
"t6c:w:v" GETOPT_HELP_VERSION_STRING,
longopts, NULL)) != -1)
{
switch (c)
{
default:
usage (stderr);
case 't':
tcp_flags |= TCP_v4;
break;
case '6':
tcp_flags |= TCP_v6;
break;
case 'c':
critical = optarg;
break;
case 'w':
warning = optarg;
break;
case 'v':
verbose = true;
break;
case_GETOPT_HELP_CHAR
case_GETOPT_VERSION_CHAR
}
}
if (tcp_flags == TCP_UNSET)
tcp_flags = TCP_v4;
if (verbose)
tcp_flags |= TCP_VERBOSE;
status = set_thresholds (&my_threshold, warning, critical);
if (status == NP_RANGE_UNPARSEABLE)
usage (stderr);
err = proc_tcptable_new (&tcptable);
if (err < 0)
plugin_error (STATE_UNKNOWN, err, "memory exhausted");
proc_tcptable_read (tcptable, tcp_flags);
tcp_established = proc_tcp_get_tcp_established (tcptable);
tcp_syn_sent = proc_tcp_get_tcp_syn_sent (tcptable);
tcp_syn_recv = proc_tcp_get_tcp_syn_recv (tcptable);
tcp_fin_wait1 = proc_tcp_get_tcp_fin_wait1 (tcptable);
tcp_fin_wait2 = proc_tcp_get_tcp_fin_wait2 (tcptable);
tcp_time_wait = proc_tcp_get_tcp_time_wait (tcptable);
tcp_close = proc_tcp_get_tcp_close (tcptable);
tcp_close_wait = proc_tcp_get_tcp_close_wait (tcptable);
tcp_last_ack = proc_tcp_get_tcp_last_ack (tcptable);
tcp_listen = proc_tcp_get_tcp_listen (tcptable);
tcp_closing = proc_tcp_get_tcp_closing (tcptable);
proc_tcptable_unref (tcptable);
status = get_status (tcp_established, my_threshold);
free (my_threshold);
printf ("%s %s - %lu tcp established | "
"tcp_established=%lu tcp_syn_sent=%lu tcp_syn_recv=%lu "
"tcp_fin_wait1=%lu tcp_fin_wait2=%lu tcp_time_wait=%lu "
"tcp_close=%lu tcp_close_wait=%lu tcp_last_ack=%lu "
"tcp_listen=%lu tcp_closing=%lu\n",
program_name_short, state_text (status), tcp_established,
tcp_established, tcp_syn_sent, tcp_syn_recv,
tcp_fin_wait1, tcp_fin_wait2, tcp_time_wait,
tcp_close, tcp_close_wait, tcp_last_ack,
tcp_listen, tcp_closing);
return status;
}
int
main(int argc, char **argv)
{
int argerr = 0;
int flag;
int attempts = 0;
#ifdef HAVE_GETOPT_H
int option_index = 0;
static struct option long_options[] = {
/* Top-level Options */
{"verbose", 0, 0, 'V'},
{"help", 0, 0, '?'},
{"log-diffs", 0, 0, 'd'},
{"log-updates", 0, 0, 'u'},
{"max-conn-fail", 1, 0, 'm'},
{0, 0, 0, 0}
};
#endif
crm_log_init_quiet(NULL, LOG_INFO, FALSE, FALSE, argc, argv);
crm_signal(SIGTERM, cibmon_shutdown);
while (1) {
#ifdef HAVE_GETOPT_H
flag = getopt_long(argc, argv, OPTARGS, long_options, &option_index);
#else
flag = getopt(argc, argv, OPTARGS);
#endif
if (flag == -1)
break;
switch (flag) {
case 'V':
crm_bump_log_level();
break;
case '?':
usage(crm_system_name, LSB_EXIT_OK);
break;
case 'd':
log_diffs = TRUE;
break;
case 'u':
log_updates = TRUE;
break;
case 'm':
max_failures = crm_parse_int(optarg, "30");
break;
default:
printf("Argument code 0%o (%c)" " is not (?yet?) supported\n", flag, flag);
++argerr;
break;
}
}
if (optind < argc) {
printf("non-option ARGV-elements: ");
while (optind < argc)
printf("%s ", argv[optind++]);
printf("\n");
}
if (optind > argc) {
++argerr;
}
if (argerr) {
usage(crm_system_name, LSB_EXIT_GENERIC);
}
cib = cib_new();
do {
sleep(1);
exit_code = cib->cmds->signon(cib, crm_system_name, cib_query);
} while (exit_code == cib_connection && attempts++ < max_failures);
if (exit_code != cib_ok) {
crm_err("Signon to CIB failed: %s", cib_error2string(exit_code));
}
if (exit_code == cib_ok) {
crm_debug("Setting dnotify");
exit_code = cib->cmds->set_connection_dnotify(cib, cib_connection_destroy);
}
crm_debug("Setting diff callback");
exit_code = cib->cmds->add_notify_callback(cib, T_CIB_DIFF_NOTIFY, cibmon_diff);
if (exit_code != cib_ok) {
crm_err("Failed to set %s callback: %s", T_CIB_DIFF_NOTIFY, cib_error2string(exit_code));
}
if (exit_code != cib_ok) {
crm_err("Setup failed, could not monitor CIB actions");
return -exit_code;
}
mainloop = g_main_new(FALSE);
crm_info("Starting mainloop");
g_main_run(mainloop);
crm_debug_3("%s exiting normally", crm_system_name);
fflush(stderr);
return -exit_code;
}
int main(int argc, char **argv)
{
int ch, longindex, nr;
int is_daemon = 1, is_debug = 1;
pid_t pid;
struct pollfd *poll_array;
while ((ch = getopt_long(argc, argv, "fd:vh", long_options, &longindex)) >= 0) {
switch (ch) {
case 'f':
is_daemon = 0;
break;
case 'd':
is_debug = atoi(optarg);
break;
case 'v':
exit(0);
break;
case 'h':
usage(0);
break;
default:
usage(1);
break;
}
}
init(is_daemon, is_debug);
if (is_daemon) {
pid = fork();
if (pid < 0)
exit(-1);
else if (pid)
exit(0);
chdir("/");
close(0);
open("/dev/null", O_RDWR);
dup2(0, 1);
dup2(0, 2);
setsid();
}
nl_fd = nl_open();
if (nl_fd < 0)
exit(nl_fd);
ipc_fd = ipc_open();
if (ipc_fd < 0)
exit(ipc_fd);
dl_init();
nr = MAX_DL_HANDLES;
poll_array = poll_init(nr);
dl_config_load();
event_loop(nr, poll_array);
return 0;
}
int main( int argc, char **argv )
{
int i, listenSocket[ MAX_PLAYERS ], v, longOpt;
int fixedSeats, quiet;
int seatFD[ MAX_PLAYERS ];
FILE *file, *logFile, *transactionFile;
ReadBuf *readBuf[ MAX_PLAYERS ];
Game *game;
rng_state_t rng;
ErrorInfo errorInfo;
struct sockaddr_in addr;
socklen_t addrLen;
char *seatName[ MAX_PLAYERS ];
int useLogFile, useTransactionFile;
uint64_t maxResponseMicros, maxUsedHandMicros, maxUsedPerHandMicros;
uint32_t numHands, seed, maxInvalidActions;
uint16_t listenPort[ MAX_PLAYERS ];
char name[ MAX_LINE_LEN ];
static struct option longOptions[] = {
{ "t_response", 1, 0, 0 },
{ "t_hand", 1, 0, 0 },
{ "t_per_hand", 1, 0, 0 },
{ 0, 0, 0, 0 }
};
/* set defaults */
/* game error conditions */
maxInvalidActions = DEFAULT_MAX_INVALID_ACTIONS;
maxResponseMicros = DEFAULT_MAX_RESPONSE_MICROS;
maxUsedHandMicros = DEFAULT_MAX_USED_HAND_MICROS;
maxUsedPerHandMicros = DEFAULT_MAX_USED_PER_HAND_MICROS;
/* use random ports */
for( i = 0; i < MAX_PLAYERS; ++i ) {
listenPort[ i ] = 0;
}
/* use log file, don't use transaction file */
useLogFile = 1;
useTransactionFile = 0;
/* print all messages */
quiet = 0;
/* players rotate around the table */
fixedSeats = 0;
/* parse options */
while( 1 ) {
i = getopt_long( argc, argv, "flLp:qtT", longOptions, &longOpt );
if( i < 0 ) {
break;
}
switch( i ) {
case 0:
/* long option longOpt */
switch( longOpt ) {
case 0:
/* t_response */
if( sscanf( optarg, "%"SCNu64, &maxResponseMicros ) < 1 ) {
fprintf( stderr, "ERROR: could not get response timeout from %s\n",
optarg );
exit( EXIT_FAILURE );
}
/* convert from milliseconds to microseconds */
maxResponseMicros *= 1000;
break;
case 1:
/* t_hand */
if( sscanf( optarg, "%"SCNu64, &maxUsedHandMicros ) < 1 ) {
fprintf( stderr,
"ERROR: could not get player hand timeout from %s\n",
optarg );
exit( EXIT_FAILURE );
}
/* convert from milliseconds to microseconds */
maxUsedHandMicros *= 1000;
break;
case 2:
/* t_per_hand */
if( sscanf( optarg, "%"SCNu64, &maxUsedPerHandMicros ) < 1 ) {
fprintf( stderr, "ERROR: could not get average player hand timeout from %s\n", optarg );
exit( EXIT_FAILURE );
}
/* convert from milliseconds to microseconds */
maxUsedPerHandMicros *= 1000;
break;
}
break;
case 'f':
/* fix the player seats */;
fixedSeats = 1;
break;
case 'l':
/* no transactionFile */;
useLogFile = 0;
break;
case 'L':
/* use transactionFile */;
useLogFile = 1;
break;
case 'p':
/* port specification */
if( scanPortString( optarg, listenPort ) < 0 ) {
fprintf( stderr, "ERROR: bad port string %s\n", optarg );
exit( EXIT_FAILURE );
}
break;
case 'q':
quiet = 1;
break;
case 't':
/* no transactionFile */
useTransactionFile = 0;
break;
case 'T':
/* use transactionFile */
useTransactionFile = 1;
break;
default:
fprintf( stderr, "ERROR: unknown option %c\n", i );
exit( EXIT_FAILURE );
}
}
if( optind + 4 > argc ) {
printUsage( stdout, 0 );
exit( EXIT_FAILURE );
}
/* get the game definition */
file = fopen( argv[ optind + 1 ], "r" );
if( file == NULL ) {
fprintf( stderr, "ERROR: could not open game definition %s\n",
argv[ optind + 1 ] );
exit( EXIT_FAILURE );
}
game = readGame( file );
if( game == NULL ) {
fprintf( stderr, "ERROR: could not read game %s\n", argv[ optind + 1 ] );
exit( EXIT_FAILURE );
}
fclose( file );
/* save the seat names */
if( optind + 4 + game->numPlayers > argc ) {
printUsage( stdout, 0 );
exit( EXIT_FAILURE );
}
for( i = 0; i < game->numPlayers; ++i ) {
seatName[ i ] = argv[ optind + 4 + i ];
}
/* get number of hands */
if( sscanf( argv[ optind + 2 ], "%"SCNu32, &numHands ) < 1
|| numHands == 0 ) {
fprintf( stderr, "ERROR: invalid number of hands %s\n",
argv[ optind + 2 ] );
exit( EXIT_FAILURE );
}
/* get random number seed */
if( sscanf( argv[ optind + 3 ], "%"SCNu32, &seed ) < 1 ) {
fprintf( stderr, "ERROR: invalid random number seed %s\n",
argv[ optind + 3 ] );
exit( EXIT_FAILURE );
}
init_genrand( &rng, seed );
srandom( seed ); /* used for random port selection */
if( useLogFile ) {
/* create/open the log */
if( snprintf( name, MAX_LINE_LEN, "%s.log", argv[ optind ] ) < 0 ) {
fprintf( stderr, "ERROR: match file name too long %s\n", argv[ optind ] );
exit( EXIT_FAILURE );
}
logFile = fopen( name, "a+" );
if( logFile == NULL ) {
fprintf( stderr, "ERROR: could not open log file %s\n", name );
exit( EXIT_FAILURE );
}
} else {
/* no log file */
logFile = NULL;
}
if( useTransactionFile ) {
/* create/open the transaction log */
if( snprintf( name, MAX_LINE_LEN, "%s.tlog", argv[ optind ] ) < 0 ) {
fprintf( stderr, "ERROR: match file name too long %s\n", argv[ optind ] );
exit( EXIT_FAILURE );
}
transactionFile = fopen( name, "a+" );
if( transactionFile == NULL ) {
fprintf( stderr, "ERROR: could not open transaction file %s\n", name );
exit( EXIT_FAILURE );
}
} else {
/* no transaction file */
transactionFile = NULL;
}
/* set up the error info */
initErrorInfo( maxInvalidActions, maxResponseMicros, maxUsedHandMicros,
maxUsedPerHandMicros * numHands, &errorInfo );
/* open sockets for players to connect to */
for( i = 0; i < game->numPlayers; ++i ) {
listenSocket[ i ] = getListenSocket( &listenPort[ i ] );
if( listenSocket[ i ] < 0 ) {
fprintf( stderr, "ERROR: could not create listen socket for player %d\n",
i + 1 );
exit( EXIT_FAILURE );
}
}
/* print out the final port assignments */
for( i = 0; i < game->numPlayers; ++i ) {
printf( i ? " %"PRIu16 : "%"PRIu16, listenPort[ i ] );
}
printf( "\n" );
fflush( stdout );
/* print out usage information */
printInitialMessage( argv[ optind ], argv[ optind + 1 ],
numHands, seed, &errorInfo, logFile );
/* wait for each player to connect */
for( i = 0; i < game->numPlayers; ++i ) {
addrLen = sizeof( addr );
seatFD[ i ] = accept( listenSocket[ i ],
(struct sockaddr *)&addr, &addrLen );
if( seatFD[ i ] < 0 ) {
fprintf( stderr, "ERROR: seat %d could not connect\n", i + 1 );
exit( EXIT_FAILURE );
}
close( listenSocket[ i ] );
v = 1;
setsockopt( seatFD[ i ], IPPROTO_TCP, TCP_NODELAY,
(char *)&v, sizeof(int) );
readBuf[ i ] = createReadBuf();
}
/* play the match */
if( gameLoop( game, seatName, numHands, quiet, fixedSeats, &rng, &errorInfo,
seatFD, readBuf, logFile, transactionFile ) < 0 ) {
/* should have already printed an error message */
exit( EXIT_FAILURE );
}
fflush( stderr );
fflush( stdout );
if( transactionFile != NULL ) {
fclose( transactionFile );
}
if( logFile != NULL ) {
fclose( logFile );
}
free( game );
return EXIT_SUCCESS;
}
int main (int argc, char* argv[])
{
bool argVerbose = false;
bool argNoHeaders = false;
bool argPrintHelp = false;
const char* argBinaryDumpFile = 0;
const char* argParseBinary = 0;
while (true)
{
int option_index = 0;
static struct option long_options[] = {
{"dumpbinary", required_argument, 0, 'd' },
{"parsebinary", required_argument, 0, 'p' },
{"verbose", no_argument, 0, 'v' },
{"noheader", no_argument, 0, 'n' },
{"help", no_argument, 0, 'h' },
{0, 0, 0, 0 }
};
int c = getopt_long(argc, argv, "l:d:p:vnh", long_options, &option_index);
if (c == -1)
break;
switch (c)
{
case 'd':
argBinaryDumpFile = optarg;
break;
case 'p':
argParseBinary = optarg;
break;
case 'v':
argVerbose = true;
break;
case 'n':
argNoHeaders = true;
break;
case 'h':
argPrintHelp = true;
break;
case '?':
std::cerr << "ERROR: error occurred while parsing command line options.\n\n";
printHelp();
return 1;
break;
default:
std::cerr << "ERROR: getopt returned unhandled character code " << int(c) << "\n\n";
printHelp();
return 1;
}
}
if (optind < argc)
{
std::cerr << "ERROR: non-option arguments provided: ";
while (optind < argc)
{
std::cerr << "\"" << argv[optind++] << "\" ";
}
std::cerr << "\n\n";
printHelp();
return 1;
}
if (argPrintHelp)
{
printHelp();
return 0;
}
if (argParseBinary)
{
processFile(argParseBinary, !argNoHeaders, argVerbose);
return 0;
}
else
{
return processUSB(!argNoHeaders, argVerbose, argBinaryDumpFile);
}
return 1;
}
/* Process the command line options and arguments. */
static lists_t_strs *process_command_line (int argc, char *argv[],
struct parameters *params,
lists_t_strs *deferred)
{
int ret, opt_index = 0;
const char *jump_type;
lists_t_strs *result;
struct option long_options[] = {
{ "version", 0, NULL, 'V' },
{ "help", 0, NULL, 'h' },
#ifndef NDEBUG
{ "debug", 0, NULL, 'D' },
#endif
{ "server", 0, NULL, 'S' },
{ "foreground", 0, NULL, 'F' },
{ "sound-driver", 1, NULL, 'R' },
{ "music-dir", 0, NULL, 'm' },
{ "append", 0, NULL, 'a' },
{ "enqueue", 0, NULL, 'q' },
{ "clear", 0, NULL, 'c' },
{ "play", 0, NULL, 'p' },
{ "playit", 0, NULL, 'l' },
{ "stop", 0, NULL, 's' },
{ "next", 0, NULL, 'f' },
{ "previous", 0, NULL, 'r' },
{ "exit", 0, NULL, 'x' },
{ "theme", 1, NULL, 'T' },
{ "config", 1, NULL, 'C' },
{ "set-option", 1, NULL, 'O' },
{ "moc-dir", 1, NULL, 'M' },
{ "pause", 0, NULL, 'P' },
{ "unpause", 0, NULL, 'U' },
{ "toggle-pause", 0, NULL, 'G' },
{ "sync", 0, NULL, 'y' },
{ "nosync", 0, NULL, 'n' },
{ "ascii", 0, NULL, 'A' },
{ "info", 0, NULL, 'i' },
{ "recursively", 0, NULL, 'e' },
{ "seek", 1, NULL, 'k' },
{ "jump", 1, NULL, 'j' },
{ "format", 1, NULL, 'Q' },
{ "volume", 1, NULL, 'v' },
{ "toggle", 1, NULL, 't' },
{ "on", 1, NULL, 'o' },
{ "off", 1, NULL, 'u' },
{ 0, 0, 0, 0 }
};
assert (argc >= 0);
assert (argv != NULL);
assert (argv[argc] == NULL);
assert (params != NULL);
assert (deferred != NULL);
while ((ret = getopt_long(argc, argv,
"VhDSFR:macpsxT:C:O:M:PUynArfiGelk:j:v:t:o:u:Q:q",
long_options, &opt_index)) != -1) {
switch (ret) {
case 'V':
show_version ();
exit (0);
case 'h':
show_usage (argv[0]);
exit (0);
#ifndef NDEBUG
case 'D':
params->debug = 1;
break;
#endif
case 'S':
params->only_server = 1;
break;
case 'F':
params->foreground = 1;
params->only_server = 1;
break;
case 'R':
if (!options_check_list ("SoundDriver", optarg))
fatal ("No such sound driver: %s", optarg);
options_set_list ("SoundDriver", optarg, false);
options_ignore_config ("SoundDriver");
break;
case 'm':
options_set_int ("StartInMusicDir", 1);
options_ignore_config ("StartInMusicDir");
break;
case 'a':
case 'e':
params->append = 1;
params->dont_run_iface = 1;
break;
case 'q':
params->enqueue = 1;
params->dont_run_iface = 1;
break;
case 'c':
params->clear = 1;
params->dont_run_iface = 1;
break;
case 'i':
params->get_file_info = 1;
params->dont_run_iface = 1;
break;
case 'p':
params->play = 1;
params->dont_run_iface = 1;
break;
case 'l':
params->playit = 1;
params->dont_run_iface = 1;
break;
case 's':
params->stop = 1;
params->dont_run_iface = 1;
break;
case 'f':
params->next = 1;
params->dont_run_iface = 1;
break;
case 'r':
params->previous = 1;
params->dont_run_iface = 1;
break;
case 'x':
params->exit = 1;
params->dont_run_iface = 1;
break;
case 'P':
params->pause = 1;
params->dont_run_iface = 1;
break;
case 'U':
params->unpause = 1;
params->dont_run_iface = 1;
break;
case 'T':
options_set_str ("ForceTheme", optarg);
break;
case 'C':
params->config_file = xstrdup (optarg);
break;
case 'O':
override_config_option (optarg, deferred);
break;
case 'M':
options_set_str ("MOCDir", optarg);
options_ignore_config ("MOCDir");
break;
case 'y':
options_set_int ("SyncPlaylist", 1);
options_ignore_config ("SyncPlaylist");
break;
case 'n':
options_set_int ("SyncPlaylist", 0);
options_ignore_config ("SyncPlaylist");
break;
case 'A':
options_set_int ("ASCIILines", 1);
options_ignore_config ("ASCIILines");
break;
case 'G':
params->toggle_pause = 1;
params->dont_run_iface = 1;
break;
case 'k':
params->seek_by = get_num_param (optarg, NULL);
params->dont_run_iface = 1;
break;
case 'j':
params->jump_to = get_num_param (optarg, &jump_type);
if (*jump_type)
if (!jump_type[1])
if (*jump_type == '%' || tolower (*jump_type) == 's') {
params->jump_type = tolower (*jump_type);
params->dont_run_iface = 1;
break;
}
//TODO: Add message explaining the error
show_usage (argv[0]);
exit (1);
case 'v' :
params->adj_volume = optarg;
params->dont_run_iface = 1;
break;
case 't' :
params->toggle = optarg;
params->dont_run_iface = 1;
break;
case 'o' :
params->on = optarg;
params->dont_run_iface = 1;
break;
case 'u' :
params->off = optarg;
params->dont_run_iface = 1;
break;
case 'Q':
params->formatted_into_param = optarg;
params->get_formatted_info = 1;
params->dont_run_iface = 1;
break;
default:
show_usage (argv[0]);
exit (1);
}
}
result = lists_strs_new (argc - optind);
lists_strs_load (result, argv + optind);
return result;
}
/* Parse command line options */
void patch_options_parse(int argc, char **argv) {
int opt;
const struct option opts[] = {
{"address", required_argument, NULL, 'a'},
{"bytes", required_argument, NULL, 'b'},
{"filename", required_argument, NULL, 'f'},
{"help", no_argument, NULL, 'h'},
{"offset", required_argument, NULL, 'o'},
{"output", required_argument, NULL, 'O'},
{"raw", no_argument, NULL, 'r'},
{NULL, 0, NULL, 0 }
};
while((opt = getopt_long(argc, argv, "a:b:f:ho:O:r", opts, NULL)) != -1) {
switch(opt) {
case 'a':
patch_options_address = strtoull(optarg, NULL, 0);
break;
case 'b':
patch_options_bytes = r_utils_bytes_unhexlify(optarg);
break;
case 'f':
patch_options_filename = optarg;
break;
case 'h':
patch_help();
exit(EXIT_FAILURE);
break;
case 'o':
patch_options_offset = strtoull(optarg, NULL, 0);
break;
case 'O':
patch_options_output = optarg;
break;
case 'r':
patch_options_arch = R_BINFMT_ARCH_X86;
break;
default:
patch_help();
exit(EXIT_FAILURE);
}
}
if(optind < argc) {
patch_options_filename = argv[optind];
}
if(patch_options_address == R_BINFMT_BAD_ADDR && patch_options_offset == R_BINFMT_BAD_ADDR)
R_UTILS_ERR("Where I patch ? Random location ?! Use --offset or --address options !");
if(patch_options_address != R_BINFMT_BAD_ADDR && patch_options_offset != R_BINFMT_BAD_ADDR)
R_UTILS_ERR("I need an offset OR an address, not twice !");
if(patch_options_bytes == NULL)
R_UTILS_ERR("I patch what ? use --bytes option !");
}
// Takes the command line options and turns them into something we can understand
static parsed_opts_t* parse_args(int argc, char** argv)
{
if (argc == 1) { usage(pysam_stdout); return NULL; }
const char* optstring = "vf:u:";
char* delim;
static const struct option lopts[] = {
SAM_OPT_GLOBAL_OPTIONS('-', 0, 0, 0, 0),
{ NULL, 0, NULL, 0 }
};
parsed_opts_t* retval = calloc(sizeof(parsed_opts_t), 1);
if (! retval ) { perror("cannot allocate option parsing memory"); return NULL; }
sam_global_args_init(&retval->ga);
int opt;
while ((opt = getopt_long(argc, argv, optstring, lopts, NULL)) != -1) {
switch (opt) {
case 'f':
retval->output_format_string = strdup(optarg);
if (! retval->output_format_string ) { perror("cannot allocate output format string memory"); return NULL; }
break;
case 'v':
retval->verbose = true;
break;
case 'u':
retval->unaccounted_name = strdup(optarg);
if (! retval->unaccounted_name ) { perror("cannot allocate string memory"); return NULL; }
if ((delim = strchr(retval->unaccounted_name, ':')) != NULL) {
*delim = '\0';
retval->unaccounted_header_name = strdup(delim+1);
if (! retval->unaccounted_header_name ) { perror("cannot allocate string memory"); return NULL; }
}
break;
default:
if (parse_sam_global_opt(opt, optarg, lopts, &retval->ga) == 0) break;
/* else fall-through */
case '?':
usage(pysam_stdout);
free(retval);
return NULL;
}
}
if (retval->output_format_string == NULL) retval->output_format_string = strdup("%*_%#.%.");
argc -= optind;
argv += optind;
if (argc != 1) {
fprintf(pysam_stderr, "Invalid number of arguments: %d\n", argc);
usage(pysam_stderr);
free(retval);
return NULL;
}
retval->merged_input_name = strdup(argv[0]);
if (! retval->merged_input_name ) { perror("cannot allocate string memory"); return NULL; }
return retval;
}
static int ParseCommandLine(int argc, char *argv[])
{
int c;
int option_index = 0;
static struct option long_options[] =
{
{"name", 1, NULL, 'n'},
{"path", 1, NULL, 'p'},
{"help", 0, NULL, 0},
{NULL, 0, NULL, 0}
};
memset(&config, 0, sizeof(config));
while((c = getopt_long(argc, argv, "n:p:", long_options,
&option_index)) != -1)
{
switch(c)
{
case 0:
if(strcasecmp("help", long_options[option_index].name) == 0)
{
usage(argv[0]);
exit(0);
}
else
{
fprintf(stderr, "Unknown command line option: %s",
long_options[option_index].name);
return SF_EINVAL;
}
break;
case 'n':
config.name = malloc(strlen(optarg)+2);
if(!(config.name))
{
fprintf(stderr, "Out of memory processing command line");
return SF_ENOMEM;
}
strcpy(config.name, optarg);
strcat(config.name,".");
break;
case 'p':
if(!(config.path = strdup(optarg)))
{
fprintf(stderr, "Out of memory processing command line");
return SF_ENOMEM;
}
break;
default:
return SF_EINVAL;
}
}
if (!config.name || !config.path)
{
usage(argv[0]);
exit(-1);
}
config.priority = (LOG_INFO | LOG_INFO);
return 0;
}
int
main (int argc, char **argv)
{
register int c;
int errflg;
int function;
u_short portnum;
static const struct option long_options[] = {
{ "help", no_argument, NULL, 'H' },
{ "version", no_argument, NULL, 'V' },
{ NULL, 0, NULL, 0 }
};
setlocale (LC_ALL, "");
textdomain (_libc_intl_domainname);
function = NONE;
portnum = 0;
errflg = 0;
while ((c = getopt_long (argc, argv, "ptubdn:", long_options, NULL)) != -1)
{
switch (c)
{
case 'p':
if (function != NONE)
errflg = 1;
else
function = PMAPDUMP;
break;
case 't':
if (function != NONE)
errflg = 1;
else
function = TCPPING;
break;
case 'u':
if (function != NONE)
errflg = 1;
else
function = UDPPING;
break;
case 'b':
if (function != NONE)
errflg = 1;
else
function = BRDCST;
break;
case 'n':
portnum = (u_short) atoi (optarg); /* hope we don't get bogus # */
break;
case 'd':
if (function != NONE)
errflg = 1;
else
function = DELETES;
break;
case 'H':
usage (stdout);
return 0;
case 'V':
print_version ();
return 0;
case '?':
errflg = 1;
}
}
if (errflg || function == NONE)
{
usage (stderr);
return 1;
}
switch (function)
{
case PMAPDUMP:
if (portnum != 0)
{
usage (stderr);
return 1;
}
pmapdump (argc - optind, argv + optind);
break;
case UDPPING:
udpping (portnum, argc - optind, argv + optind);
break;
case TCPPING:
tcpping (portnum, argc - optind, argv + optind);
break;
case BRDCST:
if (portnum != 0)
{
usage (stderr);
return 1;
}
brdcst (argc - optind, argv + optind);
break;
case DELETES:
deletereg (argc - optind, argv + optind);
break;
}
return 0;
}
