ruleop.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>

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

extern GVAR	gVar;

void AddRule( RULE *pRule)
{
	switch( pRule->protocolType )
	{
	case RULE_PROTOCOL_IP:
		AddRuleIP( pRule->iKey, pRule->ruleID, true, pRule->ruleType );
		kfree( pRule );
		break;
	case RULE_PROTOCOL_QQ:
		AddQQRule( pRule );
		printk( "wangyi:Add Rule:%d qq:%d\r\n", pRule->ruleID, pRule->iKey );
		break;
	case RULE_PROTOCOL_MSN:
		AddMsnRule( pRule);
		break;
	case RULE_PROTOCOL_MAIL:
		AddMailRule( pRule);
		printk("wangyi:Add Rule:%d email:%s\r\n", pRule->ruleID, pRule->key );
		break;
	case RULE_PROTOCOL_ICQ:
		AddIcqRule( pRule);
		break;
	case RULE_PROTOCOL_YAHOO:
		AddYahooRule( pRule);
		break;
	case RULE_PROTOCOL_PP:
		AddPpRule( pRule );
		printk( "wangyi:Add Rule:%d pp:%d\r\n", pRule->ruleID, pRule->iKey );
		break;
	case RULE_PROTOCOL_AOL:
		AddAolRule( pRule);
		break;
	case RULE_PROTOCOL_GTALK:
		AddGtalkRule( pRule);
		printk("wangyi:Add Rule:%d gtalk:%s\r\n", pRule->ruleID, pRule->key );
		break;
	case RULE_PROTOCOL_IRC:
		AddIrcRule( pRule);
		printk("wangyi:Add Rule:%d irc:%s\r\n", pRule->ruleID, pRule->key );
		break;	
	case RULE_PROTOCOL_POST:
		AddPostRule( pRule );
		break;
	default:
		printk("wangyi:!!!!!!!!!!!!! add rule default:ruleid:%d\r\n", pRule->ruleID );
		kfree( pRule );
		break;
	}
}


void DeleteRule( RULE *pRule )
{
	switch( pRule->protocolType )
	{
	case RULE_PROTOCOL_IP:
		DeleteRuleIP( pRule->iKey );
		break;
	case RULE_PROTOCOL_QQ:
		DeleteQQRule( pRule );
		break;
	case RULE_PROTOCOL_MSN:
		DeleteMsnRule( pRule);
		break;
	case RULE_PROTOCOL_MAIL:
		DeleteMailRule( pRule);
		break;
	case RULE_PROTOCOL_IRC:
		DeleteIrcRule( pRule );
		break;
	case RULE_PROTOCOL_PP:
		DeletePpRule( pRule );
		break;
	case RULE_PROTOCOL_AOL:
		DeleteAolRule( pRule);
		break;
	case RULE_PROTOCOL_GTALK:
		DeleteGtalkRule( pRule);
		break;	
	case RULE_PROTOCOL_POST:
		DeletePostRule( pRule );
		break;
	default:
		break;
	
	}
	kfree( pRule );
}


void AddQQRule( RULE *pRule )
{
	UINT		iHash;
	iHash = (pRule->iKey)%QQ_HASH_LEN;
	
	down_interruptible( &gVar.ruleHash.qq[iHash].fastMutex );
	pRule->pNext = gVar.ruleHash.qq[iHash].pRule;
	gVar.ruleHash.qq[iHash].pRule = pRule;
	up( &gVar.ruleHash.qq[iHash].fastMutex );	
}

void AddIcqRule( RULE *pRule )
{
	UINT		iHash;
	iHash = (pRule->iKey)%ICQ_HASH_LEN;
	
	down_interruptible( &gVar.ruleHash.icq[iHash].fastMutex );
	pRule->pNext = gVar.ruleHash.icq[iHash].pRule;
	gVar.ruleHash.icq[iHash].pRule = pRule;
	up( &gVar.ruleHash.icq[iHash].fastMutex );	

}

void AddMsnRule( RULE *pRule )
{
	UINT		iHash;
	
	if( pRule->keyLen== 0 )
	{
		kfree( pRule );
		return;
	}
	printk( "add msn:%s len:%d\r\n", pRule->key, pRule->keyLen);
	iHash = StrLowerCaseHash( pRule->key, pRule->keyLen);
	iHash = iHash%MSN_HASH_LEN;
	
	down_interruptible( &gVar.ruleHash.msn[iHash].fastMutex );
	pRule->pNext = gVar.ruleHash.msn[iHash].pRule;
	gVar.ruleHash.msn[iHash].pRule = pRule;
	up( &gVar.ruleHash.msn[iHash].fastMutex );
}


