usrmarshal.c File Reference

#include "ole2.h"
#include "wine/debug.h"

Include dependency graph for usrmarshal.c:

Go to the source code of this file.

Macros
#define	COBJMACROS
#define	ALIGNED_LENGTH(_Len, _Align)   (((_Len)+(_Align))&~(_Align))
#define	ALIGNED_POINTER(_Ptr, _Align)   ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
#define	ALIGN_LENGTH(_Len, _Align)   _Len = ALIGNED_LENGTH(_Len, _Align)
#define	ALIGN_POINTER(_Ptr, _Align)   _Ptr = ALIGNED_POINTER(_Ptr, _Align)
#define	IMPL_WIREM_HANDLE(type)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
static const char *	debugstr_user_flags (ULONG *pFlags)
static ULONG	handle_UserSize (ULONG *pFlags, ULONG StartingSize, HANDLE *handle)
static unsigned char *	handle_UserMarshal (ULONG *pFlags, unsigned char *pBuffer, HANDLE *handle)
static unsigned char *	handle_UserUnmarshal (ULONG *pFlags, unsigned char *pBuffer, HANDLE *handle)
static void	handle_UserFree (ULONG *pFlags, HANDLE *handle)
ULONG __RPC_USER	CLIPFORMAT_UserSize (ULONG *pFlags, ULONG size, CLIPFORMAT *pCF)
unsigned char *__RPC_USER	CLIPFORMAT_UserMarshal (ULONG *pFlags, unsigned char *pBuffer, CLIPFORMAT *pCF)
unsigned char *__RPC_USER	CLIPFORMAT_UserUnmarshal (ULONG *pFlags, unsigned char *pBuffer, CLIPFORMAT *pCF)
void __RPC_USER	CLIPFORMAT_UserFree (ULONG *pFlags, CLIPFORMAT *pCF)
ULONG __RPC_USER	HBITMAP_UserSize (ULONG *flags, ULONG size, HBITMAP *bmp)
unsigned char *__RPC_USER	HBITMAP_UserMarshal (ULONG *flags, unsigned char *buffer, HBITMAP *bmp)
unsigned char *__RPC_USER	HBITMAP_UserUnmarshal (ULONG *flags, unsigned char *buffer, HBITMAP *bmp)
void __RPC_USER	HBITMAP_UserFree (ULONG *flags, HBITMAP *bmp)
ULONG __RPC_USER	HPALETTE_UserSize (ULONG *pFlags, ULONG StartingSize, HPALETTE *phPal)
unsigned char *__RPC_USER	HPALETTE_UserMarshal (ULONG *pFlags, unsigned char *pBuffer, HPALETTE *phPal)
unsigned char *__RPC_USER	HPALETTE_UserUnmarshal (ULONG *pFlags, unsigned char *pBuffer, HPALETTE *phPal)
ULONG __RPC_USER	HGLOBAL_UserSize (ULONG *pFlags, ULONG StartingSize, HGLOBAL *phGlobal)
unsigned char *__RPC_USER	HGLOBAL_UserMarshal (ULONG *pFlags, unsigned char *pBuffer, HGLOBAL *phGlobal)
unsigned char *__RPC_USER	HGLOBAL_UserUnmarshal (ULONG *pFlags, unsigned char *pBuffer, HGLOBAL *phGlobal)
void __RPC_USER	HGLOBAL_UserFree (ULONG *pFlags, HGLOBAL *phGlobal)
void __RPC_USER	HPALETTE_UserFree (ULONG *pFlags, HPALETTE *phPal)
ULONG __RPC_USER	WdtpInterfacePointer_UserSize (ULONG *pFlags, ULONG RealFlags, ULONG StartingSize, IUnknown *punk, REFIID riid)
unsigned char *WINAPI	WdtpInterfacePointer_UserMarshal (ULONG *pFlags, ULONG RealFlags, unsigned char *pBuffer, IUnknown *punk, REFIID riid)
unsigned char *WINAPI	WdtpInterfacePointer_UserUnmarshal (ULONG *pFlags, unsigned char *pBuffer, IUnknown **ppunk, REFIID riid)
void WINAPI	WdtpInterfacePointer_UserFree (IUnknown *punk)

