windows-nt/Source/XPSP1/NT/net/mmc/ipsecmon/harray.cpp

/**********************************************************************/
/**                       Microsoft Windows/NT                       **/
/**                Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/

/*
	hArray.cpp	
		Index manager for IPSecMon

	FILE HISTORY:
    Nov 29  1999    Ning Sun     Created

*/

#include "stdafx.h"
#include "spddb.h"
#include "harray.h"
#include "mbstring.h"
#include "spdutil.h"

extern const DWORD INDEX_TYPE_DEFAULT = 0;

int __cdecl CompareFilterName(const void *elem1, const void *elem2);
int __cdecl CompareFilterSourceAddr(const void *elem1, const void *elem2);
int __cdecl CompareFilterDestAddr(const void *elem1, const void *elem2);
int __cdecl CompareFilterSrcPort(const void *elem1, const void *elem2);
int __cdecl CompareFilterDestPort(const void *elem1, const void *elem2);
int __cdecl CompareFilterProtocol(const void *elem1, const void *elem2);
int __cdecl CompareFilterDirection(const void *elem1, const void *elem2);
int __cdecl CompareFilterWeight(const void *elem1, const void *elem2);
int __cdecl CompareFilterPolicyName(const void *elem1, const void *elem2);
int __cdecl CompareFilterIfType(const void *elem1, const void *elem2);
int __cdecl CompareFilterInboundFlag(const void *elem1, const void *elem2);
int __cdecl CompareFilterOutboundFlag(const void *elem1, const void *elem2);
int __cdecl CompareFilterFlag(const void *elem1, const void *elem2);

int __cdecl CompareMmFilterName(const void *elem1, const void *elem2);
int __cdecl CompareMmFilterSourceAddr(const void *elem1, const void *elem2);
int __cdecl CompareMmFilterDestAddr(const void *elem1, const void *elem2);
int __cdecl CompareMmFilterDirection(const void *elem1, const void *elem2);
int __cdecl CompareMmFilterWeight(const void *elem1, const void *elem2);
int __cdecl CompareMmFilterPolicyName(const void *elem1, const void *elem2);
int __cdecl CompareMmFilterAuth(const void *elem1, const void *elem2);
int __cdecl CompareMmFilterIfType(const void *elem1, const void *elem2);
int __cdecl CompareMmPolicyName(const void *elem1, const void *elem2);
int __cdecl CompareMmPolicyOfferNumber(const void *elem1, const void *elem2);
int __cdecl CompareQmPolicyName(const void *elem1, const void *elem2);
int __cdecl CompareQmPolicyOfferNumber(const void *elem1, const void *elem2);

int __cdecl CompareMmSAMeAddr(const void *elem1, const void *elem2);
int __cdecl CompareMmSAPeerAddr(const void *elem1, const void *elem2);
int __cdecl CompareMmSAAuth(const void *elem1, const void *elem2);
int __cdecl CompareMmSAEncryption(const void *elem1, const void *elem2);
int __cdecl CompareMmSAIntegrity(const void *elem1, const void *elem2);
int __cdecl CompareMmSADhGroup(const void *elem1, const void *elem2);

int __cdecl CompareQmSAPolicyName(const void *elem1, const void *elem2);
int __cdecl CompareQmSAAuth(const void *elem1, const void *elem2);
int __cdecl CompareQmSAConf(const void *elem1, const void *elem2);
int __cdecl CompareQmSAIntegrity(const void *elem1, const void *elem2);
int __cdecl CompareQmSASrc(const void *elem1, const void *elem2);
int __cdecl CompareQmSADest(const void *elem1, const void *elem2);
int __cdecl CompareQmSAProtocol(const void *elem1, const void *elem2);
int __cdecl CompareQmSASrcPort(const void *elem1, const void *elem2);
int __cdecl CompareQmSADestPort(const void *elem1, const void *elem2);
int __cdecl CompareQmSAMyTnlEp(const void *elem1, const void *elem2);
int __cdecl CompareQmSAPeerTnlEp(const void *elem1, const void *elem2);
int __cdecl CompareFilterSrcTnl(const void *elem1, const void *elem2);
int __cdecl CompareFilterDestTnl(const void *elem1, const void *elem2);

typedef int (__cdecl *PFNCompareProc)(const void *, const void *);

//This structure saves the pair of sort type and sort function
struct SortTypeAndCompareProcPair
{
	DWORD			dwType;
	PFNCompareProc	pCompareProc;
};

SortTypeAndCompareProcPair TypeProcMmFilter[] = 
{
	{IDS_COL_FLTR_NAME, CompareMmFilterName},
	{IDS_COL_FLTR_SRC, CompareMmFilterSourceAddr},
	{IDS_COL_FLTR_DEST, CompareMmFilterDestAddr},
	{IDS_COL_FLTR_DIR, CompareMmFilterDirection},
	{IDS_COL_MM_FLTR_POL, CompareMmFilterPolicyName},
	{IDS_COL_MM_FLTR_AUTH, CompareMmFilterAuth},
	{IDS_COL_IF_TYPE, CompareMmFilterIfType},
	{IDS_COL_FLTR_WEIGHT, CompareMmFilterWeight},
	{INDEX_TYPE_DEFAULT, NULL}		//NULL means do nothing during sort
};

