dlls/crypt32/crypt32_private.h

   1 /*
   2  * Copyright 2005 Juan Lang
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #ifndef __CRYPT32_PRIVATE_H__
  20 #define __CRYPT32_PRIVATE_H__
  21
  22 /* a few asn.1 tags we need */
  23 #define ASN_BOOL            (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x01)
  24 #define ASN_BITSTRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x03)
  25 #define ASN_ENUMERATED      (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x0a)
  26 #define ASN_UTF8STRING      (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x0c)
  27 #define ASN_SETOF           (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x11)
  28 #define ASN_NUMERICSTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x12)
  29 #define ASN_PRINTABLESTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x13)
  30 #define ASN_T61STRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x14)
  31 #define ASN_VIDEOTEXSTRING  (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x15)
  32 #define ASN_IA5STRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x16)
  33 #define ASN_UTCTIME         (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x17)
  34 #define ASN_GENERALTIME     (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x18)
  35 #define ASN_GRAPHICSTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x19)
  36 #define ASN_VISIBLESTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1a)
  37 #define ASN_GENERALSTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1b)
  38 #define ASN_UNIVERSALSTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1c)
  39 #define ASN_BMPSTRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1e)
  40
  41 BOOL CRYPT_EncodeLen(DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
  42
  43 typedef BOOL (WINAPI *CryptEncodeObjectExFunc)(DWORD, LPCSTR, const void *,
  44  DWORD, PCRYPT_ENCODE_PARA, BYTE *, DWORD *);
  45
  46 struct AsnEncodeSequenceItem
  47 {
  48     const void             *pvStructInfo;
  49     CryptEncodeObjectExFunc encodeFunc;
  50     DWORD                   size; /* used during encoding, not for your use */
  51 };
  52
  53 BOOL WINAPI CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType,
  54  struct AsnEncodeSequenceItem items[], DWORD cItem, DWORD dwFlags,
  55  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
  56
  57 struct AsnConstructedItem
  58 {
  59     BYTE                    tag;
  60     const void             *pvStructInfo;
  61     CryptEncodeObjectExFunc encodeFunc;
  62 };
  63
  64 BOOL WINAPI CRYPT_AsnEncodeConstructed(DWORD dwCertEncodingType,
  65  LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
  66  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
  67 BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType,
  68  LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
  69  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
  70 BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType,
  71  LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
  72  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
  73
  74 typedef struct _CRYPT_DIGESTED_DATA
  75 {
  76     DWORD                      version;
  77     CRYPT_ALGORITHM_IDENTIFIER DigestAlgorithm;
  78     CRYPT_CONTENT_INFO         ContentInfo;
  79     CRYPT_HASH_BLOB            hash;
  80 } CRYPT_DIGESTED_DATA;
  81
  82 BOOL CRYPT_AsnEncodePKCSDigestedData(const CRYPT_DIGESTED_DATA *digestedData,
  83  void *pvData, DWORD *pcbData) DECLSPEC_HIDDEN;
  84
  85 typedef struct _CRYPT_ENCRYPTED_CONTENT_INFO
  86 {
  87     LPSTR                      contentType;
  88     CRYPT_ALGORITHM_IDENTIFIER contentEncryptionAlgorithm;
  89     CRYPT_DATA_BLOB            encryptedContent;
  90 } CRYPT_ENCRYPTED_CONTENT_INFO;
  91
  92 typedef struct _CRYPT_ENVELOPED_DATA
  93 {
  94     DWORD                          version;
  95     DWORD                          cRecipientInfo;
  96     PCMSG_KEY_TRANS_RECIPIENT_INFO rgRecipientInfo;
  97     CRYPT_ENCRYPTED_CONTENT_INFO   encryptedContentInfo;
  98 } CRYPT_ENVELOPED_DATA;
  99
 100 BOOL CRYPT_AsnEncodePKCSEnvelopedData(const CRYPT_ENVELOPED_DATA *envelopedData,
 101  void *pvData, DWORD *pcbData) DECLSPEC_HIDDEN;
 102
 103 BOOL CRYPT_AsnDecodePKCSEnvelopedData(const BYTE *pbEncoded, DWORD cbEncoded,
 104  DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara,
 105  CRYPT_ENVELOPED_DATA *envelopedData, DWORD *pcbEnvelopedData) DECLSPEC_HIDDEN;
 106
 107 typedef struct _CRYPT_SIGNED_INFO
 108 {
 109     DWORD                 version;
 110     DWORD                 cCertEncoded;
 111     PCERT_BLOB            rgCertEncoded;
 112     DWORD                 cCrlEncoded;
 113     PCRL_BLOB             rgCrlEncoded;
 114     CRYPT_CONTENT_INFO    content;
 115     DWORD                 cSignerInfo;
 116     PCMSG_CMS_SIGNER_INFO rgSignerInfo;
 117 } CRYPT_SIGNED_INFO;
 118
 119 BOOL CRYPT_AsnEncodeCMSSignedInfo(CRYPT_SIGNED_INFO *, void *pvData,
 120  DWORD *pcbData) DECLSPEC_HIDDEN;
 121
 122 BOOL CRYPT_AsnDecodeCMSSignedInfo(const BYTE *pbEncoded, DWORD cbEncoded,
 123  DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara,
 124  CRYPT_SIGNED_INFO *signedInfo, DWORD *pcbSignedInfo) DECLSPEC_HIDDEN;
 125
 126 /* Helper function to check *pcbEncoded, set it to the required size, and
 127  * optionally to allocate memory.  Assumes pbEncoded is not NULL.
 128  * If CRYPT_ENCODE_ALLOC_FLAG is set in dwFlags, *pbEncoded will be set to a
 129  * pointer to the newly allocated memory.
 130  */
 131 BOOL CRYPT_EncodeEnsureSpace(DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara,
 132  BYTE *pbEncoded, DWORD *pcbEncoded, DWORD bytesNeeded) DECLSPEC_HIDDEN;
 133
 134 BOOL CRYPT_AsnDecodePKCSDigestedData(const BYTE *pbEncoded, DWORD cbEncoded,
 135  DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara,
 136  CRYPT_DIGESTED_DATA *digestedData, DWORD *pcbDigestedData) DECLSPEC_HIDDEN;
 137
 138 BOOL WINAPI CRYPT_AsnEncodePubKeyInfoNoNull(DWORD dwCertEncodingType,
 139  LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
 140  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
 141
 142 /* The following aren't defined in wincrypt.h, as they're "reserved" */
 143 #define CERT_CERT_PROP_ID 32
 144 #define CERT_CRL_PROP_ID  33
 145 #define CERT_CTL_PROP_ID  34
 146
 147 /* Returns a handle to the default crypto provider; loads it if necessary.
 148  * Returns NULL on failure.
 149  */
 150 HCRYPTPROV CRYPT_GetDefaultProvider(void) DECLSPEC_HIDDEN;
 151
 152 HINSTANCE hInstance DECLSPEC_HIDDEN;
 153
 154 void crypt_oid_init(void) DECLSPEC_HIDDEN;
 155 void crypt_oid_free(void) DECLSPEC_HIDDEN;
 156 void crypt_sip_free(void) DECLSPEC_HIDDEN;
 157 void root_store_free(void) DECLSPEC_HIDDEN;
 158 void default_chain_engine_free(void) DECLSPEC_HIDDEN;
 159
 160 /* Some typedefs that make it easier to abstract which type of context we're
 161  * working with.
 162  */
 163 typedef const void *(WINAPI *CreateContextFunc)(DWORD dwCertEncodingType,
 164  const BYTE *pbCertEncoded, DWORD cbCertEncoded);
 165 typedef BOOL (WINAPI *AddContextToStoreFunc)(HCERTSTORE hCertStore,
 166  const void *context, DWORD dwAddDisposition, const void **ppStoreContext);
 167 typedef BOOL (WINAPI *AddEncodedContextToStoreFunc)(HCERTSTORE hCertStore,
 168  DWORD dwCertEncodingType, const BYTE *pbEncoded, DWORD cbEncoded,
 169  DWORD dwAddDisposition, const void **ppContext);
 170 typedef const void *(WINAPI *DuplicateContextFunc)(const void *context);
 171 typedef const void *(WINAPI *EnumContextsInStoreFunc)(HCERTSTORE hCertStore,
 172  const void *pPrevContext);
 173 typedef DWORD (WINAPI *EnumPropertiesFunc)(const void *context, DWORD dwPropId);
 174 typedef BOOL (WINAPI *GetContextPropertyFunc)(const void *context,
 175  DWORD dwPropID, void *pvData, DWORD *pcbData);
 176 typedef BOOL (WINAPI *SetContextPropertyFunc)(const void *context,
 177  DWORD dwPropID, DWORD dwFlags, const void *pvData);
 178 typedef BOOL (WINAPI *SerializeElementFunc)(const void *context, DWORD dwFlags,
 179  BYTE *pbElement, DWORD *pcbElement);
 180 typedef BOOL (WINAPI *FreeContextFunc)(const void *context);
 181 typedef BOOL (WINAPI *DeleteContextFunc)(const void *contex);
 182
 183 /* An abstract context (certificate, CRL, or CTL) interface */
 184 typedef struct _WINE_CONTEXT_INTERFACE
 185 {
 186     CreateContextFunc            create;
 187     AddContextToStoreFunc        addContextToStore;
 188     AddEncodedContextToStoreFunc addEncodedToStore;
 189     DuplicateContextFunc         duplicate;
 190     EnumContextsInStoreFunc      enumContextsInStore;
 191     EnumPropertiesFunc           enumProps;
 192     GetContextPropertyFunc       getProp;
 193     SetContextPropertyFunc       setProp;
 194     SerializeElementFunc         serialize;
 195     FreeContextFunc              free;
 196     DeleteContextFunc            deleteFromStore;
 197 } WINE_CONTEXT_INTERFACE;
 198
 199 extern const WINE_CONTEXT_INTERFACE *pCertInterface DECLSPEC_HIDDEN;
 200 extern const WINE_CONTEXT_INTERFACE *pCRLInterface DECLSPEC_HIDDEN;
 201 extern const WINE_CONTEXT_INTERFACE *pCTLInterface DECLSPEC_HIDDEN;
 202
 203 /* (Internal) certificate store types and functions */
 204 struct WINE_CRYPTCERTSTORE;
 205
 206 typedef struct WINE_CRYPTCERTSTORE * (*StoreOpenFunc)(HCRYPTPROV hCryptProv,
 207  DWORD dwFlags, const void *pvPara);
 208
 209 /* Called to enumerate the next context in a store. */
 210 typedef void * (*EnumFunc)(struct WINE_CRYPTCERTSTORE *store, void *pPrev);
 211
 212 /* Called to add a context to a store.  If toReplace is not NULL,
 213  * context replaces toReplace in the store, and access checks should not be
 214  * performed.  Otherwise context is a new context, and it should only be
 215  * added if the store allows it.  If ppStoreContext is not NULL, the added
 216  * context should be returned in *ppStoreContext.
 217  */
 218 typedef BOOL (*AddFunc)(struct WINE_CRYPTCERTSTORE *store, void *context,
 219  void *toReplace, const void **ppStoreContext);
 220
 221 typedef BOOL (*DeleteFunc)(struct WINE_CRYPTCERTSTORE *store, void *context);
 222
 223 typedef struct _CONTEXT_FUNCS
 224 {
 225     AddFunc    addContext;
 226     EnumFunc   enumContext;
 227     DeleteFunc deleteContext;
 228 } CONTEXT_FUNCS;
 229
 230 typedef enum _CertStoreType {
 231     StoreTypeMem,
 232     StoreTypeCollection,
 233     StoreTypeProvider,
 234 } CertStoreType;
 235
 236 typedef struct _CONTEXT_PROPERTY_LIST CONTEXT_PROPERTY_LIST;
 237
 238 #define WINE_CRYPTCERTSTORE_MAGIC 0x74726563
 239
 240 /* A cert store is polymorphic through the use of function pointers.  A type
 241  * is still needed to distinguish collection stores from other types.
 242  * On the function pointers:
 243  * - closeStore is called when the store's ref count becomes 0
 244  * - control is optional, but should be implemented by any store that supports
 245  *   persistence
 246  */
 247 typedef struct WINE_CRYPTCERTSTORE
 248 {
 249     DWORD                       dwMagic;
 250     LONG                        ref;
 251     DWORD                       dwOpenFlags;
 252     CertStoreType               type;
 253     PFN_CERT_STORE_PROV_CLOSE   closeStore;
 254     CONTEXT_FUNCS               certs;
 255     CONTEXT_FUNCS               crls;
 256     CONTEXT_FUNCS               ctls;
 257     PFN_CERT_STORE_PROV_CONTROL control; /* optional */
 258     CONTEXT_PROPERTY_LIST      *properties;
 259 } WINECRYPT_CERTSTORE;
 260
 261 void CRYPT_InitStore(WINECRYPT_CERTSTORE *store, DWORD dwFlags,
 262  CertStoreType type) DECLSPEC_HIDDEN;
 263 void CRYPT_FreeStore(WINECRYPT_CERTSTORE *store) DECLSPEC_HIDDEN;
 264 BOOL WINAPI I_CertUpdateStore(HCERTSTORE store1, HCERTSTORE store2, DWORD unk0,
 265  DWORD unk1) DECLSPEC_HIDDEN;
 266
 267 WINECRYPT_CERTSTORE *CRYPT_CollectionOpenStore(HCRYPTPROV hCryptProv,
 268  DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN;
 269 WINECRYPT_CERTSTORE *CRYPT_ProvCreateStore(DWORD dwFlags,
 270  WINECRYPT_CERTSTORE *memStore, const CERT_STORE_PROV_INFO *pProvInfo) DECLSPEC_HIDDEN;
 271 WINECRYPT_CERTSTORE *CRYPT_ProvOpenStore(LPCSTR lpszStoreProvider,
 272  DWORD dwEncodingType, HCRYPTPROV hCryptProv, DWORD dwFlags,
 273  const void *pvPara) DECLSPEC_HIDDEN;
 274 WINECRYPT_CERTSTORE *CRYPT_RegOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags,
 275  const void *pvPara) DECLSPEC_HIDDEN;
 276 WINECRYPT_CERTSTORE *CRYPT_FileOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags,
 277  const void *pvPara) DECLSPEC_HIDDEN;
 278 WINECRYPT_CERTSTORE *CRYPT_FileNameOpenStoreA(HCRYPTPROV hCryptProv,
 279  DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN;
 280 WINECRYPT_CERTSTORE *CRYPT_FileNameOpenStoreW(HCRYPTPROV hCryptProv,
 281  DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN;
 282 WINECRYPT_CERTSTORE *CRYPT_RootOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags) DECLSPEC_HIDDEN;
 283
 284 /* Allocates and initializes a certificate chain engine, but without creating
 285  * the root store.  Instead, it uses root, and assumes the caller has done any
 286  * checking necessary.
 287  */
 288 HCERTCHAINENGINE CRYPT_CreateChainEngine(HCERTSTORE root,
 289  PCERT_CHAIN_ENGINE_CONFIG pConfig) DECLSPEC_HIDDEN;
 290
 291 /* Helper function for store reading functions and
 292  * CertAddSerializedElementToStore.  Returns a context of the appropriate type
 293  * if it can, or NULL otherwise.  Doesn't validate any of the properties in
 294  * the serialized context (for example, bad hashes are retained.)
 295  * *pdwContentType is set to the type of the returned context.
 296  */
 297 const void *CRYPT_ReadSerializedElement(const BYTE *pbElement,
 298  DWORD cbElement, DWORD dwContextTypeFlags, DWORD *pdwContentType) DECLSPEC_HIDDEN;
 299
 300 /* Reads contexts serialized in the file into the memory store.  Returns FALSE
 301  * if the file is not of the expected format.
 302  */
 303 BOOL CRYPT_ReadSerializedStoreFromFile(HANDLE file, HCERTSTORE store) DECLSPEC_HIDDEN;
 304
 305 /* Reads contexts serialized in the blob into the memory store.  Returns FALSE
 306  * if the file is not of the expected format.
 307  */
 308 BOOL CRYPT_ReadSerializedStoreFromBlob(const CRYPT_DATA_BLOB *blob,
 309  HCERTSTORE store) DECLSPEC_HIDDEN;
 310
 311 /* Fixes up the pointers in info, where info is assumed to be a
 312  * CRYPT_KEY_PROV_INFO, followed by its container name, provider name, and any
 313  * provider parameters, in a contiguous buffer, but where info's pointers are
 314  * assumed to be invalid.  Upon return, info's pointers point to the
 315  * appropriate memory locations.
 316  */
 317 void CRYPT_FixKeyProvInfoPointers(PCRYPT_KEY_PROV_INFO info) DECLSPEC_HIDDEN;
 318
 319 /**
 320  *  String functions
 321  */
 322
 323 DWORD cert_name_to_str_with_indent(DWORD dwCertEncodingType, DWORD indent,
 324  const CERT_NAME_BLOB *pName, DWORD dwStrType, LPWSTR psz, DWORD csz) DECLSPEC_HIDDEN;
 325
 326 /**
 327  *  Context functions
 328  */
 329
 330 /* Allocates a new data context, a context which owns properties directly.
 331  * contextSize is the size of the public data type associated with context,
 332  * which should be one of CERT_CONTEXT, CRL_CONTEXT, or CTL_CONTEXT.
 333  * Free with Context_Release.
 334  */
 335 void *Context_CreateDataContext(size_t contextSize) DECLSPEC_HIDDEN;
 336
 337 /* Creates a new link context with extra bytes.  The context refers to linked
 338  * rather than owning its own properties.  If addRef is TRUE (which ordinarily
 339  * it should be) linked is addref'd.
 340  * Free with Context_Release.
 341  */
 342 void *Context_CreateLinkContext(unsigned int contextSize, void *linked, unsigned int extra,
 343  BOOL addRef) DECLSPEC_HIDDEN;
 344
 345 /* Returns a pointer to the extra bytes allocated with context, which must be
 346  * a link context.
 347  */
 348 void *Context_GetExtra(const void *context, size_t contextSize) DECLSPEC_HIDDEN;
 349
 350 /* Gets the context linked to by context, which must be a link context. */
 351 void *Context_GetLinkedContext(void *context) DECLSPEC_HIDDEN;
 352
 353 /* Copies properties from fromContext to toContext. */
 354 void Context_CopyProperties(const void *to, const void *from) DECLSPEC_HIDDEN;
 355
 356 /* Returns context's properties, or the linked context's properties if context
 357  * is a link context.
 358  */
 359 CONTEXT_PROPERTY_LIST *Context_GetProperties(const void *context) DECLSPEC_HIDDEN;
 360
 361 void Context_AddRef(void *context) DECLSPEC_HIDDEN;
 362
 363 typedef void (*ContextFreeFunc)(void *context);
 364
 365 /* Decrements context's ref count.  If context is a link context, releases its
 366  * linked context as well.
 367  * If a data context has its ref count reach 0, calls dataContextFree on it.
 368  * Returns FALSE if the reference count is <= 0 when called.
 369  */
 370 BOOL Context_Release(void *context, ContextFreeFunc dataContextFree) DECLSPEC_HIDDEN;
 371
 372 /**
 373  *  Context property list functions
 374  */
 375
 376 CONTEXT_PROPERTY_LIST *ContextPropertyList_Create(void) DECLSPEC_HIDDEN;
 377
 378 /* Searches for the property with ID id in the context.  Returns TRUE if found,
 379  * and copies the property's length and a pointer to its data to blob.
 380  * Otherwise returns FALSE.
 381  */
 382 BOOL ContextPropertyList_FindProperty(CONTEXT_PROPERTY_LIST *list, DWORD id,
 383  PCRYPT_DATA_BLOB blob) DECLSPEC_HIDDEN;
 384
 385 BOOL ContextPropertyList_SetProperty(CONTEXT_PROPERTY_LIST *list, DWORD id,
 386  const BYTE *pbData, size_t cbData) DECLSPEC_HIDDEN;
 387
 388 void ContextPropertyList_RemoveProperty(CONTEXT_PROPERTY_LIST *list, DWORD id) DECLSPEC_HIDDEN;
 389
 390 DWORD ContextPropertyList_EnumPropIDs(CONTEXT_PROPERTY_LIST *list, DWORD id) DECLSPEC_HIDDEN;
 391
 392 void ContextPropertyList_Copy(CONTEXT_PROPERTY_LIST *to,
 393  CONTEXT_PROPERTY_LIST *from) DECLSPEC_HIDDEN;
 394
 395 void ContextPropertyList_Free(CONTEXT_PROPERTY_LIST *list) DECLSPEC_HIDDEN;
 396
 397 /**
 398  *  Context list functions.  A context list is a simple list of link contexts.
 399  */
 400 struct ContextList;
 401
 402 struct ContextList *ContextList_Create(
 403  const WINE_CONTEXT_INTERFACE *contextInterface, size_t contextSize) DECLSPEC_HIDDEN;
 404
 405 void *ContextList_Add(struct ContextList *list, void *toLink, void *toReplace) DECLSPEC_HIDDEN;
 406
 407 void *ContextList_Enum(struct ContextList *list, void *pPrev) DECLSPEC_HIDDEN;
 408
 409 /* Removes a context from the list.  Returns TRUE if the context was removed,
 410  * or FALSE if not.  (The context may have been duplicated, so subsequent
 411  * removes have no effect.)
 412  */
 413 BOOL ContextList_Remove(struct ContextList *list, void *context) DECLSPEC_HIDDEN;
 414
 415 void ContextList_Free(struct ContextList *list) DECLSPEC_HIDDEN;
 416
 417 /**
 418  *  Utilities.
 419  */
 420
 421 /* Align up to a DWORD_PTR boundary
 422  */
 423 #define ALIGN_DWORD_PTR(x) (((x) + sizeof(DWORD_PTR) - 1) & ~(sizeof(DWORD_PTR) - 1))
 424 #define POINTER_ALIGN_DWORD_PTR(p) ((LPVOID)ALIGN_DWORD_PTR((DWORD_PTR)(p)))
 425
 426 /* Check if the OID is a small int
 427  */
 428 #define IS_INTOID(x)    (((ULONG_PTR)(x) >> 16) == 0)
 429
 430 #endif