Macro Definition Documentation

ALIGN_LENGTH

#define ALIGN_LENGTH	(		_Len,
			_Align
	)		_Len = ALIGNED_LENGTH(_Len, _Align)

Definition at line 31 of file usrmarshal.c.

ALIGN_POINTER

#define ALIGN_POINTER	(		_Ptr,
			_Align
	)		_Ptr = ALIGNED_POINTER(_Ptr, _Align)

Definition at line 32 of file usrmarshal.c.

ALIGNED_LENGTH

#define ALIGNED_LENGTH	(		_Len,
			_Align
	)		(((_Len)+(_Align))&~(_Align))

Definition at line 29 of file usrmarshal.c.

ALIGNED_POINTER

#define ALIGNED_POINTER	(		_Ptr,
			_Align
	)		((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))

Definition at line 30 of file usrmarshal.c.

COBJMACROS

#define COBJMACROS

Definition at line 22 of file usrmarshal.c.

IMPL_WIREM_HANDLE

#define IMPL_WIREM_HANDLE

(

type

)

Value:

    ULONG __RPC_USER type##_UserSize(ULONG *pFlags, ULONG StartingSize, type *handle) \
    { \
        TRACE("%s, %lu, %p.\n", debugstr_user_flags(pFlags), StartingSize, handle); \
        return handle_UserSize(pFlags, StartingSize, (HANDLE *)handle); \
    } \
    \
    unsigned char * __RPC_USER type##_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, type *handle) \
    { \
        TRACE("%s, %p, &%p.\n", debugstr_user_flags(pFlags), pBuffer, *handle); \
        return handle_UserMarshal(pFlags, pBuffer, (HANDLE *)handle); \
    } \
    \
    unsigned char * __RPC_USER type##_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, type *handle) \
    { \
        TRACE("%s, %p, %p.\n", debugstr_user_flags(pFlags), pBuffer, handle); \
        return handle_UserUnmarshal(pFlags, pBuffer, (HANDLE *)handle); \
    } \
    \
    void __RPC_USER type##_UserFree(ULONG *pFlags, type *handle) \
    { \
        TRACE("%s, &%p.\n", debugstr_user_flags(pFlags), *handle); \
        handle_UserFree(pFlags, (HANDLE *)handle); \
    }

Definition at line 110 of file usrmarshal.c.

Function Documentation

CLIPFORMAT_UserFree()

void __RPC_USER CLIPFORMAT_UserFree	(	ULONG *	pFlags,
		CLIPFORMAT *	pCF
	)

Definition at line 336 of file usrmarshal.c.

{
    /* there is no inverse of the RegisterClipboardFormat function,
     * so nothing to do */
}

Referenced by test_marshal_CLIPFORMAT().

CLIPFORMAT_UserMarshal()

unsigned char *__RPC_USER CLIPFORMAT_UserMarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		CLIPFORMAT *	pCF
	)

Definition at line 207 of file usrmarshal.c.

{
    TRACE("%s, %p, &0x%04x.\n", debugstr_user_flags(pFlags), pBuffer, *pCF);
 
    ALIGN_POINTER(pBuffer, 3);
 
    /* only need to marshal the name if it is not a pre-defined type and
     * we are going remote */
    if ((*pCF >= 0xc000) && (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE))
    {
        WCHAR format[255];
        UINT len;
 
        *(DWORD *)pBuffer = WDT_REMOTE_CALL;
        pBuffer += 4;
        *(DWORD *)pBuffer = *pCF;
        pBuffer += 4;
 
        len = GetClipboardFormatNameW(*pCF, format, ARRAY_SIZE(format)-1);
        if (!len)
            RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL);
        len += 1;
        *(UINT *)pBuffer = len;
        pBuffer += sizeof(UINT);
        *(UINT *)pBuffer = 0;
        pBuffer += sizeof(UINT);
        *(UINT *)pBuffer = len;
        pBuffer += sizeof(UINT);
        TRACE("marshaling format name %s\n", debugstr_w(format));
        memcpy(pBuffer, format, len * sizeof(WCHAR));
        pBuffer += len * sizeof(WCHAR);
    }
    else
    {
        *(DWORD *)pBuffer = WDT_INPROC_CALL;
        pBuffer += 4;
        *(DWORD *)pBuffer = *pCF;
        pBuffer += 4;
    }
 
    return pBuffer;
}