SortTypeAndCompareProcPair TypeProcMmPolicy[] = 
{
	{IDS_COL_MM_POL_NAME, CompareMmPolicyName},
	{IDS_COL_MM_POL_OFFER, CompareMmPolicyOfferNumber},
	{INDEX_TYPE_DEFAULT, NULL}		//NULL means do nothing during sort
};

//SortTypeAndCompareProcPair
SortTypeAndCompareProcPair TypeProcMmSA[] =
{
	{IDS_COL_MM_SA_ME, CompareMmSAMeAddr},
	{IDS_COL_MM_SA_PEER, CompareMmSAPeerAddr},	
	{IDS_COL_MM_SA_AUTH, CompareMmSAAuth},	
	{IDS_COL_MM_SA_ENCRYPITON, CompareMmSAEncryption},
	{IDS_COL_MM_SA_INTEGRITY, CompareMmSAIntegrity},
	{IDS_COL_MM_SA_DH, CompareMmSADhGroup},
	{INDEX_TYPE_DEFAULT, NULL}		//NULL means do nothing during sort
};

SortTypeAndCompareProcPair TypeProcQmFilter[] = 
{
	{IDS_COL_FLTR_NAME, CompareFilterName},
	{IDS_COL_FLTR_SRC, CompareFilterSourceAddr},
	{IDS_COL_FLTR_SRC_PORT, CompareFilterSrcPort},
	{IDS_COL_FLTR_DEST, CompareFilterDestAddr},
	{IDS_COL_FLTR_DEST_PORT, CompareFilterDestPort},
	{IDS_COL_FLTR_SRC_TNL, CompareFilterSrcTnl},
	{IDS_COL_FLTR_DEST_TNL, CompareFilterDestTnl},
	{IDS_COL_FLTR_PROT, CompareFilterProtocol},
	{IDS_COL_FLTR_DIR, CompareFilterDirection},
	{IDS_COL_QM_POLICY, CompareFilterPolicyName},
	{IDS_COL_IF_TYPE, CompareFilterIfType},
	{IDS_COL_FLTR_WEIGHT, CompareFilterWeight},
	{IDS_COL_FLTR_OUT_FLAG, CompareFilterOutboundFlag},
	{IDS_COL_FLTR_IN_FLAG, CompareFilterInboundFlag},
	{IDS_COL_FLTR_FLAG, CompareFilterFlag},
	{INDEX_TYPE_DEFAULT, NULL}		//NULL means do nothing during sort
};

SortTypeAndCompareProcPair TypeProcQmPolicy[] =
{
	{IDS_COL_QM_POL_NAME, CompareQmPolicyName},
	{IDS_COL_QM_POL_OFFER, CompareQmPolicyOfferNumber},
	{INDEX_TYPE_DEFAULT, NULL}		//NULL means do nothing during sort
};

SortTypeAndCompareProcPair TypeProcQmSA[] =
{
	{IDS_COL_QM_SA_POL, CompareQmSAPolicyName},
	{IDS_COL_QM_SA_AUTH, CompareQmSAAuth},
	{IDS_COL_QM_SA_CONF, CompareQmSAConf},
	{IDS_COL_QM_SA_INTEGRITY, CompareQmSAIntegrity},
	{IDS_COL_QM_SA_SRC, CompareQmSASrc},
	{IDS_COL_QM_SA_DEST, CompareQmSADest},
	{IDS_COL_QM_SA_PROT, CompareQmSAProtocol},
	{IDS_COL_QM_SA_SRC_PORT, CompareQmSASrcPort},
	{IDS_COL_QM_SA_DES_PORT, CompareQmSADestPort},
	{IDS_COL_QM_SA_MY_TNL, CompareQmSAMyTnlEp},
	{IDS_COL_QM_SA_PEER_TNL, CompareQmSAPeerTnlEp},
	{INDEX_TYPE_DEFAULT, NULL}		//NULL means do nothing during sort
};


CColumnIndex::CColumnIndex(DWORD dwIndexType, PCOMPARE_FUNCTION pfnCompare)
 :	CIndexArray(),
	m_dwIndexType(dwIndexType),
	m_pfnCompare(pfnCompare),
	m_dwSortOption(SORT_ASCENDING)
{
}


HRESULT CColumnIndex::Sort()
{
	if (NULL != m_pfnCompare)
	{
		qsort(GetData(), (size_t)GetSize(), sizeof(void *), m_pfnCompare);
	}

	return S_OK;
}

void* CColumnIndex::GetIndexedItem(int nIndex)
{
	return ((m_dwSortOption & SORT_ASCENDING)) ? GetAt(GetSize() - nIndex -1) : GetAt(nIndex);
}


CIndexManager::CIndexManager()
 :	m_DefaultIndex(INDEX_TYPE_DEFAULT, NULL), //NULL means do nothing during sort
    m_posCurrentIndex(NULL)
{
}

CIndexManager::~CIndexManager()
{
	Reset();
}


