usrmarshal.c File Reference

#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winerror.h"
#include "ole2.h"
#include "oleauto.h"
#include "rpcproxy.h"
#include "wine/debug.h"

Include dependency graph for usrmarshal.c:

Go to the source code of this file.

Classes
struct	SNB_wire

Macros
#define	COBJMACROS
#define	NONAMELESSUNION
#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	USER_MARSHAL_PTR_PREFIX
#define	IMPL_WIREM_HANDLE(type)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
static const char *	debugstr_user_flags (ULONG *pFlags)
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)
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	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)
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)
void __RPC_USER	HPALETTE_UserFree (ULONG *pFlags, HPALETTE *phPal)
ULONG __RPC_USER	HMETAFILE_UserSize (ULONG *pFlags, ULONG StartingSize, HMETAFILE *phmf)
unsigned char *__RPC_USER	HMETAFILE_UserMarshal (ULONG *pFlags, unsigned char *pBuffer, HMETAFILE *phmf)
unsigned char *__RPC_USER	HMETAFILE_UserUnmarshal (ULONG *pFlags, unsigned char *pBuffer, HMETAFILE *phmf)
void __RPC_USER	HMETAFILE_UserFree (ULONG *pFlags, HMETAFILE *phmf)
ULONG __RPC_USER	HENHMETAFILE_UserSize (ULONG *pFlags, ULONG size, HENHMETAFILE *phEmf)
unsigned char *__RPC_USER	HENHMETAFILE_UserMarshal (ULONG *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
unsigned char *__RPC_USER	HENHMETAFILE_UserUnmarshal (ULONG *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
void __RPC_USER	HENHMETAFILE_UserFree (ULONG *pFlags, HENHMETAFILE *phEmf)
ULONG __RPC_USER	HMETAFILEPICT_UserSize (ULONG *pFlags, ULONG size, HMETAFILEPICT *phMfp)
unsigned char *__RPC_USER	HMETAFILEPICT_UserMarshal (ULONG *pFlags, unsigned char *pBuffer, HMETAFILEPICT *phMfp)
unsigned char *__RPC_USER	HMETAFILEPICT_UserUnmarshal (ULONG *pFlags, unsigned char *pBuffer, HMETAFILEPICT *phMfp)
void __RPC_USER	HMETAFILEPICT_UserFree (ULONG *pFlags, HMETAFILEPICT *phMfp)
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)
ULONG __RPC_USER	STGMEDIUM_UserSize (ULONG *pFlags, ULONG StartingSize, STGMEDIUM *pStgMedium)
unsigned char *__RPC_USER	STGMEDIUM_UserMarshal (ULONG *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
unsigned char *__RPC_USER	STGMEDIUM_UserUnmarshal (ULONG *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
void __RPC_USER	STGMEDIUM_UserFree (ULONG *flags, STGMEDIUM *med)
ULONG __RPC_USER	ASYNC_STGMEDIUM_UserSize (ULONG *pFlags, ULONG StartingSize, ASYNC_STGMEDIUM *pStgMedium)
unsigned char *__RPC_USER	ASYNC_STGMEDIUM_UserMarshal (ULONG *pFlags, unsigned char *pBuffer, ASYNC_STGMEDIUM *pStgMedium)
unsigned char *__RPC_USER	ASYNC_STGMEDIUM_UserUnmarshal (ULONG *pFlags, unsigned char *pBuffer, ASYNC_STGMEDIUM *pStgMedium)
void __RPC_USER	ASYNC_STGMEDIUM_UserFree (ULONG *pFlags, ASYNC_STGMEDIUM *pStgMedium)
ULONG __RPC_USER	FLAG_STGMEDIUM_UserSize (ULONG *pFlags, ULONG StartingSize, FLAG_STGMEDIUM *pStgMedium)
unsigned char *__RPC_USER	FLAG_STGMEDIUM_UserMarshal (ULONG *pFlags, unsigned char *pBuffer, FLAG_STGMEDIUM *pStgMedium)
unsigned char *__RPC_USER	FLAG_STGMEDIUM_UserUnmarshal (ULONG *pFlags, unsigned char *pBuffer, FLAG_STGMEDIUM *pStgMedium)
void __RPC_USER	FLAG_STGMEDIUM_UserFree (ULONG *pFlags, FLAG_STGMEDIUM *pStgMedium)
ULONG __RPC_USER	SNB_UserSize (ULONG *pFlags, ULONG StartingSize, SNB *pSnb)
unsigned char *__RPC_USER	SNB_UserMarshal (ULONG *pFlags, unsigned char *pBuffer, SNB *pSnb)
unsigned char *__RPC_USER	SNB_UserUnmarshal (ULONG *pFlags, unsigned char *pBuffer, SNB *pSnb)
void __RPC_USER	SNB_UserFree (ULONG *pFlags, SNB *pSnb)
HRESULT CALLBACK	IClassFactory_CreateInstance_Proxy (IClassFactory *This, IUnknown *pUnkOuter, REFIID riid, void **ppvObject)
HRESULT __RPC_STUB	IClassFactory_CreateInstance_Stub (IClassFactory *This, REFIID riid, IUnknown **ppvObject)
HRESULT CALLBACK	IClassFactory_LockServer_Proxy (IClassFactory *This, BOOL fLock)
HRESULT __RPC_STUB	IClassFactory_LockServer_Stub (IClassFactory *This, BOOL fLock)
HRESULT CALLBACK	IEnumUnknown_Next_Proxy (IEnumUnknown *This, ULONG celt, IUnknown **rgelt, ULONG *pceltFetched)
HRESULT __RPC_STUB	IEnumUnknown_Next_Stub (IEnumUnknown *This, ULONG celt, IUnknown **rgelt, ULONG *pceltFetched)
HRESULT CALLBACK	IBindCtx_SetBindOptions_Proxy (IBindCtx *This, BIND_OPTS *pbindopts)
HRESULT __RPC_STUB	IBindCtx_SetBindOptions_Stub (IBindCtx *This, BIND_OPTS2 *pbindopts)
HRESULT CALLBACK	IBindCtx_GetBindOptions_Proxy (IBindCtx *This, BIND_OPTS *pbindopts)
HRESULT __RPC_STUB	IBindCtx_GetBindOptions_Stub (IBindCtx *This, BIND_OPTS2 *pbindopts)
HRESULT CALLBACK	IEnumMoniker_Next_Proxy (IEnumMoniker *This, ULONG celt, IMoniker **rgelt, ULONG *pceltFetched)
HRESULT __RPC_STUB	IEnumMoniker_Next_Stub (IEnumMoniker *This, ULONG celt, IMoniker **rgelt, ULONG *pceltFetched)
BOOL CALLBACK	IRunnableObject_IsRunning_Proxy (IRunnableObject *This)
HRESULT __RPC_STUB	IRunnableObject_IsRunning_Stub (IRunnableObject *This)
HRESULT CALLBACK	IMoniker_BindToObject_Proxy (IMoniker *This, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riidResult, void **ppvResult)
HRESULT __RPC_STUB	IMoniker_BindToObject_Stub (IMoniker *This, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riidResult, IUnknown **ppvResult)
HRESULT CALLBACK	IMoniker_BindToStorage_Proxy (IMoniker *This, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, void **ppvObj)
HRESULT __RPC_STUB	IMoniker_BindToStorage_Stub (IMoniker *This, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, IUnknown **ppvObj)
HRESULT CALLBACK	IEnumString_Next_Proxy (IEnumString *This, ULONG celt, LPOLESTR *rgelt, ULONG *pceltFetched)
HRESULT __RPC_STUB	IEnumString_Next_Stub (IEnumString *This, ULONG celt, LPOLESTR *rgelt, ULONG *pceltFetched)
HRESULT CALLBACK	ISequentialStream_Read_Proxy (ISequentialStream *This, void *pv, ULONG cb, ULONG *pcbRead)
HRESULT __RPC_STUB	ISequentialStream_Read_Stub (ISequentialStream *This, byte *pv, ULONG cb, ULONG *pcbRead)
HRESULT CALLBACK	ISequentialStream_Write_Proxy (ISequentialStream *This, const void *pv, ULONG cb, ULONG *pcbWritten)
HRESULT __RPC_STUB	ISequentialStream_Write_Stub (ISequentialStream *This, const byte *pv, ULONG cb, ULONG *pcbWritten)
HRESULT CALLBACK	IStream_Seek_Proxy (IStream *This, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
HRESULT __RPC_STUB	IStream_Seek_Stub (IStream *This, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
HRESULT CALLBACK	IStream_CopyTo_Proxy (IStream *This, IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
HRESULT __RPC_STUB	IStream_CopyTo_Stub (IStream *This, IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
HRESULT CALLBACK	IEnumSTATSTG_Next_Proxy (IEnumSTATSTG *This, ULONG celt, STATSTG *rgelt, ULONG *pceltFetched)
HRESULT __RPC_STUB	IEnumSTATSTG_Next_Stub (IEnumSTATSTG *This, ULONG celt, STATSTG *rgelt, ULONG *pceltFetched)
HRESULT CALLBACK	IStorage_OpenStream_Proxy (IStorage *This, LPCOLESTR pwcsName, void *reserved1, DWORD grfMode, DWORD reserved2, IStream **ppstm)
HRESULT __RPC_STUB	IStorage_OpenStream_Stub (IStorage *This, LPCOLESTR pwcsName, ULONG cbReserved1, byte *reserved1, DWORD grfMode, DWORD reserved2, IStream **ppstm)
HRESULT CALLBACK	IStorage_EnumElements_Proxy (IStorage *This, DWORD reserved1, void *reserved2, DWORD reserved3, IEnumSTATSTG **ppenum)
HRESULT __RPC_STUB	IStorage_EnumElements_Stub (IStorage *This, DWORD reserved1, ULONG cbReserved2, byte *reserved2, DWORD reserved3, IEnumSTATSTG **ppenum)
HRESULT CALLBACK	ILockBytes_ReadAt_Proxy (ILockBytes *This, ULARGE_INTEGER ulOffset, void *pv, ULONG cb, ULONG *pcbRead)
HRESULT __RPC_STUB	ILockBytes_ReadAt_Stub (ILockBytes *This, ULARGE_INTEGER ulOffset, byte *pv, ULONG cb, ULONG *pcbRead)
HRESULT CALLBACK	ILockBytes_WriteAt_Proxy (ILockBytes *This, ULARGE_INTEGER ulOffset, const void *pv, ULONG cb, ULONG *pcbWritten)
HRESULT __RPC_STUB	ILockBytes_WriteAt_Stub (ILockBytes *This, ULARGE_INTEGER ulOffset, const byte *pv, ULONG cb, ULONG *pcbWritten)
HRESULT CALLBACK	IFillLockBytes_FillAppend_Proxy (IFillLockBytes *This, const void *pv, ULONG cb, ULONG *pcbWritten)
HRESULT __RPC_STUB	IFillLockBytes_FillAppend_Stub (IFillLockBytes *This, const byte *pv, ULONG cb, ULONG *pcbWritten)
HRESULT CALLBACK	IFillLockBytes_FillAt_Proxy (IFillLockBytes *This, ULARGE_INTEGER ulOffset, const void *pv, ULONG cb, ULONG *pcbWritten)
HRESULT __RPC_STUB	IFillLockBytes_FillAt_Stub (IFillLockBytes *This, ULARGE_INTEGER ulOffset, const byte *pv, ULONG cb, ULONG *pcbWritten)
HRESULT CALLBACK	IEnumFORMATETC_Next_Proxy (IEnumFORMATETC *This, ULONG celt, FORMATETC *rgelt, ULONG *pceltFetched)
HRESULT __RPC_STUB	IEnumFORMATETC_Next_Stub (IEnumFORMATETC *This, ULONG celt, FORMATETC *rgelt, ULONG *pceltFetched)
HRESULT CALLBACK	IEnumSTATDATA_Next_Proxy (IEnumSTATDATA *This, ULONG celt, STATDATA *rgelt, ULONG *pceltFetched)
HRESULT __RPC_STUB	IEnumSTATDATA_Next_Stub (IEnumSTATDATA *This, ULONG celt, STATDATA *rgelt, ULONG *pceltFetched)
void CALLBACK	IAdviseSink_OnDataChange_Proxy (IAdviseSink *This, FORMATETC *pFormatetc, STGMEDIUM *pStgmed)
HRESULT __RPC_STUB	IAdviseSink_OnDataChange_Stub (IAdviseSink *This, FORMATETC *pFormatetc, ASYNC_STGMEDIUM *pStgmed)
void CALLBACK	IAdviseSink_OnViewChange_Proxy (IAdviseSink *This, DWORD dwAspect, LONG lindex)
HRESULT __RPC_STUB	IAdviseSink_OnViewChange_Stub (IAdviseSink *This, DWORD dwAspect, LONG lindex)
void CALLBACK	IAdviseSink_OnRename_Proxy (IAdviseSink *This, IMoniker *pmk)
HRESULT __RPC_STUB	IAdviseSink_OnRename_Stub (IAdviseSink *This, IMoniker *pmk)
void CALLBACK	IAdviseSink_OnSave_Proxy (IAdviseSink *This)
HRESULT __RPC_STUB	IAdviseSink_OnSave_Stub (IAdviseSink *This)
void CALLBACK	IAdviseSink_OnClose_Proxy (IAdviseSink *This)
HRESULT __RPC_STUB	IAdviseSink_OnClose_Stub (IAdviseSink *This)
void CALLBACK	IAdviseSink2_OnLinkSrcChange_Proxy (IAdviseSink2 *This, IMoniker *pmk)
HRESULT __RPC_STUB	IAdviseSink2_OnLinkSrcChange_Stub (IAdviseSink2 *This, IMoniker *pmk)
HRESULT CALLBACK	IDataObject_GetData_Proxy (IDataObject *This, FORMATETC *pformatetcIn, STGMEDIUM *pmedium)
HRESULT __RPC_STUB	IDataObject_GetData_Stub (IDataObject *This, FORMATETC *pformatetcIn, STGMEDIUM *pRemoteMedium)
HRESULT CALLBACK	IDataObject_GetDataHere_Proxy (IDataObject *iface, FORMATETC *fmt, STGMEDIUM *med)
HRESULT __RPC_STUB	IDataObject_GetDataHere_Stub (IDataObject *This, FORMATETC *pformatetc, STGMEDIUM *pRemoteMedium)
HRESULT CALLBACK	IDataObject_SetData_Proxy (IDataObject *This, FORMATETC *pformatetc, STGMEDIUM *pmedium, BOOL fRelease)
HRESULT __RPC_STUB	IDataObject_SetData_Stub (IDataObject *This, FORMATETC *pformatetc, FLAG_STGMEDIUM *pmedium, BOOL fRelease)
HRESULT CALLBACK	IOleInPlaceActiveObject_TranslateAccelerator_Proxy (IOleInPlaceActiveObject *This, LPMSG lpmsg)
HRESULT __RPC_STUB	IOleInPlaceActiveObject_TranslateAccelerator_Stub (IOleInPlaceActiveObject *This)
HRESULT CALLBACK	IOleInPlaceActiveObject_ResizeBorder_Proxy (IOleInPlaceActiveObject *This, LPCRECT prcBorder, IOleInPlaceUIWindow *pUIWindow, BOOL fFrameWindow)
HRESULT __RPC_STUB	IOleInPlaceActiveObject_ResizeBorder_Stub (IOleInPlaceActiveObject *This, LPCRECT prcBorder, REFIID riid, IOleInPlaceUIWindow *pUIWindow, BOOL fFrameWindow)
HRESULT CALLBACK	IOleCache2_UpdateCache_Proxy (IOleCache2 *This, LPDATAOBJECT pDataObject, DWORD grfUpdf, LPVOID pReserved)
HRESULT __RPC_STUB	IOleCache2_UpdateCache_Stub (IOleCache2 *This, LPDATAOBJECT pDataObject, DWORD grfUpdf, LONG_PTR pReserved)
HRESULT CALLBACK	IEnumOLEVERB_Next_Proxy (IEnumOLEVERB *This, ULONG celt, LPOLEVERB rgelt, ULONG *pceltFetched)
HRESULT __RPC_STUB	IEnumOLEVERB_Next_Stub (IEnumOLEVERB *This, ULONG celt, LPOLEVERB rgelt, ULONG *pceltFetched)
HRESULT CALLBACK	IViewObject_Draw_Proxy (IViewObject *This, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds, BOOL(STDMETHODCALLTYPE *pfnContinue)(ULONG_PTR dwContinue), ULONG_PTR dwContinue)
HRESULT __RPC_STUB	IViewObject_Draw_Stub (IViewObject *This, DWORD dwDrawAspect, LONG lindex, ULONG_PTR pvAspect, DVTARGETDEVICE *ptd, ULONG_PTR hdcTargetDev, ULONG_PTR hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds, IContinue *pContinue)
HRESULT CALLBACK	IViewObject_GetColorSet_Proxy (IViewObject *This, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hicTargetDev, LOGPALETTE **ppColorSet)
HRESULT __RPC_STUB	IViewObject_GetColorSet_Stub (IViewObject *This, DWORD dwDrawAspect, LONG lindex, ULONG_PTR pvAspect, DVTARGETDEVICE *ptd, ULONG_PTR hicTargetDev, LOGPALETTE **ppColorSet)
HRESULT CALLBACK	IViewObject_Freeze_Proxy (IViewObject *This, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze)
HRESULT __RPC_STUB	IViewObject_Freeze_Stub (IViewObject *This, DWORD dwDrawAspect, LONG lindex, ULONG_PTR pvAspect, DWORD *pdwFreeze)
HRESULT CALLBACK	IViewObject_GetAdvise_Proxy (IViewObject *This, DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink)
HRESULT __RPC_STUB	IViewObject_GetAdvise_Stub (IViewObject *This, DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink)

Macro Definition Documentation

ALIGN_LENGTH

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

Definition at line 44 of file usrmarshal.c.

ALIGN_POINTER

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

Definition at line 45 of file usrmarshal.c.

ALIGNED_LENGTH

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

Definition at line 42 of file usrmarshal.c.

ALIGNED_POINTER

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

Definition at line 43 of file usrmarshal.c.

COBJMACROS

#define COBJMACROS

Definition at line 25 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, %d, %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 327 of file usrmarshal.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 26 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 47 of file usrmarshal.c.

Function Documentation

ASYNC_STGMEDIUM_UserFree()

void __RPC_USER ASYNC_STGMEDIUM_UserFree	(	ULONG *	pFlags,
		ASYNC_STGMEDIUM *	pStgMedium
	)

Definition at line 2081 of file usrmarshal.c.

{
    TRACE("\n");
    STGMEDIUM_UserFree(pFlags, pStgMedium);
}

ASYNC_STGMEDIUM_UserMarshal()

unsigned char *__RPC_USER ASYNC_STGMEDIUM_UserMarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		ASYNC_STGMEDIUM *	pStgMedium
	)

Definition at line 2069 of file usrmarshal.c.

{
    TRACE("\n");
    return STGMEDIUM_UserMarshal(pFlags, pBuffer, pStgMedium);
}

ASYNC_STGMEDIUM_UserSize()

ULONG __RPC_USER ASYNC_STGMEDIUM_UserSize	(	ULONG *	pFlags,
		ULONG	StartingSize,
		ASYNC_STGMEDIUM *	pStgMedium
	)

Definition at line 2063 of file usrmarshal.c.

{
    TRACE("\n");
    return STGMEDIUM_UserSize(pFlags, StartingSize, pStgMedium);
}

ASYNC_STGMEDIUM_UserUnmarshal()

unsigned char *__RPC_USER ASYNC_STGMEDIUM_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		ASYNC_STGMEDIUM *	pStgMedium
	)

Definition at line 2075 of file usrmarshal.c.

{
    TRACE("\n");
    return STGMEDIUM_UserUnmarshal(pFlags, pBuffer, pStgMedium);
}

CLIPFORMAT_UserFree()

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

Definition at line 274 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 145 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 100 of file usrmarshal.c.

{
    TRACE("(%s, %d, %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 207 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 51 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().

FLAG_STGMEDIUM_UserFree()

void __RPC_USER FLAG_STGMEDIUM_UserFree	(	ULONG *	pFlags,
		FLAG_STGMEDIUM *	pStgMedium
	)

Definition at line 2105 of file usrmarshal.c.

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

FLAG_STGMEDIUM_UserMarshal()

unsigned char *__RPC_USER FLAG_STGMEDIUM_UserMarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		FLAG_STGMEDIUM *	pStgMedium
	)

Definition at line 2093 of file usrmarshal.c.

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

FLAG_STGMEDIUM_UserSize()

ULONG __RPC_USER FLAG_STGMEDIUM_UserSize	(	ULONG *	pFlags,
		ULONG	StartingSize,
		FLAG_STGMEDIUM *	pStgMedium
	)

Definition at line 2087 of file usrmarshal.c.

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

FLAG_STGMEDIUM_UserUnmarshal()

unsigned char *__RPC_USER FLAG_STGMEDIUM_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		FLAG_STGMEDIUM *	pStgMedium
	)

Definition at line 2099 of file usrmarshal.c.

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

handle_UserFree()

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

static

Definition at line 322 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 293 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 280 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 310 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 771 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 641 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 598 of file usrmarshal.c.

{
    TRACE("(%s, %d, %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 701 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 = HeapAlloc(GetProcessHeap(), 0, bitmap_size);
 
            memcpy(&bitmap, buffer, header_size);
            buffer += header_size;
 
            memcpy(bits, buffer, bitmap_size);
            buffer += bitmap_size;
 
            bitmap.bmBits = bits;
            *bmp = CreateBitmapIndirect(&bitmap);
 
            HeapFree(GetProcessHeap(), 0, bits);
        }
        else
            *bmp = NULL;
    }
    else
        RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 
    return buffer;
}

Referenced by STGMEDIUM_UserUnmarshal(), and test_marshal_HBITMAP().

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().

HGLOBAL_UserFree()

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

Definition at line 570 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 425 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 379 of file usrmarshal.c.

{
    ULONG size = StartingSize;
 
    TRACE("(%s, %d, %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 487 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().

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().

HPALETTE_UserFree()

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

Definition at line 873 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 824 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 799 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 849 of file usrmarshal.c.

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

IAdviseSink2_OnLinkSrcChange_Proxy()

void CALLBACK IAdviseSink2_OnLinkSrcChange_Proxy	(	IAdviseSink2 *	This,
		IMoniker *	pmk
	)

Definition at line 2884 of file usrmarshal.c.

{
    TRACE("(%p)->(%p)\n", This, pmk);
    IAdviseSink2_RemoteOnLinkSrcChange_Proxy(This, pmk);
}

IAdviseSink2_OnLinkSrcChange_Stub()

HRESULT __RPC_STUB IAdviseSink2_OnLinkSrcChange_Stub	(	IAdviseSink2 *	This,
		IMoniker *	pmk
	)

Definition at line 2892 of file usrmarshal.c.

{
    TRACE("(%p)->(%p)\n", This, pmk);
    IAdviseSink2_OnLinkSrcChange(This, pmk);
    return S_OK;
}

IAdviseSink_OnClose_Proxy()

void CALLBACK IAdviseSink_OnClose_Proxy

(

IAdviseSink *

This

)

Definition at line 2869 of file usrmarshal.c.

{
    TRACE("(%p)\n", This);
    IAdviseSink_RemoteOnClose_Proxy(This);
}

IAdviseSink_OnClose_Stub()

HRESULT __RPC_STUB IAdviseSink_OnClose_Stub

(

IAdviseSink *

This

)

Definition at line 2876 of file usrmarshal.c.

{
    TRACE("(%p)\n", This);
    IAdviseSink_OnClose(This);
    return S_OK;
}

IAdviseSink_OnDataChange_Proxy()

void CALLBACK IAdviseSink_OnDataChange_Proxy	(	IAdviseSink *	This,
		FORMATETC *	pFormatetc,
		STGMEDIUM *	pStgmed
	)

Definition at line 2799 of file usrmarshal.c.

{
    TRACE("(%p)->(%p, %p)\n", This, pFormatetc, pStgmed);
    IAdviseSink_RemoteOnDataChange_Proxy(This, pFormatetc, pStgmed);
}

IAdviseSink_OnDataChange_Stub()

HRESULT __RPC_STUB IAdviseSink_OnDataChange_Stub	(	IAdviseSink *	This,
		FORMATETC *	pFormatetc,
		ASYNC_STGMEDIUM *	pStgmed
	)

Definition at line 2808 of file usrmarshal.c.

{
    TRACE("(%p)->(%p, %p)\n", This, pFormatetc, pStgmed);
    IAdviseSink_OnDataChange(This, pFormatetc, pStgmed);
    return S_OK;
}

IAdviseSink_OnRename_Proxy()

void CALLBACK IAdviseSink_OnRename_Proxy	(	IAdviseSink *	This,
		IMoniker *	pmk
	)

Definition at line 2837 of file usrmarshal.c.

{
    TRACE("(%p)->(%p)\n", This, pmk);
    IAdviseSink_RemoteOnRename_Proxy(This, pmk);
}

IAdviseSink_OnRename_Stub()

HRESULT __RPC_STUB IAdviseSink_OnRename_Stub	(	IAdviseSink *	This,
		IMoniker *	pmk
	)

Definition at line 2845 of file usrmarshal.c.

{
    TRACE("(%p)->(%p)\n", This, pmk);
    IAdviseSink_OnRename(This, pmk);
    return S_OK;
}

IAdviseSink_OnSave_Proxy()

void CALLBACK IAdviseSink_OnSave_Proxy

(

IAdviseSink *

This

)

Definition at line 2854 of file usrmarshal.c.

{
    TRACE("(%p)\n", This);
    IAdviseSink_RemoteOnSave_Proxy(This);
}

IAdviseSink_OnSave_Stub()

HRESULT __RPC_STUB IAdviseSink_OnSave_Stub

(

IAdviseSink *

This

)

Definition at line 2861 of file usrmarshal.c.

{
    TRACE("(%p)\n", This);
    IAdviseSink_OnSave(This);
    return S_OK;
}

IAdviseSink_OnViewChange_Proxy()

void CALLBACK IAdviseSink_OnViewChange_Proxy	(	IAdviseSink *	This,
		DWORD	dwAspect,
		LONG	lindex
	)

Definition at line 2818 of file usrmarshal.c.

{
    TRACE("(%p)->(%d, %d)\n", This, dwAspect, lindex);
    IAdviseSink_RemoteOnViewChange_Proxy(This, dwAspect, lindex);
}

IAdviseSink_OnViewChange_Stub()

HRESULT __RPC_STUB IAdviseSink_OnViewChange_Stub	(	IAdviseSink *	This,
		DWORD	dwAspect,
		LONG	lindex
	)

Definition at line 2827 of file usrmarshal.c.

{
    TRACE("(%p)->(%d, %d)\n", This, dwAspect, lindex);
    IAdviseSink_OnViewChange(This, dwAspect, lindex);
    return S_OK;
}

IBindCtx_GetBindOptions_Proxy()

HRESULT CALLBACK IBindCtx_GetBindOptions_Proxy	(	IBindCtx *	This,
		BIND_OPTS *	pbindopts
	)

Definition at line 2313 of file usrmarshal.c.

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

IBindCtx_GetBindOptions_Stub()

HRESULT __RPC_STUB IBindCtx_GetBindOptions_Stub	(	IBindCtx *	This,
		BIND_OPTS2 *	pbindopts
	)

Definition at line 2321 of file usrmarshal.c.

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

IBindCtx_SetBindOptions_Proxy()

HRESULT CALLBACK IBindCtx_SetBindOptions_Proxy	(	IBindCtx *	This,
		BIND_OPTS *	pbindopts
	)

Definition at line 2297 of file usrmarshal.c.

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

IBindCtx_SetBindOptions_Stub()

HRESULT __RPC_STUB IBindCtx_SetBindOptions_Stub	(	IBindCtx *	This,
		BIND_OPTS2 *	pbindopts
	)

Definition at line 2305 of file usrmarshal.c.

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

IClassFactory_CreateInstance_Proxy()

HRESULT CALLBACK IClassFactory_CreateInstance_Proxy	(	IClassFactory *	This,
		IUnknown *	pUnkOuter,
		REFIID	riid,
		void **	ppvObject
	)

Definition at line 2227 of file usrmarshal.c.

{
    TRACE("(%p, %s, %p)\n", pUnkOuter, debugstr_guid(riid), ppvObject);
    *ppvObject = NULL;
    if (pUnkOuter)
    {
        ERR("aggregation is not allowed on remote objects\n");
        return CLASS_E_NOAGGREGATION;
    }
    return IClassFactory_RemoteCreateInstance_Proxy(This, riid,
                                                    (IUnknown **) ppvObject);
}

IClassFactory_CreateInstance_Stub()

HRESULT __RPC_STUB IClassFactory_CreateInstance_Stub	(	IClassFactory *	This,
		REFIID	riid,
		IUnknown **	ppvObject
	)

Definition at line 2244 of file usrmarshal.c.

{
    TRACE("(%s, %p)\n", debugstr_guid(riid), ppvObject);
    return IClassFactory_CreateInstance(This, NULL, riid, (void **) ppvObject);
}

IClassFactory_LockServer_Proxy()

HRESULT CALLBACK IClassFactory_LockServer_Proxy	(	IClassFactory *	This,
		BOOL	fLock
	)

Definition at line 2253 of file usrmarshal.c.

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

IClassFactory_LockServer_Stub()

HRESULT __RPC_STUB IClassFactory_LockServer_Stub	(	IClassFactory *	This,
		BOOL	fLock
	)

Definition at line 2261 of file usrmarshal.c.

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

IDataObject_GetData_Proxy()

HRESULT CALLBACK IDataObject_GetData_Proxy	(	IDataObject *	This,
		FORMATETC *	pformatetcIn,
		STGMEDIUM *	pmedium
	)

Definition at line 2901 of file usrmarshal.c.

{
    TRACE("(%p)->(%p, %p)\n", This, pformatetcIn, pmedium);
    return IDataObject_RemoteGetData_Proxy(This, pformatetcIn, pmedium);
}

IDataObject_GetData_Stub()

HRESULT __RPC_STUB IDataObject_GetData_Stub	(	IDataObject *	This,
		FORMATETC *	pformatetcIn,
		STGMEDIUM *	pRemoteMedium
	)

Definition at line 2910 of file usrmarshal.c.

{
    TRACE("(%p)->(%p, %p)\n", This, pformatetcIn, pRemoteMedium);
    return IDataObject_GetData(This, pformatetcIn, pRemoteMedium);
}

IDataObject_GetDataHere_Proxy()

HRESULT CALLBACK IDataObject_GetDataHere_Proxy	(	IDataObject *	iface,
		FORMATETC *	fmt,
		STGMEDIUM *	med
	)

Definition at line 2919 of file usrmarshal.c.

{
    IUnknown *release;
    IStorage *stg = NULL;
    HRESULT hr;
 
    TRACE("(%p)->(%p, %p)\n", iface, fmt, med);
 
    if ((med->tymed & (TYMED_HGLOBAL | TYMED_FILE | TYMED_ISTREAM | TYMED_ISTORAGE)) == 0)
        return DV_E_TYMED;
    if (med->tymed != fmt->tymed)
        return DV_E_TYMED;
 
    release = med->pUnkForRelease;
    med->pUnkForRelease = NULL;
 
    if (med->tymed == TYMED_ISTREAM || med->tymed == TYMED_ISTORAGE)
    {
        stg = med->u.pstg; /* This may actually be a stream, but that's ok */
        if (stg) IStorage_AddRef( stg );
    }
 
    hr = IDataObject_RemoteGetDataHere_Proxy(iface, fmt, med);
 
    med->pUnkForRelease = release;
    if (stg)
    {
        if (med->u.pstg)
            IStorage_Release( med->u.pstg );
        med->u.pstg = stg;
    }
 
    return hr;
}

IDataObject_GetDataHere_Stub()

HRESULT __RPC_STUB IDataObject_GetDataHere_Stub	(	IDataObject *	This,
		FORMATETC *	pformatetc,
		STGMEDIUM *	pRemoteMedium
	)

Definition at line 2954 of file usrmarshal.c.

{
    TRACE("(%p)->(%p, %p)\n", This, pformatetc, pRemoteMedium);
    return IDataObject_GetDataHere(This, pformatetc, pRemoteMedium);
}

IDataObject_SetData_Proxy()

HRESULT CALLBACK IDataObject_SetData_Proxy	(	IDataObject *	This,
		FORMATETC *	pformatetc,
		STGMEDIUM *	pmedium,
		BOOL	fRelease
	)

Definition at line 2963 of file usrmarshal.c.

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

IDataObject_SetData_Stub()

HRESULT __RPC_STUB IDataObject_SetData_Stub	(	IDataObject *	This,
		FORMATETC *	pformatetc,
		FLAG_STGMEDIUM *	pmedium,
		BOOL	fRelease
	)

Definition at line 2973 of file usrmarshal.c.

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

IEnumFORMATETC_Next_Proxy()

HRESULT CALLBACK IEnumFORMATETC_Next_Proxy	(	IEnumFORMATETC *	This,
		ULONG	celt,
		FORMATETC *	rgelt,
		ULONG *	pceltFetched
	)

Definition at line 2749 of file usrmarshal.c.

{
    ULONG fetched;
    if (!pceltFetched) pceltFetched = &fetched;
    return IEnumFORMATETC_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
}

IEnumFORMATETC_Next_Stub()

HRESULT __RPC_STUB IEnumFORMATETC_Next_Stub	(	IEnumFORMATETC *	This,
		ULONG	celt,
		FORMATETC *	rgelt,
		ULONG *	pceltFetched
	)

Definition at line 2760 of file usrmarshal.c.

{
    HRESULT hr;
    *pceltFetched = 0;
    hr = IEnumFORMATETC_Next(This, celt, rgelt, pceltFetched);
    if (hr == S_OK) *pceltFetched = celt;
    return hr;
}

IEnumMoniker_Next_Proxy()

HRESULT CALLBACK IEnumMoniker_Next_Proxy	(	IEnumMoniker *	This,
		ULONG	celt,
		IMoniker **	rgelt,
		ULONG *	pceltFetched
	)

Definition at line 2329 of file usrmarshal.c.

{
    ULONG fetched;
    TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
    if (!pceltFetched) pceltFetched = &fetched;
    return IEnumMoniker_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
}

IEnumMoniker_Next_Stub()

HRESULT __RPC_STUB IEnumMoniker_Next_Stub	(	IEnumMoniker *	This,
		ULONG	celt,
		IMoniker **	rgelt,
		ULONG *	pceltFetched
	)

Definition at line 2341 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
    *pceltFetched = 0;
    hr = IEnumMoniker_Next(This, celt, rgelt, pceltFetched);
    if (hr == S_OK) *pceltFetched = celt;
    return hr;
}

IEnumOLEVERB_Next_Proxy()

HRESULT CALLBACK IEnumOLEVERB_Next_Proxy	(	IEnumOLEVERB *	This,
		ULONG	celt,
		LPOLEVERB	rgelt,
		ULONG *	pceltFetched
	)

Definition at line 3041 of file usrmarshal.c.

{
    ULONG fetched;
    TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
    if (!pceltFetched) pceltFetched = &fetched;
    return IEnumOLEVERB_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
}

IEnumOLEVERB_Next_Stub()

HRESULT __RPC_STUB IEnumOLEVERB_Next_Stub	(	IEnumOLEVERB *	This,
		ULONG	celt,
		LPOLEVERB	rgelt,
		ULONG *	pceltFetched
	)

Definition at line 3053 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
    *pceltFetched = 0;
    hr = IEnumOLEVERB_Next(This, celt, rgelt, pceltFetched);
    if (hr == S_OK) *pceltFetched = celt;
    return hr;
}

IEnumSTATDATA_Next_Proxy()

HRESULT CALLBACK IEnumSTATDATA_Next_Proxy	(	IEnumSTATDATA *	This,
		ULONG	celt,
		STATDATA *	rgelt,
		ULONG *	pceltFetched
	)

Definition at line 2773 of file usrmarshal.c.

{
    ULONG fetched;
    TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
    if (!pceltFetched) pceltFetched = &fetched;
    return IEnumSTATDATA_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
}

IEnumSTATDATA_Next_Stub()

HRESULT __RPC_STUB IEnumSTATDATA_Next_Stub	(	IEnumSTATDATA *	This,
		ULONG	celt,
		STATDATA *	rgelt,
		ULONG *	pceltFetched
	)

Definition at line 2785 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
    *pceltFetched = 0;
    hr = IEnumSTATDATA_Next(This, celt, rgelt, pceltFetched);
    if (hr == S_OK) *pceltFetched = celt;
    return hr;
}

IEnumSTATSTG_Next_Proxy()

HRESULT CALLBACK IEnumSTATSTG_Next_Proxy	(	IEnumSTATSTG *	This,
		ULONG	celt,
		STATSTG *	rgelt,
		ULONG *	pceltFetched
	)

Definition at line 2553 of file usrmarshal.c.

{
    ULONG fetched;
    TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
    if (!pceltFetched) pceltFetched = &fetched;
    return IEnumSTATSTG_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
}

IEnumSTATSTG_Next_Stub()

HRESULT __RPC_STUB IEnumSTATSTG_Next_Stub	(	IEnumSTATSTG *	This,
		ULONG	celt,
		STATSTG *	rgelt,
		ULONG *	pceltFetched
	)

Definition at line 2565 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
    *pceltFetched = 0;
    hr = IEnumSTATSTG_Next(This, celt, rgelt, pceltFetched);
    if (hr == S_OK) *pceltFetched = celt;
    return hr;
}

IEnumString_Next_Proxy()

HRESULT CALLBACK IEnumString_Next_Proxy	(	IEnumString *	This,
		ULONG	celt,
		LPOLESTR *	rgelt,
		ULONG *	pceltFetched
	)

Definition at line 2415 of file usrmarshal.c.

{
    ULONG fetched;
    TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
    if (!pceltFetched) pceltFetched = &fetched;
    return IEnumString_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
}

IEnumString_Next_Stub()

HRESULT __RPC_STUB IEnumString_Next_Stub	(	IEnumString *	This,
		ULONG	celt,
		LPOLESTR *	rgelt,
		ULONG *	pceltFetched
	)

Definition at line 2427 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
    *pceltFetched = 0;
    hr = IEnumString_Next(This, celt, rgelt, pceltFetched);
    if (hr == S_OK) *pceltFetched = celt;
    return hr;
}

IEnumUnknown_Next_Proxy()

HRESULT CALLBACK IEnumUnknown_Next_Proxy	(	IEnumUnknown *	This,
		ULONG	celt,
		IUnknown **	rgelt,
		ULONG *	pceltFetched
	)

Definition at line 2271 of file usrmarshal.c.

{
    ULONG fetched;
    TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
    if (!pceltFetched) pceltFetched = &fetched;
    return IEnumUnknown_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
}

IEnumUnknown_Next_Stub()

HRESULT __RPC_STUB IEnumUnknown_Next_Stub	(	IEnumUnknown *	This,
		ULONG	celt,
		IUnknown **	rgelt,
		ULONG *	pceltFetched
	)

Definition at line 2283 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
    *pceltFetched = 0;
    hr = IEnumUnknown_Next(This, celt, rgelt, pceltFetched);
    if (hr == S_OK) *pceltFetched = celt;
    return hr;
}