Referenced by test_marshal_CLIPFORMAT().

CLIPFORMAT_UserSize()

ULONG __RPC_USER CLIPFORMAT_UserSize	(	ULONG *	pFlags,
		ULONG	size,
		CLIPFORMAT *	pCF
	)

Definition at line 162 of file usrmarshal.c.

{
    TRACE("%s, %lu, %p.\n", debugstr_user_flags(pFlags), size, pCF);
 
    ALIGN_LENGTH(size, 3);
 
    size += 8;
 
    /* only need to marshal the name if it is not a pre-defined type and
     * we are going remote */
    if ((*pCF >= 0xc000) && (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE))
    {
        WCHAR format[255];
        INT ret;
        size += 3 * sizeof(UINT);
        /* urg! this function is badly designed because it won't tell us how
         * much space is needed without doing a dummy run of storing the
         * name into a buffer */
        ret = GetClipboardFormatNameW(*pCF, format, ARRAY_SIZE(format)-1);
        if (!ret)
            RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL);
        size += (ret + 1) * sizeof(WCHAR);
    }
    return size;
}

Referenced by test_marshal_CLIPFORMAT().

CLIPFORMAT_UserUnmarshal()

unsigned char *__RPC_USER CLIPFORMAT_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		CLIPFORMAT *	pCF
	)

Definition at line 269 of file usrmarshal.c.

{
    LONG fContext;
 
    TRACE("%s, %p, %p.\n", debugstr_user_flags(pFlags), pBuffer, pCF);
 
    ALIGN_POINTER(pBuffer, 3);
 
    fContext = *(DWORD *)pBuffer;
    pBuffer += 4;
 
    if (fContext == WDT_INPROC_CALL)
    {
        *pCF = *(CLIPFORMAT *)pBuffer;
        pBuffer += 4;
    }
    else if (fContext == WDT_REMOTE_CALL)
    {
        CLIPFORMAT cf;
        UINT len;
 
        /* pointer ID for registered clip format string */
        if (*(DWORD *)pBuffer == 0)
            RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
        pBuffer += 4;
 
        len = *(UINT *)pBuffer;
        pBuffer += sizeof(UINT);
        if (*(UINT *)pBuffer != 0)
            RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
        pBuffer += sizeof(UINT);
        if (*(UINT *)pBuffer != len)
            RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
        pBuffer += sizeof(UINT);
        if (((WCHAR *)pBuffer)[len - 1] != '\0')
            RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
        TRACE("unmarshaling clip format %s\n", debugstr_w((LPCWSTR)pBuffer));
        cf = RegisterClipboardFormatW((LPCWSTR)pBuffer);
        pBuffer += len * sizeof(WCHAR);
        if (!cf)
            RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL);
        *pCF = cf;
    }
    else
        /* code not really appropriate, but nearest I can find */
        RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
    return pBuffer;
}

Referenced by test_marshal_CLIPFORMAT().

debugstr_user_flags()

static const char * debugstr_user_flags ( ULONG *  pFlags )

static

Definition at line 34 of file usrmarshal.c.