void
CIndexManager::Reset()
{
	while (m_listIndicies.GetCount() > 0)
	{
		delete m_listIndicies.RemoveHead();
	}

	m_posCurrentIndex = NULL;

	m_DefaultIndex.RemoveAll();
}

int
CIndexManager::AddItem(void *pItem)
{
	return (int)m_DefaultIndex.Add(pItem);
}


void * CIndexManager::GetItemData(int nIndex)
{
	CColumnIndex * pIndex = NULL;

	if (NULL == m_posCurrentIndex)
	{
		//use the default index
		pIndex = &m_DefaultIndex;
	}
	else
	{
		pIndex = m_listIndicies.GetAt(m_posCurrentIndex);
	}

	Assert(pIndex);

	if (nIndex < pIndex->GetSize() && nIndex >= 0)
	{
		return pIndex->GetIndexedItem(nIndex);
	}
	else
	{
		Panic0("We dont have that index!");
		return NULL;
	}

}

DWORD CIndexManager::GetCurrentIndexType()
{
	DWORD dwIndexType;
	
	if (m_posCurrentIndex)
	{
		CColumnIndex * pIndex = m_listIndicies.GetAt(m_posCurrentIndex);
		dwIndexType = pIndex->GetType();
	}
	else
	{
		dwIndexType = m_DefaultIndex.GetType();
	}

	return dwIndexType;
}

DWORD CIndexManager::GetCurrentSortOption()
{
	DWORD dwSortOption;
	
	if (m_posCurrentIndex)
	{
		CColumnIndex * pIndex = m_listIndicies.GetAt(m_posCurrentIndex);
		dwSortOption = pIndex->GetSortOption();
	}
	else
	{
		dwSortOption = m_DefaultIndex.GetSortOption();
	}

	return dwSortOption;
}


HRESULT
CIndexMgrFilter::SortFilters(
	DWORD dwSortType, 
	DWORD dwSortOptions
	)
{
	HRESULT hr = hrOK;

	POSITION posLast;
	POSITION pos;
	DWORD    dwIndexType;
	
	pos = m_listIndicies.GetHeadPosition();
	while (pos)
	{
		posLast = pos;
		CColumnIndex * pIndex = m_listIndicies.GetNext(pos);

		dwIndexType = pIndex->GetType();

        // the index for this type already exists, just sort accordingly
        if (dwIndexType == dwSortType)
		{
			pIndex->SetSortOption(dwSortOptions);

			m_posCurrentIndex = posLast;
		
			return hrOK;
		}
    }

    // if not, create one
	CColumnIndex * pNewIndex = NULL;
	for (int i = 0; i < DimensionOf(TypeProcQmFilter); i++)
	{
		if (TypeProcQmFilter[i].dwType == dwSortType)
		{
			pNewIndex = new CColumnIndex(dwSortType, TypeProcQmFilter[i].pCompareProc);
			break;
		}
	}

    Assert(pNewIndex);
	if (NULL == pNewIndex)
	{
		return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
	}

    // copy the array from the original index
    pNewIndex->Copy(m_DefaultIndex);
	

    pNewIndex->SetSortOption(dwSortOptions);
    pNewIndex->Sort();

	m_posCurrentIndex = m_listIndicies.AddTail(pNewIndex);

    return hr;
}


HRESULT
CIndexMgrMmFilter::SortMmFilters(
	DWORD dwSortType, 
	DWORD dwSortOptions
	)
{
	HRESULT hr = hrOK;

	POSITION posLast;
	POSITION pos;
	DWORD    dwIndexType;
	
	pos = m_listIndicies.GetHeadPosition();
	while (pos)
	{
		posLast = pos;
		CColumnIndex * pIndex = m_listIndicies.GetNext(pos);

		dwIndexType = pIndex->GetType();

        // the index for this type already exists, just sort accordingly
        if (dwIndexType == dwSortType)
		{
			pIndex->SetSortOption(dwSortOptions);

			m_posCurrentIndex = posLast;
		
			return hrOK;
		}
    }

    // if not, create one
	CColumnIndex * pNewIndex = NULL;
	for (int i = 0; i < DimensionOf(TypeProcMmFilter); i++)
	{
		if (TypeProcMmFilter[i].dwType == dwSortType)
		{
			pNewIndex = new CColumnIndex(dwSortType, TypeProcMmFilter[i].pCompareProc);
			break;
		}
	}

    Assert(pNewIndex);

	if (NULL == pNewIndex)
	{
		return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
	}

    // copy the array from the original index
    pNewIndex->Copy(m_DefaultIndex);
	

    pNewIndex->SetSortOption(dwSortOptions);
    pNewIndex->Sort();

	m_posCurrentIndex = m_listIndicies.AddTail(pNewIndex);

    return hr;
}


