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  * CreateActCtxA (KERNEL32.@)
  38  *
  39  * Create an activation context.
  40  */
  41 HANDLE WINAPI CreateActCtxA(PCACTCTXA pActCtx)
  42 {
  43     ACTCTXW     actw;
  44     SIZE_T      len;
  45     HANDLE      ret = INVALID_HANDLE_VALUE;
  46     LPWSTR      src = NULL, assdir = NULL, resname = NULL, appname = NULL;
  47
  48     TRACE("%p %08x\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
  49
  50     if (!pActCtx || pActCtx->cbSize != sizeof(*pActCtx))
  51     {
  52         SetLastError(ERROR_INVALID_PARAMETER);
  53         return INVALID_HANDLE_VALUE;
  54     }
  55
  56     actw.cbSize = sizeof(actw);
  57     actw.dwFlags = pActCtx->dwFlags;
  58     if (pActCtx->lpSource)
  59     {
  60         len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpSource, -1, NULL, 0);
  61         src = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
  62         if (!src) return INVALID_HANDLE_VALUE;
  63         MultiByteToWideChar(CP_ACP, 0, pActCtx->lpSource, -1, src, len);
  64     }
  65     actw.lpSource = src;
  66
  67     if (actw.dwFlags & ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID)
  68         actw.wProcessorArchitecture = pActCtx->wProcessorArchitecture;
  69     if (actw.dwFlags & ACTCTX_FLAG_LANGID_VALID)
  70         actw.wLangId = pActCtx->wLangId;
  71     if (actw.dwFlags & ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID)
  72     {
  73         len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpAssemblyDirectory, -1, NULL, 0);
  74         assdir = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
  75         if (!assdir) goto done;
  76         MultiByteToWideChar(CP_ACP, 0, pActCtx->lpAssemblyDirectory, -1, assdir, len);
  77         actw.lpAssemblyDirectory = assdir;
  78     }
  79     if (actw.dwFlags & ACTCTX_FLAG_RESOURCE_NAME_VALID)
  80     {
  81         if ((ULONG_PTR)pActCtx->lpResourceName >> 16)
  82         {
  83             len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpResourceName, -1, NULL, 0);
  84             resname = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
  85             if (!resname) goto done;
  86             MultiByteToWideChar(CP_ACP, 0, pActCtx->lpResourceName, -1, resname, len);
  87             actw.lpResourceName = resname;
  88         }
  89         else actw.lpResourceName = (LPCWSTR)pActCtx->lpResourceName;
  90     }
  91     if (actw.dwFlags & ACTCTX_FLAG_APPLICATION_NAME_VALID)
  92     {
  93         len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpApplicationName, -1, NULL, 0);
  94         appname = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
  95         if (!appname) goto done;
  96         MultiByteToWideChar(CP_ACP, 0, pActCtx->lpApplicationName, -1, appname, len);
  97         actw.lpApplicationName = appname;
  98     }
  99     if (actw.dwFlags & ACTCTX_FLAG_HMODULE_VALID)
 100         actw.hModule = pActCtx->hModule;
 101
 102     ret = CreateActCtxW(&actw);
 103
 104 done:
 105     HeapFree(GetProcessHeap(), 0, src);
 106     HeapFree(GetProcessHeap(), 0, assdir);
 107     HeapFree(GetProcessHeap(), 0, resname);
 108     HeapFree(GetProcessHeap(), 0, appname);
 109     return ret;
 110 }
 111
 112 /***********************************************************************
 113  * CreateActCtxW (KERNEL32.@)
 114  *
 115  * Create an activation context.
 116  */
 117 HANDLE WINAPI CreateActCtxW(PCACTCTXW pActCtx)
 118 {
 119     NTSTATUS    status;
 120     HANDLE      hActCtx;
 121
 122     TRACE("%p %08x\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
 123
 124     if ((status = RtlCreateActivationContext(&hActCtx, pActCtx)))
 125     {
 126         SetLastError(RtlNtStatusToDosError(status));
 127         return INVALID_HANDLE_VALUE;
 128     }
 129     return hActCtx;
 130 }
 131
 132 /***********************************************************************
 133  * ActivateActCtx (KERNEL32.@)
 134  *
 135  * Activate an activation context.
 136  */
 137 BOOL WINAPI ActivateActCtx(HANDLE hActCtx, ULONG_PTR *ulCookie)
 138 {
 139     NTSTATUS status;
 140
 141     if ((status = RtlActivateActivationContext( 0, hActCtx, ulCookie )))
 142     {
 143         SetLastError(RtlNtStatusToDosError(status));
 144         return FALSE;
 145     }
 146     return TRUE;
 147 }
 148
 149 /***********************************************************************
 150  * DeactivateActCtx (KERNEL32.@)
 151  *
 152  * Deactivate an activation context.
 153  */
 154 BOOL WINAPI DeactivateActCtx(DWORD dwFlags, ULONG_PTR ulCookie)
 155 {
 156     RtlDeactivateActivationContext( dwFlags, ulCookie );
 157     return TRUE;
 158 }
 159
 160 /***********************************************************************
 161  * GetCurrentActCtx (KERNEL32.@)
 162  *
 163  * Get the current activation context.
 164  */
 165 BOOL WINAPI GetCurrentActCtx(HANDLE* phActCtx)
 166 {
 167     NTSTATUS status;
 168
 169     if ((status = RtlGetActiveActivationContext(phActCtx)))
 170     {
 171         SetLastError(RtlNtStatusToDosError(status));
 172         return FALSE;
 173     }
 174     return TRUE;
 175 }
 176
 177 /***********************************************************************
 178  * AddRefActCtx (KERNEL32.@)
 179  *
 180  * Add a reference to an activation context.
 181  */
 182 void WINAPI AddRefActCtx(HANDLE hActCtx)
 183 {
 184     RtlAddRefActivationContext(hActCtx);
 185 }
 186
 187 /***********************************************************************
 188  * ReleaseActCtx (KERNEL32.@)
 189  *
 190  * Release a reference to an activation context.
 191  */
 192 void WINAPI ReleaseActCtx(HANDLE hActCtx)
 193 {
 194     RtlReleaseActivationContext(hActCtx);
 195 }
 196
 197 /***********************************************************************
 198  * ZombifyActCtx (KERNEL32.@)
 199  *
 200  * Deactivate context without releasing it.
 201  */
 202 BOOL WINAPI ZombifyActCtx(HANDLE hActCtx)
 203 {
 204     NTSTATUS status;
 205
 206     if ((status = RtlZombifyActivationContext(hActCtx)))
 207     {
 208         SetLastError(RtlNtStatusToDosError(status));
 209         return FALSE;
 210     }
 211     return TRUE;
 212 }
 213
 214 /***********************************************************************
 215  * FindActCtxSectionStringA (KERNEL32.@)
 216  *
 217  * Find information about a string in an activation context.
 218  */
 219 BOOL WINAPI FindActCtxSectionStringA(DWORD dwFlags, const GUID* lpExtGuid,
 220                                     ULONG ulId, LPCSTR lpSearchStr,
 221                                     PACTCTX_SECTION_KEYED_DATA pInfo)
 222 {
 223     LPWSTR  search_str;
 224     DWORD   len;
 225     BOOL    ret;
 226
 227     TRACE("%08x %s %u %s %p\n", dwFlags, debugstr_guid(lpExtGuid),
 228           ulId, debugstr_a(lpSearchStr), pInfo);
 229
 230     if (!lpSearchStr)
 231     {
 232         SetLastError(ERROR_INVALID_PARAMETER);
 233         return FALSE;
 234     }
 235
 236     len = MultiByteToWideChar(CP_ACP, 0, lpSearchStr, -1, NULL, 0);
 237     search_str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 238     MultiByteToWideChar(CP_ACP, 0, lpSearchStr, -1, search_str, len);
 239
 240     ret = FindActCtxSectionStringW(dwFlags, lpExtGuid, ulId, search_str, pInfo);
 241
 242     HeapFree(GetProcessHeap(), 0, search_str);
 243     return ret;
 244 }
 245
 246 /***********************************************************************
 247  * FindActCtxSectionStringW (KERNEL32.@)
 248  *
 249  * Find information about a string in an activation context.
 250  */
 251 BOOL WINAPI FindActCtxSectionStringW(DWORD dwFlags, const GUID* lpExtGuid,
 252                                     ULONG ulId, LPCWSTR lpSearchStr,
 253                                     PACTCTX_SECTION_KEYED_DATA pInfo)
 254 {
 255     UNICODE_STRING us;
 256     NTSTATUS status;
 257
 258     RtlInitUnicodeString(&us, lpSearchStr);
 259     if ((status = RtlFindActivationContextSectionString(dwFlags, lpExtGuid, ulId, &us, pInfo)))
 260     {
 261         SetLastError(RtlNtStatusToDosError(status));
 262         return FALSE;
 263     }
 264     return TRUE;
 265 }
 266
 267 /***********************************************************************
 268  * FindActCtxSectionGuid (KERNEL32.@)
 269  *
 270  * Find information about a GUID in an activation context.
 271  */
 272 BOOL WINAPI FindActCtxSectionGuid(DWORD dwFlags, const GUID* lpExtGuid,
 273                                   ULONG ulId, const GUID* lpSearchGuid,
 274                                   PACTCTX_SECTION_KEYED_DATA pInfo)
 275 {
 276     NTSTATUS status;
 277
 278     if ((status = RtlFindActivationContextSectionGuid(dwFlags, lpExtGuid, ulId, lpSearchGuid, pInfo)))
 279     {
 280         SetLastError(RtlNtStatusToDosError(status));
 281         return FALSE;
 282     }
 283
 284     return TRUE;
 285 }
 286
 287 /***********************************************************************
 288  * QueryActCtxW (KERNEL32.@)
 289  *
 290  * Get information about an activation context.
 291  */
 292 BOOL WINAPI QueryActCtxW(DWORD dwFlags, HANDLE hActCtx, PVOID pvSubInst,
 293                          ULONG ulClass, PVOID pvBuff, SIZE_T cbBuff,
 294                          SIZE_T *pcbLen)
 295 {
 296     NTSTATUS status;
 297
 298     if ((status = RtlQueryInformationActivationContext( dwFlags, hActCtx, pvSubInst, ulClass,
 299                                                         pvBuff, cbBuff, pcbLen )))
 300     {
 301         SetLastError(RtlNtStatusToDosError(status));
 302         return FALSE;
 303     }
 304     return TRUE;
 305 }