int main() { signal(SIGPIPE, SIG_IGN); redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379); if (c->err) { /* Let *c leak for now... */ printf("Error: %s\n", c->errstr); return 1; } redisLibevAttach(EV_DEFAULT_ c); redisAsyncSetConnectCallback(c,connectCallback); redisAsyncSetDisconnectCallback(c,disconnectCallback); // redisAsyncCommand(c, getCallback, (char*)"sub", "SUBSCRIBE name"); new ChatRoom(c, {"79153060652", "79030072726", "79853672651"}); ev_loop(EV_DEFAULT_ 0); return 0; }
int main(int argc, char* argv[]) { int c; while( (c = getopt(argc, argv, "hs:r:dp:")) != -1 ) switch( c ) { case 'h': usage_msg(stdout); exit(0); break; case 'd': cfg_delegated = 1; break; case 's': cfg_tx_size = atoi(optarg); break; case 'r': cfg_rx_size = atoi(optarg); break; case 'p': cfg_port = optarg; break; case '?': usage_err(); break; default: TEST(0); break; } argc -= optind; argv += optind; if( argc != 2 ) usage_err(); const char* interface = argv[0]; const char* server = argv[1]; struct client_state* cs = calloc(1, sizeof(*cs)); init(cs, interface, server, cfg_port); pthread_t tid; TEST( pthread_create(&tid, NULL, alarm_thread, cs) == 0 ); ev_loop(cs); return 0; }
int main(int argc, char** argv) { enum uprobe_log_level loglevel = UPROBE_LOG_LEVEL; bool upipe_ts = false; int opt; // parse options while ((opt = getopt(argc, argv, "dt")) != -1) { switch (opt) { case 'd': loglevel--; break; case 't': upipe_ts = true; break; default: break; } } if (optind >= argc) { printf("Usage: %s [-d] [-t] filename\n", argv[0]); exit(-1); } const char *uri = argv[optind++]; // upipe env struct ev_loop *loop = ev_default_loop(0); struct upump_mgr *upump_mgr = upump_ev_mgr_alloc(loop, UPUMP_POOL, UPUMP_BLOCKER_POOL); assert(upump_mgr != NULL); struct upipe_glxplayer *glxplayer = upipe_glxplayer_alloc(loglevel); assert(glxplayer != NULL); upipe_glxplayer_play(glxplayer, upump_mgr, uri, upipe_ts); upump_mgr_release(upump_mgr); ev_loop(loop, 0); upipe_glxplayer_free(glxplayer); ev_default_destroy(); return 0; }
/* * Worker thread: main event loop */ static void *worker_libev(void *arg) { WORK_THREAD *me = arg; /* Any per-thread setup can happen here; thread_init() will block until * all threads have finished initializing. */ pthread_mutex_lock(&init_lock); init_count++; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock); me->thread_id = pthread_self(); ev_loop(me->loop, 0); return NULL; }
void HttpWorker::run() { state_ = Running; // XXX invoke onWorkerSpawned-hook here because we want to ensure this hook is // XXX being invoked from *within* the worker-thread. server_.onWorkerSpawn(this); TRACE("enter loop"); ev_loop(loop_, 0); TRACE("event loop left. killing remaining connections (%ld).", connections_.size()); if (!connections_.empty()) _kill(); server_.onWorkerUnspawn(this); state_ = Inactive; }
void server_run(const char* hostaddr, const int port) { struct ev_loop* mainloop = ev_default_loop(0); ev_io accept_watcher; ev_io_init(&accept_watcher, ev_io_on_request, sockfd, EV_READ); ev_io_start(mainloop, &accept_watcher); #if WANT_SIGINT_HANDLING ev_signal signal_watcher; ev_signal_init(&signal_watcher, ev_signal_on_sigint, SIGINT); ev_signal_start(mainloop, &signal_watcher); #endif /* This is the program main loop */ Py_BEGIN_ALLOW_THREADS ev_loop(mainloop, 0); Py_END_ALLOW_THREADS }
int main(int argc, char **argv) { struct rdns_resolver *resolver_ev; struct ev_loop *loop; loop = ev_default_loop (0); resolver_ev = rdns_resolver_new (); rdns_bind_libev (resolver_ev, loop); rdns_resolver_add_server (resolver_ev, argv[1], strtoul (argv[2], NULL, 10), 0, 8); rdns_resolver_init (resolver_ev); rdns_test_a (resolver_ev); ev_loop (loop, 0); return 0; }
/** * Event loop for a client context. * * Usage of the loop is the following: * - client_injector_signal: send new client socket to the loop. Callback is * client_injector_cb(). * - client_writer_signal: if a write is needed, ask for removal of client socket. * from the loop and process to write by poping write event from a per-client * message queue. Callback is client_writer_cb(). * - client_destructor_signal: ask for removal a client socket from the loop. This * is used by the command_mode to trigger disconnection. Callback is * client_destructor_cb(). * - client_accept_cb(): treat new client. This call back is called by watcher * other server socket. * - loop_fini_signal: async signal used to trigger loop end * */ void tls_user_main_loop(struct tls_user_context_t *context, GMutex * mutex) { ev_io client_watcher; ev_timer timer; context->loop = ev_loop_new(0); /* register injector cb */ ev_async_init(&context->client_injector_signal, client_injector_cb); ev_async_start(context->loop, &context->client_injector_signal); context->client_injector_signal.data = context; /* register writer cb */ ev_async_init(&context->client_writer_signal, client_writer_cb); ev_async_start(context->loop, &context->client_writer_signal); context->client_writer_signal.data = context; ev_timer_init (&timer, client_timeout_cb, 0, 0.200); ev_timer_start (context->loop, &timer); /* register destructor cb */ ev_async_init(&context->client_destructor_signal, client_destructor_cb); ev_async_start(context->loop, &context->client_destructor_signal); context->client_destructor_signal.data = context; /* register destructor cb */ ev_async_init(&context->loop_fini_signal, loop_destructor_cb); ev_async_start(context->loop, &context->loop_fini_signal); context->loop_fini_signal.data = context; /* register accept cb */ fcntl(context->sck_inet,F_SETFL,(fcntl(context->sck_inet,F_GETFL)|O_NONBLOCK)); ev_io_init(&client_watcher, client_accept_cb, context->sck_inet, EV_READ); ev_io_start(context->loop, &client_watcher); client_watcher.data = context; log_message(INFO, DEBUG_AREA_USER, "[+] NuAuth is waiting for client connections."); ev_loop(context->loop, 0); ev_loop_destroy(context->loop); close(context->sck_inet); }
const char* slave_run_cb(void) { struct ev_loop *loop; ev_io io_listen; ev_signal sigint_listen; ev_signal sigterm_listen; pthread_mutex_init(&srv.pending_lk, 0); pthread_mutex_init(&srv.clients_lk, 0); if (!(loop = ev_default_loop(EVFLAG_AUTO))) return 1; syslog(LOG_INFO, "listening on %s:%hd", inet_ntoa(srv.addr.sin_addr), ntohs(srv.addr.sin_port)); ev_signal_init(&sigint_listen, &nol_s_ev_sigint, SIGINT); ev_signal_init(&sigterm_listen, &nol_s_ev_sigint, SIGTERM); ev_io_init(&io_listen, &nol_s_ev_conn_accept, srv.listen_sock, EV_READ); ev_io_init(&srv.master_io, &nol_s_ev_master, srv.master_sock, EV_READ); ev_async_init(&srv.client_status, &nol_s_ev_client_status); /* catch SIGINT so we can close connections and clean up properly */ ev_signal_start(loop, &sigint_listen); ev_signal_start(loop, &sigterm_listen); ev_io_start(loop, &io_listen); ev_io_start(loop, &srv.master_io); ev_async_start(loop, &srv.client_status); /** * This loop will listen for new connections and data from * the master. **/ ev_loop(loop, 0); close(srv.listen_sock); ev_default_destroy(); closelog(); pthread_mutex_destroy(&srv.pending_lk); pthread_mutex_destroy(&srv.clients_lk); nol_s_hook_invoke(HOOK_CLEANUP); return 0; }
int zero_stream (struct sockaddr *address, size_t to_write) { int r; assert(to_write >= 1024); // should be kind of big at least. zero_to_write = to_write; got_server_close = 0; zero_written = 0; zero_read = 0; zero_client_closed = 0; evcom_server_init(&server); server.on_connection = make_echo_connection; server.on_close = common_on_server_close; evcom_server_listen(&server, address, 1000); evcom_server_attach(EV_DEFAULT_ &server); evcom_stream client; evcom_stream_init(&client); client.on_read = zero_recv; client.on_connect = zero_start; client.on_close = zero_close; client.on_timeout = error_out; evcom_stream_reset_timeout(&client, ZERO_TIMEOUT); #if EVCOM_HAVE_GNUTLS if (use_tls) anon_tls_client(&client); #endif r = evcom_stream_connect(&client, address); assert(r == 0 && "problem connecting"); evcom_stream_attach(EV_DEFAULT_ &client); ev_loop(EV_DEFAULT_ 0); assert(got_server_close); assert(zero_written == zero_to_write); assert(zero_read == zero_to_write); assert(zero_client_closed) ; return 0; }
int main() { int sd; struct sockaddr_in addr; int addr_len = sizeof(addr); // Create server socket if((sd = socket(PF_INET, SOCK_STREAM, 0)) < 0 ) { perror("socket error"); return -1; } bzero(&addr, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(PORT_NO); addr.sin_addr.s_addr = INADDR_ANY; // Bind socket to address if (bind(sd, (struct sockaddr*) &addr, sizeof(addr)) != 0) { perror("bind error"); } // Start listing on the socket if (listen(sd, 2) < 0) { perror("listen error"); return -1; } // Part inilah yang membedakan socket programming biasa dengan event-based programming // Initialize and start a watcher to accepts client requests struct ev_loop *loop = ev_default_loop(0); struct ev_io w_accept; ev_io_init(&w_accept, accept_cb, sd, EV_READ); ev_io_start(loop, &w_accept); // Start infinite loop while (1) { ev_loop(loop, 0); } return 0; }
static int fdevent_libev_poll(fdevents *ev, int timeout_ms) { union { struct ev_watcher w; struct ev_timer timer; } timeout_watcher; if (!timeout_ms) timeout_ms = 1; ev_init(&timeout_watcher.w, NULL); ev_set_cb(&timeout_watcher.timer, timeout_watcher_cb); timeout_watcher.timer.repeat = ((ev_tstamp) timeout_ms)/1000.0; assert(timeout_watcher.timer.repeat); ev_timer_again(ev->libev_loop, &timeout_watcher.timer); ev_loop(ev->libev_loop, EVLOOP_ONESHOT); ev_timer_stop(ev->libev_loop, &timeout_watcher.timer); return 0; }
static void wait_for_event(void) { size_t i; int udp_event_fd; ev_io events[config.udp_nserver]; ev_async_init(&ev_interrupt, libev_interrupt_cb); ev_async_start(&ev_interrupt); for ( i = 0; i < config.udp_nserver; i++ ) { udp_event_fd = udp_server_get_event_fd(config.udp_server[i]); ev_io_init(&events[i], libev_udp_cb, udp_event_fd, EV_READ); events[i].data = config.udp_server[i]; ev_io_start(&events[i]); } ev_loop(0); }
int main(int argc, char **argv) { struct ev_loop *loop = ev_default_loop(0); int sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); struct sockaddr_in addr; bzero(&addr, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(6666); addr.sin_addr.s_addr = htonl(INADDR_ANY); bind(sd, (struct sockaddr *)&addr, sizeof(addr)); listen(sd, SOMAXCONN); struct ev_io w_accept; ev_io_init(&w_accept, accept_cb, sd, EV_READ); ev_io_start(loop, &w_accept); while(1) ev_loop(loop, 0); }
/** @This starts the source thread. * * @param _glxplayer pointer to glxplayer structure * @return always NULL */ static void *upipe_glxplayer_source_thread(void *_glxplayer) { struct upipe_glxplayer *glxplayer = (struct upipe_glxplayer *)_glxplayer; struct ev_loop *loop = ev_loop_new(0); struct upump_mgr *upump_mgr = upump_ev_mgr_alloc(loop, UPUMP_POOL, UPUMP_BLOCKER_POOL); upipe_xfer_mgr_attach(glxplayer->src_xfer, upump_mgr); uprobe_pthread_upump_mgr_set(glxplayer->uprobe_logger, upump_mgr); upump_mgr_release(upump_mgr); ev_loop(loop, 0); ev_loop_destroy(loop); printf("end of source thread\n"); upipe_mgr_release(glxplayer->dec_xfer); pthread_join(glxplayer->dec_thread_id, NULL); return NULL; }
int main(int argc, char **argv) { long flags; loop = ev_default_loop(0); mgr = upump_ev_mgr_alloc(loop, UPUMP_POOL, UPUMP_BLOCKER_POOL); assert(mgr != NULL); /* Create a pipe with non-blocking write */ assert(pipe(pipefd) != -1); flags = fcntl(pipefd[1], F_GETFL); assert(flags != -1); flags |= O_NONBLOCK; assert(fcntl(pipefd[1], F_SETFL, flags) != -1); /* Create watchers */ write_idler = upump_alloc_idler(mgr, write_idler_cb, NULL); assert(write_idler != NULL); write_watcher = upump_alloc_fd_write(mgr, write_watcher_cb, NULL, pipefd[1]); assert(write_watcher != NULL); read_timer = upump_alloc_timer(mgr, read_timer_cb, NULL, timeout, 0); assert(read_timer != NULL); read_watcher = upump_alloc_fd_read(mgr, read_watcher_cb, NULL, pipefd[0]); assert(read_watcher != NULL); /* Start tests */ upump_start(write_idler); ev_loop(loop, 0); assert(bytes_read); assert(bytes_read == bytes_written); /* Clean up */ upump_free(write_idler); upump_free(write_watcher); upump_free(read_timer); upump_free(read_watcher); upump_mgr_release(mgr); ev_default_destroy(); return 0; }
void server_run(ServerInfo* server_info) { struct ev_loop* mainloop = ev_loop_new(0); ev_set_userdata(mainloop, server_info); ev_io accept_watcher; ev_io_init(&accept_watcher, ev_io_on_request, server_info->sockfd, EV_READ); ev_io_start(mainloop, &accept_watcher); #if WANT_SIGINT_HANDLING ev_signal signal_watcher; ev_signal_init(&signal_watcher, ev_signal_on_sigint, SIGINT); ev_signal_start(mainloop, &signal_watcher); #endif /* This is the program main loop */ Py_BEGIN_ALLOW_THREADS ev_loop(mainloop, 0); ev_default_destroy(); Py_END_ALLOW_THREADS }
void cpu_event_run(STATE) { environment e; e = environment_current(); /* If there are normal events, then wait in the signal loop. */ if(state->pending_events == 0) { ev_loop(e->sig_event_base, EVLOOP_ONESHOT); // HACK ev_loop(state->event_base, EVLOOP_NONBLOCK); ev_loop(e->sig_event_base, EVLOOP_NONBLOCK); // HACK } else { ev_loop(e->sig_event_base, EVLOOP_NONBLOCK); // HACK ev_loop(state->event_base, EVLOOP_ONESHOT); ev_loop(e->sig_event_base, EVLOOP_NONBLOCK); // HACK } }
int main(void) { int fd = socket(PF_INET, SOCK_STREAM, 0); if (fd < 0) { printf("socket error. errno:%d\n", errno); return -1; } struct sockaddr_in addr; bzero(&addr, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(PORT); addr.sin_addr.s_addr = INADDR_ANY; if (bind(fd, (struct sockaddr*) &addr, sizeof(addr)) != 0) { printf("bind error.errno:%d\n",errno); } if (listen(fd, 10) < 0) { printf("listen error\n"); return -1; } struct ev_loop *loop = ev_default_loop(0); ev_io socket_watcher; ev_io_init(&socket_watcher, accept_cb, fd, EV_READ); ev_io_start(loop, &socket_watcher); ev_timer timeout_watcher; ev_timer_init (&timeout_watcher, timeout_cb, 2, 2); ev_timer_start (loop, &timeout_watcher); while (1) { printf("ev_loop...\n") ; ev_loop(loop, 0); } return 0; }
int connint (struct sockaddr *address) { int r; nconnections = 0; got_server_close = 0; evcom_server_init(&server); server.on_connection = connint_on_connection; server.on_close = common_on_server_close; evcom_server_listen(&server, address, 1000); evcom_server_attach(EV_DEFAULT_ &server); evcom_stream clients[NCONN]; int i; for (i = 0; i < NCONN; i++) { evcom_stream *client = &clients[i]; evcom_stream_init(client); client->on_read = connint_on_client_read; client->on_connect = connint_on_client_connect; client->on_close = connint_on_client_close; client->on_timeout = common_on_client_timeout; evcom_stream_reset_timeout(client, CONNINT_TIMEOUT); #if EVCOM_HAVE_GNUTLS if (use_tls) anon_tls_client(client); #endif r = evcom_stream_connect(client, address); assert(r == 0 && "problem connecting"); evcom_stream_attach(EV_DEFAULT_ client); } ev_loop(EV_DEFAULT_ 0); assert(nconnections == NCONN); assert(got_server_close); return 0; }
void *update_ipc(void *data) { char *socket_path = getenv("I3SOCK"); char *i3_default_sock_path = "/tmp/i3-ipc.sock"; main_loop = ev_default_loop(0); if (socket_path == NULL) { ELOG("No Socket Path Specified, default to %s\n", i3_default_sock_path); socket_path = i3_default_sock_path; } if (init_connection(socket_path)) { /* We subscribe to the i3-events we need */ subscribe_events(); /* Get current workspaces from i3. */ i3_send_msg(I3_IPC_MESSAGE_TYPE_GET_WORKSPACES, NULL); } ev_loop(main_loop, 0); }
int main() { int listen_fd; struct sockaddr_in listen_addr; int reuseaddr_on = 1; listen_fd = socket(AF_INET, SOCK_STREAM, 0); if (listen_fd < 0) err(1, "create listen fd failed"); if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr_on, sizeof(reuseaddr_on)) == -1) err(1, "setsockopt failed"); memset(&listen_addr, 0, sizeof(listen_addr)); listen_addr.sin_family = AF_INET; listen_addr.sin_addr.s_addr = INADDR_ANY; listen_addr.sin_port = htons(SERVER_PORT); if (bind(listen_fd, (struct sockaddr *)&listen_addr, sizeof(listen_addr)) < 0) err(1, "bind failed"); if (listen(listen_fd, 5) < 0) err(1, "call listen failed"); if (setnonblock(listen_fd) < 0) err(1, "failed to set server socket to non-blocking"); // start ev loop struct ev_loop *loop = ev_default_loop (0); ev_io ev_accept; ev_io_init(&ev_accept, accept_cb, listen_fd, EV_READ); ev_io_start(loop, &ev_accept); ev_loop(loop, 0); return 0; }
int pipe_stream (void) { reader_cnt = 0; reader_got_close = 0; reader_got_hello = 0; reader_got_eof = 0; writer_got_close = 0; int pipefd[2]; int r = pipe(pipefd); if (r < 0) { perror("pipe()"); return -1; } evcom_reader_init(&reader); reader.on_read = reader_read; reader.on_close = reader_close; evcom_reader_set(&reader, pipefd[0]); evcom_reader_attach(EV_DEFAULT_ &reader); evcom_writer_init(&writer); writer.on_close = writer_close; evcom_writer_set(&writer, pipefd[1]); evcom_writer_attach(EV_DEFAULT_ &writer); evcom_writer_write(&writer, PIPE_MSG, strlen(PIPE_MSG)); ev_loop(EV_DEFAULT_ 0); assert(reader_got_close); assert(reader_got_hello); assert(reader_got_eof); assert(writer_got_close); assert(reader_cnt == PIPE_CNT); return 0; }
int emc_start_server(struct emc_server_context *ctx) { log_printf(DEBUG_LEVEL_INFO, "INFO EMC server ready"); while (ctx->continue_processing) ev_loop(loop, 0 /* or: EVLOOP_NONBLOCK */ ); log_printf(DEBUG_LEVEL_INFO, "INFO EMC server shutting down"); g_thread_pool_free(ctx->pool_tls_handshake, TRUE, TRUE); g_thread_pool_free(ctx->pool_reader, TRUE, TRUE); g_async_queue_unref(ctx->work_queue); g_mutex_free(ctx->tls_client_list_mutex); g_tree_destroy(ctx->nuauth_directory); ev_default_destroy(); emc_close_servers(ctx); return 0; }
int main(int argc, char **argv) { if (!g_thread_supported ()) g_thread_init (NULL); #ifdef HAVE_AVFORMAT ffmpeg_init(); #endif /* parses the command line and initializes the log*/ command_environment(argc, argv); /* This goes before feng_bind_ports */ feng_loop = ev_default_loop(0); feng_handle_signals(); g_list_foreach(configured_sockets, feng_bind_socket, NULL); accesslog_init(feng_default_vhost, NULL); stats_init(); feng_drop_privs(); http_tunnel_initialise(); clients_init(); ev_loop (feng_loop, 0); /* This is explicit to send disconnections! */ clients_cleanup(); #ifdef CLEANUP_DESTRUCTOR ev_loop_destroy(feng_loop); #endif return 0; }
int main(int argc, char *argv[]){ struct ev_loop *loop = ev_default_loop(0); int i; struct ev_io socket_accept; get_param(argc, argv); // options.faddr = "0.0.0.0:8765"; // options.baddr = ""; // options.cryptoMethod = "RC4"; // options.secret = "secret"; // options.clientMod = 1; build_server(); ev_io_init(&socket_accept, accept_cb, serv_sock, EV_READ); ev_io_start(loop, &socket_accept); while(1) { ev_loop(loop, 0); } return 0; }
/*-----------------------------EventLoop------------------------------*/ static int EventLoop () { struct ev_loop *loop; struct ev_idle *eidle; ev_io *standard_input; ev_io *socket_input; LogDebug("%s EventLoop Started", global_argv[0]); loop = ev_default_loop(EVBACKEND_SELECT); /* Create an idle event to stop the program */ eidle = malloc(sizeof(ev_idle)); ev_idle_init(eidle, Idle); ev_idle_start(loop, eidle); /* Create the standard_input event */ standard_input = malloc(sizeof(ev_io)); ev_io_init(standard_input, ReadStdin, STDIN_FILENO, EV_READ); ev_io_start(loop, standard_input); ev_loop(loop, 0); LogDebug("%s EventLoop finished", global_argv[0]); return 0; }
int main(void) { int port = DEFAULT_PORT; puts("udp_echo server started..."); // Setup a udp listening socket. sd = socket(PF_INET, SOCK_DGRAM, 0); bzero(&addr, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr.s_addr = INADDR_ANY; if (bind(sd, (struct sockaddr*) &addr, sizeof(addr)) != 0) perror("bind"); // Do the libev stuff. struct ev_loop *loop = ev_default_loop(0); ev_io udp_watcher; ev_io_init(&udp_watcher, udp_cb, sd, EV_READ); ev_io_start(loop, &udp_watcher); ev_loop(loop, 0); // This point is never reached. close(sd); return EXIT_SUCCESS; }
int main(int argc, char **argv) { int webfd; tnrld = new_tnrld(10002); connections = new_ilist(500); processes = new_ilist(500); loop = EV_DEFAULT; // Start tnrld on port 10002. webfd = start_webserver("10002"); if (webfd < 0) { exit(1); } tnrld->listen_fd = webfd; tnrld->evloop = loop; // Signal handler to close cleanly. signal(SIGINT, int_handler); // Signal handler so child pipes end safely. signal(SIGPIPE, SIG_IGN); // Set up the main event loop. ev_io http_watcher; ev_io_init (&http_watcher, accept_cb, webfd, EV_READ); ev_io_start(loop, &http_watcher); ev_set_io_collect_interval (loop, 0.001); ev_loop(loop, 0); printf("Server shut down.\n"); exit(0); }
//------------------------------------------------------------------- int main(int argc, char **argv) { int opt_res; std::string ip_addr = ""; int ip_port = -1; htmlFilesDir = ""; bool daemon = true; while( (opt_res = getopt(argc, argv, "h:p:d:x")) != -1) { if(opt_res == 'h') { ip_addr = optarg; } else if(opt_res == 'p') { ip_port = atoi(optarg); } else if(opt_res == 'd'){ htmlFilesDir = optarg; } else if(opt_res == 'x'){ daemon = false; } } if(ip_addr == "" || ip_port == -1 || htmlFilesDir == "") { return 0; } if(daemon) { if( fork() ) { return 0; } umask(0); if( setsid() < 0 ) return 0; if((chdir("/")) < 0) return 0; close(STDIN_FILENO); close(STDOUT_FILENO); close(STDERR_FILENO); } if( (mainSockDescr = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1 ) { return 0; } struct sockaddr_in addr; bzero(&addr, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(ip_port); addr.sin_addr.s_addr = inet_addr(ip_addr.c_str()); if( bind(mainSockDescr, (struct sockaddr*)&addr, sizeof(addr)) == -1) { return 0; } if( listen(mainSockDescr, SOMAXCONN) == -1) { return 0; } struct ev_loop *mainLoop = ev_default_loop(0); struct ev_io acceptWatcher; ev_io_init(&acceptWatcher, acceptCallback, mainSockDescr, EV_READ); ev_io_start(mainLoop, &acceptWatcher); struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_handler = term_handler; sigset_t newset; sigemptyset(&newset); sigaddset(&newset, SIGTERM); sigaddset(&newset, SIGINT); sa.sa_mask = newset; sigaction(SIGTERM, &sa, 0); sigaction(SIGINT, &sa, 0); while(1) { ev_loop(mainLoop, 0); } return 0; }