void GTcpClt_OnReadWrite(DWORD dwBytes, PGHND_DATA pClient, PGIO_DATA pIoData) { if(!dwBytes) { if((GIO_READ_COMPLETED == pIoData->OperType) && bGSockIsZeroByteRecv) { GIoDat_ResetIoDataOnRead(pIoData); pIoData->OperType = GIO_ZERO_READ_COMPLETED; pIoData->WSABuf.len = dwGBufSize; dwBytes = 0; DWORD dwFlag = 0; if((SOCKET_ERROR == WSARecv(pClient->Socket, &(pIoData->WSABuf), 1, &dwBytes, &dwFlag, LPWSAOVERLAPPED(pIoData), NULL)) || (ERROR_IO_PENDING == WSAGetLastError())) { return; } } GTcpClt_OnReadWriteError(pClient, pIoData); return; } pClient->dwTickCountAcitve = GetTickCount(); if(GIO_WRITE_COMPLETED == pIoData->OperType) { pfnOnGSockSendedClt((DWORD)pClient, pIoData->cData, dwBytes); GIoDat_Free(pIoData); }else { #if(_USE_GPROTOCOL) if(GCommProt_ProcessReceive(pClient, pIoData->cData, dwBytes, pfnOnGSockReceiveClt)) { pIoData = GIoDat_Alloc(); if(!pIoData) { GLog_Write("GTcpClt_OnReadWrite:IoData分配失败,无法再投递接收"); return; } } #else pfnOnGSockReceiveClt((DWORD)pClient, pIoData->cData, dwBytes); #endif GIoDat_ResetIoDataOnRead(pIoData); pIoData->OperType = GIO_READ_COMPLETED; pIoData->WSABuf.len = dwGSockRecvBytes; dwBytes = 0; DWORD dwFlag = 0; if((SOCKET_ERROR == WSARecv(pClient->Socket, &(pIoData->WSABuf), 1, &dwBytes, &dwFlag, LPWSAOVERLAPPED(pIoData), NULL)) && (ERROR_IO_PENDING != WSAGetLastError())) { GTcpClt_OnReadWriteError(pClient, pIoData); } } }
void GTcpSvr_CloseListeners(void) { GLog_Write("GTcpSvr_CloseListeners:正在关闭监听者"); for(DWORD i = 0; i < dwGTcpSvrListenerCount; i++) closesocket(pGTcpSvrListeners[i]->Socket); GLog_Write("GTcpSvr_CloseListeners:成功关闭监听者"); }
BOOL GTcpClt_Connect(PGHND_DATA pClient) { PGIO_DATA pIoData; pIoData = GIoDat_Alloc(); if(!pIoData) { GLog_Write("GTcpClt_Connect:申请IoData失败,无法连接"); return(FALSE); } SOCKADDR_IN saRemoteAddr; saRemoteAddr.sin_family = AF_INET; saRemoteAddr.sin_addr.S_un.S_addr = pClient->dwAddr; saRemoteAddr.sin_port = htons((WORD)pClient->dwPort); pClient->dwTickCountAcitve = GetTickCount(); pClient->pfnOnIocpOper = >cpClt_OnConnected; pClient->pfnOnIocpError = >cpClt_OnConnectError; pClient->hsState = GHND_STATE_CONNECTING; pIoData->OperType = GIO_READ_COMPLETED; pIoData->pOwner = pClient; pIoData->WSABuf.len = dwGSockRecvBytes; if((!GTcpClt_ConnectEx(pClient, saRemoteAddr, pIoData)) && (WSA_IO_PENDING != WSAGetLastError())) { pClient->hsState = GHND_STATE_DISCONNECT; GIoDat_Free(pIoData); GLog_Write("GTcpClt_Connect:ConnectEx请求失败"); return(FALSE); } return(TRUE); }
void GTcpSvr_FreeClients(void) { PGHND_DATA pHndData; #if(_USE_INTERLOCKED_IN_LIST) GTcpSvr_LockClientList(); #else EnterCriticalSection(>cpSvrClientCS); #endif pGTcpSvrOvertimeCount = 0; pHndData = pGTcpSvrClientHead; while(pHndData) { pGTcpSvrOvertimeClient[pGTcpSvrOvertimeCount] = pHndData; pGTcpSvrOvertimeCount++; pHndData = pHndData->pNext; } #if(_USE_INTERLOCKED_IN_LIST) GTcpSvr_UnlockClientList(); #else LeaveCriticalSection(>cpSvrClientCS); #endif GLog_Write("GTcpSvr_CloseClients:正在关闭客户连接"); while(pGTcpSvrOvertimeCount) { pGTcpSvrOvertimeCount--; closesocket(pGTcpSvrOvertimeClient[pGTcpSvrOvertimeCount]->Socket); } GLog_Write("GTcpSvr_CloseClients:成功关闭客户连接"); }
/********************************************************************************* 监听者 *********************************************************************************/ DWORD GTcpSvr_CreateListen(char *lpszLocalIp, DWORD dwLocalPort, void* pOwner) { if((!bGTcpSvrIsActive) || (WSA_MAXIMUM_WAIT_EVENTS <= dwGTcpSvrListenerCount)) return(0); SOCKADDR_IN Addr; PGHND_DATA pListener; pListener = GHndDat_Alloc(); if(!pListener) { GLog_Write("GTcpSvr_CreateListen:分配HndData失败,无法创建一个监听者"); return(0); } #if(!_REUSED_SOCKET) GSock_InitTcpHndData(pListener); #endif Addr.sin_family = AF_INET; Addr.sin_addr.S_un.S_addr = inet_addr(lpszLocalIp); Addr.sin_port = htons((u_short)dwLocalPort); if((SOCKET_ERROR == bind(pListener->Socket, (PSOCKADDR)&Addr, sizeof(SOCKADDR_IN))) || (SOCKET_ERROR == listen(pListener->Socket, SOMAXCONN))) { #if(!_REUSED_SOCKET) GSock_UninitTcpHndData(pListener); #endif GHndDat_Free(pListener); GLog_Write("GTcpSvr_CreateListen:绑定或监听操作失败,无法创建一个监听者"); return(0); } pListener->pfnOnIocpOper = >cpSvr_OnAccept; pListener->pfnOnIocpError = >cpSvr_OnAcceptError; pListener->dwAddr = Addr.sin_addr.S_un.S_addr; pListener->dwPort = dwLocalPort; pListener->htType = GHND_TYPE_TCP_SVR_LISTEN; pListener->hsState = GHND_STATE_LISTENING; pListener->pOwner = pOwner; pListener->pData = NULL; if(!GTcpSvr_PostAccept(pListener, dwGSockNumberPostAccept)) { #if(!_REUSED_SOCKET) GSock_UninitTcpHndData(pListener); #endif GHndDat_Free(pListener); GLog_Write("GTcpSvr_CreateListen:投递接受失败“GTcpSvr_PostAccept”,无法创建一个监听者"); return(0); } EnterCriticalSection(>cpSvrListenerCS); pGTcpSvrListeners[dwGTcpSvrListenerCount] = pListener; hGTcpSvrListenerEvents[dwGTcpSvrListenerCount] = CreateEvent(NULL, FALSE, FALSE, NULL); WSAEventSelect(pListener->Socket, hGTcpSvrListenerEvents[dwGTcpSvrListenerCount], FD_ACCEPT); dwGTcpSvrListenerCount++; LeaveCriticalSection(>cpSvrListenerCS); return(DWORD(pListener)); }
DWORD GTcpClt_CreateClient(char *pszRemoteIp, DWORD dwRemotePort, char *pszLocalIp, void* pOwner) { PGHND_DATA pClient; pClient = GHndDat_Alloc(); if(!pClient) { GLog_Write("GTcpClt_CreateClient:申请HndData失败,无法创建连接"); return(0); } #if(!_REUSED_SOCKET) GSock_InitTcpHndData(pClient); #endif SOCKADDR_IN saLocalAddr; saLocalAddr.sin_family = AF_INET; saLocalAddr.sin_addr.S_un.S_addr = inet_addr(pszLocalIp); saLocalAddr.sin_port = htons(0); do { if(SOCKET_ERROR == bind(pClient->Socket, (sockaddr *)&(saLocalAddr), sizeof(SOCKADDR_IN))) { #if(_REUSED_SOCKET) GTcpClt_DisconnectEx(pClient); #else GSock_UninitTcpHndData(pClient); #endif GHndDat_Free(pClient); GLog_Write("GTcpClt_CreateClient:bind失败,无法创建连接"); return(0); }else break; }while(1); pClient->htType = GHND_TYPE_TCP_CLT_CLIENT; pClient->pData = NULL; pClient->pOwner = pOwner; pClient->dwAddr = inet_addr(pszRemoteIp); pClient->dwPort = dwRemotePort; GTcpClt_InsertClientList(pClient); pfnOnGSockCreateClientClt(DWORD(pClient)); if(!GTcpClt_Connect(pClient)) { GTcpClt_DeleteClientList(pClient); pfnOnGSockDestroyClientClt(DWORD(pClient)); #if(_REUSED_SOCKET) GTcpClt_DisconnectEx(pClient); #else GSock_UninitTcpHndData(pClient); #endif GHndDat_Free(pClient); GLog_Write("GTcpClt_CreateClient:GTcpClt_Connect失败,无法创建连接"); return(0); }else return((DWORD)pClient); }
void GTcpSvr_EndThread(void) { if(!GTcpSvrServiceThreadData.bIsShutdown) { GTcpSvrServiceThreadData.bIsShutdown = TRUE; GLog_Write("GTcpSvr_EndThread:正在关闭服务线程"); GThrd_DestroyThread(>cpSvrServiceThreadData); GLog_Write("GTcpSvr_EndThread:成功关闭服务线程"); } }
void GTcpClt_EndThread(void) { if(GTcpCltServiceThreadData.bIsShutdown) { GTcpCltServiceThreadData.bIsShutdown = TRUE; GLog_Write("GTcpClt_EndThread:正在关闭服务线程“GTcpCltServiceThread”"); GThrd_DestroyThread(>cpCltServiceThreadData); GLog_Write("GTcpClt_EndThread:成功关闭服务线程“GTcpCltServiceThread”"); } }
void GTcpClt_CloseClients(void) { PGHND_DATA pClient; GLog_Write("GTcpClt_CloseClients:正在关闭客户端的连接"); pClient = pGTcpCltClientHead; while(pClient) { closesocket(pClient->Socket); pClient = pClient->pNext; } GLog_Write("GTcpClt_CloseClients:成功关闭客户端的连接"); }
void GProcThrd_Create(void) { if(bGProcThrdThreadIsActive) return; DWORD dwNP = GWkrThrd_GetNumberOfProcessors(); if(!dwGProcThrdThreadNumber) dwGProcThrdThreadNumber = dwNP * 2 + 2; if(dwGProcThrdThreadNumber < dwNP) dwGProcThrdThreadNumber = dwNP; hGProcThrdThreadCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, dwGProcThrdThreadNumber); if(NULL == hGProcThrdThreadCompletionPort) { GLog_Write("GProcThrd_Create:完成端口句柄创建失败"); return; } pGProcThrdThreadAddr = (PGTHREAD)GMem_Alloc(dwGProcThrdThreadNumber * sizeof(GTHREAD)); if(!pGProcThrdThreadAddr) { dwGProcThrdThreadNumber = 0; CloseHandle(hGProcThrdThreadCompletionPort); GLog_Write("GProcThrd_Create:从GMem分配工作者内存失败"); return; } DWORD i; PGTHREAD pThread; pThread = pGProcThrdThreadAddr; for(i = 0; i < dwGProcThrdThreadNumber; i++) { GThrd_CreateThread(pThread, GTHREAD_TYPE_IOCP, "处理者", &GProcesserThreadProc); if(!pThread->dwThreadId) { GLog_Write("GProcThrd_Create:创建处理者线程失败"); return; } pThread = pThread + 1; } bGProcThrdThreadIsActive = TRUE; }
void GTcpClt_FreeClients(void) { PGHND_DATA pClient, tmp; GLog_Write("GTcpClt_FreeClients:正在释放客户端"); pClient = pGTcpCltClientHead; while(pClient) { tmp = pClient->pNext; pfnOnGSockDestroyClientClt(DWORD(pClient)); GTcpClt_DeleteClientList(pClient); GHndDat_Free(pClient); pClient = tmp; } GLog_Write("GTcpClt_FreeClients:成功释放客户端"); }
void GTcpSvr_Create(void) { if(bGTcpSvrIsActive) return; pGTcpSvrOvertimeClient = (PGHND_DATA*)GMem_Alloc(dwGSockMaxNumberConnection * sizeof(SOCKET*)); if(!pGTcpSvrOvertimeClient) { GLog_Write("GTcpSvr_Create:从GMem分配超时句柄数据失败"); return; } pGTcpSvrPendingAcceptHead = NULL; dwGTcpSvrPendingAcceptCount = 0; #if(!_USE_INTERLOCKED_IN_LIST) InitializeCriticalSection(>cpSvrPendingAcceptCS); #endif pGTcpSvrClientHead = NULL; dwGTcpSvrClientCount = 0; #if(!_USE_INTERLOCKED_IN_LIST) InitializeCriticalSection(>cpSvrClientCS); #endif InitializeCriticalSection(>cpSvrListenerCS); dwGTcpSvrListenerCount = 0; pGTcpSvrOvertimeCount = 0; GThrd_CreateThread(>cpSvrServiceThreadData, GTHREAD_TYPE_TCP_SERVER_SERVICE, "TcpSvr伺服", >cpSvrServiceThread); if(!GTcpSvrServiceThreadData.dwThreadId) { #if(!_USE_INTERLOCKED_IN_LIST) DeleteCriticalSection(>cpSvrPendingAcceptCS); DeleteCriticalSection(>cpSvrClientCS); #endif DeleteCriticalSection(>cpSvrListenerCS); GLog_Write("GTcpSvr_Create:创建服务线程“GTcpSvrServiceThread”失败"); return; } bGTcpSvrIsActive = TRUE; }
void GTcpClt_DisconnectClient(DWORD dwClientContext) { PGIO_DATA pIoData = GIoDat_Alloc(); if(pIoData) { pIoData->OperType = GIO_CLOSE; pIoData->WSABuf.len = 0; pIoData->pOwner = (void*)dwClientContext; PostQueuedCompletionStatus(hGWkrThrdCompletionPort, 0, dwClientContext, (LPOVERLAPPED)pIoData); }else GLog_Write("GTcpSvr_DoCloseClient:申请IoData失败,无法关闭连接"); }
/********************************************************************************* 服务管理 *********************************************************************************/ void GTcpSvr_DoCloseClient(PGHND_DATA pClient, PGHND_DATA pIoDataOwner, GIO_OPER_TYPE OperType) { PGIO_DATA pIoData = GIoDat_Alloc(__FUNCTION__); if(pIoData) { pIoData->OperType = OperType; pIoData->WSABuf.len = 0; pIoData->pOwner = pIoDataOwner; PostQueuedCompletionStatus(hGWkrThrdCompletionPort, 0, (DWORD)pClient, (LPOVERLAPPED)pIoData); }else GLog_Write("GTcpSvr_DoCloseClient:申请IoData失败,无法关闭连接"); }
void GTcpSvr_PostBroadcastBuf(char* pBuf, DWORD dwBytes, DWORD dwParam, DWORD dwSvrContext, PFN_ON_GSOCK_TRAVERSAL pfnOnProc) //not lock { if(!bGTcpSvrIsActive) return; PGHND_DATA pClient = pGTcpSvrClientHead; while(pClient) { if (pfnOnProc(dwParam, dwSvrContext, (DWORD)pClient)) { GCommProt_PostSendBuf((DWORD)pClient, pBuf, dwBytes); GLog_Write("GTcpSvr_PostBroadcastBuf"); } pClient = pClient->pNext; } }
void GTcpClt_Create(void) { if(bGTcpCltIsActive) return; pGTcpCltClientHead = NULL; dwGTcpCltClientCount = 0; #if(!_USE_INTERLOCKED_IN_LIST) InitializeCriticalSection(>cpCltClientCS); #endif GThrd_CreateThread(>cpCltServiceThreadData, GTHREAD_TYPE_TCP_CLIENT_SERVICE, "TcpClt伺服", >cpCltServiceThread); if(!GTcpCltServiceThreadData.dwThreadId) { #if(!_USE_INTERLOCKED_IN_LIST) DeleteCriticalSection(>cpCltClientCS); #endif GLog_Write("GTcpClt_Create:创建服务线程“GTcpCltServiceThread”失败"); return; } bGTcpCltIsActive = TRUE; }
void GTcpClt_OnConnected(DWORD dwBytes, PGHND_DATA pClient, PGIO_DATA pIoData) { setsockopt(pClient->Socket, SOL_SOCKET, SO_UPDATE_CONNECT_CONTEXT, NULL, 0); pClient->hsState = GHND_STATE_CONNECTED; pClient->dwTickCountAcitve = GetTickCount(); pClient->pfnOnIocpOper = >cpClt_OnReadWrite; pClient->pfnOnIocpError = >cpClt_OnReadWriteError; pfnOnGSockConnectClt((DWORD)pClient, pIoData->cData, dwBytes); ZeroMemory(pIoData, sizeof(WSAOVERLAPPED)); DWORD dwCount = dwGSockNumberPostRecv; for(;;) { GIoDat_ResetIoDataOnRead(pIoData); pIoData->WSABuf.len = dwGSockRecvBytes; dwBytes = 0; DWORD dwFlag = 0; if((SOCKET_ERROR == WSARecv(pClient->Socket, &(pIoData->WSABuf), 1, &dwBytes, &dwFlag, LPWSAOVERLAPPED(pIoData), NULL)) && (ERROR_IO_PENDING != WSAGetLastError())) { GTcpClt_OnReadWriteError(pClient, pIoData); return; } dwCount--; if(!dwCount) return; pIoData = GIoDat_Alloc(); if(!pIoData) { GLog_Write("GTcpClt_OnConnected:连接后,申请IoData失败"); return; } pIoData->OperType = GIO_READ_COMPLETED; pIoData->pOwner = pClient; } }
BOOL GTcpSvr_PostAccept(PGHND_DATA pListener, DWORD dwCount) { int nCount; PGHND_DATA pClient; PGIO_DATA pIoData; nCount = 0; while(dwCount && (dwGTcpSvrClientCount + dwGTcpSvrPendingAcceptCount < dwGSockMaxNumberConnection)) { pClient = GHndDat_Alloc(); if(!pClient) { GLog_Write("GTcpSvr_PostAccept:分配HndData失败,无法投递接受"); return(nCount); } #if(!_REUSED_SOCKET) GSock_InitTcpHndData(pClient); //初始化CLIENT 【初始化SOCKET】 #endif pIoData = GIoDat_Alloc(__FUNCTION__); if(!pIoData) { #if(!_REUSED_SOCKET) GSock_UninitTcpHndData(pClient); #endif GHndDat_Free(pClient); GLog_Write("GTcpSvr_PostAccept:分配IoData失败,无法投递接受"); return(nCount); } pClient->pfnOnIocpOper = >cpSvr_OnReadWrite; pClient->pfnOnIocpError = >cpSvr_OnReadWriteError; pClient->htType = GHND_TYPE_TCP_SVR_CLIENT; pClient->hsState = GHND_STATE_ACCEPTING; pClient->pOwner = pListener; pClient->pData = NULL; pIoData->OperType = GIO_CONNECTED; pIoData->pOwner = pClient; pIoData->WSABuf.len = dwGSockRecvBytes; GTcpSvr_InsertPendingAcceptList(pClient); if((!GTcpSvr_AcceptEx(pListener, pClient, pIoData)) && (ERROR_IO_PENDING != WSAGetLastError())) { GTcpSvr_DeletePendingAcceptList(pClient); GIoDat_Free(pIoData,__FUNCTION__); #if(!_REUSED_SOCKET) GSock_UninitTcpHndData(pClient); #endif GHndDat_Free(pClient); GLog_Write("GTcpSvr_PostAccept:执行pfnGTcpSvrAcceptEx失败,无法投递接受"); return(nCount); } else { #if(_OUTWSDATA_INFO) std::stringstream ss; ss << "["<<pIoData << "][WSARecv][GTcpSvr_PostAccept]"; GLog_Write(const_cast<char*>(ss.str().c_str())); #endif } dwCount--; nCount++; }//for(i = 0; i < dwCount; i++) return(TRUE); }
/********************************************************************************* TcpClient伺服线程 *********************************************************************************/ void GTcpCltServiceThread(PGTHREAD pThread) { PGHND_DATA pClient; INT nLong; INT nLongBytes = sizeof(INT); DWORD dwTickCount; GLog_Write("GTcpCltServiceThread:服务线程开始"); for(;;) { #if(_RUN_INFO) pThread->dwState = GTHREAD_STATE_SLEEP; #endif Sleep(1000); #if(_RUN_INFO) pThread->dwState = GTHREAD_STATE_WORKING1; pThread->dwRunCount++; #endif if(pThread->bIsShutdown) break; #if(_USE_INTERLOCKED_IN_LIST) GTcpClt_LockClientList(); #else EnterCriticalSection(>cpCltClientCS); #endif pClient = pGTcpCltClientHead; dwTickCount = GetTickCount(); #if(_RUN_INFO) pThread->dwState = GTHREAD_STATE_WORKING1; #endif while(pClient) { if(GHND_STATE_DISCONNECT == pClient->hsState) { if(dwTickCount > pClient->dwTickCountAcitve) nLong = dwTickCount - pClient->dwTickCountAcitve; else nLong = pClient->dwTickCountAcitve - dwTickCount; if((DWORD)nLong > dwGSockTimeAutoConnect) { #if(_RUN_INFO) pThread->dwState = GTHREAD_STATE_WORKING2; #endif GTcpClt_Connect(pClient); } }else if(GHND_STATE_CONNECTED == pClient->hsState) { if(dwTickCount > pClient->dwTickCountAcitve) nLong = dwTickCount - pClient->dwTickCountAcitve; else nLong = pClient->dwTickCountAcitve - dwTickCount; if((DWORD)nLong > dwGSockTimeIdleOvertime) { #if(_RUN_INFO) pThread->dwState = GTHREAD_STATE_WORKING3; #endif GTcpClt_DisconnectClient(DWORD(pClient)); }else if((DWORD)nLong > dwGSockTimeHeartbeat) { #if(_RUN_INFO) pThread->dwState = GTHREAD_STATE_WORKING4; #endif pfnOnGSockHeartbeat(DWORD(pClient)); } } pClient = pClient->pNext; } #if(_USE_INTERLOCKED_IN_LIST) GTcpClt_UnlockClientList(); #else LeaveCriticalSection(>cpCltClientCS); #endif } GLog_Write("GTcpCltServiceThread:服务线程结束"); }
void GTcpSvr_OnAccept(DWORD dwBytes, PGHND_DATA pListener, PGIO_DATA pIoData) { if((!dwBytes) && (dwGSockAcceptBytes)) { GTcpSvr_OnAcceptError(pListener, pIoData); return; } PGHND_DATA pClient; PSOCKADDR_IN pAddr; int nLen; pClient = PGHND_DATA(pIoData->pOwner); GTcpSvr_DeletePendingAcceptList(pClient); setsockopt(pClient->Socket, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, (char *)&(pListener->Socket), sizeof(pListener->Socket)); BOOL bDontLinger = FALSE; setsockopt(pClient->Socket, SOL_SOCKET, SO_DONTLINGER, (const char *) &bDontLinger, sizeof(BOOL)); GTcpSvr_GetAcceptExSockAddrs(pListener, pIoData->cData, dwGSockAcceptBytes, pAddr, nLen); //读取 AcceptEx Buffer pClient->dwAddr = pAddr->sin_addr.S_un.S_addr; pClient->dwPort = htons(pAddr->sin_port); pClient->hsState = GHND_STATE_CONNECTED; pClient->dwTickCountAcitve = GetTickCount(); GTcpSvr_InsertClientList(pClient); pfnOnGSockCreateClientSvr(DWORD(pClient)); //add wangzh creatclient GSock_InterlockedAdd(PGHND_DATA(pClient->pOwner)->pData); #if(_USE_GPROTOCOL) if(GCommProt_ProcessReceive(pClient, pIoData->cData, dwBytes, pfnOnGSockConnectTcpSvr)) { pIoData = GIoDat_Alloc(); if(!pIoData) { GLog_Write("GTcpSvr_OnAccept:IoData分配失败,连接后无法再投递接收"); return; } } #else pfnOnGSockConnectTcpSvr((DWORD)pClient, pIoData->cData, dwBytes); #endif ZeroMemory(pIoData, sizeof(WSAOVERLAPPED)); //清空 POSTACCEPT 发送过来的数据IODATA DWORD dwCount = dwGSockNumberPostRecv; for(;;) { GIoDat_ResetIoDataOnRead(pIoData); //复用数据 pIoData->OperType = GIO_READ_COMPLETED; pIoData->WSABuf.len = dwGSockRecvBytes; dwBytes = 0; DWORD dwFlag = 0; //IODATA用于CLIENT WSARecv的数据 if((SOCKET_ERROR == WSARecv(pClient->Socket, &(pIoData->WSABuf), 1, &dwBytes, &dwFlag, LPWSAOVERLAPPED(pIoData), NULL)) && (ERROR_IO_PENDING != WSAGetLastError())) { GTcpSvr_OnReadWriteError(pClient, pIoData); break; }else { #if(_OUTWSDATA_INFO) std::stringstream ss; ss << "["<<pIoData << "][WSARecv][GTcpSvr_OnAccept][Error:"<<WSAGetLastError()<<"]"; GLog_Write(const_cast<char*>(ss.str().c_str())); #endif } dwCount--; if(!dwCount) break; pIoData = GIoDat_Alloc(__FUNCTION__); if(!pIoData) { GLog_Write("GTcpSvr_OnAccept:申请IoData失败,连接后无法投递接收"); break; } pIoData->pOwner = pClient; //再次创建IODATA CLIENT WSARecv的数据 } if(dwGTcpSvrClientCount >= dwGSockMaxNumberConnection) { pfnOnGSockConnectionOverflow((DWORD)pClient); void GTcpSvr_DoCloseClient(PGHND_DATA pClient, PGHND_DATA pIoDataOwner, GIO_OPER_TYPE OperType); GTcpSvr_DoCloseClient(pClient, pClient, GIO_CLOSE); GLog_Write("GTcpSvr_OnAccept:连接超过最大值"); } }
void GTcpSvrServiceThread(PGTHREAD pThread) { DWORD dwResult; PGHND_DATA pClient; INT nResult; INT nLong; INT nLongBytes = sizeof(INT); DWORD dwTickCount; GLog_Write("GTcpSvrServiceThread:伺服线程开始"); for(;;) { #if(_RUN_INFO) pThread->dwState = GTHREAD_STATE_SLEEP; #endif if(!dwGTcpSvrListenerCount) { Sleep(1000); dwResult = WSA_WAIT_TIMEOUT; }else dwResult = WSAWaitForMultipleEvents(dwGTcpSvrListenerCount, hGTcpSvrListenerEvents, FALSE, 1000, FALSE); if(pThread->bIsShutdown) break; #if(_RUN_INFO) pThread->dwState = GTHREAD_STATE_WORKING1; pThread->dwRunCount++; #endif if(WSA_WAIT_TIMEOUT != dwResult) { dwResult -= WSA_WAIT_EVENT_0; WSAResetEvent(hGTcpSvrListenerEvents[dwResult]); if((dwGTcpSvrClientCount + dwGTcpSvrPendingAcceptCount >= dwGSockMaxNumberConnection) || (!GTcpSvr_PostAccept(pGTcpSvrListeners[dwResult], dwGSockNumberPostAccept))) { SOCKADDR_IN Addr; int nLen; nLen = sizeof(SOCKADDR_IN); closesocket(WSAAccept(pGTcpSvrListeners[dwResult]->Socket, (SOCKADDR*)&Addr, &nLen, NULL, 0)); if(dwGTcpSvrClientCount >= dwGSockMaxNumberConnection) GLog_Write("GTcpSvrServiceThread:超出连接限制"); else GLog_Write("GTcpSvrServiceThread:投递接受“GTcpSvr_PostAccept”失败"); #if(_OUTIODATA_INFO) std::stringstream ss; ss << "[GTcpSvrServiceThread]" << "[SvrClientCount:"<<dwGTcpSvrClientCount <<"|SvrPendingAcceptCount:" <<dwGTcpSvrPendingAcceptCount<< "]"; GLog_Write(const_cast<char*>(ss.str().c_str())); #endif } continue; } if(dwGSockAcceptBytes) { #if(_USE_INTERLOCKED_IN_LIST) GTcpSvr_LockPendingAcceptList(); #else EnterCriticalSection(>cpSvrPendingAcceptCS); #endif #if(_RUN_INFO) pThread->dwState = GTHREAD_STATE_WORKING2; #endif pClient = pGTcpSvrPendingAcceptHead; pGTcpSvrOvertimeCount = 0; while(pClient) { nResult = getsockopt(pClient->Socket, SOL_SOCKET, SO_CONNECT_TIME, (char *)&nLong, (PINT)&nLongBytes); if((SOCKET_ERROR != nResult) && (0xFFFFFFFF != nLong) && (dwGSockTimeAcceptOvertime < (DWORD)nLong)) { pGTcpSvrOvertimeClient[pGTcpSvrOvertimeCount] = pClient; pGTcpSvrOvertimeCount++; } pClient = pClient->pNext; } #if(_USE_INTERLOCKED_IN_LIST) GTcpSvr_UnlockPendingAcceptList(); #else LeaveCriticalSection(>cpSvrPendingAcceptCS); #endif #if(_RUN_INFO) pThread->dwState = GTHREAD_STATE_WORKING3; #endif while(pGTcpSvrOvertimeCount) //overtime send GIO_CLOSE { pGTcpSvrOvertimeCount--; pGTcpSvrOvertimeClient[pGTcpSvrOvertimeCount]->dwTickCountAcitve = dwTickCount; GTcpSvr_DoCloseClient(PGHND_DATA(pGTcpSvrOvertimeClient[pGTcpSvrOvertimeCount]->pOwner), pGTcpSvrOvertimeClient[pGTcpSvrOvertimeCount], GIO_CLOSE); } }//if(dwGSockAcceptBytes) if(dwGSockTimeIdleOvertime) { #if(_USE_INTERLOCKED_IN_LIST) GTcpSvr_LockClientList(); #else EnterCriticalSection(>cpSvrClientCS); #endif #if(_RUN_INFO) pThread->dwState = GTHREAD_STATE_WORKING4; #endif pClient = pGTcpSvrClientHead; pGTcpSvrOvertimeCount = 0; dwTickCount = GetTickCount(); while(pClient) {//QueryPerformanceCounter if(dwTickCount >= pClient->dwTickCountAcitve) nLong = dwTickCount - pClient->dwTickCountAcitve; else nLong = 0xFFFFFFFF - pClient->dwTickCountAcitve + dwTickCount; if((DWORD)nLong > dwGSockTimeIdleOvertime) { pGTcpSvrOvertimeClient[pGTcpSvrOvertimeCount] = pClient; pGTcpSvrOvertimeCount++; } pClient = pClient->pNext; } #if(_USE_INTERLOCKED_IN_LIST) GTcpSvr_UnlockClientList(); #else LeaveCriticalSection(>cpSvrClientCS); #endif #if(_RUN_INFO) pThread->dwState = GTHREAD_STATE_WORKING5; #endif while(pGTcpSvrOvertimeCount) { pGTcpSvrOvertimeCount--; pGTcpSvrOvertimeClient[pGTcpSvrOvertimeCount]->dwTickCountAcitve = dwTickCount; GTcpSvr_DoCloseClient(pGTcpSvrOvertimeClient[pGTcpSvrOvertimeCount], pGTcpSvrOvertimeClient[pGTcpSvrOvertimeCount], GIO_IDLE_OVERTIME); } }//if(dwGSockTimeIdleOvertime) }//for(;;) }
void GTcpSvr_OnReadWrite(DWORD dwBytes, PGHND_DATA pClient, PGIO_DATA pIoData) { if(!dwBytes) //接收数据为0 { if(bGSockIsZeroByteRecv && (GHND_STATE_CONNECTED == pClient->hsState) && (GIO_READ_COMPLETED == pIoData->OperType)) { GIoDat_ResetIoDataOnRead(pIoData); pIoData->OperType = GIO_ZERO_READ_COMPLETED; pIoData->WSABuf.len = dwGBufSize; dwBytes = 0; DWORD dwFlag = 0; if((SOCKET_ERROR != WSARecv(pClient->Socket, &(pIoData->WSABuf), 1, &dwBytes, &dwFlag, LPWSAOVERLAPPED(pIoData), NULL)) || (ERROR_IO_PENDING == WSAGetLastError())) { return; } } GTcpSvr_OnReadWriteError(pClient, pIoData); return; } if(GIO_WRITE_COMPLETED == pIoData->OperType) { pfnOnGSockSendedSvr((DWORD)pClient, pIoData->cData, dwBytes); GIoDat_Free(pIoData,__FUNCTION__); }else { pClient->dwTickCountAcitve = GetTickCount(); #if(_USE_GPROTOCOL) if(GCommProt_ProcessReceive(pClient, pIoData->cData, dwBytes, pfnOnGSockReceiveSvr)) { pIoData = GIoDat_Alloc(); if(!pIoData) { GLog_Write("GTcpSvr_OnReadWrite:IoData分配失败,无法再投递接收"); return; } } #else pfnOnGSockReceiveSvr((DWORD)pClient, pIoData->cData, dwBytes); #endif GIoDat_ResetIoDataOnRead(pIoData); pIoData->OperType = GIO_READ_COMPLETED; pIoData->WSABuf.len = dwGSockRecvBytes; dwBytes = 0; DWORD dwFlag = 0; if((SOCKET_ERROR == WSARecv(pClient->Socket, &(pIoData->WSABuf), 1, &dwBytes, &dwFlag, LPWSAOVERLAPPED(pIoData), NULL)) && (ERROR_IO_PENDING != WSAGetLastError())) { GTcpSvr_OnReadWriteError(pClient, pIoData); }else { #if(_OUTWSDATA_INFO) std::stringstream ss; ss << "[" <<pIoData<< "][WSARecv][GTcpSvr_OnReadWrite][Error:"<<WSAGetLastError()<<"]"; GLog_Write(const_cast<char*>(ss.str().c_str())); #endif } } }