ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

crypt32: Win64 printf format warning fixes.

This commit is contained in:
Juan Lang 2006-10-03 21:58:09 -07:00 committed by Alexandre Julliard
parent 92afe743ef
commit f3a1f2bf60
14 changed files with 228 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dlls/crypt32/Makefile.in
View File

@ -1,4 +1,4 @@
EXTRADEFS = -D_CRYPT32_ -DWINE_NO_LONG_AS_INT EXTRADEFS = -D_CRYPT32_
TOPSRCDIR = @top_srcdir@ TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ../.. TOPOBJDIR = ../..
SRCDIR = @srcdir@ SRCDIR = @srcdir@

8
dlls/crypt32/base64.c
View File

@ -222,7 +222,7 @@ BOOL WINAPI CryptBinaryToStringA(const BYTE *pbBinary,
{ {
BinaryToStringAFunc encoder = NULL; BinaryToStringAFunc encoder = NULL;
TRACE("(%p, %ld, %08lx, %p, %p)\n", pbBinary, cbBinary, dwFlags, pszString, TRACE("(%p, %d, %08x, %p, %p)\n", pbBinary, cbBinary, dwFlags, pszString,
pcchString); pcchString);
if (!pbBinary) if (!pbBinary)
@ -251,7 +251,7 @@ BOOL WINAPI CryptBinaryToStringA(const BYTE *pbBinary,
case CRYPT_STRING_HEXASCII: case CRYPT_STRING_HEXASCII:
case CRYPT_STRING_HEXADDR: case CRYPT_STRING_HEXADDR:
case CRYPT_STRING_HEXASCIIADDR: case CRYPT_STRING_HEXASCIIADDR:
FIXME("Unimplemented type %ld\n", dwFlags & 0x7fffffff); FIXME("Unimplemented type %d\n", dwFlags & 0x7fffffff);
/* fall through */ /* fall through */
default: default:
SetLastError(ERROR_INVALID_PARAMETER); SetLastError(ERROR_INVALID_PARAMETER);
@ -523,7 +523,7 @@ BOOL WINAPI CryptStringToBinaryA(LPCSTR pszString,
StringToBinaryAFunc decoder; StringToBinaryAFunc decoder;
LONG ret; LONG ret;
TRACE("(%s, %ld, %08lx, %p, %p, %p, %p)\n", debugstr_a(pszString), TRACE("(%s, %d, %08x, %p, %p, %p, %p)\n", debugstr_a(pszString),
cchString, dwFlags, pbBinary, pcbBinary, pdwSkip, pdwFlags); cchString, dwFlags, pbBinary, pcbBinary, pdwSkip, pdwFlags);
if (!pszString) if (!pszString)
@ -564,7 +564,7 @@ BOOL WINAPI CryptStringToBinaryA(LPCSTR pszString,
case CRYPT_STRING_HEXASCII: case CRYPT_STRING_HEXASCII:
case CRYPT_STRING_HEXADDR: case CRYPT_STRING_HEXADDR:
case CRYPT_STRING_HEXASCIIADDR: case CRYPT_STRING_HEXASCIIADDR:
FIXME("Unimplemented type %ld\n", dwFlags & 0x7fffffff); FIXME("Unimplemented type %d\n", dwFlags & 0x7fffffff);
/* fall through */ /* fall through */
default: default:
SetLastError(ERROR_INVALID_PARAMETER); SetLastError(ERROR_INVALID_PARAMETER);

54
dlls/crypt32/cert.c
View File

@ -54,7 +54,7 @@ BOOL WINAPI CertAddEncodedCertificateToStore(HCERTSTORE hCertStore,
pbCertEncoded, cbCertEncoded); pbCertEncoded, cbCertEncoded);
BOOL ret; BOOL ret;
TRACE("(%p, %08lx, %p, %ld, %08lx, %p)\n", hCertStore, dwCertEncodingType, TRACE("(%p, %08x, %p, %d, %08x, %p)\n", hCertStore, dwCertEncodingType,
pbCertEncoded, cbCertEncoded, dwAddDisposition, ppCertContext); pbCertEncoded, cbCertEncoded, dwAddDisposition, ppCertContext);
if (cert) if (cert)
@ -76,7 +76,7 @@ PCCERT_CONTEXT WINAPI CertCreateCertificateContext(DWORD dwCertEncodingType,
PCERT_INFO certInfo = NULL; PCERT_INFO certInfo = NULL;
DWORD size = 0; DWORD size = 0;
TRACE("(%08lx, %p, %ld)\n", dwCertEncodingType, pbCertEncoded, TRACE("(%08x, %p, %d)\n", dwCertEncodingType, pbCertEncoded,
cbCertEncoded); cbCertEncoded);
ret = CryptDecodeObjectEx(dwCertEncodingType, X509_CERT_TO_BE_SIGNED, ret = CryptDecodeObjectEx(dwCertEncodingType, X509_CERT_TO_BE_SIGNED,
@ -141,7 +141,7 @@ DWORD WINAPI CertEnumCertificateContextProperties(PCCERT_CONTEXT pCertContext,
(void *)pCertContext, sizeof(CERT_CONTEXT)); (void *)pCertContext, sizeof(CERT_CONTEXT));
DWORD ret; DWORD ret;
TRACE("(%p, %ld)\n", pCertContext, dwPropId); TRACE("(%p, %d)\n", pCertContext, dwPropId);
if (properties) if (properties)
ret = ContextPropertyList_EnumPropIDs(properties, dwPropId); ret = ContextPropertyList_EnumPropIDs(properties, dwPropId);
@ -174,7 +174,7 @@ static BOOL WINAPI CertContext_GetProperty(void *context, DWORD dwPropId,
BOOL ret; BOOL ret;
CRYPT_DATA_BLOB blob; CRYPT_DATA_BLOB blob;
TRACE("(%p, %ld, %p, %p)\n", context, dwPropId, pvData, pcbData); TRACE("(%p, %d, %p, %p)\n", context, dwPropId, pvData, pcbData);
if (properties) if (properties)
ret = ContextPropertyList_FindProperty(properties, dwPropId, &blob); ret = ContextPropertyList_FindProperty(properties, dwPropId, &blob);
@ -272,7 +272,7 @@ BOOL WINAPI CertGetCertificateContextProperty(PCCERT_CONTEXT pCertContext,
{ {
BOOL ret; BOOL ret;
TRACE("(%p, %ld, %p, %p)\n", pCertContext, dwPropId, pvData, pcbData); TRACE("(%p, %d, %p, %p)\n", pCertContext, dwPropId, pvData, pcbData);
switch (dwPropId) switch (dwPropId)
{ {
@ -422,7 +422,7 @@ static BOOL WINAPI CertContext_SetProperty(void *context, DWORD dwPropId,
Context_GetProperties(context, sizeof(CERT_CONTEXT)); Context_GetProperties(context, sizeof(CERT_CONTEXT));
BOOL ret; BOOL ret;
TRACE("(%p, %ld, %08lx, %p)\n", context, dwPropId, dwFlags, pvData); TRACE("(%p, %d, %08x, %p)\n", context, dwPropId, dwFlags, pvData);
if (!properties) if (!properties)
ret = FALSE; ret = FALSE;
@ -519,7 +519,7 @@ static BOOL WINAPI CertContext_SetProperty(void *context, DWORD dwPropId,
break; break;
} }
default: default:
FIXME("%ld: stub\n", dwPropId); FIXME("%d: stub\n", dwPropId);
ret = FALSE; ret = FALSE;
} }
} }
@ -532,7 +532,7 @@ BOOL WINAPI CertSetCertificateContextProperty(PCCERT_CONTEXT pCertContext,
{ {
BOOL ret; BOOL ret;
TRACE("(%p, %ld, %08lx, %p)\n", pCertContext, dwPropId, dwFlags, pvData); TRACE("(%p, %d, %08x, %p)\n", pCertContext, dwPropId, dwFlags, pvData);
/* Handle special cases for "read-only"/invalid prop IDs. Windows just /* Handle special cases for "read-only"/invalid prop IDs. Windows just
* crashes on most of these, I'll be safer. * crashes on most of these, I'll be safer.
@ -613,7 +613,7 @@ BOOL WINAPI CryptAcquireCertificatePrivateKey(PCCERT_CONTEXT pCert,
CERT_KEY_CONTEXT keyContext; CERT_KEY_CONTEXT keyContext;
DWORD size; DWORD size;
TRACE("(%p, %08lx, %p, %p, %p, %p)\n", pCert, dwFlags, pvReserved, TRACE("(%p, %08x, %p, %p, %p, %p)\n", pCert, dwFlags, pvReserved,
phCryptProv, pdwKeySpec, pfCallerFreeProv); phCryptProv, pdwKeySpec, pfCallerFreeProv);
if (dwFlags & CRYPT_ACQUIRE_USE_PROV_INFO_FLAG) if (dwFlags & CRYPT_ACQUIRE_USE_PROV_INFO_FLAG)
@ -682,7 +682,7 @@ BOOL WINAPI CryptAcquireCertificatePrivateKey(PCCERT_CONTEXT pCert,
BOOL WINAPI CertCompareCertificate(DWORD dwCertEncodingType, BOOL WINAPI CertCompareCertificate(DWORD dwCertEncodingType,
PCERT_INFO pCertId1, PCERT_INFO pCertId2) PCERT_INFO pCertId1, PCERT_INFO pCertId2)
{ {
TRACE("(%08lx, %p, %p)\n", dwCertEncodingType, pCertId1, pCertId2); TRACE("(%08x, %p, %p)\n", dwCertEncodingType, pCertId1, pCertId2);
return CertCompareCertificateName(dwCertEncodingType, &pCertId1->Issuer, return CertCompareCertificateName(dwCertEncodingType, &pCertId1->Issuer,
&pCertId2->Issuer) && CertCompareIntegerBlob(&pCertId1->SerialNumber, &pCertId2->Issuer) && CertCompareIntegerBlob(&pCertId1->SerialNumber,
@ -694,7 +694,7 @@ BOOL WINAPI CertCompareCertificateName(DWORD dwCertEncodingType,
{ {
BOOL ret; BOOL ret;
TRACE("(%08lx, %p, %p)\n", dwCertEncodingType, pCertName1, pCertName2); TRACE("(%08x, %p, %p)\n", dwCertEncodingType, pCertName1, pCertName2);
if (pCertName1->cbData == pCertName2->cbData) if (pCertName1->cbData == pCertName2->cbData)
{ {
@ -756,7 +756,7 @@ BOOL WINAPI CertComparePublicKeyInfo(DWORD dwCertEncodingType,
{ {
BOOL ret; BOOL ret;
TRACE("(%08lx, %p, %p)\n", dwCertEncodingType, pPublicKey1, pPublicKey2); TRACE("(%08x, %p, %p)\n", dwCertEncodingType, pPublicKey1, pPublicKey2);
if (pPublicKey1->PublicKey.cbData == pPublicKey2->PublicKey.cbData && if (pPublicKey1->PublicKey.cbData == pPublicKey2->PublicKey.cbData &&
pPublicKey1->PublicKey.cUnusedBits == pPublicKey2->PublicKey.cUnusedBits) pPublicKey1->PublicKey.cUnusedBits == pPublicKey2->PublicKey.cUnusedBits)
@ -777,7 +777,7 @@ DWORD WINAPI CertGetPublicKeyLength(DWORD dwCertEncodingType,
{ {
DWORD len = 0; DWORD len = 0;
TRACE("(%08lx, %p)\n", dwCertEncodingType, pPublicKey); TRACE("(%08x, %p)\n", dwCertEncodingType, pPublicKey);
if (dwCertEncodingType != X509_ASN_ENCODING) if (dwCertEncodingType != X509_ASN_ENCODING)
{ {
@ -900,7 +900,7 @@ PCCERT_CONTEXT WINAPI CertFindCertificateInStore(HCERTSTORE hCertStore,
PCCERT_CONTEXT ret; PCCERT_CONTEXT ret;
CertCompareFunc compare; CertCompareFunc compare;
TRACE("(%p, %ld, %ld, %ld, %p, %p)\n", hCertStore, dwCertEncodingType, TRACE("(%p, %d, %d, %d, %p, %p)\n", hCertStore, dwCertEncodingType,
dwFlags, dwType, pvPara, pPrevCertContext); dwFlags, dwType, pvPara, pPrevCertContext);
switch (dwType >> CERT_COMPARE_SHIFT) switch (dwType >> CERT_COMPARE_SHIFT)
@ -924,7 +924,7 @@ PCCERT_CONTEXT WINAPI CertFindCertificateInStore(HCERTSTORE hCertStore,
compare = compare_cert_by_issuer; compare = compare_cert_by_issuer;
break; break;
default: default:
FIXME("find type %08lx unimplemented\n", dwType); FIXME("find type %08x unimplemented\n", dwType);
compare = NULL; compare = NULL;
} }
@ -952,7 +952,7 @@ PCCERT_CONTEXT WINAPI CertFindCertificateInStore(HCERTSTORE hCertStore,
PCCERT_CONTEXT WINAPI CertGetSubjectCertificateFromStore(HCERTSTORE hCertStore, PCCERT_CONTEXT WINAPI CertGetSubjectCertificateFromStore(HCERTSTORE hCertStore,
DWORD dwCertEncodingType, PCERT_INFO pCertId) DWORD dwCertEncodingType, PCERT_INFO pCertId)
{ {
TRACE("(%p, %08lx, %p)\n", hCertStore, dwCertEncodingType, pCertId); TRACE("(%p, %08x, %p)\n", hCertStore, dwCertEncodingType, pCertId);
if (!pCertId) if (!pCertId)
{ {
@ -1011,7 +1011,7 @@ PCCERT_CONTEXT WINAPI CertGetIssuerCertificateFromStore(HCERTSTORE hCertStore,
{ {
PCCERT_CONTEXT ret; PCCERT_CONTEXT ret;
TRACE("(%p, %p, %p, %08lx)\n", hCertStore, pSubjectContext, TRACE("(%p, %p, %p, %08x)\n", hCertStore, pSubjectContext,
pPrevIssuerContext, *pdwFlags); pPrevIssuerContext, *pdwFlags);
if (!pSubjectContext) if (!pSubjectContext)
@ -1042,7 +1042,7 @@ PCRYPT_ATTRIBUTE WINAPI CertFindAttribute(LPCSTR pszObjId, DWORD cAttr,
PCRYPT_ATTRIBUTE ret = NULL; PCRYPT_ATTRIBUTE ret = NULL;
DWORD i; DWORD i;
TRACE("%s %ld %p\n", debugstr_a(pszObjId), cAttr, rgAttr); TRACE("%s %d %p\n", debugstr_a(pszObjId), cAttr, rgAttr);
if (!cAttr) if (!cAttr)
return NULL; return NULL;
@ -1064,7 +1064,7 @@ PCERT_EXTENSION WINAPI CertFindExtension(LPCSTR pszObjId, DWORD cExtensions,
PCERT_EXTENSION ret = NULL; PCERT_EXTENSION ret = NULL;
DWORD i; DWORD i;
TRACE("%s %ld %p\n", debugstr_a(pszObjId), cExtensions, rgExtensions); TRACE("%s %d %p\n", debugstr_a(pszObjId), cExtensions, rgExtensions);
if (!cExtensions) if (!cExtensions)
return NULL; return NULL;
@ -1132,7 +1132,7 @@ BOOL WINAPI CryptHashCertificate(HCRYPTPROV hCryptProv, ALG_ID Algid,
BOOL ret = TRUE; BOOL ret = TRUE;
HCRYPTHASH hHash = 0; HCRYPTHASH hHash = 0;
TRACE("(%ld, %d, %08lx, %p, %ld, %p, %p)\n", hCryptProv, Algid, dwFlags, TRACE("(%08lx, %d, %08x, %p, %d, %p, %p)\n", hCryptProv, Algid, dwFlags,
pbEncoded, cbEncoded, pbComputedHash, pcbComputedHash); pbEncoded, cbEncoded, pbComputedHash, pcbComputedHash);
if (!hCryptProv) if (!hCryptProv)
@ -1161,7 +1161,7 @@ BOOL WINAPI CryptHashPublicKeyInfo(HCRYPTPROV hCryptProv, ALG_ID Algid,
BOOL ret = TRUE; BOOL ret = TRUE;
HCRYPTHASH hHash = 0; HCRYPTHASH hHash = 0;
TRACE("(%ld, %d, %08lx, %ld, %p, %p, %p)\n", hCryptProv, Algid, dwFlags, TRACE("(%08lx, %d, %08x, %d, %p, %p, %p)\n", hCryptProv, Algid, dwFlags,
dwCertEncodingType, pInfo, pbComputedHash, pcbComputedHash); dwCertEncodingType, pInfo, pbComputedHash, pcbComputedHash);
if (!hCryptProv) if (!hCryptProv)
@ -1201,7 +1201,7 @@ BOOL WINAPI CryptSignCertificate(HCRYPTPROV hCryptProv, DWORD dwKeySpec,
PCCRYPT_OID_INFO info; PCCRYPT_OID_INFO info;
HCRYPTHASH hHash; HCRYPTHASH hHash;
TRACE("(%08lx, %ld, %ld, %p, %ld, %p, %p, %p, %p)\n", hCryptProv, TRACE("(%08lx, %d, %d, %p, %d, %p, %p, %p, %p)\n", hCryptProv,
dwKeySpec, dwCertEncodingType, pbEncodedToBeSigned, cbEncodedToBeSigned, dwKeySpec, dwCertEncodingType, pbEncodedToBeSigned, cbEncodedToBeSigned,
pSignatureAlgorithm, pvHashAuxInfo, pbSignature, pcbSignature); pSignatureAlgorithm, pvHashAuxInfo, pbSignature, pcbSignature);
@ -1259,7 +1259,7 @@ BOOL WINAPI CryptSignAndEncodeCertificate(HCRYPTPROV hCryptProv,
BOOL ret; BOOL ret;
DWORD encodedSize, hashSize; DWORD encodedSize, hashSize;
TRACE("(%08lx, %ld, %ld, %s, %p, %p, %p, %p, %p)\n", hCryptProv, dwKeySpec, TRACE("(%08lx, %d, %d, %s, %p, %p, %p, %p, %p)\n", hCryptProv, dwKeySpec,
dwCertEncodingType, debugstr_a(lpszStructType), pvStructInfo, dwCertEncodingType, debugstr_a(lpszStructType), pvStructInfo,
pSignatureAlgorithm, pvHashAuxInfo, pbEncoded, pcbEncoded); pSignatureAlgorithm, pvHashAuxInfo, pbEncoded, pcbEncoded);
@ -1394,7 +1394,7 @@ BOOL WINAPI CryptVerifyCertificateSignatureEx(HCRYPTPROV hCryptProv,
BOOL ret = TRUE; BOOL ret = TRUE;
CRYPT_DATA_BLOB subjectBlob; CRYPT_DATA_BLOB subjectBlob;
TRACE("(%08lx, %ld, %ld, %p, %ld, %p, %08lx, %p)\n", hCryptProv, TRACE("(%08lx, %d, %d, %p, %d, %p, %08x, %p)\n", hCryptProv,
dwCertEncodingType, dwSubjectType, pvSubject, dwIssuerType, pvIssuer, dwCertEncodingType, dwSubjectType, pvSubject, dwIssuerType, pvIssuer,
dwFlags, pvReserved); dwFlags, pvReserved);
@ -1493,7 +1493,7 @@ BOOL WINAPI CertGetEnhancedKeyUsage(PCCERT_CONTEXT pCertContext, DWORD dwFlags,
return FALSE; return FALSE;
} }
TRACE("(%p, %08lx, %p, %ld)\n", pCertContext, dwFlags, pUsage, *pcbUsage); TRACE("(%p, %08x, %p, %d)\n", pCertContext, dwFlags, pUsage, *pcbUsage);
if (!(dwFlags & CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG)) if (!(dwFlags & CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG))
{ {
@ -1747,7 +1747,7 @@ BOOL WINAPI CertGetValidUsages(DWORD cCerts, PCCERT_CONTEXT *rghCerts,
BOOL allUsagesValid = TRUE; BOOL allUsagesValid = TRUE;
CERT_ENHKEY_USAGE validUsages = { 0, NULL }; CERT_ENHKEY_USAGE validUsages = { 0, NULL };
TRACE("(%ld, %p, %p, %p, %ld)\n", cCerts, *rghCerts, cNumOIDSs, TRACE("(%d, %p, %p, %p, %d)\n", cCerts, *rghCerts, cNumOIDSs,
rghOIDs, *pcbOIDs); rghOIDs, *pcbOIDs);
for (i = 0; ret && i < cCerts; i++) for (i = 0; ret && i < cCerts; i++)
@ -2143,7 +2143,7 @@ PCCERT_CONTEXT WINAPI CertCreateSelfSignCertificate(HCRYPTPROV hProv,
PCERT_PUBLIC_KEY_INFO pubKey = NULL; PCERT_PUBLIC_KEY_INFO pubKey = NULL;
DWORD pubKeySize = 0; DWORD pubKeySize = 0;
TRACE("(0x%08lx, %p, %08lx, %p, %p, %p, %p, %p)\n", hProv, TRACE("(%08lx, %p, %08x, %p, %p, %p, %p, %p)\n", hProv,
pSubjectIssuerBlob, dwFlags, pKeyProvInfo, pSignatureAlgorithm, pStartTime, pSubjectIssuerBlob, dwFlags, pKeyProvInfo, pSignatureAlgorithm, pStartTime,
pExtensions, pExtensions); pExtensions, pExtensions);

4
dlls/crypt32/context.c
View File

@ -94,7 +94,7 @@ void *Context_CreateLinkContext(unsigned int contextSize, void *linked, unsigned
linkContext->linked = linkedBase; linkContext->linked = linkedBase;
if (addRef) if (addRef)
InterlockedIncrement(&linkedBase->ref); InterlockedIncrement(&linkedBase->ref);
TRACE("%p's ref count is %ld\n", context, linkContext->ref); TRACE("%p's ref count is %d\n", context, linkContext->ref);
} }
return context; return context;
} }
@ -161,7 +161,7 @@ void Context_Release(void *context, size_t contextSize,
CryptMemFree(context); CryptMemFree(context);
} }
else else
TRACE("%p's ref count is %ld\n", context, base->ref); TRACE("%p's ref count is %d\n", context, base->ref);
} }
void Context_CopyProperties(const void *to, const void *from, void Context_CopyProperties(const void *to, const void *from,

28
dlls/crypt32/crl.c
View File

@ -35,7 +35,7 @@ PCCRL_CONTEXT WINAPI CertCreateCRLContext(DWORD dwCertEncodingType,
PCRL_INFO crlInfo = NULL; PCRL_INFO crlInfo = NULL;
DWORD size = 0; DWORD size = 0;
TRACE("(%08lx, %p, %ld)\n", dwCertEncodingType, pbCrlEncoded, TRACE("(%08x, %p, %d)\n", dwCertEncodingType, pbCrlEncoded,
cbCrlEncoded); cbCrlEncoded);
if ((dwCertEncodingType & CERT_ENCODING_TYPE_MASK) != X509_ASN_ENCODING) if ((dwCertEncodingType & CERT_ENCODING_TYPE_MASK) != X509_ASN_ENCODING)
@ -80,7 +80,7 @@ BOOL WINAPI CertAddEncodedCRLToStore(HCERTSTORE hCertStore,
pbCrlEncoded, cbCrlEncoded); pbCrlEncoded, cbCrlEncoded);
BOOL ret; BOOL ret;
TRACE("(%p, %08lx, %p, %ld, %08lx, %p)\n", hCertStore, dwCertEncodingType, TRACE("(%p, %08x, %p, %d, %08x, %p)\n", hCertStore, dwCertEncodingType,
pbCrlEncoded, cbCrlEncoded, dwAddDisposition, ppCrlContext); pbCrlEncoded, cbCrlEncoded, dwAddDisposition, ppCrlContext);
if (crl) if (crl)
@ -144,7 +144,7 @@ PCCRL_CONTEXT WINAPI CertFindCRLInStore(HCERTSTORE hCertStore,
PCCRL_CONTEXT ret; PCCRL_CONTEXT ret;
CrlCompareFunc compare; CrlCompareFunc compare;
TRACE("(%p, %ld, %ld, %ld, %p, %p)\n", hCertStore, dwCertEncodingType, TRACE("(%p, %d, %d, %d, %p, %p)\n", hCertStore, dwCertEncodingType,
dwFindFlags, dwFindType, pvFindPara, pPrevCrlContext); dwFindFlags, dwFindType, pvFindPara, pPrevCrlContext);
switch (dwFindType) switch (dwFindType)
@ -159,7 +159,7 @@ PCCRL_CONTEXT WINAPI CertFindCRLInStore(HCERTSTORE hCertStore,
compare = compare_crl_existing; compare = compare_crl_existing;
break; break;
default: default:
FIXME("find type %08lx unimplemented\n", dwFindType); FIXME("find type %08x unimplemented\n", dwFindType);
compare = NULL; compare = NULL;
} }
@ -192,7 +192,7 @@ PCCRL_CONTEXT WINAPI CertGetCRLFromStore(HCERTSTORE hCertStore,
CERT_STORE_DELTA_CRL_FLAG; CERT_STORE_DELTA_CRL_FLAG;
PCCRL_CONTEXT ret; PCCRL_CONTEXT ret;
TRACE("(%p, %p, %p, %08lx)\n", hCertStore, pIssuerContext, pPrevCrlContext, TRACE("(%p, %p, %p, %08x)\n", hCertStore, pIssuerContext, pPrevCrlContext,
*pdwFlags); *pdwFlags);
if (*pdwFlags & ~supportedFlags) if (*pdwFlags & ~supportedFlags)
@ -257,7 +257,7 @@ DWORD WINAPI CertEnumCRLContextProperties(PCCRL_CONTEXT pCRLContext,
(void *)pCRLContext, sizeof(CRL_CONTEXT)); (void *)pCRLContext, sizeof(CRL_CONTEXT));
DWORD ret; DWORD ret;
TRACE("(%p, %ld)\n", pCRLContext, dwPropId); TRACE("(%p, %d)\n", pCRLContext, dwPropId);
if (properties) if (properties)
ret = ContextPropertyList_EnumPropIDs(properties, dwPropId); ret = ContextPropertyList_EnumPropIDs(properties, dwPropId);
@ -293,7 +293,7 @@ static BOOL WINAPI CRLContext_GetProperty(void *context, DWORD dwPropId,
BOOL ret; BOOL ret;
CRYPT_DATA_BLOB blob; CRYPT_DATA_BLOB blob;
TRACE("(%p, %ld, %p, %p)\n", context, dwPropId, pvData, pcbData); TRACE("(%p, %d, %p, %p)\n", context, dwPropId, pvData, pcbData);
if (properties) if (properties)
ret = ContextPropertyList_FindProperty(properties, dwPropId, &blob); ret = ContextPropertyList_FindProperty(properties, dwPropId, &blob);
@ -346,7 +346,7 @@ BOOL WINAPI CertGetCRLContextProperty(PCCRL_CONTEXT pCRLContext,
{ {
BOOL ret; BOOL ret;
TRACE("(%p, %ld, %p, %p)\n", pCRLContext, dwPropId, pvData, pcbData); TRACE("(%p, %d, %p, %p)\n", pCRLContext, dwPropId, pvData, pcbData);
switch (dwPropId) switch (dwPropId)
{ {
@ -390,7 +390,7 @@ static BOOL WINAPI CRLContext_SetProperty(void *context, DWORD dwPropId,
Context_GetProperties(context, sizeof(CERT_CONTEXT)); Context_GetProperties(context, sizeof(CERT_CONTEXT));
BOOL ret; BOOL ret;
TRACE("(%p, %ld, %08lx, %p)\n", context, dwPropId, dwFlags, pvData); TRACE("(%p, %d, %08x, %p)\n", context, dwPropId, dwFlags, pvData);
if (!properties) if (!properties)
ret = FALSE; ret = FALSE;
@ -432,7 +432,7 @@ static BOOL WINAPI CRLContext_SetProperty(void *context, DWORD dwPropId,
(LPBYTE)pvData, sizeof(FILETIME)); (LPBYTE)pvData, sizeof(FILETIME));
break; break;
default: default:
FIXME("%ld: stub\n", dwPropId); FIXME("%d: stub\n", dwPropId);
ret = FALSE; ret = FALSE;
} }
} }
@ -445,7 +445,7 @@ BOOL WINAPI CertSetCRLContextProperty(PCCRL_CONTEXT pCRLContext,
{ {
BOOL ret; BOOL ret;
TRACE("(%p, %ld, %08lx, %p)\n", pCRLContext, dwPropId, dwFlags, pvData); TRACE("(%p, %d, %08x, %p)\n", pCRLContext, dwPropId, dwFlags, pvData);
/* Handle special cases for "read-only"/invalid prop IDs. Windows just /* Handle special cases for "read-only"/invalid prop IDs. Windows just
* crashes on most of these, I'll be safer. * crashes on most of these, I'll be safer.
@ -469,7 +469,7 @@ BOOL WINAPI CertSetCRLContextProperty(PCCRL_CONTEXT pCRLContext,
BOOL WINAPI CertIsValidCRLForCertificate(PCCERT_CONTEXT pCert, BOOL WINAPI CertIsValidCRLForCertificate(PCCERT_CONTEXT pCert,
PCCRL_CONTEXT pCrl, DWORD dwFlags, void *pvReserved) PCCRL_CONTEXT pCrl, DWORD dwFlags, void *pvReserved)
{ {
TRACE("(%p, %p, %08lx, %p)\n", pCert, pCrl, dwFlags, pvReserved); TRACE("(%p, %p, %08x, %p)\n", pCert, pCrl, dwFlags, pvReserved);
return TRUE; return TRUE;
} }
@ -489,7 +489,7 @@ BOOL WINAPI CertFindCertificateInCRL(PCCERT_CONTEXT pCert,
PCCRL_CONTEXT pCrlContext, DWORD dwFlags, void *pvReserved, PCCRL_CONTEXT pCrlContext, DWORD dwFlags, void *pvReserved,
PCRL_ENTRY *ppCrlEntry) PCRL_ENTRY *ppCrlEntry)
{ {
TRACE("(%p, %p, %08lx, %p, %p)\n", pCert, pCrlContext, dwFlags, pvReserved, TRACE("(%p, %p, %08x, %p, %p)\n", pCert, pCrlContext, dwFlags, pvReserved,
ppCrlEntry); ppCrlEntry);
*ppCrlEntry = CRYPT_FindCertificateInCRL(pCert->pCertInfo, *ppCrlEntry = CRYPT_FindCertificateInCRL(pCert->pCertInfo,
@ -503,7 +503,7 @@ BOOL WINAPI CertVerifyCRLRevocation(DWORD dwCertEncodingType,
DWORD i; DWORD i;
PCRL_ENTRY entry = NULL; PCRL_ENTRY entry = NULL;
TRACE("(%08lx, %p, %ld, %p)\n", dwCertEncodingType, pCertId, cCrlInfo, TRACE("(%08x, %p, %d, %p)\n", dwCertEncodingType, pCertId, cCrlInfo,
rgpCrlInfo); rgpCrlInfo);
for (i = 0; !entry && i < cCrlInfo; i++) for (i = 0; !entry && i < cCrlInfo; i++)

116
dlls/crypt32/decode.c
View File

@ -134,7 +134,7 @@ BOOL WINAPI CryptDecodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType,
CryptDecodeObjectFunc pCryptDecodeObject; CryptDecodeObjectFunc pCryptDecodeObject;
HCRYPTOIDFUNCADDR hFunc; HCRYPTOIDFUNCADDR hFunc;
TRACE("(0x%08lx, %s, %p, %ld, 0x%08lx, %p, %p)\n", dwCertEncodingType, TRACE("(0x%08x, %s, %p, %d, 0x%08x, %p, %p)\n", dwCertEncodingType,
debugstr_a(lpszStructType), pbEncoded, cbEncoded, dwFlags, debugstr_a(lpszStructType), pbEncoded, cbEncoded, dwFlags,
pvStructInfo, pcbStructInfo); pvStructInfo, pcbStructInfo);
@ -331,9 +331,9 @@ static BOOL CRYPT_AsnDecodeSequenceItems(DWORD dwCertEncodingType,
if (items[i].decodeFunc) if (items[i].decodeFunc)
{ {
if (pvStructInfo) if (pvStructInfo)
TRACE("decoding item %ld\n", i); TRACE("decoding item %d\n", i);
else else
TRACE("sizing item %ld\n", i); TRACE("sizing item %d\n", i);
ret = items[i].decodeFunc(dwCertEncodingType, ret = items[i].decodeFunc(dwCertEncodingType,
NULL, ptr, 1 + nextItemLenBytes + nextItemLen, NULL, ptr, 1 + nextItemLenBytes + nextItemLen,
dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL,
@ -359,13 +359,13 @@ static BOOL CRYPT_AsnDecodeSequenceItems(DWORD dwCertEncodingType,
else if (items[i].optional && else if (items[i].optional &&
GetLastError() == CRYPT_E_ASN1_BADTAG) GetLastError() == CRYPT_E_ASN1_BADTAG)
{ {
TRACE("skipping optional item %ld\n", i); TRACE("skipping optional item %d\n", i);
items[i].size = items[i].minSize; items[i].size = items[i].minSize;
SetLastError(NOERROR); SetLastError(NOERROR);
ret = TRUE; ret = TRUE;
} }
else else
TRACE("item %ld failed: %08lx\n", i, TRACE("item %d failed: %08x\n", i,
GetLastError()); GetLastError());
} }
else else
@ -373,7 +373,7 @@ static BOOL CRYPT_AsnDecodeSequenceItems(DWORD dwCertEncodingType,
} }
else if (items[i].optional) else if (items[i].optional)
{ {
TRACE("skipping optional item %ld\n", i); TRACE("skipping optional item %d\n", i);
items[i].size = items[i].minSize; items[i].size = items[i].minSize;
} }
else else
@ -387,19 +387,19 @@ static BOOL CRYPT_AsnDecodeSequenceItems(DWORD dwCertEncodingType,
} }
else if (items[i].optional) else if (items[i].optional)
{ {
TRACE("missing optional item %ld, skipping\n", i); TRACE("missing optional item %d, skipping\n", i);
items[i].size = items[i].minSize; items[i].size = items[i].minSize;
} }
else else
{ {
TRACE("not enough bytes for item %ld, failing\n", i); TRACE("not enough bytes for item %d, failing\n", i);
SetLastError(CRYPT_E_ASN1_CORRUPT); SetLastError(CRYPT_E_ASN1_CORRUPT);
ret = FALSE; ret = FALSE;
} }
} }
if (cbEncoded - (ptr - pbEncoded) != 0) if (cbEncoded - (ptr - pbEncoded) != 0)
{ {
TRACE("%ld remaining bytes, failing\n", cbEncoded - TRACE("%d remaining bytes, failing\n", cbEncoded -
(ptr - pbEncoded)); (ptr - pbEncoded));
SetLastError(CRYPT_E_ASN1_CORRUPT); SetLastError(CRYPT_E_ASN1_CORRUPT);
ret = FALSE; ret = FALSE;
@ -423,7 +423,7 @@ static BOOL CRYPT_AsnDecodeSequence(DWORD dwCertEncodingType,
{ {
BOOL ret; BOOL ret;
TRACE("%p, %ld, %p, %ld, %08lx, %p, %p, %ld, %p\n", items, cItem, pbEncoded, TRACE("%p, %d, %p, %d, %08x, %p, %p, %d, %p\n", items, cItem, pbEncoded,
cbEncoded, dwFlags, pDecodePara, pvStructInfo, *pcbStructInfo, cbEncoded, dwFlags, pDecodePara, pvStructInfo, *pcbStructInfo,
startingPointer); startingPointer);
@ -471,7 +471,7 @@ static BOOL CRYPT_AsnDecodeSequence(DWORD dwCertEncodingType,
SetLastError(CRYPT_E_ASN1_BADTAG); SetLastError(CRYPT_E_ASN1_BADTAG);
ret = FALSE; ret = FALSE;
} }
TRACE("returning %d (%08lx)\n", ret, GetLastError()); TRACE("returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -513,7 +513,7 @@ static BOOL CRYPT_AsnDecodeArray(const struct AsnArrayDescriptor *arrayDesc,
{ {
BOOL ret = TRUE; BOOL ret = TRUE;
TRACE("%p, %p, %ld, %08lx, %p, %p, %ld, %p\n", arrayDesc, pbEncoded, TRACE("%p, %p, %d, %08x, %p, %p, %d, %p\n", arrayDesc, pbEncoded,
cbEncoded, dwFlags, pDecodePara, pvStructInfo, *pcbStructInfo, cbEncoded, dwFlags, pDecodePara, pvStructInfo, *pcbStructInfo,
startingPointer); startingPointer);
@ -701,7 +701,7 @@ static BOOL WINAPI CRYPT_AsnDecodeBitsSwapBytes(DWORD dwCertEncodingType,
{ {
BOOL ret; BOOL ret;
TRACE("(%p, %ld, 0x%08lx, %p, %p, %ld)\n", pbEncoded, cbEncoded, dwFlags, TRACE("(%p, %d, 0x%08x, %p, %p, %d)\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
/* Can't use the CRYPT_DECODE_NOCOPY_FLAG, because we modify the bytes in- /* Can't use the CRYPT_DECODE_NOCOPY_FLAG, because we modify the bytes in-
@ -727,7 +727,7 @@ static BOOL WINAPI CRYPT_AsnDecodeBitsSwapBytes(DWORD dwCertEncodingType,
} }
} }
} }
TRACE("returning %d (%08lx)\n", ret, GetLastError()); TRACE("returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -737,7 +737,7 @@ static BOOL WINAPI CRYPT_AsnDecodeCertSignedContent(DWORD dwCertEncodingType,
{ {
BOOL ret = TRUE; BOOL ret = TRUE;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
__TRY __TRY
@ -768,7 +768,7 @@ static BOOL WINAPI CRYPT_AsnDecodeCertSignedContent(DWORD dwCertEncodingType,
} }
__ENDTRY __ENDTRY
TRACE("Returning %d (%08lx)\n", ret, GetLastError()); TRACE("Returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -867,14 +867,14 @@ static BOOL WINAPI CRYPT_AsnDecodeCertInfo(DWORD dwCertEncodingType,
offsetof(CERT_INFO, rgExtension), 0 }, offsetof(CERT_INFO, rgExtension), 0 },
}; };
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items, ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags, sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, pcbStructInfo, NULL); pDecodePara, pvStructInfo, pcbStructInfo, NULL);
TRACE("Returning %d (%08lx)\n", ret, GetLastError()); TRACE("Returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -884,7 +884,7 @@ static BOOL WINAPI CRYPT_AsnDecodeCert(DWORD dwCertEncodingType,
{ {
BOOL ret = TRUE; BOOL ret = TRUE;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
__TRY __TRY
@ -921,7 +921,7 @@ static BOOL WINAPI CRYPT_AsnDecodeCert(DWORD dwCertEncodingType,
} }
__ENDTRY __ENDTRY
TRACE("Returning %d (%08lx)\n", ret, GetLastError()); TRACE("Returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -942,7 +942,7 @@ static BOOL WINAPI CRYPT_AsnDecodeCRLEntry(DWORD dwCertEncodingType,
}; };
PCRL_ENTRY entry = (PCRL_ENTRY)pvStructInfo; PCRL_ENTRY entry = (PCRL_ENTRY)pvStructInfo;
TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, entry, TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags, entry,
*pcbStructInfo); *pcbStructInfo);
ret = CRYPT_AsnDecodeSequence(X509_ASN_ENCODING, items, ret = CRYPT_AsnDecodeSequence(X509_ASN_ENCODING, items,
@ -964,13 +964,13 @@ static BOOL WINAPI CRYPT_AsnDecodeCRLEntries(DWORD dwCertEncodingType,
offsetof(CRL_ENTRY, SerialNumber.pbData) }; offsetof(CRL_ENTRY, SerialNumber.pbData) };
struct GenericArray *entries = (struct GenericArray *)pvStructInfo; struct GenericArray *entries = (struct GenericArray *)pvStructInfo;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags, ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, pcbStructInfo, pDecodePara, pvStructInfo, pcbStructInfo,
entries ? entries->rgItems : NULL); entries ? entries->rgItems : NULL);
TRACE("Returning %d (%08lx)\n", ret, GetLastError()); TRACE("Returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -1000,14 +1000,14 @@ static BOOL WINAPI CRYPT_AsnDecodeCRLInfo(DWORD dwCertEncodingType,
}; };
BOOL ret = TRUE; BOOL ret = TRUE;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items, ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags, sizeof(items) / sizeof(items[0]), pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, pcbStructInfo, NULL); pDecodePara, pvStructInfo, pcbStructInfo, NULL);
TRACE("Returning %d (%08lx)\n", ret, GetLastError()); TRACE("Returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -1017,7 +1017,7 @@ static BOOL WINAPI CRYPT_AsnDecodeCRL(DWORD dwCertEncodingType,
{ {
BOOL ret = TRUE; BOOL ret = TRUE;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
__TRY __TRY
@ -1054,7 +1054,7 @@ static BOOL WINAPI CRYPT_AsnDecodeCRL(DWORD dwCertEncodingType,
} }
__ENDTRY __ENDTRY
TRACE("Returning %d (%08lx)\n", ret, GetLastError()); TRACE("Returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -1064,7 +1064,7 @@ static BOOL WINAPI CRYPT_AsnDecodeOidInternal(DWORD dwCertEncodingType,
{ {
BOOL ret = TRUE; BOOL ret = TRUE;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
if (pbEncoded[0] == ASN_OBJECTIDENTIFIER) if (pbEncoded[0] == ASN_OBJECTIDENTIFIER)
@ -1185,7 +1185,7 @@ static BOOL WINAPI CRYPT_AsnDecodeExtension(DWORD dwCertEncodingType,
BOOL ret = TRUE; BOOL ret = TRUE;
PCERT_EXTENSION ext = (PCERT_EXTENSION)pvStructInfo; PCERT_EXTENSION ext = (PCERT_EXTENSION)pvStructInfo;
TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, ext, TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags, ext,
*pcbStructInfo); *pcbStructInfo);
if (ext) if (ext)
@ -1196,7 +1196,7 @@ static BOOL WINAPI CRYPT_AsnDecodeExtension(DWORD dwCertEncodingType,
if (ext) if (ext)
TRACE("ext->pszObjId is %p (%s)\n", ext->pszObjId, TRACE("ext->pszObjId is %p (%s)\n", ext->pszObjId,
debugstr_a(ext->pszObjId)); debugstr_a(ext->pszObjId));
TRACE("returning %d (%08lx)\n", ret, GetLastError()); TRACE("returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -1210,7 +1210,7 @@ static BOOL WINAPI CRYPT_AsnDecodeExtensionsInternal(DWORD dwCertEncodingType,
offsetof(CERT_EXTENSION, pszObjId) }; offsetof(CERT_EXTENSION, pszObjId) };
PCERT_EXTENSIONS exts = (PCERT_EXTENSIONS)pvStructInfo; PCERT_EXTENSIONS exts = (PCERT_EXTENSIONS)pvStructInfo;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags, ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
@ -1630,7 +1630,7 @@ static BOOL WINAPI CRYPT_AsnDecodeRdnAttr(DWORD dwCertEncodingType,
}; };
CERT_RDN_ATTR *attr = (CERT_RDN_ATTR *)pvStructInfo; CERT_RDN_ATTR *attr = (CERT_RDN_ATTR *)pvStructInfo;
TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo); pvStructInfo, *pcbStructInfo);
if (attr) if (attr)
@ -1642,9 +1642,9 @@ static BOOL WINAPI CRYPT_AsnDecodeRdnAttr(DWORD dwCertEncodingType,
{ {
TRACE("attr->pszObjId is %p (%s)\n", attr->pszObjId, TRACE("attr->pszObjId is %p (%s)\n", attr->pszObjId,
debugstr_a(attr->pszObjId)); debugstr_a(attr->pszObjId));
TRACE("attr->dwValueType is %ld\n", attr->dwValueType); TRACE("attr->dwValueType is %d\n", attr->dwValueType);
} }
TRACE("returning %d (%08lx)\n", ret, GetLastError()); TRACE("returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -1702,7 +1702,7 @@ static BOOL WINAPI CRYPT_AsnDecodeUnicodeRdnAttr(DWORD dwCertEncodingType,
}; };
CERT_RDN_ATTR *attr = (CERT_RDN_ATTR *)pvStructInfo; CERT_RDN_ATTR *attr = (CERT_RDN_ATTR *)pvStructInfo;
TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo); pvStructInfo, *pcbStructInfo);
if (attr) if (attr)
@ -1714,9 +1714,9 @@ static BOOL WINAPI CRYPT_AsnDecodeUnicodeRdnAttr(DWORD dwCertEncodingType,
{ {
TRACE("attr->pszObjId is %p (%s)\n", attr->pszObjId, TRACE("attr->pszObjId is %p (%s)\n", attr->pszObjId,
debugstr_a(attr->pszObjId)); debugstr_a(attr->pszObjId));
TRACE("attr->dwValueType is %ld\n", attr->dwValueType); TRACE("attr->dwValueType is %d\n", attr->dwValueType);
} }
TRACE("returning %d (%08lx)\n", ret, GetLastError()); TRACE("returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -1766,7 +1766,7 @@ static BOOL WINAPI CRYPT_AsnDecodeCopyBytes(DWORD dwCertEncodingType,
BOOL ret = TRUE; BOOL ret = TRUE;
DWORD bytesNeeded = sizeof(CRYPT_OBJID_BLOB); DWORD bytesNeeded = sizeof(CRYPT_OBJID_BLOB);
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG)) if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
@ -1812,7 +1812,7 @@ static BOOL WINAPI CRYPT_AsnDecodeAlgorithmId(DWORD dwCertEncodingType,
offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters.pbData), 0 }, offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters.pbData), 0 },
}; };
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items, ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items,
@ -1928,7 +1928,7 @@ static BOOL WINAPI CRYPT_AsnDecodeBool(DWORD dwCertEncodingType,
*(BOOL *)pvStructInfo = pbEncoded[2] ? TRUE : FALSE; *(BOOL *)pvStructInfo = pbEncoded[2] ? TRUE : FALSE;
ret = TRUE; ret = TRUE;
} }
TRACE("returning %d (%08lx)\n", ret, GetLastError()); TRACE("returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -1940,7 +1940,7 @@ static BOOL WINAPI CRYPT_AsnDecodeAltNameEntry(DWORD dwCertEncodingType,
DWORD dataLen, lenBytes, bytesNeeded = sizeof(CERT_ALT_NAME_ENTRY); DWORD dataLen, lenBytes, bytesNeeded = sizeof(CERT_ALT_NAME_ENTRY);
BOOL ret; BOOL ret;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
if (cbEncoded < 2) if (cbEncoded < 2)
@ -2045,7 +2045,7 @@ static BOOL WINAPI CRYPT_AsnDecodeAltNameInternal(DWORD dwCertEncodingType,
offsetof(CERT_ALT_NAME_ENTRY, u.pwszURL) }; offsetof(CERT_ALT_NAME_ENTRY, u.pwszURL) };
PCERT_ALT_NAME_INFO info = (PCERT_ALT_NAME_INFO)pvStructInfo; PCERT_ALT_NAME_INFO info = (PCERT_ALT_NAME_INFO)pvStructInfo;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
if (info) if (info)
@ -2096,7 +2096,7 @@ static BOOL WINAPI CRYPT_AsnDecodeAltName(DWORD dwCertEncodingType,
{ {
BOOL ret = TRUE; BOOL ret = TRUE;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
__TRY __TRY
@ -2129,7 +2129,7 @@ static BOOL WINAPI CRYPT_AsnDecodePathLenConstraint(DWORD dwCertEncodingType,
{ {
BOOL ret = TRUE; BOOL ret = TRUE;
TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo); pvStructInfo, *pcbStructInfo);
if (cbEncoded) if (cbEncoded)
@ -2157,7 +2157,7 @@ static BOOL WINAPI CRYPT_AsnDecodePathLenConstraint(DWORD dwCertEncodingType,
&constraint->dwPathLenConstraint, &size); &constraint->dwPathLenConstraint, &size);
if (ret) if (ret)
constraint->fPathLenConstraint = TRUE; constraint->fPathLenConstraint = TRUE;
TRACE("got an int, dwPathLenConstraint is %ld\n", TRACE("got an int, dwPathLenConstraint is %d\n",
constraint->dwPathLenConstraint); constraint->dwPathLenConstraint);
} }
} }
@ -2167,7 +2167,7 @@ static BOOL WINAPI CRYPT_AsnDecodePathLenConstraint(DWORD dwCertEncodingType,
ret = FALSE; ret = FALSE;
} }
} }
TRACE("returning %d (%08lx)\n", ret, GetLastError()); TRACE("returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -2181,13 +2181,13 @@ static BOOL WINAPI CRYPT_AsnDecodeSubtreeConstraints(DWORD dwCertEncodingType,
offsetof(CERT_NAME_BLOB, pbData) }; offsetof(CERT_NAME_BLOB, pbData) };
struct GenericArray *entries = (struct GenericArray *)pvStructInfo; struct GenericArray *entries = (struct GenericArray *)pvStructInfo;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags, ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, pcbStructInfo, pDecodePara, pvStructInfo, pcbStructInfo,
entries ? entries->rgItems : NULL); entries ? entries->rgItems : NULL);
TRACE("Returning %d (%08lx)\n", ret, GetLastError()); TRACE("Returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -2335,7 +2335,7 @@ static BOOL WINAPI CRYPT_AsnDecodeOctetsInternal(DWORD dwCertEncodingType,
BOOL ret; BOOL ret;
DWORD bytesNeeded, dataLen; DWORD bytesNeeded, dataLen;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen))) if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
@ -2379,7 +2379,7 @@ static BOOL WINAPI CRYPT_AsnDecodeOctets(DWORD dwCertEncodingType,
{ {
BOOL ret; BOOL ret;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
__TRY __TRY
@ -2433,7 +2433,7 @@ static BOOL WINAPI CRYPT_AsnDecodeBitsInternal(DWORD dwCertEncodingType,
{ {
BOOL ret; BOOL ret;
TRACE("(%p, %ld, 0x%08lx, %p, %p, %ld)\n", pbEncoded, cbEncoded, dwFlags, TRACE("(%p, %d, 0x%08x, %p, %p, %d)\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
if (pbEncoded[0] == ASN_BITSTRING) if (pbEncoded[0] == ASN_BITSTRING)
@ -2487,7 +2487,7 @@ static BOOL WINAPI CRYPT_AsnDecodeBitsInternal(DWORD dwCertEncodingType,
SetLastError(CRYPT_E_ASN1_BADTAG); SetLastError(CRYPT_E_ASN1_BADTAG);
ret = FALSE; ret = FALSE;
} }
TRACE("returning %d (%08lx)\n", ret, GetLastError()); TRACE("returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -2497,7 +2497,7 @@ static BOOL WINAPI CRYPT_AsnDecodeBits(DWORD dwCertEncodingType,
{ {
BOOL ret; BOOL ret;
TRACE("(%p, %ld, 0x%08lx, %p, %p, %p)\n", pbEncoded, cbEncoded, dwFlags, TRACE("(%p, %d, 0x%08x, %p, %p, %p)\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, pcbStructInfo); pDecodePara, pvStructInfo, pcbStructInfo);
__TRY __TRY
@ -2532,7 +2532,7 @@ static BOOL WINAPI CRYPT_AsnDecodeBits(DWORD dwCertEncodingType,
ret = FALSE; ret = FALSE;
} }
__ENDTRY __ENDTRY
TRACE("returning %d (%08lx)\n", ret, GetLastError()); TRACE("returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -3356,7 +3356,7 @@ static BOOL WINAPI CRYPT_AsnDecodeCRLDistPoints(DWORD dwCertEncodingType,
{ {
BOOL ret; BOOL ret;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
__TRY __TRY
@ -3383,7 +3383,7 @@ static BOOL WINAPI CRYPT_AsnDecodeEnhancedKeyUsage(DWORD dwCertEncodingType,
{ {
BOOL ret; BOOL ret;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
__TRY __TRY
@ -3409,7 +3409,7 @@ static BOOL WINAPI CRYPT_AsnDecodeIssuingDistPoint(DWORD dwCertEncodingType,
{ {
BOOL ret; BOOL ret;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, TRACE("%p, %d, %08x, %p, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pDecodePara, pvStructInfo, *pcbStructInfo); pDecodePara, pvStructInfo, *pcbStructInfo);
__TRY __TRY
@ -3456,7 +3456,7 @@ BOOL WINAPI CryptDecodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType,
CryptDecodeObjectExFunc decodeFunc = NULL; CryptDecodeObjectExFunc decodeFunc = NULL;
HCRYPTOIDFUNCADDR hFunc = NULL; HCRYPTOIDFUNCADDR hFunc = NULL;
TRACE("(0x%08lx, %s, %p, %ld, 0x%08lx, %p, %p, %p)\n", TRACE("(0x%08x, %s, %p, %d, 0x%08x, %p, %p, %p)\n",
dwCertEncodingType, debugstr_a(lpszStructType), pbEncoded, dwCertEncodingType, debugstr_a(lpszStructType), pbEncoded,
cbEncoded, dwFlags, pDecodePara, pvStructInfo, pcbStructInfo); cbEncoded, dwFlags, pDecodePara, pvStructInfo, pcbStructInfo);

36
dlls/crypt32/encode.c
View File

@ -106,7 +106,7 @@ BOOL WINAPI CryptEncodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType,
HCRYPTOIDFUNCADDR hFunc; HCRYPTOIDFUNCADDR hFunc;
CryptEncodeObjectFunc pCryptEncodeObject; CryptEncodeObjectFunc pCryptEncodeObject;
TRACE("(0x%08lx, %s, %p, %p, %p)\n", dwCertEncodingType, TRACE("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType,
debugstr_a(lpszStructType), pvStructInfo, pbEncoded, debugstr_a(lpszStructType), pvStructInfo, pbEncoded,
pcbEncoded); pcbEncoded);
@ -225,7 +225,7 @@ static BOOL WINAPI CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType,
BOOL ret; BOOL ret;
DWORD i, dataLen = 0; DWORD i, dataLen = 0;
TRACE("%p, %ld, %08lx, %p, %p, %ld\n", items, cItem, dwFlags, pEncodePara, TRACE("%p, %d, %08x, %p, %p, %d\n", items, cItem, dwFlags, pEncodePara,
pbEncoded, *pcbEncoded); pbEncoded, *pcbEncoded);
for (i = 0, ret = TRUE; ret && i < cItem; i++) for (i = 0, ret = TRUE; ret && i < cItem; i++)
{ {
@ -268,7 +268,7 @@ static BOOL WINAPI CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType,
} }
} }
} }
TRACE("returning %d (%08lx)\n", ret, GetLastError()); TRACE("returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -590,7 +590,7 @@ static BOOL WINAPI CRYPT_AsnEncodeCRLEntry(const CRL_ENTRY *entry,
ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL, ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
pbEncoded, pcbEncoded); pbEncoded, pcbEncoded);
TRACE("returning %d (%08lx)\n", ret, GetLastError()); TRACE("returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -727,7 +727,7 @@ static BOOL CRYPT_AsnEncodeExtension(CERT_EXTENSION *ext, BYTE *pbEncoded,
}; };
DWORD cItem = 1; DWORD cItem = 1;
TRACE("%p, %p, %ld\n", ext, pbEncoded, *pcbEncoded); TRACE("%p, %p, %d\n", ext, pbEncoded, *pcbEncoded);
if (ext->fCritical) if (ext->fCritical)
{ {
@ -741,7 +741,7 @@ static BOOL CRYPT_AsnEncodeExtension(CERT_EXTENSION *ext, BYTE *pbEncoded,
ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL, ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL,
pbEncoded, pcbEncoded); pbEncoded, pcbEncoded);
TRACE("returning %d (%08lx)\n", ret, GetLastError()); TRACE("returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -1296,7 +1296,7 @@ static BOOL WINAPI CRYPT_AsnEncodeUnicodeName(DWORD dwCertEncodingType,
const CERT_NAME_INFO *info = (const CERT_NAME_INFO *)pvStructInfo; const CERT_NAME_INFO *info = (const CERT_NAME_INFO *)pvStructInfo;
DWORD bytesNeeded = 0, lenBytes, size, i; DWORD bytesNeeded = 0, lenBytes, size, i;
TRACE("encoding name with %ld RDNs\n", info->cRDN); TRACE("encoding name with %d RDNs\n", info->cRDN);
ret = TRUE; ret = TRUE;
for (i = 0; ret && i < info->cRDN; i++) for (i = 0; ret && i < info->cRDN; i++)
{ {
@ -1640,7 +1640,7 @@ static BOOL WINAPI CRYPT_AsnEncodeName(DWORD dwCertEncodingType,
const CERT_NAME_INFO *info = (const CERT_NAME_INFO *)pvStructInfo; const CERT_NAME_INFO *info = (const CERT_NAME_INFO *)pvStructInfo;
DWORD bytesNeeded = 0, lenBytes, size, i; DWORD bytesNeeded = 0, lenBytes, size, i;
TRACE("encoding name with %ld RDNs\n", info->cRDN); TRACE("encoding name with %d RDNs\n", info->cRDN);
ret = TRUE; ret = TRUE;
for (i = 0; ret && i < info->cRDN; i++) for (i = 0; ret && i < info->cRDN; i++)
{ {
@ -1718,7 +1718,7 @@ static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType,
*pbEncoded++ = val ? 0xff : 0; *pbEncoded++ = val ? 0xff : 0;
ret = TRUE; ret = TRUE;
} }
TRACE("returning %d (%08lx)\n", ret, GetLastError()); TRACE("returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -1760,7 +1760,7 @@ static BOOL CRYPT_AsnEncodeAltNameEntry(const CERT_ALT_NAME_ENTRY *entry,
/* FIXME: encode OID */ /* FIXME: encode OID */
case CERT_ALT_NAME_OTHER_NAME: case CERT_ALT_NAME_OTHER_NAME:
case CERT_ALT_NAME_DIRECTORY_NAME: case CERT_ALT_NAME_DIRECTORY_NAME:
FIXME("name type %ld unimplemented\n", entry->dwAltNameChoice); FIXME("name type %d unimplemented\n", entry->dwAltNameChoice);
return FALSE; return FALSE;
default: default:
SetLastError(E_INVALIDARG); SetLastError(E_INVALIDARG);
@ -1805,7 +1805,7 @@ static BOOL CRYPT_AsnEncodeAltNameEntry(const CERT_ALT_NAME_ENTRY *entry,
*pcbEncoded = bytesNeeded; *pcbEncoded = bytesNeeded;
} }
} }
TRACE("returning %d (%08lx)\n", ret, GetLastError()); TRACE("returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -2072,7 +2072,7 @@ static BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType,
const CRYPT_DATA_BLOB *blob = (const CRYPT_DATA_BLOB *)pvStructInfo; const CRYPT_DATA_BLOB *blob = (const CRYPT_DATA_BLOB *)pvStructInfo;
DWORD bytesNeeded, lenBytes; DWORD bytesNeeded, lenBytes;
TRACE("(%ld, %p), %08lx, %p, %p, %ld\n", blob->cbData, blob->pbData, TRACE("(%d, %p), %08x, %p, %p, %d\n", blob->cbData, blob->pbData,
dwFlags, pEncodePara, pbEncoded, *pcbEncoded); dwFlags, pEncodePara, pbEncoded, *pcbEncoded);
CRYPT_EncodeLen(blob->cbData, NULL, &lenBytes); CRYPT_EncodeLen(blob->cbData, NULL, &lenBytes);
@ -2103,7 +2103,7 @@ static BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType,
ret = FALSE; ret = FALSE;
} }
__ENDTRY __ENDTRY
TRACE("returning %d (%08lx)\n", ret, GetLastError()); TRACE("returning %d (%08x)\n", ret, GetLastError());
return ret; return ret;
} }
@ -2895,7 +2895,7 @@ BOOL WINAPI CryptEncodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType,
CryptEncodeObjectExFunc encodeFunc = NULL; CryptEncodeObjectExFunc encodeFunc = NULL;
HCRYPTOIDFUNCADDR hFunc = NULL; HCRYPTOIDFUNCADDR hFunc = NULL;
TRACE("(0x%08lx, %s, %p, 0x%08lx, %p, %p, %p)\n", dwCertEncodingType, TRACE("(0x%08x, %s, %p, 0x%08x, %p, %p, %p)\n", dwCertEncodingType,
debugstr_a(lpszStructType), pvStructInfo, dwFlags, pEncodePara, debugstr_a(lpszStructType), pvStructInfo, dwFlags, pEncodePara,
pvEncoded, pcbEncoded); pvEncoded, pcbEncoded);
@ -3068,7 +3068,7 @@ static BOOL WINAPI CRYPT_ExportRsaPublicKeyInfoEx(HCRYPTPROV hCryptProv,
HCRYPTKEY key; HCRYPTKEY key;
static CHAR oid[] = szOID_RSA_RSA; static CHAR oid[] = szOID_RSA_RSA;
TRACE("(%08lx, %ld, %08lx, %s, %08lx, %p, %p, %p)\n", hCryptProv, dwKeySpec, TRACE("(%08lx, %d, %08x, %s, %08x, %p, %p, %p)\n", hCryptProv, dwKeySpec,
dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags, pvAuxInfo, dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags, pvAuxInfo,
pInfo, pcbInfo); pInfo, pcbInfo);
@ -3148,7 +3148,7 @@ BOOL WINAPI CryptExportPublicKeyInfoEx(HCRYPTPROV hCryptProv, DWORD dwKeySpec,
ExportPublicKeyInfoExFunc exportFunc = NULL; ExportPublicKeyInfoExFunc exportFunc = NULL;
HCRYPTOIDFUNCADDR hFunc = NULL; HCRYPTOIDFUNCADDR hFunc = NULL;
TRACE("(%08lx, %ld, %08lx, %s, %08lx, %p, %p, %p)\n", hCryptProv, dwKeySpec, TRACE("(%08lx, %d, %08x, %s, %08x, %p, %p, %p)\n", hCryptProv, dwKeySpec,
dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags, pvAuxInfo, dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags, pvAuxInfo,
pInfo, pcbInfo); pInfo, pcbInfo);
@ -3189,7 +3189,7 @@ static BOOL WINAPI CRYPT_ImportRsaPublicKeyInfoEx(HCRYPTPROV hCryptProv,
BOOL ret; BOOL ret;
DWORD pubKeySize = 0; DWORD pubKeySize = 0;
TRACE("(%ld, %ld, %p, %d, %08lx, %p, %p)\n", hCryptProv, TRACE("(%08lx, %d, %p, %d, %08x, %p, %p)\n", hCryptProv,
dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey); dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
ret = CryptDecodeObject(dwCertEncodingType, RSA_CSP_PUBLICKEYBLOB, ret = CryptDecodeObject(dwCertEncodingType, RSA_CSP_PUBLICKEYBLOB,
@ -3227,7 +3227,7 @@ BOOL WINAPI CryptImportPublicKeyInfoEx(HCRYPTPROV hCryptProv,
ImportPublicKeyInfoExFunc importFunc = NULL; ImportPublicKeyInfoExFunc importFunc = NULL;
HCRYPTOIDFUNCADDR hFunc = NULL; HCRYPTOIDFUNCADDR hFunc = NULL;
TRACE("(%ld, %ld, %p, %d, %08lx, %p, %p)\n", hCryptProv, TRACE("(%08lx, %d, %p, %d, %08x, %p, %p)\n", hCryptProv,
dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey); dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
if (!set) if (!set)

22
dlls/crypt32/main.c
View File

@ -77,19 +77,19 @@ BOOL WINAPI I_CryptCreateLruCache(void *unknown, HLRUCACHE *out)
BOOL WINAPI I_CryptFindLruEntryData(DWORD unk0, DWORD unk1, DWORD unk2) BOOL WINAPI I_CryptFindLruEntryData(DWORD unk0, DWORD unk1, DWORD unk2)
{ {
FIXME("(%08lx, %08lx, %08lx): stub!\n", unk0, unk1, unk2); FIXME("(%08x, %08x, %08x): stub!\n", unk0, unk1, unk2);
return FALSE; return FALSE;
} }
DWORD WINAPI I_CryptFlushLruCache(HLRUCACHE h, DWORD unk0, DWORD unk1) DWORD WINAPI I_CryptFlushLruCache(HLRUCACHE h, DWORD unk0, DWORD unk1)
{ {
FIXME("(%p, %08lx, %08lx): stub!\n", h, unk0, unk1); FIXME("(%p, %08x, %08x): stub!\n", h, unk0, unk1);
return 0; return 0;
} }
HLRUCACHE WINAPI I_CryptFreeLruCache(HLRUCACHE h, DWORD unk0, DWORD unk1) HLRUCACHE WINAPI I_CryptFreeLruCache(HLRUCACHE h, DWORD unk0, DWORD unk1)
{ {
FIXME("(%p, %08lx, %08lx): stub!\n", h, unk0, unk1); FIXME("(%p, %08x, %08x): stub!\n", h, unk0, unk1);
return h; return h;
} }
@ -134,13 +134,13 @@ BOOL WINAPI I_CryptSetTls(DWORD dwTlsIndex, LPVOID lpTlsValue)
BOOL WINAPI I_CryptFreeTls(DWORD dwTlsIndex, DWORD unknown) BOOL WINAPI I_CryptFreeTls(DWORD dwTlsIndex, DWORD unknown)
{ {
TRACE("(%ld, %ld)\n", dwTlsIndex, unknown); TRACE("(%d, %d)\n", dwTlsIndex, unknown);
return TlsFree(dwTlsIndex); return TlsFree(dwTlsIndex);
} }
BOOL WINAPI I_CryptGetOssGlobal(DWORD x) BOOL WINAPI I_CryptGetOssGlobal(DWORD x)
{ {
FIXME("%08lx\n", x); FIXME("%08x\n", x);
return FALSE; return FALSE;
} }
@ -148,7 +148,7 @@ HCRYPTPROV WINAPI I_CryptGetDefaultCryptProv(DWORD reserved)
{ {
HCRYPTPROV ret; HCRYPTPROV ret;
TRACE("(%08lx)\n", reserved); TRACE("(%08x)\n", reserved);
if (reserved) if (reserved)
{ {
@ -190,13 +190,13 @@ BOOL WINAPI I_CryptReadTrustedPublisherDWORDValueFromRegistry(LPCWSTR name,
BOOL WINAPI I_CryptInstallOssGlobal(DWORD x, DWORD y, DWORD z) BOOL WINAPI I_CryptInstallOssGlobal(DWORD x, DWORD y, DWORD z)
{ {
FIXME("%08lx %08lx %08lx\n", x, y, z); FIXME("%08x %08x %08x\n", x, y, z);
return FALSE; return FALSE;
} }
BOOL WINAPI I_CryptInstallAsn1Module(void *x, DWORD y, DWORD z) BOOL WINAPI I_CryptInstallAsn1Module(void *x, DWORD y, DWORD z)
{ {
FIXME("%p %08lx %08lx\n", x, y, z); FIXME("%p %08x %08x\n", x, y, z);
return TRUE; return TRUE;
} }
@ -210,7 +210,7 @@ BOOL WINAPI CryptFormatObject(DWORD dwCertEncodingType, DWORD dwFormatType,
DWORD dwFormatStrType, void *pFormatStruct, LPCSTR lpszStructType, DWORD dwFormatStrType, void *pFormatStruct, LPCSTR lpszStructType,
const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, DWORD *pcbFormat) const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, DWORD *pcbFormat)
{ {
FIXME("(%08lx, %ld, %ld, %p, %s, %p, %ld, %p, %p): stub\n", FIXME("(%08x, %d, %d, %p, %s, %p, %d, %p, %p): stub\n",
dwCertEncodingType, dwFormatType, dwFormatStrType, pFormatStruct, dwCertEncodingType, dwFormatType, dwFormatStrType, pFormatStruct,
debugstr_a(lpszStructType), pbEncoded, cbEncoded, pbFormat, pcbFormat); debugstr_a(lpszStructType), pbEncoded, cbEncoded, pbFormat, pcbFormat);
return FALSE; return FALSE;
@ -222,7 +222,7 @@ BOOL WINAPI CryptQueryObject(DWORD dwObjectType, const void* pvObject,
DWORD* pdwFormatType, HCERTSTORE* phCertStore, HCRYPTMSG* phMsg, DWORD* pdwFormatType, HCERTSTORE* phCertStore, HCRYPTMSG* phMsg,
const void** ppvContext) const void** ppvContext)
{ {
FIXME( "%08lx %p %08lx %08lx %08lx %p %p %p %p %p %p", dwObjectType, FIXME( "%08x %p %08x %08x %08x %p %p %p %p %p %p", dwObjectType,
pvObject, dwExpectedContentTypeFlags, dwExpectedFormatTypeFlags, pvObject, dwExpectedContentTypeFlags, dwExpectedFormatTypeFlags,
dwFlags, pdwMsgAndCertEncodingType, pdwContentType, pdwFormatType, dwFlags, pdwMsgAndCertEncodingType, pdwContentType, pdwFormatType,
phCertStore, phMsg, ppvContext); phCertStore, phMsg, ppvContext);
@ -233,7 +233,7 @@ BOOL WINAPI CryptVerifyMessageSignature(PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara,
DWORD dwSignerIndex, const BYTE* pbSignedBlob, DWORD cbSignedBlob, DWORD dwSignerIndex, const BYTE* pbSignedBlob, DWORD cbSignedBlob,
BYTE* pbDecoded, DWORD* pcbDecoded, PCCERT_CONTEXT* ppSignerCert) BYTE* pbDecoded, DWORD* pcbDecoded, PCCERT_CONTEXT* ppSignerCert)
{ {
FIXME("stub: %p, %ld, %p, %ld, %p, %p, %p\n", FIXME("stub: %p, %d, %p, %d, %p, %p, %p\n",
pVerifyPara, dwSignerIndex, pbSignedBlob, cbSignedBlob, pVerifyPara, dwSignerIndex, pbSignedBlob, cbSignedBlob,
pbDecoded, pcbDecoded, ppSignerCert); pbDecoded, pcbDecoded, ppSignerCert);
return FALSE; return FALSE;

34
dlls/crypt32/oid.c
View File

@ -109,7 +109,7 @@ HCRYPTOIDFUNCSET WINAPI CryptInitOIDFunctionSet(LPCSTR pszFuncName,
{ {
struct OIDFunctionSet *cursor, *ret = NULL; struct OIDFunctionSet *cursor, *ret = NULL;
TRACE("(%s, %lx)\n", debugstr_a(pszFuncName), dwFlags); TRACE("(%s, %x)\n", debugstr_a(pszFuncName), dwFlags);
EnterCriticalSection(&funcSetCS); EnterCriticalSection(&funcSetCS);
LIST_FOR_EACH_ENTRY(cursor, &funcSets, struct OIDFunctionSet, next) LIST_FOR_EACH_ENTRY(cursor, &funcSets, struct OIDFunctionSet, next)
@ -150,7 +150,7 @@ static char *CRYPT_GetKeyName(DWORD dwEncodingType, LPCSTR pszFuncName,
LPCSTR pszOID) LPCSTR pszOID)
{ {
static const char szEncodingTypeFmt[] = static const char szEncodingTypeFmt[] =
"Software\\Microsoft\\Cryptography\\OID\\EncodingType %ld\\%s\\%s"; "Software\\Microsoft\\Cryptography\\OID\\EncodingType %d\\%s\\%s";
UINT len; UINT len;
char numericOID[7]; /* enough for "#65535" */ char numericOID[7]; /* enough for "#65535" */
const char *oid; const char *oid;
@ -190,7 +190,7 @@ BOOL WINAPI CryptGetDefaultOIDDllList(HCRYPTOIDFUNCSET hFuncSet,
HKEY key; HKEY key;
long rc; long rc;
TRACE("(%p, %ld, %p, %p)\n", hFuncSet, dwEncodingType, pwszDllList, TRACE("(%p, %d, %p, %p)\n", hFuncSet, dwEncodingType, pwszDllList,
pcchDllList); pcchDllList);
keyName = CRYPT_GetKeyName(dwEncodingType, set->name, "DEFAULT"); keyName = CRYPT_GetKeyName(dwEncodingType, set->name, "DEFAULT");
@ -230,7 +230,7 @@ BOOL WINAPI CryptInstallOIDFunctionAddress(HMODULE hModule,
BOOL ret = TRUE; BOOL ret = TRUE;
struct OIDFunctionSet *set; struct OIDFunctionSet *set;
TRACE("(%p, %ld, %s, %ld, %p, %08lx)\n", hModule, dwEncodingType, TRACE("(%p, %d, %s, %d, %p, %08x)\n", hModule, dwEncodingType,
debugstr_a(pszFuncName), cFuncEntry, rgFuncEntry, dwFlags); debugstr_a(pszFuncName), cFuncEntry, rgFuncEntry, dwFlags);
set = (struct OIDFunctionSet *)CryptInitOIDFunctionSet(pszFuncName, 0); set = (struct OIDFunctionSet *)CryptInitOIDFunctionSet(pszFuncName, 0);
@ -354,7 +354,7 @@ BOOL WINAPI CryptGetOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet,
BOOL ret = FALSE; BOOL ret = FALSE;
struct OIDFunctionSet *set = (struct OIDFunctionSet *)hFuncSet; struct OIDFunctionSet *set = (struct OIDFunctionSet *)hFuncSet;
TRACE("(%p, %ld, %s, %08lx, %p, %p)\n", hFuncSet, dwEncodingType, TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet, dwEncodingType,
debugstr_a(pszOID), dwFlags, ppvFuncAddr, phFuncAddr); debugstr_a(pszOID), dwFlags, ppvFuncAddr, phFuncAddr);
*ppvFuncAddr = NULL; *ppvFuncAddr = NULL;
@ -398,7 +398,7 @@ BOOL WINAPI CryptGetOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet,
BOOL WINAPI CryptFreeOIDFunctionAddress(HCRYPTOIDFUNCADDR hFuncAddr, BOOL WINAPI CryptFreeOIDFunctionAddress(HCRYPTOIDFUNCADDR hFuncAddr,
DWORD dwFlags) DWORD dwFlags)
{ {
TRACE("(%p, %08lx)\n", hFuncAddr, dwFlags); TRACE("(%p, %08x)\n", hFuncAddr, dwFlags);
/* FIXME: as MSDN states, need to check for DllCanUnloadNow in the DLL, /* 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 * and only unload it if it can be unloaded. Also need to implement ref
@ -412,7 +412,7 @@ BOOL WINAPI CryptGetDefaultOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet,
DWORD dwEncodingType, LPCWSTR pwszDll, DWORD dwFlags, void *ppvFuncAddr, DWORD dwEncodingType, LPCWSTR pwszDll, DWORD dwFlags, void *ppvFuncAddr,
HCRYPTOIDFUNCADDR *phFuncAddr) HCRYPTOIDFUNCADDR *phFuncAddr)
{ {
FIXME("(%p, %ld, %s, %08lx, %p, %p): stub\n", hFuncSet, dwEncodingType, FIXME("(%p, %d, %s, %08x, %p, %p): stub\n", hFuncSet, dwEncodingType,
debugstr_w(pwszDll), dwFlags, ppvFuncAddr, phFuncAddr); debugstr_w(pwszDll), dwFlags, ppvFuncAddr, phFuncAddr);
return FALSE; return FALSE;
} }
@ -444,7 +444,7 @@ BOOL WINAPI CryptRegisterOIDFunction(DWORD dwEncodingType, LPCSTR pszFuncName,
HKEY hKey; HKEY hKey;
LPSTR szKey; LPSTR szKey;
TRACE("(%lx, %s, %s, %s, %s)\n", dwEncodingType, pszFuncName, TRACE("(%x, %s, %s, %s, %s)\n", dwEncodingType, pszFuncName,
debugstr_a(pszOID), debugstr_w(pwszDll), pszOverrideFuncName); debugstr_a(pszOID), debugstr_w(pwszDll), pszOverrideFuncName);
/* This only registers functions for encoding certs, not messages */ /* This only registers functions for encoding certs, not messages */
@ -505,7 +505,7 @@ BOOL WINAPI CryptUnregisterOIDFunction(DWORD dwEncodingType, LPCSTR pszFuncName,
LPSTR szKey; LPSTR szKey;
LONG rc; LONG rc;
TRACE("%lx %s %s\n", dwEncodingType, pszFuncName, pszOID); TRACE("%x %s %s\n", dwEncodingType, pszFuncName, pszOID);
if (!GET_CERT_ENCODING_TYPE(dwEncodingType)) if (!GET_CERT_ENCODING_TYPE(dwEncodingType))
return TRUE; return TRUE;
@ -532,7 +532,7 @@ BOOL WINAPI CryptGetOIDFunctionValue(DWORD dwEncodingType, LPCSTR pszFuncName,
LONG rc; LONG rc;
HKEY hKey; HKEY hKey;
TRACE("%lx %s %s %s %p %p %p\n", dwEncodingType, debugstr_a(pszFuncName), TRACE("%x %s %s %s %p %p %p\n", dwEncodingType, debugstr_a(pszFuncName),
debugstr_a(pszOID), debugstr_w(pwszValueName), pdwValueType, pbValueData, debugstr_a(pszOID), debugstr_w(pwszValueName), pdwValueType, pbValueData,
pcbValueData); pcbValueData);
@ -569,7 +569,7 @@ BOOL WINAPI CryptSetOIDFunctionValue(DWORD dwEncodingType, LPCSTR pszFuncName,
LONG rc; LONG rc;
HKEY hKey; HKEY hKey;
TRACE("%lx %s %s %s %ld %p %ld\n", dwEncodingType, debugstr_a(pszFuncName), TRACE("%x %s %s %s %d %p %d\n", dwEncodingType, debugstr_a(pszFuncName),
debugstr_a(pszOID), debugstr_w(pwszValueName), dwValueType, pbValueData, debugstr_a(pszOID), debugstr_w(pwszValueName), dwValueType, pbValueData,
cbValueData); cbValueData);
@ -773,7 +773,7 @@ BOOL WINAPI CryptRegisterDefaultOIDFunction(DWORD dwEncodingType,
LPCWSTR existing; LPCWSTR existing;
BOOL ret = FALSE; BOOL ret = FALSE;
TRACE("(%lx, %s, %lx, %s)\n", dwEncodingType, pszFuncName, dwIndex, TRACE("(%x, %s, %x, %s)\n", dwEncodingType, pszFuncName, dwIndex,
debugstr_w(pwszDll)); debugstr_w(pwszDll));
if (!pwszDll) if (!pwszDll)
@ -806,7 +806,7 @@ BOOL WINAPI CryptUnregisterDefaultOIDFunction(DWORD dwEncodingType,
LPWSTR dlls; LPWSTR dlls;
BOOL ret; BOOL ret;
TRACE("(%lx, %s, %s)\n", dwEncodingType, debugstr_a(pszFuncName), TRACE("(%x, %s, %s)\n", dwEncodingType, debugstr_a(pszFuncName),
debugstr_w(pwszDll)); debugstr_w(pwszDll));
if (!pwszDll) if (!pwszDll)
@ -1250,7 +1250,7 @@ BOOL WINAPI CryptEnumOIDInfo(DWORD dwGroupId, DWORD dwFlags, void *pvArg,
BOOL ret = TRUE; BOOL ret = TRUE;
struct OIDInfo *info; struct OIDInfo *info;
TRACE("(%ld, %08lx, %p, %p)\n", dwGroupId, dwFlags, pvArg, TRACE("(%d, %08x, %p, %p)\n", dwGroupId, dwFlags, pvArg,
pfnEnumOIDInfo); pfnEnumOIDInfo);
EnterCriticalSection(&oidInfoCS); EnterCriticalSection(&oidInfoCS);
@ -1272,7 +1272,7 @@ PCCRYPT_OID_INFO WINAPI CryptFindOIDInfo(DWORD dwKeyType, void *pvKey,
{ {
PCCRYPT_OID_INFO ret = NULL; PCCRYPT_OID_INFO ret = NULL;
TRACE("(%ld, %p, %ld)\n", dwKeyType, pvKey, dwGroupId); TRACE("(%d, %p, %d)\n", dwKeyType, pvKey, dwGroupId);
switch(dwKeyType) switch(dwKeyType)
{ {
@ -1280,7 +1280,7 @@ PCCRYPT_OID_INFO WINAPI CryptFindOIDInfo(DWORD dwKeyType, void *pvKey,
{ {
struct OIDInfo *info; struct OIDInfo *info;
TRACE("CRYPT_OID_INFO_ALGID_KEY: %ld\n", *(DWORD *)pvKey); TRACE("CRYPT_OID_INFO_ALGID_KEY: %d\n", *(DWORD *)pvKey);
EnterCriticalSection(&oidInfoCS); EnterCriticalSection(&oidInfoCS);
LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry) LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
{ {
@ -1335,7 +1335,7 @@ PCCRYPT_OID_INFO WINAPI CryptFindOIDInfo(DWORD dwKeyType, void *pvKey,
{ {
struct OIDInfo *info; struct OIDInfo *info;
TRACE("CRYPT_OID_INFO_SIGN_KEY: %ld\n", *(DWORD *)pvKey); TRACE("CRYPT_OID_INFO_SIGN_KEY: %d\n", *(DWORD *)pvKey);
EnterCriticalSection(&oidInfoCS); EnterCriticalSection(&oidInfoCS);
LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry) LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
{ {

2
dlls/crypt32/proplist.c
View File

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

8
dlls/crypt32/serialize.c
View File

@ -43,7 +43,7 @@ static BOOL CRYPT_SerializeStoreElement(const void *context,
{ {
BOOL ret; BOOL ret;
TRACE("(%p, %p, %08lx, %d, %p, %p)\n", context, contextInterface, dwFlags, TRACE("(%p, %p, %08x, %d, %p, %p)\n", context, contextInterface, dwFlags,
omitHashes, pbElement, pcbElement); omitHashes, pbElement, pcbElement);
if (context) if (context)
@ -294,7 +294,7 @@ const void *CRYPT_ReadSerializedElement(const BYTE *pbElement, DWORD cbElement,
{ {
const void *context; const void *context;
TRACE("(%p, %ld, %08lx, %p)\n", pbElement, cbElement, dwContextTypeFlags, TRACE("(%p, %d, %08x, %p)\n", pbElement, cbElement, dwContextTypeFlags,
pdwContentType); pdwContentType);
if (!cbElement) if (!cbElement)
@ -381,7 +381,7 @@ const void *CRYPT_ReadSerializedElement(const BYTE *pbElement, DWORD cbElement,
const WINE_CERT_PROP_HEADER *hdr = const WINE_CERT_PROP_HEADER *hdr =
(const WINE_CERT_PROP_HEADER *)pbElement; (const WINE_CERT_PROP_HEADER *)pbElement;
TRACE("prop is %ld\n", hdr->propID); TRACE("prop is %d\n", hdr->propID);
cbElement -= sizeof(WINE_CERT_PROP_HEADER); cbElement -= sizeof(WINE_CERT_PROP_HEADER);
pbElement += sizeof(WINE_CERT_PROP_HEADER); pbElement += sizeof(WINE_CERT_PROP_HEADER);
if (!hdr->propID) if (!hdr->propID)
@ -606,7 +606,7 @@ BOOL WINAPI CertAddSerializedElementToStore(HCERTSTORE hCertStore,
DWORD type; DWORD type;
BOOL ret; BOOL ret;
TRACE("(%p, %p, %ld, %08lx, %08lx, %08lx, %p, %p)\n", hCertStore, TRACE("(%p, %p, %d, %08x, %08x, %08x, %p, %p)\n", hCertStore,
pbElement, cbElement, dwAddDisposition, dwFlags, dwContextTypeFlags, pbElement, cbElement, dwAddDisposition, dwFlags, dwContextTypeFlags,
pdwContentType, ppvContext); pdwContentType, ppvContext);

8
dlls/crypt32/sip.c
View File

@ -375,7 +375,7 @@ cleanup3:
BOOL WINAPI CryptSIPLoad BOOL WINAPI CryptSIPLoad
(const GUID *pgSubject, DWORD dwFlags, SIP_DISPATCH_INFO *pSipDispatch) (const GUID *pgSubject, DWORD dwFlags, SIP_DISPATCH_INFO *pSipDispatch)
{ {
FIXME("(%s %ld %p) stub!\n", debugstr_guid(pgSubject), dwFlags, pSipDispatch); FIXME("(%s %d %p) stub!\n", debugstr_guid(pgSubject), dwFlags, pSipDispatch);
return FALSE; return FALSE;
} }
@ -396,7 +396,7 @@ BOOL WINAPI CryptSIPCreateIndirectData(SIP_SUBJECTINFO* pSubjectInfo, DWORD* pcb
BOOL WINAPI CryptSIPGetSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD* pdwEncodingType, BOOL WINAPI CryptSIPGetSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD* pdwEncodingType,
DWORD dwIndex, DWORD* pcbSignedDataMsg, BYTE* pbSignedDataMsg) DWORD dwIndex, DWORD* pcbSignedDataMsg, BYTE* pbSignedDataMsg)
{ {
FIXME("(%p %p %ld %p %p) stub\n", pSubjectInfo, pdwEncodingType, dwIndex, FIXME("(%p %p %d %p %p) stub\n", pSubjectInfo, pdwEncodingType, dwIndex,
pcbSignedDataMsg, pbSignedDataMsg); pcbSignedDataMsg, pbSignedDataMsg);
return FALSE; return FALSE;
@ -408,7 +408,7 @@ BOOL WINAPI CryptSIPGetSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD* pdwEn
BOOL WINAPI CryptSIPPutSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD pdwEncodingType, BOOL WINAPI CryptSIPPutSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD pdwEncodingType,
DWORD* pdwIndex, DWORD cbSignedDataMsg, BYTE* pbSignedDataMsg) DWORD* pdwIndex, DWORD cbSignedDataMsg, BYTE* pbSignedDataMsg)
{ {
FIXME("(%p %ld %p %ld %p) stub\n", pSubjectInfo, pdwEncodingType, pdwIndex, FIXME("(%p %d %p %d %p) stub\n", pSubjectInfo, pdwEncodingType, pdwIndex,
cbSignedDataMsg, pbSignedDataMsg); cbSignedDataMsg, pbSignedDataMsg);
return FALSE; return FALSE;
@ -420,7 +420,7 @@ BOOL WINAPI CryptSIPPutSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD pdwEnc
BOOL WINAPI CryptSIPRemoveSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, BOOL WINAPI CryptSIPRemoveSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo,
DWORD dwIndex) DWORD dwIndex)
{ {
FIXME("(%p %ld) stub\n", pSubjectInfo, dwIndex); FIXME("(%p %d) stub\n", pSubjectInfo, dwIndex);
return FALSE; return FALSE;
} }

98
dlls/crypt32/store.c
View File

@ -311,9 +311,9 @@ static void WINAPI CRYPT_MemCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
{ {
WINE_MEMSTORE *store = (WINE_MEMSTORE *)hCertStore; WINE_MEMSTORE *store = (WINE_MEMSTORE *)hCertStore;
TRACE("(%p, %08lx)\n", store, dwFlags); TRACE("(%p, %08x)\n", store, dwFlags);
if (dwFlags) if (dwFlags)
FIXME("Unimplemented flags: %08lx\n", dwFlags); FIXME("Unimplemented flags: %08x\n", dwFlags);
ContextList_Free(store->certs); ContextList_Free(store->certs);
ContextList_Free(store->crls); ContextList_Free(store->crls);
@ -325,7 +325,7 @@ static WINECRYPT_CERTSTORE *CRYPT_MemOpenStore(HCRYPTPROV hCryptProv,
{ {
PWINE_MEMSTORE store; PWINE_MEMSTORE store;
TRACE("(%ld, %08lx, %p)\n", hCryptProv, dwFlags, pvPara); TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
if (dwFlags & CERT_STORE_DELETE_FLAG) if (dwFlags & CERT_STORE_DELETE_FLAG)
{ {
@ -361,7 +361,7 @@ static void WINAPI CRYPT_CollectionCloseStore(HCERTSTORE store, DWORD dwFlags)
PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store; PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
PWINE_STORE_LIST_ENTRY entry, next; PWINE_STORE_LIST_ENTRY entry, next;
TRACE("(%p, %08lx)\n", store, dwFlags); TRACE("(%p, %08x)\n", store, dwFlags);
LIST_FOR_EACH_ENTRY_SAFE(entry, next, &cs->stores, WINE_STORE_LIST_ENTRY, LIST_FOR_EACH_ENTRY_SAFE(entry, next, &cs->stores, WINE_STORE_LIST_ENTRY,
entry) entry)
@ -685,7 +685,7 @@ static void WINAPI CRYPT_ProvCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
{ {
PWINE_PROVIDERSTORE store = (PWINE_PROVIDERSTORE)hCertStore; PWINE_PROVIDERSTORE store = (PWINE_PROVIDERSTORE)hCertStore;
TRACE("(%p, %08lx)\n", store, dwFlags); TRACE("(%p, %08x)\n", store, dwFlags);
if (store->provCloseStore) if (store->provCloseStore)
store->provCloseStore(store->hStoreProv, dwFlags); store->provCloseStore(store->hStoreProv, dwFlags);
@ -826,7 +826,7 @@ static BOOL WINAPI CRYPT_ProvControl(HCERTSTORE hCertStore, DWORD dwFlags,
PWINE_PROVIDERSTORE store = (PWINE_PROVIDERSTORE)hCertStore; PWINE_PROVIDERSTORE store = (PWINE_PROVIDERSTORE)hCertStore;
BOOL ret = TRUE; BOOL ret = TRUE;
TRACE("(%p, %08lx, %ld, %p)\n", hCertStore, dwFlags, dwCtrlType, TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
pvCtrlPara); pvCtrlPara);
if (store->provControl) if (store->provControl)
@ -1219,9 +1219,9 @@ static void WINAPI CRYPT_RegCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
{ {
PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore; PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
TRACE("(%p, %08lx)\n", store, dwFlags); TRACE("(%p, %08x)\n", store, dwFlags);
if (dwFlags) if (dwFlags)
FIXME("Unimplemented flags: %08lx\n", dwFlags); FIXME("Unimplemented flags: %08x\n", dwFlags);
CRYPT_RegFlushStore(store, FALSE); CRYPT_RegFlushStore(store, FALSE);
RegCloseKey(store->key); RegCloseKey(store->key);
@ -1291,7 +1291,7 @@ static BOOL WINAPI CRYPT_RegWriteCert(HCERTSTORE hCertStore,
{ {
PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore; PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
TRACE("(%p, %p, %ld)\n", hCertStore, cert, dwFlags); TRACE("(%p, %p, %d)\n", hCertStore, cert, dwFlags);
return CRYPT_RegWriteContext(store, cert, dwFlags); return CRYPT_RegWriteContext(store, cert, dwFlags);
} }
@ -1301,7 +1301,7 @@ static BOOL WINAPI CRYPT_RegDeleteCert(HCERTSTORE hCertStore,
{ {
PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore; PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
TRACE("(%p, %p, %08lx)\n", store, pCertContext, dwFlags); TRACE("(%p, %p, %08x)\n", store, pCertContext, dwFlags);
return CRYPT_RegDeleteContext(store, &store->certsToDelete, pCertContext, return CRYPT_RegDeleteContext(store, &store->certsToDelete, pCertContext,
pCertInterface); pCertInterface);
@ -1312,7 +1312,7 @@ static BOOL WINAPI CRYPT_RegWriteCRL(HCERTSTORE hCertStore,
{ {
PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore; PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
TRACE("(%p, %p, %ld)\n", hCertStore, crl, dwFlags); TRACE("(%p, %p, %d)\n", hCertStore, crl, dwFlags);
return CRYPT_RegWriteContext(store, crl, dwFlags); return CRYPT_RegWriteContext(store, crl, dwFlags);
} }
@ -1322,7 +1322,7 @@ static BOOL WINAPI CRYPT_RegDeleteCRL(HCERTSTORE hCertStore,
{ {
PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore; PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
TRACE("(%p, %p, %08lx)\n", store, pCrlContext, dwFlags); TRACE("(%p, %p, %08x)\n", store, pCrlContext, dwFlags);
return CRYPT_RegDeleteContext(store, &store->crlsToDelete, pCrlContext, return CRYPT_RegDeleteContext(store, &store->crlsToDelete, pCrlContext,
pCRLInterface); pCRLInterface);
@ -1334,7 +1334,7 @@ static BOOL WINAPI CRYPT_RegControl(HCERTSTORE hCertStore, DWORD dwFlags,
PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore; PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
BOOL ret; BOOL ret;
TRACE("(%p, %08lx, %ld, %p)\n", hCertStore, dwFlags, dwCtrlType, TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
pvCtrlPara); pvCtrlPara);
switch (dwCtrlType) switch (dwCtrlType)
@ -1350,7 +1350,7 @@ static BOOL WINAPI CRYPT_RegControl(HCERTSTORE hCertStore, DWORD dwFlags,
dwFlags & CERT_STORE_CTRL_COMMIT_FORCE_FLAG); dwFlags & CERT_STORE_CTRL_COMMIT_FORCE_FLAG);
break; break;
default: default:
FIXME("%ld: stub\n", dwCtrlType); FIXME("%d: stub\n", dwCtrlType);
ret = FALSE; ret = FALSE;
} }
return ret; return ret;
@ -1431,7 +1431,7 @@ static WINECRYPT_CERTSTORE *CRYPT_RegOpenStore(HCRYPTPROV hCryptProv,
{ {
PWINECRYPT_CERTSTORE store = NULL; PWINECRYPT_CERTSTORE store = NULL;
TRACE("(%ld, %08lx, %p)\n", hCryptProv, dwFlags, pvPara); TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
if (dwFlags & CERT_STORE_DELETE_FLAG) if (dwFlags & CERT_STORE_DELETE_FLAG)
{ {
@ -1506,7 +1506,7 @@ static PWINECRYPT_CERTSTORE CRYPT_SysRegOpenStoreW(HCRYPTPROV hCryptProv,
LPCWSTR base; LPCWSTR base;
BOOL ret; BOOL ret;
TRACE("(%ld, %08lx, %s)\n", hCryptProv, dwFlags, TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
debugstr_w((LPCWSTR)pvPara)); debugstr_w((LPCWSTR)pvPara));
if (!pvPara) if (!pvPara)
@ -1606,7 +1606,7 @@ static PWINECRYPT_CERTSTORE CRYPT_SysRegOpenStoreA(HCRYPTPROV hCryptProv,
int len; int len;
PWINECRYPT_CERTSTORE ret = NULL; PWINECRYPT_CERTSTORE ret = NULL;
TRACE("(%ld, %08lx, %s)\n", hCryptProv, dwFlags, TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
debugstr_a((LPCSTR)pvPara)); debugstr_a((LPCSTR)pvPara));
if (!pvPara) if (!pvPara)
@ -1635,7 +1635,7 @@ static PWINECRYPT_CERTSTORE CRYPT_SysOpenStoreW(HCRYPTPROV hCryptProv,
HCERTSTORE store = 0; HCERTSTORE store = 0;
BOOL ret; BOOL ret;
TRACE("(%ld, %08lx, %s)\n", hCryptProv, dwFlags, TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
debugstr_w((LPCWSTR)pvPara)); debugstr_w((LPCWSTR)pvPara));
if (!pvPara) if (!pvPara)
@ -1704,7 +1704,7 @@ static PWINECRYPT_CERTSTORE CRYPT_SysOpenStoreA(HCRYPTPROV hCryptProv,
int len; int len;
PWINECRYPT_CERTSTORE ret = NULL; PWINECRYPT_CERTSTORE ret = NULL;
TRACE("(%ld, %08lx, %s)\n", hCryptProv, dwFlags, TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
debugstr_a((LPCSTR)pvPara)); debugstr_a((LPCSTR)pvPara));
if (!pvPara) if (!pvPara)
@ -1731,7 +1731,7 @@ static void WINAPI CRYPT_FileCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
{ {
PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore; PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
TRACE("(%p, %08lx)\n", store, dwFlags); TRACE("(%p, %08x)\n", store, dwFlags);
if (store->dirty) if (store->dirty)
CRYPT_WriteSerializedFile(store->file, store->memStore); CRYPT_WriteSerializedFile(store->file, store->memStore);
CertCloseStore(store->memStore, dwFlags); CertCloseStore(store->memStore, dwFlags);
@ -1744,7 +1744,7 @@ static BOOL WINAPI CRYPT_FileWriteCert(HCERTSTORE hCertStore,
{ {
PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore; PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
TRACE("(%p, %p, %ld)\n", hCertStore, cert, dwFlags); TRACE("(%p, %p, %d)\n", hCertStore, cert, dwFlags);
store->dirty = TRUE; store->dirty = TRUE;
return TRUE; return TRUE;
} }
@ -1754,7 +1754,7 @@ static BOOL WINAPI CRYPT_FileDeleteCert(HCERTSTORE hCertStore,
{ {
PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore; PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
TRACE("(%p, %p, %08lx)\n", hCertStore, pCertContext, dwFlags); TRACE("(%p, %p, %08x)\n", hCertStore, pCertContext, dwFlags);
store->dirty = TRUE; store->dirty = TRUE;
return TRUE; return TRUE;
} }
@ -1764,7 +1764,7 @@ static BOOL WINAPI CRYPT_FileWriteCRL(HCERTSTORE hCertStore,
{ {
PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore; PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
TRACE("(%p, %p, %ld)\n", hCertStore, crl, dwFlags); TRACE("(%p, %p, %d)\n", hCertStore, crl, dwFlags);
store->dirty = TRUE; store->dirty = TRUE;
return TRUE; return TRUE;
} }
@ -1774,7 +1774,7 @@ static BOOL WINAPI CRYPT_FileDeleteCRL(HCERTSTORE hCertStore,
{ {
PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore; PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
TRACE("(%p, %p, %08lx)\n", hCertStore, pCrlContext, dwFlags); TRACE("(%p, %p, %08x)\n", hCertStore, pCrlContext, dwFlags);
store->dirty = TRUE; store->dirty = TRUE;
return TRUE; return TRUE;
} }
@ -1785,7 +1785,7 @@ static BOOL WINAPI CRYPT_FileControl(HCERTSTORE hCertStore, DWORD dwFlags,
PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore; PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
BOOL ret; BOOL ret;
TRACE("(%p, %08lx, %ld, %p)\n", hCertStore, dwFlags, dwCtrlType, TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
pvCtrlPara); pvCtrlPara);
switch (dwCtrlType) switch (dwCtrlType)
@ -1807,7 +1807,7 @@ static BOOL WINAPI CRYPT_FileControl(HCERTSTORE hCertStore, DWORD dwFlags,
ret = TRUE; ret = TRUE;
break; break;
default: default:
FIXME("%ld: stub\n", dwCtrlType); FIXME("%d: stub\n", dwCtrlType);
ret = FALSE; ret = FALSE;
} }
return ret; return ret;
@ -1836,7 +1836,7 @@ static PWINECRYPT_CERTSTORE CRYPT_FileOpenStore(HCRYPTPROV hCryptProv,
PWINECRYPT_CERTSTORE store = NULL; PWINECRYPT_CERTSTORE store = NULL;
HANDLE file = (HANDLE)pvPara; HANDLE file = (HANDLE)pvPara;
TRACE("(%ld, %08lx, %p)\n", hCryptProv, dwFlags, pvPara); TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
if (!pvPara) if (!pvPara)
{ {
@ -1901,7 +1901,7 @@ static PWINECRYPT_CERTSTORE CRYPT_FileNameOpenStoreW(HCRYPTPROV hCryptProv,
DWORD access, create; DWORD access, create;
HANDLE file; HANDLE file;
TRACE("(%ld, %08lx, %s)\n", hCryptProv, dwFlags, debugstr_w(fileName)); TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags, debugstr_w(fileName));
if (!fileName) if (!fileName)
{ {
@ -1944,7 +1944,7 @@ static PWINECRYPT_CERTSTORE CRYPT_FileNameOpenStoreA(HCRYPTPROV hCryptProv,
int len; int len;
PWINECRYPT_CERTSTORE ret = NULL; PWINECRYPT_CERTSTORE ret = NULL;
TRACE("(%ld, %08lx, %s)\n", hCryptProv, dwFlags, TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
debugstr_a((LPCSTR)pvPara)); debugstr_a((LPCSTR)pvPara));
if (!pvPara) if (!pvPara)
@ -1971,9 +1971,9 @@ static PWINECRYPT_CERTSTORE CRYPT_PhysOpenStoreW(HCRYPTPROV hCryptProv,
DWORD dwFlags, const void *pvPara) DWORD dwFlags, const void *pvPara)
{ {
if (dwFlags & CERT_SYSTEM_STORE_RELOCATE_FLAG) if (dwFlags & CERT_SYSTEM_STORE_RELOCATE_FLAG)
FIXME("(%ld, %08lx, %p): stub\n", hCryptProv, dwFlags, pvPara); FIXME("(%ld, %08x, %p): stub\n", hCryptProv, dwFlags, pvPara);
else else
FIXME("(%ld, %08lx, %s): stub\n", hCryptProv, dwFlags, FIXME("(%ld, %08x, %s): stub\n", hCryptProv, dwFlags,
debugstr_w((LPCWSTR)pvPara)); debugstr_w((LPCWSTR)pvPara));
return NULL; return NULL;
} }
@ -1985,7 +1985,7 @@ HCERTSTORE WINAPI CertOpenStore(LPCSTR lpszStoreProvider,
WINECRYPT_CERTSTORE *hcs; WINECRYPT_CERTSTORE *hcs;
StoreOpenFunc openFunc = NULL; StoreOpenFunc openFunc = NULL;
TRACE("(%s, %08lx, %08lx, %08lx, %p)\n", debugstr_a(lpszStoreProvider), TRACE("(%s, %08x, %08lx, %08x, %p)\n", debugstr_a(lpszStoreProvider),
dwMsgAndCertEncodingType, hCryptProv, dwFlags, pvPara); dwMsgAndCertEncodingType, hCryptProv, dwFlags, pvPara);
if (!HIWORD(lpszStoreProvider)) if (!HIWORD(lpszStoreProvider))
@ -2081,7 +2081,7 @@ HCERTSTORE WINAPI CertOpenSystemStoreW(HCRYPTPROV hProv,
BOOL WINAPI CertSaveStore(HCERTSTORE hCertStore, DWORD dwMsgAndCertEncodingType, BOOL WINAPI CertSaveStore(HCERTSTORE hCertStore, DWORD dwMsgAndCertEncodingType,
DWORD dwSaveAs, DWORD dwSaveTo, void* pvSaveToPara, DWORD dwFlags) DWORD dwSaveAs, DWORD dwSaveTo, void* pvSaveToPara, DWORD dwFlags)
{ {
FIXME("(%p,%ld,%ld,%ld,%p,%08lx) stub!\n", hCertStore, FIXME("(%p,%d,%d,%d,%p,%08x) stub!\n", hCertStore,
dwMsgAndCertEncodingType, dwSaveAs, dwSaveTo, pvSaveToPara, dwFlags); dwMsgAndCertEncodingType, dwSaveAs, dwSaveTo, pvSaveToPara, dwFlags);
return TRUE; return TRUE;
} }
@ -2112,7 +2112,7 @@ BOOL WINAPI CertAddCertificateContextToStore(HCERTSTORE hCertStore,
BOOL ret = TRUE; BOOL ret = TRUE;
PCCERT_CONTEXT toAdd = NULL, existing = NULL; PCCERT_CONTEXT toAdd = NULL, existing = NULL;
TRACE("(%p, %p, %08lx, %p)\n", hCertStore, pCertContext, TRACE("(%p, %p, %08x, %p)\n", hCertStore, pCertContext,
dwAddDisposition, ppStoreContext); dwAddDisposition, ppStoreContext);
/* Weird case to pass a test */ /* Weird case to pass a test */
@ -2166,7 +2166,7 @@ BOOL WINAPI CertAddCertificateContextToStore(HCERTSTORE hCertStore,
CertContext_CopyProperties(existing, pCertContext); CertContext_CopyProperties(existing, pCertContext);
break; break;
default: default:
FIXME("Unimplemented add disposition %ld\n", dwAddDisposition); FIXME("Unimplemented add disposition %d\n", dwAddDisposition);
ret = FALSE; ret = FALSE;
} }
@ -2239,7 +2239,7 @@ BOOL WINAPI CertAddCRLContextToStore(HCERTSTORE hCertStore,
BOOL ret = TRUE; BOOL ret = TRUE;
PCCRL_CONTEXT toAdd = NULL, existing = NULL; PCCRL_CONTEXT toAdd = NULL, existing = NULL;
TRACE("(%p, %p, %08lx, %p)\n", hCertStore, pCrlContext, TRACE("(%p, %p, %08x, %p)\n", hCertStore, pCrlContext,
dwAddDisposition, ppStoreContext); dwAddDisposition, ppStoreContext);
/* Weird case to pass a test */ /* Weird case to pass a test */
@ -2300,7 +2300,7 @@ BOOL WINAPI CertAddCRLContextToStore(HCERTSTORE hCertStore,
CrlContext_CopyProperties(existing, pCrlContext); CrlContext_CopyProperties(existing, pCrlContext);
break; break;
default: default:
FIXME("Unimplemented add disposition %ld\n", dwAddDisposition); FIXME("Unimplemented add disposition %d\n", dwAddDisposition);
ret = FALSE; ret = FALSE;
} }
@ -2365,7 +2365,7 @@ PCCRL_CONTEXT WINAPI CertEnumCRLsInStore(HCERTSTORE hCertStore,
PCCTL_CONTEXT WINAPI CertCreateCTLContext(DWORD dwCertEncodingType, PCCTL_CONTEXT WINAPI CertCreateCTLContext(DWORD dwCertEncodingType,
const BYTE* pbCtlEncoded, DWORD cbCtlEncoded) const BYTE* pbCtlEncoded, DWORD cbCtlEncoded)
{ {
FIXME("(%08lx, %p, %08lx): stub\n", dwCertEncodingType, pbCtlEncoded, FIXME("(%08x, %p, %08x): stub\n", dwCertEncodingType, pbCtlEncoded,
cbCtlEncoded); cbCtlEncoded);
return NULL; return NULL;
} }
@ -2374,7 +2374,7 @@ BOOL WINAPI CertAddEncodedCTLToStore(HCERTSTORE hCertStore,
DWORD dwMsgAndCertEncodingType, const BYTE *pbCtlEncoded, DWORD cbCtlEncoded, DWORD dwMsgAndCertEncodingType, const BYTE *pbCtlEncoded, DWORD cbCtlEncoded,
DWORD dwAddDisposition, PCCTL_CONTEXT *ppCtlContext) DWORD dwAddDisposition, PCCTL_CONTEXT *ppCtlContext)
{ {
FIXME("(%p, %08lx, %p, %ld, %08lx, %p): stub\n", hCertStore, FIXME("(%p, %08x, %p, %d, %08x, %p): stub\n", hCertStore,
dwMsgAndCertEncodingType, pbCtlEncoded, cbCtlEncoded, dwAddDisposition, dwMsgAndCertEncodingType, pbCtlEncoded, cbCtlEncoded, dwAddDisposition,
ppCtlContext); ppCtlContext);
return FALSE; return FALSE;
@ -2384,7 +2384,7 @@ BOOL WINAPI CertAddCTLContextToStore(HCERTSTORE hCertStore,
PCCTL_CONTEXT pCtlContext, DWORD dwAddDisposition, PCCTL_CONTEXT pCtlContext, DWORD dwAddDisposition,
PCCTL_CONTEXT* ppStoreContext) PCCTL_CONTEXT* ppStoreContext)
{ {
FIXME("(%p, %p, %08lx, %p): stub\n", hCertStore, pCtlContext, FIXME("(%p, %p, %08x, %p): stub\n", hCertStore, pCtlContext,
dwAddDisposition, ppStoreContext); dwAddDisposition, ppStoreContext);
return TRUE; return TRUE;
} }
@ -2429,7 +2429,7 @@ BOOL WINAPI CertCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
{ {
WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *) hCertStore; WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *) hCertStore;
TRACE("(%p, %08lx)\n", hCertStore, dwFlags); TRACE("(%p, %08x)\n", hCertStore, dwFlags);
if( ! hCertStore ) if( ! hCertStore )
return TRUE; return TRUE;
@ -2446,7 +2446,7 @@ BOOL WINAPI CertCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
hcs->closeStore(hcs, dwFlags); hcs->closeStore(hcs, dwFlags);
} }
else else
TRACE("%p's ref count is %ld\n", hcs, hcs->ref); TRACE("%p's ref count is %d\n", hcs, hcs->ref);
return TRUE; return TRUE;
} }
@ -2456,7 +2456,7 @@ BOOL WINAPI CertControlStore(HCERTSTORE hCertStore, DWORD dwFlags,
WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *)hCertStore; WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *)hCertStore;
BOOL ret; BOOL ret;
TRACE("(%p, %08lx, %ld, %p)\n", hCertStore, dwFlags, dwCtrlType, TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
pvCtrlPara); pvCtrlPara);
if (!hcs) if (!hcs)
@ -2476,21 +2476,21 @@ BOOL WINAPI CertControlStore(HCERTSTORE hCertStore, DWORD dwFlags,
DWORD WINAPI CertEnumCTLContextProperties(PCCTL_CONTEXT pCTLContext, DWORD WINAPI CertEnumCTLContextProperties(PCCTL_CONTEXT pCTLContext,
DWORD dwPropId) DWORD dwPropId)
{ {
FIXME("(%p, %ld): stub\n", pCTLContext, dwPropId); FIXME("(%p, %d): stub\n", pCTLContext, dwPropId);
return 0; return 0;
} }
BOOL WINAPI CertGetCTLContextProperty(PCCTL_CONTEXT pCTLContext, BOOL WINAPI CertGetCTLContextProperty(PCCTL_CONTEXT pCTLContext,
DWORD dwPropId, void *pvData, DWORD *pcbData) DWORD dwPropId, void *pvData, DWORD *pcbData)
{ {
FIXME("(%p, %ld, %p, %p): stub\n", pCTLContext, dwPropId, pvData, pcbData); FIXME("(%p, %d, %p, %p): stub\n", pCTLContext, dwPropId, pvData, pcbData);
return FALSE; return FALSE;
} }
BOOL WINAPI CertSetCTLContextProperty(PCCTL_CONTEXT pCTLContext, BOOL WINAPI CertSetCTLContextProperty(PCCTL_CONTEXT pCTLContext,
DWORD dwPropId, DWORD dwFlags, const void *pvData) DWORD dwPropId, DWORD dwFlags, const void *pvData)
{ {
FIXME("(%p, %ld, %08lx, %p): stub\n", pCTLContext, dwPropId, dwFlags, FIXME("(%p, %d, %08x, %p): stub\n", pCTLContext, dwPropId, dwFlags,
pvData); pvData);
return FALSE; return FALSE;
} }
@ -2503,7 +2503,7 @@ BOOL WINAPI CertAddStoreToCollection(HCERTSTORE hCollectionStore,
PWINE_STORE_LIST_ENTRY entry; PWINE_STORE_LIST_ENTRY entry;
BOOL ret; BOOL ret;
TRACE("(%p, %p, %08lx, %ld)\n", hCollectionStore, hSiblingStore, TRACE("(%p, %p, %08x, %d)\n", hCollectionStore, hSiblingStore,
dwUpdateFlags, dwPriority); dwUpdateFlags, dwPriority);
if (!collection || !sibling) if (!collection || !sibling)
@ -2528,12 +2528,12 @@ BOOL WINAPI CertAddStoreToCollection(HCERTSTORE hCollectionStore,
if (entry) if (entry)
{ {
InterlockedIncrement(&sibling->ref); InterlockedIncrement(&sibling->ref);
TRACE("sibling %p's ref count is %ld\n", sibling, sibling->ref); TRACE("sibling %p's ref count is %d\n", sibling, sibling->ref);
entry->store = sibling; entry->store = sibling;
entry->dwUpdateFlags = dwUpdateFlags; entry->dwUpdateFlags = dwUpdateFlags;
entry->dwPriority = dwPriority; entry->dwPriority = dwPriority;
list_init(&entry->entry); list_init(&entry->entry);
TRACE("%p: adding %p, priority %ld\n", collection, entry, dwPriority); TRACE("%p: adding %p, priority %d\n", collection, entry, dwPriority);
EnterCriticalSection(&collection->cs); EnterCriticalSection(&collection->cs);
if (dwPriority) if (dwPriority)
{ {

36
dlls/crypt32/str.c
View File

@ -31,7 +31,7 @@ DWORD WINAPI CertRDNValueToStrA(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
{ {
DWORD ret = 0; DWORD ret = 0;
TRACE("(%ld, %p, %p, %ld)\n", dwValueType, pValue, psz, csz); TRACE("(%d, %p, %p, %d)\n", dwValueType, pValue, psz, csz);
switch (dwValueType) switch (dwValueType)
{ {
@ -60,7 +60,7 @@ DWORD WINAPI CertRDNValueToStrA(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
} }
break; break;
default: default:
FIXME("string type %ld unimplemented\n", dwValueType); FIXME("string type %d unimplemented\n", dwValueType);
} }
if (psz && csz) if (psz && csz)
{ {
@ -70,7 +70,7 @@ DWORD WINAPI CertRDNValueToStrA(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
} }
else else
ret++; ret++;
TRACE("returning %ld (%s)\n", ret, debugstr_a(psz)); TRACE("returning %d (%s)\n", ret, debugstr_a(psz));
return ret; return ret;
} }
@ -79,7 +79,7 @@ DWORD WINAPI CertRDNValueToStrW(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
{ {
DWORD ret = 0; DWORD ret = 0;
TRACE("(%ld, %p, %p, %ld)\n", dwValueType, pValue, psz, csz); TRACE("(%d, %p, %p, %d)\n", dwValueType, pValue, psz, csz);
switch (dwValueType) switch (dwValueType)
{ {
@ -111,7 +111,7 @@ DWORD WINAPI CertRDNValueToStrW(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
} }
break; break;
default: default:
FIXME("string type %ld unimplemented\n", dwValueType); FIXME("string type %d unimplemented\n", dwValueType);
} }
if (psz && csz) if (psz && csz)
{ {
@ -121,7 +121,7 @@ DWORD WINAPI CertRDNValueToStrW(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
} }
else else
ret++; ret++;
TRACE("returning %ld (%s)\n", ret, debugstr_w(psz)); TRACE("returning %d (%s)\n", ret, debugstr_w(psz));
return ret; return ret;
} }
@ -134,7 +134,7 @@ static DWORD CRYPT_AddPrefixA(LPCSTR prefix, LPSTR psz, DWORD csz)
{ {
DWORD chars; DWORD chars;
TRACE("(%s, %p, %ld)\n", debugstr_a(prefix), psz, csz); TRACE("(%s, %p, %d)\n", debugstr_a(prefix), psz, csz);
if (psz) if (psz)
{ {
@ -164,10 +164,10 @@ DWORD WINAPI CertNameToStrA(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName,
BOOL bRet; BOOL bRet;
CERT_NAME_INFO *info; CERT_NAME_INFO *info;
TRACE("(%ld, %p, %08lx, %p, %ld)\n", dwCertEncodingType, pName, dwStrType, TRACE("(%d, %p, %08x, %p, %d)\n", dwCertEncodingType, pName, dwStrType,
psz, csz); psz, csz);
if (dwStrType & unsupportedFlags) if (dwStrType & unsupportedFlags)
FIXME("unsupported flags: %08lx\n", dwStrType & unsupportedFlags); FIXME("unsupported flags: %08x\n", dwStrType & unsupportedFlags);
bRet = CryptDecodeObjectEx(dwCertEncodingType, X509_NAME, pName->pbData, bRet = CryptDecodeObjectEx(dwCertEncodingType, X509_NAME, pName->pbData,
pName->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &bytes); pName->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &bytes);
@ -267,7 +267,7 @@ static DWORD CRYPT_AddPrefixAToW(LPCSTR prefix, LPWSTR psz, DWORD csz)
{ {
DWORD chars; DWORD chars;
TRACE("(%s, %p, %ld)\n", debugstr_a(prefix), psz, csz); TRACE("(%s, %p, %d)\n", debugstr_a(prefix), psz, csz);
if (psz) if (psz)
{ {
@ -295,7 +295,7 @@ static DWORD CRYPT_AddPrefixW(LPCWSTR prefix, LPWSTR psz, DWORD csz)
{ {
DWORD chars; DWORD chars;
TRACE("(%s, %p, %ld)\n", debugstr_w(prefix), psz, csz); TRACE("(%s, %p, %d)\n", debugstr_w(prefix), psz, csz);
if (psz) if (psz)
{ {
@ -325,10 +325,10 @@ DWORD WINAPI CertNameToStrW(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName,
BOOL bRet; BOOL bRet;
CERT_NAME_INFO *info; CERT_NAME_INFO *info;
TRACE("(%ld, %p, %08lx, %p, %ld)\n", dwCertEncodingType, pName, dwStrType, TRACE("(%d, %p, %08x, %p, %d)\n", dwCertEncodingType, pName, dwStrType,
psz, csz); psz, csz);
if (dwStrType & unsupportedFlags) if (dwStrType & unsupportedFlags)
FIXME("unsupported flags: %08lx\n", dwStrType & unsupportedFlags); FIXME("unsupported flags: %08x\n", dwStrType & unsupportedFlags);
bRet = CryptDecodeObjectEx(dwCertEncodingType, X509_NAME, pName->pbData, bRet = CryptDecodeObjectEx(dwCertEncodingType, X509_NAME, pName->pbData,
pName->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &bytes); pName->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &bytes);
@ -430,7 +430,7 @@ BOOL WINAPI CertStrToNameA(DWORD dwCertEncodingType, LPCSTR pszX500,
BOOL ret; BOOL ret;
int len; int len;
TRACE("(%08lx, %s, %08lx, %p, %p, %p, %p)\n", dwCertEncodingType, TRACE("(%08x, %s, %08x, %p, %p, %p, %p)\n", dwCertEncodingType,
debugstr_a(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded, debugstr_a(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded,
ppszError); ppszError);
@ -706,7 +706,7 @@ BOOL WINAPI CertStrToNameW(DWORD dwCertEncodingType, LPCWSTR pszX500,
DWORD i, error = ERROR_SUCCESS; DWORD i, error = ERROR_SUCCESS;
BOOL ret = TRUE; BOOL ret = TRUE;
TRACE("(%08lx, %s, %08lx, %p, %p, %p, %p)\n", dwCertEncodingType, TRACE("(%08x, %s, %08x, %p, %p, %p, %p)\n", dwCertEncodingType,
debugstr_w(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded, debugstr_w(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded,
ppszError); ppszError);
@ -798,7 +798,7 @@ DWORD WINAPI CertGetNameStringA(PCCERT_CONTEXT pCertContext, DWORD dwType,
{ {
DWORD ret; DWORD ret;
TRACE("(%p, %ld, %08lx, %p, %p, %ld)\n", pCertContext, dwType, dwFlags, TRACE("(%p, %d, %08x, %p, %p, %d)\n", pCertContext, dwType, dwFlags,
pvTypePara, pszNameString, cchNameString); pvTypePara, pszNameString, cchNameString);
if (pszNameString) if (pszNameString)
@ -843,7 +843,7 @@ DWORD WINAPI CertGetNameStringW(PCCERT_CONTEXT pCertContext, DWORD dwType,
PCERT_NAME_BLOB name; PCERT_NAME_BLOB name;
LPCSTR altNameOID; LPCSTR altNameOID;
TRACE("(%p, %ld, %08lx, %p, %p, %ld)\n", pCertContext, dwType, TRACE("(%p, %d, %08x, %p, %p, %d)\n", pCertContext, dwType,
dwFlags, pvTypePara, pszNameString, cchNameString); dwFlags, pvTypePara, pszNameString, cchNameString);
if (dwFlags & CERT_NAME_ISSUER_FLAG) if (dwFlags & CERT_NAME_ISSUER_FLAG)
@ -919,7 +919,7 @@ DWORD WINAPI CertGetNameStringW(PCCERT_CONTEXT pCertContext, DWORD dwType,
break; break;
} }
default: default:
FIXME("unimplemented for type %ld\n", dwType); FIXME("unimplemented for type %d\n", dwType);
ret = 0; ret = 0;
} }
return ret; return ret;