HRESULT
CIndexMgrMmPolicy::Sort(
	DWORD dwSortType, 
	DWORD dwSortOptions
	)
{
	HRESULT hr = hrOK;

	POSITION posLast;
	POSITION pos;
	DWORD    dwIndexType;
	
	pos = m_listIndicies.GetHeadPosition();
	while (pos)
	{
		posLast = pos;
		CColumnIndex * pIndex = m_listIndicies.GetNext(pos);

		dwIndexType = pIndex->GetType();

        // the index for this type already exists, just sort accordingly
        if (dwIndexType == dwSortType)
		{
			pIndex->SetSortOption(dwSortOptions);

			m_posCurrentIndex = posLast;
		
			return hrOK;
		}
    }

    // if not, create one
	CColumnIndex * pNewIndex = NULL;
	for (int i = 0; i < DimensionOf(TypeProcMmPolicy); i++)
	{
		if (TypeProcMmPolicy[i].dwType == dwSortType)
		{
			pNewIndex = new CColumnIndex(dwSortType, TypeProcMmPolicy[i].pCompareProc);
			break;
		}
	}

    Assert(pNewIndex);

	if (NULL == pNewIndex)
	{
		return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
	}

    // copy the array from the original index
    pNewIndex->Copy(m_DefaultIndex);
	

    pNewIndex->SetSortOption(dwSortOptions);
    pNewIndex->Sort();

	m_posCurrentIndex = m_listIndicies.AddTail(pNewIndex);

    return hr;
}


HRESULT
CIndexMgrQmPolicy::Sort(
	DWORD dwSortType, 
	DWORD dwSortOptions
	)
{
	HRESULT hr = hrOK;

	POSITION posLast;
	POSITION pos;
	DWORD    dwIndexType;
	
	pos = m_listIndicies.GetHeadPosition();
	while (pos)
	{
		posLast = pos;
		CColumnIndex * pIndex = m_listIndicies.GetNext(pos);

		dwIndexType = pIndex->GetType();

        // the index for this type already exists, just sort accordingly
        if (dwIndexType == dwSortType)
		{
			pIndex->SetSortOption(dwSortOptions);

			m_posCurrentIndex = posLast;
		
			return hrOK;
		}
    }

    // if not, create one
	CColumnIndex * pNewIndex = NULL;
	for (int i = 0; i < DimensionOf(TypeProcQmPolicy); i++)
	{
		if (TypeProcQmPolicy[i].dwType == dwSortType)
		{
			pNewIndex = new CColumnIndex(dwSortType, TypeProcQmPolicy[i].pCompareProc);
			break;
		}
	}


    Assert(pNewIndex);

	if (NULL == pNewIndex)
	{
		return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
	}

    // copy the array from the original index
    pNewIndex->Copy(m_DefaultIndex);
	

    pNewIndex->SetSortOption(dwSortOptions);
    pNewIndex->Sort();

	m_posCurrentIndex = m_listIndicies.AddTail(pNewIndex);

    return hr;
}

HRESULT
CIndexMgrMmSA::Sort(
	DWORD dwSortType, 
	DWORD dwSortOptions
	)
{
	HRESULT hr = hrOK;

	POSITION posLast;
	POSITION pos;
	DWORD    dwIndexType;
	
	pos = m_listIndicies.GetHeadPosition();
	while (pos)
	{
		posLast = pos;
		CColumnIndex * pIndex = m_listIndicies.GetNext(pos);

		dwIndexType = pIndex->GetType();

        // the index for this type already exists, just sort accordingly
        if (dwIndexType == dwSortType)
		{
			pIndex->SetSortOption(dwSortOptions);

			m_posCurrentIndex = posLast;
		
			return hrOK;
		}
    }

    // if not, create one
	CColumnIndex * pNewIndex = NULL;
	for (int i = 0; i < DimensionOf(TypeProcMmSA); i++)
	{
		if (TypeProcMmSA[i].dwType == dwSortType)
		{
			pNewIndex = new CColumnIndex(dwSortType, TypeProcMmSA[i].pCompareProc);
			break;
		}
	}

    Assert(pNewIndex);

	if (NULL == pNewIndex)
	{
		return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
	}

    // copy the array from the original index
    pNewIndex->Copy(m_DefaultIndex);
	

    pNewIndex->SetSortOption(dwSortOptions);
    pNewIndex->Sort();

	m_posCurrentIndex = m_listIndicies.AddTail(pNewIndex);

    return hr;
}


HRESULT
CIndexMgrQmSA::Sort(
	DWORD dwSortType, 
	DWORD dwSortOptions
	)
{

	HRESULT hr = hrOK;

	POSITION posLast;
	POSITION pos;
	DWORD    dwIndexType;
	
	pos = m_listIndicies.GetHeadPosition();
	while (pos)
	{
		posLast = pos;
		CColumnIndex * pIndex = m_listIndicies.GetNext(pos);

		dwIndexType = pIndex->GetType();

        // the index for this type already exists, just sort accordingly
        if (dwIndexType == dwSortType)
		{
			pIndex->SetSortOption(dwSortOptions);

			m_posCurrentIndex = posLast;
		
			return hrOK;
		}
    }

    // if not, create one
	CColumnIndex * pNewIndex = NULL;
	for (int i = 0; i < DimensionOf(TypeProcQmSA); i++)
	{
		if (TypeProcQmSA[i].dwType == dwSortType)
		{
			pNewIndex = new CColumnIndex(dwSortType, TypeProcQmSA[i].pCompareProc);
			break;
		}
	}

    Assert(pNewIndex);

	if (NULL == pNewIndex)
	{
		return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
	}

    // copy the array from the original index
    pNewIndex->Copy(m_DefaultIndex);
	

    pNewIndex->SetSortOption(dwSortOptions);
    pNewIndex->Sort();

	m_posCurrentIndex = m_listIndicies.AddTail(pNewIndex);


    return hr;
}


