arwinclient_t.cpp

wangchuanDll.rar 网络传输的DLL 源代码

}

//------------------------------------------------------------------------------

unsigned int  __stdcall ArWinClient_T::SocketMessage(void* pParent)
{
	ArWinClient_T* pClient = (ArWinClient_T*)pParent;

	pClient->m_MessageSocketPara.pBuffer = (char*)::HeapAlloc(pClient->m_hHeap, 0, pClient->m_iMaxMsgBufferSize);
	pClient->m_MessageSocketPara.DataBuf.buf = pClient->m_MessageSocketPara.pBuffer; 
	pClient->m_MessageSocketPara.DataBuf.len = pClient->m_iMaxMsgBufferSize;
	
	ZeroMemory(&pClient->m_MessageSocketPara.Overlapped,  sizeof(OVERLAPPED));
	pClient->m_MessageSocketPara.Overlapped.hEvent = WSACreateEvent();

	while(true)
	{
		DWORD RecvBytes;
        DWORD Flags;
		Flags = 0;
        if (WSARecv(pClient->m_MessageSocket,
			&(pClient->m_MessageSocketPara.DataBuf), 1,
			&RecvBytes, &Flags,
			&(pClient->m_MessageSocketPara.Overlapped),
			NULL) == SOCKET_ERROR)
        {
			if (WSAGetLastError() != ERROR_IO_PENDING)
			{
				break;
			}
		}		
	
	    if ( WSAWaitForMultipleEvents(1, &pClient->m_MessageSocketPara.Overlapped.hEvent, FALSE,
			WSA_INFINITE, FALSE) == WSA_WAIT_FAILED)
		{
			break;
		}
			
		WSAResetEvent(pClient->m_MessageSocketPara.Overlapped.hEvent);
		
		DWORD BytesTransferred;
		if (WSAGetOverlappedResult(pClient->m_MessageSocket,
			&(pClient->m_MessageSocketPara.Overlapped),
			&BytesTransferred,
			FALSE, &Flags) == FALSE )
		{
			break;
		}
		
		ArDataPackage_T* pDataPackager = (ArDataPackage_T*)pClient->m_MessageSocketPara.DataBuf.buf;
		if(DATA == pDataPackager->ucType)
		{
			char* pReceiveData = pClient->m_MessageSocketPara.DataBuf.buf + sizeof(ArDataPackage_T);
			if(pClient->m_pReceiveDataFunc)
			{
				pClient->m_pReceiveDataFunc(pReceiveData, 
					                        pDataPackager->iDataSize, 
					                        pClient->m_SenderInfo,
											pClient->m_pPara);	
			}			
		}
				    
	}

	WSACloseEvent(pClient->m_MessageSocketPara.Overlapped.hEvent);
	::HeapFree(pClient->m_hHeap, 0,pClient->m_MessageSocketPara.pBuffer);
	return 0;
}
//------------------------------------------------------------------------------

unsigned int  __stdcall ArWinClient_T::SocketMultiCast(void* pParent)
{
	ArWinClient_T* pClient = (ArWinClient_T*)pParent;
		
	pClient->m_MulitCastSocketPara.pBuffer = (char*)HeapAlloc(pClient->m_hHeap, 0, pClient->m_iMaxMultCastMsgSize);
	pClient->m_MulitCastSocketPara.DataBuf.buf = pClient->m_MulitCastSocketPara.pBuffer; 
	pClient->m_MulitCastSocketPara.DataBuf.len = pClient->m_iMaxMultCastMsgSize;
	
	ZeroMemory(&pClient->m_MulitCastSocketPara.Overlapped,  sizeof(OVERLAPPED));
	pClient->m_MulitCastSocketPara.Overlapped.hEvent = WSACreateEvent();
	
	while(true)
	{
		DWORD RecvBytes;
        DWORD Flags;
		Flags = 0;
        if (WSARecv(pClient->m_MultiCastSocket,
			&(pClient->m_MulitCastSocketPara.DataBuf), 1,
			&RecvBytes, &Flags,
			&(pClient->m_MulitCastSocketPara.Overlapped),
			NULL) == SOCKET_ERROR)
        {
			if (WSAGetLastError() != ERROR_IO_PENDING)
			{
				break;
			}
		}		
	
	    if ( WSAWaitForMultipleEvents(1, &pClient->m_MulitCastSocketPara.Overlapped.hEvent, FALSE,
			WSA_INFINITE, FALSE) == WSA_WAIT_FAILED)
		{
			break;
		}
	
		WSAResetEvent(pClient->m_MulitCastSocketPara.Overlapped.hEvent);

		DWORD BytesTransferred;
		if (WSAGetOverlappedResult(pClient->m_MultiCastSocket,
			&(pClient->m_MulitCastSocketPara.Overlapped),
			&BytesTransferred,
			FALSE, &Flags) == FALSE )
		{
			break;
		}
		
		ArDataPackage_T* pDataPackager = (ArDataPackage_T*)pClient->m_MulitCastSocketPara.DataBuf.buf;
		if(DATA == pDataPackager->ucType)
		{
			char* pReceiveData = pClient->m_MulitCastSocketPara.DataBuf.buf + sizeof(ArDataPackage_T);
			if(pClient->m_pReceiveDataFunc)
			{
				pClient->m_pReceiveDataFunc(pReceiveData, pDataPackager->iDataSize, 
					                        pClient->m_SenderInfo,
											pClient->m_pPara);	
			}			
		}
		
	}


	WSACloseEvent(pClient->m_MulitCastSocketPara.Overlapped.hEvent);
	::HeapFree(pClient->m_hHeap, 0, pClient->m_MulitCastSocketPara.pBuffer);
	return 0;
}
//------------------------------------------------------------------------------

