usrmarshal.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "objbase.h"
#include "objidl.h"
#include "wine/test.h"

Include dependency graph for usrmarshal.c:

Go to the source code of this file.

Classes
struct	host_object_data
struct	TestUnknown
struct	test_stream
struct	obj

Macros
#define	COBJMACROS
#define	CONST_VTABLE
#define	RELEASEMARSHALDATA   WM_USER
#define	USER_MARSHAL_PTR_PREFIX

Functions
ULONG __RPC_USER	HMETAFILE_UserSize (ULONG *, ULONG, HMETAFILE *)
unsigned char *__RPC_USER	HMETAFILE_UserMarshal (ULONG *, unsigned char *, HMETAFILE *)
unsigned char *__RPC_USER	HMETAFILE_UserUnmarshal (ULONG *, unsigned char *, HMETAFILE *)
void __RPC_USER	HMETAFILE_UserFree (ULONG *, HMETAFILE *)
ULONG __RPC_USER	HENHMETAFILE_UserSize (ULONG *, ULONG, HENHMETAFILE *)
unsigned char *__RPC_USER	HENHMETAFILE_UserMarshal (ULONG *, unsigned char *, HENHMETAFILE *)
unsigned char *__RPC_USER	HENHMETAFILE_UserUnmarshal (ULONG *, unsigned char *, HENHMETAFILE *)
void __RPC_USER	HENHMETAFILE_UserFree (ULONG *, HENHMETAFILE *)
ULONG __RPC_USER	HMETAFILEPICT_UserSize (ULONG *, ULONG, HMETAFILEPICT *)
unsigned char *__RPC_USER	HMETAFILEPICT_UserMarshal (ULONG *, unsigned char *, HMETAFILEPICT *)
unsigned char *__RPC_USER	HMETAFILEPICT_UserUnmarshal (ULONG *, unsigned char *, HMETAFILEPICT *)
void __RPC_USER	HMETAFILEPICT_UserFree (ULONG *, HMETAFILEPICT *)
ULONG __RPC_USER	HBRUSH_UserSize (ULONG *, ULONG, HBRUSH *)
unsigned char *__RPC_USER	HBRUSH_UserMarshal (ULONG *, unsigned char *, HBRUSH *)
unsigned char *__RPC_USER	HBRUSH_UserUnmarshal (ULONG *, unsigned char *, HBRUSH *)
void __RPC_USER	HBRUSH_UserFree (ULONG *, HBRUSH *)
static void *WINAPI	user_allocate (SIZE_T size)
static void WINAPI	user_free (void *p)
static void	init_user_marshal_cb (USER_MARSHAL_CB *umcb, PMIDL_STUB_MESSAGE stub_msg, PRPC_MESSAGE rpc_msg, unsigned char *buffer, unsigned int size, MSHCTX context)
static DWORD CALLBACK	host_object_proc (LPVOID p)
static DWORD	start_host_object2 (IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, IMessageFilter *filter, HANDLE *thread)
static void	end_host_object (DWORD tid, HANDLE thread)
static void	test_marshal_CLIPFORMAT (void)
static void	test_marshal_HWND (void)
static void	test_marshal_HGLOBAL (void)
static HENHMETAFILE	create_emf (void)
static void	test_marshal_HENHMETAFILE (void)
static HMETAFILE	create_mf (void)
static void	test_marshal_HMETAFILE (void)
static void	test_marshal_HMETAFILEPICT (void)
static TestUnknown *	impl_from_IUnknown (IUnknown *iface)
static HRESULT WINAPI	Test_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppvObj)
static ULONG WINAPI	Test_IUnknown_AddRef (LPUNKNOWN iface)
static ULONG WINAPI	Test_IUnknown_Release (LPUNKNOWN iface)
static struct test_stream *	impl_from_IStream (IStream *iface)
static HRESULT WINAPI	Test_IStream_QueryInterface (IStream *iface, REFIID riid, LPVOID *ppvObj)
static ULONG WINAPI	Test_IStream_AddRef (IStream *iface)
static ULONG WINAPI	Test_IStream_Release (IStream *iface)
ULONG __RPC_USER	WdtpInterfacePointer_UserSize (ULONG *, ULONG, ULONG, IUnknown *, REFIID)
unsigned char *__RPC_USER	WdtpInterfacePointer_UserMarshal (ULONG *, ULONG, unsigned char *, IUnknown *, REFIID)
unsigned char *__RPC_USER	WdtpInterfacePointer_UserUnmarshal (ULONG *, unsigned char *, IUnknown **, REFIID)
static void	marshal_WdtpInterfacePointer (DWORD umcb_ctx, DWORD ctx, BOOL client, BOOL in, BOOL out)
static void	test_marshal_WdtpInterfacePointer (void)
static void	marshal_STGMEDIUM (BOOL client, BOOL in, BOOL out)
static void	test_marshal_STGMEDIUM (void)
static void	test_marshal_SNB (void)
static void	test_marshal_HDC (void)
static void	test_marshal_HICON (void)
static void	test_marshal_HBRUSH (void)
static void	test_marshal_HBITMAP (void)
static HRESULT WINAPI	obj_QueryInterface (IDataObject *iface, REFIID iid, void **obj)
static ULONG WINAPI	obj_AddRef (IDataObject *iface)
static ULONG WINAPI	obj_Release (IDataObject *iface)
static HRESULT WINAPI	obj_DO_GetDataHere (IDataObject *iface, FORMATETC *fmt, STGMEDIUM *med)
static void	test_GetDataHere_Proxy (void)
	START_TEST (usrmarshal)

Variables
static BOOL	g_expect_user_alloc
static BOOL	g_expect_user_free
static const char	cf_marshaled []
static const IUnknownVtbl	TestUnknown_Vtbl
static const IStreamVtbl	TestStream_Vtbl
static TestUnknown	Test_Unknown = { {&TestUnknown_Vtbl}, 1 }
static TestUnknown	Test_Unknown2 = { {&TestUnknown_Vtbl}, 1 }
static struct test_stream	Test_Stream = { {&TestStream_Vtbl}, 1 }
static struct test_stream	Test_Stream2 = { {&TestStream_Vtbl}, 1 }
static const IDataObjectVtbl	obj_data_object_vtbl
static struct obj	obj

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 21 of file usrmarshal.c.

CONST_VTABLE

#define CONST_VTABLE

Definition at line 22 of file usrmarshal.c.

RELEASEMARSHALDATA

#define RELEASEMARSHALDATA   WM_USER

Definition at line 88 of file usrmarshal.c.

USER_MARSHAL_PTR_PREFIX

#define USER_MARSHAL_PTR_PREFIX

Value:

  ( (DWORD)'U'         | ( (DWORD)'s' << 8 ) | \
  ( (DWORD)'e' << 16 ) | ( (DWORD)'r' << 24 ) )

Definition at line 480 of file usrmarshal.c.

Function Documentation

create_emf()

static HENHMETAFILE create_emf ( void  )

static

Definition at line 337 of file usrmarshal.c.

{
    const RECT rect = {0, 0, 100, 100};
    HDC hdc = CreateEnhMetaFileA(NULL, NULL, &rect, "HENHMETAFILE Marshaling Test\0Test\0\0");
    ExtTextOutA(hdc, 0, 0, ETO_OPAQUE, &rect, "Test String", strlen("Test String"), NULL);
    return CloseEnhMetaFile(hdc);
}

Referenced by test_marshal_HENHMETAFILE().

create_mf()

static HMETAFILE create_mf ( void  )

static

Definition at line 411 of file usrmarshal.c.

{
    RECT rect = {0, 0, 100, 100};
    HDC hdc = CreateMetaFileA(NULL);
    ExtTextOutA(hdc, 0, 0, ETO_OPAQUE, &rect, "Test String", strlen("Test String"), NULL);
    return CloseMetaFile(hdc);
}

Referenced by test_marshal_HMETAFILE(), and test_marshal_HMETAFILEPICT().

end_host_object()

static void end_host_object ( DWORD  tid, HANDLE  thread  )

static

Definition at line 164 of file usrmarshal.c.

{
    BOOL ret = PostThreadMessageA(tid, WM_QUIT, 0, 0);
    ok(ret, "PostThreadMessage failed with error %d\n", GetLastError());
    /* be careful of races - don't return until hosting thread has terminated */
    ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
    CloseHandle(thread);
}

Referenced by test_GetDataHere_Proxy().

HBRUSH_UserFree()

void __RPC_USER HBRUSH_UserFree	(	ULONG *	,
		HBRUSH *
	)

Referenced by test_marshal_HBRUSH().

HBRUSH_UserMarshal()

unsigned char *__RPC_USER HBRUSH_UserMarshal	(	ULONG *	,
		unsigned char *	,
		HBRUSH *
	)

Referenced by test_marshal_HBRUSH().

HBRUSH_UserSize()

ULONG __RPC_USER HBRUSH_UserSize	(	ULONG *	,
		ULONG	,
		HBRUSH *
	)

Referenced by test_marshal_HBRUSH().

HBRUSH_UserUnmarshal()

unsigned char *__RPC_USER HBRUSH_UserUnmarshal	(	ULONG *	,
		unsigned char *	,
		HBRUSH *
	)

Referenced by test_marshal_HBRUSH().

HENHMETAFILE_UserFree()

void __RPC_USER HENHMETAFILE_UserFree	(	ULONG *	pFlags,
		HENHMETAFILE *	phEmf
	)

Definition at line 1265 of file usrmarshal.c.

{
    TRACE("(%s, &%p\n", debugstr_user_flags(pFlags), *phEmf);
 
    if (LOWORD(*pFlags) != MSHCTX_INPROC)
        DeleteEnhMetaFile(*phEmf);
}

Referenced by test_marshal_HENHMETAFILE().

HENHMETAFILE_UserMarshal()

unsigned char *__RPC_USER HENHMETAFILE_UserMarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		HENHMETAFILE *	phEmf
	)

Definition at line 1142 of file usrmarshal.c.

{
    TRACE("(%s, %p, &%p\n", debugstr_user_flags(pFlags), pBuffer, *phEmf);
 
    ALIGN_POINTER(pBuffer, 3);
 
    if (LOWORD(*pFlags) == MSHCTX_INPROC)
    {
        if (sizeof(*phEmf) == 8)
            *(ULONG *)pBuffer = WDT_INPROC64_CALL;
        else
            *(ULONG *)pBuffer = WDT_INPROC_CALL;
        pBuffer += sizeof(ULONG);
        *(HENHMETAFILE *)pBuffer = *phEmf;
        pBuffer += sizeof(HENHMETAFILE);
    }
    else
    {
        *(ULONG *)pBuffer = WDT_REMOTE_CALL;
        pBuffer += sizeof(ULONG);
        *(ULONG *)pBuffer = (ULONG)(ULONG_PTR)*phEmf;
        pBuffer += sizeof(ULONG);
    
        if (*phEmf)
        {
            UINT emfsize = GetEnhMetaFileBits(*phEmf, 0, NULL);
    
            *(ULONG *)pBuffer = emfsize;
            pBuffer += sizeof(ULONG);
            *(ULONG *)pBuffer = emfsize;
            pBuffer += sizeof(ULONG);
            GetEnhMetaFileBits(*phEmf, emfsize, pBuffer);
            pBuffer += emfsize;
        }
    }
 
    return pBuffer;
}

Referenced by STGMEDIUM_UserMarshal(), and test_marshal_HENHMETAFILE().

HENHMETAFILE_UserSize()

ULONG __RPC_USER HENHMETAFILE_UserSize	(	ULONG *	pFlags,
		ULONG	size,
		HENHMETAFILE *	phEmf
	)

Definition at line 1097 of file usrmarshal.c.

{
    TRACE("(%s, %d, %p\n", debugstr_user_flags(pFlags), size, *phEmf);
 
    ALIGN_LENGTH(size, 3);
 
    size += sizeof(ULONG);
    if (LOWORD(*pFlags) == MSHCTX_INPROC)
        size += sizeof(ULONG_PTR);
    else
    {
        size += sizeof(ULONG);
 
        if (*phEmf)
        {
            UINT emfsize;
    
            size += 2 * sizeof(ULONG);
            emfsize = GetEnhMetaFileBits(*phEmf, 0, NULL);
            size += emfsize;
        }
    }
 
    return size;
}

