/* parse_cli_params */
int parse_module_args(int argc, char *argv[]) {
int i = 0;
/* Set default values */
arg_options = (arg_options_t) {
.prefix = NULL,
.before = NULL,
.after = NULL,
.mainsrc = NULL,
};
if (((0 >= my_module_globals.threshold) ||
(1 < my_module_globals.threshold))) {
OUTPUT(("%s", _ERROR("invalid threshold")));
return PERFEXPERT_ERROR;
}
/* If some environment variable is defined, use it! */
if (PERFEXPERT_SUCCESS != parse_env_vars()) {
OUTPUT(("%s", _ERROR("parsing environment variables")));
return PERFEXPERT_ERROR;
}
/* Parse arguments */
argp_parse(&argp, argc, argv, 0, 0, NULL);
/* Expand AFTERs, BEFOREs, and PREFIXs arguments */
// TODO: right now we only use the before, after and
// prefix from globals. We should also consider values coming
// throught args_options.* (that have been set in the previous
// instruction
if (NULL != arg_options.after) {
perfexpert_string_split(perfexpert_string_remove_spaces(
arg_options.after), my_module_globals.after, ' ');
}
if (NULL != arg_options.before) {
perfexpert_string_split(perfexpert_string_remove_spaces(
arg_options.before), my_module_globals.before, ' ');
}
if (NULL != arg_options.prefix) {
perfexpert_string_split(perfexpert_string_remove_spaces(
arg_options.prefix), my_module_globals.prefix, ' ');
}
if (NULL != arg_options.mainsrc) {
my_module_globals.mainsrc = arg_options.mainsrc;
}
OUTPUT_VERBOSE((7, "%s", _BLUE("Summary of options")));
if (7 <= globals.verbose) {
printf("%s Threshold: %f", PROGRAM_PREFIX, my_module_globals.threshold);
printf("\n%s Prefix: ", PROGRAM_PREFIX);
if (NULL == my_module_globals.prefix[0]) {
printf(" (null)");
} else {
i = 0;
while (NULL != my_module_globals.prefix[i]) {
printf(" [%s]", (char *)my_module_globals.prefix[i]);
i++;
}
}
printf("\n%s Before each run: ", PROGRAM_PREFIX);
if (NULL == my_module_globals.before[0]) {
printf(" (null)");
} else {
i = 0;
while (NULL != my_module_globals.before[i]) {
printf(" [%s]", (char *)my_module_globals.before[i]);
i++;
}
}
printf("\n%s After each run: ", PROGRAM_PREFIX);
if (NULL == my_module_globals.after[0]) {
printf(" (null)");
} else {
i = 0;
while (NULL != my_module_globals.after[i]) {
printf(" [%s]", (char *)my_module_globals.after[i]);
i++;
}
}
printf("\n%s Main src file: ", PROGRAM_PREFIX);
if (NULL == my_module_globals.mainsrc) {
printf(" (null)");
} else {
printf(" [%s]", (char *)my_module_globals.mainsrc);
}
printf("\n");
fflush(stdout);
}
/* Not using OUTPUT_VERBOSE because I want only one line */
if (8 <= globals.verbose) {
i = 0;
printf("%s %s", PROGRAM_PREFIX, _YELLOW("options:"));
for (i = 0; i < argc; i++) {
printf(" [%s]", argv[i]);
}
printf("\n");
fflush(stdout);
}
return PERFEXPERT_SUCCESS;
}
int parse_args(int argc, char** argv, struct arguments* parguments) {
return argp_parse(&argp, argc, argv, 0, 0, parguments);
}
int main(int argc, char *argv[])
{
int dev_from_class = 0, write_cnt;
int fd;
static struct sysfs_names *names;
struct rc_device rc_dev;
argp_parse(&argp, argc, argv, 0, 0, 0);
/* Just list all devices */
if (!clear && !readtable && !keys.next && !ch_proto && !cfg.next && !test && !delay && !period) {
if (devicename) {
fd = open(devicename, O_RDONLY);
if (fd < 0) {
perror("Can't open device");
return -1;
}
device_info(fd, "");
close(fd);
return 0;
}
if (show_sysfs_attribs(&rc_dev))
return -1;
return 0;
}
if (cfg.next && (clear || keys.next || ch_proto || devicename)) {
fprintf (stderr, "Auto-mode can be used only with --read, --debug and --sysdev options\n");
return -1;
}
if (!devicename) {
names = find_device(devclass);
if (!names)
return -1;
rc_dev.sysfs_name = names->name;
if (get_attribs(&rc_dev, names->name)) {
free_names(names);
return -1;
}
names->name = NULL;
free_names(names);
devicename = rc_dev.input_name;
dev_from_class++;
}
if (cfg.next) {
struct cfgfile *cur;
char *fname, *name;
int rc;
for (cur = &cfg; cur->next; cur = cur->next) {
if ((!rc_dev.drv_name || strcasecmp(cur->driver, rc_dev.drv_name)) && strcasecmp(cur->driver, "*"))
continue;
if ((!rc_dev.keytable_name || strcasecmp(cur->table, rc_dev.keytable_name)) && strcasecmp(cur->table, "*"))
continue;
break;
}
if (!cur->next) {
if (debug)
fprintf(stderr, "Table for %s, %s not found. Keep as-is\n",
rc_dev.drv_name, rc_dev.keytable_name);
return 0;
}
if (debug)
fprintf(stderr, "Table for %s, %s is on %s file.\n",
rc_dev.drv_name, rc_dev.keytable_name,
cur->fname);
if (cur->fname[0] == '/' || ((cur->fname[0] == '.') && strchr(cur->fname, '/'))) {
fname = cur->fname;
rc = parse_keyfile(fname, &name);
if (rc < 0) {
fprintf(stderr, "Can't load %s table\n", fname);
return -1;
}
} else {
fname = malloc(strlen(cur->fname) + strlen(IR_KEYTABLE_USER_DIR) + 2);
strcpy(fname, IR_KEYTABLE_USER_DIR);
strcat(fname, "/");
strcat(fname, cur->fname);
rc = parse_keyfile(fname, &name);
if (rc != 0) {
fname = malloc(strlen(cur->fname) + strlen(IR_KEYTABLE_SYSTEM_DIR) + 2);
strcpy(fname, IR_KEYTABLE_SYSTEM_DIR);
strcat(fname, "/");
strcat(fname, cur->fname);
rc = parse_keyfile(fname, &name);
}
if (rc != 0) {
fprintf(stderr, "Can't load %s table from %s or %s\n", cur->fname, IR_KEYTABLE_USER_DIR, IR_KEYTABLE_SYSTEM_DIR);
return -1;
}
}
if (!keys.next) {
fprintf(stderr, "Empty table %s\n", fname);
return -1;
}
clear = 1;
}
if (debug)
fprintf(stderr, "Opening %s\n", devicename);
fd = open(devicename, O_RDONLY);
if (fd < 0) {
perror(devicename);
return -1;
}
if (dev_from_class)
free(devicename);
if (get_input_protocol_version(fd))
return -1;
/*
* First step: clear, if --clear is specified
*/
if (clear) {
clear_table(fd);
fprintf(stderr, "Old keytable cleared\n");
}
/*
* Second step: stores key tables from file or from commandline
*/
write_cnt = add_keys(fd);
if (write_cnt)
fprintf(stderr, "Wrote %d keycode(s) to driver\n", write_cnt);
/*
* Third step: change protocol
*/
if (ch_proto) {
rc_dev.current = ch_proto;
if (set_proto(&rc_dev))
fprintf(stderr, "Couldn't change the IR protocols\n");
else {
fprintf(stderr, "Protocols changed to ");
show_proto(rc_dev.current);
fprintf(stderr, "\n");
}
}
/*
* Fourth step: display current keytable
*/
if (readtable)
display_table(&rc_dev, fd);
/*
* Fiveth step: change repeat rate/delay
*/
if (delay || period) {
unsigned int new_delay, new_period;
get_rate(fd, &new_delay, &new_period);
if (delay)
new_delay = delay;
if (period)
new_period = period;
set_rate(fd, new_delay, new_period);
}
if (test)
test_event(fd);
return 0;
}
int main(int argc, char **argv)
{
struct arguments args;
int lnb = -1,idx = -1;
const struct argp argp = {
.options = options,
.parser = parse_opt,
.doc = "scan DVB services using the channel file",
.args_doc = "<initial file>",
};
memset(&args, 0, sizeof(args));
args.sat_number = -1;
args.output = DEFAULT_OUTPUT;
args.input_format = FILE_DVBV5;
args.output_format = FILE_DVBV5;
args.timeout_multiply = 1;
argp_parse(&argp, argc, argv, 0, &idx, &args);
if (args.timeout_multiply == 0)
args.timeout_multiply = 1;
if (args.lnb_name) {
lnb = dvb_sat_search_lnb(args.lnb_name);
if (lnb < 0) {
printf("Please select one of the LNBf's below:\n");
print_all_lnb();
exit(1);
} else {
printf("Using LNBf ");
print_lnb(lnb);
}
}
if (idx < argc)
args.confname = argv[idx];
if (!args.confname || idx < 0) {
argp_help(&argp, stderr, ARGP_HELP_STD_HELP, PROGRAM_NAME);
return -1;
}
if ((args.input_format == FILE_ZAP) ||
(args.input_format == FILE_UNKNOWN) ||
(args.output_format == FILE_UNKNOWN)) {
fprintf(stderr, "ERROR: Please specify a valid format\n");
argp_help(&argp, stderr, ARGP_HELP_STD_HELP, PROGRAM_NAME);
return -1;
}
asprintf(&args.demux_dev,
"/dev/dvb/adapter%i/demux%i", args.adapter, args.demux);
if (verbose)
fprintf(stderr, "using demux '%s'\n", args.demux_dev);
struct dvb_v5_fe_parms *parms = dvb_fe_open(args.adapter,
args.frontend,
verbose, args.force_dvbv3);
if (!parms)
return -1;
if (lnb >= 0)
parms->lnb = dvb_sat_get_lnb(lnb);
if (args.sat_number >= 0)
parms->sat_number = args.sat_number % 3;
parms->diseqc_wait = args.diseqc_wait;
parms->freq_bpf = args.freq_bpf;
if (run_scan(&args, parms))
return -1;
dvb_fe_close(parms);
free(args.demux_dev);
return 0;
}
int main(int argc, char *argv[])
{
int i, j, entriesPrinted, totalPrinted, remainingCount;
int rc;
char client_name[] = "ofdpa flowtable_dump client";
char docBuffer[1000];
char argsDocBuffer[300];
/* Our argp parser. */
struct argp argp =
{
.args_doc = argsDocBuffer,
.doc = docBuffer,
.options = options,
.parser = parse_opt,
};
count = DEFAULT_COUNT;
strcpy(argsDocBuffer, "[table_ID]");
strcpy(docBuffer, "Prints entries in the OF-DPA flow tables. Specify table ID to print content of a single table. "
"If no argument given, content of all tables are printed.\vDefault values:\n");
i = strlen(docBuffer);
i += sprintf(&docBuffer[i], "COUNT = %d\n", DEFAULT_COUNT);
i += sprintf(&docBuffer[i], "\n");
rc = ofdpaClientInitialize(client_name);
if (rc != OFDPA_E_NONE)
{
return rc;
}
/* Parse our arguments; every option seen by `parse_opt' will be reflected in
`arguments'. */
argp_parse(&argp, argc, argv, 0, 0, 0);
if (showValidTableIds)
{
printf("Valid flow table IDs:\r\n");
for (j = 0; j < 256; j++)
{
if (ofdpaFlowTableSupported(j) == OFDPA_E_NONE)
{
printf(" %d - %s\r\n", j, ofdpaFlowTableNameGet(j));
}
}
printf("\r\n");
return 0;
}
totalPrinted = 0;
if (tableIdSpecified)
{
dumpFlowTable(tableId, count, &totalPrinted);
}
else
{
remainingCount = count;
for (j = 0; j < 256; j++)
{
if (ofdpaFlowTableSupported(j) == OFDPA_E_NONE)
{
entriesPrinted = 0;
dumpFlowTable(j, remainingCount, &entriesPrinted);
totalPrinted += entriesPrinted;
if (count != 0)
{
if (remainingCount > entriesPrinted)
{
remainingCount -= entriesPrinted;
}
else
{
/* printed the requested number of total entries */
break;
}
}
}
}
}
/*
* if not printing empty table stats and no flow entries found, we haven't printed anything at all
* so print a message letting the user know we are responsive
*/
if ((showEmptyTables == 0) && (totalPrinted == 0))
{
printf("No flow entries found.\r\n");
}
return 0;
}
int
main(int argc, char *argv[])
{
error_t err;
/* The filesystem node we're putting a translator on. */
char *node_name = 0;
file_t node;
/* The translator's arg vector, in '\0' separated format. */
char *argz = 0;
size_t argz_len = 0;
/* The control port for any active translator we start up. */
fsys_t active_control = MACH_PORT_NULL;
/* Flags to pass to file_set_translator. */
int active_flags = 0;
int passive_flags = 0;
int lookup_flags = O_NOTRANS;
int goaway_flags = 0;
/* Various option flags. */
int passive = 0, active = 0, keep_active = 0, pause = 0, kill_active = 0,
orphan = 0;
int start = 0;
int stack = 0;
char *pid_file = NULL;
int excl = 0;
int timeout = DEFAULT_TIMEOUT * 1000; /* ms */
char *underlying_node_name = NULL;
int underlying_lookup_flags;
char **chroot_command = 0;
char *chroot_chdir = "/";
/* Parse our options... */
error_t parse_opt (int key, char *arg, struct argp_state *state)
{
switch (key)
{
case ARGP_KEY_ARG:
if (state->arg_num == 0)
node_name = arg;
else /* command */
{
if (start)
argp_error (state, "both --start and TRANSLATOR given");
error_t err =
argz_create (state->argv + state->next - 1, &argz, &argz_len);
if (err)
error(3, err, "Can't create options vector");
state->next = state->argc; /* stop parsing */
}
break;
case ARGP_KEY_NO_ARGS:
argp_usage (state);
return EINVAL;
case 'a': active = 1; break;
case 's':
start = 1;
active = 1; /* start implies active */
break;
case OPT_STACK:
stack = 1;
active = 1; /* stack implies active */
orphan = 1; /* stack implies orphan */
break;
case 'p': passive = 1; break;
case 'k': keep_active = 1; break;
case 'g': kill_active = 1; break;
case 'x': excl = 1; break;
case 'P': pause = 1; break;
case 'F':
pid_file = strdup (arg);
if (pid_file == NULL)
error(3, ENOMEM, "Failed to duplicate argument");
break;
case 'o': orphan = 1; break;
case 'U':
underlying_node_name = strdup (arg);
if (underlying_node_name == NULL)
error(3, ENOMEM, "Failed to duplicate argument");
break;
case 'C':
if (chroot_command)
{
argp_error (state, "--chroot given twice");
return EINVAL;
}
chroot_command = &state->argv[state->next];
while (state->next < state->argc)
{
if (!strcmp (state->argv[state->next], "--"))
{
state->argv[state->next++] = 0;
if (chroot_command[0] == 0)
{
argp_error (state,
"--chroot must be followed by a command");
return EINVAL;
}
return 0;
}
++state->next;
}
argp_error (state, "--chroot command must be terminated with `--'");
return EINVAL;
case OPT_CHROOT_CHDIR:
if (arg[0] != '/')
argp_error (state, "--chroot-chdir must be absolute");
chroot_chdir = arg;
break;
case 'c': lookup_flags |= O_CREAT; break;
case 'L': lookup_flags &= ~O_NOTRANS; break;
case 'R': goaway_flags |= FSYS_GOAWAY_RECURSE; break;
case 'S': goaway_flags |= FSYS_GOAWAY_NOSYNC; break;
case 'f': goaway_flags |= FSYS_GOAWAY_FORCE; break;
/* Use atof so the user can specifiy fractional timeouts. */
case 't': timeout = atof (arg) * 1000.0; break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
struct argp argp = {options, parse_opt, args_doc, doc};
argp_parse (&argp, argc, argv, ARGP_IN_ORDER, 0, 0);
if (stack)
{
underlying_node_name = node_name;
underlying_lookup_flags = lookup_flags && ~O_NOTRANS;
}
else
underlying_lookup_flags = lookup_flags;
if (!active && !passive && !chroot_command)
passive = 1; /* By default, set the passive translator. */
if (passive)
passive_flags = FS_TRANS_SET | (excl ? FS_TRANS_EXCL : 0);
if (active)
active_flags = FS_TRANS_SET | (excl ? FS_TRANS_EXCL : 0)
| (orphan ? FS_TRANS_ORPHAN : 0);
if (passive && !active)
{
/* When setting just the passive, decide what to do with any active. */
if (kill_active)
/* Make it go away. */
active_flags = FS_TRANS_SET;
else if (! keep_active)
/* Ensure that there isn't one. */
active_flags = FS_TRANS_SET | FS_TRANS_EXCL;
}
if (start)
{
/* Retrieve the passive translator record in argz. */
mach_port_t node = file_name_lookup (node_name, lookup_flags, 0);
if (node == MACH_PORT_NULL)
error (4, errno, "%s", node_name);
char buf[1024];
argz = buf;
argz_len = sizeof (buf);
err = file_get_translator (node, &argz, &argz_len);
if (err == EINVAL)
error (4, 0, "%s: no passive translator record found", node_name);
if (err)
error (4, err, "%s", node_name);
mach_port_deallocate (mach_task_self (), node);
}
if ((active || chroot_command) && argz_len > 0)
{
/* Error during file lookup; we use this to avoid duplicating error
messages. */
error_t open_err = 0;
/* The callback to start_translator opens NODE as a side effect. */
error_t open_node (int flags,
mach_port_t *underlying,
mach_msg_type_name_t *underlying_type,
task_t task, void *cookie)
{
if (pause)
{
fprintf (stderr, "Translator pid: %d\nPausing...",
task2pid (task));
getchar ();
}
if (pid_file != NULL)
{
FILE *h;
h = fopen (pid_file, "w");
if (h == NULL)
error (4, errno, "Failed to open pid file");
fprintf (h, "%i\n", task2pid (task));
fclose (h);
}
node = file_name_lookup (node_name, flags | lookup_flags, 0666);
if (node == MACH_PORT_NULL)
{
open_err = errno;
return open_err;
}
if (underlying_node_name)
{
*underlying = file_name_lookup (underlying_node_name,
flags | underlying_lookup_flags,
0666);
if (! MACH_PORT_VALID (*underlying))
{
/* For the error message. */
node_name = underlying_node_name;
open_err = errno;
return open_err;
}
}
else
*underlying = node;
*underlying_type = MACH_MSG_TYPE_COPY_SEND;
return 0;
}
err = fshelp_start_translator (open_node, NULL, argz, argz, argz_len,
timeout, &active_control);
if (err)
/* If ERR is due to a problem opening the translated node, we print
that name, otherwise, the name of the translator. */
error(4, err, "%s", (err == open_err) ? node_name : argz);
}
int main(int argc, char **argv)
{
struct arguments arguments;
// Default values
arguments.cmd = NULL;
arguments.cmdargs[0] = NULL;
arguments.cmdargs[1] = NULL;
arguments.cmdargs[2] = NULL;
arguments.bit_num = -1;
argp_parse(&argp, argc, argv, 0, 0, &arguments);
// printf("cmd = %s\ncmdargs[0] = %s\ncmdargs[1] = %s\n"
// "cmdargs[2] = %s\nbit_num = %d\n",
// arguments.cmd,
// arguments.cmdargs[0],
// arguments.cmdargs[1],
// arguments.cmdargs[2],
// arguments.bit_num);
if (arguments.bit_num > 7) {
fprintf(stderr, "pifacecad: bit num must in range 0-7.\n");
exit(1);
}
pifacecad_open_noinit();
if (strcmp(arguments.cmd, "open") == 0) {
pifacecad_open();
int i;
for (i = 0; i <= 2; i++) {
if (arguments.cmdargs[i] == NULL) {
continue;
}
if (strcmp(arguments.cmdargs[i], "displayoff") == 0) {
pifacecad_lcd_display_off();
}
if (strcmp(arguments.cmdargs[i], "blinkoff") == 0) {
pifacecad_lcd_blink_off();
}
if (strcmp(arguments.cmdargs[i], "cursoroff") == 0) {
pifacecad_lcd_cursor_off();
}
}
} else if (strcmp(arguments.cmd, "read") == 0) {
pfc_read_switch(arguments.bit_num, str2reg(arguments.cmdargs[0]));
} else if (strcmp(arguments.cmd, "write") == 0) {
pifacecad_lcd_write(arguments.cmdargs[0]);
} else if (strcmp(arguments.cmd, "backlight") == 0) {
if (strcmp(arguments.cmdargs[0], "on") == 0) {
pifacecad_lcd_backlight_on();
} else {
pifacecad_lcd_backlight_off();
}
} else if (strcmp(arguments.cmd, "home") == 0) {
pifacecad_lcd_home();
} else if (strcmp(arguments.cmd, "clear") == 0) {
pifacecad_lcd_clear();
} else if (strcmp(arguments.cmd, "setcursor") == 0) {
const uint8_t col = atoi(arguments.cmdargs[0]);
const uint8_t row = atoi(arguments.cmdargs[1]);
pifacecad_lcd_set_cursor(col, row);
}
pifacecad_close();
exit(0);
}
int main (int argc, char **argv)
{
struct arguments arguments;
/* Default values. */
arguments.verbose = 0;
arguments.grd = 0;
arguments.region = NULL;
arguments.type = NULL;
static const int NUM_DAYS = 365;
/* Parse our arguments; every option seen by parse_opt will
be reflected in arguments. */
argp_parse (&argp, argc, argv, 0, 0, &arguments);
/* Set up variables */
int num_columns;
int num_rows;
char* region = arguments.region;
char* type = arguments.type;
int grd = arguments.grd;
int i,j,k;
/* Initialize NETCDF Variables */
int ncid, row_dimid, col_dimid;
int varid, wet_varid, dry_varid, slope_varid;
int retval;
char FILE_NAME[100];
int dimids[NDIMS];
/* multithread args */
thread_args t_args[NUM_THREADS];
pthread_t thread_id[NUM_THREADS];
int ind_per_thread;
int start_index;
int stop_index;
printf ("GEN_C0\n---------------\nBeginning processing with options:\n");
printf ("Region = %s\nVERBOSE = %s\nTYPE = %s\n---------------\n",
arguments.region,
arguments.verbose ? "yes" : "no",
arguments.type);
/* define image areas based on region */
if (!grd) {
if (strcmp(region,"Ama") == 0) {
num_columns = 1128;
num_rows = 744;
} else if (strcmp(region,"Ber") == 0) {
num_columns = 1350;
num_rows = 750;
} else if (strcmp(region,"CAm") == 0) {
num_columns = 1440;
num_rows = 700;
} else if (strcmp(region,"ChJ") == 0) {
num_columns = 1980;
num_rows = 950;
} else if (strcmp(region,"Eur") == 0) {
num_columns = 1530;
num_rows = 1040;
} else if (strcmp(region,"Ind") == 0) {
num_columns = 1800;
num_rows = 680;
} else if (strcmp(region,"NAf") == 0) {
num_columns = 2120;
num_rows = 1130;
} else if (strcmp(region,"NAm") == 0) {
num_columns = 1890;
num_rows = 1150;
} else if (strcmp(region,"SAf") == 0) {
num_columns = 1220;
num_rows = 1260;
} else if (strcmp(region,"SAm") == 0) {
num_columns = 1310;
num_rows = 1850;
} else if (strcmp(region,"SAs") == 0) {
num_columns = 1760;
num_rows = 720;
} else {
printf("ERROR SETTING REGION SIZES!");
exit(-1);
}
} else {
if (strcmp(region,"NAm") == 0) {
num_columns = 672;
num_rows = 410;
} else {
printf("ERROR SETTING REGION SIZES!");
exit(-1);
}
}
/* allocate memory for 2d arrays */
printf("Allocating Memory...");
float **c0_dry = (float**)malloc(sizeof(float *)*num_rows);
float **c0_wet = (float**)malloc(sizeof(float *)*num_rows);
float **dry_slope = (float**)malloc(sizeof(float *)*num_rows);
c0_dry[0] = (float*)malloc(sizeof(float)*num_rows*num_columns);
c0_wet[0] = (float*)malloc(sizeof(float)*num_rows*num_columns);
dry_slope[0] = (float*)malloc(sizeof(float)*num_rows*num_columns);
for (i = 1; i < num_rows; i++) {
c0_dry[i] = c0_dry[0] + i * num_columns;
c0_wet[i] = c0_wet[0] + i * num_columns;
dry_slope[i] = dry_slope[0] + i * num_columns;
}
memset(c0_dry[0],0,num_rows*num_columns*sizeof(float));
memset(c0_wet[0],0,num_rows*num_columns*sizeof(float));
memset(dry_slope[0],0,num_rows*num_columns*sizeof(float));
/* allocate memory for NetCDF File */
float ****row_ptr = (float****)malloc(sizeof(float ***)*num_rows);
float ***column_ptr = (float***)malloc(sizeof(float **)*num_rows * num_columns);
float **year_ptr = (float**)malloc(sizeof(float *)*num_rows * num_columns*NUM_YEARS);
float *day_ptr = (float*)malloc(sizeof(float)*num_rows*num_columns*NUM_YEARS*NUM_DAYS);
float ****tseries = row_ptr;
for (i = 0; i < num_rows; i++, column_ptr += num_columns) {
tseries[i] = column_ptr;
for (j = 0; j < num_columns; j++, year_ptr += NUM_YEARS) {
tseries[i][j] = year_ptr;
for (k = 0; k < NUM_YEARS; k++, day_ptr += NUM_DAYS) {
tseries[i][j][k] = day_ptr;
}
}
}
row_ptr = (float****)malloc(sizeof(float ***)*num_rows);
column_ptr = (float***)malloc(sizeof(float **)*num_rows * num_columns);
year_ptr = (float**)malloc(sizeof(float *)*num_rows * num_columns*NUM_YEARS);
day_ptr = (float*)malloc(sizeof(float)*num_rows*num_columns*NUM_YEARS*NUM_DAYS);
float ****tseriesb = row_ptr;
for (i = 0; i < num_rows; i++, column_ptr += num_columns) {
tseriesb[i] = column_ptr;
for (j = 0; j < num_columns; j++, year_ptr += NUM_YEARS) {
tseriesb[i][j] = year_ptr;
for (k = 0; k < NUM_YEARS; k++, day_ptr += NUM_DAYS) {
tseriesb[i][j][k] = day_ptr;
}
}
}
printf("done\n");
setvbuf (stdout, NULL, _IONBF, 0);
printf("Reading NetCDF Files...");
/* Open the netCDF time series a file*/
sprintf(FILE_NAME,"/auto/temp/lindell/soilmoisture/ts/ts_%s_%s.nc",region,"a");
if ((retval = nc_open(FILE_NAME, NC_NOWRITE, &ncid)))
ERR(retval);
/* Get the varid of the data variable, based on its name. */
if ((retval = nc_inq_varid(ncid, "data", &varid)))
ERR(retval);
/* read values from netCDF variable */
if ((retval = nc_get_var_float(ncid, varid, &tseries[0][0][0][0])))
ERR(retval);
/* Open the netCDF time series b file*/
sprintf(FILE_NAME,"/auto/temp/lindell/soilmoisture/ts/ts_%s_%s.nc",region,"b");
if ((retval = nc_open(FILE_NAME, NC_NOWRITE, &ncid)))
ERR(retval);
/* Get the varid of the data variable, based on its name. */
if ((retval = nc_inq_varid(ncid, "data", &varid)))
ERR(retval);
/* read values from netCDF variable */
if ((retval = nc_get_var_float(ncid, varid, &tseriesb[0][0][0][0])))
ERR(retval);
printf("done\n");
/* get threads ready */
/* split up column processing based on number of threads/rows */
ind_per_thread = num_rows / NUM_THREADS - 1;
start_index = 0;
stop_index = 0;
for (i = 0; i < NUM_THREADS; i++) {
if (i == NUM_THREADS - 1) {
stop_index = num_rows-1;
} else {
stop_index = start_index + ind_per_thread;
}
t_args[i].tseries = tseries;
t_args[i].tseriesb = tseriesb;
t_args[i].c0_wet = c0_wet;
t_args[i].c0_dry = c0_dry;
t_args[i].dry_slope = dry_slope;
t_args[i].start_i = start_index;
t_args[i].stop_i = stop_index;
t_args[i].num_columns = num_columns;
t_args[i].region = region;
t_args[i].type = type;
start_index = stop_index + 1;
}
/* call multithreaded function */
/* submit threads */
printf("Starting Processing\n");
for (i = 0; i < NUM_THREADS; i++) {
pthread_create(&thread_id[i], NULL, mthreadGenC0, &t_args[i]);
}
/* join threads */
for (i = 0; i < NUM_THREADS; i++) {
pthread_join(thread_id[i], NULL);
}
/* save min/max 2d arrays to netcdf file */
/* Create the file. */
sprintf(FILE_NAME,"/auto/temp/lindell/soilmoisture/c0/c0_%s.nc",region);
if ((retval = nc_create(FILE_NAME, NC_NETCDF4, &ncid)))
ERR(retval);
/* Define the dimensions. */
if ((retval = nc_def_dim(ncid, "row", num_rows, &row_dimid)))
ERR(retval);
if ((retval = nc_def_dim(ncid, "column", num_columns, &col_dimid)))
ERR(retval);
/* Define the netCDF variables. The dimids array is used to pass
the dimids of the dimensions of the variables.*/
dimids[0] = row_dimid;
dimids[1] = col_dimid;
/* define the variable */
if ((retval = nc_def_var(ncid, "dry", NC_FLOAT, NDIMS, dimids, &dry_varid)))
ERR(retval);
if ((retval = nc_def_var(ncid, "wet", NC_FLOAT, NDIMS, dimids, &wet_varid)))
ERR(retval);
if ((retval = nc_def_var(ncid, "dry_slope", NC_FLOAT, NDIMS, dimids, &slope_varid)))
ERR(retval);
/* End define mode. */
if ((retval = nc_enddef(ncid)))
ERR(retval);
/* Write the data. */
if ((retval = nc_put_var_float(ncid, dry_varid, &c0_dry[0][0])))
ERR(retval);
if ((retval = nc_put_var_float(ncid, wet_varid, &c0_wet[0][0])))
ERR(retval);
if ((retval = nc_put_var_float(ncid, slope_varid, &dry_slope[0][0])))
ERR(retval);
/* Close the file. */
if ((retval = nc_close(ncid)))
ERR(retval);
/* Free memory for 3D image timeseries array */
printf("Finishing up...");
free(tseries[0][0][0]);
free(tseries[0][0]);
free(tseries[0]);
free(tseries);
free(c0_wet[0]);
free(c0_dry[0]);
free(dry_slope[0]);
free(c0_wet);
free(c0_dry);
free(dry_slope);
printf("done\n");
exit (0);
}
int
main (int argc, char **argv)
{
argp_parse (0, argc, argv, 0, 0, 0);
exit (0);
}
int
main (int argc, char **argv, char **envp)
{
mach_port_t boot;
error_t err;
void *genport;
process_t startup_port;
mach_port_t startup;
struct argp argp = { 0, 0, 0, "Hurd process server" };
argp_parse (&argp, argc, argv, 0, 0, 0);
initialize_version_info ();
err = task_get_bootstrap_port (mach_task_self (), &boot);
assert_perror (err);
if (boot == MACH_PORT_NULL)
error (2, 0, "proc server can only be run by init during boot");
proc_bucket = ports_create_bucket ();
proc_class = ports_create_class (0, 0);
generic_port_class = ports_create_class (0, 0);
exc_class = ports_create_class (exc_clean, 0);
ports_create_port (generic_port_class, proc_bucket,
sizeof (struct port_info), &genport);
generic_port = ports_get_right (genport);
/* Create the initial proc object for init (PID 1). */
init_proc = create_init_proc ();
/* Create the startup proc object for /hurd/init (PID 2). */
startup_proc = allocate_proc (MACH_PORT_NULL);
startup_proc->p_deadmsg = 1;
complete_proc (startup_proc, HURD_PID_STARTUP);
/* Create our own proc object. */
self_proc = allocate_proc (mach_task_self ());
assert (self_proc);
complete_proc (self_proc, HURD_PID_PROC);
startup_port = ports_get_send_right (startup_proc);
err = startup_procinit (boot, startup_port, &startup_proc->p_task,
&authserver, &_hurd_host_priv, &_hurd_device_master);
assert_perror (err);
mach_port_deallocate (mach_task_self (), startup_port);
mach_port_mod_refs (mach_task_self (), authserver, MACH_PORT_RIGHT_SEND, 1);
_hurd_port_set (&_hurd_ports[INIT_PORT_AUTH], authserver);
mach_port_deallocate (mach_task_self (), boot);
proc_death_notify (startup_proc);
add_proc_to_hash (startup_proc); /* Now that we have the task port. */
/* Set our own argv and envp locations. */
self_proc->p_argv = (vm_address_t) argv;
self_proc->p_envp = (vm_address_t) envp;
/* Give ourselves good scheduling performance, because we are so
important. */
err = increase_priority ();
if (err)
error (0, err, "Increasing priority failed");
#if 0
err = register_new_task_notification (_hurd_host_priv,
generic_port,
MACH_MSG_TYPE_MAKE_SEND);
if (err)
error (0, err, "Registering task notifications failed");
#endif
{
/* Get our stderr set up to print on the console, in case we have
to panic or something. */
mach_port_t cons;
error_t err;
err = device_open (_hurd_device_master, D_READ|D_WRITE, "console", &cons);
assert_perror (err);
stdin = mach_open_devstream (cons, "r");
stdout = stderr = mach_open_devstream (cons, "w");
mach_port_deallocate (mach_task_self (), cons);
}
startup = file_name_lookup (_SERVERS_STARTUP, 0, 0);
if (MACH_PORT_VALID (startup))
{
err = startup_essential_task (startup, mach_task_self (),
MACH_PORT_NULL, "proc", _hurd_host_priv);
if (err)
/* Due to the single-threaded nature of /hurd/startup, it can
only handle requests once the core server bootstrap has
completed. Therefore, it does not bind itself to
/servers/startup until it is ready. */
/* Fall back to abusing the message port lookup. */
startup_fallback = 1;
err = mach_port_deallocate (mach_task_self (), startup);
assert_perror (err);
}
else
/* Fall back to abusing the message port lookup. */
startup_fallback = 1;
while (1)
ports_manage_port_operations_multithread (proc_bucket,
message_demuxer,
0, 0, 0);
}
int main (int argc, char *argv[])
{
#ifdef HAVE_ICONV
char *locale_charset;
#endif
int status = OK;
program_name = base_name (argv[0]);
if (STREQ (program_name, APROPOS_NAME)) {
am_apropos = 1;
argp_program_version = "apropos " PACKAGE_VERSION;
} else {
struct argp_option *optionp;
am_apropos = 0;
argp_program_version = "whatis " PACKAGE_VERSION;
for (optionp = (struct argp_option *) whatis_argp.options;
optionp->name || optionp->key || optionp->arg ||
optionp->flags || optionp->doc || optionp->group;
++optionp) {
if (!optionp->name)
continue;
if (STREQ (optionp->name, "exact") ||
STREQ (optionp->name, "and"))
optionp->flags |= OPTION_HIDDEN;
}
}
init_debug ();
pipeline_install_post_fork (pop_all_cleanups);
init_locale ();
internal_locale = setlocale (LC_MESSAGES, NULL);
/* Use LANGUAGE only when LC_MESSAGES locale category is
* neither "C" nor "POSIX". */
if (internal_locale && strcmp (internal_locale, "C") &&
strcmp (internal_locale, "POSIX"))
multiple_locale = getenv ("LANGUAGE");
internal_locale = xstrdup (internal_locale ? internal_locale : "C");
if (argp_parse (am_apropos ? &apropos_argp : &whatis_argp, argc, argv,
0, 0, 0))
exit (FAIL);
read_config_file (user_config_file != NULL);
/* close this locale and reinitialise if a new locale was
issued as an argument or in $MANOPT */
if (locale) {
free (internal_locale);
internal_locale = setlocale (LC_ALL, locale);
if (internal_locale)
internal_locale = xstrdup (internal_locale);
else
internal_locale = xstrdup (locale);
debug ("main(): locale = %s, internal_locale = %s\n",
locale, internal_locale);
if (internal_locale) {
setenv ("LANGUAGE", internal_locale, 1);
locale_changed ();
multiple_locale = NULL;
}
}
/* sort out the internal manpath */
if (manp == NULL)
manp = locale_manpath (get_manpath (alt_systems));
else
free (get_manpath (NULL));
create_pathlist (manp, manpathlist);
display_seen = hashtable_create (&null_hashtable_free);
#ifdef HAVE_ICONV
locale_charset = xasprintf ("%s//IGNORE", get_locale_charset ());
conv_to_locale = iconv_open (locale_charset, "UTF-8");
free (locale_charset);
#endif /* HAVE_ICONV */
if (regex_opt) {
int i;
preg = XNMALLOC (num_keywords, regex_t);
for (i = 0; i < num_keywords; ++i)
xregcomp (&preg[i], keywords[i],
REG_EXTENDED | REG_NOSUB | REG_ICASE);
}
if (!search ((const char **) keywords, num_keywords))
status = NOT_FOUND;
if (regex_opt) {
int i;
for (i = 0; i < num_keywords; ++i)
regfree (&preg[i]);
free (preg);
}
#ifdef HAVE_ICONV
if (conv_to_locale != (iconv_t) -1)
iconv_close (conv_to_locale);
#endif /* HAVE_ICONV */
hashtable_free (display_seen);
free_pathlist (manpathlist);
free (manp);
free (internal_locale);
free (program_name);
exit (status);
}
int main(int argc, char *argv[])
{
char errbuf[PCAP_ERRBUF_SIZE];
char *dev;
struct iface_config *ifc;
int optind;
int i;
bzero(&cfg, sizeof(cfg));
/* Default configuration */
// cfg.ratelimit = 0;
cfg.hashsize = 1;
// cfg.quiet = 0;
cfg.promisc_flag = 1;
// cfg.ratelimit = 0;
// cfg.sqlite_file = NULL;
// cfg.uname = NULL;
cfg.shm_data.size = DEFAULT_SHM_LOG_SIZE;
cfg.shm_data.name = DEFAULT_SHM_LOG_NAME;
#if HAVE_LIBSQLITE3
cfg.sqlite_table = PACKAGE;
#endif
log_open(PACKAGE_NAME);
argp_parse(&argp, argc, argv, 0, &optind, 0);
if (!cfg.hostname) {
cfg.hostname_len = sysconf(_SC_HOST_NAME_MAX);
cfg.hostname = (char *)calloc(cfg.hostname_len, sizeof(char));
gethostname(cfg.hostname, cfg.hostname_len);
}
daemonize();
save_pid();
libevent_init();
if (cfg.ratelimit > 0)
log_msg(LOG_DEBUG, "Ratelimiting duplicate entries to 1 per %d seconds", cfg.ratelimit);
else if (cfg.ratelimit == -1)
log_msg(LOG_DEBUG, "Duplicate entries supressed indefinitely");
else
log_msg(LOG_DEBUG, "Duplicate entries ratelimiting disabled");
if (cfg.promisc_flag)
log_msg(LOG_DEBUG, "PROMISC mode enabled");
else
log_msg(LOG_DEBUG, "PROMISC mode disabled");
if (argc > optind) {
for (i = optind; i < argc; i++)
add_iface(argv[i]);
} else {
dev = pcap_lookupdev(errbuf);
if (dev != NULL)
add_iface(dev);
}
if (!cfg.interfaces)
log_msg(LOG_ERR, "No suitable interfaces found!");
if (cfg.uname)
drop_root(cfg.uname);
output_flatfile_init();
output_sqlite_init();
output_shm_init();
/* main loop */
#if HAVE_LIBEVENT2
event_base_dispatch(cfg.eb);
#else
event_dispatch();
#endif
output_shm_close();
output_sqlite_close();
output_flatfile_close();
for (ifc = cfg.interfaces; ifc != NULL; ifc = del_iface(ifc));
libevent_close();
log_close();
del_pid();
blacklist_free();
free(cfg.hostname);
return 0;
}
int
main (int argc, char *argv[])
{
int fd;
int remaining;
int must_swap;
uint32_t word;
/* Parse and process arguments. */
argp_parse (&argp, argc, argv, 0, &remaining, NULL);
if (remaining == argc)
fd = STDIN_FILENO;
else if (remaining + 1 != argc)
{
argp_help (&argp, stdout, ARGP_HELP_SEE | ARGP_HELP_EXIT_ERR,
program_invocation_short_name);
exit (1);
}
else
{
/* Open the given file. */
fd = open (argv[remaining], O_RDONLY);
if (fd == -1)
error (EXIT_FAILURE, errno, _("cannot open input file"));
}
/* Read the first 4-byte word. It contains the information about
the word size and the endianess. */
if (TEMP_FAILURE_RETRY (read (fd, &word, 4)) != 4)
error (EXIT_FAILURE, errno, _("cannot read header"));
/* Check whether we have to swap the byte order. */
must_swap = (word & 0xfffffff0) == bswap_32 (0xdeb00000);
if (must_swap)
word = bswap_32 (word);
/* We have two loops, one for 32 bit pointers, one for 64 bit pointers. */
if (word == 0xdeb00004)
{
union
{
uint32_t ptrs[2];
char bytes[8];
} pair;
while (1)
{
size_t len = sizeof (pair);
size_t n;
while (len > 0
&& (n = TEMP_FAILURE_RETRY (read (fd, &pair.bytes[8 - len],
len))) != 0)
len -= n;
if (len != 0)
/* Nothing to read. */
break;
printf ("this = %#010" PRIx32 ", caller = %#010" PRIx32 "\n",
must_swap ? bswap_32 (pair.ptrs[0]) : pair.ptrs[0],
must_swap ? bswap_32 (pair.ptrs[1]) : pair.ptrs[1]);
}
}
else if (word == 0xdeb00008)
{
union
{
uint64_t ptrs[2];
char bytes[16];
} pair;
while (1)
{
size_t len = sizeof (pair);
size_t n;
while (len > 0
&& (n = TEMP_FAILURE_RETRY (read (fd, &pair.bytes[8 - len],
len))) != 0)
len -= n;
if (len != 0)
/* Nothing to read. */
break;
printf ("this = %#018" PRIx64 ", caller = %#018" PRIx64 "\n",
must_swap ? bswap_64 (pair.ptrs[0]) : pair.ptrs[0],
must_swap ? bswap_64 (pair.ptrs[1]) : pair.ptrs[1]);
}
}
else
/* This should not happen. */
error (EXIT_FAILURE, 0, _("invalid pointer size"));
/* Clean up. */
close (fd);
return 0;
}
static void handle_session(ssh_event event, ssh_session session) {
int n;
int rc = 0;
/* Structure for storing the pty size. */
struct winsize wsize = {
.ws_row = 0,
.ws_col = 0,
.ws_xpixel = 0,
.ws_ypixel = 0
};
/* Our struct holding information about the channel. */
struct channel_data_struct cdata = {
.pid = 0,
.pty_master = -1,
.pty_slave = -1,
.child_stdin = -1,
.child_stdout = -1,
.child_stderr = -1,
.event = NULL,
.winsize = &wsize
};
/* Our struct holding information about the session. */
struct session_data_struct sdata = {
.channel = NULL,
.auth_attempts = 0,
.authenticated = 0
};
struct ssh_channel_callbacks_struct channel_cb = {
.userdata = &cdata,
.channel_pty_request_function = pty_request,
.channel_pty_window_change_function = pty_resize,
.channel_shell_request_function = shell_request,
.channel_exec_request_function = exec_request,
.channel_data_function = data_function,
.channel_subsystem_request_function = subsystem_request
};
struct ssh_server_callbacks_struct server_cb = {
.userdata = &sdata,
.auth_password_function = auth_password,
.channel_open_request_session_function = channel_open,
};
if (authorizedkeys[0]) {
server_cb.auth_pubkey_function = auth_publickey;
ssh_set_auth_methods(session, SSH_AUTH_METHOD_PASSWORD | SSH_AUTH_METHOD_PUBLICKEY);
} else
ssh_set_auth_methods(session, SSH_AUTH_METHOD_PASSWORD);
ssh_callbacks_init(&server_cb);
ssh_callbacks_init(&channel_cb);
ssh_set_server_callbacks(session, &server_cb);
if (ssh_handle_key_exchange(session) != SSH_OK) {
fprintf(stderr, "%s\n", ssh_get_error(session));
return;
}
ssh_event_add_session(event, session);
n = 0;
while (sdata.authenticated == 0 || sdata.channel == NULL) {
/* If the user has used up all attempts, or if he hasn't been able to
* authenticate in 10 seconds (n * 100ms), disconnect. */
if (sdata.auth_attempts >= 3 || n >= 100) {
return;
}
if (ssh_event_dopoll(event, 100) == SSH_ERROR) {
fprintf(stderr, "%s\n", ssh_get_error(session));
return;
}
n++;
}
ssh_set_channel_callbacks(sdata.channel, &channel_cb);
do {
/* Poll the main event which takes care of the session, the channel and
* even our child process's stdout/stderr (once it's started). */
if (ssh_event_dopoll(event, -1) == SSH_ERROR) {
ssh_channel_close(sdata.channel);
}
/* If child process's stdout/stderr has been registered with the event,
* or the child process hasn't started yet, continue. */
if (cdata.event != NULL || cdata.pid == 0) {
continue;
}
/* Executed only once, once the child process starts. */
cdata.event = event;
/* If stdout valid, add stdout to be monitored by the poll event. */
if (cdata.child_stdout != -1) {
if (ssh_event_add_fd(event, cdata.child_stdout, POLLIN, process_stdout,
sdata.channel) != SSH_OK) {
fprintf(stderr, "Failed to register stdout to poll context\n");
ssh_channel_close(sdata.channel);
}
}
/* If stderr valid, add stderr to be monitored by the poll event. */
if (cdata.child_stderr != -1){
if (ssh_event_add_fd(event, cdata.child_stderr, POLLIN, process_stderr,
sdata.channel) != SSH_OK) {
fprintf(stderr, "Failed to register stderr to poll context\n");
ssh_channel_close(sdata.channel);
}
}
} while(ssh_channel_is_open(sdata.channel) &&
(cdata.pid == 0 || waitpid(cdata.pid, &rc, WNOHANG) == 0));
close(cdata.pty_master);
close(cdata.child_stdin);
close(cdata.child_stdout);
close(cdata.child_stderr);
/* Remove the descriptors from the polling context, since they are now
* closed, they will always trigger during the poll calls. */
ssh_event_remove_fd(event, cdata.child_stdout);
ssh_event_remove_fd(event, cdata.child_stderr);
/* If the child process exited. */
if (kill(cdata.pid, 0) < 0 && WIFEXITED(rc)) {
rc = WEXITSTATUS(rc);
ssh_channel_request_send_exit_status(sdata.channel, rc);
/* If client terminated the channel or the process did not exit nicely,
* but only if something has been forked. */
} else if (cdata.pid > 0) {
kill(cdata.pid, SIGKILL);
}
ssh_channel_send_eof(sdata.channel);
ssh_channel_close(sdata.channel);
/* Wait up to 5 seconds for the client to terminate the session. */
for (n = 0; n < 50 && (ssh_get_status(session) & SESSION_END) == 0; n++) {
ssh_event_dopoll(event, 100);
}
}
/* SIGCHLD handler for cleaning up dead children. */
static void sigchld_handler(int signo) {
(void) signo;
while (waitpid(-1, NULL, WNOHANG) > 0);
}
int main(int argc, char **argv) {
ssh_bind sshbind;
ssh_session session;
ssh_event event;
struct sigaction sa;
int rc;
/* Set up SIGCHLD handler. */
sa.sa_handler = sigchld_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
if (sigaction(SIGCHLD, &sa, NULL) != 0) {
fprintf(stderr, "Failed to register SIGCHLD handler\n");
return 1;
}
rc = ssh_init();
if (rc < 0) {
fprintf(stderr, "ssh_init failed\n");
return 1;
}
sshbind = ssh_bind_new();
if (sshbind == NULL) {
fprintf(stderr, "ssh_bind_new failed\n");
return 1;
}
#ifdef HAVE_ARGP_H
argp_parse(&argp, argc, argv, 0, 0, sshbind);
#else
(void) argc;
(void) argv;
set_default_keys(sshbind, 0, 0, 0);
#endif /* HAVE_ARGP_H */
if(ssh_bind_listen(sshbind) < 0) {
fprintf(stderr, "%s\n", ssh_get_error(sshbind));
return 1;
}
while (1) {
session = ssh_new();
if (session == NULL) {
fprintf(stderr, "Failed to allocate session\n");
continue;
}
/* Blocks until there is a new incoming connection. */
if(ssh_bind_accept(sshbind, session) != SSH_ERROR) {
switch(fork()) {
case 0:
/* Remove the SIGCHLD handler inherited from parent. */
sa.sa_handler = SIG_DFL;
sigaction(SIGCHLD, &sa, NULL);
/* Remove socket binding, which allows us to restart the
* parent process, without terminating existing sessions. */
ssh_bind_free(sshbind);
event = ssh_event_new();
if (event != NULL) {
/* Blocks until the SSH session ends by either
* child process exiting, or client disconnecting. */
handle_session(event, session);
ssh_event_free(event);
} else {
fprintf(stderr, "Could not create polling context\n");
}
ssh_disconnect(session);
ssh_free(session);
exit(0);
case -1:
fprintf(stderr, "Failed to fork\n");
}
} else {
fprintf(stderr, "%s\n", ssh_get_error(sshbind));
}
/* Since the session has been passed to a child fork, do some cleaning
* up at the parent process. */
ssh_disconnect(session);
ssh_free(session);
}
ssh_bind_free(sshbind);
ssh_finalize();
return 0;
}
int main(int argc, char **argv)
{
unsigned i;
conf_t *conf;
dict_t *repositories;
dict_t *ports_dict;
dict_t *not_founds;
list_t *ports_list;
list_t *packages;
list_t *list;
list_t *drivers;
struct arguments arguments;
arguments.action = 0;
arguments.no_favourite_repositories = 0;
arguments.no_locked_versions = 0;
arguments.no_aliases = 0;
arguments.no_colors = 0;
arguments.no_deps = 1;
arguments.all = 0;
arguments.fetch_only = 0;
arguments.no_repositories_hierarchy = 0;
arguments.tree = 0;
arguments.verbose = 0;
arguments.rebuild_cache = 0;
arguments.args = list_new();
if (argc < 2) {
char *fake_arg[2];
fake_arg[0] = "ilenia";
fake_arg[1] = "--help";
argp_parse(&argp, 2, fake_arg, 0, 0, &arguments);
}
argp_parse(&argp, argc, argv, 0, 0, &arguments);
conf = conf_init();
if (arguments.no_repositories_hierarchy) {
list_free(conf->repositories_hierarchy, free);
conf->repositories_hierarchy = list_new();
}
if (arguments.no_favourite_repositories) {
dict_free(conf->favourite_repositories, NULL);
conf->favourite_repositories = dict_new();
}
if (arguments.no_locked_versions) {
dict_free(conf->locked_versions, free);
conf->locked_versions = dict_new();
}
if (arguments.no_aliases) {
aliases_free(conf->aliases);
conf->aliases = dict_new();
}
drivers = drivers_list_init();
repositories = repositories_dict_init(drivers,
conf->repositories_hierarchy);
if (!conf->enable_colors || arguments.no_colors)
cprintf = uncoloredprintf;
else
cprintf = coloredprintf;
if (arguments.rebuild_cache)
cache_build(repositories);
packages = packages_list_init();
if ((ports_list = ports_list_init(repositories)) == NULL) {
list_free(arguments.args, NULL);
dict_free(repositories, repository_free);
list_free(packages, port_free);
list_free(drivers, free);
dict_free(conf->favourite_repositories, free);
conf->favourite_repositories = dict_new();
conf_free(conf);
return 1;
}
conf_reparse(conf, ports_list);
ports_dict = ports_dict_init(ports_list, packages, conf);
not_founds = dict_new();
if (!arguments.verbose)
arguments.verbose = conf->verbose;
switch (arguments.action) {
case ACT_LIST:
if (!arguments.args->length) {
list_dump(ports_list, port_dump);
break;
}
for (i = 0; i < arguments.args->length; i++) {
if (dict_get(repositories, list_get(arguments.args, i))
== NULL) {
warning("repository %s not found!",
list_get(arguments.args, i));
continue;
}
list = list_query(ports_list,
port_query_by_repository,
list_get(arguments.args, i));
list_dump(list, port_dump);
list_free(list, NULL);
}
break;
case ACT_SEARCH:
if (!arguments.args->length) {
warning("action --search (-s) requires at least an "
"argument!");
break;
}
for (i = 0; i < arguments.args->length; i++) {
list = list_query(ports_list, port_query_by_name,
list_get(arguments.args, i));
if (arguments.verbose)
list_dump(list, port_info_dump);
else
list_dump(list, port_dump);
if (list->length == 0)
printf("%s not found!\n",
(char *)list_get(arguments.args, i));
list_free(list, NULL);
}
break;
case ACT_SEARCHDESC:
if (!arguments.args->length) {
warning("action --search-desc requires at least an "
"argument!");
break;
}
for (i = 0; i < arguments.args->length; i++) {
char *key = xstrdup(list_get(arguments.args, i));
if (isalpha(*key) && isalpha(*(key + strlen(key) - 1))) {
strprepend(&key, "*");
strappend(&key, "*");
}
list = list_query(ports_list, port_query_by_description,
key);
if (arguments.verbose)
list_dump(list, port_info_dump);
else
list_dump(list, port_dump);
list_free(list, NULL);
free(key);
}
break;
case ACT_DIFF:
port_show_diffs(ports_dict, packages);
break;
case ACT_UPDATED:
port_show_outdated(ports_dict, packages);
break;
case ACT_DEPENDENCIES:
if (!arguments.args->length) {
warning("action --dependencies (-D) requires at "
"least an argument!");
break;
}
//for (i = 0; i < arguments.args->length; i++)
dependencies_dump(arguments.args,
ports_dict, conf->aliases,
not_founds,
arguments.tree, arguments.verbose);
break;
case ACT_DEPENDENTS:
if (!arguments.args->length) {
warning("action --dependents (-T) requires at "
"least an argument!");
break;
}
for (i = 0; i < arguments.args->length; i++)
dependents_dump(list_get(arguments.args, i),
ports_dict, conf->aliases,
arguments.tree, arguments.verbose,
arguments.all);
break;
case ACT_INFO:
if (!arguments.args->length) {
warning("action --info requires at "
"least an argument!");
break;
}
for (i = 0; i < arguments.args->length; i++)
info_dump(list_get(arguments.args, i), ports_dict);
break;
case ACT_README:
if (!arguments.args->length) {
warning("action --show-readme requires at "
"least an argument!");
break;
}
for (i = 0; i < arguments.args->length; i++)
readme_dump(list_get(arguments.args, i), ports_dict);
break;
case ACT_REPOSITORY_LIST:
repositories_dict_dump(repositories);
break;
case ACT_UPDATE:
if (arguments.args->length)
repositories_dict_update(repositories, arguments.args);
else
repositories_dict_update_all(repositories);
break;
case ACT_REMOVE:
if (!arguments.args->length) {
warning("action --remove (-R) requires at "
"least an argument!");
break;
}
remove_packages(arguments.args, packages, ports_dict, conf,
arguments.all);
break;
case ACT_UPDATE_PKG:
if (!arguments.args->length) {
update_system(ports_dict,
conf->aliases, arguments.fetch_only,
conf->ask_for_update,
conf->not_found_policy);
break;
}
update_package(arguments.args, ports_dict, conf,
arguments.fetch_only);
break;
default:
if (!arguments.rebuild_cache)
warning("What can I do for you?");
}
list_free(arguments.args, NULL);
dict_free(repositories, repository_free);
list_free(ports_list, port_free);
list_free(packages, port_free);
dict_free(ports_dict, NULL);
list_free(drivers, free);
conf_free(conf);
dict_free(not_founds, port_free);
return 0;
}
// ------------------------------------------------------------------------------------------------
int main (int argc, char **argv)
// ------------------------------------------------------------------------------------------------
{
int i, nbytes;
// unsolicited termination handling
struct sigaction sa;
// Catch all signals possible on process exit!
for (i = 1; i < 64; i++)
{
// skip SIGUSR2 for Wiring Pi
if (i == 17)
continue;
// These are uncatchable or harmless or we want a core dump (SEGV)
if (i != SIGKILL
&& i != SIGSEGV
&& i != SIGSTOP
&& i != SIGVTALRM
&& i != SIGWINCH
&& i != SIGPROF)
{
memset(&sa, 0, sizeof(sa));
sa.sa_handler = terminate;
sigaction(i, &sa, NULL);
}
}
// Set argument defaults
init_args(&arguments);
// Parse arguments
argp_parse (&argp, argc, argv, 0, 0, &arguments);
if (arguments.print_long_help)
{
print_long_help();
return 0;
}
if (!arguments.usbacm_device)
{
arguments.usbacm_device = strdup("/dev/ttyACM2");
}
if (!arguments.serial_device)
{
arguments.serial_device = strdup("/var/ax25/axp2");
}
if (!arguments.bulk_filename)
{
arguments.bulk_filename = strdup("-");
}
set_serial_parameters(&serial_parms_ax25, arguments.serial_device, get_serial_speed(arguments.serial_speed, &arguments.serial_speed_n));
set_serial_parameters(&serial_parms_usb, arguments.usbacm_device, get_serial_speed(115200, &arguments.usb_speed_n));
init_radio_parms(&radio_parms, &arguments);
if (arguments.verbose_level > 0)
{
print_args(&arguments);
print_radio_parms(&radio_parms);
fprintf(stderr, "\n");
}
if (arguments.tnc_mode == TNC_KISS)
{
kiss_init(&arguments);
kiss_run(&serial_parms_ax25, &serial_parms_usb, &radio_parms, &arguments);
}
else if (arguments.tnc_mode == TNC_SLIP)
{
arguments.slip = 1;
kiss_init(&arguments);
kiss_run(&serial_parms_ax25, &serial_parms_usb, &radio_parms, &arguments);
}
else if (arguments.tnc_mode == TNC_TEST_USB_ECHO) // This one does not need any access to the radio
{
usb_test_echo(&serial_parms_usb, &arguments);
}
else if (arguments.tnc_mode == TNC_RADIO_STATUS)
{
print_radio_status(&serial_parms_usb, &arguments);
}
else if (arguments.tnc_mode == TNC_RADIO_INIT)
{
init_radio(&serial_parms_usb, &radio_parms, &arguments);
if (nbytes < 0)
{
fprintf(stderr, "Error\n");
}
}
else if (arguments.tnc_mode == TNC_TEST_TX)
{
radio_transmit_test(&serial_parms_usb, &radio_parms, &arguments);
}
else if (arguments.tnc_mode == TNC_TEST_RX)
{
radio_receive_test(&serial_parms_usb, &radio_parms, &arguments);
}
else if (arguments.tnc_mode == TNC_TEST_ECHO_TX)
{
radio_echo_test(&serial_parms_usb, &radio_parms, &arguments, 1);
}
else if (arguments.tnc_mode == TNC_TEST_ECHO_RX)
{
radio_echo_test(&serial_parms_usb, &radio_parms, &arguments, 0);
}
else if (arguments.tnc_mode == TNC_TEST_TX_PACKET)
{
radio_packet_transmit_test(&serial_parms_usb, &radio_parms, &arguments);
}
else if (arguments.tnc_mode == TNC_TEST_RX_PACKET)
{
radio_packet_receive_test(&serial_parms_usb, &radio_parms, &arguments);
}
else if (arguments.tnc_mode == TNC_TEST_RX_PACKET_NON_BLOCKING)
{
radio_packet_receive_nb_test(&serial_parms_usb, &radio_parms, &arguments);
}
else if (arguments.tnc_mode == TNC_BULK_TX)
{
file_bulk_transmit(&serial_parms_usb, &radio_parms, &arguments);
}
else if (arguments.tnc_mode == TNC_BULK_RX)
{
file_bulk_receive(&serial_parms_usb, &radio_parms, &arguments);
}
close_serial(&serial_parms_usb);
close_serial(&serial_parms_ax25);
delete_args(&arguments);
return 0;
}
int main( int argc, char *argv[] )
{
struct structArgs cmdArgs;
unsigned int val, val2;
int dir;
int errNum;
cmdArgs.card = 0; // Default card.
cmdArgs.control = 1; // Default control.
// ************************************************************************
// ALSA control elements.
// ************************************************************************
snd_pcm_t *pcmp;
snd_pcm_hw_params_t *params;
// snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
snd_pcm_stream_t stream = SND_PCM_STREAM_CAPTURE;
snd_pcm_uframes_t frames;
// ************************************************************************
// Get command line parameters.
// ************************************************************************
argp_parse( &argp, argc, argv, 0, 0, &cmdArgs );
printf( "Card = %i\n", cmdArgs.card );
printf( "Control = %i\n", cmdArgs.control );
sprintf( cmdArgs.deviceID, "hw:%i,%i", cmdArgs.card, cmdArgs.control );
printf( "Using device %s :", cmdArgs.deviceID );
/* Allocate a hardware parameters object. */
if ( snd_pcm_hw_params_alloca( ¶ms ) < 0 )
{
fprintf( stderr, "Unable to allocate.\n" );
return -1;
}
/* Open PCM device for playback. */
// if ( snd_pcm_open( &pcmp, cmdArgs.deviceID, stream, 0 ) < 0 )
// {
// fprintf( stderr, "Unable to open pcm device.\n" );
// return -1;
// }
/* Fill it in with default values. */
// if ( snd_pcm_hw_params_any( pcmp, params ) < 0
// {
// fprintf( stderr, "Unable to set default values.\n" );
// return -1;
// }
/* Interleaved mode */
// snd_pcm_hw_params_set_access( pcmp, params,
// SND_PCM_ACCESS_RW_INTERLEAVED );
/* Signed 16-bit little-endian format */
snd_pcm_hw_params_set_format( pcmp, params,
SND_PCM_FORMAT_S16_LE );
/* Two channels (stereo) */
snd_pcm_hw_params_set_channels( pcmp, params, 2 );
/* 44100 bits/second sampling rate (CD quality) */
val = 44100;
snd_pcm_hw_params_set_rate_near( pcmp, params, &val, &dir );
/* Write the parameters to the driver */
errNum = snd_pcm_hw_params( pcmp, params );
if ( errNum < 0 )
{
fprintf(stderr, "unable to set hw parameters: %s\n",
snd_strerror( errNum ));
exit( 1 );
}
/* Display information about the PCM interface */
printf( "PCM handle name = '%s'\n", snd_pcm_name( pcmp ));
printf("PCM state = %s\n", snd_pcm_state_name( snd_pcm_state( pcmp )));
snd_pcm_hw_params_get_access( params, ( snd_pcm_access_t * ) &val );
printf( "access type = %s\n",
snd_pcm_access_name(( snd_pcm_access_t ) val ));
snd_pcm_hw_params_get_format( params, ( snd_pcm_format_t * ) &val );
printf( "format = '%s' (%s)\n",
snd_pcm_format_name(( snd_pcm_format_t ) val ),
snd_pcm_format_description(( snd_pcm_format_t ) val ));
snd_pcm_hw_params_get_subformat( params,
( snd_pcm_subformat_t * ) &val );
printf( "subformat = '%s' (%s)\n",
snd_pcm_subformat_name(( snd_pcm_subformat_t ) val ),
snd_pcm_subformat_description((
snd_pcm_subformat_t ) val ));
snd_pcm_hw_params_get_channels( params, &val );
printf( "channels = %d\n", val );
snd_pcm_hw_params_get_rate( params, &val, &dir );
printf( "rate = %d bps\n", val );
snd_pcm_hw_params_get_period_time( params, &val, &dir );
printf( "period time = %d us\n", val );
snd_pcm_hw_params_get_period_size( params, &frames, &dir );
printf( "period size = %d frames\n", ( int ) frames );
snd_pcm_hw_params_get_buffer_time( params, &val, &dir );
printf( "buffer time = %d us\n", val );
snd_pcm_hw_params_get_buffer_size( params,
( snd_pcm_uframes_t * ) &val );
printf( "buffer size = %d frames\n", val );
snd_pcm_hw_params_get_periods( params, &val, &dir );
printf( "periods per buffer = %d frames\n", val );
snd_pcm_hw_params_get_rate_numden( params, &val, &val2 );
printf( "exact rate = %d/%d bps\n", val, val2 );
val = snd_pcm_hw_params_get_sbits( params );
printf( "significant bits = %d\n", val );
// snd_pcm_hw_params_get_tick_time( params, &val, &dir );
// printf( "tick time = %d us\n", val );
val = snd_pcm_hw_params_is_batch( params );
printf( "is batch = %d\n", val );
val = snd_pcm_hw_params_is_block_transfer( params );
printf( "is block transfer = %d\n", val );
val = snd_pcm_hw_params_is_double( params );
printf( "is double = %d\n", val );
val = snd_pcm_hw_params_is_half_duplex( params );
printf( "is half duplex = %d\n", val );
val = snd_pcm_hw_params_is_joint_duplex( params );
printf( "is joint duplex = %d\n", val );
val = snd_pcm_hw_params_can_overrange( params );
printf( "can overrange = %d\n", val );
val = snd_pcm_hw_params_can_mmap_sample_resolution( params );
printf( "can mmap = %d\n", val );
val = snd_pcm_hw_params_can_pause( params );
printf( "can pause = %d\n", val );
val = snd_pcm_hw_params_can_resume( params );
printf( "can resume = %d\n", val );
val = snd_pcm_hw_params_can_sync_start( params );
printf( "can sync start = %d\n", val );
snd_pcm_close( pcmp );
return 0;
}
int main (int argc, char* argv[])
{
// Create our single-loop for this single-thread application
EV_P;
pthread_attr_t attr;
int thread_status;
struct evn_server* server;
char socket_address[256];
EV_A = ev_default_loop(0);
// Set default options, then parse new arguments to update the settings
dummy_settings_set_presets(&dummy_settings);
argp_parse (&argp, argc, argv, 0, 0, &dummy_settings);
// TODO separate worker settings from daemon settings
// (i.e. redirect)
if (true == redirect)
{
redirect_output();
}
if (0)
{
struct ev_periodic every_few_seconds;
// To be sure that we aren't actually blocking
ev_periodic_init(&every_few_seconds, test_process_is_not_blocked, 0, 1, 0);
ev_periodic_start(EV_A_ &every_few_seconds);
}
// Set the priority of this whole process higher (requires root)
setpriority(PRIO_PROCESS, 0, -13); // -15
// initialize the values of the struct that we will be giving to the new thread
thread_control.dummy_settings = &dummy_settings;
thread_control.buffer_head = 0;
thread_control.buffer_count = 0;
thread_control.EV_A = ev_loop_new(EVFLAG_AUTO);
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
// Initialize the thread that will manage the DUMMY_WORKER
thread_status = pthread_create(&dummy_worker_pthread, &attr, dummy_worker_thread, (void *)(&thread_control));
if (0 != thread_status)
{
fprintf(stderr, "thread creation failed with errno %d (%s)\n", thread_status, strerror(thread_status));
exit(EXIT_FAILURE);
}
pthread_attr_destroy(&attr);
// Create unix socket in non-blocking fashion
snprintf(socket_address, sizeof(socket_address), DUMMYD_SOCK, (int)getuid());
unlink(socket_address);
server = evn_server_create(EV_A_ server_on_connection);
server->on_connection = server_on_connection;
evn_server_listen(server, 0, socket_address);
// Run our loop, until we recieve the QUIT, TERM or INT signals, or an 'x' over the socket.
puts("[Daemon] Looping.\n");
ev_loop(EV_A_ 0);
// Cleanup if `unloop` is ever called
clean_shutdown(EV_A_ 0);
return 0;
}
int main(int argc, char **argv)
{
struct arguments arguments;
int sockfd, n;
struct sockaddr_in serv_addr;
struct hostent *server;
char buffer[1028];
int result_size = 1028;
char* result;
char* command;
// Default values.
arguments.verbose = 0;
arguments.port_number = 5002;
arguments.addr = "localhost";
// Parse our arguments; every option seen by parse_opt will be reflected in arguments.
argp_parse (&argp, argc, argv, 0, 0, &arguments);
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
error("ERROR opening socket");
}
server = gethostbyname(arguments.addr);
if (server == NULL) {
error("ERROR, no such host");
}
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char *)server->h_addr,
(char *)&serv_addr.sin_addr.s_addr,
server->h_length);
serv_addr.sin_port = htons(arguments.port_number);
if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0) {
error("ERROR connecting");
}
command = build_command(arguments.args);
if (write(sockfd, command, strlen(command)) < 0) {
error("ERROR writing to socket");
}
result = "";
while ((n = read(sockfd, buffer, 1027))) {
buffer[n] = '\0';
result = concat(result, "", buffer);
}
printf("%s\n", result);
if (command) {
free(command);
}
if (result) {
free(result);
}
return 0;
}
int main(int argc, char** argv){
int seed = getpid();
int c;
int option_index = 0;
int league_id;
int num_players;
struct argp_option options[] = {
{"seed",'s', "int", 0, 0},
{"league-id", 'l', "int", 0, 0},
{"players", 'n', "int", 0, 0},
{"hitter-mean",'h', "double", 0, 0},
{"hitter-sd", 'i', "double", 0, 0},
{"pitcher-mean", 'p', "double", 0, 0},
{"pitcher-sd", 'r', "double", 0, 0},
{0}
};
struct arguments args = {&seed, &league_id, &num_players, &HITTER_MEAN,
&HITTER_SD, &PITCHER_MEAN, &PITCHER_SD};
struct argp argp = {options, arg_parser, 0, 0, global_child};
argp_parse(&argp, argc, argv, 0, 0, &args);
#ifdef _USEGSL_
gsl_rng_env_setup();
const gsl_rng_type *type = gsl_rng_default;
rng = gsl_rng_alloc(type);
gsl_rng_set(rng,seed);
#else
srand(seed);
#endif
Db_Object db = db_connect(CONFIG_FILE);
db->begin_transaction(db->conn);
fprintf(stderr,"Seed: %d\n",seed);
Array_List first_names = Array_List_create(sizeof(char*));
Array_List last_names = Array_List_create(sizeof(char*));
select_names(db,first_names,last_names);
int i;
struct player new_player;
struct hitter_skill hitter_skill;
struct pitcher_skill pitcher_skill;
struct fielder_skill fielder_skill;
for(i=0;i<num_players;i++){
int power= random_normal(HITTER_MEAN,HITTER_SD,MIN_SKILL,MAX_SKILL);
int contact = random_normal(HITTER_MEAN,HITTER_SD,MIN_SKILL,MAX_SKILL);
int fielding = random_normal(HITTER_MEAN,HITTER_SD,MIN_SKILL,MAX_SKILL);
int speed = random_normal(HITTER_MEAN,HITTER_SD,MIN_SKILL,MAX_SKILL);
int intelligence = random_normal(HITTER_MEAN,HITTER_SD,MIN_SKILL,MAX_SKILL);
int control = random_normal(PITCHER_MEAN,PITCHER_SD,MIN_SKILL,MAX_SKILL);
int movement = random_normal(PITCHER_MEAN,PITCHER_SD,MIN_SKILL,MAX_SKILL);
int velocity = random_normal(PITCHER_MEAN,PITCHER_SD,MIN_SKILL,MAX_SKILL);
int endurance = 0;
int bats = (rand()%100)+1;
int throws = (rand()%100)+1;
int position = rand()%18;
/*TODO: Make the choosing of names random.*/
int first_name = 8 * (power + contact + fielding + speed + bats) % first_names->length;
int last_name = 8 * (first_name + speed + intelligence + control + movement + velocity + bats + throws + control + movement + position) % last_names->length;
if(throws <= PERCENT_THROW_RIGHT){
new_player.throws = RIGHT;
}
else{
new_player.throws = LEFT;
}
if(bats<= PERCENT_HIT_SAME){
new_player.bats = new_player.throws;
}
else if(bats<PERCENT_HIT_SAME+PERCENT_HIT_DIFFERENT){
if(new_player.throws == RIGHT){
new_player.bats = LEFT;
}
else{
new_player.bats = RIGHT;
}
}
else{
new_player.bats = SWITCH;
}
if(position <= 9 && position > 1){
new_player. position = position;
pitcher_skill.end = random_normal(30.0,PITCHER_SD*SD_TWEAK,0,49);
}
else if(position>=15 || position == 1){
new_player.position =1;
pitcher_skill.end = random_normal(80.0,PITCHER_SD*SD_TWEAK,50,100);
}
else{
new_player.position = 0;
pitcher_skill.end = random_normal(30.0,PITCHER_SD*SD_TWEAK,0,49);
}
int vs_right_mod = 5;
int vs_left_mod = 5;
if(new_player.bats == RIGHT){
vs_right_mod = -5;
}
if(new_player.bats ==LEFT){
vs_left_mod = -5;
}
new_player.first_name = gget(first_names,first_name);
new_player.last_name = gget(last_names,last_name);
hitter_skill.cvr = calc_skill(contact+vs_right_mod,HITTER_SD);
hitter_skill.pvr = calc_skill(power+vs_right_mod,HITTER_SD);
hitter_skill.cvl = calc_skill(contact+vs_left_mod,HITTER_SD);
hitter_skill.pvl = calc_skill(power+vs_left_mod,HITTER_SD);
hitter_skill.spd = speed;
fielder_skill.range = calc_skill(fielding,HITTER_SD);
fielder_skill.arm = calc_skill(fielding,HITTER_SD);
fielder_skill.field = calc_skill(fielding,HITTER_SD);
new_player.intelligence = intelligence;
pitcher_skill.mov = calc_skill(movement,PITCHER_SD);
pitcher_skill.vel = calc_skill(velocity,PITCHER_SD);
pitcher_skill.ctrl = calc_skill(control,PITCHER_SD);
insert_player(db,&new_player,&hitter_skill,&pitcher_skill,&fielder_skill,league_id);
}
db->commit(db->conn);
db->close_connection(db->conn);
#ifdef _USEGSL_
gsl_rng_free(rng);
#endif
return 0;
}
int
mutool_acl (int argc, char **argv)
{
int rc, index;
mu_acl_result_t result;
mu_cfg_tree_t *tree = NULL, *temp_tree = NULL;
mu_cfg_node_t *node;
if (argp_parse (&acl_argp, argc, argv, ARGP_IN_ORDER, &index, NULL))
return 1;
argc -= index;
argv += index;
if (argc == 0)
{
mu_error (_("not enough arguments"));
return 1;
}
if (input_file_name)
{
mu_load_site_rcfile = 0;
mu_load_user_rcfile = 0;
mu_load_rcfile = input_file_name;
}
mu_acl_cfg_init ();
if (mu_libcfg_parse_config (&tree))
return 1;
if (!tree)
return 0;
if (mu_cfg_find_node (tree, path, &node))
{
mu_error (_("cannot find node: %s"), path);
return 1;
}
mu_cfg_tree_create (&temp_tree);
mu_cfg_tree_add_node (temp_tree, node);
rc = mu_cfg_tree_reduce (temp_tree, NULL, acl_cfg_param, NULL);
if (rc)
return 1;
if (!acl)
{
mu_error (_("No ACL found in config"));
return 1;
}
while (argc--)
{
const char *ap = *argv++;
rc = mu_sockaddr_from_node (&target_sa, ap, NULL, NULL);
if (rc)
{
mu_error ("mu_sockaddr_from_node: %s", mu_strerror (rc));
exit (1);
}
mu_printf ("Testing %s:\n", ap);
rc = mu_acl_check_sockaddr (acl, target_sa->addr, target_sa->addrlen,
&result);
mu_sockaddr_free_list (target_sa);
if (rc)
{
mu_error ("mu_acl_check_sockaddr failed: %s", mu_strerror (rc));
return 1;
}
switch (result)
{
case mu_acl_result_undefined:
mu_printf ("%s: undefined\n", ap);
break;
case mu_acl_result_accept:
mu_printf ("%s: accept\n", ap);
break;
case mu_acl_result_deny:
mu_printf ("%s: deny\n", ap);
break;
}
}
mu_cfg_destroy_tree (&tree);
mu_cfg_destroy_tree (&temp_tree);
return 0;
}
int
main (int ac, char *ag[])
{
int index;
pth_init ();
argp_parse (&argp, ac, ag, ARGP_IN_ORDER, &index, &arg);
// if you ever want this to be fatal, doing it here would be too late
if (getuid () == 0)
ERRORPRINTF (arg.tracer(), E_WARNING | 20, 0, "EIBD should not run as root");
signal (SIGPIPE, SIG_IGN);
if (arg.daemon)
{
int fd = open (arg.daemon, O_WRONLY | O_APPEND | O_CREAT, FILE_MODE);
if (fd == -1)
die ("Can not open file %s", arg.daemon);
int i = fork ();
if (i < 0)
die ("fork failed");
if (i > 0)
exit (0);
close (1);
close (2);
close (0);
dup2 (fd, 1);
dup2 (fd, 2);
close (fd);
setsid ();
}
FILE *pidf;
if (arg.pidfile)
if ((pidf = fopen (arg.pidfile, "w")) != NULL)
{
fprintf (pidf, "%d", getpid ());
fclose (pidf);
}
signal (SIGINT, SIG_IGN);
signal (SIGTERM, SIG_IGN);
// main loop
#ifdef HAVE_SYSTEMD
sd_notify(0,"READY=1");
#endif
int sig;
if (! arg.stop_now)
do {
sigset_t t1;
sigemptyset (&t1);
sigaddset (&t1, SIGINT);
sigaddset (&t1, SIGHUP);
sigaddset (&t1, SIGTERM);
pth_sigwait (&t1, &sig);
if (sig == SIGHUP && arg.daemon)
{
int fd =
open (arg.daemon, O_WRONLY | O_APPEND | O_CREAT, FILE_MODE);
if (fd == -1)
{
ERRORPRINTF (arg.tracer(), E_ERROR | 21, 0, "can't open log file %s",
arg.daemon);
continue;
}
close (1);
close (2);
dup2 (fd, 1);
dup2 (fd, 2);
close (fd);
}
} while (sig == SIGHUP);
#ifdef HAVE_SYSTEMD
sd_notify(0,"STOPPING=1");
#endif
signal (SIGINT, SIG_DFL);
signal (SIGTERM, SIG_DFL);
#ifdef HAVE_GROUPCACHE
DeleteGroupCache ();
#endif
arg.free_l3();
if (arg.pidfile)
unlink (arg.pidfile);
pth_yield (0);
pth_yield (0);
pth_yield (0);
pth_yield (0);
pth_exit (0);
return 0;
}
static int do_exec_cmd_ent(struct cmdctx *cmdctx, int argc, char **argv)
{
int rc = 1;
unsigned parse_flags;
struct poclidek_cmd *cmd = cmdctx->cmd;
struct argp cmd_argp = { cmd->argp_opts, cmd->parse_opt_fn,
cmd->arg,
cmd->doc, 0, 0, 0};
struct argp_child cmd_argp_child[2] = { { &cmd_argp, 0, NULL, 0 },
{ NULL, 0, NULL, 0 }, };
struct argp argp = { common_options, parse_opt, 0, 0,
cmd_argp_child, 0, 0 };
if (argv == NULL)
return 0;
cmd = cmdctx->cmd;
if (poclidek_argv_is_help(argc, (const char**)argv)) {
cmdctx->rtflags |= CMDCTX_ISHELP;
DBGF("is_help!\n");
}
if (poldek_verbose() < 0)
cmdctx->rtflags |= CMDCTX_NOCTRLMSGS;
cmdctx->_data = NULL;
if (cmd->init_cmd_arg_d)
cmdctx->_data = cmd->init_cmd_arg_d();
if (cmd->cmd_fn) { /* option parses its args itself */
DBGF("run cmd_fn(arc, argv)\n");
rc = cmd->cmd_fn(cmdctx, argc, (const char**)argv, &argp);
goto l_end;
}
if ((cmd->flags & COMMAND_NOHELP) && (cmd->flags & COMMAND_NOARGS) &&
(cmd->flags & COMMAND_NOOPTS)) {
rc = cmd->do_cmd_fn(cmdctx);
goto l_end;
}
argp.help_filter = help_filter;
parse_flags = argp_parse_flags;
argp_parse(&argp, argc, (char**)argv, parse_flags, 0, cmdctx);
if (cmdctx->rtflags & CMDCTX_ERR) {
rc = 0;
goto l_end;
}
if (cmdctx->rtflags & CMDCTX_ISHELP) {
rc = 1;
goto l_end;
}
rc = cmd->do_cmd_fn(cmdctx);
l_end:
if (cmd->destroy_cmd_arg_d && cmdctx->_data)
cmd->destroy_cmd_arg_d(cmdctx->_data);
return rc;
}
int main (int argc, char **argv)
{
struct arguments arguments;
/* Parse our arguments; every option seen by parse_opt will
be reflected in arguments. */
argp_parse (&argp, argc, argv, 0, 0, &arguments);
// number of nearest neighbors
int k;
k = 1; //default is 1
if (sscanf (arguments.args[0], "%i", &k)!=1) {}
//omp vars
int num_threads;
num_threads = 4;
if (sscanf(arguments.args[1], "%i", &num_threads)!=1) {}
//verbose?
int verbose;
verbose = arguments.verbose;
if (verbose>0 && verbose<130){
verbose = 1;
}
else{
verbose = 0;
}
//define a bunch of counters!
int i, j, m, n, ii, jj, kk;
//number of examples to read in
int total_examples = 10000;
// int total_examples = 19;
//max words per question
int num_words = 300;
//max word length
int max_word_len = 20;
//max vocab count
// int max_vocab = 200000;
//data read in poorly
int bad_iter = 0;
//Used to split into training and testing data (will train on example_num%train)
int train = 10;
//Debug
int debug = 0;
printf("k, Verbose, num_threads = %i, %i, %i\n",
k, verbose, num_threads);
//Allocate space for data being read in with fgets
char *csv_line = malloc(sizeof(char)*1500);
//store all data
//array of structs
//struct.question->array of char*
//struct.cat->char*
//struct.example_num->int
struct data *all_data;
all_data = malloc(sizeof(struct data)*total_examples);
for (ii=0; ii<total_examples; ii++){
all_data[ii].question = malloc(sizeof(char*)*num_words);
for (jj=0; jj<num_words; jj++){
// all_data[ii].question[jj] = malloc(sizeof(char)*max_word_len);
all_data[ii].question[jj] = calloc(max_word_len, sizeof(char));
}
all_data[ii].cat = malloc(sizeof(char)*max_word_len);
}
//store numeric version of data for algorithms
struct numeric_data *num_data;
num_data = malloc(sizeof(struct numeric_data)*total_examples);
for (ii=0; ii<total_examples; ii++){
num_data[ii].array_of_features = malloc(sizeof(struct feature_count)*num_words);
for (jj=0; jj<num_words; jj++){
num_data[ii].array_of_features[jj].feature_num = 0;
num_data[ii].array_of_features[jj].count = 0;
}
}
//store struct which keep track of the k nearest neighbors
// struct distance_results results;
// results.example_num = 0;
// results.distances = calloc(k, sizeof(double));
// results.cat = calloc(k, sizeof(int));
// results.example_nums = calloc(k, sizeof(int));
// //struct used to calculate the mode of the k nearest neighbors
// struct mode mod;
// mod.count = calloc(k, sizeof(int));
// mod.cat = calloc(k, sizeof(int));
// //store vocabulary list (char** points to array of char* of length 20)
// char **word_list;
// word_list = malloc(sizeof(char*)*max_vocab); //assumes max_vocab total vocab
// for (ii=0; ii<max_vocab; ii++){
// // word_list[ii] = malloc(sizeof(char)*max_word_len); //assumes max word length of 20
// word_list[ii] = calloc(max_word_len, sizeof(char)); //assumes max word length of 20
// }
//alternate vocab store tree
feature_tree *vocab;
vocab = NULL;
//store category list
char **cat_list;
cat_list = malloc(sizeof(char*)*40); //assumes 20 max categories
for (ii=0; ii<40; ii++){
cat_list[ii] = malloc(sizeof(char)*max_word_len);
strncpy(cat_list[ii], "\0", 1);
}
//Read in csv file
FILE *f = fopen("train_pruned2.csv", "r");
if (f == NULL){
printf("Failed to open file \n");
return -1;
}
//parse question into individual words, create vocabulary list
int vocab_count = 0;
int category_count = 1;
for (i=0; i<total_examples; i++){
// printf("Iteration = %i\n", i);
//line in csv to buffer
if (fgets(csv_line, 1500, f) == NULL){
printf("Fgets error!\n");
exit(0);
}
//csv line to 3 individual parts
if (i>0)
{
char *tok;
char *tok_copy; //problem with tok getting overwritten in parse_question
// char **parsed_question = malloc(sizeof(char*)*num_words);
// printf("CSV_LINE = %s\n", csv_line);
tok = strtok(csv_line, "|");
if (tok == NULL){
// all_data[i-bad_iter-1].example_num = -1;
bad_iter++;
// i--;
continue;
}
sscanf(tok, "%i", &all_data[i-bad_iter-1].example_num);
tok = strtok(NULL, "|");
if (tok == NULL){
// all_data[i-bad_iter-1].example_num = -1;
bad_iter++;
// i--;
continue;
}
tok_copy = (char *)tok;
tok = strtok(NULL, "|");
if (tok == NULL){
// all_data[i-bad_iter-1].example_num = -1;
bad_iter++;
// i--;
continue;
}
strncpy(all_data[i-bad_iter-1].cat, tok, 19);
all_data[i-bad_iter-1].cat[max_word_len-1] = 0;
char *tok2;
tok2 = strtok(tok_copy, " \t");
j = 0;
if ((tok2 != NULL) && (strlen(tok2)>3)){
strncpy(all_data[i-bad_iter-1].question[0], tok2, 19);
all_data[i-bad_iter-1].question[0][max_word_len-1] = 0;
//add to tree if not test data
// if (all_data[i-bad_iter-1].example_num % train != 0){
insert_word(&vocab, all_data[i-bad_iter-1].question[0]);
j += 1;
// }
}
while (tok2 != NULL){
if (j>=num_words){
break;
}
tok2 = strtok(NULL, " \t");
if ((tok2 != NULL) && (strlen(tok2)>3)){
strncpy(all_data[i-bad_iter-1].question[j], tok2, 19);
all_data[i-bad_iter-1].question[j][max_word_len-1] = 0;
//add to tree if not test data
// if (all_data[i-bad_iter-1].example_num % train != 0){
insert_word(&vocab, all_data[i-bad_iter-1].question[j]);
j++;
// }
}
} //end while
// all_data[i-bad_iter-1] = instance;
// print_data(&all_data[i-bad_iter-1]);
////add to vocabulary (using array, VERY slow with lots of data)
// add_to_word_list(all_data[i-bad_iter-1].question, word_list, &vocab_count);
//add to category list
add_to_cat_list(all_data[i-bad_iter-1].cat, cat_list, &category_count);
} //end if
} //end for
//close file
fclose(f);
//assign unique number to each feature
//first feature is feature 1, feature 0 is for errors etc.
unsigned int mm = 1;
number_features(vocab, &mm);
//Some of the csv rows aren't read in properly with fgets
printf("Bad iterations = %i/%i\n", bad_iter, i);
printf("Feature count = %i\n", count_features(vocab));
// print_inorder(vocab);
// for (ii=0; ii<40; ii++){
// printf("%s", cat_list[ii]);
// }
////turn data into numeric features////
for (i=0; i<total_examples; i++){
num_data[i].example_num = all_data[i].example_num;
num_data[i].cat = get_cat_index(cat_list, all_data[i].cat);
words_to_num(&num_data[i], &all_data[i], &vocab, num_words);
// count_features2(&num_data[i]);
}
// num_data->array_of_features[0].feature_num = 44;
// print_num_data(&num_data[0]);
// print_num_data(&num_data[1]);
total_examples = total_examples-bad_iter-1;
int sadfjh;
double av_feature_count = 0;
for (ii=0; ii<total_examples; ii++){
sadfjh = count_features2(&num_data[ii]);
av_feature_count += sadfjh;
// printf("%i ", sadfjh);
}
// printf("\n av_feature_count %f\n", av_feature_count/(total_examples-bad_iter-1));
// print_num_data(&num_data[4464]);
// printf("vocab->right = %s \n", vocab->feature);
// print_data(&all_data[0]);
// print_data(&all_data[29000]);
// printf("%s, %u\n", "1829", get_feature_number(&vocab, "1829"));
//find the distance between first example and rest
double distance;
//range each process will cover
int range;
// printf("%i, %i\n", range, total_examples);
// printf("R, Min, Max = %i, %i, %i\n", rank, rank*range, (rank+1)*range);
// struct distance_results results;
// results.example_num = 0;
// results.distances = calloc(k, sizeof(double));
// results.cat = calloc(k, sizeof(int));
// results.example_nums = calloc(k, sizeof(int));
// //struct used to calculate the mode of the k nearest neighbors
// struct mode mod;
// mod.count = calloc(k, sizeof(int));
// mod.cat = calloc(k, sizeof(int));
//correct/total/answer
int c = 0;
int total = 0;
int answer;
omp_set_dynamic(0); //Explicitly disable dynamic teams
omp_set_num_threads(num_threads); //Specify thread count
#pragma omp parallel \
private(kk, ii, distance, answer) \
reduction(+:c,total) \
shared(num_data)
{
//store struct which keep track of the k nearest neighbors
struct distance_results results;
results.example_num = 0;
results.distances = calloc(k, sizeof(double));
results.cat = calloc(k, sizeof(int));
results.example_nums = calloc(k, sizeof(int));
//struct used to calculate the mode of the k nearest neighbors
struct mode mod;
mod.count = calloc(k, sizeof(int));
mod.cat = calloc(k, sizeof(int));
#pragma omp for
for (kk=0; kk<total_examples; kk++){
// printf("Thread = %i, Iter = %i, c = %i, total=%i\n", omp_get_thread_num(), kk, c, total);
//only test on test data
if (num_data[kk].example_num%train != 0){
continue;
}
if (num_data[kk].cat == 0){
continue;
}
results.correct_answer = num_data[kk].cat;
results.example_num = num_data[kk].example_num;
for (ii=0; ii<k; ii++){
results.distances[ii] = 0;
results.cat[ii] = 0;
mod.count[ii] = 0;
mod.cat[ii] = 0;
}
// print_num_data(&num_data[kk]);
//calc distance to neighbors
for (ii=0; ii<total_examples-1; ii++){
//don't calc distance to self
if (kk != ii){
//Eliminate bad data (examples with few words tend to have low distances
//reguardless of whether they are more similar...
if (num_data[ii].total_features >= 40){
distance = get_distance(&num_data[kk], &num_data[ii], num_words);
// if (distance < 2){
// continue;
// }
// printf("%f ", distance);
if (num_data[ii].example_num > 0){
add_distance_to_results(&results, distance, k,
num_data[ii].cat, num_data[ii].example_num);
}
}
}
}
answer = calc_nearest_neighbor(&results, &mod, k);
if (answer == results.correct_answer){
c += 1;
}
// printf("\n");
// for (ii=0; ii<k; ii++){
// printf("Distance, cat, example_num1, example_num2 = %2.2f, %i, %i, %i\n",
// results.distances[ii], results.cat[ii], results.example_num, results.example_nums[ii]);
// }
// else{
// }
total += 1;
if (verbose>0 && debug>0){
printf("Thread = %i, Correct/Total = %i/%i Answer/Correct = %i/%i\n",
omp_get_thread_num(), c, total, answer, results.correct_answer);
}
}
//Thread results
#pragma omp barrier
if (omp_get_thread_num() == 0){
printf("/// Thread Results ///\n");
}
#pragma omp barrier
printf("Thread = %i, Correct/Total = %i/%i\n",
omp_get_thread_num(), c, total);
//free distance result
free(results.distances);
free(results.cat);
//free mode struct
free(mod.count);
free(mod.cat);
}
printf("/// Final Results ///\n");
printf("Correct/Total = %i/%i\n", c, total);
// printf("verbose = %i", verbose);
////free malloc calls////
//free feature tree
free_feature_tree(vocab);
//free numeric data
for (ii=0; ii<total_examples; ii++){
free(num_data[ii].array_of_features);
}
free(num_data);
// //free vocab list
// for (ii=0; ii<max_vocab; ii++){
// free(word_list[ii]);
// }
// free(word_list);
//free category list
for (ii=0; ii<40; ii++){
free(cat_list[ii]);
}
free(cat_list);
//free all_data list
for (ii=0; ii<total_examples; ii++){
for (jj=0; jj<num_words; jj++){
free(all_data[ii].question[jj]);
}
free(all_data[ii].question);
free(all_data[ii].cat);
}
free(all_data);
//free var used to rean in csv
free(csv_line);
}
int main(int argc, char **argv)
{
struct lsh_decode_key_options *options = make_lsh_decode_key_options();
struct lsh_string *input;
struct lsh_string *output;
int out = STDOUT_FILENO;
argp_parse(&main_argp, argc, argv, 0, NULL, options);
if (options->file)
{
out = open(lsh_get_cstring(options->file),
O_WRONLY | O_CREAT, 0666);
if (out < 0)
{
werror("Failed to open file `%S' for writing: %e.\n",
options->file, errno);
return EXIT_FAILURE;
}
}
input = io_read_file_raw(STDIN_FILENO, 3000);
if (!input)
{
werror("Failed to read stdin: %e.\n", errno);
return EXIT_FAILURE;
}
if (options->base64)
{
if (!lsh_string_base64_decode(input))
{
werror("Invalid base64 encoding.\n");
lsh_string_free(input);
return EXIT_FAILURE;
}
}
output = lsh_decode_key(input);
lsh_string_free(input);
if (!output)
{
werror("Invalid ssh2 key.\n");
return EXIT_FAILURE;
}
if (!write_raw(out, STRING_LD(output)))
{
werror("Write failed: %e.\n", errno);
return EXIT_FAILURE;
}
lsh_string_free(output);
gc_final();
return EXIT_SUCCESS;
}
void
parse_commandline (int argc, char **argv)
{
char next_arg, i, arg_error = 0;
Log ("--[ PARSING COMMAND LINE ]--------------------------\n");
#if 0 // !defined(WIN32) && !defined(SOLARIS) && !defined(NGC) && !defined(PSP)
argp_parse (&argp, argc, argv, 0, 0, &option);
#else
next_arg = 0;
for (i = 1; i < argc; i++)
if (!next_arg)
{
if (argv[i][0] == '-')
{
if (strlen (argv[i]) == 2)
{
switch (argv[i][1])
{
default:
next_arg = argv[i][1];
break;
}
}
else
arg_error |= set_arg (argv[i][1], (char *) &argv[i][2]);
}
else
{
if (!cart_name[0])
{
strcpy (cart_name, argv[i]);
Log ("Setting card name to %s\n", cart_name);
{
int x;
for (x = 0; x < strlen (cart_name); x++)
if (cart_name[x] == '\\')
cart_name[x] = '/';
}
}
else if (!bmdefault)
{
Log ("Setting backup mem file name to %s\n", argv[i]);
bmdefault = argv[i];
}
else
{
Log ("Unrecognized option : %s\n", argv[i]);
arg_error = 1;
};
}
}
else
{
arg_error |= set_arg (next_arg, argv[i]);
next_arg = 0;
}
if (next_arg)
{
Log ("No value for last arg : %c\n", next_arg);
next_arg = 0;
arg_error = 1;
};
#endif
Log ("End of parsing command line\n");
video_driver = 0;
if (use_eagle)
video_driver = 1;
else if (use_scanline)
video_driver = 2;
}
int main(int argc, char **argv)
{
argp_parse(&argp, argc, argv, 0, 0, 0);
return capture(dev_name, x_res, y_res, n_frames, out_dir);
}
int main(int argc, char **argv)
{
struct arguments args;
int err, lnb = -1,idx = -1;
int r;
const struct argp argp = {
.options = options,
.parser = parse_opt,
.doc = N_("scan DVB services using the channel file"),
.args_doc = N_("<initial file>"),
};
#ifdef ENABLE_NLS
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
#endif
memset(&args, 0, sizeof(args));
args.sat_number = -1;
args.output = DEFAULT_OUTPUT;
args.input_format = FILE_DVBV5;
args.output_format = FILE_DVBV5;
args.timeout_multiply = 1;
args.adapter = (unsigned)-1;
args.lna = LNA_AUTO;
if (argp_parse(&argp, argc, argv, ARGP_NO_HELP | ARGP_NO_EXIT, &idx, &args)) {
argp_help(&argp, stderr, ARGP_HELP_SHORT_USAGE, PROGRAM_NAME);
return -1;
}
if (args.timeout_multiply == 0)
args.timeout_multiply = 1;
if (args.n_adapter == 1) {
args.adapter_fe = args.adapter;
args.adapter_dmx = args.adapter;
}
if (args.lnb_name) {
lnb = dvb_sat_search_lnb(args.lnb_name);
if (lnb < 0) {
printf(_("Please select one of the LNBf's below:\n"));
dvb_print_all_lnb();
exit(1);
} else {
printf(_("Using LNBf "));
dvb_print_lnb(lnb);
}
}
if (idx < argc)
args.confname = argv[idx];
if (!args.confname || idx < 0) {
argp_help(&argp, stderr, ARGP_HELP_STD_HELP, PROGRAM_NAME);
return -1;
}
if ((args.input_format == FILE_ZAP) ||
(args.input_format == FILE_UNKNOWN) ||
(args.output_format == FILE_UNKNOWN)) {
fprintf(stderr, _("ERROR: Please specify a valid format\n"));
argp_help(&argp, stderr, ARGP_HELP_STD_HELP, PROGRAM_NAME);
return -1;
}
r = asprintf(&args.demux_dev,
"/dev/dvb/adapter%i/demux%i", args.adapter_dmx, args.demux);
if (r < 0) {
fprintf(stderr, _("asprintf error\n") );
return -1;
}
if (verbose)
fprintf(stderr, _("using demux '%s'\n"), args.demux_dev);
struct dvb_v5_fe_parms *parms = dvb_fe_open(args.adapter_fe,
args.frontend,
verbose, args.force_dvbv3);
if (!parms) {
free(args.demux_dev);
return -1;
}
if (lnb >= 0)
parms->lnb = dvb_sat_get_lnb(lnb);
if (args.sat_number >= 0)
parms->sat_number = args.sat_number % 3;
parms->diseqc_wait = args.diseqc_wait;
parms->freq_bpf = args.freq_bpf;
parms->lna = args.lna;
r = dvb_fe_set_default_country(parms, args.cc);
if (r < 0)
fprintf(stderr, _("Failed to set the country code:%s\n"), args.cc);
timeout_flag = &parms->abort;
signal(SIGTERM, do_timeout);
signal(SIGINT, do_timeout);
err = run_scan(&args, parms);
dvb_fe_close(parms);
free(args.demux_dev);
return err;
}
int main(int argc, char **argv){
ssh_session session;
ssh_bind sshbind;
ssh_message message;
ssh_channel chan=0;
char buf[2048];
int auth=0;
int shell=0;
int i;
int r;
sshbind=ssh_bind_new();
session=ssh_new();
ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_DSAKEY,
KEYS_FOLDER "ssh_host_dsa_key");
ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_RSAKEY,
KEYS_FOLDER "ssh_host_rsa_key");
#ifdef HAVE_ARGP_H
/*
* Parse our arguments; every option seen by parse_opt will
* be reflected in arguments.
*/
argp_parse (&argp, argc, argv, 0, 0, sshbind);
#else
(void) argc;
(void) argv;
#endif
#ifdef WITH_PCAP
set_pcap(session);
#endif
if(ssh_bind_listen(sshbind)<0){
printf("Error listening to socket: %s\n", ssh_get_error(sshbind));
return 1;
}
printf("Started sample libssh sshd on port %d\n", port);
printf("You can login as the user %s with the password %s\n", SSHD_USER,
SSHD_PASSWORD);
r = ssh_bind_accept(sshbind, session);
if(r==SSH_ERROR){
printf("Error accepting a connection: %s\n", ssh_get_error(sshbind));
return 1;
}
if (ssh_handle_key_exchange(session)) {
printf("ssh_handle_key_exchange: %s\n", ssh_get_error(session));
return 1;
}
/* proceed to authentication */
auth = authenticate(session);
if (!auth || !authenticated) {
printf("Authentication error: %s\n", ssh_get_error(session));
ssh_disconnect(session);
return 1;
}
/* wait for a channel session */
do {
message = ssh_message_get(session);
if(message){
if(ssh_message_type(message) == SSH_REQUEST_CHANNEL_OPEN &&
ssh_message_subtype(message) == SSH_CHANNEL_SESSION) {
chan = ssh_message_channel_request_open_reply_accept(message);
ssh_message_free(message);
break;
} else {
ssh_message_reply_default(message);
ssh_message_free(message);
}
} else {
break;
}
} while(!chan);
if(!chan) {
printf("Error: cleint did not ask for a channel session (%s)\n",
ssh_get_error(session));
ssh_finalize();
return 1;
}
/* wait for a shell */
do {
message = ssh_message_get(session);
if(message != NULL) {
if(ssh_message_type(message) == SSH_REQUEST_CHANNEL &&
ssh_message_subtype(message) == SSH_CHANNEL_REQUEST_SHELL) {
shell = 1;
ssh_message_channel_request_reply_success(message);
ssh_message_free(message);
break;
}
ssh_message_reply_default(message);
ssh_message_free(message);
} else {
break;
}
} while(!shell);
if(!shell) {
printf("Error: No shell requested (%s)\n", ssh_get_error(session));
return 1;
}
printf("it works !\n");
do{
i=ssh_channel_read(chan,buf, 2048, 0);
if(i>0) {
if(*buf == '' || *buf == '')
break;
if(i == 1 && *buf == '\r')
ssh_channel_write(chan, "\r\n", 2);
else
ssh_channel_write(chan, buf, i);
if (write(1,buf,i) < 0) {
printf("error writing to buffer\n");
return 1;
}
}
} while (i>0);
ssh_channel_close(chan);
ssh_disconnect(session);
ssh_bind_free(sshbind);
#ifdef WITH_PCAP
cleanup_pcap();
#endif
ssh_finalize();
return 0;
}
int main(int argc, char **argv)
{
struct arguments arguments;
arguments.action = 0;
arguments.no_favorite_repo = 0;
arguments.no_favorite_version = 0;
arguments.no_deps = 1;
arguments.all = 0;
arguments.args = NULL;
if (argc < 2) {
char *fake_arg[2];
fake_arg[0] = "ilenia";
fake_arg[1] = "--help";
argp_parse(&argp, 2, fake_arg, 0, 0, &arguments);
}
argp_parse(&argp, argc, argv, 0, 0, &arguments);
if (parse_ileniarc() != 0)
return (EXIT_FAILURE);
ilenia_repos = build_repolist();
if (arguments.action == ACT_CACHE) {
FILE *file;
if ((file = fopen(CACHE, "w")))
fclose(file);
}
ilenia_favoriterepo = get_favorite(FAVORITE_REPO);
ilenia_favoriteversion = get_favorite(FAVORITE_VERSION);
ilenia_aliases = aliaseslist_build();
ilenia_ports = lsports();
ilenia_pkgs = lspkgs();
ilenia_favoritepkgmk = pkgmklist_build();
if (arguments.action > 21 || arguments.action == 0)
error("%s", "please perform an action at a time!");
int confront_options =
arguments.no_favorite_repo + arguments.no_favorite_version;
int update_options = arguments.no_deps;
if (confront_options)
update_options = confront_options * update_options;
int status = EXIT_SUCCESS;
if (arguments.action == ACT_UPDATE) {
if (arguments.args == NULL) {
status = update_all_repos();
return (EXIT_SUCCESS);
}
while (arguments.args) {
status = update_repo(arguments.args->data);
arguments.args = arguments.args->next;
}
}
if (arguments.action == ACT_LIST) {
if (arguments.args == NULL) {
pkglist_print(ilenia_ports);
return (EXIT_SUCCESS);
}
while (arguments.args) {
if (repolist_exists(arguments.args->data,
ilenia_repos)) {
warning("repository %s not found!\n",
arguments.args->data);
arguments.args = arguments.args->next;
continue;
}
pkglist_print(pkglist_select_from_repo
(arguments.args->data,
ilenia_ports));
arguments.args = arguments.args->next;
}
}
if (arguments.action == ACT_SEARCH) {
if (arguments.args == NULL)
error("action search requires an argument!");
while (arguments.args) {
pkglist_print(pkglist_find_like
(arguments.args->data,
ilenia_ports));
arguments.args = arguments.args->next;
}
}
if (arguments.action == ACT_INFO) {
if (arguments.args == NULL)
error("action info requires an argument!");
while (arguments.args) {
info(arguments.args->data, confront_options);
arguments.args = arguments.args->next;
}
}
if (arguments.action == ACT_DIFF)
pkglist_confront(DIFF, confront_options, 1);
if (arguments.action == ACT_UPDATED)
pkglist_confront(UPDATED, confront_options, 1);
if (arguments.action == ACT_DEPENDENCIES) {
if (arguments.args == NULL)
error("action dependencies requires an argument!");
while (arguments.args) {
print_dependencies(arguments.args->data);
arguments.args = arguments.args->next;
}
}
if (arguments.action == ACT_UPDATE_PKG) {
if (arguments.args == NULL) {
status = update_system(update_options);
return status;
}
while (arguments.args) {
status =
update_pkg(update_options,
arguments.args->data);
arguments.args = arguments.args->next;
}
}
if (arguments.action == ACT_DEPENDENTS) {
if (arguments.args == NULL)
error("action dependents requires an argument!");
while (arguments.args) {
print_dependents(arguments.args->data,
arguments.all);
arguments.args = arguments.args->next;
}
}
if (arguments.action == ACT_REMOVE) {
if (arguments.args == NULL)
error("action remove requires an argument!");
while (arguments.args) {
status =
remove_pkg(arguments.args->data,
arguments.no_deps, arguments.all);
arguments.args = arguments.args->next;
}
}
if (arguments.action == ACT_REPOSITORY_LIST) {
while (ilenia_repos != NULL) {
printf("name %s path %s\n", ilenia_repos->name,
ilenia_repos->path);
ilenia_repos = ilenia_repos->next;
}
}
return status;
}
