Esempio n. 1
0
static AJ_Status AJ_ARDP_UDP_Recv(void* context, uint8_t** data, uint32_t* recved, uint32_t timeout)
{
    NetContext* ctx = (NetContext*) context;
    DWORD ret = SOCKET_ERROR;
    WSAEVENT events[2];
    DWORD flags = 0;
    static uint8_t buffer[UDP_SEGBMAX];

    *data = NULL;

    if (wsaOverlapped.hEvent == INVALID_HANDLE_VALUE) {
        wsbuf.len = sizeof(buffer);
        wsbuf.buf = buffer;
        memset(&wsaOverlapped, 0, sizeof(WSAOVERLAPPED));
        wsaOverlapped.hEvent = recvEvent;
        ret = WSARecvFrom(ctx->udpSock, &wsbuf, 1, NULL, &flags, NULL, NULL, &wsaOverlapped, NULL);
        if ((ret == SOCKET_ERROR) && (WSAGetLastError() != WSA_IO_PENDING)) {
            AJ_ErrPrintf(("WSARecvFrom(): failed WSAGetLastError()=%d\n", WSAGetLastError()));
            return AJ_ERR_READ;
        }
    }

    events[0] = wsaOverlapped.hEvent;
    events[1] = interruptEvent;

    ret = WSAWaitForMultipleEvents(2, events, FALSE, timeout, TRUE);
    switch (ret) {
    case WSA_WAIT_EVENT_0:
        flags = 0;
        if (WSAGetOverlappedResult(ctx->udpSock, &wsaOverlapped, recved, TRUE, &flags)) {
            WSAResetEvent(wsaOverlapped.hEvent);
            wsaOverlapped.hEvent = INVALID_HANDLE_VALUE;
            *data = buffer;
            return AJ_OK;
        } else {
            AJ_ErrPrintf(("AJ_ARDP_UDP_Recv(): WSAGetOverlappedResult error; WSAGetLastError()=%d\n", WSAGetLastError()));
            return AJ_ERR_READ;
        }
        break;

    case WSA_WAIT_EVENT_0 + 1:
        WSAResetEvent(interruptEvent);
        return AJ_ERR_INTERRUPTED;

    case WSA_WAIT_TIMEOUT:
        return AJ_ERR_TIMEOUT;
        break;

    default:
        AJ_ErrPrintf(("AJ_ARDP_UDP_Recv(): WSAWaitForMultipleEvents error; WSAGetLastError()=%d\n", WSAGetLastError()));
        return AJ_ERR_READ;
    }
}
Esempio n. 2
0
File: SOCKET.cpp Progetto: 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);
}
Esempio n. 3
0
CPassiveSock::CPassiveSock(SOCKET s, HANDLE hServerStopEvent)
{
    LastError = 0;
    RecvInitiated = false;
    TimeoutSeconds = 1; // Default timeout is 1 seconds, encourages callers to set it
    ActualSocket = s;
    read_event = WSACreateEvent();  // if create fails we should return an error
    WSAResetEvent(read_event);
    write_event = WSACreateEvent();  // if create fails we should return an error
    WSAResetEvent(write_event);
    int rc = true;
    setsockopt(ActualSocket, IPPROTO_TCP, TCP_NODELAY, (char *)&rc, sizeof(int));
    m_hStopEvent = hServerStopEvent;
}
Esempio n. 4
0
/* Process receivable fds, return true if connection should live on */
static int
l_rdp_check_fds(rdpInst * inst)
{
	rdpRdp * rdp;
	RD_BOOL deactivated;
	int rv;

	rdp = RDP_FROM_INST(inst);
#ifdef _WIN32
	WSAResetEvent(rdp->sec->mcs->iso->tcp->wsa_event);
#endif
	rv = 0;
	if (tcp_can_recv(rdp->sec->mcs->iso->tcp->sock, 0))
	{
		if (!rdp_loop(rdp, &deactivated))
		{
			rv = 1;
		}
	}
	if ((rv != 0) && rdp->redirect)
	{
		rdp->redirect = False;
		if (rdp_reconnect(rdp))
		{
			rv = 0;
		}
	}
	return rv;
}
Esempio n. 5
0
int transport_check_fds(rdpTransport* transport)
{
	int status;
	int recv_status;
	wStream* received;

	if (!transport)
		return -1;

#ifdef _WIN32
	WSAResetEvent(transport->TcpIn->event);
#endif
	ResetEvent(transport->ReceiveEvent);

	/**
	 * Loop through and read all available PDUs.  Since multiple
	 * PDUs can exist, it's important to deliver them all before
	 * returning.  Otherwise we run the risk of having a thread
	 * wait for a socket to get signaled that data is available
	 * (which may never happen).
	 */
	for (;;)
	{
		/**
		 * Note: transport_read_pdu tries to read one PDU from
		 * the transport layer.
		 * The ReceiveBuffer might have a position > 0 in case of a non blocking
		 * transport. If transport_read_pdu returns 0 the pdu couldn't be read at
		 * this point.
		 * Note that transport->ReceiveBuffer is replaced after each iteration
		 * of this loop with a fresh stream instance from a pool.
		 */
		if ((status = transport_read_pdu(transport, transport->ReceiveBuffer)) <= 0)
		{
			return status;
		}

		received = transport->ReceiveBuffer;
		transport->ReceiveBuffer = StreamPool_Take(transport->ReceivePool, 0);
		/**
		 * status:
		 * 	-1: error
		 * 	 0: success
		 * 	 1: redirection
		 */
		recv_status = transport->ReceiveCallback(transport, received, transport->ReceiveExtra);
		Stream_Release(received);

		/* session redirection or activation */
		if (recv_status == 1 || recv_status == 2)
		{
			return recv_status;
		}

		if (recv_status < 0)
			return -1;
	}

	return 0;
}
Esempio n. 6
0
void NET_Thread::Execute()
{
	m_executing = true;
	SetEvent(m_started_event);
	DWORD res, i;
	HANDLE one_event;
	while (true)
	{
		res = WaitForMultipleObjects(m_events_num, m_events, FALSE, INFINITE);
		if (res == WAIT_OBJECT_0)
			return;
		for (i = 0; i < m_events_num - 1; i++)
		{
			one_event = Event(i);
			if (res == WAIT_OBJECT_0 + (i + 1) || WaitForSingleObject(one_event, 0) == WAIT_OBJECT_0)
			{
				WSAResetEvent(one_event);
				{
					//MutexWrap socket_access(m_socket->m_socket_mutex);
					if (m_socket->m_created)
					{
						MutexWrap socket_access(m_socket->m_socket_mutex);
						OnEvent(i);
					}
				}
			}
		}
	}
	CRUSH("Wrong NET_Thread::Execute() exit");
}
Esempio n. 7
0
void NET_BaseSocket::PrivateOnSend()
{
	if (!m_created)
		return;

	MutexWrap out_read_access(m_out_data->m_r_mutex);
	int filled_size;
	{
		MutexWrap out_write_access(m_out_data->m_w_mutex);
		filled_size = m_out_data->NoLockSpaceFor(RingBuffer_READ);
	}
	if (filled_size <= 0)
		return;		
	int size_to_send = min((int)m_out_buf_size, filled_size);
	m_out_data->Read(m_out_buf, size_to_send);
	DWORD bytes_written = 0, flags = 0;
	m_out_wsa_buf.buf = m_out_buf;
	m_out_wsa_buf.len = size_to_send;
	m_last_error = 0;
	OP2( WSASend(m_socket, &m_out_wsa_buf, 1, &bytes_written, flags, m_write_thread.GetOverlapped(), NULL), m_last_error != WSA_IO_PENDING, "NET_BaseSocket::PrivateOnSend, WSASend" );
	if (m_last_error == WSA_IO_PENDING)
	{
		WSAResetEvent(m_write_thread.GetOverlapped()->hEvent);
		return;
	}
	CHECK(bytes_written == size_to_send);
	OnSend();
}
Esempio n. 8
0
void Event::Reset()
{
	if (wsaEvent == NULL)
		KNET_LOG(LogError, "Event::Reset called on a null event!");
	else
		WSAResetEvent(wsaEvent);
}
Esempio n. 9
0
	bool CCommunication::IsConnected()
	{
		HANDLE hEvent = WSACreateEvent();
		bool bRet = true;
		try
		{
			if (WSA_INVALID_EVENT == hEvent)
				throw("");

			if (SOCKET_ERROR == WSAEventSelect(m_WorkSocket, hEvent, FD_CLOSE)) 
				throw("");

			if (m_WorkSocket && hEvent) 
			{
				if (WAIT_OBJECT_0 == WSAWaitForMultipleEvents(1, &hEvent, false, 80, false)) 
				{
					WSAResetEvent(hEvent);
					CloseSocket();
					throw("");
				}
			}
			else 
				throw("");
		}
		catch (char* szErr)
		{
			bRet = false;
		}
		if (hEvent)
			WSACloseEvent(hEvent);
		return bRet;
	}