Referenced by STGMEDIUM_UserSize(), and test_marshal_HENHMETAFILE().

HENHMETAFILE_UserUnmarshal()

unsigned char *__RPC_USER HENHMETAFILE_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		HENHMETAFILE *	phEmf
	)

Definition at line 1200 of file usrmarshal.c.

{
    ULONG fContext;
 
    TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, phEmf);
 
    ALIGN_POINTER(pBuffer, 3);
 
    fContext = *(ULONG *)pBuffer;
    pBuffer += sizeof(ULONG);
 
    if (((fContext == WDT_INPROC_CALL) && (sizeof(*phEmf) < 8)) ||
        ((fContext == WDT_INPROC64_CALL) && (sizeof(*phEmf) == 8)))
    {
        *phEmf = *(HENHMETAFILE *)pBuffer;
        pBuffer += sizeof(*phEmf);
    }
    else if (fContext == WDT_REMOTE_CALL)
    {
        ULONG handle;
 
        handle = *(ULONG *)pBuffer;
        pBuffer += sizeof(ULONG);
 
        if (handle)
        {
            ULONG size;
            size = *(ULONG *)pBuffer;
            pBuffer += sizeof(ULONG);
            if (size != *(ULONG *)pBuffer)
            {
                RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
                return pBuffer;
            }
            pBuffer += sizeof(ULONG);
            *phEmf = SetEnhMetaFileBits(size, pBuffer);
            pBuffer += size;
        }
        else 
            *phEmf = NULL;
    }
    else
        RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 
    return pBuffer;
}

Referenced by STGMEDIUM_UserUnmarshal(), and test_marshal_HENHMETAFILE().

HMETAFILE_UserFree()

void __RPC_USER HMETAFILE_UserFree	(	ULONG *	pFlags,
		HMETAFILE *	phmf
	)

Definition at line 1069 of file usrmarshal.c.

{
    TRACE("(%s, &%p\n", debugstr_user_flags(pFlags), *phmf);
 
    if (LOWORD(*pFlags) != MSHCTX_INPROC)
        DeleteMetaFile(*phmf);
}

Referenced by HMETAFILEPICT_UserFree(), and test_marshal_HMETAFILE().

HMETAFILE_UserMarshal()

unsigned char *__RPC_USER HMETAFILE_UserMarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		HMETAFILE *	phmf
	)

Definition at line 946 of file usrmarshal.c.

{
    TRACE("(%s, %p, &%p\n", debugstr_user_flags(pFlags), pBuffer, *phmf);
 
    ALIGN_POINTER(pBuffer, 3);
 
    if (LOWORD(*pFlags) == MSHCTX_INPROC)
    {
        if (sizeof(*phmf) == 8)
            *(ULONG *)pBuffer = WDT_INPROC64_CALL;
        else
            *(ULONG *)pBuffer = WDT_INPROC_CALL;
        pBuffer += sizeof(ULONG);
        *(HMETAFILE *)pBuffer = *phmf;
        pBuffer += sizeof(HMETAFILE);
    }
    else
    {
        *(ULONG *)pBuffer = WDT_REMOTE_CALL;
        pBuffer += sizeof(ULONG);
        *(ULONG *)pBuffer = (ULONG)(ULONG_PTR)*phmf;
        pBuffer += sizeof(ULONG);
 
        if (*phmf)
        {
            UINT mfsize = GetMetaFileBitsEx(*phmf, 0, NULL);
 
            *(ULONG *)pBuffer = mfsize;
            pBuffer += sizeof(ULONG);
            *(ULONG *)pBuffer = mfsize;
            pBuffer += sizeof(ULONG);
            GetMetaFileBitsEx(*phmf, mfsize, pBuffer);
            pBuffer += mfsize;
        }
    }
 
    return pBuffer;
}

Referenced by HMETAFILEPICT_UserMarshal(), and test_marshal_HMETAFILE().

HMETAFILE_UserSize()

ULONG __RPC_USER HMETAFILE_UserSize	(	ULONG *	pFlags,
		ULONG	StartingSize,
		HMETAFILE *	phmf
	)

Definition at line 899 of file usrmarshal.c.

{
    ULONG size = StartingSize;
 
    TRACE("(%s, %d, &%p\n", debugstr_user_flags(pFlags), StartingSize, *phmf);
 
    ALIGN_LENGTH(size, 3);
 
    size += sizeof(ULONG);
    if (LOWORD(*pFlags) == MSHCTX_INPROC)
        size += sizeof(ULONG_PTR);
    else
    {
        size += sizeof(ULONG);
 
        if (*phmf)
        {
            UINT mfsize;
 
            size += 2 * sizeof(ULONG);
            mfsize = GetMetaFileBitsEx(*phmf, 0, NULL);
            size += mfsize;
        }
    }
 
    return size;
}

Referenced by HMETAFILEPICT_UserSize(), and test_marshal_HMETAFILE().

HMETAFILE_UserUnmarshal()

unsigned char *__RPC_USER HMETAFILE_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		HMETAFILE *	phmf
	)

Definition at line 1004 of file usrmarshal.c.

{
    ULONG fContext;
 
    TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, phmf);
 
    ALIGN_POINTER(pBuffer, 3);
 
    fContext = *(ULONG *)pBuffer;
    pBuffer += sizeof(ULONG);
 
    if (((fContext == WDT_INPROC_CALL) && (sizeof(*phmf) < 8)) ||
        ((fContext == WDT_INPROC64_CALL) && (sizeof(*phmf) == 8)))
    {
        *phmf = *(HMETAFILE *)pBuffer;
        pBuffer += sizeof(*phmf);
    }
    else if (fContext == WDT_REMOTE_CALL)
    {
        ULONG handle;
 
        handle = *(ULONG *)pBuffer;
        pBuffer += sizeof(ULONG);
 
        if (handle)
        {
            ULONG size;
            size = *(ULONG *)pBuffer;
            pBuffer += sizeof(ULONG);
            if (size != *(ULONG *)pBuffer)
            {
                RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
                return pBuffer;
            }
            pBuffer += sizeof(ULONG);
            *phmf = SetMetaFileBitsEx(size, pBuffer);
            pBuffer += size;
        }
        else
            *phmf = NULL;
    }
    else
        RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 
    return pBuffer;
}

Referenced by HMETAFILEPICT_UserUnmarshal(), and test_marshal_HMETAFILE().

HMETAFILEPICT_UserFree()

void __RPC_USER HMETAFILEPICT_UserFree	(	ULONG *	pFlags,
		HMETAFILEPICT *	phMfp
	)

Definition at line 1477 of file usrmarshal.c.

{
    TRACE("(%s, &%p)\n", debugstr_user_flags(pFlags), *phMfp);
 
    if ((LOWORD(*pFlags) != MSHCTX_INPROC) && *phMfp)
    {
        METAFILEPICT *mfpict;
 
        mfpict = GlobalLock(*phMfp);
        /* FIXME: raise an exception if mfpict is NULL? */
        HMETAFILE_UserFree(pFlags, &mfpict->hMF);
        GlobalUnlock(*phMfp);
 
        GlobalFree(*phMfp);
    }
}

Referenced by test_marshal_HMETAFILEPICT().

HMETAFILEPICT_UserMarshal()

unsigned char *__RPC_USER HMETAFILEPICT_UserMarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		HMETAFILEPICT *	phMfp
	)

Definition at line 1343 of file usrmarshal.c.

{
    TRACE("(%s, %p, &%p)\n", debugstr_user_flags(pFlags), pBuffer, *phMfp);
 
    ALIGN_POINTER(pBuffer, 3);
 
    if (LOWORD(*pFlags) == MSHCTX_INPROC)
    {
        if (sizeof(HMETAFILEPICT) == 8)
            *(ULONG *)pBuffer = WDT_INPROC64_CALL;
        else
            *(ULONG *)pBuffer = WDT_INPROC_CALL;
        pBuffer += sizeof(ULONG);
        *(HMETAFILEPICT *)pBuffer = *phMfp;
        pBuffer += sizeof(HMETAFILEPICT);
    }
    else
    {
        *(ULONG *)pBuffer = WDT_REMOTE_CALL;
        pBuffer += sizeof(ULONG);
        *(ULONG *)pBuffer = (ULONG)(ULONG_PTR)*phMfp;
        pBuffer += sizeof(ULONG);
 
        if (*phMfp)
        {
            METAFILEPICT *mfpict = GlobalLock(*phMfp);
            remoteMETAFILEPICT * remmfpict = (remoteMETAFILEPICT *)pBuffer;
 
            /* FIXME: raise an exception if mfpict is NULL? */
            remmfpict->mm = mfpict->mm;
            remmfpict->xExt = mfpict->xExt;
            remmfpict->yExt = mfpict->yExt;
            pBuffer += 3 * sizeof(ULONG);
            *(ULONG *)pBuffer = USER_MARSHAL_PTR_PREFIX;
            pBuffer += sizeof(ULONG);
 
            pBuffer = HMETAFILE_UserMarshal(pFlags, pBuffer, &mfpict->hMF);
 
            GlobalUnlock(*phMfp);
        }
    }
    return pBuffer;
}

Referenced by STGMEDIUM_UserMarshal(), and test_marshal_HMETAFILEPICT().

HMETAFILEPICT_UserSize()

ULONG __RPC_USER HMETAFILEPICT_UserSize	(	ULONG *	pFlags,
		ULONG	size,
		HMETAFILEPICT *	phMfp
	)

Definition at line 1293 of file usrmarshal.c.

{
    TRACE("(%s, %d, &%p)\n", debugstr_user_flags(pFlags), size, *phMfp);
 
    ALIGN_LENGTH(size, 3);
 
    size += sizeof(ULONG);
 
    if(LOWORD(*pFlags) == MSHCTX_INPROC)
        size += sizeof(HMETAFILEPICT);
    else
    {
        size += sizeof(ULONG);
 
        if (*phMfp)
        {
            METAFILEPICT *mfpict = GlobalLock(*phMfp);
 
            /* FIXME: raise an exception if mfpict is NULL? */
            size += 3 * sizeof(ULONG);
            size += sizeof(ULONG);
 
            size = HMETAFILE_UserSize(pFlags, size, &mfpict->hMF);
 
            GlobalUnlock(*phMfp);
        }
    }
 
    return size;
}

Referenced by STGMEDIUM_UserSize(), and test_marshal_HMETAFILEPICT().

HMETAFILEPICT_UserUnmarshal()

unsigned char *__RPC_USER HMETAFILEPICT_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		HMETAFILEPICT *	phMfp
	)

Definition at line 1406 of file usrmarshal.c.

{
    ULONG fContext;
 
    TRACE("(%s, %p, %p)\n", debugstr_user_flags(pFlags), pBuffer, phMfp);
 
    ALIGN_POINTER(pBuffer, 3);
 
    fContext = *(ULONG *)pBuffer;
    pBuffer += sizeof(ULONG);
 
    if ((fContext == WDT_INPROC_CALL) || fContext == WDT_INPROC64_CALL)
    {
        *phMfp = *(HMETAFILEPICT *)pBuffer;
        pBuffer += sizeof(HMETAFILEPICT);
    }
    else
    {
        ULONG handle = *(ULONG *)pBuffer;
        pBuffer += sizeof(ULONG);
        *phMfp = NULL;
 
        if(handle)
        {
            METAFILEPICT *mfpict;
            const remoteMETAFILEPICT *remmfpict;
            ULONG user_marshal_prefix;
 
            remmfpict = (const remoteMETAFILEPICT *)pBuffer;
 
            *phMfp = GlobalAlloc(GMEM_MOVEABLE, sizeof(METAFILEPICT));
            if (!*phMfp)
                RpcRaiseException(E_OUTOFMEMORY);
 
            mfpict = GlobalLock(*phMfp);
            mfpict->mm = remmfpict->mm;
            mfpict->xExt = remmfpict->xExt;
            mfpict->yExt = remmfpict->yExt;
            pBuffer += 3 * sizeof(ULONG);
            user_marshal_prefix = *(ULONG *)pBuffer;
            pBuffer += sizeof(ULONG);
 
            if (user_marshal_prefix != USER_MARSHAL_PTR_PREFIX)
                RpcRaiseException(RPC_X_INVALID_TAG);
 
            pBuffer = HMETAFILE_UserUnmarshal(pFlags, pBuffer, &mfpict->hMF);
 
            GlobalUnlock(*phMfp);
        }
    }
    return pBuffer;
}