void AddPostRule( RULE *pRule )
{
//	UINT		iHash;
	UCHAR 		*pDot = NULL;
	char		*p = NULL;
	char 		*pEnd = NULL;
	char 		host[WEB_MAIL_HOST_LEN];
	
	if( pRule->keyLen== 0 )
	{
		kfree( pRule );
		return;
	}
	
	printk( "add post domain:%s len:%d,ruleid:%d\r\n", pRule->key, pRule->keyLen, pRule->ruleID);
	memset( host, 0, WEB_MAIL_HOST_LEN );
	sprintf( host+1, "%s", pRule->key );
	pDot = host;
	pEnd = host + 1 + strlen( host+1 );
	p = strstr( host+1, WEB_MAIL_HOST_SEQ );
	while( p )
	{
		*pDot = (UCHAR)( ( (UCHAR *)p - pDot ) - 1 );
		pDot = p;
		p = strstr( p + 1, WEB_MAIL_HOST_SEQ );
	}
	*pDot = (UCHAR)( ( (UCHAR *)pEnd - pDot ) -1 );	
	AddDomain(host, IP_TYPE_POST, NULL, pRule->ruleID );
	kfree( pRule );

}


void AddYahooRule( RULE *pRule )
{
	UINT		iHash;
	
	if( pRule->keyLen== 0 )
	{
		kfree( pRule );
		return;
	}
	printk( "add yahoo:%s len:%d\r\n", pRule->key, pRule->keyLen);
	iHash = StrLowerCaseHash( pRule->key, pRule->keyLen);
	iHash = iHash%YAHOO_HASH_LEN;
	
	down_interruptible( &gVar.ruleHash.yahoo[iHash].fastMutex );
	pRule->pNext = gVar.ruleHash.yahoo[iHash].pRule;
	gVar.ruleHash.yahoo[iHash].pRule = pRule;
	up( &gVar.ruleHash.yahoo[iHash].fastMutex );
}


void AddMailRule( RULE *pRule )
{
	UINT		iHash;
	
	if( pRule->keyLen == 0 )
	{
		kfree( pRule );
		return;
	}
	printk( "add mail:%s len:%d\r\n", pRule->key, pRule->keyLen);
	iHash = StrLowerCaseHash( pRule->key, pRule->keyLen);
	iHash = iHash%MAIL_HASH_LEN;
	
	down_interruptible( &gVar.ruleHash.mail[iHash].fastMutex );
	pRule->pNext = gVar.ruleHash.mail[iHash].pRule;
	gVar.ruleHash.mail[iHash].pRule = pRule;
	up( &gVar.ruleHash.mail[iHash].fastMutex );

}


void AddPpRule( RULE *pRule )
{
	UINT		iHash;
	iHash = (pRule->iKey)%PP_HASH_LEN;
	
	down_interruptible( &gVar.ruleHash.pp[iHash].fastMutex );
	pRule->pNext = gVar.ruleHash.pp[iHash].pRule;
	gVar.ruleHash.pp[iHash].pRule = pRule;
	up( &gVar.ruleHash.pp[iHash].fastMutex );
}


void AddGtalkRule( RULE *pRule )
{
	UINT		iHash;
	
	if( pRule->keyLen== 0 )
	{
		kfree( pRule );
		return;
	}
	printk( "add gtakl:%s len:%d\r\n", pRule->key, pRule->keyLen);
	iHash = StrLowerCaseHash( pRule->key, pRule->keyLen);
	iHash = iHash%GTALK_HASH_LEN;
	
	down_interruptible( &gVar.ruleHash.gtalk[iHash].fastMutex );
	pRule->pNext = gVar.ruleHash.gtalk[iHash].pRule;
	gVar.ruleHash.gtalk[iHash].pRule = pRule;
	up( &gVar.ruleHash.gtalk[iHash].fastMutex );
}


void AddAolRule( RULE *pRule )
{
	UINT		iHash;
	
	if( pRule->keyLen== 0 )
	{
		kfree( pRule );
		return;
	}
	printk( "add gtakl:%s len:%d\r\n", pRule->key, pRule->keyLen);
	iHash = StrLowerCaseHash( pRule->key, pRule->keyLen);
	iHash = iHash%AOL_HASH_LEN;
	
	down_interruptible( &gVar.ruleHash.aol[iHash].fastMutex );
	pRule->pNext = gVar.ruleHash.aol[iHash].pRule;
	gVar.ruleHash.aol[iHash].pRule = pRule;
	up( &gVar.ruleHash.aol[iHash].fastMutex );
}


