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; }
/** * 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); } }
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; }
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; }
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); }
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; }
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); } }
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); }
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; }
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); }
/*============================================================================== * 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); }
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); }
/* 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; }
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; }
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); }
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; }
//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 : }
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 */
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; }
/** * 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); }
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; }
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; }
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; }
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); } }
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; }
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; }
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; }
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; } }
/* 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); }