int main(int argc, char **argv) { struct timeval one_second = { 1, 0 }; struct event *timeout_event, *sigint_event; base = event_base_new(); durations = histogram_new(100); delays = histogram_new(100); /* add prepare and check watchers; no need to hang on to their pointers, * since they will be freed for us in event_base_free. */ evwatch_prepare_new(base, &on_prepare, NULL); evwatch_check_new(base, &on_check, NULL); /* set a persistent one second timeout */ timeout_event = event_new(base, -1, EV_PERSIST, &on_timeout, NULL); if (!timeout_event) return EXIT_FAILURE; event_add(timeout_event, &one_second); /* set a handler for interrupt, so we can quit cleanly */ sigint_event = evsignal_new(base, SIGINT, &on_sigint, NULL); if (!sigint_event) return EXIT_FAILURE; event_add(sigint_event, NULL); /* run the event loop until interrupted */ event_base_dispatch(base); /* clean up */ event_free(timeout_event); event_free(sigint_event); event_base_free(base); histogram_free(durations); histogram_free(delays); return EXIT_SUCCESS; }
void multi_tcp_free(struct multi_tcp *mtcp) { if (mtcp) { event_free(mtcp->es); if (mtcp->esr) { free(mtcp->esr); } free(mtcp); } }
int main(void) { srand(time(NULL)); cmockaTest(); puts("\nPress ANY KEY to continue..."); getch(); system("cls"); queue_t * myQueue = queue_new(); user_t * me = user_new("Me"); user_t * firstuser = user_new("First"); user_t * seconduser = user_new("Second"); user_t * users[] = { me, firstuser, seconduser }; int usersSize = sizeof(users) / sizeof(users[0]); event_t * firstEvent = event_new("10 measurements \\ everything OK (1st event)"); event_t * secondEvent = event_new("last 5 measurements \\ not everything OK (2d event)"); event_t * thirdEvent = event_new("last 5 measurements \\ everything NOT OK (3d event)"); event_addAlertSingle(me, firstEvent, alert_fantasy); event_addAlertSingle(me, secondEvent, alert_master); event_addAlertSeveral(users, usersSize, thirdEvent, alert_common); while (!kbhit()) { event_start(firstEvent, secondEvent, thirdEvent, myQueue); } event_free(firstEvent); event_free(secondEvent); event_free(thirdEvent); for (int i = 0; i < usersSize; i++) { user_free(users[i]); } queue_free(myQueue); getch(); puts("Press ANY KEY to exit the program..."); getch(); return 0; }
void Worker::finishWriting(int fd) { assert(clients.find(fd) != clients.end()); event_del(clients[fd]->writeEvent); event_free(clients[fd]->writeEvent); clients[fd]->writeEvent = nullptr; if (!clients[fd]->readEvent) { /* Close client */ closeClient(fd); } }
void Timer::reset() { if (NULL != _event) { event_free(_event); _event = NULL; } // _interval = 0; // _round = 0; // _curRound = 0; // _handler = NULL; }
void socket_unit(void) { int i; for (i = 0; i < MAX_SOCKET; i++) { struct socket *sock = &S.slot[i]; if (sock->type != SOCKET_TYPE_RESERVE) { struct socket_message ret; socket_force_close(sock, &ret); } } close(S.sendctl_fd); close(S.recvctl_fd); event_free(S.event_fd); }
int main(int argc, char **argv) { struct event_base *base; struct evconnlistener *listener; struct event *signal_event; struct sockaddr_in sin; #ifdef WIN32 WSADATA wsa_data; WSAStartup(0x0201, &wsa_data); #endif base = event_base_new(); if (!base) { fprintf(stderr, "Could not initialize libevent!\n"); return 1; } const char* method = event_base_get_method(base); printf("method:%s\n",method); memset(&sin, 0, sizeof(sin)); sin.sin_family = AF_INET; sin.sin_port = htons(PORT); listener = evconnlistener_new_bind(base, listener_cb, (void *)base, LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -1, (struct sockaddr*)&sin, sizeof(sin)); if (!listener) { fprintf(stderr, "Could not create a listener!\n"); return 1; } signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base); if (!signal_event || event_add(signal_event, NULL)<0) { fprintf(stderr, "Could not create/add a signal event!\n"); return 1; } event_base_dispatch(base); evconnlistener_free(listener); event_free(signal_event); event_base_free(base); printf("done\n"); return 0; }
int serv_loop () { int fd ; int i ; struct event_base *base ; struct event *event ; base = event_base_new () ; if (NULL == base) { fprintf (LOG_STREAM, "[ERROR] even_base_new in 'serv_loop' failed\n") ; return -1 ; } event = event_new (base, g_listen, EV_READ | EV_ET | EV_PERSIST, on_accept, event_self_cbag ()) ; if (NULL == event) { fprintf (LOG_STREAM, "[ERROR] event_new in 'serv_loop' failed\n") ; event_base_free (base) ; return -1 ; } if (-1 == event_add (event, NULL)) { fprintf (LOG_STREAM, "[ERROR] event_add in 'serv_loop' failed\n") ; event_base_free (base) ; event_free (event) ; return -1 ; } if (-1 == event_base_loop (base, EVLOOP_NO_EXIT_ON_EMPTY)) { fprintf (LOG_STREAM, "[ERROR] event_base_loop 'serv_loop' failed\n") ; event_base_free (base) ; event_free (event) ; return -1 ; } return 0 ; }
static void nc_conn_free(struct nc_conn *conn) { if (!conn) return; if (conn->write_q) { clist *tmp = conn->write_q; while (tmp) { struct buffer *buf; buf = tmp->data; tmp = tmp->next; free(buf->p); free(buf); } clist_free(conn->write_q); } if (conn->ev) { event_del(conn->ev); event_free(conn->ev); } if (conn->write_ev) { event_del(conn->write_ev); event_free(conn->write_ev); } if (conn->fd >= 0) close(conn->fd); free(conn->msg.data); memset(conn, 0, sizeof(*conn)); free(conn); }
static void readFromPipe (evutil_socket_t fd, short eventType, void * veh) { char ch; int ret; tr_event_handle * eh = veh; dbgmsg ("readFromPipe: eventType is %hd", eventType); /* read the command type */ ch = '\0'; do { ret = piperead (fd, &ch, 1); } while (!eh->die && ret < 0 && errno == EAGAIN); dbgmsg ("command is [%c], ret is %d, errno is %d", ch, ret, (int)errno); switch (ch) { case 'r': /* run in libevent thread */ { struct tr_run_data data; const size_t nwant = sizeof (data); const ssize_t ngot = piperead (fd, &data, nwant); if (!eh->die && (ngot == (ssize_t)nwant)) { dbgmsg ("invoking function in libevent thread"); (data.func)(data.user_data); } break; } case '\0': /* eof */ { dbgmsg ("pipe eof reached... removing event listener"); event_free (eh->pipeEvent); break; } default: { assert (0 && "unhandled command type!"); break; } } }
// When the system is shutting down, it will close all listening servers. void server_shutdown(server_t *server) { assert(server); assert(server->sysdata); logger(server->sysdata->logging, 1, "Closing socket %d.", server->handle); assert(server->event); event_free(server->event); server->event = NULL; assert(server->handle != INVALID_HANDLE); close(server->handle); server->handle = INVALID_HANDLE; }
/* Assign information to a SockInfo structure */ static void setsock(SockInfo*f, curl_socket_t s, CURL*e, int act, GlobalInfo*g) { int kind = (act&CURL_POLL_IN?EV_READ:0)|(act&CURL_POLL_OUT?EV_WRITE:0)|EV_PERSIST; f->sockfd = s; f->action = act; f->easy = e; if (f->evset) event_free(f->ev); f->ev = event_new(g->evbase, f->sockfd, kind, event_cb, g); f->evset = 1; event_add(f->ev, NULL); }
static void task_destroy(struct async_network_task_s *task) { pthread_mutex_lock(&lock); g_hash_table_remove(tasks_ht, task); if (task->event) { event_free(task->event); task->event = NULL; } free(task->host); g_slice_free(struct async_network_task_s, task); pthread_mutex_unlock(&lock); }
void gda_transaction_status_free_events (GdaTransactionStatus *tstatus, GdaTransactionStatusEvent *event, gboolean free_after) { GList *node; g_return_if_fail (GDA_IS_TRANSACTION_STATUS (tstatus)); node = g_list_find (tstatus->events, event); g_return_if_fail (node); if (free_after) { GList *list = g_list_last (tstatus->events); GList *tmp; while (list != node) { event_free ((GdaTransactionStatusEvent *)(list->data)); tmp = list->prev; tstatus->events = g_list_delete_link (tstatus->events, list); list = tmp; } } event_free (event); tstatus->events = g_list_delete_link (tstatus->events, node); }
void fs_node_close(struct fs_node* node){ if(fs_node_is_closed(node)) return; fs_node_set_closed(node); if(node->recv_buffer){ fs_stream_free_output(node->recv_buffer); node->recv_buffer = NULL; } if(node->send_buffer){ pthread_mutex_lock(&node->write_mutex); fs_stream_free_output(node->send_buffer); node->send_buffer = NULL; pthread_mutex_unlock(&node->write_mutex); } pthread_mutex_destroy(&node->write_mutex); pthread_mutex_destroy(&node->close_mutex); fs_node_close_socket(node); if(node->read_ev != NULL){ event_free(node->read_ev); node->read_ev = NULL; } if(node->write_ev != NULL){ event_free(node->write_ev); node->write_ev = NULL; } if(fs_node_is_from_listener(node)){ fs_server_on_node_shudown(node->server, node->node_id); } }
void _bosh_conn_destroy(_bosh_conn conn) { if (_test_fns) { _test_fns->conn_destroy(conn); return; } assert(conn); _bosh_conn_ctx conn_ctx = conn->ctx; PUSH_CONN_NDC; JW_LOG_TRACE_FUNCTION_NO_ARGS; assert(conn_ctx); if (conn->easy) { CURL *easy = conn->easy; conn->easy = NULL; if (conn->active) { curl_multi_remove_handle(conn_ctx->multi, easy); } curl_easy_cleanup(easy); } conn->active = false; if (conn->sock_ev) { event_free(conn->sock_ev); conn->sock_ev = NULL; } if (conn->req_buf) { evbuffer_free(conn->req_buf); conn->req_buf = NULL; } if (conn->resp_buf) { evbuffer_free(conn->resp_buf); conn->resp_buf = NULL; } jw_data_free(conn); POP_CONN_NDC; }
int main() { struct event_base *eb; struct event *ev1, *ev2; pthread_t pid; /*init event_base*/ eb = event_base_new(); assert(eb); ev1 = evsignal_new(eb, SIGUSR1, signal_handler, (void*)0x1); assert(ev1); assert(evsignal_add(ev1, NULL) == 0); ev2 = evsignal_new(eb, SIGUSR2, signal_handler, (void*)0x2); assert(ev2); assert(evsignal_add(ev2, NULL) == 0); assert(pthread_create(&pid, NULL, emit_signal, NULL) == 0); /*start loop*/ assert(event_base_loop(eb, EVLOOP_ONCE) == 0); assert(pthread_join(pid, NULL) == 0); assert(evsignal_del(ev1) == 0); assert(evsignal_del(ev2) == 0); event_free(ev1); event_free(ev2); /*destroy event_base*/ event_base_free(eb); return 0; }
static void olibc_msg_q_destroy_internal (olibc_msg_q_hdl msg_q_hdl) { if (!msg_q_hdl) { return; } printf("\n In internal q destroy"); if (msg_q_hdl->timer_event_handle) { evtimer_del(msg_q_hdl->timer_event_handle); event_free(msg_q_hdl->timer_event_handle); msg_q_hdl->timer_event_handle = NULL; } if (msg_q_hdl->event_handle) { event_del(msg_q_hdl->event_handle); event_free(msg_q_hdl->event_handle); msg_q_hdl->event_handle = NULL; } olibc_free((void **)&msg_q_hdl->msg_q_nodes); olibc_free((void **)&msg_q_hdl); }
// MUST be idempotent and MUST work with half-initialized objects void NeubotPollable::detach(void) { neubot_info("pollable: detach()"); // poller: continue to point to the poller this->timeout = -1.0; if (this->evread != NULL) { event_free(this->evread); this->evread = NULL; } if (this->evwrite != NULL) { event_free(this->evwrite); this->evwrite = NULL; } // // We don't close the file descriptor because the Neubot pollable // class does not close the file description as well. // this->fileno = NEUBOT_SOCKET_INVALID; }
static getdns_return_t getdns_libevent_clear(getdns_eventloop *loop, getdns_eventloop_event *el_ev) { struct event *my_ev = (struct event *)el_ev->ev; (void)loop; assert(my_ev); if (event_del(my_ev) != 0) return GETDNS_RETURN_GENERIC_ERROR; event_free(my_ev); el_ev->ev = NULL; return GETDNS_RETURN_GOOD; }
void loose_cb(evutil_socket_t sock, short ev, void *arg) { UNUSED(sock); UNUSED(ev); UNUSED(arg); int seqno, times; fscanf(stdin, "%d %d", &seqno, ×); getchar(); if (feof(stdin)) { event_free(loose_evt); } else { loose_add(seqno, times); } }
void btc_node_release_events(btc_node *node) { if (node->event_bev) { bufferevent_free(node->event_bev); node->event_bev = NULL; } if (node->timer_event) { event_del(node->timer_event); event_free(node->timer_event); node->timer_event = NULL; } }
void clean_up( void ) { sound_free(); game_list_free(); submenu_free(); platform_free(); menu_free(); hint_free(); font_free(); bg_free(); location_free(); event_free(); snap_free(); video_free(); sdl_free(); }
/** * Call the GSource callback. * * @param source * @param callback callback function, which may be NULL * @param user_data ignored * @return result TRUE or FALSE */ static gboolean result_queue_source_dispatch(GSource *source, GSourceFunc callback, gpointer user_data) { struct result_queue *queue; struct event *ev; g_return_val_if_fail(source, FALSE); g_return_val_if_fail(callback==source_callback, FALSE); queue = RESULT_QUEUE(source); while( (ev=(struct event *)g_async_queue_try_pop(queue->async_queue)) != NULL) { callback(ev); event_free(ev); } return TRUE; }
NetworkWrapper::~NetworkWrapper() { if (m_stEvtlistener) { evconnlistener_free(m_stEvtlistener); } if (gstEvtBase) { event_base_free(gstEvtBase); } if (m_stSigEvt) { event_free(m_stSigEvt); } }
static void redisLibeventCleanup(void *privdata) { if (privdata) { struct redisLibeventEvents *e = (struct redisLibeventEvents *) privdata; if (e->allocated) { e->allocated = 0; if (e->rev) { if(e->rev_set) event_del(e->rev); event_free(e->rev); e->rev = NULL; } if (e->wev) { if(e->wev_set) event_del(e->wev); event_free(e->wev); e->wev = NULL; } turn_free(privdata, sizeof(struct redisLibeventEvents)); } } }
void event_cb(struct bufferevent *bev, short event, void *arg) { if (event & BEV_EVENT_EOF) printf("connection closed\n"); else if (event & BEV_EVENT_ERROR) printf("some other error\n"); //这将自动close套接字和free读写缓冲区 bufferevent_free(bev); struct event *ev = (struct event*)arg; //因为socket已经没有,所以这个event也没有存在的必要了 event_free(ev); }
static void send_resp(evutil_socket_t fd, short what __attribute__ ((__unused__)), void *arg) { struct is_data *data = arg; ssize_t len; len = send(fd, &data->resp, sizeof data->resp, 0); if (len != (int) sizeof data->resp) { penn_perror("error writing packet"); exit(EXIT_FAILURE); } event_free(data->ev); free(data); }
static void pxy_conn_ctx_free(pxy_conn_ctx_t *ctx) { #ifdef DEBUG_PROXY if (OPTS_DEBUG(ctx->opts)) { log_dbg_printf("%p pxy_conn_ctx_free\n", (void*)ctx); } #endif /* DEBUG_PROXY */ pxy_thrmgr_detach(ctx->thrmgr, ctx->thridx); if (ctx->src_str) { free(ctx->src_str); } if (ctx->dst_str) { free(ctx->dst_str); } if (ctx->http_method) { free(ctx->http_method); } if (ctx->http_uri) { free(ctx->http_uri); } if (ctx->http_host) { free(ctx->http_host); } if (ctx->http_content_type) { free(ctx->http_content_type); } if (ctx->ssl_names) { free(ctx->ssl_names); } if (ctx->ssl_orignames) { free(ctx->ssl_orignames); } if (ctx->origcrt) { X509_free(ctx->origcrt); } if (ctx->ev) { event_free(ctx->ev); } if (ctx->sni) { free(ctx->sni); } if (WANT_CONTENT_LOG(ctx)) { log_content_close(&ctx->logctx); } free(ctx); }
/* * sntp_addremove_fd() is invoked by the intres blocking worker code * to read from a pipe, or to stop same. */ void sntp_addremove_fd( int fd, int is_pipe, int remove_it ) { u_int idx; blocking_child *c; struct event * ev; #ifdef HAVE_SOCKETPAIR if (is_pipe) { /* sntp only asks for EV_FEATURE_FDS without HAVE_SOCKETPAIR */ msyslog(LOG_ERR, "fatal: pipes not supported on systems with socketpair()"); exit(1); } #endif c = NULL; for (idx = 0; idx < blocking_children_alloc; idx++) { c = blocking_children[idx]; if (NULL == c) continue; if (fd == c->resp_read_pipe) break; } if (idx == blocking_children_alloc) return; if (remove_it) { ev = c->resp_read_ctx; c->resp_read_ctx = NULL; event_del(ev); event_free(ev); return; } ev = event_new(base, fd, EV_READ | EV_PERSIST, &worker_resp_cb, c); if (NULL == ev) { msyslog(LOG_ERR, "sntp_addremove_fd: event_new(base, fd) failed!"); return; } c->resp_read_ctx = ev; event_add(ev, NULL); }