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 }
300
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.