int main( int argc, char **argval ) { JOB_DATA job_data; long long cnt = 0; signal( SIGINT, sig_int_handler ); #ifndef _HAVE_MSG_NOSIGNAL_ signal( SIGPIPE, SIG_IGN ); #endif parse_cmd_line( argc, argval, &job_data ); create_payload( &job_data ); if ( job_data.verbose ) { print_job_data( job_data ); } /* if */ cnt = flood_forked( job_data ); //printf( "%s[%d]: Sent %lld packets.\n\n", APPNAME, (int)getpid(), cnt ); free_job_data( &job_data ); drop_hash(); return cnt > 0; } /* main */
int main(int argc, char *argv[]) { int ret; config.logFilePath = DEFAULT_LOG_FILE_PATH; config.logLevel = INFO_LOG; parse_cmd_line(argc, argv); ret = load_config(); if(ret) { log_message(ERROR_LOG, "Loading configuration failed."); config_free(); return 1; } ret = initialize(); if(ret != 0) { log_message(ERROR_LOG, "initialize is failed."); config_free(); return 1; } ret = socks_proxy(); cachemgr_fini(); log_fini(); config_free(); return 0; }
int main(int argc, char* argv[]) { char* cmd = NULL; MEM_POOL* mem_pool = mem_pool_init(MB_SIZE); int socket_fd; signal(SIGPIPE, SIG_IGN); signal(SIGHUP, SIG_IGN); signal(SIGINT, sign_handler); signal(SIGTERM, sign_handler); if((socket_fd = parse_cmd_line(argc, argv, mem_pool)) <= 0) { mem_pool_destroy(mem_pool); return 0; } while (global_start) { if ((cmd = readline("MILE>")) == NULL) { break; } parse_cmd(cmd,socket_fd,mem_pool); mem_pool_reset(mem_pool); if(cmd != NULL) { free(cmd); cmd = NULL; } } mem_pool_destroy(mem_pool); return 0; }
static void spawn_init_start(int8_t *cmd_line) { proc_t *init_proc = proc_make(noval); // group leader set later assert(init_proc != 0); init_proc->cap.regs[0] = parse_cmd_line(&init_proc->hp, cmd_line); assert(init_proc->cap.regs[0] != noval); init_proc->cap.live = 1; init_proc->init_call_mod = A_INIT; init_proc->init_call_func = A_BOOT; init_proc->init_call_arity = 1; export_t *exp = code_base_lookup(A_INIT, A_BOOT, 1); assert(exp != 0); init_proc->cap.ip = exp->entry; module_info_t *mi = code_base_module_by_name(A_INIT, 0); assert(mi != 0); init_proc->cap.cp = mi->code_starts + mi->code_size-1; scheduler_enlist0(init_proc); // pid assigned init_proc->group_leader = init_proc->pid; // init is its own leader proc_main(init_proc); /* UNREACHANBLE */ }
int main(int argc, char *argv[]) { MLOG_init( MLOG_LEVEL_INFO, MLOG_ACTION_CONSOLE, 0); parse_cmd_line( argc, argv ); start_server(); return 0; }
int main(int argc, char** argv) { options opts = parse_cmd_line(argc,argv); if(opts.do_help) { if(opts.error) { std::cout << "Error parsing the command line." << std::endl; } do_help(argv); return -1; } if(test_duplicate_list(opts.node_count,opts.use_quick_and_dirty)) { std::cout << "Contratulations. duplicate_list is a success." << std::endl; } else { std::cout << "Unfortunately, duplicate_list failed." << std::endl; } return 0; }
void run_menu_command(GtkWidget *menu, MenuItem *mi) { (void) menu; if (mi->context & WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE) { gchar* cmd = g_strdup_printf("%s %s", mi->cmd, mi->argument); parse_cmd_line(cmd, NULL); g_free(cmd); g_free(mi->argument); } else { parse_cmd_line(mi->cmd, NULL); } }
/** * 程序入口 */ int main(int argc, char** argv) { cmdline_param cp; easy_listen_t* listen; easy_io_handler_pt io_handler; int ret; // default memset(&cp, 0, sizeof(cmdline_param)); cp.io_thread_cnt = 1; // parse cmd line if (parse_cmd_line(argc, argv, &cp) == EASY_ERROR) return EASY_ERROR; // 检查必需参数 if (cp.port == 0) { print_usage(argv[0]); return EASY_ERROR; } // 对easy_io初始化, 设置io的线程数, file的线程数 if (!easy_io_create(cp.io_thread_cnt)) { easy_error_log("easy_io_init error.\n"); return EASY_ERROR; } // 为监听端口设置处理函数,并增加一个监听端口 easy_io_var.tcp_defer_accept = 0; memset(&io_handler, 0, sizeof(io_handler)); io_handler.decode = echo_decode; io_handler.encode = echo_encode; io_handler.process = echo_process; io_handler.on_connect = echo_connect; if ((listen = easy_io_add_listen(NULL, cp.port, &io_handler)) == NULL) { easy_error_log("easy_io_add_listen error, port: %d, %s\n", cp.port, strerror(errno)); return EASY_ERROR; } else { easy_error_log("listen start, port = %d\n", cp.port); } // 起处理速度统计定时器 ev_timer stat_watcher; easy_io_stat_t iostat; easy_io_stat_watcher_start(&stat_watcher, 5.0, &iostat, NULL); // 起线程并开始 if (easy_io_start()) { easy_error_log("easy_io_start error.\n"); return EASY_ERROR; } // 等待线程退出 ret = easy_io_wait(); easy_io_destroy(); return ret; }
int main (int argc, char **argv) { #ifdef ANDROID read_default_bdaddr(); #endif if (parse_cmd_line(argc, argv)) { exit(1); } if (uart_fd < 0) { exit(2); } init_uart(); proc_reset(); if (use_baudrate_for_download) { if (termios_baudrate) { proc_baudrate(); } } if (hcdfile_fd > 0) { proc_patchram(); } if (termios_baudrate) { proc_baudrate(); } if (bdaddr_flag) { proc_bdaddr(); } if (enable_lpm) { proc_enable_lpm(); } if (scopcm) { proc_scopcm(); } if (i2s) { proc_i2s(); } if (enable_hci) { proc_enable_hci(); while (1) { sleep(UINT_MAX); } } exit(0); }
int main(int argc, char * argv[]) { int dh_bits=2048; if (argc<2) { usage(); return 1 ; } OpenSSL_add_all_algorithms(); /* Initialize DN fields to default values */ memset(&certinfo, 0, sizeof(certinfo)); certinfo.rsa_keysz = RSA_KEYSZ ; strcpy(certinfo.o, "Home"); certinfo.days = 3650 ; strcpy(certinfo.signing_ca, "root"); if ((argc>2) && (parse_cmd_line(argc, argv)!=0)) { return -1 ; } if (certinfo.cn[0]==0) { strcpy(certinfo.cn, argv[1]); } if (!strcmp(argv[1], "root")) { certinfo.profile = PROFILE_ROOT_CA ; build_identity(); } else if (!strcmp(argv[1], "sub")) { certinfo.profile = PROFILE_SUB_CA ; build_identity(); } else if (!strcmp(argv[1], "server")) { certinfo.profile = PROFILE_SERVER ; build_identity() ; } else if (!strcmp(argv[1], "client")) { certinfo.profile = PROFILE_CLIENT ; build_identity() ; } else if (!strcmp(argv[1], "www")) { certinfo.profile = PROFILE_WWW ; build_identity() ; } else if (!strcmp(argv[1], "crl")) { show_crl(certinfo.signing_ca); } else if (!strcmp(argv[1], "revoke")) { if (argc>2) { revoke_cert(certinfo.signing_ca, argv[2]); } else { fprintf(stderr, "Missing certificate name for revocation\n"); } } else if (!strcmp(argv[1], "dh")) { if (argc>2) { dh_bits=atoi(argv[2]); } generate_dhparam(dh_bits); } return 0 ; }
int main(int argc,char *argv[]){ int exitcode = 0; t_state state, *s=&state; /* Parse command line and pass any relevant arguments to CPU record */ parse_cmd_line(argc,argv, &cmd_line_args); fprintf(stderr,"ION (MIPS32 clone) core emulator (" __DATE__ ")\n\n"); if(!init_cpu(s, &cmd_line_args)){ fprintf(stderr,"Trouble allocating memory, quitting!\n"); exit(71); }; /* Read binary object files into memory*/ if(!read_binary_files(s, &cmd_line_args)){ exit(66); } fprintf(stderr,"\n\n"); /* Open the CPU console output file if not stdout. */ if (cmd_line_args.conout_filename!=NULL) { cpuconout = fopen(cmd_line_args.conout_filename, "w"); if (cpuconout==NULL){ fprintf(stderr,"Trouble opening console log file '%s', quitting.\n", cmd_line_args.conout_filename); exitcode = 2; goto main_quit; } } else { cpuconout = stdout; } init_trace_buffer(s, &cmd_line_args); /* NOTE: Original mlite supported loading little-endian code, which this program doesn't. The endianess-conversion code has been removed. */ /* Simulate a CPU reset */ reset_cpu(s); /* Simulate the work of the uClinux bootloader */ if(cmd_line_args.memory_map == MAP_UCLINUX){ /* FIXME this 'bootloader' is a stub, flesh it out */ s->pc = 0x80002400; } /* Enter debug command interface; will only exit clean with user command */ do_debug(s, cmd_line_args.no_prompt); main_quit: /* Close and deallocate everything and quit */ close_trace_buffer(s); free_cpu(s); if (cmd_line_args.conout_filename!=NULL && cpuconout!=NULL) fclose(cpuconout); exit(0); }
void test_sync_sh (void) { GString *result = g_string_new(""); parse_cmd_line("sync_sh 'echo Test echo.'", result); g_assert_cmpstr("Test echo.\n", ==, result->str); g_string_free(result, TRUE); }
void run_menu_command(GtkWidget *menu, MenuItem *mi) { (void) menu; if (mi->context & WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE) { gchar* uri; g_object_get(mi->hittest, "image-uri", &uri, NULL); gchar* cmd = g_strdup_printf("%s %s", mi->cmd, uri); parse_cmd_line(cmd, NULL); g_free(cmd); g_free(uri); g_object_unref(mi->hittest); } else { parse_cmd_line(mi->cmd, NULL); } }
int main(void) { char *argv[MAX_ARGC]; int argc; char line[400]; SIOUXSettings.asktosaveonclose = 0; SIOUXSettings.showstatusline = 1; argc=parse_cmd_line(MAX_ARGC,argv,sizeof(line),line); return xxx_main(argc,argv); }
void test_event (struct EventFixture *ef, const void *data) { (void) data; parse_cmd_line("event", NULL); assert_no_event(ef); /* a simple event can be sent */ parse_cmd_line("event event_type arg u ments", NULL); ASSERT_EVENT(ef, "EVENT_TYPE arg u ments"); /* arguments to event should be expanded */ parse_cmd_line("event event_type @(echo expansion)@ test", NULL); ASSERT_EVENT(ef, "EVENT_TYPE expansion test"); /* "request" is just an alias for "event" */ parse_cmd_line("request event_type arg u ments", NULL); ASSERT_EVENT(ef, "EVENT_TYPE arg u ments"); }
void test_js (void) { GString *result = g_string_new(""); /* simple javascript can be evaluated and returned */ parse_cmd_line("js ('x' + 345).toUpperCase()", result); g_assert_cmpstr("X345", ==, result->str); g_string_free(result, TRUE); }
void test_scroll (void) { GtkScrollbar *scbar_v = (GtkScrollbar*) gtk_vscrollbar_new (NULL); uzbl.gui.bar_v = gtk_range_get_adjustment((GtkRange*) scbar_v); gtk_adjustment_set_lower(uzbl.gui.bar_v, 0); gtk_adjustment_set_upper(uzbl.gui.bar_v, 100); gtk_adjustment_set_page_size(uzbl.gui.bar_v, 5); /* scroll vertical end should scroll it to upper - page_size */ parse_cmd_line("scroll vertical end", NULL); g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 95); /* scroll vertical begin should scroll it to lower */ parse_cmd_line("scroll vertical begin", NULL); g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 0); /* scroll vertical can scroll by pixels */ parse_cmd_line("scroll vertical 15", NULL); g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 15); parse_cmd_line("scroll vertical -10", NULL); g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 5); /* scroll vertical can scroll by a percentage of the page size */ parse_cmd_line("scroll vertical 100%", NULL); g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 10); parse_cmd_line("scroll vertical 150%", NULL); g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 17.5); /* scroll_horz behaves basically the same way. */ }
gboolean control_client_socket(GIOChannel *clientchan) { char *ctl_line; GString *result = g_string_new(""); GError *error = NULL; GIOStatus ret; gsize len; ret = g_io_channel_read_line(clientchan, &ctl_line, &len, NULL, &error); if (ret == G_IO_STATUS_ERROR) { g_warning ("Error reading: %s", error->message); g_clear_error (&error); ret = g_io_channel_shutdown (clientchan, TRUE, &error); remove_socket_from_array (clientchan); if (ret == G_IO_STATUS_ERROR) { g_warning ("Error closing: %s", error->message); g_clear_error (&error); } return FALSE; } else if (ret == G_IO_STATUS_EOF) { /* shutdown and remove channel watch from main loop */ ret = g_io_channel_shutdown (clientchan, TRUE, &error); remove_socket_from_array (clientchan); if (ret == G_IO_STATUS_ERROR) { g_warning ("Error closing: %s", error->message); g_clear_error (&error); } return FALSE; } if (ctl_line) { parse_cmd_line (ctl_line, result); g_string_append_c(result, '\n'); ret = g_io_channel_write_chars (clientchan, result->str, result->len, &len, &error); if (ret == G_IO_STATUS_ERROR) { g_warning ("Error writing: %s", error->message); g_clear_error (&error); } if (g_io_channel_flush(clientchan, &error) == G_IO_STATUS_ERROR) { g_warning ("Error flushing: %s", error->message); g_clear_error (&error); } } g_string_free(result, TRUE); g_free(ctl_line); return TRUE; }
void gendep(const deque<wstring>& params) { list<wstring> source_dirs, include_dirs; parse_cmd_line(params, source_dirs, include_dirs); wstring output; set<wstring> file_set; for (list<wstring>::const_iterator src_dir = source_dirs.begin(); src_dir != source_dirs.end(); src_dir++) { DirList dir_list(get_full_path_name(src_dir->empty() ? L"." : *src_dir)); while (dir_list.next()) { if (!dir_list.data().is_dir() && is_valid_ext(dir_list.data().cFileName)) { process_file(output, file_set, add_trailing_slash(*src_dir) + dir_list.data().cFileName, include_dirs); } } } cout << unicode_to_ansi(output, CP_ACP); }
void test_set_variable (struct EventFixture *ef, const void *data) { (void) data; /* set a string */ parse_cmd_line("set useragent = Uzbl browser kthxbye!", NULL); ASSERT_EVENT(ef, "VARIABLE_SET useragent str 'Uzbl browser kthxbye!'"); g_assert_cmpstr("Uzbl browser kthxbye!", ==, uzbl.net.useragent); /* set an int */ parse_cmd_line("set forward_keys = 0", NULL); ASSERT_EVENT(ef, "VARIABLE_SET forward_keys int 0"); g_assert_cmpint(0, ==, uzbl.behave.forward_keys); /* set a float */ /* we have to be careful about locales here */ GString *cmd; cmd = g_string_new("set zoom_level = "); g_string_append_printf(cmd, "%f", 0.25); parse_cmd_line(g_string_free(cmd, FALSE), NULL); ASSERT_EVENT(ef, "VARIABLE_SET zoom_level float 0.25"); g_assert_cmpfloat(0.25, ==, get_var_value_float("zoom_level")); /* set a constant int (nothing should happen) */ int old_major = uzbl.info.webkit_major; parse_cmd_line("set WEBKIT_MAJOR = 100", NULL); assert_no_event(ef); g_assert_cmpint(old_major, ==, uzbl.info.webkit_major); /* set a constant str (nothing should happen) */ GString *old_arch = g_string_new(uzbl.info.arch); parse_cmd_line("set ARCH_UZBL = A Lisp Machine", NULL); assert_no_event(ef); g_assert_cmpstr(g_string_free(old_arch, FALSE), ==, uzbl.info.arch); /* set a custom variable */ parse_cmd_line("set nonexistant_variable = Some Value", NULL); ASSERT_EVENT(ef, "VARIABLE_SET nonexistant_variable str 'Some Value'"); uzbl_cmdprop *c = g_hash_table_lookup(uzbl.behave.proto_var, "nonexistant_variable"); g_assert_cmpstr("Some Value", ==, *(c->ptr.s)); /* set a custom variable with expansion */ parse_cmd_line("set an_expanded_variable = Test @(echo expansion)@", NULL); ASSERT_EVENT(ef, "VARIABLE_SET an_expanded_variable str 'Test expansion'"); c = g_hash_table_lookup(uzbl.behave.proto_var, "an_expanded_variable"); g_assert_cmpstr("Test expansion", ==, *(c->ptr.s)); }
int main(int argc, char** argv) { int ret = EXIT_SUCCESS; mysql_init(NULL); parse_cmd_line(argc, argv); TBSYS_CONFIG.load(g_config); TBSYS_LOGGER.setFileName("bigquery.log"); TBSYS_LOGGER.setLogLevel("info"); TBSYS_LOGGER.setMaxFileSize(256 * 1024L * 1024L); /* 256M */ BigqueryTest bigquery; bigquery.start(); bigquery.wait(); bigquery.stop(); return ret; }
int main(int argc, char **argv) { parse_cmd_line(argc, argv); FileList *filelist = (FileList *)malloc(sizeof(FileList)); FileList_Init(filelist); GetFileListInPaths(DIRPATHS, filelist); IdentFileList *ifiles; IdenticalFile_Init(&ifiles); GetIdenticalFile(filelist, ifiles); if (OPTIONS & OPT_HASH) PrintIdenticalFileHash(ifiles); else PrintIdenticalFile(ifiles); }
int main(int argc, char **argv) { MastSendTool *tool = NULL; SF_INFO sfinfo; // Create the send tool object tool = new MastSendTool( MAST_TOOL_NAME ); tool->enable_scheduling(); // Parse the command line arguments // and configure the session parse_cmd_line( argc, argv, tool ); // Open the input file by filename memset( &sfinfo, 0, sizeof(sfinfo) ); g_input_file = sf_open(g_filename, SFM_READ, &sfinfo); if (g_input_file == NULL) MAST_FATAL("Failed to open input file:\n%s", sf_strerror(NULL)); tool->set_input_channels( sfinfo.channels ); tool->set_input_samplerate( sfinfo.samplerate ); // Display some information about the input file print_file_info( g_input_file, &sfinfo ); // Setup signal handlers mast_setup_signals(); // Run the main loop tool->run(); // Clean up delete tool; // Close input file if (sf_close( g_input_file )) { MAST_ERROR("Failed to close input file:\n%s", sf_strerror(g_input_file)); } // Success ! return 0; }
gboolean control_stdin(GIOChannel *gio, GIOCondition condition) { (void) condition; gchar *ctl_line = NULL; GIOStatus ret; ret = g_io_channel_read_line(gio, &ctl_line, NULL, NULL, NULL); if ( (ret == G_IO_STATUS_ERROR) || (ret == G_IO_STATUS_EOF) ) return FALSE; GString *result = g_string_new(""); parse_cmd_line(ctl_line, result); g_free(ctl_line); puts(result->str); g_string_free(result, TRUE); return TRUE; }
// Main driver for program1 int main(int argc, char** argv) { options opts = parse_cmd_line(argc, argv); if(opts.do_help) { if(opts.error) { std::cout << "Error parsing command line." << std::endl; } do_help(argv); return -1; } if(opts.run_tests) { std::ifstream file; file.open(opts.input_file,std::ifstream::out); test_reverse_word(file); file.close(); return 0; } char* sentence = &opts.sentence[0]; std::cout << "Input sentence: " << opts.sentence << std::endl; if(opts.use_quick_and_dirty) { reverse_words_quick_and_dirty(sentence); } else { reverse_words(sentence); } std::cout << "Output sentence: " << sentence << std::endl; return 0; }
int main(int argc, char **argv) { MastSendTool *tool = NULL; jack_client_t* client = NULL; // Create the send tool object tool = new MastSendTool( MAST_TOOL_NAME ); // Parse the command line arguments // and configure the session parse_cmd_line( argc, argv, tool ); // Initialise Jack client = init_jack( tool ); if (client==NULL) MAST_FATAL( "Failed to initialise JACK client" ); // Get the samplerate of the JACK Router tool->set_input_samplerate( jack_get_sample_rate( client ) ); // Setup signal handlers mast_setup_signals(); // Run the main loop tool->run(); // Clean up delete tool; // Shut down JACK deinit_jack( client ); // Success ! return 0; }
int main(int argc, char* argv[]) { init_default_config(); parse_cmd_line(argc, argv); init_thread_event_loops(g_config.thread_number); init_thread_base_conn(g_config.thread_number); for (int i = 0; i < g_config.thread_number; ++i) { NbClientConn* client = new NbClientConn(); net_handle_t handle = client->Connect(g_config.host, g_config.port); if (handle != NETLIB_INVALID_HANDLE) { PktHeartBeat* pkt = new PktHeartBeat; BaseConn::SendPkt(handle, pkt); } } get_main_event_loop()->Start(); return 0; }
/** * No need to explain this. * * @param argc Number of arguments. * @param argv Arguments array. * @return Return code. */ int main(int argc, char **argv) { bool running = true; char *script_file = NULL; char *csv_file = NULL; char *ctok = NULL; gnuplot_ctrl *gp = gnuplot_init(); char prompt[64] = "> "; if (argc == 2) { if (argv[1][strlen(argv[1]) - 3] == '.' && argv[1][strlen(argv[1]) - 2] == 'p' && argv[1][strlen(argv[1]) - 1] == 'c') { // Script file. script_file = argv[1]; running = parse_script(script_file, ctok, &csv_file, gp, prompt); } else { // CSV file. csv_file = argv[1]; generate_prompt(prompt, csv_file); } } while (running) { char *buffer = NULL; buffer = readline(prompt); if (buffer && *buffer) { add_history(buffer); ctok = strtok(buffer, " "); } else { continue; } running = parse_cmd_line(ctok, &csv_file, gp, prompt, false); } gnuplot_close(gp); return EXIT_SUCCESS; }
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ int main(int argc, char **argv) /* @7c */ { int i; int rc; /* @7a */ rc = parse_cmd_line(argc, argv, cmds, &num_subcmds); /* @7a */ if (rc != BAIL_OUT) /* @7c */ if (open_files(cmds, argc, argv) != BAIL_OUT) if (num_files) { for (i = firstfile; i < argc; i++) if (process_file_spec(argv[i], cmds) == BAIL_OUT) { /* @7a */ rc = BAIL_OUT; /* @7a */ break; } /* @7a */ } else rc = process_file(NULL, cmds); /* @7c */ else /* @7a */ rc = BAIL_OUT; /* @7a */ return(rc); /* @7a */ }
int _tmain(int argc, _TCHAR * argv[]) { int rv; rv = parse_cmd_line(argc, argv); if(rv != 0) return rv; create_sync_objects(); if(!isChild) { if(spawn_kids(argc, argv)) return 1; } else { SetEvent(event_parent); } rv = run_tests(); free_sync_objects(); cleanup(); return rv; }