示例#1
0
remote_ctx_t *
new_remote(int fd, server_ctx_t *server_ctx)
{
    remote_ctx_t *ctx = ss_malloc(sizeof(remote_ctx_t));
    memset(ctx, 0, sizeof(remote_ctx_t));

    ctx->fd         = fd;
    ctx->server_ctx = server_ctx;

    ev_io_init(&ctx->io, remote_recv_cb, fd, EV_READ);
    ev_timer_init(&ctx->watcher, remote_timeout_cb, server_ctx->timeout,
                  server_ctx->timeout);

    return ctx;
}
示例#2
0
/** 
 * Called when a message is sent from the server
 **/
static void
nol_s_ev_master(EV_P_ ev_io *w, int revents)
{
    if ((revents & EV_ERROR) || nolp_recv(srv.m_nolp) != 0) {
        /* reach here if connection was closed or a socket error occured */
        syslog(LOG_WARNING, "master has gone away, reconnecting in 5s");
        close(w->fd);
        ev_io_stop(EV_A_ w);
        ev_timer_init(&srv.master_timer,
                &nol_s_ev_master_timer,
                5.0f, 0.f);
        srv.master_timer.repeat = 5;
        ev_timer_start(EV_A_ &srv.master_timer);
    }
}
示例#3
0
int dns_forward_query_udp(event_entry_t *general_entry) {
	int sock, n;
	struct event_udp_entry *entry = &general_entry->udp;

	if (!ip_udp_open(&sock, &global_target_address)) {
		debug_log(DEBUG_ERROR, "dns_forward_query_udp(): unable to open a UDP socket to forward query to authoritative server\n");
		goto wrong;
	}

	// randomize the outgoing source port and set the source IP address, if needed
	if (!ip_bind_random(sock)) {
		// if this fails, let the kernel handle it (would mean source IP address is not guaranteed...)
		debug_log(DEBUG_WARN, "dns_forward_query_udp(): unable to bind to source IP address and/or random port\n");
	}

	entry->state = EVENT_UDP_INT_WRITING;
	entry->read_int_watcher.data = general_entry;
	entry->timeout_int_watcher.data = general_entry;
	entry->retries++;

	// Now generate a new TXID to forecome any poisoning:
	entry->buffer[0] = misc_crypto_random(256);
	entry->buffer[1] = misc_crypto_random(256);
	// XXX: do this platform safe (i.e. ntoh)
	entry->dns.dsttxid = (entry->buffer[0] << 8) + entry->buffer[1];

	ev_io_init(&entry->read_int_watcher, event_udp_int_cb, sock, EV_READ);
	ev_timer_init(&entry->timeout_int_watcher, event_udp_timeout_cb, 0., global_ip_internal_timeout);

	ev_io_start(event_default_loop, &entry->read_int_watcher);
	ev_timer_again(event_default_loop, &entry->timeout_int_watcher);

	debug_log(DEBUG_INFO, "dns_forward_query_udp(): forwarding query to authoritative name server (prev id = %d, new id = %d)\n",
			(entry->dns.type == DNS_DNSCURVE_STREAMLINED || entry->dns.type == DNS_NON_DNSCURVE) ? entry->dns.srctxid : entry->dns.srcinsidetxid,
			entry->dns.dsttxid);

	n = sendto(sock, entry->buffer, entry->packetsize, MSG_DONTWAIT,
			(struct sockaddr *) &global_target_address.sa, global_target_address_len);
	if (n == -1) {
		debug_log(DEBUG_ERROR, "dns_forward_query_udp(): unable to forward the query to authoritative name server (%s)\n", strerror(errno));
		goto wrong;
	}

	return 1;

wrong:
	return 0;
}
int
main (void)
{
    // use the default event loop unless you have special needs
    struct ev_loop *loop = ev_default_loop (0);
    printf("Type help for a list of commands\n");

    CBByteArray *ip = CBNewByteArrayWithDataCopy((uint8_t [16]){0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 128, 8, 126, 25}, 16);
    CBNetworkAddress *peeraddr = CBNewNetworkAddress(0, ip, DEFAULT_PORT, CB_SERVICE_FULL_BLOCKS, false);
    peer = CBNewPeerByTakingNetworkAddress(peeraddr);

    // Create client socket
    if( (sd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
        perror("socket error");
        return -1;
    }
    memset(&addr, sizeof(addr), 0);
    addr.sin_family = AF_INET;
    addr.sin_port = htons(DEFAULT_PORT);
    addr.sin_addr.s_addr = (((((25 << 8) | 126) << 8) | 8) << 8) | 128;

    // Connect to server socket
    if(connect(sd, (struct sockaddr *)&addr, sizeof addr) < 0) {
        perror("Connect error");
        return -1;
    }

    printf("Connected to %s:%d\n", DEFAULT_IP, DEFAULT_PORT);
    
    // initialise an io watcher, then start it
    // this one will watch for stdin to become readable
    ev_io_init (&stdin_watcher, stdin_cb, /*STDIN_FILENO*/ 0, EV_READ);
    ev_io_start (loop, &stdin_watcher);

    // io watcher for the socket
    ev_io_init (&sock_watcher, sockread_cb, sd, EV_READ);
    ev_io_start (loop, &sock_watcher);

    // initialise a timer watcher, then start it
    ev_timer_init (&timeout_watcher, timeout_cb, 2.0, 0.);
    ev_timer_start (loop, &timeout_watcher);

    // now wait for events to arrive
    ev_loop (loop, 0);

    // unloop was called, so exit
    return 0;
}
示例#5
0
文件: i3lock.c 项目: seirl/i3lock
ev_timer *start_timer(ev_timer *timer_obj, ev_tstamp timeout, ev_callback_t callback) {
    if (timer_obj) {
        ev_timer_stop(main_loop, timer_obj);
        ev_timer_set(timer_obj, timeout, 0.);
        ev_timer_start(main_loop, timer_obj);
    } else {
        /* When there is no memory, we just don’t have a timeout. We cannot
         * exit() here, since that would effectively unlock the screen. */
        timer_obj = calloc(sizeof(struct ev_timer), 1);
        if (timer_obj) {
            ev_timer_init(timer_obj, callback, timeout, 0.);
            ev_timer_start(main_loop, timer_obj);
        }
    }
    return timer_obj;
}
示例#6
0
static void session_start(session_context *sc, EV_P) {
  ev_io_init(&sc->backend_rd_watcher, session_dispatch,
             sc->backend_fd.fd, EV_READ);
  sc->backend_rd_watcher.data = sc;

  ev_io_init(&sc->backend_wr_watcher, session_dispatch,
             sc->backend_fd.fd, EV_WRITE);
  sc->backend_wr_watcher.data = sc;

  ev_timer_init(&sc->inactivity_timer, session_inactivity_timer_handler,
                0., (double)sc->options->session_timeout);
  sc->inactivity_timer.data = sc;

  ev_io_start(EV_A_ &sc->backend_rd_watcher);
  session_mark_activity(EV_A_ sc);
}
示例#7
0
int server_generic_process_requests(server_generic_t *server, server_generic_client_t *client)
{
        client->server = server;

        ev_io_init(&client->evio, libev_notification_cb, (int) prelude_io_get_fd(client->fd), EV_READ);
        ev_io_start(manager_event_loop, &client->evio);

        if ( ! (client->state & SERVER_GENERIC_CLIENT_STATE_ACCEPTED) ) {
                ev_timer_init(&client->evtimer, libev_timer_cb, 0, config.connection_timeout);
                client->evtimer.data = client;

                ev_timer_again(manager_event_loop, &client->evtimer);
        }

        return 0;
}
示例#8
0
void ldap_bind(int msgid, BindRequest_t *req, ev_loop *loop, ev_io *watcher)
{
	ev_tstamp delay = 0.0;
	LDAPMessage_t *res = XNEW0(LDAPMessage_t, 1);

	res->messageID = msgid;
	res->protocolOp.present = LDAPMessage__protocolOp_PR_bindResponse;
	BindResponse_t *bindResponse = &res->protocolOp.choice.bindResponse;
	OCTET_STRING_fromBuf(&bindResponse->matchedDN, (const char *)req->name.buf, req->name.size);

	if (setting_anonymous && req->name.size == 0) {
		/* allow anonymous */
		asn_long2INTEGER(&bindResponse->resultCode, BindResponse__resultCode_success);
	} else if (req->authentication.present == AuthenticationChoice_PR_simple) {
		/* simple auth */
		char *user = cn2name((const char *)req->name.buf);
		char *pw = (char *)req->authentication.choice.simple.buf;
		char *status = NULL;
		if (!user) {
			asn_long2INTEGER(&bindResponse->resultCode, BindResponse__resultCode_invalidDNSyntax);
		} else if (PAM_SUCCESS != auth_pam(user, pw, &status, &delay)) {
			asn_long2INTEGER(&bindResponse->resultCode, BindResponse__resultCode_invalidCredentials);
			OCTET_STRING_fromString(&bindResponse->diagnosticMessage, status);
		} else {	/* Success! */
			asn_long2INTEGER(&bindResponse->resultCode, BindResponse__resultCode_success);
		}
		free(user);
		free(status);
	} else {
		/* sasl or anonymous auth */
		asn_long2INTEGER(&bindResponse->resultCode, BindResponse__resultCode_authMethodNotSupported);
	}
	if (delay > 0.0) {
		ev_timer *delay_timer = XNEW(ev_timer, 1);
		delay_data_t *data = XNEW(delay_data_t, 1);
		data->message = res;
		data->watcher = watcher;
		ev_timer_init(delay_timer, delay_cb, delay, 0.0);
		delay_timer->data = data;
		/* Stop the connection watcher to stop other requests while delayed. */
		ev_io_stop(loop, watcher);
		ev_timer_start(loop, delay_timer);
	} else {
		ldap_send(res, loop, watcher);
		ldapmessage_free(res);
	}
}
示例#9
0
void connection_start(backend_t *backend, int fd, struct sockaddr_in remote_addr)
{
  connection_t *c = (connection_t *) queue_pop(&backend->connections);
  
  /* no free connection found, add more */
  if (c == NULL) {
    connections_push(backend);
    c = (connection_t *) queue_pop(&backend->connections);
  }
  
  assert(c != NULL);
  
  /* init connection */
  c->finished       = 0;
  c->loop           = backend->loop;
  c->backend        = backend;
  c->content_length = 0;
  c->fd             = fd;
  c->remote_addr    = inet_ntoa(remote_addr.sin_addr);
  c->thread.obj     = Qnil;
  c->thread.active  = 0;
  
  /* mark as used to Ruby GC */
  c->env = rb_hash_new();
  rb_gc_register_address(&c->env);
  
  /* reset buffers */
  buffer_reset(&c->read_buffer);
  buffer_reset(&c->write_buffer);
  
  /* reinit parser */
  http_parser_init(&c->parser);
  c->parser.data = c;
  
  /* init libev stuff */
  c->read_watcher.data    = c;
  c->write_watcher.data   = c;
  c->timeout_watcher.data = c;
  ev_io_init(&c->read_watcher, connection_readable_cb, c->fd, EV_READ | EV_ERROR);
  ev_io_init(&c->write_watcher, connection_writable_cb, c->fd, EV_WRITE | EV_ERROR);
  ev_timer_init(&c->timeout_watcher, connection_timeout_cb, backend->timeout, backend->timeout);
  
  /* start event watchers */
  ev_timer_start(c->loop, &c->timeout_watcher);
  ev_io_start(c->loop, &c->read_watcher);
}
示例#10
0
static struct server * new_server(int fd, struct listen_ctx *listener)
{
    if (verbose) {
        server_conn++;
    }

    struct server *server;
    server = malloc(sizeof(struct server));

    memset(server, 0, sizeof(struct server));

    server->buf = malloc(BUF_SIZE);
    server->recv_ctx = malloc(sizeof(struct server_ctx));
    server->send_ctx = malloc(sizeof(struct server_ctx));
    server->fd = fd;
    ev_io_init(&server->recv_ctx->io, server_recv_cb, fd, EV_READ);
    ev_io_init(&server->send_ctx->io, server_send_cb, fd, EV_WRITE);
    ev_timer_init(&server->recv_ctx->watcher, server_timeout_cb,
            min(MAX_CONNECT_TIMEOUT, listener->timeout), listener->timeout);
    server->recv_ctx->server = server;
    server->recv_ctx->connected = 0;
    server->send_ctx->server = server;
    server->send_ctx->connected = 0;
    server->stage = 0;
    server->query = NULL;
    server->listen_ctx = listener;
    if (listener->method) {
        server->e_ctx = malloc(sizeof(struct enc_ctx));
        server->d_ctx = malloc(sizeof(struct enc_ctx));
        enc_ctx_init(listener->method, server->e_ctx, 1);
        enc_ctx_init(listener->method, server->d_ctx, 0);
    } else {
        server->e_ctx = NULL;
        server->d_ctx = NULL;
    }
    server->buf_len = 0;
    server->buf_idx = 0;
    server->remote = NULL;

    server->chunk = (struct chunk *)malloc(sizeof(struct chunk));
    memset(server->chunk, 0, sizeof(struct chunk));

    cork_dllist_add(&connections, &server->entries);

    return server;
}
示例#11
0
文件: http.cpp 项目: alheio/blizzard
void blizzard::http::add_watcher(struct ev_loop *loop)
{
	blizzard::server *s = (blizzard::server *) ev_userdata(loop);

	e.con = this;

	ev_io_init(&e.watcher_recv, recv_callback, fd, EV_READ);
	ev_io_start(loop, &e.watcher_recv);

	ev_io_init(&e.watcher_send, send_callback, fd, EV_WRITE);

	ev_timer_init(&e.watcher_timeout, timeout_callback, 0, s->config.blz.plugin.connection_timeout / (double) 1000);
	ev_timer_again(loop, &e.watcher_timeout);

	server_loop = loop;
	response_time = ev_now(loop);
}
示例#12
0
/*==============================================================================
* Name	 :	void Client_switch_to_stop(CONN_INFO* conn)
* Abstr	 :	Stop the socket io watcher and close it after a moment
* Params :	CONN_INFO* conn : connection with db server
* Return :	
* Modify :	
*=============================================================================*/
void Client_switch_to_stop(CONN_INFO* conn)
{
	/* reset connection alive flag */
	conn->is_alive = FALSE;

	log_fatal(log_cat, "%s: catch exception", &conn->name[0]);

	/* stop connection io watcher */
	ev_io_stop(host_loop, &conn->io_wt);

	/* do stopping handle after 10s */
	ev_timer_init(&conn->t_wt, Client_stop_cb, timer_array[TID_STOP_DELAY].t_val, 0.);
	ev_timer_start(host_loop, &conn->t_wt); 

	/* notice the host loop */
	ev_async_send(host_loop, &async_wt);
}
示例#13
0
void accept_cb(struct ev_loop *loop, ev_io *w, int revents)
{
	int client_sd = 0;
	struct sockaddr_in client_addr;
	socklen_t client_len = sizeof(struct sockaddr_in);

	if(EV_ERROR &revents)
	{
		printf("Error event in accpet, code %d:%s\r\n", errno, strerror(errno));
		return;
	}

	client_sd = accept(w->fd, (struct sockaddr *)(&client_addr), &client_len);
	if(client_sd < 0)
	{
		printf("Accept error, code %d:%s\r\n", errno, strerror(errno));
		return ;
	}

	if(client_sd > MAX_FD)
	{
		printf("Max fd thread\r\n");
		goto err_sd;
	}

	client[client_sd] = (struct libev_context *)malloc(sizeof(struct libev_context));
	if(client[client_sd] == NULL)
	{
		printf("Alloc context error, code %d:%s\r\n", errno, strerror(errno));
		goto err_sd;
	}

	printf("Context alloc ok for client_fd=%d \r\n", client_sd);

	ev_io_init(&(client[client_sd]->watcher), client_cb, client_sd, EV_READ);
	ev_io_start(loop, &(*client[client_sd]).watcher);
	
	ev_timer_init(&((*client[client_sd]).timer), client_timer_cb, CONNECT_TIMEOUT, 0);
	ev_timer_start(loop, &((*client[client_sd]).timer));
	printf("client connected success\r\n");

	return ;

err_sd:
	close(client_sd);
}
示例#14
0
文件: _evwsgi.c 项目: Amli/fapws3
/*
Procedure exposed in Python will generate and start the event loop
*/
static PyObject *py_run_loop(PyObject *self, PyObject *args)
{
    char *backend="";
    int i;
    ev_io accept_watcher;
    ev_signal signal_watcher, signal_watcher2, signal_watcher3;
    struct TimerObj *timer;
    loop = ev_default_loop (0);
    switch (ev_backend(loop))
    {
        case 1:
            backend="select";
            break;
        case 2:
            backend="poll";
            break;
        case 4:
            backend="epoll";
            break;
        case 8:
            backend="kqueue";
            break;
    }
    printf("Using %s as event backend\n", backend);
    ev_io_init(&accept_watcher,accept_cb,sockfd,EV_READ);
    ev_io_start(loop,&accept_watcher);
    ev_signal_init(&signal_watcher, sigint_cb, SIGINT);
    ev_signal_start(loop, &signal_watcher);
    ev_signal_init(&signal_watcher2, sigpipe_cb, SIGPIPE);
    ev_signal_start(loop, &signal_watcher2);
    ev_signal_init(&signal_watcher3, sigterm_cb, SIGTERM);
    ev_signal_start(loop, &signal_watcher3);
    idle_watcher = malloc(sizeof(ev_idle));
    ev_idle_init(idle_watcher, idle_cb);
    if (list_timers_i>=0)
    {
        for (i=0; i<list_timers_i; i++)
        {
            timer=list_timers[i];
            ev_timer_init(&timer->timerwatcher, timer_cb, timer->delay, timer->delay);
            ev_timer_start(loop, &timer->timerwatcher);
        }
    }
    ev_loop (loop, 0);
    return Py_None;
}
示例#15
0
文件: libev.c 项目: BinaryBlob/getdns
static getdns_return_t
getdns_libev_schedule_timeout(struct getdns_context* context,
    void* eventloop_data, uint16_t timeout,
    getdns_timeout_data_t* timeout_data,
    void** eventloop_timer) {

    struct ev_timer *timer;
    struct getdns_libev_data* ev_data = (struct getdns_libev_data*) eventloop_data;
    ev_tstamp to = timeout;
    to /= 1000;
    timer = (struct ev_timer*) malloc(sizeof(struct ev_timer));
    ev_timer_init(timer, getdns_libev_timeout_cb, to, 0);
    timer->data = timeout_data;
    ev_timer_start(ev_data->loop, timer);

    *eventloop_timer = timer;
    return GETDNS_RETURN_GOOD;
}
示例#16
0
文件: channel.c 项目: gstein/pocore
static void
init_cctx(pc_context_t *ctx)
{
    /* ### custom config flags for this root pool?  */
    pc_pool_t *pool = pc_pool_root(ctx);
    struct pc__channel_ctx_s *cctx;

    cctx = ctx->cctx = pc_calloc(pool, sizeof(*cctx));
    cctx->pool = pool;

    cctx->loop = ev_loop_new(EVFLAG_AUTO);

    /* Use some arbitrary values for the timer. Before we call ev_run(),
       we'll put proper values into the timer.  */
    ev_timer_init(&cctx->timeout, loop_timeout, 5.0, 5.0);

    cctx->callback_scratch = pc_pool_create(pool);
}
示例#17
0
文件: echoev.c 项目: dhess/echoev
listener_io *
make_listener(const struct sockaddr *addr, socklen_t addr_len)
{
    int listen_fd = listen_on(addr, addr_len);
    if (listen_fd == -1)
        return NULL;

    listener_io *lio = malloc(sizeof(listener_io));
    if (lio) {
        ev_io_init(&lio->listener, listen_cb, listen_fd, EV_READ);
        ev_timer_init(&lio->cooldown.timer,
                      cooldown_cb,
                      COOLDOWN_DURATION,
                      0);
        lio->cooldown.listener = &lio->listener;
    }
    return lio;
}
示例#18
0
//static void hp_timeout_cb(EV_P_ ev_timer *w, int revents)
//{
//	EV_ALL *cev = (EV_ALL *)(((char *)w) - offsetof (EV_ALL, mt_pingw));
//}
//zigbee callback
static void zg_connect_cb(EV_P_ ev_io *w, int revents)
{
	EV_ALL *cev = (EV_ALL *)(((char *)w) - offsetof (EV_ALL, zg_connectw));

	log_printf(LOG_NOTICE, "[ZigbeeConneted]\n");
	ev_io_stop(cev->mainloop, &cev->zg_connectw);
	ev_io_start(cev->mainloop, &cev->zg_readw);

	cev->zigbee_client.isconnected = socket_connected;
	cev->zigbee_client.reconnect_count = 0; //重置重连次数

	if(cev->zigbee_client.keepAliveInterval >0)
	{
		ev_timer_init(&cev->zg_pingw, zg_ping_cb, 0, cev->zigbee_client.keepAliveInterval);
		ev_timer_again(cev->mainloop, &cev->zg_pingw);
	}
//	dev_init();  //todo :
}
示例#19
0
void start_process(procnanny_t *pn, process_t *process) {
  program_t *program = pn_proc_program(process);
  program->state_cb = pn_proc_state_cb;
  pn_proc_start(process);
  ev_child *newwatcher = calloc(1, sizeof(ev_child));
  ev_child_init(newwatcher, child_proc_cb, pn_proc_pid(process), 0);
  ev_child_start(pn->loop, newwatcher);
  newwatcher->data = process;
  pn_proc_watch_io(pn->loop, process);
  //publish_proc_event(process, "starting");

  struct proc_data *procdata = process->data;
  procdata->running_state_timer = calloc(1, sizeof(ev_timer));
  procdata->running_state_timer->data = process;
  ev_timer_init(procdata->running_state_timer, running_state_timer_cb,
                program->minimum_run_duration, program->minimum_run_duration);
  ev_timer_start(pn->loop, procdata->running_state_timer);
} /* start_process */
示例#20
0
struct remote* new_remote(int fd, int timeout) {
    struct remote *remote;
    remote = malloc(sizeof(struct remote));
    remote->buf = malloc(BUF_SIZE);
    remote->recv_ctx = malloc(sizeof(struct remote_ctx));
    remote->send_ctx = malloc(sizeof(struct remote_ctx));
    remote->fd = fd;
    ev_io_init(&remote->recv_ctx->io, remote_recv_cb, fd, EV_READ);
    ev_io_init(&remote->send_ctx->io, remote_send_cb, fd, EV_WRITE);
    ev_timer_init(&remote->send_ctx->watcher, remote_timeout_cb, timeout, 0);
    remote->recv_ctx->remote = remote;
    remote->recv_ctx->connected = 0;
    remote->send_ctx->remote = remote;
    remote->send_ctx->connected = 0;
    remote->buf_len = 0;
    remote->buf_idx = 0;
    return remote;
}
示例#21
0
文件: tls_user.c 项目: regit/nufw
/**
 * 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);
}
示例#22
0
bool LinkageWorker::RegisterTimer(int64_t interval,
                                  Runnable *runnable,
                                  bool auto_release)
{
    if (!interval || !runnable) {
        return false;
    }

    double i = static_cast<double>(interval) / 1000000000;
    struct timer_t *timer = new struct timer_t;
    struct ev_timer *t = &timer->ev_timer;
    ev_timer_init(t, timer_cb, i, i);
    timer->auto_release = auto_release;
    timer->runnable = runnable;
    _timers.insert(timer);

    ev_timer_start(_loop, &timer->ev_timer);
    return true;
}
示例#23
0
文件: async.c 项目: giter/pidgin-lwqq
void lwqq_async_global_quit()
{
    //no need to destroy thread
    if(ev_thread_status == THREAD_NOT_CREATED) return ;
    global_quit_lock = 1;

    if(ev_thread_status == THREAD_NOW_WAITING){
        pthread_cond_signal(&ev_thread_cond);
    }else if(ev_thread_status == THREAD_NOW_RUNNING){
        ev_timer_init(&bomb,ev_bomb,0.001,0.001);
        ev_timer_start(ev_default,&bomb);
    }
    ev_thread_status = THREAD_NOT_CREATED;
    pthread_join(pid,NULL);
    ev_loop_destroy(ev_default);
    ev_default = NULL;
    pid = 0;
    global_quit_lock = 0;
}
示例#24
0
文件: asynio.c 项目: zhaoweikid/zocle
zcAsynIO* 
zc_asynio_new(zcSocket *sock, zcProtocol *p, struct ev_loop *loop, int rbufsize, int wbufsize)
{
    zcAsynIO *conn = NULL;
    conn = zc_calloct(zcAsynIO);
    zc_socket_setblock(sock, ZC_FALSE);

    conn->rbuf = zc_buffer_new(rbufsize);
    conn->wbuf = zc_buffer_new(wbufsize);
    conn->rbuf_free = 1;
    conn->wbuf_free = 1;
    conn->rbuf_auto_compact = 1;

    /*conn->connected = ZC_FALSE;
    conn->accepting = ZC_FALSE;
    conn->close= ZC_FALSE;
    conn->ssl  = ZC_FALSE;*/
    conn->sock = sock;
    conn->loop = loop;

    if (p) {
        zc_asynio_set_protocol(conn, p);
    }else{ //default
        zc_protocol_init(&conn->p);
    }

    ev_io_init(&conn->r, zc_asynio_ev_read, conn->sock->fd, EV_READ);
    conn->r.data = conn;
    ev_io_start(conn->loop, &conn->r);
    
    int timeout = sock->timeout;
    conn->read_timeout = conn->write_timeout = conn->conn_timeout = timeout;
    //ZCINFO("timeout:%d\n", timeout);
    if (timeout > 0) {
        //ev_timer_init(&conn->timer, zc_asynio_ev_timeout, timeout, 1);
        float tm = timeout/1000.0;
        ev_timer_init(&conn->rtimer, zc_asynio_read_ev_timeout, tm, tm);
        conn->rtimer.data = conn;
        ev_timer_start(conn->loop, &conn->rtimer);
    }

    return conn;
}
示例#25
0
void
as_event_command_begin(as_event_command* cmd)
{
	// Always initialize timer first when timeouts are specified.
	if (cmd->timeout_ms) {
		ev_timer_init(&cmd->timer, as_ev_timeout, (double)cmd->timeout_ms / 1000.0, 0.0);
		cmd->timer.data = cmd;
		ev_timer_start(cmd->event_loop->loop, &cmd->timer);
	}
	
	as_connection_status status = cmd->pipe_listener != NULL ? as_pipe_get_connection(cmd) : as_event_get_connection(cmd);
	
	if (status == AS_CONNECTION_FROM_POOL) {
		as_ev_command_write_start(cmd);
	}
	else if (status == AS_CONNECTION_NEW) {
		as_ev_connect(cmd);
	}
}
示例#26
0
文件: asynio.c 项目: zhaoweikid/zocle
int
zc_asynio_call_later(zcAsynIO *conn, int after, int repeat, 
        int (*callback)(zcAsynIO*, void *data), void *data)
{
    struct zc_asyn_callback_value_t *v = zc_calloct(struct zc_asyn_callback_value_t);
    //ev_timer timer; 
    double after2  = after/1000.0;
    double repeat2 = repeat/1000.0;
    ev_timer_init(&v->timer, _call_later_ev_timeout, after2, repeat2);

    v->callback = callback;
    v->conn = conn;
    v->data = data;
    v->timer.data = v;

    ev_timer_start(conn->loop, &v->timer);
    
    return ZC_OK;
}
示例#27
0
static int lcb_io_update_timer(struct lcb_io_opt_st *iops,
                               void *timer,
                               lcb_uint32_t usec,
                               void *cb_data,
                               void (*handler)(lcb_socket_t sock,
                                               short which,
                                               void *cb_data))
{
    struct libev_cookie *io_cookie = iops->v.v2.cookie;
    struct libev_event *evt = timer;
    ev_tstamp start;
    evt->data = cb_data;
    evt->handler = handler;
    start = usec / (ev_tstamp)1000000;
    ev_timer_stop(io_cookie->loop, &evt->ev.timer);
    ev_timer_init(&evt->ev.timer, timer_thunk, start, 0);
    ev_timer_start(io_cookie->loop, &evt->ev.timer);
    return 0;
}
示例#28
0
bool
cuev_init(struct curlev *cuev, struct ev_loop *loop)
{
	memset(cuev, 0, sizeof(*cuev));
	cuev->loop = loop;

	cuev->multi = curl_multi_init();
	curl_multi_setopt(cuev->multi, CURLMOPT_SOCKETFUNCTION, _curl_socket_cb);
	curl_multi_setopt(cuev->multi, CURLMOPT_SOCKETDATA, cuev);

	curl_multi_setopt(cuev->multi, CURLMOPT_TIMERFUNCTION, _curl_timer_cb);
	curl_multi_setopt(cuev->multi, CURLMOPT_TIMERDATA, cuev);

	/* инициализация колбека для таймера */
	ev_timer_init(&cuev->timer, _ev_timer_curl_cb, 0., 0.);
	cuev->timer.data = cuev;

	return true;
}
示例#29
0
文件: main.c 项目: mcspring/blastbeat
static void bb_acceptor_bind(struct bb_acceptor *acceptor) {

	int server = socket(acceptor->addr.in.sa_family, SOCK_STREAM, 0);
        if (server < 0) {
                bb_error_exit("socket()");
        }

        int on = 1;
        if (setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(int))) {
                bb_error_exit("setsockopt()");
        }

        if (setsockopt(server, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(int))) {
                bb_error_exit("setsockopt()");
        }

        if (bind(server, &acceptor->addr.in, sizeof(union bb_addr))) {
                bb_error_exit("unable to bind to address: bind()");
        }

        if (listen(server, 100) < 0) {
                bb_error_exit("unable to put socket in listen mode: listen()");
        }

        if (bb_nonblock(server)) {
                fprintf(stderr,"unable to put socket in non-blocking mode\n");
                exit(1);
        }

	ev_io_init(&acceptor->acceptor, accept_callback, server, EV_READ);	
	ev_io_start(blastbeat.loop, &acceptor->acceptor);


	struct bb_virtualhost *vhost = acceptor->vhosts;
        while(vhost) {
                vhost->pinger.vhost = vhost;
                ev_timer_init(&vhost->pinger.pinger, pinger_cb, blastbeat.ping_freq, blastbeat.ping_freq);
                ev_timer_start(blastbeat.loop, &vhost->pinger.pinger);
                vhost = vhost->next;
        }

}
示例#30
0
文件: loop.c 项目: Adios/cool.io
/* Run the event loop, calling rb_thread_schedule every 10ms */
static void Coolio_Loop_ev_loop_oneshot(struct Coolio_Loop *loop_data)
{
  struct ev_timer timer;
  struct timeval tv;

  /* Set up an ev_timer to unblock the loop every 10ms */
  ev_timer_init(&timer, timer_callback, BLOCKING_INTERVAL, BLOCKING_INTERVAL);
  ev_timer_start(loop_data->ev_loop, &timer);

  /* Loop until we receive events */
  while(!loop_data->events_received) {
    TRAP_BEG;
    RUN_LOOP(loop_data, EVLOOP_ONESHOT);
    TRAP_END;

    rb_thread_schedule();
  }

  ev_timer_stop(loop_data->ev_loop, &timer);
}