コード例 #1
0
void Cleanup(int index)  
{  
	closesocket(g_CliSocketArr[index]);  
	WSACloseEvent(g_CliEventArr[index]);  
	if (index < g_iTotalConn-1)  
	{  
		g_CliSocketArr[index] = g_CliSocketArr[g_iTotalConn-1];  
		g_CliEventArr[index] = g_CliEventArr[g_iTotalConn-1];  
	}  
	g_iTotalConn--;  
} 
コード例 #2
0
ファイル: svrsync.cpp プロジェクト: lubing521/important-files
UINT __stdcall CSvrSyncPlug::UdpThread(LPVOID lpVoid)
{
	CSvrSyncPlug* pThis = reinterpret_cast<CSvrSyncPlug*>(lpVoid);

	SOCKET sck = socket(AF_INET, SOCK_DGRAM, 0);
	if (sck == INVALID_SOCKET)
		return 0;
	sockaddr_in addr = {0};
	addr.sin_family = AF_INET;
	addr.sin_port	= htons(5000);
	addr.sin_addr.s_addr = ADDR_ANY;
	if (SOCKET_ERROR == bind(sck, (PSOCKADDR)&addr, sizeof(addr)))
	{
		closesocket(sck);
		return 0;
	}
	int RecvBufSize = 0x10000;
	setsockopt(sck,SOL_SOCKET, SO_RCVBUF,	(char*)&RecvBufSize, sizeof(int) );
	setsockopt(sck,SOL_SOCKET, SO_SNDBUF,	(char*)&RecvBufSize, sizeof(int) );
	WSAEVENT hNetEvent = WSACreateEvent();
	if (hNetEvent == NULL || SOCKET_ERROR == WSAEventSelect(sck, hNetEvent, FD_READ))
	{
		closesocket(sck);
		return 0;
	}
	
	HANDLE hEvents[2] = {pThis->m_hExited, hNetEvent};
	while (1)
	{
		DWORD ret = WSAWaitForMultipleEvents(_countof(hEvents), hEvents, FALSE,WSA_INFINITE, FALSE);
		if (ret == WAIT_OBJECT_0)
			break;
		else if (ret == WAIT_OBJECT_0 + 1)
		{
			WSANETWORKEVENTS NetworkEvents;
			WSAEnumNetworkEvents(sck, hNetEvent, &NetworkEvents);
			if(NetworkEvents.lNetworkEvents == FD_READ && NetworkEvents.iErrorCode[FD_READ_BIT] == 0)
			{
				char data[4096] = {0};
				pkgheader* pheader = (pkgheader*)data;
				int len = recvfrom(sck, data, sizeof(data), 0, NULL, NULL);
				if (len > 0 && pheader->Length == len)
				{
					data[len] = 0;
					try {  pThis->UdpProcess(data, len); }  catch (...) {}
				}
			}
		}
		else break;
	}
	closesocket(sck);
	WSACloseEvent(hNetEvent);
	return 0;
}
コード例 #3
0
void eloop_wait_for_read_sock(int sock)
{
	WSAEVENT event;

	event = WSACreateEvent();
	if (event == WSA_INVALID_EVENT) {
		printf("WSACreateEvent() failed: %d\n", WSAGetLastError());
		return;
	}

	if (WSAEventSelect(sock, event, FD_READ)) {
		printf("WSAEventSelect() failed: %d\n", WSAGetLastError());
		WSACloseEvent(event);
		return ;
	}

	WaitForSingleObject(event, INFINITE);
	WSAEventSelect(sock, event, 0);
	WSACloseEvent(event);
}
コード例 #4
0
ファイル: ListenerImpl_Win.cpp プロジェクト: fion45/MyServer
void ListenerImpl::stopListening()
{
    ::SetEvent(hKillEvent);

    WaitForSingleObject(hThread, INFINITE);

    CloseHandle(hThread);
    CloseHandle(hKillEvent);
    closesocket(hSocket);
    WSACloseEvent(hSocketEvent);
}
コード例 #5
0
ファイル: net.cpp プロジェクト: Barosonix/AstraViewer
S32 tcp_open_channel(LLHost host)
{
	// Open a TCP channel
	// Jump through some hoops to ensure that if the request hosts is down
	// or not reachable connect() does not block

	S32 handle;
	handle = socket(AF_INET, SOCK_STREAM, 0);
	if (!handle)
	{
		llwarns << "Error opening TCP control socket, socket() returned " << handle << llendl;
		return -1;
	}

	struct sockaddr_in address;
	address.sin_port        = htons(host.getPort());
	address.sin_family      = AF_INET;
	address.sin_addr.s_addr = host.getAddress();

	// Non blocking 
	WSAEVENT hEvent=WSACreateEvent();
	WSAEventSelect(handle, hEvent, FD_CONNECT) ;
	connect(handle, (struct sockaddr*)&address, sizeof(address)) ;
	// Wait fot 5 seconds, if we can't get a TCP channel open in this
	// time frame then there is something badly wrong.
	WaitForSingleObject(hEvent, 1000*5); // 5 seconds time out

	WSANETWORKEVENTS netevents;
	WSAEnumNetworkEvents(handle,hEvent,&netevents);

	// Check the async event status to see if we connected
	if ((netevents.lNetworkEvents & FD_CONNECT) == FD_CONNECT)
	{
		if (netevents.iErrorCode[FD_CONNECT_BIT] != 0)
		{
			llwarns << "Unable to open TCP channel, WSA returned an error code of " << netevents.iErrorCode[FD_CONNECT_BIT] << llendl;
			WSACloseEvent(hEvent);
			return -1;
		}

		// Now we are connected disable non blocking
		// we don't need support an async interface as
		// currently our only consumer (socks5) will make one round
		// of packets then just hold the connection open
		WSAEventSelect(handle, hEvent, NULL) ;
		unsigned long NonBlock = 0;
		ioctlsocket(handle, FIONBIO, &NonBlock);

		return handle;
	}

	llwarns << "Unable to open TCP channel, Timeout is the host up?" << netevents.iErrorCode[FD_CONNECT_BIT] << llendl;
	return -1;
}
コード例 #6
0
ファイル: Os.c プロジェクト: broonie/ohNet
int32_t OsNetworkReceiveFrom(THandle aHandle, uint8_t* aBuffer, uint32_t aBytes, TIpAddress* aAddress, uint16_t* aPort)
{
    int32_t received;
    OsNetworkHandle* handle = (OsNetworkHandle*)aHandle;
    struct sockaddr_in addr;
    int len = sizeof(addr);
    WSAEVENT event;
    HANDLE handles[2];
    DWORD ret;

    if (SocketInterrupted(handle)) {
        return -1;
    }

    sockaddrFromEndpoint(&addr, 0, 0);

    event = WSACreateEvent();
    if (NULL == event) {
        return -1;
    }
    if (0 != WSAEventSelect(handle->iSocket, event, FD_READ|FD_CLOSE)) {
        WSACloseEvent(event);
        return -1;
    }

    received = recvfrom(handle->iSocket, (char*)aBuffer, aBytes, 0, (struct sockaddr*)&addr, &len);
    if (SOCKET_ERROR==received && WSAEWOULDBLOCK==WSAGetLastError()) {
        handles[0] = event;
        handles[1] = handle->iEvent;
        ret = WSAWaitForMultipleEvents(2, &handles[0], FALSE, INFINITE, FALSE);
        if (WAIT_OBJECT_0 == ret) {
            received = recvfrom(handle->iSocket, (char*)aBuffer, aBytes, 0, (struct sockaddr*)&addr, &len);
        }
    }

    SetSocketBlocking(handle->iSocket);
    WSACloseEvent(event);
    *aAddress = addr.sin_addr.s_addr;
    *aPort = SwapEndian16(addr.sin_port);
    return received;
}
コード例 #7
0
ファイル: eloop_win.c プロジェクト: Alkzndr/freebsd
int eloop_register_read_sock(int sock, eloop_sock_handler handler,
			     void *eloop_data, void *user_data)
{
	WSAEVENT event;
	struct eloop_sock *tmp;

	if (eloop_prepare_handles())
		return -1;

	event = WSACreateEvent();
	if (event == WSA_INVALID_EVENT) {
		printf("WSACreateEvent() failed: %d\n", WSAGetLastError());
		return -1;
	}

	if (WSAEventSelect(sock, event, FD_READ)) {
		printf("WSAEventSelect() failed: %d\n", WSAGetLastError());
		WSACloseEvent(event);
		return -1;
	}
	tmp = os_realloc_array(eloop.readers, eloop.reader_count + 1,
			       sizeof(struct eloop_sock));
	if (tmp == NULL) {
		WSAEventSelect(sock, event, 0);
		WSACloseEvent(event);
		return -1;
	}

	tmp[eloop.reader_count].sock = sock;
	tmp[eloop.reader_count].eloop_data = eloop_data;
	tmp[eloop.reader_count].user_data = user_data;
	tmp[eloop.reader_count].handler = handler;
	tmp[eloop.reader_count].event = event;
	eloop.reader_count++;
	eloop.readers = tmp;
	if (sock > eloop.max_sock)
		eloop.max_sock = sock;
	eloop.reader_table_changed = 1;

	return 0;
}
コード例 #8
0
ファイル: TCPSocket.cpp プロジェクト: marczaku/zaku-webserver
//---------------------------------------
void TCPSocket::Close()
{
	if(m_xSock!=INVALID_SOCKET)
	{
		shutdown(m_xSock,SD_BOTH);
		closesocket(m_xSock);
		m_xSock=INVALID_SOCKET;
		if(m_hClose!=WSA_INVALID_EVENT)
			WSACloseEvent(m_hClose);
		m_hClose=WSA_INVALID_EVENT;
	}
}
コード例 #9
0
void RemoteDesktop::GatewayServer::_Run(){

	std::vector<WSAEVENT> EventArray;
	auto socketarray = std::vector<std::shared_ptr<Gateway_Socket>>();
	EventArray.reserve(WSA_MAXIMUM_WAIT_EVENTS);
	socketarray.reserve(WSA_MAXIMUM_WAIT_EVENTS);

	SOCKET listensocket = RemoteDesktop::Listen(_Port, _Host);
	if (listensocket == INVALID_SOCKET) return;

	auto newevent = WSACreateEvent();
	WSAEventSelect(listensocket, newevent, FD_ACCEPT | FD_CLOSE);

	EventArray.push_back(newevent);
	socketarray.push_back(std::make_shared<Gateway_Socket>(listensocket));

	WSANETWORKEVENTS NetworkEvents;
	auto timer = std::chrono::high_resolution_clock::now();
	while (_Running && !EventArray.empty()) {

		auto Index = WSAWaitForMultipleEvents(EventArray.size(), EventArray.data(), FALSE, 1000, FALSE);

		if ((Index != WSA_WAIT_FAILED) && (Index != WSA_WAIT_TIMEOUT) && _Running) {

			WSAEnumNetworkEvents(socketarray[Index]->ThisSocket->socket, EventArray[Index], &NetworkEvents);
			if (((NetworkEvents.lNetworkEvents & FD_ACCEPT) == FD_ACCEPT) && NetworkEvents.iErrorCode[FD_ACCEPT_BIT] == ERROR_SUCCESS){
				if (EventArray.size() >= WSA_MAXIMUM_WAIT_EVENTS - 1) continue;// ignore this event too many connections
				_HandleNewConnect(listensocket, EventArray, socketarray);
			}
			else if (((NetworkEvents.lNetworkEvents & FD_READ) == FD_READ) && NetworkEvents.iErrorCode[FD_READ_BIT] == ERROR_SUCCESS){
				socketarray[Index]->Receive();
			}
			else if (((NetworkEvents.lNetworkEvents & FD_CLOSE) == FD_CLOSE) && NetworkEvents.iErrorCode[FD_CLOSE_BIT] == ERROR_SUCCESS){
				if (Index == 0) {//stop all processing, set running to false and next loop will fail and cleanup
					_Running = false;
					continue;
				}
			}
		}
		//once every second send a keep alive. this will trigger disconnects 
		if (std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - timer).count() > 1000){
			_CheckForDisconnects(EventArray, socketarray);
			timer = std::chrono::high_resolution_clock::now();
		}
	}
	for (size_t beg = 1; beg < socketarray.size(); beg++){
		//OnDisconnect(sharedrockarray->at(beg));//let all callers know about the disconnect, skip slot 0 which is the listen socket
	}
	//cleanup code here
	for (auto x : EventArray) WSACloseEvent(x);
	DEBUG_MSG("_Listen Exiting");
}
コード例 #10
0
ファイル: win32.cpp プロジェクト: ashl1/libktorrent-stream
static void clean(nfds_t nfds, SOCKET *fds, HANDLE *hEvents) {
    nfds_t i;
    
    for (i = 0; i < nfds; i++) {
        if (fds[i] != INVALID_SOCKET) {
            WSAEventSelect(fds[i], NULL, 0);
        }
        
        if (hEvents[i] != NULL) {
            WSACloseEvent(hEvents[i]);
        }
    }
}
コード例 #11
0
ファイル: aj_net.c プロジェクト: dengcj0/QCA4010
void AJ_Net_Disconnect(AJ_NetSocket* netSock)
{
    AJ_InfoPrintf(("AJ_Net_Disconnect(nexSock=0x%p)\n", netSock));

    if (netContext.tcpSock != INVALID_SOCKET) {
        shutdown(netContext.tcpSock, 0);
        closesocket(netContext.tcpSock);
        netContext.tcpSock = INVALID_SOCKET;
    } else if (netContext.udpSock != INVALID_SOCKET) {
#ifdef AJ_ARDP
        AJ_ARDP_Disconnect(FALSE);
#endif
        shutdown(netContext.udpSock, 0);
        closesocket(netContext.udpSock);
        netContext.udpSock = INVALID_SOCKET;
    }

    memset(netSock, 0, sizeof(AJ_NetSocket));
    WSACloseEvent(recvEvent);
    WSACloseEvent(sendEvent);
    WSACloseEvent(interruptEvent);
}
コード例 #12
0
ファイル: tube.c プロジェクト: 2asoft/freebsd
void tube_delete(struct tube* tube)
{
	if(!tube) return;
	tube_remove_bg_listen(tube);
	tube_remove_bg_write(tube);
	tube_close_read(tube);
	tube_close_write(tube);
	if(!WSACloseEvent(tube->event))
		log_err("WSACloseEvent: %s", wsa_strerror(WSAGetLastError()));
	lock_basic_destroy(&tube->res_lock);
	verbose(VERB_ALGO, "tube deleted");
	free(tube);
}
コード例 #13
0
void DeleteOverlappedTransferBuffer(OverlappedTransferBuffer *buffer)
{
	if (!buffer)
		return;
	delete[] buffer->buffer.buf;
#ifdef WIN32
	BOOL success = WSACloseEvent(buffer->overlapped.hEvent);
	if (success == FALSE)
		LOG(LogError, "Socket.cpp:DeleteOverlappedTransferBuffer: WSACloseEvent failed!");
	buffer->overlapped.hEvent = WSA_INVALID_EVENT;
#endif
	delete buffer;
}
コード例 #14
0
ファイル: SOCKET.cpp プロジェクト: tiku/test
void WSA_Async::Event_Proc(){
	enum{NETWORK_EVENT=0,SYSTEM_EVENT,SIZE};
	wstring res;
	WSANETWORKEVENTS events;
	DWORD dwResult;

	m_hWSAEvent=WSACreateEvent();
	WSAEventSelect(m_socket->GetSocket(),m_hWSAEvent,FD_READ|FD_CLOSE);

	HANDLE hWSAEvents[SIZE];
	hWSAEvents[NETWORK_EVENT]=m_hWSAEvent;
	hWSAEvents[SYSTEM_EVENT]=m_hEvent;

	while(running){
		dwResult=WSAWaitForMultipleEvents(SIZE,hWSAEvents,FALSE,WSA_INFINITE,FALSE);
		if(dwResult==WSA_WAIT_FAILED){
			break;
		}
		dwResult-=WSA_WAIT_EVENT_0;
		WSAResetEvent(hWSAEvents[dwResult]);

		if(dwResult==SYSTEM_EVENT){
			while(pause&&running){
				if(WSAWaitForMultipleEvents(1,&m_hEvent,FALSE,WSA_INFINITE,FALSE)==WSA_WAIT_FAILED){
					break;
				}
				WSAResetEvent(m_hEvent);
			}
		}else{
			wstring read;
			read.clear();
			WSAEnumNetworkEvents(m_socket->GetSocket(),m_hWSAEvent,&events);
			switch(events.lNetworkEvents){
			case FD_READ:
				m_socket->Recv(&read);
				m_call(events.lNetworkEvents,(wchar_t*)read.c_str());
				break;
			case FD_CLOSE:
				m_socket->Reset();
				m_call(events.lNetworkEvents,TEXT(""));
				running=false;
				break;
			}
		}
	}
END:
	running=false;
	pause=false;
	WSAResetEvent(m_hEvent);
	WSACloseEvent(m_hWSAEvent);
}
コード例 #15
0
ファイル: Os.c プロジェクト: sewood/ohNet
void OsDestroy(OsContext* aContext)
{
    if (aContext == NULL) {
        return;
    }
    (void)SymCleanup(aContext->iDebugSymbolHandle);
    if (NULL != aContext->iInterfaceChangeObserver) {
        aContext->iInterfaceChangeObserver->iShutdown = 1;
        (void)WSASetEvent(aContext->iInterfaceChangeObserver->iShutdownEvent);
        (void)WaitForSingleObject(aContext->iInterfaceChangeObserver->iSem, INFINITE);
        CloseHandle(aContext->iInterfaceChangeObserver->iSem);
        WSACloseEvent(aContext->iInterfaceChangeObserver->iEvent);
        WSACloseEvent(aContext->iInterfaceChangeObserver->iShutdownEvent);
        (void)closesocket(aContext->iInterfaceChangeObserver->iSocket);
        free(aContext->iInterfaceChangeObserver);
        aContext->iInterfaceChangeObserver = NULL;
    }
    (void)WSACleanup();
    OsMutexDestroy(aContext->iMutex);
    aContext->iMutex = kHandleNull;
    TlsFree(aContext->iTlsIndex);
    free(aContext);
}
コード例 #16
0
ファイル: W32SocketServer.cpp プロジェクト: carribus/firecell
void CW32SocketServer::Shutdown()
{
	if ( m_hListenThrd )
	{
		m_bRun = false;
		SetEvent( m_hListenEvent );
		WaitForSingleObject( m_hListenThrd, INFINITE );
		WSACloseEvent(m_hListenEvent);
		CloseHandle(m_hListenThrd);
		m_hListenEvent = m_hListenThrd = 0;
	}

  delete this;
}
コード例 #17
0
ファイル: lws-plat-win.c プロジェクト: bitsatul/libwebsockets
LWS_VISIBLE void
lws_plat_context_early_destroy(struct lws_context *context)
{
	struct lws_context_per_thread *pt = &context->pt[0];
	int n = context->count_threads;

	while (n--) {
		if (pt->events) {
			WSACloseEvent(pt->events[0]);
			lws_free(pt->events);
		}
		pt++;
	}
}
コード例 #18
0
void AsyncEventPoller::CleanUp()
{
    for (auto iter = eventFds_.begin(); iter != eventFds_.end();++iter)
    {
        WSAEVENT hEvent = iter->first;
        FdEntry* entry = iter->second;
        WSAEventSelect(entry->fd, NULL, 0);
        WSACloseEvent(hEvent);
        closesocket(entry->fd);
        delete entry;
    }
    eventFds_.clear();
    fdEvents_.clear(); 
}
コード例 #19
0
static
void
globus_l_xio_win32_blocking_destroy(
    globus_l_xio_win32_blocking_info_t * blocking_info)
{
    GlobusXIOName(globus_l_xio_win32_blocking_destroy);
    
    GlobusXIOSystemDebugEnter();
    
    WSACloseEvent(blocking_info->event);
    globus_free(blocking_info);
    
    GlobusXIOSystemDebugExit();
}
コード例 #20
0
ファイル: TCPSocket.cpp プロジェクト: marczaku/zaku-webserver
//---------------------------------------
void TCPAcceptSocket::Close()
{
	if(m_xSock!=INVALID_SOCKET)
	{
		shutdown(m_xSock,SD_BOTH);
		closesocket(m_xSock);
		m_xSock=INVALID_SOCKET;
	}
	if(m_hEvent)
	{
		WSACloseEvent(m_hEvent);
		m_hEvent=WSA_INVALID_EVENT;
	}
}
コード例 #21
0
ファイル: link_win32.c プロジェクト: Distrotech/DirectFB
static void
Close( VoodooLink *link )
{
     Link *l = link->priv;

     D_INFO( "Voodoo/Link: Closing connection.\n" );

     // FIXME: how to close socket?

     direct_mutex_deinit( &l->lock );

     WSACloseEvent( l->event );

     D_FREE( l );
}
コード例 #22
0
ファイル: MMC.cpp プロジェクト: sechacking/r3pos
void UnInitSock()   
{   
	if (g_wsaEvent != WSA_INVALID_EVENT)   
	{   
		WSACloseEvent(g_wsaEvent);   
	}   
	if (g_socketServer != INVALID_SOCKET)   
	{   
		closesocket(g_socketServer);   
		g_socketServer = INVALID_SOCKET; 
	}   
	WSACleanup();   


}   
コード例 #23
0
ファイル: xbox_main.cpp プロジェクト: JohnnyonFlame/odamex
//
// GetHostByName
//
struct hostent *Xbox::GetHostByName(const char *name)
{
	static struct hostent *he = NULL;
	unsigned long          addr = INADDR_NONE;
	WSAEVENT               hEvent;
	XNDNS                 *pDns = NULL;
	INT                    err;
	
