sxs.c File Reference

#include <stdio.h>
#include <windows.h>
#include <winsxs.h>
#include <corerror.h>
#include "shlwapi.h"
#include "wine/test.h"
#include "initguid.h"
#include "interfaces.h"

Include dependency graph for sxs.c:

Go to the source code of this file.

Classes
struct	_SXS_GUID_INFORMATION_CLR

Macros
#define	COBJMACROS
#define	SXS_LOOKUP_CLR_GUID_USE_ACTCTX   0x00000001
#define	SXS_LOOKUP_CLR_GUID_FIND_SURROGATE   0x00010000
#define	SXS_LOOKUP_CLR_GUID_FIND_CLR_CLASS   0x00020000
#define	SXS_LOOKUP_CLR_GUID_FIND_ANY   (SXS_LOOKUP_CLR_GUID_FIND_SURROGATE | SXS_LOOKUP_CLR_GUID_FIND_CLR_CLASS)
#define	SXS_GUID_INFORMATION_CLR_FLAG_IS_SURROGATE   0x00000001
#define	SXS_GUID_INFORMATION_CLR_FLAG_IS_CLASS   0x00000002

Typedefs
typedef struct _SXS_GUID_INFORMATION_CLR	SXS_GUID_INFORMATION_CLR

Functions
BOOL WINAPI	SxsLookupClrGuid (DWORD flags, GUID *clsid, HANDLE actctx, void *buffer, SIZE_T buffer_len, SIZE_T *buffer_len_required)
static BOOL	write_resource_file (const char *path_tmp, const char *name_res, const char *name_file, char *path_file)
static void	run_test (void)
static void	prepare_and_run_test (void)
static void	run_child_process (void)
static void	test_SxsLookupClrGuid (void)
	START_TEST (sxs)

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 21 of file sxs.c.

SXS_GUID_INFORMATION_CLR_FLAG_IS_CLASS

#define SXS_GUID_INFORMATION_CLR_FLAG_IS_CLASS   0x00000002

Definition at line 39 of file sxs.c.

SXS_GUID_INFORMATION_CLR_FLAG_IS_SURROGATE

#define SXS_GUID_INFORMATION_CLR_FLAG_IS_SURROGATE   0x00000001

Definition at line 38 of file sxs.c.

SXS_LOOKUP_CLR_GUID_FIND_ANY

#define SXS_LOOKUP_CLR_GUID_FIND_ANY   (SXS_LOOKUP_CLR_GUID_FIND_SURROGATE | SXS_LOOKUP_CLR_GUID_FIND_CLR_CLASS)

Definition at line 36 of file sxs.c.

SXS_LOOKUP_CLR_GUID_FIND_CLR_CLASS

#define SXS_LOOKUP_CLR_GUID_FIND_CLR_CLASS   0x00020000

Definition at line 35 of file sxs.c.

SXS_LOOKUP_CLR_GUID_FIND_SURROGATE

#define SXS_LOOKUP_CLR_GUID_FIND_SURROGATE   0x00010000

Definition at line 34 of file sxs.c.

SXS_LOOKUP_CLR_GUID_USE_ACTCTX

#define SXS_LOOKUP_CLR_GUID_USE_ACTCTX   0x00000001

Definition at line 33 of file sxs.c.

Typedef Documentation

SXS_GUID_INFORMATION_CLR

typedef struct _SXS_GUID_INFORMATION_CLR SXS_GUID_INFORMATION_CLR

Function Documentation

prepare_and_run_test()

static void prepare_and_run_test ( void  )

static

Definition at line 152 of file sxs.c.

