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);
}
}
