arwinserver_t.cpp

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

{
	ArClientInfo_T ClientInfo;
	if(FindClient(ulClientAddr, ClientInfo))
	{
			
		closesocket(ClientInfo.ConnectSocket);
		return true;
	}
	return false;
}
//------------------------------------------------------------------------------

int   __stdcall	ArWinServer_T::	SendData(unsigned long ulClientAddr, char* pcData, int iLength) 
{
	ArClientInfo_T Info;
	int iData;
	/*if(iLength < 224)
	{
		return(SendDataPackage(ulClientAddr, pcData, iLength));
	}*/
	if(FindClient(ulClientAddr, Info))
	{
		ArDataPackage_T DataPackage;
		DataPackage.ucType = DATA;
		DataPackage.iDataSize = iLength;
		for(int i = 0; i < 58; i++)
		{
			DataPackage.ucVerify[i] = i % 3;
		}
		
		int  iSendDataSize = sizeof(ArDataPackage_T) + iLength; 
	
		memcpy(m_pcDataSendBuffer, &DataPackage, sizeof(ArDataPackage_T));
		memcpy(m_pcDataSendBuffer + sizeof(ArDataPackage_T), pcData, iLength);
		iData = send(Info.ConnectSocket, m_pcDataSendBuffer, iSendDataSize, 0) ;
		return iData;
	}
	
	return 0;
}
//------------------------------------------------------------------------------

int   __stdcall	ArWinServer_T::SendDataPackage(unsigned long ulClientAddr,char* pcData, int iLength) 
{
	struct sockaddr_in ClientAddr;
	ClientAddr.sin_addr.S_un.S_addr = ulClientAddr;
	ClientAddr.sin_family = AF_INET;
	ClientAddr.sin_port = htons(m_iPort + 4);

	if(NULL == pcData)
	{
		iLength = 0;	
	}
	if(iLength + sizeof(ArDataPackage_T) >= m_iMaxMsgBufferSize)
	{
		iLength = m_iMaxMsgBufferSize - sizeof(ArDataPackage_T);
	}	
		
	ArDataPackage_T DataPackage;
	DataPackage.ucType = DATA;
	DataPackage.iDataSize = iLength;

	memcpy(m_SendMessagerBuffer, &DataPackage, sizeof(DataPackage));
	if(iLength > 0)
	{
		
		memcpy(m_SendMessagerBuffer + sizeof(DataPackage), pcData, iLength);
		
	}
	int iDataNum = 0;
	iDataNum = sendto(m_MessageSocket, m_SendMessagerBuffer, 
		              sizeof(DataPackage) + DataPackage.iDataSize, 0, 
	                 (const struct sockaddr*)&ClientAddr, sizeof(ClientAddr));

	return iDataNum;
}
//------------------------------------------------------------------------------

int   __stdcall ArWinServer_T::BroadCastAllClients(char* pcData, int iDataLength)
{
	if(m_iConnectClientNum <= 0)
	{
		return 0;
	}
	if(NULL == pcData)
	{
		iDataLength = 0;	
	}
	if(iDataLength + sizeof(ArDataPackage_T) >= m_iMaxMultCastMsgSize)
	{
		iDataLength = m_iMaxMultCastMsgSize - sizeof(ArDataPackage_T);
	}	

	sockaddr_in remote;
	memset(&remote, 0, sizeof(remote));
	remote.sin_addr.s_addr = inet_addr (MULTICAST_IP);
	remote.sin_family = AF_INET ;
	remote.sin_port = htons(m_iPort + 2);

	ArDataPackage_T DataPackage;
	DataPackage.ucType = DATA;
	DataPackage.iDataSize = iDataLength;

	memcpy(m_MutiCastBuffer, &DataPackage, sizeof(DataPackage));
	if(iDataLength > 0)
	{
		memcpy(m_MutiCastBuffer + sizeof(DataPackage), pcData, iDataLength);
	}

	
	int iSendNum;
	iSendNum = sendto(m_MultiCastSocket, m_MutiCastBuffer, 
		              sizeof(ArDataPackage_T) + iDataLength, 0,
					  (sockaddr*)(&remote), sizeof(remote)); 
    	
	return iSendNum;	
}
//------------------------------------------------------------------------------

