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