Sync to trunk (r44371)
[reactos.git] / reactos / dll / win32 / kernel32 / misc / actctx.c
index 3e81c9c..05c9dbb 100644 (file)
  * COPYRIGHT:       See COPYING in the top level directory
  * PROJECT:         ReactOS system libraries
  * FILE:            dll/win32/kernel32/misc/actctx.c
- * PURPOSE:         Comm functions
+ * PURPOSE:         Activation contexts
  * PROGRAMMERS:     Jacek Caban for CodeWeavers
  *                  Eric Pouech
  *                  Jon Griffiths
  *                  Dmitry Chapyshev (dmitry@reactos.org)
+ *                  Samuel SerapiĆ³n 
  */
 
+/* synched with wine 1.1.26 */
+
 #include <k32.h>
 
-#define NDEBUG
-#include <debug.h>
+#include "wine/debug.h"
 
-#define ACTCTX_FLAGS_ALL (\
- ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID |\
- ACTCTX_FLAG_LANGID_VALID |\
- ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID |\
- ACTCTX_FLAG_RESOURCE_NAME_VALID |\
- ACTCTX_FLAG_SET_PROCESS_DEFAULT |\
- ACTCTX_FLAG_APPLICATION_NAME_VALID |\
- ACTCTX_FLAG_SOURCE_IS_ASSEMBLYREF |\
- ACTCTX_FLAG_HMODULE_VALID )
+WINE_DEFAULT_DEBUG_CHANNEL(actctx);
 
 #define ACTCTX_FAKE_HANDLE ((HANDLE) 0xf00baa)
-#define ACTCTX_FAKE_COOKIE ((ULONG_PTR) 0xf00bad)
 
-/*
- * @implemented
+/***********************************************************************
+ * CreateActCtxA (KERNEL32.@)
+ *
+ * Create an activation context.
  */
-BOOL
-WINAPI
-FindActCtxSectionStringA(
-    DWORD dwFlags,
-    const GUID *lpExtensionGuid,
-    ULONG ulSectionId,
-    LPCSTR lpStringToFind,
-    PACTCTX_SECTION_KEYED_DATA ReturnedData
-    )
+HANDLE WINAPI CreateActCtxA(PCACTCTXA pActCtx)
 {
-    BOOL bRetVal;
-    LPWSTR lpStringToFindW = NULL;
+    ACTCTXW     actw;
+    SIZE_T      len;
+    HANDLE      ret = INVALID_HANDLE_VALUE;
+    LPWSTR      src = NULL, assdir = NULL, resname = NULL, appname = NULL;
+
+    TRACE("%p %08x\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
 
-    /* Convert lpStringToFind */
-    if (lpStringToFind)
+    if (!pActCtx || pActCtx->cbSize != sizeof(*pActCtx))
     {
-        BasepAnsiStringToHeapUnicodeString(lpStringToFind,
-                                            (LPWSTR*) &lpStringToFindW);
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return INVALID_HANDLE_VALUE;
     }
 
-    /* Call the Unicode function */
-    bRetVal = FindActCtxSectionStringW(dwFlags,
-                                        lpExtensionGuid,
-                                        ulSectionId,
-                                        lpStringToFindW,
-                                        ReturnedData);
-
-    /* Clean up */
-    if (lpStringToFindW)
-        RtlFreeHeap(GetProcessHeap(), 0, (LPWSTR*) lpStringToFindW);
-
-    return bRetVal;
-}
-
-
-/*
- * @implemented
- */
-HANDLE
-WINAPI
-CreateActCtxA(
-    PCACTCTXA pActCtx
-    )
-{
-    ACTCTXW pActCtxW;
-    HANDLE hRetVal;
-
-    ZeroMemory(&pActCtxW, sizeof(ACTCTXW));
-    pActCtxW.cbSize = sizeof(ACTCTXW);
-    pActCtxW.dwFlags = pActCtx->dwFlags;
-    pActCtxW.wLangId = pActCtx->wLangId;
-    pActCtxW.hModule = pActCtx->hModule;
-    pActCtxW.wProcessorArchitecture = pActCtx->wProcessorArchitecture;
-
-    pActCtxW.hModule = pActCtx->hModule;
-
-    /* Convert ActCtx Strings */
+    actw.cbSize = sizeof(actw);
+    actw.dwFlags = pActCtx->dwFlags;
     if (pActCtx->lpSource)
     {
-        BasepAnsiStringToHeapUnicodeString(pActCtx->lpSource,
-                                          (LPWSTR*) &pActCtxW.lpSource);
+        len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpSource, -1, NULL, 0);
+        src = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+        if (!src) return INVALID_HANDLE_VALUE;
+        MultiByteToWideChar(CP_ACP, 0, pActCtx->lpSource, -1, src, len);
     }
-    if (pActCtx->lpAssemblyDirectory)
+    actw.lpSource = src;
+
+    if (actw.dwFlags & ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID)
+        actw.wProcessorArchitecture = pActCtx->wProcessorArchitecture;
+    if (actw.dwFlags & ACTCTX_FLAG_LANGID_VALID)
+        actw.wLangId = pActCtx->wLangId;
+    if (actw.dwFlags & ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID)
     {
-        BasepAnsiStringToHeapUnicodeString(pActCtx->lpAssemblyDirectory,
-                                          (LPWSTR*) &pActCtxW.lpAssemblyDirectory);
+        len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpAssemblyDirectory, -1, NULL, 0);
+        assdir = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+        if (!assdir) goto done;
+        MultiByteToWideChar(CP_ACP, 0, pActCtx->lpAssemblyDirectory, -1, assdir, len);
+        actw.lpAssemblyDirectory = assdir;
     }
