msvcr90: Added _get/set_invalid_parameter_handler implementation.
[wine] / dlls / shlwapi / thread.c
1 /*
2  * SHLWAPI thread and MT synchronisation functions
3  *
4  * Copyright 2002 Juergen Schmied
5  * Copyright 2002 Jon Griffiths
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21 #include <stdarg.h>
22 #include <string.h>
23
24 #define COBJMACROS
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winnls.h"
29 #include "winuser.h"
30 #define NO_SHLWAPI_REG
31 #define NO_SHLWAPI_PATH
32 #define NO_SHLWAPI_GDI
33 #define NO_SHLWAPI_STREAM
34 #define NO_SHLWAPI_USER
35 #include "shlwapi.h"
36 #include "shlobj.h"
37 #include "wine/debug.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(shell);
40
41 extern DWORD SHLWAPI_ThreadRef_index;  /* Initialised in shlwapi_main.c */
42
43 INT WINAPI SHStringFromGUIDA(REFGUID,LPSTR,INT);
44
45 /**************************************************************************
46  *      CreateAllAccessSecurityAttributes       [SHLWAPI.356]
47  *
48  * Initialise security attributes from a security descriptor.
49  *
50  * PARAMS
51  *  lpAttr [O] Security attributes
52  *  lpSec  [I] Security descriptor
53  *
54  * RETURNS
55  *  Success: lpAttr, initialised using lpSec.
56  *  Failure: NULL, if any parameters are invalid.
57  *
58  * NOTES
59  *  This function always returns NULL if the underlying OS version
60  *  Wine is impersonating does not use security descriptors (i.e. anything
61  *  before Windows NT).
62  */
63 LPSECURITY_ATTRIBUTES WINAPI CreateAllAccessSecurityAttributes(
64         LPSECURITY_ATTRIBUTES lpAttr,
65         PSECURITY_DESCRIPTOR lpSec,
66         DWORD p3)
67 {
68   /* This function is used within SHLWAPI only to create security attributes
69    * for shell semaphores. */
70
71   TRACE("(%p,%p,%08x)\n", lpAttr, lpSec, p3);
72
73   if (!(GetVersion() & 0x80000000))  /* NT */
74   {
75     if (!lpSec || !lpAttr)
76       return NULL;
77
78     if (InitializeSecurityDescriptor(lpSec, 1))
79     {
80       if (SetSecurityDescriptorDacl(lpSec, TRUE, NULL, FALSE))
81       {
82          lpAttr->nLength = sizeof(SECURITY_ATTRIBUTES);
83          lpAttr->lpSecurityDescriptor = lpSec;
84          lpAttr->bInheritHandle = FALSE;
85          return lpAttr;
86       }
87     }
88   }
89   return NULL;
90 }
91
92 /*************************************************************************
93  *      _SHGetInstanceExplorer  [SHLWAPI.@]
94  *
95  * Get an interface to the shell explorer.
96  *
97  * PARAMS
98  *  lppUnknown [O] Destination for explorers IUnknown interface.
99  *
100  * RETURNS
101  *  Success: S_OK. lppUnknown contains the explorer interface.
102  *  Failure: An HRESULT error code.
103  */
104 HRESULT WINAPI _SHGetInstanceExplorer(IUnknown **lppUnknown)
105 {
106   /* This function is used within SHLWAPI only to hold the IE reference
107    * for threads created with the CTF_PROCESS_REF flag set. */
108     return SHGetInstanceExplorer(lppUnknown);
109 }
110
111 /* Internal thread information structure */
112 typedef struct tagSHLWAPI_THREAD_INFO
113 {
114   LPTHREAD_START_ROUTINE pfnThreadProc; /* Thread start */
115   LPTHREAD_START_ROUTINE pfnCallback;   /* Thread initialisation */
116   PVOID     pData;                      /* Application specific data */
117   BOOL      bInitCom;                   /* Initialise COM for the thread? */
118   HANDLE    hEvent;                     /* Signal for creator to continue */
119   IUnknown *refThread;                  /* Reference to thread creator */
120   IUnknown *refIE;                      /* Reference to the IE process */
121 } SHLWAPI_THREAD_INFO, *LPSHLWAPI_THREAD_INFO;
122
123
124 /*************************************************************************
125  * SHGetThreadRef       [SHLWAPI.@]
126  *
127  * Get a per-thread object reference set by SHSetThreadRef().
128  *
129  * PARAMS
130  *   lppUnknown [O] Destination to receive object reference
131  *
132  * RETURNS
133  *   Success: S_OK. lppUnknown is set to the object reference.
134  *   Failure: E_NOINTERFACE, if an error occurs or lppUnknown is NULL.
135  */
136 HRESULT WINAPI SHGetThreadRef(IUnknown **lppUnknown)
137 {
138   TRACE("(%p)\n", lppUnknown);
139
140   if (!lppUnknown || SHLWAPI_ThreadRef_index == TLS_OUT_OF_INDEXES)
141     return E_NOINTERFACE;
142
143   *lppUnknown = TlsGetValue(SHLWAPI_ThreadRef_index);
144   if (!*lppUnknown)
145     return E_NOINTERFACE;
146
147   /* Add a reference. Caller will Release() us when finished */
148   IUnknown_AddRef(*lppUnknown);
149   return S_OK;
150 }
151
152 /*************************************************************************
153  * SHSetThreadRef       [SHLWAPI.@]
154  *
155  * Store a per-thread object reference.
156  *
157  * PARAMS
158  *   lpUnknown [I] Object reference to store
159  *
160  * RETURNS
161  *   Success: S_OK. lpUnknown is stored and can be retrieved by SHGetThreadRef()
162  *   Failure: E_NOINTERFACE, if an error occurs or lpUnknown is NULL.
163  */
164 HRESULT WINAPI SHSetThreadRef(IUnknown *lpUnknown)
165 {
166   TRACE("(%p)\n", lpUnknown);
167
168   if (!lpUnknown || SHLWAPI_ThreadRef_index  == TLS_OUT_OF_INDEXES)
169     return E_NOINTERFACE;
170
171   TlsSetValue(SHLWAPI_ThreadRef_index, lpUnknown);
172   return S_OK;
173 }
174
175 /*************************************************************************
176  * SHReleaseThreadRef   [SHLWAPI.@]
177  *
178  * Release a per-thread object reference.
179  *
180  * PARAMS
181  *  None.
182  *
183  * RETURNS
184  *   Success: S_OK. The threads object reference is released.
185  *   Failure: An HRESULT error code.
186  */
187 HRESULT WINAPI SHReleaseThreadRef(void)
188 {
189   FIXME("() - stub!\n");
190   return S_OK;
191 }
192
193 /*************************************************************************
194  * SHLWAPI_ThreadWrapper
195  *
196  * Internal wrapper for executing user thread functions from SHCreateThread.
197  */
198 static DWORD WINAPI SHLWAPI_ThreadWrapper(PVOID pTi)
199 {
200   SHLWAPI_THREAD_INFO ti;
201   HRESULT hCom = E_FAIL;
202   DWORD dwRet;
203
204   TRACE("(%p)\n", pTi);
205
206   /* We are now executing in the context of the newly created thread.
207    * So we copy the data passed to us (it is on the stack of the function
208    * that called us, which is waiting for us to signal an event before
209    * returning). */
210   memcpy(&ti, pTi, sizeof(SHLWAPI_THREAD_INFO));
211
212   /* Initialise COM for the thread, if desired */
213   if (ti.bInitCom)
214   {
215     hCom = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED|COINIT_DISABLE_OLE1DDE);
216
217     if (FAILED(hCom))
218       hCom = CoInitializeEx(NULL, COINIT_DISABLE_OLE1DDE);
219   }
220
221   /* Execute the callback function before returning */
222   if (ti.pfnCallback)
223     ti.pfnCallback(ti.pData);
224
225   /* Signal the thread that created us; it can return now */
226   SetEvent(ti.hEvent);
227
228   /* Execute the callers start code */
229   dwRet = ti.pfnThreadProc(ti.pData);
230
231   /* Release references to the caller and IE process, if held */
232   if (ti.refThread)
233     IUnknown_Release(ti.refThread);
234
235   if (ti.refIE)
236     IUnknown_Release(ti.refIE);
237
238   if (SUCCEEDED(hCom))
239     CoUninitialize();
240
241   /* Return the users thread return value */
242   return dwRet;
243 }
244
245 /*************************************************************************
246  *      SHCreateThread  [SHLWAPI.16]
247  *
248  * Create a new thread.
249  *
250  * PARAMS
251  *   pfnThreadProc [I] Function to execute in new thread
252  *   pData         [I] Application specific data passed to pfnThreadProc
253  *   dwFlags       [I] CTF_ flags from "shlwapi.h"
254  *   pfnCallback   [I] Function to execute before pfnThreadProc
255  *
256  * RETURNS
257  *   Success: TRUE. pfnThreadProc was executed.
258  *   Failure: FALSE. pfnThreadProc was not executed.
259  *
260  * NOTES
261  *   If the thread cannot be created, pfnCallback is NULL, and dwFlags
262  *   has bit CTF_INSIST set, pfnThreadProc will be executed synchronously.
263  */
264 BOOL WINAPI SHCreateThread(LPTHREAD_START_ROUTINE pfnThreadProc, VOID *pData,
265                            DWORD dwFlags, LPTHREAD_START_ROUTINE pfnCallback)
266 {
267   SHLWAPI_THREAD_INFO ti;
268   BOOL bCalled = FALSE;
269
270   TRACE("(%p,%p,0x%X,%p)\n", pfnThreadProc, pData, dwFlags, pfnCallback);
271
272   /* Set up data to pass to the new thread (On our stack) */
273   ti.pfnThreadProc = pfnThreadProc;
274   ti.pfnCallback = pfnCallback;
275   ti.pData = pData;
276   ti.bInitCom = dwFlags & CTF_COINIT ? TRUE : FALSE;
277   ti.hEvent = CreateEventW(NULL,FALSE,FALSE,NULL);
278
279   /* Hold references to the current thread and IE process, if desired */
280   if(dwFlags & CTF_THREAD_REF)
281     SHGetThreadRef(&ti.refThread);
282   else
283     ti.refThread = NULL;
284
285   if(dwFlags & CTF_PROCESS_REF)
286     _SHGetInstanceExplorer(&ti.refIE);
287   else
288     ti.refIE = NULL;
289
290   /* Create the thread */
291   if(ti.hEvent)
292   {
293     DWORD dwRetVal;
294     HANDLE hThread;
295
296     hThread = CreateThread(NULL, 0, SHLWAPI_ThreadWrapper, &ti, 0, &dwRetVal);
297
298     if(hThread)
299     {
300       /* Wait for the thread to signal us to continue */
301       WaitForSingleObject(ti.hEvent, INFINITE);
302       CloseHandle(hThread);
303       bCalled = TRUE;
304     }
305     CloseHandle(ti.hEvent);
306   }
307
308   if (!bCalled)
309   {
310     if (!ti.pfnCallback && dwFlags & CTF_INSIST)
311     {
312       /* Couldn't call, call synchronously */
313       pfnThreadProc(pData);
314       bCalled = TRUE;
315     }
316     else
317     {
318       /* Free references, since thread hasn't run to do so */
319       if(ti.refThread)
320         IUnknown_Release(ti.refThread);
321
322       if(ti.refIE)
323         IUnknown_Release(ti.refIE);
324     }
325   }
326   return bCalled;
327 }
328
329 /*************************************************************************
330  *      SHGlobalCounterGetValue [SHLWAPI.223]
331  *
332  * Get the current count of a semaphore.
333  *
334  * PARAMS
335  *  hSem [I] Semaphore handle
336  *
337  * RETURNS
338  *  The current count of the semaphore.
339  */
340 LONG WINAPI SHGlobalCounterGetValue(HANDLE hSem)
341 {
342   LONG dwOldCount = 0;
343
344   TRACE("(%p)\n", hSem);
345   ReleaseSemaphore(hSem, 1, &dwOldCount); /* +1 */
346   WaitForSingleObject(hSem, 0);           /* -1 */
347   return dwOldCount;
348 }
349
350 /*************************************************************************
351  *      SHGlobalCounterIncrement        [SHLWAPI.224]
352  *
353  * Claim a semaphore.
354  *
355  * PARAMS
356  *  hSem [I] Semaphore handle
357  *
358  * RETURNS
359  *  The new count of the semaphore.
360  */
361 LONG WINAPI SHGlobalCounterIncrement(HANDLE hSem)
362 {
363   LONG dwOldCount = 0;
364
365   TRACE("(%p)\n", hSem);
366   ReleaseSemaphore(hSem, 1, &dwOldCount);
367   return dwOldCount + 1;
368 }
369
370 /*************************************************************************
371  *      SHGlobalCounterDecrement        [SHLWAPI.424]
372  *
373  * Release a semaphore.
374  *
375  * PARAMS
376  *  hSem [I] Semaphore handle
377  *
378  * RETURNS
379  *  The new count of the semaphore.
380  */
381 DWORD WINAPI SHGlobalCounterDecrement(HANDLE hSem)
382 {
383   DWORD dwOldCount = 0;
384
385   TRACE("(%p)\n", hSem);
386
387   dwOldCount = SHGlobalCounterGetValue(hSem);
388   WaitForSingleObject(hSem, 0);
389   return dwOldCount - 1;
390 }
391
392 /*************************************************************************
393  *      SHGlobalCounterCreateNamedW     [SHLWAPI.423]
394  *
395  * Unicode version of SHGlobalCounterCreateNamedA.
396  */
397 HANDLE WINAPI SHGlobalCounterCreateNamedW(LPCWSTR lpszName, DWORD iInitial)
398 {
399   static const WCHAR szPrefix[] = { 's', 'h', 'e', 'l', 'l', '.', '\0' };
400   const int iPrefixLen = 6;
401   WCHAR szBuff[MAX_PATH];
402   const int iBuffLen = sizeof(szBuff)/sizeof(WCHAR);
403   SECURITY_DESCRIPTOR sd;
404   SECURITY_ATTRIBUTES sAttr, *pSecAttr;
405   HANDLE hRet;
406
407   TRACE("(%s,%d)\n", debugstr_w(lpszName), iInitial);
408
409   /* Create Semaphore name */
410   memcpy(szBuff, szPrefix, (iPrefixLen + 1) * sizeof(WCHAR));
411   if (lpszName)
412     StrCpyNW(szBuff + iPrefixLen, lpszName, iBuffLen - iPrefixLen);
413
414   /* Initialise security attributes */
415   pSecAttr = CreateAllAccessSecurityAttributes(&sAttr, &sd, 0);
416
417   if (!(hRet = CreateSemaphoreW(pSecAttr , iInitial, MAXLONG, szBuff)))
418     hRet = OpenSemaphoreW(SYNCHRONIZE|SEMAPHORE_MODIFY_STATE, 0, szBuff);
419   return hRet;
420 }
421
422 /*************************************************************************
423  *      SHGlobalCounterCreateNamedA     [SHLWAPI.422]
424  *
425  * Create a semaphore.
426  *
427  * PARAMS
428  *  lpszName [I] Name of semaphore
429  *  iInitial [I] Initial count for semaphore
430  *
431  * RETURNS
432  *  A new semaphore handle.
433  */
434 HANDLE WINAPI SHGlobalCounterCreateNamedA(LPCSTR lpszName, DWORD iInitial)
435 {
436   WCHAR szBuff[MAX_PATH];
437
438   TRACE("(%s,%d)\n", debugstr_a(lpszName), iInitial);
439
440   if (lpszName)
441     MultiByteToWideChar(0, 0, lpszName, -1, szBuff, MAX_PATH);
442   return SHGlobalCounterCreateNamedW(lpszName ? szBuff : NULL, iInitial);
443 }
444
445 /*************************************************************************
446  *      SHGlobalCounterCreate   [SHLWAPI.222]
447  *
448  * Create a semaphore using the name of a GUID.
449  *
450  * PARAMS
451  *  guid [I] GUID to use as semaphore name
452  *
453  * RETURNS
454  *  A handle to the semaphore.
455  *
456  * NOTES
457  *  The initial count of the semaphore is set to 0.
458  */
459 HANDLE WINAPI SHGlobalCounterCreate (REFGUID guid)
460 {
461   char szName[40];
462
463   TRACE("(%s)\n", debugstr_guid(guid));
464
465   /* Create a named semaphore using the GUID string */
466   SHStringFromGUIDA(guid, szName, sizeof(szName) - 1);
467   return SHGlobalCounterCreateNamedA(szName, 0);
468 }