static void zipper_init_sig(zipper_t *zipper) { struct sigaction sighandler; sighandler.sa_handler = SIG_IGN; sighandler.sa_flags = 0; sigfillset(&sighandler.sa_mask); int ret = sigaction(SIGPIPE, &sighandler, NULL); ASSERT (ret == 0, "sigaction failed"); ret = sigaction(SIGHUP, &sighandler, NULL); ASSERT (ret == 0, "sigaction failed"); zipper->sig_int_event_ = evsignal_new(zipper->base_event_, SIGINT, zipper_stop_call_back, zipper); zipper->sig_term_event_ = evsignal_new(zipper->base_event_, SIGTERM, zipper_stop_call_back, zipper); event_add(zipper->sig_int_event_, NULL); event_add(zipper->sig_term_event_, NULL); }
// handle SIGINT static void init_signals(system_data_t *sysdata) { assert(sysdata); assert(sysdata->evbase); assert(sysdata->sighup_event == NULL); sysdata->sighup_event = evsignal_new(sysdata->evbase, SIGHUP, sighup_handler, sysdata); assert(sysdata->sighup_event); event_add(sysdata->sighup_event, NULL); assert(sysdata->sigint_event == NULL); sysdata->sigint_event = evsignal_new(sysdata->evbase, SIGINT, sigint_handler, sysdata); assert(sysdata->sigint_event); event_add(sysdata->sigint_event, NULL); assert(sysdata->sigusr1_event == NULL); sysdata->sigusr1_event = evsignal_new(sysdata->evbase, SIGUSR1, sigusr1_handler, sysdata); assert(sysdata->sigusr1_event); event_add(sysdata->sigusr1_event, NULL); assert(sysdata->sigusr2_event == NULL); sysdata->sigusr2_event = evsignal_new(sysdata->evbase, SIGUSR2, sigusr2_handler, sysdata); assert(sysdata->sigusr2_event); event_add(sysdata->sigusr2_event, NULL); }
static void dnscache_init_sig(dnscache_t *dnscache) { struct sigaction sighandler; sighandler.sa_handler = SIG_IGN; sighandler.sa_flags = 0; sigfillset(&sighandler.sa_mask); int ret = sigaction(SIGPIPE, &sighandler, NULL); ASSERT (ret == 0, "sigaction failed"); ret = sigaction(SIGHUP, &sighandler, NULL); ASSERT (ret == 0, "sigaction failed"); dnscache->sig_int_event_ = evsignal_new(dnscache->base_event_, SIGINT, stop_call_back, dnscache); dnscache->sig_term_event_ = evsignal_new(dnscache->base_event_, SIGTERM, stop_call_back, dnscache); event_add(dnscache->sig_int_event_, NULL); event_add(dnscache->sig_term_event_, NULL); }
void run(char *conf_file) { struct running rr; struct event *sig1_ev,*sig2_ev,*sig_hup; evthread_use_pthreads(); setup_running(&rr); register_interface_types(&rr); register_source_types(&rr); run_config(&rr,conf_file); start_stats_timer(&rr); ref_release(&(rr.ic_running)); event_add(sq_consumer(rr.sq),0); event_add(si_consumer(rr.si),0); sq_release(rr.sq); evsignal_add(sig1_ev=evsignal_new(rr.eb,SIGINT,user_quit,&rr),0); evsignal_add(sig2_ev=evsignal_new(rr.eb,SIGTERM,user_quit,&rr),0); evsignal_add(sig_hup=evsignal_new(rr.eb,SIGHUP,hupev,&rr),0); rr.sigkill_timer = event_new(rr.eb,-1,EV_PERSIST,sigkill_self,&rr); log_info(("Starting event loop")); event_base_loop(rr.eb,0); log_info(("Event loop finished")); event_del(sig1_ev); event_del(sig2_ev); event_del(sig_hup); event_free(sig1_ev); event_free(sig2_ev); event_free(sig_hup); closedown(&rr); log_info(("Bye!")); config_finished(); }
static void levent_init(struct lldpd *cfg) { /* Setup libevent */ log_debug("event", "initialize libevent"); event_set_log_callback(levent_log_cb); if (!(cfg->g_base = event_base_new())) fatalx("unable to create a new libevent base"); log_info("event", "libevent %s initialized with %s method", event_get_version(), event_base_get_method(cfg->g_base)); /* Setup SNMP */ #ifdef USE_SNMP if (cfg->g_snmp) { agent_init(cfg, cfg->g_snmp_agentx); cfg->g_snmp_timeout = evtimer_new(cfg->g_base, levent_snmp_timeout, cfg); if (!cfg->g_snmp_timeout) fatalx("unable to setup timeout function for SNMP"); if ((cfg->g_snmp_fds = malloc(sizeof(struct ev_l))) == NULL) fatalx("unable to allocate memory for SNMP events"); TAILQ_INIT(levent_snmp_fds(cfg)); } #endif /* Setup loop that will run every X seconds. */ log_debug("event", "register loop timer"); if (!(cfg->g_main_loop = event_new(cfg->g_base, -1, 0, levent_update_and_send, cfg))) fatalx("unable to setup main timer"); event_active(cfg->g_main_loop, EV_TIMEOUT, 1); /* Setup unix socket */ log_debug("event", "register Unix socket"); TAILQ_INIT(&lldpd_clients); evutil_make_socket_nonblocking(cfg->g_ctl); if ((cfg->g_ctl_event = event_new(cfg->g_base, cfg->g_ctl, EV_READ|EV_PERSIST, levent_ctl_accept, cfg)) == NULL) fatalx("unable to setup control socket event"); event_add(cfg->g_ctl_event, NULL); /* Signals */ log_debug("event", "register signals"); signal(SIGHUP, SIG_IGN); evsignal_add(evsignal_new(cfg->g_base, SIGUSR1, levent_dump, cfg->g_base), NULL); evsignal_add(evsignal_new(cfg->g_base, SIGINT, levent_stop, cfg->g_base), NULL); evsignal_add(evsignal_new(cfg->g_base, SIGTERM, levent_stop, cfg->g_base), NULL); }
// Initializes TCP and LibEvent, then listens for connections on port // and calls accept_cb when they occur. Terminates cleanly on SIGINT. // Returns 0 on clean shutdown; otherwise nonzero int InitAndListenLoop(int port, evconnlistener_cb accept_cb, struct telex_conf *conf) { #ifdef WIN32 WSADATA WSAData; WSAStartup(0x101, &WSAData); #endif struct event_base *base; base = event_base_new(); if (!base) { LogFatal("listener", "Could not initialize libevent"); return 1; } //void event_enable_debug_mode(void); conf->dns_base = evdns_base_new(base, 1); if (!conf->dns_base) { LogFatal("listener", "Could not initialize dns"); return 1; } struct evconnlistener *listener; listener = listener_init_local(base, port, accept_cb, conf, NULL); if (!listener) { LogFatal("listener", "Could not create listener"); return 1; } struct event *signal_event; signal_event = evsignal_new(base, SIGINT, sigint_cb, (void *)base); if (!signal_event || event_add(signal_event, NULL)<0) { LogFatal("listener", "Could not create/add signal event"); return 1; } struct event *sigpipe_event; sigpipe_event = evsignal_new(base, SIGPIPE, sigpipe_cb, (void *)base); if (!sigpipe_event || event_add(sigpipe_event, NULL)<0) { LogFatal("listener", "Could not create/add signal event"); return 1; } // handle events ... LogTrace("listener", "Starting dispatch"); event_base_dispatch(base); evconnlistener_free(listener); event_free(signal_event); event_free(sigpipe_event); event_base_free(base); LogInfo("listener", "Shutdown complete"); return 0; }
int main(int argc, char *argv[]) { struct event_base *base = event_base_new(); assert(base!=NULL); struct evconnlistener *listener; struct event *signal_event; struct sockaddr_in myAddr; bzero(&myAddr,sizeof(myAddr)); myAddr.sin_family = AF_INET; myAddr.sin_port = htons(PORT); listener = evconnlistener_new_bind(base,(evconnlistener_cb)listen_cb,(void*)base, LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE,-1, (struct sockaddr *)&myAddr,sizeof(myAddr)); assert(listener!=NULL); signal_event = evsignal_new(base,SIGINT,signal_cb,(void*)base); assert(signal_event != NULL||event_add(signal_event,NULL)<0); event_base_dispatch(base); evconnlistener_free(listener); event_free(signal_event); event_base_free(base); return 0; }
int main(int argc, const char *argv[]) { struct evconnlistener *listener; struct event_base *base; struct event *signal_event; struct sockaddr_in sin; base = event_base_new(); sin.sin_family = AF_INET; sin.sin_port = 8000; listener = evconnlistener_new_bind(base, listener_cb, (void *)base, LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -1, (struct sockaddr *)&sin, sizeof(sin)); signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base); event_add(signal_event, NULL); event_base_dispatch(base); event_base_free(base); printf("wow, survived until the end :).\n"); return 0; }
int main(int argc, const char* argv[]) { int id; struct event* sig; struct evacceptor* acc; struct event_base* base; if(argc != 3){ printf("Usage %s id config\n", argv[0]); return 0; } /*构建libevent base*/ base = event_base_new(); /*读取acceptor id,全局唯一*/ id = atoi(argv[1]); /*创建一个acceptor 的事件响应器*/ acc = evacceptor_init(id, argv[2], base); if(acc == NULL){ printf("Could not start the acceptor\n"); return 0; } sig = evsignal_new(base, SIGINT, handle_sigint, base); evsignal_add(sig, NULL); event_base_dispatch(base); event_free(sig); evacceptor_free(acc); event_base_free(base); return 1; }
int main(int argc, char **argv){ struct event_base *base; struct evconnlistener *listener; struct event *signal_event; struct sockaddr_in sin; base = event_base_new(); 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)); signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base); event_base_dispatch(base); evconnlistener_free(listener); event_free(signal_event); event_base_free(base); printf("done\n"); return 0; }
int main(int argc, char const *argv[]) { struct event* sig; struct evlearner* lea; struct event_base* base; if (argc != 2) { printf("Usage: %s config\n", argv[0]); exit(1); } base = event_base_new(); lea = evlearner_init(argv[1], deliver, NULL, base); if (lea == NULL) { printf("Could not start the learner!\n"); exit(1); } sig = evsignal_new(base, SIGINT, handle_sigint, base); evsignal_add(sig, NULL); event_base_dispatch(base); event_free(sig); evlearner_free(lea); event_base_free(base); return 0; }
int main(int argc, char **argv) { const char *ubus_socket = "/var/run/ubus.sock"; struct ubus_context *ctx = ubus_connect(ubus_socket); if (!ctx) { fprintf(stderr, "Failed to connect to ubus\n"); return -1; } memset(&listener, 0, sizeof(listener)); listener.cb = receive_event; int ret = ubus_register_event_handler(ctx, &listener, "foo"); if (ret) return ret; struct event_base *evloop = event_base_new(); struct event *signal_int = evsignal_new(evloop, SIGINT, signal_cb, evloop); event_add(signal_int, NULL); struct event *e = event_new(evloop, ctx->sock.fd, EV_READ | EV_PERSIST, cb, ctx); event_add(e, NULL); event_base_dispatch(evloop); event_free(signal_int); event_free(e); event_base_free(evloop); ubus_free(ctx); return 0; }
int main(int argc, char **argv) { struct event *signal_int; struct event_base* base; #ifdef _WIN32 WORD wVersionRequested; WSADATA wsaData; wVersionRequested = MAKEWORD(2, 2); (void) WSAStartup(wVersionRequested, &wsaData); #endif /* Initalize the event library */ base = event_base_new(); /* Initalize one event */ signal_int = evsignal_new(base, SIGINT, signal_cb, event_self_cbarg()); event_add(signal_int, NULL); event_base_dispatch(base); event_free(signal_int); event_base_free(base); return (0); }
void SocketServerLibEvent::addSignalHandler(int signal, SignalHandler f, void* arg) { struct event *sig; signal_handlers.emplace_back(std::unique_ptr<SignalInfo>(new SignalInfo(f, arg))); SignalInfo* info = signal_handlers.rbegin()->get(); sig = evsignal_new(base, signal , ssle_my_signal_handler, reinterpret_cast<void*>(info)); event_add(sig, 0); }
int main (int argc, char const *argv[]) { struct event* sig; struct event_base* base; struct evproposer* prop; if (argc != 3) { printf("Usage: %s id config\n", argv[0]); exit(1); } base = event_base_new(); sig = evsignal_new(base, SIGINT, handle_sigint, base); evsignal_add(sig, NULL); prop = evproposer_init(atoi(argv[1]), argv[2], base); if (prop == NULL) { printf("Could not start the proposer!\n"); exit(1); } event_base_dispatch(base); event_free(sig); evproposer_free(prop); event_base_free(base); return 0; }
int setupListeners() { evthread_use_pthreads(); evBase = event_base_new(); const char **methods = event_get_supported_methods(); lprintf("Starting Libevent %s. Supported methods are:\n", event_get_version()); for (int i=0;methods[i] != NULL; i++){ lprintf("\t%s\n",methods[i]); } free((char**)methods); lprintf("Using %s.\n",event_base_get_method(evBase)); struct event *signalEvent; signalEvent = evsignal_new(evBase, SIGINT, signalCallback, (void*) evBase); if (!signalEvent || event_add(signalEvent, NULL) < 0){ lprintf("Could not create / add a signal event!\n"); return -1; } lprintf("done\n"); try{ contConnection = new ControllerLink(); mtc = new MTCModel(); for (int i=0;i<MAX_XL3_CON;i++){ xl3s[i] = new XL3Model(i); } tubii = new TUBIIModel(); } catch(int e){ return -1; } return 0; }
/* * Create and add signal to specified event base with handler block * * @note method allocates memory for <b>struct event </b> * that will be freed when object will be freed by ruby' GC * * @param [Base] base event base instance * @param [String] name a name of signal * @param [Object] handler object that perform signal handling. Any object that responds to :call method * */ static VALUE t_initialize(VALUE self, VALUE base, VALUE name, VALUE handler) { Libevent_Signal *le_signal; Libevent_Base *le_base; VALUE signal_list; VALUE signal_number; Data_Get_Struct(self, Libevent_Signal, le_signal); Data_Get_Struct(base, Libevent_Base, le_base); // check name signal_list = rb_funcall( rb_const_get(rb_cObject, rb_intern("Signal")), rb_intern("list"), 0); signal_number = rb_hash_aref(signal_list, name); if ( signal_number == Qnil ) rb_raise(rb_eArgError, "unknown signal name given"); rb_iv_set(self, "@name", name); // check handler if ( !rb_respond_to(handler, rb_intern("call"))) rb_raise(rb_eArgError, "handler does not response to call method"); rb_iv_set(self, "@handler", handler); // create signal event le_signal->ev_event = evsignal_new(le_base->ev_base, FIX2INT(signal_number), t_handler, (void *)handler); if ( !le_signal->ev_event ) rb_fatal("Could not create a signal event"); if ( event_add(le_signal->ev_event, NULL) < 0 ) rb_fatal("Could not add a signal event"); return self; }
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; }
GuNET_Server_Error_t GuNET_Server_Init(GuNET_Server_t ** server, int port, GuNET_Server_Client_OnConnect_t onConnect, GuNET_Server_Client_OnDisconnect_t onDisconnect, GuNET_Server_Client_OnData_t onData, void * userdata) { GuNET_Server_t * newServer; struct sockaddr_in addr; #ifdef _WIN32 WORD wVersionRequested; WSADATA wsaData; wVersionRequested = MAKEWORD(2, 2); WSAStartup(wVersionRequested, &wsaData); #endif check(!server, GuNET_SERVER_ERROR_INVALID_ARGS); newServer = malloc(sizeof(GuNET_Server_t)); check(!newServer, GuNET_SERVER_ERROR_MEMORY_ERROR); newServer->base = event_base_new(); addr.sin_family = AF_INET; addr.sin_addr.s_addr = 0; addr.sin_port = htons(port); newServer->fd = socket(AF_INET, SOCK_STREAM, 0); evutil_make_socket_nonblocking(newServer->fd); evutil_make_listen_socket_reuseable(newServer->fd); check(bind(newServer->fd, (struct sockaddr * )&addr, sizeof(addr)) < 0, GuNET_SERVER_ERROR_SOCKET_ERROR); check(listen(newServer->fd, 16) < 0, GuNET_SERVER_ERROR_SOCKET_ERROR); newServer->listen = event_new(newServer->base, newServer->fd, EV_READ | EV_PERSIST, GuNET_Server_Client_onConnect, (void *) newServer); event_add(newServer->listen, NULL ); newServer->onConnect = onConnect; newServer->onDisconnect = onDisconnect; newServer->onData = onData; newServer->userdata = userdata; newServer->clients = NULL; newServer->signal = evsignal_new(newServer->base, SIGINT, GuNET_Server_Client_onSignal, (void *)newServer->base); if (!newServer->signal || event_add(newServer->signal, NULL ) < 0) { fprintf(stderr, "Could not create/add a signal event!\n"); return 1; } *server = newServer; return GuNET_SERVER_ERROR_NONE; }
// 控制进程事件 int jmm_init_event(struct event_base* base) { if (base) { event.base = base; // SIGTERM event.term = evsignal_new(base, SIGTERM, jmm_ctrl_c_cb, (void *)base); if (!event.term || event_add(event.term, NULL) < 0) { return JMM_FAIL; } // CTRL-C event.ctrl_c = evsignal_new(base, SIGINT, jmm_ctrl_c_cb, (void *)base); if (!event.ctrl_c || event_add(event.ctrl_c, NULL) < 0) { return JMM_FAIL; } // USR1 event.usr1 = evsignal_new(base, SIGUSR1, jmm_usr1_cb, (void *)base); if (!event.usr1 || event_add(event.usr1, NULL) < 0) { return JMM_FAIL; } // CHLD event.child = evsignal_new(base, SIGCHLD, jmm_child_cb, (void *)base); if (!event.child || event_add(event.child, NULL) < 0) { return JMM_FAIL; } // 监听接口 struct sockaddr_in sin; memset(&sin, 0, sizeof(sin)); sin.sin_family = AF_INET; sin.sin_port = htons(conf.net_port); event.listener = evconnlistener_new_bind(base, jmm_listener_cb, (void *)base, LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE|LEV_OPT_CLOSE_ON_EXEC, conf.net_backlog, (struct sockaddr*)&sin, sizeof(sin)); if (!event.listener) { return JMM_FAIL; } return JMM_SUCCESS; } return JMM_FAIL; }
bool Master::StartMaster(int argc, char *argv[]) { if (0 != conf_para.InitPara(argc, argv)) return false; std::cout << "Start Master" << std::endl; if (!m_worker.Init(this)) { std::cerr<< "Master: Worker::Init()" << std::endl; return false; } nums_of_child = conf_para.MaxWorker; //创建一定数量的worker while (nums_of_child > 0) { switch (fork()) { case -1: std::cerr<< "Master: StartMaster(): fork()" << std::endl; return false; case 0: m_worker.Run(); return true; default: --nums_of_child; break; } } m_base = event_base_new(); m_exit_event = evsignal_new(m_base, SIGINT, Master::MasterExitSignal, m_base); m_chld_event = evsignal_new(m_base, SIGCHLD, Master::MasterChldSignal, this); evsignal_add(m_exit_event, NULL); evsignal_add(m_chld_event, NULL); event_base_dispatch(m_base); return true; }
int main(int argc, char **argv) { struct event_base *base; struct evconnlistener *listener; struct sockaddr_in sin; struct event *evstop; int port = 9876; if (argc > 1) { port = atoi(argv[1]); } if (port<=0 || port>65535) { puts("Invalid port"); return 1; } signal(SIGPIPE, SIG_IGN); base = event_base_new(); if (!base) { puts("Couldn't open event base"); return 1; } evstop = evsignal_new(base, SIGHUP, signal_cb, base); evsignal_add(evstop, NULL); /* Clear the sockaddr before using it, in case there are extra * * platform-specific fields that can mess us up. */ memset(&sin, 0, sizeof(sin)); /* This is an INET address */ sin.sin_family = AF_INET; /* Listen on 0.0.0.0 */ sin.sin_addr.s_addr = htonl(0); /* Listen on the given port. */ sin.sin_port = htons(port); listener = evconnlistener_new_bind(base, accept_conn_cb, NULL, LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1, (struct sockaddr*)&sin, sizeof(sin)); if (!listener) { perror("Couldn't create listener"); return 1; } event_base_dispatch(base); evconnlistener_free(listener); event_free(evstop); event_base_free(base); return 0; }
void run() { evutil_socket_t listener; struct sockaddr_in sin; struct event_base *base; struct event* listener_event; struct event *signal_event; base = event_base_new(); if(!base) { return; } signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base); if (!signal_event || event_add(signal_event, NULL)<0) { //printf(stderr, "Could not create/add a signal event!\n"); printf("Could not create/add a signal event!\n"); return ; } sin.sin_family = AF_INET; sin.sin_addr.s_addr = 0; sin.sin_port = htons(LISTEN_PORT); listener = socket(AF_INET, SOCK_STREAM, 0); evutil_make_socket_nonblocking(listener); #ifndef WIN32 { int one = 1; setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); } #endif if(bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0) { perror("bind"); return; } if(listen(listener, 16)<0) { perror("listen"); return; } listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base); event_add(listener_event, NULL); event_base_dispatch(base); event_free(signal_event); }
int main1(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; } 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 main(int argc, char *argv[]) { base = event_base_new(); if (!base) { fprintf(stderr, "no evbase.. aborting\n"); return -1; } if (argc != 3) { fprintf(stderr, "Usage: %s REMOTE PORT", argv[0]); return 1; } lew_ssl_factory_t *essl = lew_ssl_create ( base, argv[1], atoi(argv[2]), NULL, NULL, NULL ); lew_ssl_dont_really_ssl(essl); int stdinfd = fileno(stdin); evutil_make_socket_nonblocking(stdinfd); bev_stdin = bufferevent_socket_new( base, stdinfd, BEV_OPT_DEFER_CALLBACKS ); bufferevent_setcb(bev_stdin, stdinreadcb, NULL, stdineventcb, "stdin"); bev_ssl = lew_ssl_connect(essl); bufferevent_setcb(bev_ssl, sslinreadcb, NULL, sslineventcb, "ssl"); bufferevent_enable(bev_ssl, EV_READ | EV_WRITE); bufferevent_enable(bev_stdin, EV_READ); sig_event = evsignal_new(base, SIGINT, handle_interrupt, essl); event_add(sig_event, NULL); event_base_dispatch(base); //base_cleanup: event_base_free(base); }
// 子进程事件 int jmm_init_event_wf(struct event_base* base) { if (base) { event_wf.base = base; // SIGTERM event_wf.term = evsignal_new(base, SIGTERM, jmm_ctrl_c_wf_cb, (void *)base); if (!event_wf.term || event_add(event_wf.term, NULL) < 0) { return JMM_FAIL; } // CTRL-C event_wf.ctrl_c = evsignal_new(base, SIGINT, jmm_ctrl_c_wf_cb, (void *)base); if (!event_wf.ctrl_c || event_add(event_wf.ctrl_c, NULL) < 0) { return JMM_FAIL; } // USR1 event_wf.usr1 = evsignal_new(base, SIGUSR1, jmm_usr1_wf_cb, (void *)base); if (!event_wf.usr1 || event_add(event_wf.usr1, NULL) < 0) { return JMM_FAIL; } // CMM event_wf.cmm = event_new(base, shm_wf->girl_fd, EV_READ | EV_PERSIST, jmm_cmm_read_wf_cb, NULL); if (!event_wf.cmm || event_add(event_wf.cmm, NULL) < 0) { return JMM_FAIL; } //sock event_wf.sock_num = conf.proc_svr_num; event_wf.sock = (struct bufferevent**)malloc(sizeof(struct bufferevent*)*event_wf.sock_num); memset(event_wf.sock, 0, sizeof(struct bufferevent*)*event_wf.sock_num); return JMM_SUCCESS; } return JMM_FAIL; }
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; }
int add_signal(int signum, struct event *event) { if (!event) { event = evsignal_new(base, signum, cb_signal, NULL); if (!event) { log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s %d: evsignal_new failed[%d]", __FUNCTION__, __LINE__, errno); return (-1); } event->ev_arg = event; } else { evsignal_assign(event, base, signum, event->ev_callback, NULL); } return evsignal_add(event, NULL); }
int main(){ struct event_base* base = event_init(); struct event* signal_event = evsignal_new(base, SIGINT, sig_cb, base); event_add(signal_event,NULL); timeval tv = {1,0}; struct event* timeout_event = evtimer_new(base, timeout_cb, NULL); event_add(timeout_event, &tv); event_base_dispatch(base); event_free(timeout_event); event_free(signal_event); event_base_free(base); }
int NetworkWrapper::Init() { struct sockaddr_in sin; gstEvtBase = event_base_new(); if (!gstEvtBase) { logerr("Could not initialize libevent!\n"); return -1; } memset(&sin, 0, sizeof(sin)); sin.sin_family = AF_INET; sin.sin_port = htons(m_iPort); m_stEvtlistener = evconnlistener_new_bind(gstEvtBase, accept_conn_cb, (void *)gstEvtBase, LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -1, (struct sockaddr*)&sin, sizeof(sin)); if (!m_stEvtlistener) { logerr("Could not create a listener!\n"); return -1; } evconnlistener_set_error_cb(m_stEvtlistener, accept_error_cb); m_stSigEvt = evsignal_new(gstEvtBase, SIGINT, signal_cb, (void *)gstEvtBase); if (!m_stSigEvt || event_add(m_stSigEvt, NULL)<0) { logerr("Could not create/add a signal event!\n"); return -1; } /*add tick*/ struct timeval tv; tv.tv_sec = 1; tv.tv_usec = 0; m_stTimeEvt = evtimer_new(gstEvtBase,timer_cb, (void *)this); if (!m_stTimeEvt || event_add(m_stTimeEvt, &tv)<0) { logerr("Could not create/add a time event!\n"); return -1; } return 0; }