struct bufferevent * bufferevent_socket_new(struct event_base *base, evutil_socket_t fd, int options) { struct bufferevent_private *bufev_p; struct bufferevent *bufev; #ifdef _WIN32 if (base && event_base_get_iocp_(base)) return bufferevent_async_new_(base, fd, options); #endif if ((bufev_p = mm_calloc(1, sizeof(struct bufferevent_private)))== NULL) return NULL; if (bufferevent_init_common_(bufev_p, base, &bufferevent_ops_socket, options) < 0) { mm_free(bufev_p); return NULL; } bufev = &bufev_p->bev; evbuffer_set_flags(bufev->output, EVBUFFER_FLAG_DRAINS_TO_FD); event_assign(&bufev->ev_read, bufev->ev_base, fd, EV_READ|EV_PERSIST, bufferevent_readcb, bufev); event_assign(&bufev->ev_write, bufev->ev_base, fd, EV_WRITE|EV_PERSIST, bufferevent_writecb, bufev); evbuffer_add_cb(bufev->output, bufferevent_socket_outbuf_cb, bufev); evbuffer_freeze(bufev->input, 0); evbuffer_freeze(bufev->output, 1); return bufev; }
static int http_dispatch_uri_handler_cb(struct http_connection *hc) { if (!hc || !hc->hs || !hc->uri) return -1; struct http_uri *hu = hc->hs->uris; while(hu != NULL) { if (strcmp(hu->uri, hc->uri) == 0) { break; } else { hu = hu->next; } } if (hu && hu->handler_cb) { event_assign(hc->ev_write, hc->hs->base, hc->fd, EV_WRITE, hu->handler_cb, hc); } else { event_assign(hc->ev_write, hc->hs->base, hc->fd, EV_WRITE, http_404_cb, hc); } event_add(hc->ev_write, NULL); return 0; }
void bufferevent_init_generic_timeout_cbs_(struct bufferevent *bev) { event_assign(&bev->ev_read, bev->ev_base, -1, EV_FINALIZE, bufferevent_generic_read_timeout_cb, bev); event_assign(&bev->ev_write, bev->ev_base, -1, EV_FINALIZE, bufferevent_generic_write_timeout_cb, bev); }
fs_bool fs_node_bind_event(struct fs_node* node, fs_id node_id, int socket, struct sockaddr* sa, socklen_t socklen, struct fs_server* server, struct event_base* event_base ){ int ret = 0; if(node->read_ev){ event_free(node->read_ev); } if(node->write_ev){ event_free(node->write_ev); } node->node_id = node_id; node->socket = socket; node->server = server; node->read_ev = (struct event*)fs_malloc(sizeof(struct event)); node->write_ev = (struct event*)fs_malloc(sizeof(struct event)); const char bOper = 1; evutil_make_socket_nonblocking(node->socket); setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, (const char*)&bOper, sizeof(const char)); ret = event_assign(node->read_ev, event_base, node->socket, EV_READ | EV_PERSIST, libevent_cb_node_onrecv_data, node); ret |= event_assign(node->write_ev, event_base, node->socket, EV_WRITE | EV_PERSIST, libevent_cb_node_onsend_data, node); if(ret != 0){ goto fail; } node->recv_buffer = fs_create_output_stream(1024); node->send_buffer = fs_create_output_stream(1024); pthread_mutex_init(&node->write_mutex, NULL); pthread_mutex_init(&node->close_mutex, NULL); event_add(node->read_ev, NULL); event_add(node->write_ev, NULL); goto success; success: return fs_true; fail: if(node->read_ev) event_free(node->read_ev); if(node->write_ev) event_free(node->write_ev); return fs_false; }
struct bufferevent * bufferevent_socket_new(struct event_base *base, evutil_socket_t fd, int options) { struct bufferevent_private *bufev_p; struct bufferevent *bufev; #ifdef WIN32 if (base && event_base_get_iocp(base)) return bufferevent_async_new(base, fd, options); #endif if ((bufev_p = mm_calloc(1, sizeof(struct bufferevent_private)))== NULL) return NULL; if (bufferevent_init_common(bufev_p, base, &bufferevent_ops_socket, options) < 0) { mm_free(bufev_p); return NULL; } bufev = &bufev_p->bev; //设置将evbuffer的数据向fd传 evbuffer_set_flags(bufev->output, EVBUFFER_FLAG_DRAINS_TO_FD); //设置读写回调 event_assign(&bufev->ev_read, bufev->ev_base, fd, EV_READ|EV_PERSIST, bufferevent_readcb, bufev); event_assign(&bufev->ev_write, bufev->ev_base, fd, EV_WRITE|EV_PERSIST, bufferevent_writecb, bufev); //设置evbuffer的回调函数,使得外界给写缓冲区添加数据时,能触发 //写操作,这个回调对于写事件的监听是很重要的 evbuffer_add_cb(bufev->output, bufferevent_socket_outbuf_cb, bufev); /* 虽然这里冻结了,但实际上Libevent在读数据或者写数据之前会解冻的读完或者写完数据后,又会马上冻结。 * 这主要防止数据被意外修改。用户一般不会直接调用evbuffer_freeze或者evbuffer_unfreeze函数。 * 一切的冻结和解冻操作都由Libevent内部完成。还有一点要注意,因为这里只是把写缓冲区的头部冻结了。 * 所以还是可以往写缓冲区的尾部追加数据。同样,此时也是可以从读缓冲区读取数据。这个是必须的。 * 因为在Libevent内部不解冻的时候,用户需要从读缓冲区中获取数据(这相当于从socket fd中读取数据), * 用户也需要把数据写到写缓冲区中(这相当于把数据写入到socket fd中)。*/ //冻结读缓冲区的尾部,未解冻之前不能往读缓冲区追加数据 //也就是说不能从socket fd中读取数据 evbuffer_freeze(bufev->input, 0); //冻结写缓冲区的头部,未解冻之前不能把写缓冲区的头部数据删除 //也就是说不能把数据写到socket fd evbuffer_freeze(bufev->output, 1); return bufev; }
/* There is no way to get `EVLIST_INSERTED` event flag outside of libevent, so * here are tracking functions. */ static void tracked_event_set( struct tracked_event *tev, evutil_socket_t fd, short events, void (*callback)(evutil_socket_t, short, void *), void *arg) { event_assign(&tev->ev, get_event_base(), fd, events, callback, arg); timerclear(&tev->inserted); }
int evsig_init_(struct event_base *base) { /* * Our signal handler is going to write to one end of the socket * pair to wake up our event loop. The event loop then scans for * signals that got delivered. */ if (evutil_make_internal_pipe_(base->sig.ev_signal_pair) == -1) { #ifdef _WIN32 /* Make this nonfatal on win32, where sometimes people have localhost firewalled. */ event_sock_warn(-1, "%s: socketpair", __func__); #else event_sock_err(1, -1, "%s: socketpair", __func__); #endif return -1; } if (base->sig.sh_old) { mm_free(base->sig.sh_old); } base->sig.sh_old = NULL; base->sig.sh_old_max = 0; event_assign(&base->sig.ev_signal, base, base->sig.ev_signal_pair[0], EV_READ | EV_PERSIST, evsig_cb, base); base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL; event_priority_set(&base->sig.ev_signal, 0); base->evsigsel = &evsigops; return 0; }
int game_add_connect_event(struct sockaddr *sa, int socklen, CLIENT_MAP *client_map) { int ret; struct event *event_conn = &client_map->event_recv; int fd = 0; fd = create_new_socket(0); if (0 != event_assign(event_conn, base, fd, EV_READ|EV_PERSIST, cb_recv, client_map)) { log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s %d: event_new failed[%d]", __FUNCTION__, __LINE__, errno); goto fail; } event_add(event_conn, NULL); ret = evutil_socket_connect(&fd, sa, socklen); if (ret < 0) { log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s %d: evutil_socket_connect failed[%d]", __FUNCTION__, __LINE__, errno); goto fail; } game_set_socket_opt(fd); return (fd); fail: if (fd > 0) { evutil_closesocket(fd); } if (event_conn) { event_del(event_conn); } return (-1); }
int main(int argc, char **argv) { struct event timeout[N]; struct ST_EventWithDescription stEvent[N]; int time_interval[N]; int i = 0; struct timeval tv; struct event_base *base; int flag = 0; setTimeIntervalArr(time_interval, N); if(argc == 2 && !strcmp(argv[1], "-p")) flag = EV_PERSIST; else flag = 0; base = event_base_new(); evutil_timerclear(&tv); for(i = 0; i < N; ++i) { char buf[BUFFER] = {0}; sprintf(buf, "task_%d", i+1); setParam(stEvent+i, timeout+i, time_interval[i], buf); event_assign(timeout+i, base, -1, flag, timeout_cb,(void *)(stEvent+i)); event_add(timeout+i, &tv); } evutil_gettimeofday(&lasttime, NULL); event_base_dispatch(base); return 0; }
static void t1func(evutil_socket_t fd, short what, void *arg) { struct event *t1 = (struct event*)arg; struct event *t2; fprintf(stderr, "CAUGHT EVENT\n"); fflush(stderr); event_del(t1); free(t1); loops++; if (loops < 10) { t2 = (struct event*)malloc(sizeof(struct event)); if (event_assign(t2, base, -1, EV_WRITE, t1func, t2) < 0) { die("event_assign_term"); } if (event_priority_set(t2, TERMPRI) < 0) { die("event_priority_set_term"); } fprintf(stderr, "EVENT %d DEFINED\n", loops); fflush(stderr); event_active(t2, EV_WRITE, 1); fprintf(stderr, "EVENT %d ACTIVATED\n", loops); fflush(stderr); } }
void makeDNSTask(struct DNSTask * dnstask) { int type; struct ares_options options; int optmask; switch (dnstask->role) { case DNS_TASK: gettimeofday(&dnstask->CheckDt, NULL); optmask = ARES_OPT_FLAGS; options.servers = getNulledMemory(sizeof (struct in_addr)); options.nservers = 1; options.flags = ARES_FLAG_NOCHECKRESP; optmask |= ARES_OPT_SERVERS; memcpy(options.servers, &dnstask->task->resolv->NSIP, sizeof (struct in_addr)); ares_init_options(&dnstask->channel, &options, optmask); MSToTimeval(dnstask->task->Record.TimeOut, tv); type = dnstask->taskType; break; default: return; break; } ares_query(dnstask->channel, getPTR(dnstask->task->Record.HostName), C_IN, type, DNSTaskResolvCallback, dnstask); ares_getsock(dnstask->channel, &dnstask->fd, 1); event_assign(&dnstask->ev, base, dnstask->fd, EV_READ | EV_TIMEOUT, OnEventDNSTask, dnstask); event_add(&dnstask->ev, &tv); }
bool PipedEventWatcher::DoInit() { assert(pipe_[0] == 0); if (evutil_socketpair(AF_LOCAL, SOCK_STREAM, 0, pipe_) < 0) { log_error("evutil_socketpair failed"); goto failed; } if (evutil_make_socket_nonblocking(pipe_[0]) < 0 || evutil_make_socket_nonblocking(pipe_[1]) < 0) { log_error("evutil_make_socket_nonblockingfailed"); goto failed; } event_assign(&event_, event_base_, pipe_[1], EV_READ | EV_PERSIST, PipedEventWatcher::HandlerFn, this); return true; failed: Close(); return false; }
static void php_http_client_curl_event_timer(CURLM *multi, long timeout_ms, void *timer_data) { php_http_client_curl_event_context_t *context = timer_data; struct timeval timeout; #if DBG_EVENTS fprintf(stderr, "(%ld)", timeout_ms); #endif switch (timeout_ms) { case -1: if (event_initialized(context->timeout) && event_pending(context->timeout, EV_TIMEOUT, NULL)) { event_del(context->timeout); } break; case 0: php_http_client_curl_event_handler(context, CURL_SOCKET_TIMEOUT, 0); break; default: if (!event_initialized(context->timeout)) { event_assign(context->timeout, context->evbase, CURL_SOCKET_TIMEOUT, 0, php_http_client_curl_event_timeout_callback, context); } timeout.tv_sec = timeout_ms / 1000; timeout.tv_usec = (timeout_ms % 1000) * 1000; if (!event_pending(context->timeout, EV_TIMEOUT, &timeout)) { event_add(context->timeout, &timeout); } break; } }
static ZEND_RESULT_CODE php_http_client_curl_event_wait(void *context, struct timeval *custom_timeout) { php_http_client_curl_event_context_t *ctx = context; struct timeval timeout; #if DBG_EVENTS fprintf(stderr, "W"); #endif if (!event_initialized(ctx->timeout)) { if (0 > event_assign(ctx->timeout, ctx->evbase, CURL_SOCKET_TIMEOUT, 0, php_http_client_curl_event_timeout_callback, ctx)) { return FAILURE; } } else if (custom_timeout && timerisset(custom_timeout)) { if (0 > event_add(ctx->timeout, custom_timeout)) { return FAILURE; } } else if (!event_pending(ctx->timeout, EV_TIMEOUT, NULL)) { php_http_client_curl_get_timeout(ctx->client->ctx, 1000, &timeout); if (0 > event_add(ctx->timeout, &timeout)) { return FAILURE; } } if (0 > event_base_loop(ctx->evbase, EVLOOP_ONCE)) { return FAILURE; } return SUCCESS; }
int main(int argc, char **argv) { struct event signal_int; struct event_base* base; #ifdef WIN32 WORD wVersionRequested; WSADATA wsaData; int err; wVersionRequested = MAKEWORD(2, 2); err = WSAStartup(wVersionRequested, &wsaData); #endif /* Initalize the event library */ base = event_base_new(); /* Initalize one event */ event_assign(&signal_int, base, SIGINT, EV_SIGNAL|EV_PERSIST, signal_cb, &signal_int); event_add(&signal_int, NULL); event_base_dispatch(base); event_base_free(base); return (0); }
void EventLoopThread::threadFunc() { struct event_base* base = event_base_new(); int iret = evutil_socketpair(AF_INET, SOCK_STREAM, 0, wakeFd_); std::cout << "socket pair ret:" << iret << std::endl; std::cout << "thread id:" << std::this_thread::get_id() << std::endl; iret = event_assign(&ev_, base, wakeFd_[1], EV_READ | EV_PERSIST, WakeupCallback, this); if (0 != iret) { std::cout << "event assign error" << iret << std::endl; } iret = event_add(&ev_, nullptr); if (0 != iret) { std::cout << "event add error:" << iret << std::endl; } { std::unique_lock<std::mutex> ul(mutex_); base_ = base; cond_.notify_one(); } event_base_dispatch(base); std::cout << "event loop exiting...\n"; }
void Client::UnsetWriteEvent() { short event = event_get_events(m_event); event_del(m_event); event_assign(m_event, m_server->m_server_base, m_sockfd, event & (~EV_WRITE), Client::ClientEventCallback, this); event_add(m_event, NULL); }
int main(int argc, char **argv) { struct event timeout; struct timeval tv; struct event_base *base; int flags; if (argc == 2 && !strcmp(argv[1], "-p")) { event_is_persistent = 1; flags = EV_PERSIST; } else { event_is_persistent = 0; flags = 0; } /* Initalize the event library */ base = event_base_new(); /* Initalize one event */ event_assign(&timeout, base, -1, flags, timeout_cb, (void*) &timeout); evutil_timerclear(&tv); tv.tv_sec = 2; event_add(&timeout, &tv); evutil_gettimeofday(&lasttime, NULL); event_base_dispatch(base); return 0; return (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)) { short flags = EV_TIMEOUT | EV_PERSIST; struct timeval tmo; if (flags == event_get_events(timer) && handler == event_get_callback(timer)) { /* no change! */ return 0; } if (event_pending(timer, EV_TIMEOUT, 0)) { event_del(timer); } event_assign(timer, ((struct libevent_cookie *)iops->v.v2.cookie)->base, -1, flags, handler, cb_data); tmo.tv_sec = usec / 1000000; tmo.tv_usec = usec % 1000000; return event_add(timer, &tmo); }
/** * setup task thread * @param me * ************************************************************/ static void setup_task_thread(task_thread_t *me) { if( me == NULL ){ LM_ERR( " in setup_task_thread task_thread me is null \n"); return; } me->base = event_base_new(); if (! me->base) { fprintf(stderr, "Can't allocate event base\n"); exit(1); } /* Listen for notifications from other threads */ event_assign(&me->notify_event, me->base, me->notify_receive_fd, EV_READ | EV_PERSIST, me->ttm->thread_libevent_process, me); if (event_add(&me->notify_event, 0) == -1) { fprintf(stderr, "Can't monitor libevent notify pipe\n"); exit(1); } me->new_task_queue = (task_queue_t*)malloc(sizeof(task_queue_t)); if (me->new_task_queue == NULL) { LM_ERR("Failed to allocate memory for connection queue"); exit(EXIT_FAILURE); } task_queue_init(me->new_task_queue); /* if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) { perror("Failed to initialize mutex"); exit(EXIT_FAILURE); } */ }
static void thread_basic(void *arg) { THREAD_T threads[NUM_THREADS]; struct event ev; struct timeval tv; int i; struct basic_test_data *data = arg; struct event_base *base = data->base; struct event *notification_event = NULL; struct event *sigchld_event = NULL; EVTHREAD_ALLOC_LOCK(count_lock, 0); tt_assert(count_lock); tt_assert(base); if (evthread_make_base_notifiable(base)<0) { tt_abort_msg("Couldn't make base notifiable!"); } #ifndef WIN32 if (data->setup_data && !strcmp(data->setup_data, "forking")) { pid_t pid; int status; sigchld_event = evsignal_new(base, SIGCHLD, sigchld_cb, base); /* This piggybacks on the th_notify_fd weirdly, and looks * inside libevent internals. Not a good idea in non-testing * code! */ notification_event = event_new(base, base->th_notify_fd[0], EV_READ|EV_PERSIST, notify_fd_cb, NULL); event_add(sigchld_event, NULL); event_add(notification_event, NULL); if ((pid = fork()) == 0) { event_del(notification_event); if (event_reinit(base) < 0) { TT_FAIL(("reinit")); exit(1); } event_assign(notification_event, base, base->th_notify_fd[0], EV_READ|EV_PERSIST, notify_fd_cb, NULL); event_add(notification_event, NULL); goto child; } event_base_dispatch(base); if (waitpid(pid, &status, 0) == -1) tt_abort_perror("waitpid"); TT_BLATHER(("Waitpid okay\n")); tt_assert(got_sigchld); tt_int_op(notification_fd_used, ==, 0); goto end; }
/** * connect to as server * @param s: the the connection ************************************************************/ int emp_server_connect(connection_t *connection) { int r = 0, res = 0; char iabuf[INET_ADDRSTRLEN]; const char *ipaddr = (const char*)ast_inet_ntoa(iabuf, sizeof(iabuf), connection->sin.sin_addr); if (ipaddr == NULL) ipaddr = "n/a"; for (;;) { if (connect(connection->sfd, (struct sockaddr *) &connection->sin, sizeof(connection->sin)) < 0) { ++r; if (errno == EISCONN) { pthread_mutex_lock(&connection->lock); connection->sfd = socket(AF_INET, SOCK_STREAM, 0); // set socket to nonblock /* int flags = 1; if ((flags = fcntl(s->sfd, F_GETFL, 0)) < 0 || fcntl(s->sfd, F_SETFL, flags | O_NONBLOCK) < 0) { LM_ERR("setting O_NONBLOCK fail \n"); close(s->sfd); continue; } */ struct event_base *base = connection->event.ev_base; if (event_del(&connection->event) == -1) { pthread_mutex_unlock(&connection->lock); LM_ERR("event_del failed \n"); continue; } event_assign(&connection->event, base, connection->sfd, EV_READ | EV_PERSIST, server_message_got, (void *)connection); if (event_add(&connection->event, 0) == -1) { pthread_mutex_unlock(&connection->lock); LM_ERR("event_del failed \n"); continue; } pthread_mutex_unlock(&connection->lock); } LM_DBG("%d> emp_server@%s: Connect failed, Retrying (%04d) %s\n", connection->sfd, ipaddr, r, strerror(errno)); if (proxy_config.maxretries && (r > proxy_config.maxretries)) { res = 1; break; } else sleep(proxy_config.retryinterval); } else { LM_DBG("%d> emp_server@%s connect to emp_server\n", connection->sfd, ipaddr); res = 0; break; } } return res; }
void Client::NotWantRead() { m_want_read = false; short event = event_get_events(m_event); event_del(m_event); event_assign(m_event, m_server->m_server_base, m_sockfd, event & (~EV_READ), Client::ClientEventCallback, this); event_add(m_event, NULL); }
void CIOServer::Reset_Event(::event* ev, evutil_socket_t sock, short flag, event_callback_fn cb, void* p) { int err = event_assign(ev, m_evbase, sock, flag, cb, p); if ( err!=0 ) { //int test = 9; } }
int main(int argc, char **argv) { struct event ev; struct event *t1; event_enable_debug_mode(); fprintf(stderr, "Libevent %s\n", event_get_version()); fflush(stderr); if (!(base = event_base_new())) die("event_base_new"); if (event_base_priority_init(base, 8) < 0) die("event_base_priority_init"); if (event_assign(&ev, base, SIGTERM, EV_SIGNAL|EV_PERSIST, cbfunc, NULL)<0) die("event_assign"); if (event_priority_set(&ev, SIGPRI) < 0) die("event_priority_set"); if (event_add(&ev, NULL) < 0) die("event_add"); fprintf(stderr, "SIGNAL EVENT DEFINED\n"); fflush(stderr); t1 = (struct event*)malloc(sizeof(struct event)); if (event_assign(t1, base, -1, EV_WRITE, t1func, t1) < 0) { die("event_assign_term"); } if (event_priority_set(t1, TERMPRI) < 0) { die("event_priority_set_term"); } event_active(t1, EV_WRITE, 1); fprintf(stderr, "FIRST TERMINATION EVENT DEFINED\n"); fflush(stderr); /* event_dispatch(base); */ while (run) { event_base_loop(base, EVLOOP_ONCE); } fprintf(stderr, "EXITED LOOP - FREEING BASE\n"); fflush(stderr); event_base_free(base); return 0; }
static void lcb_io_delete_timer(struct lcb_io_opt_st *iops, void *event) { (void)iops; if (event_pending(event, EV_TIMEOUT, 0) != 0 && event_del(event) == -1) { iops->v.v2.error = EINVAL; } event_assign(event, ((struct libevent_cookie *)iops->v.v2.cookie)->base, -1, 0, NULL, NULL); }
static const char *wait_for_event(struct Worker *w, short flags) { event_assign(&w->ev, w->evbase, w->socket, flags, worker_cb, w); tt_assert(event_add(&w->ev, NULL) == 0); w->pending = 1; return "OK"; end: return "event_add failed"; }
TimerEvent::TimerEvent(event_base* evBase, int milliSecs, bool repeated) { short flag = 0; if (repeated) flag |= EV_PERSIST; m_timeval.tv_sec = milliSecs / 1000; m_timeval.tv_usec = (milliSecs % 1000) * 1000; event_assign(&m_event, evBase, -1, flag, TimerCallback, (void*)this); }
static void be_socket_setfd(struct bufferevent *bufev, evutil_socket_t fd) { BEV_LOCK(bufev); EVUTIL_ASSERT(bufev->be_ops == &bufferevent_ops_socket); event_del(&bufev->ev_read); event_del(&bufev->ev_write); event_assign(&bufev->ev_read, bufev->ev_base, fd, EV_READ|EV_PERSIST, bufferevent_readcb, bufev); event_assign(&bufev->ev_write, bufev->ev_base, fd, EV_WRITE|EV_PERSIST, bufferevent_writecb, bufev); if (fd >= 0) bufferevent_enable(bufev, bufev->enabled); BEV_UNLOCK(bufev); }
static void libcouchbase_io_delete_event(struct libcouchbase_io_opt_st *iops, libcouchbase_socket_t sock, void *event) { (void)iops; (void)sock; if (event_del(event) == -1) { iops->error = EINVAL; } event_assign(event, ((struct libevent_cookie *)iops->cookie)->base, -1, 0, NULL, NULL); }