perambulate.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 "DomainIPHash.h"
#include "list.h"
#include "Rule.h"
#include "RuleIp.h"
#include "protocol.h"
#include "smtpparser.h"
#include "createDir.h"
#include "function.h"
#include "Perambulate.h"

#define TIME_OUT		60

extern GVAR	gVar;

int Perambulate( void *arg )
{
	USHORT i = 0;
	PTHREAD_CONTROL	pControl = (PTHREAD_CONTROL)arg;
	
	schedule_timeout( 15000  );

	daemonize( "Perambulate" );
	allow_signal( SIGTERM );	
	while( !signal_pending( current ) )
	{
		if( !gVar.CtrlThreadCtx.bReady  )
			i++;
		
		PerambulateSmtpHash();
		PerambulateHttpHash();
		PerambulateMsnHash();
		PerambulateFtpHash();
		PerambulateTelnetHash();
		PerambulateIcqHash();
		PerambulateYahooHash();
		PerambulatePostHash();
		
		if( !gVar.CtrlThreadCtx.bReady  && i==2)
		{
			i = 0;
		}

		//等待1分钟
		set_current_state( TASK_INTERRUPTIBLE );
		schedule_timeout( 1000 );
	}

	complete_and_exit( &(pControl->thread_exited), 1 );

	return 0;
}

void PerambulateSmtpHash( void )
{
	UINT			i, j, iReceive, iFileHash;
	PSMTP_HASH_HEAD	pSmtpHashHead;
	PSMTP_HASH_HEAD	pTempHashHead;
	PSMTP_HASH_HEAD	pReceiveHead[ _MAX_SEQ_NUMBER ];
	PSMTP_HASH_HEAD	pFileHashHead[ _MAX_SEQ_NUMBER ];
	struct timeval	current_time;
	
	for( i=0; i<_MAX_SEQ_NUMBER; i++)
	{
		pReceiveHead[ i ] = NULL;
		pFileHashHead[ i ] = NULL;
	}
	
	do_gettimeofday( &current_time );
	for( i=0; i<_MAX_SMTP_HASH_BUCKET; i++)
	{
		iReceive = 0;
		iFileHash = 0;
	
		down_interruptible( &gVar.pSmtpHash[ i ]->fastMutex  );
		pSmtpHashHead = (PSMTP_HASH_HEAD)gVar.pSmtpHash[ i ]->pHead;
		while( pSmtpHashHead )
		{
			pTempHashHead = (PSMTP_HASH_HEAD)pSmtpHashHead->item.pNext;
			if( pSmtpHashHead->iNumber > _MAX_TOLERATE_PACKET_NUMBER 
				|| ( current_time.tv_sec - pSmtpHashHead->timelast.tv_sec ) > TIME_OUT
				|| !gVar.CtrlThreadCtx.bReady )
			{
				if( pSmtpHashHead->type == ONE_OF_MAIL )
				{
					pFileHashHead[ iFileHash++ ] = pSmtpHashHead;
					_RemoveItemNonLock( gVar.pSmtpHash[ i ], &pSmtpHashHead->item );
				}
				else
				{
					if( pSmtpHashHead->bPrew )
					{
						pSmtpHashHead->bDelete = true;
						pFileHashHead[ iFileHash++ ] = pSmtpHashHead;
						_RemoveItemNonLock( gVar.pSmtpHash[i], &pSmtpHashHead->item );
					}
					else
					{
						pReceiveHead[ iReceive++ ] = pSmtpHashHead;
						_RemoveItemNonLock( gVar.pSmtpHash[ i ], &pSmtpHashHead->item );
					}
				}
			}

			if( iReceive >= _MAX_SEQ_NUMBER ||iFileHash >= _MAX_SEQ_NUMBER )
				break;

			pSmtpHashHead = pTempHashHead;
		}
		
		up( &gVar.pSmtpHash[i]->fastMutex  );
		
		if( iReceive > 0 || iFileHash > 0 )
		{
			for( j = 0; j < iReceive; j ++ )
			{
				_InsertTailListFromSmtpHashHeadByLong( pReceiveHead[ j ] );
				FREE_HASHHEAD(pReceiveHead[j] );
			}
			
			for( j = 0; j < iFileHash; j ++ )
			{
				_InsertHeadList( gVar.pFileQueque, &(pFileHashHead[j]->item) );
			}
		}
	}
}