IFillLockBytes_FillAppend_Proxy()

HRESULT CALLBACK IFillLockBytes_FillAppend_Proxy	(	IFillLockBytes *	This,
		const void *	pv,
		ULONG	cb,
		ULONG *	pcbWritten
	)

Definition at line 2693 of file usrmarshal.c.

{
    ULONG written;
    HRESULT hr;
 
    TRACE("(%p)->(%p, %d, %p)\n", This, pv, cb, pcbWritten);
 
    hr = IFillLockBytes_RemoteFillAppend_Proxy(This, pv, cb, &written);
    if(pcbWritten) *pcbWritten = written;
 
    return hr;
}

IFillLockBytes_FillAppend_Stub()

HRESULT __RPC_STUB IFillLockBytes_FillAppend_Stub	(	IFillLockBytes *	This,
		const byte *	pv,
		ULONG	cb,
		ULONG *	pcbWritten
	)

Definition at line 2710 of file usrmarshal.c.

{
    TRACE("(%p)->(%p, %d, %p)\n", This, pv, cb, pcbWritten);
    return IFillLockBytes_FillAppend(This, pv, cb, pcbWritten);
}

IFillLockBytes_FillAt_Proxy()

HRESULT CALLBACK IFillLockBytes_FillAt_Proxy	(	IFillLockBytes *	This,
		ULARGE_INTEGER	ulOffset,
		const void *	pv,
		ULONG	cb,
		ULONG *	pcbWritten
	)

