int main(int argc, char *argv[]) { struct hooks_t hooks; struct files_t files; //int c; /* TODO: Parse command line arguments */ parse_commandline(argc, argv); /* TODO: Initialize hooks and files lists */ TAILQ_INIT(&hooks); TAILQ_INIT(&files); /* TODO: Load hooks */ set_hooks(&hooks); // TODO: Continuously check directory and timestamps //while(true){ char *timestamp = timestamp_string(); check_directory(directory, &hooks, &files, recursive,(time_t) timestamp); sleep(1); //} return (EXIT_SUCCESS); }
int main(int argc, char *argv[]) { double clock; struct buffer buf; char *pattern = NULL; char *infile = NULL; char *outdir = strdup("."); parse_commandline(argc, argv, &pattern, &infile, &outdir); if(infile == NULL) return EXIT_FAILURE; MPI_Init(&argc, &argv); tic(&clock); load_file(infile, &buf); toc(&clock, "Read input:"); transfer_partials(pattern, &buf); toc(&clock, "Transfer:"); write_chunks(infile, outdir, &buf); toc(&clock, "Write chunks:"); MPI_Finalize(); free(buf.data); free(pattern); free(infile); return EXIT_SUCCESS; }
/* configuration-dependent initialization */ int main_configure(char *arg1, char *arg2) { if(parse_commandline(arg1, arg2)) return 1; str_canary_init(); /* needs prng initialization from parse_commandline */ #if !defined(USE_WIN32) && !defined(__vms) /* syslog_open() must be called before change_root() * to be able to access /dev/log socket */ syslog_open(); #endif /* !defined(USE_WIN32) && !defined(__vms) */ if(bind_ports()) return 1; #ifdef HAVE_CHROOT /* change_root() must be called before drop_privileges() * since chroot() needs root privileges */ if(change_root()) return 1; #endif /* HAVE_CHROOT */ #if !defined(USE_WIN32) && !defined(__vms) && !defined(USE_OS2) if(drop_privileges(1)) return 1; #endif /* standard Unix */ /* log_open() must be be called after drop_privileges() * or logfile rotation won't be possible */ /* log_open() must be be called before daemonize() * since daemonize() invalidates stderr */ log_open(); return 0; }
int PASCAL WinMain(HINSTANCE hInst,HINSTANCE hPrev,LPSTR szCmdLine,int sw) { char szModuleName[260]; GetModuleFileName(hInst,szModuleName,sizeof(szModuleName)); parse_commandline(szModuleName,szCmdLine,&argc,argv,MAX_ARGV); return main(argc,argv); }
/*---------------------------------------------------------------*/ int main(int argc, char *argv[]) { int nargs; nargs = handle_version_option (argc, argv, vcid, "$Name: stable5 $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; cmdline = argv2cmdline(argc,argv); uname(&uts); getcwd(cwd,2000); Progname = argv[0] ; argc --; argv++; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; if (argc == 0) usage_exit(); parse_commandline(argc, argv); check_options(); if (checkoptsonly) return(0); dump_options(stdout); SUBJECTS_DIR = getenv("SUBJECTS_DIR"); if (SUBJECTS_DIR == NULL) { printf("ERROR: SUBJECTS_DIR not defined in environment\n"); exit(1); } return 0; }
int main(int argc, char **argv) { /* Init configuration */ init_config(); parse_commandline(argc, argv); switch(config.command) { case WDCTL_STATUS: wdctl_status(); break; // 停掉 wifidog进程 case WDCTL_STOP: wdctl_stop(); break; case WDCTL_KILL: wdctl_reset(); break; case WDCTL_RESTART: wdctl_restart(); break; default: /* XXX NEVER REACHED */ fprintf(stderr, "Oops\n"); exit(1); break; } exit(0); }
int main(int argc, const char **argv) { clioptions opts; parse_commandline(argc, argv, &opts); run_server(&opts); return 0; }
int main (int argc, char *argv[]) { parse_commandline(argc, argv); mclget(); exit(0); }
/** Reads the configuration file and then starts the main loop */ int main(int argc, char **argv) { s_config *config = config_get_config(); config_init(); parse_commandline(argc, argv); /* Initialize the config */ config_read(config->configfile); config_validate(); /* Initializes the linked list of connected clients */ client_list_init(); /* Init the signals to catch chld/quit/etc */ init_signals(); if (restart_orig_pid) { /* * We were restarted and our parent is waiting for us to talk to it over the socket */ get_clients_from_parent(); /* * At this point the parent will start destroying itself and the firewall. Let it finish it's job before we continue */ while (kill(restart_orig_pid, 0) != -1) { debug(LOG_INFO, "Waiting for parent PID %d to die before continuing loading", restart_orig_pid); sleep(1); } debug(LOG_INFO, "Parent PID %d seems to be dead. Continuing loading."); } if (config->daemon) { debug(LOG_INFO, "Forking into background"); switch(safe_fork()) { case 0: /* child */ setsid(); append_x_restartargv(); main_loop(); break; default: /* parent */ exit(0); break; } } else { append_x_restartargv(); main_loop(); } return(0); /* never reached */ }
int main (int argc, char *argv[]) { srand (time (NULL)); omp_set_nested (1); omp_set_num_threads (16); // process command line parse_commandline (&argc, &argv); LOG (INFO) << "rtrt init"; Window win (FLAGS_width, FLAGS_height, FLAGS_fullscreen, "Real-time Ray Tracer", FLAGS_interval); Image front (win.width(), win.height()), back (win.width(), win.height()); // create the images Image *front_p = &front, *back_p = &back; World world; //world.fill(75, 4); world.demo0(); RayTracer rt (world); #pragma omp parallel { #pragma omp single nowait { while (win.is_running()) { // update frame PerformanceMonitor::instance().RT_FPS.count(); //win.update_frame_rate(); win.clearXY(); // render the new back buffer rt.render (back_p); // swap buffers std::swap (front_p, back_p); } } #pragma omp master { while (win.is_running()) { // main rendering loop, keep rendering the front buffer PerformanceMonitor::instance().GL_FPS.count(); win.clear(); // clear the render windows back buffer if (FLAGS_fps) { win.update_title_with_frame_rate(); // show the frame rate in the window title } win.render_image (*front_p); // render the image to the back buffer win.update(); // swap the back buffer with the front buffer PerformanceMonitor::instance().update(); } } } LOG (INFO) << "shutting down"; LOG (INFO) << "Average frame rate was " << win.average_framerate(); front.destroy_image(); back.destroy_image(); win.destroy_window(); LOG (INFO) << PerformanceMonitor::instance(); return (0); }
int main(int argc, char* argv[]) { char* prmfname = NULL; parse_commandline(argc, argv, &prmfname); gridgen_generategrid(prmfname); return 0; }
/****************************************************************************** * * * Function: * * * * Purpose: * * * * Parameters: * * * * Return value: * * * * Comments: * * * ******************************************************************************/ int main(int argc, char **argv) { progname = get_program_name(argv[0]); parse_commandline(argc, argv); ja_load_config(CONFIG_FILE); START_MAIN_ZABBIX_ENTRY(CONFIG_ALLOW_ROOT); exit(SUCCEED); }
void telemetry::parse_input() { if(get_protocol() == protocol_t::command_line){ parse_commandline(); }else{ parse_av_cobs(); telemetry::parse_frsky_bytestuff(); } // parse_input_from_FrSky_with_cobs_protocol(); }
/** * * \brief implements the message server, which spawn the buisness logic process * * This is the main entry point for any C program. * * \param argc the number of arguments * \param argv the arguments itselves (including the program name in argv[0]) * * \return success or failure * */ int main(int argc, const char * const * argv) { int sockfd = -1; /* listen on sockfd */ int sockfdchild = -1; /* new connection on sockfdchild */ struct sockaddr_storage their_addr; /* client's address information */ socklen_t sin_size = -1; pid_t pid = -1; parse_commandline(argc,argv); sockfd = get_port(sockfd, argv); while(1) { /* loop to accept() connections */ sin_size = sizeof their_addr; sockfdchild = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size); if (sockfdchild == -1) { perror("accept"); continue; } switch (pid = fork()) /*forking the child....*/ { case -1: { /*error*/ close(sockfdchild); close(sockfd); fprintf(stderr,"error after forking"); exit(1); /*maybe it would be better not to exit the program here...*/ break; } case 0:{/*child process*/ close(sockfd); if (dup2(sockfdchild,0) == -1){ /*Umwandeln stdin*/ close(sockfdchild); exit(EXIT_FAILURE); } if (dup2(sockfdchild,1) == -1){ /*Umwandeln stdout*/ close(sockfdchild); exit(EXIT_FAILURE); } errno = 0; (void) execlp(PATHBULOGIC,"simple_message_server_logic" ,NULL); fprintf(stderr, "execlp() failed: %s\n", strerror(errno)); exit(EXIT_FAILURE); } default:{ /*mother process*/ close(sockfdchild); /* parent doesn't need this */ } } } exit(EXIT_SUCCESS); }
int main(int argc, char* const argv[]) { SkTArray<SkString> inputs; sk_tools::PictureBenchmark* benchmark = NULL; parse_commandline(argc, argv, &inputs, benchmark); for (int i = 0; i < inputs.count(); ++i) { process_input(inputs[i], *benchmark); } SkDELETE(benchmark); }
int main (int argc, char * const * const argv) { NVQRConnection connection; NVQRQueryDataBuffer data; pid_t pid = 0; GLenum queryType; nvqrReturn_t result; result = parse_commandline(argc, argv, &pid, &queryType); if (result != NVQR_SUCCESS) { fprintf(stderr, "%s: invalid command line\n", argv[0]); return result; } result = nvqr_connect(&connection, pid); if (result != NVQR_SUCCESS) { if (result == NVQR_ERROR_NOT_SUPPORTED && connection.process_name) { printf("Resource query not supported for '%s' (pid %ld)\n", connection.process_name, (long) connection.pid); } else { fprintf(stderr, "Error: failed to open connection to pid %ld\n", (long) connection.pid); } return result; } result = nvqr_request_meminfo(connection, queryType, &data); if (result == NVQR_SUCCESS) { int version = nvqr_get_data_format_version(data.data); if (version < NVQR_MIN_DATA_FORMAT_VERSION || version > NVQR_MAX_DATA_FORMAT_VERSION) { fprintf(stderr, "Error: unrecognized data format version '%d'. " "(Minimum supported: %d; Maximum supported: %d)\n", version, NVQR_MIN_DATA_FORMAT_VERSION, NVQR_MAX_DATA_FORMAT_VERSION); } if (connection.process_name) { printf("%s, pid = %ld, data format version %d\n", connection.process_name, (long) connection.pid, version); } print_memory_info(queryType, data.data); } else { fprintf(stderr, "Error: failed to query resource usage information " "for pid %ld.\n", (long) connection.pid); } result = nvqr_disconnect(&connection); return result; }
int main(int argc, char **argv) { static acs_cli_info_t ai; int rc; /* Initalise our context object */ memset(&ai, 0, sizeof(ai)); ai.wl_ifname = DEFAULT_WL_IFNAME; ai.server_host = DEFAULT_SERVER_HOST; ai.server_port = DEFAULT_SERVER_PORT; ai.socket = -1; for (rc = 0; rc < CMDARG_MAX; ++rc) { ai.cmdarg[rc] = ""; } rc = parse_commandline(&ai, argc, argv); if (rc != BCME_OK) { return rc; } switch (ai.action) { case ACTION_SHOW_COMMANDS: rc = show_command_list(); break; case ACTION_SHOW_USAGE: rc = BCME_OK; usage(argv[0]); break; case ACTION_REPORT_VARIABLES: rc = report_all_variables(&ai); break; case ACTION_REPORT_EVERYTHING: rc = report_everything(&ai); break; case ACTION_DO_COMMAND: rc = connect_to_server(&ai); if (rc == BCME_OK) { rc = do_command_response(&ai); disconnect_from_server(&ai); } break; } return rc; }
int main(int argc, char *argv[]) { parse_commandline(argc, argv); signal(SIGINT, sigproc); signal(SIGQUIT, sigproc); //infinte loop to pipe input until program is killed for(;;) { pipeInput(); } return (EXIT_SUCCESS); }
/** Entry point to tor-gencert */ int main(int argc, char **argv) { int r = 1; init_logging(1); /* Don't bother using acceleration. */ if (crypto_global_init(0, NULL, NULL)) { fprintf(stderr, "Couldn't initialize crypto library.\n"); return 1; } if (crypto_seed_rng()) { fprintf(stderr, "Couldn't seed RNG.\n"); goto done; } /* Make sure that files are made private. */ umask(0077); if (parse_commandline(argc, argv)) goto done; if (load_identity_key()) goto done; if (reuse_signing_key) { if (load_signing_key()) goto done; } else { if (generate_signing_key()) goto done; } if (generate_certificate()) goto done; r = 0; done: clear_passphrase(); if (identity_key) EVP_PKEY_free(identity_key); if (signing_key) EVP_PKEY_free(signing_key); tor_free(address); tor_free(identity_key_file); tor_free(signing_key_file); tor_free(certificate_file); tor_free(address); crypto_global_cleanup(); return r; }
int main(int argc, char* argv[]) { char* fname = NULL; int ij = 0; int compact = 0; NODETYPE nt = NT_DD; gridnodes* gn = NULL; poly* pl = NULL; parse_commandline(argc, argv, &fname, &compact, &ij, &nt); if (nt == NT_DD) { /* * read DD grid nodes */ gridnodes* gndd = gridnodes_read(fname, NT_DD); gridnodes_validate(gndd); /* * get corner grid nodes from DD grid nodes */ gn = gridnodes_transform(gndd, NT_COR); gridnodes_destroy(gndd); } else { gn = gridnodes_read(fname, NT_COR); gridnodes_validate(gn); } /* * build boundary polygon */ if (!ij) pl = poly_formbound(gridnodes_getnce1(gn), gridnodes_getnce2(gn), gridnodes_getx(gn), gridnodes_gety(gn)); else pl = poly_formboundij(gridnodes_getnce1(gn), gridnodes_getnce2(gn), gridnodes_getx(gn)); if (compact) poly_compact(pl, 1.0e-10); poly_write(pl, stdout); poly_destroy(pl); gridnodes_destroy(gn); return 0; }
int main(int argc, char *argv[]) { print_level = LOG_NOTICE; // print_level = LOG_DEBUG; if (!parse_commandline(argc, argv)) { help(); return 1; } sprintf(program_info, "pidp11_blinkenlightd - Blinkenlight API server daemon for PiDP11 %s", VERSION); // info(); print(LOG_INFO, "Start\n"); // link set/get events blinkenlight_api_panel_get_controlvalues_evt = on_blinkenlight_api_panel_get_controlvalues; blinkenlight_api_panel_set_controlvalue_evt = on_blinkenlight_api_panel_set_controlvalue; blinkenlight_api_panel_set_controlvalues_evt = on_blinkenlight_api_panel_set_controlvalues; blinkenlight_api_panel_get_state_evt = on_blinkenlight_api_panel_get_state; blinkenlight_api_panel_set_state_evt = on_blinkenlight_api_panel_set_state; blinkenlight_api_panel_get_mode_evt = on_blinkenlight_api_panel_get_mode; blinkenlight_api_panel_set_mode_evt = on_blinkenlight_api_panel_set_mode; blinkenlight_api_get_info_evt = on_blinkenlight_api_get_info; register_controls(); if (opt_test) { printf("Dump of register <-> control data struct:\n"); blinkenlight_panels_diagprint(blinkenlight_panel_list, stdout); exit(0); } gpio_mux_thread_start(); gpiopattern_start_thread(); blinkenlight_api_server(); // does never end! print_close(); // well .... blinkenlight_panels_destructor(blinkenlight_panel_list); return 0; }
static pascal OSErr CmdLineMessage(const AppleEvent *evt, AppleEvent *b, long c) { AEDescList cmdList; DescType retType; AEKeyword keywd; char *cmdLine; long size; AEGetParamDesc(evt, keyDirectObject, typeAEList, &cmdList); size = 1023; cmdLine = (char *)malloc(size + 1); AEGetNthPtr(&cmdList, 1, typeChar, &keywd, &retType, (Ptr)cmdLine, size, &size); cmdLine[size] = 0; scheme_mac_ready = 1; parse_commandline(cmdLine, NULL, 0); return 0; }
/*---------------------------------------------------------------*/ int main(int argc, char *argv[]) { int nargs; char *surf1_fname ; char *surf2_fname ; char *out_fname ; MRI_SURFACE *mris1, *mris2 ; nargs = handle_version_option (argc, argv, vcid, "$Name: $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; cmdline = argv2cmdline(argc,argv); uname(&uts); getcwd(cwd,2000); Progname = argv[0] ; argc --; argv++; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; if (argc == 0) usage_exit(); parse_commandline(argc, argv); check_options(); if (checkoptsonly) return(0); dump_options(stdout); SUBJECTS_DIR = getenv("SUBJECTS_DIR"); if (SUBJECTS_DIR == NULL) { printf("ERROR: SUBJECTS_DIR not defined in environment\n"); exit(1); } surf1_fname = argv[0] ; surf2_fname = argv[1] ; out_fname = argv[2] ; mris1 = MRISread(surf1_fname) ; if (mris1 == NULL) ErrorExit(ERROR_NOFILE, "could not read surface 1 from %s", surf1_fname) ; mris2 = MRISread(surf2_fname) ; if (mris2 == NULL) ErrorExit(ERROR_NOFILE, "could not read surface 2 from %s", surf2_fname) ; compute_surface_distance(mris1, mris2, mris1) ; MRISwriteValues(mris1, out_fname) ; return 0; }
int main (int argc, char **argv) { //初始化必要的资源 if( init_resource() < 0 ){ debug(LOG_ERR, " init_resource fail !"); return -1; } parse_commandline(argc, argv); /* Init the signals to catch chld/quit/etc */ init_signals(); if( do_process() < 0 ) { debug(LOG_ERR, " do_process fail !"); exit(-1); } debug(LOG_ERR, "%s : QUIT do_process()",__FUNCTION__); return 0; }
/* main * in: argc, argv: Classic commandline parameters. * returns: int: 0: success, !0: !success :-) */ int main(int argc, char ** argv) { parameters_t param; sh_param = ¶m; y4m_accept_extensions(1); parse_commandline(argc, argv, ¶m); mjpeg_default_handler_verbosity(param.verbose); mjpeg_info("Parsing & checking input files."); if (init_parse_files(¶m)) { mjpeg_error_exit1("* Error processing the PNG input."); } if (generate_YUV4MPEG(¶m)) { mjpeg_error_exit1("* Error processing the input files."); } return 0; }
/** Main entry point for nodogsplash. * Reads the configuration file and then starts the main loop. */ int main(int argc, char **argv) { s_config *config = config_get_config(); config_init(); parse_commandline(argc, argv); /* Initialize the config */ debug(LOG_NOTICE,"Reading and validating configuration file %s", config->configfile); config_read(config->configfile); config_validate(); /* Initializes the linked list of connected clients */ client_list_init(); /* Init the signals to catch chld/quit/etc */ debug(LOG_NOTICE,"Initializing signal handlers"); init_signals(); if (config->daemon) { debug(LOG_NOTICE, "Starting as daemon, forking to background"); switch(safe_fork()) { case 0: /* child */ setsid(); main_loop(); break; default: /* parent */ exit(0); break; } } else { main_loop(); } return(0); /* never reached */ }
int main(int argc, char const* argv[]) { auto params = parse_commandline(argc, argv); if (!params.valid) { printf( "OVERVIEW: A tool to merge multiple C/C++ files into one.\n" "\n" "Parses #include \".*\" directives and merges contents into output file.\n" "Any #defines before such an include that starts with MERGE_ will be\n" "automatically expanded and #undef statements will be removed.\n" "\n" "USAGE: %s <in-filename> <out-filename> <include-dir>", argv[0]); return -1; } auto in = read_file(params.in); if (!in.success) { fprintf(stderr, "Can't read from %s\n", params.in); return -1; } merge_result result = {}; do { result = merge(in.data, params.dir, result.merged_files); if (!result.success) { return -1; } if (params.recursive && result.changed) { in.data = std::move(result.data); in.data.push_back(0); result.data.clear(); } } while (params.recursive && result.changed); if (!write_file(params.out, result.data)) { printf("Can't write to file %s\n", params.out); return -1; } return 0; }
/** * Mainloop of olsrd * @return exit code for olsrd */ static int mainloop(int argc, char **argv, const struct oonf_appdata *appdata) { int exit_code = 0; OONF_INFO(LOG_MAIN, "Starting %s", appdata->app_name); /* enter main loop */ while (oonf_cfg_is_running()) { /* call event scheduler */ if (_handle_scheduling()) { exit_code = 1; break; } /* reload configuration if triggered */ if (oonf_cfg_is_reload_set()) { OONF_INFO(LOG_MAIN, "Reloading configuration"); if (oonf_cfg_clear_rawdb()) { break; } if (parse_commandline(argc, argv, appdata, true) == -1) { if (oonf_cfg_apply()) { break; } } } /* commit config if triggered */ if (oonf_cfg_is_commit_set()) { OONF_INFO(LOG_MAIN, "Commiting configuration"); if (oonf_cfg_apply()) { break; } } } OONF_INFO(LOG_MAIN, "Ending %s", appdata->app_name); return exit_code; }
int main(int argc, char **argv) { parse_commandline(argc, argv); //dump_options(); if (!std::strlen(gFile)) { usage(); std::exit(1); } acquire_board(gFile); Sudoku board(BASESIZE, SYMBOL_TYPE, Callback); board.SetupBoard(gBoard, std::strlen(gBoard)); board.Solve(); PrintStats(board); std::cout << std::endl; delete [] gBoard; return 0; }
int tool_main(int argc, char** argv) { SkAutoGraphics ag; SkTArray<SkString> inputs; sk_tools::PictureRenderer* renderer = NULL; SkString* outputDir = NULL; bool validate = false; int maxComponentDiff = 256; bool writeWholeImage = false; int clones = 0; parse_commandline(argc, argv, &inputs, renderer, outputDir, &validate, &maxComponentDiff, &writeWholeImage, &clones); SkASSERT(renderer); int failures = 0; for (int i = 0; i < inputs.count(); i ++) { failures += process_input(inputs[i], outputDir, *renderer, validate, maxComponentDiff, writeWholeImage, clones); } if (failures != 0) { SkDebugf("Failed to render %i pictures.\n", failures); return 1; } #if SK_SUPPORT_GPU #if GR_CACHE_STATS if (renderer->isUsingGpuDevice()) { GrContext* ctx = renderer->getGrContext(); ctx->printCacheStats(); } #endif #endif if (NULL != outputDir) { SkDELETE(outputDir); } SkDELETE(renderer); return 0; }