C++ (Cpp) GIoDat_Alloc示例

示例#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

文件： 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);
}

示例#3

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

示例#4

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

示例#5

文件： 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;
	}
}

示例#6

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

示例#7

文件： 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);
}

示例#8

文件： 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
		}
	}
}