{
    char path_tmp[MAX_PATH];
    char path_manifest_dll[MAX_PATH];
    char path_manifest_exe[MAX_PATH];
    BOOL success;
    ACTCTXA context = {0};
    ULONG_PTR cookie;
    HANDLE handle_context = INVALID_HANDLE_VALUE;
 
    GetTempPathA(MAX_PATH, path_tmp);
 
    if (!write_resource_file(path_tmp, "comtest_exe.manifest", "exe.manifest", path_manifest_exe))
    {
        ok(0, "Failed to create file for testing\n");
        goto cleanup;
    }
 
    if (!write_resource_file(path_tmp, "comtest_dll.manifest", "comtest.manifest", path_manifest_dll))
    {
        ok(0, "Failed to create file for testing\n");
        goto cleanup;
    }
 
    context.cbSize = sizeof(ACTCTXA);
    context.lpSource = path_manifest_exe;
    context.lpAssemblyDirectory = path_tmp;
    context.dwFlags = ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID;
 
    handle_context = CreateActCtxA(&context);
    ok(handle_context != INVALID_HANDLE_VALUE, "CreateActCtxA failed: %ld\n", GetLastError());
 
    if (handle_context == INVALID_HANDLE_VALUE)
    {
        ok(0, "Failed to create activation context\n");
        goto cleanup;
    }
 
    success = ActivateActCtx(handle_context, &cookie);
    ok(success, "ActivateActCtx failed: %ld\n", GetLastError());
 
    run_test();
 
cleanup:
    if (handle_context != INVALID_HANDLE_VALUE)
    {
        success = DeactivateActCtx(0, cookie);
        ok(success, "DeactivateActCtx failed: %ld\n", GetLastError());
        ReleaseActCtx(handle_context);
    }
    if (*path_manifest_exe)
    {
        success = DeleteFileA(path_manifest_exe);
        ok(success, "DeleteFileA failed: %ld\n", GetLastError());
    }
    if(*path_manifest_dll)
    {
        success = DeleteFileA(path_manifest_dll);
        ok(success, "DeleteFileA failed: %ld\n", GetLastError());
    }
}

Referenced by START_TEST().

run_child_process()

static void run_child_process ( void  )

static

Definition at line 214 of file sxs.c.

