packetmac.cpp

基于MAC网卡物理地址的通信类

// PacketMAC.cpp: implementation of the PacketMAC class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "PacketMAC.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif


#include "WINSOCK2.H"
#include "Packet32.h"
#include "Ntddndis.h"
#include "string.h"

#pragma comment(lib, "Packet.lib")
#pragma comment(lib, "wpcap.lib")
#pragma comment(lib, "ws2_32.lib")

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

UINT GetPacket(LPVOID pParam);
void GetData(PacketMAC *dlg);		
UINT GetMine( LPVOID pParam );

PacketMAC::PacketMAC()
:Buffer(BUFMAX),gatewayBuffer(BUFMAX)
{
	ErrorText = "";
	AdapterList = "";
	AdapterName = "";
	AdapterNameCount = 0;
	lpPacket = PacketAllocatePacket();//建立数据缓存
	lpadapter = NULL;
	start = false;
	myip = "";
	for(int i=0;i<6;i++)
	{
		mmac[i] = 0;
	}
	GetWKNameList();
}

PacketMAC::~PacketMAC()
{
	start = false;
	Sleep(200);
	
	PacketFreePacket(lpPacket);		
	if(lpadapter !=NULL)
	{
		PacketCloseAdapter( lpadapter);
	}
}
//初始化
bool PacketMAC::init()
{
	//获得本机IP
	HKEY hKey;
	CString strKeyName = 
		"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\";
	
	strKeyName += AdapterName.Mid(12);
	
	if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
		(LPCSTR)strKeyName,
		0,
		KEY_READ,
		&hKey) != ERROR_SUCCESS)
	{
		
		return FALSE;
	}
	
	unsigned char szData[256];
	DWORD dwDataType, dwBufSize;
	
	CString temp;
	
	dwBufSize = 256;
	if(RegQueryValueEx(hKey, "IPAddress", 0, &dwDataType, szData, &dwBufSize) == ERROR_SUCCESS)
	{	
		myip = (CString)szData;
	}

	//打开网卡
	lpadapter=PacketOpenAdapter(AdapterName.GetBuffer(100));
	
	if(NULL == lpadapter)
	{
		ErrorText = "Open Adapter Error";
		return false;
	}


	//过虑--只有目的地为本地主机网络适配器的数据报才会被接收
	PacketSetHwFilter(lpadapter,NDIS_PACKET_TYPE_PROMISCUOUS);
	
	// 设置driver有512KB字节的缓冲区	
	PacketSetBuff(lpadapter,512000) ;
	
	// 设置读操作超时时间0.5秒
	PacketSetReadTimeout(lpadapter,5000) ; 
	
	//即将packet结构中的buffer设置为传递的buffer指针。
	PacketInitPacket(lpPacket,(char*)buffer,256000);
	
	//设置调用PacketSendPacket()函数发送一个数据报副本所重复的次数。
	PacketSetNumWrites(lpadapter,1);

	ErrorText ="";
	return true;
}
//取网卡名列表
bool PacketMAC::GetWKNameList()
{
	
		char Name[8192],*name1,adapterlist[10][1024] = {{0}};
		ULONG    AdapterLength;
		int i,n,AdapterNum;
		
		if( PacketGetAdapterNames(Name,&AdapterLength) == FALSE )
		{	
			ErrorText.Format("不存在网卡!");
			return false;
	 	}
		
		if(strcmp(Name,"") == 0)
		{
			ErrorText = "不存在网卡!";
			return false;
		}
		name1 = Name;
	 	i = 0;
		n = 0;
	 	while((*name1!='\0') || (*(name1+2)!='\0'))
	 	{
			adapterlist[i][n]=*name1;
	 		name1 = name1 + 2;
	 		if(*name1 == '\0' && *(name1+1) == '\0' 
	 			&& *(name1+2)!='\0')
			{
				adapterlist[i][n]=*name1;
	 			i++;
				n=0;
					name1 = name1 + 2;
			}
			else
			{
					n++;
			}
		}
		 	
		AdapterNum = i+1;
		CString temp;
		for(i=0; i<AdapterNum ;i++)
		{
			temp.Format("%s",adapterlist[i]);
			AdapterList += temp+"&";
		}

		AdapterNameCount = AdapterNum;
	return true;
}

//获取网卡个数
int PacketMAC::GetAdapterNameCount()
{
	return AdapterNameCount;
}

//从列表中取网卡名
CString PacketMAC::GetAdapterNameForList(int index)
{

	if(index > AdapterNameCount)
	{
		ErrorText.Format("Index Error");
		return "Error";
	}
	CString name = AdapterList;
	for(int i=0;i<index;i++)
	{

		name = name.Mid(name.Find("&",0)+1);
	}

	ErrorText = "";
	int ind = name.Find("&",0);
	if(ind<0)
	{
		return name;
	}
	else
	{
		return name.Left(ind);
	}
	
}