int __cdecl CompareFilterName(const void *elem1, const void *elem2)
{
	CFilterInfo *pFilter1;
	CFilterInfo *pFilter2;
	pFilter1 = *((CFilterInfo**)elem1);
	pFilter2 = *((CFilterInfo**)elem2);

	return pFilter1->m_stName.CompareNoCase(pFilter2->m_stName);
}

int __cdecl CompareFilterSourceAddr(const void *elem1, const void *elem2)
{
	CFilterInfo *pFilter1;
	CFilterInfo *pFilter2;
	pFilter1 = *((CFilterInfo**)elem1);
	pFilter2 = *((CFilterInfo**)elem2);

	CString str1;
	CString str2;

	AddressToString(pFilter1->m_SrcAddr, &str1);
	AddressToString(pFilter2->m_SrcAddr, &str2);
	return str1.CompareNoCase(str2);
}

int __cdecl CompareFilterDestAddr(const void *elem1, const void *elem2)
{
	CFilterInfo *pFilter1;
	CFilterInfo *pFilter2;
	pFilter1 = *((CFilterInfo**)elem1);
	pFilter2 = *((CFilterInfo**)elem2);

	CString str1;
	CString str2;

	AddressToString(pFilter1->m_DesAddr, &str1);
	AddressToString(pFilter2->m_DesAddr, &str2);
	return str1.CompareNoCase(str2);
}

int __cdecl CompareFilterSrcPort(const void *elem1, const void *elem2)
{
	CFilterInfo *pFilter1;
	CFilterInfo *pFilter2;
	pFilter1 = *((CFilterInfo**)elem1);
	pFilter2 = *((CFilterInfo**)elem2);

	return (int)pFilter1->m_SrcPort.wPort - (int)pFilter2->m_SrcPort.wPort;
}

int __cdecl CompareFilterDestPort(const void *elem1, const void *elem2)
{
	CFilterInfo *pFilter1;
	CFilterInfo *pFilter2;
	pFilter1 = *((CFilterInfo**)elem1);
	pFilter2 = *((CFilterInfo**)elem2);

	return (int)pFilter1->m_DesPort.wPort - (int)pFilter2->m_DesPort.wPort;
}

int __cdecl CompareFilterSrcTnl(const void *elem1, const void *elem2)
{
	CFilterInfo *pFilter1;
	CFilterInfo *pFilter2;
	pFilter1 = *((CFilterInfo**)elem1);
	pFilter2 = *((CFilterInfo**)elem2);

	CString str1;
	CString str2;

	TnlEpToString(pFilter1->m_FilterType, pFilter1->m_MyTnlAddr, &str1);
	TnlEpToString(pFilter2->m_FilterType, pFilter2->m_MyTnlAddr, &str2);

	return str1.CompareNoCase(str2);
}

int __cdecl CompareFilterDestTnl(const void *elem1, const void *elem2)
{
	CFilterInfo *pFilter1;
	CFilterInfo *pFilter2;
	pFilter1 = *((CFilterInfo**)elem1);
	pFilter2 = *((CFilterInfo**)elem2);

	CString str1;
	CString str2;

	TnlEpToString(pFilter1->m_FilterType, pFilter1->m_PeerTnlAddr, &str1);
	TnlEpToString(pFilter2->m_FilterType, pFilter2->m_PeerTnlAddr, &str2);

	return str1.CompareNoCase(str2);
}

int __cdecl CompareFilterProtocol(const void *elem1, const void *elem2)
{
	CFilterInfo *pFilter1;
	CFilterInfo *pFilter2;
	pFilter1 = *((CFilterInfo**)elem1);
	pFilter2 = *((CFilterInfo**)elem2);
	
	CString st1;
	CString st2;

	ProtocolToString(pFilter1->m_Protocol, &st1);
	ProtocolToString(pFilter2->m_Protocol, &st2);
	
	return st1.CompareNoCase(st2);
}

