crypt32: Enable compilation with long types.

dlls/crypt32/Makefile.in

-EXTRADEFS = -DWINE_NO_LONG_TYPES -D_CRYPT32_
+EXTRADEFS = -D_CRYPT32_
 MODULE    = crypt32.dll
 UNIXLIB   = crypt32.so
 IMPORTLIB = crypt32

dlls/crypt32/base64.c

@@ -246,7 +246,7 @@ BOOL WINAPI CryptBinaryToStringA(const BYTE *pbBinary,
 {
     BinaryToStringAFunc encoder = NULL;
 
-    TRACE("(%p, %d, %08x, %p, %p)\n", pbBinary, cbBinary, dwFlags, pszString,
+    TRACE("(%p, %ld, %08lx, %p, %p)\n", pbBinary, cbBinary, dwFlags, pszString,
      pcchString);
 
     if (!pbBinary)
@@ -275,7 +275,7 @@ BOOL WINAPI CryptBinaryToStringA(const BYTE *pbBinary,
     case CRYPT_STRING_HEXASCII:
     case CRYPT_STRING_HEXADDR:
     case CRYPT_STRING_HEXASCIIADDR:
-        FIXME("Unimplemented type %d\n", dwFlags & 0x0fffffff);
+        FIXME("Unimplemented type %ld\n", dwFlags & 0x0fffffff);
         /* fall through */
     default:
         SetLastError(ERROR_INVALID_PARAMETER);
@@ -584,7 +584,7 @@ BOOL WINAPI CryptBinaryToStringW(const BYTE *pbBinary,
 {
     BinaryToStringWFunc encoder = NULL;
 
-    TRACE("(%p, %d, %08x, %p, %p)\n", pbBinary, cbBinary, dwFlags, pszString,
+    TRACE("(%p, %ld, %08lx, %p, %p)\n", pbBinary, cbBinary, dwFlags, pszString,
      pcchString);
 
     if (!pbBinary)
@@ -618,7 +618,7 @@ BOOL WINAPI CryptBinaryToStringW(const BYTE *pbBinary,
     case CRYPT_STRING_HEXASCII:
     case CRYPT_STRING_HEXADDR:
     case CRYPT_STRING_HEXASCIIADDR:
-        FIXME("Unimplemented type %d\n", dwFlags & 0x0fffffff);
+        FIXME("Unimplemented type %ld\n", dwFlags & 0x0fffffff);
         /* fall through */
     default:
         SetLastError(ERROR_INVALID_PARAMETER);
@@ -890,7 +890,7 @@ BOOL WINAPI CryptStringToBinaryA(LPCSTR pszString,
     StringToBinaryAFunc decoder;
     LONG ret;
 
-    TRACE("(%s, %d, %08x, %p, %p, %p, %p)\n", debugstr_an(pszString, cchString ? cchString : -1),
+    TRACE("(%s, %ld, %08lx, %p, %p, %p, %p)\n", debugstr_an(pszString, cchString ? cchString : -1),
      cchString, dwFlags, pbBinary, pcbBinary, pdwSkip, pdwFlags);
 
     if (!pszString)
@@ -931,7 +931,7 @@ BOOL WINAPI CryptStringToBinaryA(LPCSTR pszString,
     case CRYPT_STRING_HEXASCII:
     case CRYPT_STRING_HEXADDR:
     case CRYPT_STRING_HEXASCIIADDR:
-        FIXME("Unimplemented type %d\n", dwFlags & 0x7fffffff);
+        FIXME("Unimplemented type %ld\n", dwFlags & 0x7fffffff);
         /* fall through */
     default:
         SetLastError(ERROR_INVALID_PARAMETER);
@@ -1101,7 +1101,7 @@ BOOL WINAPI CryptStringToBinaryW(LPCWSTR pszString,
     StringToBinaryWFunc decoder;
     LONG ret;
 
-    TRACE("(%s, %d, %08x, %p, %p, %p, %p)\n", debugstr_wn(pszString, cchString ? cchString : -1),
+    TRACE("(%s, %ld, %08lx, %p, %p, %p, %p)\n", debugstr_wn(pszString, cchString ? cchString : -1),
      cchString, dwFlags, pbBinary, pcbBinary, pdwSkip, pdwFlags);
 
     if (!pszString)
@@ -1142,7 +1142,7 @@ BOOL WINAPI CryptStringToBinaryW(LPCWSTR pszString,
     case CRYPT_STRING_HEXASCII:
     case CRYPT_STRING_HEXADDR:
     case CRYPT_STRING_HEXASCIIADDR:
-        FIXME("Unimplemented type %d\n", dwFlags & 0x7fffffff);
+        FIXME("Unimplemented type %ld\n", dwFlags & 0x7fffffff);
         /* fall through */
     default:
         SetLastError(ERROR_INVALID_PARAMETER);

dlls/crypt32/collectionstore.c

@@ -42,7 +42,7 @@ typedef struct _WINE_COLLECTIONSTORE
 static void Collection_addref(WINECRYPT_CERTSTORE *store)
 {
     LONG ref = InterlockedIncrement(&store->ref);
-    TRACE("ref = %d\n", ref);
+    TRACE("ref = %ld\n", ref);
 }
 
 static DWORD Collection_release(WINECRYPT_CERTSTORE *store, DWORD flags)
@@ -52,10 +52,10 @@ static DWORD Collection_release(WINECRYPT_CERTSTORE *store, DWORD flags)
     LONG ref;
 
     if(flags)
-        FIXME("Unimplemented flags %x\n", flags);
+        FIXME("Unimplemented flags %lx\n", flags);
 
     ref = InterlockedDecrement(&cs->hdr.ref);
-    TRACE("(%p) ref=%d\n", store, ref);
+    TRACE("(%p) ref=%ld\n", store, ref);
     if(ref)
         return ERROR_SUCCESS;
 
@@ -411,7 +411,7 @@ static BOOL Collection_control(WINECRYPT_CERTSTORE *cert_store, DWORD dwFlags,
     WINE_COLLECTIONSTORE *store = (WINE_COLLECTIONSTORE*)cert_store;
     WINE_STORE_LIST_ENTRY *entry;
 
-    TRACE("(%p, %08x, %d, %p)\n", cert_store, dwFlags, dwCtrlType, pvCtrlPara);
+    TRACE("(%p, %08lx, %ld, %p)\n", cert_store, dwFlags, dwCtrlType, pvCtrlPara);
 
     if (!store)
         return TRUE;
@@ -494,7 +494,7 @@ BOOL WINAPI CertAddStoreToCollection(HCERTSTORE hCollectionStore,
     WINE_STORE_LIST_ENTRY *entry;
     BOOL ret;
 
-    TRACE("(%p, %p, %08x, %d)\n", hCollectionStore, hSiblingStore,
+    TRACE("(%p, %p, %08lx, %ld)\n", hCollectionStore, hSiblingStore,
      dwUpdateFlags, dwPriority);
 
     if (!collection || !sibling)
@@ -519,11 +519,11 @@ BOOL WINAPI CertAddStoreToCollection(HCERTSTORE hCollectionStore,
     if (entry)
     {
         InterlockedIncrement(&sibling->ref);
-        TRACE("sibling %p's ref count is %d\n", sibling, sibling->ref);
+        TRACE("sibling %p's ref count is %ld\n", sibling, sibling->ref);
         entry->store = sibling;
         entry->dwUpdateFlags = dwUpdateFlags;
         entry->dwPriority = dwPriority;
-        TRACE("%p: adding %p, priority %d\n", collection, entry, dwPriority);
+        TRACE("%p: adding %p, priority %ld\n", collection, entry, dwPriority);
         EnterCriticalSection(&collection->cs);
         if (dwPriority)
         {

dlls/crypt32/context.c

@@ -79,7 +79,7 @@ void Context_AddRef(context_t *context)
 {
     LONG ref = InterlockedIncrement(&context->ref);
 
-    TRACE("(%p) ref=%d\n", context, context->ref);
+    TRACE("(%p) ref=%ld\n", context, context->ref);
 
     if(ref == 1) {
         /* This is the first external (non-store) reference. Increase store ref cnt. */
@@ -107,7 +107,7 @@ void Context_Release(context_t *context)
 {
     LONG ref = InterlockedDecrement(&context->ref);
 
-    TRACE("(%p) ref=%d\n", context, ref);
+    TRACE("(%p) ref=%ld\n", context, ref);
     assert(ref >= 0);
 
     if (!ref) {

dlls/crypt32/crl.c

@@ -185,7 +185,7 @@ PCCRL_CONTEXT WINAPI CertCreateCRLContext(DWORD dwCertEncodingType,
     BYTE *data = NULL;
     DWORD size = 0;
 
-    TRACE("(%08x, %p, %d)\n", dwCertEncodingType, pbCrlEncoded,
+    TRACE("(%08lx, %p, %ld)\n", dwCertEncodingType, pbCrlEncoded,
      cbCrlEncoded);
 
     if ((dwCertEncodingType & CERT_ENCODING_TYPE_MASK) != X509_ASN_ENCODING)
@@ -228,7 +228,7 @@ BOOL WINAPI CertAddEncodedCRLToStore(HCERTSTORE hCertStore,
      pbCrlEncoded, cbCrlEncoded);
     BOOL ret;
 
-    TRACE("(%p, %08x, %p, %d, %08x, %p)\n", hCertStore, dwCertEncodingType,
+    TRACE("(%p, %08lx, %p, %ld, %08lx, %p)\n", hCertStore, dwCertEncodingType,
      pbCrlEncoded, cbCrlEncoded, dwAddDisposition, ppCrlContext);
 
     if (crl)
@@ -385,7 +385,7 @@ PCCRL_CONTEXT WINAPI CertFindCRLInStore(HCERTSTORE hCertStore,
     PCCRL_CONTEXT ret;
     CrlCompareFunc compare;
 
-    TRACE("(%p, %d, %d, %d, %p, %p)\n", hCertStore, dwCertEncodingType,
+    TRACE("(%p, %ld, %ld, %ld, %p, %p)\n", hCertStore, dwCertEncodingType,
 	 dwFindFlags, dwFindType, pvFindPara, pPrevCrlContext);
 
     switch (dwFindType)
@@ -403,7 +403,7 @@ PCCRL_CONTEXT WINAPI CertFindCRLInStore(HCERTSTORE hCertStore,
         compare = compare_crl_issued_for;
         break;
     default:
-        FIXME("find type %08x unimplemented\n", dwFindType);
+        FIXME("find type %08lx unimplemented\n", dwFindType);
         compare = NULL;
     }
 
@@ -436,7 +436,7 @@ PCCRL_CONTEXT WINAPI CertGetCRLFromStore(HCERTSTORE hCertStore,
      CERT_STORE_DELTA_CRL_FLAG;
     PCCRL_CONTEXT ret;
 
-    TRACE("(%p, %p, %p, %08x)\n", hCertStore, pIssuerContext, pPrevCrlContext,
+    TRACE("(%p, %p, %p, %08lx)\n", hCertStore, pIssuerContext, pPrevCrlContext,
      *pdwFlags);
 
     if (*pdwFlags & ~supportedFlags)
@@ -489,7 +489,7 @@ BOOL WINAPI CertFreeCRLContext(PCCRL_CONTEXT pCrlContext)
 DWORD WINAPI CertEnumCRLContextProperties(PCCRL_CONTEXT pCRLContext,
  DWORD dwPropId)
 {
-    TRACE("(%p, %d)\n", pCRLContext, dwPropId);
+    TRACE("(%p, %ld)\n", pCRLContext, dwPropId);
 
     return ContextPropertyList_EnumPropIDs(crl_from_ptr(pCRLContext)->base.properties, dwPropId);
 }
@@ -518,7 +518,7 @@ static BOOL CRLContext_GetProperty(crl_t *crl, DWORD dwPropId,
     BOOL ret;
     CRYPT_DATA_BLOB blob;
 
-    TRACE("(%p, %d, %p, %p)\n", crl, dwPropId, pvData, pcbData);
+    TRACE("(%p, %ld, %p, %p)\n", crl, dwPropId, pvData, pcbData);
 
     if (crl->base.properties)
         ret = ContextPropertyList_FindProperty(crl->base.properties, dwPropId, &blob);
@@ -568,7 +568,7 @@ BOOL WINAPI CertGetCRLContextProperty(PCCRL_CONTEXT pCRLContext,
 {
     BOOL ret;
 
-    TRACE("(%p, %d, %p, %p)\n", pCRLContext, dwPropId, pvData, pcbData);
+    TRACE("(%p, %ld, %p, %p)\n", pCRLContext, dwPropId, pvData, pcbData);
 
     switch (dwPropId)
     {
@@ -607,7 +607,7 @@ static BOOL CRLContext_SetProperty(crl_t *crl, DWORD dwPropId,
 {
     BOOL ret;
 
-    TRACE("(%p, %d, %08x, %p)\n", crl, dwPropId, dwFlags, pvData);
+    TRACE("(%p, %ld, %08lx, %p)\n", crl, dwPropId, dwFlags, pvData);
 
     if (!crl->base.properties)
         ret = FALSE;
@@ -649,7 +649,7 @@ static BOOL CRLContext_SetProperty(crl_t *crl, DWORD dwPropId,
              pvData, sizeof(FILETIME));
             break;
         default:
-            FIXME("%d: stub\n", dwPropId);
+            FIXME("%ld: stub\n", dwPropId);
             ret = FALSE;
         }
     }
@@ -662,7 +662,7 @@ BOOL WINAPI CertSetCRLContextProperty(PCCRL_CONTEXT pCRLContext,
 {
     BOOL ret;
 
-    TRACE("(%p, %d, %08x, %p)\n", pCRLContext, dwPropId, dwFlags, pvData);
+    TRACE("(%p, %ld, %08lx, %p)\n", pCRLContext, dwPropId, dwFlags, pvData);
 
     /* Handle special cases for "read-only"/invalid prop IDs.  Windows just
      * crashes on most of these, I'll be safer.
@@ -719,7 +719,7 @@ static BOOL compare_dist_point_name(const CRL_DIST_POINT_NAME *name1,
                              entry1->u.DirectoryName.cbData);
                             break;
                         default:
-                            FIXME("unimplemented for type %d\n",
+                            FIXME("unimplemented for type %ld\n",
                              entry1->dwAltNameChoice);
                             match = FALSE;
                         }
@@ -778,7 +778,7 @@ BOOL WINAPI CertIsValidCRLForCertificate(PCCERT_CONTEXT pCert,
     PCERT_EXTENSION ext;
     BOOL ret;
 
-    TRACE("(%p, %p, %08x, %p)\n", pCert, pCrl, dwFlags, pvReserved);
+    TRACE("(%p, %p, %08lx, %p)\n", pCert, pCrl, dwFlags, pvReserved);
 
     if (!pCert)
         return TRUE;
@@ -845,7 +845,7 @@ BOOL WINAPI CertFindCertificateInCRL(PCCERT_CONTEXT pCert,
  PCCRL_CONTEXT pCrlContext, DWORD dwFlags, void *pvReserved,
  PCRL_ENTRY *ppCrlEntry)
 {
-    TRACE("(%p, %p, %08x, %p, %p)\n", pCert, pCrlContext, dwFlags, pvReserved,
+    TRACE("(%p, %p, %08lx, %p, %p)\n", pCert, pCrlContext, dwFlags, pvReserved,
      ppCrlEntry);
 
     *ppCrlEntry = CRYPT_FindCertificateInCRL(pCert->pCertInfo,
@@ -859,7 +859,7 @@ BOOL WINAPI CertVerifyCRLRevocation(DWORD dwCertEncodingType,
     DWORD i;
     PCRL_ENTRY entry = NULL;
 
-    TRACE("(%08x, %p, %d, %p)\n", dwCertEncodingType, pCertId, cCrlInfo,
+    TRACE("(%08lx, %p, %ld, %p)\n", dwCertEncodingType, pCertId, cCrlInfo,
      rgpCrlInfo);
 
     for (i = 0; !entry && i < cCrlInfo; i++)

dlls/crypt32/ctl.c

@@ -68,7 +68,7 @@ BOOL WINAPI CertAddCTLContextToStore(HCERTSTORE hCertStore,
     BOOL ret = TRUE;
     PCCTL_CONTEXT toAdd = NULL, existing = NULL;
 
-    TRACE("(%p, %p, %08x, %p)\n", hCertStore, pCtlContext, dwAddDisposition,
+    TRACE("(%p, %p, %08lx, %p)\n", hCertStore, pCtlContext, dwAddDisposition,
      ppStoreContext);
 
     if (dwAddDisposition != CERT_STORE_ADD_ALWAYS)
@@ -150,7 +150,7 @@ BOOL WINAPI CertAddCTLContextToStore(HCERTSTORE hCertStore,
             toAdd = CertDuplicateCTLContext(pCtlContext);
         break;
     default:
-        FIXME("Unimplemented add disposition %d\n", dwAddDisposition);
+        FIXME("Unimplemented add disposition %ld\n", dwAddDisposition);
         ret = FALSE;
     }
 
@@ -182,7 +182,7 @@ BOOL WINAPI CertAddEncodedCTLToStore(HCERTSTORE hCertStore,
      pbCtlEncoded, cbCtlEncoded);
     BOOL ret;
 
-    TRACE("(%p, %08x, %p, %d, %08x, %p)\n", hCertStore,
+    TRACE("(%p, %08lx, %p, %ld, %08lx, %p)\n", hCertStore,
      dwMsgAndCertEncodingType, pbCtlEncoded, cbCtlEncoded, dwAddDisposition,
      ppCtlContext);
 
@@ -295,7 +295,7 @@ PCCTL_CONTEXT WINAPI CertFindCTLInStore(HCERTSTORE hCertStore,
     PCCTL_CONTEXT ret;
     CtlCompareFunc compare;
 
-    TRACE("(%p, %d, %d, %d, %p, %p)\n", hCertStore, dwCertEncodingType,
+    TRACE("(%p, %ld, %ld, %ld, %p, %p)\n", hCertStore, dwCertEncodingType,
 	 dwFindFlags, dwFindType, pvFindPara, pPrevCtlContext);
 
     switch (dwFindType)
@@ -313,7 +313,7 @@ PCCTL_CONTEXT WINAPI CertFindCTLInStore(HCERTSTORE hCertStore,
         compare = compare_ctl_existing;
         break;
     default:
-        FIXME("find type %08x unimplemented\n", dwFindType);
+        FIXME("find type %08lx unimplemented\n", dwFindType);
         compare = NULL;
     }
 
@@ -370,7 +370,7 @@ PCCTL_CONTEXT WINAPI CertCreateCTLContext(DWORD dwMsgAndCertEncodingType,
     DWORD contentSize = 0, size;
     PCTL_INFO ctlInfo = NULL;
 
-    TRACE("(%08x, %p, %d)\n", dwMsgAndCertEncodingType, pbCtlEncoded,
+    TRACE("(%08lx, %p, %ld)\n", dwMsgAndCertEncodingType, pbCtlEncoded,
      cbCtlEncoded);
 
     if (GET_CERT_ENCODING_TYPE(dwMsgAndCertEncodingType) != X509_ASN_ENCODING)
@@ -511,7 +511,7 @@ DWORD WINAPI CertEnumCTLContextProperties(PCCTL_CONTEXT pCTLContext,
     ctl_t *ctl = ctl_from_ptr(pCTLContext);
     DWORD ret;
 
-    TRACE("(%p, %d)\n", pCTLContext, dwPropId);
+    TRACE("(%p, %ld)\n", pCTLContext, dwPropId);
 
     if (ctl->base.properties)
         ret = ContextPropertyList_EnumPropIDs(ctl->base.properties, dwPropId);
@@ -544,7 +544,7 @@ static BOOL CTLContext_GetProperty(ctl_t *ctl, DWORD dwPropId,
     BOOL ret;
     CRYPT_DATA_BLOB blob;
 
-    TRACE("(%p, %d, %p, %p)\n", ctl, dwPropId, pvData, pcbData);
+    TRACE("(%p, %ld, %p, %p)\n", ctl, dwPropId, pvData, pcbData);
 
     if (ctl->base.properties)
         ret = ContextPropertyList_FindProperty(ctl->base.properties, dwPropId, &blob);
@@ -592,7 +592,7 @@ BOOL WINAPI CertGetCTLContextProperty(PCCTL_CONTEXT pCTLContext,
 {
     BOOL ret;
 
-    TRACE("(%p, %d, %p, %p)\n", pCTLContext, dwPropId, pvData, pcbData);
+    TRACE("(%p, %ld, %p, %p)\n", pCTLContext, dwPropId, pvData, pcbData);
 
     switch (dwPropId)
     {
@@ -632,7 +632,7 @@ static BOOL CTLContext_SetProperty(ctl_t *ctl, DWORD dwPropId,
 {
     BOOL ret;
 
-    TRACE("(%p, %d, %08x, %p)\n", ctl, dwPropId, dwFlags, pvData);
+    TRACE("(%p, %ld, %08lx, %p)\n", ctl, dwPropId, dwFlags, pvData);
 
     if (!ctl->base.properties)
         ret = FALSE;
@@ -674,7 +674,7 @@ static BOOL CTLContext_SetProperty(ctl_t *ctl, DWORD dwPropId,
              pvData, sizeof(FILETIME));
             break;
         default:
-            FIXME("%d: stub\n", dwPropId);
+            FIXME("%ld: stub\n", dwPropId);
             ret = FALSE;
         }
     }
@@ -687,7 +687,7 @@ BOOL WINAPI CertSetCTLContextProperty(PCCTL_CONTEXT pCTLContext,
 {
     BOOL ret;
 
-    TRACE("(%p, %d, %08x, %p)\n", pCTLContext, dwPropId, dwFlags, pvData);
+    TRACE("(%p, %ld, %08lx, %p)\n", pCTLContext, dwPropId, dwFlags, pvData);
 
     /* Handle special cases for "read-only"/invalid prop IDs.  Windows just
      * crashes on most of these, I'll be safer.

dlls/crypt32/encode.c

@@ -180,7 +180,7 @@ BOOL WINAPI CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType,
     BOOL ret;
     DWORD i, dataLen = 0;
 
-    TRACE("%p, %d, %08x, %p, %p, %d\n", items, cItem, dwFlags, pEncodePara,
+    TRACE("%p, %ld, %08lx, %p, %p, %ld\n", items, cItem, dwFlags, pEncodePara,
      pbEncoded, pbEncoded ? *pcbEncoded : 0);
     for (i = 0, ret = TRUE; ret && i < cItem; i++)
     {
@@ -228,7 +228,7 @@ BOOL WINAPI CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType,
             }
         }
     }
-    TRACE("returning %d (%08x)\n", ret, GetLastError());
+    TRACE("returning %d (%08lx)\n", ret, GetLastError());
     return ret;
 }
 
@@ -576,7 +576,7 @@ static BOOL CRYPT_AsnEncodeCRLEntry(const CRL_ENTRY *entry,
     DWORD cItem = 2;
     BOOL ret;
 
-    TRACE("%p, %p, %d\n", entry, pbEncoded, pbEncoded ? *pcbEncoded : 0);
+    TRACE("%p, %p, %ld\n", entry, pbEncoded, pbEncoded ? *pcbEncoded : 0);
 
     if (entry->cExtension)
     {
@@ -588,7 +588,7 @@ static BOOL CRYPT_AsnEncodeCRLEntry(const CRL_ENTRY *entry,
     ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
      pbEncoded, pcbEncoded);
 
-    TRACE("returning %d (%08x)\n", ret, GetLastError());
+    TRACE("returning %d (%08lx)\n", ret, GetLastError());
     return ret;
 }
 
@@ -732,7 +732,7 @@ static BOOL CRYPT_AsnEncodeExtension(CERT_EXTENSION *ext, BYTE *pbEncoded,
     };
     DWORD cItem = 1;
 
-    TRACE("%p, %p, %d\n", ext, pbEncoded, pbEncoded ? *pcbEncoded : 0);
+    TRACE("%p, %p, %ld\n", ext, pbEncoded, pbEncoded ? *pcbEncoded : 0);
 
     if (ext->fCritical)
     {
@@ -746,7 +746,7 @@ static BOOL CRYPT_AsnEncodeExtension(CERT_EXTENSION *ext, BYTE *pbEncoded,
 
     ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
      pbEncoded, pcbEncoded);
-    TRACE("returning %d (%08x)\n", ret, GetLastError());
+    TRACE("returning %d (%08lx)\n", ret, GetLastError());
     return ret;
 }
 
@@ -1405,7 +1405,7 @@ static BOOL WINAPI CRYPT_AsnEncodeUnicodeName(DWORD dwCertEncodingType,
         const CERT_NAME_INFO *info = pvStructInfo;
         DWORD bytesNeeded = 0, lenBytes, size, i;
 
-        TRACE("encoding name with %d RDNs\n", info->cRDN);
+        TRACE("encoding name with %ld RDNs\n", info->cRDN);
         ret = TRUE;
         for (i = 0; ret && i < info->cRDN; i++)
         {
@@ -2306,7 +2306,7 @@ static BOOL WINAPI CRYPT_AsnEncodeName(DWORD dwCertEncodingType,
         const CERT_NAME_INFO *info = pvStructInfo;
         DWORD bytesNeeded = 0, lenBytes, size, i;
 
-        TRACE("encoding name with %d RDNs\n", info->cRDN);
+        TRACE("encoding name with %ld RDNs\n", info->cRDN);
         ret = TRUE;
         for (i = 0; ret && i < info->cRDN; i++)
         {
@@ -2387,7 +2387,7 @@ static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType,
         *pbEncoded++ = val ? 0xff : 0;
         ret = TRUE;
     }
-    TRACE("returning %d (%08x)\n", ret, GetLastError());
+    TRACE("returning %d (%08lx)\n", ret, GetLastError());
     return ret;
 }
 
@@ -2444,7 +2444,7 @@ static BOOL WINAPI CRYPT_AsnEncodeAltNameEntry(DWORD dwCertEncodingType,
          pcbEncoded);
     }
     case CERT_ALT_NAME_OTHER_NAME:
-        FIXME("name type %d unimplemented\n", entry->dwAltNameChoice);
+        FIXME("name type %ld unimplemented\n", entry->dwAltNameChoice);
         return FALSE;
     default:
         SetLastError(E_INVALIDARG);
@@ -2492,7 +2492,7 @@ static BOOL WINAPI CRYPT_AsnEncodeAltNameEntry(DWORD dwCertEncodingType,
                 *pcbEncoded = bytesNeeded;
         }
     }
-    TRACE("returning %d (%08x)\n", ret, GetLastError());
+    TRACE("returning %d (%08lx)\n", ret, GetLastError());
     return ret;
 }
 
@@ -3226,7 +3226,7 @@ BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType,
         const CRYPT_DATA_BLOB *blob = pvStructInfo;
         DWORD bytesNeeded, lenBytes;
 
-        TRACE("(%d, %p), %08x, %p, %p, %d\n", blob->cbData, blob->pbData,
+        TRACE("(%ld, %p), %08lx, %p, %p, %ld\n", blob->cbData, blob->pbData,
          dwFlags, pEncodePara, pbEncoded, pbEncoded ? *pcbEncoded : 0);
 
         CRYPT_EncodeLen(blob->cbData, NULL, &lenBytes);
@@ -3257,7 +3257,7 @@ BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType,
         ret = FALSE;
     }
     __ENDTRY
-    TRACE("returning %d (%08x)\n", ret, GetLastError());
+    TRACE("returning %d (%08lx)\n", ret, GetLastError());
     return ret;
 }
 
@@ -4707,7 +4707,7 @@ BOOL WINAPI CryptEncodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType,
     CryptEncodeObjectFunc pCryptEncodeObject = NULL;
     CryptEncodeObjectExFunc pCryptEncodeObjectEx = NULL;
 
-    TRACE_(crypt)("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
+    TRACE_(crypt)("(0x%08lx, %s, %p, %p, %p)\n", dwCertEncodingType,
      debugstr_a(lpszStructType), pvStructInfo, pbEncoded,
      pcbEncoded);
 
@@ -4748,7 +4748,7 @@ BOOL WINAPI CryptEncodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType,
     HCRYPTOIDFUNCADDR hFunc = NULL;
     CryptEncodeObjectExFunc encodeFunc = NULL;
 
-    TRACE_(crypt)("(0x%08x, %s, %p, 0x%08x, %p, %p, %p)\n", dwCertEncodingType,
+    TRACE_(crypt)("(0x%08lx, %s, %p, 0x%08lx, %p, %p, %p)\n", dwCertEncodingType,
      debugstr_a(lpszStructType), pvStructInfo, dwFlags, pEncodePara,
      pvEncoded, pcbEncoded);
 
@@ -4824,7 +4824,7 @@ static BOOL WINAPI CRYPT_ExportPublicKeyInfoEx(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE h
     HCRYPTKEY key;
     static CHAR rsa_oid[] = szOID_RSA_RSA;
 
-    TRACE_(crypt)("(%08lx, %d, %08x, %s, %08x, %p, %p, %d)\n", hCryptProv,
+    TRACE_(crypt)("(%08Ix, %ld, %08lx, %s, %08lx, %p, %p, %ld)\n", hCryptProv,
      dwKeySpec, dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags,
      pvAuxInfo, pInfo, pInfo ? *pcbInfo : 0);
 
@@ -4973,7 +4973,7 @@ BOOL WINAPI CryptExportPublicKeyInfoEx(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptPro
     ExportPublicKeyInfoExFunc exportFunc = NULL;
     HCRYPTOIDFUNCADDR hFunc = NULL;
 
-    TRACE_(crypt)("(%08lx, %d, %08x, %s, %08x, %p, %p, %d)\n", hCryptProv,
+    TRACE_(crypt)("(%08Ix, %ld, %08lx, %s, %08lx, %p, %p, %ld)\n", hCryptProv,
      dwKeySpec, dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags,
      pvAuxInfo, pInfo, pInfo ? *pcbInfo : 0);
 
@@ -5022,7 +5022,7 @@ static BOOL WINAPI CRYPT_ImportPublicKeyInfoEx(HCRYPTPROV hCryptProv,
     DWORD pubKeySize;
     LPBYTE pubKey;
 
-    TRACE_(crypt)("(%08lx, %08x, %p, %08x, %08x, %p, %p)\n", hCryptProv,
+    TRACE_(crypt)("(%08Ix, %08lx, %p, %08x, %08lx, %p, %p)\n", hCryptProv,
      dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
 
     if (!set)
@@ -5083,7 +5083,7 @@ BOOL WINAPI CryptImportPublicKeyInfoEx(HCRYPTPROV hCryptProv,
     ImportPublicKeyInfoExFunc importFunc = NULL;
     HCRYPTOIDFUNCADDR hFunc = NULL;
 
-    TRACE_(crypt)("(%08lx, %08x, %p, %08x, %08x, %p, %p)\n", hCryptProv,
+    TRACE_(crypt)("(%08Ix, %08lx, %p, %08x, %08lx, %p, %p)\n", hCryptProv,
      dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
 
     if (!set)
@@ -5103,11 +5103,11 @@ BOOL WINAPI CryptImportPublicKeyInfoEx2(DWORD dwCertEncodingType,
  PCERT_PUBLIC_KEY_INFO pInfo, DWORD dwFlags, void *pvAuxInfo,
  BCRYPT_KEY_HANDLE *phKey)
 {
-    TRACE_(crypt)("(%d, %p, %08x, %p, %p)\n", dwCertEncodingType, pInfo,
+    TRACE_(crypt)("(%ld, %p, %08lx, %p, %p)\n", dwCertEncodingType, pInfo,
      dwFlags, pvAuxInfo, phKey);
 
     if (dwFlags)
-        FIXME("flags %#x ignored\n", dwFlags);
+        FIXME("flags %#lx ignored\n", dwFlags);
 
     return CNG_ImportPubKey(pInfo, phKey);
 }

dlls/crypt32/filestore.c

@@ -38,7 +38,7 @@ static void WINAPI CRYPT_FileCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
 {
     WINE_FILESTOREINFO *store = hCertStore;
 
-    TRACE("(%p, %08x)\n", store, dwFlags);
+    TRACE("(%p, %08lx)\n", store, dwFlags);
     if (store->dirty)
         CertSaveStore(store->memStore, X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
          store->type, CERT_STORE_SAVE_TO_FILE, store->file, 0);
@@ -51,7 +51,7 @@ static BOOL WINAPI CRYPT_FileWriteCert(HCERTSTORE hCertStore,
 {
     WINE_FILESTOREINFO *store = hCertStore;
 
-    TRACE("(%p, %p, %d)\n", hCertStore, cert, dwFlags);
+    TRACE("(%p, %p, %ld)\n", hCertStore, cert, dwFlags);
     store->dirty = TRUE;
     return TRUE;
 }
@@ -61,7 +61,7 @@ static BOOL WINAPI CRYPT_FileDeleteCert(HCERTSTORE hCertStore,
 {
     WINE_FILESTOREINFO *store = hCertStore;
 
-    TRACE("(%p, %p, %08x)\n", hCertStore, pCertContext, dwFlags);
+    TRACE("(%p, %p, %08lx)\n", hCertStore, pCertContext, dwFlags);
     store->dirty = TRUE;
     return TRUE;
 }
@@ -71,7 +71,7 @@ static BOOL WINAPI CRYPT_FileWriteCRL(HCERTSTORE hCertStore,
 {
     WINE_FILESTOREINFO *store = hCertStore;
 
-    TRACE("(%p, %p, %d)\n", hCertStore, crl, dwFlags);
+    TRACE("(%p, %p, %ld)\n", hCertStore, crl, dwFlags);
     store->dirty = TRUE;
     return TRUE;
 }
@@ -81,7 +81,7 @@ static BOOL WINAPI CRYPT_FileDeleteCRL(HCERTSTORE hCertStore,
 {
     WINE_FILESTOREINFO *store = hCertStore;
 
-    TRACE("(%p, %p, %08x)\n", hCertStore, pCrlContext, dwFlags);
+    TRACE("(%p, %p, %08lx)\n", hCertStore, pCrlContext, dwFlags);
     store->dirty = TRUE;
     return TRUE;
 }
@@ -91,7 +91,7 @@ static BOOL WINAPI CRYPT_FileWriteCTL(HCERTSTORE hCertStore,
 {
     WINE_FILESTOREINFO *store = hCertStore;
 
-    TRACE("(%p, %p, %d)\n", hCertStore, ctl, dwFlags);
+    TRACE("(%p, %p, %ld)\n", hCertStore, ctl, dwFlags);
     store->dirty = TRUE;
     return TRUE;
 }
@@ -101,7 +101,7 @@ static BOOL WINAPI CRYPT_FileDeleteCTL(HCERTSTORE hCertStore,
 {
     WINE_FILESTOREINFO *store = hCertStore;
 
-    TRACE("(%p, %p, %08x)\n", hCertStore, pCtlContext, dwFlags);
+    TRACE("(%p, %p, %08lx)\n", hCertStore, pCtlContext, dwFlags);
     store->dirty = TRUE;
     return TRUE;
 }
@@ -133,7 +133,7 @@ static BOOL WINAPI CRYPT_FileControl(HCERTSTORE hCertStore, DWORD dwFlags,
     WINE_FILESTOREINFO *store = hCertStore;
     BOOL ret;
 
-    TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
+    TRACE("(%p, %08lx, %ld, %p)\n", hCertStore, dwFlags, dwCtrlType,
      pvCtrlPara);
 
     switch (dwCtrlType)
@@ -173,7 +173,7 @@ static BOOL WINAPI CRYPT_FileControl(HCERTSTORE hCertStore, DWORD dwFlags,
         }
         else
         {
-            WARN("unknown type %d\n", store->type);
+            WARN("unknown type %ld\n", store->type);
             ret = FALSE;
         }
         break;
@@ -191,7 +191,7 @@ static BOOL WINAPI CRYPT_FileControl(HCERTSTORE hCertStore, DWORD dwFlags,
             ret = TRUE;
         break;
     default:
-        FIXME("%d: stub\n", dwCtrlType);
+        FIXME("%ld: stub\n", dwCtrlType);
         ret = FALSE;
     }
     return ret;
@@ -244,7 +244,7 @@ WINECRYPT_CERTSTORE *CRYPT_FileOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags,
     WINECRYPT_CERTSTORE *store = NULL;
     HANDLE file = (HANDLE)pvPara;
 
-    TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
+    TRACE("(%Id, %08lx, %p)\n", hCryptProv, dwFlags, pvPara);
 
     if (!pvPara)
     {
@@ -296,7 +296,7 @@ WINECRYPT_CERTSTORE *CRYPT_FileNameOpenStoreW(HCRYPTPROV hCryptProv,
     DWORD access, create;
     HANDLE file;
 
-    TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags, debugstr_w(fileName));
+    TRACE("(%Id, %08lx, %s)\n", hCryptProv, dwFlags, debugstr_w(fileName));
 
     if (!fileName)
     {
@@ -383,7 +383,7 @@ WINECRYPT_CERTSTORE *CRYPT_FileNameOpenStoreA(HCRYPTPROV hCryptProv,
     int len;
     WINECRYPT_CERTSTORE *ret = NULL;
 
-    TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
+    TRACE("(%Id, %08lx, %s)\n", hCryptProv, dwFlags,
      debugstr_a(pvPara));
 
     if (!pvPara)

dlls/crypt32/main.c

@@ -106,31 +106,31 @@ BOOL WINAPI I_CryptCreateLruCache(void *unknown, HLRUCACHE *out)
 
 BOOL WINAPI I_CryptFindLruEntry(DWORD unk0, DWORD unk1)
 {
-    FIXME("(%08x, %08x): stub!\n", unk0, unk1);
+    FIXME("(%08lx, %08lx): stub!\n", unk0, unk1);
     return FALSE;
 }
 
 BOOL WINAPI I_CryptFindLruEntryData(DWORD unk0, DWORD unk1, DWORD unk2)
 {
-    FIXME("(%08x, %08x, %08x): stub!\n", unk0, unk1, unk2);
+    FIXME("(%08lx, %08lx, %08lx): stub!\n", unk0, unk1, unk2);
     return FALSE;
 }
 
 BOOL WINAPI I_CryptCreateLruEntry(HLRUCACHE h, DWORD unk0, DWORD unk1)
 {
-    FIXME("(%p, %08x, %08x): stub!\n", h, unk0, unk1);
+    FIXME("(%p, %08lx, %08lx): stub!\n", h, unk0, unk1);
     return FALSE;
 }
 
 DWORD WINAPI I_CryptFlushLruCache(HLRUCACHE h, DWORD unk0, DWORD unk1)
 {
-    FIXME("(%p, %08x, %08x): stub!\n", h, unk0, unk1);
+    FIXME("(%p, %08lx, %08lx): stub!\n", h, unk0, unk1);
     return 0;
 }
 
 HLRUCACHE WINAPI I_CryptFreeLruCache(HLRUCACHE h, DWORD unk0, DWORD unk1)
 {
-    FIXME("(%p, %08x, %08x): stub!\n", h, unk0, unk1);
+    FIXME("(%p, %08lx, %08lx): stub!\n", h, unk0, unk1);
     return h;
 }
 
@@ -177,7 +177,7 @@ BOOL WINAPI I_CryptFreeTls(DWORD dwTlsIndex, DWORD unknown)
 {
     BOOL ret;
 
-    TRACE("(%d, %d)\n", dwTlsIndex, unknown);
+    TRACE("(%ld, %ld)\n", dwTlsIndex, unknown);
 
     ret = TlsFree(dwTlsIndex);
     if (!ret) SetLastError( E_INVALIDARG );
@@ -186,7 +186,7 @@ BOOL WINAPI I_CryptFreeTls(DWORD dwTlsIndex, DWORD unknown)
 
 BOOL WINAPI I_CryptGetOssGlobal(DWORD x)
 {
-    FIXME("%08x\n", x);
+    FIXME("%08lx\n", x);
     return FALSE;
 }
 
@@ -281,44 +281,44 @@ DWORD WINAPI I_CryptInstallOssGlobal(DWORD x, DWORD y, DWORD z)
 {
     static int ret = 8;
     ret++;
-    FIXME("%08x %08x %08x, return value %d\n", x, y, z,ret);
+    FIXME("%08lx %08lx %08lx, return value %d\n", x, y, z,ret);
     return ret;
 }
 
 BOOL WINAPI I_CryptInstallAsn1Module(ASN1module_t x, DWORD y, void* z)
 {
-    FIXME("(%p %08x %p): stub\n", x, y, z);
+    FIXME("(%p %08lx %p): stub\n", x, y, z);
     return TRUE;
 }
 
 BOOL WINAPI I_CryptUninstallAsn1Module(HCRYPTASN1MODULE x)
 {
-    FIXME("(%08x): stub\n", x);
+    FIXME("(%08lx): stub\n", x);
     return TRUE;
 }
 
 ASN1decoding_t WINAPI I_CryptGetAsn1Decoder(HCRYPTASN1MODULE x)
 {
-    FIXME("(%08x): stub\n", x);
+    FIXME("(%08lx): stub\n", x);
     return NULL;
 }
 
 ASN1encoding_t WINAPI I_CryptGetAsn1Encoder(HCRYPTASN1MODULE x)
 {
-    FIXME("(%08x): stub\n", x);
+    FIXME("(%08lx): stub\n", x);
     return NULL;
 }
 
 BOOL WINAPI CryptProtectMemory(void *data, DWORD len, DWORD flags)
 {
     static int fixme_once;
-    if (!fixme_once++) FIXME("(%p %u %08x): stub\n", data, len, flags);
+    if (!fixme_once++) FIXME("(%p %lu %08lx): stub\n", data, len, flags);
     return TRUE;
 }
 
 BOOL WINAPI CryptUnprotectMemory(void *data, DWORD len, DWORD flags)
 {
     static int fixme_once;
-    if (!fixme_once++) FIXME("(%p %u %08x): stub\n", data, len, flags);
+    if (!fixme_once++) FIXME("(%p %lu %08lx): stub\n", data, len, flags);
     return TRUE;
 }

dlls/crypt32/message.c

@@ -31,7 +31,7 @@ HCERTSTORE WINAPI CryptGetMessageCertificates(DWORD dwMsgAndCertEncodingType,
 {
     CRYPT_DATA_BLOB blob = { cbSignedBlob, (LPBYTE)pbSignedBlob };
 
-    TRACE("(%08x, %ld, %d08x %p, %d)\n", dwMsgAndCertEncodingType, hCryptProv,
+    TRACE("(%08lx, %Id, %ld08x %p, %ld)\n", dwMsgAndCertEncodingType, hCryptProv,
      dwFlags, pbSignedBlob, cbSignedBlob);
 
     return CertOpenStore(CERT_STORE_PROV_PKCS7, dwMsgAndCertEncodingType,
@@ -44,7 +44,7 @@ LONG WINAPI CryptGetMessageSignerCount(DWORD dwMsgEncodingType,
     HCRYPTMSG msg;
     LONG count = -1;
 
-    TRACE("(%08x, %p, %d)\n", dwMsgEncodingType, pbSignedBlob, cbSignedBlob);
+    TRACE("(%08lx, %p, %ld)\n", dwMsgEncodingType, pbSignedBlob, cbSignedBlob);
 
     msg = CryptMsgOpenToDecode(dwMsgEncodingType, 0, 0, 0, NULL, NULL);
     if (msg)
@@ -114,7 +114,7 @@ BOOL WINAPI CryptVerifyDetachedMessageSignature(
     BOOL ret = FALSE;
     HCRYPTMSG msg;
 
-    TRACE("(%p, %d, %p, %d, %d, %p, %p, %p)\n", pVerifyPara, dwSignerIndex,
+    TRACE("(%p, %ld, %p, %ld, %ld, %p, %p, %p)\n", pVerifyPara, dwSignerIndex,
      pbDetachedSignBlob, cbDetachedSignBlob, cToBeSigned, rgpbToBeSigned,
      rgcbToBeSigned, ppSignerCert);
 
@@ -188,7 +188,7 @@ BOOL WINAPI CryptVerifyMessageSignature(PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara,
     BOOL ret = FALSE;
     HCRYPTMSG msg;
 
-    TRACE("(%p, %d, %p, %d, %p, %p, %p)\n",
+    TRACE("(%p, %ld, %p, %ld, %p, %p, %p)\n",
      pVerifyPara, dwSignerIndex, pbSignedBlob, cbSignedBlob,
      pbDecoded, pcbDecoded, ppSignerCert);
 
@@ -262,7 +262,7 @@ BOOL WINAPI CryptHashMessage(PCRYPT_HASH_MESSAGE_PARA pHashPara,
     HCRYPTMSG msg;
     CMSG_HASHED_ENCODE_INFO info;
 
-    TRACE("(%p, %d, %d, %p, %p, %p, %p, %p, %p)\n", pHashPara, fDetachedHash,
+    TRACE("(%p, %d, %ld, %p, %p, %p, %p, %p, %p)\n", pHashPara, fDetachedHash,
      cToBeHashed, rgpbToBeHashed, rgcbToBeHashed, pbHashedBlob, pcbHashedBlob,
      pbComputedHash, pcbComputedHash);
 
@@ -314,7 +314,7 @@ BOOL WINAPI CryptVerifyDetachedMessageHash(PCRYPT_HASH_MESSAGE_PARA pHashPara,
     HCRYPTMSG msg;
     BOOL ret = FALSE;
 
-    TRACE("(%p, %p, %d, %d, %p, %p, %p, %p)\n", pHashPara, pbDetachedHashBlob,
+    TRACE("(%p, %p, %ld, %ld, %p, %p, %p, %p)\n", pHashPara, pbDetachedHashBlob,
      cbDetachedHashBlob, cToBeHashed, rgpbToBeHashed, rgcbToBeHashed,
      pbComputedHash, pcbComputedHash);
 
@@ -368,7 +368,7 @@ BOOL WINAPI CryptVerifyMessageHash(PCRYPT_HASH_MESSAGE_PARA pHashPara,
     HCRYPTMSG msg;
     BOOL ret = FALSE;
 
-    TRACE("(%p, %p, %d, %p, %p, %p, %p)\n", pHashPara, pbHashedBlob,
+    TRACE("(%p, %p, %ld, %p, %p, %p, %p)\n", pHashPara, pbHashedBlob,
      cbHashedBlob, pbToBeHashed, pcbToBeHashed, pbComputedHash,
      pcbComputedHash);
 
@@ -416,7 +416,7 @@ BOOL WINAPI CryptSignMessage(PCRYPT_SIGN_MESSAGE_PARA pSignPara,
     CMSG_SIGNER_ENCODE_INFO signer;
     HCRYPTMSG msg = 0;
 
-    TRACE("(%p, %d, %d, %p, %p, %p, %p)\n", pSignPara, fDetachedSignature,
+    TRACE("(%p, %d, %ld, %p, %p, %p, %p)\n", pSignPara, fDetachedSignature,
      cToBeSigned, rgpbToBeSigned, rgcbToBeSigned, pbSignedBlob, pcbSignedBlob);
 
     if (pSignPara->cbSize != sizeof(CRYPT_SIGN_MESSAGE_PARA) ||
@@ -529,7 +529,7 @@ BOOL WINAPI CryptEncryptMessage(PCRYPT_ENCRYPT_MESSAGE_PARA pEncryptPara,
     CMSG_ENVELOPED_ENCODE_INFO envelopedInfo;
     HCRYPTMSG msg = 0;
 
-    TRACE("(%p, %d, %p, %p, %d, %p, %p)\n", pEncryptPara, cRecipientCert,
+    TRACE("(%p, %ld, %p, %p, %ld, %p, %p)\n", pEncryptPara, cRecipientCert,
      rgpRecipientCert, pbToBeEncrypted, cbToBeEncrypted, pbEncryptedBlob,
      pcbEncryptedBlob);
 

dlls/crypt32/msg.c

@@ -46,7 +46,7 @@ typedef BOOL (*CryptMsgControlFunc)(HCRYPTMSG hCryptMsg, DWORD dwFlags,
 static BOOL CRYPT_DefaultMsgControl(HCRYPTMSG hCryptMsg, DWORD dwFlags,
  DWORD dwCtrlType, const void *pvCtrlPara)
 {
-    TRACE("(%p, %08x, %d, %p)\n", hCryptMsg, dwFlags, dwCtrlType, pvCtrlPara);
+    TRACE("(%p, %08lx, %ld, %p)\n", hCryptMsg, dwFlags, dwCtrlType, pvCtrlPara);
     SetLastError(E_INVALIDARG);
     return FALSE;
 }
@@ -439,7 +439,7 @@ static BOOL CHashEncodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
     CHashEncodeMsg *msg = hCryptMsg;
     BOOL ret = FALSE;
 
-    TRACE("(%p, %d, %d, %p, %p)\n", hCryptMsg, dwParamType, dwIndex,
+    TRACE("(%p, %ld, %ld, %p, %p)\n", hCryptMsg, dwParamType, dwIndex,
      pvData, pcbData);
 
     switch (dwParamType)
@@ -506,7 +506,7 @@ static BOOL CHashEncodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
     CHashEncodeMsg *msg = hCryptMsg;
     BOOL ret = FALSE;
 
-    TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
+    TRACE("(%p, %p, %ld, %d)\n", hCryptMsg, pbData, cbData, fFinal);
 
     if (msg->base.state == MsgStateFinalized)
         SetLastError(CRYPT_E_MSG_ERROR);
@@ -2034,7 +2034,7 @@ HCRYPTMSG WINAPI CryptMsgOpenToEncode(DWORD dwMsgEncodingType, DWORD dwFlags,
 {
     HCRYPTMSG msg = NULL;
 
-    TRACE("(%08x, %08x, %08x, %p, %s, %p)\n", dwMsgEncodingType, dwFlags,
+    TRACE("(%08lx, %08lx, %08lx, %p, %s, %p)\n", dwMsgEncodingType, dwFlags,
      dwMsgType, pvMsgEncodeInfo, debugstr_a(pszInnerContentObjID), pStreamInfo);
 
     if (GET_CMSG_ENCODING_TYPE(dwMsgEncodingType) != PKCS_7_ASN_ENCODING)
@@ -2471,13 +2471,13 @@ static BOOL CDecodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
     CDecodeMsg *msg = hCryptMsg;
     BOOL ret = FALSE;
 
-    TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
+    TRACE("(%p, %p, %ld, %d)\n", hCryptMsg, pbData, cbData, fFinal);
 
     if (msg->base.state == MsgStateFinalized)
         SetLastError(CRYPT_E_MSG_ERROR);
     else if (msg->base.streamed)
     {
-        FIXME("(%p, %p, %d, %d): streamed update stub\n", hCryptMsg, pbData,
+        FIXME("(%p, %p, %ld, %d): streamed update stub\n", hCryptMsg, pbData,
          cbData, fFinal);
         switch (msg->base.state)
         {
@@ -2728,7 +2728,7 @@ static BOOL CRYPT_CopySignerInfo(void *pvData, DWORD *pcbData,
     DWORD size = sizeof(CMSG_SIGNER_INFO), rdnSize = 0;
     BOOL ret;
 
-    TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, in);
+    TRACE("(%p, %ld, %p)\n", pvData, pvData ? *pcbData : 0, in);
 
     if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
     {
@@ -2800,7 +2800,7 @@ static BOOL CRYPT_CopyCMSSignerInfo(void *pvData, DWORD *pcbData,
     DWORD size = sizeof(CMSG_CMS_SIGNER_INFO);
     BOOL ret;
 
-    TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, in);
+    TRACE("(%p, %ld, %p)\n", pvData, pvData ? *pcbData : 0, in);
 
     if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
     {
@@ -2867,7 +2867,7 @@ static BOOL CRYPT_CopySignerCertInfo(void *pvData, DWORD *pcbData,
     DWORD size = sizeof(CERT_INFO), rdnSize = 0;
     BOOL ret;
 
-    TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, in);
+    TRACE("(%p, %ld, %p)\n", pvData, pvData ? *pcbData : 0, in);
 
     if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
     {
@@ -2918,7 +2918,7 @@ static BOOL CRYPT_CopyRecipientInfo(void *pvData, DWORD *pcbData,
     DWORD size = sizeof(CERT_INFO);
     BOOL ret;
 
-    TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, in);
+    TRACE("(%p, %ld, %p)\n", pvData, pvData ? *pcbData : 0, in);
 
     size += in->SerialNumber.cbData;
     size += in->Issuer.cbData;
@@ -2989,7 +2989,7 @@ static BOOL CDecodeEnvelopedMsg_GetParam(CDecodeMsg *msg, DWORD dwParamType,
             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
         break;
     default:
-        FIXME("unimplemented for %d\n", dwParamType);
+        FIXME("unimplemented for %ld\n", dwParamType);
         SetLastError(CRYPT_E_INVALID_MSG_TYPE);
     }
     return ret;
@@ -3000,7 +3000,7 @@ static BOOL CRYPT_CopyAttr(void *pvData, DWORD *pcbData, const CRYPT_ATTRIBUTES
     DWORD size;
     BOOL ret;
 
-    TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, attr);
+    TRACE("(%p, %ld, %p)\n", pvData, pvData ? *pcbData : 0, attr);
 
     size = CRYPT_SizeOfAttributes(attr);
     if (!pvData)
@@ -3225,7 +3225,7 @@ static BOOL CDecodeSignedMsg_GetParam(CDecodeMsg *msg, DWORD dwParamType,
             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
         break;
     default:
-        FIXME("unimplemented for %d\n", dwParamType);
+        FIXME("unimplemented for %ld\n", dwParamType);
         SetLastError(CRYPT_E_INVALID_MSG_TYPE);
     }
     return ret;
@@ -3384,7 +3384,7 @@ static BOOL CDecodeSignedMsg_VerifySignature(CDecodeMsg *msg, PCERT_INFO info)
         }
         else
         {
-            FIXME("signer %d: unimplemented for key id\n", i);
+            FIXME("signer %ld: unimplemented for key id\n", i);
         }
     }
     if (ret)
@@ -3424,7 +3424,7 @@ static BOOL CDecodeSignedMsg_VerifySignatureEx(CDecodeMsg *msg,
             break;
         }
         default:
-            FIXME("unimplemented for signer type %d\n", para->dwSignerType);
+            FIXME("unimplemented for signer type %ld\n", para->dwSignerType);
             SetLastError(CRYPT_E_SIGNER_NOT_FOUND);
         }
     }
@@ -3608,7 +3608,7 @@ HCRYPTMSG WINAPI CryptMsgOpenToDecode(DWORD dwMsgEncodingType, DWORD dwFlags,
 {
     CDecodeMsg *msg;
 
-    TRACE("(%08x, %08x, %08x, %08lx, %p, %p)\n", dwMsgEncodingType,
+    TRACE("(%08lx, %08lx, %08lx, %08Ix, %p, %p)\n", dwMsgEncodingType,
      dwFlags, dwMsgType, hCryptProv, pRecipientInfo, pStreamInfo);
 
     if (GET_CMSG_ENCODING_TYPE(dwMsgEncodingType) != PKCS_7_ASN_ENCODING)
@@ -3671,7 +3671,7 @@ BOOL WINAPI CryptMsgUpdate(HCRYPTMSG hCryptMsg, const BYTE *pbData,
 {
     CryptMsgBase *msg = hCryptMsg;
 
-    TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
+    TRACE("(%p, %p, %ld, %d)\n", hCryptMsg, pbData, cbData, fFinal);
 
     return msg->update(hCryptMsg, pbData, cbData, fFinal);
 }
@@ -3681,7 +3681,7 @@ BOOL WINAPI CryptMsgGetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
 {
     CryptMsgBase *msg = hCryptMsg;
 
-    TRACE("(%p, %d, %d, %p, %p)\n", hCryptMsg, dwParamType, dwIndex,
+    TRACE("(%p, %ld, %ld, %p, %p)\n", hCryptMsg, dwParamType, dwIndex,
      pvData, pcbData);
     return msg->get_param(hCryptMsg, dwParamType, dwIndex, pvData, pcbData);
 }
@@ -3691,7 +3691,7 @@ BOOL WINAPI CryptMsgControl(HCRYPTMSG hCryptMsg, DWORD dwFlags,
 {
     CryptMsgBase *msg = hCryptMsg;
 
-    TRACE("(%p, %08x, %d, %p)\n", hCryptMsg, dwFlags, dwCtrlType,
+    TRACE("(%p, %08lx, %ld, %p)\n", hCryptMsg, dwFlags, dwCtrlType,
      pvCtrlPara);
     return msg->control(hCryptMsg, dwFlags, dwCtrlType, pvCtrlPara);
 }
@@ -3728,7 +3728,7 @@ BOOL WINAPI CryptMsgGetAndVerifySigner(HCRYPTMSG hCryptMsg, DWORD cSignerStore,
     PCCERT_CONTEXT signerCert = NULL;
     BOOL ret = FALSE;
 
-    TRACE("(%p, %d, %p, %08x, %p, %p)\n", hCryptMsg, cSignerStore,
+    TRACE("(%p, %ld, %p, %08lx, %p, %p)\n", hCryptMsg, cSignerStore,
      rghSignerStore, dwFlags, ppSigner, pdwSignerIndex);
 
     /* Clear output parameters */
@@ -3817,7 +3817,7 @@ BOOL WINAPI CryptMsgVerifyCountersignatureEncoded(HCRYPTPROV_LEGACY hCryptProv,
  PBYTE pbSignerInfoCountersignature, DWORD cbSignerInfoCountersignature,
  CERT_INFO *pciCountersigner)
 {
-    FIXME("(%08lx, %08x, %p, %d, %p, %d, %p): stub\n", hCryptProv,
+    FIXME("(%08Ix, %08lx, %p, %ld, %p, %ld, %p): stub\n", hCryptProv,
      dwEncodingType, pbSignerInfo, cbSignerInfo, pbSignerInfoCountersignature,
      cbSignerInfoCountersignature, pciCountersigner);
     return FALSE;
@@ -3828,7 +3828,7 @@ BOOL WINAPI CryptMsgVerifyCountersignatureEncodedEx(HCRYPTPROV_LEGACY hCryptProv
  PBYTE pbSignerInfoCountersignature, DWORD cbSignerInfoCountersignature,
  DWORD dwSignerType, void *pvSigner, DWORD dwFlags, void *pvReserved)
 {
-    FIXME("(%08lx, %08x, %p, %d, %p, %d, %d, %p, %08x, %p): stub\n", hCryptProv,
+    FIXME("(%08Ix, %08lx, %p, %ld, %p, %ld, %ld, %p, %08lx, %p): stub\n", hCryptProv,
      dwEncodingType, pbSignerInfo, cbSignerInfo, pbSignerInfoCountersignature,
      cbSignerInfoCountersignature, dwSignerType, pvSigner, dwFlags, pvReserved);
     return FALSE;
@@ -3842,12 +3842,12 @@ BOOL WINAPI CryptMsgEncodeAndSignCTL(DWORD dwMsgEncodingType,
     BYTE *pbCtlContent;
     DWORD cbCtlContent;
 
-    TRACE("(%08x, %p, %p, %08x, %p, %p)\n", dwMsgEncodingType, pCtlInfo,
+    TRACE("(%08lx, %p, %p, %08lx, %p, %p)\n", dwMsgEncodingType, pCtlInfo,
      pSignInfo, dwFlags, pbEncoded, pcbEncoded);
 
     if (dwFlags)
     {
-        FIXME("unimplemented for flags %08x\n", dwFlags);
+        FIXME("unimplemented for flags %08lx\n", dwFlags);
         return FALSE;
     }
     if ((ret = CryptEncodeObjectEx(dwMsgEncodingType, PKCS_CTL, pCtlInfo,
@@ -3868,12 +3868,12 @@ BOOL WINAPI CryptMsgSignCTL(DWORD dwMsgEncodingType, BYTE *pbCtlContent,
     BOOL ret;
     HCRYPTMSG msg;
 
-    TRACE("(%08x, %p, %d, %p, %08x, %p, %p)\n", dwMsgEncodingType,
+    TRACE("(%08lx, %p, %ld, %p, %08lx, %p, %p)\n", dwMsgEncodingType,
      pbCtlContent, cbCtlContent, pSignInfo, dwFlags, pbEncoded, pcbEncoded);
 
     if (dwFlags)
     {
-        FIXME("unimplemented for flags %08x\n", dwFlags);
+        FIXME("unimplemented for flags %08lx\n", dwFlags);
         return FALSE;
     }
     msg = CryptMsgOpenToEncode(dwMsgEncodingType, 0, CMSG_SIGNED, pSignInfo,

dlls/crypt32/object.c

@@ -328,7 +328,7 @@ static BOOL CRYPT_QuerySerializedStoreFromBlob(const CRYPT_DATA_BLOB *blob,
      CERT_STORE_CREATE_NEW_FLAG, NULL);
     BOOL ret;
 
-    TRACE("(%d, %p)\n", blob->cbData, blob->pbData);
+    TRACE("(%ld, %p)\n", blob->cbData, blob->pbData);
 
     ret = CRYPT_ReadSerializedStoreFromBlob(blob, store);
     if (ret)
@@ -358,7 +358,7 @@ static BOOL CRYPT_QuerySerializedStoreObject(DWORD dwObjectType,
         return CRYPT_QuerySerializedStoreFromBlob(pvObject,
          pdwMsgAndCertEncodingType, pdwContentType, phCertStore, phMsg);
     default:
-        FIXME("unimplemented for type %d\n", dwObjectType);
+        FIXME("unimplemented for type %ld\n", dwObjectType);
         SetLastError(E_INVALIDARG); /* FIXME: is this the correct error? */
         return FALSE;
     }
@@ -481,7 +481,7 @@ static BOOL CRYPT_QueryMessageObject(DWORD dwObjectType, const void *pvObject,
     DWORD encodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
     DWORD formatType = 0;
 
-    TRACE("(%d, %p, %08x, %08x, %p, %p, %p, %p, %p)\n", dwObjectType, pvObject,
+    TRACE("(%ld, %p, %08lx, %08lx, %p, %p, %p, %p, %p)\n", dwObjectType, pvObject,
      dwExpectedContentTypeFlags, dwExpectedFormatTypeFlags,
      pdwMsgAndCertEncodingType, pdwContentType, pdwFormatType, phCertStore,
      phMsg);
@@ -631,7 +631,7 @@ static BOOL CRYPT_QueryEmbeddedMessageObject(DWORD dwObjectType,
 
     if (dwObjectType != CERT_QUERY_OBJECT_FILE)
     {
-        WARN("don't know what to do for type %d embedded signed messages\n",
+        WARN("don't know what to do for type %ld embedded signed messages\n",
          dwObjectType);
         SetLastError(E_INVALIDARG);
         return FALSE;
@@ -703,7 +703,7 @@ static BOOL CRYPT_QueryPFXObject(DWORD dwObjectType, const void *pvObject,
     CRYPT_DATA_BLOB blob = {0}, *ptr;
     BOOL ret;
 
-    TRACE("(%d, %p, %08x, %08x, %p, %p, %p, %p, %p)\n", dwObjectType, pvObject,
+    TRACE("(%ld, %p, %08lx, %08lx, %p, %p, %p, %p, %p)\n", dwObjectType, pvObject,
      dwExpectedContentTypeFlags, dwExpectedFormatTypeFlags,
      pdwMsgAndCertEncodingType, pdwContentType, pdwFormatType, phCertStore,
      phMsg);
@@ -747,7 +747,7 @@ BOOL WINAPI CryptQueryObject(DWORD dwObjectType, const void *pvObject,
      CERT_QUERY_CONTENT_FLAG_PKCS10 | CERT_QUERY_CONTENT_FLAG_CERT_PAIR;
     BOOL ret = TRUE;
 
-    TRACE("(%08x, %p, %08x, %08x, %08x, %p, %p, %p, %p, %p, %p)\n",
+    TRACE("(%08lx, %p, %08lx, %08lx, %08lx, %p, %p, %p, %p, %p, %p)\n",
      dwObjectType, pvObject, dwExpectedContentTypeFlags,
      dwExpectedFormatTypeFlags, dwFlags, pdwMsgAndCertEncodingType,
      pdwContentType, pdwFormatType, phCertStore, phMsg, ppvContext);
@@ -755,7 +755,7 @@ BOOL WINAPI CryptQueryObject(DWORD dwObjectType, const void *pvObject,
     if (dwObjectType != CERT_QUERY_OBJECT_BLOB &&
      dwObjectType != CERT_QUERY_OBJECT_FILE)
     {
-        WARN("unsupported type %d\n", dwObjectType);
+        WARN("unsupported type %ld\n", dwObjectType);
         SetLastError(E_INVALIDARG);
         return FALSE;
     }
@@ -766,7 +766,7 @@ BOOL WINAPI CryptQueryObject(DWORD dwObjectType, const void *pvObject,
         return FALSE;
     }
     if (dwExpectedContentTypeFlags & unimplementedTypes)
-        WARN("unimplemented for types %08x\n",
+        WARN("unimplemented for types %08lx\n",
          dwExpectedContentTypeFlags & unimplementedTypes);
 
     if (pdwFormatType)
@@ -1290,14 +1290,14 @@ static BOOL CRYPT_FormatAltNameEntry(DWORD dwFormatStrType, DWORD indentLevel,
         }
         else
         {
-            FIXME("unknown IP address format (%d bytes)\n",
+            FIXME("unknown IP address format (%ld bytes)\n",
              entry->u.IPAddress.cbData);
             ret = FALSE;
         }
         break;
     }
     default:
-        FIXME("unimplemented for %d\n", entry->dwAltNameChoice);
+        FIXME("unimplemented for %ld\n", entry->dwAltNameChoice);
         ret = FALSE;
     }
     if (ret)
@@ -2590,7 +2590,7 @@ BOOL WINAPI CryptFormatObject(DWORD dwCertEncodingType, DWORD dwFormatType,
     HCRYPTOIDFUNCADDR hFunc = NULL;
     BOOL ret = FALSE;
 
-    TRACE("(%08x, %d, %08x, %p, %s, %p, %d, %p, %p)\n", dwCertEncodingType,
+    TRACE("(%08lx, %ld, %08lx, %p, %s, %p, %ld, %p, %p)\n", dwCertEncodingType,
      dwFormatType, dwFormatStrType, pFormatStruct, debugstr_a(lpszStructType),
      pbEncoded, cbEncoded, pbFormat, pcbFormat);
 

dlls/crypt32/oid.c

@@ -105,7 +105,7 @@ HCRYPTOIDFUNCSET WINAPI CryptInitOIDFunctionSet(LPCSTR pszFuncName,
 {
     struct OIDFunctionSet *cursor, *ret = NULL;
 
-    TRACE("(%s, %x)\n", debugstr_a(pszFuncName), dwFlags);
+    TRACE("(%s, %lx)\n", debugstr_a(pszFuncName), dwFlags);
 
     EnterCriticalSection(&funcSetCS);
     LIST_FOR_EACH_ENTRY(cursor, &funcSets, struct OIDFunctionSet, next)
@@ -147,7 +147,7 @@ static char *CRYPT_GetKeyName(DWORD dwEncodingType, LPCSTR pszFuncName,
  LPCSTR pszOID)
 {
     static const char szEncodingTypeFmt[] =
-     "Software\\Microsoft\\Cryptography\\OID\\EncodingType %d\\%s\\%s";
+     "Software\\Microsoft\\Cryptography\\OID\\EncodingType %ld\\%s\\%s";
     UINT len;
     char numericOID[7]; /* enough for "#65535" */
     const char *oid;
@@ -187,7 +187,7 @@ BOOL WINAPI CryptGetDefaultOIDDllList(HCRYPTOIDFUNCSET hFuncSet,
     HKEY key;
     LSTATUS rc;
 
-    TRACE("(%p, %d, %p, %p)\n", hFuncSet, dwEncodingType, pwszDllList,
+    TRACE("(%p, %ld, %p, %p)\n", hFuncSet, dwEncodingType, pwszDllList,
      pcchDllList);
 
     keyName = CRYPT_GetKeyName(dwEncodingType, set->name, "DEFAULT");
@@ -229,7 +229,7 @@ BOOL WINAPI CryptInstallOIDFunctionAddress(HMODULE hModule,
     BOOL ret = TRUE;
     struct OIDFunctionSet *set;
 
-    TRACE("(%p, %d, %s, %d, %p, %08x)\n", hModule, dwEncodingType,
+    TRACE("(%p, %ld, %s, %ld, %p, %08lx)\n", hModule, dwEncodingType,
      debugstr_a(pszFuncName), cFuncEntry, rgFuncEntry, dwFlags);
 
     set = CryptInitOIDFunctionSet(pszFuncName, 0);
@@ -379,7 +379,7 @@ BOOL WINAPI CryptGetOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet,
     BOOL ret = FALSE;
     struct OIDFunctionSet *set = hFuncSet;
 
-    TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet, dwEncodingType,
+    TRACE("(%p, %ld, %s, %08lx, %p, %p)\n", hFuncSet, dwEncodingType,
      debugstr_a(pszOID), dwFlags, ppvFuncAddr, phFuncAddr);
 
     *ppvFuncAddr = NULL;
@@ -456,7 +456,7 @@ static BOOL is_module_registered(HMODULE hModule)
 BOOL WINAPI CryptFreeOIDFunctionAddress(HCRYPTOIDFUNCADDR hFuncAddr,
  DWORD dwFlags)
 {
-    TRACE("(%p, %08x)\n", hFuncAddr, dwFlags);
+    TRACE("(%p, %08lx)\n", hFuncAddr, dwFlags);
 
     /* FIXME: as MSDN states, need to check for DllCanUnloadNow in the DLL,
      * and only unload it if it can be unloaded.  Also need to implement ref
@@ -503,7 +503,7 @@ BOOL WINAPI CryptGetDefaultOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet,
     struct OIDFunctionSet *set = hFuncSet;
     BOOL ret = FALSE;
 
-    TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet, dwEncodingType,
+    TRACE("(%p, %ld, %s, %08lx, %p, %p)\n", hFuncSet, dwEncodingType,
      debugstr_w(pwszDll), dwFlags, ppvFuncAddr, phFuncAddr);
 
     if (pwszDll)
@@ -639,7 +639,7 @@ BOOL WINAPI CryptRegisterOIDFunction(DWORD dwEncodingType, LPCSTR pszFuncName,
     HKEY hKey;
     LPSTR szKey;
 
-    TRACE("(%x, %s, %s, %s, %s)\n", dwEncodingType, debugstr_a(pszFuncName),
+    TRACE("(%lx, %s, %s, %s, %s)\n", dwEncodingType, debugstr_a(pszFuncName),
           debugstr_a(pszOID), debugstr_w(pwszDll), debugstr_a(pszOverrideFuncName));
 
     /* Native does nothing pwszDll is NULL */
@@ -717,7 +717,7 @@ BOOL WINAPI CryptUnregisterOIDInfo(PCCRYPT_OID_INFO info)
     key_name = CryptMemAlloc(strlen(info->pszOID) + 16);
     if (key_name)
     {
-        sprintf(key_name, "%s!%u", info->pszOID, info->dwGroupId);
+        sprintf(key_name, "%s!%lu", info->pszOID, info->dwGroupId);
         err = RegDeleteKeyA(root, key_name);
     }
     else
@@ -741,7 +741,7 @@ BOOL WINAPI CryptRegisterOIDInfo(PCCRYPT_OID_INFO info, DWORD flags)
     HKEY root = 0, key = 0;
     DWORD err;
 
-    TRACE("(%p, %x)\n", info, flags );
+    TRACE("(%p, %lx)\n", info, flags );
 
     if (!info || info->cbSize != sizeof(*info) || !info->pszOID)
     {
@@ -762,7 +762,7 @@ BOOL WINAPI CryptRegisterOIDInfo(PCCRYPT_OID_INFO info, DWORD flags)
                           0, NULL, 0, KEY_ALL_ACCESS, NULL, &root, NULL);
     if (err != ERROR_SUCCESS) goto done;
 
-    sprintf(key_name, "%s!%u", info->pszOID, info->dwGroupId);
+    sprintf(key_name, "%s!%lu", info->pszOID, info->dwGroupId);
     err = RegCreateKeyA(root, key_name, &key);
     if (err != ERROR_SUCCESS) goto done;
 
@@ -822,7 +822,7 @@ BOOL WINAPI CryptUnregisterOIDFunction(DWORD dwEncodingType, LPCSTR pszFuncName,
     LPSTR szKey;
     LONG rc;
 
-    TRACE("%x %s %s\n", dwEncodingType, debugstr_a(pszFuncName),
+    TRACE("%lx %s %s\n", dwEncodingType, debugstr_a(pszFuncName),
      debugstr_a(pszOID));
 
     if (!pszFuncName || !pszOID)
@@ -847,7 +847,7 @@ BOOL WINAPI CryptGetOIDFunctionValue(DWORD dwEncodingType, LPCSTR pszFuncName,
     LONG rc;
     HKEY hKey;
 
-    TRACE("%x %s %s %s %p %p %p\n", dwEncodingType, debugstr_a(pszFuncName),
+    TRACE("%lx %s %s %s %p %p %p\n", dwEncodingType, debugstr_a(pszFuncName),
      debugstr_a(pszOID), debugstr_w(pwszValueName), pdwValueType, pbValueData,
      pcbValueData);
 
@@ -884,7 +884,7 @@ BOOL WINAPI CryptSetOIDFunctionValue(DWORD dwEncodingType, LPCSTR pszFuncName,
     LONG rc;
     HKEY hKey;
 
-    TRACE("%x %s %s %s %d %p %d\n", dwEncodingType, debugstr_a(pszFuncName),
+    TRACE("%lx %s %s %s %ld %p %ld\n", dwEncodingType, debugstr_a(pszFuncName),
      debugstr_a(pszOID), debugstr_w(pwszValueName), dwValueType, pbValueData,
      cbValueData);
 
@@ -1101,7 +1101,7 @@ BOOL WINAPI CryptRegisterDefaultOIDFunction(DWORD dwEncodingType,
     LPWSTR dlls;
     BOOL ret = FALSE;
 
-    TRACE("(%x, %s, %d, %s)\n", dwEncodingType, debugstr_a(pszFuncName),
+    TRACE("(%lx, %s, %ld, %s)\n", dwEncodingType, debugstr_a(pszFuncName),
      dwIndex, debugstr_w(pwszDll));
 
     if (!pwszDll)
@@ -1134,7 +1134,7 @@ BOOL WINAPI CryptUnregisterDefaultOIDFunction(DWORD dwEncodingType,
     LPWSTR dlls;
     BOOL ret;
 
-    TRACE("(%x, %s, %s)\n", dwEncodingType, debugstr_a(pszFuncName),
+    TRACE("(%lx, %s, %s)\n", dwEncodingType, debugstr_a(pszFuncName),
      debugstr_w(pwszDll));
 
     if (!pwszDll)
@@ -1584,7 +1584,7 @@ static void init_registered_oid_info(void)
         {
             if ((info = read_oid_info(root, key_name, &flags)))
             {
-                TRACE("adding oid %s, name %s, groupid %u, algid %u, extra %u, CNG algid %s, CNG extra %s\n",
+                TRACE("adding oid %s, name %s, groupid %lu, algid %u, extra %lu, CNG algid %s, CNG extra %s\n",
                       debugstr_a(info->info.pszOID), debugstr_w(info->info.pwszName),
                       info->info.dwGroupId, info->info.u.Algid, info->info.ExtraInfo.cbData,
                       debugstr_w(info->info.pwszCNGAlgid), debugstr_w(info->info.pwszCNGExtraAlgid));
@@ -1692,7 +1692,7 @@ BOOL WINAPI CryptEnumOIDInfo(DWORD dwGroupId, DWORD dwFlags, void *pvArg,
     BOOL ret = TRUE;
     struct OIDInfo *info;
 
-    TRACE("(%d, %08x, %p, %p)\n", dwGroupId, dwFlags, pvArg,
+    TRACE("(%ld, %08lx, %p, %p)\n", dwGroupId, dwFlags, pvArg,
      pfnEnumOIDInfo);
 
     EnterCriticalSection(&oidInfoCS);
@@ -1714,7 +1714,7 @@ PCCRYPT_OID_INFO WINAPI CryptFindOIDInfo(DWORD dwKeyType, void *pvKey,
 {
     PCCRYPT_OID_INFO ret = NULL;
 
-    TRACE("(%d, %p, %d)\n", dwKeyType, pvKey, dwGroupId);
+    TRACE("(%ld, %p, %ld)\n", dwKeyType, pvKey, dwGroupId);
 
     switch(dwKeyType)
     {
@@ -1722,7 +1722,7 @@ PCCRYPT_OID_INFO WINAPI CryptFindOIDInfo(DWORD dwKeyType, void *pvKey,
     {
         struct OIDInfo *info;
 
-        TRACE("CRYPT_OID_INFO_ALGID_KEY: %d\n", *(DWORD *)pvKey);
+        TRACE("CRYPT_OID_INFO_ALGID_KEY: %ld\n", *(DWORD *)pvKey);
         EnterCriticalSection(&oidInfoCS);
         LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
         {
@@ -1777,7 +1777,7 @@ PCCRYPT_OID_INFO WINAPI CryptFindOIDInfo(DWORD dwKeyType, void *pvKey,
     {
         struct OIDInfo *info;
 
-        TRACE("CRYPT_OID_INFO_SIGN_KEY: %d\n", *(DWORD *)pvKey);
+        TRACE("CRYPT_OID_INFO_SIGN_KEY: %ld\n", *(DWORD *)pvKey);
         EnterCriticalSection(&oidInfoCS);
         LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
         {

dlls/crypt32/pfx.c

@@ -50,7 +50,7 @@ static HCRYPTPROV import_key( cert_store_data_t data, DWORD flags )
         acquire_flags &= ~CRYPT_NEWKEYSET;
         if (!CryptAcquireContextW( &prov, NULL, MS_ENHANCED_PROV_W, PROV_RSA_FULL, acquire_flags ))
         {
-            WARN( "CryptAcquireContextW failed %08x\n", GetLastError() );
+            WARN( "CryptAcquireContextW failed %08lx\n", GetLastError() );
             return 0;
         }
     }
@@ -59,7 +59,7 @@ static HCRYPTPROV import_key( cert_store_data_t data, DWORD flags )
     if (CRYPT32_CALL( import_store_key, &params ) ||
         !CryptImportKey( prov, key, size, 0, flags & CRYPT_EXPORTABLE, &cryptkey ))
     {
-        WARN( "CryptImportKey failed %08x\n", GetLastError() );
+        WARN( "CryptImportKey failed %08lx\n", GetLastError() );
         CryptReleaseContext( prov, 0 );
         free( key );
         return 0;
@@ -156,7 +156,7 @@ HCERTSTORE WINAPI PFXImportCertStore( CRYPT_DATA_BLOB *pfx, const WCHAR *passwor
     }
     if (flags & ~(CRYPT_EXPORTABLE|CRYPT_USER_KEYSET|CRYPT_MACHINE_KEYSET|PKCS12_NO_PERSIST_KEY))
     {
-        FIXME( "flags %08x not supported\n", flags );
+        FIXME( "flags %08lx not supported\n", flags );
         return NULL;
     }
     if (CRYPT32_CALL( open_cert_store, &open_params )) return NULL;
@@ -166,7 +166,7 @@ HCERTSTORE WINAPI PFXImportCertStore( CRYPT_DATA_BLOB *pfx, const WCHAR *passwor
 
     if (!(store = CertOpenStore( CERT_STORE_PROV_MEMORY, 0, 0, 0, NULL )))
     {
-        WARN( "CertOpenStore failed %08x\n", GetLastError() );
+        WARN( "CertOpenStore failed %08lx\n", GetLastError() );
         goto error;
     }
 
@@ -183,27 +183,27 @@ HCERTSTORE WINAPI PFXImportCertStore( CRYPT_DATA_BLOB *pfx, const WCHAR *passwor
         free( cert );
         if (!ctx)
         {
-            WARN( "CertCreateContext failed %08x\n", GetLastError() );
+            WARN( "CertCreateContext failed %08lx\n", GetLastError() );
             goto error;
         }
         if (flags & PKCS12_NO_PERSIST_KEY)
         {
             if (!set_key_context( ctx, prov ))
             {
-                WARN( "failed to set context property %08x\n", GetLastError() );
+                WARN( "failed to set context property %08lx\n", GetLastError() );
                 CertFreeCertificateContext( ctx );
                 goto error;
             }
         }
         else if (!set_key_prov_info( ctx, prov ))
         {
-            WARN( "failed to set provider info property %08x\n", GetLastError() );
+            WARN( "failed to set provider info property %08lx\n", GetLastError() );
             CertFreeCertificateContext( ctx );
             goto error;
         }
         if (!CertAddCertificateContextToStore( store, ctx, CERT_STORE_ADD_ALWAYS, NULL ))
         {
-            WARN( "CertAddCertificateContextToStore failed %08x\n", GetLastError() );
+            WARN( "CertAddCertificateContextToStore failed %08lx\n", GetLastError() );
             CertFreeCertificateContext( ctx );
             goto error;
         }
@@ -224,7 +224,7 @@ error:
 
 BOOL WINAPI PFXVerifyPassword( CRYPT_DATA_BLOB *pfx, const WCHAR *password, DWORD flags )
 {
-    FIXME( "(%p, %p, %08x): stub\n", pfx, password, flags );
+    FIXME( "(%p, %p, %08lx): stub\n", pfx, password, flags );
     return FALSE;
 }
 
@@ -236,6 +236,6 @@ BOOL WINAPI PFXExportCertStore( HCERTSTORE store, CRYPT_DATA_BLOB *pfx, const WC
 BOOL WINAPI PFXExportCertStoreEx( HCERTSTORE store, CRYPT_DATA_BLOB *pfx, const WCHAR *password, void *reserved,
                                   DWORD flags )
 {
-    FIXME( "(%p, %p, %p, %p, %08x): stub\n", store, pfx, password, reserved, flags );
+    FIXME( "(%p, %p, %p, %p, %08lx): stub\n", store, pfx, password, reserved, flags );
     return FALSE;
 }

dlls/crypt32/proplist.c

@@ -75,7 +75,7 @@ BOOL ContextPropertyList_FindProperty(CONTEXT_PROPERTY_LIST *list, DWORD id,
     CONTEXT_PROPERTY *prop;
     BOOL ret = FALSE;
 
-    TRACE("(%p, %d, %p)\n", list, id, blob);
+    TRACE("(%p, %ld, %p)\n", list, id, blob);
 
     EnterCriticalSection(&list->cs);
     LIST_FOR_EACH_ENTRY(prop, &list->properties, CONTEXT_PROPERTY, entry)

dlls/crypt32/protectdata.c

@@ -330,7 +330,7 @@ BOOL serialize(const struct protect_data_t *pInfo, DATA_BLOB *pSerial)
 
     if (ptr - pSerial->pbData != dwStruct)
     {
-        ERR("struct size changed!? expected %u\n", dwStruct);
+        ERR("struct size changed!? expected %lu\n", dwStruct);
         LocalFree(pSerial->pbData);
         pSerial->pbData=NULL;
         pSerial->cbData=0;
@@ -475,7 +475,7 @@ BOOL unserialize(const DATA_BLOB *pSerial, struct protect_data_t *pInfo)
     {
         /* this is an impossible-to-reach test, but if the padding
          * issue is ever understood, this may become more useful */
-        ERR("loaded corrupt structure! (used %u expected %u)\n", index, size);
+        ERR("loaded corrupt structure! (used %lu expected %lu)\n", index, size);
         status=FALSE;
     }
 
@@ -772,15 +772,15 @@ report(const DATA_BLOB* pDataIn, const DATA_BLOB* pOptionalEntropy,
     TRACE("pPromptStruct: %p\n", pPromptStruct);
     if (pPromptStruct)
     {
-        TRACE("  cbSize: 0x%x\n", pPromptStruct->cbSize);
-        TRACE("  dwPromptFlags: 0x%x\n", pPromptStruct->dwPromptFlags);
+        TRACE("  cbSize: 0x%lx\n", pPromptStruct->cbSize);
+        TRACE("  dwPromptFlags: 0x%lx\n", pPromptStruct->dwPromptFlags);
         TRACE("  hwndApp: %p\n", pPromptStruct->hwndApp);
         TRACE("  szPrompt: %p %s\n",
               pPromptStruct->szPrompt,
               pPromptStruct->szPrompt ? debugstr_w(pPromptStruct->szPrompt)
               : "");
     }
-    TRACE("dwFlags: 0x%04x\n", dwFlags);
+    TRACE("dwFlags: 0x%04lx\n", dwFlags);
     TRACE_DATA_BLOB(pDataIn);
     if (pOptionalEntropy)
     {
@@ -888,7 +888,7 @@ BOOL WINAPI CryptProtectData(DATA_BLOB* pDataIn,
         ERR("CryptEncrypt\n");
         goto free_hash;
     }
-    TRACE("required encrypted storage: %u\n", dwLength);
+    TRACE("required encrypted storage: %lu\n", dwLength);
 
     /* copy plain text into cipher area for CryptEncrypt call */
     protect_data.cipher.cbData=dwLength;
@@ -905,7 +905,7 @@ BOOL WINAPI CryptProtectData(DATA_BLOB* pDataIn,
     if (!CryptEncrypt(hKey, hHash, TRUE, 0, protect_data.cipher.pbData,
                       &dwLength, protect_data.cipher.cbData))
     {
-        ERR("CryptEncrypt %u\n", GetLastError());
+        ERR("CryptEncrypt %lu\n", GetLastError());
         goto free_hash;
     }
     protect_data.cipher.cbData=dwLength;

dlls/crypt32/provstore.c

@@ -46,7 +46,7 @@ typedef struct _WINE_PROVIDERSTORE
 static void ProvStore_addref(WINECRYPT_CERTSTORE *store)
 {
     LONG ref = InterlockedIncrement(&store->ref);
-    TRACE("ref = %d\n", ref);
+    TRACE("ref = %ld\n", ref);
 }
 
 static DWORD ProvStore_release(WINECRYPT_CERTSTORE *cert_store, DWORD flags)
@@ -55,10 +55,10 @@ static DWORD ProvStore_release(WINECRYPT_CERTSTORE *cert_store, DWORD flags)
     LONG ref;
 
     if(flags)
-        FIXME("Unimplemented flags %x\n", flags);
+        FIXME("Unimplemented flags %lx\n", flags);
 
     ref = InterlockedDecrement(&store->hdr.ref);
-    TRACE("(%p) ref=%d\n", store, ref);
+    TRACE("(%p) ref=%ld\n", store, ref);
 
     if(ref)
         return ERROR_SUCCESS;
@@ -275,7 +275,7 @@ static BOOL ProvStore_control(WINECRYPT_CERTSTORE *cert_store, DWORD dwFlags, DW
     WINE_PROVIDERSTORE *store = (WINE_PROVIDERSTORE*)cert_store;
     BOOL ret = TRUE;
 
-    TRACE("(%p, %08x, %d, %p)\n", store, dwFlags, dwCtrlType,
+    TRACE("(%p, %08lx, %ld, %p)\n", store, dwFlags, dwCtrlType,
      pvCtrlPara);
 
     if (store->provControl)

dlls/crypt32/regstore.c

@@ -316,9 +316,9 @@ static void WINAPI CRYPT_RegCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
 {
     WINE_REGSTOREINFO *store = hCertStore;
 
-    TRACE("(%p, %08x)\n", store, dwFlags);
+    TRACE("(%p, %08lx)\n", store, dwFlags);
     if (dwFlags)
-        FIXME("Unimplemented flags: %08x\n", dwFlags);
+        FIXME("Unimplemented flags: %08lx\n", dwFlags);
 
     CRYPT_RegFlushStore(store, FALSE);
     RegCloseKey(store->key);
@@ -388,7 +388,7 @@ static BOOL WINAPI CRYPT_RegWriteCert(HCERTSTORE hCertStore,
 {
     WINE_REGSTOREINFO *store = hCertStore;
 
-    TRACE("(%p, %p, %d)\n", hCertStore, cert, dwFlags);
+    TRACE("(%p, %p, %ld)\n", hCertStore, cert, dwFlags);
 
     return CRYPT_RegWriteContext(store, cert, dwFlags);
 }
@@ -398,7 +398,7 @@ static BOOL WINAPI CRYPT_RegDeleteCert(HCERTSTORE hCertStore,
 {
     WINE_REGSTOREINFO *store = hCertStore;
 
-    TRACE("(%p, %p, %08x)\n", store, pCertContext, dwFlags);
+    TRACE("(%p, %p, %08lx)\n", store, pCertContext, dwFlags);
 
     return CRYPT_RegDeleteContext(store, &store->certsToDelete, pCertContext,
      pCertInterface);
@@ -409,7 +409,7 @@ static BOOL WINAPI CRYPT_RegWriteCRL(HCERTSTORE hCertStore,
 {
     WINE_REGSTOREINFO *store = hCertStore;
 
-    TRACE("(%p, %p, %d)\n", hCertStore, crl, dwFlags);
+    TRACE("(%p, %p, %ld)\n", hCertStore, crl, dwFlags);
 
     return CRYPT_RegWriteContext(store, crl, dwFlags);
 }
@@ -419,7 +419,7 @@ static BOOL WINAPI CRYPT_RegDeleteCRL(HCERTSTORE hCertStore,
 {
     WINE_REGSTOREINFO *store = hCertStore;
 
-    TRACE("(%p, %p, %08x)\n", store, pCrlContext, dwFlags);
+    TRACE("(%p, %p, %08lx)\n", store, pCrlContext, dwFlags);
 
     return CRYPT_RegDeleteContext(store, &store->crlsToDelete, pCrlContext,
      pCRLInterface);
@@ -430,7 +430,7 @@ static BOOL WINAPI CRYPT_RegWriteCTL(HCERTSTORE hCertStore,
 {
     WINE_REGSTOREINFO *store = hCertStore;
 
-    TRACE("(%p, %p, %d)\n", hCertStore, ctl, dwFlags);
+    TRACE("(%p, %p, %ld)\n", hCertStore, ctl, dwFlags);
 
     return CRYPT_RegWriteContext(store, ctl, dwFlags);
 }
@@ -440,7 +440,7 @@ static BOOL WINAPI CRYPT_RegDeleteCTL(HCERTSTORE hCertStore,
 {
     WINE_REGSTOREINFO *store = hCertStore;
 
-    TRACE("(%p, %p, %08x)\n", store, pCtlContext, dwFlags);
+    TRACE("(%p, %p, %08lx)\n", store, pCtlContext, dwFlags);
 
     return CRYPT_RegDeleteContext(store, &store->ctlsToDelete, pCtlContext,
      pCTLInterface);
@@ -452,7 +452,7 @@ static BOOL WINAPI CRYPT_RegControl(HCERTSTORE hCertStore, DWORD dwFlags,
     WINE_REGSTOREINFO *store = hCertStore;
     BOOL ret = TRUE;
 
-    TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
+    TRACE("(%p, %08lx, %ld, %p)\n", hCertStore, dwFlags, dwCtrlType,
      pvCtrlPara);
 
     switch (dwCtrlType)
@@ -479,7 +479,7 @@ static BOOL WINAPI CRYPT_RegControl(HCERTSTORE hCertStore, DWORD dwFlags,
         FIXME("CERT_STORE_CTRL_NOTIFY_CHANGE: stub\n");
         break;
     default:
-        FIXME("%u: stub\n", dwCtrlType);
+        FIXME("%lu: stub\n", dwCtrlType);
         ret = FALSE;
     }
     return ret;
@@ -507,7 +507,7 @@ WINECRYPT_CERTSTORE *CRYPT_RegOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags,
 {
     WINECRYPT_CERTSTORE *store = NULL;
 
-    TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
+    TRACE("(%Id, %08lx, %p)\n", hCryptProv, dwFlags, pvPara);
 
     if (dwFlags & CERT_STORE_DELETE_FLAG)
     {

dlls/crypt32/rootstore.c

@@ -166,7 +166,7 @@ static void check_and_store_certs(HCERTSTORE from, HCERTSTORE to)
         } while (cert);
         CertFreeCertificateChainEngine(engine);
     }
-    TRACE("Added %d root certificates\n", root_count);
+    TRACE("Added %ld root certificates\n", root_count);
 }
 
 static const BYTE authenticode[] = {
@@ -605,7 +605,7 @@ static void add_ms_root_certs(HCERTSTORE to)
     for (i = 0; i < ARRAY_SIZE(msRootCerts); i++)
         if (!CertAddEncodedCertificateToStore(to, X509_ASN_ENCODING,
          msRootCerts[i].pb, msRootCerts[i].cb, CERT_STORE_ADD_NEW, NULL))
-            WARN("adding root cert %d failed: %08x\n", i, GetLastError());
+            WARN("adding root cert %ld failed: %08lx\n", i, GetLastError());
 }
 
 /* Reads certificates from the list of known locations into store.  Stops when
@@ -685,7 +685,7 @@ void CRYPT_ImportSystemRootCertsToReg(void)
             if (!rc)
             {
                 if (!CRYPT_SerializeContextsToReg(key, REG_OPTION_VOLATILE, pCertInterface, store))
-                    ERR("Failed to import system certs into registry, %08x\n", GetLastError());
+                    ERR("Failed to import system certs into registry, %08lx\n", GetLastError());
                 RegCloseKey(key);
             }
             CertCloseStore(store, 0);

dlls/crypt32/serialize.c

@@ -123,7 +123,7 @@ static BOOL CRYPT_SerializeStoreElement(const void *context,
 {
     BOOL ret;
 
-    TRACE("(%p, %p, %08x, %d, %p, %p)\n", context, contextInterface, dwFlags,
+    TRACE("(%p, %p, %08lx, %d, %p, %p)\n", context, contextInterface, dwFlags,
      omitHashes, pbElement, pcbElement);
 
     if (context)
@@ -382,7 +382,7 @@ static DWORD read_serialized_KeyProvInfoProperty(const struct store_CRYPT_KEY_PR
     else
         info->rgProvParam = NULL;
 
-    TRACE("%s,%s,%u,%08x,%u,%p,%u\n", debugstr_w(info->pwszContainerName), debugstr_w(info->pwszProvName),
+    TRACE("%s,%s,%lu,%08lx,%lu,%p,%lu\n", debugstr_w(info->pwszContainerName), debugstr_w(info->pwszProvName),
           info->dwProvType, info->dwFlags, info->cProvParam, info->rgProvParam, info->dwKeySpec);
 
     *ret = info;
@@ -478,7 +478,7 @@ const void *CRYPT_ReadSerializedElement(const BYTE *pbElement, DWORD cbElement,
 {
     const void *context;
 
-    TRACE("(%p, %d, %08x, %p)\n", pbElement, cbElement, dwContextTypeFlags,
+    TRACE("(%p, %ld, %08lx, %p)\n", pbElement, cbElement, dwContextTypeFlags,
      pdwContentType);
 
     if (!cbElement)
@@ -565,7 +565,7 @@ const void *CRYPT_ReadSerializedElement(const BYTE *pbElement, DWORD cbElement,
                     const WINE_CERT_PROP_HEADER *hdr =
                      (const WINE_CERT_PROP_HEADER *)pbElement;
 
-                    TRACE("prop is %d\n", hdr->propID);
+                    TRACE("prop is %ld\n", hdr->propID);
                     cbElement -= sizeof(WINE_CERT_PROP_HEADER);
                     pbElement += sizeof(WINE_CERT_PROP_HEADER);
                     if (!hdr->propID)
@@ -685,7 +685,7 @@ static BOOL CRYPT_ReadSerializedStore(void *handle,
                             {
                                 if (!contextInterface)
                                 {
-                                    WARN("prop id %d before a context id\n",
+                                    WARN("prop id %ld before a context id\n",
                                      propHdr.propID);
                                     ret = FALSE;
                                 }
@@ -879,7 +879,7 @@ static BOOL CRYPT_SavePKCSToMem(HCERTSTORE store,
     DWORD size;
     BOOL ret = TRUE;
 
-    TRACE("(%d, %p)\n", blob->pbData ? blob->cbData : 0, blob->pbData);
+    TRACE("(%ld, %p)\n", blob->pbData ? blob->cbData : 0, blob->pbData);
 
     do {
         cert = CertEnumCertificatesInStore(store, cert);
@@ -1080,7 +1080,7 @@ BOOL WINAPI CertSaveStore(HCERTSTORE hCertStore, DWORD dwMsgAndCertEncodingType,
     void *handle;
     BOOL ret, closeFile = TRUE;
 
-    TRACE("(%p, %08x, %d, %d, %p, %08x)\n", hCertStore,
+    TRACE("(%p, %08lx, %ld, %ld, %p, %08lx)\n", hCertStore,
           dwMsgAndCertEncodingType, dwSaveAs, dwSaveTo, pvSaveToPara, dwFlags);
 
     switch (dwSaveAs)
@@ -1098,7 +1098,7 @@ BOOL WINAPI CertSaveStore(HCERTSTORE hCertStore, DWORD dwMsgAndCertEncodingType,
             saveFunc = CRYPT_SavePKCSToFile;
         break;
     default:
-        WARN("unimplemented for %d\n", dwSaveAs);
+        WARN("unimplemented for %ld\n", dwSaveAs);
         SetLastError(ERROR_INVALID_PARAMETER);
         return FALSE;
     }
@@ -1120,7 +1120,7 @@ BOOL WINAPI CertSaveStore(HCERTSTORE hCertStore, DWORD dwMsgAndCertEncodingType,
         handle = pvSaveToPara;
         break;
     default:
-        WARN("unimplemented for %d\n", dwSaveTo);
+        WARN("unimplemented for %ld\n", dwSaveTo);
         SetLastError(ERROR_INVALID_PARAMETER);
         return FALSE;
     }
@@ -1139,7 +1139,7 @@ BOOL WINAPI CertAddSerializedElementToStore(HCERTSTORE hCertStore,
     DWORD type;
     BOOL ret;
 
-    TRACE("(%p, %p, %d, %08x, %08x, %08x, %p, %p)\n", hCertStore,
+    TRACE("(%p, %p, %ld, %08lx, %08lx, %08lx, %p, %p)\n", hCertStore,
      pbElement, cbElement, dwAddDisposition, dwFlags, dwContextTypeFlags,
      pdwContentType, ppvContext);
 

dlls/crypt32/sip.c

@@ -352,7 +352,7 @@ BOOL WINAPI CryptSIPRetrieveSubjectGuid
     {
         DWORD fileLen = GetFileSize(hFile, NULL);
 
-        TRACE("fileLen = %d\n", fileLen);
+        TRACE("fileLen = %ld\n", fileLen);
         /* Sanity-check length */
         if (hdr[1] < 0x80 && fileLen == 2 + hdr[1])
         {
@@ -657,7 +657,7 @@ error:
 BOOL WINAPI CryptSIPLoad
        (const GUID *pgSubject, DWORD dwFlags, SIP_DISPATCH_INFO *pSipDispatch)
 {
-    TRACE("(%s %d %p)\n", debugstr_guid(pgSubject), dwFlags, pSipDispatch);
+    TRACE("(%s %ld %p)\n", debugstr_guid(pgSubject), dwFlags, pSipDispatch);
 
     if (!pgSubject || dwFlags != 0 || !pSipDispatch)
     {
@@ -708,7 +708,7 @@ BOOL WINAPI CryptSIPGetSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD* pdwEn
     WINE_SIP_PROVIDER *sip;
     BOOL ret = FALSE;
 
-    TRACE("(%p %p %d %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex,
+    TRACE("(%p %p %ld %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex,
           pcbSignedDataMsg, pbSignedDataMsg);
 
     if ((sip = CRYPT_GetCachedSIP(pSubjectInfo->pgSubjectType)))
@@ -727,7 +727,7 @@ BOOL WINAPI CryptSIPPutSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD pdwEnc
     WINE_SIP_PROVIDER *sip;
     BOOL ret = FALSE;
 
-    TRACE("(%p %d %p %d %p)\n", pSubjectInfo, pdwEncodingType, pdwIndex,
+    TRACE("(%p %ld %p %ld %p)\n", pSubjectInfo, pdwEncodingType, pdwIndex,
           cbSignedDataMsg, pbSignedDataMsg);
 
     if ((sip = CRYPT_GetCachedSIP(pSubjectInfo->pgSubjectType)))
@@ -746,7 +746,7 @@ BOOL WINAPI CryptSIPRemoveSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo,
     WINE_SIP_PROVIDER *sip;
     BOOL ret = FALSE;
 
-    TRACE("(%p %d)\n", pSubjectInfo, dwIndex);
+    TRACE("(%p %ld)\n", pSubjectInfo, dwIndex);
 
     if ((sip = CRYPT_GetCachedSIP(pSubjectInfo->pgSubjectType)))
         ret = sip->info.pfRemove(pSubjectInfo, dwIndex);

dlls/crypt32/str.c

@@ -34,7 +34,7 @@ DWORD WINAPI CertRDNValueToStrA(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
 {
     DWORD ret = 0, len;
 
-    TRACE("(%d, %p, %p, %d)\n", dwValueType, pValue, psz, csz);
+    TRACE("(%ld, %p, %p, %ld)\n", dwValueType, pValue, psz, csz);
 
     switch (dwValueType)
     {
@@ -82,7 +82,7 @@ DWORD WINAPI CertRDNValueToStrA(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
         }
         break;
     default:
-        FIXME("string type %d unimplemented\n", dwValueType);
+        FIXME("string type %ld unimplemented\n", dwValueType);
     }
     if (psz && csz)
     {
@@ -92,7 +92,7 @@ DWORD WINAPI CertRDNValueToStrA(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
     }
     else
         ret++;
-    TRACE("returning %d (%s)\n", ret, debugstr_a(psz));
+    TRACE("returning %ld (%s)\n", ret, debugstr_a(psz));
     return ret;
 }
 
@@ -101,7 +101,7 @@ DWORD WINAPI CertRDNValueToStrW(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
 {
     DWORD ret = 0, len, i, strLen;
 
-    TRACE("(%d, %p, %p, %d)\n", dwValueType, pValue, psz, csz);
+    TRACE("(%ld, %p, %p, %ld)\n", dwValueType, pValue, psz, csz);
 
     switch (dwValueType)
     {
@@ -142,7 +142,7 @@ DWORD WINAPI CertRDNValueToStrW(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
         }
         break;
     default:
-        FIXME("string type %d unimplemented\n", dwValueType);
+        FIXME("string type %ld unimplemented\n", dwValueType);
     }
     if (psz && csz)
     {
@@ -152,7 +152,7 @@ DWORD WINAPI CertRDNValueToStrW(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
     }
     else
         ret++;
-    TRACE("returning %d (%s)\n", ret, debugstr_w(psz));
+    TRACE("returning %ld (%s)\n", ret, debugstr_w(psz));
     return ret;
 }
 
@@ -181,7 +181,7 @@ static DWORD quote_rdn_value_to_str_a(DWORD dwValueType,
     DWORD ret = 0, len, i;
     BOOL needsQuotes = FALSE;
 
-    TRACE("(%d, %p, %p, %d)\n", dwValueType, pValue, psz, csz);
+    TRACE("(%ld, %p, %p, %ld)\n", dwValueType, pValue, psz, csz);
 
     switch (dwValueType)
     {
@@ -270,7 +270,7 @@ static DWORD quote_rdn_value_to_str_a(DWORD dwValueType,
         }
         break;
     default:
-        FIXME("string type %d unimplemented\n", dwValueType);
+        FIXME("string type %ld unimplemented\n", dwValueType);
     }
     if (psz && csz)
     {
@@ -280,7 +280,7 @@ static DWORD quote_rdn_value_to_str_a(DWORD dwValueType,
     }
     else
         ret++;
-    TRACE("returning %d (%s)\n", ret, debugstr_a(psz));
+    TRACE("returning %ld (%s)\n", ret, debugstr_a(psz));
     return ret;
 }
 
@@ -290,7 +290,7 @@ static DWORD quote_rdn_value_to_str_w(DWORD dwValueType,
     DWORD ret = 0, len, i, strLen;
     BOOL needsQuotes = FALSE;
 
-    TRACE("(%d, %p, %p, %d)\n", dwValueType, pValue, psz, csz);
+    TRACE("(%ld, %p, %p, %ld)\n", dwValueType, pValue, psz, csz);
 
     switch (dwValueType)
     {
@@ -373,7 +373,7 @@ static DWORD quote_rdn_value_to_str_w(DWORD dwValueType,
         }
         break;
     default:
-        FIXME("string type %d unimplemented\n", dwValueType);
+        FIXME("string type %ld unimplemented\n", dwValueType);
     }
     if (psz && csz)
     {
@@ -383,7 +383,7 @@ static DWORD quote_rdn_value_to_str_w(DWORD dwValueType,
     }
     else
         ret++;
-    TRACE("returning %d (%s)\n", ret, debugstr_w(psz));
+    TRACE("returning %ld (%s)\n", ret, debugstr_w(psz));
     return ret;
 }
 
@@ -396,7 +396,7 @@ static DWORD CRYPT_AddPrefixA(LPCSTR prefix, LPSTR psz, DWORD csz)
 {
     DWORD chars;
 
-    TRACE("(%s, %p, %d)\n", debugstr_a(prefix), psz, csz);
+    TRACE("(%s, %p, %ld)\n", debugstr_a(prefix), psz, csz);
 
     if (psz)
     {
@@ -424,10 +424,10 @@ DWORD WINAPI CertNameToStrA(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName,
     BOOL bRet;
     CERT_NAME_INFO *info;
 
-    TRACE("(%d, %p, %08x, %p, %d)\n", dwCertEncodingType, pName, dwStrType,
+    TRACE("(%ld, %p, %08lx, %p, %ld)\n", dwCertEncodingType, pName, dwStrType,
      psz, csz);
     if (dwStrType & unsupportedFlags)
-        FIXME("unsupported flags: %08x\n", dwStrType & unsupportedFlags);
+        FIXME("unsupported flags: %08lx\n", dwStrType & unsupportedFlags);
 
     bRet = CryptDecodeObjectEx(dwCertEncodingType, X509_NAME, pName->pbData,
      pName->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &bytes);
@@ -530,7 +530,7 @@ static DWORD CRYPT_AddPrefixAToW(LPCSTR prefix, LPWSTR psz, DWORD csz)
 {
     DWORD chars;
 
-    TRACE("(%s, %p, %d)\n", debugstr_a(prefix), psz, csz);
+    TRACE("(%s, %p, %ld)\n", debugstr_a(prefix), psz, csz);
 
     if (psz)
     {
@@ -556,7 +556,7 @@ static DWORD CRYPT_AddPrefixW(LPCWSTR prefix, LPWSTR psz, DWORD csz)
 {
     DWORD chars;
 
-    TRACE("(%s, %p, %d)\n", debugstr_w(prefix), psz, csz);
+    TRACE("(%s, %p, %ld)\n", debugstr_w(prefix), psz, csz);
 
     if (psz)
     {
@@ -582,7 +582,7 @@ DWORD cert_name_to_str_with_indent(DWORD dwCertEncodingType, DWORD indentLevel,
     CERT_NAME_INFO *info;
 
     if (dwStrType & unsupportedFlags)
-        FIXME("unsupported flags: %08x\n", dwStrType & unsupportedFlags);
+        FIXME("unsupported flags: %08lx\n", dwStrType & unsupportedFlags);
 
     bRet = CryptDecodeObjectEx(dwCertEncodingType, X509_NAME, pName->pbData,
      pName->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &bytes);
@@ -698,7 +698,7 @@ DWORD WINAPI CertNameToStrW(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName,
 {
     BOOL ret;
 
-    TRACE("(%d, %p, %08x, %p, %d)\n", dwCertEncodingType, pName, dwStrType,
+    TRACE("(%ld, %p, %08lx, %p, %ld)\n", dwCertEncodingType, pName, dwStrType,
      psz, csz);
 
     ret = cert_name_to_str_with_indent(dwCertEncodingType, 0, pName, dwStrType,
@@ -714,7 +714,7 @@ BOOL WINAPI CertStrToNameA(DWORD dwCertEncodingType, LPCSTR pszX500,
     BOOL ret;
     int len;
 
-    TRACE("(%08x, %s, %08x, %p, %p, %p, %p)\n", dwCertEncodingType,
+    TRACE("(%08lx, %s, %08lx, %p, %p, %p, %p)\n", dwCertEncodingType,
      debugstr_a(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded,
      ppszError);
 
@@ -1025,7 +1025,7 @@ BOOL WINAPI CertStrToNameW(DWORD dwCertEncodingType, LPCWSTR pszX500,
     DWORD i;
     BOOL ret = TRUE;
 
-    TRACE("(%08x, %s, %08x, %p, %p, %p, %p)\n", dwCertEncodingType,
+    TRACE("(%08lx, %s, %08lx, %p, %p, %p, %p)\n", dwCertEncodingType,
      debugstr_w(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded,
      ppszError);
 
@@ -1118,7 +1118,7 @@ DWORD WINAPI CertGetNameStringA(PCCERT_CONTEXT pCertContext, DWORD dwType,
 {
     DWORD ret;
 
-    TRACE("(%p, %d, %08x, %p, %p, %d)\n", pCertContext, dwType, dwFlags,
+    TRACE("(%p, %ld, %08lx, %p, %p, %ld)\n", pCertContext, dwType, dwFlags,
      pvTypePara, pszNameString, cchNameString);
 
     if (pszNameString)
@@ -1221,7 +1221,7 @@ DWORD WINAPI CertGetNameStringW(PCCERT_CONTEXT pCertContext, DWORD dwType,
     PCERT_NAME_BLOB name;
     LPCSTR altNameOID;
 
-    TRACE("(%p, %d, %08x, %p, %p, %d)\n", pCertContext, dwType,
+    TRACE("(%p, %ld, %08lx, %p, %p, %ld)\n", pCertContext, dwType,
      dwFlags, pvTypePara, pszNameString, cchNameString);
 
     if (!pCertContext)
@@ -1410,7 +1410,7 @@ DWORD WINAPI CertGetNameStringW(PCCERT_CONTEXT pCertContext, DWORD dwType,
         break;
     }
     default:
-        FIXME("unimplemented for type %d\n", dwType);
+        FIXME("unimplemented for type %ld\n", dwType);
         ret = 0;
     }
 done: