www.pudn.com > EthernetSpy.zip > Filter.cpp

#include  
#include  
 
#include "packet32.h" 
#include "EthernetSpyReader.h" 
#include "Filter.h" 
 
 
#define ASCII_TO_EXE(c) (c >= 'A' ? c-'A'+10 : c-'0')  
 
PBYTE CStringToHex (CString S, int Len) 
{ 
	if (S.GetLength() > 0) 
	{ 
		PBYTE H = (PBYTE) malloc(Len); 
 
		S.MakeUpper (); 
 
		for(int i = 0; i < min(Len, S.GetLength()); i++) 
		{ 
			H[i] = ASCII_TO_EXE( S[2*i] ) * 16 + ASCII_TO_EXE( S[2*i+1] ); 
		}	 
 
		return H; 
	} 
	else 
		return NULL; 
} 
 
CString HexToCString (PBYTE H, int Len) 
{ 
	CString S(""); 
	 
	if (H) 
	{ 
		CString Buf; 
		 
		for(int i = 0; i < Len; i++) 
		{ 
			Buf.Format("%02X", H[i]); 
			S = S + Buf; 
		} 
	} 
 
	return S; 
} 
 
 
////////////////////////////////////////////////////////////////////////// 
///// 
/////    EthernetHeaderFilter 
/////     
 
 
EthernetHeaderFilter::EthernetHeaderFilter(PBYTE _Source, PBYTE _Dest, PUSHORT _Type, EthernetSpyReader* _SpyReader) 
{ 
	Source = NULL; 
	Dest = NULL; 
	Type = NULL; 
 
	SpyReader = _SpyReader; 
 
	SetSourceAddrFlt (_Source); 
	SetDestAddrFlt (_Dest); 
	SetPktTypeFlt (_Type); 
} 
 
EthernetHeaderFilter::EthernetHeaderFilter(CString _Source, CString _Dest, CString _Type, EthernetSpyReader* _SpyReader) 
{ 
	Source = NULL; 
	Dest = NULL; 
	Type = NULL; 
 
	SpyReader = _SpyReader; 
 
	SetSourceAddrFlt (_Source); 
	SetDestAddrFlt (_Dest); 
	SetPktTypeFlt (_Type); 
} 
 
EthernetHeaderFilter::~EthernetHeaderFilter() 
{ 
	if( Source != NULL ); 
		free(Source); 
	 
	if( Dest != NULL ); 
		free(Dest); 
	 
	if( Type != NULL ); 
		free(Type);	 
} 
 
void EthernetHeaderFilter::SetSourceAddrFlt (PBYTE _Source) 
{ 
	if( Source != NULL ) 
		free(Source); 
	 
	if (_Source) 
	{ 
		Source = (PBYTE) malloc (6);  
		memcpy (Source, _Source, 6); 
	} 
	else 
		Source = NULL; 
} 
 
void EthernetHeaderFilter::SetSourceAddrFlt (CString _Source) 
{	 
	BYTE EthAddr[6]; 
 
	if (SpyReader->ConvertAddress(_Source, EthAddr)) 
	{ 
		SetSourceAddrFlt (EthAddr); 
		sSource = _Source; 
	} 
	else 
	{ 
		sSource = ""; 
		SetSourceAddrFlt (NULL); 
	} 
} 
	 
void EthernetHeaderFilter::SetDestAddrFlt (PBYTE _Dest) 
{ 
	if( Dest != NULL ) 
	{ 
		free(Dest); 
	} 
 
	if (_Dest) 
	{ 
		Dest = (PBYTE) malloc (6); 	 
		memcpy (Dest, _Dest, 6); 
	} 
	else 
		Dest = NULL;	 
} 
 
void EthernetHeaderFilter::SetDestAddrFlt (CString _Dest) 
{	 
	BYTE EthAddr[6]; 
 
	if (SpyReader->ConvertAddress(_Dest, EthAddr)) 
	{ 
		SetDestAddrFlt (EthAddr); 
		sDest = _Dest; 
	} 
	else 
	{ 
		sDest = ""; 
		SetDestAddrFlt (NULL); 
	}	 
} 
	 
