user32: Check structure size in GetGUIThreadInfo.
[wine] / dlls / kernel32 / actctx.c
1 /*
2  * Activation contexts
3  *
4  * Copyright 2004 Jon Griffiths
5  * Copyright 2007 Eric Pouech
6  * Copyright 2007 Jacek Caban for CodeWeavers
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <stdarg.h>
27 #include "windef.h"
28 #include "winbase.h"
29 #include "winerror.h"
30 #include "winnls.h"
31 #include "winternl.h"
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(actctx);
35
36
37 #define ACTCTX_FAKE_HANDLE ((HANDLE) 0xf00baa)
38
39 /***********************************************************************
40  * CreateActCtxA (KERNEL32.@)
41  *
42  * Create an activation context.
43  */
44 HANDLE WINAPI CreateActCtxA(PCACTCTXA pActCtx)
45 {
46     ACTCTXW     actw;
47     SIZE_T      len;
48     HANDLE      ret = INVALID_HANDLE_VALUE;
49     LPWSTR      src = NULL, assdir = NULL, resname = NULL, appname = NULL;
50
51     TRACE("%p %08x\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
52
53     if (!pActCtx || pActCtx->cbSize != sizeof(*pActCtx))
54     {
55         SetLastError(ERROR_INVALID_PARAMETER);
56         return INVALID_HANDLE_VALUE;
57     }
58
59     actw.cbSize = sizeof(actw);
60     actw.dwFlags = pActCtx->dwFlags;
61     if (pActCtx->lpSource)
62     {
63         len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpSource, -1, NULL, 0);
64         src = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
65         if (!src) return INVALID_HANDLE_VALUE;
66         MultiByteToWideChar(CP_ACP, 0, pActCtx->lpSource, -1, src, len);
67     }
68     actw.lpSource = src;
69
70     if (actw.dwFlags & ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID)
71         actw.wProcessorArchitecture = pActCtx->wProcessorArchitecture;
72     if (actw.dwFlags & ACTCTX_FLAG_LANGID_VALID)
73         actw.wLangId = pActCtx->wLangId;
74     if (actw.dwFlags & ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID)
75     {
76         len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpAssemblyDirectory, -1, NULL, 0);
77         assdir = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
78         if (!assdir) goto done;
79         MultiByteToWideChar(CP_ACP, 0, pActCtx->lpAssemblyDirectory, -1, assdir, len);
80         actw.lpAssemblyDirectory = assdir;
81     }
82     if (actw.dwFlags & ACTCTX_FLAG_RESOURCE_NAME_VALID)
83     {
84         if ((ULONG_PTR)pActCtx->lpResourceName >> 16)
85         {
86             len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpResourceName, -1, NULL, 0);
87             resname = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
88             if (!resname) goto done;
89             MultiByteToWideChar(CP_ACP, 0, pActCtx->lpResourceName, -1, resname, len);
90             actw.lpResourceName = resname;
91         }
92         else actw.lpResourceName = (LPCWSTR)pActCtx->lpResourceName;
93     }
94     if (actw.dwFlags & ACTCTX_FLAG_APPLICATION_NAME_VALID)
95     {
96         len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpApplicationName, -1, NULL, 0);
97         appname = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
98         if (!appname) goto done;
99         MultiByteToWideChar(CP_ACP, 0, pActCtx->lpApplicationName, -1, appname, len);
100         actw.lpApplicationName = appname;
101     }
102     if (actw.dwFlags & ACTCTX_FLAG_HMODULE_VALID)
103         actw.hModule = pActCtx->hModule;
104
105     ret = CreateActCtxW(&actw);
106
107 done:
108     HeapFree(GetProcessHeap(), 0, src);
109     HeapFree(GetProcessHeap(), 0, assdir);
110     HeapFree(GetProcessHeap(), 0, resname);
111     HeapFree(GetProcessHeap(), 0, appname);
112     return ret;
113 }
114
115 /***********************************************************************
116  * CreateActCtxW (KERNEL32.@)
117  *
118  * Create an activation context.
119  */
120 HANDLE WINAPI CreateActCtxW(PCACTCTXW pActCtx)
121 {
122     NTSTATUS    status;
123     HANDLE      hActCtx;
124
125     TRACE("%p %08x\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
126
127     if ((status = RtlCreateActivationContext(&hActCtx, pActCtx)))
128     {
129         SetLastError(RtlNtStatusToDosError(status));
130         return INVALID_HANDLE_VALUE;
131     }
132     return hActCtx;
133 }
134
135 /***********************************************************************
136  * ActivateActCtx (KERNEL32.@)
137  *
138  * Activate an activation context.
139  */
140 BOOL WINAPI ActivateActCtx(HANDLE hActCtx, ULONG_PTR *ulCookie)
141 {
142     NTSTATUS status;
143
144     if ((status = RtlActivateActivationContext( 0, hActCtx, ulCookie )))
145     {
146         SetLastError(RtlNtStatusToDosError(status));
147         return FALSE;
148     }
149     return TRUE;
150 }
151
152 /***********************************************************************
153  * DeactivateActCtx (KERNEL32.@)
154  *
155  * Deactivate an activation context.
156  */
157 BOOL WINAPI DeactivateActCtx(DWORD dwFlags, ULONG_PTR ulCookie)
158 {
159     RtlDeactivateActivationContext( dwFlags, ulCookie );
160     return TRUE;
161 }
162
163 /***********************************************************************
164  * GetCurrentActCtx (KERNEL32.@)
165  *
166  * Get the current activation context.
167  */
168 BOOL WINAPI GetCurrentActCtx(HANDLE* phActCtx)
169 {
170     NTSTATUS status;
171
172     if ((status = RtlGetActiveActivationContext(phActCtx)))
173     {
174         SetLastError(RtlNtStatusToDosError(status));
175         return FALSE;
176     }
177     return TRUE;
178 }
179
180 /***********************************************************************
181  * AddRefActCtx (KERNEL32.@)
182  *
183  * Add a reference to an activation context.
184  */
185 void WINAPI AddRefActCtx(HANDLE hActCtx)
186 {
187     RtlAddRefActivationContext(hActCtx);
188 }
189
190 /***********************************************************************
191  * ReleaseActCtx (KERNEL32.@)
192  *
193  * Release a reference to an activation context.
194  */
195 void WINAPI ReleaseActCtx(HANDLE hActCtx)
196 {
197     RtlReleaseActivationContext(hActCtx);
198 }
199
200 /***********************************************************************
201  * ZombifyActCtx (KERNEL32.@)
202  *
203  * Release a reference to an activation context.
204  */
205 BOOL WINAPI ZombifyActCtx(HANDLE hActCtx)
206 {
207   FIXME("%p\n", hActCtx);
208   if (hActCtx != ACTCTX_FAKE_HANDLE)
209     return FALSE;
210   return TRUE;
211 }
212
213 /***********************************************************************
214  * FindActCtxSectionStringA (KERNEL32.@)
215  *
216  * Find information about a string in an activation context.
217  */
218 BOOL WINAPI FindActCtxSectionStringA(DWORD dwFlags, const GUID* lpExtGuid,
219                                     ULONG ulId, LPCSTR lpSearchStr,
220                                     PACTCTX_SECTION_KEYED_DATA pInfo)
221 {
222     LPWSTR  search_str;
223     DWORD   len;
224     BOOL    ret;
225
226     TRACE("%08x %s %u %s %p\n", dwFlags, debugstr_guid(lpExtGuid),
227           ulId, debugstr_a(lpSearchStr), pInfo);
228
229     if (!lpSearchStr)
230     {
231         SetLastError(ERROR_INVALID_PARAMETER);
232         return FALSE;
233     }
234
235     len = MultiByteToWideChar(CP_ACP, 0, lpSearchStr, -1, NULL, 0);
236     search_str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
237     MultiByteToWideChar(CP_ACP, 0, lpSearchStr, -1, search_str, len);
238
239     ret = FindActCtxSectionStringW(dwFlags, lpExtGuid, ulId, search_str, pInfo);
240
241     HeapFree(GetProcessHeap(), 0, search_str);
242     return ret;
243 }
244
245 /***********************************************************************
246  * FindActCtxSectionStringW (KERNEL32.@)
247  *
248  * Find information about a string in an activation context.
249  */
250 BOOL WINAPI FindActCtxSectionStringW(DWORD dwFlags, const GUID* lpExtGuid,
251                                     ULONG ulId, LPCWSTR lpSearchStr,
252                                     PACTCTX_SECTION_KEYED_DATA pInfo)
253 {
254     UNICODE_STRING us;
255     NTSTATUS status;
256
257     RtlInitUnicodeString(&us, lpSearchStr);
258     if ((status = RtlFindActivationContextSectionString(dwFlags, lpExtGuid, ulId, &us, pInfo)))
259     {
260         SetLastError(RtlNtStatusToDosError(status));
261         return FALSE;
262     }
263     return TRUE;
264 }
265
266 /***********************************************************************
267  * FindActCtxSectionGuid (KERNEL32.@)
268  *
269  * Find information about a GUID in an activation context.
270  */
271 BOOL WINAPI FindActCtxSectionGuid(DWORD dwFlags, const GUID* lpExtGuid,
272                                   ULONG ulId, const GUID* lpSearchGuid,
273                                   PACTCTX_SECTION_KEYED_DATA pInfo)
274 {
275   FIXME("%08x %s %u %s %p\n", dwFlags, debugstr_guid(lpExtGuid),
276        ulId, debugstr_guid(lpSearchGuid), pInfo);
277   SetLastError( ERROR_CALL_NOT_IMPLEMENTED);
278   return FALSE;
279 }
280
281 /***********************************************************************
282  * QueryActCtxW (KERNEL32.@)
283  *
284  * Get information about an activation context.
285  */
286 BOOL WINAPI QueryActCtxW(DWORD dwFlags, HANDLE hActCtx, PVOID pvSubInst,
287                          ULONG ulClass, PVOID pvBuff, SIZE_T cbBuff,
288                          SIZE_T *pcbLen)
289 {
290     NTSTATUS status;
291
292     if ((status = RtlQueryInformationActivationContext( dwFlags, hActCtx, pvSubInst, ulClass,
293                                                         pvBuff, cbBuff, pcbLen )))
294     {
295         SetLastError(RtlNtStatusToDosError(status));
296         return FALSE;
297     }
298     return TRUE;
299 }