domainiphash.c

Linux下面截获以态网数据包！是在内核态下面运行的驱动程序

#include <linux/module.h> 
#include <linux/config.h> 
#include <linux/init.h> 
#include <linux/netdevice.h> 		/* for dev_base */
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/file.h>
#include <linux/dnotify.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/tcp.h>
#include <linux/udp.h>
#include <linux/time.h>

#include <asm/semaphore.h>
#include <asm/unistd.h>

#define MEMORY_CONTROL_NUM					120000//100000

#include "createDir.h"
#include "DomainIPHash.h"
#include "list.h"
#include "Rule.h"
#include "RuleIp.h"
#include "protocol.h"
#include "function.h"

extern GVAR gVar;

UINT StrHash( const char *key, UINT len )  
{  
	UINT hash;  
	const char *end = key + len;  
	
	for( hash = 0; key < end; key++)  
	{  
		hash *= 16777619;  
		hash ^= (UINT) *(UCHAR*)key;  
	}
	
	return (hash%_MAX_DOMAIN_HASH_BUCKET);  
}

UINT StrLowerCaseHash(const char *key, UINT len)  
{  
	UINT hash;  
	UCHAR lowerChar;
	const char *end = key + len;  
	
	for( hash = 0; key < end; key++)  
	{  
		hash *= 16777619;  
		if( (*(UCHAR*) key) >= 'A' && (*(UCHAR*) key) <= 'Z' )
		{
			lowerChar = (*(UCHAR*) key)+ 0x20;
			hash ^= (UINT)lowerChar; 
		}
		else
			hash ^= (UINT) *(UCHAR*) key;  
	}  
	//return (hash%_MAX_DOMAIN_HASH_BUCKET);  
	return hash;
}  

PDOMAIN_HASH_BUCKET FindDomain( const char *domain, UINT *pIndex)
{
	PDOMAIN_HASH_BUCKET pDomain;
	UINT 	index;
	UINT 	domainLen = strlen(domain);

	index = StrLowerCaseHash( domain, domainLen );
	index = index % _MAX_DOMAIN_HASH_BUCKET;
	pDomain = gVar.pDomainHash[index];
	while( pDomain )
	{
		if( pDomain->domainLen == domainLen )
		{
			if( 0 == strnicmp( domain, pDomain->payload, pDomain->domainLen ) )
			{
				break;
			}
		}
		pDomain = pDomain->pNext;
	}

	if( pIndex )
		*pIndex = index;
		
	return pDomain;
}

/*
三个地方调用:
1.读取WEBMAIL配置文件的域名；
2.重定位是加入过渡域名；
3.POST 域名
*/
void AddDomain( const char *domain, UINT type,
			PWEB_MAIL_CONFIG pConfig, int ruleID )
{
	PDOMAIN_HASH_BUCKET pDomainItem = NULL;
	UINT	index = 0;
	UINT	len = 0;

	pDomainItem = FindDomain( domain, &index);
	if( pDomainItem )
	{
		//已经存在该域名，则在type上或上新的类型。
		if( type == IP_TYPE_POST )
		{
			pDomainItem->ruleID = ruleID;
			pDomainItem->state = DOMAIN_STATE_VALIDATE;
		}
		pDomainItem->type |= type;
		return;
	}
		
	len = strlen( domain );
	pDomainItem = ( PDOMAIN_HASH_BUCKET ) kmalloc( sizeof(DOMAIN_HASH_BUCKET) + len, GFP_ATOMIC);
	if( !pDomainItem )
		return;
		
	pDomainItem->type = type;
	pDomainItem->domainLen = len;
	pDomainItem->pNext = gVar.pDomainHash[index];
	pDomainItem->pConfig = pConfig;
	pDomainItem->ruleID = ruleID;
	pDomainItem->state = DOMAIN_STATE_VALIDATE;
	
	memset( pDomainItem->payload, 0, len + 1 );
	memcpy( pDomainItem->payload, domain, len );
	
	gVar.pDomainHash[ index ] = pDomainItem;	
	gVar.domainNumber ++;
}

void InvalidateDomain( const char *domain)
{
	PDOMAIN_HASH_BUCKET pDomainItem = NULL;
	UINT index = 0;
//	UINT len = 0;
	pDomainItem = FindDomain( domain, &index);

	if( NULL == pDomainItem )
	{
		return;
	}
	pDomainItem->state = DOMAIN_STATE_INVALIDATE;
		
}

