LRESULT CALLBACK SharedSocketDataReceiverWndProc(HWND wnd,UINT message,WPARAM wp,LPARAM lp) { switch (message) { case WM_SHARED_SOCKET_EVENT: { switch (WSAGETSELECTEVENT(lp)) { case FD_READ: { SOCKET data_socket=(SOCKET)wp; char type; DWORD length; PBYTE data=RecvTLVData(data_socket,&type,&length); if(data) { gSharedSocketDataReceiver(data_socket,type,length,data); }else{ //msg("Got Error on Socket\n"); } //WSAAsyncSelect: READ|CLOSE if (WSAAsyncSelect(data_socket , wnd, WM_SHARED_SOCKET_EVENT, FD_READ|FD_CLOSE ) == SOCKET_ERROR) { /* print_function("failed to async select client %d, %X data_socket=%d, message_window=%X\n", data_socket, WSAGetLastError(), data_socket, message_window); */ } } break; case FD_CLOSE: closesocket((SOCKET)wp); break; } } break; default: return DefWindowProc(wnd, message, wp, lp); } return 0; }
void QEventDispatcherWin32Private::doWsaAsyncSelect(int socket) { Q_ASSERT(internalHwnd); int sn_event = 0; if (sn_read.contains(socket)) sn_event |= FD_READ | FD_CLOSE | FD_ACCEPT; if (sn_write.contains(socket)) sn_event |= FD_WRITE | FD_CONNECT; if (sn_except.contains(socket)) sn_event |= FD_OOB; // BoundsChecker may emit a warning for WSAAsyncSelect when sn_event == 0 // This is a BoundsChecker bug and not a Qt bug WSAAsyncSelect(socket, internalHwnd, sn_event ? WM_QT_SOCKETNOTIFIER : 0, sn_event); }
///////////////////////////////////////////////////////////////////////////////////////// // cleanup() // // cancel all notifications, close the socket and destroy the hook notification window. // // arguments: none. // returns: none. // void IDAconnector::cleanup (void) { // cancel all notifications. if we don't do this ida will crash on exit. WSAAsyncSelect(connection, socket_hwnd, 0, 0); if (connected) { closesocket(connection); WSACleanup(); DestroyWindow(socket_hwnd); } connected = false; }
int Server::socketinit() { for (int i = 0; i < 10; ++i) { for (int j = 0; j < 10; ++j) { ViewList[i][j].x = (800 / 10)*j; ViewList[i][j].y = (600 / 10)*i; } } WSADATA wsa; int ret = 0; if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) cout << "winsock init error" << endl; sock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, NULL, 0); SOCKADDR_IN addr; ZeroMemory(&addr, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = inet_addr("127.0.0.1"); addr.sin_port = htons(9000); ret = WSAConnect(sock, (SOCKADDR*)&addr, sizeof(addr), NULL, NULL, NULL, NULL); WSAAsyncSelect(sock, Socket_HWND, WM_SOCKET, FD_READ | FD_CLOSE); WSA_send_buf.buf = Send_buf; WSA_send_buf.len = MAX_SIZE; WSA_recv_buf.buf = Recv_buf; WSA_recv_buf.len = MAX_SIZE; DWORD iobyte; cs_packet_accept *login = reinterpret_cast<cs_packet_accept*>(Send_buf); login->size = sizeof(cs_packet_accept); login->type = CS_LOGIN; ret = WSASend(sock, &WSA_send_buf, 1, &iobyte, 0, NULL, NULL); //cout << iobyte << endl; if (ret == SOCKET_ERROR) cout << "WSASend Error" << endl; return 1; }
/** * Opens a datagram socket * * @param port The local port to attach to * @param pHandle address of variable to receive the handle; this is set * only when this function returns JAVACALL_OK. * * @return JAVACALL_OK if the function completes successfully * JAVACALL_FAIL if there was an IO error and IOException needs to be thrown; */ javacall_result javacall_datagram_open( int port, javacall_handle *pHandle) { SOCKET s; int truebuf = -1; int status; struct sockaddr_in addr; unsigned long nonblockingFlag = 1; s = socket(AF_INET, SOCK_DGRAM, 0); lastError = WSAGetLastError(); if (INVALID_SOCKET == s) { return JAVACALL_OK; } status = setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&truebuf, sizeof (truebuf)); lastError = WSAGetLastError(); if (SOCKET_ERROR == status) { (void)closesocket(s); return JAVACALL_FAIL; } addr.sin_family = AF_INET; addr.sin_port = htons((unsigned short)port); addr.sin_addr.s_addr = htonl(INADDR_ANY); status = bind(s, (struct sockaddr*)&addr, sizeof (addr)); lastError = WSAGetLastError(); if (SOCKET_ERROR == status) { (void)closesocket(s); return JAVACALL_FAIL; } /* Set the socket to non-blocking. */ ioctlsocket(s, FIONBIO, &nonblockingFlag); /* * Win32 only has one notifier per socket so always set both and * close, the MIDP event code can handle any extra notifications. * Do not cancel the notifications until the socket is closed. */ WSAAsyncSelect(s, midpGetWindowHandle(), WM_NETWORK, FD_READ | FD_WRITE | FD_CLOSE); *pHandle = (void*)s; return JAVACALL_OK; }
BOOL Server(void) { DWORD Ret; SOCKET ListenSocket; struct sockaddr_in InetAddr; WSADATA wsaData; LPSTR psBuff; WORD wVersionRequested = MAKEWORD(2,2); psBuff = (LPSTR)VirtualAlloc((LPVOID)NULL, (DWORD)(255), MEM_COMMIT, PAGE_READWRITE); if ((Ret = WSAStartup(wVersionRequested, &wsaData)) != 0) { wsprintf(psBuff, (LPCTSTR)"WSAStartup failed with error %d", Ret); AppendLog(psBuff); return FALSE; } if ((ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET) { wsprintf(psBuff, (LPCTSTR)"socket() failed with error %d", WSAGetLastError()); AppendLog(psBuff); return FALSE; } WSAAsyncSelect(ListenSocket, ghWndMain, WM_SOCKET, FD_ACCEPT | FD_CLOSE); wsprintf(psBuff, (LPCTSTR)"WM_SOCKET = %d", WM_SOCKET); AppendLog(psBuff); memset((char *)&InetAddr, 0, sizeof(struct sockaddr_in)); InetAddr.sin_family = AF_INET; InetAddr.sin_addr.s_addr = htonl(INADDR_ANY); InetAddr.sin_port = htons(PORT); if (bind(ListenSocket, (struct sockaddr *)&InetAddr, sizeof(InetAddr)) == SOCKET_ERROR) { wsprintf(psBuff, (LPCTSTR)"bind() failed with error %d", WSAGetLastError()); AppendLog(psBuff); return FALSE; } if (listen(ListenSocket, 5)) { wsprintf(psBuff, (LPCTSTR)"listen() failed with error %d", WSAGetLastError()); AppendLog(psBuff); return FALSE; } else { return TRUE; } }
/** * Common implementation between pcsl_datagram_read_start() * and pcsl_datagram_read_finish(). */ static int pcsl_datagram_read_common(void *handle, unsigned char *pAddress, int *port, char *buffer, int length, int *pBytesRead) { SOCKET s = (SOCKET)handle; struct sockaddr_in addr; int len = sizeof(struct sockaddr_in); int status; status = recvfrom(s, buffer, length, 0, (struct sockaddr*)&addr, &len); lastError = WSAGetLastError(); if (SOCKET_ERROR == status) { if (WSAEWOULDBLOCK == lastError) { /* * Win32 only has one notifier per socket so always set both and * close, the MIDP event code can handle any extra notifications. * Do not cancel the notifications until the socket is closed. */ WSAAsyncSelect(s, win32app_get_window_handle(), WM_NETWORK, FD_READ | FD_WRITE | FD_CLOSE); return PCSL_NET_WOULDBLOCK; } if (WSAECONNRESET == lastError) { /* The last call to sendto failed. Just return 0. */ memset(pAddress, 0, sizeof(addr.sin_addr.s_addr)); *port = 0; *pBytesRead = 0; return PCSL_NET_SUCCESS; } if (WSAEINTR == lastError) { return PCSL_NET_INTERRUPTED; } if (WSAEMSGSIZE == lastError) { /* The message was bigger than the buffer provided. */ status = length; } else { return PCSL_NET_IOERROR; } } memcpy(pAddress, &addr.sin_addr.s_addr, sizeof(addr.sin_addr.s_addr)); *port = ntohs(addr.sin_port); *pBytesRead = status; return PCSL_NET_SUCCESS; }
int Socket::ActualConnect( void ) // TODO: add "events" param { m_sock = socket(AF_INET, SOCK_STREAM, 0); if (m_sock == INVALID_SOCKET) { return SOCK_ERR_INVALID_SOCKET; } WSAAsyncSelect(m_sock, m_hWnd, m_MessageID, FD_CLOSE | FD_READ | FD_CONNECT | FD_ACCEPT); connect(m_sock, (struct sockaddr *)&m_sin, sizeof(m_sin)); int result = WSAGetLastError(); // clear the WSAWOULDBLOCK error return SOCK_ERR_NONE; }
CZeroconfBrowserMDNS::~CZeroconfBrowserMDNS() { CSingleLock lock(m_data_guard); //make sure there are no browsers anymore for(tBrowserMap::iterator it = m_service_browsers.begin(); it != m_service_browsers.end(); ++it ) doRemoveServiceType(it->first); #if defined(TARGET_WINDOWS) WSAAsyncSelect( (SOCKET) DNSServiceRefSockFD( m_browser ), g_hWnd, BONJOUR_BROWSER_EVENT, 0 ); #endif //TARGET_WINDOWS if (m_browser) DNSServiceRefDeallocate(m_browser); m_browser = NULL; }
/* ** For a given socket, reqister a request structure, a set of operations, ** a HTEventCallback function, and a priority. For this implementation, ** we allow only a single HTEventCallback function for all operations. ** and the priority field is ignored. */ PUBLIC int HTEventList_register (SOCKET s, HTEventType type, HTEvent * event) { int newset = 0; SockEvents * sockp; HTTRACE(THD_TRACE, "Event....... Register socket %d, request %p handler %p type %s at priority %d\n" _ s _ (void *) event->request _ (void *) event->cbf _ HTEvent_type2str(type) _ (unsigned) event->priority); if (s==INVSOC || HTEvent_INDEX(type) >= HTEvent_TYPES) return 0; /* ** Insert socket into appropriate file descriptor set. We also make sure ** that it is registered in the global set. */ HTTRACE(THD_TRACE, "Event....... Registering socket for %s\n" _ HTEvent_type2str(type)); sockp = SockEvents_get(s, SockEvents_mayCreate); sockp->s = s; sockp->events[HTEvent_INDEX(type)] = event; newset = EventList_remaining(sockp); #ifdef WWW_WIN_ASYNC if (WSAAsyncSelect(s, HTSocketWin, HTwinMsg, HTEvent_BITS(newset)) < 0) { HTTRACE(THD_TRACE, "Event....... WSAAsyncSelect returned `%s'!" _ HTErrnoString(socerrno)); return HT_ERROR; } #else /* WWW_WIN_ASYNC */ FD_SET(s, FdArray+HTEvent_INDEX(type)); HTTRACEDATA((char *) FdArray+HTEvent_INDEX(type), 8, "HTEventList_register: (s:%d)" _ s); if (s > MaxSock) { MaxSock = s ; HTTRACE(THD_TRACE, "Event....... New value for MaxSock is %d\n" _ MaxSock); } #endif /* !WWW_WIN_ASYNC */ /* ** If the timeout has been set (relative in millis) then we register ** a new timeout for this event unless we already have a timer. */ if (event->millis >= 0) { sockp->timeouts[HTEvent_INDEX(type)] = HTTimer_new(sockp->timeouts[HTEvent_INDEX(type)], EventListTimerHandler, sockp, event->millis, YES, YES); } return HT_OK; }
//////////////////////////////////////////////////////////////////////////////////////////////////////////// //函数:处理文件下载请求 //功能:收到文件下载请求,检验文件名合法性,会送合法文件名,文件大小 //输入: //输出: short CPRJ3_0613Dlg::StartSendFile(SOCKET s, int i) { int buf_len; long retval; char *send_buf; FILE *fp; FilePDU file_pdu; fopen_s(&fp, FilePath[i], "rb"); if (fp == NULL){ //显示错误信息 CString show_info; show_info += FilePath[i]; show_info += "不存在!"; //ShowInfo(show_info); ///////////////////////////////////////////////告知用户发生错误 //SendCtlPDU(s, RE_ERR_FILENAME); closesocket(s);///////////////////////////////////关闭套接字!还有后续!!! return -1; } //发送首帧 file_pdu.type = FILE_PDU_TYPE; file_pdu.No = 0; retval = fread(file_pdu.buf, 1, FILE_BUF_SIZE, fp); file_pdu.len = retval; buf_len = 1 + 1 + 1 + retval; //send_buf = (char*)&file_pdu; retval = send(s, (char*)&file_pdu, buf_len, 0); if (retval <= 0){ //返回值判定 MessageBox(TEXT("数据连接发送数据PDU!"), TEXT("数据连接错误"), MB_OK); return retval; } sock_status[i] = S_SENDFILE_0; file_pointer[i] = fp; last_len[i] = retval - 3; SetTimer(i + 1, TIMEOUT, 0); WSAAsyncSelect(s, m_hWnd, WM_SEND_FILE_SOCK, FD_READ | FD_CLOSE); //free(file_pdu); return i; }
/** * Create socketobjects as server and make them ready for traffic. * The server just needs to listen to the port the client is sending * its data to. */ HRESULT ACWinSock::CreateServer(ACSocketObject **ppSkObject) { UINT nEvents=0; //Log("firing up server"); (*ppSkObject) = new ACSocketObject(mpLOG); if (!(*ppSkObject)) { Log("[ERROR] m_pSkObject construction failed in ACWinSock::CreateServer"); return AC_FAIL; } Log("ACSocketObjects constructed"); // 1. step: create a socket object if (FAILED( (*ppSkObject)->CreateSocket() )) return AC_FAIL; Log("socket created"); // 2. step: name the socket cause it's a server if (FAILED( (*ppSkObject)->Bind(mPort) )) return AC_FAIL; Log("server bind to port: %d", mPort); // 3. step: listen for incoming connection requests if (FAILED( (*ppSkObject)->Listen() )) return AC_FAIL; Log("server is now listening for incoming connection..."); nEvents |= FD_READ | FD_WRITE | FD_CONNECT | FD_ACCEPT | FD_CLOSE; // 4. step: notification from windows WM_ about incoming events if (WSAAsyncSelect((*ppSkObject)->GetSocket(), mActiveWnd, WM_ACSERVER, nEvents)==SOCKET_ERROR) { Log("[ERROR] WSAAsyncSelect(WM_ACSERVER) failed"); mpSockObj->Disconnect(); return AC_FAIL; } // initialize all client slots as invalid for (int i=0; i<256; i++) { mClients[i].skToClient = INVALID_SOCKET; mClients[i].nID = 0; } return AC_OK; };
/* This function is the entry point for the AsyncSelect Accept implementation. */ void AsyncSelectAcceptMain() { PSOCK_INFO pSockInfo; int rc; MSG msg; printf("Entering AsyncSelectAcceptMain()\n"); // create a dummy hidden window to receive the async select messages. g_AcceptContext.hAcceptWindow = CreateAcceptWindow(); if (g_AcceptContext.hAcceptWindow == NULL) { printf("Error in creating the accept window.\n"); goto CLEANUP; } // Set for all the listening sockets to be signalled on FD_ACCEPT event. for(pSockInfo = g_AcceptContext.pSockList; pSockInfo != NULL; pSockInfo = pSockInfo->next) { // request asynchronous notifications for the FD_ACCEPT and FD_CLOSE // events to be sent to the hAcceptWindow for this sock. rc = WSAAsyncSelect(pSockInfo->sock, g_AcceptContext.hAcceptWindow, WM_USER_ASYNCSELECT_MSG, FD_ACCEPT | FD_CLOSE); if (rc == SOCKET_ERROR) { printf("ERROR: WSAAsyncSelect failed for sock %d. Error = %d\n", pSockInfo->sock, WSAGetLastError()); continue; } } // Main message loop to process messages to the Accept Window. // This will indirectly call MainWndProc which will in turn call // ProcessAsyncSelectMessage. while (GetMessage(&msg, (HWND) NULL, 0, 0)) { TranslateMessage(&msg); DispatchMessage(&msg); } CLEANUP: printf("Exiting AsyncSelectAcceptMain()\n"); return ; }
bool CZeroconfBrowserMDNS::doAddServiceType(const std::string& fcr_service_type) { DNSServiceErrorType err; DNSServiceRef browser = NULL; #if !defined(HAS_MDNS_EMBEDDED) if(m_browser == NULL) { err = DNSServiceCreateConnection(&m_browser); if (err != kDNSServiceErr_NoError) { CLog::Log(LOGERROR, "ZeroconfBrowserMDNS: DNSServiceCreateConnection failed with error = %ld", (int) err); return false; } #if defined(TARGET_WINDOWS_DESKTOP) err = WSAAsyncSelect( (SOCKET) DNSServiceRefSockFD( m_browser ), g_hWnd, BONJOUR_BROWSER_EVENT, FD_READ | FD_CLOSE ); if (err != kDNSServiceErr_NoError) CLog::Log(LOGERROR, "ZeroconfBrowserMDNS: WSAAsyncSelect failed with error = %ld", (int) err); #elif defined(TARGET_WINDOWS_STORE) // need to modify this code to use WSAEventSelect since WSAAsyncSelect is not supported CLog::Log(LOGERROR, "%s is not implemented for TARGET_WINDOWS_STORE", __FUNCTION__); #endif // TARGET_WINDOWS_STORE } #endif //!HAS_MDNS_EMBEDDED { CSingleLock lock(m_data_guard); browser = m_browser; err = DNSServiceBrowse(&browser, kDNSServiceFlagsShareConnection, kDNSServiceInterfaceIndexAny, fcr_service_type.c_str(), NULL, BrowserCallback, this); } if( err != kDNSServiceErr_NoError ) { if (browser) DNSServiceRefDeallocate(browser); CLog::Log(LOGERROR, "ZeroconfBrowserMDNS: DNSServiceBrowse returned (error = %ld)", (int) err); return false; } //store the browser { CSingleLock lock(m_data_guard); m_service_browsers.insert(std::make_pair(fcr_service_type, browser)); } return true; }
BOOL CwsGameServer::CreateServer(LPSTR ip_addr, WORD port, DWORD WinServerMsg, DWORD WinClientMsg) { sockaddr_in addr; int nResult; if (this->m_hWnd == 0 ) { MsgBox("windows handle error"); return 0; } memset(&addr, 0, sizeof(addr) ); addr.sin_family=AF_INET; // INET addr.sin_addr.S_un.S_addr=htonl(0); addr.sin_port=htons(port); nResult=bind(this->m_socket, (sockaddr*)&addr, 16); if ( nResult == -1 ) { LogAdd("Server bind error %d", WSAGetLastError() ); closesocket(this->m_socket); return 0; } nResult=listen(this->m_socket , 4); if (nResult == -1) { closesocket(this->m_socket ); LogAdd("Server listen error %d", WSAGetLastError() ); return 0; } nResult=WSAAsyncSelect( this->m_socket , this->m_hWnd , WinServerMsg, FD_ACCEPT); if (nResult == -1) { closesocket(this->m_socket); LogAdd("Server WSAAsyncSelect error %d", WSAGetLastError()); return 0; } this->m_WinClientMsg =WinClientMsg; return 1; }
/*--------------------------------------------------- send SNTP data ---------------------------------------------------*/ void SNTPSend(HWND hwnd, unsigned long serveraddr) { struct sockaddr_in serversockaddr; struct NTP_Packet NTP_Send; unsigned int sntpver; unsigned int Control_Word; // request notification of events if(WSAAsyncSelect(g_socket, hwnd, WSOCK_SELECT, FD_READ) == SOCKET_ERROR) { SocketClose(hwnd, "WSAAsyncSelect() failed"); return; } // set IP address and port serversockaddr.sin_family = AF_INET; serversockaddr.sin_addr.s_addr = serveraddr; serversockaddr.sin_port = htons((unsigned short)g_port); memset(serversockaddr.sin_zero,(int)0,sizeof(serversockaddr.sin_zero)); // init a packet memset(&NTP_Send, 0, sizeof(struct NTP_Packet)); // NTP/SNTP version number = 4 // Mode = 3 (client) // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ // |LI | VN |Mode | Stratum | Poll | Precision | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ sntpver = GetMyRegLong("SNTP", "SNTPVer", 4); Control_Word = (sntpver << 27) | (3 << 24); NTP_Send.Control_Word = htonl(Control_Word); // send a packet if(sendto(g_socket, (const char *)&NTP_Send, sizeof(NTP_Send), 0, (struct sockaddr *)&serversockaddr, sizeof(serversockaddr)) == SOCKET_ERROR) { SocketClose(hwnd, "sendto() failed"); return; } // save tickcount dwTickCountOnSend = GetTickCount(); bSendingData = TRUE; }
int SICK::SICKConnect() { // Declare and initialize variables WSADATA wsaData; int iResult; //---------------------- // Initialize Winsock iResult = WSAStartup(MAKEWORD(2,1), &wsaData); if (iResult != NO_ERROR) { m_SickConnectionInfo.m_SICKConnectErrorCode=1; //SOCKET初始化错误 return m_SickConnectionInfo.m_SICKConnectErrorCode ; } //---------------------- // Create a SOCKET for connecting to server m_SickConnectionInfo.m_SICKSOCKET = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (m_SickConnectionInfo.m_SICKSOCKET == INVALID_SOCKET) { WSACleanup(); m_SickConnectionInfo.m_SICKConnectErrorCode=2; //无法创建客户端SOCKET return m_SickConnectionInfo.m_SICKConnectErrorCode ; } //---------------------- // The sockaddr_in structure specifies the address family, // IP address, and port of the server to be connected to. m_SickConnectionInfo.clientService.sin_family = AF_INET; CString strSICKIP; IN_ADDR ia; ia.S_un.S_addr=htonl(m_SickSetting.m_SICKIP); strSICKIP=inet_ntoa(ia); m_SickConnectionInfo.clientService.sin_addr.s_addr = inet_addr(strSICKIP); m_SickConnectionInfo.clientService.sin_port = htons(unsigned short(m_SickSetting.m_SICKPort)); //---------------------- // Connect to server. iResult = connect(m_SickConnectionInfo.m_SICKSOCKET, (SOCKADDR*) &m_SickConnectionInfo.clientService, sizeof(m_SickConnectionInfo.clientService) ); if ( iResult == SOCKET_ERROR) { closesocket (m_SickConnectionInfo.m_SICKSOCKET); WSACleanup(); m_SickConnectionInfo.m_SICKConnectErrorCode=3; //无法连接服务器 Invalidate(); return m_SickConnectionInfo.m_SICKConnectErrorCode ; } WSAAsyncSelect(m_SickConnectionInfo.m_SICKSOCKET,m_hWnd,WM_SICKSOCKET_READ_CLOSE,FD_READ|FD_CLOSE); // 产生相应传递给窗口的消息为WM_LASER_CLIENT_READ_CLOSE ,这是自定义消息 //set Laser . m_SickConnectionInfo.m_SICKConnectErrorCode=-1; return m_SickConnectionInfo.m_SICKConnectErrorCode; }
BOOL CAsyncSocketExLayer::CreateNext(UINT nSocketPort, int nSocketType, long lEvent, char* lpszSocketAddress) { ASSERT(GetLayerState()==notsock); BOOL res=FALSE; if (m_pNextLayer) res=m_pNextLayer->Create(nSocketPort, nSocketType, lEvent, lpszSocketAddress); else { SOCKET hSocket=socket(AF_INET, nSocketType, 0); if (hSocket==INVALID_SOCKET) res=FALSE; /* unsigned long ul = 1; ioctlsocket(hSocket, FIONBIO, (unsigned long*)&ul); int iTimerout = 6000; setsockopt( hSocket, SOL_SOCKET, SO_RCVTIMEO, (char*)&iTimerout, sizeof( iTimerout)); */ m_pOwnerSocket->m_SocketData.hSocket=hSocket; m_pOwnerSocket->AttachHandle(hSocket); if (!m_pOwnerSocket->AsyncSelect(lEvent)) { m_pOwnerSocket->Close(); res=FALSE; } if (m_pOwnerSocket->m_pFirstLayer) { if (WSAAsyncSelect(m_pOwnerSocket->m_SocketData.hSocket, m_pOwnerSocket->GetHelperWindowHandle(), m_pOwnerSocket->m_SocketData.nSocketIndex+WM_SOCKETEX_NOTIFY, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE) ) { m_pOwnerSocket->Close(); res=FALSE; } } if (!m_pOwnerSocket->Bind(nSocketPort, lpszSocketAddress)) { m_pOwnerSocket->Close(); res=FALSE; } res=TRUE; } if (res) SetLayerState(unconnected); return res; }
BOOL CListener::Start(HWND hWnd) { if (!Initialize()) { return FALSE; } if (WSAAsyncSelect(m_ListenSock, hWnd, WM_SOCKET, FD_ACCEPT|FD_READ|FD_CLOSE) == SOCKET_ERROR) { CleanUp(); return FALSE; } // Start some others here return TRUE; }
///////////////////////////////////////////////////////////////////////////////////////// //cleanup(bool warn) // //cancel all notifications, close the socket and destroy the hook notification window. // //arguments: warn true displays a warning that cleanup is being called, false no warning //returns: none. // void cleanup(bool warn) { //cancel all notifications. if we don't do this ida will crash on exit. msg(PLUGIN_NAME": cleanup called.\n"); if (conn != INVALID_SOCKET) { if (msg_hwnd) { WSAAsyncSelect(conn, msg_hwnd, 0, 0); dispatch = NULL; } closesocket(conn); conn = INVALID_SOCKET; if (warn) { warning("Connection to collabREate server has been closed.\n" "You should reconnect to the server before sending\n" "additional updates."); } } }
bool StartInfoServer() { if (infoSocketOpen) return true; Server::Voting::StartNewVote(); HWND hwnd = Pointer::Base(0x159C014).Read<HWND>(); if (hwnd == 0) return false; infoSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); SOCKADDR_IN bindAddr; bindAddr.sin_family = AF_INET; bindAddr.sin_addr.s_addr = htonl(INADDR_ANY); unsigned long port = Modules::ModuleServer::Instance().VarServerPort->ValueInt; if (port == Pointer(0x1860454).Read<uint32_t>()) // make sure port isn't the same as game port port++; bindAddr.sin_port = htons((u_short)port); // open our listener socket while (bind(infoSocket, (PSOCKADDR)&bindAddr, sizeof(bindAddr)) != 0) { port++; if (port == Pointer(0x1860454).Read<uint32_t>()) // make sure port isn't the same as game port port++; bindAddr.sin_port = htons((u_short)port); if (port > (Modules::ModuleServer::Instance().VarServerPort->ValueInt + 10)) return false; // tried 10 ports, lets give up } Modules::CommandMap::Instance().SetVariable(Modules::ModuleServer::Instance().VarServerPort, std::to_string(port), std::string()); //Setup UPnP if (Modules::ModuleUPnP::Instance().VarUPnPEnabled->ValueInt) { Modules::ModuleUPnP::Instance().UPnPForwardPort(true, port, port, "ElDewrito InfoServer"); Modules::ModuleUPnP::Instance().UPnPForwardPort(false, Pointer(0x1860454).Read<uint32_t>(), Pointer(0x1860454).Read<uint32_t>(), "ElDewrito Game"); Modules::ModuleUPnP::Instance().UPnPForwardPort(false, 9987, 9987, "ElDewrito VoIP"); } WSAAsyncSelect(infoSocket, hwnd, WM_INFOSERVER, FD_ACCEPT | FD_CLOSE); listen(infoSocket, 5); infoSocketOpen = true; return true; }
/*======================================================================================== FUNCTION: LBaseSock::Accept() DESCRIPT: Accept the socket connection. RETURN : EWS_NO_ERR: Success! Others : System error code ARGUMENT: Sock: (i)Socket descriptor UPDATE : 2004/07/01, In-hyeok Paek; First work! ========================================================================================*/ int LBaseSock::Accept( SOCKET Sock ) { SOCKADDR_IN SockAddr; // Socket information structure int nLen; // Length of the block int nResult; // Function result // Accept the socket connection. nLen = sizeof( SOCKADDR ); m_Sock = accept( Sock, (LPSOCKADDR)&SockAddr, &nLen ); if( m_Sock == INVALID_SOCKET ) { return (m_nLastErr = WSAGetLastError()); } // Select the socket event. nResult = WSAAsyncSelect( m_Sock, m_hWnd, WM_SOCK_SOCKET, FD_CLOSE | FD_READ | FD_WRITE ); if( nResult == SOCKET_ERROR ) { return (m_nLastErr = WSAGetLastError()); } return EWS_NO_ERR; }
CZeroconfBrowserMDNS::~CZeroconfBrowserMDNS() { CSingleLock lock(m_data_guard); //make sure there are no browsers anymore for(tBrowserMap::iterator it = m_service_browsers.begin(); it != m_service_browsers.end(); ++it ) doRemoveServiceType(it->first); #if defined(TARGET_WINDOWS_DESKTOP) WSAAsyncSelect( (SOCKET) DNSServiceRefSockFD( m_browser ), g_hWnd, BONJOUR_BROWSER_EVENT, 0 ); #elif defined(TARGET_WINDOWS_STORE) // need to modify this code to use WSAEventSelect since WSAAsyncSelect is not supported CLog::Log(LOGDEBUG, "%s is not implemented for TARGET_WINDOWS_STORE", __FUNCTION__); #endif //TARGET_WINDOWS if (m_browser) DNSServiceRefDeallocate(m_browser); m_browser = NULL; }
void ServerCF::Accept() { struct sockaddr_in client; int len; len = sizeof( client ); ToClientSocket = accept(serverSocket, (struct sockaddr*)&client, &len); if(ToClientSocket < 0){ //error handling }else{ WSAAsyncSelect(serverSocket,g_pWindow,WM_TOCLIENTSOCKET,(FD_READ|FD_CLOSE)); //we don't want more than one connection, cause it crashes closesocket(serverSocket); } }
int CreateInitSockClient(HWND hwnd, SOCKET& sock, sockaddr_in sa, char *buf) { int i; char lineErr[256], buf2[128]; CHECKERR(sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP), FL_ERR_SOCKET); CHECKERR(i = WSAAsyncSelect (sock, hwnd, WM_FLY_TASKS, FD_CONNECT | FD_WRITE | FD_READ | FD_CLOSE ), FL_ERR_WSAAYNC); i=connect (sock, (SOCKADDR *)&sa, sizeof(sa)); if (i==-1) { if (WSAGetLastError()!=WSAEWOULDBLOCK) { sprintf(buf, "code=%d", i); MessageBox (NULL, buf, "Error in connect", MB_OK); } } _beginthreadex (NULL, 0, ConnectingThread, (void*)sock, 0, &connectThreadID); return i; }
int xsSocketCreate(void) { SOCKET sock; int ret; sock = socket(PF_INET, SOCK_STREAM, 0); if (sock == INVALID_SOCKET) return XS_EC_ERROR; ret = WSAAsyncSelect(sock, g_hMainWnd, WM_XS_SOCKET_MSG, FD_READ | FD_WRITE | FD_CONNECT | FD_CLOSE); if (ret != 0) { closesocket(sock); return XS_EC_ERROR; } return sock; }
/////////////////////////////////////////////////////// // End of transfer : /////////////////////////////////////////////////////// static void StopTransfer (void) { // stop transfer WSAAsyncSelect (sTC.s, hTftpClientWnd, 0, 0); KillTimer(hTftpClientWnd, WM_CLIENT_DATA); KillTimer(hTftpClientWnd, WM_CLIENT_ACK); // free resource closesocket (sTC.s); sTC.s = INVALID_SOCKET; CloseHandle (sTC.hFile); sTC.hFile = INVALID_HANDLE_VALUE; sTC.bConnected = TFTP_NOTCONNECTED; // reinit buttons EnableWindow (GetDlgItem (GetParent(hTftpClientWnd), IDC_CLIENT_SEND_BUTTON), TRUE); EnableWindow (GetDlgItem (GetParent(hTftpClientWnd), IDC_CLIENT_GET_BUTTON), TRUE); EnableWindow (GetDlgItem (GetParent(hTftpClientWnd), IDC_CLIENT_BREAK_BUTTON), FALSE); SetDlgItemText (GetParent(hTftpClientWnd), IDC_CLIENT_BLOCK, ""); SendDlgItemMessage (GetParent(hTftpClientWnd), IDC_CLIENT_PROGRESS, PBM_SETPOS, 0, 0); } // StopTransfer
bool ConnectAsyncSocket(int index, char *server, unsigned short port) { struct sockaddr_in sName; SOCKET sck; sck = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (sck == INVALID_SOCKET) return false; if (WSAAsyncSelect(sck, bot[index]->hWnd_main, WM_WSDATAARRIVAL, FD_READ | FD_CLOSE | FD_CONNECT) == SOCKET_ERROR) return false; memset(&sName, 0, sizeof(sName)); sName.sin_family = AF_INET; sName.sin_port = htons(port); char *p = server; while (*p && (isdigit(*p) || (*p == '.'))) p++; if (*p) { struct hostent *hstEnt = gethostbyname(server); if (!hstEnt) { closesocket(sck); return false; } memcpy(&sName.sin_addr, hstEnt->h_addr, hstEnt->h_length); } else { sName.sin_addr.s_addr = inet_addr(server); } if (connect(sck, (struct sockaddr *)&sName, sizeof(sName))) { int tmp = WSAGetLastError(); if (tmp != WSAEWOULDBLOCK) { shutdown(sck, SD_BOTH); closesocket(sck); return false; } } bot[index]->sck = sck; return true; }
/*======================================================================================== FUNCTION: LBaseSock::Listen() DESCRIPT: Listen connections for the server socket. RETURN : EWS_NO_ERR: Success! Others : System error code ARGUMENT: szAddr : (i)IP address nPort : (i)Port # nMaxConnect: (i)Max. # of connections accepted (Default = 1) UPDATE : 2004/07/01, In-hyeok Paek; First work! ========================================================================================*/ int LBaseSock::Listen( char *szAddr, int nPort, int nMaxConnect ) { SOCKADDR_IN SockAddr; // Socket address structure BOOL bOpt = true; DWORD dwResult; // Function result int nResult; // Function result // Get the socket descriptor. if( (m_Sock = socket( AF_INET, SOCK_STREAM, 0 )) == INVALID_SOCKET ) { return (m_nLastErr = WSAGetLastError()); } // Set the socket option. setsockopt( m_Sock, SOL_SOCKET, SO_REUSEADDR, (const char *)&bOpt, sizeof( bOpt ) ); // Bind socket. SockAddr.sin_family = AF_INET; SockAddr.sin_port = htons( (u_short)nPort ); if( szAddr == NULL ) { SockAddr.sin_addr.s_addr = htonl( INADDR_ANY ); } else { dwResult = inet_addr( szAddr ); if( dwResult == INADDR_NONE ) { return (m_nLastErr = WSAGetLastError()); } SockAddr.sin_addr.s_addr = dwResult; } if( bind( m_Sock, (LPSOCKADDR)&SockAddr, sizeof( SOCKADDR ) ) == SOCKET_ERROR ) { return (m_nLastErr = WSAGetLastError()); } // Select the socket event. nResult = WSAAsyncSelect( m_Sock, m_hWnd, WM_SOCK_SOCKET, FD_ACCEPT | FD_CONNECT | FD_READ | FD_WRITE | FD_CLOSE ); if( nResult == SOCKET_ERROR ) { return (m_nLastErr = WSAGetLastError()); } // Listen connections. if( listen( m_Sock, nMaxConnect ) == SOCKET_ERROR ) { m_nLastErr = WSAGetLastError(); closesocket( m_Sock ); m_Sock = INVALID_SOCKET; return m_nLastErr; } m_fListenSocket = true; return EWS_NO_ERR; }
//============================================================================= BOOL XSocket::bConnect(char * pAddr, int iPort, unsigned int uiMsg) { SOCKADDR_IN saTemp; u_long arg; int iRet; DWORD dwOpt; PutLogList("bConnect"); if (m_cType == XSOCK_LISTENSOCK) return FALSE; if (m_Sock != INVALID_SOCKET) closesocket(m_Sock); m_Sock = socket(AF_INET, SOCK_STREAM, 0); if (m_Sock == INVALID_SOCKET) return FALSE; arg = 1; ioctlsocket(m_Sock, FIONBIO, &arg); memset(&saTemp,0,sizeof(saTemp)); saTemp.sin_family = AF_INET; saTemp.sin_addr.s_addr = inet_addr(pAddr); saTemp.sin_port = htons(iPort); iRet = connect(m_Sock, (struct sockaddr *) &saTemp, sizeof(saTemp)); if (iRet == SOCKET_ERROR) { if (WSAGetLastError() != WSAEWOULDBLOCK) { m_WSAErr = WSAGetLastError(); return FALSE; } } WSAAsyncSelect(m_Sock, m_hWnd, uiMsg, FD_CONNECT | FD_READ | FD_WRITE | FD_CLOSE); dwOpt = 8192*5; setsockopt(m_Sock, SOL_SOCKET, SO_RCVBUF, (const char FAR *)&dwOpt, sizeof(dwOpt)); setsockopt(m_Sock, SOL_SOCKET, SO_SNDBUF, (const char FAR *)&dwOpt, sizeof(dwOpt)); SafeCopy(m_pAddr, pAddr); m_iPortNum = iPort; m_uiMsg = uiMsg; m_cType = XSOCK_NORMALSOCK; return TRUE; }//=============================================================================