{
    char buf[12];
    const char* loword;
    switch (LOWORD(*pFlags))
    {
    case MSHCTX_LOCAL:
        loword = "MSHCTX_LOCAL";
        break;
    case MSHCTX_NOSHAREDMEM:
        loword = "MSHCTX_NOSHAREDMEM";
        break;
    case MSHCTX_DIFFERENTMACHINE:
        loword = "MSHCTX_DIFFERENTMACHINE";
        break;
    case MSHCTX_INPROC:
        loword = "MSHCTX_INPROC";
        break;
    default:
        sprintf(buf, "%d", LOWORD(*pFlags));
        loword=buf;
    }
 
    if (HIWORD(*pFlags) == NDR_LOCAL_DATA_REPRESENTATION)
        return wine_dbg_sprintf("MAKELONG(%s, NDR_LOCAL_DATA_REPRESENTATION)", loword);
    else
        return wine_dbg_sprintf("MAKELONG(%s, 0x%04x)", loword, HIWORD(*pFlags));
}

Referenced by CLIPFORMAT_UserMarshal(), CLIPFORMAT_UserSize(), CLIPFORMAT_UserUnmarshal(), HBITMAP_UserFree(), HBITMAP_UserMarshal(), HBITMAP_UserSize(), HBITMAP_UserUnmarshal(), HENHMETAFILE_UserFree(), HENHMETAFILE_UserMarshal(), HENHMETAFILE_UserSize(), HENHMETAFILE_UserUnmarshal(), HGLOBAL_UserFree(), HGLOBAL_UserMarshal(), HGLOBAL_UserSize(), HGLOBAL_UserUnmarshal(), HMETAFILE_UserFree(), HMETAFILE_UserMarshal(), HMETAFILE_UserSize(), HMETAFILE_UserUnmarshal(), HMETAFILEPICT_UserFree(), HMETAFILEPICT_UserMarshal(), HMETAFILEPICT_UserSize(), HMETAFILEPICT_UserUnmarshal(), SNB_UserMarshal(), SNB_UserSize(), SNB_UserUnmarshal(), STGMEDIUM_UserFree(), STGMEDIUM_UserMarshal(), STGMEDIUM_UserSize(), STGMEDIUM_UserUnmarshal(), WdtpInterfacePointer_UserMarshal(), WdtpInterfacePointer_UserSize(), and WdtpInterfacePointer_UserUnmarshal().

handle_UserFree()

static void handle_UserFree ( ULONG *  pFlags, HANDLE *  handle  )

static

Definition at line 105 of file usrmarshal.c.

{
    /* nothing to do */
}

handle_UserMarshal()

static unsigned char * handle_UserMarshal ( ULONG *  pFlags, unsigned char *  pBuffer, HANDLE *  handle  )

static

Definition at line 76 of file usrmarshal.c.

{
    RemotableHandle *remhandle;
    if (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE)
    {
        ERR("can't remote a local handle\n");
        RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
        return pBuffer;
    }
 
    ALIGN_POINTER(pBuffer, 3);
    remhandle = (RemotableHandle *)pBuffer;
    remhandle->fContext = WDT_INPROC_CALL;
    remhandle->u.hInproc = (LONG_PTR)*handle;
    return pBuffer + sizeof(RemotableHandle);
}

handle_UserSize()

static ULONG handle_UserSize ( ULONG *  pFlags, ULONG  StartingSize, HANDLE *  handle  )

static

Definition at line 63 of file usrmarshal.c.

{
    if (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE)
    {
        ERR("can't remote a local handle\n");
        RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
        return StartingSize;
    }
 
    ALIGN_LENGTH(StartingSize, 3);
    return StartingSize + sizeof(RemotableHandle);
}

handle_UserUnmarshal()

static unsigned char * handle_UserUnmarshal ( ULONG *  pFlags, unsigned char *  pBuffer, HANDLE *  handle  )

static

Definition at line 93 of file usrmarshal.c.

{
    RemotableHandle *remhandle;
 
    ALIGN_POINTER(pBuffer, 3);
    remhandle = (RemotableHandle *)pBuffer;
    if (remhandle->fContext != WDT_INPROC_CALL)
        RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
    *handle = (HANDLE)(LONG_PTR)remhandle->u.hInproc;
    return pBuffer + sizeof(RemotableHandle);
}

HBITMAP_UserFree()