Referenced by STGMEDIUM_UserUnmarshal(), and test_marshal_HMETAFILEPICT().

host_object_proc()

static DWORD CALLBACK host_object_proc ( LPVOID  p )

static

Definition at line 100 of file usrmarshal.c.

{
    struct host_object_data *data = p;
    HRESULT hr;
    MSG msg;
 
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 
    if (data->filter)
    {
        IMessageFilter * prev_filter = NULL;
        hr = CoRegisterMessageFilter(data->filter, &prev_filter);
        if (prev_filter) IMessageFilter_Release(prev_filter);
        ok(hr == S_OK, "got %08x\n", hr);
    }
 
    hr = CoMarshalInterface(data->stream, &data->iid, data->object, MSHCTX_INPROC, NULL, data->marshal_flags);
    ok(hr == S_OK, "got %08x\n", hr);
 
    /* force the message queue to be created before signaling parent thread */
    PeekMessageA(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
 
    SetEvent(data->marshal_event);
 
    while (GetMessageA(&msg, NULL, 0, 0))
    {
        if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
        {
            CoReleaseMarshalData(data->stream);
            SetEvent((HANDLE)msg.lParam);
        }
        else
            DispatchMessageA(&msg);
    }
 
    HeapFree(GetProcessHeap(), 0, data);
 
    CoUninitialize();
 
    return hr;
}

Referenced by start_host_object2().

impl_from_IStream()

static struct test_stream * impl_from_IStream ( IStream *  iface )

inlinestatic

Definition at line 630 of file usrmarshal.c.

{
    return CONTAINING_RECORD(iface, struct test_stream, IStream_iface);
}

Referenced by Test_IStream_AddRef(), and Test_IStream_Release().

impl_from_IUnknown()

static TestUnknown * impl_from_IUnknown ( IUnknown *  iface )

inlinestatic

Definition at line 582 of file usrmarshal.c.

{
    return CONTAINING_RECORD(iface, TestUnknown, IUnknown_iface);
}

Referenced by HeapUnknown_AddRef(), HeapUnknown_Release(), Test_IUnknown_AddRef(), and Test_IUnknown_Release().

init_user_marshal_cb()

static void init_user_marshal_cb ( USER_MARSHAL_CB *  umcb, PMIDL_STUB_MESSAGE  stub_msg, PRPC_MESSAGE  rpc_msg, unsigned char *  buffer, unsigned int  size, MSHCTX  context  )

static

Definition at line 66 of file usrmarshal.c.

{
    memset(rpc_msg, 0, sizeof(*rpc_msg));
    rpc_msg->Buffer = buffer;
    rpc_msg->BufferLength = size;
 
    memset(stub_msg, 0, sizeof(*stub_msg));
    stub_msg->RpcMsg = rpc_msg;
    stub_msg->Buffer = buffer;
    stub_msg->pfnAllocate = user_allocate;
    stub_msg->pfnFree = user_free;
 
    memset(umcb, 0, sizeof(*umcb));
    umcb->Flags = MAKELONG(context, NDR_LOCAL_DATA_REPRESENTATION);
    umcb->pStubMsg = stub_msg;
    umcb->Signature = USER_MARSHAL_CB_SIGNATURE;
    umcb->CBType = buffer ? USER_MARSHAL_CB_UNMARSHALL : USER_MARSHAL_CB_BUFFER_SIZE;
}

Referenced by marshal_STGMEDIUM(), marshal_WdtpInterfacePointer(), test_marshal_BSTR(), test_marshal_CLIPFORMAT(), test_marshal_HBITMAP(), test_marshal_HBRUSH(), test_marshal_HDC(), test_marshal_HENHMETAFILE(), test_marshal_HGLOBAL(), test_marshal_HICON(), test_marshal_HMETAFILE(), test_marshal_HMETAFILEPICT(), test_marshal_HWND(), test_marshal_LPSAFEARRAY(), and test_marshal_SNB().

marshal_STGMEDIUM()

static void marshal_STGMEDIUM ( BOOL  client, BOOL  in, BOOL  out  )

static

Definition at line 794 of file usrmarshal.c.

{
    USER_MARSHAL_CB umcb;
    MIDL_STUB_MESSAGE stub_msg;
    RPC_MESSAGE rpc_msg;
    unsigned char *buffer, *buffer_end, *expect_buffer, *expect_buffer_end;
    ULONG size, expect_size;
    STGMEDIUM med, med2;
    IUnknown *unk = &Test_Unknown.IUnknown_iface;
    IStream *stm = &Test_Stream.IStream_iface;
 
    /* TYMED_NULL with pUnkForRelease */
 
    Test_Unknown.refs = 1;
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    expect_size = WdtpInterfacePointer_UserSize(&umcb.Flags, umcb.Flags, 2 * sizeof(DWORD), unk, &IID_IUnknown);
    expect_buffer = HeapAlloc(GetProcessHeap(), 0, expect_size);
    *(DWORD*)expect_buffer = TYMED_NULL;
    *((DWORD*)expect_buffer + 1) = 0xdeadbeef;
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, expect_buffer, expect_size, MSHCTX_DIFFERENTMACHINE);
    expect_buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, umcb.Flags, expect_buffer + 2 * sizeof(DWORD), unk, &IID_IUnknown);
 
    med.tymed = TYMED_NULL;
    U(med).pstg = NULL;
    med.pUnkForRelease = unk;
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    size = STGMEDIUM_UserSize(&umcb.Flags, 0, &med);
    ok(size == expect_size, "size %d should be %d bytes\n", size, expect_size);
 
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    buffer_end = STGMEDIUM_UserMarshal(&umcb.Flags, buffer, &med);
    ok(buffer_end - buffer == expect_buffer_end - expect_buffer, "buffer size mismatch\n");
    ok(*(DWORD*)buffer == TYMED_NULL, "got %08x\n", *(DWORD*)buffer);
    ok(*((DWORD*)buffer+1) != 0, "got %08x\n", *((DWORD*)buffer+1));
    ok(!memcmp(buffer+8, expect_buffer + 8, expect_buffer_end - expect_buffer - 8), "buffer mismatch\n");
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    umcb.pStubMsg->IsClient = client;
    umcb.pStubMsg->fIsIn = in;
    umcb.pStubMsg->fIsOut = out;
 
    Test_Unknown2.refs = 1;
    med2.tymed = TYMED_NULL;
    U(med2).pstm = NULL;
    med2.pUnkForRelease = &Test_Unknown2.IUnknown_iface;
 
    STGMEDIUM_UserUnmarshal(&umcb.Flags, buffer, &med2);
 
    ok(med2.tymed == TYMED_NULL, "got tymed %x\n", med2.tymed);
    ok(med2.pUnkForRelease != NULL, "Incorrectly unmarshalled\n");
    ok(Test_Unknown2.refs == 0, "got %d\n", Test_Unknown2.refs);
 
    HeapFree(GetProcessHeap(), 0, buffer);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    STGMEDIUM_UserFree(&umcb.Flags, &med2);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, expect_buffer, expect_size, MSHCTX_DIFFERENTMACHINE);
    med2.tymed = TYMED_NULL;
    U(med2).pstm = NULL;
    med2.pUnkForRelease = NULL;
    STGMEDIUM_UserUnmarshal(&umcb.Flags, expect_buffer, &med2);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    STGMEDIUM_UserFree(&umcb.Flags, &med2);
 
    ok(Test_Unknown.refs == 1, "got %d\n", Test_Unknown.refs);
 
    HeapFree(GetProcessHeap(), 0, expect_buffer);
 
    /* TYMED_ISTREAM with pUnkForRelease */
 
    Test_Unknown.refs = 1;
    Test_Stream.refs = 1;
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    expect_size = WdtpInterfacePointer_UserSize(&umcb.Flags, umcb.Flags, 3 * sizeof(DWORD), (IUnknown*)stm, &IID_IStream);
    expect_size = WdtpInterfacePointer_UserSize(&umcb.Flags, umcb.Flags, expect_size, unk, &IID_IUnknown);
 
    expect_buffer = HeapAlloc(GetProcessHeap(), 0, expect_size);
    /* There may be a hole between the two interfaces so init the buffer to something */
    memset(expect_buffer, 0xcc, expect_size);
    *(DWORD*)expect_buffer = TYMED_ISTREAM;
    *((DWORD*)expect_buffer + 1) = 0xdeadbeef;
    *((DWORD*)expect_buffer + 2) = 0xcafe;
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, expect_buffer, expect_size, MSHCTX_DIFFERENTMACHINE);
    expect_buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, umcb.Flags, expect_buffer + 3 * sizeof(DWORD), (IUnknown*)stm, &IID_IStream);
    expect_buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, umcb.Flags, expect_buffer_end, unk, &IID_IUnknown);
 
    med.tymed = TYMED_ISTREAM;
    U(med).pstm = stm;
    med.pUnkForRelease = unk;
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    size = STGMEDIUM_UserSize(&umcb.Flags, 0, &med);
    ok(size == expect_size, "size %d should be %d bytes\n", size, expect_size);
 
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    memset(buffer, 0xcc, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    buffer_end = STGMEDIUM_UserMarshal(&umcb.Flags, buffer, &med);
    ok(buffer_end - buffer == expect_buffer_end - expect_buffer, "buffer size mismatch\n");
    ok(*(DWORD*)buffer == TYMED_ISTREAM, "got %08x\n", *(DWORD*)buffer);
    ok(*((DWORD*)buffer+1) != 0, "got %08x\n", *((DWORD*)buffer+1));
    ok(*((DWORD*)buffer+2) != 0, "got %08x\n", *((DWORD*)buffer+2));
    ok(!memcmp(buffer + 12, expect_buffer + 12, (buffer_end - buffer) - 12), "buffer mismatch\n");
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    umcb.pStubMsg->IsClient = client;
    umcb.pStubMsg->fIsIn = in;
    umcb.pStubMsg->fIsOut = out;
 
    Test_Stream2.refs = 1;
    Test_Unknown2.refs = 1;
    med2.tymed = TYMED_ISTREAM;
    U(med2).pstm = &Test_Stream2.IStream_iface;
    med2.pUnkForRelease = &Test_Unknown2.IUnknown_iface;
 
    STGMEDIUM_UserUnmarshal(&umcb.Flags, buffer, &med2);
 
    ok(med2.tymed == TYMED_ISTREAM, "got tymed %x\n", med2.tymed);
    ok(U(med2).pstm != NULL, "Incorrectly unmarshalled\n");
    ok(med2.pUnkForRelease != NULL, "Incorrectly unmarshalled\n");
    ok(Test_Stream2.refs == 0, "got %d\n", Test_Stream2.refs);
    ok(Test_Unknown2.refs == 0, "got %d\n", Test_Unknown2.refs);
 
    HeapFree(GetProcessHeap(), 0, buffer);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    STGMEDIUM_UserFree(&umcb.Flags, &med2);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, expect_buffer, expect_size, MSHCTX_DIFFERENTMACHINE);
    med2.tymed = TYMED_NULL;
    U(med2).pstm = NULL;
    med2.pUnkForRelease = NULL;
    STGMEDIUM_UserUnmarshal(&umcb.Flags, expect_buffer, &med2);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    STGMEDIUM_UserFree(&umcb.Flags, &med2);
 
    ok(Test_Unknown.refs == 1, "got %d\n", Test_Unknown.refs);
    ok(Test_Stream.refs == 1, "got %d\n", Test_Stream.refs);
 
    HeapFree(GetProcessHeap(), 0, expect_buffer);
 
    /* TYMED_ISTREAM = NULL with pUnkForRelease = NULL */
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    expect_size = 3 * sizeof(DWORD);
 
    med.tymed = TYMED_ISTREAM;
    U(med).pstm = NULL;
    med.pUnkForRelease = NULL;
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    size = STGMEDIUM_UserSize(&umcb.Flags, 0, &med);
    ok(size == expect_size, "size %d should be %d bytes\n", size, expect_size);
 
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    memset(buffer, 0xcc, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    buffer_end = STGMEDIUM_UserMarshal(&umcb.Flags, buffer, &med);
    ok(buffer_end - buffer == expect_size, "buffer size mismatch\n");
    ok(*(DWORD*)buffer == TYMED_ISTREAM, "got %08x\n", *(DWORD*)buffer);
    ok(*((DWORD*)buffer+1) == 0, "got %08x\n", *((DWORD*)buffer+1));
    ok(*((DWORD*)buffer+2) == 0, "got %08x\n", *((DWORD*)buffer+2));
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    umcb.pStubMsg->IsClient = client;
    umcb.pStubMsg->fIsIn = in;
    umcb.pStubMsg->fIsOut = out;
 
    Test_Stream2.refs = 1;
    Test_Unknown2.refs = 1;
    med2.tymed = TYMED_ISTREAM;
    U(med2).pstm = &Test_Stream2.IStream_iface;
    med2.pUnkForRelease = &Test_Unknown2.IUnknown_iface;
 
    STGMEDIUM_UserUnmarshal(&umcb.Flags, buffer, &med2);
 
    ok(med2.tymed == TYMED_ISTREAM, "got tymed %x\n", med2.tymed);
    ok(U(med2).pstm == NULL, "Incorrectly unmarshalled\n");
    ok(med2.pUnkForRelease == &Test_Unknown2.IUnknown_iface, "Incorrectly unmarshalled\n");
    ok(Test_Stream2.refs == 0, "got %d\n", Test_Stream2.refs);
    ok(Test_Unknown2.refs == 1, "got %d\n", Test_Unknown2.refs);
 
    HeapFree(GetProcessHeap(), 0, buffer);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    STGMEDIUM_UserFree(&umcb.Flags, &med2);
}