void PerambulateHttpHash( void )
{
	UINT				i;
	PSMTP_HASH_HEAD		pHttpHashHead;
	PSMTP_HASH_HEAD		pTempHashHead;
	PSMTP_HASH_HEAD		pFreeHashHead, pTemp;
	DOUBLE_LIST_HEAD	ReceiveHead;
	struct timeval		current_time;
	
	do_gettimeofday( &current_time );
	for( i=0; i<_MAX_HTTP_HASH_BUCKET; i++)
	{		
		_InitializeList( &ReceiveHead );
		down_interruptible( &gVar.pHttpHash[ i ]->fastMutex  );
		pHttpHashHead = (PSMTP_HASH_HEAD)gVar.pHttpHash[ i ]->pHead;
		while( pHttpHashHead )
		{
			pTempHashHead = (PSMTP_HASH_HEAD)pHttpHashHead->item.pNext;
			if( pHttpHashHead->iNumber>_MAX_TOLERATE_PACKET_NUMBER
				|| ( current_time.tv_sec - pHttpHashHead->timelast.tv_sec ) > TIME_OUT
				|| !gVar.CtrlThreadCtx.bReady )
			{
				pFreeHashHead = pHttpHashHead;
				_RemoveItemNonLock( gVar.pHttpHash[i], &pHttpHashHead->item);
				_InsertTailListNonLock( &ReceiveHead, &(pFreeHashHead->item) );
				
			}

			pHttpHashHead = pTempHashHead;
		}
		
		up( &gVar.pHttpHash[i]->fastMutex  );
		
		if( ReceiveHead.pHead )
		{
			pTemp = (PSMTP_HASH_HEAD)_RemoveTailListNonLock(&ReceiveHead);
			while( pTemp )
			{
//				ChangeFileAttr( pTemp, false );
				_InsertTailListFromSmtpHashHeadByLong( pTemp );
				FREE_HASHHEAD(pTemp );
				pTemp = (PSMTP_HASH_HEAD)_RemoveTailListNonLock(&ReceiveHead);
			}
		}	
	}	
}

void PerambulateMsnHash( void )
{
	UINT				i;
	PSMTP_HASH_HEAD		pMsnHashHead;
	PSMTP_HASH_HEAD		pTempHashHead;
	PSMTP_HASH_HEAD		pFreeHashHead, pTemp;
	DOUBLE_LIST_HEAD	ReceiveHead;
	struct timeval		current_time;
	
	do_gettimeofday( &current_time );
	for( i=0; i<_MAX_MSN_HASH_BUCKET; i++)
	{
		_InitializeList( &ReceiveHead );
		down_interruptible( &gVar.pMsnHash[i]->fastMutex  );
		pMsnHashHead = (PSMTP_HASH_HEAD)gVar.pMsnHash[i]->pHead;
		while( pMsnHashHead )
		{
			pTempHashHead = (PSMTP_HASH_HEAD)pMsnHashHead->item.pNext;
			if( pMsnHashHead->iNumber > _MAX_TOLERATE_PACKET_NUMBER
				|| ( current_time.tv_sec - pMsnHashHead->timelast.tv_sec ) > TIME_OUT
				|| !gVar.CtrlThreadCtx.bReady)
			{
				pFreeHashHead = pMsnHashHead;
				_RemoveItemNonLock( gVar.pMsnHash[i], &pMsnHashHead->item);
				_InsertTailListNonLock( &ReceiveHead, &(pFreeHashHead->item) );
				
			}

			pMsnHashHead = pTempHashHead;
		}
		
		up( &gVar.pMsnHash[i]->fastMutex  );
		
		if( ReceiveHead.pHead )
		{
			pTemp = (PSMTP_HASH_HEAD)_RemoveTailListNonLock(&ReceiveHead);
			while( pTemp )
			{
				_InsertTailListFromSmtpHashHeadByLong( pTemp );
				FREE_HASHHEAD(pTemp );
				pTemp = (PSMTP_HASH_HEAD)_RemoveTailListNonLock(&ReceiveHead);
			}
		}	
	}
}

