Changeset 21353 for trunk/src

Timestamp:

Feb 21, 2010, 5:30:47 PM (16 years ago)

Author:

rlwalsh

Message:

eliminate VACPP warning & info msgs - see Ticket #1

Location:

trunk/src/advapi32

Files:

• crypt.c (modified) (22 diffs)
• crypt.h (modified) (1 diff)
• registry.c (modified) (4 diffs)
• security.c (modified) (2 diffs)

trunk/src/advapi32/crypt.c

@@ -200 +200 @@
 
 #define CRYPT_GetProvFunc(name) \
-        if ( !(provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)) ) goto error
+        if ( !(provider->pFuncs->p##name = (fn##name *)GetProcAddress(provider->hModule, #name)) ) goto error
 #define CRYPT_GetProvFuncOpt(name) \
-        provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)
+        provider->pFuncs->p##name = (fn##name *)GetProcAddress(provider->hModule, #name)
 static PCRYPTPROV CRYPT_LoadProvider(PCWSTR pImage)
 {
@@ -208 +208 @@
         DWORD errorcode = ERROR_NOT_ENOUGH_MEMORY;
 
-        if ( !(provider = CRYPT_Alloc(sizeof(CRYPTPROV))) ) goto error;
-        if ( !(provider->pFuncs = CRYPT_Alloc(sizeof(PROVFUNCS))) ) goto error;
-        if ( !(provider->pVTable = CRYPT_Alloc(sizeof(VTableProvStruc))) ) goto error;
+        if ( !(provider = (PCRYPTPROV)CRYPT_Alloc(sizeof(CRYPTPROV))) ) goto error;
+        if ( !(provider->pFuncs = (PPROVFUNCS)CRYPT_Alloc(sizeof(PROVFUNCS))) ) goto error;
+        if ( !(provider->pVTable = (PVTableProvStruc)CRYPT_Alloc(sizeof(VTableProvStruc))) ) goto error;
         if ( !(provider->hModule = LoadLibraryW(pImage)) )
         {
@@ -325 +325 @@
                                              uuid.Data4[6], uuid.Data4[7] );
                                     RegSetValueExW(key, machineGuidW, 0, REG_SZ,
-                                                   (const BYTE *)buf,
+                                                   (BYTE *)buf,
                                                    (lstrlenW(buf)+1)*sizeof(WCHAR));
                                 }
@@ -417 +417 @@
                         goto error;
                 }
