int
main(int argc, char *argv[])
{
// TODO: Make port configurable
int port = 1234;
struct event_base *base;
struct evconnlistener *listener;
struct sockaddr_in sin;
if ((base = event_base_new()) == NULL) {
err(1, "Failed to open base event");
}
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0);
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;
}
evconnlistener_set_error_cb(listener, accept_error_cb);
event_base_dispatch(base);
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, char **argv)
{
printf("Server based on LibEvent PID -- %d.\n", getpid());
struct event_base *base = event_base_new();
// Set address
struct sockaddr_in serv_addr;
memset(&serv_addr, '\0', sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); // 0.0.0.0 (INADDR_LOOPBACK - 127.0.0.1)
// Change bytes order to network'
int nport = htons((int)PORTNUM);
serv_addr.sin_port = nport;
struct evconnlistener *listener = evconnlistener_new_bind(
base,
accept_conn_callback,
NULL, // Parent context
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
-1, // Backlog => means SOMAXCONN
(struct sockaddr*) &serv_addr,
sizeof(serv_addr));
evconnlistener_set_error_cb(listener, accept_error_callback);
printf("Server is ready: %s\n", inet_ntoa(serv_addr.sin_addr));
event_base_dispatch(base);
return 0;
}
void server_binding()
{
char *err = NULL;
int i;
for(i = 0; i < server.bind_addr_count; i++)
{
struct server_bind *bind = &server.bind_arr[i];
bind->addr.sin_port = htons(server.port);
bind->listener = evconnlistener_new_bind(server.evbase,
server_accept_client,
(void*) bind,
LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE|LEV_OPT_CLOSE_ON_EXEC,
server.tcp_backlog,
(struct sockaddr*) &bind->addr,
sizeof(struct sockaddr_in));
if(!bind->listener)
{
err = sdscatprintf(sdsempty(), "Cann't create listener with %s", bind->addr_str);
goto binderr;
}
log_msg("Listening for client [%s:%d]", bind->addr_str, server.port);
}
return;
binderr:
log_eerr("NETWORK ERROR.");
log_eerr(">> %s", err);
sdsfree(err);
exit(1);
}
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;
}
static void* network_manager_thread_routine(void* context) {
if (NULL != context) {
printf("1\n");
struct network_manager* manager = (struct network_manager*)context;
if (NULL != manager->base && NULL == manager->listener) {
printf("2\n");
struct sockaddr_in address;
memset(&address, 0, sizeof(struct sockaddr_in));
address.sin_family = AF_INET;
address.sin_addr.s_addr = inet_addr("127.0.0.1");
address.sin_port = htons(1025);
manager->listener = evconnlistener_new_bind(manager->base,
network_manager_accept_handler, manager,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE | LEV_OPT_THREADSAFE,
-1, (struct sockaddr*)&address, sizeof(struct sockaddr_in));
if (NULL != manager->listener) {
printf("3\n");
evconnlistener_set_error_cb(manager->listener, network_manager_accept_error_handler);
event_base_dispatch(manager->base);
printf("4\n");
}
}
}
return ((void*)0);
}
void server_rl_binding()
{
char *err = NULL;
if(!server.req_log_uds)
return;
unlink(server.req_log_uds);
struct server_bind_rl *bind = &server.bind_rl;
bind->addr.sun_family = AF_UNIX;
strcpy(bind->addr.sun_path, server.req_log_uds);
bind->listener = evconnlistener_new_bind(server.evbase,
server_accept_log_client,
(void*) bind,
LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE|LEV_OPT_CLOSE_ON_EXEC,
-1,
(struct sockaddr*) &bind->addr,
sizeof(struct sockaddr_un));
if(!bind->listener)
{
err = sdscatprintf(sdsempty(), "Cann't create request log domain socket on %s", server.req_log_uds);
goto binderr;
}
log_msg("Listening for request log [%s]", server.req_log_uds);
return;
binderr:
log_eerr("ERROR.");
log_eerr("%s", err);
sdsfree(err);
exit(1);
}
// Initializes event-driven connection listener on 127.0.0.1:port,
// with given accept and error callbacks.
// Returns pointer to listener or 0 on error
struct evconnlistener *listener_init_local(struct event_base *base, int port,
evconnlistener_cb accept_cb, void *state,
evconnlistener_errorcb error_cb /* optional */)
{
if (error_cb == NULL) {
error_cb = listener_default_error_cb;
}
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0x7f000001); // i.e., 127.0.0.1
sin.sin_port = htons(port);
struct evconnlistener *listener;
listener = evconnlistener_new_bind(base, accept_cb, state,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1,
(struct sockaddr*)&sin, sizeof(sin));
if (!listener) {
return 0;
}
evconnlistener_set_error_cb(listener, error_cb);
char addr[255];
address_to_string(&sin, addr, sizeof(addr));
LogInfo("listener", "Listening on %s", addr);
return listener;
}
void main(int argc, char **argv)
{
int server_addrlen;
struct evconnlistener *listener;
base = event_base_new();
if (!base) {
perror("event_base_new()");
exit(1);
}
memset(&client_addr, 0, sizeof(client_addr));
memset(&server_addr, 0, sizeof(server_addr));
client_addrlen = sizeof(client_addr);
server_addrlen = sizeof(server_addr);
evutil_parse_sockaddr_port(argv[1], (struct sockaddr*)&server_addr, &server_addrlen);
evutil_parse_sockaddr_port(argv[2], (struct sockaddr*)&client_addr, &client_addrlen);
listener = evconnlistener_new_bind(base, accept_cb, NULL,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_CLOSE_ON_EXEC|LEV_OPT_REUSEABLE,
-1, (struct sockaddr*)&server_addr, server_addrlen);
event_base_dispatch(base);
evconnlistener_free(listener);
event_base_free(base);
}
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 **argv)
{
SSL_CTX *ctx;
struct evconnlistener *listener;
struct event_base *evbase;
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(9999);
sin.sin_addr.s_addr = htonl(0x7f000001); /* 127.0.0.1 */
ctx = evssl_init();
if (ctx == NULL)
return 1;
evbase = event_base_new();
listener = evconnlistener_new_bind(
evbase, ssl_acceptcb, (void *)ctx,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, 1024,
(struct sockaddr *)&sin, sizeof(sin));
event_base_loop(evbase, 0);
evconnlistener_free(listener);
SSL_CTX_free(ctx);
return 0;
}
//server_t* server_init(struct sockaddr_in *listen_addr)
server_t* server_init(int port)
{
log_debug(__FILE__, __LINE__, "Open server socket. Port : %d", port);
server_t *server = calloc(sizeof(server_t), 1);
// set address
server->addr = calloc(sizeof(struct sockaddr_in), 1);
server->addr->sin_family = AF_INET;
server->addr->sin_addr.s_addr = INADDR_ANY;
server->addr->sin_port = htons(port);
server->evbase = event_base_new();
if(!server->evbase)
{
log_err(__FILE__, __LINE__, "Cannot init event base.");
return NULL;
}
server->evlistener = evconnlistener_new_bind(server->evbase, server_event_accept, (void *)server, LEV_OPT_REUSEABLE | LEV_OPT_CLOSE_ON_FREE, -1, (struct sockaddr*)server->addr, sizeof(struct sockaddr_in));
if(!server->evlistener)
{
log_err(__FILE__, __LINE__, "Cannot init event listener. error : %s", evutil_socket_error_to_string(errno));
return NULL;
}
evconnlistener_set_error_cb(server->evlistener, server_event_error2);
return server;
}
int main() {
//SIGPIPE ignore
struct sigaction act;
act.sa_handler = SIG_IGN;
if (sigaction(SIGPIPE, &act, NULL) == 0) {
LOG("SIGPIPE ignore");
}
//initialize
setbuf(stdout, NULL);
base = event_base_new();
assert(base);
struct sockaddr_in srvaddr;
srvaddr.sin_family = AF_INET;
srvaddr.sin_addr.s_addr = INADDR_ANY;
srvaddr.sin_port = htons(10086);
listener = evconnlistener_new_bind(base, listencb, NULL, LEV_OPT_REUSEABLE | LEV_OPT_CLOSE_ON_FREE, 500, (const struct sockaddr*)&srvaddr, sizeof(struct sockaddr));
assert(listener);
event_base_dispatch(base);
LOG("loop exit");
evconnlistener_free(listener);
event_base_free(base);
return 0;
}
void Conn::run()
{
if(conn_type & CONN_TYPE_LISTENER)
{
this->pEvbase = event_base_new();
struct evconnlistener* pEvConn = evconnlistener_new_bind(this->pEvbase,
OnConnListenerCb,
(void*)this,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
-1,
(struct sockaddr*)&sAddrIn,
sizeof(struct sockaddr_in));
if(!pEvConn)
{
LOG_DEBUG("server on " << addr << ":" << ntohs(sAddrIn.sin_port) << " fail");
return;
}
LOG_DEBUG("server on " << addr << ":" << ntohs(sAddrIn.sin_port));
evconnlistener_set_error_cb(pEvConn, OnConnListenerErrCb);
event_base_dispatch(this->pEvbase);
return;
}
if(conn_type & CONN_TYPE_CONNECTER)
{
this->pEvbase = event_base_new();
this->pConnEvBuf = bufferevent_socket_new(this->pEvbase, -1, BEV_OPT_CLOSE_ON_FREE);
bufferevent_setcb(this->pConnEvBuf, OnReadCbAddr, NULL, OnConnEventCb, (void*)this);
if(bufferevent_socket_connect(this->pConnEvBuf, (struct sockaddr*)&sAddrIn, sizeof(struct sockaddr_in)) != 0)
{
LOG_DEBUG("conn on " << addr << ":" << ntohs(sAddrIn.sin_port) << " fail");
bufferevent_free(this->pConnEvBuf);
return;
}
LOG_DEBUG("conn on " << addr << ":" << ntohs(sAddrIn.sin_port));
struct event* pEvent = NULL;
evutil_socket_t fd = bufferevent_getfd(this->pConnEvBuf);
if(fd != -1 && OnTimingCbAddr != NULL)
{
pEvent = event_new(this->pEvbase, fd, EV_PERSIST, OnTimingEventCb, (void*)this);
event_add(pEvent, &this->tv);
}
bufferevent_enable(this->pConnEvBuf, EV_READ);
event_base_dispatch(this->pEvbase);
if(fd != -1 && OnTimingCbAddr != NULL)
{
event_del(pEvent);
}
return;
}
}
int main(int argc, char **argv) {
struct evconnlistener *listener;
struct event_base *base;
struct sockaddr_in srv_sin;
struct option long_options[] = { { "port", 1, 0, 0 } };
int32_t idx;
u_int16_t port = 0;
char c;
while (1) {
c = getopt_long(argc, argv, "", long_options, &idx);
if (c == -1)
break;
switch (c) {
case 0:
if (strcmp(long_options[idx].name, "port") == 0)
port = atoi(optarg);
break;
default:
return usage(argv[0]);
}
}
if (!port)
return usage(argv[0]);
signal(SIGPIPE, SIG_IGN);
base = event_base_new();
if (!base) {
perror("Couldn't open event base");
return -1;
}
memset(&srv_sin, 0, sizeof(srv_sin));
srv_sin.sin_family = AF_INET;
srv_sin.sin_addr.s_addr = htonl(0);
srv_sin.sin_port = htons(port);
listener = evconnlistener_new_bind(base, drone_srv_accept_success_cb,
NULL,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1, (struct sockaddr*) &srv_sin,
sizeof(srv_sin));
if (!listener) {
perror("Couldn't create listener");
return -1;
}
evconnlistener_set_error_cb(listener, drone_srv_accept_error_cb);
printf("Drone started, waiting for job...\n");
event_base_dispatch(base);
event_base_free(base);
return 0;
}
int
evhtp_bind_sockaddr(evhtp * htp, struct sockaddr * sa, size_t sin_len, int backlog) {
#ifdef SIGPIPE
signal(SIGPIPE, SIG_IGN);
#endif
htp->server = evconnlistener_new_bind(htp->evbase, _evhtp_accept_cb, (void *)htp,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
backlog, sa, sin_len);
return htp->server ? 0 : -1;
}
struct evconnlistener *init_socket_standalone(int port) {
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0);
sin.sin_port = htons(port);
return evconnlistener_new_bind(base, cb_new_connection, NULL,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1, (struct sockaddr*) &sin,
sizeof(sin));
}
static void watch_service_cb(neuworker_t *nw, struct neuhandle *nh, void *data){
struct neuservice *ns = (struct neuservice *)data;
ASSERT((nw != NULL) && (ns != NULL));
ns->ns_listen = evconnlistener_new_bind(nw->base, neuservice_accept_cb,
ns, 0, -1, (struct sockaddr*)&ns->ns_addr, sizeof(ns->ns_addr));
evconnlistener_set_error_cb(ns->ns_listen, neuservice_shutdown_cb);
ns->ns_worker = nw;
}
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;
}
int smpp_listener_start(SMPPServer *smpp_server) {
struct sockaddr_in sin;
/* Create new event base */
smpp_server->event_base = event_base_new();
if (!smpp_server->event_base) {
error(0, "Couldn't open event base");
return 1;
}
/* Clear the sockaddr before using it, in case there are extra
* platform-specific fields that can mess us up. */
memset(&sin, 0, sizeof (sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(smpp_server->smpp_port);
sin.sin_addr.s_addr = htonl(INADDR_ANY);
/* Create a new listener */
info(0, "Starting SMPP server on port %ld", smpp_server->smpp_port);
smpp_server->event_listener = evconnlistener_new_bind(smpp_server->event_base, smpp_listener_connection_callback, smpp_server,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1,
(struct sockaddr *) &sin, sizeof (sin));
if (!smpp_server->event_listener) {
panic(0,"Couldn't create listener");
return 1;
}
smpp_server->ip_blocklist = dict_create(512, (void(*)(void *))smpp_blocked_ip_destroy);
smpp_bearerbox_init(smpp_server);
smpp_esme_init(smpp_server);
smpp_queues_init(smpp_server);
evconnlistener_set_error_cb(smpp_server->event_listener, smpp_listener_accept_error_callback);
event_base_dispatch(smpp_server->event_base);
smpp_queues_shutdown(smpp_server);
smpp_esme_shutdown(smpp_server);
smpp_bearerbox_shutdown(smpp_server);
dict_destroy(smpp_server->ip_blocklist);
evconnlistener_free(smpp_server->event_listener);
event_base_free(smpp_server->event_base);
return 0;
}
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)
{
int socklen;
struct evconnlistener *listener;
if (argc < 3)
syntax();
memset(&listen_on_addr, 0, sizeof(listen_on_addr));
socklen = sizeof(listen_on_addr);
if (evutil_parse_sockaddr_port(argv[1], (struct sockaddr*)&listen_on_addr, &socklen) < 0)
{
int p = atoi(argv[1]);
struct sockaddr_in *sin = (struct sockaddr_in*)&listen_on_addr;
if (p < 1 || p > 65535)
syntax();
sin->sin_port = htons(p);
sin->sin_addr.s_addr = htonl(0x7f000001);
sin->sin_family = AF_INET;
socklen = sizeof(struct sockaddr_in);
}
memset(&connect_to_addr, 0, sizeof(connect_to_addr));
connect_to_addrlen = sizeof(connect_to_addr);
if (evutil_parse_sockaddr_port(argv[2], (struct sockaddr*)&connect_to_addr, &connect_to_addrlen) < 0)
syntax();
base = event_base_new();
if (!base) {
perror("event_base_new()");
return 1;
}
listener = evconnlistener_new_bind(base, accept_cb, NULL,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_CLOSE_ON_EXEC|LEV_OPT_REUSEABLE,
-1, (struct sockaddr*)&listen_on_addr, socklen);
if (! listener) {
fprintf(stderr, "Couldn't open listener.\n");
event_base_free(base);
return 1;
}
event_base_dispatch(base);
evconnlistener_free(listener);
event_base_free(base);
return 0;
}
int bp_server_listen(bp_server_s *server, unsigned short port)
{
struct sockaddr_in6 listensin;
memset(&listensin, 0, sizeof(listensin));
listensin.sin6_family = AF_INET6;
listensin.sin6_port = htons(port);
server->listener = evconnlistener_new_bind(server->program->eventbase, accept_conn_cb, server, LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -1, (struct sockaddr*)&listensin, sizeof(listensin));
if (!server->listener) {
write_log(5, "Failed to listen on port %u", port);
return -1;
}
return 0;
}
int
main(int argc, char **argv)
{
struct event_base *base;
struct evconnlistener *listener;
struct sockaddr_in sin;
int port = 9876;
if (argc > 1) {
port = atoi(argv[1]);
}
if (port<=0 || port>65535) {
puts("Invalid port");
return 1;
}
base = event_base_new();
if (!base) {
puts("Couldn't open event base");
return 1;
}
/* 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, base,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE|LEV_OPT_DEFERRED_ACCEPT, -1,
(struct sockaddr*)&sin, sizeof(sin));
if (!listener) {
perror("Couldn't create listener");
return 1;
}
else
{
printf("create listener success, base:%p\n", base);
}
evconnlistener_set_error_cb(listener, accept_error_cb);
event_base_dispatch(base);
return 0;
}
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;
}
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);
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0);
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;
}
//启动监听
bool MMaster::StartListen()
{
do
{
struct sockaddr_in sin;
server_base_ = event_base_new();
if (!server_base_)
break;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0);
sin.sin_port = htons(listen_port_);
//设置AcceptConn事件 监听连接信息
server_conn_listenner_ = evconnlistener_new_bind(server_base_,
AcceptConn, this, LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
-1, (struct sockaddr*) &sin, sizeof(sin));
if (!server_conn_listenner_)
break;
evconnlistener_set_error_cb(server_conn_listenner_, AcceptError);
//每个线程都在跑server_base_的事件循环
try
{
main_listen_thread_.reset(
new std::thread([this]
{
//注册定时事件，定时调用
timeval tv;
int flags = 0;
event timeout;
event_assign(&timeout, server_base_, -1, flags, timeout_cb, (void*) &timeout);
evutil_timerclear(&tv);
tv.tv_sec = 0;
tv.tv_usec = micsec;
event_add(&timeout, &tv);
evutil_gettimeofday(&lasttime, NULL);
event_base_dispatch(server_base_);
}));
}
catch (...)
{
break;
}
return true;
}
while (0);
return false;
}
int initMailListener(struct event_base* event_base, unsigned short listen_port)
{
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(listen_port);
listener = evconnlistener_new_bind(event_base, smtp_listener_cb, (void*) event_base
,LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -1
,(struct sockaddr*) &sin, sizeof(sin));
if (!listener) {
ERROR("Could not create a listener on port %d.", listen_port);
return 1;
}
write_to_log("Listening on port %d.", listen_port);
return 0;
}
int main(int argc, char **argv){
base = event_base_new();
storage_prepare();
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0);
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; }
evconnlistener_set_error_cb(listener, accept_error_cb);
event_base_dispatch(base);
return 0;
}
int main(int argc, char *argv[])
{
FLAGS_log_dir = "./log";
// FLAGS_logtostderr = true;
FLAGS_minloglevel = 1;
google::InitGoogleLogging(argv[0]);
int port = 8888;
if (argc > 1) {
port = atoi(argv[1]);
}
if (port <=0 || port > 65545) {
puts("Invaild port");
return -1;
}
struct event_base *base;
base = event_base_new();
if (!base) {
LOG(ERROR) << "Couldn't open event base";
return -1;
}
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0);
sin.sin_port = htons(port);
struct evconnlistener *listener;
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) {
LOG(ERROR) << "Could't create listener";
return -1;
}
evconnlistener_set_error_cb(listener, accept_error_cb);
event_base_dispatch(base);
return 0;
}
