C++ (Cpp) GLog_Write примеры использования

Пример #1

Файл: GTcpClient.cpp Проект: lubing521/Hitown

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);
		}
	}
}

Пример #2

Файл: GTcpServer.cpp Проект: minicool/IOCP

void GTcpSvr_CloseListeners(void)
{
	GLog_Write("GTcpSvr_CloseListeners：正在关闭监听者");
	for(DWORD i = 0; i < dwGTcpSvrListenerCount; i++)
		closesocket(pGTcpSvrListeners[i]->Socket);
	GLog_Write("GTcpSvr_CloseListeners：成功关闭监听者");
}

Пример #3

Файл: GTcpClient.cpp Проект: lubing521/Hitown

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 = &GTcpClt_OnConnected;
	pClient->pfnOnIocpError = &GTcpClt_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);
}

Пример #4

Файл: GTcpServer.cpp Проект: minicool/IOCP

void GTcpSvr_FreeClients(void)
{
	PGHND_DATA pHndData;

	#if(_USE_INTERLOCKED_IN_LIST)
	GTcpSvr_LockClientList();
	#else
	EnterCriticalSection(&GTcpSvrClientCS);
	#endif

	pGTcpSvrOvertimeCount = 0;
	pHndData = pGTcpSvrClientHead;
	while(pHndData)
	{
		pGTcpSvrOvertimeClient[pGTcpSvrOvertimeCount] = pHndData;
		pGTcpSvrOvertimeCount++;
		pHndData = pHndData->pNext;
	}

	#if(_USE_INTERLOCKED_IN_LIST)
	GTcpSvr_UnlockClientList();
	#else
	LeaveCriticalSection(&GTcpSvrClientCS);
	#endif

	GLog_Write("GTcpSvr_CloseClients：正在关闭客户连接");
	while(pGTcpSvrOvertimeCount)
	{
		pGTcpSvrOvertimeCount--;
		closesocket(pGTcpSvrOvertimeClient[pGTcpSvrOvertimeCount]->Socket);
	}
	GLog_Write("GTcpSvr_CloseClients：成功关闭客户连接");
}

Пример #5

Файл: GTcpServer.cpp Проект: minicool/IOCP

/*********************************************************************************
                   监听者
*********************************************************************************/
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 = &GTcpSvr_OnAccept;
	pListener->pfnOnIocpError = &GTcpSvr_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(&GTcpSvrListenerCS);
	pGTcpSvrListeners[dwGTcpSvrListenerCount] = pListener;
	hGTcpSvrListenerEvents[dwGTcpSvrListenerCount] = CreateEvent(NULL, FALSE, FALSE, NULL);
	WSAEventSelect(pListener->Socket, hGTcpSvrListenerEvents[dwGTcpSvrListenerCount], FD_ACCEPT);
	dwGTcpSvrListenerCount++;
	LeaveCriticalSection(&GTcpSvrListenerCS);

	return(DWORD(pListener));
}

Пример #6

Файл: GTcpClient.cpp Проект: lubing521/Hitown

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);
}

Пример #7

Файл: GTcpServer.cpp Проект: minicool/IOCP

void GTcpSvr_EndThread(void)
{
	if(!GTcpSvrServiceThreadData.bIsShutdown)
	{
		GTcpSvrServiceThreadData.bIsShutdown = TRUE;
		GLog_Write("GTcpSvr_EndThread：正在关闭服务线程");
		GThrd_DestroyThread(&GTcpSvrServiceThreadData);
		GLog_Write("GTcpSvr_EndThread：成功关闭服务线程");
	}
}

Пример #8

Файл: GTcpClient.cpp Проект: lubing521/Hitown

void GTcpClt_EndThread(void)
{
	if(GTcpCltServiceThreadData.bIsShutdown)
	{
		GTcpCltServiceThreadData.bIsShutdown = TRUE;
		GLog_Write("GTcpClt_EndThread：正在关闭服务线程“GTcpCltServiceThread”");
		GThrd_DestroyThread(&GTcpCltServiceThreadData);
		GLog_Write("GTcpClt_EndThread：成功关闭服务线程“GTcpCltServiceThread”");
	}
}

Пример #9

Файл: GTcpClient.cpp Проект: lubing521/Hitown

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：成功关闭客户端的连接");
}