Esempio n. 10
0
static void msgloop_loop(void * vqlink)
{
	WSAEVENT hReadEvent;
	SOCKET rx_socket = vqp_link_rx_socket((vqp_link_t) vqlink);

	s_fLoopStarted = TRUE;

	hReadEvent = WSACreateEvent();
	WSAEventSelect(rx_socket, hReadEvent, FD_READ);

	while(!Miranda_Terminated() && !s_fStopLoop) {
		DWORD nEvent = WSAWaitForMultipleEvents(
				1, &hReadEvent, FALSE, WSA_INFINITE, TRUE);

		if(nEvent==WSA_WAIT_EVENT_0) {
			vqp_msg_t msg;

			WSAResetEvent(hReadEvent);
	
			if(!vqp_link_recv((vqp_link_t) vqlink, &msg)) {
				QueueUserAPC(
					s_lpfnMsgHandleApc,
					s_hMainThread, (ULONG_PTR)msg);
			}
		}
	}

	WSACloseEvent(hReadEvent);

	/* wait for pending user APC */
	while(SleepEx(10, TRUE) == WAIT_IO_COMPLETION) /* nothing */;

	/* signal that we've finished */
	SetEvent(s_hStopWaitEvent);
}
Esempio n. 11
0
/** handle is_signal events and see if signalled */
static void _getdns_handle_signal(struct _getdns_event* ev)
{
	DWORD ret;
	//log_assert(ev->is_signal && ev->hEvent);
	/* see if the event is signalled */
	ret = WSAWaitForMultipleEvents(1, &ev->hEvent, 0 /* any object */,
		0 /* return immediately */, 0 /* not alertable for IOcomple*/);
	if(ret == WSA_WAIT_IO_COMPLETION || ret == WSA_WAIT_FAILED) {
		log_err("getdns: WSAWaitForMultipleEvents(signal) failed: %s",
			wsa_strerror(WSAGetLastError()));
		return;
	}
	if(ret == WSA_WAIT_TIMEOUT) {
		/* not signalled */
		return;
	}

	/* reset the signal */
	if(!WSAResetEvent(ev->hEvent))
		log_err("getdns: WSAResetEvent failed: %s",
			wsa_strerror(WSAGetLastError()));
	/* do the callback (which may set the signal again) */
	fptr_ok(fptr_whitelist_event(ev->ev_callback));
	(*ev->ev_callback)(ev->ev_fd, ev->ev_events, ev->ev_arg);
}
Esempio n. 12
0
void NET_Thread::Start(int priority)
{
	LOG_V0_AddMessage(LOG_V0_DEBUG_MESSAGE, m_socket->GetName() + " " + GetName() + "::Start()");
	CHECK(m_events && m_events_num > 0);
	WSAResetEvent(m_events[0]);
	AfxBeginThread(ThreadProcedure, this, priority);
	WaitForSingleObject(m_started_event, INFINITE);
}
Esempio n. 13
0
/**
 * The main function for the service.
 * Called by the services API when starting on windows in background.
 * Arguments could have been present in the string 'path'.
 * @param argc: nr args
 * @param argv: arg text.
 */