void __RPC_USER HBITMAP_UserFree	(	ULONG *	flags,
		HBITMAP *	bmp
	)

Definition at line 535 of file usrmarshal.c.

{
    TRACE("(%s, %p)\n", debugstr_user_flags(flags), *bmp);
 
    if (LOWORD(*flags) != MSHCTX_INPROC)
        DeleteObject(*bmp);
}

Referenced by test_marshal_HBITMAP().

HBITMAP_UserMarshal()

unsigned char *__RPC_USER HBITMAP_UserMarshal	(	ULONG *	flags,
		unsigned char *	buffer,
		HBITMAP *	bmp
	)

Definition at line 405 of file usrmarshal.c.

{
    TRACE("(%s, %p, %p)\n", debugstr_user_flags(flags), buffer, *bmp);
 
    ALIGN_POINTER(buffer, 3);
 
    if (LOWORD(*flags) == MSHCTX_INPROC)
    {
        *(ULONG *)buffer = WDT_INPROC_CALL;
        buffer += sizeof(ULONG);
        *(ULONG *)buffer = (ULONG)(ULONG_PTR)*bmp;
        buffer += sizeof(ULONG);
    }
    else
    {
        *(ULONG *)buffer = WDT_REMOTE_CALL;
        buffer += sizeof(ULONG);
        *(ULONG *)buffer = (ULONG)(ULONG_PTR)*bmp;
        buffer += sizeof(ULONG);
 
        if (*bmp)
        {
            static const ULONG header_size = FIELD_OFFSET(userBITMAP, cbSize);
            BITMAP bitmap;
            ULONG bitmap_size;
 
            bitmap_size = GetBitmapBits(*bmp, 0, NULL);
            *(ULONG *)buffer = bitmap_size;
            buffer += sizeof(ULONG);
 
            GetObjectW(*bmp, sizeof(BITMAP), &bitmap);
            memcpy(buffer, &bitmap, header_size);
            buffer += header_size;
 
            GetBitmapBits(*bmp, bitmap_size, buffer);
            buffer += bitmap_size;
        }
    }
    return buffer;
}

Referenced by STGMEDIUM_UserMarshal(), and test_marshal_HBITMAP().

HBITMAP_UserSize()

ULONG __RPC_USER HBITMAP_UserSize	(	ULONG *	flags,
		ULONG	size,
		HBITMAP *	bmp
	)

Definition at line 362 of file usrmarshal.c.

{
    TRACE("%s, %lu, %p.\n", debugstr_user_flags(flags), size, *bmp);
 
    ALIGN_LENGTH(size, 3);
 
    size += sizeof(ULONG);
    if (LOWORD(*flags) == MSHCTX_INPROC)
        size += sizeof(ULONG);
    else
    {
        size += sizeof(ULONG);
 
        if (*bmp)
        {
            size += sizeof(ULONG);
            size += FIELD_OFFSET(userBITMAP, cbSize);
            size += GetBitmapBits(*bmp, 0, NULL);
        }
    }
 
    return size;
}

Referenced by STGMEDIUM_UserSize(), and test_marshal_HBITMAP().

HBITMAP_UserUnmarshal()

unsigned char *__RPC_USER HBITMAP_UserUnmarshal	(	ULONG *	flags,
		unsigned char *	buffer,
		HBITMAP *	bmp
	)

Definition at line 465 of file usrmarshal.c.

