int main(int argc, char *argv[]) { const char *term = getenv("TERM"); const char *home = getenv("HOME"); const char *tag = NULL; const char *rc = NULL; const char *command = NULL; char *command_history_filename; char *search_history_filename; char *editor_dir; bool read_rc = true; int i; if (!home) home = ""; home_dir = xstrdup(home); for (i = 1; i < argc; i++) { const char *opt = argv[i]; if (opt[0] != '-' || !opt[1]) break; if (!opt[2]) { switch (opt[1]) { case 'R': read_rc = false; continue; case 't': tag = opt_arg(opt, argv[++i]); continue; case 'r': rc = opt_arg(opt, argv[++i]); continue; case 'c': command = opt_arg(opt, argv[++i]); continue; case 'V': printf("%s %s\nWritten by Timo Hirvonen\n", program, version); return 0; } if (opt[1] == '-') { i++; break; } } printf("Usage: %s [-R] [-V] [-c command] [-t tag] [-r rcfile] [file]...\n", argv[0]); return 1; } if (!isatty(1)) { fprintf(stderr, "stdout doesn't refer to a terminal\n"); return 1; } if (term == NULL || term[0] == 0) { fprintf(stderr, "TERM not set\n"); return 1; } switch (term_init(term)) { case -1: fprintf(stderr, "terminal is hardcopy\n"); return 1; case -2: fprintf(stderr, "terminal could not be found\n"); return 1; case -3: fprintf(stderr, "terminfo database could not be found\n"); return 1; } // create this early. needed if lock-files is true editor_dir = editor_file(""); mkdir(editor_dir, 0755); free(editor_dir); setlocale(LC_CTYPE, ""); charset = nl_langinfo(CODESET); if (streq(charset, "UTF-8")) term_utf8 = true; exec_builtin_rc(builtin_rc); fill_builtin_colors(); // NOTE: syntax_changed() uses window. should possibly create window after reading rc window = new_window(); root_frame = new_root_frame(window); if (read_rc) { if (rc) { read_config(commands, rc, true); } else { char *filename = editor_file("rc"); if (read_config(commands, filename, false)) { free(filename); filename = xsprintf("%s/rc", pkgdatadir); read_config(commands, filename, true); } free(filename); } } update_all_syntax_colors(); sort_aliases(); /* Terminal does not generate signals for control keys. */ set_signal_handler(SIGINT, SIG_IGN); set_signal_handler(SIGQUIT, SIG_IGN); set_signal_handler(SIGPIPE, SIG_IGN); /* Terminal does not generate signal for ^Z but someone can send * us SIGTSTP nevertheless. SIGSTOP can't be caught. */ set_signal_handler(SIGTSTP, handle_sigtstp); set_signal_handler(SIGCONT, handle_sigcont); set_signal_handler(SIGWINCH, handle_sigwinch); load_file_history(); command_history_filename = editor_file("command-history"); search_history_filename = editor_file("search-history"); history_load(&command_history, command_history_filename, command_history_size); history_load(&search_history, search_history_filename, search_history_size); if (search_history.count) search_set_regexp(search_history.ptrs[search_history.count - 1]); /* Initialize terminal but don't update screen yet. Also display * "Press any key to continue" prompt if there were any errors * during reading configuration files. */ term_raw(); if (nr_errors) { any_key(); clear_error(); } editor_status = EDITOR_RUNNING; for (; i < argc; i++) window_open_buffer(window, argv[i], false, NULL); if (window->views.count == 0) window_open_empty_buffer(window); set_view(window->views.ptrs[0]); if (command || tag) resize(); if (command) handle_command(commands, command); if (tag) { PTR_ARRAY(array); ptr_array_add(&array, xstrdup("tag")); ptr_array_add(&array, xstrdup(tag)); ptr_array_add(&array, NULL); run_commands(commands, &array); ptr_array_free(&array); } resize(); main_loop(); ui_end(); // unlock files and add files to file history remove_frame(root_frame); history_save(&command_history, command_history_filename); history_save(&search_history, search_history_filename); free(command_history_filename); free(search_history_filename); save_file_history(); return 0; }
int main(int argc,char **argv){ char option; char *blacklist_file = NULL; char *whitelist_file = NULL; char *file_config = NULL; char *interface = NULL; char *pcap_file = NULL; int daemonize = 0, sniffer = 0; set_signal(SIGHUP); set_signal(SIGINT); set_signal(SIGILL); set_signal(SIGQUIT); //set_signal(SIGSEGV); set_signal(SIGTERM); while((option = getopt(argc,argv,"i:b:w:t:c:dsp:h?")) > 0){ switch(option){ case 'b': blacklist_file = optarg; break; case 'w': whitelist_file = optarg; break; case 'c': file_config = optarg; break; case 't': mWorld.type = atoi(optarg); break; case 'd': daemonize = 1; break; case 's': sniffer = 1; break; case 'p': pcap_file = optarg; break; case 'i': interface = optarg; break; case '?': case 'h': usage(argv[0],EXIT_SUCCESS); default: break; } } argc -= optind; argv += optind; if(daemonize) daemon(1,0); mWorld.root_list = new_domain_structure("ROOT",-1); if(mWorld.type == 0){ fprintf(stderr,"\n\n[*] Please choose detection method [ -t ])\n\n"); exit(EXIT_FAILURE); } if(((interface == NULL) && sniffer) && (pcap_file == NULL)){ fprintf(stderr,"\n\n[*] Please set interface for sniffer or provide .pcap file for analysis\n\n"); exit(EXIT_FAILURE); } if(!file_config){ fprintf(stderr,"\n[*] Please set config file [ -c ]\n"); exit(EXIT_FAILURE); } config = set_config((void *)&mWorld); read_config(file_config,config); switch(mWorld.type){ case 1: cor_initialize((void *) &mWorld); break; case 2: ga_initialize((void *) &mWorld); break; case 3: naive_initialize((void *) &mWorld); break; } if(interface){ if(!(mWorld.interface = (char *) malloc(sizeof(char) * strlen(interface)))){ fprintf(stderr,"[malloc] OOM\n"); exit(EXIT_FAILURE); } memcpy(mWorld.interface,interface,strlen(interface)+1); } if(!mWorld.log_file){ openDB(&mWorld,"dnsmoleLog.db"); } else openDB(&mWorld,mWorld.log_file); useDB((void *)&mWorld,SELECT_LIST,"domainList",&listDomains_select_callback); if(blacklist_file) read_list((void *)&mWorld,mWorld.root_list,blacklist_file,1); if(whitelist_file) read_list((void *)&mWorld,mWorld.root_list,whitelist_file,0); if(!mWorld.parameters.subnet) mWorld.parameters.subnet = 16; if(pcap_file){ if(read_pcap(pcap_file)) mWorld.moleFunctions.analyze(mWorld.count,(void *) &mWorld); printf("\n\n[*] File: %s analyzed\n\n",pcap_file); } pcap_file = NULL; if(sniffer && interface){ event_init(); if(sniffer_setup((void *)&mWorld) < 0){ fprintf(stderr,"[sniffer_setup] error\n"); exit(EXIT_FAILURE); } mWorld.tv.tv_sec = 0; mWorld.tv.tv_usec = 500; if(!mWorld.analyze_tv.tv_sec) mWorld.analyze_tv.tv_sec = 600; mWorld.analyze_tv.tv_usec = 0; mWorld.pcap_fd = pcap_fileno(mWorld.p); event_set(&mWorld.recv_ev,mWorld.pcap_fd,EV_READ, _dns_sniffer, (void *)&mWorld); event_add(&mWorld.recv_ev, NULL); evtimer_set(&mWorld.analyze_ev, _analyzer, (void *)&mWorld); evtimer_add(&mWorld.analyze_ev,&mWorld.analyze_tv); event_dispatch(); } cleanup(); exit(EXIT_SUCCESS); }
int main(int argc, char* argv[]) { char* path_to_config; char* path_to_errors; int is_batch_mode; int key = 0; int list_scr = 0; struct process_list* proc_list; screen_t* screen = NULL; int screen_num = 0; int q; int paranoia_level; /* Check OS to make sure we can run. */ paranoia_level = check(); init_options(&options); options.paranoia_level = paranoia_level; path_to_config = get_path_to_config(argc, argv); path_to_errors = get_path_to_error(argc, argv); is_batch_mode = get_batch_mode(argc, argv); init_errors(is_batch_mode, path_to_errors); q = read_config(path_to_config, &options); if (q == 0) { debug_printf("Config file successfully parsed.\n"); options.config_file = 1; } else debug_printf("Could not parse config file.\n"); /* Parse command line arguments. */ parse_command_line(argc, argv, &options, &list_scr, &screen_num); /* Add default screens */ if (options.default_screen == 1) init_screen(); /* Remove unused but declared counters */ tamp_counters(); if (list_scr) { list_screens(); delete_screens(); exit(0); } if (options.spawn_pos) { /* monitor only spawned process */ int child = spawn(argv + options.spawn_pos); options.only_pid = child; options.idle = 1; } do { if (screen_num >= 0) screen = get_screen(screen_num); else screen = get_screen_by_name(argv[-screen_num]); if (!screen) { fprintf(stderr, "No such screen.\n"); exit(EXIT_FAILURE); } /* initialize the list of processes, and then run */ proc_list = init_proc_list(); if (options.spawn_pos) { options.spawn_pos = 0; /* do this only once */ new_processes(proc_list, screen, &options); start_child(); } if (options.batch) { batch_mode(proc_list, screen); key = 'q'; } #ifdef HAVE_LIBCURSES else { key = live_mode(proc_list, screen); if ((key == '+') || (key == KEY_RIGHT)) { screen_num = (screen_num + 1) % get_num_screens(); active_col = 0; done_proc_list(proc_list); free(header); } if ((key == '-') || (key == KEY_LEFT)) { int n = get_num_screens(); screen_num = (screen_num + n - 1) % n; active_col = 0; done_proc_list(proc_list); free(header); } if ((key == 'u') || (key == 'K') || (key == 'p')) { done_proc_list(proc_list); } } #endif } while (key != 'q'); /* done, free memory (makes valgrind happy) */ close_error(); delete_screens(); done_proc_list(proc_list); free_options(&options); return 0; }
int main (int argc, char *argv[]) { DSPAM_CTX *CTX = NULL, *CTX2; char *user; int do_sigs = 0; int do_probs = 0; int do_unused = 0; int age_sigs = 14; int age_probs = 30; int age_unused[4] = { 90, 30, 15, 15 }; int i, help = 0; struct nt *users = NULL; struct nt_node *node = NULL; #ifndef _WIN32 #ifdef TRUSTED_USER_SECURITY struct passwd *p = getpwuid (getuid ()); #endif #endif /* Read dspam.conf */ agent_config = read_config(NULL); if (!agent_config) { LOG(LOG_ERR, ERR_AGENT_READ_CONFIG); fprintf (stderr, ERR_AGENT_READ_CONFIG "\n"); exit(EXIT_FAILURE); } if (!_ds_read_attribute(agent_config, "Home")) { LOG(LOG_ERR, ERR_AGENT_DSPAM_HOME); fprintf (stderr, ERR_AGENT_DSPAM_HOME "\n"); goto bail; } if (libdspam_init(_ds_read_attribute(agent_config, "StorageDriver")) != 0) { LOG(LOG_ERR, ERR_DRV_INIT); fprintf (stderr, ERR_DRV_INIT "\n"); _ds_destroy_config(agent_config); exit(EXIT_FAILURE); } #ifndef _WIN32 #ifdef TRUSTED_USER_SECURITY if (!_ds_match_attribute(agent_config, "Trust", p->pw_name) && p->pw_uid) { fprintf(stderr, ERR_TRUSTED_MODE "\n"); goto bail; } #endif #endif for(i=0;i<argc;i++) { if (!strncmp (argv[i], "--profile=", 10)) { if (!_ds_match_attribute(agent_config, "Profile", argv[i]+10)) { LOG(LOG_ERR, ERR_AGENT_NO_SUCH_PROFILE, argv[i]+10); fprintf (stderr, ERR_AGENT_NO_SUCH_PROFILE "\n", argv[i]+10); goto bail; } else { _ds_overwrite_attribute(agent_config, "DefaultProfile", argv[i]+10); } break; } } #ifdef DEBUG fprintf (stdout, "dspam_clean starting\n"); #endif if (_ds_read_attribute(agent_config, "PurgeSignatures") && !_ds_match_attribute(agent_config, "PurgeSignatures", "off")) { do_sigs = 1; age_sigs = atoi(_ds_read_attribute(agent_config, "PurgeSignatures")); } if (_ds_read_attribute(agent_config, "PurgeNeutral") && !_ds_match_attribute(agent_config, "PurgeNeutral", "off")) { do_probs = 1; age_probs = atoi(_ds_read_attribute(agent_config, "PurgeNeutral")); } if (_ds_read_attribute(agent_config, "PurgeUnused") && !_ds_match_attribute(agent_config, "PurgeUnused", "off")) { int i; do_unused = 1; age_unused[0] = atoi(_ds_read_attribute(agent_config, "PurgeUnused")); age_unused[1] = atoi(_ds_read_attribute(agent_config, "PurgeHapaxes")); age_unused[2] = atoi(_ds_read_attribute(agent_config, "PurgeHits1S")); age_unused[3] = atoi(_ds_read_attribute(agent_config, "PurgeHits1I")); for(i=0;i<4;i++) if (age_unused[i]==0) do_unused = 0; } users = nt_create(NT_CHAR); if (users == NULL) { fprintf(stderr, "%s", ERR_MEM_ALLOC); goto bail; } for(i=0;i<argc;i++) { if (!strncmp(argv[i], "-p", 2)) { do_probs = 1; if (strlen(argv[i])>2) age_probs = atoi(argv[i]+2); } else if (!strncmp(argv[i], "-s", 2)) { do_sigs = 1; if (strlen(argv[i])>2) age_sigs = atoi(argv[i]+2); } else if (!strncmp(argv[i], "-u", 2)) { do_unused = 1; if (strlen(argv[i])>2) { char *c = strdup(argv[i]+2); char *d = strtok(c, ","); int j = 0; while(d != NULL && j<4) { age_unused[j] = atoi(d); j++; d = strtok(NULL, ","); } free(c); } } else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) help = 1; else if (i>0) nt_add(users, argv[i]); } if (help || (!do_probs && !do_sigs && !do_unused)) { fprintf(stderr, "%s", CLEANSYNTAX); _ds_destroy_config(agent_config); nt_destroy(users); libdspam_shutdown(); if (help) { exit(EXIT_SUCCESS); } exit(EXIT_FAILURE); } open_ctx = open_mtx = NULL; signal (SIGINT, dieout); signal (SIGPIPE, dieout); signal (SIGTERM, dieout); dspam_init_driver (NULL); if (users->items == 0) { CTX = dspam_create (NULL, NULL, _ds_read_attribute(agent_config, "Home"), DSM_TOOLS, 0); open_ctx = CTX; if (CTX == NULL) { fprintf (stderr, "Could not initialize context: %s\n", strerror (errno)); dspam_shutdown_driver (NULL); goto bail; } set_libdspam_attributes(CTX); if (dspam_attach(CTX, NULL)) { LOG (LOG_WARNING, "unable to attach dspam context"); fprintf (stderr, "Unable to attach DSPAM context\n"); goto bail; } user = _ds_get_nextuser (CTX); } else { node = users->first; if (node != NULL) user = node->ptr; else goto bail; } while (user != NULL) { #ifdef DEBUG printf ("PROCESSING USER: %s\n", user); #endif CTX2 = dspam_create (user, NULL, _ds_read_attribute(agent_config, "Home"), DSM_TOOLS, 0); open_mtx = CTX2; if (CTX2 == NULL) { fprintf (stderr, "Could not initialize context: %s\n", strerror (errno)); return EUNKNOWN; } set_libdspam_attributes(CTX2); if (dspam_attach(CTX2, NULL)) { LOG (LOG_WARNING, "unable to attach dspam context"); fprintf (stderr, "Unable to attach DSPAM context\n"); goto bail; } if (do_sigs) process_sigs(CTX2, age_sigs); if (do_probs) process_probs(CTX2, age_probs); if (do_unused) process_unused(CTX2, age_unused[0], age_unused[1], age_unused[2], age_unused[3]); dspam_destroy (CTX2); open_mtx = NULL; if (users->items == 0) { user = _ds_get_nextuser (CTX); } else { if (node == NULL || node->next == NULL) { node = NULL; user = NULL; } else { node = node->next; user = node->ptr; } } } if (users->items == 0) { dspam_destroy (CTX); open_ctx = NULL; } dspam_shutdown_driver (NULL); _ds_destroy_config(agent_config); nt_destroy(users); libdspam_shutdown(); exit (EXIT_SUCCESS); bail: if (open_ctx) dspam_destroy(open_ctx); if (open_mtx) dspam_destroy(open_mtx); _ds_destroy_config(agent_config); nt_destroy(users); libdspam_shutdown(); exit(EXIT_FAILURE); }
void process_cmd(char *readbuf, int length) { typedef enum pipe_cmd_type{ca,im,tl,px,bo,tv,an,as,at,ac,ab,sh,co,br,sa,is,vs,rl,ec,em,wb,mm,ie,ce,ro,fl,ri,ss,qu,pv,bi,ru,md,sc,rs,bu,mn,mt,mi,mb,me,mx,mf,vm,vp,wd,sy,cn,st} pipe_cmd_type; char pipe_cmds[] = "ca,im,tl,px,bo,tv,an,as,at,ac,ab,sh,co,br,sa,is,vs,rl,ec,em,wb,mm,ie,ce,ro,fl,ri,ss,qu,pv,bi,ru,md,sc,rs,bu,mn,mt,mi,mb,me,mx,mf,vm,vp,wd,sy,cn,st"; pipe_cmd_type pipe_cmd; int parcount; char pars[128][10]; long int par0; char cmd[3]; char par[MAX_COMMAND_LEN]; char *parstring=0, *temp; int key = -1; if (length < 2 || length > (MAX_COMMAND_LEN - 2)) return; //Get cmd strncpy(cmd, readbuf, 2); //find 2 letter command and translate into enum temp = strstr(pipe_cmds, cmd); if (temp == NULL) return; pipe_cmd = (pipe_cmd_type)((temp - pipe_cmds) / 3); if(length > 3) { strcpy(par, readbuf + 3); par[length-3] = 0; //extract space separated numeric parameters // and make separate string parameter (strtok changes the original) asprintf(&parstring, "%s", par); parcount = 0; temp = strtok(par, " "); while(parcount<10 && temp != NULL) { strcpy(pars[parcount], temp); parcount++; temp = strtok(NULL, " "); } par0 = strtol(pars[0], NULL, 10); } else { par0 = 0; } switch(pipe_cmd) { case ca: if(par0 == 1) { if (parcount > 1) { long vtime = strtol(pars[1], NULL, 10); video_stoptime = time(NULL) + vtime; printLog("Capturing %d seconds\n", vtime); } start_video(0); } else { stop_video(0); } break; case im: capt_img(); break; case tl: if(par0) { timelapse = 1; lapse_cnt = 1; updateStatus(); printLog("Timelapse started\n"); } else { image2_cnt++; timelapse = 0; updateStatus(); printLog("Timelapse stopped\n"); } break; case px: stop_all(); addUserValue(c_video_width, pars[0]); addUserValue(c_video_height, pars[1]); addUserValue(c_video_fps, pars[2]); addUserValue(c_MP4Box_fps, pars[3]); addUserValue(c_image_width, pars[4]); addUserValue(c_image_height, pars[5]); start_all(0); break; case bo: addUserValue(c_MP4Box, pars[0]); break; case tv: addUserValue(c_tl_interval, pars[0]); break; case an: addUserValue(c_annotation, parstring); break; case as: addUserValue(c_anno_text_size, pars[0]); break; case at: addUserValue(c_anno3_custom_text_colour, pars[0]); addUserValue(c_anno3_custom_text_Y, pars[1]); addUserValue(c_anno3_custom_text_U, pars[2]); addUserValue(c_anno3_custom_text_V, pars[3]); break; case ac: addUserValue(c_anno3_custom_background_colour, pars[0]); addUserValue(c_anno3_custom_background_Y, pars[1]); addUserValue(c_anno3_custom_background_U, pars[2]); addUserValue(c_anno3_custom_background_V, pars[3]); break; case ab: addUserValue(c_anno_background, pars[0]); break; case sh: key = c_sharpness; break; case co: key = c_contrast; break; case br: key = c_brightness; break; case sa: key = c_saturation; break; case is: key = c_iso; break; case vs: key = c_video_stabilisation; break; case rl: key = c_raw_layer; break; case ec: key = 1000 + c_exposure_compensation; break; case em: key = 1000 + c_exposure_mode; break; case wb: key = 1000 + c_white_balance; break; case mm: key = 1000 + c_metering_mode; break; case ie: key = 1000 + c_image_effect; break; case ce: addUserValue(c_colour_effect_u, pars[1]); addUserValue(c_colour_effect_v, pars[2]); key = c_colour_effect_en; break; case ro: key = c_rotation; break; case fl: if(par0 & 1) addUserValue(c_hflip, "1"); else addUserValue(c_hflip, "0"); if((par0 >> 1) & 1) addUserValue(c_vflip, "1"); else addUserValue(c_vflip, "0"); cam_set(c_hflip); break; case ri: addUserValue(c_sensor_region_y, pars[1]); addUserValue(c_sensor_region_w, pars[2]); addUserValue(c_sensor_region_h, pars[3]); key = c_sensor_region_x; break; case ss: addUserValue(c_shutter_speed, pars[0]); key = c_shutter_speed; break; case qu: key = c_image_quality; break; case pv: stop_all(); addUserValue(c_quality, pars[0]); addUserValue(c_width, pars[1]); addUserValue(c_divider, pars[2]); start_all(0); break; case bi: stop_all(); addUserValue(c_video_bitrate, pars[0]); start_all(0); break; case st: stop_all(); addUserValue(c_stat_pass, pars[0]); start_all(0); break; case wd: addUserValue(c_watchdog_interval, pars[0]); addUserValue(c_watchdog_errors, pars[1]); break; case ru: if (par0 == 0) { stop_all(); idle = 1; printLog("Stream halted\n"); } else { start_all(1); idle = 0; printLog("Stream continued\n"); } updateStatus(); break; case mx: key = c_motion_external; //If switching to internal with motion detection on then try to kill external motion if (cfg_val[c_motion_detection] != 0 && !par0) { if(system("killall motion") == -1) error("Could not stop external motion", 1); printLog("External motion detection stopped\n"); } break; case md: exec_macro(cfg_stru[c_do_cmd], readbuf); stop_all(); if (cfg_val[c_motion_external]) { if(par0 == 0) { if(system("killall motion") == -1) error("Could not stop external motion", 1); printLog("External motion detection stopped\n"); } else { if (cfg_val[c_motion_detection] == 0) { if(system("motion") == -1) error("Could not start external motion", 1); printLog("External motion detection started\n"); } else { printLog("Motion already running. md 1 ignored\n"); } } } else { if(par0 == 0) { printLog("Internal motion detection stopped\n"); } else { printLog("Internal motion detection started\n"); } } cfg_val[c_motion_detection] = par0?1:0; start_all(0); updateStatus(); break; case sc: set_counts(); printLog("Scan for highest count\n"); break; case rs: printLog("Reset settings to defaults\n"); stop_all(); read_config("/etc/raspimjpeg", 1); saveUserConfig(cfg_stru[c_user_config]); start_all(0); break; case bu: key = c_video_buffer; break; case vp: stop_all(); addUserValue(c_vector_preview, pars[0]); start_all(0); break; case mn: key = c_motion_noise; break; case mt: key = c_motion_threshold; break; case mi: key = c_motion_image + 1000; break; case mb: key = c_motion_startframes; break; case me: key = c_motion_stopframes; break; case mf: key = c_motion_file; break; case vm: key = c_vector_mode; break; case sy: exec_macro(parstring, NULL); break; case cn: stop_all(); addUserValue(c_camera_num, pars[0]); start_all(0); break; default: printLog("Unrecognised pipe command\n"); break; }
svn_error_t * svn_fs_fs__initialize_caches(svn_fs_t *fs, apr_pool_t *pool) { fs_fs_data_t *ffd = fs->fsap_data; const char *prefix = apr_pstrcat(pool, "fsfs:", ffd->uuid, "/", fs->path, ":", NULL); svn_memcache_t *memcache; svn_boolean_t no_handler; SVN_ERR(read_config(&memcache, &no_handler, fs, pool)); /* Make the cache for revision roots. For the vast majority of * commands, this is only going to contain a few entries (svnadmin * dump/verify is an exception here), so to reduce overhead let's * try to keep it to just one page. I estimate each entry has about * 72 bytes of overhead (svn_revnum_t key, svn_fs_id_t + * id_private_t + 3 strings for value, and the cache_entry); the * default pool size is 8192, so about a hundred should fit * comfortably. */ if (memcache) SVN_ERR(svn_cache__create_memcache(&(ffd->rev_root_id_cache), memcache, serialize_id, deserialize_id, sizeof(svn_revnum_t), apr_pstrcat(pool, prefix, "RRI", NULL), fs->pool)); else SVN_ERR(svn_cache__create_inprocess(&(ffd->rev_root_id_cache), dup_id, sizeof(svn_revnum_t), 1, 100, FALSE, fs->pool)); if (! no_handler) SVN_ERR(svn_cache__set_error_handler(ffd->rev_root_id_cache, warn_on_cache_errors, fs, pool)); /* Rough estimate: revision DAG nodes have size around 320 bytes, so * let's put 16 on a page. */ if (memcache) SVN_ERR(svn_cache__create_memcache(&(ffd->rev_node_cache), memcache, svn_fs_fs__dag_serialize, svn_fs_fs__dag_deserialize, APR_HASH_KEY_STRING, apr_pstrcat(pool, prefix, "DAG", NULL), fs->pool)); else SVN_ERR(svn_cache__create_inprocess(&(ffd->rev_node_cache), svn_fs_fs__dag_dup_for_cache, APR_HASH_KEY_STRING, 1024, 16, FALSE, fs->pool)); if (! no_handler) SVN_ERR(svn_cache__set_error_handler(ffd->rev_node_cache, warn_on_cache_errors, fs, pool)); /* Very rough estimate: 1K per directory. */ if (memcache) SVN_ERR(svn_cache__create_memcache(&(ffd->dir_cache), memcache, svn_fs_fs__dir_entries_serialize, svn_fs_fs__dir_entries_deserialize, APR_HASH_KEY_STRING, apr_pstrcat(pool, prefix, "DIR", NULL), fs->pool)); else SVN_ERR(svn_cache__create_inprocess(&(ffd->dir_cache), dup_dir_listing, APR_HASH_KEY_STRING, 1024, 8, FALSE, fs->pool)); if (! no_handler) SVN_ERR(svn_cache__set_error_handler(ffd->dir_cache, warn_on_cache_errors, fs, pool)); /* Only 16 bytes per entry (a revision number + the corresponding offset). Since we want ~8k pages, that means 512 entries per page. */ if (memcache) SVN_ERR(svn_cache__create_memcache(&(ffd->packed_offset_cache), memcache, manifest_serialize, manifest_deserialize, sizeof(svn_revnum_t), apr_pstrcat(pool, prefix, "PACK-MANIFEST", NULL), fs->pool)); else SVN_ERR(svn_cache__create_inprocess(&(ffd->packed_offset_cache), dup_pack_manifest, sizeof(svn_revnum_t), 32, 1, FALSE, fs->pool)); if (! no_handler) SVN_ERR(svn_cache__set_error_handler(ffd->packed_offset_cache, warn_on_cache_errors, fs, pool)); if (memcache) { SVN_ERR(svn_cache__create_memcache(&(ffd->fulltext_cache), memcache, /* Values are svn_string_t */ NULL, NULL, APR_HASH_KEY_STRING, apr_pstrcat(pool, prefix, "TEXT", NULL), fs->pool)); if (! no_handler) SVN_ERR(svn_cache__set_error_handler(ffd->fulltext_cache, warn_on_cache_errors, fs, pool)); } else ffd->fulltext_cache = NULL; return SVN_NO_ERROR; }
int main (int argc, char **argv) { read_config ("./config.txt"); upload (argv[1], argv[2], argv[3], argv[4]); }
int main(int argc, char* argv[]) { thread_t command_t; char* tmp; int i; logger_set_limit(1); logger_set_instant_func(print_message_cli); if((timer = timer_init()) == NULL) { printf("Failed to create timer!\n"); return 1; } common_init(); read_config(); #ifdef USE_READLINE rl_catch_signals = 0; #endif for(i = 1 ; i < argc ; i++) { if(!strcmp(argv[i], "-h")) help(); else if(!strcmp(argv[i], "-c")) { information(); exit(0); } } signal(SIGINT , &ctrl_c);//&signalHandler); exit_time = 0; #ifndef DISABLE_PHYSICS space = NULL; staticBody = NULL; lInit(&to_remove_array, NULL); lInit(&chipmunk_data_array, NULL); pthread_mutex_init(&text_lock, NULL); physics_exit_time = 0; simple_lock_init(&physics_lock); #endif #ifndef DISABLE_PHYSICS /* Set the functions for the network_lib library. */ nlServerSetFuncs(&send_server_name, &fill_info, &new_chipmunk_data, &mark_for_delete, &key_press, &key_release, &get_exit_state, NULL, &logger_new_message); #else nlServerSetFuncs(&send_server_name, NULL, NULL, NULL, NULL, NULL, &get_exit_state, NULL, &logger_new_message); #endif nlServerInit(); if(argc > 2) { int i; for(i = 1; i < argc ; i++) { if(!strcmp(argv[i], "-u") && i+1 < argc) { mfree(IGD_URL); IGD_URL = m_strdup(argv[++i]); LOG("IGD Path: %s", IGD_URL); } else if(!strcmp(argv[i], "-p") && i+1 < argc) { #warning Check for errors. int port = 0; sscanf(argv[++i], "%d", &port); LOG("New port: %d", port); nlServerBindPort(port); } } } /* Start everything that has to do with the thread starting! */ nlServerStart(); #ifndef DISABLE_PHYSICS pthread_create(&command_t, NULL, command_thread, NULL); physics_thread(); /* If we arrive here, it is that an exit demand was * performed (certainly ^C or ^D). * We now clean everything up. */ pthread_cancel(command_t); #else command_thread(NULL); #endif quit(); return 0; }
network::connection ana_network_manager::read_from( network::connection connection_num, config& cfg, size_t timeout_ms) { if ( components_.empty() ) return 0; ana_component_set::iterator it; if ( connection_num == 0 ) { if ( components_.size() == 1 ) return read_from( components_.begin(), cfg, timeout_ms ); else { //Check first if there is an available buffer for (it = components_.begin(); it != components_.end(); ++it) if ( (*it)->new_buffer_ready() ) return read_from_ready_buffer( it, cfg ); // If no timeout was requested, return if (timeout_ms == 0 ) return 0; // Wait timeout_ms milliseconds to see if any component will receive something ana_multiple_receive_handler handler( components_ ); for (it = components_.begin(); it != components_.end(); ++it ) (*it)->listener()->set_listener_handler( &handler ); handler.wait_completion( timeout_ms ); for (it = components_.begin(); it != components_.end(); ++it ) (*it)->listener()->set_listener_handler( this ); if ( handler.error() ) { for (it = components_.begin(); it != components_.end(); ++it) if ( (*it)->new_buffer_ready() ) return read_from_ready_buffer( it, cfg ); // So nothing was read: return 0; } else { read_config( handler.buffer(), cfg); return handler.get_wesnoth_id(); } } } else { ana::net_id id( connection_num ); it = std::find_if( components_.begin(), components_.end(), boost::bind(std::logical_or<bool>(), (boost::bind(&ana_component::get_wesnoth_id, _1) == connection_num), (boost::bind(&ana_component::get_id, _1) == id ) ) ); //Make a broad attempt at finding it, test for both ANA's id and the assigned one. if ( it != components_.end()) return read_from(it, cfg, timeout_ms); else throw std::runtime_error("Trying a network read from an invalid component id."); } }
int main(int argc, char **argv) { struct server *s = NULL; pthread_t pt, ctl; int c, is_forward = 0; const char *config = SR_CONFIG_FILE; int daemon = 0; while ((c = getopt(argc,argv,"c:vhfd")) != -1) { switch(c) { case 'c': config = optarg; break; case 'h': help(argv[0]); exit(0); break; case 'f': is_forward = 1; break; case 'd': daemon = 1; break; case '?': printf("Try -h please\n"); exit(0); break; case 'v': printf("dnspod-sr 0.01\n"); exit(0); break; default: exit(0); break; } } sanity_test(0); drop_privilege("./"); daemonrize(daemon); trig_signals(1); global_now = time(NULL); //for read root.z g_nameservers[0] = g_nameservers[1] = NULL; init_globe(); init_mempool(); s = server_init(); s->is_forward = is_forward; read_config(config, (char *)s->logpath, s->forward, g_nameservers); // add default dns server 8.8.8.8, 114.114.114.114 if (g_nameservers[0] == NULL) { assert(g_nameservers[1] == NULL); g_nameservers[0] = strdup("119.29.29.29"); g_nameservers[1] = strdup("8.8.4.4"); } if (g_nameservers[1] == NULL) { if (strcmp(g_nameservers[0], "119.29.29.29") == 0) { g_nameservers[1] = strdup("8.8.4.4"); } else { g_nameservers[1] = strdup("119.29.29.29"); } } // if (create_fetcher(s, s->nfetcher) < 0) dns_error(0, "create worker"); if (create_author(s, s->nquizzer) < 0) dns_error(0, "create author"); if (pthread_create(&pt, NULL, (void *) time_cron, s) != 0) dns_error(0, "time cron error"); if (pthread_create(&ctl, NULL, (void *)recv_update, s) != 0) { dns_error(0, "recv update thread error"); } read_root(s->datasets, s->ttlexp); print_basic_debug(); global_serv = s; run_sentinel(s); return 0; }