Referenced by test_marshal_STGMEDIUM().

marshal_WdtpInterfacePointer()

static void marshal_WdtpInterfacePointer ( DWORD  umcb_ctx, DWORD  ctx, BOOL  client, BOOL  in, BOOL  out  )

static

Definition at line 681 of file usrmarshal.c.

{
    USER_MARSHAL_CB umcb;
    MIDL_STUB_MESSAGE stub_msg;
    RPC_MESSAGE rpc_msg;
    unsigned char *buffer, *buffer_end;
    ULONG size;
    IUnknown *unk;
    IUnknown *unk2;
    unsigned char *wireip;
    HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE, 0);
    IStream *stm;
    void *marshal_data;
    LARGE_INTEGER zero;
    ULARGE_INTEGER pos;
    DWORD marshal_size;
 
    /* shows that the WdtpInterfacePointer functions don't marshal anything for
     * NULL pointers, so code using these functions must handle that case
     * itself */
 
    unk = NULL;
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, umcb_ctx);
    size = WdtpInterfacePointer_UserSize(&umcb.Flags, ctx, 0, unk, &IID_IUnknown);
    ok(size == 0, "size should be 0 bytes, not %d\n", size);
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, ctx, buffer, unk, &IID_IUnknown);
    ok(buffer_end == buffer, "buffer_end %p buffer %p\n", buffer_end, buffer);
    HeapFree(GetProcessHeap(), 0, buffer);
 
    /* Now for a non-NULL pointer. The marshalled data are two size DWORDS and then
       the result of CoMarshalInterface called with the LOWORD of the ctx */
 
    unk = &Test_Unknown.IUnknown_iface;
    Test_Unknown.refs = 1;
 
    CreateStreamOnHGlobal(h, TRUE, &stm);
    CoMarshalInterface(stm, &IID_IUnknown, unk, LOWORD(ctx), NULL, MSHLFLAGS_NORMAL);
    zero.QuadPart = 0;
    IStream_Seek(stm, zero, STREAM_SEEK_CUR, &pos);
    marshal_size = pos.u.LowPart;
    marshal_data = GlobalLock(h);
todo_wine
    ok(Test_Unknown.refs == 2, "got %d\n", Test_Unknown.refs);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, umcb_ctx);
    size = WdtpInterfacePointer_UserSize(&umcb.Flags, ctx, 0, unk, &IID_IUnknown);
    ok(size >= marshal_size + 2 * sizeof(DWORD), "marshal size %x got %x\n", marshal_size, size);
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, umcb_ctx);
    buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, ctx, buffer, unk, &IID_IUnknown);
todo_wine
    ok(Test_Unknown.refs == 2, "got %d\n", Test_Unknown.refs);
    wireip = buffer;
 
    ok(buffer_end == buffer + marshal_size + 2 * sizeof(DWORD), "buffer_end %p buffer %p\n", buffer_end, buffer);
 
    ok(*(DWORD *)wireip == marshal_size, "wireip + 0x0 should be %x instead of %x\n", marshal_size, *(DWORD *)wireip);
    wireip += sizeof(DWORD);
    ok(*(DWORD *)wireip == marshal_size, "wireip + 0x4 should be %x instead of %x\n", marshal_size, *(DWORD *)wireip);
    wireip += sizeof(DWORD);
 
    ok(!memcmp(marshal_data, wireip, marshal_size), "buffer mismatch\n");
    GlobalUnlock(h);
    zero.QuadPart = 0;
    IStream_Seek(stm, zero, STREAM_SEEK_SET, NULL);
    CoReleaseMarshalData(stm);
    IStream_Release(stm);
 
    Test_Unknown2.refs = 1;
    unk2 = &Test_Unknown2.IUnknown_iface;
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, umcb_ctx);
    umcb.pStubMsg->IsClient = client;
    umcb.pStubMsg->fIsIn = in;
    umcb.pStubMsg->fIsOut = out;
 
    WdtpInterfacePointer_UserUnmarshal(&umcb.Flags, buffer, &unk2, &IID_IUnknown);
    ok(unk2 != NULL, "IUnknown object didn't unmarshal properly\n");
    ok(Test_Unknown.refs == 2, "got %d\n", Test_Unknown.refs);
    ok(Test_Unknown2.refs == 0, "got %d\n", Test_Unknown2.refs);
    HeapFree(GetProcessHeap(), 0, buffer);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_INPROC);
    IUnknown_Release(unk2);
}

Referenced by test_marshal_WdtpInterfacePointer().

obj_AddRef()

static ULONG WINAPI obj_AddRef ( IDataObject *  iface )

static

Definition at line 1293 of file usrmarshal.c.

{
    return 2;
}

obj_DO_GetDataHere()

static HRESULT WINAPI obj_DO_GetDataHere ( IDataObject *  iface, FORMATETC *  fmt, STGMEDIUM *  med  )

static

Definition at line 1303 of file usrmarshal.c.

{
    ok( med->pUnkForRelease == NULL, "got %p\n", med->pUnkForRelease );
 
    if (fmt->cfFormat == 2)
    {
        IStream_Release(U(med)->pstm);
        U(med)->pstm = &Test_Stream2.IStream_iface;
    }
 
    return S_OK;
}

obj_QueryInterface()

static HRESULT WINAPI obj_QueryInterface ( IDataObject *  iface, REFIID  iid, void **  obj  )

static

Definition at line 1276 of file usrmarshal.c.

{
    *obj = NULL;
 
    if (IsEqualGUID(iid, &IID_IUnknown) ||
        IsEqualGUID(iid, &IID_IDataObject))
        *obj = iface;
 
    if (*obj)
    {
        IDataObject_AddRef(iface);
        return S_OK;
    }
 
    return E_NOINTERFACE;
}

obj_Release()

static ULONG WINAPI obj_Release ( IDataObject *  iface )

static

Definition at line 1298 of file usrmarshal.c.

{
    return 1;
}

start_host_object2()

static DWORD start_host_object2 ( IStream *  stream, REFIID  riid, IUnknown *  object, MSHLFLAGS  marshal_flags, IMessageFilter *  filter, HANDLE *  thread  )

static

Definition at line 142 of file usrmarshal.c.

{
    DWORD tid = 0;
    HANDLE marshal_event = CreateEventA(NULL, FALSE, FALSE, NULL);
    struct host_object_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data));
 
    data->stream = stream;
    data->iid = *riid;
    data->object = object;
    data->marshal_flags = marshal_flags;
    data->marshal_event = marshal_event;
    data->filter = filter;
 
    *thread = CreateThread(NULL, 0, host_object_proc, data, 0, &tid);
 
    /* wait for marshaling to complete before returning */
    ok( !WaitForSingleObject(marshal_event, 10000), "wait timed out\n" );
    CloseHandle(marshal_event);
 
    return tid;
}

Referenced by test_GetDataHere_Proxy().

START_TEST()

START_TEST

(

usrmarshal

)

Definition at line 1418 of file usrmarshal.c.

{
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 
    test_marshal_CLIPFORMAT();
    test_marshal_HWND();
    test_marshal_HGLOBAL();
    test_marshal_HENHMETAFILE();
    test_marshal_HMETAFILE();
    test_marshal_HMETAFILEPICT();
    test_marshal_WdtpInterfacePointer();
    test_marshal_STGMEDIUM();
    test_marshal_SNB();
    test_marshal_HDC();
    test_marshal_HICON();
    test_marshal_HBRUSH();
    test_marshal_HBITMAP();
 
    test_GetDataHere_Proxy();
 
    CoUninitialize();
}

test_GetDataHere_Proxy()

static void test_GetDataHere_Proxy ( void  )

static

Definition at line 1338 of file usrmarshal.c.

{
    HRESULT hr;
    IStream *stm;
    HANDLE thread;
    DWORD tid;
    static const LARGE_INTEGER zero;
    IDataObject *data;
    FORMATETC fmt;
    STGMEDIUM med;
 
    hr = CreateStreamOnHGlobal( NULL, TRUE, &stm );
    ok( hr == S_OK, "got %08x\n", hr );
    tid = start_host_object2( stm, &IID_IDataObject, (IUnknown *)&obj.IDataObject_iface, MSHLFLAGS_NORMAL, NULL, &thread );
 
    IStream_Seek( stm, zero, STREAM_SEEK_SET, NULL );
    hr = CoUnmarshalInterface( stm, &IID_IDataObject, (void **)&data );
    ok( hr == S_OK, "got %08x\n", hr );
    IStream_Release( stm );
 
    Test_Stream.refs = 1;
    Test_Stream2.refs = 1;
    Test_Unknown.refs = 1;
 
    fmt.cfFormat = 1;
    fmt.ptd = NULL;
    fmt.dwAspect = DVASPECT_CONTENT;
    fmt.lindex = -1;
    U(med).pstm = NULL;
    med.pUnkForRelease = &Test_Unknown.IUnknown_iface;
 
    fmt.tymed = med.tymed = TYMED_NULL;
    hr = IDataObject_GetDataHere( data, &fmt, &med );
    ok( hr == DV_E_TYMED, "got %08x\n", hr );
 
    for (fmt.tymed = TYMED_HGLOBAL; fmt.tymed <= TYMED_ENHMF; fmt.tymed <<= 1)
    {
        med.tymed = fmt.tymed;
        hr = IDataObject_GetDataHere( data, &fmt, &med );
        ok( hr == (fmt.tymed <= TYMED_ISTORAGE ? S_OK : DV_E_TYMED), "got %08x for tymed %d\n", hr, fmt.tymed );
        ok( Test_Unknown.refs == 1, "got %d\n", Test_Unknown.refs );
    }
 
    fmt.tymed = TYMED_ISTREAM;
    med.tymed = TYMED_ISTORAGE;
    hr = IDataObject_GetDataHere( data, &fmt, &med );
    ok( hr == DV_E_TYMED, "got %08x\n", hr );
 
    fmt.tymed = med.tymed = TYMED_ISTREAM;
    U(med).pstm = &Test_Stream.IStream_iface;
    med.pUnkForRelease = &Test_Unknown.IUnknown_iface;
 
    hr = IDataObject_GetDataHere( data, &fmt, &med );
    ok( hr == S_OK, "got %08x\n", hr );
 
    ok( U(med).pstm == &Test_Stream.IStream_iface, "stm changed\n" );
    ok( med.pUnkForRelease == &Test_Unknown.IUnknown_iface, "punk changed\n" );
 
    ok( Test_Stream.refs == 1, "got %d\n", Test_Stream.refs );
    ok( Test_Unknown.refs == 1, "got %d\n", Test_Unknown.refs );
 
    fmt.cfFormat = 2;
    fmt.tymed = med.tymed = TYMED_ISTREAM;
    U(med).pstm = &Test_Stream.IStream_iface;
    med.pUnkForRelease = &Test_Unknown.IUnknown_iface;
 
    hr = IDataObject_GetDataHere( data, &fmt, &med );
    ok( hr == S_OK, "got %08x\n", hr );
 
    ok( U(med).pstm == &Test_Stream.IStream_iface, "stm changed\n" );
    ok( med.pUnkForRelease == &Test_Unknown.IUnknown_iface, "punk changed\n" );
 
    ok( Test_Stream.refs == 1, "got %d\n", Test_Stream.refs );
    ok( Test_Unknown.refs == 1, "got %d\n", Test_Unknown.refs );
    ok( Test_Stream2.refs == 0, "got %d\n", Test_Stream2.refs );
 
    IDataObject_Release( data );
    end_host_object( tid, thread );
}

