747 lines
19 KiB
C++
747 lines
19 KiB
C++
/*****************************************************************************\
|
|
* MODULE: genutil.c
|
|
*
|
|
* Various common routines used throughout the gen* files.
|
|
*
|
|
* routines
|
|
* --------
|
|
* genGetCurDir
|
|
* genGetWinDir
|
|
* genBuildFileName
|
|
* genFindChar
|
|
* genFindCharDiff
|
|
* genFindRChar
|
|
* genWCFromMB
|
|
* genMBFromWC
|
|
* genItoA
|
|
*
|
|
* genIsWin9X
|
|
* genIdxCliPlatform
|
|
* genStrCliCab
|
|
* genStrCliEnvironment
|
|
* genStrCliOverride
|
|
* genValCliArchitecture
|
|
* genIdxCliVersion
|
|
* genStrCliVersion
|
|
* genValSvrArchitecture
|
|
*
|
|
*
|
|
* Copyright (C) 1996-1997 Microsoft Corporation
|
|
* Copyright (C) 1996-1997 Hewlett Packard
|
|
*
|
|
* history:
|
|
* 22-Nov-1996 <chriswil> created.
|
|
*
|
|
\*****************************************************************************/
|
|
|
|
#include "pch.h"
|
|
|
|
/*****************************************************************************\
|
|
* genGetCurDir
|
|
*
|
|
* Returns string indicating current-directory.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR genGetCurDir(VOID)
|
|
{
|
|
DWORD cbSize;
|
|
LPTSTR lpszDir = NULL;
|
|
|
|
|
|
cbSize = GetCurrentDirectory(0, NULL);
|
|
|
|
if (cbSize && (lpszDir = (LPTSTR)genGAlloc((cbSize * sizeof(TCHAR)))))
|
|
GetCurrentDirectory(cbSize, lpszDir);
|
|
|
|
return lpszDir;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genGetWinDir
|
|
*
|
|
* Returns string indicating the windows-directory.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR genGetWinDir(VOID)
|
|
{
|
|
DWORD cbSize;
|
|
LPTSTR lpszDir = NULL;
|
|
|
|
|
|
cbSize = GetWindowsDirectory(NULL, 0);
|
|
|
|
if (cbSize && (lpszDir = (LPTSTR)genGAlloc((cbSize * sizeof(TCHAR)))))
|
|
GetWindowsDirectory(lpszDir, cbSize);
|
|
|
|
return lpszDir;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genBuildFileName
|
|
*
|
|
* Takes path, name, extension strings and builds a fully-qualified
|
|
* string representing the file. This can also be used to build other
|
|
* names.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR genBuildFileName(
|
|
LPCTSTR lpszPath,
|
|
LPCTSTR lpszName,
|
|
LPCTSTR lpszExt)
|
|
{
|
|
DWORD cch;
|
|
LPTSTR lpszFull;
|
|
|
|
|
|
// Calculate the size necessary to hold the full-path filename.
|
|
//
|
|
cch = lstrlen(g_szBkSlash);
|
|
cch += (lpszPath ? lstrlen(lpszPath) : 0);
|
|
cch += (lpszName ? lstrlen(lpszName) : 0);
|
|
cch += (lpszExt ? lstrlen(lpszExt) : 0);
|
|
|
|
|
|
if (lpszFull = (LPTSTR)genGAlloc(((cch + 1) * sizeof(TCHAR)))) {
|
|
|
|
if (lpszPath) {
|
|
|
|
if (lpszExt)
|
|
cch = wsprintf(lpszFull, TEXT("%s\\%s%s"), lpszPath, lpszName, lpszExt);
|
|
else
|
|
cch = wsprintf(lpszFull, TEXT("%s\\%s"), lpszPath, lpszName);
|
|
|
|
} else {
|
|
|
|
if (lpszExt)
|
|
cch = wsprintf(lpszFull, TEXT("%s%s"), lpszName, lpszExt);
|
|
else
|
|
cch = wsprintf(lpszFull, TEXT("%s"), lpszName);
|
|
}
|
|
}
|
|
|
|
return lpszFull;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genFindCharDiff
|
|
*
|
|
* This routine returns a pointer to the location in DST, where the characters
|
|
* cease to match.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR genFindCharDiff(
|
|
LPTSTR lpszDst,
|
|
LPTSTR lpszSrc)
|
|
{
|
|
LPTSTR lpszCS;
|
|
LPTSTR lpszCD;
|
|
|
|
|
|
CharLower(lpszSrc);
|
|
CharLower(lpszDst);
|
|
|
|
|
|
lpszCS = lpszSrc;
|
|
lpszCD = lpszDst;
|
|
|
|
while (*lpszCS == *lpszCD) {
|
|
lpszCD++;
|
|
lpszCS++;
|
|
}
|
|
|
|
return (*lpszCD ? lpszCD : NULL);
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genFindChar
|
|
*
|
|
* Searches for the first occurence of (cch) in a string.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR genFindChar(
|
|
LPTSTR lpszStr,
|
|
TCHAR cch)
|
|
{
|
|
if (lpszStr) {
|
|
|
|
while ((*lpszStr != cch) && (*lpszStr != TEXT('\0')))
|
|
lpszStr++;
|
|
|
|
if (((cch != TEXT('\0')) && (*lpszStr != TEXT('\0'))) || (cch == TEXT('\0')))
|
|
return lpszStr;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genFindRChar
|
|
*
|
|
* Searches for the first occurence of (cch) in a string in reverse order.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR genFindRChar(
|
|
LPTSTR lpszStr,
|
|
TCHAR cch)
|
|
{
|
|
int nLimit;
|
|
|
|
if (nLimit = lstrlen(lpszStr)) {
|
|
|
|
lpszStr += nLimit;
|
|
|
|
while ((*lpszStr != cch) && nLimit--)
|
|
lpszStr--;
|
|
|
|
if (nLimit >= 0)
|
|
return lpszStr;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genWCFromMB
|
|
*
|
|
* This routine returns a buffer of wide-character representation of a
|
|
* ansi string. The caller is responsible for freeing this pointer returned
|
|
* by this function.
|
|
*
|
|
\*****************************************************************************/
|
|
LPWSTR genWCFromMB(
|
|
LPCSTR lpszStr)
|
|
{
|
|
DWORD cbSize;
|
|
LPWSTR lpwszBuf = NULL;
|
|
|
|
|
|
cbSize = genMBtoWC(NULL, lpszStr, 0);
|
|
|
|
if (cbSize && (lpwszBuf = (LPWSTR)genGAlloc(cbSize)))
|
|
genMBtoWC(lpwszBuf, lpszStr, cbSize);
|
|
|
|
return lpwszBuf;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genTCFromMB
|
|
*
|
|
* This routine returns a buffer of tchar representation of a
|
|
* ansi string. The caller is responsible for freeing this pointer returned
|
|
* by this function.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR genTCFromMB(
|
|
LPCSTR lpszStr)
|
|
{
|
|
|
|
#ifdef UNICODE
|
|
|
|
return genWCFromMB(lpszStr);
|
|
|
|
#else
|
|
|
|
return genGAllocStr(lpszStr);
|
|
|
|
#endif
|
|
}
|
|
|
|
/*****************************************************************************\
|
|
* genTCFromWC
|
|
*
|
|
* This routine returns a buffer of tchar representation of a
|
|
* wide string. The caller is responsible for freeing this pointer returned
|
|
* by this function.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR genTCFromWC(
|
|
LPCWSTR lpszwStr)
|
|
{
|
|
|
|
#ifdef UNICODE
|
|
|
|
return genGAllocStr(lpszwStr);
|
|
|
|
#else
|
|
|
|
return genMBFromWC(lpszwStr);
|
|
|
|
#endif
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genMBFromWC
|
|
*
|
|
* This routine returns a buffer of byte-character representation of a
|
|
* wide-char string. The caller is responsible for freeing this pointer
|
|
* returned by this function.
|
|
*
|
|
\*****************************************************************************/
|
|
LPSTR genMBFromWC(
|
|
LPCWSTR lpwszStr)
|
|
{
|
|
DWORD cbSize;
|
|
LPSTR lpszBuf = NULL;
|
|
|
|
|
|
cbSize = genWCtoMB(NULL, lpwszStr, 0);
|
|
|
|
if (cbSize && (lpszBuf = (LPSTR)genGAlloc(cbSize)))
|
|
genWCtoMB(lpszBuf, lpwszStr, cbSize);
|
|
|
|
return lpszBuf;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genMBFromTC
|
|
*
|
|
* This routine returns a buffer of byte-character representation of a
|
|
* tchar string. The caller is responsible for freeing this pointer
|
|
* returned by this function.
|
|
*
|
|
\*****************************************************************************/
|
|
LPSTR genMBFromTC(
|
|
LPCTSTR lpszStr)
|
|
{
|
|
|
|
#ifdef UNICODE
|
|
|
|
return genMBFromWC(lpszStr);
|
|
|
|
#else
|
|
|
|
return genGAllocStr(lpszStr);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genItoA
|
|
*
|
|
* Convert integer to string.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR genItoA(
|
|
int nVal)
|
|
{
|
|
DWORD cch = 0;
|
|
LPTSTR lpszVal;
|
|
|
|
if (lpszVal = (LPTSTR)genGAlloc(INF_MIN_BUFFER))
|
|
cch = wsprintf(lpszVal, TEXT("%d"), nVal);
|
|
|
|
SPLASSERT((cch < INF_MIN_BUFFER));
|
|
|
|
return lpszVal;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* Client Platform Table.
|
|
*
|
|
* This table describes the various platforms/architectures. By refering
|
|
* to the index into the table, various platform information can be
|
|
* obtained.
|
|
*
|
|
* Members are as follows:
|
|
* a) CAB string. Used to denote the architecture in the cab-name.
|
|
* b) Environment string. Used to denote printer-environment.
|
|
* c) Platform string. Used for path override in setup api's.
|
|
* d) Architecture value. Used to denote platform of client.
|
|
*
|
|
\*****************************************************************************/
|
|
static PLTINFO s_PltTable[] = {
|
|
|
|
g_szCabX86, g_szEnvX86, g_szPltX86, PROCESSOR_ARCHITECTURE_INTEL, // IDX_X86
|
|
g_szCabMIP, g_szEnvMIP, g_szPltMIP, PROCESSOR_ARCHITECTURE_MIPS, // IDX_MIP
|
|
g_szCabAXP, g_szEnvAXP, g_szPltAXP, PROCESSOR_ARCHITECTURE_ALPHA, // IDX_AXP
|
|
g_szCabPPC, g_szEnvPPC, g_szPltPPC, PROCESSOR_ARCHITECTURE_PPC, // IDX_PPC
|
|
g_szCabW9X, g_szEnvW9X, g_szPltW9X, PROCESSOR_ARCHITECTURE_INTEL, // IDX_W9X
|
|
g_szCabI64, g_szEnvI64, g_szPltI64, PROCESSOR_ARCHITECTURE_IA64, // IDX_I64
|
|
g_szCabAMD64, g_szEnvAMD64, g_szPltAMD64, PROCESSOR_ARCHITECTURE_AMD64 // IDX_AMD64
|
|
};
|
|
|
|
|
|
/*****************************************************************************\
|
|
* Client Version Table.
|
|
*
|
|
* This table describes the spooler-versions which the client can request
|
|
* drivers for.
|
|
*
|
|
\*****************************************************************************/
|
|
static LPCTSTR s_VerTable[] = {
|
|
|
|
TEXT("\\0"), // Win NT 3.1 - IDX_SPLVER_0
|
|
TEXT("\\1"), // Win NT 3.51 - IDX_SPLVER_1
|
|
TEXT("\\2"), // Win NT 4.0 - IDX_SPLVER_2
|
|
TEXT("\\3") // Win NT 5.0 - IDX_SPLVER_3
|
|
};
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genIdxCliPlatform
|
|
*
|
|
* This routine returns a platform-index into the s_PltTable. The caller
|
|
* can use this index to refer to platform specific information about the
|
|
* client.
|
|
*
|
|
\*****************************************************************************/
|
|
DWORD genIdxCliPlatform(
|
|
DWORD dwCliInfo)
|
|
{
|
|
DWORD idx;
|
|
DWORD cEnv;
|
|
WORD wArch;
|
|
|
|
|
|
// If the platform is win9X, then set the index appropriately. Otherwise,
|
|
// continue on to determine the correct architecture for the NT case.
|
|
//
|
|
if (webGetOSPlatform(dwCliInfo) == VER_PLATFORM_WIN32_WINDOWS)
|
|
return IDX_W9X;
|
|
|
|
|
|
// Otherwise, the client is an NT platform.
|
|
//
|
|
cEnv = sizeof(s_PltTable) / sizeof(s_PltTable[0]);
|
|
wArch = webGetOSArch(dwCliInfo);
|
|
|
|
|
|
// Look for matching client-info for the NT case. The architecture
|
|
// values will match up in this case.
|
|
//
|
|
for (idx = 0; idx < cEnv; idx++) {
|
|
|
|
if (wArch == s_PltTable[idx].wArch)
|
|
return idx;
|
|
}
|
|
|
|
return IDX_UNKNOWN;
|
|
|
|
}
|
|
|
|
/*****************************************************************************\
|
|
* genStrCliCab
|
|
*
|
|
* This routine returns a static-string representing the client-cabname.
|
|
*
|
|
\*****************************************************************************/
|
|
LPCTSTR genStrCliCab(
|
|
DWORD idxPlt)
|
|
{
|
|
return (idxPlt < (sizeof(s_PltTable) / sizeof(s_PltTable[0])) ? s_PltTable[idxPlt].lpszCab : NULL);
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genStrCliEnvironment
|
|
*
|
|
* This routine returns a static-string representing the client-platform. This
|
|
* string is used by the spooler API calls to specify environment.
|
|
*
|
|
\*****************************************************************************/
|
|
LPCTSTR genStrCliEnvironment(
|
|
DWORD idxPlt)
|
|
{
|
|
return (idxPlt < (sizeof(s_PltTable) / sizeof(s_PltTable[0])) ? s_PltTable[idxPlt].lpszEnv : NULL);
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genStrCliOverride
|
|
*
|
|
* This routines returns a static-string representing the client-path-override
|
|
* for the setup API.
|
|
*
|
|
\*****************************************************************************/
|
|
LPCTSTR genStrCliOverride(
|
|
DWORD idxPlt)
|
|
{
|
|
return (idxPlt < (sizeof(s_PltTable) / sizeof(s_PltTable[0])) ? s_PltTable[idxPlt].lpszPlt : NULL);
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genValCliArchitecture
|
|
*
|
|
* Returns the architecture platform of the client.
|
|
*
|
|
\*****************************************************************************/
|
|
WORD genValCliArchitecture(
|
|
DWORD idxPlt)
|
|
{
|
|
return (idxPlt < (sizeof(s_PltTable) / sizeof(s_PltTable[0])) ? s_PltTable[idxPlt].wArch : PROCESSOR_ARCHITECTURE_UNKNOWN);
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genValSvrArchitecture
|
|
*
|
|
* Returns the architecture platform of the server. The current architecture
|
|
* running this dll.
|
|
*
|
|
\*****************************************************************************/
|
|
WORD genValSvrArchitecture(VOID)
|
|
{
|
|
DWORD idxEnv;
|
|
|
|
#if defined(_X86_)
|
|
|
|
idxEnv = IDX_X86;
|
|
|
|
#elif defined(_AMD64_)
|
|
|
|
idxEnv = IDX_AMD64;
|
|
|
|
#elif defined(_IA64_)
|
|
|
|
idxEnv = IDX_I64;
|
|
|
|
#endif
|
|
|
|
return genValCliArchitecture(idxEnv);
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genIdxCliVersion
|
|
*
|
|
* This routine returns an index into the s_VerTable. The caller can refer
|
|
* to this index for the client-version information.
|
|
*
|
|
\*****************************************************************************/
|
|
DWORD genIdxCliVersion(
|
|
DWORD dwCliInfo)
|
|
{
|
|
DWORD dwPlt = webGetOSPlatform(dwCliInfo);
|
|
DWORD dwMaj = webGetOSMajorVer(dwCliInfo);
|
|
DWORD dwMin = webGetOSMinorVer(dwCliInfo);
|
|
|
|
|
|
if (dwMaj == 5)
|
|
return IDX_SPLVER_3;
|
|
|
|
if ((dwMaj == 4) && (dwPlt == VER_PLATFORM_WIN32_NT))
|
|
return IDX_SPLVER_2;
|
|
|
|
if ((dwMaj == 3) && (dwMin == 51))
|
|
return IDX_SPLVER_1;
|
|
|
|
if ((dwMaj == 4) && (dwPlt == VER_PLATFORM_WIN32_WINDOWS))
|
|
return IDX_SPLVER_0;
|
|
|
|
if ((dwMaj == 3) && (dwMin == 1))
|
|
return IDX_SPLVER_0;
|
|
|
|
return IDX_UNKNOWN;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genStrCliVersion
|
|
*
|
|
* Returns a string representing the spooler-version directory. This is
|
|
* the relative directory off the system32\spool\drivers\*\ path that contains
|
|
* the drivers.
|
|
*
|
|
\*****************************************************************************/
|
|
LPCTSTR genStrCliVersion(
|
|
DWORD idxVer)
|
|
{
|
|
return (idxVer < (sizeof(s_VerTable) / sizeof(s_VerTable[0])) ? s_VerTable[idxVer] : NULL);
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genIdxFromStrVersion
|
|
*
|
|
* Returns an index that matches the client-version-string.
|
|
*
|
|
\*****************************************************************************/
|
|
DWORD genIdxFromStrVersion(
|
|
LPCTSTR lpszVer)
|
|
{
|
|
DWORD idx;
|
|
DWORD cVer;
|
|
|
|
|
|
cVer = sizeof(s_VerTable) / sizeof(s_VerTable[0]);
|
|
|
|
for (idx = 0; idx < cVer; idx++) {
|
|
|
|
if (lstrcmpi(lpszVer, s_VerTable[idx]) == 0)
|
|
return idx;
|
|
}
|
|
|
|
return IDX_UNKNOWN;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genUpdIPAddr
|
|
*
|
|
* Updates the registry with the current IP-Addr of this machine. If there
|
|
* is already an entry in the registry and it's different than the one
|
|
* currently established for the machine, then we return FALSE, and update
|
|
* the entry.
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL genUpdIPAddr(VOID)
|
|
{
|
|
HKEY hKey;
|
|
LRESULT lRet;
|
|
LPSTR lpszCmp;
|
|
DWORD cbData;
|
|
DWORD dwIpCmp;
|
|
DWORD dwIpReg;
|
|
DWORD dwVal;
|
|
BOOL bRet = TRUE;
|
|
|
|
|
|
lRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
g_szPrtReg,
|
|
0,
|
|
KEY_READ | KEY_WRITE,
|
|
&hKey);
|
|
|
|
if (lRet == ERROR_SUCCESS) {
|
|
|
|
if (lpszCmp = genMBFromWC(g_szHttpServerName)) {
|
|
|
|
// Get the IP-Addr associated with this machine.
|
|
//
|
|
dwIpCmp = GetIPAddr(lpszCmp);
|
|
|
|
|
|
// Setup our registry-information so get/set a value.
|
|
//
|
|
dwVal = REG_DWORD;
|
|
cbData = sizeof(DWORD);
|
|
|
|
|
|
// Get what we already have stored there. If no value exists,
|
|
// the write it out.
|
|
//
|
|
lRet = RegQueryValueEx(hKey,
|
|
g_szIpAddr,
|
|
NULL,
|
|
&dwVal,
|
|
(LPBYTE)&dwIpReg,
|
|
&cbData);
|
|
|
|
if ((lRet != ERROR_SUCCESS) || (dwIpReg != dwIpCmp)) {
|
|
|
|
bRet = FALSE;
|
|
|
|
RegSetValueEx(hKey,
|
|
g_szIpAddr,
|
|
0,
|
|
REG_DWORD,
|
|
(LPBYTE)&dwIpCmp,
|
|
cbData);
|
|
}
|
|
|
|
genGFree(lpszCmp, genGSize(lpszCmp));
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genFrnName
|
|
*
|
|
* Returns a cluster-capable friendly-name.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR genFrnName(
|
|
LPCTSTR lpszFrnName)
|
|
{
|
|
DWORD cbSize;
|
|
LPTSTR lpszName = NULL;
|
|
|
|
|
|
// Calc size for friendly-name.
|
|
//
|
|
cbSize = lstrlen(lpszFrnName) + lstrlen(g_szPrintServerName) + 6;
|
|
|
|
|
|
// Build it.
|
|
//
|
|
if (lpszName = (LPTSTR)genGAlloc(cbSize * sizeof(TCHAR)))
|
|
wsprintf(lpszName, TEXT("\\\\%s\\%s"), g_szPrintServerName, lpszFrnName);
|
|
|
|
return lpszName;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* genChkSum (Local Routine)
|
|
*
|
|
* This routine checksums a string into a WORD value.
|
|
*
|
|
\*****************************************************************************/
|
|
|
|
#define CRC_HI(wHi) (((wHi << 1) | (wHi & 0x8000)) ? 0x0001 : 0)
|
|
#define CRC_LO(wLo) (((wLo >> 1) | (wLo & 0x0001)) ? 0x8000 : 0)
|
|
|
|
WORD genChkSum(
|
|
LPCTSTR lpszStr)
|
|
{
|
|
WORD wMask;
|
|
DWORD idx;
|
|
DWORD cLoop;
|
|
DWORD cbStr;
|
|
WORD wHi = 0;
|
|
WORD wLo = 0;
|
|
WORD wChkSum = 0;
|
|
|
|
|
|
if (lpszStr && (cbStr = lstrlen(lpszStr))) {
|
|
|
|
// Loop through the bytes (in WORD increments). This is an
|
|
// optimized method in cyclying through bits.
|
|
//
|
|
cLoop = (cbStr / sizeof(WORD));
|
|
|
|
for (idx = 0, wLo = 0, wHi = 0, wChkSum = 0; idx < cLoop; idx++) {
|
|
|
|
wChkSum += *(((PWORD)lpszStr) + idx);
|
|
|
|
wHi = CRC_HI(wHi) ^ wChkSum;
|
|
wLo = CRC_LO(wLo) ^ wChkSum;
|
|
}
|
|
|
|
|
|
// If there's any extra bytes left over, then include that
|
|
// in the checksum. Mask off any bytes that should be
|
|
// excluded from the checksum.
|
|
//
|
|
if (cbStr & 3) {
|
|
|
|
wMask = ((WORD)-1 >> ((sizeof(WORD) - (cbStr & 3)) * 8));
|
|
|
|
wChkSum += ((*((PWORD)lpszStr + cLoop)) & wMask);
|
|
|
|
wHi = CRC_HI(wHi) ^ wChkSum;
|
|
wLo = CRC_LO(wLo) ^ wChkSum;
|
|
}
|
|
}
|
|
|
|
return (wChkSum + wHi + wLo);
|
|
}
|