{
    char cmdline[MAX_PATH];
    char exe[MAX_PATH];
    char **argv;
    PROCESS_INFORMATION pi;
    STARTUPINFOA si = { 0 };
    BOOL ret;
 
    winetest_get_mainargs(&argv);
 
    if (strstr(argv[0], ".exe"))
        sprintf(exe, "%s", argv[0]);
    else
        sprintf(exe, "%s.exe", argv[0]);
    sprintf(cmdline, "\"%s\" %s %s", argv[0], argv[1], "subtest");
 
    si.cb = sizeof(si);
    ret = CreateProcessA(exe, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
    ok(ret, "Could not create process: %lu\n", GetLastError());
 
    wait_child_process(pi.hProcess);
 
    CloseHandle(pi.hThread);
    CloseHandle(pi.hProcess);
}

Referenced by test_SxsLookupClrGuid().

run_test()

static void run_test ( void  )

static

Definition at line 82 of file sxs.c.

{
    SIZE_T buffer_size;
    BOOL ret;
    SXS_GUID_INFORMATION_CLR *info;
 
    SetLastError(0xdeadbeef);
    ret = SxsLookupClrGuid(SXS_LOOKUP_CLR_GUID_FIND_ANY | SXS_LOOKUP_CLR_GUID_USE_ACTCTX, (GUID *)&CLSID_Test,
            NULL, NULL, 0, &buffer_size);
    ok(!ret, "Unexpected return value %d.\n", ret);
    ok(GetLastError() == ERROR_NOT_FOUND, "Unexpected error %ld.\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    ret = SxsLookupClrGuid(SXS_LOOKUP_CLR_GUID_FIND_ANY | SXS_LOOKUP_CLR_GUID_USE_ACTCTX, (GUID *)&CLSID_Test,
            NULL, NULL, 0, &buffer_size);
    ok(!ret, "Unexpected return value %d.\n", ret);
    ok(GetLastError() == ERROR_NOT_FOUND, "Unexpected error %ld.\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    ret = SxsLookupClrGuid(SXS_LOOKUP_CLR_GUID_FIND_ANY, (GUID*)&CLSID_Test, NULL, NULL, 0, &buffer_size);
    ok(!ret, "Unexpected return value %d.\n", ret);
    ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Got %ld\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    ret = SxsLookupClrGuid(SXS_LOOKUP_CLR_GUID_FIND_CLR_CLASS, (GUID*)&CLSID_Test, NULL, NULL, 0, &buffer_size);
    ok(ret == FALSE, "Got %d\n", ret);
    ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Got %ld\n", GetLastError());
 
    info = malloc(buffer_size);
    SetLastError(0xdeadbeef);
    ret = SxsLookupClrGuid(SXS_LOOKUP_CLR_GUID_FIND_CLR_CLASS, (GUID*)&CLSID_Test, NULL, info, buffer_size, &buffer_size);
    ok(ret == TRUE, "Got %d\n", ret);
    ok(GetLastError() == 0, "Got %ld\n", GetLastError());
 
    ok(info->dwFlags == SXS_GUID_INFORMATION_CLR_FLAG_IS_CLASS, "Got %ld\n", info->dwFlags);
    ok(!lstrcmpW(info->pcwszTypeName, L"DLL.Test"), "Unexpected typename %s.\n", wine_dbgstr_w(info->pcwszTypeName));
    ok(!lstrcmpW(info->pcwszAssemblyIdentity, L"comtest,type=\"win32\",version=\"1.0.0.0\""),
           "Unexpected assembly identity %s.\n", wine_dbgstr_w(info->pcwszAssemblyIdentity));
    ok(!lstrcmpW(info->pcwszRuntimeVersion, L"v4.0.0.0"), "Unexpected runtime version %s.\n",
           wine_dbgstr_w(info->pcwszRuntimeVersion));
 
    free(info);
 
    SetLastError(0xdeadbeef);
    ret = SxsLookupClrGuid(SXS_LOOKUP_CLR_GUID_FIND_SURROGATE, (GUID *)&CLSID_SurrogateTest, NULL, NULL, 0, &buffer_size);
    ok(!ret, "Unexpected return value %d.\n", ret);
    ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Got %ld\n", GetLastError());
 
    info = malloc(buffer_size);
    SetLastError(0xdeadbeef);
    ret = SxsLookupClrGuid(SXS_LOOKUP_CLR_GUID_FIND_SURROGATE, (GUID *)&CLSID_SurrogateTest, NULL, info,
            buffer_size, &buffer_size);
    ok(ret, "Unexpected return value %d.\n", ret);
    ok(GetLastError() == 0, "Got %ld\n", GetLastError());
 
    ok(info->dwFlags == SXS_GUID_INFORMATION_CLR_FLAG_IS_SURROGATE, "Unexpected flags %#lx.\n", info->dwFlags);
    ok(!lstrcmpW(info->pcwszTypeName, L"Surrogate.Test"), "Unexpected typename %s.\n", wine_dbgstr_w(info->pcwszTypeName));
    ok(!lstrcmpW(info->pcwszAssemblyIdentity, L"comtest,type=\"win32\",version=\"1.0.0.0\""),
           "Unexpected assembly identity %s.\n", wine_dbgstr_w(info->pcwszAssemblyIdentity));
    ok(!lstrcmpW(info->pcwszRuntimeVersion, L"v4.0.0.1"), "Unexpected runtime version %s.\n",
           wine_dbgstr_w(info->pcwszRuntimeVersion));
 
    free(info);
 
    SetLastError(0xdeadbeef);
    ret = SxsLookupClrGuid(SXS_LOOKUP_CLR_GUID_FIND_ANY, (GUID *)&CLSID_SurrogateTest, NULL, NULL, 0, &buffer_size);
    ok(!ret, "Unexpected return value %d.\n", ret);
    ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Got %ld\n", GetLastError());
}

Referenced by prepare_and_run_test().

START_TEST()

START_TEST

(

sxs

)

Definition at line 265 of file sxs.c.

{
    char **argv;
    int argc = winetest_get_mainargs(&argv);
    if (argc > 2)
    {
        prepare_and_run_test();
        return;
    }
 
    test_SxsLookupClrGuid();
}

SxsLookupClrGuid()

BOOL WINAPI SxsLookupClrGuid	(	DWORD	flags,
		GUID *	clsid,
		HANDLE	actctx,
		void *	buffer,
		SIZE_T	buffer_len,
		SIZE_T *	buffer_len_required
	)

Definition at line 94 of file sxs.c.

{
    ACTCTX_SECTION_KEYED_DATA guid_info = { sizeof(ACTCTX_SECTION_KEYED_DATA) };
    ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION *assembly_info = NULL;
    SIZE_T bytes_assembly_info;
    unsigned int len_version = 0, len_name, len_identity;
    const void *ptr_name, *ptr_version, *ptr_identity;
    SXS_GUID_INFORMATION_CLR *ret = buffer;
    BOOL retval = FALSE;
    char *ret_strings;
    ULONG_PTR cookie;
 
    TRACE("%#lx, %s, %p, %p, %Ix, %p.\n", flags, wine_dbgstr_guid(clsid), actctx,
          buffer, buffer_len, buffer_len_required);
 
    if (flags & SXS_LOOKUP_CLR_GUID_USE_ACTCTX)
    {
        if (!ActivateActCtx(actctx, &cookie))
        {
            WARN("Failed to activate context.\n");
            return FALSE;
        }
    }
 
    if (flags & SXS_LOOKUP_CLR_GUID_FIND_SURROGATE)
    {
        if ((retval = FindActCtxSectionGuid(FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX, NULL,
                ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES, clsid, &guid_info)))
        {
            flags &= ~SXS_LOOKUP_CLR_GUID_FIND_CLR_CLASS;
        }
    }
 
    if (!retval && (flags & SXS_LOOKUP_CLR_GUID_FIND_CLR_CLASS))
    {
        if ((retval = FindActCtxSectionGuid(FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX, NULL,
                ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION, clsid, &guid_info)))
        {
            flags &= ~SXS_LOOKUP_CLR_GUID_FIND_SURROGATE;
        }
    }
 
    if (!retval)
    {
        SetLastError(ERROR_NOT_FOUND);
        goto out;
    }
 
    retval = QueryActCtxW(0, guid_info.hActCtx, &guid_info.ulAssemblyRosterIndex,
            AssemblyDetailedInformationInActivationContext, NULL, 0, &bytes_assembly_info);
    if (!retval && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
    {
        goto out;
    }
 
    assembly_info = malloc(bytes_assembly_info);
    if (!(retval = QueryActCtxW(0, guid_info.hActCtx, &guid_info.ulAssemblyRosterIndex,
            AssemblyDetailedInformationInActivationContext, assembly_info,
            bytes_assembly_info, &bytes_assembly_info)))
    {
        goto out;
    }
 
    if (flags & SXS_LOOKUP_CLR_GUID_FIND_CLR_CLASS)
    {
        const struct comclassredirect_data *redirect_data = guid_info.lpData;
        const struct clrclass_data *class_data;
 
        class_data = (void *)((char *)redirect_data + redirect_data->clrdata_offset);
        ptr_name = (char *)class_data + class_data->name_offset;
        ptr_version = (char *)class_data + class_data->version_offset;
        len_name = class_data->name_len + sizeof(WCHAR);
        if (class_data->version_len)
            len_version = class_data->version_len + sizeof(WCHAR);
    }
    else
    {
        const struct clrsurrogate_data *surrogate = guid_info.lpData;
        ptr_name = (char *)surrogate + surrogate->name_offset;
        ptr_version = (char *)surrogate + surrogate->version_offset;
        len_name = surrogate->name_len + sizeof(WCHAR);
        if (surrogate->version_len)
            len_version = surrogate->version_len + sizeof(WCHAR);
    }
 
    ptr_identity = assembly_info->lpAssemblyEncodedAssemblyIdentity;
    len_identity = assembly_info->ulEncodedAssemblyIdentityLength + sizeof(WCHAR);
 
    *buffer_len_required = sizeof(*ret) + len_identity + len_version + len_name;
    if (!buffer || buffer_len < *buffer_len_required)
    {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        retval = FALSE;
        goto out;
    }
 
    ret->cbSize = sizeof(*ret);
    ret->dwFlags = flags & SXS_LOOKUP_CLR_GUID_FIND_CLR_CLASS ? SXS_GUID_INFORMATION_CLR_FLAG_IS_CLASS :
            SXS_GUID_INFORMATION_CLR_FLAG_IS_SURROGATE;
 
    /* Copy strings into buffer */
    ret_strings = (char *)ret + sizeof(*ret);
 
    memcpy(ret_strings, ptr_identity, len_identity);
    ret->pcwszAssemblyIdentity = (WCHAR *)ret_strings;
    ret_strings += len_identity;
 
    memcpy(ret_strings, ptr_name, len_name);
    ret->pcwszTypeName = (WCHAR *)ret_strings;
    ret_strings += len_name;
 
    if (len_version > 0)
    {
        memcpy(ret_strings, ptr_version, len_version);
        ret->pcwszRuntimeVersion = (WCHAR *)ret_strings;
    }
    else
        ret->pcwszRuntimeVersion = NULL;
 
    SetLastError(0);
 
out:
    ReleaseActCtx(guid_info.hActCtx);
 
    if (flags & SXS_LOOKUP_CLR_GUID_USE_ACTCTX)
        DeactivateActCtx(0, cookie);
 
    free(assembly_info);
    return retval;
}

Referenced by run_test(), and test_SxsLookupClrGuid().

test_SxsLookupClrGuid()

static void test_SxsLookupClrGuid ( void  )

static

Definition at line 241 of file sxs.c.

{
    SIZE_T buffer_size;
    BOOL ret;
 
    SetLastError(0xdeadbeef);
    ret = SxsLookupClrGuid(SXS_LOOKUP_CLR_GUID_FIND_CLR_CLASS, (GUID*)&CLSID_Test, NULL, NULL, 0, &buffer_size);
    ok(ret == FALSE, "Expected FALSE, got %d\n", ret);
    ok(GetLastError() == ERROR_NOT_FOUND, "Expected ERROR_NOT_FOUND, got %ld\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    ret = SxsLookupClrGuid(SXS_LOOKUP_CLR_GUID_FIND_CLR_CLASS | SXS_LOOKUP_CLR_GUID_USE_ACTCTX, (GUID *)&CLSID_Test,
            NULL, NULL, 0, &buffer_size);
    ok(!ret, "Unexpected return value %d.\n", ret);
    ok(GetLastError() == ERROR_NOT_FOUND, "Expected ERROR_NOT_FOUND, got %ld\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    ret = SxsLookupClrGuid(SXS_LOOKUP_CLR_GUID_FIND_SURROGATE, (GUID *)&CLSID_Test, NULL, NULL, 0, &buffer_size);
    ok(!ret, "Unexpected return value %d.\n", ret);
    ok(GetLastError() == ERROR_NOT_FOUND, "Expected ERROR_NOT_FOUND, got %ld\n", GetLastError());
 
    run_child_process();
}

Referenced by START_TEST().

write_resource_file()

static BOOL write_resource_file ( const char *  path_tmp, const char *  name_res, const char *  name_file, char *  path_file  )

static

Definition at line 53 of file sxs.c.

{
    HRSRC rsrc;
    void *rsrc_data;
    DWORD rsrc_size;
    BOOL ret;
    HANDLE hfile;
 
    path_file[0] = 0;
    rsrc = FindResourceA(GetModuleHandleA(NULL), name_res, (LPCSTR)RT_RCDATA);
    if (!rsrc) return FALSE;
 
    rsrc_data = LockResource(LoadResource(GetModuleHandleA(NULL), rsrc));
    if (!rsrc_data) return FALSE;
 
    rsrc_size = SizeofResource(GetModuleHandleA(NULL), rsrc);
    if (!rsrc_size) return FALSE;
 
    strcpy(path_file, path_tmp);
    PathAppendA(path_file, name_file);
    hfile = CreateFileA(path_file, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
    if (hfile == INVALID_HANDLE_VALUE) return FALSE;
 
    ret = WriteFile(hfile, rsrc_data, rsrc_size, &rsrc_size, NULL);
 
    CloseHandle(hfile);
    return ret;
}

Referenced by prepare_and_run_test().