-    if (HIWORD(pActCtx->lpResourceName))
+    if (actw.dwFlags & ACTCTX_FLAG_RESOURCE_NAME_VALID)
     {
-        BasepAnsiStringToHeapUnicodeString(pActCtx->lpResourceName,
-                                          (LPWSTR*) &pActCtxW.lpResourceName);
-    }
-    else
+        if ((ULONG_PTR)pActCtx->lpResourceName >> 16)
     {
-        pActCtxW.lpResourceName = (LPWSTR) pActCtx->lpResourceName;
+            len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpResourceName, -1, NULL, 0);
+            resname = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+            if (!resname) goto done;
+            MultiByteToWideChar(CP_ACP, 0, pActCtx->lpResourceName, -1, resname, len);
+            actw.lpResourceName = resname;
     }
-    if (pActCtx->lpApplicationName)
+        else actw.lpResourceName = (LPCWSTR)pActCtx->lpResourceName;
+    }
+    if (actw.dwFlags & ACTCTX_FLAG_APPLICATION_NAME_VALID)
     {
-        BasepAnsiStringToHeapUnicodeString(pActCtx->lpApplicationName,
-                                          (LPWSTR*) &pActCtxW.lpApplicationName);
+        len = MultiByteToWideChar(CP_ACP, 0, pActCtx->lpApplicationName, -1, NULL, 0);
+        appname = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+        if (!appname) goto done;
+        MultiByteToWideChar(CP_ACP, 0, pActCtx->lpApplicationName, -1, appname, len);
+        actw.lpApplicationName = appname;
     }
-    /* Call the Unicode function */
-    hRetVal = CreateActCtxW(&pActCtxW);
+    if (actw.dwFlags & ACTCTX_FLAG_HMODULE_VALID)
+        actw.hModule = pActCtx->hModule;
 
-    /* Clean up */
-    RtlFreeHeap(GetProcessHeap(), 0, (LPWSTR*) pActCtxW.lpSource);
-    RtlFreeHeap(GetProcessHeap(), 0, (LPWSTR*) pActCtxW.lpAssemblyDirectory);
-    if (HIWORD(pActCtx->lpResourceName))
-        RtlFreeHeap(GetProcessHeap(), 0, (LPWSTR*) pActCtxW.lpResourceName);
-    RtlFreeHeap(GetProcessHeap(), 0, (LPWSTR*) pActCtxW.lpApplicationName);
+    ret = CreateActCtxW(&actw);
 
