void redemption_main_loop(Inifile & ini, unsigned uid, unsigned gid) { init_signals(); SessionServer ss(&refreshconf, uid, gid); // Inifile ini(CFG_PATH "/" RDPPROXY_INI); uint32_t s_addr = inet_addr(ini.globals.listen_address); if (s_addr == INADDR_NONE) { s_addr = INADDR_ANY; } int port = ini.globals.port; Listen listener(ss, s_addr, port); listener.run(); }
void start_main(int argc, char** argv, char** envp) { init_process_malloc(); init_stdfiles(); init_signals(); init_environ(envp); exit(main(argc, argv)); }
int main(int argc, char *argv[]) { pid_t pid; #ifdef SIGNAL init_signals(); #endif if (argc == 2) { usage(); return 0; } if (argc == 3) { if (!strcmp(argv[1], "-i")) { if (getIfIsUp(argv[2]) == 1) strcpy(IF_NAME, argv[2]); else return 0; } else { usage(); return 0; } } else { strcpy(IF_NAME, "ra0"); } /* background ourself */ if (do_fork) { pid = fork(); } else { pid = getpid(); } switch (pid) { case -1: /* error */ perror("fork/getpid"); return -1; case 0: /* child, success */ break; default: /* parent, success */ if (do_fork) return 0; break; } RaCfg_Agent(); return 0; }
void attach_debug() { #ifndef RUMBLE_MSC init_signals(); #else signal(SIGINT, &signal_windows); signal(SIGBREAK, &signal_windows); signal(SIGSEGV, &signal_windows); signal(SIGTERM, &signal_windows); signal(SIGABRT, &signal_windows); signal(SIGILL, &signal_windows); atexit(&cleanup); #endif }
int main(void) { t_env *env; char buffer[20]; init_signals(); tgetent(0, getenv("TERM")); if (!(env = malloc(sizeof(*env)))) quit("Failed to malloc env"); if (!(env->caps = malloc(sizeof(*env->caps)))) quit("Failed to malloc env caps"); env->messages = NULL; if (!(env->input = ft_memalloc(1))) quit("Failed to malloc new input"); init_caps(env->caps); terminal_catch_mode(); ft_putstr(env->caps->fullscreen_start); ft_putstr(env->caps->clear); ft_putstr(env->caps->stand_start); ft_putstr(env->caps->bold_start); int i = 0; set_cursor_position(env, 0, get_window_height() - 2); int width = get_window_width(); while (i < width) { ft_putchar('-'); i++; } ft_putstr(env->caps->stand_end); fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK); int t = 0; int rd; while (t < 50) { ft_bzero(buffer, 20); while ((rd = read(0, buffer, 20)) < 1) { if (errno != EAGAIN && errno != EWOULDBLOCK) quit("Error on stdin read"); //check tcp //check resize } ft_putstr(buffer); t++; } fcntl(0, F_SETFL, fcntl(0, F_GETFL) & ~O_NONBLOCK); ft_putstr(env->caps->fullscreen_end); terminal_normal_mode(); return (0); }
void handle_int(int UN signal) { t_term *s_term; if ((s_term = static_term(NULL))) { waddstr(s_term->slave.wins[WIN_SH], "^C"); if (s_term->line) clear_line(s_term->line); s_term->line = NULL; s_term->intr = 1; } init_signals(); }
int main(int argc, char *argv[]) { int rc; int interractive = 0; boost(); init_signals(); while (argc > 1) { char *arg = argv[--argc]; if (*arg=='-' && *(arg+1)=='i') { interractive = 1; } else if (*arg=='-' && *(arg+1)=='p') { pj_str_t port = pj_str(argv[--argc]); param_echo_port = pj_strtoul(&port); } else if (*arg=='-' && *(arg+1)=='s') { param_echo_server = argv[--argc]; } else if (*arg=='-' && *(arg+1)=='t') { pj_str_t type = pj_str(argv[--argc]); if (pj_stricmp2(&type, "tcp")==0) param_echo_sock_type = pj_SOCK_STREAM(); else if (pj_stricmp2(&type, "udp")==0) param_echo_sock_type = pj_SOCK_DGRAM(); else { PJ_LOG(3,("", "error: unknown socket type %s", type.ptr)); return 1; } } } rc = test_main(); if (interractive) { char s[10]; puts(""); puts("Press <ENTER> to exit"); if (!fgets(s, sizeof(s), stdin)) return rc; } return rc; }
/* Get things started */ void init_factor(F_PARAMETERS *p) { /* Kilobytes */ p->ds_size = align_page(p->ds_size << 10); p->rs_size = align_page(p->rs_size << 10); /* Megabytes */ p->young_size <<= 20; p->aging_size <<= 20; p->tenured_size <<= 20; p->code_size <<= 20; /* Disable GC during init as a sanity check */ gc_off = true; /* OS-specific initialization */ early_init(); if(p->image == NULL) p->image = default_image_path(); srand(current_micros()); init_ffi(); init_stacks(p->ds_size,p->rs_size); load_image(p); init_c_io(); init_signals(); if(p->console) open_console(); stack_chain = NULL; profiling_p = false; performing_gc = false; last_code_heap_scan = NURSERY; collecting_aging_again = false; userenv[CPU_ENV] = tag_object(from_char_string(FACTOR_CPU_STRING)); userenv[OS_ENV] = tag_object(from_char_string(FACTOR_OS_STRING)); userenv[CELL_SIZE_ENV] = tag_fixnum(sizeof(CELL)); userenv[STACK_TRACES_ENV] = tag_boolean(p->stack_traces); /* We can GC now */ gc_off = false; if(!stage2) do_stage1_init(); }
int jed_spawn_fg_process (int (*f)(VOID_STAR), VOID_STAR cd) { int status; int inited; if ((Jed_Secure_Mode) || (Jed_Suspension_Not_Allowed)) { msg_error ("Access to shell denied."); return -1; } /* FIXME: X_Suspend_Hook should not be here. Currently, this hook is * used only by GUI jed, where suspension makes no sense. Of course in * this case, spawning a foreground process also does not make sense. */ if (Batch || (X_Suspend_Hook != NULL)) return (*f) (cd); SLsig_block_signals (); inited = Jed_Display_Initialized; SLsig_unblock_signals (); jed_reset_display(); #if !defined(IBMPC_SYSTEM) && !defined(VMS) jed_reset_signals (); #endif reset_tty(); status = (*f) (cd); if (inited) { #if !defined(IBMPC_SYSTEM) && !defined(VMS) init_signals(); #endif if (-1 == init_tty()) { exit_error ("Unable to initialize terminal.", 0); } flush_input (); jed_init_display (); } check_buffers(); return status; }
int main(int ac, char **arv) { int error; #ifdef DEBUG /* logfile=/var/log/log.txt */ create_log(); fprintf(log_path, "ac = %d\n", ac); fflush(log_path); #endif /* setup signal handlers */ init_signals(); /* printer DEVICE ID and command line option check */ if((error = get_printer_devid()) < 0 || check_arg(ac,arv) < 0){ /* Not Canon printer or "--gui" option not found */ #ifdef DEBUG write_log("Now normal printing ......\n"); #endif print_normal(); exit(0); } /* create semapho and other setup */ if((error = lm_init(PRNT_PATH))){ exit(0); } /* monitor_process/print_process/status_process start */ lm_main_fork(); /* delete semapho */ remove_sem(sem_id); /* free memory (status monitor argv string) */ free_arg(); #ifdef DEBUG write_log("LM end \n"); #endif exit(0); }
int main(void) { // Vars struct fp_dev *device; struct fp_driver *driver; struct fp_print_data *print_data; struct fp_img *img; int err; // Init the LCD lcdinit(0x00, 0x12, 0x20); lcd_reset(); // Init libfprint fp_init(); // Init the keypad matrix_init(4, 17, 27, 22, 10, 9, 11, handle_key_press); // Signal handler - does an fp_exit() on SIGINT init_signals(); // Get the first fingerprint device if ((err = get_fingerprint_device(&device)) < 0 || !device) { // Errorz if (err == -1) { error("No devices found"); } else if (err == -2) { error("Couldn't open the device"); } return 1; } // Get driver driver = fp_dev_get_driver(device); // Init message printf("Programme started! Device is %s\n\n", fp_driver_get_full_name(driver)); // Scan the print fp_enroll_finger_img(device, &print_data, &img); // Deinit libfprint fp_exit(); return 0; }
int main(int argc, char **argv) { bool recovering = false; int port, control = 0; init_signals(); /** Get the port number. */ port = 7778; if (argc > 1) { if (!is_number(argv[1])) { fprintf(stderr, "Usage: %s [port #]\n", argv[0]); return 0; } else if ((port = atoi(argv[1])) <= 1024) { fprintf(stderr, "Port number must be above 1024.\n"); return 0; } /* Are we recovering from a copyover? */ if ((argv[2] != NULL) && (argv[2][0] != '\0')) { recovering = true; control = atoi(argv[3]); } else { recovering = false; } } init_time(&globalSystemState); boot_db(); /** Run the game. */ if (!recovering) { control = remote_listen(port); } log_string("BT is ready to rock on port %d.", port); if (recovering) { copyover_recover(); } game_loop(port, control); remote_deafen(control); log_string("Normal termination of game."); return 0; }
int create_cmdline_interface (char *prmt) { /* init the tty promt properties*/ init_tty_prompt (); /*signal handlers for SIGINT, SIGSEGV, SIGUSR1, SIGUSR2*/ init_signals(); /*XXX:set the tty prompt - we take control from shell don't forget to call reset_tty () once your job is done*/ set_tty(); set_prompt(prmt, strlen(prmt)); create_sync_lock (&cmd_root.lock); /*finally kick-start the shell thread*/ spawn_cli_thread (); return 0; }
void redemption_new_session() { char text[256]; char ip_source[256]; union { struct sockaddr s; struct sockaddr_storage ss; struct sockaddr_in s4; struct sockaddr_in6 s6; } u; int sock_len = sizeof(u); Inifile ini(CFG_PATH "/" RDPPROXY_INI); init_signals(); snprintf(text, 255, "redemption_%8.8x_main_term", getpid()); getpeername(0, &u.s, (socklen_t *)&sock_len); strcpy(ip_source, inet_ntoa(u.s4.sin_addr)); int sck = 0; if (ini.globals.debug.session){ LOG(LOG_INFO, "Setting new session socket to %d\n", sck); } int nodelay = 1; if (0 == setsockopt(sck, IPPROTO_TCP, TCP_NODELAY, (char*)&nodelay, sizeof(nodelay))){ wait_obj front_event(sck); Session session(front_event, sck, ip_source, &refreshconf, &ini); if (ini.globals.debug.session){ LOG(LOG_INFO, "Session::end of Session(%u)", sck); } shutdown(sck, 2); close(sck); } else { LOG(LOG_INFO, "Failed to set socket TCP_NODELAY option on client socket"); } }
void redemption_main_loop(Inifile & ini, unsigned uid, unsigned gid) { init_signals(); SessionServer ss(uid, gid); // Inifile ini(CFG_PATH "/" RDPPROXY_INI); uint32_t s_addr = inet_addr(ini.globals.listen_address); if (s_addr == INADDR_NONE) { s_addr = INADDR_ANY; } int port = ini.globals.port; Listen listener( ss , s_addr , port , false /* exit on timeout */ , 60 /* timeout sec */ , ini.globals.enable_ip_transparent ); listener.run(); }
int main(int argc, char **argv) { int listenfd, port, ret; struct horse *horses; unsigned int horse_num, pperh; pthread_mutex_t mutex, mfinished, mbank, mcur_run, mhb, mnr; pthread_cond_t cond; pthread_barrier_t barrier; struct service service; if (argc != 3) { usage(argv[0]); exit(EXIT_FAILURE); } // parse port port = atoi(argv[1]); listenfd = init_socket(port); _listen(listenfd, LISTENQ); init_sync(&mutex, &cond, &mfinished, &mbank, &mcur_run, &mhb, &mnr); ret = parse_conf_file(argv[2], &horses, &horse_num, &pperh, &mutex, &cond, &barrier, &service); if (ret) goto clean; if (!pperh || pperh > MAX_RACE_NUM) { fprintf(stderr, "races per hour %u should be more than 0 and less than %d\n", pperh, MAX_RACE_NUM + 1); goto clean; } init_signals(); srand(time(NULL)); init_service(&service, &mfinished, &mbank, &mcur_run, &mhb, &mnr, (unsigned int)(60 * 60 / pperh)); server_work(listenfd, &cond, &service, horses, horse_num); clean: // cleaning clean(&mutex, &cond, &mfinished, &mbank, &mcur_run, &mhb, &mnr, horses, listenfd); return EXIT_SUCCESS; }
int main(int argc, char **argv) { init_signals(); if (init_dbus() < 0) { fprintf(stderr, "Cannot initialize DBus\n"); return 1; } while (dbus_connection_read_write(conn, -1)) { while (dbus_connection_dispatch(conn) != DBUS_DISPATCH_COMPLETE) { } } shutdown_dbus(); return 0; }
void startup() { totalbytes = 0; printf("Acidblood %s\n", VERSION); init_conf() ; init_signals() ; init_networking() ; conf_userdata=NULL ; conf_channels=NULL ; init_usercommands() ; init_ctcp() ; init_srvcommands() ; init_log(); init_serverinfo() ; init_numeric() ; init_timers() ; init_events() ; read_main_config() ; init_modules() ; }
int main(int argc, char **argv) { int fd; int i; pid_t pid; sigset_t set; mainParseOptions(argc, argv); printf("yang test ... opt_send_signal:%d\r\n", opt_send_signal); if (-1 == opt_send_signal) if (checkRunningPid()) exit(1); enableCoredumps(); writePidFile(); save_argv(argc, argv); init_setproctitle(); init_signals(); sigemptyset(&set); printf("father pid1=%d\n",getpid()); int worker_processes = 3; start_worker_processes(worker_processes, PROCESS_RESPAWN); start_dispatcher_process(PROCESS_RESPAWN); printf("father pid2=%d\n", getpid()); setproctitle("nginx:master"); int live = 1; for (;;) { printf("father before suspend\n"); sigsuspend(&set); printf("father after suspend\n"); if (reap) { reap = 0; fprintf(stderr, "reap children\n"); live = reap_children(); } } return 0; }
/* This function is called (via check_events()) from the top level sieve loops (prime_sieve() etc.). It can assume that it is safe to tighten any sieving parameters other than p_min and p_max. */ void process_events(uint64_t current_prime) { /* event_happened was set last in notify_event(), so clear it first which ensures that if some signal arrives while we are in process_events() it might have to wait until the next sieve iteration to get processed, but it won't be lost. */ event_happened = 0; if (clear_event(initialise_events)) { init_signals(); init_progress_report(current_prime); } if (clear_event(subsequence_eliminated)) remove_eliminated_subsequences(current_prime); if (clear_event(sieve_parameters_changed)) init_progress_report(current_prime); if (clear_event(received_sigterm)) { finish_srsieve("SIGTERM was received",current_prime); signal(SIGTERM,SIG_DFL); raise(SIGTERM); } if (clear_event(received_sigint)) { finish_srsieve("SIGINT was received",current_prime); signal(SIGINT,SIG_DFL); raise(SIGINT); } if (clear_event(report_due)) progress_report(current_prime); if (clear_event(save_due)) write_save_file(current_prime); }
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; }
static int init_mysh(t_term *s_term, char **environ) { char *env_path; my_bzero((void *)s_term, sizeof(*s_term)); if (environ && *environ) { get_environ(s_term, environ); static_term(s_term); init_signals(); s_term->tsave = init_termcap(s_term->environ); s_term->pid = my_getpid(); s_term->progs = NULL; if ((env_path = my_getenv(environ, "PATH=")) && (s_term->progs = get_path_progs(env_path)) && !add_builtins(s_term->progs)) return (1); } 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 */ }
void redemption_main_loop(Inifile & ini, CryptoContext & cctx, unsigned uid, unsigned gid, std::string config_filename) { init_signals(); SessionServer ss(cctx, uid, gid, std::move(config_filename), ini.get<cfg::debug::config>() == Inifile::ENABLE_DEBUG_CONFIG); // Inifile ini(CFG_PATH "/" RDPPROXY_INI); uint32_t s_addr = inet_addr(ini.get<cfg::globals::listen_address>().c_str()); // TODO -Wold-style-cast is ignored #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wold-style-cast" if (s_addr == INADDR_NONE) { s_addr = INADDR_ANY; } #pragma GCC diagnostic pop int port = ini.get<cfg::globals::port>(); Listen listener( ss , s_addr , port , false /* exit on timeout */ , 60 /* timeout sec */ , ini.get<cfg::globals::enable_ip_transparent>() ); listener.run(); }
int main(int argc, char **argv) { out_bgorlit(); test_hex2pro(); test_pro2hex(); cmd_parser(argc,argv,&glb_cfg); if(glb_cfg.daemon) run_as_daemon(); /* * Make sure only one copy of the daemon is running. */ if (already_running()) { debug(LOG_ERR, "daemon already running\n"); exit(1); } pthread_mutex_init(&(glb_cfg.lock), NULL); pthread_cond_init(&(glb_cfg.cond), NULL); // init_log(argv[0]); init_signals(); alarm(WT_SDCARD_PRIOD); pthread_t sorpid; pthread_create(&sorpid,NULL,handle_uart,NULL); pthread_t cmdpid; pthread_create(&cmdpid,NULL,handle_socket_machine,NULL); pthread_join(sorpid,NULL); pthread_join(cmdpid,NULL); debug(LOG_NOTICE,"<==========Process exit!\n"); // close_log(); return 0; }
int main(int argc, char *argv[]) { int rc; PJ_UNUSED_ARG(argc); PJ_UNUSED_ARG(argv); boost(); init_signals(); rc = test_main(); if (argc==2 && pj_ansi_strcmp(argv[1], "-i")==0) { char s[10]; puts("Press ENTER to quit"); if (fgets(s, sizeof(s), stdin) == NULL) return rc; } return rc; }
int main( int argc, char *argv[] ) { parse_args( argc, argv ); /* setup temporary handlers before the real signal initialization is done */ signal( SIGPIPE, SIG_IGN ); signal( SIGHUP, sigterm_handler ); signal( SIGINT, sigterm_handler ); signal( SIGQUIT, sigterm_handler ); signal( SIGTERM, sigterm_handler ); signal( SIGABRT, sigterm_handler ); sock_init(); open_master_socket(); setvbuf( stderr, NULL, _IOLBF, 0 ); if (debug_level) fprintf( stderr, "wineserver: starting (pid=%ld)\n", (long) getpid() ); init_signals(); init_directories(); init_registry(); main_loop(); return 0; }
int main() { int argc; char **argv; win32_get_argv_utf8(&argc, &argv); #else int main(int argc, char **argv) { #endif parse_shift_args(&opts, &argc, &argv); __idris_argc = argc; __idris_argv = argv; VM* vm = init_vm(opts.max_stack_size, opts.init_heap_size, 1); init_threadkeys(); init_threaddata(vm); init_gmpalloc(); init_nullaries(); init_signals(); _idris__123_runMain0_125_(vm, NULL); #ifdef IDRIS_DEBUG if (opts.show_summary) { idris_gcInfo(vm, 1); } #endif Stats stats = terminate(vm); if (opts.show_summary) { print_stats(&stats); } free_nullaries(); return EXIT_SUCCESS; }
int main (int argc, char *argv[]) { int ch; bool no_signals = false; bool test_config = false; pthread_t thid; char *uid = NULL; char *gid = NULL; start_heap = sbrk(0); setlocale(LC_ALL, ""); bindtextdomain("bareos", LOCALEDIR); textdomain("bareos"); init_stack_dump(); my_name_is(argc, argv, "bareos-sd"); init_msg(NULL, NULL); daemon_start_time = time(NULL); /* Sanity checks */ if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) { Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"), TAPE_BSIZE, B_DEV_BSIZE); } if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) { Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE); } while ((ch = getopt(argc, argv, "c:d:fg:mpstu:v?")) != -1) { switch (ch) { case 'c': /* configuration file */ if (configfile != NULL) { free(configfile); } configfile = bstrdup(optarg); break; case 'd': /* debug level */ if (*optarg == 't') { dbg_timestamp = true; } else { debug_level = atoi(optarg); if (debug_level <= 0) { debug_level = 1; } } break; case 'f': /* run in foreground */ foreground = true; break; case 'g': /* set group id */ gid = optarg; break; case 'm': /* print kaboom output */ prt_kaboom = true; break; case 'p': /* proceed in spite of I/O errors */ forge_on = true; break; case 's': /* no signals */ no_signals = true; break; case 't': test_config = true; break; case 'u': /* set uid */ uid = optarg; break; case 'v': /* verbose */ verbose++; break; case '?': default: usage(); break; } } argc -= optind; argv += optind; if (argc) { if (configfile != NULL) { free(configfile); } configfile = bstrdup(*argv); argc--; argv++; } if (argc) usage(); /* * See if we want to drop privs. */ if (geteuid() == 0) { drop(uid, gid, false); } if (!no_signals) { init_signals(terminate_stored); } if (configfile == NULL) { configfile = bstrdup(CONFIG_FILE); } my_config = new_config_parser(); parse_sd_config(my_config, configfile, M_ERROR_TERM); if (init_crypto() != 0) { Jmsg((JCR *)NULL, M_ERROR_TERM, 0, _("Cryptography library initialization failed.\n")); } if (!check_resources()) { Jmsg((JCR *)NULL, M_ERROR_TERM, 0, _("Please correct configuration file: %s\n"), configfile); } init_reservations_lock(); if (test_config) { terminate_stored(0); } my_name_is(0, (char **)NULL, me->hdr.name); /* Set our real name */ if (!foreground) { daemon_start(); /* become daemon */ init_stack_dump(); /* pick up new pid */ } create_pid_file(me->pid_directory, "bareos-sd", get_first_port_host_order(me->SDaddrs)); read_state_file(me->working_directory, "bareos-sd", get_first_port_host_order(me->SDaddrs)); read_crypto_cache(me->working_directory, "bareos-sd", get_first_port_host_order(me->SDaddrs)); set_jcr_in_tsd(INVALID_JCR); /* * Make sure on Solaris we can run concurrent, watch dog + servers + misc */ set_thread_concurrency(me->max_concurrent_jobs * 2 + 4); lmgr_init_thread(); /* initialize the lockmanager stack */ load_sd_plugins(me->plugin_directory, me->plugin_names); cleanup_old_files(); /* Ensure that Volume Session Time and Id are both * set and are both non-zero. */ VolSessionTime = (uint32_t)daemon_start_time; if (VolSessionTime == 0) { /* paranoid */ Jmsg0(NULL, M_ABORT, 0, _("Volume Session Time is ZERO!\n")); } /* * Start the device allocation thread */ create_volume_lists(); /* do before device_init */ if (pthread_create(&thid, NULL, device_initialization, NULL) != 0) { berrno be; Emsg1(M_ABORT, 0, _("Unable to create thread. ERR=%s\n"), be.bstrerror()); } start_watchdog(); /* start watchdog thread */ if (me->jcr_watchdog_time) { init_jcr_subsystem(me->jcr_watchdog_time); /* start JCR watchdogs etc. */ } #if HAVE_NDMP /* Seperate thread that handles NDMP connections */ if (me->ndmp_enable) { start_ndmp_thread_server(me->NDMPaddrs, me->max_concurrent_jobs * 2 + 1, &ndmp_workq); } #endif /* Single server used for Director/Storage and File daemon */ sock_fds = New(alist(10, not_owned_by_alist)); bnet_thread_server_tcp(me->SDaddrs, me->max_concurrent_jobs * 2 + 1, sock_fds, &dird_workq, me->nokeepalive, handle_connection_request); exit(1); /* to keep compiler quiet */ }
void redemption_new_session(CryptoContext & cctx, char const * config_filename) { char text[256]; char source_ip[256]; int target_port = 0; char real_target_ip[256]; union { struct sockaddr s; struct sockaddr_storage ss; struct sockaddr_in s4; struct sockaddr_in6 s6; } u; int sock_len = sizeof(u); Inifile ini; { ConfigurationLoader cfg_loader(ini.configuration_holder(), config_filename); } init_signals(); snprintf(text, 255, "redemption_%8.8x_main_term", unsigned(getpid())); getpeername(0, &u.s, reinterpret_cast<socklen_t *>(&sock_len)); strcpy(source_ip, inet_ntoa(u.s4.sin_addr)); union { struct sockaddr s; struct sockaddr_storage ss; struct sockaddr_in s4; struct sockaddr_in6 s6; } localAddress; socklen_t addressLength = sizeof(localAddress); int sck = 0; if (-1 == getsockname(sck, &localAddress.s, &addressLength)){ LOG(LOG_INFO, "getsockname failed error=%s", strerror(errno)); _exit(1); } target_port = localAddress.s4.sin_port; strcpy(real_target_ip, inet_ntoa(localAddress.s4.sin_addr)); if (ini.get<cfg::globals::enable_ip_transparent>()) { const int source_port = 0; char target_ip[256]; strcpy(target_ip, inet_ntoa(localAddress.s4.sin_addr)); int fd = open("/proc/net/ip_conntrack", O_RDONLY); // source and dest are inverted because we get the information we want from reply path rule int res = parse_ip_conntrack(fd, target_ip, source_ip, target_port, source_port, real_target_ip, sizeof(real_target_ip)); if (res){ LOG(LOG_WARNING, "Failed to get transparent proxy target from ip_conntrack"); } close(fd); } ini.set_acl<cfg::globals::host>(source_ip); ini.set_acl<cfg::globals::target>(real_target_ip); if (ini.get<cfg::debug::session>()){ LOG(LOG_INFO, "Setting new session socket to %d\n", sck); } int nodelay = 1; if (0 == setsockopt(sck, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char*>(&nodelay), sizeof(nodelay))){ Session session(sck, ini, cctx); if (ini.get<cfg::debug::session>()){ LOG(LOG_INFO, "Session::end of Session(%u)", sck); } shutdown(sck, 2); close(sck); } else { LOG(LOG_INFO, "Failed to set socket TCP_NODELAY option on client socket"); } }