netinterface.cpp

用事件方式

	dwFlags=0;
	pending=FALSE;
	memset(&addr,0,sizeof(SOCKADDR));
	memset(&overlapped,0,sizeof(overlapped));

	overlapped.hEvent=WSACreateEvent();		//读完数据事件
	
	AddMessageToLogFile("接收到数据！");

	wsbuf.len=BUFFER_SIZE;
	wsbuf.buf=pdata->rawData;

	int len=sizeof(SOCKADDR);		
	nRet=WSARecvFrom(m_server,&wsbuf,1,&pdata->rawDataLen,&dwFlags,
		(LPSOCKADDR)&addr,&len,&overlapped,NULL);
	
	if(nRet==0)
	{
		pdata->rawData[pdata->rawDataLen]='\0';
		pdata->m_strIP=inet_ntoa(addr.sin_addr);
		pdata->m_uPort=ntohs(addr.sin_port);
		strMessage.Format("成功读取数据[ip=%s][port=%d]！\r\n数据内容:[%s][%d]",
			pdata->m_strIP,pdata->m_uPort,pdata->rawData,pdata->rawDataLen);
		AddMessageToLogFile(strMessage);
	}
	else if(nRet==SOCKET_ERROR)
	{
		error=WSAGetLastError();
		if(error==WSA_IO_PENDING)pending=TRUE;
		else
		{
			//WSARecvFrom错误,就将这个数据丢掉
			AddMessageToLogFile("WSARecvFrom错误,就将这个数据丢掉");
			bRet=FALSE;
		}
	}
	if(pending)
	{
		AddMessageToLogFile("操作系统正在进行重叠操作，等待...");
		dwPendingRet=WaitForSingleObject(overlapped.hEvent,TIME_OUT);
		if(dwPendingRet==WAIT_TIMEOUT)
		{
			//超时
			AddMessageToLogFile("读取数据超时");
			bRet=FALSE;
		}
		else
		{
			if(dwPendingRet==WAIT_OBJECT_0)//操作系统完成重叠操作
			{
				AddMessageToLogFile("操作系统完成重叠操作");
				if(!WSAGetOverlappedResult(m_server,&overlapped,&pdata->rawDataLen,FALSE,&dwFlags))
				{
					//不能得到重叠操作结果,就将这个数据丢掉
					AddMessageToLogFile("不能得到重叠操作结果,丢掉数据");
					bRet=FALSE;
				}
				else//得到重叠操作结果
				{
					AddMessageToLogFile("得到重叠操作结果，读取数据成功!");
				}
			}
			else
			{
				//发生未知错误,就将这个数据丢掉
				AddMessageToLogFile("重叠操作出现错误");
				bRet=FALSE;
			}
		}
	}

	WSACloseEvent(overlapped.hEvent);
	return bRet;
}
BOOL CNetInterfaceApp::_SendData(CData*pdata, SOCKADDR_IN &addr)
{
	BOOL	bRet=TRUE;

	WSABUF			wsbuf;
	WSAOVERLAPPED	overlapped;
	DWORD			dwFlags;
	DWORD			dwSendBytes;
	DWORD			dwPendingRet;
	int				nRet,error;
	BOOL			pending;
	CString			strMessage;

	dwFlags=0;
	pending=FALSE;
	wsbuf.len=BUFFER_SIZE;
	memset(&overlapped,0,sizeof(overlapped));

	overlapped.hEvent=WSACreateEvent();		//发送完数据事件

	wsbuf.buf=pdata->rawData;
	wsbuf.len=pdata->rawDataLen;

	memset(&addr,0,sizeof(SOCKADDR));

	addr.sin_family=AF_INET;
	addr.sin_addr.s_addr=inet_addr(pdata->m_strIP);
	addr.sin_port=htons(pdata->m_uPort);

	nRet=WSASendTo(m_server,&wsbuf,1,&dwSendBytes,dwFlags,(LPSOCKADDR)&addr,sizeof(SOCKADDR),
		&overlapped,NULL);
	if(nRet==0)
	{
		strMessage.Format("成功发送数据[ip=%s][port=%d]！\r\n数据内容:[%s][%d]",
			pdata->m_strIP,pdata->m_uPort,pdata->fineData,pdata->fineDataLen);
		AddMessageToLogFile(strMessage);
	}
	else if(nRet==SOCKET_ERROR)
	{
		error=WSAGetLastError();
		if(error==WSA_IO_PENDING)pending=TRUE;
		else
		{
			//WSASendTo错误,就将这个数据丢掉
			AddMessageToLogFile("WSASendTo错误,就将这个数据丢掉");
			bRet=FALSE;
		}
	}
	if(pending)
	{
		dwPendingRet=WaitForSingleObject(overlapped.hEvent,TIME_OUT);
		if(dwPendingRet==WAIT_TIMEOUT)
		{
			AddMessageToLogFile("发送数据超时");
			bRet=FALSE;
		}
		else if(dwPendingRet==WAIT_OBJECT_0)
		{
			if(!WSAGetOverlappedResult(m_server,&overlapped,&dwSendBytes,FALSE,&dwFlags))
			{
				AddMessageToLogFile("经过重叠操作，发送数据失败");
				bRet=FALSE;
			}
			else
			{
				AddMessageToLogFile("经过重叠操作，成功发送数据");
			}
		}
		else
		{
			AddMessageToLogFile("重叠操作出现错误");
			bRet=FALSE;
		}
	}

	WSACloseEvent(overlapped.hEvent);
	return TRUE;
}
////////////////////////////////////////////////////////////////////////////////////////
//以下为输出函数
////////////////////////////////////////////////////////////////////////////////////////
//设置DLL
void CNetInterfaceApp::SetNetInterfaceInfo(HWND hWnd, CString ip, UINT port, UINT message)
{
	m_hUserProgramWnd=hWnd;
	WM_NEW_MESSAGE=message;

	memset(&m_server_sockaddr_in,0,sizeof(SOCKADDR_IN));
	m_server_sockaddr_in.sin_family=AF_INET;
	m_server_sockaddr_in.sin_addr.s_addr=inet_addr(ip);
	m_server_sockaddr_in.sin_port=htons(port);

	m_bHasSetupDLL=TRUE;
}
//启动服务
BOOL CNetInterfaceApp::StartServer()
{
	if(!m_bHasSetupDLL)
	{
		AddMessageToLogFile("没有设置DLL");
		return FALSE;
	}
	if(m_bServerStart)return TRUE;

	WSAData wsData;
	WORD version=MAKEWORD(2,2);
	if(WSAStartup(version,&wsData))
	{
		AddMessageToLogFile("WSAStartup fail!");
		return FALSE;
	}
	else
	{
		AddMessageToLogFile("WSAStartup successs!");
	}
	if(version!=wsData.wVersion)
	{
		AddMessageToLogFile("version not right!");
		return FALSE;
	}
	else
	{
		AddMessageToLogFile("version right!");
	}
	m_server=WSASocket(PF_INET,SOCK_DGRAM,0,NULL,0,WSA_FLAG_OVERLAPPED);
	if(INVALID_SOCKET==m_server)
	{
		AddMessageToLogFile("socket create fail!");
		return FALSE;
	}
	else
	{
		AddMessageToLogFile("socket create success!");
	}
	int error=bind(m_server,(LPSOCKADDR)&m_server_sockaddr_in,sizeof(SOCKADDR));
	if(SOCKET_ERROR==error)
	{
		AddMessageToLogFile("bind fail!");
		return FALSE;
	}
	else
	{
		AddMessageToLogFile("bind success!");
	}
	//创建网络事件
	for(int i=0;i<EVENT_NUM;i++)
	{
		EventArray[i]=WSACreateEvent();
		if(EventArray[i]==INVALID_HANDLE_VALUE)
		{
			AddMessageToLogFile("WSACreateEvent Failed!");
			return FALSE;
		}
		else
		{
			AddMessageToLogFile("WSACreateEvent success!");
		}
	}

	//设置接收事件
	error=WSAEventSelect(m_server,EventArray[EVENT_BEGIN_READ],FD_READ);
	if(error!=0)
	{
		AddMessageToLogFile("WSAEventSelect Failed!");
		return FALSE;
	}
	else
	{
		AddMessageToLogFile("WSAEventSelect success!");
	}
	//启动成功
	m_bServerStart=TRUE;
	AddMessageToLogFile("NetInterface DLL Init success!");

	//初始化接收、发送缓冲区
	InitBuffer();

	//创建数据处理器
	m_pDataEngine=new CDataAnalysisEngine();

	//启动读取和发送数据线程
	AfxBeginThread(&DataAnalysisThread,(LPVOID)this);
	AfxBeginThread(&ReadDataThread,(LPVOID)this,THREAD_PRIORITY_HIGHEST);
	AfxBeginThread(&SendDataThread,(LPVOID)this);

	return TRUE;
}
BOOL CNetInterfaceApp::StopServer()
{
	if(!m_bServerStart)return TRUE;

	//停止读取数据线程
	WSASetEvent(EventArray[EVENT_CLOSE_READ_THREAD]);
	//停止发送数据线程
	WSASetEvent(EventArray[EVENT_CLOSE_SEND_THREAD]);
	//停止发送数据线程
	WSASetEvent(EventArray[EVENT_CLOSE_DATA_PROCESS_THREAD]);

	//等待读取、发送线程停止
	WaitForMultipleObjects(3,&EventArray[EVENT_READ_THREAD_END],TRUE,WSA_INFINITE);

	//关闭SOCKET
	shutdown(m_server,SD_BOTH);
	closesocket(m_server);
	m_server=INVALID_SOCKET;

	//清除网络事件
	for(int i=0;i<EVENT_NUM;i++)
	{
		WSACloseEvent(EventArray[i]);
	}

	//清除缓冲区
	UnInitBuffer();

	//清除SOCKET
	WSACleanup();

	//清除数据处理器具
	delete m_pDataEngine;
	m_pDataEngine=NULL;

	//重置打开标志
	m_bServerStart=FALSE;
	return TRUE;
}
//发送数据
void CNetInterfaceApp::SendData(int nOrderGroup,
								int nOrder,
								char szData[], int len, CString ip, UINT port)
{
	if(!m_bHasSetupDLL||!m_bServerStart)return;

	CData *pdata=GetNextBlankBuffer(m_send_data_list,m_nextBlank_sendData);
	memcpy(pdata->fineData,szData,len);
	pdata->fineData[len]='\0';
	pdata->fineDataLen=len;
	pdata->m_strIP=ip;
	pdata->m_uPort=port;
	pdata->m_nOrder=nOrder;
	pdata->m_nOrderGroup=nOrderGroup;


	m_pDataEngine->ComposeData(pdata);
	//通知，启动发送数据过程
	WSASetEvent(EventArray[EVENT_BEGIN_SEND]);
}
//读取数据
int CNetInterfaceApp::ReadData(int &nOrderGroup,
							   int &nOrder,
							   char szData[], int &len, CString &ip, UINT &port)
{
	if(!m_bHasSetupDLL||!m_bServerStart)return -2;

	if(len==0)return -1;
	CData *pdata=GetNextBuffer(m_read_data_list,m_nextUnanalysised_readData);
	if(pdata==NULL)return 0;
	memcpy(szData,pdata->fineData,pdata->fineDataLen);
	len=pdata->fineDataLen;
	szData[len]='\0';
	ip=pdata->m_strIP;
	port=pdata->m_uPort;
	nOrder=pdata->m_nOrder;
	nOrderGroup=pdata->m_nOrderGroup;
	return 1;
}