/*--------------- main routine ---------------*/
int main( int argc, char *argv[] )
{
options_t * opts = &g_opts;
int rv;
if( argc < 2 ) { show_help(); return 0; }
mainENTRY("3dTto1D main"); machdep(); AFNI_logger("3dTto1D",argc,argv);
/* process command line arguments (and read dataset and mask) */
rv = process_opts(opts, argc, argv);
if( rv ) RETURN(rv < 0); /* only a negative return is considered failure */
if( check_dims(opts) ) RETURN(1);
/* evaluation of rv now depends on the method, usually non-zero is bad */
rv = compute_results(opts);
/* for 4095_warn, return now, regardless */
if( opts->method == T21_METH_4095_WARN ) RETURN(rv);
/* otherwise, any non-zero return is a failure */
if ( rv ) RETURN(1);
if( write_results(opts) ) RETURN(1);
RETURN(0);
}
int main(int argc, char *argv[])
{
process_opts(argc, argv);
listener();
return 0;
}
/* This is quite horrible, but it does seem to work... We make a
shallow copy of config, and then recall read_config. config will
now be changed with any additional options in the subsection - we
copy it where we want it, and restore config. The copy is only a
shallow one, but we get away with it as other funcs overwrite
pointers not their contents. */
int store_subsect(sstr * str, struct subsect_list *subsecs)
{
struct options tmp;
struct subsect item;
parse_match(str, &item.match);
memcpy(&tmp, &config, sizeof(struct options));
sublevel++;
config.acls.list = NULL;
config.subsecs.list = NULL;
config.acls.num = config.subsecs.num = 0;
if (read_config() == -1)
return (-1);
sublevel--;
if(process_opts()==-1) return(-1);
memcpy(&item.config, &config, sizeof(struct options));
memcpy(&config, &tmp, sizeof(struct options));
subsecs->list = realloc(subsecs->list,
(subsecs->num + 1) * sizeof(struct subsect));
memcpy(subsecs->list + subsecs->num, &item, sizeof(struct subsect));
subsecs->num++;
return (0);
}
int main(int argc, char *argv[]) {
/* Process command line options. */
process_opts(argc, argv);
/* Verify that the scoreboard file is useable. */
verify_scoreboard_file();
/* Install signal handlers. */
signal(SIGINT, finish);
signal(SIGTERM, finish);
#if defined(PR_USE_NLS) && defined(HAVE_LOCALE_H)
(void) setlocale(LC_ALL, "");
#endif
/* Initialize the display. */
initscr();
cbreak();
noecho();
#ifndef HAVE_NCURSES
nodelay(stdscr, TRUE);
#endif
curs_set(0);
/* Paint the initial display. */
show_sessions();
/* Loop endlessly. */
for (;;) {
int c = -1;
#ifdef HAVE_NCURSES
if (halfdelay(delay * 10) != ERR)
c = getch();
#else
sleep(delay);
c = getch();
#endif
if (c != -1) {
if (tolower(c) == 'q') {
break;
}
if (tolower(c) == 't') {
toggle_mode();
}
}
show_sessions();
}
/* done */
finish(0);
return 0;
}
/*--------------- main routine ---------------*/
int main( int argc, char *argv[] )
{
THD_3dim_dataset * countset=NULL;
param_t * params = &g_params;
int rv, limit;
if( argc < 1 ) { show_help(); return 0; }
/* general stuff */
mainENTRY("3dmask_tool"); machdep(); AFNI_logger("3dmask_tool",argc,argv);
enable_mcw_malloc();
/* process options: a negative return is considered an error */
rv = process_opts(params, argc, argv);
if( rv ) RETURN(rv < 0);
/* open, convert to byte, zeropad, dilate, unzeropad */
if( process_input_dsets(params) ) RETURN(1);
/* create mask count dataset and return num volumes (delete old dsets) */
if( count_masks(params->dsets, params->ndsets, params->verb,
&countset, ¶ms->nvols) ) RETURN(1);
/* limit to frac of nvols (if not counting, convert to 0/1 mask) */
limit = ceil((params->frac>1) ? params->frac : params->nvols*params->frac );
if( params->verb )
INFO_message("frac %g over %d volumes gives min count %d\n",
params->frac, params->nvols, limit);
if( limit <= 0 ) limit = 1;
/* if not counting, result is binary 0/1 */
if( limit_to_frac(countset, limit, params->count, params->verb) )
RETURN(1);
/* maybe apply dilations to output */
if( params->RESD.num > 0 ) {
countset = apply_dilations(countset, ¶ms->RESD, 0, params->verb);
if( !countset ) RETURN(1);
}
/* maybe fill any remaining holes */
if( params->fill )
if ( fill_holes(countset, params->verb) ) RETURN(1);
/* create output */
if( write_result(params, countset, argc, argv) ) RETURN(1);
/* clean up a little memory */
DSET_delete(countset);
free(params->dsets);
RETURN(0);
}
int read_config()
{
struct option_array *opt;
sstr *buf;
if (!fp) {
if (config.config_file == NULL) fp = fopen(CONFIG_FILE, "r");
else fp = fopen(config.config_file, "r");
if (fp == NULL) return (-1);
line_no=0;
}
buf = sstr_init(0);
while (sstr_fgets(buf, fp) != NULL) {
line_no++;
switch (parse_line(buf)) {
case -1:
sstr_free(buf);
if (sublevel == 0) fclose(fp);
return (-1);
case 0:
break;
case 1: /* end subsection */
sstr_free(buf);
return (0);
}
};
sstr_free(buf);
fclose(fp);
fp = NULL;
opt = opts;
while (opt->name != NULL && !opt->essential)
opt++;
if (opt->name != NULL) {
fprintf(stderr, "Essential option \"%s\" not specified.\n",
opt->name);
return (-1);
}
process_opts();
#ifdef DEBUG
if(!config.inetd) print_config();
#endif
return (0);
}
int main(int argc, void* argv)
{
sigset_t emptyset;
// sigsegv_init(&ss_dispatcher);
sigsegv_install_handler(ss_handler);
/* Save the current signal mask. */
sigemptyset (&emptyset);
sigprocmask (SIG_BLOCK, &emptyset, &mainsigset);
enable_memory_block(&Vm_image_start, &Vm_image_end);
process_opts(argc,argv);
install_exception_handler(kernel_exception_handler);
if ( opts.image_file != 0 )
load_image(opts.image_file);
run_repl();
return 0;
}
int main(int argc, char *argv[])
{
int nprocs;
double t;
double total_bytes = 0;
int i;
if (!process_opts(argc, argv, &nprocs))
show_usage();
t = create_procs(nprocs, child_run);
for (i=0;i<nprocs;i++) {
total_bytes += children[i].bytes_in + children[i].bytes_out;
}
t = end_timer();
printf("Throughput %g MB/sec%s%s %d procs\n",
1.0e-6 * total_bytes / t,
sync_open ? " (sync open)" : "",
sync_dirs ? " (sync dirs)" : "", nprocs);
return 0;
}
int main (int argc, char *argv[])
{
GEN_PAR Pg;
IN_PAR Pi;
OUT_PAR Po;
int i;
char *shortopts = "a:c:d:D:f:h:l:m:o:O:p:P:r:s:S:V:w:x:X:y:Y:CFHinqtvN";
struct option longopts[] =
{
{"mode", 1, NULL, 'm'},
{"pencolors", 1, NULL, 'c'},
{"pensizes", 1, NULL, 'p'},
{"pages", 1, NULL, 'P'},
{"quiet", 0, NULL, 'q'},
{"nofill", 0, NULL, 'n'},
{"no_ps", 0, NULL, 'N'},
{"DPI", 1, NULL, 'd'},
{"DPI_x", 1, NULL, 'd'},
{"DPI_y", 1, NULL, 'D'},
{"PCL_formfeed",0, NULL, 'F'},
{"PCL_init", 0, NULL, 'i'},
{"PCL_Deskjet", 1, NULL, 'S'},
{"outfile", 1, NULL, 'f'},
{"logfile", 1, NULL, 'l'},
{"swapfile", 1, NULL, 's'},
{"aspectfactor",1, NULL, 'a'},
{"height", 1, NULL, 'h'},
{"width", 1, NULL, 'w'},
{"truesize", 0, NULL, 't'},
{"x0", 1, NULL, 'x'},
{"x1", 1, NULL, 'X'},
{"y0", 1, NULL, 'y'},
{"y1", 1, NULL, 'Y'},
{"xoffset", 1, NULL, 'o'},
{"yoffset", 1, NULL, 'O'},
{"center", 0, NULL, 'C'},
#ifdef DOS
{"VGAmodebyte", 1, NULL, 'V'},
#endif
{"help", 0, NULL, 'H'},
{"version", 0, NULL, 'v'},
{NULL, 0, NULL, '\0'}
};
preset_par (&Pg, &Pi, &Po);
if (argc == 1)
{
usage_msg (&Pg, &Pi, &Po);
exit (ERROR);
}
#ifdef WIN32
/* set stdin and stdout to binary mode: */
_setmode( _fileno(stdin), _O_BINARY );
_setmode( _fileno(stdout), _O_BINARY );
#endif /* WIN32 */
process_opts (argc, argv, shortopts, longopts, &Pg, &Pi, &Po);
/**
** Determine internal mode code
**/
for (i=0; ModeList[i].mode != XX_TERM; i++)
/* if (strncmp(Pg.mode, ModeList[i].modestr,
strlen(ModeList[i].modestr)) == 0)*/
if (strcmp(Pg.mode, ModeList[i].modestr)==0)
{
Pg.xx_mode = ModeList[i].mode;
break;
}
/**
** Place consistency checks & adjustments here if you like
**/
if (Po.dpi_y == 0)
Po.dpi_y = Po.dpi_x;
/**
** Action loop over all input files
**/
if (optind == argc) /* No filename: use stdin */
{
Pi.in_file = "-";
autoset_outfile_name (Pg.mode, Pi.in_file, &Po.outfile);
action_oldstyle (&Pg, &Pi, &Po);
}
else for ( ; optind < argc; optind++)
{ /* Multiple-input file handling: */
Pi.in_file = argv[optind];
autoset_outfile_name (Pg.mode, Pi.in_file, &Po.outfile);
action_oldstyle (&Pg, &Pi, &Po);
reset_par (&Pi);
}
cleanup (&Pg, &Pi, &Po);
if (*Pg.logfile)
fclose (stderr);
return NOERROR;
}
int main(int argc, char *argv[])
{
FILE *log = stdout;
struct timeval tv;
option_block options;
int i;
g_plugin = NULL;
sfuzz_setsearchpath(
#ifndef __WIN32__
"./:"PREFIX"/share/sfuzz-db"
#else
"./"
#endif
);
memset(&options, 0, sizeof(options));
gettimeofday(&tv, NULL);
birth = tv.tv_sec;
options.pFilename = malloc(MAX_FILENAME_SIZE);
options.pLogFilename = malloc(MAX_FILENAME_SIZE);
options.host_spec = malloc(MAX_HOSTSPEC_SIZE);
options.port_spec = malloc(MAX_PORTSPEC_SIZE);
options.repl_pol = 2; /* once ! for always, choose 1. */
memset(options.pFilename, 0, MAX_FILENAME_SIZE-1);
memset(options.pLogFilename, 0, MAX_FILENAME_SIZE-1);
/*default line terminator*/
options.line_term[0] = '\n';
options.line_terminator_size = 1;
options.state = CMD_LINE_OPTS;
process_opts(argc, argv, &options);
options.state = INIT_READ;
read_config(&options);
if(options.pLogFilename[0] != 0)
{
if(options.new_logfile)
{
strncat(options.pLogFilename, ".0", MAX_FILENAME_SIZE);
}
log = fopen(options.pLogFilename, "w");
if(log != NULL)
{
options.fp_log = log;
} else
{
fprintf(stderr, "[%s] error: using stdout - unable to open log.\n",
get_time_as_log());
log = stdout;
}
}
if(options.verbosity == VERBOSE)
dump_options(&options);
if(options.verbosity != QUIET)
{
fprintf(log, "[%s] info: beginning fuzz - method:", get_time_as_log());
if(options.tcp_flag)
{
fprintf(log, " tcp,");
} else if(options.udp_flag)
{
fprintf(log, " udp,");
}
else
{
fprintf(log, " io,");
}
fprintf(log, " config from: [%s], out: [%s:%d]\n",
options.pFilename, options.host_spec, options.port);
}
options.state = FUZZ;
execute_fuzz(&options);
if(options.verbosity != QUIET)
fprintf(log, "[%s] completed fuzzing.\n", get_time_as_log());
free( options.pFilename );
free( options.pLogFilename );
free( options.host_spec );
for(i = 0; i < options.num_litr; ++i)
{
free(options.litr[i]);
}
free(options.litr);
free(options.litr_lens);
for(i = 0; i < options.num_seq; ++i)
{
free(options.seq[i]);
}
free(options.seq);
free(options.seq_lens);
/*this might be the better way of doing things =)*/
if(options.sym_count)
free(options.syms_array);
return 0;
}
int
mount_autofs(
struct mapent *me,
char *mntpnt,
action_list *alp,
char *rootp,
char *subdir,
char *key
)
{
int mntflags = 0;
struct utsname utsname;
autofs_args *fnip = NULL;
int mount_timeout = AUTOFS_MOUNT_TIMEOUT;
int sawnest, len, error = 0;
char *buf, rel_mntpnt[MAXPATHLEN];
if (trace > 1)
trace_prt(1, " mount_autofs %s on %s\n",
me->map_fs->mfs_dir, mntpnt);
if (strcmp(mntpnt, "/-") == 0) {
syslog(LOG_ERR, "invalid mountpoint: /-");
return (ENOENT);
}
/*
* get relative mountpoint
*/
sprintf(rel_mntpnt, ".%s", mntpnt+strlen(rootp));
if (trace > 2)
trace_prt(1, "rel_mntpnt = %s\n", rel_mntpnt);
if (uname(&utsname) < 0) {
error = errno;
syslog(LOG_ERR, "uname %s", strerror(error));
return (error);
}
if ((fnip = (autofs_args *)
malloc(sizeof (autofs_args))) == NULL) {
goto free_mem;
}
(void) memset((void *) fnip, 0, sizeof (*fnip));
if ((fnip->addr.buf = (char *)malloc(MAXADDRLEN)) == NULL)
goto free_mem;
(void) strcpy(fnip->addr.buf, utsname.nodename);
(void) strcat(fnip->addr.buf, ".autofs");
if ((fnip->opts = malloc(MAX_MNTOPT_STR)) == NULL)
goto free_mem;
strcpy(fnip->opts, me->map_mntopts);
if (process_opts(fnip->opts, &fnip->direct, &sawnest) != 0)
goto free_mem;
fnip->addr.len = strlen(fnip->addr.buf);
fnip->addr.maxlen = fnip->addr.len;
/*
* get absolute mountpoint
*/
if ((fnip->path = strdup(mntpnt)) == NULL)
goto free_mem;
if ((fnip->map = strdup(me->map_fs->mfs_dir)) == NULL)
goto free_mem;
if ((fnip->subdir = strdup(subdir)) == NULL)
goto free_mem;
/*
* This timeout is really ignored by autofs, it uses the
* parent directory's timeout since it's really the one
* specified/inherited from the original mount by 'automount'
*/
fnip->mount_to = mount_timeout; /* IGNORED */
fnip->rpc_to = AUTOFS_RPC_TIMEOUT;
if (fnip->direct) {
if (me->map_modified == TRUE || me->map_faked == TRUE) {
if ((fnip->key = strdup(key)) == NULL)
goto free_mem;
} else {
/* wierd case of a direct map pointer in another map */
if ((fnip->key = strdup(fnip->path)) == NULL)
goto free_mem;
}
} else {
fnip->key = NULL;
}
/*
* Fill out action list.
*/
alp->action.action = AUTOFS_MOUNT_RQ;
if ((alp->action.action_list_entry_u.mounta.spec =
strdup(me->map_fs->mfs_dir)) == NULL)
goto free_mem;
if ((alp->action.action_list_entry_u.mounta.dir =
strdup(rel_mntpnt)) == NULL)
goto free_mem;
len = strlen(fnip->opts);
/*
* Get a buffer for the option string, it holds the map options plus
* space for "nest" if it isn't already in the option string
*/
if ((buf = (char *)malloc(MAX_MNTOPT_STR)) == NULL)
goto free_mem;
strcpy(buf, fnip->opts);
if (!sawnest) {
if (len + strlen(",nest") + 1 > MAX_MNTOPT_STR)
goto free_mem;
if (len)
(void) strcat(buf, ",");
(void) strcat(buf, "nest");
}
alp->action.action_list_entry_u.mounta.optptr = buf;
alp->action.action_list_entry_u.mounta.optlen = strlen(buf) + 1;
alp->action.action_list_entry_u.mounta.flags =
mntflags | MS_DATA | MS_OPTIONSTR;
if ((alp->action.action_list_entry_u.mounta.fstype =
strdup(MNTTYPE_AUTOFS)) == NULL)
goto free_mem;
alp->action.action_list_entry_u.mounta.dataptr = (char *)fnip;
alp->action.action_list_entry_u.mounta.datalen = sizeof (*fnip);
return (0);
free_mem:
/*
* We got an error, free the memory we allocated.
*/
syslog(LOG_ERR, "mount_autofs: memory allocation failure");
free_autofs_args(fnip);
alp->action.action_list_entry_u.mounta.dataptr = NULL;
alp->action.action_list_entry_u.mounta.datalen = 0;
free_mounta(&alp->action.action_list_entry_u.mounta);
return (error ? error : ENOMEM);
}
/**
* @brief
* The main function in C - entry point
*
* @param[in] argc - argument count
* @param[in] argv - pointer to argument array
* @param[in] envp - pointer to environment values
*
* @return int
* @retval 0 - success
* @retval !0 - error
*/
int
main(int argc, char *argv[], char *envp[])
{
int errflg; /* command line option error */
int connect; /* return from pbs_connect */
char *errmsg; /* return from pbs_geterrmsg */
char destbuf[256]; /* buffer for option server */
struct attrl *attrib; /* the attrib list */
char *new_resvname; /* the name returned from pbs_submit_resv */
struct ecl_attribute_errors *err_list;
char *interactive = NULL;
/*test for real deal or just version and exit*/
execution_mode(argc, argv);
#ifdef WIN32
winsock_init();
#endif
destbuf[0] = '\0';
errflg = process_opts(argc, argv, &attrib, destbuf); /* get cmdline options */
if (errflg || ((optind+1) < argc) || argc == 1) {
print_usage();
exit(2);
}
/* Get any required environment variables needing to be sent. */
if (! set_resv_env(envp)) {
fprintf(stderr, "pbs_rsub: can't send environment with the reservation\n");
exit(3);
}
/*perform needed security library initializations (including none)*/
if (CS_client_init() != CS_SUCCESS) {
fprintf(stderr, "pbs_rsub: unable to initialize security library.\n");
exit(1);
}
/* Connect to the server */
connect = cnt2server(destbuf);
if (connect <= 0) {
fprintf(stderr, "pbs_rsub: cannot connect to server %s (errno=%d)\n",
pbs_server, pbs_errno);
CS_close_app();
exit(pbs_errno);
}
if (qmoveflg == TRUE) {
qmoveflg = FALSE;
interactive = get_attr(attrib, ATTR_inter, NULL);
if (interactive == NULL) {
set_attr(&attrib, ATTR_inter, DEFAULT_INTERACTIVE);
} else {
if (atoi(interactive) > -1) {
fprintf(stderr, "pbs_rsub: -I <timeout> value must be negative when used with -Wqmove option.\n");
CS_close_app();
exit(2);
}
}
errflg = cnvrt_proc_attrib(connect, &attrib, destbuf);
if (errflg) {
fprintf(stderr, "pbs_rsub: can't make a reservation with the qmove option\n");
CS_close_app();
exit(2);
}
}
pbs_errno = 0;
new_resvname = pbs_submit_resv(connect, (struct attropl *)attrib, NULL);
if (new_resvname == NULL) {
if ((err_list = pbs_get_attributes_in_error(connect)))
handle_attribute_errors(err_list);
errmsg = pbs_geterrmsg(connect);
if (errmsg != NULL) {
fprintf(stderr, "pbs_rsub: %s\n", errmsg);
}
else
fprintf(stderr, "pbs_rsub: Error (%d) submitting reservation\n", pbs_errno);
CS_close_app();
exit(pbs_errno);
} else {
printf("%s\n", new_resvname);
free(new_resvname);
}
/* Disconnet from the server. */
pbs_disconnect(connect);
CS_close_app();
exit(0);
}
int harness_init(int argc, char** argv, HARNESS_INSTANCE** inst){
int i = 0,rval = 0;
MYSQL_session* mysqlsess;
DCB* dcb;
char cwd[1024];
char tmp[2048];
if(!(argc == 2 && strcmp(argv[1],"-h") == 0)){
mxs_log_init(NULL,NULL,MXS_LOG_TARGET_DEFAULT);
}
if(!(instance.head = calloc(1,sizeof(FILTERCHAIN))))
{
printf("Error: Out of memory\n");
MXS_ERROR("Out of memory\n");
return 1;
}
*inst = &instance;
instance.running = 1;
instance.infile = -1;
instance.outfile = -1;
instance.expected = -1;
instance.buff_ind = -1;
instance.last_ind = -1;
instance.sess_ind = -1;
instance.session = calloc(1,sizeof(SESSION));
dcb = calloc(1,sizeof(DCB));
mysqlsess = calloc(1,sizeof(MYSQL_session));
sprintf(mysqlsess->user,"dummyuser");
sprintf(mysqlsess->db,"dummydb");
dcb->func.write = dcbfun;
dcb->remote = strdup("0.0.0.0");
dcb->user = strdup("user");
instance.session->client = (void*)dcb;
instance.session->data = (void*)mysqlsess;
getcwd(cwd,sizeof(cwd));
sprintf(tmp,"%s",cwd);
mxs_log_init(NULL, tmp, MXS_LOG_TARGET_DEFAULT);
rval = process_opts(argc,argv);
if(!(instance.thrpool = malloc(instance.thrcount * sizeof(pthread_t)))){
printf("Error: Out of memory\n");
MXS_ERROR("Out of memory\n");
return 1;
}
/**Initialize worker threads*/
pthread_mutex_lock(&instance.work_mtx);
size_t thr_num = 1;
for(i = 0;i<instance.thrcount;i++){
rval |= pthread_create(&instance.thrpool[i],NULL,(void*)work_buffer,(void*)thr_num++);
}
return rval;
}