static void 
service_main(DWORD ATTR_UNUSED(argc), LPTSTR* ATTR_UNUSED(argv))
{
	struct cfg* cfg = NULL;
	struct svr* svr = NULL;

	service_status_handle = RegisterServiceCtrlHandler(SERVICE_NAME, 
		(LPHANDLER_FUNCTION)hdlr);
	if(!service_status_handle) {
		reportev("Could not RegisterServiceCtrlHandler");
		return;
	}
	
	service_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
	service_status.dwServiceSpecificExitCode = 0;

	/* we are now starting up */
	report_status(SERVICE_START_PENDING, NO_ERROR, 3000);
	if(!service_init(&svr, &cfg)) {
		reportev("Could not service_init");
		report_status(SERVICE_STOPPED, NO_ERROR, 0);
		return;
	}

	/* event that gets signalled when we want to quit */
	service_stop_event = WSACreateEvent();
	if(service_stop_event == WSA_INVALID_EVENT) {
		log_err("WSACreateEvent: %s", wsa_strerror(WSAGetLastError()));
		reportev("Could not WSACreateEvent");
		report_status(SERVICE_STOPPED, NO_ERROR, 0);
		return;
	}
	if(!WSAResetEvent(service_stop_event)) {
		log_err("WSAResetEvent: %s", wsa_strerror(WSAGetLastError()));
	}
	wsvc_setup_worker(svr->base);

	/* SetServiceStatus SERVICE_RUNNING;*/
	report_status(SERVICE_RUNNING, NO_ERROR, 0);
	verbose(VERB_QUERY, "winservice - init complete");
	
	/* register DHCP hook and perform first sweep */
	netlist_start(svr);

	/* daemon performs work */
	svr_service(svr);

	/* exit */
	verbose(VERB_ALGO, "winservice - cleanup.");
	report_status(SERVICE_STOP_PENDING, NO_ERROR, 0);
	netlist_stop();
	wsvc_desetup_worker();
	service_deinit(svr, cfg);
	free(service_cfgfile);
	if(service_stop_event) (void)WSACloseEvent(service_stop_event);
	verbose(VERB_QUERY, "winservice - full stop");
	report_status(SERVICE_STOPPED, NO_ERROR, 0);
}
Esempio n. 14
0
/*-------------------------------------------------------------------------------------------------------------------------------------

FUNCTION:		TCPWorkerThread

INTERFACE:		DWORD WINAPI TCPWorkerThread(LPVOID lpParameter)

RETURNS:		DWORD

NOTES:			Waits for a connect request from a client. The accept call is called, the function will assume that there is
				data waiting on the socket and then call the completion routine.

--------------------------------------------------------------------------------------------------------------------------------------*/
DWORD WINAPI TCPWorkerThread(LPVOID lpParameter)
{
	DWORD					Flags = 0;
	LPSOCKET_INFORMATION	SocketInfo;
	WSAEVENT				EventArray[1];
	DWORD					Index;
	DWORD					RecvBytes = 0;

	// Save the accept event in the event array.
	EventArray[0] = (WSAEVENT)lpParameter;

	while (TRUE)
	{
		while (TRUE)
		{
			Index = WSAWaitForMultipleEvents(1, EventArray, FALSE, WSA_INFINITE, TRUE);

			if (Index == WSA_WAIT_FAILED)
			{
				formatMessage("WSAWaitForMultipleEvents failed");
				return FALSE;
			}
			if (Index != WAIT_IO_COMPLETION)
			{
				// An accept() call event is ready - break the wait loop
				break;
			}
			if (Index == WAIT_IO_COMPLETION && exitThread == true)
			{
				formatMessage("Server Terminating");
				exitThread = false;
				closesocket(SocketInfo->Socket);
				logDataFile(fileInfo);
				free(fileInfo);
				fclose(serverFP);
				WSACleanup();
				return TRUE;
			}
		}

		WSAResetEvent(EventArray[Index - WSA_WAIT_EVENT_0]);

		// Create a socket information structure to associate with the accepted socket.
		if ((SocketInfo = (LPSOCKET_INFORMATION)GlobalAlloc(GPTR, sizeof(SOCKET_INFORMATION))) == NULL)
		{
			formatMessage("GlobalAlloc() failed");
			return FALSE;
		}

		// Fill in the details of our accepted socket.
		SocketInfo->Socket = acceptSocket;
		initSockInfo(SocketInfo, SocketInfo->Buffer, DATA_BUFSIZE);
		receiveTCP(SocketInfo, RecvBytes, Flags);

	}
	GlobalFree(SocketInfo);
}
Esempio n. 15
0
/// 连接检查线程函数
void CTcpIocpServer::ConnectCheckFunc(void)
{
	uint32_t nTimeNow = 0;
	uint32_t nLastCheckTime = GetTickCount();

	int32_t nResult = 0;
	int32_t nOptlen = 0;
	uint32_t nOptval = 0;
	//int32_t nAcceptCount = 0;

	OVERLAPPEDPLUS *lpOverlapPlus = NULL;
	CTcpContext* lpTcpContext = NULL;
	uint32_t nWaitResult = 0;

	while(INVALID_SOCKET != m_hListenSocket)
	{
		nWaitResult = WSAWaitForMultipleEvents(1, &m_hAcceptEvent, FALSE, 1000, FALSE);
		if (INVALID_SOCKET == m_hListenSocket)
		{
			break;
		}

		if (WSA_WAIT_EVENT_0 == nWaitResult || GetAcceptExCount() < 2) //已无连接可用
		{
			WSAResetEvent(m_hAcceptEvent);

			//投递AcceptEx请求			
			for(uint32_t nAcceptCount = 0; nAcceptCount < 100; nAcceptCount++)
			{
				OVERLAPPEDPLUS* pOverlap = MallocOverlap(IO_ACCEPT);
				if(NULL != pOverlap)
				{
					if(!AddAcceptEx(pOverlap))
					{
						FreeOverlap(pOverlap);
					}
				}
			}
		}

		//10秒检查一次(预防拒绝服务攻击)
		nTimeNow = GetTickCount();
		if (nTimeNow > nLastCheckTime + 10000)
		{
			// 检查空连接(用户已建立连接,但在规定时间内没发包)
			CheckAcceptExTimeout();
			
			//检查无效连接
			CheckInvalidContext();

			nLastCheckTime = nTimeNow;
		}
	}
}
Esempio n. 16
0
_inline int PollSockets(LPCONNPOOL cp) {
	int num_fds, i;
	SOCKET fd_highest;
	LPSESS sess;

	#if defined(_USE_KQUEUE)
		num_fds = kevent(cp->smfd, NULL, 0, cp->events, cp->nconns, NULL);
		return num_fds;
		
	#elif defined(_USE_EPOLL)
		num_fds = epoll_wait(cp->smfd, cp->events, cp->nconns, -1);
		return num_fds;
		
	#elif defined(_USE_DEVPOLL)
		num_fds = ioctl(cp->smfd, DP_POLL, &pollstuff);
		return (num_fds >= 0) ? num_fds : -1;

	#elif defined(_USE_POLL)
		num_fds = poll(cp->fds, cp->nconns, -1);
		return num_fds;
		
	#elif defined(_USE_WSAPOLL)
		num_fds = WSAPoll(cp->fdarray, cp->nconns, -1);
		return num_fds;
		
	#elif defined(_USE_WSAEVENTS)
		num_fds = WSAWaitForMultipleEvents(cp->nconns, cp->events, FALSE, WSA_INFINITE, TRUE);
		if (num_fds == WSA_WAIT_FAILED)
			return -1;
		WSAResetEvent(cp->events[num_fds - WSA_WAIT_EVENT_0]);
		return num_fds;

	#elif defined(_USE_SELECT)
		FD_ZERO(&cp->rdfds);
		fd_highest = 0;
		for (i = 0; i != cp->nconns; i++) {
			sess = cp->sessions[i];
			FD_SET(sess->sck, &cp->rdfds);
			if (sess->sck > fd_highest)
				fd_highest = sess->sck;
		}
		//printf("#before select(): nfds %d\n", cp->rdfds.fd_count);
		num_fds = select(fd_highest + 1, &cp->rdfds, NULL, NULL, NULL);
		//printf("#after select(): nfds %d\n", cp->rdfds.fd_count);
		/*if (!num_fds) {
			printf("WARNING: fd_count being manually set!\n");
			cp->rdfds.fd_count = cp->nconns - cp->n_connupdates;
			return 0;
		}*/
		//return num_fds;
		return (num_fds != -1) ? cp->nconns : -1;
	#endif
}
Esempio n. 17
0
bool Socket::EndSend(OverlappedTransferBuffer *sendBuffer)
{
	assert(sendBuffer);
	if (!sendBuffer)
		return false;

	// For the purposes of this send, mark the allocated length of the send buffer equal to the 
	// number of bytes the user had filled into the buffer.
	sendBuffer->buffer.len = sendBuffer->bytesContains;

#ifdef WIN32
	// Clear the event flag so that the completion of WSASend can trigger this and signal us.
	WSAResetEvent(sendBuffer->overlapped.hEvent);

	unsigned long bytesSent = 0;

	int ret;

	if (transport == SocketOverUDP)
		ret = WSASendTo(connectSocket, &sendBuffer->buffer, 1, (LPDWORD)&bytesSent, 0, (sockaddr*)&udpPeerAddress, sizeof(udpPeerAddress), &sendBuffer->overlapped, 0);
	else
		ret = WSASend(connectSocket, &sendBuffer->buffer, 1, (LPDWORD)&bytesSent, 0, &sendBuffer->overlapped, 0);

	int error = (ret == 0) ? 0 : Network::GetLastError();
	if (ret != 0 && error != WSA_IO_PENDING)
	{
		if (error != KNET_EWOULDBLOCK)
		{
			LOG(LogError, "Socket::EndSend() failed! Error: %s.", Network::GetErrorString(error).c_str());
			if (!IsUDPServerSocket())
				writeOpen = false;
		}
		DeleteOverlappedTransferBuffer(sendBuffer);
		return false;
	}

	bool success = queuedSendBuffers.Insert(sendBuffer);
	if (!success)
	{
		LOG(LogError, "queuedSendBuffers.Insert(send); failed!");
		///\todo WARNING: Deleting a buffer that is submitted to WSASend. This crashes. The alternative
		/// is to leak. Refactor so that the above queuedSendBuffers.Insert is tried for success before calling WSASend.
		DeleteOverlappedTransferBuffer(sendBuffer);
		return false;
	}
	return true;

#elif defined(UNIX) || defined(ANDROID)
	bool success = Send(sendBuffer->buffer.buf, sendBuffer->buffer.len);
	DeleteOverlappedTransferBuffer(sendBuffer);
	return success;
#endif
}
Esempio n. 18
0
File: gpoll.c Progetto: cosimoc/glib
static void
reset_fds (GPollFD fds[],
           int     num_pollees)
{
  gint i;

  for (i = 0; i < num_pollees; i++)
    {
      WSAResetEvent ((HANDLE) fds[i].fd);
      fds[i].events =  G_IO_IN | G_IO_OUT | G_IO_ERR;
      fds[i].revents = 0;
    }
}
Esempio n. 19
0
/*
 * AcceptThread will wait for AcceptEvents to be triggered and then start to recv data.
 */