bool ArWinClient_T::CreateSocket(void)
{
	m_DataSocket = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0,
		                     WSA_FLAG_OVERLAPPED);
	m_MessageSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	m_MultiCastSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if(INVALID_SOCKET == m_DataSocket || INVALID_SOCKET == m_MessageSocket)
	{
		char strInfo[100];
		sprintf(strInfo,"创建Socket出错,出错号:%d!\n", WSAGetLastError());
		::MessageBox(NULL, strInfo, "错误", MB_ICONWARNING);
		return false;
	}

	//SetDataSocket
	if(true == m_bDataEnableLinger)
	{
		struct linger Linger;
		Linger.l_linger = 2000;
		Linger.l_onoff = true;
		setsockopt(m_DataSocket, SOL_SOCKET, SO_LINGER, (char*)&Linger, sizeof(Linger) );	
	}
	else
	{
		struct linger Linger;
		Linger.l_linger = 0;
		Linger.l_onoff = false;
		setsockopt(m_DataSocket, SOL_SOCKET, SO_LINGER, (char*)&Linger, sizeof(Linger) );
	}
	
	if(false == m_bDataHasRcvBuffer)
	{
		int iRcvBufferSize = 0; 
		setsockopt(m_DataSocket, SOL_SOCKET,SO_RCVBUF, (char*)&iRcvBufferSize, sizeof(iRcvBufferSize));	
	}
	
	if(false == m_bDataHasSendBuffer)
	{
		int iSendBufferSize = 0;
		setsockopt(m_DataSocket, SOL_SOCKET,SO_SNDBUF, (char*)&iSendBufferSize, sizeof(iSendBufferSize));	
	}
	//SetMessageSocket
	if(true == m_bMessageEnableLinger)
	{
		struct linger Linger;
		Linger.l_linger = 2000;
		Linger.l_onoff = true;
		setsockopt(m_MessageSocket, SOL_SOCKET, SO_LINGER, (char*)&Linger, sizeof(Linger) );	
	}
	else
	{
		struct linger Linger;
		Linger.l_linger = 0;
		Linger.l_onoff = false;
		setsockopt(m_MessageSocket, SOL_SOCKET, SO_LINGER, (char*)&Linger, sizeof(Linger) );
	}
	
	if(false == m_bMessageHasRcvBuffer)
	{
		int iRcvBufferSize = 0; 
		setsockopt(m_MessageSocket, SOL_SOCKET,SO_RCVBUF, (char*)&iRcvBufferSize, sizeof(iRcvBufferSize));	
	}
	
	if(false == m_bMessageHasSendBuffer)
	{
		int iSendBufferSize = 0;
		setsockopt(m_MessageSocket, SOL_SOCKET,SO_SNDBUF, (char*)&iSendBufferSize, sizeof(iSendBufferSize));	
	}

	//SetMultiCastSocket
	if(true == m_bMultiCastEnableLinger)
	{
		struct linger Linger;
		Linger.l_linger = 2000;
		Linger.l_onoff = true;
		setsockopt(m_MultiCastSocket, SOL_SOCKET, SO_LINGER, (char*)&Linger, sizeof(Linger) );	
	}
	else
	{
		struct linger Linger;
		Linger.l_linger = 0;
		Linger.l_onoff = false;
		setsockopt(m_MultiCastSocket, SOL_SOCKET, SO_LINGER, (char*)&Linger, sizeof(Linger) );
	}
	
	if(false == m_bMultiCastHasRcvBuffer)
	{
		int iRcvBufferSize = 0; 
		setsockopt(m_MultiCastSocket, SOL_SOCKET,SO_RCVBUF, (char*)&iRcvBufferSize, sizeof(iRcvBufferSize));	
	}
	
	if(false == m_bMultiCastHasSendBuffer)
	{
		int iSendBufferSize = 0;
		setsockopt(m_MultiCastSocket, SOL_SOCKET,SO_SNDBUF, (char*)&iSendBufferSize, sizeof(iSendBufferSize));	
	}



	if(bind(m_MessageSocket, (struct sockaddr *)&m_LocalMessageAddr , 
		sizeof(m_LocalMessageAddr)) == SOCKET_ERROR)
	{
		char strInfo[100];
		sprintf(strInfo,"绑定ClientMessageSocket出错,出错号:%d!\n", WSAGetLastError());
        ::MessageBox(NULL, strInfo, "错误", MB_ICONWARNING);
		return false;
	}
	
	
	//设置多播Socket
 #ifdef ENABLE_MUTICAST
    const int on = 1;
	int ret = setsockopt(m_MultiCastSocket, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on));
	if(ret == SOCKET_ERROR)
	{
		char strInfo[100];
		sprintf(strInfo,"setsockopt(SO_REUSEADDR)出错,出错号:%d!\n", WSAGetLastError());
        ::MessageBox(NULL, strInfo, "错误", MB_ICONWARNING);
		//return false;
	}
	
    const int routenum = 4;
	ret = setsockopt(m_MultiCastSocket,IPPROTO_IP,IP_MULTICAST_TTL,(char*)&routenum,sizeof(routenum));
	if( ret == SOCKET_ERROR )
	{
		char strInfo[100];
		sprintf(strInfo,"setsockopt(IP_MULTICAST_TTL)出错,出错号:%d!\n", WSAGetLastError());
        ::MessageBox(NULL, strInfo, "错误", MB_ICONWARNING);
		//return false;
	}
	
	/*const int loopback = 0; //禁止回馈
	ret = setsockopt(m_MultiCastSocket,IPPROTO_IP,IP_MULTICAST_LOOP,(char*)&loopback,sizeof(loopback));
	if( ret == SOCKET_ERROR )
	{
		char strInfo[100];
		sprintf(strInfo,"setsockopt(IP_MULTICAST_LOOP)出错,出错号:%d!\n", WSAGetLastError());
        ::MessageBox(NULL, strInfo, "错误", MB_ICONWARNING);
		return false;
	}*/
	
	if(bind(m_MultiCastSocket, (struct sockaddr *)&m_MutiCastAdrr, 
		sizeof(m_MutiCastAdrr)) == SOCKET_ERROR)
	{
		char strInfo[100];
		sprintf(strInfo,"绑定MessageSocket出错,出错号:%d!\n", WSAGetLastError());
        ::MessageBox(NULL, strInfo, "错误", MB_ICONWARNING);
		return false;
	}
	
	
	ip_mreq mreq;
	memset(&mreq, 0, sizeof(mreq));
	mreq.imr_interface.S_un.S_addr = INADDR_ANY;
	mreq.imr_multiaddr.S_un.S_addr = inet_addr(MULTICAST_IP);
	
	ret = setsockopt(m_MultiCastSocket,IPPROTO_IP,IP_ADD_MEMBERSHIP,(char*)&mreq,sizeof(mreq));
	if( ret == SOCKET_ERROR )
	{
		char strInfo[100];
		sprintf(strInfo,"setsockopt(IP_ADD_MEMBERSHIP)出错,出错号:%d!\n", WSAGetLastError());
        ::MessageBox(NULL, strInfo, "错误", MB_ICONWARNING);
		return false;
		
	}
#endif
	
	return true;
}
//------------------------------------------------------------------------------

void ArWinClient_T::CloseSocket(void)
{
	closesocket(m_DataSocket);
	closesocket(m_MessageSocket);
#ifdef ENABLE_MUTICAST
	closesocket(m_MultiCastSocket);
#endif
}