void PerambulatePostHash( void )
{
	UINT				i;
	PSMTP_HASH_HEAD		pPostHashHead;
	PSMTP_HASH_HEAD		pTempHashHead;
	PSMTP_HASH_HEAD		pFreeHashHead, pTemp;
	DOUBLE_LIST_HEAD	ReceiveHead;
	struct timeval		current_time;
	
	do_gettimeofday( &current_time );
	for( i=0; i<_MAX_HTTP_POST_BUCKET; i++)
	{
		_InitializeList( &ReceiveHead );
		down_interruptible( &gVar.pPostHash[i]->fastMutex  );
		pPostHashHead = (PSMTP_HASH_HEAD)gVar.pPostHash[i]->pHead;
		while( pPostHashHead )
		{
			pTempHashHead = (PSMTP_HASH_HEAD)pPostHashHead->item.pNext;
			if( ( current_time.tv_sec - pPostHashHead->timelast.tv_sec ) > TIME_OUT 
				|| !gVar.CtrlThreadCtx.bReady )
			{
				pFreeHashHead = pPostHashHead;
				_RemoveItemNonLock( gVar.pPostHash[i], &pPostHashHead->item);
				_InsertTailListNonLock( &ReceiveHead, &(pFreeHashHead->item) );	
			}

			pPostHashHead = pTempHashHead;
		}
		
		up( &gVar.pPostHash[i]->fastMutex  );
		
		if( ReceiveHead.pHead )
		{
			pTemp = (PSMTP_HASH_HEAD)_RemoveTailListNonLock(&ReceiveHead);
			while( pTemp )
			{
				_InsertTailListFromSmtpHashHeadByLong( pTemp );
				FREE_HASHHEAD(pTemp );
				pTemp = (PSMTP_HASH_HEAD)_RemoveTailListNonLock(&ReceiveHead);
			}
		}
	}
}

void PerambulateFtpHash( void )
{
	UINT				i;
	PSMTP_HASH_HEAD		pMsnHashHead;
	PSMTP_HASH_HEAD		pTempHashHead;
	PSMTP_HASH_HEAD		pFreeHashHead, pTemp;
	DOUBLE_LIST_HEAD	ReceiveHead;
	struct timeval		current_time;
		
	do_gettimeofday( &current_time );
	for( i = 0; i < _MAX_FTP_HASH_BUCKET; i ++ )
	{
		_InitializeList( &ReceiveHead );
		down_interruptible( &gVar.pFtpHash[i]->fastMutex  );
		pMsnHashHead = (PSMTP_HASH_HEAD)gVar.pFtpHash[i]->pHead;
		while( pMsnHashHead )
		{
			pTempHashHead = (PSMTP_HASH_HEAD)pMsnHashHead->item.pNext;
			if( pMsnHashHead->iNumber>_MAX_TOLERATE_PACKET_NUMBER 
				|| ( current_time.tv_sec - pMsnHashHead->timelast.tv_sec ) > TIME_OUT
				|| !gVar.CtrlThreadCtx.bReady )
			{
				pFreeHashHead = pMsnHashHead;
				_RemoveItemNonLock( gVar.pFtpHash[i], &pMsnHashHead->item);
				_InsertTailListNonLock( &ReceiveHead, &(pFreeHashHead->item) );
				
			}

			pMsnHashHead = pTempHashHead;
		}
		
		up( &gVar.pFtpHash[ i ]->fastMutex  );
		
		if( ReceiveHead.pHead )
		{
			pTemp = (PSMTP_HASH_HEAD)_RemoveTailListNonLock(&ReceiveHead);
			while( pTemp )
			{
				pTemp->type = MSN_HASH_TYPE_END;
				_InsertHeadList( gVar.pFtpFileQueque, &pTemp->item);
				pTemp = (PSMTP_HASH_HEAD)_RemoveTailListNonLock(&ReceiveHead);
			}
		}
	}
}

void PerambulateTelnetHash( void )
{
	UINT				i;
	PSMTP_HASH_HEAD		pMsnHashHead;
	PSMTP_HASH_HEAD		pTempHashHead;
	PSMTP_HASH_HEAD		pFreeHashHead, pTemp;
	DOUBLE_LIST_HEAD	ReceiveHead;
	struct timeval		current_time;
	
	do_gettimeofday( &current_time );
	for( i=0; i<_MAX_TELNET_HASH_BUCKET; i++)
	{
		_InitializeList( &ReceiveHead );
		down_interruptible( &gVar.pTelnetHash[i]->fastMutex  );
		pMsnHashHead = (PSMTP_HASH_HEAD)gVar.pTelnetHash[i]->pHead;
		while( pMsnHashHead )
		{
			pTempHashHead = (PSMTP_HASH_HEAD)pMsnHashHead->item.pNext;
			if( pMsnHashHead->iNumber>_MAX_TOLERATE_PACKET_NUMBER
				|| ( current_time.tv_sec - pMsnHashHead->timelast.tv_sec ) > TIME_OUT
				|| !gVar.CtrlThreadCtx.bReady )
			{
				pFreeHashHead = pMsnHashHead;
				_RemoveItemNonLock( gVar.pTelnetHash[i], &pMsnHashHead->item);
				_InsertTailListNonLock( &ReceiveHead, &(pFreeHashHead->item) );
				
			}

			pMsnHashHead = pTempHashHead;
		}
		
		up( &gVar.pTelnetHash[i]->fastMutex  );
		
		if( ReceiveHead.pHead )
		{
			pTemp = (PSMTP_HASH_HEAD)_RemoveTailListNonLock(&ReceiveHead);
			while( pTemp )
			{
				pTemp->type = MSN_HASH_TYPE_END;
				_InsertHeadList( gVar.pTelnetFileQueque, &pTemp->item);
				pTemp = (PSMTP_HASH_HEAD)_RemoveTailListNonLock(&ReceiveHead);
			}
		}	
	}
}