PIP_HASH_BUCKET FindIP( UINT ip)
{
	PIP_HASH_BUCKET pIP;
	
	
	UINT index = ip % _MAX_IP_HASH_BUCKET;
	pIP = gVar.pIPHash[ index ];
	while( pIP )
	{
		if( pIP->ip == ip )
		{
			break;
		}
		pIP = pIP->pNext;
	}
	
	return pIP;
}

void AddIPHash( UINT ip, UINT type, PWEB_MAIL_CONFIG pConfig )
{
	PIP_HASH_BUCKET pIP = NULL;
	UINT	index = 0;
	
	if( FindIP( ip ) )
	{
		//printk("Have above ip\r\n");
		return;
	}
		
	index = ip%_MAX_IP_HASH_BUCKET;
	pIP = ( PIP_HASH_BUCKET ) kmalloc( sizeof(IP_HASH_BUCKET), GFP_ATOMIC );
	if( !pIP )
		return;
		
	pIP->ip = ip;
	pIP->type = type;
	pIP->pNext = gVar.pIPHash[index];
	pIP->pConfig = pConfig;

	gVar.IPNumber++;
	gVar.pIPHash[index] = pIP;	
}

inline PDOUBLE_LIST_ITEM GetShortPacketPool()
{
	PDOUBLE_LIST_ITEM pItem = NULL;

	pItem = _RemoveHeadList( gVar.pShortPacketPool );
	if( pItem == NULL )
	{
		pItem = ALLOCATE_PACKETHEAD( false );
		
		if( pItem )
			((PSHORT_DOUBLE_LIST_PACKET)pItem)->bDynamic = true;
	}
	else
		((PSHORT_DOUBLE_LIST_PACKET)pItem)->bDynamic = false;
	
	if( pItem )
		( (PSHORT_DOUBLE_LIST_PACKET)pItem )->bLong = false;
	
	return pItem;
}

inline PDOUBLE_LIST_ITEM GetLongPacketPool()
{
	PDOUBLE_LIST_ITEM pItem = NULL;

	pItem = _RemoveHeadList( gVar.pLongPacketPool );
	if( pItem == NULL )
	{
		pItem = ALLOCATE_PACKETHEAD(  true );
		
		if( pItem )
			((PDOUBLE_LIST_PACKET)pItem)->bDynamic = true;
	}
	else
		((PDOUBLE_LIST_PACKET)pItem)->bDynamic = false;
	
	if( pItem )
		( (PDOUBLE_LIST_PACKET)pItem )->bLong = true;	
	
	return pItem;
}

inline void PutPacketPool(PDOUBLE_LIST_PACKET pItem)
{
	if( pItem->bLong )
	{
		if( pItem->bDynamic )
		{
			FREE_PACKETHEAD( pItem, true );
			return;
		}

		_InsertHeadList( gVar.pLongPacketPool, &(pItem->doubleListItem) );
	}
	else
	{
		if( pItem->bDynamic )
		{
			FREE_PACKETHEAD( pItem, false );
			return;
		}


		_InsertHeadList( gVar.pShortPacketPool, &(pItem->doubleListItem) );
	}
}

inline char INIT_HASHHEAD_INFO() 
{
	gVar.hashHeadInfo.iNumber = 0;
	init_MUTEX( &gVar.hashHeadInfo.fastMutex );
	
	gVar.hashHeadInfo.pHashLookside = NULL;
	gVar.hashHeadInfo.pHashLookside = kmem_cache_create( "HASH", sizeof(SMTP_HASH_HEAD), 0,
		SLAB_HWCACHE_ALIGN, NULL, NULL );
	if( !gVar.hashHeadInfo.pHashLookside )
	{
		printk( "Create HASH cache Failed\r\n" );
		return 0;
	}

	return 1;
}
	