//设置网卡名
bool PacketMAC::SetAdapterName(int index)
{
	if(index > AdapterNameCount)
	{
		ErrorText = "index Error";
		return false;
	}
	AdapterName = GetAdapterNameForList(index);
	ErrorText = "";
	return true;
}

bool PacketMAC::SetAdapterName(CString name)
{
	for(int i=0 ;i<AdapterNameCount;i++)
	{
		if(name.Compare(GetAdapterNameForList(i)) == 0)
		{
			AdapterName = name;
			ErrorText = "";
			return true;
		}
	}

	ErrorText = "name Error";
	return false;
}

//取当前网卡名
CString PacketMAC::GetAdapterName()
{
	return AdapterName;
}

//取错误信息
CString PacketMAC::GetErrorText()
{

	return ErrorText;
}

//开始接收服务
bool PacketMAC::Open()
{
	if(start)
	{
		return false;
	}
	start = true;
	AfxBeginThread(GetPacket, this);
	Sleep(300);
/*

	int i;
	for(i=0;i<10;i++)
	{
		int t;
		for(t=0;t<6;t++)
		{
			if(mmac[i] != 0)
			{
				break;
			}
		}
		if(t<6)
		{
			break;
		}
		Sleep(500);
	}
	if(i<10)
	{
		return true;
	}
	start = false;
	return false;
*/
	return true;
}

//关闭接收服务
bool PacketMAC::Close()
{
	this->start = false;
	Sleep(300);
	return true;
}

//读缓存
MAC PacketMAC::ReadBuffer()
{
	return Buffer.Get();
}

//
bool PacketMAC::IsNull()
{
	return Buffer.IsNull();
}
//发送数据
bool PacketMAC::Send(CString data,unsigned char tmac[])
{
	LPPACKET lppackets;
	lppackets = PacketAllocatePacket();
	
	MAC mac;
	char   sendbuf[sizeof(mac)];
	mac.head = MAC_HEAD;

	memcpy(mac.tha,tmac,6);
	memcpy(mac.sha,mmac,6);
	
	short int len = 1000;
	memcpy(mac.len,&len,2);
	int crc = 100;
	memcpy(mac.crc,&crc,4);
	MACDATA macdata;
	macdata.head = DATA_HEAD;
	
	memcpy(macdata.data,data.GetBuffer(999),sizeof(macdata.data));
	
	memcpy(mac.data,&macdata,sizeof(macdata));
	
	memset(sendbuf,0,sizeof(sendbuf));
	memcpy(sendbuf,&mac,sizeof(mac));
	PacketInitPacket(lppackets,sendbuf,sizeof(mac));
	if(PacketSendPacket(lpadapter,lppackets,TRUE)==FALSE)
	{
		PacketFreePacket(lppackets);		
		return false;
	}
	PacketFreePacket(lppackets);			
	return true;
}

bool PacketMAC::Send(CString data)
{
	LPPACKET lppackets;
	lppackets = PacketAllocatePacket();
	
	MAC mac;
	char   sendbuf[sizeof(mac)];
	mac.head = MAC_HEAD;
	
	for (int i = 0;i<6;i++)
	{
		mac.tha[i] = 0xff; 
	}
	
	memcpy(mac.sha,mmac,6);
	
	short int len = 1000;
	memcpy(mac.len,&len,2);
	int crc = 100;
	memcpy(mac.crc,&crc,4);
	MACDATA macdata;
	macdata.head = DATA_HEAD_ALL;
	
	memcpy(macdata.data,data.GetBuffer(999),sizeof(macdata.data));
	
	memcpy(mac.data,&macdata,sizeof(macdata));

	memset(sendbuf,0,sizeof(sendbuf));
	memcpy(sendbuf,&mac,sizeof(mac));
	PacketInitPacket(lppackets,sendbuf,sizeof(mac));
	if(PacketSendPacket(lpadapter,lppackets,TRUE)==FALSE)
	{
		PacketFreePacket(lppackets);				
		return false;
	}
	PacketFreePacket(lppackets);			
	return true;

}


//===================================================================
//全局函数

UINT GetPacket(LPVOID pParam)
{
	PacketMAC *dlg = (PacketMAC *)pParam;
	while(dlg->start)
	{
		
		if( PacketReceivePacket(dlg->lpadapter,dlg->lpPacket,TRUE) )
		{
			GetData(dlg) ;		
		}
		
	}
	
	return 0;
}

