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;
}
