evutil_socket_t bind_socket_ai_(struct evutil_addrinfo* ai, int reuse) {
evutil_socket_t fd;
int on = 1, r;
int serrno;
fd = socket(ai ? ai->ai_family : AF_INET, SOCK_STREAM, 0);
if (fd == -1)
return -1;
if (evutil_make_socket_nonblocking(fd) < 0)
goto out;
if (evutil_make_socket_closeonexec(fd) < 0)
goto out;
setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&on, sizeof(on));
if (reuse)
evutil_make_listen_socket_reuseable(fd);
if (ai != NULL) {
r = bind(fd, ai->ai_addr, (ev_socklen_t)ai->ai_addrlen);
if (r == -1)
goto out;
}
return (fd);
out:
serrno = EVUTIL_SOCKET_ERROR();
evutil_closesocket(fd);
EVUTIL_SET_SOCKET_ERROR(serrno);
return -1;
}
struct evconnlistener *
evconnlistener_new_bind(struct event_base *base, evconnlistener_cb cb,
void *ptr, unsigned flags, int backlog, const struct sockaddr *sa,
int socklen)
{
struct evconnlistener *listener;
evutil_socket_t fd;
int on = 1;
int family = sa ? sa->sa_family : AF_UNSPEC;
if (backlog == 0)
return NULL;
fd = socket(family, SOCK_STREAM, 0);
if (fd == -1)
return NULL;
if (evutil_make_socket_nonblocking(fd) < 0) {
evutil_closesocket(fd);
return NULL;
}
if (flags & LEV_OPT_CLOSE_ON_EXEC) {
if (evutil_make_socket_closeonexec(fd) < 0) {
evutil_closesocket(fd);
return NULL;
}
}
if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void*)&on, sizeof(on))<0) {
evutil_closesocket(fd);
return NULL;
}
if (flags & LEV_OPT_REUSEABLE) {
if (evutil_make_listen_socket_reuseable(fd) < 0) {
evutil_closesocket(fd);
return NULL;
}
}
if (sa) {
if (bind(fd, sa, socklen)<0) {
evutil_closesocket(fd);
return NULL;
}
}
listener = evconnlistener_new(base, cb, ptr, flags, backlog, fd);
if (!listener) {
evutil_closesocket(fd);
return NULL;
}
return listener;
}
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_socketpair(
AF_UNIX, SOCK_STREAM, 0, 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;
}
evutil_make_socket_closeonexec(base->sig.ev_signal_pair[0]);
evutil_make_socket_closeonexec(base->sig.ev_signal_pair[1]);
base->sig.sh_old = NULL;
base->sig.sh_old_max = 0;
base->sig.evsig_caught = 0;
memset(&base->sig.evsigcaught, 0, sizeof(sig_atomic_t)*NSIG);
evutil_make_socket_nonblocking(base->sig.ev_signal_pair[0]);
event_assign(&base->sig.ev_signal, base, base->sig.ev_signal_pair[1],
EV_READ | EV_PERSIST, evsig_cb, &base->sig.ev_signal);
base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL;
base->evsigsel = &evsigops;
base->evsigbase = &base->sig;
return 0;
}
//初始化base->sig成员
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_socketpair(
AF_UNIX, SOCK_STREAM, 0, 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;
}
evutil_make_socket_closeonexec(base->sig.ev_signal_pair[0]);//两个都设置执行时关闭
evutil_make_socket_closeonexec(base->sig.ev_signal_pair[1]);
base->sig.sh_old = NULL; //？
base->sig.sh_old_max = 0;
evutil_make_socket_nonblocking(base->sig.ev_signal_pair[0]);//设置为非阻塞
evutil_make_socket_nonblocking(base->sig.ev_signal_pair[1]);
event_assign(&base->sig.ev_signal, base, base->sig.ev_signal_pair[1],//注册了上一个函数evsig_cb为回调函数
EV_READ | EV_PERSIST, evsig_cb, base);
base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL;//sig为evsig_info类型，ev_signal为event类型。设置为内部，一直没搞懂是啥
event_priority_set(&base->sig.ev_signal, 0);//初始优先级为0
base->evsigsel = &evsigops;//设置信号处理的后端
return 0;
}
static void *
epoll_init(struct event_base *base)
{
int epfd = -1;
struct epollop *epollop;
#ifdef _EVENT_HAVE_EPOLL_CREATE1
/* First, try the shiny new epoll_create1 interface, if we have it. */
epfd = epoll_create1(EPOLL_CLOEXEC);
#endif
if (epfd == -1) {
/* Initialize the kernel queue using the old interface. (The
size field is ignored since 2.6.8.) */
if ((epfd = epoll_create(32000)) == -1) {
if (errno != ENOSYS)
event_warn("epoll_create");
return (NULL);
}
evutil_make_socket_closeonexec(epfd);
}
if (!(epollop = mm_calloc(1, sizeof(struct epollop)))) {
close(epfd);
return (NULL);
}
epollop->epfd = epfd;
/* Initialize fields */
epollop->events = mm_calloc(INITIAL_NEVENT, sizeof(struct epoll_event));
if (epollop->events == NULL) {
mm_free(epollop);
close(epfd);
return (NULL);
}
epollop->nevents = INITIAL_NEVENT;
if ((base->flags & EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST) != 0 ||
((base->flags & EVENT_BASE_FLAG_IGNORE_ENV) == 0 &&
evutil_getenv("EVENT_EPOLL_USE_CHANGELIST") != NULL))
base->evsel = &epollops_changelist;
evsig_init(base);
return (epollop);
}
int Listener::open(const struct sockaddr *sa, int socklen, int backlog){
int family = sa ? sa->sa_family : AF_UNSPEC;
if (backlog == 0)
return -1;
evutil_socket_t fd = socket(family, SOCK_STREAM, 0);
if (fd == -1)
return -1;
if (evutil_make_socket_nonblocking(fd) < 0) {
evutil_closesocket(fd);
return -1;
}
if (flags & LEV_OPT_CLOSE_ON_EXEC) {
if (evutil_make_socket_closeonexec(fd) < 0) {
evutil_closesocket(fd);
return -1;
}
}
if (setKeepAlive(fd)) {
evutil_closesocket(fd);
return -1;
}
if (flags & LEV_OPT_REUSEABLE) {
if (evutil_make_listen_socket_reuseable(fd) < 0) {
evutil_closesocket(fd);
return -1;
}
}
if (sa) {
if (bind(fd, sa, socklen)<0) {
evutil_closesocket(fd);
return -1;
}
}
int ret = this->open(fd, backlog);
if (ret <0){
evutil_closesocket(fd);
return ret;
}
return 0;
}
void attach_namespace (int client, struct arguments arguments) {
w(evutil_make_socket_closeonexec(client));
w(evutil_make_socket_nonblocking(client));
struct event_config *ev_config = p(event_config_new());
w(event_config_require_features(ev_config, EV_FEATURE_FDS));
struct event_base *ev_base = p(event_base_new_with_config(ev_config));
event_config_free(ev_config);
struct event *ev_client = p(event_new(ev_base, client, EV_READ|EV_PERSIST, client_func, NULL));
struct arg arg = { .event = ev_client, .command = arguments.command };
w(event_assign(ev_client, ev_base, client, EV_READ|EV_PERSIST, client_func, &arg));
event_add(ev_client, NULL);
w(event_base_dispatch(ev_base));
event_base_free(ev_base);
}
static void *
epoll_init(struct event_base *base)
{
int epfd;
struct epollop *epollop;
/* Initialize the kernel queue. (The size field is ignored since
* 2.6.8.) */
if ((epfd = epoll_create(32000)) == -1) {
if (errno != ENOSYS)
event_warn("epoll_create");
return (NULL);
}
evutil_make_socket_closeonexec(epfd);
if (!(epollop = mm_calloc(1, sizeof(struct epollop)))) {
close(epfd);
return (NULL);
}
epollop->epfd = epfd;
/* Initialize fields */
epollop->events = mm_calloc(INITIAL_NEVENT, sizeof(struct epoll_event));
if (epollop->events == NULL) {
mm_free(epollop);
close(epfd);
return (NULL);
}
epollop->nevents = INITIAL_NEVENT;
if ((base->flags & EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST) != 0 ||
((base->flags & EVENT_BASE_FLAG_IGNORE_ENV) == 0 &&
evutil_getenv("EVENT_EPOLL_USE_CHANGELIST") != NULL))
base->evsel = &epollops_changelist;
evsig_init(base);
return (epollop);
}
static void *
epoll_init(struct event_base *base)
{
int epfd = -1;
struct epollop *epollop;
#ifdef EVENT__HAVE_EPOLL_CREATE1
/* First, try the shiny new epoll_create1 interface, if we have it. */
epfd = epoll_create1(EPOLL_CLOEXEC);
#endif
if (epfd == -1) {
/* Initialize the kernel queue using the old interface. (The
size field is ignored since 2.6.8.) */
if ((epfd = epoll_create(32000)) == -1) {
if (errno != ENOSYS)
event_warn("epoll_create");
return (NULL);
}
evutil_make_socket_closeonexec(epfd);
}
if (!(epollop = mm_calloc(1, sizeof(struct epollop)))) {
close(epfd);
return (NULL);
}
epollop->epfd = epfd;
/* Initialize fields */
epollop->events = mm_calloc(INITIAL_NEVENT, sizeof(struct epoll_event));
if (epollop->events == NULL) {
mm_free(epollop);
close(epfd);
return (NULL);
}
epollop->nevents = INITIAL_NEVENT;
if ((base->flags & EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST) != 0 ||
((base->flags & EVENT_BASE_FLAG_IGNORE_ENV) == 0 &&
evutil_getenv_("EVENT_EPOLL_USE_CHANGELIST") != NULL)) {
base->evsel = &epollops_changelist;
}
#ifdef USING_TIMERFD
/*
The epoll interface ordinarily gives us one-millisecond precision,
so on Linux it makes perfect sense to use the CLOCK_MONOTONIC_COARSE
timer. But when the user has set the new PRECISE_TIMER flag for an
event_base, we can try to use timerfd to give them finer granularity.
*/
if ((base->flags & EVENT_BASE_FLAG_PRECISE_TIMER) &&
base->monotonic_timer.monotonic_clock == CLOCK_MONOTONIC) {
int fd;
fd = epollop->timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
if (epollop->timerfd >= 0) {
struct epoll_event epev;
memset(&epev, 0, sizeof(epev));
epev.data.fd = epollop->timerfd;
epev.events = EPOLLIN;
if (epoll_ctl(epollop->epfd, EPOLL_CTL_ADD, fd, &epev) < 0) {
event_warn("epoll_ctl(timerfd)");
close(fd);
epollop->timerfd = -1;
}
} else {
if (errno != EINVAL && errno != ENOSYS) {
/* These errors probably mean that we were
* compiled with timerfd/TFD_* support, but
* we're running on a kernel that lacks those.
*/
event_warn("timerfd_create");
}
epollop->timerfd = -1;
}
} else {
epollop->timerfd = -1;
}
#endif
evsig_init_(base);
return (epollop);
}
void TNonblockingIOThread::createNotificationPipe() {
if(evutil_socketpair(AF_LOCAL, SOCK_STREAM, 0, notificationPipeFDs_) == -1) {
GlobalOutput.perror("TNonblockingServer::createNotificationPipe ", EVUTIL_SOCKET_ERROR());
throw TException("can't create notification pipe");
}
if(evutil_make_socket_nonblocking(notificationPipeFDs_[0])<0 ||
evutil_make_socket_nonblocking(notificationPipeFDs_[1])<0) {
::THRIFT_CLOSESOCKET(notificationPipeFDs_[0]);
::THRIFT_CLOSESOCKET(notificationPipeFDs_[1]);
throw TException("TNonblockingServer::createNotificationPipe() THRIFT_O_NONBLOCK");
}
for (int i = 0; i < 2; ++i) {
#if LIBEVENT_VERSION_NUMBER < 0x02000000
int flags;
if ((flags = THRIFT_FCNTL(notificationPipeFDs_[i], F_GETFD, 0)) < 0 ||
THRIFT_FCNTL(notificationPipeFDs_[i], F_SETFD, flags | FD_CLOEXEC) < 0) {
#else
if (evutil_make_socket_closeonexec(notificationPipeFDs_[i]) < 0) {
#endif
::THRIFT_CLOSESOCKET(notificationPipeFDs_[0]);
::THRIFT_CLOSESOCKET(notificationPipeFDs_[1]);
throw TException("TNonblockingServer::createNotificationPipe() "
"FD_CLOEXEC");
}
}
}
/**
* Register the core libevent events onto the proper base.
*/
void TNonblockingIOThread::registerEvents() {
threadId_ = Thread::get_current();
assert(eventBase_ == 0);
eventBase_ = getServer()->getUserEventBase();
if (eventBase_ == NULL) {
eventBase_ = event_base_new();
ownEventBase_ = true;
}
// Print some libevent stats
if (number_ == 0) {
GlobalOutput.printf("TNonblockingServer: using libevent %s method %s",
event_get_version(),
event_base_get_method(eventBase_));
}
if (listenSocket_ >= 0) {
// Register the server event
event_set(&serverEvent_,
listenSocket_,
EV_READ | EV_PERSIST,
TNonblockingIOThread::listenHandler,
server_);
event_base_set(eventBase_, &serverEvent_);
// Add the event and start up the server
if (-1 == event_add(&serverEvent_, 0)) {
throw TException("TNonblockingServer::serve(): "
"event_add() failed on server listen event");
}
GlobalOutput.printf("TNonblocking: IO thread #%d registered for listen.",
number_);
}
createNotificationPipe();
// Create an event to be notified when a task finishes
event_set(¬ificationEvent_,
getNotificationRecvFD(),
EV_READ | EV_PERSIST,
TNonblockingIOThread::notifyHandler,
this);
// Attach to the base
event_base_set(eventBase_, ¬ificationEvent_);
// Add the event and start up the server
if (-1 == event_add(¬ificationEvent_, 0)) {
throw TException("TNonblockingServer::serve(): "
"event_add() failed on task-done notification event");
}
GlobalOutput.printf("TNonblocking: IO thread #%d registered for notify.",
number_);
}
int main(int argc, char* argv[])
{
#if 1
// For debug with segment fault
struct sigaction sa;
sa.sa_handler = backtrace_info;
sigaction(SIGSEGV, &sa, NULL);
// ignore SIGPIPE
signal(SIGPIPE, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
signal(SIGABRT, SIG_IGN);
#endif
int opt_g = 0;
memset(&cltopt, 0, sizeof(CLT_OPT));
cltopt.C_TYPE = C_USR;
while( (opt_g = getopt(argc, argv, "Dh")) != -1 )
{
switch(opt_g)
{
case 'D':
cltopt.C_TYPE = C_DAEMON;
break;
case 'h':
default:
usage();
exit(EXIT_SUCCESS);
}
}
if(load_settings_client(&cltopt) == RET_NO)
{
st_d_error("加载配置文件settings.json出错！");
exit(EXIT_FAILURE);
}
OpenSSL_add_ssl_algorithms();
SSL_load_error_strings();
SSL_library_init(); //SSL_library_init() always returns "1"
//int sd_id128_from_string(const char *s, sd_id128_t *ret);
sd_id128_get_machine(&cltopt.mach_uuid);
gethostname(cltopt.hostname, sizeof(cltopt.hostname));
st_d_print("CURRENT MACH_ID:%s, HOSTNAME:%s", SD_ID128_CONST_STR(cltopt.mach_uuid),
cltopt.hostname);
if (cltopt.C_TYPE == C_DAEMON)
{
cltopt.session_uuid = cltopt.mach_uuid;
st_d_print("PLEASE REMEMEBER SET MACH_ID FOR USER TYPE!");
}
dump_clt_opts(&cltopt);
/*带配置产生event_base对象*/
struct event_config *cfg;
cfg = event_config_new();
event_config_avoid_method(cfg, "select"); //避免使用select
event_config_require_features(cfg, EV_FEATURE_ET); //使用边沿触发类型
base = event_base_new_with_config(cfg);
event_config_free(cfg);
st_d_print("当前复用Event模式: %s", event_base_get_method(base)); // epoll
/*连接服务器*/
int srv_fd = socket(AF_INET, SOCK_STREAM, 0);
unsigned int optval = 1;
setsockopt(srv_fd, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(optval));//禁用NAGLE算法
if(sc_connect_srv(srv_fd) != RET_YES)
{
SYS_ABORT("连接服务器失败！");
}
if(cltopt.C_TYPE == C_DAEMON)
{
if (sc_daemon_init_srv(srv_fd) != RET_YES)
SYS_ABORT("(Daemon) 服务器返回错误！");
}
else
{
if (sc_usr_init_srv(srv_fd) != RET_YES)
SYS_ABORT("(Usr) 服务器返回错误！");
}
st_d_print("客户端连接服务器OK！");
/**
* USR 建立本地Listen侦听套接字
*/
if (cltopt.C_TYPE == C_USR)
{
int i = 0;
for (i=0; i<MAX_PORT_NUM; i++)
{
if (cltopt.maps[i].usrport)
{
struct evconnlistener *listener;
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(cltopt.maps[i].usrport); /* Port Num */
listener = evconnlistener_new_bind(base, accept_conn_cb, &cltopt.maps[i],
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1/*backlog 连接无限制*/,
(struct sockaddr*)&sin, sizeof(sin));
if (!listener)
{
st_d_error("[USR]创建侦听套接字失败 %d:%d",
cltopt.maps[i].usrport, cltopt.maps[i].daemonport);
continue;
}
evconnlistener_set_error_cb(listener, accept_error_cb);
st_d_print("[USR]创建侦听套接字 %d:%d OK",
cltopt.maps[i].usrport, cltopt.maps[i].daemonport);
}
else
break;
}
}
encrypt_init(SD_ID128_CONST_STR(cltopt.mach_uuid), cltopt.enc_key);
if (cltopt.C_TYPE == C_DAEMON && cltopt.ss5_port )
{
/**
* 目前只考虑将sockets5代理使用线程池来处理，其它的端口暴露
* 基本都是长连接，不单独处理
*/
cltopt.thread_num = 5;
cltopt.main_thread_id = pthread_self();
cltopt.thread_objs = (P_THREAD_OBJ)calloc(sizeof(THREAD_OBJ), cltopt.thread_num);
if (!cltopt.thread_objs)
{
SYS_ABORT("申请THREAD_OBJ出错");
}
sc_create_ss5_worker_threads(cltopt.thread_num, cltopt.thread_objs);
st_d_print("[DAEMON]创建sockets5代理端口：%d", cltopt.ss5_port);
struct evconnlistener *listener;
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(cltopt.ss5_port); /* Port Num */
listener = evconnlistener_new_bind(base, ss5_accept_conn_cb, NULL,
LEV_OPT_LEAVE_SOCKETS_BLOCKING/* 阻塞 */|LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE,
-1/*backlog 连接无限制*/,
(struct sockaddr*)&sin, sizeof(sin));
if (!listener)
{
st_d_error("[DAEMON]sockets5代理创建侦听套接字失败 %d", cltopt.ss5_port);
exit(EXIT_FAILURE);
}
evconnlistener_set_error_cb(listener, accept_error_cb);
st_d_print("[DAEMON]sockets5代理创建侦听套接字OK %d", cltopt.ss5_port);
}
if (cltopt.C_TYPE == C_DAEMON && cltopt.dns_port)
{
st_d_print("[DAEMON]创建DNS代理端口：%d", cltopt.dns_port);
if (cltopt.dns_port != 53)
{
st_d_print("[DAEMON]请注意标准DNS侦听#53端口！");
}
int dns_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (dns_socket < 0 )
{
st_d_error("Create DNS socket error!");
exit(EXIT_FAILURE);
}
unsigned int optval = 1;
setsockopt(dns_socket, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(optval));//禁用NAGLE算法
setsockopt(dns_socket, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof(optval));
evutil_make_socket_closeonexec(dns_socket);
evutil_make_socket_nonblocking(dns_socket);
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(cltopt.dns_port); /* Port Num */
if (bind(dns_socket, (struct sockaddr *)&sin, sizeof(sin)))
{
st_d_error("Bind DNS socket error!");
exit(EXIT_FAILURE);
}
cltopt.dns_transid_port_map = (unsigned short*)malloc(sizeof(unsigned short) * 0xFFFF);
if (!cltopt.dns_transid_port_map)
{
st_d_error("Malloc for requestid-port failed!");
exit(EXIT_FAILURE);
}
P_PORTTRANS p_trans = sc_create_trans(cltopt.dns_port);
if (!p_trans)
{
st_d_error("本地无空闲TRANS!");
exit(EXIT_FAILURE);
}
p_trans->is_enc = 1;
p_trans->l_port = cltopt.dns_port;
encrypt_ctx_init(&p_trans->ctx_enc, p_trans->l_port, cltopt.enc_key, 1);
encrypt_ctx_init(&p_trans->ctx_dec, p_trans->l_port, cltopt.enc_key, 0);
// 建立DNS UDP事件侦听
p_trans->extra_ev = event_new(base, dns_socket, EV_READ | EV_PERSIST,
dns_client_to_proxy_cb, p_trans);
int dns_srv_fd = socket(AF_INET, SOCK_STREAM, 0);
if(sc_connect_srv(dns_srv_fd) != RET_YES)
{
SYS_ABORT("连接服务器失败！");
}
sc_daemon_dns_init_srv(dns_srv_fd, p_trans->l_port, 12333);
evutil_make_socket_nonblocking(dns_srv_fd);
// later enabled
//event_add(p_trans->extra_ev, NULL) != 0);
p_trans->srv_bev = bufferevent_socket_new(base, dns_srv_fd, BEV_OPT_CLOSE_ON_FREE);
bufferevent_setcb(p_trans->srv_bev, dns_bufferread_cb_enc, NULL, dns_bufferevent_cb, p_trans);
st_d_print("[DAEMON]DNS代理创建侦听套接字OK %d", cltopt.dns_port);
}
sc_set_eventcb_srv(srv_fd, base);
/**
* Main Loop Here
*/
event_base_loop(base, 0);
event_base_free(base);
st_d_print("程序退出！！！！");
return 0;
}
void TNonblockingIOThread::createNotificationPipe() {
if(evutil_socketpair(AF_LOCAL, SOCK_STREAM, 0, notificationPipeFDs_) == -1) {
GlobalOutput.perror("TNonblockingServer::createNotificationPipe ", EVUTIL_SOCKET_ERROR());
throw TException("can't create notification pipe");
}
if(evutil_make_socket_nonblocking(notificationPipeFDs_[0])<0 ||
evutil_make_socket_nonblocking(notificationPipeFDs_[1])<0) {
::close(notificationPipeFDs_[0]);
::close(notificationPipeFDs_[1]);
throw TException("TNonblockingServer::createNotificationPipe() O_NONBLOCK");
}
for (int i = 0; i < 2; ++i) {
#if LIBEVENT_VERSION_NUMBER < 0x02000000
int flags;
if ((flags = fcntl(notificationPipeFDs_[i], F_GETFD, 0)) < 0 ||
fcntl(notificationPipeFDs_[i], F_SETFD, flags | FD_CLOEXEC) < 0) {
#else
if (evutil_make_socket_closeonexec(notificationPipeFDs_[i]) < 0) {
#endif
::close(notificationPipeFDs_[0]);
::close(notificationPipeFDs_[1]);
throw TException("TNonblockingServer::createNotificationPipe() "
"FD_CLOEXEC");
}
}
}
/**
* Register the core libevent events onto the proper base.
*/
void TNonblockingIOThread::registerEvents() {
if (listenSocket_ >= 0) {
// Register the server event
event_set(&serverEvent_,
listenSocket_,
EV_READ | EV_PERSIST,
TNonblockingIOThread::listenHandler,
server_);
event_base_set(eventBase_, &serverEvent_);
// Add the event and start up the server
if (-1 == event_add(&serverEvent_, 0)) {
throw TException("TNonblockingServer::serve(): "
"event_add() failed on server listen event");
}
GlobalOutput.printf("TNonblocking: IO thread #%d registered for listen.",
number_);
}
createNotificationPipe();
// Create an event to be notified when a task finishes
event_set(¬ificationEvent_,
getNotificationRecvFD(),
EV_READ | EV_PERSIST,
TNonblockingIOThread::notifyHandler,
this);
// Attach to the base
event_base_set(eventBase_, ¬ificationEvent_);
// Add the event and start up the server
if (-1 == event_add(¬ificationEvent_, 0)) {
throw TException("TNonblockingServer::serve(): "
"event_add() failed on task-done notification event");
}
GlobalOutput.printf("TNonblocking: IO thread #%d registered for notify.",
number_);
}
bool TNonblockingIOThread::notify(TNonblockingServer::TConnection* conn) {
int fd = getNotificationSendFD();
if (fd < 0) {
return false;
}
const int kSize = sizeof(conn);
if (send(fd, const_cast_sockopt(&conn), kSize, 0) != kSize) {
return false;
}
return true;
}