void EthernetHeaderFilter::SetPktTypeFlt (PBYTE _Type) 
{ 
	if( Type != NULL ) 
	{ 
		free(Type); 
	} 
 
	Type = _Type; 
	sType = HexToCString (Type, 2); 
} 
 
void EthernetHeaderFilter::SetPktTypeFlt (CString _Type) 
{	 
	SetPktTypeFlt (CStringToHex (_Type, 2)); 
} 
	 
BOOL EthernetHeaderFilter::Match ( PFRAMEETH Frame ) 
{ 
	BOOL Result = TRUE; 
	 
	if (Source) 
		Result &= (memcmp( Source, Frame->SrcAddr, 6) == 0);					 
	 
	if (Dest) 
		Result &= (memcmp( Dest, Frame->DestAddr, 6) == 0);		 
	 
	if (Type) 
		Result &= (memcmp(Type, Frame->Type, 2) == 0); 
	 
	return Result; 
} 
 
 
 
////////////////////////////////////////////////////////////////////////// 
///// 
/////    TwoTalkingComputersFilter  
/////     
 
TwoTalkingComputersFilter::TwoTalkingComputersFilter (PBYTE _AddrA, PBYTE _AddrB, EthernetSpyReader* _SpyReader) 
{ 
	AddrA = NULL; 
	AddrB = NULL; 
 
	SpyReader = _SpyReader; 
 
	SetAddresses (_AddrA, _AddrB); 
} 
 
TwoTalkingComputersFilter::TwoTalkingComputersFilter (CString _AddrA, CString _AddrB, EthernetSpyReader* _SpyReader) 
{ 
	AddrA = NULL; 
	AddrB = NULL; 
 
	SpyReader = _SpyReader; 
 
	SetAddresses (_AddrA, _AddrB); 
} 
 
TwoTalkingComputersFilter::~TwoTalkingComputersFilter () 
{ 
	if( AddrA != NULL ) 
		free(AddrA); 
 
	if( AddrB != NULL ) 
		free(AddrB); 
} 
 
void TwoTalkingComputersFilter::SetAddresses (PBYTE _AddrA, PBYTE _AddrB) 
{ 
	if( AddrA != NULL ) 
		free(AddrA); 
 
	if (_AddrA) 
	{ 
		AddrA = (PBYTE) malloc (6); 	 
		memcpy (AddrA, _AddrA, 6); 
	} 
	else 
		AddrA = NULL; 
	 
	if( AddrB != NULL ) 
		free(AddrB); 
 
	if (_AddrB) 
	{ 
		AddrB = (PBYTE) malloc (6); 	 
		memcpy (AddrB, _AddrB, 6); 
	} 
	else 
		AddrB = NULL; 
 
} 
 
void TwoTalkingComputersFilter::SetAddresses (CString _AddrA, CString _AddrB) 
{ 
	BYTE EthAddrA[6]; 
	BYTE EthAddrB[6]; 
 
	BOOL A = SpyReader->ConvertAddress(_AddrA, EthAddrA); 
	BOOL B = SpyReader->ConvertAddress(_AddrB, EthAddrB); 
 
	SetAddresses ( A ? EthAddrA : NULL, B ? EthAddrB : NULL); 
 
	sAddrA = A ? _AddrA : ""; 
	sAddrB = B ? _AddrB : ""; 
} 
 
BOOL TwoTalkingComputersFilter::Match ( PFRAMEETH Frame ) 
{ 
	BOOL Result = TRUE; 
	 
	if (AddrA && AddrB) 
	{ 
		Result = ((memcmp( AddrA, Frame->SrcAddr, 6) == 0) && 					 
					(memcmp( AddrB, Frame->DestAddr, 6) == 0)) || 
				 ((memcmp( AddrA, Frame->DestAddr, 6) == 0) && 
					(memcmp( AddrB, Frame->SrcAddr, 6) == 0)); 
	} 
	else if (AddrA) 
	{ 
		Result = (memcmp( AddrA, Frame->SrcAddr, 6) == 0) || 
				   (memcmp( AddrA, Frame->DestAddr, 6) == 0); 
	} 
	else if (AddrB) 
	{ 
		Result = (memcmp( AddrB, Frame->SrcAddr, 6) == 0) || 
				   (memcmp( AddrB, Frame->DestAddr, 6) == 0); 
	} 
	 
	return Result; 
}