Referenced by START_TEST().

Test_IStream_AddRef()

static ULONG WINAPI Test_IStream_AddRef ( IStream *  iface )

static

Definition at line 652 of file usrmarshal.c.

{
    struct test_stream *This = impl_from_IStream(iface);
    return InterlockedIncrement(&This->refs);
}

Test_IStream_QueryInterface()

static HRESULT WINAPI Test_IStream_QueryInterface ( IStream *  iface, REFIID  riid, LPVOID *  ppvObj  )

static

Definition at line 635 of file usrmarshal.c.

{
    if (ppvObj == NULL) return E_POINTER;
 
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IStream))
    {
        *ppvObj = iface;
        IStream_AddRef(iface);
        return S_OK;
    }
 
    *ppvObj = NULL;
    return E_NOINTERFACE;
}

Test_IStream_Release()

static ULONG WINAPI Test_IStream_Release ( IStream *  iface )

static

Definition at line 658 of file usrmarshal.c.

{
    struct test_stream *This = impl_from_IStream(iface);
    return InterlockedDecrement(&This->refs);
}

Test_IUnknown_AddRef()

static ULONG WINAPI Test_IUnknown_AddRef ( LPUNKNOWN  iface )

static

Definition at line 605 of file usrmarshal.c.

{
    TestUnknown *This = impl_from_IUnknown(iface);
    return InterlockedIncrement(&This->refs);
}

Test_IUnknown_QueryInterface()

static HRESULT WINAPI Test_IUnknown_QueryInterface ( LPUNKNOWN  iface, REFIID  riid, LPVOID *  ppvObj  )

static

Definition at line 587 of file usrmarshal.c.

{
    if (ppvObj == NULL) return E_POINTER;
 
    if (IsEqualGUID(riid, &IID_IUnknown))
    {
        *ppvObj = iface;
        IUnknown_AddRef(iface);
        return S_OK;
    }
 
    *ppvObj = NULL;
    return E_NOINTERFACE;
}

Test_IUnknown_Release()

static ULONG WINAPI Test_IUnknown_Release ( LPUNKNOWN  iface )

static

Definition at line 611 of file usrmarshal.c.

{
    TestUnknown *This = impl_from_IUnknown(iface);
    return InterlockedDecrement(&This->refs);
}

test_marshal_CLIPFORMAT()

static void test_marshal_CLIPFORMAT ( void  )

static

Definition at line 185 of file usrmarshal.c.

{
    USER_MARSHAL_CB umcb;
    MIDL_STUB_MESSAGE stub_msg;
    RPC_MESSAGE rpc_msg;
    unsigned char *buffer, *buffer_end;
    ULONG i, size;
    CLIPFORMAT cf = RegisterClipboardFormatA("MyFormat");
    CLIPFORMAT cf2;
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    size = CLIPFORMAT_UserSize(&umcb.Flags, 1, &cf);
    ok(size == 12 + sizeof(cf_marshaled) ||
       broken(size == 16 + sizeof(cf_marshaled)),  /* win64 adds 4 extra (unused) bytes */
              "CLIPFORMAT: Wrong size %d\n", size);
 
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    memset( buffer, 0xcc, size );
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    buffer_end = CLIPFORMAT_UserMarshal(&umcb.Flags, buffer + 1, &cf);
    ok(buffer_end == buffer + 12 + sizeof(cf_marshaled), "got %p buffer %p\n", buffer_end, buffer);
    ok(*(LONG *)(buffer + 4) == WDT_REMOTE_CALL, "CLIPFORMAT: Context should be WDT_REMOTE_CALL instead of 0x%08x\n", *(LONG *)(buffer + 0));
    ok(*(DWORD *)(buffer + 8) == cf, "CLIPFORMAT: Marshaled value should be 0x%04x instead of 0x%04x\n", cf, *(DWORD *)(buffer + 4));
    ok(!memcmp(buffer + 12, cf_marshaled, min( sizeof(cf_marshaled), size-12 )), "Marshaled data differs\n");
    if (size > sizeof(cf_marshaled) + 12)  /* make sure the extra bytes are not used */
        for (i = sizeof(cf_marshaled) + 12; i < size; i++)
            ok( buffer[i] == 0xcc, "buffer offset %u has been set to %x\n", i, buffer[i] );
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    buffer_end = CLIPFORMAT_UserUnmarshal(&umcb.Flags, buffer + 1, &cf2);
    ok(buffer_end == buffer + 12 + sizeof(cf_marshaled), "got %p buffer %p\n", buffer_end, buffer);
    ok(cf == cf2, "CLIPFORMAT: Didn't unmarshal properly\n");
    HeapFree(GetProcessHeap(), 0, buffer);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    CLIPFORMAT_UserFree(&umcb.Flags, &cf2);
}

Referenced by START_TEST().

test_marshal_HBITMAP()

static void test_marshal_HBITMAP ( void  )

static

Definition at line 1208 of file usrmarshal.c.

{
    static const ULONG header_size = FIELD_OFFSET(userBITMAP, cbSize);
    static BYTE bmp_bits[1024];
    MIDL_STUB_MESSAGE stub_msg;
    HBITMAP hBitmap, hBitmap2;
    USER_MARSHAL_CB umcb;
    RPC_MESSAGE rpc_msg;
    unsigned char *buffer, *buffer_end;
    unsigned char bitmap[1024];
    ULONG size, bitmap_size;
 
    hBitmap = CreateBitmap(16, 16, 1, 1, bmp_bits);
    ok(hBitmap != 0, "CreateBitmap failed\n");
    size = GetObjectA(hBitmap, sizeof(bitmap), bitmap);
    ok(size != 0, "GetObject failed\n");
    bitmap_size = GetBitmapBits(hBitmap, 0, NULL);
    ok(bitmap_size != 0, "GetBitmapBits failed\n");
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_INPROC);
    size = HBITMAP_UserSize(&umcb.Flags, 1, &hBitmap);
    ok(size == 0xc, "Wrong size %d\n", size);
    buffer = HeapAlloc(GetProcessHeap(), 0, size + 4);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_INPROC);
    buffer_end = HBITMAP_UserMarshal(&umcb.Flags, buffer + 1, &hBitmap);
    ok(buffer_end == buffer + 0xc, "HBITMAP_UserMarshal() returned wrong size %d\n", (LONG)(buffer_end - buffer));
    ok(*(ULONG *)(buffer + 0x4) == WDT_INPROC_CALL, "Context should be WDT_INPROC_CALL instead of 0x%08x\n", *(ULONG *)(buffer + 0x4));
    ok(*(ULONG *)(buffer + 0x8) == (ULONG)(ULONG_PTR)hBitmap, "wirestgm + 0x4 should be bitmap handle instead of 0x%08x\n", *(ULONG *)(buffer + 0x8));
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_INPROC);
    HBITMAP_UserUnmarshal(&umcb.Flags, buffer + 1, &hBitmap2);
    ok(hBitmap2 != NULL, "Didn't unmarshal properly\n");
    HeapFree(GetProcessHeap(), 0, buffer);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_INPROC);
    HBITMAP_UserFree(&umcb.Flags, &hBitmap2);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    size = HBITMAP_UserSize(&umcb.Flags, 1, &hBitmap);
    ok(size == 0x10 + header_size + bitmap_size ||
       broken(size == 0x14 + header_size + bitmap_size), /* Windows adds 4 extra (unused) bytes */
       "Wrong size %d\n", size);
 
    buffer = HeapAlloc(GetProcessHeap(), 0, size + 4);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
    buffer_end = HBITMAP_UserMarshal(&umcb.Flags, buffer + 1, &hBitmap);
    ok(buffer_end == buffer + 0x10 + header_size + bitmap_size, "HBITMAP_UserMarshal() returned wrong size %d\n", (LONG)(buffer_end - buffer));
    ok(*(ULONG *)(buffer + 0x4) == WDT_REMOTE_CALL, "Context should be WDT_REMOTE_CALL instead of 0x%08x\n", *(ULONG *)buffer);
    ok(*(ULONG *)(buffer + 0x8) == (ULONG)(ULONG_PTR)hBitmap, "wirestgm + 0x4 should be bitmap handle instead of 0x%08x\n", *(ULONG *)(buffer + 0x4));
    ok(*(ULONG *)(buffer + 0xc) == (ULONG)(ULONG_PTR)bitmap_size, "wirestgm + 0x8 should be bitmap size instead of 0x%08x\n", *(ULONG *)(buffer + 0x4));
    ok(!memcmp(buffer + 0x10, bitmap, header_size), "buffer mismatch\n");
    ok(!memcmp(buffer + 0x10 + header_size, bmp_bits, bitmap_size), "buffer mismatch\n");
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
    HBITMAP_UserUnmarshal(&umcb.Flags, buffer + 1, &hBitmap2);
    ok(hBitmap2 != NULL, "Didn't unmarshal properly\n");
    HeapFree(GetProcessHeap(), 0, buffer);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    HBITMAP_UserFree(&umcb.Flags, &hBitmap2);
    DeleteObject(hBitmap);
}

Referenced by START_TEST().

test_marshal_HBRUSH()

static void test_marshal_HBRUSH ( void  )

static

Definition at line 1167 of file usrmarshal.c.

{
    MIDL_STUB_MESSAGE stub_msg;
    HBRUSH hBrush, hBrush2;
    USER_MARSHAL_CB umcb;
    RPC_MESSAGE rpc_msg;
    unsigned char *buffer, *buffer_end;
    LOGBRUSH logbrush;
    wireHBRUSH wirehbrush;
    ULONG size;
 
    logbrush.lbStyle = BS_SOLID;
    logbrush.lbColor = RGB(0, 0, 0);
    logbrush.lbHatch = 0;
 
    hBrush = CreateBrushIndirect(&logbrush);
    ok(hBrush != 0, "CreateBrushIndirect failed\n");
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    size = HBRUSH_UserSize(&umcb.Flags, 1, &hBrush);
    ok(size == 4 + sizeof(*wirehbrush), "Wrong size %d\n", size);
 
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
    buffer_end = HBRUSH_UserMarshal(&umcb.Flags, buffer + 1, &hBrush);
    ok(buffer_end == buffer + 4 + sizeof(*wirehbrush), "got %p buffer %p\n", buffer_end, buffer);
    wirehbrush = (wireHBRUSH)(buffer + 4);
    ok(wirehbrush->fContext == WDT_INPROC_CALL, "Context should be WDT_INPROC_CALL instead of 0x%08x\n", wirehbrush->fContext);
    ok(wirehbrush->u.hInproc == (LONG_PTR)hBrush, "Marshaled value should be %p instead of %x\n", hBrush, wirehbrush->u.hRemote);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
    buffer_end = HBRUSH_UserUnmarshal(&umcb.Flags, buffer + 1, &hBrush2);
    ok(buffer_end == buffer + 4 + sizeof(*wirehbrush), "got %p buffer %p\n", buffer_end, buffer);
    ok(hBrush == hBrush2, "Didn't unmarshal properly\n");
    HeapFree(GetProcessHeap(), 0, buffer);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    HBRUSH_UserFree(&umcb.Flags, &hBrush2);
    DeleteObject(hBrush);
}

Referenced by START_TEST().

test_marshal_HDC()

static void test_marshal_HDC ( void  )

static

Definition at line 1097 of file usrmarshal.c.