-                if(!(provname = CRYPT_Alloc(len)))
+                if(!(provname = (PWSTR)CRYPT_Alloc(len)))
                 {
                         RegCloseKey(key);
@@ -433 +433 @@
                 RegCloseKey(key);
         } else {
-                if ( !(provname = CRYPT_Alloc((strlenW(pszProvider) +1)*sizeof(WCHAR))) )
+                if ( !(provname = (PWSTR)CRYPT_Alloc((strlenW(pszProvider) +1)*sizeof(WCHAR))) )
                 {
                         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -471 +471 @@
                 goto error;
         }
-        if (!(temp = CRYPT_Alloc(len)))
+        if (!(temp = (PWSTR)CRYPT_Alloc(len)))
         {
                 RegCloseKey(key);
@@ -487 +487 @@
         RegCloseKey(key);
         len = ExpandEnvironmentStringsW(temp, NULL, 0);
-        if ( !(imagepath = CRYPT_Alloc(len*sizeof(WCHAR))) )
+        if ( !(imagepath = (PWSTR)CRYPT_Alloc(len*sizeof(WCHAR))) )
         {
                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -660 +660 @@
 
         pProv->refcount--;
-        if (pProv->refcount <= 0) 
+        if (pProv->refcount == 0) 
         {
                 ret = pProv->pFuncs->pCPReleaseContext(pProv->hPrivate, dwFlags);
@@ -757 +757 @@
                 return FALSE;
         }
-        if ( !(hash = CRYPT_Alloc(sizeof(CRYPTHASH))) )
+        if ( !(hash = (PCRYPTHASH)CRYPT_Alloc(sizeof(CRYPTHASH))) )
         {
                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -851 +851 @@
                 return FALSE;
         }
-        if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
+        if ( !(key = (PCRYPTKEY)CRYPT_Alloc(sizeof(CRYPTKEY))) )
         {
                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -984 +984 @@
         }
 
-        if ( !(newhash = CRYPT_Alloc(sizeof(CRYPTHASH))) )
+        if ( !(newhash = (PCRYPTHASH)CRYPT_Alloc(sizeof(CRYPTHASH))) )
         {
                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -1037 +1037 @@
         }
 
-        if ( !(newkey = CRYPT_Alloc(sizeof(CRYPTKEY))) )
+        if ( !(newkey = (PCRYPTKEY)CRYPT_Alloc(sizeof(CRYPTKEY))) )
         {
                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -1159 +1159 @@
                                  NULL, NULL, NULL, NULL, NULL, NULL);
                 
-                if (!(provNameW = CRYPT_Alloc(*pcbProvName * sizeof(WCHAR))))
+                if (!(provNameW = (WCHAR *)CRYPT_Alloc(*pcbProvName * sizeof(WCHAR))))
                 {
                         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -1213 +1213 @@
         if(!CryptEnumProvidersW(dwIndex, pdwReserved, dwFlags, pdwProvType, NULL, &bufsize))
                 return FALSE;
-        if ( pszProvName && !(str = CRYPT_Alloc(bufsize)) )
+        if ( pszProvName && !(str = (PWSTR)CRYPT_Alloc(bufsize)) )
         {
                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -1296 +1296 @@
         }
         keylen++;
-        if ( !(keyname = CRYPT_Alloc(keylen*sizeof(WCHAR))) )
+        if ( !(keyname = (PWSTR)CRYPT_Alloc(keylen*sizeof(WCHAR))) )
         {
                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -1342 +1342 @@
         if(!CryptEnumProviderTypesW(dwIndex, pdwReserved, dwFlags, pdwProvType, NULL, &bufsize))
                 return FALSE;
-        if ( pszTypeName && !(str = CRYPT_Alloc(bufsize)) )
+        if ( pszTypeName && !(str = (PWSTR)CRYPT_Alloc(bufsize)) )
         {
                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -1435 +1435 @@
                 return FALSE;
         }
-        if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
+        if ( !(key = (PCRYPTKEY)CRYPT_Alloc(sizeof(CRYPTKEY))) )
         {
                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -1540 +1540 @@
 
         CryptGetDefaultProviderW(dwProvType, pdwReserved, dwFlags, NULL, &bufsize);
-        if ( pszProvName && !(str = CRYPT_Alloc(bufsize)) )
+        if ( pszProvName && !(str = (PWSTR)CRYPT_Alloc(bufsize)) )
         {
                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -1703 +1703 @@
                 return FALSE;
         }
-        if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
+        if ( !(key = (PCRYPTKEY)CRYPT_Alloc(sizeof(CRYPTKEY))) )
         {
                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -1829 +1829 @@
         }
 
-        if ( !(importkey = CRYPT_Alloc(sizeof(CRYPTKEY))) )
+        if ( !(importkey = (PCRYPTKEY)CRYPT_Alloc(sizeof(CRYPTKEY))) )
         {
                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
@@ -2067 +2067 @@
         if (dwFlags & CRYPT_DELETE_DEFAULT)
         {
-                RegDeleteValueW(hTypeKey, nameW);
+        RegDeleteValueW(hTypeKey, (WCHAR*)nameW);
         }
         else
@@ -2087 +2087 @@
                 CRYPT_Free(keyname);
                 
-                if (RegSetValueExW(hTypeKey, nameW, 0, REG_SZ, (const BYTE *)pszProvName,
+                if (RegSetValueExW(hTypeKey, nameW, 0, REG_SZ, (BYTE *)pszProvName,
                         (strlenW(pszProvName) + 1)*sizeof(WCHAR)))
                 {

trunk/src/advapi32/crypt.h

@@ -28 +28 @@
 #include "wincrypt.h"
 
+/*RLW - created typedefs for each function to enable pointers
+  to be cast to the appropriate type when loaded using GetProcAddress()
+*/
+typedef BOOL (WINAPI fnCPAcquireContext)(HCRYPTPROV *phProv, LPSTR pszContainer, DWORD dwFlags, PVTableProvStruc pVTable);
+typedef BOOL (WINAPI fnCPCreateHash)(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DWORD dwFlags, HCRYPTHASH *phHash);
+typedef BOOL (WINAPI fnCPDecrypt)(HCRYPTPROV hProv, HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen);
+typedef BOOL (WINAPI fnCPDeriveKey)(HCRYPTPROV hProv, ALG_ID     Algid, HCRYPTHASH hBaseData, DWORD dwFlags, HCRYPTKEY *phKey);
+typedef BOOL (WINAPI fnCPDestroyHash)(HCRYPTPROV hProv, HCRYPTHASH hHash);
+typedef BOOL (WINAPI fnCPDestroyKey)(HCRYPTPROV hProv, HCRYPTKEY hKey);
+typedef BOOL (WINAPI fnCPDuplicateHash)(HCRYPTPROV hUID, HCRYPTHASH hHash, DWORD *pdwReserved, DWORD dwFlags, HCRYPTHASH *phHash);
+typedef BOOL (WINAPI fnCPDuplicateKey)(HCRYPTPROV hUID, HCRYPTKEY hKey, DWORD *pdwReserved, DWORD dwFlags, HCRYPTKEY *phKey);
+typedef BOOL (WINAPI fnCPEncrypt)(HCRYPTPROV hProv, HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen, DWORD dwBufLen);
+typedef BOOL (WINAPI fnCPExportKey)(HCRYPTPROV hProv, HCRYPTKEY hKey, HCRYPTKEY hPubKey, DWORD dwBlobType, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen);
+typedef BOOL (WINAPI fnCPGenKey)(HCRYPTPROV hProv, ALG_ID Algid, DWORD dwFlags, HCRYPTKEY *phKey);
+typedef BOOL (WINAPI fnCPGenRandom)(HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer);
+typedef BOOL (WINAPI fnCPGetHashParam)(HCRYPTPROV hProv, HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags);
+typedef BOOL (WINAPI fnCPGetKeyParam)(HCRYPTPROV hProv, HCRYPTKEY hKey, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags);
+typedef BOOL (WINAPI fnCPGetProvParam)(HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags);
+typedef BOOL (WINAPI fnCPGetUserKey)(HCRYPTPROV hProv, DWORD dwKeySpec, HCRYPTKEY *phUserKey);
+typedef BOOL (WINAPI fnCPHashData)(HCRYPTPROV hProv, HCRYPTHASH hHash, CONST BYTE *pbData, DWORD dwDataLen, DWORD dwFlags);
+typedef BOOL (WINAPI fnCPHashSessionKey)(HCRYPTPROV hProv, HCRYPTHASH hHash, HCRYPTKEY hKey, DWORD dwFlags);
+typedef BOOL (WINAPI fnCPImportKey)(HCRYPTPROV hProv, CONST BYTE *pbData, DWORD dwDataLen, HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY *phKey);
+typedef BOOL (WINAPI fnCPReleaseContext)(HCRYPTPROV hProv, DWORD dwFlags);
+typedef BOOL (WINAPI fnCPSetHashParam)(HCRYPTPROV hProv, HCRYPTHASH hHash, DWORD dwParam, CONST BYTE *pbData, DWORD dwFlags);
+typedef BOOL (WINAPI fnCPSetKeyParam)(HCRYPTPROV hProv, HCRYPTKEY hKey, DWORD dwParam, CONST BYTE *pbData, DWORD dwFlags);
+typedef BOOL (WINAPI fnCPSetProvParam)(HCRYPTPROV hProv, DWORD dwParam, CONST BYTE *pbData, DWORD dwFlags);
+typedef BOOL (WINAPI fnCPSignHash)(HCRYPTPROV hProv, HCRYPTHASH hHash, DWORD dwKeySpec, LPCWSTR sDescription, DWORD dwFlags, BYTE *pbSignature, DWORD *pdwSigLen);
+typedef BOOL (WINAPI fnCPVerifySignature)(HCRYPTPROV hProv, HCRYPTHASH hHash, CONST BYTE *pbSignature, DWORD dwSigLen, HCRYPTKEY hPubKey, LPCWSTR sDescription, DWORD dwFlags);
+
 typedef struct tagPROVFUNCS
 {
-        BOOL (*WINAPI pCPAcquireContext)(HCRYPTPROV *phProv, LPSTR pszContainer, DWORD dwFlags, PVTableProvStruc pVTable);
-        BOOL (*WINAPI pCPCreateHash)(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DWORD dwFlags, HCRYPTHASH *phHash);
-        BOOL (*WINAPI pCPDecrypt)(HCRYPTPROV hProv, HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen);
-        BOOL (*WINAPI pCPDeriveKey)(HCRYPTPROV hProv, ALG_ID     Algid, HCRYPTHASH hBaseData, DWORD dwFlags, HCRYPTKEY *phKey);
-        BOOL (*WINAPI pCPDestroyHash)(HCRYPTPROV hProv, HCRYPTHASH hHash);
-        BOOL (*WINAPI pCPDestroyKey)(HCRYPTPROV hProv, HCRYPTKEY hKey);
-        BOOL (*WINAPI pCPDuplicateHash)(HCRYPTPROV hUID, HCRYPTHASH hHash, DWORD *pdwReserved, DWORD dwFlags, HCRYPTHASH *phHash);
-        BOOL (*WINAPI pCPDuplicateKey)(HCRYPTPROV hUID, HCRYPTKEY hKey, DWORD *pdwReserved, DWORD dwFlags, HCRYPTKEY *phKey);
-        BOOL (*WINAPI pCPEncrypt)(HCRYPTPROV hProv, HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen, DWORD dwBufLen);
-        BOOL (*WINAPI pCPExportKey)(HCRYPTPROV hProv, HCRYPTKEY hKey, HCRYPTKEY hPubKey, DWORD dwBlobType, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen);
-        BOOL (*WINAPI pCPGenKey)(HCRYPTPROV hProv, ALG_ID Algid, DWORD dwFlags, HCRYPTKEY *phKey);
-        BOOL (*WINAPI pCPGenRandom)(HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer);
-        BOOL (*WINAPI pCPGetHashParam)(HCRYPTPROV hProv, HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags);
-        BOOL (*WINAPI pCPGetKeyParam)(HCRYPTPROV hProv, HCRYPTKEY hKey, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags);
-        BOOL (*WINAPI pCPGetProvParam)(HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags);
-        BOOL (*WINAPI pCPGetUserKey)(HCRYPTPROV hProv, DWORD dwKeySpec, HCRYPTKEY *phUserKey);
-        BOOL (*WINAPI pCPHashData)(HCRYPTPROV hProv, HCRYPTHASH hHash, CONST BYTE *pbData, DWORD dwDataLen, DWORD dwFlags);
-        BOOL (*WINAPI pCPHashSessionKey)(HCRYPTPROV hProv, HCRYPTHASH hHash, HCRYPTKEY hKey, DWORD dwFlags);
-        BOOL (*WINAPI pCPImportKey)(HCRYPTPROV hProv, CONST BYTE *pbData, DWORD dwDataLen, HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY *phKey);
-        BOOL (*WINAPI pCPReleaseContext)(HCRYPTPROV hProv, DWORD dwFlags);
-        BOOL (*WINAPI pCPSetHashParam)(HCRYPTPROV hProv, HCRYPTHASH hHash, DWORD dwParam, CONST BYTE *pbData, DWORD dwFlags);
-        BOOL (*WINAPI pCPSetKeyParam)(HCRYPTPROV hProv, HCRYPTKEY hKey, DWORD dwParam, CONST BYTE *pbData, DWORD dwFlags);
-        BOOL (*WINAPI pCPSetProvParam)(HCRYPTPROV hProv, DWORD dwParam, CONST BYTE *pbData, DWORD dwFlags);
-        BOOL (*WINAPI pCPSignHash)(HCRYPTPROV hProv, HCRYPTHASH hHash, DWORD dwKeySpec, LPCWSTR sDescription, DWORD dwFlags, BYTE *pbSignature, DWORD *pdwSigLen);
-        BOOL (*WINAPI pCPVerifySignature)(HCRYPTPROV hProv, HCRYPTHASH hHash, CONST BYTE *pbSignature, DWORD dwSigLen, HCRYPTKEY hPubKey, LPCWSTR sDescription, DWORD dwFlags);
+    fnCPAcquireContext*  pCPAcquireContext;
+    fnCPCreateHash*      pCPCreateHash;
+    fnCPDecrypt*         pCPDecrypt;
+    fnCPDeriveKey*       pCPDeriveKey;
+    fnCPDestroyHash*     pCPDestroyHash;
+    fnCPDestroyKey*      pCPDestroyKey;
+    fnCPDuplicateHash*   pCPDuplicateHash;
+    fnCPDuplicateKey*    pCPDuplicateKey;
+    fnCPEncrypt*         pCPEncrypt;
+    fnCPExportKey*       pCPExportKey;
+    fnCPGenKey*          pCPGenKey;
+    fnCPGenRandom*       pCPGenRandom;
+    fnCPGetHashParam*    pCPGetHashParam;
+    fnCPGetKeyParam*     pCPGetKeyParam;
+    fnCPGetProvParam*    pCPGetProvParam;
+    fnCPGetUserKey*      pCPGetUserKey;
+    fnCPHashData*        pCPHashData;
+    fnCPHashSessionKey*  pCPHashSessionKey;
+    fnCPImportKey*       pCPImportKey;
+    fnCPReleaseContext*  pCPReleaseContext;
+    fnCPSetHashParam*    pCPSetHashParam;
+    fnCPSetKeyParam*     pCPSetKeyParam;
+    fnCPSetProvParam*    pCPSetProvParam;
+    fnCPSignHash*        pCPSignHash;
+    fnCPVerifySignature* pCPVerifySignature;
 } PROVFUNCS, *PPROVFUNCS;
 

trunk/src/advapi32/registry.c

@@ -127 +127 @@
     }
 
-    if (!(ret = InterlockedCompareExchangePointer( (void **)&special_root_keys[idx], hkey, 0 )))
+    if (!(ret = (HKEY)InterlockedCompareExchangePointer( (void **)&special_root_keys[idx], hkey, 0 )))
         ret = hkey;
     else
@@ -159 +159 @@
     WCHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
     HKEY hSubKey = hKey;
+    BOOL isTrue = TRUE;
 
     TRACE("(hkey=%p,%p %s)\n", hKey, lpszSubKey, debugstr_w(lpszSubKey));
@@ -188 +189 @@
 
     /* Recursively delete all the subkeys */
-    while (TRUE)
+    while (isTrue)
     {
         dwSize = dwMaxLen;
@@ -201 +202 @@
         ret = RegDeleteKeyW(hKey, lpszSubKey);
     else
-        while (TRUE)
+        while (isTrue)
         {
             dwSize = dwMaxLen;

trunk/src/advapi32/security.c

@@ -1092 +1092 @@
 
     sz = 14 + pisid->SubAuthorityCount * 11;
-    str = LocalAlloc( 0, sz*sizeof(WCHAR) );
+    str = (LPWSTR)LocalAlloc( 0, sz*sizeof(WCHAR) );
     sprintfW( str, fmt, pisid->Revision, MAKELONG(
      MAKEWORD( pisid->IdentifierAuthority.Value[5],
@@ -1120 +1120 @@
 
     len = WideCharToMultiByte( CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL );
-    str = LocalAlloc( 0, len );
+    str = (LPSTR)LocalAlloc( 0, len );
     WideCharToMultiByte( CP_ACP, 0, wstr, -1, str, len, NULL, NULL );
-    LocalFree( wstr );
+    LocalFree( (HANDLE)wstr );
 
     *pstr = str;