492 lines
9.9 KiB
C++
492 lines
9.9 KiB
C++
|
#include "util.h"
|
||
|
|
|
||
|
|
WCHAR g_szwIds[MAX_PATH + 1];
|
||
|
|
WCHAR g_szwSpace[MAX_PATH + 1];
|
||
|
|
|
||
|
|
WCHAR *
|
||
|
|
ids(LONG nIndex)
|
||
|
|
{
|
||
|
|
if( LoadString((HINSTANCE)g_hModule,nIndex,g_szwIds,MAX_PATH) )
|
||
|
|
{
|
||
|
|
return g_szwIds;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return L"";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
WCHAR *
|
||
|
|
Space(
|
||
|
|
int nSpace
|
||
|
|
)
|
||
|
|
{
|
||
|
|
for(int i=0; i<nSpace && i< MAX_PATH; i++)
|
||
|
|
{
|
||
|
|
g_szwSpace[i] = L' ';
|
||
|
|
}
|
||
|
|
|
||
|
|
g_szwSpace[i] = L'\0';
|
||
|
|
|
||
|
|
return g_szwSpace;
|
||
|
|
}
|
||
|
|
|
||
|
|
WCHAR *
|
||
|
|
Indent(
|
||
|
|
int nIndent
|
||
|
|
)
|
||
|
|
{
|
||
|
|
return Space(nIndent * 4);
|
||
|
|
}
|
||
|
|
BOOLEAN
|
||
|
|
IsNumber(
|
||
|
|
IN LPCTSTR pszw
|
||
|
|
)
|
||
|
|
{
|
||
|
|
if( !pszw )
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
for(int i=0; pszw[i]!=L'\0'; i++)
|
||
|
|
{
|
||
|
|
if( !isdigit(pszw[i]) )
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOLEAN
|
||
|
|
IsContained(
|
||
|
|
IN LPCTSTR pszwInstance,
|
||
|
|
IN LPCTSTR pszwSrch
|
||
|
|
)
|
||
|
|
/*++
|
||
|
|
|
||
|
|
Routine Description
|
||
|
|
This method compares two strings and determines if the strings resemble each
|
||
|
|
other. If the strings are identical, then they resemble each other.
|
||
|
|
If the search string (pszwSrch) starts or ends with a '*', then the method
|
||
|
|
checks if the search string is contained inside of the instance string (pszwInstance).
|
||
|
|
i.e. pszwInstance = 3Com 3C918 Integrated Fast Ethernet Controller (3C905B-TX Compatible)
|
||
|
|
pszwSrch = com* | *com
|
||
|
|
then pszwSrch resembles pszwInstance. The string compare is not case sensative.
|
||
|
|
|
||
|
|
Arguments
|
||
|
|
pszwInstance The instance string
|
||
|
|
pszwSrch The search string
|
||
|
|
|
||
|
|
Return Value
|
||
|
|
TRUE if the strings resemble each other
|
||
|
|
else FALSE
|
||
|
|
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
LPCTSTR pszw = NULL;
|
||
|
|
int nLen;
|
||
|
|
|
||
|
|
if( !pszwSrch || !pszwInstance || lstrcmpi(pszwSrch,L"*")==0 )
|
||
|
|
{
|
||
|
|
// The strings are empty, so they match.
|
||
|
|
//
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if( pszwSrch[0] == L'*' )
|
||
|
|
{
|
||
|
|
// The search string starts with a '*', check if the search
|
||
|
|
// string is contained in the instance string
|
||
|
|
//
|
||
|
|
pszw = &pszwSrch[1];
|
||
|
|
|
||
|
|
if( wcsstri(pszwInstance,pszw) )
|
||
|
|
{
|
||
|
|
// Search string is contain within the instance string
|
||
|
|
//
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
nLen = lstrlen(pszwSrch);
|
||
|
|
if( nLen > 1 && pszwSrch[nLen -1] == L'*' )
|
||
|
|
{
|
||
|
|
// The search string ends with a '*'. check if the search
|
||
|
|
// string is contained in the instance string
|
||
|
|
//
|
||
|
|
if( wcsstri(pszwInstance,pszwSrch,nLen-1) )
|
||
|
|
{
|
||
|
|
// Search string is contain within the instance string
|
||
|
|
//
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if( lstrcmpi(pszwInstance,pszwSrch) == 0 )
|
||
|
|
{
|
||
|
|
// No '*'. Check if the strings are the same
|
||
|
|
//
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Strings do not resemble each other
|
||
|
|
//
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
void
|
||
|
|
ToLowerStr(
|
||
|
|
WCHAR *pszwText
|
||
|
|
)
|
||
|
|
{
|
||
|
|
while( pszwText && *pszwText )
|
||
|
|
{
|
||
|
|
*pszwText = towlower(*pszwText);
|
||
|
|
pszwText++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOLEAN
|
||
|
|
wcsstri(
|
||
|
|
IN LPCTSTR pszw,
|
||
|
|
IN LPCTSTR pszwSrch,
|
||
|
|
IN int nLen
|
||
|
|
)
|
||
|
|
{
|
||
|
|
BOOLEAN bMatch = FALSE;
|
||
|
|
int i=0,j=0;
|
||
|
|
|
||
|
|
if( !pszw || !pszwSrch )
|
||
|
|
{
|
||
|
|
// Invalid pointers
|
||
|
|
//
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
for(i=0; pszw[i]!=L'\0'; i++)
|
||
|
|
{
|
||
|
|
if( j == nLen )
|
||
|
|
{
|
||
|
|
return bMatch;
|
||
|
|
}
|
||
|
|
if( pszwSrch[j] == L'\0' )
|
||
|
|
{
|
||
|
|
return bMatch;
|
||
|
|
}
|
||
|
|
if( towlower(pszw[i]) == towlower(pszwSrch[j]) )
|
||
|
|
{
|
||
|
|
j++;
|
||
|
|
bMatch = TRUE;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
j=0;
|
||
|
|
bMatch = FALSE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
BOOLEAN IsVariantEmpty(_variant_t &vValue)
|
||
|
|
{
|
||
|
|
_bstr_t bstr;
|
||
|
|
if( SUCCEEDED(GetVariant(vValue,0,bstr)) )
|
||
|
|
{
|
||
|
|
return lstrcmp(bstr,L"") == 0;
|
||
|
|
}
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOLEAN MakeIPByteArray(LPCTSTR pszwIPAddress, BYTE bIPByte[])
|
||
|
|
{
|
||
|
|
LONG nByteValue = 0;
|
||
|
|
LONG nByte = 0;
|
||
|
|
|
||
|
|
for(int i=0; pszwIPAddress[i]!=0; i++)
|
||
|
|
{
|
||
|
|
if( pszwIPAddress[i] == L'.')
|
||
|
|
{
|
||
|
|
if( nByteValue > 255 )
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
bIPByte[nByte] = nByteValue;
|
||
|
|
nByteValue = 0;
|
||
|
|
nByte++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if( !iswdigit(pszwIPAddress[i]) )
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
nByteValue = nByteValue * 10 + (pszwIPAddress[i] - L'0');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
bIPByte[nByte] = nByteValue;
|
||
|
|
|
||
|
|
return (nByte != 3)?FALSE:TRUE;
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
BOOLEAN IsInvalidIPAddress(LPCTSTR pszwIPAddress)
|
||
|
|
{
|
||
|
|
BYTE bIPByte[4];
|
||
|
|
|
||
|
|
if( MakeIPByteArray(pszwIPAddress,bIPByte) )
|
||
|
|
{
|
||
|
|
INT iZeroCount = 0;
|
||
|
|
INT i255Count = 0;
|
||
|
|
for(INT i=0; i<4; i++)
|
||
|
|
{
|
||
|
|
if( pszwIPAddress[i] == 0 )
|
||
|
|
{
|
||
|
|
iZeroCount++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if( pszwIPAddress[i] == 255 )
|
||
|
|
{
|
||
|
|
i255Count++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if( i255Count == 4 || iZeroCount == 4 )
|
||
|
|
{
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
BOOLEAN
|
||
|
|
IsSameSubnet(
|
||
|
|
IN LPCTSTR pszwIP1,
|
||
|
|
IN LPCTSTR pszwIP2,
|
||
|
|
IN LPCTSTR pszwSubnetMask
|
||
|
|
)
|
||
|
|
/*++
|
||
|
|
|
||
|
|
Routine Description
|
||
|
|
This method determines if two IP address are in the same subnet.
|
||
|
|
|
||
|
|
Arguments
|
||
|
|
pszwIP1 IP Address one
|
||
|
|
pszwIP2 IP Address two
|
||
|
|
pszwSubnetMask Subnet mask
|
||
|
|
|
||
|
|
Return Value
|
||
|
|
TRUE if they are in the same subnet
|
||
|
|
FALSE if they are not in the smae subnet
|
||
|
|
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
BYTE bIP1[4];
|
||
|
|
BYTE bIP2[4];
|
||
|
|
BYTE bSubnetMask[4];
|
||
|
|
int iRetVal;
|
||
|
|
|
||
|
|
if( !MakeIPByteArray(pszwIP1,bIP1) )
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
if( !MakeIPByteArray(pszwIP2,bIP2) )
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
if( !MakeIPByteArray(pszwSubnetMask,bSubnetMask) )
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// Check if IP1 and IP2 are in the same subnet
|
||
|
|
//
|
||
|
|
for( int i = 0; i< 4; i++)
|
||
|
|
{
|
||
|
|
// If (IP1 & with Subnetmas) == (IP2 & with subnet) then they are in the same subnet
|
||
|
|
//
|
||
|
|
if( (bIP1[i] & bSubnetMask[i]) != (bIP2[i] & bSubnetMask[i]) )
|
||
|
|
{
|
||
|
|
// No the same subnet
|
||
|
|
//
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Same subnet
|
||
|
|
//
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOLEAN
|
||
|
|
IsSameSubnet(
|
||
|
|
IN _variant_t *vIPAddress,
|
||
|
|
IN _variant_t *vSubnetMask,
|
||
|
|
IN WCHAR *pszwIPAddress2
|
||
|
|
)
|
||
|
|
{
|
||
|
|
DWORD i = 0;
|
||
|
|
DWORD j = 0;
|
||
|
|
_bstr_t bstrIP;
|
||
|
|
_bstr_t bstrSubnetMask;
|
||
|
|
|
||
|
|
if( !vIPAddress || !vSubnetMask || !pszwIPAddress2 )
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
while( S_OK == GetVariant(*vIPAddress,i,bstrIP) )
|
||
|
|
{
|
||
|
|
j = 0;
|
||
|
|
while( S_OK == GetVariant(*vSubnetMask,j,bstrSubnetMask) )
|
||
|
|
{
|
||
|
|
if( IsSameSubnet(bstrIP, pszwIPAddress2, bstrSubnetMask) )
|
||
|
|
{
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
j++;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
HRESULT
|
||
|
|
GetVariant(
|
||
|
|
IN _variant_t &vValue,
|
||
|
|
IN long nIndex,
|
||
|
|
OUT _bstr_t &bstr
|
||
|
|
)
|
||
|
|
/*++
|
||
|
|
|
||
|
|
Routine Description
|
||
|
|
This method extracts nth piece of data from a variant, converts it into a bstring
|
||
|
|
and returns the bstring.
|
||
|
|
|
||
|
|
Arguments
|
||
|
|
vValue Variant to extract data from
|
||
|
|
nIndex The index into the variant array (for non-arrays nIndex always is 0)
|
||
|
|
bstr Stores the variant as a bstr
|
||
|
|
|
||
|
|
Return Value
|
||
|
|
S_OK successfull
|
||
|
|
else HRESULT
|
||
|
|
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
HRESULT hr = S_FALSE;
|
||
|
|
BYTE g[100];
|
||
|
|
LPVOID pData = (LPVOID)g;
|
||
|
|
|
||
|
|
WCHAR szw[MAX_PATH];
|
||
|
|
_variant_t vTmp;
|
||
|
|
|
||
|
|
if( nIndex >= 25 )
|
||
|
|
{
|
||
|
|
// The array is to big. We are cutting it short
|
||
|
|
return E_INVALIDARG;
|
||
|
|
}
|
||
|
|
if( (vValue.vt & VT_ARRAY) )
|
||
|
|
{
|
||
|
|
// The variant contains an array. get the nIndex element from the array
|
||
|
|
//
|
||
|
|
hr = SafeArrayGetElement(vValue.parray,&nIndex,pData);
|
||
|
|
|
||
|
|
if( S_OK == hr )
|
||
|
|
{
|
||
|
|
|
||
|
|
// Convert the extracted data into a string
|
||
|
|
//
|
||
|
|
switch( vValue.vt & ~VT_ARRAY )
|
||
|
|
{
|
||
|
|
case VT_BSTR:
|
||
|
|
bstr = (BSTR)*((BSTR *)pData);
|
||
|
|
return S_OK;
|
||
|
|
|
||
|
|
case VT_I2:
|
||
|
|
bstr = (short)*((short *)pData);
|
||
|
|
return S_OK;
|
||
|
|
|
||
|
|
case VT_I4:
|
||
|
|
bstr = (long)*((LONG *)pData);
|
||
|
|
return S_OK;
|
||
|
|
|
||
|
|
case VT_UI1:
|
||
|
|
bstr = (BYTE)*((BYTE *)pData);
|
||
|
|
return S_OK;
|
||
|
|
|
||
|
|
case VT_NULL:
|
||
|
|
return S_FALSE;
|
||
|
|
|
||
|
|
case VT_EMPTY:
|
||
|
|
return S_FALSE;
|
||
|
|
|
||
|
|
case VT_BOOL:
|
||
|
|
{
|
||
|
|
if( (VARIANT_BOOL *)pData )
|
||
|
|
{
|
||
|
|
bstr = ids(IDS_TRUE);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
bstr = ids(IDS_FALSE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
default:
|
||
|
|
bstr = L"";
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if( nIndex == 0)
|
||
|
|
{
|
||
|
|
// The variant is not an array. In this case nIndex always needs to be 0
|
||
|
|
//
|
||
|
|
if( vValue.vt == VT_NULL || vValue.vt == VT_EMPTY)
|
||
|
|
{
|
||
|
|
// The variant is empty
|
||
|
|
//
|
||
|
|
bstr = L"";
|
||
|
|
return S_FALSE;
|
||
|
|
}
|
||
|
|
else if( (vValue.vt == VT_EMPTY) || (vValue.vt == VT_BSTR && lstrlen(vValue.bstrVal) == 0) )
|
||
|
|
{
|
||
|
|
// The variant is empty
|
||
|
|
//
|
||
|
|
bstr = L"";
|
||
|
|
return S_FALSE;
|
||
|
|
}
|
||
|
|
else if( vValue.vt == VT_BOOL )
|
||
|
|
{
|
||
|
|
if( vValue.boolVal )
|
||
|
|
{
|
||
|
|
bstr = ids(IDS_TRUE);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
bstr = ids(IDS_FALSE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// The variant contains valid data. Convert the data into a bstring.
|
||
|
|
//
|
||
|
|
vTmp = vValue;
|
||
|
|
vTmp.ChangeType(VT_BSTR);
|
||
|
|
bstr = vTmp.bstrVal;
|
||
|
|
}
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return E_INVALIDARG;
|
||
|
|
}
|