urifilter.cpp

The C++ Client Edition contains a full set of C++ class libraries, with client side source code for

#include "StdAfx.h"
#include ".\urifilter.h"


CURIFilter::CURIFilter(void)
{
}

CURIFilter::~CURIFilter(void)
{
}

int CURIFilter::Init(SProgramVariables in_pf)
{
	m_pFilterObj = new CManageFilters(in_pf.m_szLstFilterPath);	
	
	if (m_pFilterObj->LoadPatternSearch() <= 0 &&
		m_pFilterObj->m_vecPatternSearch.size() <= 0)
	{
		return -1;
	}
	

	return 1;
}
unsigned char*	CURIFilter::GetPattern(int in_idx)
{
	return m_pFilterObj->m_vecPatternSearch[in_idx];
}

int CURIFilter::CheckPattern(unsigned char* in_szPattern, unsigned long in_ulPatternLen, int* out_matched)
{
	bool bResult = false;
	
	for (int i = 0; i < (int)m_pFilterObj->m_vecPatternSearch.size(); i++)
	{
		bmSearch(in_szPattern,
			m_pFilterObj->m_vecPatternSearch[i],
			in_ulPatternLen,
			(unsigned long)_mbslen(m_pFilterObj->m_vecPatternSearch[i]),
			bResult);
		if (bResult == true)
		{
			*out_matched = i;
			return 1;
		}
	}

	return 0;
}

unsigned long CURIFilter::bmSearch(unsigned char *TargetMem,
								   unsigned char *SourceMem,
								   unsigned long TargetMemLen,
								   unsigned long SourceMemLen,
								   bool& searchresult)
{
	unsigned char searchstr[256];     // Max pattern length is 256.
	unsigned char alfa[256];          // Remember where alphabet chars are located.
	unsigned char skipsInsens[256];   // Skips array.
	unsigned char patlenInsens;       // Length of search pattern.
	int LenIndex = 0;

	// Get length and make 'smalls'copy.
	unsigned char c = SourceMem[LenIndex];
	while ( c != '\0')
	{
		alfa[LenIndex] = 0;
		if (c >= 'A'&& c <= 'Z')
		{
			searchstr[LenIndex] = c + 0x20;
			alfa[LenIndex] = 1;
		}
		else
		{

			searchstr[LenIndex] = c;
			if (c >= 'a'&& c <= 'z')
				alfa[LenIndex] = 1;
		}
		c = SourceMem[++LenIndex];
	}

	int len = LenIndex + 1;

	// For chars not in pattern.
	for (int i = 0; i < 255; i++)
		skipsInsens[i] = len;  //length + 1.

	// For chars in pattern.
	//  with double chars only right most survives.
	for ( i = 0; i < LenIndex; i++)
	{
		skipsInsens[searchstr[i]] = LenIndex - i;
		if (alfa[i]) skipsInsens[searchstr[i]-0x20] = LenIndex - i;
	}


	patlenInsens = LenIndex;



	// Check if searchstr is longer than TargetMem or zero length.
	if (patlenInsens > TargetMemLen || patlenInsens == 0)
	{
		searchresult = false;
		return -1;
	}

	unsigned long Position = 0;
	unsigned char * end = TargetMem + TargetMemLen;
	int PatternLenIndex = patlenInsens -1;

	int j;

	for(;;)
	{
		// main loop for comparing strings.
		j = PatternLenIndex;
		while (
			((TargetMem[j] == searchstr[j]) ||
			((alfa[j]) && (TargetMem[j] == (char) (searchstr[j]-0x20))))
			&& --j >= 0);

		if (j != -1)
		{
			// Mismatch; align and check for end of TargetMem.
			unsigned char* skipindex = (unsigned char*) TargetMem + patlenInsens;
			if (skipindex >= end)
			{
				searchresult = false;
				return -1;  // string not in TargetMem.
			}

			TargetMem += skipsInsens[*skipindex];
			Position +=skipsInsens[*skipindex];	
		}
		else
		{
			// Match found.
			searchresult = true;
			return Position;
		}
	}

	return -1;
}