{
    ULONG context;
 
    TRACE("(%s, %p, %p)\n", debugstr_user_flags(flags), buffer, bmp);
 
    ALIGN_POINTER(buffer, 3);
 
    context = *(ULONG *)buffer;
    buffer += sizeof(ULONG);
 
    if (context == WDT_INPROC_CALL)
    {
        *bmp = *(HBITMAP *)buffer;
        buffer += sizeof(*bmp);
    }
    else if (context == WDT_REMOTE_CALL)
    {
        ULONG handle = *(ULONG *)buffer;
        buffer += sizeof(ULONG);
 
        if (handle)
        {
            static const ULONG header_size = FIELD_OFFSET(userBITMAP, cbSize);
            BITMAP bitmap;
            ULONG bitmap_size;
            unsigned char *bits;
 
            bitmap_size = *(ULONG *)buffer;
            buffer += sizeof(ULONG);
            bits = malloc(bitmap_size);
 
            memcpy(&bitmap, buffer, header_size);
            buffer += header_size;
 
            memcpy(bits, buffer, bitmap_size);
            buffer += bitmap_size;
 
            bitmap.bmBits = bits;
            *bmp = CreateBitmapIndirect(&bitmap);
 
            free(bits);
        }
        else
            *bmp = NULL;
    }
    else
        RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 
    return buffer;
}

Referenced by STGMEDIUM_UserUnmarshal(), and test_marshal_HBITMAP().

HGLOBAL_UserFree()

void __RPC_USER HGLOBAL_UserFree	(	ULONG *	pFlags,
		HGLOBAL *	phGlobal
	)

Definition at line 830 of file usrmarshal.c.

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

Referenced by test_marshal_HGLOBAL().

HGLOBAL_UserMarshal()

unsigned char *__RPC_USER HGLOBAL_UserMarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		HGLOBAL *	phGlobal
	)

Definition at line 685 of file usrmarshal.c.

{
    TRACE("%s, %p, &%p.\n", debugstr_user_flags(pFlags), pBuffer, *phGlobal);
 
    ALIGN_POINTER(pBuffer, 3);
 
    if (LOWORD(*pFlags) == MSHCTX_INPROC)
    {
        if (sizeof(*phGlobal) == 8)
            *(ULONG *)pBuffer = WDT_INPROC64_CALL;
        else
            *(ULONG *)pBuffer = WDT_INPROC_CALL;
        pBuffer += sizeof(ULONG);
        *(HGLOBAL *)pBuffer = *phGlobal;
        pBuffer += sizeof(HGLOBAL);
    }
    else
    {
        *(ULONG *)pBuffer = WDT_REMOTE_CALL;
        pBuffer += sizeof(ULONG);
        *(ULONG *)pBuffer = HandleToULong(*phGlobal);
        pBuffer += sizeof(ULONG);
        if (*phGlobal)
        {
            const unsigned char *memory;
            SIZE_T size = GlobalSize(*phGlobal);
            *(ULONG *)pBuffer = (ULONG)size;
            pBuffer += sizeof(ULONG);
            *(ULONG *)pBuffer = HandleToULong(*phGlobal);
            pBuffer += sizeof(ULONG);
            *(ULONG *)pBuffer = (ULONG)size;
            pBuffer += sizeof(ULONG);
 
            memory = GlobalLock(*phGlobal);
            memcpy(pBuffer, memory, size);
            pBuffer += size;
            GlobalUnlock(*phGlobal);
        }
    }
 
    return pBuffer;
}

Referenced by STGMEDIUM_UserMarshal(), and test_marshal_HGLOBAL().

HGLOBAL_UserSize()

ULONG __RPC_USER HGLOBAL_UserSize	(	ULONG *	pFlags,
		ULONG	StartingSize,
		HGLOBAL *	phGlobal
	)

Definition at line 639 of file usrmarshal.c.

{
    ULONG size = StartingSize;
 
    TRACE("%s, %lu, %p.\n", debugstr_user_flags(pFlags), StartingSize, phGlobal);
 
    ALIGN_LENGTH(size, 3);
 
    size += sizeof(ULONG);
 
    if (LOWORD(*pFlags) == MSHCTX_INPROC)
        size += sizeof(HGLOBAL);
    else
    {
        size += sizeof(ULONG);
        if (*phGlobal)
        {
            SIZE_T ret;
            size += 3 * sizeof(ULONG);
            ret = GlobalSize(*phGlobal);
            size += (ULONG)ret;
        }
    }
 
    return size;
}

Referenced by STGMEDIUM_UserSize(), and test_marshal_HGLOBAL().

HGLOBAL_UserUnmarshal()