{
    MIDL_STUB_MESSAGE stub_msg;
    HDC hdc = GetDC(0), hdc2;
    USER_MARSHAL_CB umcb;
    RPC_MESSAGE rpc_msg;
    unsigned char *buffer, *buffer_end;
    wireHDC wirehdc;
    ULONG size;
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    size = HDC_UserSize(&umcb.Flags, 1, &hdc);
    ok(size == 4 + sizeof(*wirehdc), "Wrong size %d\n", size);
 
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
    buffer_end = HDC_UserMarshal(&umcb.Flags, buffer + 1, &hdc);
    ok(buffer_end == buffer + 4 + sizeof(*wirehdc), "got %p buffer %p\n", buffer_end, buffer);
    wirehdc = (wireHDC)(buffer + 4);
    ok(wirehdc->fContext == WDT_INPROC_CALL, "Context should be WDT_INPROC_CALL instead of 0x%08x\n", wirehdc->fContext);
    ok(wirehdc->u.hInproc == (LONG_PTR)hdc, "Marshaled value should be %p instead of %x\n", hdc, wirehdc->u.hRemote);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
    buffer_end = HDC_UserUnmarshal(&umcb.Flags, buffer + 1, &hdc2);
    ok(buffer_end == buffer + 4 + sizeof(*wirehdc), "got %p buffer %p\n", buffer_end, buffer);
    ok(hdc == hdc2, "Didn't unmarshal properly\n");
    HeapFree(GetProcessHeap(), 0, buffer);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    HDC_UserFree(&umcb.Flags, &hdc2);
    ReleaseDC(0, hdc);
}

Referenced by START_TEST().

test_marshal_HENHMETAFILE()

static void test_marshal_HENHMETAFILE ( void  )

static

Definition at line 345 of file usrmarshal.c.