bool  __stdcall		ArWinServer_T::OnReceiveData(pOnReceiveData func)
{
	m_pOnReceiveFunc = func;
	return true;
}
//------------------------------------------------------------------------------

bool  __stdcall		ArWinServer_T::OnAccept(pOnConnect func) 
{
	m_pOnConnect = func;
	return true;
}
//------------------------------------------------------------------------------

bool  __stdcall		ArWinServer_T::OnDisconnect(pOnConnect func)
{
	m_pOnDisConnect = func;
	return true;
}

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

 bool  __stdcall ArWinServer_T::ClientAddrss(int iIndex, unsigned long& ulAddress)
{
	if(iIndex > m_iConnectClientNum)
	{
		iIndex =  m_iConnectClientNum;
	}
	if(iIndex < 1)
	{
		iIndex = 1;
	}
	std::list<ArClientInfo_T*>::iterator  ClientPos;
	ClientPos = m_ConnectClientInfoList.begin();
	bool bResult = false;
	int iPos = 1;
	while(ClientPos != m_ConnectClientInfoList.end())
	{
		ArClientInfo_T* pTemp = *ClientPos;
		if(iIndex == iPos)
		{
			ulAddress = pTemp->SenderInfo.ulAddress;
			bResult = true;
			break;
		}
		iPos++;
		ClientPos++;
	}	
	return bResult;
}
//------------------------------------------------------------------------------

bool ArWinServer_T::CreateSocket(void)
{
	m_ListenSocket = 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(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));	
	}
	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_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(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(INVALID_SOCKET == m_ListenSocket || INVALID_SOCKET == m_MessageSocket)
	{
		char strInfo[100];
		sprintf(strInfo,"创建ServerSocket出错,出错号:%d!\n", WSAGetLastError());
        ::MessageBox(NULL, strInfo, "错误", MB_ICONWARNING);
		return false;
	}

	//--------------StartBind----------------------------------------------

	if(bind(m_ListenSocket, (struct sockaddr *)&m_LocalAdrr, 
		sizeof(m_LocalAdrr)) == SOCKET_ERROR)
	{
		char strInfo[100];
		sprintf(strInfo,"绑定ListenSocketSocket出错,出错号:%d!\n", WSAGetLastError());
        ::MessageBox(NULL, strInfo, "错误", MB_ICONWARNING);
		return false;
	}

	if(bind(m_MessageSocket, (struct sockaddr *)&m_LocalMessageAdrr, 
		sizeof(m_LocalMessageAdrr)) == SOCKET_ERROR)
	{
		char strInfo[100];
		sprintf(strInfo,"绑定ServerMessageSocket出错,出错号:%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,"绑定ServerMultiCastSocket出错,出错号:%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		
	//--------------Start Listenning----------------------------------------

	if(listen(m_ListenSocket, m_iMaxClientNum) == SOCKET_ERROR)
	{
		char strInfo[100];
		sprintf(strInfo,"监听出错,出错号:%d!\n", WSAGetLastError());
        ::MessageBox(NULL, strInfo, "错误", MB_ICONWARNING);
		return false;
	}


 	unsigned int uiThreadID;
	m_ulThreadMessage = _beginthreadex(NULL, 0, SoketMessage,(void*)this, 0, &uiThreadID);
	m_ulThreadListen = _beginthreadex(NULL, 0, SoketListenning,(void*)this, 0, &uiThreadID);
 
	return true;
}
//------------------------------------------------------------------------------

void ArWinServer_T::DestroyAllClient(void)
{
	std::list<ArClientInfo_T*>::iterator  ClientPos;
	ClientPos = m_ConnectClientInfoList.begin();
	while(ClientPos != m_ConnectClientInfoList.end())
	{
		ArClientInfo_T* pTemp = *ClientPos;
		closesocket(pTemp->ConnectSocket);
		::WSACloseEvent(pTemp->hEvent);
		ClientPos++;
	}	
}