void AddIrcRule( RULE *pRule )
{
	UINT		iHash;
	
	if( pRule->keyLen== 0 )
	{
		kfree( pRule );
		return;
	}
	printk( "add gtakl:%s len:%d\r\n", pRule->key, pRule->keyLen);
	iHash = StrLowerCaseHash( pRule->key, pRule->keyLen);
	iHash = iHash%IRC_HASH_LEN;
	
	down_interruptible( &gVar.ruleHash.irc[iHash].fastMutex );
	pRule->pNext = gVar.ruleHash.irc[iHash].pRule;
	gVar.ruleHash.irc[iHash].pRule = pRule;
	up( &gVar.ruleHash.irc[iHash].fastMutex );
}




void DeleteQQRule( RULE *pRule )
{
	RULE		*pPre,*pTemp = NULL;
	UINT		iHash;
	UINT		sip = 0;
	
	iHash = (pRule->iKey)%QQ_HASH_LEN;
	
	down_interruptible( &gVar.ruleHash.qq[iHash].fastMutex );
	pPre =  gVar.ruleHash.qq[iHash].pRule;
	while( pPre )
	{
		if( pPre->ruleID == pRule->ruleID )
			break;
			
		pTemp = pPre;
		pPre = pPre->pNext;
	}
	
	if( pPre )
	{
		if( pTemp )
			pTemp->pNext = pPre->pNext;
		else
			gVar.ruleHash.qq[iHash].pRule = pPre->pNext;
		
		sip = pPre->sip;
		kfree( pPre );
	}
	
	up( &gVar.ruleHash.qq[iHash].fastMutex );
	
	if( 0 != sip )
		DeleteRuleIP( sip );
}



void DeleteIcqRule( RULE *pRule )
{
	RULE		*pPre,*pTemp = NULL;
	UINT		iHash;
	UINT		sip = 0;
	
	iHash = (pRule->iKey)%ICQ_HASH_LEN;
	
	down_interruptible( &gVar.ruleHash.icq[iHash].fastMutex );
	pPre =  gVar.ruleHash.icq[iHash].pRule;
	while( pPre )
	{
		if( pPre->ruleID == pRule->ruleID )
			break;
			
		pTemp = pPre;
		pPre = pPre->pNext;
	
	}
	
	if( pPre )
	{
		if( pTemp )
			pTemp->pNext = pPre->pNext;
		else
			gVar.ruleHash.icq[iHash].pRule = pPre->pNext;
		
		sip = pPre->sip;
		kfree( pPre );
	}
	up( &gVar.ruleHash.icq[iHash].fastMutex );
	
	if( 0 != sip )
		DeleteRuleIP( sip );
}



void DeleteMsnRule( RULE *pRule )
{
	RULE		*pPre,*pTemp = NULL;
	UINT		iHash;
	UINT		sip = 0;
	
	if( pRule->keyLen== 0 )
		return;

	printk("delete msn:%s\r\n", pRule->key );
	iHash = StrLowerCaseHash( pRule->key, pRule->keyLen);
	iHash = iHash%MSN_HASH_LEN;
	
	down_interruptible( &gVar.ruleHash.msn[iHash].fastMutex );
	pPre =  gVar.ruleHash.msn[iHash].pRule;
	while( pPre )
	{
		if( pPre->ruleID == pRule->ruleID )
			break;
			
		pTemp = pPre;
		pPre = pPre->pNext;
	}
	
	if( pPre )
	{
		if( pTemp )
			pTemp->pNext = pPre->pNext;
		else
			gVar.ruleHash.msn[iHash].pRule = pPre->pNext;
		
		sip = pPre->sip;
		kfree( pPre );
	}
	up( &gVar.ruleHash.msn[iHash].fastMutex );
	
	if( 0 != sip )
		DeleteRuleIP( sip );
}

void DeletePostRule( RULE *pRule )
{
//	RULE		*pPre,*pTemp = NULL;
//	UINT		iHash;
//	UINT		sip = 0;
	UCHAR 		*pDot = NULL;
	char		*p = NULL;
	char 		*pEnd = NULL;
	char 		host[WEB_MAIL_HOST_LEN];	
	
	if( pRule->keyLen== 0 )
	{
		return;
	}
	
	memset( host, 0, WEB_MAIL_HOST_LEN );
	sprintf( host+1, "%s", pRule->key );
	pDot = host;
	pEnd = host+1+strlen( host+1 );