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