	if(!name)
		return NULL;

	// This data is static and it should not be freed.
	if(!he)
	{
		he = (struct hostent *)malloc(sizeof(struct hostent));
		if(!he)
		{
			// Failed to allocate!
			return NULL;
		}

		he->h_addr_list = (char **)malloc(sizeof(char*));
		he->h_addr_list[0] = (char *)malloc(sizeof(struct in_addr));
	}

	if(isdigit(name[0]))
		addr = inet_addr(name);

	if(addr != INADDR_NONE)
		*(int *)he->h_addr_list[0] = addr;
	else
	{
		hEvent = WSACreateEvent();
		err = XNetDnsLookup(name, hEvent, &pDns);

		WaitForSingleObject( (HANDLE)hEvent, INFINITE);

		if(!pDns || pDns->iStatus != 0)
			return NULL;

		memcpy(he->h_addr_list[0], pDns->aina, sizeof(struct in_addr));

		XNetDnsRelease(pDns);
		WSACloseEvent(hEvent);
	}

	return he;
}
コード例 #24
0
void AsyncEventPoller::RemoveFd(SOCKET fd)
{
    auto iter = fdEvents_.find(fd);
    if (iter == fdEvents_.end())
    {
        return; // not found
    }

    WSAEVENT hEvent = iter->second;

    //clear the event record associated with socket
    WSAEventSelect(fd, NULL, 0); 
    WSACloseEvent(hEvent);
    eventFds_.erase(hEvent);
    fdEvents_.erase(fd);
}
コード例 #25
0
ファイル: tcp.c プロジェクト: nidelius/FreeRDP
/* Disconnect on the TCP layer */
void
tcp_disconnect(rdpTcp * tcp)
{
	if (tcp->sock != -1)
	{
		TCP_CLOSE(tcp->sock);
		tcp->sock = -1;
	}
#ifdef _WIN32
	if (tcp->wsa_event)
	{
		WSACloseEvent(tcp->wsa_event);
		tcp->wsa_event = 0;
	}
#endif
}
コード例 #26
0
ファイル: Sockopt.cpp プロジェクト: ytc301/FastDFS_Client_Win
int is_socket_closed(int sock)
{
	int nRet;
	HANDLE hCloseEvent = WSACreateEvent();
	WSAEventSelect(sock, hCloseEvent, FD_CLOSE);

	DWORD dwRet = WaitForSingleObject(hCloseEvent, 1);

	if(dwRet == WSA_WAIT_EVENT_0)
		nRet = 1;
	else if(dwRet == WSA_WAIT_TIMEOUT)
		nRet = 0;

	WSACloseEvent(hCloseEvent);
	return nRet;
}
コード例 #27
0
ConnectionSockets::~ConnectionSockets()
{
	int num_reserved_events=ReturnNumberOfReservedEvents();
	
	// Close the reserved events
	for(int i=0;i<num_reserved_events;i++)
	{
		if(WSACloseEvent(m_events[i])==FALSE)
		{
			char msg[1024];
			strcpy(msg,"Could not close reserved event ");
			_itoa(i,&msg[strlen(msg)],10);
			::MessageBox(NULL,msg,"Error",MB_OK);
		}
	}
}
コード例 #28
0
ファイル: epoll.cpp プロジェクト: zgpxgame/skynet-mingw
int epoll_close(int epfd)
{
	GUARD();
    if(epfd < 1 || ep_data.find(epfd) == ep_data.end())
        return ENOENT;

    ep_internal& epi = ep_data[epfd];
    for(ep_internal::size_type i = 0; i < epi.size(); ++i) {

		// now unset the event notifications
		WSAEventSelect(epi[i].fd, 0, 0);
		// clean up event
		WSACloseEvent(epi[i].wsa_event);
	}
    ep_data.erase(epfd);
    return 0;
}
コード例 #29
0
/*
* Performs an alertable wait for the specified event (FD_ACCEPT_BIT,
* FD_CONNECT_BIT, FD_READ_BIT, FD_WRITE_BIT) on the specified socket.
* Returns TRUE if the event is fired without errors. Calls WSASetLastError()
* with WSAEINTR and returns FALSE if the thread is alerted. If the event is
* fired but with an error WSASetLastError() is called to set the error and the
* function returns FALSE.
*/
static gboolean alertable_socket_wait (SOCKET sock, int event_bit)
{
	static char *EVENT_NAMES[] = { "FD_READ", "FD_WRITE", NULL /*FD_OOB*/, "FD_ACCEPT", "FD_CONNECT", "FD_CLOSE" };
	gboolean success = FALSE;
	int error = -1;
	DWORD timeout = WSA_INFINITE;
	if (event_bit == FD_READ_BIT || event_bit == FD_WRITE_BIT) {
		timeout = get_socket_timeout (sock, event_bit == FD_READ_BIT ? SO_RCVTIMEO : SO_SNDTIMEO);
	}
	WSASetLastError (0);
	WSAEVENT event = WSACreateEvent ();
	if (event != WSA_INVALID_EVENT) {
		if (WSAEventSelect (sock, event, (1 << event_bit) | FD_CLOSE) != SOCKET_ERROR) {
			LOGDEBUG (g_message ("%06d - Calling WSAWaitForMultipleEvents () on socket %d", GetCurrentThreadId (), sock));
			DWORD ret = WSAWaitForMultipleEvents (1, &event, TRUE, timeout, TRUE);
			if (ret == WSA_WAIT_IO_COMPLETION) {
				LOGDEBUG (g_message ("%06d - WSAWaitForMultipleEvents () returned WSA_WAIT_IO_COMPLETION for socket %d", GetCurrentThreadId (), sock));
				error = WSAEINTR;
			} else if (ret == WSA_WAIT_TIMEOUT) {
				error = WSAETIMEDOUT;
			} else {
				g_assert (ret == WSA_WAIT_EVENT_0);
				WSANETWORKEVENTS ne = { 0 };
				if (WSAEnumNetworkEvents (sock, event, &ne) != SOCKET_ERROR) {
					if (ne.lNetworkEvents & (1 << event_bit) && ne.iErrorCode[event_bit]) {
						LOGDEBUG (g_message ("%06d - %s error %d on socket %d", GetCurrentThreadId (), EVENT_NAMES[event_bit], ne.iErrorCode[event_bit], sock));
						error = ne.iErrorCode[event_bit];
					} else if (ne.lNetworkEvents & FD_CLOSE_BIT && ne.iErrorCode[FD_CLOSE_BIT]) {
						LOGDEBUG (g_message ("%06d - FD_CLOSE error %d on socket %d", GetCurrentThreadId (), ne.iErrorCode[FD_CLOSE_BIT], sock));
						error = ne.iErrorCode[FD_CLOSE_BIT];
					} else {
						LOGDEBUG (g_message ("%06d - WSAEnumNetworkEvents () finished successfully on socket %d", GetCurrentThreadId (), sock));
						success = TRUE;
						error = 0;
					}
				}
			}
			WSAEventSelect (sock, NULL, 0);
		}
		WSACloseEvent (event);
	}
	if (error != -1) {
		WSASetLastError (error);
	}
	return success;
}
コード例 #30
0
// 소켓 정보 삭제
void RemoveSocketInfo(int nIndex)
{
	EnterCriticalSection(&cs);

	SOCKETINFO *ptr = SocketInfoArray[nIndex];
	closesocket(ptr->sock);
	delete ptr;
	WSACloseEvent(EventArray[nIndex]);

	if(nIndex != (nTotalSockets-1)){
		SocketInfoArray[nIndex] = SocketInfoArray[nTotalSockets-1];
		EventArray[nIndex] = EventArray[nTotalSockets-1];
	}
	--nTotalSockets;

	LeaveCriticalSection(&cs);
}