able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/mmc/dhcp/utils.cpp

1247 lines
29 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/**********************************************************************/
/** Microsoft Windows NT **/
/** Copyright(c) Microsoft Corporation, 1991 - 1999 **/
/**********************************************************************/
/*
utils.cpp
Utility routines for the DHCP admin snapin
FILE HISTORY:
DavidHov 6/15/93 Created
*/
#include "stdafx.h"
//#include "svcguid.h"
#define NUM_OPTION_TYPES 3
#define NUM_OPTION_POSS NUM_OPTION_TYPES * NUM_OPTION_TYPES
int g_OptionPriorityMap[NUM_OPTION_POSS][NUM_OPTION_TYPES] =
{
{ICON_IDX_CLIENT_OPTION_LEAF, ICON_IDX_CLIENT_OPTION_LEAF, 0},
{ICON_IDX_CLIENT_OPTION_LEAF, ICON_IDX_SCOPE_OPTION_LEAF, -1},
{ICON_IDX_CLIENT_OPTION_LEAF, ICON_IDX_SERVER_OPTION_LEAF, -1},
{ICON_IDX_SCOPE_OPTION_LEAF, ICON_IDX_CLIENT_OPTION_LEAF, 1},
{ICON_IDX_SCOPE_OPTION_LEAF, ICON_IDX_SCOPE_OPTION_LEAF, 0},
{ICON_IDX_SCOPE_OPTION_LEAF, ICON_IDX_SERVER_OPTION_LEAF, -1},
{ICON_IDX_SERVER_OPTION_LEAF, ICON_IDX_CLIENT_OPTION_LEAF, 1},
{ICON_IDX_SERVER_OPTION_LEAF, ICON_IDX_SCOPE_OPTION_LEAF, 1},
{ICON_IDX_SERVER_OPTION_LEAF, ICON_IDX_SERVER_OPTION_LEAF, 0}
};
int
UtilGetOptionPriority(int nOpt1, int nOpt2)
{
int nRet = 0;
for (int i = 0; i < NUM_OPTION_POSS; i++)
{
if ( (nOpt1 == g_OptionPriorityMap[i][0]) &&
(nOpt2 == g_OptionPriorityMap[i][1]) )
{
nRet = g_OptionPriorityMap[i][2];
break;
}
}
return nRet;
}
int ServerBrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData)
{
int i;
switch (uMsg)
{
case BFFM_INITIALIZED:
SendMessage(hwnd, BFFM_SETSELECTION, TRUE, lpData);
break;
}
return 0;
}
/*---------------------------------------------------------------------------
UtilGetFolderName()
Gets the folder name for backup/restore.
Author: EricDav
---------------------------------------------------------------------------*/
BOOL
UtilGetFolderName(CString & strInitialPath, CString& strHelpText, CString& strSelectedPath)
{
BOOL fOk = FALSE;
TCHAR szBuffer[MAX_PATH];
TCHAR szExpandedPath[MAX_PATH * 2];
HRESULT hr;
CString strStartingPath = strInitialPath;
if (strStartingPath.IsEmpty())
{
strStartingPath = _T("%SystemDrive%\\");
}
ExpandEnvironmentStrings(strStartingPath, szExpandedPath, sizeof(szExpandedPath) / sizeof(TCHAR));
LPITEMIDLIST pidlPrograms = NULL;
hr = SHGetSpecialFolderLocation(NULL, CSIDL_DRIVES, &pidlPrograms);
if ( FAILED( hr ) )
{
return fOk;
}
BROWSEINFO browseInfo;
browseInfo.hwndOwner = ::FindMMCMainWindow();
browseInfo.pidlRoot = pidlPrograms;
browseInfo.pszDisplayName = szBuffer;
browseInfo.lpszTitle = strHelpText;
browseInfo.ulFlags = BIF_NEWDIALOGSTYLE | BIF_RETURNONLYFSDIRS ;
browseInfo.lpfn = ServerBrowseCallbackProc;
browseInfo.lParam = (LPARAM) szExpandedPath;
LPITEMIDLIST pidlBrowse = SHBrowseForFolder(&browseInfo);
fOk = SHGetPathFromIDList(pidlBrowse, szBuffer);
CString strPath(szBuffer);
strSelectedPath = strPath;
LPMALLOC pMalloc = NULL;
if (pidlPrograms && SUCCEEDED(SHGetMalloc(&pMalloc)))
{
if (pMalloc)
pMalloc->Free(pidlPrograms);
}
return fOk;
}
/*---------------------------------------------------------------------------
UtilConvertLeaseTime
Converts the lease time from a dword to its day, hour and minute
values
Author: EricDav
---------------------------------------------------------------------------*/
void
UtilConvertLeaseTime
(
DWORD dwLeaseTime,
int * pnDays,
int * pnHours,
int * pnMinutes
)
{
*pnDays = dwLeaseTime / (60 * 60 * 24);
dwLeaseTime = (dwLeaseTime % (60 * 60 * 24));
*pnHours = dwLeaseTime / (60 * 60);
dwLeaseTime = (dwLeaseTime % (60 * 60));
*pnMinutes = dwLeaseTime / 60;
}
/*---------------------------------------------------------------------------
UtilConvertLeaseTime
Converts the lease time from its day, hour and minute values to
a dword
Author: EricDav
---------------------------------------------------------------------------*/
DWORD
UtilConvertLeaseTime
(
int nDays,
int nHours,
int nMinutes
)
{
return (DWORD) (nDays * 60 * 60 * 24) +
(nHours * 60 * 60) +
(nMinutes * 60);
}
/*---------------------------------------------------------------------------
UtilCvtStringToIpAddr
Description
Author: EricDav
---------------------------------------------------------------------------*/
ENUM_HOST_NAME_TYPE
UtilCategorizeName
(
LPCTSTR pszName
)
{
// assume a NetBios name
ENUM_HOST_NAME_TYPE enResult = HNM_TYPE_NB ;
const TCHAR chDash = '-';
const TCHAR chDot = '.' ;
const TCHAR chSlash = '\\' ;
CString strName( pszName ) ;
int cch = strName.GetLength() ;
// Does the name begin with two slashes??
if ( cch > 2
&& strName.GetAt(0) == chSlash
&& strName.GetAt(1) == chSlash )
{
enResult = HNM_TYPE_NB ;
}
else
{
//
// Scan the name looking for DNS name or IP address
//
int i = 0,
cDots = 0,
cAlpha = 0,
cDash = 0;
TCHAR ch ;
BOOL bOk = TRUE ;
for ( ; i < cch ; i++ )
{
switch ( ch = strName.GetAt( i ) )
{
case chDot:
if ( ++cDots > 3 )
{
// we keep track of the number of dots,
// but we need to be able to handle fully
// qualified domain names (FQDN) so more than
// 3 dots is ok.
//bOk = FALSE ;
}
break;
default:
if ( _istalpha( ch ) )
{
cAlpha++;
}
else if ( ch == chDash )
{
cDash++;
}
else if ( !_istdigit(ch) )
{
bOk = FALSE;
}
break;
}
if ( ! bOk )
{
break ;
}
}
if ( bOk )
{
if ( cAlpha )
{
enResult = HNM_TYPE_DNS ;
}
else if ( cDots == 3 )
{
enResult = HNM_TYPE_IP ;
}
}
}
return enResult ;
}
/*---------------------------------------------------------------------------
UtilCvtStringToIpAddr
Description
Author: EricDav
---------------------------------------------------------------------------*/
DHCP_IP_ADDRESS
UtilCvtStringToIpAddr
(
const CHAR * pszString
)
{
//
// Convert the string to network byte order, then to host byte order.
//
return (DHCP_IP_ADDRESS) ::ntohl( ::inet_addr( pszString ) ) ;
}
/*---------------------------------------------------------------------------
UtilCvtWstrToIpAddr
Description
Author: EricDav
---------------------------------------------------------------------------*/
DHCP_IP_ADDRESS
UtilCvtWstrToIpAddr
(
const LPCWSTR pcwString
)
{
CHAR szString [ MAX_PATH ] = {0};
::WideCharToMultiByte(CP_OEMCP, 0, pcwString, -1, szString, sizeof(szString), NULL, NULL);
//
// Convert the string to network byte order, then to host byte order.
//
return (DHCP_IP_ADDRESS) ::ntohl( ::inet_addr( szString ) );
}
/*---------------------------------------------------------------------------
UtilCvtIpAddrToString
Description
Author: EricDav
---------------------------------------------------------------------------*/
void
UtilCvtIpAddrToString
(
DHCP_IP_ADDRESS dhipa,
CHAR * pszString,
UINT cBuffSize
)
{
struct in_addr ipaddr ;
//
// Convert the unsigned long to network byte order
//
ipaddr.s_addr = ::htonl( (u_long) dhipa ) ;
//
// Convert the IP address value to a string
//
CHAR * pszAddr = inet_ntoa( ipaddr ) ;
// Copy the string to the caller's buffer.
ASSERT(cBuffSize > ::strlen(pszAddr));
ASSERT(pszString);
if (pszAddr)
{
::strcpy( pszString, pszAddr ) ;
}
}
/*---------------------------------------------------------------------------
UtilCvtIpAddrToWstr
Description
Author: EricDav
---------------------------------------------------------------------------*/
BOOL
UtilCvtIpAddrToWstr
(
DHCP_IP_ADDRESS dhipa,
CString * pstrIpAddress
)
{
CHAR szString [ MAX_PATH ] ;
LPCTSTR pbuf;
::UtilCvtIpAddrToString( dhipa, szString, MAX_PATH );
INT cch = ::strlen( szString ) ;
LPTSTR pBuf = pstrIpAddress->GetBuffer(IP_ADDDRESS_LENGTH_MAX);
ZeroMemory(pBuf, IP_ADDDRESS_LENGTH_MAX);
::MultiByteToWideChar(CP_OEMCP, MB_PRECOMPOSED, szString, -1, pBuf, IP_ADDDRESS_LENGTH_MAX);
pstrIpAddress->ReleaseBuffer();
return TRUE;
}
/*---------------------------------------------------------------------------
UtilCvtIpAddrToWstr
Description
Author: EricDav
---------------------------------------------------------------------------*/
BOOL
UtilCvtIpAddrToWstr
(
DHCP_IP_ADDRESS dhipa,
WCHAR * pwcszString,
INT cBuffCount
)
{
CHAR szString [ MAX_PATH ] ;
if ( cBuffCount > sizeof szString - 1 )
{
cBuffCount = sizeof szString - 1 ;
}
::UtilCvtIpAddrToString( dhipa, szString, cBuffCount );
#ifdef FE_SB
INT cch;
cch = ::MultiByteToWideChar(CP_OEMCP, MB_PRECOMPOSED, szString, -1, pwcszString, cBuffCount);
pwcszString[cch] = L'\0';
#else
INT cch = ::strlen( szString ) ;
//::mbstowcs( pwcszString, szString, cch ) ;
::MultiByteToWideChar(CP_OEMCP, MB_PRECOMPOSED, szString, cch, pwcszString, cBuffCount);
pwcszString[cch] = 0 ;
#endif
return TRUE ;
}
/*---------------------------------------------------------------------------
UtilDupIpAddrToWstr
Description
Author: EricDav
---------------------------------------------------------------------------*/
WCHAR *
UtilDupIpAddrToWstr
(
DHCP_IP_ADDRESS dhipa
)
{
WCHAR wcszString [ MAX_PATH ] ;
if ( ! ::UtilCvtIpAddrToWstr( dhipa, wcszString, ( sizeof ( wcszString ) / sizeof( WCHAR ) ) ) )
{
return NULL ;
}
return ::UtilWcstrDup( wcszString ) ;
}
/*---------------------------------------------------------------------------
validateNetbiosName
Simplistic routine to check to see if the given name is viable
as a NetBIOS name.
Author: EricDav
---------------------------------------------------------------------------*/
static BOOL
validateNetbiosName
(
const CHAR * pchName
)
{
INT nChars = ::strlen( pchName ) ;
if ( nChars > MAX_COMPUTERNAME_LENGTH || nChars == 0 )
{
return FALSE ;
}
for ( ; *pchName ; pchName++ )
{
if ( *pchName == '.' )
{
break ;
}
}
return *pchName == 0 ;
}
/*---------------------------------------------------------------------------
UtilGetHostInfo
Description
Author: EricDav
---------------------------------------------------------------------------*/
DWORD
UtilGetHostInfo
(
DHCP_IP_ADDRESS dhipa,
DHC_HOST_INFO_STRUCT * pdhsrvi
)
{
ZeroMemory(pdhsrvi, sizeof(DHC_HOST_INFO_STRUCT));
pdhsrvi->_dhipa = dhipa ;
//
// Call the Winsock API to get host name and alias information.
//
u_long ulAddrInNetOrder = ::htonl( (u_long) dhipa ) ;
HOSTENT * pHostInfo = ::gethostbyaddr( (CHAR *) & ulAddrInNetOrder,
sizeof ulAddrInNetOrder,
PF_INET ) ;
if ( pHostInfo == NULL )
{
return ::WSAGetLastError();
}
CHAR * * ppchAlias = pHostInfo->h_aliases ;
//
// Check and copy the host name.
//
if ( sizeof (pdhsrvi->_chNetbiosName) <= ::strlen( pHostInfo->h_name ) )
{
return ERROR_INVALID_NAME ;
}
ZeroMemory(pdhsrvi->_chNetbiosName, sizeof(pdhsrvi->_chNetbiosName));
::MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
pHostInfo->h_name,
lstrlenA(pHostInfo->h_name),
pdhsrvi->_chNetbiosName,
sizeof(pdhsrvi->_chNetbiosName));
// remove any periods at the end
while (pdhsrvi->_chHostName[lstrlen(pdhsrvi->_chNetbiosName) - 1] == '.')
{
pdhsrvi->_chHostName[lstrlen(pdhsrvi->_chNetbiosName) - 1] = 0;
}
// gethostbyaddr is returning the hostname only in some cases.
// Make another call to get the fqdn
CString strTemp = pdhsrvi->_chNetbiosName;
if (strTemp.Find('.') == -1)
{
// this is not a FQDN
strTemp.Empty();
UtilGetHostAddressFQDN(pdhsrvi->_chNetbiosName, &strTemp, &dhipa);
}
// copy the data into the buffer
strTemp.MakeLower();
memset(pdhsrvi->_chHostName, 0, sizeof(pdhsrvi->_chHostName));
lstrcpy(pdhsrvi->_chHostName, strTemp);
//
// Find the first acceptable NetBIOS name among the aliases;
// i.e., the first name without a period
//
/*
for ( ; *ppchAlias ; ppchAlias++ )
{
if ( validateNetbiosName( *ppchAlias ) )
{
break ;
}
}
//
// Empty the NetBIOS name in case we didn't get one.
//
pdhsrvi->_chNetbiosName[0] = 0 ;
if ( *ppchAlias )
{
//
// We found a usable name; copy it to output structure.
//
::MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
*ppchAlias,
lstrlenA(*ppchAlias),
pdhsrvi->_chNetbiosName,
sizeof(pdhsrvi->_chNetbiosName));
}
*/
return NOERROR ;
}
/*---------------------------------------------------------------------------
addrFromHostent
Description
Author: EricDav
---------------------------------------------------------------------------*/
static DHCP_IP_ADDRESS
addrFromHostent
(
const HOSTENT * pHostent,
INT index = 0
)
{
return (DHCP_IP_ADDRESS) ::ntohl( *((u_long *) pHostent->h_addr_list[index]) ) ;
}
/*---------------------------------------------------------------------------
UtilGetHostAddress
Description
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
UtilGetHostAddressFQDN
(
LPCTSTR pszHostName,
CString * pstrFQDN,
DHCP_IP_ADDRESS * pdhipa
)
{
HRESULT hr = NOERROR;
CHAR szString [ MAX_PATH ] = {0};
::WideCharToMultiByte(CP_ACP, 0, pszHostName, -1, szString, sizeof(szString), NULL, NULL);
HOSTENT * pHostent = ::gethostbyname( szString ) ;
if ( pHostent )
{
*pdhipa = addrFromHostent( pHostent ) ;
LPTSTR pName = pstrFQDN->GetBuffer(DHCPSNAP_STRING_MAX * 2);
ZeroMemory(pName, DHCPSNAP_STRING_MAX * 2);
::MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
pHostent->h_name,
strlen(pHostent->h_name),
pName,
DHCPSNAP_STRING_MAX * 2);
pstrFQDN->ReleaseBuffer();
}
else
{
hr = ::WSAGetLastError() ;
}
return hr;
}
/*---------------------------------------------------------------------------
UtilGetHostAddress
Description
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
UtilGetHostAddress
(
LPCTSTR pszHostName,
DHCP_IP_ADDRESS * pdhipa
)
{
HRESULT hr = NOERROR;
CHAR szString [ MAX_PATH ] = {0};
::WideCharToMultiByte(CP_ACP, 0, pszHostName, -1, szString, sizeof(szString), NULL, NULL);
HOSTENT * pHostent = ::gethostbyname( szString ) ;
if ( pHostent )
{
*pdhipa = addrFromHostent( pHostent ) ;
}
else
{
hr = ::WSAGetLastError() ;
}
return hr ;
}
/*---------------------------------------------------------------------------
UtilGetLocalHostAddress
Description
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
UtilGetLocalHostAddress
(
DHCP_IP_ADDRESS * pdhipa
)
{
CHAR chHostName [ DHCPSNAP_STRING_MAX ] ;
HRESULT hr = NOERROR;
if ( ::gethostname( chHostName, sizeof chHostName ) == 0 )
{
CString strTemp = chHostName;
hr = ::UtilGetHostAddress( strTemp, pdhipa ) ;
}
else
{
//err = ::WSAGetLastError() ;
hr = E_FAIL;
}
return hr;
}
/*---------------------------------------------------------------------------
UtilGetLocalHostName
Description
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
UtilGetLocalHostName
(
CString * pstrName
)
{
CHAR chHostName [ DHCPSNAP_STRING_MAX * 2 ] ;
HRESULT hr = NOERROR;
if ( ::gethostname( chHostName, sizeof (chHostName) ) == 0 )
{
LPTSTR pName = pstrName->GetBuffer(DHCPSNAP_STRING_MAX * 2);
ZeroMemory(pName, DHCPSNAP_STRING_MAX * 2);
::MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
chHostName,
strlen(chHostName),
pName,
DHCPSNAP_STRING_MAX * 2);
pstrName->ReleaseBuffer();
}
else
{
//err = ::WSAGetLastError() ;
hr = E_FAIL;
}
return hr;
}
/*---------------------------------------------------------------------------
UtilGetNetbiosAddress
Description
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
UtilGetNetbiosAddress
(
LPCTSTR pszNetbiosName,
DHCP_IP_ADDRESS * pdhipa
)
{
//
// This code presupposes that the "hosts" file maps NetBIOS names
// and DNS names identically. THIS IS NOT A VALID SUPPOSITION, but is
// expedient for the on-campus work.
//
return UtilGetHostAddress( pszNetbiosName, pdhipa ) ;
}
/*---------------------------------------------------------------------------
UtilWcstrDup
"strdup" a WC string
Author: EricDav
---------------------------------------------------------------------------*/
WCHAR *
UtilWcstrDup
(
const WCHAR * pwcsz,
INT * pccwLength
)
{
WCHAR szwchEmpty [2] = { 0 } ;
if ( pwcsz == NULL )
{
pwcsz = szwchEmpty ;
}
INT ccw = ::wcslen( pwcsz );
WCHAR * pwcszNew = new WCHAR [ ccw + 1 ] ;
if ( pwcszNew == NULL )
{
return NULL ;
}
::wcscpy( pwcszNew, pwcsz ) ;
if ( pccwLength )
{
*pccwLength = ccw ;
}
return pwcszNew ;
}
/*---------------------------------------------------------------------------
UtilWcstrDup
Description
Author: EricDav
---------------------------------------------------------------------------*/
WCHAR *
UtilWcstrDup
(
const CHAR * psz,
INT * pccwLength
)
{
INT ccw = ::strlen( psz ) ;
WCHAR * pwcszNew = new WCHAR [ ccw + 1 ] ;
if ( pwcszNew == NULL )
{
return NULL ;
}
//::mbstowcs( pwcszNew, psz, ccw ) ;
#ifdef FE_SB
ccw = ::MultiByteToWideChar(CP_OEMCP, MB_PRECOMPOSED, psz, -1, pwcszNew, ccw+1);
if ( pccwLength )
{
*pccwLength = ccw ;
}
pwcszNew[ccw] = L'\0';
#else
::MultiByteToWideChar(CP_OEMCP, MB_PRECOMPOSED, psz, ccw, pwcszNew, ccw+1);
if ( pccwLength )
{
*pccwLength = ccw ;
}
pwcszNew[ccw] = 0 ;
#endif
return pwcszNew ;
}
/*---------------------------------------------------------------------------
UtilCstrDup
Description
Author: EricDav
---------------------------------------------------------------------------*/
CHAR *
UtilCstrDup
(
const WCHAR * pwcsz
)
{
INT ccw = ::wcslen( pwcsz ),
cch = (ccw + 1) * 2 ;
CHAR * psz = new CHAR [ cch ] ;
if ( psz == NULL )
{
return NULL ;
}
//::wcstombs( psz, pwcsz, cch ) ;
::WideCharToMultiByte( CP_OEMCP, WC_COMPOSITECHECK, pwcsz, -1, psz, cch, NULL, NULL ) ;
return psz ;
}
/*---------------------------------------------------------------------------
UtilCstrDup
Description
Author: EricDav
---------------------------------------------------------------------------*/
CHAR *
UtilCstrDup
(
const CHAR * psz
)
{
CHAR * pszNew = new CHAR [ ::strlen( psz ) + 1 ] ;
if ( pszNew == NULL )
{
return NULL ;
}
::strcpy( pszNew, psz ) ;
return pszNew ;
}
/*---------------------------------------------------------------------------
cvtWcStrToStr
Description
Author: EricDav
---------------------------------------------------------------------------*/
static HRESULT
cvtWcStrToStr
(
char * psz,
size_t cch,
const WCHAR * pwcsz,
size_t cwch
)
{
#ifdef FE_SB
int cchResult = ::WideCharToMultiByte( CP_ACP, 0,
pwcsz, -1,
psz, cch,
NULL, NULL ) ;
#else
int cchResult = ::WideCharToMultiByte( CP_ACP, 0,
pwcsz, cwch,
psz, cwch,
NULL, NULL ) ;
#endif
psz[ cchResult ] = 0 ;
//return cchResult ? 0 : ::GetLastError();
return cchResult ? NOERROR : E_FAIL;
}
wchar_t rgchHex[] = L"00112233445566778899aAbBcCdDeEfF";
/*---------------------------------------------------------------------------
UtilCvtHexString
Convert a string of hex digits to a byte array
Author: EricDav
---------------------------------------------------------------------------*/
BOOL
UtilCvtHexString
(
LPCTSTR pszNum,
CByteArray & cByte
)
{
int i = 0,
iDig,
iByte,
cDig ;
int iBase = 16 ;
BOOL bByteBoundary ;
//
// Skip leading blanks
//
for ( ; *pszNum == L' ' ; pszNum++ ) ;
//
// Skip a leading zero
//
if ( *pszNum == L'0' )
{
pszNum++ ;
}
//
// Look for hexadecimal marker
//
if ( *pszNum == L'x' || *pszNum == L'X' )
{
pszNum++ ;
}
bByteBoundary = ::wcslen( pszNum ) % 2 ;
for ( iByte = cDig = 0 ; *pszNum ; )
{
wchar_t * pszDig = ::wcschr( rgchHex, *pszNum++ ) ;
if ( pszDig == NULL )
{
break;
// return FALSE;
}
iDig = ((int) (pszDig - rgchHex)) / 2 ;
if ( iDig >= iBase )
{
break ;
// return FALSE;
}
iByte = (iByte * 16) + iDig ;
if ( bByteBoundary )
{
cByte.SetAtGrow( cDig++, (UCHAR) iByte ) ;
iByte = 0 ;
}
bByteBoundary = ! bByteBoundary ;
}
cByte.SetSize( cDig ) ;
//
// Return TRUE if we reached the end of the string.
//
return *pszNum == 0 ;
}
/*---------------------------------------------------------------------------
UtilCvtByteArrayToString
Description
Author: EricDav
---------------------------------------------------------------------------*/
BOOL
UtilCvtByteArrayToString
(
const CByteArray & abAddr,
CString & str
)
{
int i ;
DWORD err = 0 ;
// TRY
{
str.Empty() ;
//
// The hex conversion string has two characters per nibble,
// to allow for upper case.
//
for ( i = 0 ; i < abAddr.GetSize() ; i++ )
{
int i1 = ((abAddr.GetAt(i) & 0xF0) >> 4) * 2 ,
i2 = (abAddr.GetAt(i) & 0x0F) * 2 ;
str += rgchHex[ i1 ] ;
str += rgchHex[ i2 ] ;
}
}
// CATCH(CMemoryException, pMemException)
// if ( pMemException )
// {
// str.Empty() ;
// err = 1;
// }
return err == 0 ;
}
/*---------------------------------------------------------------------------
PchParseUnicodeString
Parse a unicode string by copying its content
into a CString object.
The parsing ends when the null-terminator ('\0')is
reached or the comma (',') is reached.
Return pointer to the character where parsing
ended('\0') or (',')
Author: EricDav
---------------------------------------------------------------------------*/
WCHAR *
PchParseUnicodeString
(
CONST WCHAR * szwString, // IN: String to parse
DWORD dwLength,
CString& rString // OUT: Content of the substring
)
{
ASSERT(szwString != NULL);
ASSERT(BOOT_FILE_STRING_DELIMITER_W == L','); // Just in case
WCHAR szwBufferT[1024]; // Temporary buffer
WCHAR * pchwDst = szwBufferT;
while (*szwString != L'\0')
{
if (*szwString == BOOT_FILE_STRING_DELIMITER_W)
break;
*pchwDst++ = *szwString++;
if ((DWORD) (pchwDst - szwBufferT) > dwLength)
{
// we've gone past the end of our buffer!! ouch
Panic0("PchParseUnicodeString: Gone past end of buffer");
break;
}
ASSERT((pchwDst - szwBufferT < sizeof(szwBufferT)) && "Buffer overflow");
} // while
*pchwDst = L'\0';
rString = szwBufferT; // Copy the string into the CString object
return const_cast<WCHAR *>(szwString);
} // PchParseUnicodeString()
/////////////////////////////////////////////////////////////////////////////
// FGetCtrlDWordValue()
//
// Return a 32-bit unsigned integer from an edit control
//
// This function is like GetDlgItemInt() except it accepts hexadecimal values,
// has range checking and/or overflow checking.
// If value is out of range, function will display a friendly message and will
// set the focus to control.
// Range: dwMin to dwMax inclusive
// - If both dwMin and dwMax are zero, no range checking is performed
// - Return TRUE if successful, otherwise FALSE
// - On error, pdwValue remains unchanged.
//
BOOL FGetCtrlDWordValue(HWND hwndEdit, DWORD * pdwValue, DWORD dwMin, DWORD dwMax)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
TCHAR szT[256];
DWORD dwResult;
ASSERT(IsWindow(hwndEdit));
ASSERT(pdwValue);
ASSERT(dwMin <= dwMax);
::GetWindowText(hwndEdit, szT, (sizeof(szT)-1)/sizeof(TCHAR));
if (!FCvtAsciiToInteger(szT, OUT &dwResult))
{
// Syntax Error and/or integer overflow
goto Error;
}
if ((dwMin == 0) && (dwMax == 0))
goto Success;
if ((dwResult < dwMin) || (dwResult > dwMax))
Error:
{
CString strBuffer;
strBuffer.LoadString(IDS_ERR_INVALID_INTEGER);
//::LoadString(theApp.m_hInstance, IDS_ERR_INVALID_INTEGER, szBuffer, sizeof(szBuffer)-1);
::wsprintf (szT, strBuffer, (int)dwMin, (int)dwMax);
ASSERT(wcslen(szT)<sizeof(szT));
::SetFocus(hwndEdit);
::AfxMessageBox(szT);
::SetFocus(hwndEdit);
return FALSE;
}
Success:
*pdwValue = dwResult;
return TRUE;
} // FGetCtrlDWordValue
/////////////////////////////////////////////////////////////////////////////
//
// Convert a string to a binary integer
// - String is allowed to be decimal or hexadecimal
// - Minus sign is not allowed
// If successful, set *pdwValue to the integer and return TRUE.
// If not successful (overflow or illegal integer) return FALSE.
//
BOOL FCvtAsciiToInteger
(
IN const TCHAR * pszNum,
OUT DWORD * pdwValue
)
{
DWORD dwResult = 0;
DWORD dwResultPrev = 0;
int iBase = 10; // Assume a decimal base
ASSERT(pszNum != NULL);
ASSERT(pdwValue != NULL);
while (*pszNum == ' ' || *pszNum == '0') // Skip leading blanks and/or zeroes
pszNum++;
if (*pszNum == 'x' || *pszNum == 'X') // Check if we are using hexadecimal base
{
iBase = 16;
pszNum++;
}
while (*pszNum)
{
int iDigit;
// Search the character in the hexadecimal string
TCHAR const * const pchDigit = wcschr(rgchHex, *pszNum);
if (!pchDigit)
{
// Character is not found
return(FALSE);
}
iDigit = ((int) (pchDigit - rgchHex)) >> 1;
if (iDigit >= iBase)
{
// Hexadecimal character in a decimal integer
return(FALSE);
}
dwResultPrev = dwResult;
dwResult *= iBase;
dwResult += iDigit;
if (dwResult < dwResultPrev)
{
// Integer Overflow
return(FALSE);
}
pszNum++; // Parse the next character
} // while
// Convertion has been successful
*pdwValue = dwResult;
return(TRUE);
} // FCvtAsciiToInteger
void UtilConvertStringToDwordDword(LPCTSTR pszString, DWORD_DWORD * pdwdw)
{
BOOL bHex = FALSE;
while (*pszString == ' ' || *pszString == '0') // Skip leading blanks and/or zeroes
pszString++;
if (*pszString == 'x' || *pszString == 'X') // Check if we are using hexadecimal base
{
bHex = TRUE;
pszString++;
}
CString str = pszString;
int j = str.GetLength();
if (bHex)
{
TCHAR sz[] = _T("0000000000000000");
TCHAR *pch;
::_tcscpy(sz + 16 - j, (LPCTSTR)str);
pch = sz + 8;
::_stscanf(pch, _T("%08lX"), &pdwdw->DWord2);
*pch = '\0';
::_stscanf(sz, _T("%08lX"), &pdwdw->DWord1);
}
else
{
::_stscanf(pszString, _T("%I64u"), pdwdw);
// is this true on alpha as well? Processor dependant?
// an __int64 is dword swapped, so to get the correct value we want,
// swap the dwords in our struct
DWORD dwTemp = pdwdw->DWord2;
pdwdw->DWord2 = pdwdw->DWord1;
pdwdw->DWord1 = dwTemp;
}
}
void UtilConvertDwordDwordToString(DWORD_DWORD * pdwdw, CString * pstrString, BOOL bDecimal)
{
const TCHAR * pszDwordDwordMask = _T("0x%08lX%08lX");
TCHAR szNum [ STRING_LENGTH_MAX ] ;
if (bDecimal)
{
unsigned __int64 ui64;
// is this true on alpha as well? Processor dependant?
// an __int64 is dword swapped, so to get the correct value we want,
// swap the dwords in our struct
DWORD dwTemp = pdwdw->DWord2;
pdwdw->DWord2 = pdwdw->DWord1;
pdwdw->DWord1 = dwTemp;
memcpy (&ui64, pdwdw, sizeof(DWORD_DWORD));
_ui64tot(ui64, szNum, 10);
}
else
{
::wsprintf( szNum, pszDwordDwordMask, pdwdw->DWord1, pdwdw->DWord2 ) ;
}
*pstrString = szNum ;
}
// End of DHCPUTIL.CPP
Reference in a new issue Copy permalink