Definition at line 2720 of file usrmarshal.c.

{
    ULONG written;
    HRESULT hr;
 
    TRACE("(%p)->(%s, %p, %d, %p)\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbWritten);
 
    hr = IFillLockBytes_RemoteFillAt_Proxy(This, ulOffset, pv, cb, &written);
    if(pcbWritten) *pcbWritten = written;
 
    return hr;
}

IFillLockBytes_FillAt_Stub()

HRESULT __RPC_STUB IFillLockBytes_FillAt_Stub	(	IFillLockBytes *	This,
		ULARGE_INTEGER	ulOffset,
		const byte *	pv,
		ULONG	cb,
		ULONG *	pcbWritten
	)

Definition at line 2738 of file usrmarshal.c.

{
    TRACE("(%p)->(%s, %p, %d, %p)\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbWritten);
    return IFillLockBytes_FillAt(This, ulOffset, pv, cb, pcbWritten);
}

ILockBytes_ReadAt_Proxy()

HRESULT CALLBACK ILockBytes_ReadAt_Proxy	(	ILockBytes *	This,
		ULARGE_INTEGER	ulOffset,
		void *	pv,
		ULONG	cb,
		ULONG *	pcbRead
	)

Definition at line 2635 of file usrmarshal.c.

{
    ULONG read;
    HRESULT hr;
 
    TRACE("(%p)->(%s, %p, %d, %p)\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbRead);
 
    hr = ILockBytes_RemoteReadAt_Proxy(This, ulOffset, pv, cb, &read);
    if(pcbRead) *pcbRead = read;
 
    return hr;
}

ILockBytes_ReadAt_Stub()

HRESULT __RPC_STUB ILockBytes_ReadAt_Stub	(	ILockBytes *	This,
		ULARGE_INTEGER	ulOffset,
		byte *	pv,
		ULONG	cb,
		ULONG *	pcbRead
	)

Definition at line 2653 of file usrmarshal.c.

{
    TRACE("(%p)->(%s, %p, %d, %p)\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbRead);
    return ILockBytes_ReadAt(This, ulOffset, pv, cb, pcbRead);
}

ILockBytes_WriteAt_Proxy()

HRESULT CALLBACK ILockBytes_WriteAt_Proxy	(	ILockBytes *	This,
		ULARGE_INTEGER	ulOffset,
		const void *	pv,
		ULONG	cb,
		ULONG *	pcbWritten
	)

Definition at line 2664 of file usrmarshal.c.

{
    ULONG written;
    HRESULT hr;
 
    TRACE("(%p)->(%s, %p, %d, %p)\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbWritten);
 
    hr = ILockBytes_RemoteWriteAt_Proxy(This, ulOffset, pv, cb, &written);
    if(pcbWritten) *pcbWritten = written;
 
    return hr;
}

ILockBytes_WriteAt_Stub()

HRESULT __RPC_STUB ILockBytes_WriteAt_Stub	(	ILockBytes *	This,
		ULARGE_INTEGER	ulOffset,
		const byte *	pv,
		ULONG	cb,
		ULONG *	pcbWritten
	)

Definition at line 2682 of file usrmarshal.c.

{
    TRACE("(%p)->(%s, %p, %d, %p)\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbWritten);
    return ILockBytes_WriteAt(This, ulOffset, pv, cb, pcbWritten);
}

IMoniker_BindToObject_Proxy()

HRESULT CALLBACK IMoniker_BindToObject_Proxy	(	IMoniker *	This,
		IBindCtx *	pbc,
		IMoniker *	pmkToLeft,
		REFIID	riidResult,
		void **	ppvResult
	)

Definition at line 2371 of file usrmarshal.c.

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

IMoniker_BindToObject_Stub()

HRESULT __RPC_STUB IMoniker_BindToObject_Stub	(	IMoniker *	This,
		IBindCtx *	pbc,
		IMoniker *	pmkToLeft,
		REFIID	riidResult,
		IUnknown **	ppvResult
	)

Definition at line 2382 of file usrmarshal.c.

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

IMoniker_BindToStorage_Proxy()

HRESULT CALLBACK IMoniker_BindToStorage_Proxy	(	IMoniker *	This,
		IBindCtx *	pbc,
		IMoniker *	pmkToLeft,
		REFIID	riid,
		void **	ppvObj
	)

Definition at line 2393 of file usrmarshal.c.

{
    TRACE("(%p)->(%p %p %s %p)\n", This, pbc, pmkToLeft, debugstr_guid(riid), ppvObj);
    return IMoniker_RemoteBindToStorage_Proxy(This, pbc, pmkToLeft, riid, (IUnknown**)ppvObj);
}

IMoniker_BindToStorage_Stub()

HRESULT __RPC_STUB IMoniker_BindToStorage_Stub	(	IMoniker *	This,
		IBindCtx *	pbc,
		IMoniker *	pmkToLeft,
		REFIID	riid,
		IUnknown **	ppvObj
	)

Definition at line 2404 of file usrmarshal.c.

{
    TRACE("(%p)->(%p %p %s %p)\n", This, pbc, pmkToLeft, debugstr_guid(riid), ppvObj);
    return IMoniker_BindToStorage(This, pbc, pmkToLeft, riid, (void**)ppvObj);
}

IOleCache2_UpdateCache_Proxy()

HRESULT CALLBACK IOleCache2_UpdateCache_Proxy	(	IOleCache2 *	This,
		LPDATAOBJECT	pDataObject,
		DWORD	grfUpdf,
		LPVOID	pReserved
	)

Definition at line 3021 of file usrmarshal.c.

{
    TRACE("(%p, %p, 0x%08x, %p)\n", This, pDataObject, grfUpdf, pReserved);
    return IOleCache2_RemoteUpdateCache_Proxy(This, pDataObject, grfUpdf, (LONG_PTR)pReserved);
}

IOleCache2_UpdateCache_Stub()

HRESULT __RPC_STUB IOleCache2_UpdateCache_Stub	(	IOleCache2 *	This,
		LPDATAOBJECT	pDataObject,
		DWORD	grfUpdf,
		LONG_PTR	pReserved
	)

Definition at line 3031 of file usrmarshal.c.

{
    TRACE("(%p, %p, 0x%08x, %li)\n", This, pDataObject, grfUpdf, pReserved);
    return IOleCache2_UpdateCache(This, pDataObject, grfUpdf, (void*)pReserved);
}

IOleInPlaceActiveObject_ResizeBorder_Proxy()

HRESULT CALLBACK IOleInPlaceActiveObject_ResizeBorder_Proxy	(	IOleInPlaceActiveObject *	This,
		LPCRECT	prcBorder,
		IOleInPlaceUIWindow *	pUIWindow,
		BOOL	fFrameWindow
	)

Definition at line 3000 of file usrmarshal.c.

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

IOleInPlaceActiveObject_ResizeBorder_Stub()

HRESULT __RPC_STUB IOleInPlaceActiveObject_ResizeBorder_Stub	(	IOleInPlaceActiveObject *	This,
		LPCRECT	prcBorder,
		REFIID	riid,
		IOleInPlaceUIWindow *	pUIWindow,
		BOOL	fFrameWindow
	)

Definition at line 3010 of file usrmarshal.c.

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

IOleInPlaceActiveObject_TranslateAccelerator_Proxy()

HRESULT CALLBACK IOleInPlaceActiveObject_TranslateAccelerator_Proxy	(	IOleInPlaceActiveObject *	This,
		LPMSG	lpmsg
	)

Definition at line 2985 of file usrmarshal.c.

{
    TRACE("(%p %p)\n", This, lpmsg);
    return IOleInPlaceActiveObject_RemoteTranslateAccelerator_Proxy(This);
}

IOleInPlaceActiveObject_TranslateAccelerator_Stub()

HRESULT __RPC_STUB IOleInPlaceActiveObject_TranslateAccelerator_Stub

(

IOleInPlaceActiveObject *

This

)

Definition at line 2993 of file usrmarshal.c.

{
    TRACE("(%p)\n", This);
    return S_FALSE;
}

IRunnableObject_IsRunning_Proxy()

BOOL CALLBACK IRunnableObject_IsRunning_Proxy

(

IRunnableObject *

This

)

Definition at line 2355 of file usrmarshal.c.

{
    BOOL rv;
    FIXME(":stub\n");
    memset(&rv, 0, sizeof rv);
    return rv;
}

IRunnableObject_IsRunning_Stub()

HRESULT __RPC_STUB IRunnableObject_IsRunning_Stub

(

IRunnableObject *

This

)

Definition at line 2364 of file usrmarshal.c.

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

ISequentialStream_Read_Proxy()

HRESULT CALLBACK ISequentialStream_Read_Proxy	(	ISequentialStream *	This,
		void *	pv,
		ULONG	cb,
		ULONG *	pcbRead
	)

Definition at line 2441 of file usrmarshal.c.

{
    ULONG read;
    HRESULT hr;
 
    TRACE("(%p)->(%p, %d, %p)\n", This, pv, cb, pcbRead);
 
    hr = ISequentialStream_RemoteRead_Proxy(This, pv, cb, &read);
    if(pcbRead) *pcbRead = read;
 
    return hr;
}

ISequentialStream_Read_Stub()

HRESULT __RPC_STUB ISequentialStream_Read_Stub	(	ISequentialStream *	This,
		byte *	pv,
		ULONG	cb,
		ULONG *	pcbRead
	)

Definition at line 2458 of file usrmarshal.c.

{
    TRACE("(%p)->(%p, %d, %p)\n", This, pv, cb, pcbRead);
    return ISequentialStream_Read(This, pv, cb, pcbRead);
}

ISequentialStream_Write_Proxy()

HRESULT CALLBACK ISequentialStream_Write_Proxy	(	ISequentialStream *	This,
		const void *	pv,
		ULONG	cb,
		ULONG *	pcbWritten
	)

Definition at line 2468 of file usrmarshal.c.

{
    ULONG written;
    HRESULT hr;
 
    TRACE("(%p)->(%p, %d, %p)\n", This, pv, cb, pcbWritten);
 
    hr = ISequentialStream_RemoteWrite_Proxy(This, pv, cb, &written);
    if(pcbWritten) *pcbWritten = written;
 
    return hr;
}

ISequentialStream_Write_Stub()

HRESULT __RPC_STUB ISequentialStream_Write_Stub	(	ISequentialStream *	This,
		const byte *	pv,
		ULONG	cb,
		ULONG *	pcbWritten
	)

Definition at line 2485 of file usrmarshal.c.

{
    TRACE("(%p)->(%p, %d, %p)\n", This, pv, cb, pcbWritten);
    return ISequentialStream_Write(This, pv, cb, pcbWritten);
}

IStorage_EnumElements_Proxy()

HRESULT CALLBACK IStorage_EnumElements_Proxy	(	IStorage *	This,
		DWORD	reserved1,
		void *	reserved2,
		DWORD	reserved3,
		IEnumSTATSTG **	ppenum
	)

Definition at line 2608 of file usrmarshal.c.

{
    TRACE("(%p)->(%d, %p, %d, %p)\n", This, reserved1, reserved2, reserved3, ppenum);
    if(reserved2) WARN("reserved2 %p\n", reserved2);
 
    return IStorage_RemoteEnumElements_Proxy(This, reserved1, 0, NULL, reserved3, ppenum);
}

IStorage_EnumElements_Stub()

HRESULT __RPC_STUB IStorage_EnumElements_Stub	(	IStorage *	This,
		DWORD	reserved1,
		ULONG	cbReserved2,
		byte *	reserved2,
		DWORD	reserved3,
		IEnumSTATSTG **	ppenum
	)

Definition at line 2621 of file usrmarshal.c.

{
    TRACE("(%p)->(%d, %d, %p, %d, %p)\n", This, reserved1, cbReserved2, reserved2, reserved3, ppenum);
    if(cbReserved2 || reserved2) WARN("cbReserved2 %d reserved2 %p\n", cbReserved2, reserved2);
 
    return IStorage_EnumElements(This, reserved1, NULL, reserved3, ppenum);
}

IStorage_OpenStream_Proxy()

HRESULT CALLBACK IStorage_OpenStream_Proxy	(	IStorage *	This,
		LPCOLESTR	pwcsName,
		void *	reserved1,
		DWORD	grfMode,
		DWORD	reserved2,
		IStream **	ppstm
	)

Definition at line 2579 of file usrmarshal.c.

{
    TRACE("(%p)->(%s, %p, %08x, %d %p)\n", This, debugstr_w(pwcsName), reserved1, grfMode, reserved2, ppstm);
    if(reserved1) WARN("reserved1 %p\n", reserved1);
 
    return IStorage_RemoteOpenStream_Proxy(This, pwcsName, 0, NULL, grfMode, reserved2, ppstm);
}

IStorage_OpenStream_Stub()

HRESULT __RPC_STUB IStorage_OpenStream_Stub	(	IStorage *	This,
		LPCOLESTR	pwcsName,
		ULONG	cbReserved1,
		byte *	reserved1,
		DWORD	grfMode,
		DWORD	reserved2,
		IStream **	ppstm
	)

Definition at line 2593 of file usrmarshal.c.

{
    TRACE("(%p)->(%s, %d, %p, %08x, %d %p)\n", This, debugstr_w(pwcsName), cbReserved1, reserved1, grfMode, reserved2, ppstm);
    if(cbReserved1 || reserved1) WARN("cbReserved1 %d reserved1 %p\n", cbReserved1, reserved1);
 
    return IStorage_OpenStream(This, pwcsName, NULL, grfMode, reserved2, ppstm);
}

IStream_CopyTo_Proxy()

HRESULT CALLBACK IStream_CopyTo_Proxy	(	IStream *	This,
		IStream *	pstm,
		ULARGE_INTEGER	cb,
		ULARGE_INTEGER *	pcbRead,
		ULARGE_INTEGER *	pcbWritten
	)

Definition at line 2522 of file usrmarshal.c.

{
    ULARGE_INTEGER read, written;
    HRESULT hr;
 
    TRACE("(%p)->(%p, %s, %p, %p)\n", This, pstm, wine_dbgstr_longlong(cb.QuadPart), pcbRead, pcbWritten);
 
    hr = IStream_RemoteCopyTo_Proxy(This, pstm, cb, &read, &written);
    if(pcbRead) *pcbRead = read;
    if(pcbWritten) *pcbWritten = written;
 
    return hr;
}

IStream_CopyTo_Stub()

HRESULT __RPC_STUB IStream_CopyTo_Stub	(	IStream *	This,
		IStream *	pstm,
		ULARGE_INTEGER	cb,
		ULARGE_INTEGER *	pcbRead,
		ULARGE_INTEGER *	pcbWritten
	)

Definition at line 2541 of file usrmarshal.c.

{
    TRACE("(%p)->(%p, %s, %p, %p)\n", This, pstm, wine_dbgstr_longlong(cb.QuadPart), pcbRead, pcbWritten);
 
    return IStream_CopyTo(This, pstm, cb, pcbRead, pcbWritten);
}

IStream_Seek_Proxy()

HRESULT CALLBACK IStream_Seek_Proxy	(	IStream *	This,
		LARGE_INTEGER	dlibMove,
		DWORD	dwOrigin,
		ULARGE_INTEGER *	plibNewPosition
	)

Definition at line 2495 of file usrmarshal.c.

{
    ULARGE_INTEGER newpos;
    HRESULT hr;
 
    TRACE("(%p)->(%s, %d, %p)\n", This, wine_dbgstr_longlong(dlibMove.QuadPart), dwOrigin, plibNewPosition);
 
    hr = IStream_RemoteSeek_Proxy(This, dlibMove, dwOrigin, &newpos);
    if(plibNewPosition) *plibNewPosition = newpos;
 
    return hr;
}

IStream_Seek_Stub()

HRESULT __RPC_STUB IStream_Seek_Stub	(	IStream *	This,
		LARGE_INTEGER	dlibMove,
		DWORD	dwOrigin,
		ULARGE_INTEGER *	plibNewPosition
	)

Definition at line 2512 of file usrmarshal.c.

{
    TRACE("(%p)->(%s, %d, %p)\n", This, wine_dbgstr_longlong(dlibMove.QuadPart), dwOrigin, plibNewPosition);
    return IStream_Seek(This, dlibMove, dwOrigin, plibNewPosition);
}

IViewObject_Draw_Proxy()

HRESULT CALLBACK IViewObject_Draw_Proxy	(	IViewObject *	This,
		DWORD	dwDrawAspect,
		LONG	lindex,
		void *	pvAspect,
		DVTARGETDEVICE *	ptd,
		HDC	hdcTargetDev,
		HDC	hdcDraw,
		LPCRECTL	lprcBounds,
		LPCRECTL	lprcWBounds,
		BOOL(STDMETHODCALLTYPE *pfnContinue)(ULONG_PTR dwContinue)	,
		ULONG_PTR	dwContinue
	)

Definition at line 3067 of file usrmarshal.c.

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

IViewObject_Draw_Stub()

HRESULT __RPC_STUB IViewObject_Draw_Stub	(	IViewObject *	This,
		DWORD	dwDrawAspect,
		LONG	lindex,
		ULONG_PTR	pvAspect,
		DVTARGETDEVICE *	ptd,
		ULONG_PTR	hdcTargetDev,
		ULONG_PTR	hdcDraw,
		LPCRECTL	lprcBounds,
		LPCRECTL	lprcWBounds,
		IContinue *	pContinue
	)

Definition at line 3084 of file usrmarshal.c.

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

IViewObject_Freeze_Proxy()

HRESULT CALLBACK IViewObject_Freeze_Proxy	(	IViewObject *	This,
		DWORD	dwDrawAspect,
		LONG	lindex,
		void *	pvAspect,
		DWORD *	pdwFreeze
	)

Definition at line 3126 of file usrmarshal.c.

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

IViewObject_Freeze_Stub()

HRESULT __RPC_STUB IViewObject_Freeze_Stub	(	IViewObject *	This,
		DWORD	dwDrawAspect,
		LONG	lindex,
		ULONG_PTR	pvAspect,
		DWORD *	pdwFreeze
	)

Definition at line 3137 of file usrmarshal.c.

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

IViewObject_GetAdvise_Proxy()

HRESULT CALLBACK IViewObject_GetAdvise_Proxy	(	IViewObject *	This,
		DWORD *	pAspects,
		DWORD *	pAdvf,
		IAdviseSink **	ppAdvSink
	)

Definition at line 3148 of file usrmarshal.c.

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

IViewObject_GetAdvise_Stub()

HRESULT __RPC_STUB IViewObject_GetAdvise_Stub	(	IViewObject *	This,
		DWORD *	pAspects,
		DWORD *	pAdvf,
		IAdviseSink **	ppAdvSink
	)

Definition at line 3158 of file usrmarshal.c.

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

IViewObject_GetColorSet_Proxy()

HRESULT CALLBACK IViewObject_GetColorSet_Proxy	(	IViewObject *	This,
		DWORD	dwDrawAspect,
		LONG	lindex,
		void *	pvAspect,
		DVTARGETDEVICE *	ptd,
		HDC	hicTargetDev,
		LOGPALETTE **	ppColorSet
	)

Definition at line 3100 of file usrmarshal.c.

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

IViewObject_GetColorSet_Stub()

HRESULT __RPC_STUB IViewObject_GetColorSet_Stub	(	IViewObject *	This,
		DWORD	dwDrawAspect,
		LONG	lindex,
		ULONG_PTR	pvAspect,
		DVTARGETDEVICE *	ptd,
		ULONG_PTR	hicTargetDev,
		LOGPALETTE **	ppColorSet
	)

Definition at line 3113 of file usrmarshal.c.

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

SNB_UserFree()

void __RPC_USER SNB_UserFree	(	ULONG *	pFlags,
		SNB *	pSnb
	)

Definition at line 2217 of file usrmarshal.c.

{
    USER_MARSHAL_CB *umcb = (USER_MARSHAL_CB*)pFlags;
    TRACE("(%p)\n", pSnb);
    if (*pSnb)
        umcb->pStubMsg->pfnFree(*pSnb);
}

Referenced by test_marshal_SNB().

SNB_UserMarshal()

unsigned char *__RPC_USER SNB_UserMarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		SNB *	pSnb
	)

Definition at line 2143 of file usrmarshal.c.

{
    struct SNB_wire *wire;
    ULONG size;
 
    TRACE("(%s, %p, %p)\n", debugstr_user_flags(pFlags), pBuffer, pSnb);
 
    ALIGN_POINTER(pBuffer, 3);
 
    wire = (struct SNB_wire*)pBuffer;
    wire->charcnt = wire->strcnt = 0;
    size = 3*sizeof(ULONG);
 
    if (*pSnb)
    {
        WCHAR **ptrW = *pSnb;
        WCHAR *dataW = wire->data;
 
        while (*ptrW)
        {
            ULONG len = lstrlenW(*ptrW) + 1;
 
            wire->strcnt++;
            wire->charcnt += len;
            memcpy(dataW, *ptrW, len*sizeof(WCHAR));
            dataW += len;
 
            size += len*sizeof(WCHAR);
            ptrW++;
        }
    }
 
    wire->datalen = wire->charcnt;
    return pBuffer + size;
}

Referenced by test_marshal_SNB().

SNB_UserSize()

ULONG __RPC_USER SNB_UserSize	(	ULONG *	pFlags,
		ULONG	StartingSize,
		SNB *	pSnb
	)

Definition at line 2110 of file usrmarshal.c.

{
    ULONG size = StartingSize;
 
    TRACE("(%s, %d, %p\n", debugstr_user_flags(pFlags), StartingSize, pSnb);
 
    ALIGN_LENGTH(size, 3);
 
    /* two counters from RemSNB header, plus one more ULONG */
    size += 3*sizeof(ULONG);
 
    /* now actual data length */
    if (*pSnb)
    {
        WCHAR **ptrW = *pSnb;
 
        while (*ptrW)
        {
            size += (lstrlenW(*ptrW) + 1)*sizeof(WCHAR);
            ptrW++;
        }
    }
 
    return size;
}

Referenced by test_marshal_SNB().

SNB_UserUnmarshal()

unsigned char *__RPC_USER SNB_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		SNB *	pSnb
	)

Definition at line 2179 of file usrmarshal.c.

{
    USER_MARSHAL_CB *umcb = (USER_MARSHAL_CB*)pFlags;
    struct SNB_wire *wire;
 
    TRACE("(%s, %p, %p)\n", debugstr_user_flags(pFlags), pBuffer, pSnb);
 
    wire = (struct SNB_wire*)pBuffer;
 
    if (*pSnb)
        umcb->pStubMsg->pfnFree(*pSnb);
 
    if (wire->datalen == 0)
        *pSnb = NULL;
    else
    {
        WCHAR *src = wire->data, *dest;
        WCHAR **ptrW;
        ULONG i;
 
        ptrW = *pSnb = umcb->pStubMsg->pfnAllocate((wire->strcnt+1)*sizeof(WCHAR*) + wire->datalen*sizeof(WCHAR));
        dest = (WCHAR*)(*pSnb + wire->strcnt + 1);
 
        for (i = 0; i < wire->strcnt; i++)
        {
            ULONG len = lstrlenW(src);
            memcpy(dest, src, (len + 1)*sizeof(WCHAR));
            *ptrW = dest;
            src += len + 1;
            dest += len + 1;
            ptrW++;
        }
        *ptrW = NULL;
    }
 
    return pBuffer + 3*sizeof(ULONG) + wire->datalen*sizeof(WCHAR);
}

Referenced by test_marshal_SNB().

STGMEDIUM_UserFree()

void __RPC_USER STGMEDIUM_UserFree	(	ULONG *	flags,
		STGMEDIUM *	med
	)

Definition at line 2038 of file usrmarshal.c.

{
    TRACE("(%s, %p)\n", debugstr_user_flags(flags), med);
 
    switch (med->tymed)
    {
    case TYMED_NULL:
    case TYMED_FILE:
    case TYMED_ISTREAM:
    case TYMED_ISTORAGE:
        ReleaseStgMedium(med);
        break;
    case TYMED_HGLOBAL:
    case TYMED_GDI:
    case TYMED_MFPICT:
    case TYMED_ENHMF:
        if (LOWORD(*flags) == MSHCTX_INPROC)
            med->tymed = TYMED_NULL;
        ReleaseStgMedium(med);
        break;
    default:
        RaiseException(DV_E_TYMED, 0, 0, NULL);
    }
}

Referenced by ASYNC_STGMEDIUM_UserFree(), and marshal_STGMEDIUM().

STGMEDIUM_UserMarshal()

unsigned char *__RPC_USER STGMEDIUM_UserMarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		STGMEDIUM *	pStgMedium
	)

Definition at line 1785 of file usrmarshal.c.

{
    TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, pStgMedium);
 
    ALIGN_POINTER(pBuffer, 3);
 
    *(DWORD *)pBuffer = pStgMedium->tymed;
    pBuffer += sizeof(DWORD);
    if (pStgMedium->tymed != TYMED_NULL)
    {
        *(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->u.pstg;
        pBuffer += sizeof(DWORD);
    }
    *(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->pUnkForRelease;
    pBuffer += sizeof(DWORD);
 
    switch (pStgMedium->tymed)
    {
    case TYMED_NULL:
        TRACE("TYMED_NULL\n");
        break;
    case TYMED_HGLOBAL:
        TRACE("TYMED_HGLOBAL\n");
        if (pStgMedium->u.hGlobal)
            pBuffer = HGLOBAL_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hGlobal);
        break;
    case TYMED_FILE:
        TRACE("TYMED_FILE\n");
        if (pStgMedium->u.lpszFileName)
        {
            DWORD len;
            len = lstrlenW(pStgMedium->u.lpszFileName);
            /* conformance */
            *(DWORD *)pBuffer = len + 1;
            pBuffer += sizeof(DWORD);
            /* offset */
            *(DWORD *)pBuffer = 0;
            pBuffer += sizeof(DWORD);
            /* variance */
            *(DWORD *)pBuffer = len + 1;
            pBuffer += sizeof(DWORD);
 
            TRACE("file name is %s\n", debugstr_w(pStgMedium->u.lpszFileName));
            memcpy(pBuffer, pStgMedium->u.lpszFileName, (len + 1) * sizeof(WCHAR));
        }
        break;
    case TYMED_ISTREAM:
        TRACE("TYMED_ISTREAM\n");
        if (pStgMedium->u.pstm)
        {
            IUnknown *unk;
            IStream_QueryInterface(pStgMedium->u.pstm, &IID_IUnknown, (void**)&unk);
            pBuffer = WdtpInterfacePointer_UserMarshal(pFlags, LOWORD(*pFlags), pBuffer, unk, &IID_IStream);
            IUnknown_Release(unk);
        }
        break;
    case TYMED_ISTORAGE:
        TRACE("TYMED_ISTORAGE\n");
        if (pStgMedium->u.pstg)
        {
            IUnknown *unk;
            IStorage_QueryInterface(pStgMedium->u.pstg, &IID_IUnknown, (void**)&unk);
            pBuffer = WdtpInterfacePointer_UserMarshal(pFlags, LOWORD(*pFlags), pBuffer, unk, &IID_IStorage);
            IUnknown_Release(unk);
        }
        break;
    case TYMED_GDI:
        TRACE("TYMED_GDI\n");
        if (pStgMedium->u.hBitmap)
            pBuffer = HBITMAP_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hBitmap);
        break;
    case TYMED_MFPICT:
        TRACE("TYMED_MFPICT\n");
        if (pStgMedium->u.hMetaFilePict)
            pBuffer = HMETAFILEPICT_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hMetaFilePict);
        break;
    case TYMED_ENHMF:
        TRACE("TYMED_ENHMF\n");
        if (pStgMedium->u.hEnhMetaFile)
            pBuffer = HENHMETAFILE_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hEnhMetaFile);
        break;
    default:
        RaiseException(DV_E_TYMED, 0, 0, NULL);
    }
 
    if (pStgMedium->pUnkForRelease)
        pBuffer = WdtpInterfacePointer_UserMarshal(pFlags, LOWORD(*pFlags), pBuffer, pStgMedium->pUnkForRelease, &IID_IUnknown);
 
    return pBuffer;
}

