int ACE_TMAIN (int, ACE_TCHAR *[]) { u_short port = ACE_DEFAULT_SERVER_PORT + 1; // Create a server end-point. ACE_INET_Addr addr (port); ACE_SSL_SOCK_Acceptor peer_acceptor (addr); ACE_HANDLE s_handle = peer_acceptor.get_handle (); init_poll_array (); poll_array[0].fd = s_handle; ACE_DEBUG ((LM_DEBUG, "(%P|%t) starting oneway server at port %d\n", port)); for (size_t n_handles = 1;;) { // Wait for client I/O events (handle interrupts). while (ACE_OS::poll (poll_array, n_handles) == -1 && errno == EINTR) continue; handle_data (n_handles); handle_connections (peer_acceptor, n_handles); } /* NOTREACHED */ return 0; }
/* Process command line args, create the bound socket, * spawn child (worker) processes, and wait for them all to die * (which they shouldn't!) */ int main(int argc, char **argv) { parse_cli(argc, argv); if (OPTIONS.SYSLOG) openlog("stud", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_DAEMON); signal(SIGPIPE, SIG_IGN); listener_socket = create_main_socket(); struct addrinfo hints; memset(&hints, 0, sizeof hints); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_flags = 0; const int gai_err = getaddrinfo(OPTIONS.BACK_IP, OPTIONS.BACK_PORT, &hints, &backaddr); if (gai_err != 0) { ERR("{getaddrinfo}: [%s]", gai_strerror(gai_err)); exit(1); } /* load certificate, pass to handle_connections */ SSL_CTX * ctx = init_openssl(); master_pid = getpid(); if (OPTIONS.CHROOT && OPTIONS.CHROOT[0]) change_root(); if (OPTIONS.UID || OPTIONS.GID) drop_privileges(); for (child_num=0; child_num < OPTIONS.NCORES; child_num++) { int pid = fork(); if (pid == -1) { ERR("{core} fork() failed! Goodbye cruel world!\n"); exit(1); } else if (pid == 0) // child goto handle; } int child_status; int dead_child_pid = wait(&child_status); ERR("{core} A child (%d) died! This should not happen! Goodbye cruel world!\n", dead_child_pid); kill(0, SIGTERM); exit(2); handle: handle_connections(ctx); return 0; }
int Thread_Per_Connection_Logging_Server::run(int argc, char *argv[]) { if (this->open(argc > 1 ? atoi(argv[1]) : 0) == -1) return -1; for (;;) { if (wait_for_multiple_events() == -1) return -1; if (handle_connections() == -1) return -1; } return 0; }
int ChatServer::run() { if (this->open()) return EXIT_FAILURE; for (;;) { if (wait_for_multiple_events() == EXIT_FAILURE) return EXIT_FAILURE; if (handle_connections() == EXIT_FAILURE) return EXIT_FAILURE; } ACE_NOTREACHED( return 0; ) }
int Logging_Server::run (int argc, char *argv[]) { if (open (argc > 1 ? atoi (argv[1]) : 0) == -1) return -1; for (;;) { if (wait_for_multiple_events () == -1) return -1; if (handle_connections () == -1) return -1; if (handle_data () == -1) return -1; } return 0; }
/* Forks COUNT children starting with START_INDEX. * Each child's index is stored in child_num and its pid is stored in child_pids[child_num] * so the parent can manage it later. */ void start_children(int start_index, int count) { for (child_num = start_index; child_num < start_index + count; child_num++) { int pid = fork(); if (pid == -1) { ERR("{core} fork() failed! Goodbye cruel world!\n"); exit(1); } else if (pid == 0) { /* child */ handle_connections(); exit(0); } else { /* parent. Track new child. */ child_pids[child_num] = pid; } } }
/* Process command line args, create the bound socket, * spawn child (worker) processes, and wait for them all to die * (which they shouldn't!) */ int main(int argc, char **argv) { parse_cli(argc, argv); int s = create_main_socket(); int x; struct addrinfo hints; memset(&hints, 0, sizeof hints); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_flags = 0; const int gai_err = getaddrinfo(OPTIONS.BACK_IP, OPTIONS.BACK_PORT, &hints, &backaddr); if (gai_err != 0) { fprintf(stderr, "{getaddrinfo}: [%s]", gai_strerror(gai_err)); exit(1); } /* load certificate, pass to handle_connections */ SSL_CTX * ctx = init_openssl(); for (x=0; x < OPTIONS.NCORES; x++) { int pid = fork(); if (pid == -1) { fprintf(stderr, "{core} fork() failed! Goodbye cruel world!\n"); exit(1); } else if (pid == 0) // child goto handle; } int child_status; for (x=0; x < OPTIONS.NCORES; x++) { wait(&child_status); fprintf(stderr, "{core} A child died! This should not happen! Goodbye cruel world!\n"); exit(2); } handle: handle_connections(x, s, ctx); return 0; }
int Logging_Server::run(int argc, char** argv) { if (-1 == open(argc > 1 ? atoi(argv[1]) : 0)) { return -1; } while(1) { if (-1 == wait_for_multiple_events()) return -1; if (-1 == handle_connections()) return -1; if (-1 == handle_data()) return -1; } return 0; }
void run_server() { int maxfd; fd_set rfds, wfds; init_connections(); running = 1; while (running) { FD_ZERO(&rfds); FD_ZERO(&wfds); maxfd = fd_set_listeners(&config->listeners, &rfds, 0); maxfd = fd_set_connections(&rfds, &wfds, maxfd); if (select(maxfd + 1, &rfds, &wfds, NULL, NULL) < 0) { /* select() might have failed because we received a signal, so we need to check */ if (errno != EINTR) { perror("select"); return; } /* We where interrupted by a signal */ if (sighup_received) { sighup_received = 0; reload_config(config); } if (sigusr1_received) { sigusr1_received = 0; print_connections(); } continue; /* our file descriptor sets are undefined, so select again */ } handle_listeners(&config->listeners, &rfds, accept_connection); handle_connections(&rfds, &wfds); } free_connections(); }
void CLogic::handle_set( CServer &server, const CNodeEndpoint &node_endpoint, const CValue *previous_value, CCommandSource source ) { const CEndpointDefinition &endpoint_definition = CEndpointDefinition::downcast( node_endpoint.get_endpoint_definition() ); const string &endpoint_name = endpoint_definition.get_name(); if( source == CCommandSource::INITIALIZATION ) { if( endpoint_name == endpoint_active ) { const CInterfaceDefinition &interface_definition = CInterfaceDefinition::downcast( m_node.get_interface_definition() ); if( !interface_definition.is_named_core_interface( module_container ) ) { non_container_active_initializer( server ); } } } if( endpoint_name == endpoint_data_directory ) { data_directory_handler( server, node_endpoint, previous_value, source ); } if( endpoint_definition.is_input_file() && should_copy_input_file( node_endpoint, source ) ) { handle_input_file( server, node_endpoint ); } switch( source ) { case CCommandSource::INITIALIZATION: case CCommandSource::LOAD: break; default: handle_connections( server, m_node, node_endpoint ); } }
void CLogic::handle_connections( CServer &server, const CNode &search_node, const CNodeEndpoint &changed_endpoint ) { const CNode *parent = CNode::downcast( search_node.get_parent() ); /* recurse up the tree first, so that higher-level connections are evaluated first */ if( parent ) { handle_connections( server, *parent, changed_endpoint ); } /* build endpoint path relative to search_node */ string relative_endpoint_path = changed_endpoint.get_path().get_string(); if( parent ) { relative_endpoint_path = relative_endpoint_path.substr( parent->get_path().get_string().length() + 1 ); } /* search amongst sibling nodes */ const node_map &siblings = server.get_siblings( search_node ); for( node_map::const_iterator i = siblings.begin(); i != siblings.end(); i++ ) { const CNode *sibling = CNode::downcast( i->second ); if( !CGuidHelper::guids_are_equal(sibling->get_interface_definition().get_module_guid(), get_connection_interface_guid( server ) ) ) { /* not a connection */ continue; } if( !sibling->get_logic().node_is_active() ) { /* connection is not active */ continue; } const INodeEndpoint *source_endpoint = sibling->get_node_endpoint( endpoint_source_path ); assert( source_endpoint ); const string &source_endpoint_value = *source_endpoint->get_value(); if( source_endpoint_value == relative_endpoint_path ) { if( changed_endpoint.get_endpoint_definition().get_type() != CEndpointDefinition::CONTROL || !changed_endpoint.get_endpoint_definition().get_control_info()->get_can_be_source() ) { INTEGRA_TRACE_ERROR << "aborting handling of connection from endpoint which cannot be a connection source"; continue; } /* found a connection! */ const INodeEndpoint *target_endpoint = sibling->get_node_endpoint( endpoint_target_path ); assert( target_endpoint ); const INodeEndpoint *destination_endpoint = server.find_node_endpoint( CPath( *target_endpoint->get_value() ), parent ); if( destination_endpoint ) { /* found a destination! */ if( destination_endpoint->get_endpoint_definition().get_type() != CEndpointDefinition::CONTROL || !destination_endpoint->get_endpoint_definition().get_control_info()->get_can_be_target() ) { INTEGRA_TRACE_ERROR << "aborting handling of connection to endpoint which cannot be a connection target"; continue; } CValue *converted_value; if( destination_endpoint->get_endpoint_definition().get_control_info()->get_type() == CControlInfo::STATEFUL ) { if( changed_endpoint.get_value() ) { converted_value = changed_endpoint.get_value()->transmogrify( destination_endpoint->get_value()->get_type() ); const value_set *allowed_states = destination_endpoint->get_endpoint_definition().get_control_info()->get_state_info()->get_constraint().get_allowed_states(); if( allowed_states ) { /* if destination has set of allowed states, quantize to nearest allowed state */ quantize_to_allowed_states( *converted_value, *allowed_states ); } } else { /* if source is a bang, reset target to it's current value */ converted_value = destination_endpoint->get_value()->clone(); } } else { assert( destination_endpoint->get_endpoint_definition().get_control_info()->get_type() == CControlInfo::BANG ); converted_value = NULL; } ISetCommand *command; if( converted_value ) { command = ISetCommand::create( destination_endpoint->get_path(), *converted_value ); delete converted_value; } else { command = ISetCommand::create( destination_endpoint->get_path() ); } server.process_command( command, CCommandSource::CONNECTION ); } } } }
int main (int argc, char **argv ) { ARGPARSE_ARGS pargs; int orig_argc; gpg_error_t err; int may_coredump; char **orig_argv; FILE *configfp = NULL; char *configname = NULL; const char *shell; unsigned int configlineno; int parse_debug = 0; const char *debug_level = NULL; int default_config =1; int greeting = 0; int nogreeting = 0; int multi_server = 0; int is_daemon = 0; int nodetach = 0; int csh_style = 0; char *logfile = NULL; int debug_wait = 0; int gpgconf_list = 0; const char *config_filename = NULL; int allow_coredump = 0; int standard_socket = 0; struct assuan_malloc_hooks malloc_hooks; set_strusage (my_strusage); gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN); /* Please note that we may running SUID(ROOT), so be very CAREFUL when adding any stuff between here and the call to INIT_SECMEM() somewhere after the option parsing */ log_set_prefix ("scdaemon", 1|4); /* Make sure that our subsystems are ready. */ i18n_init (); init_common_subsystems (&argc, &argv); /* Libgcrypt requires us to register the threading model first. Note that this will also do the pth_init. */ gcry_threads_pth.init = fixed_gcry_pth_init; err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth); if (err) { log_fatal ("can't register GNU Pth with Libgcrypt: %s\n", gpg_strerror (err)); } /* Check that the libraries are suitable. Do it here because the option parsing may need services of the library */ if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) ) { log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt", NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) ); } ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free); malloc_hooks.malloc = gcry_malloc; malloc_hooks.realloc = gcry_realloc; malloc_hooks.free = gcry_free; assuan_set_malloc_hooks (&malloc_hooks); assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT); assuan_set_system_hooks (ASSUAN_SYSTEM_PTH); assuan_sock_init (); setup_libassuan_logging (&opt.debug); setup_libgcrypt_logging (); gcry_control (GCRYCTL_USE_SECURE_RNDPOOL); may_coredump = disable_core_dumps (); /* Set default options. */ opt.allow_admin = 1; opt.pcsc_driver = DEFAULT_PCSC_DRIVER; #ifdef HAVE_W32_SYSTEM standard_socket = 1; /* Under Windows we always use a standard socket. */ #endif shell = getenv ("SHELL"); if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") ) csh_style = 1; opt.homedir = default_homedir (); /* Check whether we have a config file on the commandline */ orig_argc = argc; orig_argv = argv; pargs.argc = &argc; pargs.argv = &argv; pargs.flags= 1|(1<<6); /* do not remove the args, ignore version */ while (arg_parse( &pargs, opts)) { if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll) parse_debug++; else if (pargs.r_opt == oOptions) { /* yes there is one, so we do not try the default one, but read the option file when it is encountered at the commandline */ default_config = 0; } else if (pargs.r_opt == oNoOptions) default_config = 0; /* --no-options */ else if (pargs.r_opt == oHomedir) opt.homedir = pargs.r.ret_str; } /* initialize the secure memory. */ gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0); maybe_setuid = 0; /* Now we are working under our real uid */ if (default_config) configname = make_filename (opt.homedir, "scdaemon.conf", NULL ); argc = orig_argc; argv = orig_argv; pargs.argc = &argc; pargs.argv = &argv; pargs.flags= 1; /* do not remove the args */ next_pass: if (configname) { configlineno = 0; configfp = fopen (configname, "r"); if (!configfp) { if (default_config) { if( parse_debug ) log_info (_("NOTE: no default option file `%s'\n"), configname ); } else { log_error (_("option file `%s': %s\n"), configname, strerror(errno) ); exit(2); } xfree (configname); configname = NULL; } if (parse_debug && configname ) log_info (_("reading options from `%s'\n"), configname ); default_config = 0; } while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) ) { switch (pargs.r_opt) { case aGPGConfList: gpgconf_list = 1; break; case aGPGConfTest: gpgconf_list = 2; break; case oQuiet: opt.quiet = 1; break; case oVerbose: opt.verbose++; break; case oBatch: opt.batch=1; break; case oDebug: opt.debug |= pargs.r.ret_ulong; break; case oDebugAll: opt.debug = ~0; break; case oDebugLevel: debug_level = pargs.r.ret_str; break; case oDebugWait: debug_wait = pargs.r.ret_int; break; case oDebugAllowCoreDump: enable_core_dumps (); allow_coredump = 1; break; case oDebugCCIDDriver: #ifdef HAVE_LIBUSB ccid_set_debug_level (ccid_set_debug_level (-1)+1); #endif /*HAVE_LIBUSB*/ break; case oDebugDisableTicker: ticker_disabled = 1; break; case oDebugLogTid: log_set_pid_suffix_cb (tid_log_callback); break; case oOptions: /* config files may not be nested (silently ignore them) */ if (!configfp) { xfree(configname); configname = xstrdup(pargs.r.ret_str); goto next_pass; } break; case oNoGreeting: nogreeting = 1; break; case oNoVerbose: opt.verbose = 0; break; case oNoOptions: break; /* no-options */ case oHomedir: opt.homedir = pargs.r.ret_str; break; case oNoDetach: nodetach = 1; break; case oLogFile: logfile = pargs.r.ret_str; break; case oCsh: csh_style = 1; break; case oSh: csh_style = 0; break; case oServer: pipe_server = 1; break; case oMultiServer: pipe_server = 1; multi_server = 1; break; case oDaemon: is_daemon = 1; break; case oReaderPort: opt.reader_port = pargs.r.ret_str; break; case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break; case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break; case oDisableCCID: opt.disable_ccid = 1; break; case oDisableOpenSC: break; case oDisableKeypad: opt.disable_keypad = 1; break; case oAllowAdmin: /* Dummy because allow is now the default. */ break; case oDenyAdmin: opt.allow_admin = 0; break; case oCardTimeout: opt.card_timeout = pargs.r.ret_ulong; break; case oDisableApplication: add_to_strlist (&opt.disabled_applications, pargs.r.ret_str); break; default: pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR; break; } } if (configfp) { fclose( configfp ); configfp = NULL; /* Keep a copy of the config name for use by --gpgconf-list. */ config_filename = configname; configname = NULL; goto next_pass; } xfree (configname); configname = NULL; if (log_get_errorcount(0)) exit(2); if (nogreeting ) greeting = 0; if (greeting) { es_fprintf (es_stderr, "%s %s; %s\n", strusage(11), strusage(13), strusage(14) ); es_fprintf (es_stderr, "%s\n", strusage(15) ); } #ifdef IS_DEVELOPMENT_VERSION log_info ("NOTE: this is a development version!\n"); #endif if (atexit (cleanup)) { log_error ("atexit failed\n"); cleanup (); exit (1); } set_debug (debug_level); initialize_module_command (); if (gpgconf_list == 2) scd_exit (0); if (gpgconf_list) { /* List options and default values in the GPG Conf format. */ char *filename = NULL; char *filename_esc; if (config_filename) filename = xstrdup (config_filename); else filename = make_filename (opt.homedir, "scdaemon.conf", NULL); filename_esc = percent_escape (filename, NULL); es_printf ("gpgconf-scdaemon.conf:%lu:\"%s\n", GC_OPT_FLAG_DEFAULT, filename_esc); xfree (filename_esc); xfree (filename); es_printf ("verbose:%lu:\n" "quiet:%lu:\n" "debug-level:%lu:\"none:\n" "log-file:%lu:\n", GC_OPT_FLAG_NONE, GC_OPT_FLAG_NONE, GC_OPT_FLAG_DEFAULT, GC_OPT_FLAG_NONE ); es_printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE ); es_printf ("ctapi-driver:%lu:\n", GC_OPT_FLAG_NONE ); es_printf ("pcsc-driver:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT, DEFAULT_PCSC_DRIVER ); #ifdef HAVE_LIBUSB es_printf ("disable-ccid:%lu:\n", GC_OPT_FLAG_NONE ); #endif es_printf ("deny-admin:%lu:\n", GC_OPT_FLAG_NONE ); es_printf ("disable-keypad:%lu:\n", GC_OPT_FLAG_NONE ); es_printf ("card-timeout:%lu:%d:\n", GC_OPT_FLAG_DEFAULT, 0); scd_exit (0); } /* Now start with logging to a file if this is desired. */ if (logfile) { log_set_file (logfile); log_set_prefix (NULL, 1|2|4); } if (debug_wait && pipe_server) { log_debug ("waiting for debugger - my pid is %u .....\n", (unsigned int)getpid()); gnupg_sleep (debug_wait); log_debug ("... okay\n"); } if (pipe_server) { /* This is the simple pipe based server */ ctrl_t ctrl; pth_attr_t tattr; int fd = -1; #ifndef HAVE_W32_SYSTEM { struct sigaction sa; sa.sa_handler = SIG_IGN; sigemptyset (&sa.sa_mask); sa.sa_flags = 0; sigaction (SIGPIPE, &sa, NULL); } #endif /* If --debug-allow-core-dump has been given we also need to switch the working directory to a place where we can actually write. */ if (allow_coredump) { if (chdir("/tmp")) log_debug ("chdir to `/tmp' failed: %s\n", strerror (errno)); else log_debug ("changed working directory to `/tmp'\n"); } /* In multi server mode we need to listen on an additional socket. Create that socket now before starting the handler for the pipe connection. This allows that handler to send back the name of that socket. */ if (multi_server) { socket_name = create_socket_name (standard_socket, "S.scdaemon", "gpg-XXXXXX/S.scdaemon"); fd = FD2INT(create_server_socket (standard_socket, socket_name, &socket_nonce)); } tattr = pth_attr_new(); pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0); pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024); pth_attr_set (tattr, PTH_ATTR_NAME, "pipe-connection"); ctrl = xtrycalloc (1, sizeof *ctrl); if ( !ctrl ) { log_error ("error allocating connection control data: %s\n", strerror (errno) ); scd_exit (2); } ctrl->thread_startup.fd = GNUPG_INVALID_FD; if ( !pth_spawn (tattr, start_connection_thread, ctrl) ) { log_error ("error spawning pipe connection handler: %s\n", strerror (errno) ); xfree (ctrl); scd_exit (2); } /* We run handle_connection to wait for the shutdown signal and to run the ticker stuff. */ handle_connections (fd); if (fd != -1) close (fd); } else if (!is_daemon) { log_info (_("please use the option `--daemon'" " to run the program in the background\n")); } else { /* Regular server mode */ int fd; #ifndef HAVE_W32_SYSTEM pid_t pid; int i; #endif /* Create the socket. */ socket_name = create_socket_name (standard_socket, "S.scdaemon", "gpg-XXXXXX/S.scdaemon"); fd = FD2INT (create_server_socket (standard_socket, socket_name, &socket_nonce)); fflush (NULL); #ifndef HAVE_W32_SYSTEM pid = fork (); if (pid == (pid_t)-1) { log_fatal ("fork failed: %s\n", strerror (errno) ); exit (1); } else if (pid) { /* we are the parent */ char *infostr; close (fd); /* create the info string: <name>:<pid>:<protocol_version> */ if (estream_asprintf (&infostr, "SCDAEMON_INFO=%s:%lu:1", socket_name, (ulong) pid) < 0) { log_error ("out of core\n"); kill (pid, SIGTERM); exit (1); } *socket_name = 0; /* don't let cleanup() remove the socket - the child should do this from now on */ if (argc) { /* run the program given on the commandline */ if (putenv (infostr)) { log_error ("failed to set environment: %s\n", strerror (errno) ); kill (pid, SIGTERM ); exit (1); } execvp (argv[0], argv); log_error ("failed to run the command: %s\n", strerror (errno)); kill (pid, SIGTERM); exit (1); } else { /* Print the environment string, so that the caller can use shell's eval to set it */ if (csh_style) { *strchr (infostr, '=') = ' '; es_printf ( "setenv %s\n", infostr); } else { es_printf ( "%s; export SCDAEMON_INFO;\n", infostr); } xfree (infostr); exit (0); } /* NOTREACHED */ } /* end parent */ /* This is the child. */ /* Detach from tty and put process into a new session. */ if (!nodetach ) { /* Close stdin, stdout and stderr unless it is the log stream. */ for (i=0; i <= 2; i++) { if ( log_test_fd (i) && i != fd) close (i); } if (setsid() == -1) { log_error ("setsid() failed: %s\n", strerror(errno) ); cleanup (); exit (1); } } { struct sigaction sa; sa.sa_handler = SIG_IGN; sigemptyset (&sa.sa_mask); sa.sa_flags = 0; sigaction (SIGPIPE, &sa, NULL); } if (chdir("/")) { log_error ("chdir to / failed: %s\n", strerror (errno)); exit (1); } #endif /*!HAVE_W32_SYSTEM*/ handle_connections (fd); close (fd); } return 0; }