Пример #10

Файл: GProcesserThread.cpp Проект: minicool/IOCP

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;		
}

Пример #11

Файл: GTcpClient.cpp Проект: lubing521/Hitown

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：成功释放客户端");
}

Пример #12

Файл: GTcpServer.cpp Проект: minicool/IOCP

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(&GTcpSvrPendingAcceptCS);
	#endif	

	pGTcpSvrClientHead = NULL;
	dwGTcpSvrClientCount = 0;
	#if(!_USE_INTERLOCKED_IN_LIST)
	InitializeCriticalSection(&GTcpSvrClientCS);
	#endif

	InitializeCriticalSection(&GTcpSvrListenerCS);
	dwGTcpSvrListenerCount = 0;
	pGTcpSvrOvertimeCount = 0;
	GThrd_CreateThread(&GTcpSvrServiceThreadData, GTHREAD_TYPE_TCP_SERVER_SERVICE, "TcpSvr伺服", &GTcpSvrServiceThread);
	if(!GTcpSvrServiceThreadData.dwThreadId)
	{
		#if(!_USE_INTERLOCKED_IN_LIST)
		DeleteCriticalSection(&GTcpSvrPendingAcceptCS);
		DeleteCriticalSection(&GTcpSvrClientCS);
		#endif
		DeleteCriticalSection(&GTcpSvrListenerCS);
		GLog_Write("GTcpSvr_Create：创建服务线程“GTcpSvrServiceThread”失败");
		return;
	}

	bGTcpSvrIsActive = TRUE;
}

Пример #13

Файл: GTcpClient.cpp Проект: lubing521/Hitown

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失败，无法关闭连接");
}

Пример #14

Файл: GTcpServer.cpp Проект: minicool/IOCP

/*********************************************************************************
                   服务管理
*********************************************************************************/
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失败，无法关闭连接");
}

Пример #15

Файл: GTcpServer.cpp Проект: minicool/IOCP

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;
	}
}

Пример #16

Файл: GTcpClient.cpp Проект: lubing521/Hitown

void GTcpClt_Create(void)
{
	if(bGTcpCltIsActive)
		return;	

	pGTcpCltClientHead = NULL;
	dwGTcpCltClientCount = 0;
	#if(!_USE_INTERLOCKED_IN_LIST)
	InitializeCriticalSection(&GTcpCltClientCS);
	#endif	

	GThrd_CreateThread(&GTcpCltServiceThreadData, GTHREAD_TYPE_TCP_CLIENT_SERVICE, "TcpClt伺服", &GTcpCltServiceThread);
	if(!GTcpCltServiceThreadData.dwThreadId)
	{
		#if(!_USE_INTERLOCKED_IN_LIST)
		DeleteCriticalSection(&GTcpCltClientCS);
		#endif
		GLog_Write("GTcpClt_Create：创建服务线程“GTcpCltServiceThread”失败");
		return;
	}

	bGTcpCltIsActive = TRUE;
}

Пример #17

Файл: GTcpClient.cpp Проект: lubing521/Hitown

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 = &GTcpClt_OnReadWrite;
	pClient->pfnOnIocpError = &GTcpClt_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;
	}
}

Пример #18

Файл: GTcpServer.cpp Проект: minicool/IOCP

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 = &GTcpSvr_OnReadWrite;
		pClient->pfnOnIocpError = &GTcpSvr_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);
}

Пример #19

Файл: GTcpClient.cpp Проект: lubing521/Hitown

/*********************************************************************************
                   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(&GTcpCltClientCS);
		#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(&GTcpCltClientCS);
		#endif
	}
	GLog_Write("GTcpCltServiceThread：服务线程结束");
}

Пример #20

Файл: GTcpServer.cpp Проект: minicool/IOCP

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：连接超过最大值");
	}
}

Пример #21

Файл: GTcpServer.cpp Проект: minicool/IOCP

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(&GTcpSvrPendingAcceptCS);
			#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(&GTcpSvrPendingAcceptCS);
			#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(&GTcpSvrClientCS);
			#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(&GTcpSvrClientCS);
			#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(;;)
}

Пример #22

Файл: GTcpServer.cpp Проект: minicool/IOCP

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
		}
	}
}