DWORD WINAPI AcceptThread( LPVOID lp ) {
	DWORD			Flags;
	WSAEVENT		EventArray[1];
	DWORD			Index;
	DWORD			RecvBytes;

	LPSOCKET_INFORMATION SocketInfo;
	EventArray[0] = (WSAEVENT) lp;

	while( true ) {
		
		while( true ) {
			Index = WSAWaitForMultipleEvents(1, EventArray, false, WSA_INFINITE, true );

			if( Index == WSA_WAIT_FAILED ) {
				printf ( "WSAWaitForMultipleEvents failed.\n" );
				return WSAGetLastError();
			}
			if( Index != WAIT_IO_COMPLETION )
				break;
		}
		WSAResetEvent( EventArray[Index - WSA_WAIT_EVENT_0] );

		if( ( SocketInfo = ( LPSOCKET_INFORMATION ) GlobalAlloc( GPTR, sizeof( SOCKET_INFORMATION ) ) ) == NULL ) {
			printf ( "WSAWaitForMultipleEvents failed.\n" );
			return WSAGetLastError();
		} 
		SocketInfo->Socket = AcceptSocket;
		ZeroMemory( &( SocketInfo->Overlapped ), sizeof( WSAOVERLAPPED ) );  
		SocketInfo->BytesSEND		= 0;
		SocketInfo->BytesRECV		= 0;
		SocketInfo->DataBuf.len		= BUFFSIZE;
		SocketInfo->DataBuf.buf		= SocketInfo->Buffer;

		Flags = 0;
		/*  WSARecv with a WorkerRoutine. */
		printf("New connection.\n");

		/* Attempt to read from the client. Assuming they send us something in the beginning. 
		 * Otherwise, WSASend should be used to send them the song list. 
		 */
		if( WSARecv( SocketInfo->Socket, &( SocketInfo->DataBuf ), 1, &RecvBytes, &Flags, &( SocketInfo->Overlapped ), WorkerRoutine ) == SOCKET_ERROR ) {
			if( WSAGetLastError() != WSA_IO_PENDING ) {
				printf ( "WSARecv() failed.\n" );
				return WSAGetLastError();
			}
			
		}
	}
}
static SOCKET acceptAndRead(){
	  DWORD l_err;
	  
	    l_err =WSAWaitForMultipleEvents(1,(const HANDLE *)events,FALSE,WSA_INFINITE,FALSE);
		if (l_err ==WSA_WAIT_FAILED){
			printErrorMsg(_T("WSAWaitForMultipleEvents(), ACCEPT, failed with:"), WSAGetLastError(),1,1);
			return 0;
		}
		WSAResetEvent(events[0]);
		if (gTerminateNetwork){
			return 0;
		}
		SOCKET l_acc = accept(gsockListen, NULL, NULL );
		l_err = WSAGetLastError();
		if (l_acc == INVALID_SOCKET){
			if (l_err == WSAEWOULDBLOCK){
				return WSAEWOULDBLOCK;
			}
			printErrorMsg(_T("accept() failed with:"), l_err,1,1);
			return 0;
		}
		//assign event to this newly created socket
		l_err = WSAEventSelect(l_acc,events[1], FD_READ);
		if (l_err == SOCKET_ERROR) {  
			printf("WSAEventSelect(),FD_READ|| FD_WRITE|| FD_CLOSE, failed with error: %d\n", WSAGetLastError() );
			return 0;
		}
		//wait for incomming data
		l_err =WSAWaitForMultipleEvents(1,(const HANDLE *)(events+1),FALSE,WSA_INFINITE,FALSE);
		WSAResetEvent(*(events+1));
		if (l_err ==WSA_WAIT_FAILED){
			closesocket(l_acc);
			printErrorMsg(_T("WSAWaitForMultipleEvents(),FD_READ|| FD_WRITE|| FD_CLOSE, socket, failed with:"), WSAGetLastError(),1,1);
			return 0;
		}	
		return l_acc;
}
Esempio n. 21
0
//---------------------------------------
bool TCPAcceptSocket::Accept(TCPSocket& po_rxConnection)
{
	if(!IsOpen()) return false;
	po_rxConnection.Close();
	WSAResetEvent(m_hEvent);

	sockaddr xA;
	int iSize=sizeof(xA);
	po_rxConnection.m_xSock=WSAAccept(m_xSock,&xA,&iSize,NULL,0);
	if((po_rxConnection.m_xSock==INVALID_SOCKET)||(po_rxConnection.m_xSock==WSAEWOULDBLOCK))
		return false;
	po_rxConnection.m_hClose=WSACreateEvent();
	WSAEventSelect(po_rxConnection.m_xSock,po_rxConnection.m_hClose,FD_CLOSE);
	return true;
}
Esempio n. 22
0
int nbListenerReader(void *session){
  NB_Listener *sel=(NB_Listener *)session;

#if defined(WIN32)
  int mode=0;
  WSAResetEvent(sel->hEvent);
  WSAEventSelect((SOCKET)sel->fildes,sel->hEvent,0);
  ioctlsocket((SOCKET)sel->fildes,FIONBIO,&mode); // Make the socket blocking
#endif 
  (sel->handler)(sel->context,sel->fildes,sel->session);
#if defined(WIN32)
  WSAEventSelect((SOCKET)sel->fildes,sel->hEvent,FD_ACCEPT|FD_READ);
#endif
  return(0);
  }