unsigned char *__RPC_USER HGLOBAL_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		HGLOBAL *	phGlobal
	)

Definition at line 747 of file usrmarshal.c.

{
    ULONG fContext;
 
    TRACE("%s, %p, &%p.\n", debugstr_user_flags(pFlags), pBuffer, *phGlobal);
 
    ALIGN_POINTER(pBuffer, 3);
 
    fContext = *(ULONG *)pBuffer;
    pBuffer += sizeof(ULONG);
 
    if (((fContext == WDT_INPROC_CALL) && (sizeof(*phGlobal) < 8)) ||
        ((fContext == WDT_INPROC64_CALL) && (sizeof(*phGlobal) == 8)))
    {
        *phGlobal = *(HGLOBAL *)pBuffer;
        pBuffer += sizeof(*phGlobal);
    }
    else if (fContext == WDT_REMOTE_CALL)
    {
        ULONG handle;
 
        handle = *(ULONG *)pBuffer;
        pBuffer += sizeof(ULONG);
 
        if (handle)
        {
            ULONG size;
            void *memory;
 
            size = *(ULONG *)pBuffer;
            pBuffer += sizeof(ULONG);
            /* redundancy is bad - it means you have to check consistency like
             * this: */
            if (*(ULONG *)pBuffer != handle)
            {
                RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
                return pBuffer;
            }
            pBuffer += sizeof(ULONG);
            /* redundancy is bad - it means you have to check consistency like
             * this: */
            if (*(ULONG *)pBuffer != size)
            {
                RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
                return pBuffer;
            }
            pBuffer += sizeof(ULONG);
 
            /* FIXME: check size is not too big */
 
            *phGlobal = GlobalAlloc(GMEM_MOVEABLE, size);
            memory = GlobalLock(*phGlobal);
            memcpy(memory, pBuffer, size);
            pBuffer += size;
            GlobalUnlock(*phGlobal);
        }
        else
            *phGlobal = NULL;
    }
    else
        RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 
    return pBuffer;
}

Referenced by STGMEDIUM_UserUnmarshal(), and test_marshal_HGLOBAL().

HPALETTE_UserFree()

void __RPC_USER HPALETTE_UserFree	(	ULONG *	pFlags,
		HPALETTE *	phPal
	)

Definition at line 856 of file usrmarshal.c.

{
    FIXME(":stub\n");
}

HPALETTE_UserMarshal()

unsigned char *__RPC_USER HPALETTE_UserMarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		HPALETTE *	phPal
	)

Definition at line 588 of file usrmarshal.c.

{
    FIXME(":stub\n");
    return pBuffer;
}

HPALETTE_UserSize()

ULONG __RPC_USER HPALETTE_UserSize	(	ULONG *	pFlags,
		ULONG	StartingSize,
		HPALETTE *	phPal
	)

Definition at line 563 of file usrmarshal.c.

{
    FIXME(":stub\n");
    return StartingSize;
}

HPALETTE_UserUnmarshal()

unsigned char *__RPC_USER HPALETTE_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		HPALETTE *	phPal
	)

Definition at line 613 of file usrmarshal.c.

{
    FIXME(":stub\n");
    return pBuffer;
}

WdtpInterfacePointer_UserFree()

void WINAPI WdtpInterfacePointer_UserFree

(

IUnknown *

punk

)

Definition at line 1023 of file usrmarshal.c.

{
    TRACE("%p.\n", punk);
    if (punk) IUnknown_Release(punk);
}

WdtpInterfacePointer_UserMarshal()

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

Definition at line 917 of file usrmarshal.c.

{
    HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE, 0);
    IStream *stm;
    DWORD size;
    void *ptr;
 
    TRACE("%s, %#lx, %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 882 of file usrmarshal.c.

{
    DWORD marshal_size = 0;
    HRESULT hr;
 
    TRACE("%s, %#lx, %lu, %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 *WINAPI WdtpInterfacePointer_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		IUnknown **	ppunk,
		REFIID	riid
	)

Definition at line 974 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().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)