void GetData(PacketMAC *dlg)
{
	ULONG  ulbytesreceived,off;
	ETHDR  *eth;
	ARPHDR *arp;
	IPHDR *ip;
//	MAC* mac;
	char   *buf,*pChar;
	struct bpf_hdr      *hdr;
	struct sockaddr_in  sin;

	ulbytesreceived = dlg->lpPacket->ulBytesReceived;
	buf = (char *)dlg->lpPacket->Buffer;

	off=0;
	while( off < ulbytesreceived )
	{
		
		hdr = (struct bpf_hdr *)(buf + off);
		off += hdr->bh_hdrlen;
		
		pChar = (char *)(buf + off);
		off = Packet_WORDALIGN(off + hdr->bh_caplen);
		
		eth = (ETHDR *)pChar;                
		arp = (ARPHDR *)(pChar + sizeof(ETHDR)); 
//		mac = (MAC *)pChar;
//		CString CS_ip;
		
		if( htons(ETH_IP) == eth->eh_type)				//当数据包为IP数据包时进入
		{
			unsigned char tmac[6] = {0x01,0x00,0x5e,0x7f,0xff,0xfa};
			int i;
			for(i=0;i<6;i++)
			{
				if(eth->eh_dst[i]!=tmac[i])
				{
					break;
				}
			}
			if(i>=6)
			{
				Gateway gateway;
				ip = (IPHDR *)(pChar + sizeof(ETHDR));
				sin.sin_addr.S_un.S_addr = ip->sourceip;
				CString ips = inet_ntoa(sin.sin_addr);
				memcpy(gateway.ip,ips.GetBuffer(20),ips.GetAllocLength()+1);

				dlg->gatewayBuffer.Put(gateway);
			}
		
		}
/*
		else if(eth->eh_type==htons(ETH_ARP))			//当数据包为ARP数据包时进入
		{
			
			sin.sin_addr.S_un.S_addr=*((unsigned long *)(((char *)arp)+14));
			CS_ip = inet_ntoa(sin.sin_addr);			//取发送方IP地址
			
			if(CS_ip == dlg->myip)				//若此IP为本机IP则将MAC地址存入主窗口对象
			{
				memcpy(dlg->mmac,eth->eh_src,6);
			}
		
			
		}
		else if(mac->head==MAC_HEAD)
		{
			int i;
			for(i=0;i<6;i++)
			{
				if(mac->tha[i]!=0xff)
				{
					break;
				}
			}
			if(i>=6)
			{
				dlg->Buffer.Put(*mac);
			}
			else
			{
				for(i=0;i<6;i++)
				{
					if(mac->tha[i]!=dlg->mmac[i])
					{
						break;
					}
				}
				if(i>=6)
				{
					dlg->Buffer.Put(*mac);
				}
			}
		}
		
*/		
		
	}

	return ;
	
}


UINT GetMine( LPVOID pParam )
{
	PacketMAC *dlg = (PacketMAC *)pParam;
	LPPACKET lppacket;		//数据包
	lppacket = PacketAllocatePacket();
	char   sendbuf[1024]={0};
	int    k;
	ETHDR  eth;
	ARPHDR arp;
	
	for(k=0;k<6;k++)
	{
		eth.eh_dst[k]  = 0xff;
		eth.eh_src[k]  = 0x82;
		arp.arp_sha[k] = 0x82;
		arp.arp_tha[k] = 0x00;
	}
	
	eth.eh_type = htons(ETH_ARP);
	arp.arp_hdr = htons(ARP_HARDWARE);
	arp.arp_pro = htons(ETH_IP);
	arp.arp_hln = 6;
	arp.arp_pln = 4;
	arp.arp_opt = htons(ARP_REQUEST);
	
	char *p;
	p = (char*)&arp;
	
	*((unsigned long *)(p + 14)) = inet_addr( "112.112.112.112" );
	*((unsigned long *)(p + 24)) = inet_addr( dlg->myip );
	memcpy( sendbuf, &eth, sizeof(eth) );
	memcpy( sendbuf + sizeof(eth), &arp, sizeof( arp ) );
	
	PacketInitPacket(lppacket,sendbuf,sizeof(eth)+sizeof(arp));
	if(PacketSendPacket(dlg->lpadapter,lppacket,TRUE)==FALSE)
	{
		PacketFreePacket(lppacket);				
		return -1;             
	}
	PacketFreePacket(lppacket);		
	return 0;
}


Gateway PacketMAC::ReadBufferIP()
{
	return gatewayBuffer.Get();
}

bool PacketMAC::IsNullIP()
{
	return gatewayBuffer.IsNull();
}

void PacketMAC::write()
{
	Gateway buffer;
	buffer.ip[0]='A';
	buffer.ip[1]=0;
	this->gatewayBuffer.Put(buffer);
}