Referenced by ASYNC_STGMEDIUM_UserMarshal(), and marshal_STGMEDIUM().

STGMEDIUM_UserSize()

ULONG __RPC_USER STGMEDIUM_UserSize	(	ULONG *	pFlags,
		ULONG	StartingSize,
		STGMEDIUM *	pStgMedium
	)

Definition at line 1690 of file usrmarshal.c.

{
    ULONG size = StartingSize;
 
    TRACE("(%s, %d, %p\n", debugstr_user_flags(pFlags), StartingSize, pStgMedium);
 
    ALIGN_LENGTH(size, 3);
 
    size += 2 * sizeof(DWORD);
    if (pStgMedium->tymed != TYMED_NULL)
        size += sizeof(DWORD);
 
    switch (pStgMedium->tymed)
    {
    case TYMED_NULL:
        TRACE("TYMED_NULL\n");
        break;
    case TYMED_HGLOBAL:
        TRACE("TYMED_HGLOBAL\n");
        if (pStgMedium->u.hGlobal)
            size = HGLOBAL_UserSize(pFlags, size, &pStgMedium->u.hGlobal);
        break;
    case TYMED_FILE:
        TRACE("TYMED_FILE\n");
        if (pStgMedium->u.lpszFileName)
        {
            TRACE("file name is %s\n", debugstr_w(pStgMedium->u.lpszFileName));
            size += 3 * sizeof(DWORD) +
                (lstrlenW(pStgMedium->u.lpszFileName) + 1) * sizeof(WCHAR);
        }
        break;
    case TYMED_ISTREAM:
        TRACE("TYMED_ISTREAM\n");
        if (pStgMedium->u.pstm)
        {
            IUnknown *unk;
            IStream_QueryInterface(pStgMedium->u.pstm, &IID_IUnknown, (void**)&unk);
            size = WdtpInterfacePointer_UserSize(pFlags, LOWORD(*pFlags), size, unk, &IID_IStream);
            IUnknown_Release(unk);
        }
        break;
    case TYMED_ISTORAGE:
        TRACE("TYMED_ISTORAGE\n");
        if (pStgMedium->u.pstg)
        {
            IUnknown *unk;
            IStorage_QueryInterface(pStgMedium->u.pstg, &IID_IUnknown, (void**)&unk);
            size = WdtpInterfacePointer_UserSize(pFlags, LOWORD(*pFlags), size, unk, &IID_IStorage);
            IUnknown_Release(unk);
        }
        break;
    case TYMED_GDI:
        TRACE("TYMED_GDI\n");
        if (pStgMedium->u.hBitmap)
            size = HBITMAP_UserSize(pFlags, size, &pStgMedium->u.hBitmap);
        break;
    case TYMED_MFPICT:
        TRACE("TYMED_MFPICT\n");
        if (pStgMedium->u.hMetaFilePict)
            size = HMETAFILEPICT_UserSize(pFlags, size, &pStgMedium->u.hMetaFilePict);
        break;
    case TYMED_ENHMF:
        TRACE("TYMED_ENHMF\n");
        if (pStgMedium->u.hEnhMetaFile)
            size = HENHMETAFILE_UserSize(pFlags, size, &pStgMedium->u.hEnhMetaFile);
        break;
    default:
        RaiseException(DV_E_TYMED, 0, 0, NULL);
    }
 
    if (pStgMedium->pUnkForRelease)
        size = WdtpInterfacePointer_UserSize(pFlags, LOWORD(*pFlags), size, pStgMedium->pUnkForRelease, &IID_IUnknown);
 
    return size;
}