Esempio n. 23
0
File: Os.c Progetto: broonie/ohNet
int32_t OsNetworkInterrupt(THandle aHandle, int32_t aInterrupt)
{
    int32_t err = 0;
    OsNetworkHandle* handle = (OsNetworkHandle*)aHandle;
    OsMutexLock(handle->iCtx->iMutex);
    handle->iInterrupted = aInterrupt;
    if (aInterrupt != 0) {
        (void)WSASetEvent(handle->iEvent);
    }
    else {
        (void)WSAResetEvent(handle->iEvent);
    }
    OsMutexUnlock(handle->iCtx->iMutex);
    return err;
}
Esempio n. 24
0
static void ready_io(ErlDrvData edd, ErlDrvEvent ev)
{
  dnssd_drv_t* dd = (dnssd_drv_t*) edd;
  DNSServiceErrorType err;
#ifdef __WIN32__
  WSAResetEvent(dd->event);
#endif
  err = DNSServiceProcessResult(dd->sd_ref);
  if (err != kDNSServiceErr_NoError) {
    ErlDrvTermData spec[] = {ERL_DRV_PORT, dd->term_port,
			     ERL_DRV_ATOM, dd->term_error,
			     ERL_DRV_INT, err,
			     ERL_DRV_TUPLE, 3};
    driver_output_term(dd->erl_port, spec, sizeof(spec) / sizeof(spec[0]));
  }
}
Esempio n. 25
0
static void
os_sockQueryInterfaceStatusReset(
    os_sockQueryInterfaceStatusInfo *info)
{
    HANDLE hand = NULL;
    DWORD ret;

    (void)WSAResetEvent(info->overlap.hEvent);
    (void)CancelIPChangeNotify(&info->overlap);
    ret = NotifyAddrChange(&hand, &info->overlap);
    if (ret != NO_ERROR) {
        if (WSAGetLastError() != WSA_IO_PENDING) {
            os_report(OS_ERROR, "os_sockQueryInterfaceStatusReset", __FILE__, __LINE__, 0,
                          "Failed to reset notifications for network interface address changes");
        }
    }
}
Esempio n. 26
0
//sends a message, or part of one
int CPassiveSock::Send(const void * const lpBuf, const int Len)
{
    WSAOVERLAPPED os;
    WSABUF buffers[2];
    WSAEVENT hEvents[2] = {NULL,NULL};
    DWORD
    dwWait,
    bytes_sent=0,
    msg_flags = 0;

    // Setup up the events to wait on
    hEvents[1] = write_event;
    hEvents[0] = m_hStopEvent;
    // Setup the buffers array
    buffers[0].buf = (char *)lpBuf;
    buffers[0].len = Len;
    msg_flags = 0;
    dwWait = 0;
    int rc;

    LastError = 0;

    // Create the overlapped I/O event and structures
    memset(&os, 0, sizeof(OVERLAPPED));
    os.hEvent = write_event;
    WSAResetEvent(read_event);
    rc = WSASend(ActualSocket, buffers, 1, &bytes_sent, 0, &os, NULL);
    LastError=WSAGetLastError();
    if ((rc == SOCKET_ERROR) && (LastError == WSA_IO_PENDING))  // Write in progress
    {
        CTimeSpan TimeLeft = SendEndTime - CTime::GetCurrentTime();
        dwWait = WaitForMultipleObjects(2, hEvents, false, (DWORD)TimeLeft.GetTotalSeconds()*1000);
        if (dwWait == WAIT_OBJECT_0+1) // I/O completed
        {
            if (WSAGetOverlappedResult(ActualSocket, &os, &bytes_sent, true, &msg_flags))
                return bytes_sent;
        }
    }
    else if (!rc) // if rc is zero, the read was completed immediately
    {
        if (WSAGetOverlappedResult(ActualSocket, &os, &bytes_sent, true, &msg_flags))
            return bytes_sent;
    }
    return SOCKET_ERROR;
}
Esempio n. 27
0
/*------------------------------------------------------------------------------------------------------------------
-- FUNCTION:	TimerThread
--
-- DATE:		Febuary 6th, 2016
--
-- REVISIONS:
--
-- DESIGNER:	Ruoqi Jia
--
-- PROGRAMMER:	Ruoqi Jia
--
-- INTERFACE:	DWORD WINAPI TimerThread(LPVOID lpParameter)
--
-- RETURNS: void
--
-- NOTES: Sets a timer for the UDP thread. If a packet didnt arrive in the given time it will timeout and close the
--			socket. It is used for when packets are dropped due to the nature of UDP and we need to determine if there
--			are anymore incoming traffics coming in to determine the end of transmission.
--------------------------------------------------------------------------------------------------------------------*/
DWORD WINAPI TimerThread(LPVOID lpParameter)
{
	LPSOCKET_INFORMATION SOCKET_INFO;
	WSAEVENT e[1];
	e[0] = TimerEvent;
	SOCKET_INFO = (LPSOCKET_INFORMATION)lpParameter;
	while (TRUE)
	{
		if (WSAWaitForMultipleEvents(1, e, FALSE, 100, FALSE) == WSA_WAIT_TIMEOUT)
		{
			EndOfTransmission = TRUE;
			WSACloseEvent(e[0]);
			return FALSE;
		}
		WSAResetEvent(e[0]);
	}
	return TRUE;
}
Esempio n. 28
0
static int transport_bio_simple_read(BIO* bio, char* buf, int size)
{
	int error;
	int status = 0;
	WINPR_BIO_SIMPLE_SOCKET* ptr = (WINPR_BIO_SIMPLE_SOCKET*) BIO_get_data(bio);

	if (!buf)
		return 0;

	BIO_clear_flags(bio, BIO_FLAGS_READ);

	WSAResetEvent(ptr->hEvent);

	status = _recv(ptr->socket, buf, size, 0);

	if (status > 0)
	{
		return status;
	}

	if (status == 0)
	{
		BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
		return 0;
	}

	error = WSAGetLastError();

	if ((error == WSAEWOULDBLOCK) || (error == WSAEINTR) ||
		(error == WSAEINPROGRESS) || (error == WSAEALREADY))
	{
		BIO_set_flags(bio, (BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY));
	}
	else
	{
		BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY);
	}

	return -1;
}
Esempio n. 29
0
File: Os.c Progetto: broonie/ohNet
DWORD interfaceChangeThread(LPVOID aArg)
{
    InterfaceChangeObserver* obs = (InterfaceChangeObserver*)aArg;
    while (obs->iShutdown == 0) {
        DWORD ret = WAIT_FAILED;
        DWORD bytes;
        if (SOCKET_ERROR == WSAIoctl(obs->iSocket, SIO_ADDRESS_LIST_CHANGE,
                                       NULL, 0, NULL, 0, &bytes, NULL, NULL)
            && WSAEWOULDBLOCK == WSAGetLastError()) {
            HANDLE handles[2];
            handles[0] = obs->iEvent;
            handles[1] = obs->iShutdownEvent;
            ret = WSAWaitForMultipleEvents(2, &handles[0], FALSE, INFINITE, FALSE);
        }
        if (WAIT_OBJECT_0 == ret) {
            (obs->iCallback)(obs->iArg);
            (void)WSAResetEvent(obs->iEvent);
        }
    }
    (void)ReleaseSemaphore(obs->iSem, 1, NULL);
    return 0;
}
Esempio n. 30
0
void NET_BaseSocket::PrivateOnReceived()
{
	if (!m_created)
		return;
	DWORD to_read, received = 0, flags = 0, space;
	OP( ioctlsocket(m_socket, FIONREAD, &to_read), "NET_BaseSocket::PrivateOnReceived, ioctlsocket" );
	bool repeat = to_read > m_in_buf_size;
	if (repeat)
		to_read = m_in_buf_size;
	m_in_wsa_buf.buf = m_in_buf;
	m_in_wsa_buf.len = to_read;
	m_last_error = 0;
	OP2( WSARecv(m_socket, &m_in_wsa_buf, 1, &received, &flags, m_read_thread.GetOverlapped(), NULL), m_last_error != WSA_IO_PENDING, "NET_BaseSocket::PrivateOnReceived, WSARecv" );
	if (m_last_error == WSA_IO_PENDING)
	{
		LOG_V0_AddMessage(LOG_V0_DEBUG_MESSAGE, TXT("%s::PrivateOnReceived -- PENDING") << GetName());
		WSAResetEvent(m_read_thread.GetOverlapped()->hEvent);
		return;
	}
	{
		MutexWrap in_write_access(m_in_data->m_w_mutex);
		{
			MutexWrap in_read_access(m_in_data->m_r_mutex);
			space = m_in_data->SpaceFor(RingBuffer_WRITE);
		}
		if (space < received)
			OnError("NET_BaseSocket::PrivateOnReceived -- space < received !!!");
		else
		{
			LOG_V0_AddMessage(LOG_V0_DEBUG_MESSAGE, TXT("%s -- получено %d") << GetName() << received);
			m_in_data->Write(m_in_buf, received);
		}
	}

	OnReceived();
	if (repeat || received < to_read)
		WSASetEvent(m_read_thread.Event(0));
}