1 | /*
|
---|
2 | * Copyright 2004-2007 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 | #include <stdarg.h>
|
---|
19 | #include "windef.h"
|
---|
20 | #include "winbase.h"
|
---|
21 | #include "winbase.h"
|
---|
22 | #include "winerror.h"
|
---|
23 | #include "wincrypt.h"
|
---|
24 | #include "wine/debug.h"
|
---|
25 | #include "wine/list.h"
|
---|
26 | #include "crypt32_private.h"
|
---|
27 | #include "winnt.h"
|
---|
28 |
|
---|
29 | ODINDEBUGCHANNEL(crypt);
|
---|
30 |
|
---|
31 |
|
---|
32 | typedef struct _WINE_STORE_LIST_ENTRY
|
---|
33 | {
|
---|
34 | PWINECRYPT_CERTSTORE store;
|
---|
35 | DWORD dwUpdateFlags;
|
---|
36 | DWORD dwPriority;
|
---|
37 | struct list entry;
|
---|
38 | } WINE_STORE_LIST_ENTRY, *PWINE_STORE_LIST_ENTRY;
|
---|
39 |
|
---|
40 | typedef struct _WINE_COLLECTIONSTORE
|
---|
41 | {
|
---|
42 | WINECRYPT_CERTSTORE hdr;
|
---|
43 | /*CRITICAL_SECTION*/RTL_CRITICAL_SECTION cs;
|
---|
44 | struct list stores;
|
---|
45 | } WINE_COLLECTIONSTORE, *PWINE_COLLECTIONSTORE;
|
---|
46 |
|
---|
47 | static void WINAPI CRYPT_CollectionCloseStore(HCERTSTORE store, DWORD dwFlags)
|
---|
48 | {
|
---|
49 | PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
|
---|
50 | PWINE_STORE_LIST_ENTRY entry, next;
|
---|
51 |
|
---|
52 | TRACE("(%p, %08x)\n", store, dwFlags);
|
---|
53 |
|
---|
54 | LIST_FOR_EACH_ENTRY_SAFE(entry, next, &cs->stores, WINE_STORE_LIST_ENTRY,
|
---|
55 | entry)
|
---|
56 | {
|
---|
57 | TRACE("closing %p\n", entry);
|
---|
58 | CertCloseStore((HCERTSTORE)entry->store, dwFlags);
|
---|
59 | CryptMemFree(entry);
|
---|
60 | }
|
---|
61 | cs->cs.DebugInfo->Spare[0] = 0;
|
---|
62 | DeleteCriticalSection(&cs->cs);
|
---|
63 | CRYPT_FreeStore((PWINECRYPT_CERTSTORE)store);
|
---|
64 | }
|
---|
65 |
|
---|
66 | static void *CRYPT_CollectionCreateContextFromChild(PWINE_COLLECTIONSTORE store,
|
---|
67 | PWINE_STORE_LIST_ENTRY storeEntry, void *child, size_t contextSize,
|
---|
68 | BOOL addRef)
|
---|
69 | {
|
---|
70 | void *ret = Context_CreateLinkContext(contextSize, child,
|
---|
71 | sizeof(PWINE_STORE_LIST_ENTRY), addRef);
|
---|
72 |
|
---|
73 | if (ret)
|
---|
74 | *(PWINE_STORE_LIST_ENTRY *)Context_GetExtra(ret, contextSize)
|
---|
75 | = storeEntry;
|
---|
76 |
|
---|
77 | return ret;
|
---|
78 | }
|
---|
79 |
|
---|
80 | static BOOL CRYPT_CollectionAddContext(PWINE_COLLECTIONSTORE store,
|
---|
81 | unsigned int contextFuncsOffset, void *context, void *toReplace, unsigned int contextSize,
|
---|
82 | void **pChildContext)
|
---|
83 | {
|
---|
84 | BOOL ret;
|
---|
85 | void *childContext = NULL;
|
---|
86 | PWINE_STORE_LIST_ENTRY storeEntry = NULL;
|
---|
87 |
|
---|
88 | TRACE("(%p, %d, %p, %p, %d)\n", store, contextFuncsOffset, context,
|
---|
89 | toReplace, contextSize);
|
---|
90 |
|
---|
91 | ret = FALSE;
|
---|
92 | if (toReplace)
|
---|
93 | {
|
---|
94 | void *existingLinked = Context_GetLinkedContext(toReplace, contextSize);
|
---|
95 | PCONTEXT_FUNCS contextFuncs;
|
---|
96 |
|
---|
97 | storeEntry = *(PWINE_STORE_LIST_ENTRY *)Context_GetExtra(toReplace,
|
---|
98 | contextSize);
|
---|
99 | contextFuncs = (PCONTEXT_FUNCS)((LPBYTE)storeEntry->store +
|
---|
100 | contextFuncsOffset);
|
---|
101 | ret = contextFuncs->addContext(storeEntry->store, context,
|
---|
102 | existingLinked, childContext);
|
---|
103 | }
|
---|
104 | else
|
---|
105 | {
|
---|
106 | PWINE_STORE_LIST_ENTRY entry, next;
|
---|
107 |
|
---|
108 | EnterCriticalSection(&store->cs);
|
---|
109 | LIST_FOR_EACH_ENTRY_SAFE(entry, next, &store->stores,
|
---|
110 | WINE_STORE_LIST_ENTRY, entry)
|
---|
111 | {
|
---|
112 | if (entry->dwUpdateFlags & CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG)
|
---|
113 | {
|
---|
114 | PCONTEXT_FUNCS contextFuncs = (PCONTEXT_FUNCS)(
|
---|
115 | (LPBYTE)entry->store + contextFuncsOffset);
|
---|
116 |
|
---|
117 | storeEntry = entry;
|
---|
118 | ret = contextFuncs->addContext(entry->store, context, NULL,
|
---|
119 | (const void **)&childContext);
|
---|
120 | break;
|
---|
121 | }
|
---|
122 | }
|
---|
123 | LeaveCriticalSection(&store->cs);
|
---|
124 | if (!storeEntry)
|
---|
125 | SetLastError(E_ACCESSDENIED);
|
---|
126 | }
|
---|
127 | *pChildContext = childContext;
|
---|
128 | return ret;
|
---|
129 | }
|
---|
130 |
|
---|
131 | /* Advances a collection enumeration by one context, if possible, where
|
---|
132 | * advancing means:
|
---|
133 | * - calling the current store's enumeration function once, and returning
|
---|
134 | * the enumerated context if one is returned
|
---|
135 | * - moving to the next store if the current store has no more items, and
|
---|
136 | * recursively calling itself to get the next item.
|
---|
137 | * Returns NULL if the collection contains no more items or on error.
|
---|
138 | * Assumes the collection store's lock is held.
|
---|
139 | */
|
---|
140 | static void *CRYPT_CollectionAdvanceEnum(PWINE_COLLECTIONSTORE store,
|
---|
141 | PWINE_STORE_LIST_ENTRY storeEntry, PCONTEXT_FUNCS contextFuncs,
|
---|
142 | PCWINE_CONTEXT_INTERFACE contextInterface, void *pPrev, size_t contextSize)
|
---|
143 | {
|
---|
144 | void *ret, *child;
|
---|
145 | struct list *storeNext = list_next(&store->stores, &storeEntry->entry);
|
---|
146 |
|
---|
147 | TRACE("(%p, %p, %p)\n", store, storeEntry, pPrev);
|
---|
148 |
|
---|
149 | if (pPrev)
|
---|
150 | {
|
---|
151 | /* Ref-counting funny business: "duplicate" (addref) the child, because
|
---|
152 | * the free(pPrev) below can cause the ref count to become negative.
|
---|
153 | */
|
---|
154 | child = Context_GetLinkedContext(pPrev, contextSize);
|
---|
155 | contextInterface->duplicate(child);
|
---|
156 | child = contextFuncs->enumContext(storeEntry->store, child);
|
---|
157 | contextInterface->confree(pPrev);
|
---|
158 | pPrev = NULL;
|
---|
159 | }
|
---|
160 | else
|
---|
161 | child = contextFuncs->enumContext(storeEntry->store, NULL);
|
---|
162 | if (child)
|
---|
163 | ret = CRYPT_CollectionCreateContextFromChild(store, storeEntry, child,
|
---|
164 | contextSize, FALSE);
|
---|
165 | else
|
---|
166 | {
|
---|
167 | if (storeNext)
|
---|
168 | {
|
---|
169 | /* We always want the same function pointers (from certs, crls)
|
---|
170 | * in the next store, so use the same offset into the next store.
|
---|
171 | */
|
---|
172 | size_t offset = (LPBYTE)contextFuncs - (LPBYTE)storeEntry->store;
|
---|
173 | PWINE_STORE_LIST_ENTRY storeNextEntry =
|
---|
174 | LIST_ENTRY(storeNext, WINE_STORE_LIST_ENTRY, entry);
|
---|
175 | PCONTEXT_FUNCS storeNextContexts =
|
---|
176 | (PCONTEXT_FUNCS)((LPBYTE)storeNextEntry->store + offset);
|
---|
177 |
|
---|
178 | ret = CRYPT_CollectionAdvanceEnum(store, storeNextEntry,
|
---|
179 | storeNextContexts, contextInterface, NULL, contextSize);
|
---|
180 | }
|
---|
181 | else
|
---|
182 | {
|
---|
183 | SetLastError(CRYPT_E_NOT_FOUND);
|
---|
184 | ret = NULL;
|
---|
185 | }
|
---|
186 | }
|
---|
187 | TRACE("returning %p\n", ret);
|
---|
188 | return ret;
|
---|
189 | }
|
---|
190 |
|
---|
191 | static BOOL CRYPT_CollectionAddCert(PWINECRYPT_CERTSTORE store, void *cert,
|
---|
192 | void *toReplace, const void **ppStoreContext)
|
---|
193 | {
|
---|
194 | BOOL ret;
|
---|
195 | void *childContext = NULL;
|
---|
196 | PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
|
---|
197 |
|
---|
198 | ret = CRYPT_CollectionAddContext(cs, offsetof(WINECRYPT_CERTSTORE, certs),
|
---|
199 | cert, toReplace, sizeof(CERT_CONTEXT), &childContext);
|
---|
200 | if (ppStoreContext && childContext)
|
---|
201 | {
|
---|
202 | PWINE_STORE_LIST_ENTRY storeEntry = *(PWINE_STORE_LIST_ENTRY *)
|
---|
203 | Context_GetExtra(childContext, sizeof(CERT_CONTEXT));
|
---|
204 | PCERT_CONTEXT context =
|
---|
205 | CRYPT_CollectionCreateContextFromChild(cs, storeEntry, childContext,
|
---|
206 | sizeof(CERT_CONTEXT), TRUE);
|
---|
207 |
|
---|
208 | if (context)
|
---|
209 | context->hCertStore = store;
|
---|
210 | *ppStoreContext = context;
|
---|
211 | }
|
---|
212 | CertFreeCertificateContext((PCCERT_CONTEXT)childContext);
|
---|
213 | return ret;
|
---|
214 | }
|
---|
215 |
|
---|
216 | static void *CRYPT_CollectionEnumCert(PWINECRYPT_CERTSTORE store, void *pPrev)
|
---|
217 | {
|
---|
218 | PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
|
---|
219 | void *ret;
|
---|
220 |
|
---|
221 | TRACE("(%p, %p)\n", store, pPrev);
|
---|
222 |
|
---|
223 | EnterCriticalSection(&cs->cs);
|
---|
224 | if (pPrev)
|
---|
225 | {
|
---|
226 | PWINE_STORE_LIST_ENTRY storeEntry =
|
---|
227 | *(PWINE_STORE_LIST_ENTRY *)Context_GetExtra(pPrev,
|
---|
228 | sizeof(CERT_CONTEXT));
|
---|
229 |
|
---|
230 | ret = CRYPT_CollectionAdvanceEnum(cs, storeEntry,
|
---|
231 | &storeEntry->store->certs, pCertInterface, pPrev,
|
---|
232 | sizeof(CERT_CONTEXT));
|
---|
233 | }
|
---|
234 | else
|
---|
235 | {
|
---|
236 | if (!list_empty(&cs->stores))
|
---|
237 | {
|
---|
238 | PWINE_STORE_LIST_ENTRY storeEntry = LIST_ENTRY(cs->stores.next,
|
---|
239 | WINE_STORE_LIST_ENTRY, entry);
|
---|
240 |
|
---|
241 | ret = CRYPT_CollectionAdvanceEnum(cs, storeEntry,
|
---|
242 | &storeEntry->store->certs, pCertInterface, NULL,
|
---|
243 | sizeof(CERT_CONTEXT));
|
---|
244 | }
|
---|
245 | else
|
---|
246 | {
|
---|
247 | SetLastError(CRYPT_E_NOT_FOUND);
|
---|
248 | ret = NULL;
|
---|
249 | }
|
---|
250 | }
|
---|
251 | LeaveCriticalSection(&cs->cs);
|
---|
252 | if (ret)
|
---|
253 | ((PCERT_CONTEXT)ret)->hCertStore = store;
|
---|
254 | TRACE("returning %p\n", ret);
|
---|
255 | return ret;
|
---|
256 | }
|
---|
257 |
|
---|
258 | static BOOL CRYPT_CollectionDeleteCert(PWINECRYPT_CERTSTORE store,
|
---|
259 | void *pCertContext)
|
---|
260 | {
|
---|
261 | BOOL ret;
|
---|
262 |
|
---|
263 | TRACE("(%p, %p)\n", store, pCertContext);
|
---|
264 |
|
---|
265 | ret = CertDeleteCertificateFromStore((PCCERT_CONTEXT)
|
---|
266 | Context_GetLinkedContext(pCertContext, sizeof(CERT_CONTEXT)));
|
---|
267 | return ret;
|
---|
268 | }
|
---|
269 |
|
---|
270 | static BOOL CRYPT_CollectionAddCRL(PWINECRYPT_CERTSTORE store, void *crl,
|
---|
271 | void *toReplace, const void **ppStoreContext)
|
---|
272 | {
|
---|
273 | BOOL ret;
|
---|
274 | void *childContext = NULL;
|
---|
275 | PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
|
---|
276 |
|
---|
277 | ret = CRYPT_CollectionAddContext(cs, offsetof(WINECRYPT_CERTSTORE, crls),
|
---|
278 | crl, toReplace, sizeof(CRL_CONTEXT), &childContext);
|
---|
279 | if (ppStoreContext && childContext)
|
---|
280 | {
|
---|
281 | PWINE_STORE_LIST_ENTRY storeEntry = *(PWINE_STORE_LIST_ENTRY *)
|
---|
282 | Context_GetExtra(childContext, sizeof(CRL_CONTEXT));
|
---|
283 | PCRL_CONTEXT context =
|
---|
284 | CRYPT_CollectionCreateContextFromChild(cs, storeEntry, childContext,
|
---|
285 | sizeof(CRL_CONTEXT), TRUE);
|
---|
286 |
|
---|
287 | if (context)
|
---|
288 | context->hCertStore = store;
|
---|
289 | *ppStoreContext = context;
|
---|
290 | }
|
---|
291 | CertFreeCRLContext((PCCRL_CONTEXT)childContext);
|
---|
292 | return ret;
|
---|
293 | }
|
---|
294 |
|
---|
295 | static void *CRYPT_CollectionEnumCRL(PWINECRYPT_CERTSTORE store, void *pPrev)
|
---|
296 | {
|
---|
297 | PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
|
---|
298 | void *ret;
|
---|
299 |
|
---|
300 | TRACE("(%p, %p)\n", store, pPrev);
|
---|
301 |
|
---|
302 | EnterCriticalSection(&cs->cs);
|
---|
303 | if (pPrev)
|
---|
304 | {
|
---|
305 | PWINE_STORE_LIST_ENTRY storeEntry =
|
---|
306 | *(PWINE_STORE_LIST_ENTRY *)Context_GetExtra(pPrev,
|
---|
307 | sizeof(CRL_CONTEXT));
|
---|
308 |
|
---|
309 | ret = CRYPT_CollectionAdvanceEnum(cs, storeEntry,
|
---|
310 | &storeEntry->store->crls, pCRLInterface, pPrev, sizeof(CRL_CONTEXT));
|
---|
311 | }
|
---|
312 | else
|
---|
313 | {
|
---|
314 | if (!list_empty(&cs->stores))
|
---|
315 | {
|
---|
316 | PWINE_STORE_LIST_ENTRY storeEntry = LIST_ENTRY(cs->stores.next,
|
---|
317 | WINE_STORE_LIST_ENTRY, entry);
|
---|
318 |
|
---|
319 | ret = CRYPT_CollectionAdvanceEnum(cs, storeEntry,
|
---|
320 | &storeEntry->store->crls, pCRLInterface, NULL,
|
---|
321 | sizeof(CRL_CONTEXT));
|
---|
322 | }
|
---|
323 | else
|
---|
324 | {
|
---|
325 | SetLastError(CRYPT_E_NOT_FOUND);
|
---|
326 | ret = NULL;
|
---|
327 | }
|
---|
328 | }
|
---|
329 | LeaveCriticalSection(&cs->cs);
|
---|
330 | if (ret)
|
---|
331 | ((PCRL_CONTEXT)ret)->hCertStore = store;
|
---|
332 | TRACE("returning %p\n", ret);
|
---|
333 | return ret;
|
---|
334 | }
|
---|
335 |
|
---|
336 | static BOOL CRYPT_CollectionDeleteCRL(PWINECRYPT_CERTSTORE store,
|
---|
337 | void *pCrlContext)
|
---|
338 | {
|
---|
339 | BOOL ret;
|
---|
340 |
|
---|
341 | TRACE("(%p, %p)\n", store, pCrlContext);
|
---|
342 |
|
---|
343 | ret = CertDeleteCRLFromStore((PCCRL_CONTEXT)
|
---|
344 | Context_GetLinkedContext(pCrlContext, sizeof(CRL_CONTEXT)));
|
---|
345 | return ret;
|
---|
346 | }
|
---|
347 |
|
---|
348 | static BOOL CRYPT_CollectionAddCTL(PWINECRYPT_CERTSTORE store, void *ctl,
|
---|
349 | void *toReplace, const void **ppStoreContext)
|
---|
350 | {
|
---|
351 | BOOL ret;
|
---|
352 | void *childContext = NULL;
|
---|
353 | PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
|
---|
354 |
|
---|
355 | ret = CRYPT_CollectionAddContext(cs, offsetof(WINECRYPT_CERTSTORE, ctls),
|
---|
356 | ctl, toReplace, sizeof(CTL_CONTEXT), &childContext);
|
---|
357 | if (ppStoreContext && childContext)
|
---|
358 | {
|
---|
359 | PWINE_STORE_LIST_ENTRY storeEntry = *(PWINE_STORE_LIST_ENTRY *)
|
---|
360 | Context_GetExtra(childContext, sizeof(CTL_CONTEXT));
|
---|
361 | PCTL_CONTEXT context =
|
---|
362 | CRYPT_CollectionCreateContextFromChild(cs, storeEntry, childContext,
|
---|
363 | sizeof(CTL_CONTEXT), TRUE);
|
---|
364 |
|
---|
365 | if (context)
|
---|
366 | context->hCertStore = store;
|
---|
367 | *ppStoreContext = context;
|
---|
368 | }
|
---|
369 | CertFreeCTLContext((PCCTL_CONTEXT)childContext);
|
---|
370 | return ret;
|
---|
371 | }
|
---|
372 |
|
---|
373 | static void *CRYPT_CollectionEnumCTL(PWINECRYPT_CERTSTORE store, void *pPrev)
|
---|
374 | {
|
---|
375 | PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
|
---|
376 | void *ret;
|
---|
377 |
|
---|
378 | TRACE("(%p, %p)\n", store, pPrev);
|
---|
379 |
|
---|
380 | EnterCriticalSection(&cs->cs);
|
---|
381 | if (pPrev)
|
---|
382 | {
|
---|
383 | PWINE_STORE_LIST_ENTRY storeEntry =
|
---|
384 | *(PWINE_STORE_LIST_ENTRY *)Context_GetExtra(pPrev,
|
---|
385 | sizeof(CTL_CONTEXT));
|
---|
386 |
|
---|
387 | ret = CRYPT_CollectionAdvanceEnum(cs, storeEntry,
|
---|
388 | &storeEntry->store->ctls, pCTLInterface, pPrev, sizeof(CTL_CONTEXT));
|
---|
389 | }
|
---|
390 | else
|
---|
391 | {
|
---|
392 | if (!list_empty(&cs->stores))
|
---|
393 | {
|
---|
394 | PWINE_STORE_LIST_ENTRY storeEntry = LIST_ENTRY(cs->stores.next,
|
---|
395 | WINE_STORE_LIST_ENTRY, entry);
|
---|
396 |
|
---|
397 | ret = CRYPT_CollectionAdvanceEnum(cs, storeEntry,
|
---|
398 | &storeEntry->store->ctls, pCTLInterface, NULL,
|
---|
399 | sizeof(CTL_CONTEXT));
|
---|
400 | }
|
---|
401 | else
|
---|
402 | {
|
---|
403 | SetLastError(CRYPT_E_NOT_FOUND);
|
---|
404 | ret = NULL;
|
---|
405 | }
|
---|
406 | }
|
---|
407 | LeaveCriticalSection(&cs->cs);
|
---|
408 | if (ret)
|
---|
409 | ((PCTL_CONTEXT)ret)->hCertStore = store;
|
---|
410 | TRACE("returning %p\n", ret);
|
---|
411 | return ret;
|
---|
412 | }
|
---|
413 |
|
---|
414 | static BOOL CRYPT_CollectionDeleteCTL(PWINECRYPT_CERTSTORE store,
|
---|
415 | void *pCtlContext)
|
---|
416 | {
|
---|
417 | BOOL ret;
|
---|
418 |
|
---|
419 | TRACE("(%p, %p)\n", store, pCtlContext);
|
---|
420 |
|
---|
421 | ret = CertDeleteCTLFromStore((PCCTL_CONTEXT)
|
---|
422 | Context_GetLinkedContext(pCtlContext, sizeof(CTL_CONTEXT)));
|
---|
423 | return ret;
|
---|
424 | }
|
---|
425 |
|
---|
426 | PWINECRYPT_CERTSTORE CRYPT_CollectionOpenStore(HCRYPTPROV hCryptProv,
|
---|
427 | DWORD dwFlags, const void *pvPara)
|
---|
428 | {
|
---|
429 | PWINE_COLLECTIONSTORE store;
|
---|
430 |
|
---|
431 | if (dwFlags & CERT_STORE_DELETE_FLAG)
|
---|
432 | {
|
---|
433 | SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
---|
434 | store = NULL;
|
---|
435 | }
|
---|
436 | else
|
---|
437 | {
|
---|
438 | store = CryptMemAlloc(sizeof(WINE_COLLECTIONSTORE));
|
---|
439 | if (store)
|
---|
440 | {
|
---|
441 | memset(store, 0, sizeof(WINE_COLLECTIONSTORE));
|
---|
442 | CRYPT_InitStore(&store->hdr, dwFlags, StoreTypeCollection);
|
---|
443 | store->hdr.closeStore = CRYPT_CollectionCloseStore;
|
---|
444 | store->hdr.certs.addContext = CRYPT_CollectionAddCert;
|
---|
445 | store->hdr.certs.enumContext = CRYPT_CollectionEnumCert;
|
---|
446 | store->hdr.certs.deleteContext = CRYPT_CollectionDeleteCert;
|
---|
447 | store->hdr.crls.addContext = CRYPT_CollectionAddCRL;
|
---|
448 | store->hdr.crls.enumContext = CRYPT_CollectionEnumCRL;
|
---|
449 | store->hdr.crls.deleteContext = CRYPT_CollectionDeleteCRL;
|
---|
450 | store->hdr.ctls.addContext = CRYPT_CollectionAddCTL;
|
---|
451 | store->hdr.ctls.enumContext = CRYPT_CollectionEnumCTL;
|
---|
452 | store->hdr.ctls.deleteContext = CRYPT_CollectionDeleteCTL;
|
---|
453 | InitializeCriticalSection(&store->cs);
|
---|
454 | store->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PWINE_COLLECTIONSTORE->cs");
|
---|
455 | list_init(&store->stores);
|
---|
456 | }
|
---|
457 | }
|
---|
458 | return (PWINECRYPT_CERTSTORE)store;
|
---|
459 | }
|
---|
460 |
|
---|
461 | BOOL WINAPI CertAddStoreToCollection(HCERTSTORE hCollectionStore,
|
---|
462 | HCERTSTORE hSiblingStore, DWORD dwUpdateFlags, DWORD dwPriority)
|
---|
463 | {
|
---|
464 | PWINE_COLLECTIONSTORE collection = (PWINE_COLLECTIONSTORE)hCollectionStore;
|
---|
465 | WINECRYPT_CERTSTORE *sibling = (WINECRYPT_CERTSTORE *)hSiblingStore;
|
---|
466 | PWINE_STORE_LIST_ENTRY entry;
|
---|
467 | BOOL ret;
|
---|
468 |
|
---|
469 | TRACE("(%p, %p, %08x, %d)\n", hCollectionStore, hSiblingStore,
|
---|
470 | dwUpdateFlags, dwPriority);
|
---|
471 |
|
---|
472 | if (!collection || !sibling)
|
---|
473 | return TRUE;
|
---|
474 | if (collection->hdr.dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
|
---|
475 | {
|
---|
476 | SetLastError(E_INVALIDARG);
|
---|
477 | return FALSE;
|
---|
478 | }
|
---|
479 | if (collection->hdr.type != StoreTypeCollection)
|
---|
480 | {
|
---|
481 | SetLastError(E_INVALIDARG);
|
---|
482 | return FALSE;
|
---|
483 | }
|
---|
484 | if (sibling->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
|
---|
485 | {
|
---|
486 | SetLastError(E_INVALIDARG);
|
---|
487 | return FALSE;
|
---|
488 | }
|
---|
489 |
|
---|
490 | entry = CryptMemAlloc(sizeof(WINE_STORE_LIST_ENTRY));
|
---|
491 | if (entry)
|
---|
492 | {
|
---|
493 | InterlockedIncrement(&sibling->ref);
|
---|
494 | TRACE("sibling %p's ref count is %d\n", sibling, sibling->ref);
|
---|
495 | entry->store = sibling;
|
---|
496 | entry->dwUpdateFlags = dwUpdateFlags;
|
---|
497 | entry->dwPriority = dwPriority;
|
---|
498 | list_init(&entry->entry);
|
---|
499 | TRACE("%p: adding %p, priority %d\n", collection, entry, dwPriority);
|
---|
500 | EnterCriticalSection(&collection->cs);
|
---|
501 | if (dwPriority)
|
---|
502 | {
|
---|
503 | PWINE_STORE_LIST_ENTRY cursor;
|
---|
504 | BOOL added = FALSE;
|
---|
505 |
|
---|
506 | LIST_FOR_EACH_ENTRY(cursor, &collection->stores,
|
---|
507 | WINE_STORE_LIST_ENTRY, entry)
|
---|
508 | {
|
---|
509 | if (cursor->dwPriority < dwPriority)
|
---|
510 | {
|
---|
511 | list_add_before(&cursor->entry, &entry->entry);
|
---|
512 | added = TRUE;
|
---|
513 | break;
|
---|
514 | }
|
---|
515 | }
|
---|
516 | if (!added)
|
---|
517 | list_add_tail(&collection->stores, &entry->entry);
|
---|
518 | }
|
---|
519 | else
|
---|
520 | list_add_tail(&collection->stores, &entry->entry);
|
---|
521 | LeaveCriticalSection(&collection->cs);
|
---|
522 | ret = TRUE;
|
---|
523 | }
|
---|
524 | else
|
---|
525 | ret = FALSE;
|
---|
526 | return ret;
|
---|
527 | }
|
---|
528 |
|
---|
529 | void WINAPI CertRemoveStoreFromCollection(HCERTSTORE hCollectionStore,
|
---|
530 | HCERTSTORE hSiblingStore)
|
---|
531 | {
|
---|
532 | PWINE_COLLECTIONSTORE collection = (PWINE_COLLECTIONSTORE)hCollectionStore;
|
---|
533 | WINECRYPT_CERTSTORE *sibling = (WINECRYPT_CERTSTORE *)hSiblingStore;
|
---|
534 | PWINE_STORE_LIST_ENTRY store, next;
|
---|
535 |
|
---|
536 | TRACE("(%p, %p)\n", hCollectionStore, hSiblingStore);
|
---|
537 |
|
---|
538 | if (!collection || !sibling)
|
---|
539 | return;
|
---|
540 | if (collection->hdr.dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
|
---|
541 | {
|
---|
542 | SetLastError(E_INVALIDARG);
|
---|
543 | return;
|
---|
544 | }
|
---|
545 | if (collection->hdr.type != StoreTypeCollection)
|
---|
546 | return;
|
---|
547 | if (sibling->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
|
---|
548 | {
|
---|
549 | SetLastError(E_INVALIDARG);
|
---|
550 | return;
|
---|
551 | }
|
---|
552 | EnterCriticalSection(&collection->cs);
|
---|
553 | LIST_FOR_EACH_ENTRY_SAFE(store, next, &collection->stores,
|
---|
554 | WINE_STORE_LIST_ENTRY, entry)
|
---|
555 | {
|
---|
556 | if (store->store == sibling)
|
---|
557 | {
|
---|
558 | list_remove(&store->entry);
|
---|
559 | CertCloseStore(store->store, 0);
|
---|
560 | CryptMemFree(store);
|
---|
561 | break;
|
---|
562 | }
|
---|
563 | }
|
---|
564 | LeaveCriticalSection(&collection->cs);
|
---|
565 | }
|
---|