-    return hRetVal;
+done:
+    HeapFree(GetProcessHeap(), 0, src);
+    HeapFree(GetProcessHeap(), 0, assdir);
+    HeapFree(GetProcessHeap(), 0, resname);
+    HeapFree(GetProcessHeap(), 0, appname);
+    return ret;
 }
 
-/*
- * @unimplemented
+/***********************************************************************
+ * CreateActCtxW (KERNEL32.@)
+ *
+ * Create an activation context.
  */
-BOOL
-WINAPI
-ActivateActCtx(
-    HANDLE hActCtx,
-    ULONG_PTR *ulCookie
-    )
+HANDLE WINAPI CreateActCtxW(PCACTCTXW pActCtx)
 {
-    NTSTATUS Status;
+    NTSTATUS    status;
+    HANDLE      hActCtx;
 
-    DPRINT("ActivateActCtx(%p %p)\n", hActCtx, ulCookie );
+    TRACE("%p %08x\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
 
-    Status = RtlActivateActivationContext(0, hActCtx, ulCookie);
-    if (!NT_SUCCESS(Status))
+    if ((status = RtlCreateActivationContext(&hActCtx, (PVOID*)pActCtx)))
     {
-        SetLastError(RtlNtStatusToDosError(Status));
+        SetLastError(RtlNtStatusToDosError(status));
+        return INVALID_HANDLE_VALUE;
+    }
+    return hActCtx;
+}
+
+/***********************************************************************
+ * ActivateActCtx (KERNEL32.@)
+ *
+ * Activate an activation context.
+ */
+BOOL WINAPI ActivateActCtx(HANDLE hActCtx, ULONG_PTR *ulCookie)
+{
+    NTSTATUS status;
+
+    if ((status = RtlActivateActivationContext( 0, hActCtx, ulCookie )))
+    {
+        SetLastError(RtlNtStatusToDosError(status));
         return FALSE;
     }
     return TRUE;
 }
 
-/*
- * @unimplemented
+/***********************************************************************
+ * DeactivateActCtx (KERNEL32.@)
+ *
+ * Deactivate an activation context.
  */
-VOID
-WINAPI
-AddRefActCtx(
-    HANDLE hActCtx
-    )
+BOOL WINAPI DeactivateActCtx(DWORD dwFlags, ULONG_PTR ulCookie)
 {
-    DPRINT("AddRefActCtx(%p)\n", hActCtx);
-    RtlAddRefActivationContext(hActCtx);
+    RtlDeactivateActivationContext( dwFlags, ulCookie );
+    return TRUE;
 }
 
-/*
- * @unimplemented
+/***********************************************************************
+ * GetCurrentActCtx (KERNEL32.@)
+ *
+ * Get the current activation context.
  */
-HANDLE
-WINAPI
-CreateActCtxW(
-    PCACTCTXW pActCtx
-    )
+BOOL WINAPI GetCurrentActCtx(HANDLE* phActCtx)
 {
-    NTSTATUS    Status;
-    HANDLE      hActCtx;
+    NTSTATUS status;
 
-    DPRINT("CreateActCtxW(%p %08lx)\n", pActCtx, pActCtx ? pActCtx->dwFlags : 0);
-
-    Status = RtlCreateActivationContext(&hActCtx, (PVOID*)&pActCtx);
-    if (!NT_SUCCESS(Status))
+    if ((status = RtlGetActiveActivationContext(phActCtx)))
     {
-        SetLastError(RtlNtStatusToDosError(Status));
-        return INVALID_HANDLE_VALUE;
+        SetLastError(RtlNtStatusToDosError(status));
+        return FALSE;
     }
-    return hActCtx;
+    return TRUE;
 }
 
-/*
- * @unimplemented
+/***********************************************************************
+ * AddRefActCtx (KERNEL32.@)
+ *
+ * Add a reference to an activation context.
  */
-BOOL
-WINAPI
-DeactivateActCtx(
-    DWORD dwFlags,
-    ULONG_PTR ulCookie
-    )
+void WINAPI AddRefActCtx(HANDLE hActCtx)
 {
-    NTSTATUS Status;
-
-    DPRINT("DeactivateActCtx(%08lx %08lx)\n", dwFlags, ulCookie);
-    Status = RtlDeactivateActivationContext(dwFlags, ulCookie);
-
-    if (!NT_SUCCESS(Status)) return FALSE;
+    RtlAddRefActivationContext(hActCtx);
+}
 
-    return TRUE;
+/***********************************************************************
+ * ReleaseActCtx (KERNEL32.@)
+ *
+ * Release a reference to an activation context.
+ */
+void WINAPI ReleaseActCtx(HANDLE hActCtx)
+{
+    RtlReleaseActivationContext(hActCtx);
 }
 
-/*
- * @unimplemented
+/***********************************************************************
+ * ZombifyActCtx (KERNEL32.@)
+ *
+ * Release a reference to an activation context.
  */
-BOOL
-WINAPI
-FindActCtxSectionGuid(
-    DWORD dwFlags,
-    const GUID *lpExtensionGuid,
-    ULONG ulSectionId,
-    const GUID *lpGuidToFind,
-    PACTCTX_SECTION_KEYED_DATA ReturnedData
-    )
+BOOL WINAPI ZombifyActCtx(HANDLE hActCtx)
 {
-    DPRINT("%s() is UNIMPLEMENTED!\n", __FUNCTION__);
+  FIXME("%p\n", hActCtx);
+  if (hActCtx != ACTCTX_FAKE_HANDLE)
     return FALSE;
+  return TRUE;
 }
 
-/*
- * @unimplemented
+/***********************************************************************
+ * FindActCtxSectionStringA (KERNEL32.@)
+ *
+ * Find information about a GUID in an activation context.
  */
-BOOL
-WINAPI
-FindActCtxSectionStringW(
-    DWORD dwFlags,
-    const GUID *lpExtensionGuid,
-    ULONG ulSectionId,
-    LPCWSTR lpStringToFind,
-    PACTCTX_SECTION_KEYED_DATA ReturnedData
-    )
+BOOL WINAPI FindActCtxSectionStringA(DWORD dwFlags, const GUID* lpExtGuid,
+                                    ULONG ulId, LPCSTR lpSearchStr,
+                                    PACTCTX_SECTION_KEYED_DATA pInfo)
 {
-    UNICODE_STRING us;
-    NTSTATUS Status;
+    LPWSTR  search_str;
+    DWORD   len;
+    BOOL    ret;
 
-    RtlInitUnicodeString(&us, lpStringToFind);
-    Status = RtlFindActivationContextSectionString(dwFlags, lpExtensionGuid, ulSectionId, &us, ReturnedData);
-    if (!NT_SUCCESS(Status))
+    TRACE("%08x %s %u %s %p\n", dwFlags, debugstr_guid(lpExtGuid),
+          ulId, debugstr_a(lpSearchStr), pInfo);
+
+    if (!lpSearchStr)
     {
-        SetLastError(RtlNtStatusToDosError(Status));
+        SetLastError(ERROR_INVALID_PARAMETER);
         return FALSE;
     }
-    return TRUE;
+
+    len = MultiByteToWideChar(CP_ACP, 0, lpSearchStr, -1, NULL, 0);
+    search_str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+    MultiByteToWideChar(CP_ACP, 0, lpSearchStr, -1, search_str, len);
+
+    ret = FindActCtxSectionStringW(dwFlags, lpExtGuid, ulId, search_str, pInfo);
+
+    HeapFree(GetProcessHeap(), 0, search_str);
+    return ret;
 }
 
-/*
- * @unimplemented
+/***********************************************************************
+ * FindActCtxSectionStringW (KERNEL32.@)
+ *
+ * Find information about a GUID in an activation context.
  */
-BOOL
-WINAPI
-GetCurrentActCtx(
-    HANDLE *phActCtx)
+BOOL WINAPI FindActCtxSectionStringW(DWORD dwFlags, const GUID* lpExtGuid,
+                                    ULONG ulId, LPCWSTR lpSearchStr,
+                                    PACTCTX_SECTION_KEYED_DATA pInfo)
 {
-    NTSTATUS Status;
+    UNICODE_STRING us;
+    NTSTATUS status;
 
-    DPRINT("GetCurrentActCtx(%p)\n", phActCtx);
-    Status = RtlGetActiveActivationContext(phActCtx);
-    if (!NT_SUCCESS(Status))
+    RtlInitUnicodeString(&us, lpSearchStr);
+    if ((status = RtlFindActivationContextSectionString(dwFlags, lpExtGuid, ulId, &us, pInfo)))
     {
-        SetLastError(RtlNtStatusToDosError(Status));
+        SetLastError(RtlNtStatusToDosError(status));
         return FALSE;
     }
     return TRUE;
 }
 
-/*
- * @unimplemented
+/***********************************************************************
+ * FindActCtxSectionGuid (KERNEL32.@)
+ *
+ * Find information about a GUID in an activation context.
  */
-BOOL
-WINAPI
-QueryActCtxW(
-    DWORD dwFlags,
-    HANDLE hActCtx,
-    PVOID pvSubInstance,
-    ULONG ulInfoClass,
-    PVOID pvBuffer,
-    SIZE_T cbBuffer OPTIONAL,
-    SIZE_T *pcbWrittenOrRequired OPTIONAL
-    )
+BOOL WINAPI FindActCtxSectionGuid(DWORD dwFlags, const GUID* lpExtGuid,
+                                  ULONG ulId, const GUID* lpSearchGuid,
+                                  PACTCTX_SECTION_KEYED_DATA pInfo)
 {
-    DPRINT("%s() is UNIMPLEMENTED!\n", __FUNCTION__);
-    /* this makes Adobe Photoshop 7.0 happy */
+  FIXME("%08x %s %u %s %p\n", dwFlags, debugstr_guid(lpExtGuid),
+       ulId, debugstr_guid(lpSearchGuid), pInfo);
     SetLastError( ERROR_CALL_NOT_IMPLEMENTED);
     return FALSE;
 }
 
-/*
- * @unimplemented
+/***********************************************************************
+ * QueryActCtxW (KERNEL32.@)
+ *
+ * Get information about an activation context.
  */
-VOID
-WINAPI
-ReleaseActCtx(
-    HANDLE hActCtx
-    )
+BOOL WINAPI QueryActCtxW(DWORD dwFlags, HANDLE hActCtx, PVOID pvSubInst,
+                         ULONG ulClass, PVOID pvBuff, SIZE_T cbBuff,
+                         SIZE_T *pcbLen)
 {
-    DPRINT("ReleaseActCtx(%p)\n", hActCtx);
-    RtlReleaseActivationContext(hActCtx);
-}
+    NTSTATUS status;
 
-/*
- * @unimplemented
- */
-BOOL
-WINAPI
-ZombifyActCtx(
-    HANDLE hActCtx
-    )
+    if ((status = RtlQueryInformationActivationContext( dwFlags, hActCtx, pvSubInst, ulClass,
+                                                        pvBuff, cbBuff, pcbLen )))
 {
-    NTSTATUS Status;
-    DPRINT("ZombifyActCtx(%p)\n", hActCtx);
-
-    Status = RtlZombifyActivationContext(hActCtx);
-    if (!NT_SUCCESS(Status))
-    {
-        SetLastError(RtlNtStatusToDosError(Status));
+        SetLastError(RtlNtStatusToDosError(status));
         return FALSE;
     }
-
     return TRUE;
 }