{
    USER_MARSHAL_CB umcb;
    MIDL_STUB_MESSAGE stub_msg;
    RPC_MESSAGE rpc_msg;
    unsigned char *buffer, *buffer_end;
    ULONG size;
    HENHMETAFILE hemf;
    HENHMETAFILE hemf2 = NULL;
    unsigned char *wirehemf;
 
    hemf = create_emf();
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    size = HENHMETAFILE_UserSize(&umcb.Flags, 1, &hemf);
    ok(size > 24, "size should be at least 24 bytes, not %d\n", size);
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    buffer_end = HENHMETAFILE_UserMarshal(&umcb.Flags, buffer + 1, &hemf);
    ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
    wirehemf = buffer + 4;
    ok(*(DWORD *)wirehemf == WDT_REMOTE_CALL, "wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(DWORD *)wirehemf);
    wirehemf += sizeof(DWORD);
    ok(*(DWORD *)wirehemf == (DWORD)(DWORD_PTR)hemf, "wirestgm + 0x4 should be hemf instead of 0x%08x\n", *(DWORD *)wirehemf);
    wirehemf += sizeof(DWORD);
    ok(*(DWORD *)wirehemf == (size - 0x14), "wirestgm + 0x8 should be size - 0x14 instead of 0x%08x\n", *(DWORD *)wirehemf);
    wirehemf += sizeof(DWORD);
    ok(*(DWORD *)wirehemf == (size - 0x14), "wirestgm + 0xc should be size - 0x14 instead of 0x%08x\n", *(DWORD *)wirehemf);
    wirehemf += sizeof(DWORD);
    ok(*(DWORD *)wirehemf == EMR_HEADER, "wirestgm + 0x10 should be EMR_HEADER instead of %d\n", *(DWORD *)wirehemf);
    /* ... rest of data not tested - refer to tests for GetEnhMetaFileBits
     * at this point */
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    buffer_end = HENHMETAFILE_UserUnmarshal(&umcb.Flags, buffer + 1, &hemf2);
    ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
    ok(hemf2 != NULL, "HENHMETAFILE didn't unmarshal\n");
    HeapFree(GetProcessHeap(), 0, buffer);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    HENHMETAFILE_UserFree(&umcb.Flags, &hemf2);
    DeleteEnhMetaFile(hemf);
 
    /* test NULL emf */
    hemf = NULL;
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    size = HENHMETAFILE_UserSize(&umcb.Flags, 1, &hemf);
    ok(size == 12, "size should be 12 bytes, not %d\n", size);
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    buffer_end = HENHMETAFILE_UserMarshal(&umcb.Flags, buffer + 1, &hemf);
    ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
    wirehemf = buffer + 4;
    ok(*(DWORD *)wirehemf == WDT_REMOTE_CALL, "wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(DWORD *)wirehemf);
    wirehemf += sizeof(DWORD);
    ok(*(DWORD *)wirehemf == (DWORD)(DWORD_PTR)hemf, "wirestgm + 0x4 should be hemf instead of 0x%08x\n", *(DWORD *)wirehemf);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    buffer_end = HENHMETAFILE_UserUnmarshal(&umcb.Flags, buffer + 1, &hemf2);
    ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
    ok(hemf2 == NULL, "NULL HENHMETAFILE didn't unmarshal\n");
    HeapFree(GetProcessHeap(), 0, buffer);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    HENHMETAFILE_UserFree(&umcb.Flags, &hemf2);
}

Referenced by START_TEST().

test_marshal_HGLOBAL()

static void test_marshal_HGLOBAL ( void  )

static

Definition at line 256 of file usrmarshal.c.

{
    USER_MARSHAL_CB umcb;
    MIDL_STUB_MESSAGE stub_msg;
    RPC_MESSAGE rpc_msg;
    unsigned char *buffer;
    ULONG size, block_size;
    HGLOBAL hglobal;
    HGLOBAL hglobal2;
    unsigned char *wirehglobal;
    int i;
 
    hglobal = NULL;
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    size = HGLOBAL_UserSize(&umcb.Flags, 0, &hglobal);
    /* native is poorly programmed and allocates 4/8 bytes more than it needs to
     * here - Wine doesn't have to emulate that */
    ok((size == 8) || broken(size == 12) || broken(size == 16), "Size should be 8, instead of %d\n", size);
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
    HGLOBAL_UserMarshal(&umcb.Flags, buffer, &hglobal);
    wirehglobal = buffer;
    ok(*(ULONG *)wirehglobal == WDT_REMOTE_CALL, "Context should be WDT_REMOTE_CALL instead of 0x%08x\n", *(ULONG *)wirehglobal);
    wirehglobal += sizeof(ULONG);
    ok(*(ULONG *)wirehglobal == 0, "buffer+4 should be HGLOBAL\n");
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
    hglobal2 = NULL;
    HGLOBAL_UserUnmarshal(&umcb.Flags, buffer, &hglobal2);
    ok(hglobal2 == hglobal, "Didn't unmarshal properly\n");
    HeapFree(GetProcessHeap(), 0, buffer);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    HGLOBAL_UserFree(&umcb.Flags, &hglobal2);
 
 
    for(block_size = 0; block_size <= 17; block_size++)
    {
        ULONG actual_size, expected_size;
 
        hglobal = GlobalAlloc(0, block_size);
        buffer = GlobalLock(hglobal);
        for (i = 0; i < block_size; i++)
            buffer[i] = i;
        GlobalUnlock(hglobal);
        actual_size = GlobalSize(hglobal);
        expected_size = actual_size + 5 * sizeof(DWORD);
        init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
        size = HGLOBAL_UserSize(&umcb.Flags, 0, &hglobal);
        /* native is poorly programmed and allocates 4/8 bytes more than it needs to
         * here - Wine doesn't have to emulate that */
        ok(size == expected_size ||
           broken(size == expected_size + 4) ||
           broken(size == expected_size + 8),
           "%d: got size %d\n", block_size, size);
        buffer = HeapAlloc(GetProcessHeap(), 0, size);
        init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
        HGLOBAL_UserMarshal(&umcb.Flags, buffer, &hglobal);
        wirehglobal = buffer;
        ok(*(ULONG *)wirehglobal == WDT_REMOTE_CALL, "Context should be WDT_REMOTE_CALL instead of 0x%08x\n", *(ULONG *)wirehglobal);
        wirehglobal += sizeof(ULONG);
        ok(*(ULONG *)wirehglobal == (ULONG)(ULONG_PTR)hglobal, "buffer+0x4 should be HGLOBAL\n");
        wirehglobal += sizeof(ULONG);
        ok(*(ULONG *)wirehglobal == actual_size, "%d: buffer+0x8 %08x\n", block_size, *(ULONG *)wirehglobal);
        wirehglobal += sizeof(ULONG);
        ok(*(ULONG *)wirehglobal == (ULONG)(ULONG_PTR)hglobal, "buffer+0xc should be HGLOBAL\n");
        wirehglobal += sizeof(ULONG);
        ok(*(ULONG *)wirehglobal == actual_size, "%d: buffer+0x10 %08x\n", block_size, *(ULONG *)wirehglobal);
        wirehglobal += sizeof(ULONG);
        for (i = 0; i < block_size; i++)
            ok(wirehglobal[i] == i, "buffer+0x%x should be %d\n", 0x10 + i, i);
 
        init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
        hglobal2 = NULL;
        HGLOBAL_UserUnmarshal(&umcb.Flags, buffer, &hglobal2);
        ok(hglobal2 != NULL, "Didn't unmarshal properly\n");
        HeapFree(GetProcessHeap(), 0, buffer);
        init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
        HGLOBAL_UserFree(&umcb.Flags, &hglobal2);
        GlobalFree(hglobal);
    }
}

Referenced by START_TEST().

test_marshal_HICON()

static void test_marshal_HICON ( void  )

static

Definition at line 1130 of file usrmarshal.c.

{
    static const BYTE bmp_bits[1024];
    MIDL_STUB_MESSAGE stub_msg;
    HICON hIcon, hIcon2;
    USER_MARSHAL_CB umcb;
    RPC_MESSAGE rpc_msg;
    unsigned char *buffer, *buffer_end;
    wireHICON wirehicon;
    ULONG size;
 
    hIcon = CreateIcon(0, 16, 16, 1, 1, bmp_bits, bmp_bits);
    ok(hIcon != 0, "CreateIcon failed\n");
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    size = HICON_UserSize(&umcb.Flags, 1, &hIcon);
    ok(size == 4 + sizeof(*wirehicon), "Wrong size %d\n", size);
 
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
    buffer_end = HICON_UserMarshal(&umcb.Flags, buffer + 1, &hIcon);
    ok(buffer_end == buffer + 4 + sizeof(*wirehicon), "got %p buffer %p\n", buffer_end, buffer);
    wirehicon = (wireHICON)(buffer + 4);
    ok(wirehicon->fContext == WDT_INPROC_CALL, "Context should be WDT_INPROC_CALL instead of 0x%08x\n", wirehicon->fContext);
    ok(wirehicon->u.hInproc == (LONG_PTR)hIcon, "Marshaled value should be %p instead of %x\n", hIcon, wirehicon->u.hRemote);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
    buffer_end = HICON_UserUnmarshal(&umcb.Flags, buffer + 1, &hIcon2);
    ok(buffer_end == buffer + 4 + sizeof(*wirehicon), "got %p buffer %p\n", buffer_end, buffer);
    ok(hIcon == hIcon2, "Didn't unmarshal properly\n");
    HeapFree(GetProcessHeap(), 0, buffer);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    HICON_UserFree(&umcb.Flags, &hIcon2);
    DestroyIcon(hIcon);
}

Referenced by START_TEST().

test_marshal_HMETAFILE()

static void test_marshal_HMETAFILE ( void  )

static

Definition at line 419 of file usrmarshal.c.

{
    USER_MARSHAL_CB umcb;
    MIDL_STUB_MESSAGE stub_msg;
    RPC_MESSAGE rpc_msg;
    unsigned char *buffer;
    ULONG size;
    HMETAFILE hmf;
    HMETAFILE hmf2 = NULL;
    unsigned char *wirehmf;
 
    hmf = create_mf();
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    size = HMETAFILE_UserSize(&umcb.Flags, 0, &hmf);
    ok(size > 20, "size should be at least 20 bytes, not %d\n", size);
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    HMETAFILE_UserMarshal(&umcb.Flags, buffer, &hmf);
    wirehmf = buffer;
    ok(*(DWORD *)wirehmf == WDT_REMOTE_CALL, "wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(DWORD *)wirehmf);
    wirehmf += sizeof(DWORD);
    ok(*(DWORD *)wirehmf == (DWORD)(DWORD_PTR)hmf, "wirestgm + 0x4 should be hmf instead of 0x%08x\n", *(DWORD *)wirehmf);
    wirehmf += sizeof(DWORD);
    ok(*(DWORD *)wirehmf == (size - 0x10), "wirestgm + 0x8 should be size - 0x10 instead of 0x%08x\n", *(DWORD *)wirehmf);
    wirehmf += sizeof(DWORD);
    ok(*(DWORD *)wirehmf == (size - 0x10), "wirestgm + 0xc should be size - 0x10 instead of 0x%08x\n", *(DWORD *)wirehmf);
    wirehmf += sizeof(DWORD);
    ok(*(WORD *)wirehmf == 1, "wirestgm + 0x10 should be 1 instead of 0x%08x\n", *(DWORD *)wirehmf);
    wirehmf += sizeof(DWORD);
    /* ... rest of data not tested - refer to tests for GetMetaFileBits
     * at this point */
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    HMETAFILE_UserUnmarshal(&umcb.Flags, buffer, &hmf2);
    ok(hmf2 != NULL, "HMETAFILE didn't unmarshal\n");
    HeapFree(GetProcessHeap(), 0, buffer);
    HMETAFILE_UserFree(&umcb.Flags, &hmf2);
    DeleteMetaFile(hmf);
 
    /* test NULL emf */
    hmf = NULL;
 
    size = HMETAFILE_UserSize(&umcb.Flags, 0, &hmf);
    ok(size == 8, "size should be 8 bytes, not %d\n", size);
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    HMETAFILE_UserMarshal(&umcb.Flags, buffer, &hmf);
    wirehmf = buffer;
    ok(*(DWORD *)wirehmf == WDT_REMOTE_CALL, "wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(DWORD *)wirehmf);
    wirehmf += sizeof(DWORD);
    ok(*(DWORD *)wirehmf == (DWORD)(DWORD_PTR)hmf, "wirestgm + 0x4 should be hmf instead of 0x%08x\n", *(DWORD *)wirehmf);
    wirehmf += sizeof(DWORD);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    HMETAFILE_UserUnmarshal(&umcb.Flags, buffer, &hmf2);
    ok(hmf2 == NULL, "NULL HMETAFILE didn't unmarshal\n");
    HeapFree(GetProcessHeap(), 0, buffer);
    HMETAFILE_UserFree(&umcb.Flags, &hmf2);
}

Referenced by START_TEST().

test_marshal_HMETAFILEPICT()

static void test_marshal_HMETAFILEPICT ( void  )

static

Definition at line 484 of file usrmarshal.c.

{
    USER_MARSHAL_CB umcb;
    MIDL_STUB_MESSAGE stub_msg;
    RPC_MESSAGE rpc_msg;
    unsigned char *buffer, *buffer_end;
    ULONG size;
    HMETAFILEPICT hmfp;
    HMETAFILEPICT hmfp2 = NULL;
    METAFILEPICT *pmfp;
    unsigned char *wirehmfp;
 
    hmfp = GlobalAlloc(GMEM_MOVEABLE, sizeof(*pmfp));
    pmfp = GlobalLock(hmfp);
    pmfp->mm = MM_ISOTROPIC;
    pmfp->xExt = 1;
    pmfp->yExt = 2;
    pmfp->hMF = create_mf();
    GlobalUnlock(hmfp);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    size = HMETAFILEPICT_UserSize(&umcb.Flags, 1, &hmfp);
    ok(size > 24, "size should be at least 24 bytes, not %d\n", size);
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    buffer_end = HMETAFILEPICT_UserMarshal(&umcb.Flags, buffer + 1, &hmfp);
    wirehmfp = buffer + 4;
    ok(*(DWORD *)wirehmfp == WDT_REMOTE_CALL, "wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(DWORD *)wirehmfp);
    wirehmfp += sizeof(DWORD);
    ok(*(DWORD *)wirehmfp == (DWORD)(DWORD_PTR)hmfp, "wirestgm + 0x4 should be hmf instead of 0x%08x\n", *(DWORD *)wirehmfp);
    wirehmfp += sizeof(DWORD);
    ok(*(DWORD *)wirehmfp == MM_ISOTROPIC, "wirestgm + 0x8 should be MM_ISOTROPIC instead of 0x%08x\n", *(DWORD *)wirehmfp);
    wirehmfp += sizeof(DWORD);
    ok(*(DWORD *)wirehmfp == 1, "wirestgm + 0xc should be 1 instead of 0x%08x\n", *(DWORD *)wirehmfp);
    wirehmfp += sizeof(DWORD);
    ok(*(DWORD *)wirehmfp == 2, "wirestgm + 0x10 should be 2 instead of 0x%08x\n", *(DWORD *)wirehmfp);
    wirehmfp += sizeof(DWORD);
    ok(*(DWORD *)wirehmfp == USER_MARSHAL_PTR_PREFIX, "wirestgm + 0x14 should be \"User\" instead of 0x%08x\n", *(DWORD *)wirehmfp);
    wirehmfp += sizeof(DWORD);
    ok(*(DWORD *)wirehmfp == WDT_REMOTE_CALL, "wirestgm + 0x18 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(DWORD *)wirehmfp);
    wirehmfp += sizeof(DWORD);
    pmfp = GlobalLock(hmfp);
    ok(*(DWORD *)wirehmfp == (DWORD)(DWORD_PTR)pmfp->hMF, "wirestgm + 0x1c should be pmfp->hMF instead of 0x%08x\n", *(DWORD *)wirehmfp);
    GlobalUnlock(hmfp);
    wirehmfp += sizeof(DWORD);
    /* Note use (buffer_end - buffer) instead of size here, because size is an
     * overestimate with native */
    ok(*(DWORD *)wirehmfp == (buffer_end - buffer - 0x2c), "wirestgm + 0x20 should be size - 0x34 instead of 0x%08x\n", *(DWORD *)wirehmfp);
    wirehmfp += sizeof(DWORD);
    ok(*(DWORD *)wirehmfp == (buffer_end - buffer - 0x2c), "wirestgm + 0x24 should be size - 0x34 instead of 0x%08x\n", *(DWORD *)wirehmfp);
    wirehmfp += sizeof(DWORD);
    ok(*(WORD *)wirehmfp == 1, "wirehmfp + 0x28 should be 1 instead of 0x%08x\n", *(DWORD *)wirehmfp);
    /* ... rest of data not tested - refer to tests for GetMetaFileBits
     * at this point */
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    HMETAFILEPICT_UserUnmarshal(&umcb.Flags, buffer + 1, &hmfp2);
    ok(hmfp2 != NULL, "HMETAFILEPICT didn't unmarshal\n");
    HeapFree(GetProcessHeap(), 0, buffer);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    HMETAFILEPICT_UserFree(&umcb.Flags, &hmfp2);
    pmfp = GlobalLock(hmfp);
    DeleteMetaFile(pmfp->hMF);
    GlobalUnlock(hmfp);
    GlobalFree(hmfp);
 
    /* test NULL emf */
    hmfp = NULL;
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    size = HMETAFILEPICT_UserSize(&umcb.Flags, 1, &hmfp);
    ok(size == 12, "size should be 12 bytes, not %d\n", size);
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    buffer_end = HMETAFILEPICT_UserMarshal(&umcb.Flags, buffer + 1, &hmfp);
    ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
    wirehmfp = buffer + 4;
    ok(*(DWORD *)wirehmfp == WDT_REMOTE_CALL, "wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(DWORD *)wirehmfp);
    wirehmfp += sizeof(DWORD);
    ok(*(DWORD *)wirehmfp == (DWORD)(DWORD_PTR)hmfp, "wirestgm + 0x4 should be hmf instead of 0x%08x\n", *(DWORD *)wirehmfp);
    wirehmfp += sizeof(DWORD);
 
    hmfp2 = NULL;
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
    buffer_end = HMETAFILEPICT_UserUnmarshal(&umcb.Flags, buffer + 1, &hmfp2);
    ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
    ok(hmfp2 == NULL, "NULL HMETAFILE didn't unmarshal\n");
    HeapFree(GetProcessHeap(), 0, buffer);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
    HMETAFILEPICT_UserFree(&umcb.Flags, &hmfp2);
}

Referenced by START_TEST().

test_marshal_HWND()

static void test_marshal_HWND ( void  )

static

Definition at line 223 of file usrmarshal.c.

{
    USER_MARSHAL_CB umcb;
    MIDL_STUB_MESSAGE stub_msg;
    RPC_MESSAGE rpc_msg;
    unsigned char *buffer, *buffer_end;
    ULONG size;
    HWND hwnd = GetDesktopWindow();
    HWND hwnd2;
    wireHWND wirehwnd;
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    size = HWND_UserSize(&umcb.Flags, 1, &hwnd);
    ok(size == 4 + sizeof(*wirehwnd), "Wrong size %d\n", size);
 
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
    buffer_end = HWND_UserMarshal(&umcb.Flags, buffer + 1, &hwnd);
    ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
    wirehwnd = (wireHWND)(buffer + 4);
    ok(wirehwnd->fContext == WDT_INPROC_CALL, "Context should be WDT_INPROC_CALL instead of 0x%08x\n", wirehwnd->fContext);
    ok(wirehwnd->u.hInproc == (LONG_PTR)hwnd, "Marshaled value should be %p instead of %x\n", hwnd, wirehwnd->u.hRemote);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
    buffer_end = HWND_UserUnmarshal(&umcb.Flags, buffer + 1, &hwnd2);
    ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
    ok(hwnd == hwnd2, "Didn't unmarshal properly\n");
    HeapFree(GetProcessHeap(), 0, buffer);
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    HWND_UserFree(&umcb.Flags, &hwnd2);
}

Referenced by START_TEST().

test_marshal_SNB()

static void test_marshal_SNB ( void  )

static

Definition at line 997 of file usrmarshal.c.

{
    static const WCHAR str1W[] = {'s','t','r','i','n','g','1',0};
    static const WCHAR str2W[] = {'s','t','r','2',0};
    unsigned char *buffer, *src, *mbuf;
    MIDL_STUB_MESSAGE stub_msg;
    WCHAR **ptrW, *dataW;
    USER_MARSHAL_CB umcb;
    RPC_MESSAGE rpc_msg;
    RemSNB *wiresnb;
    SNB snb, snb2;
    ULONG size;
 
    /* 4 bytes alignment */
    snb = NULL;
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    size = SNB_UserSize(&umcb.Flags, 3, &snb);
    ok(size == 16, "Size should be 16, instead of %d\n", size);
 
    /* NULL block */
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    size = SNB_UserSize(&umcb.Flags, 0, &snb);
    ok(size == 12, "Size should be 12, instead of %d\n", size);
 
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
    mbuf = SNB_UserMarshal(&umcb.Flags, buffer, &snb);
    ok(mbuf == buffer + size, "got %p, %p\n", mbuf, buffer + size);
 
    wiresnb = (RemSNB*)buffer;
    ok(wiresnb->ulCntStr == 0, "got %u\n", wiresnb->ulCntStr);
    ok(wiresnb->ulCntChar == 0, "got %u\n", wiresnb->ulCntChar);
    ok(*(ULONG*)wiresnb->rgString == 0, "got %u\n", *(ULONG*)wiresnb->rgString);
 
    snb2 = NULL;
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
    SNB_UserUnmarshal(&umcb.Flags, buffer, &snb2);
    ok(snb2 == NULL, "got %p\n", snb2);
 
    HeapFree(GetProcessHeap(), 0, buffer);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    SNB_UserFree(&umcb.Flags, &snb2);
 
    /* block with actual data */
 
    /* allocate source block, n+1 pointers first, then data */
    src = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR*)*3 + sizeof(str1W) + sizeof(str2W));
    ptrW = (WCHAR**)src;
    dataW = *ptrW = (WCHAR*)(src + 3*sizeof(WCHAR*));
    ptrW++;
    *ptrW = (WCHAR*)(src + 3*sizeof(WCHAR*) + sizeof(str1W));
    ptrW++;
    *ptrW = NULL;
    lstrcpyW(dataW, str1W);
    dataW += lstrlenW(str1W) + 1;
    lstrcpyW(dataW, str2W);
 
    snb = (SNB)src;
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
    size = SNB_UserSize(&umcb.Flags, 0, &snb);
    ok(size == 38, "Size should be 38, instead of %d\n", size);
 
    buffer = HeapAlloc(GetProcessHeap(), 0, size);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
    SNB_UserMarshal(&umcb.Flags, buffer, &snb);
 
    wiresnb = (RemSNB*)buffer;
    ok(wiresnb->ulCntStr == 13, "got %u\n", wiresnb->ulCntStr);
    ok(wiresnb->ulCntChar == 2, "got %u\n", wiresnb->ulCntChar);
    /* payload length is stored one more time, as ULONG */
    ok(*(ULONG*)wiresnb->rgString == wiresnb->ulCntStr, "got %u\n", *(ULONG*)wiresnb->rgString);
    dataW = &wiresnb->rgString[2];
    ok(!lstrcmpW(dataW, str1W), "marshalled string 0: %s\n", wine_dbgstr_w(dataW));
    dataW += ARRAY_SIZE(str1W);
    ok(!lstrcmpW(dataW, str2W), "marshalled string 1: %s\n", wine_dbgstr_w(dataW));
 
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
 
    g_expect_user_alloc = TRUE;
    snb2 = NULL;
    SNB_UserUnmarshal(&umcb.Flags, buffer, &snb2);
    g_expect_user_alloc = FALSE;
 
    ptrW = snb2;
    ok(!lstrcmpW(*ptrW, str1W), "unmarshalled string 0: %s\n", wine_dbgstr_w(*ptrW));
    ptrW++;
    ok(!lstrcmpW(*ptrW, str2W), "unmarshalled string 1: %s\n", wine_dbgstr_w(*ptrW));
    ptrW++;
    ok(*ptrW == NULL, "expected terminating NULL ptr, got %p, start %p\n", *ptrW, snb2);
 
    HeapFree(GetProcessHeap(), 0, buffer);
    init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
 
    g_expect_user_free = TRUE;
    SNB_UserFree(&umcb.Flags, &snb2);
    g_expect_user_free = FALSE;
 
    HeapFree(GetProcessHeap(), 0, src);
}

Referenced by START_TEST().

test_marshal_STGMEDIUM()

static void test_marshal_STGMEDIUM ( void  )

static

Definition at line 984 of file usrmarshal.c.

{
    marshal_STGMEDIUM(0, 0, 0);
    marshal_STGMEDIUM(0, 0, 1);
    marshal_STGMEDIUM(0, 1, 0);
    marshal_STGMEDIUM(0, 1, 1);
    /* For Windows versions post 2003, client side, non-[in,out] STGMEDIUMs get zero-initialised.
       However since inline stubs don't set fIsIn or fIsOut this behaviour would break
       ref counting in GetDataHere_Proxy for example, as we'd end up not releasing the original
       interface.  For simplicity we don't test or implement this. */
    marshal_STGMEDIUM(1, 1, 1);
}

Referenced by START_TEST().

test_marshal_WdtpInterfacePointer()

static void test_marshal_WdtpInterfacePointer ( void  )

static

Definition at line 766 of file usrmarshal.c.

{
    /*
     * There are two places where we can pass the marshalling ctx: as
     * part of the umcb and as a separate flag.  The loword of that
     * separate flag field is what matters.
     */
 
    /* All three are marshalled as inproc */
    marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_INPROC, 0,0,0);
    marshal_WdtpInterfacePointer(MSHCTX_DIFFERENTMACHINE, MSHCTX_INPROC,0,0,0);
    marshal_WdtpInterfacePointer(MSHCTX_INPROC, MAKELONG(MSHCTX_INPROC, 0xffff),0,0,0);
 
    /* All three are marshalled as remote */
    marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,0,0,0);
    marshal_WdtpInterfacePointer(MSHCTX_DIFFERENTMACHINE, MSHCTX_DIFFERENTMACHINE,0,0,0);
    marshal_WdtpInterfacePointer(MSHCTX_INPROC, MAKELONG(MSHCTX_DIFFERENTMACHINE, 0xffff),0,0,0);
 
    /* Test different combinations of client, in and out */
    marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,0,0,1);
    marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,0,1,0);
    marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,0,1,1);
    marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,1,0,0);
    marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,1,0,1);
    marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,1,1,0);
    marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,1,1,1);
}