int __cdecl CompareFilterDirection(const void *elem1, const void *elem2)
{
	CFilterInfo *pFilter1;
	CFilterInfo *pFilter2;
	pFilter1 = *((CFilterInfo**)elem1);
	pFilter2 = *((CFilterInfo**)elem2);

	CString st1;
	CString st2;
	DirectionToString(pFilter1->m_dwDirection, &st1);
	DirectionToString(pFilter2->m_dwDirection, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareFilterPolicyName(const void *elem1, const void *elem2)
{
	CFilterInfo *pFilter1;
	CFilterInfo *pFilter2;
	pFilter1 = *((CFilterInfo**)elem1);
	pFilter2 = *((CFilterInfo**)elem2);
	
	return pFilter1->m_stPolicyName.CompareNoCase(pFilter2->m_stPolicyName);
}

int __cdecl CompareFilterIfType(const void *elem1, const void *elem2)
{
	CFilterInfo *pFilter1;
	CFilterInfo *pFilter2;
	pFilter1 = *((CFilterInfo**)elem1);
	pFilter2 = *((CFilterInfo**)elem2);
	
	CString st1;
	CString st2;

	InterfaceTypeToString(pFilter1->m_InterfaceType, &st1);
	InterfaceTypeToString(pFilter2->m_InterfaceType, &st2);
	
	return st1.CompareNoCase(st2);
}

int __cdecl CompareFilterOutboundFlag(const void *elem1, const void *elem2)
{
	CFilterInfo *pFilter1;
	CFilterInfo *pFilter2;
	pFilter1 = *((CFilterInfo**)elem1);
	pFilter2 = *((CFilterInfo**)elem2);
	
	CString st1;
	CString st2;

	FilterFlagToString(pFilter1->m_OutboundFilterFlag, &st1);
	FilterFlagToString(pFilter2->m_OutboundFilterFlag, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareFilterInboundFlag(const void *elem1, const void *elem2)
{
	CFilterInfo *pFilter1;
	CFilterInfo *pFilter2;
	pFilter1 = *((CFilterInfo**)elem1);
	pFilter2 = *((CFilterInfo**)elem2);
	
	CString st1;
	CString st2;

	FilterFlagToString(pFilter1->m_InboundFilterFlag, &st1);
	FilterFlagToString(pFilter2->m_InboundFilterFlag, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareFilterFlag(const void *elem1, const void *elem2)
{
	CFilterInfo *pFilter1;
	CFilterInfo *pFilter2;
	pFilter1 = *((CFilterInfo**)elem1);
	pFilter2 = *((CFilterInfo**)elem2);
	
	CString st1;
	CString st2;

	FilterFlagToString(
					(FILTER_DIRECTION_INBOUND == pFilter1->m_dwDirection) ?
						pFilter1->m_InboundFilterFlag : pFilter1->m_OutboundFilterFlag,
					&st1
					);

	FilterFlagToString(
					(FILTER_DIRECTION_INBOUND == pFilter2->m_dwDirection) ?
						pFilter2->m_InboundFilterFlag : pFilter2->m_OutboundFilterFlag,
					&st2
					);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareFilterWeight(const void *elem1, const void *elem2)
{
	CFilterInfo *pFilter1;
	CFilterInfo *pFilter2;
	pFilter1 = *((CFilterInfo**)elem1);
	pFilter2 = *((CFilterInfo**)elem2);

	return (int)pFilter1->m_dwWeight - (int)pFilter2->m_dwWeight;
}

int __cdecl CompareMmFilterName(const void *elem1, const void *elem2)
{
	CMmFilterInfo *pFilter1;
	CMmFilterInfo *pFilter2;
	pFilter1 = *((CMmFilterInfo**)elem1);
	pFilter2 = *((CMmFilterInfo**)elem2);

	return pFilter1->m_stName.CompareNoCase(pFilter2->m_stName);
}

int __cdecl CompareMmFilterSourceAddr(const void *elem1, const void *elem2)
{
	CMmFilterInfo *pFilter1;
	CMmFilterInfo *pFilter2;
	pFilter1 = *((CMmFilterInfo**)elem1);
	pFilter2 = *((CMmFilterInfo**)elem2);

	CString str1;
	CString str2;

	AddressToString(pFilter1->m_SrcAddr, &str1);
	AddressToString(pFilter2->m_SrcAddr, &str2);
	return str1.CompareNoCase(str2);
}

int __cdecl CompareMmFilterDestAddr(const void *elem1, const void *elem2)
{
	CMmFilterInfo *pFilter1;
	CMmFilterInfo *pFilter2;
	pFilter1 = *((CMmFilterInfo**)elem1);
	pFilter2 = *((CMmFilterInfo**)elem2);

	CString str1;
	CString str2;

	AddressToString(pFilter1->m_DesAddr, &str1);
	AddressToString(pFilter2->m_DesAddr, &str2);
	return str1.CompareNoCase(str2);
}

int __cdecl CompareMmFilterDirection(const void *elem1, const void *elem2)
{
	CMmFilterInfo *pFilter1;
	CMmFilterInfo *pFilter2;
	pFilter1 = *((CMmFilterInfo**)elem1);
	pFilter2 = *((CMmFilterInfo**)elem2);

	CString st1;
	CString st2;

	DirectionToString(pFilter1->m_dwDirection, &st1);
	DirectionToString(pFilter2->m_dwDirection, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareMmFilterWeight(const void *elem1, const void *elem2)
{
	CMmFilterInfo *pFilter1;
	CMmFilterInfo *pFilter2;
	pFilter1 = *((CMmFilterInfo**)elem1);
	pFilter2 = *((CMmFilterInfo**)elem2);

	return (int)pFilter1->m_dwWeight - (int)pFilter2->m_dwWeight;
}

int __cdecl CompareMmFilterPolicyName(const void *elem1, const void *elem2)
{
	CMmFilterInfo *pFilter1;
	CMmFilterInfo *pFilter2;
	pFilter1 = *((CMmFilterInfo**)elem1);
	pFilter2 = *((CMmFilterInfo**)elem2);

	return pFilter1->m_stPolicyName.CompareNoCase(pFilter2->m_stPolicyName);
}

int __cdecl CompareMmFilterAuth(const void *elem1, const void *elem2)
{
	CMmFilterInfo *pFilter1;
	CMmFilterInfo *pFilter2;
	pFilter1 = *((CMmFilterInfo**)elem1);
	pFilter2 = *((CMmFilterInfo**)elem2);

	return pFilter1->m_stAuthDescription.CompareNoCase(pFilter2->m_stAuthDescription);
}

int __cdecl CompareMmFilterIfType(const void *elem1, const void *elem2)
{
	CMmFilterInfo *pFilter1;
	CMmFilterInfo *pFilter2;
	pFilter1 = *((CMmFilterInfo**)elem1);
	pFilter2 = *((CMmFilterInfo**)elem2);
	CString str1;
	CString str2;

	InterfaceTypeToString(pFilter1->m_InterfaceType, &str1);
	InterfaceTypeToString(pFilter2->m_InterfaceType, &str2);

	return str1.CompareNoCase(str2);
}

int __cdecl CompareMmPolicyName(const void *elem1, const void *elem2)
{
	CMmPolicyInfo * pPolicy1;
	CMmPolicyInfo * pPolicy2;

	pPolicy1 = *((CMmPolicyInfo**)elem1);
	pPolicy2 = *((CMmPolicyInfo**)elem2);

	return pPolicy1->m_stName.CompareNoCase(pPolicy2->m_stName);
}

int __cdecl CompareMmPolicyOfferNumber(const void *elem1, const void *elem2)
{
	CMmPolicyInfo * pPolicy1;
	CMmPolicyInfo * pPolicy2;

	pPolicy1 = *((CMmPolicyInfo**)elem1);
	pPolicy2 = *((CMmPolicyInfo**)elem2);

	return pPolicy1->m_dwOfferCount - pPolicy2->m_dwOfferCount;
}

int __cdecl CompareQmPolicyName(const void *elem1, const void *elem2)
{
	CQmPolicyInfo * pPolicy1;
	CQmPolicyInfo * pPolicy2;

	pPolicy1 = *((CQmPolicyInfo**)elem1);
	pPolicy2 = *((CQmPolicyInfo**)elem2);

	return pPolicy1->m_stName.CompareNoCase(pPolicy2->m_stName);
}

int __cdecl CompareQmPolicyOfferNumber(const void *elem1, const void *elem2)
{
	CQmPolicyInfo * pPolicy1;
	CQmPolicyInfo * pPolicy2;

	pPolicy1 = *((CQmPolicyInfo**)elem1);
	pPolicy2 = *((CQmPolicyInfo**)elem2);

	return (int)(pPolicy1->m_arrOffers.GetSize() - pPolicy2->m_arrOffers.GetSize());
}

int __cdecl CompareMmSAMeAddr(const void *elem1, const void *elem2)
{
	CMmSA * pSA1;
	CMmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CMmSA**)elem1);
	pSA2 = *((CMmSA**)elem2);

	AddressToString(pSA1->m_MeAddr, &st1);
	AddressToString(pSA2->m_MeAddr, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareMmSAPeerAddr(const void *elem1, const void *elem2)
{
	CMmSA * pSA1;
	CMmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CMmSA**)elem1);
	pSA2 = *((CMmSA**)elem2);

	AddressToString(pSA1->m_PeerAddr, &st1);
	AddressToString(pSA2->m_PeerAddr, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareMmSAAuth(const void *elem1, const void *elem2)
{
	CMmSA * pSA1;
	CMmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CMmSA**)elem1);
	pSA2 = *((CMmSA**)elem2);

	MmAuthToString(pSA1->m_Auth, &st1);
	MmAuthToString(pSA2->m_Auth, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareMmSAEncryption(const void *elem1, const void *elem2)
{
	CMmSA * pSA1;
	CMmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CMmSA**)elem1);
	pSA2 = *((CMmSA**)elem2);

	DoiEspAlgorithmToString(pSA1->m_SelectedOffer.m_EncryptionAlgorithm, &st1);
	DoiEspAlgorithmToString(pSA2->m_SelectedOffer.m_EncryptionAlgorithm, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareMmSAIntegrity(const void *elem1, const void *elem2)
{
	CMmSA * pSA1;
	CMmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CMmSA**)elem1);
	pSA2 = *((CMmSA**)elem2);

	DoiAuthAlgorithmToString(pSA1->m_SelectedOffer.m_HashingAlgorithm, &st1);
	DoiAuthAlgorithmToString(pSA2->m_SelectedOffer.m_HashingAlgorithm, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareMmSADhGroup(const void *elem1, const void *elem2)
{
	CMmSA * pSA1;
	CMmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CMmSA**)elem1);
	pSA2 = *((CMmSA**)elem2);

	DhGroupToString(pSA1->m_SelectedOffer.m_dwDHGroup, &st1);
	DhGroupToString(pSA2->m_SelectedOffer.m_dwDHGroup, &st2);

	return st1.CompareNoCase(st2);
}


int __cdecl CompareQmSAPolicyName(const void *elem1, const void *elem2)
{
	CQmSA * pSA1;
	CQmSA * pSA2;

	pSA1 = *((CQmSA**)elem1);
	pSA2 = *((CQmSA**)elem2);

	return pSA1->m_stPolicyName.CompareNoCase(pSA2->m_stPolicyName);
}

int __cdecl CompareQmSAAuth(const void *elem1, const void *elem2)
{
	CQmSA * pSA1;
	CQmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CQmSA**)elem1);
	pSA2 = *((CQmSA**)elem2);

	QmAlgorithmToString(QM_ALGO_AUTH, &pSA1->m_SelectedOffer, &st1);
	QmAlgorithmToString(QM_ALGO_AUTH, &pSA2->m_SelectedOffer, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareQmSAConf(const void *elem1, const void *elem2)
{
	CQmSA * pSA1;
	CQmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CQmSA**)elem1);
	pSA2 = *((CQmSA**)elem2);

	QmAlgorithmToString(QM_ALGO_ESP_CONF, &pSA1->m_SelectedOffer, &st1);
	QmAlgorithmToString(QM_ALGO_ESP_CONF, &pSA2->m_SelectedOffer, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareQmSAIntegrity(const void *elem1, const void *elem2)
{
	CQmSA * pSA1;
	CQmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CQmSA**)elem1);
	pSA2 = *((CQmSA**)elem2);

	QmAlgorithmToString(QM_ALGO_ESP_INTEG, &pSA1->m_SelectedOffer, &st1);
	QmAlgorithmToString(QM_ALGO_ESP_INTEG, &pSA2->m_SelectedOffer, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareQmSASrc(const void *elem1, const void *elem2)
{
	CQmSA * pSA1;
	CQmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CQmSA**)elem1);
	pSA2 = *((CQmSA**)elem2);

	AddressToString(pSA1->m_QmDriverFilter.m_SrcAddr, &st1);
	AddressToString(pSA2->m_QmDriverFilter.m_SrcAddr, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareQmSADest(const void *elem1, const void *elem2)
{
	CQmSA * pSA1;
	CQmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CQmSA**)elem1);
	pSA2 = *((CQmSA**)elem2);

	AddressToString(pSA1->m_QmDriverFilter.m_DesAddr, &st1);
	AddressToString(pSA2->m_QmDriverFilter.m_DesAddr, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareQmSAProtocol(const void *elem1, const void *elem2)
{
	CQmSA * pSA1;
	CQmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CQmSA**)elem1);
	pSA2 = *((CQmSA**)elem2);

	ProtocolToString(pSA1->m_QmDriverFilter.m_Protocol, &st1);
	ProtocolToString(pSA2->m_QmDriverFilter.m_Protocol, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareQmSASrcPort(const void *elem1, const void *elem2)
{
	CQmSA * pSA1;
	CQmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CQmSA**)elem1);
	pSA2 = *((CQmSA**)elem2);

	PortToString(pSA1->m_QmDriverFilter.m_SrcPort, &st1);
	PortToString(pSA2->m_QmDriverFilter.m_SrcPort, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareQmSADestPort(const void *elem1, const void *elem2)
{
	CQmSA * pSA1;
	CQmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CQmSA**)elem1);
	pSA2 = *((CQmSA**)elem2);

	PortToString(pSA1->m_QmDriverFilter.m_DesPort, &st1);
	PortToString(pSA2->m_QmDriverFilter.m_DesPort, &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareQmSAMyTnlEp(const void *elem1, const void *elem2)
{
	CQmSA * pSA1;
	CQmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CQmSA**)elem1);
	pSA2 = *((CQmSA**)elem2);

	TnlEpToString(pSA1->m_QmDriverFilter.m_Type, 
				   pSA1->m_QmDriverFilter.m_MyTunnelEndpt, 
				   &st1);
	TnlEpToString(pSA2->m_QmDriverFilter.m_Type, 
				   pSA2->m_QmDriverFilter.m_MyTunnelEndpt, 
				   &st2);

	return st1.CompareNoCase(st2);
}

int __cdecl CompareQmSAPeerTnlEp(const void *elem1, const void *elem2)
{
	CQmSA * pSA1;
	CQmSA * pSA2;

	CString st1;
	CString st2;

	pSA1 = *((CQmSA**)elem1);
	pSA2 = *((CQmSA**)elem2);

	TnlEpToString(pSA1->m_QmDriverFilter.m_Type, 
				   pSA1->m_QmDriverFilter.m_PeerTunnelEndpt, 
				   &st1);
	TnlEpToString(pSA2->m_QmDriverFilter.m_Type, 
				   pSA2->m_QmDriverFilter.m_PeerTunnelEndpt, 
				   &st2);
	return st1.CompareNoCase(st2);
}