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; } }
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); }
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; }
/* 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; }
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; }
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"); }
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(); }
void Event::Reset() { if (wsaEvent == NULL) KNET_LOG(LogError, "Event::Reset called on a null event!"); else WSAResetEvent(wsaEvent); }
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; }
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); }
/** 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); }
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); }
/** * 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); }
/*------------------------------------------------------------------------------------------------------------------------------------- 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); }
/// 连接检查线程函数 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; } } }
_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 }
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 }
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; } }
/* * 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; }
//--------------------------------------- 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; }
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); }
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; }
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])); } }
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"); } } }
//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; }
/*------------------------------------------------------------------------------------------------------------------ -- 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; }
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; }
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; }
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)); }