Referenced by ASYNC_STGMEDIUM_UserSize(), and marshal_STGMEDIUM().

STGMEDIUM_UserUnmarshal()

unsigned char *__RPC_USER STGMEDIUM_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	pBuffer,
		STGMEDIUM *	pStgMedium
	)

Definition at line 1895 of file usrmarshal.c.

{
    DWORD content = 0;
    DWORD releaseunk;
 
    ALIGN_POINTER(pBuffer, 3);
 
    TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, pStgMedium);
 
    pStgMedium->tymed = *(DWORD *)pBuffer;
    pBuffer += sizeof(DWORD);
    if (pStgMedium->tymed != TYMED_NULL)
    {
        content = *(DWORD *)pBuffer;
        pBuffer += sizeof(DWORD);
    }
    releaseunk = *(DWORD *)pBuffer;
    pBuffer += sizeof(DWORD);
 
    switch (pStgMedium->tymed)
    {
    case TYMED_NULL:
        TRACE("TYMED_NULL\n");
        break;
    case TYMED_HGLOBAL:
        TRACE("TYMED_HGLOBAL\n");
        if (content)
            pBuffer = HGLOBAL_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hGlobal);
        break;
    case TYMED_FILE:
        TRACE("TYMED_FILE\n");
        if (content)
        {
            DWORD conformance;
            DWORD variance;
            conformance = *(DWORD *)pBuffer;
            pBuffer += sizeof(DWORD);
            if (*(DWORD *)pBuffer != 0)
            {
                ERR("invalid offset %d\n", *(DWORD *)pBuffer);
                RpcRaiseException(RPC_S_INVALID_BOUND);
                return NULL;
            }
            pBuffer += sizeof(DWORD);
            variance = *(DWORD *)pBuffer;
            pBuffer += sizeof(DWORD);
            if (conformance != variance)
            {
                ERR("conformance (%d) and variance (%d) should be equal\n",
                    conformance, variance);
                RpcRaiseException(RPC_S_INVALID_BOUND);
                return NULL;
            }
            if (conformance > 0x7fffffff)
            {
                ERR("conformance 0x%x too large\n", conformance);
                RpcRaiseException(RPC_S_INVALID_BOUND);
                return NULL;
            }
            pStgMedium->u.lpszFileName = CoTaskMemAlloc(conformance * sizeof(WCHAR));
            if (!pStgMedium->u.lpszFileName) RpcRaiseException(ERROR_OUTOFMEMORY);
            TRACE("unmarshalled file name is %s\n", debugstr_wn((const WCHAR *)pBuffer, variance));
            memcpy(pStgMedium->u.lpszFileName, pBuffer, variance * sizeof(WCHAR));
            pBuffer += variance * sizeof(WCHAR);
        }
        else
            pStgMedium->u.lpszFileName = NULL;
        break;
    case TYMED_ISTREAM:
        TRACE("TYMED_ISTREAM\n");
        if (content)
        {
            pBuffer = WdtpInterfacePointer_UserUnmarshal(pFlags, pBuffer, (IUnknown**)&pStgMedium->u.pstm, &IID_IStream);
        }
        else
        {
            if (pStgMedium->u.pstm) IStream_Release( pStgMedium->u.pstm );
            pStgMedium->u.pstm = NULL;
        }
        break;
    case TYMED_ISTORAGE:
        TRACE("TYMED_ISTORAGE\n");
        if (content)
        {
            pBuffer = WdtpInterfacePointer_UserUnmarshal(pFlags, pBuffer, (IUnknown**)&pStgMedium->u.pstg, &IID_IStorage);
        }
        else
        {
            if (pStgMedium->u.pstg) IStorage_Release( pStgMedium->u.pstg );
            pStgMedium->u.pstg = NULL;
        }
        break;
    case TYMED_GDI:
        TRACE("TYMED_GDI\n");
        if (content)
            pBuffer = HBITMAP_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hBitmap);
        else
            pStgMedium->u.hBitmap = NULL;
        break;
    case TYMED_MFPICT:
        TRACE("TYMED_MFPICT\n");
        if (content)
            pBuffer = HMETAFILEPICT_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hMetaFilePict);
        else
            pStgMedium->u.hMetaFilePict = NULL;
        break;
    case TYMED_ENHMF:
        TRACE("TYMED_ENHMF\n");
        if (content)
            pBuffer = HENHMETAFILE_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hEnhMetaFile);
        else
            pStgMedium->u.hEnhMetaFile = NULL;
        break;
    default:
        RaiseException(DV_E_TYMED, 0, 0, NULL);
    }
 
    if (releaseunk)
        pBuffer = WdtpInterfacePointer_UserUnmarshal(pFlags, pBuffer, &pStgMedium->pUnkForRelease, &IID_IUnknown);
    /* Unlike the IStream / IStorage ifaces, the existing pUnkForRelease
       is left intact if a NULL ptr is unmarshalled - see the tests. */
 
    return pBuffer;
}

Referenced by ASYNC_STGMEDIUM_UserUnmarshal(), and marshal_STGMEDIUM().

WdtpInterfacePointer_UserFree()

void WINAPI WdtpInterfacePointer_UserFree

(

IUnknown *

punk

)

Definition at line 1664 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 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 *WINAPI 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().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)