void PerambulateIcqHash( void )
{
	UINT				i;
	PSMTP_HASH_HEAD		pMsnHashHead;
	PSMTP_HASH_HEAD		pTempHashHead;
	PSMTP_HASH_HEAD		pFreeHashHead, pTemp;
	DOUBLE_LIST_HEAD	ReceiveHead;
	struct timeval		current_time;
	
	do_gettimeofday( &current_time );
	for( i=0; i<_MAX_ICQ_HASH_BUCKET; i++)
	{
		_InitializeList( &ReceiveHead );
		down_interruptible( &gVar.pIcqHash[i]->fastMutex  );
		pMsnHashHead = (PSMTP_HASH_HEAD)gVar.pIcqHash[i]->pHead;
		while( pMsnHashHead )
		{
			pTempHashHead = (PSMTP_HASH_HEAD)pMsnHashHead->item.pNext;
			if( pMsnHashHead->iNumber>_MAX_TOLERATE_PACKET_NUMBER 
				|| ( current_time.tv_sec - pMsnHashHead->timelast.tv_sec ) > TIME_OUT 
				|| !gVar.CtrlThreadCtx.bReady )
			{
				pFreeHashHead = pMsnHashHead;
				_RemoveItemNonLock( gVar.pIcqHash[i], &pMsnHashHead->item);
				_InsertTailListNonLock( &ReceiveHead, &(pFreeHashHead->item) );
				
			}

			pMsnHashHead = pTempHashHead;
		}
		
		up( &gVar.pIcqHash[i]->fastMutex  );
		
		if( ReceiveHead.pHead )
		{
			pTemp = (PSMTP_HASH_HEAD)_RemoveTailListNonLock(&ReceiveHead);
			while( pTemp )
			{
				pTemp->type = MSN_HASH_TYPE_END;
				_InsertHeadList( gVar.pIcqFileQueque, &pTemp->item);
				pTemp = (PSMTP_HASH_HEAD)_RemoveTailListNonLock(&ReceiveHead);
			}
		}
		
	}
	
}

void PerambulateYahooHash( void )
{
	UINT				i;
	PSMTP_HASH_HEAD		pMsnHashHead;
	PSMTP_HASH_HEAD		pTempHashHead;
	PSMTP_HASH_HEAD		pFreeHashHead, pTemp;
	DOUBLE_LIST_HEAD	ReceiveHead;
	struct timeval		current_time;

	do_gettimeofday( &current_time );
	for( i=0; i<_MAX_YAHOO_HASH_BUCKET; i++)
	{
		_InitializeList( &ReceiveHead );
		down_interruptible( &gVar.pYahooHash[i]->fastMutex  );
		pMsnHashHead = (PSMTP_HASH_HEAD)gVar.pYahooHash[i]->pHead;
		while( pMsnHashHead )
		{
			pTempHashHead = (PSMTP_HASH_HEAD)pMsnHashHead->item.pNext;
			if( pMsnHashHead->iNumber>_MAX_TOLERATE_PACKET_NUMBER 
				|| ( current_time.tv_sec - pMsnHashHead->timelast.tv_sec ) > TIME_OUT
				|| !gVar.CtrlThreadCtx.bReady )
			{
				pFreeHashHead = pMsnHashHead;
				_RemoveItemNonLock( gVar.pYahooHash[i], &pMsnHashHead->item);
				_InsertTailListNonLock( &ReceiveHead, &(pFreeHashHead->item) );
				
			}

			pMsnHashHead = pTempHashHead;
		}
		
		up( &gVar.pYahooHash[i]->fastMutex  );
		
		if( ReceiveHead.pHead )
		{
			pTemp = (PSMTP_HASH_HEAD)_RemoveTailListNonLock(&ReceiveHead);
			while( pTemp )
			{
				pTemp->type = MSN_HASH_TYPE_END;
				_InsertHeadList( gVar.pYahooFileQueque, &pTemp->item);
				pTemp = (PSMTP_HASH_HEAD)_RemoveTailListNonLock(&ReceiveHead);
			}
		}		
	}
}