You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
650 lines
24 KiB
650 lines
24 KiB
/*
|
|
** d e m a n d . h
|
|
**
|
|
** Purpose: create an intelligent method of defer loading functions
|
|
**
|
|
** Creators: jimsch, brimo, t-erikne
|
|
** Created: 5/15/97
|
|
**
|
|
** Copyright (C) Microsoft Corp. 1997
|
|
*/
|
|
|
|
#if _MSC_VER > 1000
|
|
#pragma once
|
|
#endif
|
|
|
|
#ifndef __DEMAND_H
|
|
#define __DEMAND_H
|
|
|
|
#ifndef MAC
|
|
//
|
|
// IF YOU #INCLUDE A FILE HERE YOU PROBABLY ARE CONFUSED.
|
|
// THIS FILE IS INCLUDED BY LOTS OF PEOPLE. THINK THRICE
|
|
// BEFORE #INCLUDING *ANYTHING* HERE. MAKE GOOD USE
|
|
// OF FORWARD REFS INSTEAD.
|
|
//
|
|
|
|
#ifdef IMPLEMENT_LOADER_FUNCTIONS
|
|
|
|
#define USE_CRITSEC
|
|
|
|
#define LOADER_FUNCTION(ret, name, args1, args2, err, dll) \
|
|
typedef ret (WINAPI * TYP_##name) args1; \
|
|
extern TYP_##name VAR_##name; \
|
|
ret WINAPI LOADER_##name args1 \
|
|
{ \
|
|
DemandLoad##dll(); \
|
|
if (VAR_##name == LOADER_##name) return err; \
|
|
return VAR_##name args2; \
|
|
} \
|
|
TYP_##name VAR_##name = LOADER_##name;
|
|
|
|
#define LOADER_FUNCTION_VOID(ret, name, args1, args2, dll) \
|
|
typedef ret (WINAPI * TYP_##name) args1; \
|
|
extern TYP_##name VAR_##name; \
|
|
ret WINAPI LOADER_##name args1 \
|
|
{ \
|
|
DemandLoad##dll(); \
|
|
if (VAR_##name == LOADER_##name) return; \
|
|
VAR_##name args2; \
|
|
return; \
|
|
} \
|
|
TYP_##name VAR_##name = LOADER_##name;
|
|
#if 0
|
|
// my 1st attempt
|
|
#define DemandLoadDLL_GENERATOR(fnsuffix, dllname, handle, procaddrlist) \
|
|
BOOL DemandLoad##fnsuffix() \
|
|
{ \
|
|
BOOL fRet = TRUE; \
|
|
\
|
|
Assert(fInit); \
|
|
EnterCriticalSection(&cs); \
|
|
\
|
|
if (0 == handle) \
|
|
{ \
|
|
handle = LoadLibrary(#dllname); \
|
|
\
|
|
if (0 == handle) \
|
|
fRet = FALSE; \
|
|
else \
|
|
{ \
|
|
procaddrlist \
|
|
} \
|
|
} \
|
|
\
|
|
LeaveCriticalSection(&cs); \
|
|
return fRet; \
|
|
}
|
|
#endif
|
|
|
|
#else // !IMPLEMENT_LOADER_FUNCTIONS
|
|
|
|
#define LOADER_FUNCTION(ret, name, args1, args2, err, dll) \
|
|
typedef ret (WINAPI * TYP_##name) args1; \
|
|
extern TYP_##name VAR_##name;
|
|
#define LOADER_FUNCTION_VOID(ret, name, args1, args2, dll) \
|
|
typedef ret (WINAPI * TYP_##name) args1; \
|
|
extern TYP_##name VAR_##name;
|
|
|
|
#if 0
|
|
#define DemandLoadDLL_GENERATOR(fnsuffix, dllname, handle, procaddrlist) \
|
|
BOOL DemandLoad##fnsuffix(void);
|
|
#endif
|
|
|
|
#endif // IMPLEMENT_LOADER_FUNCTIONS
|
|
|
|
void InitDemandLoadedLibs();
|
|
void FreeDemandLoadedLibs();
|
|
|
|
/////////////////////////////////////
|
|
// CRYPT32.DLL
|
|
|
|
BOOL DemandLoadCrypt32(void);
|
|
|
|
typedef void *HCERTSTORE;
|
|
typedef const struct _CERT_CONTEXT *PCCERT_CONTEXT;
|
|
typedef ULONG_PTR HCRYPTPROV;
|
|
typedef struct _CERT_INFO *PCERT_INFO;
|
|
|
|
LOADER_FUNCTION( BOOL, CertFreeCertificateContext,
|
|
(PCCERT_CONTEXT pCertContext),
|
|
(pCertContext),
|
|
FALSE, Crypt32)
|
|
#define CertFreeCertificateContext VAR_CertFreeCertificateContext
|
|
|
|
LOADER_FUNCTION( PCCERT_CONTEXT, CertDuplicateCertificateContext,
|
|
(PCCERT_CONTEXT pCertContext),
|
|
(pCertContext), NULL, Crypt32)
|
|
#define CertDuplicateCertificateContext VAR_CertDuplicateCertificateContext
|
|
|
|
LOADER_FUNCTION( PCCERT_CONTEXT, CertFindCertificateInStore,
|
|
(HCERTSTORE hCertStore, DWORD dwCertEncodingType, DWORD dwFindFlags, DWORD dwFindType, const void *pvFindPara, PCCERT_CONTEXT pPrevCertContext),
|
|
(hCertStore, dwCertEncodingType, dwFindFlags, dwFindType, pvFindPara, pPrevCertContext),
|
|
NULL, Crypt32)
|
|
#define CertFindCertificateInStore VAR_CertFindCertificateInStore
|
|
|
|
LOADER_FUNCTION( BOOL, CertCloseStore,
|
|
(HCERTSTORE hCertStore, DWORD dwFlags),
|
|
(hCertStore, dwFlags),
|
|
FALSE, Crypt32)
|
|
#define CertCloseStore VAR_CertCloseStore
|
|
|
|
LOADER_FUNCTION( BOOL, CertDeleteCertificateFromStore,
|
|
(PCCERT_CONTEXT pccert),
|
|
(pccert),
|
|
FALSE, Crypt32)
|
|
#define CertDeleteCertificateFromStore VAR_CertDeleteCertificateFromStore
|
|
|
|
LOADER_FUNCTION( HCERTSTORE, CertOpenStore,
|
|
(LPCSTR lpszStoreProvider, DWORD dwEncodingType, HCRYPTPROV hCryptProv,
|
|
DWORD dwFlags, const void *pvPara),
|
|
(lpszStoreProvider, dwEncodingType, hCryptProv, dwFlags, pvPara),
|
|
NULL, Crypt32)
|
|
#define CertOpenStore VAR_CertOpenStore
|
|
|
|
LOADER_FUNCTION( BOOL, CertGetCertificateContextProperty,
|
|
(PCCERT_CONTEXT pCertContext, DWORD dwPropId, void *pvData, DWORD *pcbData),
|
|
(pCertContext, dwPropId, pvData, pcbData),
|
|
FALSE, Crypt32)
|
|
#define CertGetCertificateContextProperty VAR_CertGetCertificateContextProperty
|
|
|
|
LOADER_FUNCTION( BOOL, CertCompareCertificate,
|
|
(DWORD dwCertEncodingType, PCERT_INFO pCertId1, PCERT_INFO pCertId2),
|
|
(dwCertEncodingType, pCertId1, pCertId2),
|
|
FALSE, Crypt32)
|
|
#define CertCompareCertificate VAR_CertCompareCertificate
|
|
|
|
LOADER_FUNCTION( PCCERT_CONTEXT, CertEnumCertificatesInStore,
|
|
(HCERTSTORE hCertStore, PCCERT_CONTEXT pPrevCertContext),
|
|
(hCertStore, pPrevCertContext),
|
|
NULL, Crypt32)
|
|
#define CertEnumCertificatesInStore VAR_CertEnumCertificatesInStore
|
|
|
|
LOADER_FUNCTION( BOOL, CryptDecodeObject,
|
|
(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE * pbEncoded,
|
|
DWORD cbEncoded, DWORD dwFlags, void * pvStructInfo, DWORD * pcbStructInfo),
|
|
(dwCertEncodingType, lpszStructType, pbEncoded, cbEncoded, dwFlags,
|
|
pvStructInfo, pcbStructInfo),
|
|
FALSE, Crypt32)
|
|
#define CryptDecodeObject VAR_CryptDecodeObject
|
|
|
|
LOADER_FUNCTION( PCERT_EXTENSION, CertFindExtension,
|
|
(LPCSTR pszObjId, DWORD cExtensions, CERT_EXTENSION rgExtensions[]),
|
|
(pszObjId, cExtensions, rgExtensions),
|
|
NULL, Crypt32)
|
|
#define CertFindExtension VAR_CertFindExtension
|
|
|
|
LOADER_FUNCTION( BOOL, CryptFormatObject,
|
|
(DWORD dwCertEncodingType, DWORD dwFormatType, DWORD dwFormatStrType,
|
|
void * pFormatStruct, LPCSTR lpszStructType, const BYTE * pbEncoded,
|
|
DWORD cbEncoded, void * pbFormat, DWORD * pcbFormat),
|
|
(dwCertEncodingType, dwFormatType, dwFormatStrType, pFormatStruct,
|
|
lpszStructType, pbEncoded, cbEncoded, pbFormat, pcbFormat),
|
|
FALSE, Crypt32)
|
|
#define CryptFormatObject VAR_CryptFormatObject
|
|
|
|
LOADER_FUNCTION( DWORD, CertNameToStrW,
|
|
(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName, DWORD dwStrType,
|
|
LPWSTR psz, DWORD csz),
|
|
(dwCertEncodingType, pName, dwStrType, psz, csz),
|
|
0, Crypt32)
|
|
#define CertNameToStrW VAR_CertNameToStrW
|
|
|
|
LOADER_FUNCTION( BOOL, CertStrToNameA,
|
|
(DWORD dwCertEncodingType, LPCSTR pszX500, DWORD dwStrType, void *pvReserved,
|
|
BYTE *pbEncoded, DWORD *pcbEncoded, LPCSTR *ppszError),
|
|
(dwCertEncodingType, pszX500, dwStrType, pvReserved,
|
|
pbEncoded, pcbEncoded, ppszError),
|
|
FALSE, Crypt32)
|
|
#define CertStrToNameA VAR_CertStrToNameA
|
|
|
|
LOADER_FUNCTION( DWORD, CertRDNValueToStrW,
|
|
(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue, LPWSTR psz, DWORD csz),
|
|
(dwValueType, pValue, psz, csz),
|
|
0, Crypt32)
|
|
#define CertRDNValueToStrW VAR_CertRDNValueToStrW
|
|
|
|
LOADER_FUNCTION( PCERT_RDN_ATTR, CertFindRDNAttr,
|
|
(LPCSTR pszObjId, PCERT_NAME_INFO pName),
|
|
(pszObjId, pName),
|
|
NULL, Crypt32)
|
|
#define CertFindRDNAttr VAR_CertFindRDNAttr
|
|
|
|
LOADER_FUNCTION( BOOL, CryptRegisterOIDFunction,
|
|
(DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID, LPCWSTR pwszDll,
|
|
LPCSTR pszOverrideFuncName),
|
|
(dwEncodingType, pszFuncName, pszOID, pwszDll, pszOverrideFuncName),
|
|
FALSE, Crypt32)
|
|
#define CryptRegisterOIDFunction VAR_CryptRegisterOIDFunction
|
|
|
|
LOADER_FUNCTION( BOOL, CryptUnregisterOIDFunction,
|
|
(DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID),
|
|
(dwEncodingType, pszFuncName, pszOID),
|
|
FALSE, Crypt32)
|
|
#define CryptUnregisterOIDFunction VAR_CryptUnregisterOIDFunction
|
|
|
|
LOADER_FUNCTION( BOOL, CertSetCertificateContextProperty,
|
|
(PCCERT_CONTEXT pCertContext, DWORD dwPropId, DWORD dwFlags, const void * pvData),
|
|
(pCertContext, dwPropId, dwFlags, pvData),
|
|
FALSE, Crypt32)
|
|
#define CertSetCertificateContextProperty VAR_CertSetCertificateContextProperty
|
|
|
|
LOADER_FUNCTION( BOOL, CertVerifyCTLUsage,
|
|
(DWORD dwEncodingType, DWORD dwSubjectType, void *pvSubject,
|
|
PCTL_USAGE pSubjectUsage, DWORD dwFlags,
|
|
PCTL_VERIFY_USAGE_PARA pVerifyUsagePara,
|
|
PCTL_VERIFY_USAGE_STATUS pVerifyUsageStatus),
|
|
(dwEncodingType, dwSubjectType, pvSubject, pSubjectUsage, dwFlags,
|
|
pVerifyUsagePara, pVerifyUsageStatus),
|
|
0, Crypt32)
|
|
#define CertVerifyCTLUsage VAR_CertVerifyCTLUsage
|
|
|
|
LOADER_FUNCTION( PCCERT_CONTEXT, CertGetIssuerCertificateFromStore,
|
|
(HCERTSTORE hCertStore, PCCERT_CONTEXT pSubjectContext,
|
|
PCCERT_CONTEXT pPrevIssuerContext, DWORD *pdwFlags),
|
|
(hCertStore, pSubjectContext, pPrevIssuerContext, pdwFlags),
|
|
NULL, Crypt32)
|
|
#define CertGetIssuerCertificateFromStore VAR_CertGetIssuerCertificateFromStore
|
|
|
|
LOADER_FUNCTION( BOOL, CertFreeCTLContext,
|
|
(PCCTL_CONTEXT pCtlContext),
|
|
(pCtlContext),
|
|
FALSE, Crypt32)
|
|
#define CertFreeCTLContext VAR_CertFreeCTLContext
|
|
|
|
LOADER_FUNCTION( BOOL, CertAddEncodedCTLToStore,
|
|
(HCERTSTORE hCertStore, DWORD dwMsgAndCertEncodingType, const BYTE *pbCtlEncoded,
|
|
DWORD cbCtlEncoded, DWORD dwAddDisposition, PCCTL_CONTEXT *ppCtlContext),
|
|
(hCertStore, dwMsgAndCertEncodingType, pbCtlEncoded, cbCtlEncoded,
|
|
dwAddDisposition, ppCtlContext),
|
|
FALSE, Crypt32)
|
|
#define CertAddEncodedCTLToStore VAR_CertAddEncodedCTLToStore
|
|
|
|
LOADER_FUNCTION( BOOL, CryptMsgEncodeAndSignCTL,
|
|
(DWORD dwMsgEncodingType, PCTL_INFO pCtlInfo, PCMSG_SIGNED_ENCODE_INFO pSignInfo,
|
|
DWORD dwFlags, BYTE *pbEncoded, DWORD *pcbEncoded),
|
|
(dwMsgEncodingType, pCtlInfo, pSignInfo, dwFlags, pbEncoded, pcbEncoded),
|
|
FALSE, Crypt32)
|
|
#define CryptMsgEncodeAndSignCTL VAR_CryptMsgEncodeAndSignCTL
|
|
|
|
LOADER_FUNCTION( PCCTL_CONTEXT, CertFindCTLInStore,
|
|
(HCERTSTORE hCertStore, DWORD dwMsgAndCertEncodingType, DWORD dwFindFlags,
|
|
DWORD dwFindType, const void *pvFindPara, PCCTL_CONTEXT pPrevCtlContext),
|
|
(hCertStore, dwMsgAndCertEncodingType, dwFindFlags,
|
|
dwFindType, pvFindPara, pPrevCtlContext),
|
|
NULL, Crypt32)
|
|
#define CertFindCTLInStore VAR_CertFindCTLInStore
|
|
|
|
LOADER_FUNCTION( PCCTL_CONTEXT, CryptSignAndEncodeCertificate,
|
|
(HCRYPTPROV hCryptProv, DWORD dwKeySpec, DWORD dwCertEncodingType,
|
|
LPCSTR lpszStructType, const void *pvStructInfo,
|
|
PCRYPT_ALGORITHM_IDENTIFIER pSignatureAlgorithm,
|
|
const void *pvHashAuxInfo, PBYTE pbEncoded, DWORD *pcbEncoded),
|
|
(hCryptProv, dwKeySpec, dwCertEncodingType, lpszStructType,
|
|
pvStructInfo, pSignatureAlgorithm, pvHashAuxInfo, pbEncoded,
|
|
pcbEncoded),
|
|
NULL, Crypt32)
|
|
#define CryptSignAndEncodeCertificate VAR_CryptSignAndEncodeCertificate
|
|
|
|
LOADER_FUNCTION( BOOL, CryptEncodeObject,
|
|
(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo,
|
|
BYTE *pbEncoded, DWORD *pcbEncoded),
|
|
(dwCertEncodingType, lpszStructType, pvStructInfo, pbEncoded,pcbEncoded),
|
|
FALSE, Crypt32)
|
|
#define CryptEncodeObject VAR_CryptEncodeObject
|
|
|
|
LOADER_FUNCTION( BOOL, CryptExportPublicKeyInfo,
|
|
(HCRYPTPROV hCryptProv, DWORD dwKeySpec, DWORD dwCertEncodingType,
|
|
PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo),
|
|
(hCryptProv, dwKeySpec, dwCertEncodingType, pInfo, pcbInfo),
|
|
FALSE, Crypt32)
|
|
#define CryptExportPublicKeyInfo VAR_CryptExportPublicKeyInfo
|
|
|
|
LOADER_FUNCTION( HCERTSTORE, CertDuplicateStore,
|
|
(HCERTSTORE hCertStore),
|
|
(hCertStore),
|
|
NULL, Crypt32)
|
|
#define CertDuplicateStore VAR_CertDuplicateStore
|
|
|
|
LOADER_FUNCTION( BOOL, CertAddEncodedCertificateToStore,
|
|
(HCERTSTORE hCertStore, DWORD dwCertEncodingType, const BYTE *pbCertEncoded,
|
|
DWORD cbCertEncoded, DWORD dwAddDisposition, PCCERT_CONTEXT *ppCertContext),
|
|
(hCertStore, dwCertEncodingType, pbCertEncoded,
|
|
cbCertEncoded, dwAddDisposition, ppCertContext),
|
|
FALSE, Crypt32)
|
|
#define CertAddEncodedCertificateToStore VAR_CertAddEncodedCertificateToStore
|
|
|
|
LOADER_FUNCTION( LONG, CertVerifyTimeValidity,
|
|
(LPFILETIME pTimeToVerify, PCERT_INFO pCertInfo),
|
|
(pTimeToVerify, pCertInfo),
|
|
+1, Crypt32) // Return AFTER by default
|
|
#define CertVerifyTimeValidity VAR_CertVerifyTimeValidity
|
|
|
|
LOADER_FUNCTION( PCTL_ENTRY, CertFindSubjectInCTL,
|
|
(DWORD dwEncodingType, DWORD dwSubjectType, void *pvSubject,
|
|
PCCTL_CONTEXT pCtlContext, DWORD dwFlags),
|
|
(dwEncodingType, dwSubjectType, pvSubject, pCtlContext, dwFlags),
|
|
NULL, Crypt32)
|
|
#define CertFindSubjectInCTL VAR_CertFindSubjectInCTL
|
|
|
|
LOADER_FUNCTION( BOOL, CertVerifySubjectCertificateContext,
|
|
(PCCERT_CONTEXT pSubject, PCCERT_CONTEXT pIssuer, DWORD *pdwFlags),
|
|
(pSubject, pIssuer, pdwFlags),
|
|
FALSE, Crypt32)
|
|
#define CertVerifySubjectCertificateContext VAR_CertVerifySubjectCertificateContext
|
|
|
|
LOADER_FUNCTION( BOOL, CertGetEnhancedKeyUsage,
|
|
(PCCERT_CONTEXT pCertContext, DWORD dwFlags, PCERT_ENHKEY_USAGE pUsage,
|
|
DWORD *pcbUsage),
|
|
(pCertContext, dwFlags, pUsage, pcbUsage),
|
|
FALSE, Crypt32)
|
|
#define CertGetEnhancedKeyUsage VAR_CertGetEnhancedKeyUsage
|
|
|
|
LOADER_FUNCTION( BOOL, CryptDecodeObjectEx,
|
|
(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo),
|
|
(dwCertEncodingType, lpszStructType, pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo, pcbStructInfo),
|
|
FALSE, Crypt32)
|
|
#define CryptDecodeObjectEx VAR_CryptDecodeObjectEx
|
|
|
|
LOADER_FUNCTION( BOOL, CryptEncodeObjectEx,
|
|
(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void * pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, void * pbEncoded, DWORD * pcbEncoded),
|
|
(dwCertEncodingType, lpszStructType, pvStructInfo, dwFlags, pEncodePara, pbEncoded, pcbEncoded),
|
|
FALSE, Crypt32)
|
|
#define CryptEncodeObjectEx VAR_CryptEncodeObjectEx
|
|
|
|
|
|
LOADER_FUNCTION( BOOL, CertGetCertificateChain,
|
|
(
|
|
HCERTCHAINENGINE hChainEngine,
|
|
PCCERT_CONTEXT pCertContext,
|
|
LPFILETIME pTime,
|
|
HCERTSTORE hAdditionalStore,
|
|
PCERT_CHAIN_PARA pChainPara,
|
|
DWORD dwFlags,
|
|
LPVOID pvReserved,
|
|
PCCERT_CHAIN_CONTEXT* ppChainContext
|
|
),
|
|
(
|
|
hChainEngine,
|
|
pCertContext,
|
|
pTime,
|
|
hAdditionalStore,
|
|
pChainPara,
|
|
dwFlags,
|
|
pvReserved,
|
|
ppChainContext
|
|
),
|
|
FALSE, Crypt32)
|
|
#define CertGetCertificateChain VAR_CertGetCertificateChain
|
|
|
|
LOADER_FUNCTION( BOOL, CertFreeCertificateChain,
|
|
(
|
|
PCCERT_CHAIN_CONTEXT pChainContext
|
|
),
|
|
(
|
|
pChainContext
|
|
),
|
|
FALSE, Crypt32)
|
|
#define CertFreeCertificateChain VAR_CertFreeCertificateChain
|
|
|
|
LOADER_FUNCTION( PCCERT_CHAIN_CONTEXT, CertDuplicateCertificateChain,
|
|
(
|
|
PCCERT_CHAIN_CONTEXT pChainContext
|
|
),
|
|
(
|
|
pChainContext
|
|
),
|
|
NULL, Crypt32)
|
|
#define CertDuplicateCertificateChain VAR_CertDuplicateCertificateChain
|
|
|
|
LOADER_FUNCTION( BOOL, CertAddStoreToCollection,
|
|
(
|
|
HCERTSTORE hCollectionStore,
|
|
HCERTSTORE hSiblingStore,
|
|
DWORD dwUpdateFlags,
|
|
DWORD dwPriority
|
|
),
|
|
(
|
|
hCollectionStore,
|
|
hSiblingStore,
|
|
dwUpdateFlags,
|
|
dwPriority
|
|
),
|
|
FALSE, Crypt32)
|
|
#define CertAddStoreToCollection VAR_CertAddStoreToCollection
|
|
|
|
LOADER_FUNCTION( BOOL, CertAddCertificateContextToStore,
|
|
(
|
|
HCERTSTORE hCertStore,
|
|
PCCERT_CONTEXT pCertContext,
|
|
DWORD dwAddDisposition,
|
|
PCCERT_CONTEXT *ppStoreContext
|
|
),
|
|
(
|
|
hCertStore,
|
|
pCertContext,
|
|
dwAddDisposition,
|
|
ppStoreContext
|
|
),
|
|
FALSE, Crypt32)
|
|
#define CertAddCertificateContextToStore VAR_CertAddCertificateContextToStore
|
|
|
|
LOADER_FUNCTION( BOOL, CertControlStore,
|
|
(
|
|
HCERTSTORE hCertStore,
|
|
DWORD dwFlags,
|
|
DWORD dwCtrlType,
|
|
void const *pvCtrlPara
|
|
),
|
|
(
|
|
hCertStore,
|
|
dwFlags,
|
|
dwCtrlType,
|
|
pvCtrlPara
|
|
),
|
|
FALSE, Crypt32)
|
|
#define CertControlStore VAR_CertControlStore
|
|
|
|
#if 0
|
|
LOADER_FUNCTION( BOOL, ,
|
|
(),
|
|
(),
|
|
FALSE, Crypt32)
|
|
#define X VAR_
|
|
#endif // 0
|
|
|
|
|
|
/////////////////////////////////////
|
|
// CRYPTUI.DLL
|
|
|
|
BOOL DemandLoadCryptUI(void);
|
|
BOOL CryptUIAvailable(void);
|
|
|
|
#ifdef OLD_STUFF
|
|
typedef const struct _CERT_CONTEXT *PCCERT_CONTEXT;
|
|
|
|
typedef const struct tagCRYPTUI_VIEWCERTIFICATE_STRUCTW *PCCRYPTUI_VIEWCERTIFICATE_STRUCTW;
|
|
typedef const struct tagCRYPTUI_VIEWCERTIFICATE_STRUCTA *PCCRYPTUI_VIEWCERTIFICATE_STRUCTA;
|
|
|
|
typedef const struct tagCRYPTUI_VIEWCERTIFICATEPROPERTIES_STRUCTW *PCCRYPTUI_VIEWCERTIFICATEPROPERTIES_STRUCTW;
|
|
typedef const struct tagCRYPTUI_VIEWCERTIFICATEPROPERTIES_STRUCTA *PCCRYPTUI_VIEWCERTIFICATEPROPERTIES_STRUCTA;
|
|
|
|
typedef const struct tagCRYPTUI_SELECTCERTIFICATE_STRUCTW *PCCRYPTUI_SELECTCERTIFICATE_STRUCTW;
|
|
typedef const struct tagCRYPTUI_SELECTCERTIFICATE_STRUCTA *PCCRYPTUI_SELECTCERTIFICATE_STRUCTA;
|
|
#endif
|
|
|
|
|
|
LOADER_FUNCTION(BOOL, CryptUIDlgViewCertificateW,
|
|
(IN PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo, OUT BOOL *pfPropertiesChanged),
|
|
(pCertViewInfo, pfPropertiesChanged),
|
|
FALSE, CryptUI)
|
|
#define CryptUIDlgViewCertificateW VAR_CryptUIDlgViewCertificateW
|
|
|
|
LOADER_FUNCTION(BOOL, CryptUIDlgViewCertificateA,
|
|
(IN PCCRYPTUI_VIEWCERTIFICATE_STRUCTA pCertViewInfo, OUT BOOL *pfPropertiesChanged),
|
|
(pCertViewInfo, pfPropertiesChanged),
|
|
FALSE, CryptUI)
|
|
#define CryptUIDlgViewCertificateA VAR_CryptUIDlgViewCertificateA
|
|
|
|
|
|
LOADER_FUNCTION(BOOL, CryptUIDlgViewCertificatePropertiesW,
|
|
(IN PCCRYPTUI_VIEWCERTIFICATEPROPERTIES_STRUCTW pcsp, OUT BOOL *pfPropertiesChanged),
|
|
(pcsp, pfPropertiesChanged),
|
|
FALSE, CryptUI)
|
|
#define CryptUIDlgViewCertificatePropertiesW VAR_CryptUIDlgViewCertificatePropertiesW
|
|
|
|
LOADER_FUNCTION(BOOL, CryptUIDlgViewCertificatePropertiesA,
|
|
(IN PCCRYPTUI_VIEWCERTIFICATEPROPERTIES_STRUCTA pcsp, OUT BOOL *pfPropertiesChanged),
|
|
(pcsp, pfPropertiesChanged),
|
|
FALSE, CryptUI)
|
|
#define CryptUIDlgViewCertificatePropertiesA VAR_CryptUIDlgViewCertificatePropertiesA
|
|
|
|
|
|
LOADER_FUNCTION(PCCERT_CONTEXT, CryptUIDlgSelectCertificateW,
|
|
(IN PCCRYPTUI_SELECTCERTIFICATE_STRUCTW pcsc),
|
|
(pcsc),
|
|
NULL, CryptUI)
|
|
#define CryptUIDlgSelectCertificateW VAR_CryptUIDlgSelectCertificateW
|
|
|
|
LOADER_FUNCTION(PCCERT_CONTEXT, CryptUIDlgSelectCertificateA,
|
|
(IN PCCRYPTUI_SELECTCERTIFICATE_STRUCTA pcsc),
|
|
(pcsc),
|
|
NULL, CryptUI)
|
|
#define CryptUIDlgSelectCertificateA VAR_CryptUIDlgSelectCertificateA
|
|
|
|
LOADER_FUNCTION( BOOL, CryptInstallDefaultContext,
|
|
(HCRYPTPROV hCryptProv, DWORD dwDefaultType, const void *pvDefaultPara,
|
|
DWORD dwFlags, void *pvReserved, HCRYPTDEFAULTCONTEXT *phDefaultContext),
|
|
(hCryptProv, dwDefaultType, pvDefaultPara, dwFlags, pvReserved,
|
|
phDefaultContext),
|
|
FALSE, Crypt32)
|
|
#define CryptInstallDefaultContext VAR_CryptInstallDefaultContext
|
|
|
|
LOADER_FUNCTION( BOOL, CryptUninstallDefaultContext,
|
|
(HCRYPTDEFAULTCONTEXT hDefaultContext, DWORD dwFlags, void *pvReserved),
|
|
(hDefaultContext, dwFlags, pvReserved),
|
|
FALSE, Crypt32)
|
|
#define CryptUninstallDefaultContext VAR_CryptUninstallDefaultContext
|
|
|
|
LOADER_FUNCTION( PCCERT_CONTEXT, CertGetSubjectCertificateFromStore,
|
|
(HCERTSTORE hCertStore, DWORD dwCertEncodingType, PCERT_INFO pCertId),
|
|
(hCertStore, dwCertEncodingType, pCertId),
|
|
NULL, Crypt32)
|
|
#define CertGetSubjectCertificateFromStore VAR_CertGetSubjectCertificateFromStore
|
|
|
|
#if 0
|
|
LOADER_FUNCTION( BOOL, ,
|
|
(),
|
|
(),
|
|
FALSE, Crypt32)
|
|
#define X VAR_
|
|
#endif // 0
|
|
|
|
|
|
/////////////////////////////////////
|
|
// ADVAPI32.DLL
|
|
|
|
#ifndef ALGIDDEF
|
|
#define ALGIDDEF
|
|
typedef unsigned int ALG_ID;
|
|
#endif
|
|
typedef ULONG_PTR HCRYPTKEY;
|
|
|
|
BOOL DemandLoadAdvApi32(void);
|
|
|
|
LOADER_FUNCTION( BOOL, CryptAcquireContextW,
|
|
(HCRYPTPROV *phProv, LPCWSTR pszContainer, LPCWSTR pszProvider, DWORD dwProvType, DWORD dwFlags),
|
|
(phProv, pszContainer, pszProvider, dwProvType, dwFlags),
|
|
FALSE, AdvApi32)
|
|
#define CryptAcquireContextW VAR_CryptAcquireContextW
|
|
|
|
#if 0
|
|
LOADER_FUNCTION( BOOL, CryptGetProvParam,
|
|
(HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags),
|
|
(hProv, dwParam, pbData, pdwDataLen, dwFlags),
|
|
FALSE, AdvApi32)
|
|
#define CryptGetProvParam VAR_CryptGetProvParam
|
|
|
|
LOADER_FUNCTION( BOOL, CryptReleaseContext,
|
|
(HCRYPTPROV hProv, DWORD dwFlags),
|
|
(hProv, dwFlags),
|
|
FALSE, AdvApi32)
|
|
#define CryptReleaseContext VAR_CryptReleaseContext
|
|
|
|
LOADER_FUNCTION( BOOL, CryptGenKey,
|
|
(HCRYPTPROV hProv, ALG_ID Algid, DWORD dwFlags, HCRYPTKEY *phKey),
|
|
(hProv, Algid, dwFlags, phKey),
|
|
FALSE, AdvApi32)
|
|
#define CryptGenKey VAR_CryptGenKey
|
|
|
|
LOADER_FUNCTION( BOOL, CryptDestroyKey,
|
|
(HCRYPTKEY hKey),
|
|
(hKey),
|
|
FALSE, AdvApi32)
|
|
#define CryptDestroyKey VAR_CryptDestroyKey
|
|
#endif // 0
|
|
|
|
|
|
#ifndef WIN16
|
|
|
|
/////////////////////////////////////
|
|
// USER32.DLL
|
|
|
|
BOOL DemandLoadUser32();
|
|
|
|
LOADER_FUNCTION( LRESULT, SendDlgItemMessageW,
|
|
(HWND hwnd, int idCtl, UINT msg, WPARAM wparam, LPARAM lparam),
|
|
(hwnd, idCtl, msg, wparam, lparam),
|
|
-1, User32)
|
|
#define SendDlgItemMessageW VAR_SendDlgItemMessageW
|
|
|
|
LOADER_FUNCTION( BOOL, SetDlgItemTextW,
|
|
(HWND hwnd, int idCtl, LPCWSTR psz),
|
|
(hwnd, idCtl, psz),
|
|
FALSE, User32)
|
|
#define SetDlgItemTextW VAR_SetDlgItemTextW
|
|
|
|
LOADER_FUNCTION( UINT, GetDlgItemTextW,
|
|
(HWND hwnd, int idCtl, LPWSTR psz, int nMax),
|
|
(hwnd, idCtl, psz, nMax),
|
|
FALSE, User32)
|
|
#define GetDlgItemTextW VAR_GetDlgItemTextW
|
|
|
|
LOADER_FUNCTION( int, LoadStringW,
|
|
(HINSTANCE hinst, UINT idStr, LPWSTR rgwch, int cwch),
|
|
(hinst, idStr, rgwch, cwch),
|
|
0, User32)
|
|
#define LoadStringW VAR_LoadStringW
|
|
|
|
LOADER_FUNCTION( DWORD, FormatMessageW,
|
|
(DWORD dwFlags, LPCVOID pbSource, DWORD dwMessageId,
|
|
DWORD dwLangId, LPWSTR lpBuffer, DWORD nSize, va_list * args),
|
|
(dwFlags, pbSource, dwMessageId, dwLangId, lpBuffer, nSize, args),
|
|
0, User32)
|
|
#define FormatMessageW VAR_FormatMessageW
|
|
|
|
LOADER_FUNCTION( BOOL, WinHelpW,
|
|
(HWND hWndMain, LPCWSTR szHelp, UINT uCommand, ULONG_PTR dwData),
|
|
(hWndMain, szHelp, uCommand, dwData),
|
|
FALSE, User32)
|
|
#define WinHelpW VAR_WinHelpW
|
|
|
|
#endif // !WIN16
|
|
|
|
#else // MAC
|
|
#define SendDlgItemMessageW MySendDlgItemMessageW
|
|
#define SetDlgItemTextW MySetDlgItemTextW
|
|
#define GetDlgItemTextW MyGetDlgItemTextW
|
|
#define LoadStringW MyLoadStringW
|
|
#define FormatMessageW MyFormatMessageW
|
|
#define WinHelpW MyWinHelpW
|
|
#define SendMessageW SendMessageA
|
|
#undef CertOpenStore
|
|
EXTERN_C WINCRYPT32API HCERTSTORE WINAPI MacCertOpenStore(LPCSTR lpszStoreProvider,
|
|
DWORD dwEncodingType,
|
|
HCRYPTPROV hCryptProv,
|
|
DWORD dwFlags,
|
|
const void *pvPara);
|
|
#define CertOpenStore MacCertOpenStore
|
|
#endif // !MAC
|
|
#endif // include once
|