static int tcp_socket_incoming(const char *address, uint16_t port) { char address_and_port[128]; Error *local_err = NULL; combine_addr(address_and_port, 128, address, port); int fd = inet_listen(address_and_port, NULL, 0, SOCK_STREAM, 0, &local_err); if (local_err != NULL) { error_report_err(local_err); } return fd; }
int tcp_start_incoming_migration(const char *host_port, Error **errp) { int s; s = inet_listen(host_port, NULL, 256, SOCK_STREAM, 0, errp); if (s < 0) { return -1; } qemu_set_fd_handler2(s, NULL, tcp_accept_incoming_migration, NULL, (void *)(unsigned long)s); return 0; }
void searchdaemon::go() { /* let search engine get at logger */ engine.setlogger(&_log); /* fork off listeners */ _log.lprintf( logger::DEBUG, "Looks good: %d\n", getpid() ); childunix=0; childinet=0; /* fork off a unix listener .. */ if( _options.get_bool( "ListenUnix" ) ) { _log.lprintf( logger::DEBUG, "Forking UNIX domain listener\n" ); if( (childunix=fork())==0 ) { listener unix_listen( _log, _options.get_string( "UnixSocket" ) ); listenloop( unix_listen ); } } /* .. and an inet listeneer */ if( _options.get_bool( "ListenInet" ) ) { _log.lprintf( logger::DEBUG, "Forking inet domain listener\n" ); if( (childinet=fork())==0 ) { listener inet_listen( _log, _options.get_string( "BindAddress" ), _options.get_int( "ListenPort" ) ); listenloop( inet_listen ); } } signal( SIGTERM, handler_term ); /* now just chill for a bit */ while( childunix != 0 || childinet != 0 ) { pid_t child = wait( NULL ); if( child==childunix ) childunix = 0; if( child==childinet ) childinet = 0; } exit( 0 ); }
int tcp_socket_incoming_spec(const char *address_and_port) { char *ostr = NULL; int olen = 0; return inet_listen(address_and_port, ostr, olen, SOCK_STREAM, 0); }
static VALUE bossan_run_loop(int argc, VALUE *argv, VALUE self) { int ret; VALUE args1, args2, args3; rb_scan_args(argc, argv, "21", &args1, &args2, &args3); if(listen_sock > 0){ rb_raise(rb_eException, "already set listen socket"); } if (argc == 3){ server_name = StringValuePtr(args1); server_port = NUM2INT(args2); long _port = NUM2INT(args2); if (_port <= 0 || _port >= 65536) { // out of range rb_raise(rb_eArgError, "port number outside valid range"); } server_port = (short)_port; ret = inet_listen(); rack_app = args3; } else { Check_Type(args1, T_STRING); ret = unix_listen(StringValuePtr(args1)); rack_app = args2; } if(ret < 0){ //error listen_sock = -1; } if(listen_sock <= 0){ rb_raise(rb_eTypeError, "not found listen socket"); } /* init picoev */ picoev_init(MAX_FDS); /* create loop */ main_loop = picoev_create_loop(60); loop_done = 1; setsig(SIGPIPE, sigpipe_cb); setsig(SIGINT, sigint_cb); setsig(SIGTERM, sigint_cb); picoev_add(main_loop, listen_sock, PICOEV_READ, ACCEPT_TIMEOUT_SECS, accept_callback, NULL); /* loop */ while (loop_done) { picoev_loop_once(main_loop, 10); } picoev_destroy_loop(main_loop); picoev_deinit(); printf("Bye.\n"); return Qnil; }
int main(int argc, char **argv) { int sock; int backlog; int ch; int ttl; const char *protocols = INET_PROTO_NAME_ALL; /* * Fingerprint executables and core dumps. */ MAIL_VERSION_STAMP_ALLOCATE; /* * Fix 20051207. */ signal(SIGPIPE, SIG_IGN); /* * Initialize diagnostics. */ msg_vstream_init(argv[0], VSTREAM_ERR); /* * Parse JCL. */ while ((ch = GETOPT(argc, argv, "46cvx:")) > 0) { switch (ch) { case '4': protocols = INET_PROTO_NAME_IPV4; break; case '6': protocols = INET_PROTO_NAME_IPV6; break; case 'c': count_deliveries++; break; case 'v': msg_verbose++; break; case 'x': if ((ttl = atoi(optarg)) <= 0) usage(argv[0]); event_request_timer(terminate, (void *) 0, ttl); break; default: usage(argv[0]); } } if (argc - optind != 2) usage(argv[0]); if ((backlog = atoi(argv[optind + 1])) <= 0) usage(argv[0]); /* * Initialize. */ (void) inet_proto_init("protocols", protocols); buffer = vstring_alloc(1024); if (strncmp(argv[optind], "unix:", 5) == 0) { sock = unix_listen(argv[optind] + 5, backlog, BLOCKING); } else { if (strncmp(argv[optind], "inet:", 5) == 0) argv[optind] += 5; sock = inet_listen(argv[optind], backlog, BLOCKING); } /* * Start the event handler. */ event_enable_read(sock, connect_event, CAST_INT_TO_VOID_PTR(sock)); for (;;) event_loop(-1); }
void master_listen_init(MASTER_SERV *serv) { const char *myname = "master_listen_init"; char *end_point; int n; MAI_HOSTADDR_STR hostaddr; struct sockaddr *sa; /* * Find out what transport we should use, then create one or more * listener sockets. Make the listener sockets non-blocking, so that * child processes don't block in accept() when multiple processes are * selecting on the same socket and only one of them gets the connection. */ switch (serv->type) { /* * UNIX-domain or stream listener endpoints always come as singlets. */ case MASTER_SERV_TYPE_UNIX: set_eugid(var_owner_uid, var_owner_gid); serv->listen_fd[0] = LOCAL_LISTEN(serv->name, serv->max_proc > var_proc_limit ? serv->max_proc : var_proc_limit, NON_BLOCKING); close_on_exec(serv->listen_fd[0], CLOSE_ON_EXEC); set_ugid(getuid(), getgid()); break; /* * FIFO listener endpoints always come as singlets. */ case MASTER_SERV_TYPE_FIFO: set_eugid(var_owner_uid, var_owner_gid); serv->listen_fd[0] = fifo_listen(serv->name, 0622, NON_BLOCKING); close_on_exec(serv->listen_fd[0], CLOSE_ON_EXEC); set_ugid(getuid(), getgid()); break; /* * INET-domain listener endpoints can be wildcarded (the default) or * bound to specific interface addresses. * * With dual-stack IPv4/6 systems it does not matter, we have to specify * the addresses anyway, either explicit or wild-card. */ case MASTER_SERV_TYPE_INET: for (n = 0; n < serv->listen_fd_count; n++) { sa = SOCK_ADDR_PTR(MASTER_INET_ADDRLIST(serv)->addrs + n); SOCKADDR_TO_HOSTADDR(sa, SOCK_ADDR_LEN(sa), &hostaddr, (MAI_SERVPORT_STR *) 0, 0); end_point = concatenate(hostaddr.buf, ":", MASTER_INET_PORT(serv), (char *) 0); serv->listen_fd[n] = inet_listen(end_point, serv->max_proc > var_proc_limit ? serv->max_proc : var_proc_limit, NON_BLOCKING); close_on_exec(serv->listen_fd[n], CLOSE_ON_EXEC); myfree(end_point); } break; /* * Descriptor passing endpoints always come as singlets. */ #ifdef MASTER_SERV_TYPE_PASS case MASTER_SERV_TYPE_PASS: set_eugid(var_owner_uid, var_owner_gid); serv->listen_fd[0] = PASS_LISTEN(serv->name, serv->max_proc > var_proc_limit ? serv->max_proc : var_proc_limit, NON_BLOCKING); close_on_exec(serv->listen_fd[0], CLOSE_ON_EXEC); set_ugid(getuid(), getgid()); break; #endif default: msg_panic("%s: unknown service type: %d", myname, serv->type); } }