Referenced by START_TEST().

user_allocate()

static void *WINAPI user_allocate ( SIZE_T  size )

static

Definition at line 53 of file usrmarshal.c.

{
    ok(g_expect_user_alloc, "unexpected user_allocate call\n");
    return CoTaskMemAlloc(size);
}

Referenced by init_user_marshal_cb().

user_free()

static void WINAPI user_free ( void *  p )

static

Definition at line 60 of file usrmarshal.c.

{
    ok(g_expect_user_free, "unexpected user_free call\n");
    CoTaskMemFree(p);
}

Referenced by init_user_marshal_cb().

WdtpInterfacePointer_UserMarshal()

unsigned char *__RPC_USER WdtpInterfacePointer_UserMarshal	(	ULONG *	pFlags,
		ULONG	RealFlags,
		unsigned char *	pBuffer,
		IUnknown *	punk,
		REFIID	riid
	)

Definition at line 1550 of file usrmarshal.c.

{
    HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE, 0);
    IStream *stm;
    DWORD size;
    void *ptr;
 
    TRACE("(%s, 0x%x, %p, &%p, %s)\n", debugstr_user_flags(pFlags), RealFlags, pBuffer, punk, debugstr_guid(riid));
 
    if(!h) return NULL;
    if(CreateStreamOnHGlobal(h, TRUE, &stm) != S_OK)
    {
        GlobalFree(h);
        return NULL;
    }
 
    if(CoMarshalInterface(stm, riid, punk, LOWORD(RealFlags), NULL, MSHLFLAGS_NORMAL) != S_OK)
    {
        IStream_Release(stm);
        return pBuffer;
    }
 
    ALIGN_POINTER(pBuffer, 3);
    size = GlobalSize(h);
 
    *(DWORD *)pBuffer = size;
    pBuffer += sizeof(DWORD);
    *(DWORD *)pBuffer = size;
    pBuffer += sizeof(DWORD);
 
    ptr = GlobalLock(h);
    memcpy(pBuffer, ptr, size);
    GlobalUnlock(h);
 
    IStream_Release(stm);
    return pBuffer + size;
}

Referenced by interface_variant_marshal(), marshal_STGMEDIUM(), marshal_WdtpInterfacePointer(), and STGMEDIUM_UserMarshal().

WdtpInterfacePointer_UserSize()

ULONG __RPC_USER WdtpInterfacePointer_UserSize	(	ULONG *	pFlags,
		ULONG	RealFlags,
		ULONG	StartingSize,
		IUnknown *	punk,
		REFIID	riid
	)

Definition at line 1515 of file usrmarshal.c.

{
    DWORD marshal_size = 0;
    HRESULT hr;
 
    TRACE("(%s, 0%x, %d, %p, %s)\n", debugstr_user_flags(pFlags), RealFlags, StartingSize, punk, debugstr_guid(riid));
 
    hr = CoGetMarshalSizeMax(&marshal_size, riid, punk, LOWORD(RealFlags), NULL, MSHLFLAGS_NORMAL);
    if(FAILED(hr)) return StartingSize;
 
    ALIGN_LENGTH(StartingSize, 3);
    StartingSize += 2 * sizeof(DWORD);
    return StartingSize + marshal_size;
}

Referenced by interface_variant_size(), marshal_STGMEDIUM(), marshal_WdtpInterfacePointer(), and STGMEDIUM_UserSize().

WdtpInterfacePointer_UserUnmarshal()

unsigned char *__RPC_USER WdtpInterfacePointer_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		IUnknown **	ppunk,
		REFIID	riid
	)

Definition at line 1607 of file usrmarshal.c.

{
    HRESULT hr;
    HGLOBAL h;
    IStream *stm;
    DWORD size;
    void *ptr;
    IUnknown *orig;
 
    TRACE("(%s, %p, %p, %s)\n", debugstr_user_flags(pFlags), pBuffer, ppunk, debugstr_guid(riid));
 
    ALIGN_POINTER(pBuffer, 3);
 
    size = *(DWORD *)pBuffer;
    pBuffer += sizeof(DWORD);
    if(size != *(DWORD *)pBuffer)
        RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
 
    pBuffer += sizeof(DWORD);
 
    /* FIXME: sanity check on size */
 
    h = GlobalAlloc(GMEM_MOVEABLE, size);
    if(!h) RaiseException(RPC_X_NO_MEMORY, 0, 0, NULL);
 
    if(CreateStreamOnHGlobal(h, TRUE, &stm) != S_OK)
    {
        GlobalFree(h);
        RaiseException(RPC_X_NO_MEMORY, 0, 0, NULL);
    }
 
    ptr = GlobalLock(h);
    memcpy(ptr, pBuffer, size);
    GlobalUnlock(h);
 
    orig = *ppunk;
    hr = CoUnmarshalInterface(stm, riid, (void**)ppunk);
    IStream_Release(stm);
 
    if(hr != S_OK) RaiseException(hr, 0, 0, NULL);
 
    if(orig) IUnknown_Release(orig);
 
    return pBuffer + size;
}

Referenced by interface_variant_unmarshal(), marshal_WdtpInterfacePointer(), and STGMEDIUM_UserUnmarshal().

Variable Documentation

cf_marshaled

const char cf_marshaled[]

static

Initial value:

=
{
    0x9, 0x0, 0x0, 0x0,
    0x0, 0x0, 0x0, 0x0,
    0x9, 0x0, 0x0, 0x0,
    'M', 0x0, 'y', 0x0,
    'F', 0x0, 'o', 0x0,
    'r', 0x0, 'm', 0x0,
    'a', 0x0, 't', 0x0,
    0x0, 0x0
}

Definition at line 173 of file usrmarshal.c.

Referenced by test_marshal_CLIPFORMAT().

g_expect_user_alloc

BOOL g_expect_user_alloc

static

Definition at line 52 of file usrmarshal.c.

Referenced by test_marshal_SNB(), and user_allocate().

g_expect_user_free

BOOL g_expect_user_free

static

Definition at line 59 of file usrmarshal.c.

Referenced by test_marshal_SNB(), and user_free().

obj

struct obj obj

static

Initial value:

=
{
    {&obj_data_object_vtbl}
}

Definition at line 1333 of file usrmarshal.c.

obj_data_object_vtbl

const IDataObjectVtbl obj_data_object_vtbl

static

Initial value:

=
{
    obj_QueryInterface,
    obj_AddRef,
    obj_Release,
    NULL, 
    obj_DO_GetDataHere,
    NULL, 
    NULL, 
    NULL, 
    NULL, 
    NULL, 
    NULL, 
    NULL  
}

Definition at line 1317 of file usrmarshal.c.

Test_Stream

struct test_stream Test_Stream = { {&TestStream_Vtbl}, 1 }

static

Definition at line 674 of file usrmarshal.c.

Referenced by marshal_STGMEDIUM(), and test_GetDataHere_Proxy().

Test_Stream2

struct test_stream Test_Stream2 = { {&TestStream_Vtbl}, 1 }

static

Definition at line 675 of file usrmarshal.c.

Referenced by marshal_STGMEDIUM(), obj_DO_GetDataHere(), and test_GetDataHere_Proxy().

Test_Unknown

TestUnknown Test_Unknown = { {&TestUnknown_Vtbl}, 1 }

static

Definition at line 672 of file usrmarshal.c.

Referenced by marshal_STGMEDIUM(), marshal_WdtpInterfacePointer(), and test_GetDataHere_Proxy().

Test_Unknown2

TestUnknown Test_Unknown2 = { {&TestUnknown_Vtbl}, 1 }

static

Definition at line 673 of file usrmarshal.c.

Referenced by marshal_STGMEDIUM(), and marshal_WdtpInterfacePointer().

TestStream_Vtbl

const IStreamVtbl TestStream_Vtbl

static

Initial value:

=
{
    Test_IStream_QueryInterface,
    Test_IStream_AddRef,
    Test_IStream_Release
    
}

Definition at line 664 of file usrmarshal.c.

TestUnknown_Vtbl

const IUnknownVtbl TestUnknown_Vtbl

static

Initial value:

=
{
    Test_IUnknown_QueryInterface,
    Test_IUnknown_AddRef,
    Test_IUnknown_Release,
}

Definition at line 617 of file usrmarshal.c.