void simple_shell() { int n_args, i; //memory space for user command is always the same, freed on quit char * * sarray = malloc(max_arg_c * sizeof(*sarray)); for (i = 0; i < max_arg_c; i += 1) sarray[i] = malloc(max_arg_length + 1); print_commands(); while (1) { printf("\n---> "); for (i = 0; i < max_arg_c; i += 1) *sarray[i] = (char *)NULL; n_args = get_command_line(sarray); if (quit_command(sarray[0])) { printf("exiting shell \n"); for (i = 0; i < max_arg_c; i += 1) free(sarray[i]); free(sarray); break; } else if (!strcmp(sarray[0], "help")) print_commands(); else if (!strcmp(sarray[0], "echo")) { for (i = 1; i < n_args && sarray[i] != NULL; i += 1) printf("%s ", sarray[i]); } else if (!strcmp(sarray[0], "run")) run_program(sarray, n_args); else printf("command not found. "); } }
static void guile_command (char *arg, int from_tty) { struct cleanup *cleanup; cleanup = make_cleanup_restore_integer (&interpreter_async); interpreter_async = 0; arg = skip_spaces (arg); if (arg && *arg) { char *msg = gdbscm_safe_eval_string (arg, 1); if (msg != NULL) { make_cleanup (xfree, msg); error ("%s", msg); } } else { struct command_line *l = get_command_line (guile_control, ""); make_cleanup_free_command_lines (&l); execute_control_command_untraced (l); } do_cleanups (cleanup); }
int main(int argc, char **argv, char **envp) { t_ftsh *sh; sh = NULL; sh = intialize_sh(argc, argv, envp); if (!sh) { ft_putendl_fd("Error : could'nt initialize shell", 2); return (1); } while (1) { catch_signals(); if (sh->line) free(sh->line); sh->line = NULL; write(1, sh->prompt, ft_strlen(sh->prompt)); if ((sh->line = get_command_line()) != NULL) { sh->ret = execute_command_line(sh, &(sh->env_dup)); ft_tabfree(sh->path_dir); sh->path_dir = extract_path_directories(sh->env_dup); } else exit(1); } }
/** * @brief actually does the write to kafka of a string with the given * file path * @param path file path to save to kafka * @param buf write buffer * @param size size of the buffer to write * @param offset starting point in the buffer * @return 0 if the write succeeded, 1 otherwise **/ static int actual_kafka_write(const char *path, const char *buf, size_t size, off_t offset) { char* ret = NULL; (void) path; char timestamp[] = "YYYY-MM-ddTHH:mm:ss.SSS+0000"; char* text = base64(buf, size); struct fuse_context* context = fuse_get_context(); struct group* sgroup = getgrgid(context->gid); struct passwd* suser = getpwuid(context->uid); char* user = suser == NULL ? "":suser->pw_name; char* group = sgroup == NULL ? "":sgroup->gr_name; char* command = get_command_line(context->pid); char* format = "{\"path\": \"%s%s\", \"pid\": %d, \"uid\": %d, " "\"gid\": %d, \"@message\": \"%s\", \"@timestamp\": \"%s\"," "\"user\": \"%s\", \"group\": \"%s\", \"command\": \"%s\"," "\"@version\": \"%s\", \"@fields\": %s, \"@tags\": %s}"; kafka_t *private_data = (kafka_t*) fuse_get_context()->private_data; config* conf = (config*)private_data->conf; set_timestamp(timestamp); asprintf(&ret, format, conf->directories[conf->directory_n], path + 1, context->pid, context->uid, context->gid, text, timestamp, user, group, command, VERSION, conf->fields_s, conf->tags_s); free(command); free(text); if (ret == NULL) { fprintf(stderr, "Error in asprintf\n"); return 1; } send_kafka(context->private_data, ret, strlen(ret)); free(ret); return 0; }
/* returns TRUE if able to fit in one $STACK(level,...) of information in global variable structure "dollar_stack". * returns FALSE otherwise */ static boolean_t fill_dollar_stack_level(int array_level, int frame_level, int cur_zlevel) { mstr *mstrptr; mval tmpmval; dollar_stack_struct *dstack; assert(FALSE == dollar_stack.incomplete); /* we should not have come here if previous $STACK levels were incomplete */ dstack = &dollar_stack.array[array_level]; /* fill in $STACK(level) */ if (frame_level) get_frame_creation_info(frame_level, cur_zlevel, &tmpmval); else get_command_line(&tmpmval, FALSE); /* FALSE to indicate we want actual (not processed) command line */ /* note that tmpmval at this point will most likely point to the stringpool. but we rely on stp_gcol to free it up */ mstrptr = &dstack->mode_str; if (FALSE == fill_dollar_stack_info(&tmpmval, mstrptr)) return FALSE; /* fill in $STACK(level,"ECODE") */ dstack->ecode_ptr = (frame_level == (cur_zlevel - 1)) ? &dollar_ecode.array[dollar_ecode.index - 1] : NULL; /* fill in $STACK(level,"PLACE") */ get_frame_place_mcode(frame_level, DOLLAR_STACK_PLACE, cur_zlevel, &tmpmval); mstrptr = &dstack->place_str; if (FALSE == fill_dollar_stack_info(&tmpmval, mstrptr)) return FALSE; /* fill in $STACK(level,"MCODE") */ get_frame_place_mcode(frame_level, DOLLAR_STACK_MCODE, cur_zlevel, &tmpmval); mstrptr = &dstack->mcode_str; if (FALSE == fill_dollar_stack_info(&tmpmval, mstrptr)) return FALSE; return TRUE; }
int main(int argc, char **argv, char **env) { char command_line[128]; init_embedded_perl(); /* Calls Perl to load and construct a new * Term::ReadLine object. */ init_term_readline(); while (1) { /* * get_command_line calls Perl to get a scalar from stdin */ strncpy(command_line, get_command_line(), 128) ; /* Perl Term::ReadLine::readline() method chomps the "\n" * from the end of the input. */ run_plugin(command_line) ; } deinit_embedded_perl(); }
static void python_command (char *arg, int from_tty) { struct cleanup *cleanup; cleanup = ensure_python_env (get_current_arch (), current_language); make_cleanup_restore_integer (&interpreter_async); interpreter_async = 0; while (arg && *arg && isspace (*arg)) ++arg; if (arg && *arg) { if (PyRun_SimpleString (arg)) error (_("Error while executing Python code.")); } else { struct command_line *l = get_command_line (python_control, ""); make_cleanup_free_command_lines (&l); execute_control_command_untraced (l); } do_cleanups (cleanup); }
/* check we retained the initrd */ void check_reuse_initrd(void) { char *line = get_command_line(); if (strstr(line, "retain_initrd") == NULL) die("unrecoverable error: current boot didn't " "retain the initrd for reuse.\n"); free(line); }
static void if_command (const char *arg, int from_tty) { control_level = 1; command_line_up command = get_command_line (if_control, arg); if (command == NULL) return; scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0); execute_control_command_untraced (command.get ()); }
/* * Main. */ int main (int argc, char* argv[]) { struct command_line cmdline; int rc, finalrc; /* Find out what we're supposed to do */ rc = get_command_line (argc, argv, &cmdline); if (rc) { return 1; } rc= check_key_state (&cmdline); if (rc) { return 1; } /* Check for priority options --help and --version */ if (cmdline.parm[cmd_keyword_help].kw_given) { print_usage (); return 0; } else if (cmdline.parm[cmd_keyword_version].kw_given) { print_version (); return 0; } /* Make sure we're running as root */ if (check_for_root ()) { return 1; } /* Do each of the commands on each of the devices * and don't care about the return codes */ if (cmdline.device_id >= argc) { error_print ("Missing device"); print_usage (); return 1; } finalrc = 0; while (cmdline.device_id < argc) { rc = do_command (argv[cmdline.device_id], cmdline); if (rc && !finalrc) finalrc = rc; cmdline.device_id++; } return finalrc; }
static void guile_command (char *arg, int from_tty) { arg = skip_spaces (arg); if (arg && *arg) error (_("Guile scripting is not supported in this copy of GDB.")); else { /* Even if Guile isn't enabled, we still have to slurp the command list to the corresponding "end". */ struct command_line *l = get_command_line (guile_control, ""); struct cleanup *cleanups = make_cleanup_free_command_lines (&l); execute_control_command_untraced (l); do_cleanups (cleanups); } }
dynamic_string_array get_command_line_params() { dynamic_string_array params; #ifdef VOGL_USE_WIN32_API dynamic_string cmd_line; split_command_line_params(get_command_line().c_str(), params); #else const char *pSrc = get_proc_cmdline(); while (*pSrc) { params.push_back(pSrc); pSrc += strlen(pSrc) + 1; } #endif return params; }
int key_enterr(t_link *link) { if (link->line != NULL) { my_putchar('\n'); get_command_line(link, convert_list_to_str(link->line), 1); link->line = NULL; if (link->exit_status == 0 && link->term_caps == 1) display_prompt(link); } else { my_putchar('\n'); display_prompt(link); } sauv_cur(); return (TRUE); }
void op_fnstack1(int level, mval *result) { int cur_zlevel; result->mvtype = MV_STR; cur_zlevel = dollar_zlevel(); if (-1 == level) { if (!dollar_ecode.index) { MV_FORCE_MVAL(result, cur_zlevel - 1); } else if ((1 < dollar_ecode.index) || (error_frame != dollar_ecode.first_ecode_error_frame)) MV_FORCE_MVAL(result, dollar_stack.index - 1); else { /* we are in first ECODE error-handler */ if (cur_zlevel > dollar_stack.index) { MV_FORCE_MVAL(result, cur_zlevel - 1); } else { MV_FORCE_MVAL(result, dollar_stack.index - 1); } } } else if (0 > level) result->str.len = 0; else if (0 == level) get_command_line(result, FALSE); /* FALSE to indicate we want actual (not processed) command line */ else if (!dollar_stack.index) { if (level < cur_zlevel) get_frame_creation_info(level, cur_zlevel, result); else result->str.len = 0; } else if (level < dollar_stack.index) get_dollar_stack_info(level, DOLLAR_STACK_MODE, result); else if (!dollar_stack.incomplete && (1 == dollar_ecode.index) && (error_frame == dollar_ecode.first_ecode_error_frame) && (level < cur_zlevel)) get_frame_creation_info(level, cur_zlevel, result); else result->str.len = 0; return; }
void if_command (char *arg, int from_tty) { struct command_line *command = NULL; struct cleanup *old_chain; control_level = 1; command = get_command_line (if_control, arg); if (command == NULL) return; old_chain = make_cleanup_restore_integer (&interpreter_async); interpreter_async = 0; execute_control_command_untraced (command); free_command_lines (&command); do_cleanups (old_chain); }
static char *get_input_line(char *mes, int new_cmd) { FILE *f = stdin; char *res; int len; if (strlen(input_buf_ptr) > 0) { res = input_buf_ptr; input_buf_ptr = find_cmd_end(input_buf_ptr); return(res); }; input_buf_ptr = input_buffer; fflush(stdout); memset(input_buffer, 0, READ_BUF_SIZE); current_row = 0; if (read_stdin) { if (mes != (char *)NULL) snprintf(Title, READ_BUF_SIZE, "%s", mes); else strcpy(Title, "hpi_shell> "); printf("%s", Title); res = get_command_line(new_cmd, COMPL_CMD); if (res != (char *)NULL) { strcpy(input_buffer, res); res = input_buffer; } } else if (read_file) { f = input_file; res = fgets(input_buffer, READ_BUF_SIZE - 1, f); } else { printf("Internal error: get_input_line:\n" " No input file\n"); exit(1); }; if (res != (char *)NULL) { len = strlen(res); if ((len > 0) && (res[len - 1] == '\n')) res[len - 1] = 0; input_buf_ptr = find_cmd_end(input_buf_ptr); }; return(res); }
int main(int argc, char **argv, char **env) { init_embedded_perl(); /* Calls Perl to load and construct a new * Term::ReadLine object. */ init_term_readline(); while (1) { /* * get_command_line calls Perl to get a scalar from stdin */ /* Perl Term::ReadLine::readline() method chomps the "\n" * from the end of the input. */ char *cmd,*end; /* Allow any length command line */ cmd = (get_command_line ()) ; // Trim leading whitespace while (isspace (*cmd)) cmd++; // Trim trailing whitespace end = cmd + strlen (cmd) - 1; while (end > cmd && isspace (*end)) end--; // Write new null terminator *(end+1) = 0; run_plugin (cmd) ; } deinit_embedded_perl(); }
void zshow_svn(zshow_out *output) { mstr x; mval var, zdir; io_log_name *tl; stack_frame *fp; int count, save_dollar_zlevel; char *c1, *c2; char zdir_error[3 * GTM_MAX_DIR_LEN + 128]; /* PATH_MAX + "->" + GTM-W-ZDIROUTOFSYNC, <text of ZDIROUTOFSYNC> */ error_def(ERR_ZDIROUTOFSYNC); /* SV_DEVICE */ get_dlr_device(&var); ZS_VAR_EQU(&x, device_text); mval_write(output, &var, TRUE); /* SV_ECODE */ ecode_get(-1, &var); ZS_VAR_EQU(&x, ecode_text); mval_write(output, &var, TRUE); /* SV_ESTACK */ save_dollar_zlevel = dollar_zlevel(); count = (save_dollar_zlevel - 1) - dollar_estack_delta.m[0]; MV_FORCE_MVAL(&var, count); ZS_VAR_EQU(&x, estack_text); mval_write(output, &var, TRUE); /* SV_ETRAP */ var.mvtype = MV_STR; var.str = dollar_etrap.str; ZS_VAR_EQU(&x, etrap_text); mval_write(output, &var, TRUE); /* SV_HOROLOG */ op_horolog(&var); ZS_VAR_EQU(&x, horolog_text); mval_write(output, &var, TRUE); /* SV_IO */ var.str.addr = io_curr_device.in->name->dollar_io; var.str.len = io_curr_device.in->name->len; /*** The following should be in the I/O code ***/ if (ESC == *var.str.addr) { if (5 > var.str.len) var.str.len = 0; else { var.str.addr += ESC_OFFSET; var.str.len -= ESC_OFFSET; } } var.mvtype = MV_STR; ZS_VAR_EQU(&x, io_text); mval_write(output, &var, TRUE); /* SV_JOB */ ZS_VAR_EQU(&x, job_text); mval_write(output, &dollar_job, TRUE); /* SV_KEY */ get_dlr_key(&var); ZS_VAR_EQU(&x, key_text); mval_write(output, &var, TRUE); /* SV_PRINCIPAL */ if (dollar_principal) tl = dollar_principal; else tl = io_root_log_name->iod->trans_name; var.str.addr = tl->dollar_io; var.str.len = tl->len; /*** The following should be in the I/O code ***/ if (ESC == *var.str.addr) { if (5 > var.str.len) var.str.len = 0; else { var.str.addr += ESC_OFFSET; var.str.len -= ESC_OFFSET; } } var.mvtype = MV_STR; ZS_VAR_EQU(&x, principal_text); mval_write(output, &var, TRUE); /* SV_QUIT */ count = ((NULL == get_ret_targ()) ? 0 : 1); MV_FORCE_MVAL(&var, count); ZS_VAR_EQU(&x, quit_text); mval_write(output, &var, TRUE); /* SV_REFERENCE */ get_reference(&var); ZS_VAR_EQU(&x, reference_text); mval_write(output, &var, TRUE); /* SV_STACK */ count = (save_dollar_zlevel - 1); MV_FORCE_MVAL(&var, count); ZS_VAR_EQU(&x, stack_text); mval_write(output, &var, TRUE); /* SV_STORAGE */ i2mval(&var, getstorage()); ZS_VAR_EQU(&x, storage_text); mval_write(output, &var, TRUE); /* SV_SYSTEM */ var.mvtype = MV_STR; var.str = dollar_system.str; ZS_VAR_EQU(&x, system_text); mval_write(output, &var, TRUE); /* SV_TEST */ i2mval(&var, (int)op_dt_get()); ZS_VAR_EQU(&x, test_text); mval_write(output, &var, TRUE); /* SV_TLEVEL */ count = (int)dollar_tlevel; MV_FORCE_MVAL(&var, count); ZS_VAR_EQU(&x, tlevel_text); mval_write(output, &var, TRUE); /* SV_TRESTART */ MV_FORCE_MVAL(&var, (int)((MAX_VISIBLE_TRESTART < dollar_trestart) ? MAX_VISIBLE_TRESTART : dollar_trestart)); ZS_VAR_EQU(&x, trestart_text); mval_write(output, &var, TRUE); /* SV_X */ count = (int)io_curr_device.out->dollar.x; MV_FORCE_MVAL(&var, count); ZS_VAR_EQU(&x, x_text); mval_write(output, &var, TRUE); /* SV_Y */ count = (int)io_curr_device.out->dollar.y; MV_FORCE_MVAL(&var, count); ZS_VAR_EQU(&x, y_text); mval_write(output, &var, TRUE); /* SV_ZA */ count = (int)io_curr_device.in->dollar.za; MV_FORCE_MVAL(&var, count); ZS_VAR_EQU(&x, za_text); mval_write(output, &var, TRUE); /* SV_ZB */ c1 = (char *)io_curr_device.in->dollar.zb; c2 = c1 + sizeof(io_curr_device.in->dollar.zb); var.mvtype = MV_STR; var.str.addr = (char *)io_curr_device.in->dollar.zb; while (c1 < c2 && *c1) c1++; var.str.len = (char *)c1 - var.str.addr; ZS_VAR_EQU(&x, zb_text); mval_write(output, &var, TRUE); /* SV_ZCMDLINE */ get_command_line(&var, TRUE); /* TRUE to indicate we want $ZCMDLINE (i.e. processed not actual command line) */ ZS_VAR_EQU(&x, zcmdline_text); mval_write(output, &var, TRUE); /* SV_ZCOMPILE */ var.mvtype = MV_STR; var.str = dollar_zcompile; ZS_VAR_EQU(&x, zcompile_text); mval_write(output, &var, TRUE); /* SV_ZCSTATUS */ MV_FORCE_MVAL(&var, dollar_zcstatus); ZS_VAR_EQU(&x, zcstatus_text); mval_write(output, &var, TRUE); /* SV_ZDATEFORM */ MV_FORCE_MVAL(&var, zdate_form); ZS_VAR_EQU(&x, zdate_form_text); mval_write(output, &var, TRUE); /* SV_ZDIR */ ZS_VAR_EQU(&x, zdirectory_text); setzdir(NULL, &zdir); if (zdir.str.len != dollar_zdir.str.len || 0 != memcmp(zdir.str.addr, dollar_zdir.str.addr, zdir.str.len)) { memcpy(zdir_error, zdir.str.addr, zdir.str.len); memcpy(&zdir_error[zdir.str.len], arrow_text, STR_LIT_LEN(arrow_text)); sgtm_putmsg(&zdir_error[zdir.str.len + STR_LIT_LEN(arrow_text)], VARLSTCNT(6) ERR_ZDIROUTOFSYNC, 4, zdir.str.len, zdir.str.addr, dollar_zdir.str.len, dollar_zdir.str.addr); zdir.str.addr = zdir_error; zdir.str.len = strlen(zdir_error) - 1; /* eliminate trailing '\n' */ } SKIP_DEVICE_IF_NOT_NEEDED(&zdir); mval_write(output, &zdir, TRUE); /* SV_ZEDITOR */ MV_FORCE_MVAL(&var, dollar_zeditor); ZS_VAR_EQU(&x, zeditor_text); mval_write(output, &var, TRUE); /* SV_ZEOF */ ZS_VAR_EQU(&x, zeof_text); mval_write(output, io_curr_device.in->dollar.zeof ? (mval *)&literal_one : (mval *)&literal_zero, TRUE); /* SV_ZERROR */ var.mvtype = MV_STR; var.str = dollar_zerror.str; ZS_VAR_EQU(&x, zerror_text); mval_write(output, &var, TRUE); /* SV_ZGBLDIR */ ZS_VAR_EQU(&x, zgbldir_text); mval_write(output, &dollar_zgbldir, TRUE); /* SV_ZININTERRUPT */ MV_FORCE_MVAL(&var, dollar_zininterrupt); ZS_VAR_EQU(&x, zininterrupt_text); mval_write(output, &var, TRUE); /* SV_ZINTERRUPT */ var.mvtype = MV_STR; var.str = dollar_zinterrupt.str; ZS_VAR_EQU(&x, zinterrupt_text); mval_write(output, &var, TRUE); /* SV_ZIO */ var.mvtype = MV_STR; /* NOTE: This is **NOT** equivalent to : * io_curr_log_name->dollar_io */ var.str.addr = io_curr_device.in->trans_name->dollar_io; var.str.len = io_curr_device.in->trans_name->len; if (*var.str.addr == ESC) { if (5 > var.str.len) var.str.len = 0; else { var.str.addr += ESC_OFFSET; var.str.len -= ESC_OFFSET; } } ZS_VAR_EQU(&x, zio_text); mval_write(output, &var, TRUE); /* SV_ZJOB */ MV_FORCE_ULONG_MVAL(&var, dollar_zjob); ZS_VAR_EQU(&x, zjob_text); mval_write(output, &var, TRUE); /* SV_ZLEVEL */ MV_FORCE_MVAL(&var, save_dollar_zlevel); ZS_VAR_EQU(&x, zlevel_text); mval_write(output, &var, TRUE); /* SV_ZMAXTPTIME */ MV_FORCE_MVAL(&var, dollar_zmaxtptime); ZS_VAR_EQU(&x, zmaxtptime_text); mval_write(output, &var, TRUE); /* SV_ZMODE */ ZS_VAR_EQU(&x, zmode_text); mval_write(output, &dollar_zmode, TRUE); /* SV_ZPOS */ getzposition(&var); ZS_VAR_EQU(&x, zpos_text); mval_write(output, &var, TRUE); /* SV_ZPROC */ ZS_VAR_EQU(&x, zproc_text); mval_write(output, &dollar_zproc, TRUE); /* SV_PROMPT */ var.mvtype = MV_STR; var.str.addr = gtmprompt.addr; var.str.len = gtmprompt.len; ZS_VAR_EQU(&x, zprompt_text); mval_write(output, &var, TRUE); /* SV_ZROUTINES */ if (!zro_root) zro_init(); var.mvtype = MV_STR; var.str = dollar_zroutines; ZS_VAR_EQU(&x, zroutines_text); mval_write(output, &var, TRUE); /* SV_ZSOURCE */ var.mvtype = MV_STR; var.str = dollar_zsource; ZS_VAR_EQU(&x, zsource_text); mval_write(output, &var, TRUE); /* SV_ZSTATUS */ ZS_VAR_EQU(&x, zstatus_text); mval_write(output, &dollar_zstatus, TRUE); /* SV_ZSTEP */ ZS_VAR_EQU(&x, zstep_text); mval_write(output, &dollar_zstep, TRUE); /* SV_ZSYSTEM */ MV_FORCE_MVAL(&var, dollar_zsystem); ZS_VAR_EQU(&x, zsystem_text); mval_write(output, &var, TRUE); /* SV_ZTEXIT */ var.mvtype = MV_STR; var.str = dollar_ztexit.str; ZS_VAR_EQU(&x, ztexit_text); mval_write(output, &var, TRUE); /* SV_ZTRAP */ var.mvtype = MV_STR; var.str = dollar_ztrap.str; ZS_VAR_EQU(&x, ztrap_text); mval_write(output, &var, TRUE); /* SV_ZVERSION */ var.mvtype = MV_STR; var.str.addr = (char *)>m_release_name[0]; var.str.len = gtm_release_name_len; ZS_VAR_EQU(&x, zversion_text); mval_write(output, &var, TRUE); /* SV_ZYERROR */ var.mvtype = MV_STR; var.str = dollar_zyerror.str; ZS_VAR_EQU(&x, zyerror_text); mval_write(output, &var, TRUE); }
int main(int argc, char **argv) { struct sigaction sa; char *cmdline_str; char **argv_array; GMainLoop *loop; argv_array = argv_to_array(argc, argv); cmdline_str = get_command_line(argv_array); set_argv_for_child_process(argv_array); cps_config_init(argc, argv); if(global_config.daemonize) { /* When daemonizing, a child process will be launched with daemonization disabled */ daemonize(); run_watchdog(argv_array); /* Watchdog should never stop ! */ exit(EXIT_FAILURE); } /* The child (or not daemonized process) will continue here. */ L (LOGLEVEL_WARNING, PACKAGE_NAME "-" PACKAGE_VERSION " starting"); L (LOGLEVEL_DEBUG, "Command line : %s", cmdline_str); g_free(cmdline_str); /* Signals initialization {{{ */ memset (&sa, 0, sizeof (sa)); sa.sa_sigaction = signal_handler_for_stop; sa.sa_flags = SA_SIGINFO; sigemptyset(&(sa.sa_mask)); if(0 != sigaction(SIGTERM, &sa, NULL)) { L (LOGLEVEL_CRITICAL, "Could not set signal handler for TERM"); exit(EXIT_FAILURE); } if(0 != sigaction(SIGINT, &sa, NULL)) { L (LOGLEVEL_CRITICAL, "Could not set signal handler for INT"); close_all_and_exit(EXIT_FAILURE); } if(0 != sigaction(SIGQUIT, &sa, NULL)) { L (LOGLEVEL_CRITICAL, "Could not set signal handler for QUIT"); close_all_and_exit(EXIT_FAILURE); } memset (&sa, 0, sizeof (sa)); sa.sa_handler = SIG_IGN; sa.sa_flags = SA_RESTART; sigemptyset(&(sa.sa_mask)); if(0 != sigaction(SIGPIPE, &sa, NULL)) { L (LOGLEVEL_CRITICAL, "Could not set signal handler for PIPE"); exit(EXIT_FAILURE); } /* }}} */ cpsa_init(); loop = g_main_new(TRUE); g_timeout_add_seconds(global_config.agent__interval, cpsa_get_process, NULL); g_main_run( loop ); L (LOGLEVEL_WARNING, PACKAGE_NAME "-" PACKAGE_VERSION " ending"); exit(EXIT_SUCCESS); }
int main(int argc, char **argv) { Settings settings; int i; char *bam_file = NULL; samfile_t *fp_bam = NULL; const char *override_intensity_dir = NULL; const char *filter_file = NULL; int ntiles = 0; int nreads = 0; int nst = 0; SurvTable *sts[(N_TILES+1)*N_READS]; int nct = 0; CalTable *cts[(N_TILES+1)*N_READS]; settings.prefix = NULL; settings.quiet = 0; settings.filter_bad_tiles = 0; settings.spatial_filter = 0; settings.region_size = 0; settings.nregions_x = 0; settings.nregions_y = 0; settings.n_bins_left = 2; settings.n_bins_right = 2; settings.cstart[0] = 0; settings.cstart[1] = 0; settings.cstart[2] = 0; settings.intensity_dir = NULL; settings.snp_file = NULL; settings.snp_hash = NULL; settings.read_length[0] = 0; settings.read_length[1] = 0; settings.read_length[2] = 0; settings.working_dir = NULL; settings.cmdline = get_command_line(argc, argv); /* Parse args */ for (i = 1; i < argc && argv[i][0] == '-'; i++) { if (!strcmp(argv[i], "-")) { break; } else if (!strcmp(argv[i], "-intensity-dir")) { if(override_intensity_dir != NULL) { fprintf(stderr, "ERROR: -intensity-dir option specified multiple times\n"); usage(1); } check_arg(i,argc,"-intensity-dir"); override_intensity_dir = argv[++i]; } else if (!strcmp(argv[i], "-snp_file")) { if(settings.snp_file != NULL) { fprintf(stderr, "ERROR: -snp_file specified multiple times\n"); usage(1); } check_arg(i,argc,"-snp_file"); settings.snp_file = argv[++i]; } else if (!strcmp(argv[i], "-filter_file")) { if(filter_file != NULL) { fprintf(stderr, "ERROR: -filter_file specified multiple times\n"); usage(1); } check_arg(i,argc,"-filter_file"); filter_file = argv[++i]; } else if (!strcmp(argv[i], "-q")) { settings.quiet = 1; } else if (!strcmp(argv[i], "-p")) { if(settings.prefix != NULL) { fprintf(stderr, "ERROR: -p option specified multiple times\n"); usage(1); } check_arg(i,argc,"-p"); settings.prefix = argv[++i]; } else if (!strcmp(argv[i], "-filter-bad-tiles")){ settings.filter_bad_tiles = atoi(argv[++i]); if(settings.filter_bad_tiles < 1){ fprintf(stderr,"ERROR: invalid argument to -filter_bad_tiles\n"); usage(1); } } else if (!strcmp(argv[i], "-cstart1")){ check_arg(i,argc,"-cstart1"); settings.cstart[1] = atoi(argv[++i]); if(settings.cstart[1] < 1){ fprintf(stderr,"ERROR: invalid argument to -cstart1\n"); usage(1); } /* cycles are indexed from 0 not 1 */ --settings.cstart[1]; } else if (!strcmp(argv[i], "-cstart2")){ check_arg(i,argc,"-cstart2"); settings.cstart[2] = atoi(argv[++i]); if(settings.cstart[2] < 1){ fprintf(stderr,"ERROR: invalid argument to -cstart2\n"); usage(1); } /* cycles are indexed from 0 not 1 */ --settings.cstart[2]; } else if (!strcmp(argv[i], "-cstart")){ check_arg(i,argc,"-cstart"); settings.cstart[0] = atoi(argv[++i]); if(settings.cstart[0] < 1){ fprintf(stderr,"ERROR: invalid argument to -cstart\n"); usage(1); } /* cycles are indexed from 0 not 1 */ --settings.cstart[0]; } else if (!strcmp(argv[i], "-nL")){ check_arg(i,argc,"-nL"); settings.n_bins_left = atoi(argv[++i]); if(settings.n_bins_left < 0){ fprintf(stderr,"ERROR: invalid argument to -nL\n"); usage(1); } } else if (!strcmp(argv[i], "-nR")){ check_arg(i,argc,"-nR"); settings.n_bins_right = atoi(argv[++i]); if(settings.n_bins_right < 0){ fprintf(stderr,"ERROR: invalid argument to -nR\n"); usage(1); } } else if (!strcmp(argv[i], "-h")) { usage(0); } else { fprintf(stderr,"ERROR: Unknown option %s\n", argv[i]); usage(1); } } if ((argc-i) < 1) usage(0); /* preserve starting directory b/c makeSurvTable is going to chdir all over the place */ settings.working_dir = alloc_getcwd(); if (NULL == settings.working_dir) { fprintf(stderr, "ERROR: can't obtain working directory: %s\n", strerror(errno)); exit(EXIT_FAILURE); } /* get absolute intensity dir*/ if (override_intensity_dir) { settings.intensity_dir = get_real_path_name(override_intensity_dir); if (NULL == settings.intensity_dir) { fprintf(stderr, "ERROR: can't process intensity dir: %s\n", override_intensity_dir); exit(EXIT_FAILURE); } } else { fprintf(stderr,"ERROR: you must specify an intensity dir\n"); exit(EXIT_FAILURE); } /* read the snp_file */ if (NULL != settings.snp_file) { settings.snp_hash = readSnpFile(settings.snp_file); if (NULL == settings.snp_hash) { fprintf(stderr, "ERROR: reading snp file %s\n", settings.snp_file); exit(EXIT_FAILURE); } } /* read filter file */ if (NULL != filter_file) { FILE *fp = fopen(filter_file, "rb"); if (!fp) die("Can't open filter file %s\n", filter_file); Header filter_header; readHeader(fp, &filter_header); readFilterData(fp, &filter_header); settings.spatial_filter = 1; settings.region_size = filter_header.region_size; settings.nregions_x = filter_header.nregions_x; settings.nregions_y = filter_header.nregions_y; } /* Look for CIF directories */ get_cif_dirs(settings.intensity_dir); /* open the bam file */ bam_file = argv[i++]; fp_bam = samopen(bam_file, "rb", 0); if (NULL == fp_bam) { fprintf(stderr, "ERROR: can't open bam file file %s: %s\n", bam_file, strerror(errno)); exit(EXIT_FAILURE); } /* make the survival table */ nst = makeSurvTable(&settings, fp_bam, sts, &ntiles, &nreads); if (0 == nst) { fprintf(stderr,"ERROR: failed to make survival table\n"); exit(EXIT_FAILURE); } if (!settings.quiet) { fprintf(stderr, "Processed %8d traces\n", nreads); if (NULL != settings.snp_hash) { HashIter *tileIter = HashTableIterCreate(); HashItem *hashItem; size_t nsnps = 0; while ((hashItem = HashTableIterNext(settings.snp_hash, tileIter))) nsnps += hashItem->data.i; fprintf(stderr, "Ignored %lu snps\n", nsnps); } } /* back to where we belong */ checked_chdir(settings.working_dir); if (!settings.spatial_filter) makeGlobalSurvTable(&settings, ntiles, sts); outputSurvTable(&settings, sts); nct = makeCalTable(&settings, sts, cts); if (0 == nct) { fprintf(stderr,"ERROR: failed to make calibration table\n"); exit(EXIT_FAILURE); } outputCalTable(&settings, cts); /* close the bam file */ samclose(fp_bam); freeCalTable(&settings, cts); freeSurvTable(&settings, sts); if (NULL != settings.working_dir) free(settings.working_dir); return EXIT_SUCCESS; }
void op_svget(int varnum, mval *v) { io_log_name *tl; int count; gtm_uint64_t ucount; char *c1, *c2; mval *mvp; # ifdef UNIX d_rm_struct *d_rm; # endif DCL_THREADGBL_ACCESS; SETUP_THREADGBL_ACCESS; # if defined(UNIX) && defined(DEBUG) if (gtm_white_box_test_case_enabled && (WBTEST_HUGE_ALLOC == gtm_white_box_test_case_number)) { if (1 == gtm_white_box_test_case_count) totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xffff; else if (2 == gtm_white_box_test_case_count) totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xfffffff; else if (3 == gtm_white_box_test_case_count) { # ifdef GTM64 if (8 == SIZEOF(size_t)) totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xfffffffffffffff; else # endif totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xfffffff; } else totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = GTM64_ONLY(SIZEOF(size_t)) NON_GTM64_ONLY(SIZEOF(size_t) > 4 ? 4 : SIZEOF(size_t)); } # endif switch (varnum) { case SV_HOROLOG: op_horolog(v); break; case SV_ZGBLDIR: v->mvtype = MV_STR; v->str = dollar_zgbldir.str; break; case SV_PRINCIPAL: tl = dollar_principal ? dollar_principal : io_root_log_name->iod->trans_name; v->str.addr = tl->dollar_io; v->str.len = tl->len; /*** The following should be in the I/O code ***/ if (ESC == *v->str.addr) { if (5 > v->str.len) v->str.len = 0; else { v->str.addr += ESC_OFFSET; v->str.len -= ESC_OFFSET; } } s2pool(&(v->str)); v->mvtype = MV_STR; break; case SV_ZIO: v->mvtype = MV_STR; /* NOTE: This is **NOT** equivalent to : * io_curr_log_name->dollar_io */ v->str.addr = io_curr_device.in->trans_name->dollar_io; v->str.len = io_curr_device.in->trans_name->len; if (ESC == *v->str.addr) { if (5 > v->str.len) v->str.len = 0; else { v->str.addr += ESC_OFFSET; v->str.len -= ESC_OFFSET; } } s2pool(&(v->str)); break; case SV_JOB: *v = dollar_job; break; case SV_REFERENCE: get_reference(v); break; case SV_SYSTEM: *v = dollar_system; break; case SV_STORAGE: /* double2mval(v, getstorage()); Causes issues with unaligned stack on x86_64 - remove until fixed */ i2mval(v, getstorage()); break; case SV_TLEVEL: count = (int)dollar_tlevel; MV_FORCE_MVAL(v, count); break; case SV_TRESTART: MV_FORCE_MVAL(v, (int)((MAX_VISIBLE_TRESTART < dollar_trestart) ? MAX_VISIBLE_TRESTART : dollar_trestart)); break; case SV_X: count = (int)io_curr_device.out->dollar.x; MV_FORCE_MVAL(v, count); break; case SV_Y: count = (int)io_curr_device.out->dollar.y; MV_FORCE_MVAL(v, count); break; case SV_ZA: count = (int)io_curr_device.in->dollar.za; MV_FORCE_MVAL(v, count); break; case SV_ZB: c1 = (char *)io_curr_device.in->dollar.zb; c2 = c1 + SIZEOF(io_curr_device.in->dollar.zb); ENSURE_STP_FREE_SPACE(SIZEOF(io_curr_device.in->dollar.zb)); v->mvtype = MV_STR; v->str.addr = (char *)stringpool.free; while (c1 < c2 && *c1) *stringpool.free++ = *c1++; v->str.len = INTCAST((char *)stringpool.free - v->str.addr); break; case SV_ZC: /****THESE ARE DUMMY VALUES ONLY!!!!!!!!!!!!!!!!!****/ MV_FORCE_MVAL(v, 0); break; case SV_ZCMDLINE: get_command_line(v, TRUE); /* TRUE to indicate we want $ZCMDLINE (i.e. processed not actual command line) */ break; case SV_ZEOF: # ifdef UNIX if (rm == io_curr_device.in->type) { d_rm = (d_rm_struct *)io_curr_device.in->dev_sp; if (RM_READ != d_rm->lastop) { *v = literal_zero; break; } } # endif *v = io_curr_device.in->dollar.zeof ? literal_one : literal_zero; break; case SV_ZQUIT: *v = dollar_zquit_anyway ? literal_one : literal_zero; break; case SV_IO: v->str.addr = io_curr_device.in->name->dollar_io; v->str.len = io_curr_device.in->name->len; /*** The following should be in the I/O code ***/ if (ESC == *v->str.addr) { if (5 > v->str.len) v->str.len = 0; else { v->str.addr += ESC_OFFSET; v->str.len -= ESC_OFFSET; } } s2pool(&(v->str)); v->mvtype = MV_STR; break; case SV_PROMPT: v->mvtype = MV_STR; v->str.addr = (TREF(gtmprompt)).addr; v->str.len = (TREF(gtmprompt)).len; s2pool(&v->str); break; case SV_ZCOMPILE: v->mvtype = MV_STR; v->str = TREF(dollar_zcompile); s2pool(&(v->str)); break; case SV_ZDIR: setzdir(NULL, v); if (v->str.len != dollar_zdir.str.len || 0 != memcmp(v->str.addr, dollar_zdir.str.addr, v->str.len)) gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_ZDIROUTOFSYNC, 4, v->str.len, v->str.addr, dollar_zdir.str.len, dollar_zdir.str.addr); SKIP_DEVICE_IF_NOT_NEEDED(v); s2pool(&(v->str)); break; case SV_ZSTEP: *v = dollar_zstep; break; case SV_ZMODE: *v = TREF(dollar_zmode); break; case SV_ZMAXTPTIME: i2mval(v, TREF(dollar_zmaxtptime)); break; case SV_ZPOS: getzposition(v); break; case SV_ZPROC: getzprocess(); *v = dollar_zproc; break; case SV_ZLEVEL: count = dollar_zlevel(); MV_FORCE_MVAL(v, count); break; case SV_ZROUTINES: if (!TREF(zro_root)) zro_init(); v->mvtype = MV_STR; v->str = TREF(dollar_zroutines); s2pool(&(v->str)); break; case SV_ZSOURCE: v->mvtype = MV_STR; v->str = dollar_zsource.str; break; case SV_ZSTATUS: *v = dollar_zstatus; s2pool(&(v->str)); break; case SV_ZTRAP: v->mvtype = MV_STR; v->str = dollar_ztrap.str; assert(!v->str.len || !ztrap_explicit_null); s2pool(&(v->str)); break; case SV_DEVICE: get_dlr_device(v); break; case SV_KEY: get_dlr_key(v); break; case SV_ZVERSION: v->mvtype = MV_STR; v->str.addr = (char *)gtm_release_name; v->str.len = gtm_release_name_len; break; case SV_ZSYSTEM: MV_FORCE_MVAL(v, dollar_zsystem); break; case SV_ZCSTATUS: /* Maintain the external $ZCSTATUS == 1 for SUCCESS on UNIX while internal good is 0 */ MV_FORCE_MVAL(v, UNIX_ONLY((0 == TREF(dollar_zcstatus)) ? 1 : ) TREF(dollar_zcstatus)); break; case SV_ZEDITOR: MV_FORCE_MVAL(v, dollar_zeditor); break; case SV_QUIT: MV_FORCE_MVAL(v, dollar_quit()); break; case SV_ECODE: ecode_get(-1, v); break; case SV_ESTACK: count = (dollar_zlevel() - 1) - dollar_estack_delta.m[0]; MV_FORCE_MVAL(v, count); break; case SV_ETRAP: v->mvtype = MV_STR; v->str = dollar_etrap.str; assert(!v->str.len || !ztrap_explicit_null); s2pool(&(v->str)); break; case SV_STACK: count = (dollar_zlevel() - 1); MV_FORCE_MVAL(v, count); break; case SV_ZERROR: v->mvtype = MV_STR; v->str = dollar_zerror.str; s2pool(&(v->str)); break; case SV_ZYERROR: v->mvtype = MV_STR; v->str = dollar_zyerror.str; s2pool(&(v->str)); break; case SV_ZINTERRUPT: v->mvtype = MV_STR; v->str = dollar_zinterrupt.str; s2pool(&(v->str)); break; case SV_ZININTERRUPT: MV_FORCE_MVAL(v, dollar_zininterrupt); break; case SV_ZJOB: MV_FORCE_UMVAL(v, dollar_zjob); break; case SV_ZDATE_FORM: MV_FORCE_MVAL(v, TREF(zdate_form)); break; case SV_ZTEXIT: *v = dollar_ztexit; break; case SV_ZALLOCSTOR: ucount = (gtm_uint64_t)totalAlloc + (gtm_uint64_t)totalAllocGta; ui82mval(v, ucount); break; case SV_ZREALSTOR: ucount = (gtm_uint64_t)totalRmalloc + (gtm_uint64_t)totalRallocGta; ui82mval(v, ucount); break; case SV_ZUSEDSTOR: ucount = (gtm_uint64_t)totalUsed + (gtm_uint64_t)totalUsedGta; ui82mval(v, ucount); break; case SV_ZCHSET: v->mvtype = MV_STR; v->str = dollar_zchset; break; case SV_ZPATNUMERIC: v->mvtype = MV_STR; v->str = dollar_zpatnumeric; break; case SV_ZTNAME: case SV_ZTCODE: /* deprecated */ # ifdef GTM_TRIGGER if (NULL == dollar_ztname) memcpy(v, &literal_null, SIZEOF(mval)); else { v->mvtype = MV_STR; v->str.addr = dollar_ztname->addr; v->str.len = dollar_ztname->len; } break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTDATA: # ifdef GTM_TRIGGER /* Value comes from GT.M, but it might be numeric and need conversion to a string */ assert(!dollar_ztdata || MV_DEFINED(dollar_ztdata)); if (NULL != dollar_ztdata) MV_FORCE_STR(dollar_ztdata); memcpy(v, (NULL != dollar_ztdata) ? dollar_ztdata : &literal_null, SIZEOF(mval)); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTDELIM: # ifdef GTM_TRIGGER assert(!dollar_ztdelim || MV_DEFINED(dollar_ztdelim)); if (NULL == dollar_ztdelim || !(MV_STR & dollar_ztdelim->mvtype) || (0 == dollar_ztdelim->str.len)) memcpy(v, &literal_null, SIZEOF(mval)); else memcpy(v, dollar_ztdelim, SIZEOF(mval)); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTOLDVAL: # ifdef GTM_TRIGGER /* Value comes from GT.M, but it might be numeric and need conversion to a string */ assert(!dollar_ztoldval || MV_DEFINED(dollar_ztoldval)); if (NULL != dollar_ztoldval) MV_FORCE_STR(dollar_ztoldval); memcpy(v, (NULL != dollar_ztoldval) ? dollar_ztoldval : &literal_null, SIZEOF(mval)); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTRIGGEROP: # ifdef GTM_TRIGGER /* Value comes from GT.M, but assert it's a string */ assert(!dollar_ztriggerop || (MV_STR & dollar_ztriggerop->mvtype)); memcpy(v, (NULL != dollar_ztriggerop) ? dollar_ztriggerop : &literal_null, SIZEOF(mval)); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTUPDATE: # ifdef GTM_TRIGGER /* Value comes from GT.M, but if there were no delims involved, the value will be undefined, and * we return a "literal_null". */ memcpy(v, ((NULL != dollar_ztupdate && (MV_STR & dollar_ztupdate->mvtype)) ? dollar_ztupdate : &literal_null), SIZEOF(mval)); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTVALUE: # ifdef GTM_TRIGGER /* Value comes from user-land so make sure things are proper */ assert(!dollar_ztvalue || MV_DEFINED(dollar_ztvalue)); if (NULL != dollar_ztvalue) MV_FORCE_STR(dollar_ztvalue); memcpy(v, (NULL != dollar_ztvalue) ? dollar_ztvalue : &literal_null, SIZEOF(mval)); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTWORMHOLE: # ifdef GTM_TRIGGER /* Value comes from user-land so make sure things are proper */ mvp = &dollar_ztwormhole; if (MV_DEFINED(mvp)) { MV_FORCE_STR(mvp); memcpy(v, mvp, SIZEOF(mval)); } else memcpy(v, &literal_null, SIZEOF(mval)); ztwormhole_used = TRUE; break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTSLATE: # ifdef GTM_TRIGGER /* Value comes from user-land so make sure things are proper */ assert(MV_DEFINED((&dollar_ztslate))); mvp = &dollar_ztslate; MV_FORCE_STR(mvp); memcpy(v, mvp, SIZEOF(mval)); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTLEVEL: # ifdef GTM_TRIGGER MV_FORCE_MVAL(v, gtm_trigger_depth); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZONLNRLBK: # ifdef UNIX count = TREF(dollar_zonlnrlbk); MV_FORCE_MVAL(v, count); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZCLOSE: # ifdef UNIX count = TREF(dollar_zclose); MV_FORCE_MVAL(v, count); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZKEY: get_dlr_zkey(v); break; default: assertpro(FALSE); } }
int multiboot_x86_load(int argc, char **argv, const char *buf, off_t len, struct kexec_info *info) /* Marshal up a multiboot-style kernel */ { struct multiboot_info *mbi; void *mbi_buf; struct mod_list *modp; unsigned long freespace; unsigned long long mem_lower = 0, mem_upper = 0; struct mem_ehdr ehdr; unsigned long mbi_base; struct entry32_regs regs; size_t mbi_bytes, mbi_offset; char *command_line = NULL; char *imagename, *cp, *append = NULL;; struct memory_range *range; int ranges; struct AddrRangeDesc *mmap; int command_line_len; int i; uint32_t u; int opt; int modules, mod_command_line_space; /* See options.h -- add any more there, too. */ static const struct option options[] = { KEXEC_ARCH_OPTIONS { "command-line", 1, 0, OPT_CL }, { "append", 1, 0, OPT_CL }, { "reuse-cmdline", 0, 0, OPT_REUSE_CMDLINE }, { "module", 1, 0, OPT_MOD }, { 0, 0, 0, 0 }, }; static const char short_options[] = KEXEC_ARCH_OPT_STR ""; /* Probe for the MB header if it's not already found */ if (mbh == NULL && multiboot_x86_probe(buf, len) != 1) { fprintf(stderr, "Cannot find a loadable multiboot header.\n"); return -1; } /* Parse the command line */ command_line = ""; command_line_len = 0; modules = 0; mod_command_line_space = 0; while((opt = getopt_long(argc, argv, short_options, options, 0)) != -1) { switch(opt) { default: /* Ignore core options */ if (opt < OPT_ARCH_MAX) { break; } case '?': usage(); return -1; case OPT_CL: append = optarg; break; case OPT_REUSE_CMDLINE: command_line = get_command_line(); break; case OPT_MOD: modules++; mod_command_line_space += strlen(optarg) + 1; break; } } imagename = argv[optind]; command_line = concat_cmdline(command_line, append); command_line_len = strlen(command_line) + strlen(imagename) + 2; /* Load the ELF executable */ elf_exec_build_load(info, &ehdr, buf, len, 0); /* Load the setup code */ elf_rel_build_load(info, &info->rhdr, purgatory, purgatory_size, 0, ULONG_MAX, 1, 0); /* The first segment will contain the multiboot headers: * ============= * multiboot information (mbi) * ------------- * kernel command line * ------------- * bootloader name * ------------- * module information entries * ------------- * module command lines * ============== */ mbi_bytes = (sizeof(*mbi) + command_line_len + strlen (BOOTLOADER " " BOOTLOADER_VERSION) + 1 + 3) & ~3; mbi_buf = xmalloc(mbi_bytes); mbi = mbi_buf; memset(mbi, 0, sizeof(*mbi)); sprintf(((char *)mbi) + sizeof(*mbi), "%s %s", imagename, command_line); sprintf(((char *)mbi) + sizeof(*mbi) + command_line_len, "%s", BOOTLOADER " " BOOTLOADER_VERSION); mbi->flags = MB_INFO_CMDLINE | MB_INFO_BOOT_LOADER_NAME; /* We'll relocate these to absolute addresses later. For now, * all addresses within the first segment are relative to the * start of the MBI. */ mbi->cmdline = sizeof(*mbi); mbi->boot_loader_name = sizeof(*mbi) + command_line_len; /* Memory map */ if ((get_memory_ranges(&range, &ranges, info->kexec_flags) < 0) || ranges == 0) { fprintf(stderr, "Cannot get memory information\n"); return -1; } mmap = xmalloc(ranges * sizeof(*mmap)); for (i=0; i<ranges; i++) { unsigned long long length; length = range[i].end - range[i].start; /* Translate bzImage mmap to multiboot-speak */ mmap[i].size = sizeof(mmap[i]) - 4; mmap[i].base_addr_low = range[i].start & 0xffffffff; mmap[i].base_addr_high = range[i].start >> 32; mmap[i].length_low = length & 0xffffffff; mmap[i].length_high = length >> 32; if (range[i].type == RANGE_RAM) { mmap[i].Type = 1; /* RAM */ /* Is this the "low" memory? */ if ((range[i].start == 0) && (range[i].end > mem_lower)) mem_lower = range[i].end; /* Is this the "high" memory? */ if ((range[i].start <= 0x100000) && (range[i].end > mem_upper + 0x100000)) mem_upper = range[i].end - 0x100000; } else mmap[i].Type = 0xbad; /* Not RAM */ } if (mbh->flags & MULTIBOOT_MEMORY_INFO) { /* Provide a copy of the memory map to the kernel */ mbi->flags |= MB_INFO_MEMORY | MB_INFO_MEM_MAP; freespace = add_buffer(info, mmap, ranges * sizeof(*mmap), ranges * sizeof(*mmap), 4, 0, 0xFFFFFFFFUL, 1); mbi->mmap_addr = freespace; mbi->mmap_length = ranges * sizeof(*mmap); /* For kernels that care naught for fancy memory maps * and just want the size of low and high memory */ mbi->mem_lower = MIN(mem_lower>>10, 0xffffffff); mbi->mem_upper = MIN(mem_upper>>10, 0xffffffff); /* done */ }
static void process_command_line(int argc, char **argv, AMA_OPTIONS_T *options) { int option_index = 0; const int num_options = 16; struct option ama_options[] = { {"max-seq-length", required_argument, NULL, OPT_MAX_SEQ_LENGTH}, {"motif", required_argument, NULL, OPT_MOTIF}, {"motif-pseudo", required_argument, NULL, OPT_MOTIF_PSEUDO}, {"rma", no_argument, NULL, OPT_RMA}, {"pvalues", no_argument, NULL, OPT_PVALUES}, {"sdbg", required_argument, NULL, OPT_SDBG}, {"norc", no_argument, NULL, OPT_NORC}, {"cs", no_argument, NULL, OPT_CS}, {"o-format", required_argument, NULL, OPT_O_FORMAT}, {"o", required_argument, NULL, OPT_O}, {"oc", required_argument, NULL, OPT_OC}, {"scoring", required_argument, NULL, OPT_SCORING}, {"verbosity", required_argument, NULL, OPT_VERBOSITY}, {"gcbins", required_argument, NULL, OPT_GCBINS}, {"last", required_argument, NULL, OPT_LAST}, {"version", no_argument, NULL, OPT_VERSION}, {NULL, 0, NULL, 0} //boundary indicator }; bool out_set = false; bool format_set = false; // set option defaults options->max_seq_length = MAX_SEQ; options->scan_both_strands = true; options->combine_duplicates = false; options->selected_motifs = rbtree_create(rbtree_strcmp, NULL, NULL, NULL, NULL); options->pseudocount = DEFAULT_PSEUDOCOUNT; options->output_format = CISML_FORMAT; options->clobber = false; options->out_dir = NULL; options->scoring = AVG_ODDS; options->pvalues = false; options->normalize_scores = false; options->num_gc_bins = 1; options->sdbg_order = -1; options->last = 0; options->motif_filename = NULL; options->fasta_filename = NULL; options->bg_filename = NULL; // parse command line while (1) { int opt = getopt_long_only(argc, argv, "", ama_options, NULL); if (opt == -1) break; switch (opt) { case OPT_MAX_SEQ_LENGTH: options->max_seq_length = atoi(optarg); break; case OPT_MOTIF: rbtree_make(options->selected_motifs, optarg, NULL); break; case OPT_MOTIF_PSEUDO: options->pseudocount = atof(optarg); break; case OPT_RMA: options->normalize_scores = true; break; case OPT_PVALUES: options->pvalues = true; break; case OPT_SDBG: options->sdbg_order = atoi(optarg); // >=0 means use sequence bkg break; case OPT_NORC: options->scan_both_strands = false; break; case OPT_CS: options->combine_duplicates = true; break; case OPT_O_FORMAT: if (out_set) { usage("Option -o-format is incompatible with option -o/-oc"); } else { format_set = true; if (strcmp(optarg, "gff") == 0) { options->output_format = GFF_FORMAT; } else if (strcmp(optarg, "cisml") == 0) { options->output_format = CISML_FORMAT; } else { usage("Output format \"%s\" is not recognised. " "Expected \"gff\" or \"cisml\".", optarg); } } break; case OPT_OC: options->clobber = true; case OPT_O: if (format_set) { usage("Option -o/-oc is incompatible with option -o-format"); } else { out_set = true; options->out_dir = optarg; options->output_format = DIRECTORY_FORMAT; } break; case OPT_SCORING: if (strcmp(optarg, "max-odds") == 0) { options->scoring = MAX_ODDS; } else if (strcmp(optarg, "avg-odds") == 0) { options->scoring = AVG_ODDS; } else if (strcmp(optarg, "sum-odds") == 0) { options->scoring = SUM_ODDS; } else { usage("Scoring method \"%s\" is not recognised. " "Expected \"max-odds\", \"avg-odds\" or \"sum-odds\".", optarg); } break; case OPT_VERBOSITY: verbosity = atoi(optarg); break; case OPT_GCBINS: options->num_gc_bins = atoi(optarg); options->pvalues = true; if (options->num_gc_bins <= 1) usage("Number of bins in --gcbins must be greater than 1."); break; case OPT_LAST: options->last = atoi(optarg); if (options->last < 0) usage("Option --last must not be negative."); break; case OPT_VERSION: fprintf(stdout, VERSION "\n"); exit(EXIT_SUCCESS); break; case '?': //unrecognised or ambiguous argument usage("Unrecognized or ambiguous option."); } } // --sdbg overrides --pvalues and --gcbins and --rma if (options->sdbg_order >= 0) { options->pvalues = false; options->normalize_scores = false; options->num_gc_bins = 1; } if (argc <= optind) usage("Expected motif file."); options->motif_filename = argv[optind++]; if (argc <= optind) usage("Expected fasta file."); options->fasta_filename = argv[optind++]; if (argc > optind) options->bg_filename = argv[optind++]; if (options->sdbg_order >= 0) { if (options->bg_filename) usage("A background file can not be used together with --sdbg."); } else { if (!options->bg_filename) usage("You must provide a background file unless you specify --sdbg."); } if (argc > optind) usage("Too many parameters"); // for now, use uniform to mimic old implementation. I will probably remove this later if (!options->bg_filename) options->bg_filename = "--uniform--"; // Record the command line. options->command_line = get_command_line(argc, argv); }
void OutputStream::write_header() { this->printf("# File \"%s\": generated at %s by the command:\n" "# %s\n", s_filename, get_timestamp(), get_command_line()); }
int builtin_man(t_link *link, char **cmd) { (void)cmd; get_command_line(link, my_strdup("cat < .man42sh | less"), 0); return (TRUE); }
int main (int argc, char * argv[]) { std::streambuf *psbuf = NULL; std::ofstream log_stream; std::streambuf *pStreambuf = std::cout.rdbuf(); //--------------RNG INIT STUFF srand((unsigned)time(0)); long seed; r = gsl_rng_alloc (gsl_rng_rand48); // pick random number generator seed = time (NULL) * getpid(); gsl_rng_set (r, seed); // set seed // TESTING AREA //--------------- DBN *dbn; if (command_option_exists(argv, argv+argc, "-n")) { dbn = return_network(); std::cout << dbn << std::endl; std::cout << "Ready to learn" << std::endl; std::cout << "If you are using visualization:" << std::endl; std::cout << "'V': pauses visualization" << std::endl; std::cout << "<SPACE>: pauses learning" << std::endl; std::cout << "'+'/'-' increases/decreases learning rate" << std::endl; std::cout << "'['/']' increases/decreases output threshold" << std::endl; std::cout << "'L' stops learning for layer (skips to next if any)" << std::endl; std::cout << "Current visualization is the features displayed on top with the plot of the reconstruction cost in the box (gl text not supported yet)" << std::endl; std::cout << "Press <ENTER> to start learning: "; std::cin.get(); } else if (command_option_exists(argv, argv+argc, "-l")) { std::string filename = get_command_line(argv, argv+argc, "-l"); MLP mlp = load_MLP(filename); dbn = new DBN(mlp); dbn->data_layers.clear(); dbn->view(); exit(EXIT_SUCCESS); } else if (command_option_exists(argv, argv+argc, "-f")) { if (argc != 3) { print_usage(); exit(EXIT_FAILURE); } //Initialization, time, logfile stuff, etc. time_t t = time(0); // get time now struct tm * the_time = localtime( & t ); mkdir(out_path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); out_path += convert_to_string(*the_time) + "/"; mkdir((out_path).c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); std::string filename = get_command_line(argv, argv+argc, "-f"); dbn = return_aod_network(filename, log_stream, psbuf); } else if (command_option_exists(argv, argv+argc, "-F")) { std::string filename = get_command_line(argv, argv+argc, "-F"); MLP mlp = load_MLP(filename); Autoencoder ae(mlp); ae.name = (mlp).name + "fine_tuning"; Gradient_Descent gd(0); gd.teachAE(ae); MLP ae_mlp; save(ae); exit(EXIT_SUCCESS); } else if (command_option_exists(argv, argv+argc, "-stack")) { std::string filename = get_command_line(argv, argv+argc, "-stack"); dbn = load_and_stack(filename, log_stream, psbuf); } else { print_usage(); exit(EXIT_SUCCESS); } ContrastiveDivergence cd(1000); dbn->learn(cd); std::cout.rdbuf(pStreambuf); log_stream.close(); exit(1); return 0; }
static errno_t __cdecl common_configure_argv(_crt_argv_mode const mode) throw() { typedef __crt_char_traits<Character> traits; _VALIDATE_RETURN_ERRCODE( mode == _crt_argv_expanded_arguments || mode == _crt_argv_unexpanded_arguments, EINVAL); do_locale_initialization(Character()); static Character program_name[MAX_PATH + 1]; traits::get_module_file_name(nullptr, program_name, MAX_PATH); traits::set_program_name(&program_name[0]); // If there's no command line at all, then use the program name as the // command line to parse, so that argv[0] is initialized with the program // name. (This won't happen when the program is run by cmd.exe, but it // could happen if the program is spawned via some other means.) Character* const raw_command_line = get_command_line(Character()); Character* const command_line = raw_command_line == nullptr || raw_command_line[0] == '\0' ? program_name : raw_command_line; size_t argument_count = 0; size_t character_count = 0; parse_command_line( command_line, static_cast<Character**>(nullptr), static_cast<Character*>(nullptr), &argument_count, &character_count); __crt_unique_heap_ptr<unsigned char> buffer(__acrt_allocate_buffer_for_argv( argument_count, character_count, sizeof(Character))); _VALIDATE_RETURN_ERRCODE_NOEXC(buffer, ENOMEM); Character** const first_argument = reinterpret_cast<Character**>(buffer.get()); Character* const first_string = reinterpret_cast<Character*>(buffer.get() + argument_count * sizeof(Character*)); parse_command_line(command_line, first_argument, first_string, &argument_count, &character_count); // If we are not expanding wildcards, then we are done... if (mode == _crt_argv_unexpanded_arguments) { __argc = static_cast<int>(argument_count - 1); get_argv(Character()) = reinterpret_cast<Character**>(buffer.detach()); return 0; } // ... otherwise, we try to do the wildcard expansion: __crt_unique_heap_ptr<Character*> expanded_argv; errno_t const argv_expansion_status = expand_argv_wildcards(first_argument, expanded_argv.get_address_of()); if (argv_expansion_status != 0) return argv_expansion_status; __argc = [&]() { size_t n = 0; for (auto it = expanded_argv.get(); *it; ++it, ++n) { } return static_cast<int>(n); }(); get_argv(Character()) = expanded_argv.detach(); return 0; }
/******************************************************* Function: ld_compile *******************************************************/ string ld_compile (bfd *abfd) { string input_path; string output_path; int argc; string *argv; int child_pid; int statptr; string file_name = (string)abfd->filename; if (tmpdir == 0) if (create_tmpdir (FALSE) != 0) { fprintf(stderr,"create_tmpdir() failed for %s\n",abfd->filename); exit(1); } if ((input_path = create_unique_file (file_name, 'B')) == 0) { fprintf(stderr,"create_unique_file() failed for %s\n",abfd->filename); exit(1); } if (abfd->arelt_data) { if (extract_archive_member (abfd, input_path) != 0) { fprintf(stderr,"extract_archive_member() failed for %s\n",abfd->filename); exit(1); } } else { UNLINK (input_path); if (make_link (file_name, input_path) != 0) { fprintf(stderr,"make_link() failed for %s\n",abfd->filename); exit(1); } } if ((output_path = create_unique_file (file_name, 'o')) == 0) { fprintf(stderr,"create_unique_file() failed for %s\n",abfd->filename); exit(1); } add_to_tmp_file_list (output_path); add_to_tmp_file_list (input_path); argv = get_command_line (abfd, input_path, output_path, &argc); if (ld_ipa_opt[LD_IPA_VERBOSE].flag || ld_ipa_opt[LD_IPA_SHOW].flag) fprintf(stderr,"Compiling %s\n",abfd->filename); child_pid = do_compile (argv); (void) waitpid (child_pid, &statptr, 0); if (statptr != 0 && WEXITSTATUS(statptr) != 0) { fprintf(stderr,"Compile of %s failed!\n",abfd->filename); exit(1); } active_pid = 0; FREE (argv); UNLINK (input_path); remove_from_tmp_file_list (input_path); FREE (input_path); return output_path; } /* ld_compile */
int elf_x86_load(int argc, char **argv, const char *buf, off_t len, struct kexec_info *info) { struct mem_ehdr ehdr; char *command_line = NULL, *modified_cmdline = NULL; const char *append = NULL; char *tmp_cmdline = NULL; char *error_msg = NULL; int result; int command_line_len; const char *ramdisk; unsigned long entry, max_addr; int arg_style; #define ARG_STYLE_ELF 0 #define ARG_STYLE_LINUX 1 #define ARG_STYLE_NONE 2 int opt; /* See options.h -- add any more there, too. */ static const struct option options[] = { KEXEC_ARCH_OPTIONS { "command-line", 1, NULL, OPT_APPEND }, { "append", 1, NULL, OPT_APPEND }, { "reuse-cmdline", 0, NULL, OPT_REUSE_CMDLINE }, { "initrd", 1, NULL, OPT_RAMDISK }, { "ramdisk", 1, NULL, OPT_RAMDISK }, { "args-elf", 0, NULL, OPT_ARGS_ELF }, { "args-linux", 0, NULL, OPT_ARGS_LINUX }, { "args-none", 0, NULL, OPT_ARGS_NONE }, { 0, 0, NULL, 0 }, }; static const char short_options[] = KEXEC_OPT_STR ""; /* * Parse the command line arguments */ arg_style = ARG_STYLE_ELF; ramdisk = 0; result = 0; while((opt = getopt_long(argc, argv, short_options, options, 0)) != -1) { switch(opt) { default: /* Ignore core options */ if (opt < OPT_ARCH_MAX) { break; } case OPT_APPEND: append = optarg; break; case OPT_REUSE_CMDLINE: tmp_cmdline = get_command_line(); break; case OPT_RAMDISK: ramdisk = optarg; break; case OPT_ARGS_ELF: arg_style = ARG_STYLE_ELF; break; case OPT_ARGS_LINUX: arg_style = ARG_STYLE_LINUX; break; case OPT_ARGS_NONE: #ifdef __i386__ arg_style = ARG_STYLE_NONE; #else die("--args-none only works on arch i386\n"); #endif break; } } command_line = concat_cmdline(tmp_cmdline, append); if (tmp_cmdline) { free(tmp_cmdline); } command_line_len = 0; if (command_line) { command_line_len = strlen(command_line) +1; } else { command_line = strdup("\0"); command_line_len = 1; } /* Need to append some command line parameters internally in case of * taking crash dumps. */ if (info->kexec_flags & (KEXEC_ON_CRASH|KEXEC_PRESERVE_CONTEXT)) { modified_cmdline = xmalloc(COMMAND_LINE_SIZE); memset((void *)modified_cmdline, 0, COMMAND_LINE_SIZE); if (command_line) { strncpy(modified_cmdline, command_line, COMMAND_LINE_SIZE); modified_cmdline[COMMAND_LINE_SIZE - 1] = '\0'; } } /* Load the ELF executable */ elf_exec_build_load(info, &ehdr, buf, len, 0); entry = ehdr.e_entry; max_addr = elf_max_addr(&ehdr); /* Do we want arguments? */ if (arg_style != ARG_STYLE_NONE) { /* Load the setup code */ elf_rel_build_load(info, &info->rhdr, purgatory, purgatory_size, 0, ULONG_MAX, 1, 0); } if (arg_style == ARG_STYLE_NONE) { info->entry = (void *)entry; } else if (arg_style == ARG_STYLE_ELF) { unsigned long note_base; struct entry32_regs regs; uint32_t arg1, arg2; /* Setup the ELF boot notes */ note_base = elf_boot_notes(info, max_addr, command_line, command_line_len); /* Initialize the stack arguments */ arg2 = 0; /* No return address */ arg1 = note_base; elf_rel_set_symbol(&info->rhdr, "stack_arg32_1", &arg1, sizeof(arg1)); elf_rel_set_symbol(&info->rhdr, "stack_arg32_2", &arg2, sizeof(arg2)); /* Initialize the registers */ elf_rel_get_symbol(&info->rhdr, "entry32_regs", ®s, sizeof(regs)); regs.eip = entry; /* The entry point */ regs.esp = elf_rel_get_addr(&info->rhdr, "stack_arg32_2"); elf_rel_set_symbol(&info->rhdr, "entry32_regs", ®s, sizeof(regs)); if (ramdisk) { error_msg = "Ramdisks not supported with generic elf arguments"; goto out; } } else if (arg_style == ARG_STYLE_LINUX) { struct x86_linux_faked_param_header *hdr; unsigned long param_base; const char *ramdisk_buf; off_t ramdisk_length; struct entry32_regs regs; int rc = 0; /* Get the linux parameter header */ hdr = xmalloc(sizeof(*hdr)); /* Hack: With some ld versions, vmlinux program headers show * a gap of two pages between bss segment and data segment * but effectively kernel considers it as bss segment and * overwrites the any data placed there. Hence bloat the * memsz of parameter segment to 16K to avoid being placed * in such gaps. * This is a makeshift solution until it is fixed in kernel */ param_base = add_buffer(info, hdr, sizeof(*hdr), 16*1024, 16, 0, max_addr, 1); /* Initialize the parameter header */ memset(hdr, 0, sizeof(*hdr)); init_linux_parameters(&hdr->hdr); /* Add a ramdisk to the current image */ ramdisk_buf = NULL; ramdisk_length = 0; if (ramdisk) { ramdisk_buf = slurp_file(ramdisk, &ramdisk_length); } /* If panic kernel is being loaded, additional segments need * to be created. */ if (info->kexec_flags & (KEXEC_ON_CRASH|KEXEC_PRESERVE_CONTEXT)) { rc = load_crashdump_segments(info, modified_cmdline, max_addr, 0); if (rc < 0) { result = -1; goto out; } /* Use new command line. */ free(command_line); command_line = modified_cmdline; command_line_len = strlen(modified_cmdline) + 1; modified_cmdline = NULL; } /* Tell the kernel what is going on */ setup_linux_bootloader_parameters(info, &hdr->hdr, param_base, offsetof(struct x86_linux_faked_param_header, command_line), command_line, command_line_len, ramdisk_buf, ramdisk_length); /* Fill in the information bios calls would usually provide */ setup_linux_system_parameters(info, &hdr->hdr); /* Initialize the registers */ elf_rel_get_symbol(&info->rhdr, "entry32_regs", ®s, sizeof(regs)); regs.ebx = 0; /* Bootstrap processor */ regs.esi = param_base; /* Pointer to the parameters */ regs.eip = entry; /* The entry point */ regs.esp = elf_rel_get_addr(&info->rhdr, "stack_end"); /* Stack, unused */ elf_rel_set_symbol(&info->rhdr, "entry32_regs", ®s, sizeof(regs)); } else {
bool tool_trace_mode(vogl::vector<command_line_param_desc> *desc) { arguments_t args; if (desc) { desc->append(g_command_line_param_descs_dump, VOGL_ARRAY_SIZE(g_command_line_param_descs_dump)); desc->append(g_tracer_cmdline_opts, VOGL_ARRAY_SIZE(g_tracer_cmdline_opts)); return true; } // Get steam gameid / local application name. args.gameid = g_command_line_params().get_value_as_string_or_empty("", 1); if (!args.gameid.size()) errorf(VOGL_FUNCTION_INFO_CSTR, "ERROR: No application or steamid specified.\n"); // Get logfile and tracefile names. args.vogl_tracefile = g_command_line_params().get_value_as_string("vogl_tracefile"); args.vogl_logfile = g_command_line_params().get_value_as_string("vogl_logfile"); args.dryrun = g_command_line_params().get_value_as_bool("dry-run"); args.xterm = g_command_line_params().get_value_as_bool("xterm"); // Loop through all the arguments looking for "vogl_*". for (vogl::command_line_params::param_map_const_iterator param = g_command_line_params().begin(); param != g_command_line_params().end(); ++param) { const dynamic_string &first = param->first; // If this is a vogl command and it's not logfile / tracefile, add it to the vogl_cmdline. const dynamic_string prefix = param->first.get_clone().left(5); if (prefix == "vogl_" && (first != "vogl_logfile" && first != "vogl_tracefile")) { args.vogl_cmdline += " --" + first; for (uint32_t i = 0; i < param->second.m_values.size(); i++) { args.vogl_cmdline += " " + param->second.m_values[i]; } } } // Check for -- or --args and add everything after to game_args. const dynamic_string& command_line = get_command_line(); int args_index = command_line.find_left("-- "); if (args_index == -1) args_index = command_line.find_left("--args "); if (args_index != -1) { args_index = command_line.find_left(' ', args_index); if (args_index != -1) { args.game_args += command_line.get_clone().right(args_index + 1); } } bool is_steam_file = true; if (atoi(args.gameid.c_str()) == 0) { if (access(args.gameid.c_str(), F_OK)) errorf(VOGL_FUNCTION_INFO_CSTR, "\nCould not find executable '%s'\n", args.gameid.c_str()); char *filename = realpath(args.gameid.c_str(), NULL); if (filename) { // This is a local executable. is_steam_file = false; args.gameid = filename; free(filename); } } int steam_appid = is_steam_file ? atoi(args.gameid.c_str()) : -1; if (!steam_appid) errorf(VOGL_FUNCTION_INFO_CSTR, "ERROR: Could not find game number for %s\n", args.gameid.c_str()); dynamic_string gameid_str; if (is_steam_file) { gameid_str = "appid" + args.gameid; vogl_printf("\nGame AppID: %d", steam_appid); const char *game_name = get_game_name(steam_appid); if (game_name) { dynamic_string game_name_str(cVarArg, "%s", game_name); vogl_printf(" (%s)", game_name_str.c_str()); // Trim some characters that don't go well with filenames. game_name_str.replace(" ", "_"); game_name_str.replace(":", ""); game_name_str.replace("'", ""); game_name_str.replace("!", ""); game_name_str.replace("?", ""); gameid_str += "_" + game_name_str; } vogl_printf("\n"); } else { gameid_str = basename((char *)args.gameid.c_str()); vogl_printf("\nGame: %s\n", args.gameid.c_str()); } // If a tracefile / logfile wasn't specified, set em up. if (!args.vogl_tracefile.size() || !args.vogl_logfile.size()) { char timestr[200]; time_t t = time(NULL); timestr[0] = 0; struct tm *tmp = localtime(&t); if (tmp) { strftime(timestr, sizeof(timestr), "%Y_%m_%d-%H_%M_%S", tmp); } dynamic_string fname(cVarArg, "%s/vogltrace.%s.%s", P_tmpdir, gameid_str.c_str(), timestr); if (!args.vogl_tracefile.size()) args.vogl_tracefile = fname + ".bin"; if (!args.vogl_logfile.size()) args.vogl_logfile = fname + ".log"; } vogl_printf("\n"); vogl_message_printf("Tracefile: %s\n", args.vogl_tracefile.c_str()); vogl_message_printf("Logfile: %s", args.vogl_logfile.c_str()); vogl_printf(" (will have PID appended)\n"); dynamic_string vogltracepath32 = getfullpath("libvogltrace32.so"); dynamic_string vogltracepath64 = getfullpath("libvogltrace64.so"); // set up LD_PRELOAD string dynamic_string LD_PRELOAD = "LD_PRELOAD=\""; LD_PRELOAD += vogltracepath32 + ":" + vogltracepath64; if (is_steam_file || getenv("LD_PRELOAD")) LD_PRELOAD += ":$LD_PRELOAD"; LD_PRELOAD += "\" "; vogl_printf("\n%s\n", LD_PRELOAD.c_str()); // set up VOGL_CMD_LINE string dynamic_string VOGL_CMD_LINE = "VOGL_CMD_LINE=\""; VOGL_CMD_LINE += "--vogl_tracefile " + args.vogl_tracefile; VOGL_CMD_LINE += " --vogl_logfile " + args.vogl_logfile; VOGL_CMD_LINE += args.vogl_cmdline; VOGL_CMD_LINE += "\""; vogl_printf("\n%s\n", VOGL_CMD_LINE.c_str()); dynamic_string xterm_str; if (args.xterm) { xterm_str = "xterm -geom 120x80+20+20"; const char *env_user = getenv("USER"); // If this is mikesart, specify using the Consolas font (which he likes). if (env_user && !strcmp(env_user, "mikesart")) xterm_str += " -fa Consolas -fs 10"; // Add the xterm command part. xterm_str += " -e "; } if (is_steam_file) { // set up xterm string dynamic_string steam_cmd_str; steam_cmd_str = xterm_str + "%command% " + args.game_args; steam_cmd_str.trim(); // set up steam string dynamic_string steam_str = "steam steam://run/" + args.gameid + "//"; dynamic_string steam_args = VOGL_CMD_LINE + " " + LD_PRELOAD + steam_cmd_str; dynamic_string steam_fullcmd = steam_str + url_encode(steam_args.c_str()); // Spew this whole mess out. vogl_printf("\nLaunch string:\n%s\n", (steam_str + steam_args).c_str()); vogl_printf("\nURL encoded launch string:\n%s\n", steam_fullcmd.c_str()); // And launch it... if (!args.dryrun) system(steam_fullcmd.c_str()); } else { dynamic_string system_cmd; system_cmd = VOGL_CMD_LINE + " " + LD_PRELOAD + " " + xterm_str + args.gameid + " " + args.game_args; vogl_printf("\nlaunch string:\n%s\n", system_cmd.c_str()); if (!args.dryrun) system(system_cmd.c_str()); } return true; }