Exemplo n.º 1
0
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;
}
Exemplo n.º 2
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;
}
Exemplo n.º 3
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; 
}
Exemplo n.º 4
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;
}
Exemplo n.º 5
0
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;
}
Exemplo n.º 6
0
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
}
Exemplo n.º 7
0
    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;
}
Exemplo n.º 8
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);
}
Exemplo n.º 9
0
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;
}
Exemplo n.º 10
0
Arquivo: test.c Projeto: jcaose/evcom
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;
}
Exemplo n.º 11
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;
}
Exemplo n.º 12
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);
}
Exemplo n.º 14
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);
}
Exemplo n.º 15
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;
}
Exemplo n.º 16
0
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;
}
Exemplo n.º 17
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
}
Exemplo n.º 18
0
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
  }

}
Exemplo n.º 19
0
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;
}
Exemplo n.º 20
0
Arquivo: test.c Projeto: jcaose/evcom
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;
}
Exemplo n.º 21
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);
}
Exemplo n.º 22
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;
}
Exemplo n.º 23
0
Arquivo: test.c Projeto: jcaose/evcom
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;
}
Exemplo n.º 24
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;
}
Exemplo n.º 25
0
Arquivo: main.c Projeto: F35X70/feng
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;
}
Exemplo n.º 26
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;
}
Exemplo n.º 27
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;
}
Exemplo n.º 28
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;
}
Exemplo n.º 29
0
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);
}
Exemplo n.º 30
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;
}