static void
tr_watchdir_win32_free (tr_watchdir_backend * backend_base)
{
tr_watchdir_win32 * const backend = BACKEND_UPCAST (backend_base);
if (backend == NULL)
return;
assert (backend->base.free_func == &tr_watchdir_win32_free);
if (backend->fd != INVALID_HANDLE_VALUE)
CancelIoEx (backend->fd, &backend->overlapped);
if (backend->thread != NULL)
{
WaitForSingleObject (backend->thread, INFINITE);
CloseHandle (backend->thread);
}
if (backend->event != NULL)
bufferevent_free (backend->event);
if (backend->notify_pipe[0] != TR_BAD_SOCKET)
evutil_closesocket (backend->notify_pipe[0]);
if (backend->notify_pipe[1] != TR_BAD_SOCKET)
evutil_closesocket (backend->notify_pipe[1]);
if (backend->fd != INVALID_HANDLE_VALUE)
CloseHandle (backend->fd);
tr_free (backend);
}
static void GuNET_Server_Client_onConnect(evutil_socket_t fd, short event,
void * serv) {
GuNET_Server_Client_t * client;
GuNET_Server_t * server = (GuNET_Server_t *) serv;
struct sockaddr_storage ss;
#ifdef _WIN32
int slen = sizeof(ss);
#else
socklen_t slen = sizeof(ss);
#endif
struct bufferevent * bev;
int clientfd = accept(fd, (struct sockaddr *) &ss, &slen);
if (clientfd < 0) {
} else if (clientfd > FD_SETSIZE) {
if (OUTPUTERROR)
fprintf(stderr, "[GuNET_Server] clientfd > FD_SETSIZE");
evutil_closesocket(clientfd);
return;
} else {
client = malloc(sizeof(GuNET_Server_Client_t));
if (!client) {
if (OUTPUTERROR)
fprintf(stderr,
"[GuNET_Server] Failed to malloc for new client.");
evutil_closesocket(clientfd);
return;
}
evutil_make_socket_nonblocking(clientfd);
bev = bufferevent_socket_new(server->base, clientfd,
BEV_OPT_CLOSE_ON_FREE);
if (!bev) {
if (OUTPUTERROR)
fprintf(stderr, "[GuNET_Server] Failed to malloc bufferevent.");
free(client);
evutil_closesocket(clientfd);
return;
}
bufferevent_setcb(bev, GuNET_Server_Client_onRead, NULL,
GuNET_Server_Client_onError, serv);
bufferevent_setwatermark(bev, EV_READ, 0, MAX_LINE);
bufferevent_enable(bev, EV_READ | EV_WRITE | EV_PERSIST);
client->fd = clientfd;
client->bev = bev;
client->server = server;
client->length = 0;
client->key = NULL;
client->userdata = server->userdata;
client->next = NULL;
client->prev = GuNET_Server_getLastClient(server);
if (!client->prev)
server->clients = client;
else
client->prev->next = client;
if (server->onConnect)
server->onConnect(client, client->userdata);
}
}
/* Internal wrapper around 'socket' to provide Linux-style support for
* syscall-saving methods where available.
*
* In addition to regular socket behavior, you can use a bitwise or to set the
* flags EVUTIL_SOCK_NONBLOCK and EVUTIL_SOCK_CLOEXEC in the 'type' argument,
* to make the socket nonblocking or close-on-exec with as few syscalls as
* possible.
*/
evutil_socket_t
socket_with_flags(int domain, int type, int protocol)
{
evutil_socket_t r;
#if defined(SOCK_NONBLOCK) && defined(SOCK_CLOEXEC)
r = socket(domain, type, protocol);
if (r >= 0)
return r;
else if ((type & (SOCK_NONBLOCK|SOCK_CLOEXEC)) == 0)
return -1;
#endif
#define SOCKET_TYPE_MASK (~(SOCK_NONBLOCK|SOCK_CLOEXEC))
r = socket(domain, type & SOCKET_TYPE_MASK, protocol);
if (r < 0)
return -1;
if (type & SOCK_NONBLOCK) {
if (evutil_fast_socket_nonblocking(r) < 0) {
evutil_closesocket(r);
return -1;
}
}
if (type & SOCK_CLOEXEC) {
if (evutil_fast_socket_closeonexec(r) < 0) {
evutil_closesocket(r);
return -1;
}
}
return r;
}
int neuworker_init(neuworker_t *nw, void *data){
ASSERT(nw != NULL);
nw->base = event_base_new();
if(!nw->base)
return -1;
if(!evutil_socketpair(AF_LOCAL, SOCK_STREAM, 0, nw->socks)){
event_base_free(nw->base);
return -1;
}
evutil_make_socket_nonblocking(nw->socks[0]);
evutil_make_socket_nonblocking(nw->socks[1]);
nw->evsock = event_new(nw->base, nw->socks[0], EV_READ, neuworker_sockcb, nw);
if(nw->evsock == NULL){
event_base_free(nw->base);
evutil_closesocket(nw->socks[0]);
evutil_closesocket(nw->socks[1]);
return -1;
}
event_add(nw->evsock, NULL);
pthread_mutex_init(&nw->lock, NULL);
nw->data = data;
return 0;
}
void
hub_uninit(struct hub *hub)
{
struct peer *ptr = hub->peers;
tnt_tun_iface_set_status(&hub->tun, TNT_STATUS_ALL_DOWN);
tnt_tun_close(&hub->tun);
if (hub->tun.interface) {
free(hub->tun.interface);
}
evutil_closesocket(event_get_fd(hub->levent));
evutil_closesocket(event_get_fd(hub->ievent));
event_free(hub->levent);
event_free(hub->ievent);
while (ptr)
{
struct peer *tmp = ptr->next;
free(ptr->addr);
free(ptr);
ptr = tmp;
}
}
static int
basic_test_cleanup(const struct testcase_t *testcase, void *ptr)
{
struct basic_test_data *data = ptr;
if (testcase->flags & TT_NO_LOGS)
event_set_log_callback(NULL);
if (testcase->flags & TT_NEED_SOCKETPAIR) {
if (data->pair[0] != -1)
evutil_closesocket(data->pair[0]);
if (data->pair[1] != -1)
evutil_closesocket(data->pair[1]);
}
if (testcase->flags & TT_NEED_DNS) {
evdns_shutdown(0);
}
if (testcase->flags & TT_NEED_BASE) {
if (data->base) {
event_base_assert_ok(data->base);
event_base_free(data->base);
}
}
free(data);
return 1;
}
static struct timeval *
run_once(int num_pipes)
{
int i;
evutil_socket_t *cp;
static struct timeval ts, te, tv_timeout;
events = (struct event *)calloc(num_pipes, sizeof(struct event));
pipes = (evutil_socket_t *)calloc(num_pipes * 2, sizeof(evutil_socket_t));
if (events == NULL || pipes == NULL) {
perror("malloc");
exit(1);
}
for (cp = pipes, i = 0; i < num_pipes; i++, cp += 2) {
if (evutil_socketpair(AF_UNIX, SOCK_STREAM, 0, cp) == -1) {
perror("socketpair");
exit(1);
}
}
/* measurements includes event setup */
evutil_gettimeofday(&ts, NULL);
/* provide a default timeout for events */
evutil_timerclear(&tv_timeout);
tv_timeout.tv_sec = 60;
for (cp = pipes, i = 0; i < num_pipes; i++, cp += 2) {
evutil_socket_t fd = i < num_pipes - 1 ? cp[3] : -1;
event_set(&events[i], cp[0], EV_READ, read_cb,
(void *)(ev_intptr_t)fd);
event_add(&events[i], &tv_timeout);
}
fired = 0;
/* kick everything off with a single write */
if (send(pipes[1], "e", 1, 0) < 0)
perror("send");
event_dispatch();
evutil_gettimeofday(&te, NULL);
evutil_timersub(&te, &ts, &te);
for (cp = pipes, i = 0; i < num_pipes; i++, cp += 2) {
event_del(&events[i]);
evutil_closesocket(cp[0]);
evutil_closesocket(cp[1]);
}
free(pipes);
free(events);
return (&te);
}
static void
listener_read_cb(evutil_socket_t fd, short what, void *p)
{
struct evconnlistener *lev = (struct evconnlistener *)p;
int err;
evconnlistener_cb cb;
evconnlistener_errorcb errorcb;
void *user_data;
LOCK(lev);
while (1) {
struct sockaddr_storage ss;
ev_socklen_t socklen = sizeof(ss);
evutil_socket_t new_fd = evutil_accept4_(fd, (struct sockaddr*)&ss, &socklen, lev->accept4_flags);
if (new_fd < 0)
break;
if (socklen == 0) {
/* This can happen with some older linux kernels in
* response to nmap. */
evutil_closesocket(new_fd);
continue;
}
if (lev->cb == NULL) {
evutil_closesocket(new_fd);
UNLOCK(lev);
return;
}
++lev->refcnt;
cb = lev->cb;
user_data = lev->user_data;
UNLOCK(lev);
cb(lev, new_fd, (struct sockaddr*)&ss, (int)socklen,
user_data);
LOCK(lev);
if (lev->refcnt == 1) {
int freed = listener_decref_and_unlock(lev);
EVUTIL_ASSERT(freed);
return;
}
--lev->refcnt;
}
err = evutil_socket_geterror(fd);
if (EVUTIL_ERR_ACCEPT_RETRIABLE(err)) {
UNLOCK(lev);
return;
}
if (lev->errorcb != NULL) {
++lev->refcnt;
errorcb = lev->errorcb;
user_data = lev->user_data;
UNLOCK(lev);
errorcb(lev, user_data);
LOCK(lev);
listener_decref_and_unlock(lev);
} else {
event_sock_warn(fd, "Error from accept() call");
}
}
void QueryListener::onRead(bufferevent *bufEvent, void *arg) {
// Cast arg to QueryListener object
QueryListener* _this = static_cast<QueryListener*>(arg);
// Get the input from socket
evbuffer *bufInput = bufferevent_get_input(bufEvent);
// Convert it to the string
std::string data = evBufferToString(bufInput);
trim(data);
evutil_socket_t fd = bufferevent_getfd(bufEvent);
// Search for connection in the collection
auto connection = _this->connections.find(bufEvent);
// If connection contained in the collection
if (connection != _this->connections.end()) {
// Trigger success callback
std::thread thr(_this->onNew, data);
thr.detach();
// If not...
} else {
// if data equals to one of the keys
if (data == _this->userAuthKey || data == _this->clientAuthKey) {
// and if data NOT equals to the existing connection (to prevent twice connection)...
bool exists = false;
for (auto it: _this->connections) {
if (it.second->isKeyEqual(data)) {
exists = true;
}
}
// ... so the authentication is over and we are adding new connection into collection
if (!exists) {
_this->connections[bufEvent] = SharedConnWrapper(new ConnectionWrapper(bufEvent, data));
// else just close it
} else {
evutil_closesocket(fd);
}
// close socket if received data is not equal to auth messages
} else {
evutil_closesocket(fd);
}
}
}
void CSockPair::Destroy(void)
{
if (Q_INVALID_SOCK != m_ReadFD)
{
evutil_closesocket(m_ReadFD);
m_ReadFD = Q_INVALID_SOCK;
}
if (Q_INVALID_SOCK != m_WriteFD)
{
evutil_closesocket(m_WriteFD);
m_WriteFD = Q_INVALID_SOCK;
}
}
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;
}
}
setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void*)&on, sizeof(on));
if (flags & LEV_OPT_REUSEABLE) {
evutil_make_listen_socket_reuseable(fd);
}
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;
}
void CWorkThreadEvent::onMainRead(struct SockPairEventParam *pParam)
{
struct bufferevent *pBev = NULL;
Q_SOCK iFD = Q_INVALID_SOCK;
CSessionManager *pSessionManager = (CSessionManager *)(pParam->pUserDate);
while(Q_GetEventValue<Q_SOCK>(pParam->pEventBuf, iFD))
{
if (Q_INVALID_SOCK == iFD)
{
Q_Printf("%s", "invalid socket");
continue;
}
(void)evutil_make_socket_nonblocking(iFD);
pBev = bufferevent_socket_new(pParam->pMainBase, iFD,
BEV_OPT_CLOSE_ON_FREE);
if (NULL == pBev)
{
evutil_closesocket(iFD);
Q_Printf("%s", "bufferevent_socket_new error.");
continue;
}
if (Q_RTN_OK != pSessionManager->addSession(pBev))
{
evutil_closesocket(iFD);
bufferevent_free(pBev);
Q_Printf("%s", "add session error.");
continue;
}
bufferevent_setcb(pBev, workThreadReadCB, NULL, workThreadEventCB,
pSessionManager);
if (Q_RTN_OK != bufferevent_enable(pBev, EV_READ | EV_WRITE))
{
evutil_closesocket(iFD);
pSessionManager->dellSession(pBev);
bufferevent_free(pBev);
Q_Printf("%s", "bufferevent_enable error.");
continue;
}
}
}
IghtConnectionState::~IghtConnectionState(void)
{
/*
* TODO: switch to RAII.
*/
if (this->filedesc != IGHT_SOCKET_INVALID)
(void) evutil_closesocket((evutil_socket_t) this->filedesc);
if (this->bev != NULL)
bufferevent_free(this->bev);
// closing: nothing to be done
// connecting: nothing to be done
// reading: nothing to be done
if (this->address != NULL)
free(this->address);
if (this->port != NULL)
free(this->port);
if (this->addrlist != NULL)
delete (this->addrlist);
if (this->family != NULL)
free(this->family);
if (this->pflist != NULL)
delete (this->pflist);
// must_resolve_ipv4: nothing to be done
// must_resolve_ipv6: nothing to be done
}
void
fs_node_close_socket(struct fs_node* node){
if(node->socket != 0){
evutil_closesocket(node->socket);
node->socket = 0;
}
}
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;
}
void Listener::on_delete(){
MYDEBUG("delete listener");
event_del(listener);
if (this->flags & LEV_OPT_CLOSE_ON_FREE)
evutil_closesocket(event_get_fd(this->listener));
event_free(this->listener);
}
static void server_accept_callback(struct evconnlistener *lev, evutil_socket_t fd,
struct sockaddr *sa, int socklen, void *ctx)
{
(void)socklen;
struct io *io = (struct io *) ctx;
struct event_base *base = evconnlistener_get_base(lev);
struct bufferevent *bev;
debug_print(1, "client connect from [%s:%u] over fd [%d]",
inet_ntoa(((struct sockaddr_in *) sa)->sin_addr),
(unsigned short) ntohs(((struct sockaddr_in *) sa)->sin_port), fd);
bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
if (bev == NULL) {
debug_print(0, "bufferevent_socket_new() failed");
evutil_closesocket(fd);
return;
}
struct range_stream *cs = range_stream_new(io, bev);
bufferevent_setcb(bev, server_read_callback,
server_write_callback, server_event_callback, cs);
bufferevent_enable(bev, EV_READ|EV_WRITE);
//FIXME
//struct timeval tv;
//tv.tv_sec = 10;
//tv.tv_usec = 0;
//bufferevent_set_timeouts(bev, &tv, &tv);
}
void TcpClient::handleEvent(short events)
{
if (events & (BEV_EVENT_EOF | BEV_EVENT_ERROR | BEV_EVENT_TIMEOUT))
{
bufferevent_disable(_bev, EV_READ | EV_WRITE);
evutil_closesocket(getSocket());
_isConnected = false;
onDisconnected();
bufferevent_free(_bev);
_bev = NULL;
return;
}
if (events & BEV_EVENT_CONNECTED)
{
int socketError = EVUTIL_SOCKET_ERROR();
if ((socketError != ECONNREFUSED) && (socketError != ETIMEDOUT))
{
_isConnected = true;
onConnected(0);
}
else
{
onConnected(socketError);
}
}
}
int game_add_connect_event(struct sockaddr *sa, int socklen, CLIENT_MAP *client_map)
{
int ret;
struct event *event_conn = &client_map->event_recv;
int fd = 0;
fd = create_new_socket(0);
if (0 != event_assign(event_conn, base, fd, EV_READ|EV_PERSIST, cb_recv, client_map)) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s %d: event_new failed[%d]", __FUNCTION__, __LINE__, errno);
goto fail;
}
event_add(event_conn, NULL);
ret = evutil_socket_connect(&fd, sa, socklen);
if (ret < 0) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s %d: evutil_socket_connect failed[%d]", __FUNCTION__, __LINE__, errno);
goto fail;
}
game_set_socket_opt(fd);
return (fd);
fail:
if (fd > 0) {
evutil_closesocket(fd);
}
if (event_conn) {
event_del(event_conn);
}
return (-1);
}
static evutil_socket_t
createSocket (int family, int nonblock)
{
evutil_socket_t fd;
int ret;
fd = socket (family, SOCK_STREAM, 0);
if (fd < 0) {
ccnet_warning("create Socket failed %d\n", fd);
} else if (nonblock) {
int nodelay = 1;
fd = makeSocketNonBlocking( fd );
ret = setsockopt (fd, IPPROTO_TCP, TCP_NODELAY,
(char *)&nodelay, sizeof(nodelay));
if (ret < 0) {
ccnet_warning("setsockopt failed\n");
evutil_closesocket(fd);
return -1;
}
}
return fd;
}
evutil_socket_t
ccnet_net_open_tcp (const struct sockaddr *sa, int nonblock)
{
evutil_socket_t s;
int sa_len;
if( (s = createSocket(sa->sa_family, nonblock)) < 0 )
return -1;
#ifndef WIN32
if (sa->sa_family == AF_INET)
sa_len = sizeof (struct sockaddr_in);
else
sa_len = sizeof (struct sockaddr_in6);
#else
if (sa->sa_family == AF_INET)
sa_len = sizeof (struct sockaddr_in);
else
return -1;
#endif
if( (connect(s, sa, sa_len) < 0)
#ifdef WIN32
&& (sockerrno != WSAEWOULDBLOCK)
#endif
&& (sockerrno != EINPROGRESS) )
{
evutil_closesocket(s);
s = -1;
}
return s;
}
static void
socks_accept_cb(struct evconnlistener *lis, evutil_socket_t fd,
struct sockaddr *addr, int len, void *ptr)
{
obfsproxyssh_client_t *client = ptr;
obfsproxyssh_t *state = client->state;
obfsproxyssh_client_session_t *session;
struct sockaddr_in *sa;
char addr_buf[INET_ADDRSTRLEN];
uint32_t tmp;
assert(lis == client->listener);
/*
* It is possible to defer allocating the session object till after the
* SOCKS protocol handling is done, but there isn't much point in doing
* so.
*/
session = calloc(1, sizeof(obfsproxyssh_client_session_t));
if (NULL == session) {
log_f(state, "SOCKS: Error: Failed to allocate session");
goto out_close;
}
session->socks_ev = bufferevent_socket_new(state->base, fd,
BEV_OPT_CLOSE_ON_FREE);
if (NULL == session->socks_ev) {
log_f(state, "SOCKS: Error: Failed to allocate bev");
free(session);
goto out_close;
}
bufferevent_setcb(session->socks_ev, socks_read_cb, NULL,
socks_event_cb, session);
bufferevent_enable(session->socks_ev, EV_READ | EV_WRITE);
sa = (struct sockaddr_in *) addr;
if (0 == state->unsafe_logging) {
tmp = ntohl(sa->sin_addr.s_addr);
tmp &= 0x000000ff;
session->socks_addr = bformat("xxx.xxx.xxx.%d:%d", tmp,
ntohs(sa->sin_port));
} else {
evutil_inet_ntop(AF_INET, &sa->sin_addr, addr_buf,
INET_ADDRSTRLEN);
session->socks_addr = bformat("%s:%d", addr_buf,
ntohs(sa->sin_port));
}
/* TODO: Set the timeout */
LIST_INSERT_HEAD(&client->sessions, session, entries);
session->client = client;
log_f(state, "SOCKS: %s Connect", bdata(session->socks_addr));
return;
out_close:
evutil_closesocket(fd);
}
static int
iocp_listener_disable_impl(struct evconnlistener *lev, int shutdown)
{
int i;
struct evconnlistener_iocp *lev_iocp =
EVUTIL_UPCAST(lev, struct evconnlistener_iocp, base);
LOCK(lev);
iocp_listener_event_del(lev_iocp);
for (i = 0; i < lev_iocp->n_accepting; ++i) {
struct accepting_socket *as = lev_iocp->accepting[i];
if (!as)
continue;
EnterCriticalSection(&as->lock);
if (!as->free_on_cb && as->s != INVALID_SOCKET) {
if (shutdown)
as->free_on_cb = 1;
stop_accepting(as);
}
LeaveCriticalSection(&as->lock);
}
if (shutdown && lev->flags & LEV_OPT_CLOSE_ON_FREE)
evutil_closesocket(lev_iocp->fd);
UNLOCK(lev);
return 0;
}
static void accept_conn_cb(struct evconnlistener *listener, evutil_socket_t fd,
struct sockaddr *address, int socklen, void* ctx)
{
struct sockaddr_in6 sin;
struct sockaddr_in6 *sinp;
if (address->sa_family == AF_INET6) {
sinp = (struct sockaddr_in6*)address;
}
else if (address->sa_family == AF_INET) {
sin = bp_in4to6((struct sockaddr_in*)address);
socklen = sizeof(sin);
sinp = &sin;
}
else {
write_log(4, "Unable to handle incoming connection: unknown address family");
evutil_closesocket(fd);
return;
}
write_log(2, "Incoming connection");
bp_server_s *server = ctx;
bp_connection_s *conn = malloc(sizeof(bp_connection_s));
if (bp_connection_init_socket(conn, server, sinp, socklen, fd) < 0) {
bp_connection_free(conn);
}
}
int NetServer::ServerThread(void* param) {
event_base_dispatch(net_evbase);
for(auto bit = users.begin(); bit != users.end(); ++bit) {
bufferevent_disable(bit->first, EV_READ);
bufferevent_free(bit->first);
}
users.clear();
evconnlistener_free(listener);
listener = 0;
if(broadcast_ev) {
evutil_socket_t fd;
event_get_assignment(broadcast_ev, 0, &fd, 0, 0, 0);
evutil_closesocket(fd);
event_free(broadcast_ev);
broadcast_ev = 0;
}
if(duel_mode) {
event_free(duel_mode->etimer);
delete duel_mode;
}
duel_mode = 0;
event_base_free(net_evbase);
net_evbase = 0;
return 0;
}
void TcpSession::handleEvent(short events)
{
bufferevent_disable(_bev, EV_READ | EV_WRITE);
evutil_closesocket(getSocket());
_dispatcher->getServer()->onSessionDisconnected(this);
_dispatcher->removeSession(getId());
}
int neuworker_fini(neuworker_t *nw){
ASSERT(nw != NULL);
if(!nw->base)
return 0;
event_base_loopbreak(nw->base);
event_base_free(nw->base);
nw->base = NULL;
evutil_closesocket(nw->socks[0]);
evutil_closesocket(nw->socks[1]);
pthread_mutex_destroy(&nw->lock);
return 0;
}
void CServerLinker::closeSock(void)
{
if (Q_INVALID_SOCK != m_Sock)
{
evutil_closesocket(m_Sock);
m_Sock = Q_INVALID_SOCK;
}
}
void
regress_clean_dnsserver(void)
{
if (dns_port)
evdns_close_server_port(dns_port);
if (dns_sock >= 0)
evutil_closesocket(dns_sock);
}
void
ccnet_packet_io_free (CcnetPacketIO *io)
{
evutil_closesocket(io->fd);
buffer_free (io->buffer);
buffer_free (io->in_buf);
g_free (io);
}