inline PSMTP_HASH_HEAD	ALLOCATE_HASHHEAD(UINT PoolType,UINT NumberOfBytes)
{		
	PSMTP_HASH_HEAD pSmtpHashHead = NULL;
	
	pSmtpHashHead = (PSMTP_HASH_HEAD)kmem_cache_alloc( gVar.hashHeadInfo.pHashLookside,
		GFP_USER );

	if( pSmtpHashHead )
	{
		down_interruptible( &gVar.hashHeadInfo.fastMutex );
		gVar.hashHeadInfo.iNumber++;
		up( &gVar.hashHeadInfo.fastMutex );

		if( gVar.hashHeadInfo.iNumber > MEMORY_CONTROL_NUM )
			gVar.CtrlThreadCtx.bReady = 0;	
	}	
	
	return pSmtpHashHead;
}
 	
inline void FREE_HASHHEAD(PSMTP_HASH_HEAD Entry)				
{
	kmem_cache_free( gVar.hashHeadInfo.pHashLookside, Entry );
	
	down_interruptible( &gVar.hashHeadInfo.fastMutex );
	gVar.hashHeadInfo.iNumber--;
	up( &gVar.hashHeadInfo.fastMutex );
}

inline char INIT_PACKETHEAD_INFO()
{

	gVar.shortPacketHeadInfo.iNumber = 0;		
	init_MUTEX( &gVar.shortPacketHeadInfo.fastMutex );
	
	gVar.shortPacketHeadInfo.pPacketLookside = NULL;
	gVar.shortPacketHeadInfo.pPacketLookside = kmem_cache_create( "SHORT_PACKET", 
		sizeof(SHORT_DOUBLE_LIST_PACKET), 0, SLAB_HWCACHE_ALIGN, NULL, NULL );
	if( !gVar.shortPacketHeadInfo.pPacketLookside )
	{
		printk( "Create short packet cache failed\r\n" );
		return 0;
	}
		
	gVar.longPacketHeadInfo.iNumber=0;				
 	init_MUTEX( &gVar.longPacketHeadInfo.fastMutex );

	gVar.longPacketHeadInfo.pPacketLookside = NULL;
	gVar.longPacketHeadInfo.pPacketLookside = kmem_cache_create( "LONG_PACKET",
		sizeof(DOUBLE_LIST_PACKET), 0, SLAB_HWCACHE_ALIGN, NULL, NULL );
	if( !gVar.longPacketHeadInfo.pPacketLookside )
	{
		printk( "Create long packet cache failed\r\n" );

		if( gVar.shortPacketHeadInfo.pPacketLookside )
			kmem_cache_destroy( gVar.shortPacketHeadInfo.pPacketLookside );
		
		return 0;
	}

	return 1;
}

inline PDOUBLE_LIST_ITEM ALLOCATE_PACKETHEAD( char bLong )		
{							
 	PDOUBLE_LIST_ITEM pPacket = NULL;
 	if( bLong )					
 	{						
		pPacket = (PDOUBLE_LIST_ITEM)kmem_cache_alloc( gVar.longPacketHeadInfo.pPacketLookside,
 			GFP_USER );
 		if( pPacket )
 		{
			down_interruptible( &gVar.longPacketHeadInfo.fastMutex );
 			gVar.longPacketHeadInfo.iNumber++;
			up( &gVar.longPacketHeadInfo.fastMutex );
 		}		
	}						
 	else						
 	{		
		pPacket = (PDOUBLE_LIST_ITEM)kmem_cache_alloc( gVar.shortPacketHeadInfo.pPacketLookside,
 			GFP_USER );
 		if( pPacket )
 		{
			down_interruptible( &gVar.shortPacketHeadInfo.fastMutex );
 			gVar.shortPacketHeadInfo.iNumber++;
			up( &gVar.shortPacketHeadInfo.fastMutex );
 		}
	}
	
 	return 	pPacket;					
 }

inline void FREE_PACKETHEAD( PDOUBLE_LIST_PACKET Entry, char bLong ) 					
{
	if( bLong )					
	{						
		
		kmem_cache_free( gVar.longPacketHeadInfo.pPacketLookside, Entry );
		down_interruptible( &gVar.longPacketHeadInfo.fastMutex );
		gVar.longPacketHeadInfo.iNumber--;
		up( &gVar.longPacketHeadInfo.fastMutex );
	}						
	else						
	{	
		kmem_cache_free( gVar.shortPacketHeadInfo.pPacketLookside, Entry );
		down_interruptible( &gVar.shortPacketHeadInfo.fastMutex );
		gVar.shortPacketHeadInfo.iNumber--;
		up( &gVar.shortPacketHeadInfo.fastMutex );
	}			
}