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	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

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
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)
static const char *	debugstr_user_flags (ULONG *pFlags)
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	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 42 of file usrmarshal.c.

ALIGN_POINTER

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

Definition at line 43 of file usrmarshal.c.

ALIGNED_LENGTH

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

Definition at line 40 of file usrmarshal.c.

ALIGNED_POINTER

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

Definition at line 41 of file usrmarshal.c.

COBJMACROS

#define COBJMACROS

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

Function Documentation

ASYNC_STGMEDIUM_UserFree()

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

Definition at line 1108 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 1096 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 1090 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 1102 of file usrmarshal.c.

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

debugstr_user_flags()

static const char * debugstr_user_flags ( ULONG *  pFlags )

static

Definition at line 54 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));
}

FLAG_STGMEDIUM_UserFree()

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

Definition at line 1132 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 1120 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 1114 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 1126 of file usrmarshal.c.

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

HENHMETAFILE_UserFree()

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

Definition at line 469 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 346 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 301 of file usrmarshal.c.

{
    TRACE("%s, %lu, %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 404 of file usrmarshal.c.

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

Referenced by STGMEDIUM_UserUnmarshal(), and test_marshal_HENHMETAFILE().

HMETAFILE_UserFree()

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

Definition at line 273 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 150 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 103 of file usrmarshal.c.

{
    ULONG size = StartingSize;
 
    TRACE("%s, %lu, &%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 208 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 681 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 547 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 497 of file usrmarshal.c.

{
    TRACE("%s, %lu, &%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 610 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().

IAdviseSink2_OnLinkSrcChange_Proxy()

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

Definition at line 1911 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 1919 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 1896 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 1903 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 1826 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 1835 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 1864 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 1872 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 1881 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 1888 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 1845 of file usrmarshal.c.

{
    TRACE("%p, %ld, %ld.\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 1854 of file usrmarshal.c.

{
    TRACE("%p, %ld, %ld.\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 1340 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 1348 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 1324 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 1332 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 1254 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 1271 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 1280 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 1288 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 1928 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 1937 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 1946 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->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->pstg)
            IStorage_Release( med->pstg );
        med->pstg = stg;
    }
 
    return hr;
}

IDataObject_GetDataHere_Stub()

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

Definition at line 1981 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 1990 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 2000 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 1776 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 1787 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 1356 of file usrmarshal.c.

{
    ULONG fetched;
    TRACE("%p, %lu, %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 1368 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("%p, %lu, %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 2068 of file usrmarshal.c.

{
    ULONG fetched;
    TRACE("%p, %lu, %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 2080 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("%p, %lu, %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 1800 of file usrmarshal.c.

{
    ULONG fetched;
    TRACE("%p, %ld, %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 1812 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("%p, %lu, %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 1580 of file usrmarshal.c.

{
    ULONG fetched;
    TRACE("%p, %lu, %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 1592 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("%p, %lu, %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 1442 of file usrmarshal.c.

{
    ULONG fetched;
    TRACE("%p, %lu, %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 1454 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("%p, %lu, %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 1298 of file usrmarshal.c.

{
    ULONG fetched;
    TRACE("%p, %lu, %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 1310 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("%p, %lu, %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 1720 of file usrmarshal.c.

{
    ULONG written;
    HRESULT hr;
 
    TRACE("%p, %p, %lu, %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 1737 of file usrmarshal.c.

{
    TRACE("%p, %p, %lu, %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 1747 of file usrmarshal.c.

{
    ULONG written;
    HRESULT hr;
 
    TRACE("%p, %s, %p, %lu, %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 1765 of file usrmarshal.c.

{
    TRACE("%p, %s, %p, %ld, %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 1662 of file usrmarshal.c.

{
    ULONG read;
    HRESULT hr;
 
    TRACE("%p, %s, %p, %lu, %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 1680 of file usrmarshal.c.

{
    TRACE("%p, %s, %p, %lu, %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 1691 of file usrmarshal.c.

{
    ULONG written;
    HRESULT hr;
 
    TRACE("%p, %s, %p, %lu, %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 1709 of file usrmarshal.c.

{
    TRACE("%p, %s, %p, %lu, %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 1398 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 1409 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 1420 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 1431 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 2048 of file usrmarshal.c.

{
    TRACE("%p, %p, %#lx, %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 2058 of file usrmarshal.c.

{
    TRACE("%p, %p, %#lx, %Id.\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 2027 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 2037 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 2012 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 2020 of file usrmarshal.c.

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

IRunnableObject_IsRunning_Proxy()

BOOL CALLBACK IRunnableObject_IsRunning_Proxy

(

IRunnableObject *

This

)

Definition at line 1382 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 1391 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 1468 of file usrmarshal.c.

{
    ULONG read;
    HRESULT hr;
 
    TRACE("%p, %p, %lu, %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 1485 of file usrmarshal.c.

{
    TRACE("%p, %p, %lu, %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 1495 of file usrmarshal.c.

{
    ULONG written;
    HRESULT hr;
 
    TRACE("%p, %p, %lu, %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 1512 of file usrmarshal.c.

{
    TRACE("%p, %p, %lu, %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 1635 of file usrmarshal.c.

{
    TRACE("%p, %ld, %p, %ld, %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 1648 of file usrmarshal.c.

{
    TRACE("%p, %ld, %ld, %p, %ld, %p.\n", This, reserved1, cbReserved2, reserved2, reserved3, ppenum);
    if(cbReserved2 || reserved2) WARN("cbReserved2 %ld 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 1606 of file usrmarshal.c.

{
    TRACE("%p, %s, %p, %#lx, %ld, %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 1620 of file usrmarshal.c.

{
    TRACE("%p, %s, %ld, %p, %#lx, %ld, %p.\n", This, debugstr_w(pwcsName), cbReserved1, reserved1, grfMode, reserved2, ppstm);
    if(cbReserved1 || reserved1) WARN("cbReserved1 %ld 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 1549 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 1568 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 1522 of file usrmarshal.c.

{
    ULARGE_INTEGER newpos;
    HRESULT hr;
 
    TRACE("%p, %s, %ld, %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 1539 of file usrmarshal.c.

{
    TRACE("%p, %s, %ld, %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 2094 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 2111 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 2153 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 2164 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 2175 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 2185 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 2127 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 2140 of file usrmarshal.c.

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

SNB_UserFree()

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

Definition at line 1244 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 1170 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 1137 of file usrmarshal.c.

{
    ULONG size = StartingSize;
 
    TRACE("%s, %lu, %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 1206 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 1065 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 813 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->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->hGlobal)
            pBuffer = HGLOBAL_UserMarshal(pFlags, pBuffer, &pStgMedium->hGlobal);
        break;
    case TYMED_FILE:
        TRACE("TYMED_FILE\n");
        if (pStgMedium->lpszFileName)
        {
            DWORD len;
            len = lstrlenW(pStgMedium->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->lpszFileName));
            memcpy(pBuffer, pStgMedium->lpszFileName, (len + 1) * sizeof(WCHAR));
        }
        break;
    case TYMED_ISTREAM:
        TRACE("TYMED_ISTREAM\n");
        if (pStgMedium->pstm)
        {
            IUnknown *unk;
            IStream_QueryInterface(pStgMedium->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->pstg)
        {
            IUnknown *unk;
            IStorage_QueryInterface(pStgMedium->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->hBitmap)
            pBuffer = HBITMAP_UserMarshal(pFlags, pBuffer, &pStgMedium->hBitmap);
        break;
    case TYMED_MFPICT:
        TRACE("TYMED_MFPICT\n");
        if (pStgMedium->hMetaFilePict)
            pBuffer = HMETAFILEPICT_UserMarshal(pFlags, pBuffer, &pStgMedium->hMetaFilePict);
        break;
    case TYMED_ENHMF:
        TRACE("TYMED_ENHMF\n");
        if (pStgMedium->hEnhMetaFile)
            pBuffer = HENHMETAFILE_UserMarshal(pFlags, pBuffer, &pStgMedium->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 718 of file usrmarshal.c.

{
    ULONG size = StartingSize;
 
    TRACE("%s, %lu, %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->hGlobal)
            size = HGLOBAL_UserSize(pFlags, size, &pStgMedium->hGlobal);
        break;
    case TYMED_FILE:
        TRACE("TYMED_FILE\n");
        if (pStgMedium->lpszFileName)
        {
            TRACE("file name is %s\n", debugstr_w(pStgMedium->lpszFileName));
            size += 3 * sizeof(DWORD) +
                (lstrlenW(pStgMedium->lpszFileName) + 1) * sizeof(WCHAR);
        }
        break;
    case TYMED_ISTREAM:
        TRACE("TYMED_ISTREAM\n");
        if (pStgMedium->pstm)
        {
            IUnknown *unk;
            IStream_QueryInterface(pStgMedium->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->pstg)
        {
            IUnknown *unk;
            IStorage_QueryInterface(pStgMedium->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->hBitmap)
            size = HBITMAP_UserSize(pFlags, size, &pStgMedium->hBitmap);
        break;
    case TYMED_MFPICT:
        TRACE("TYMED_MFPICT\n");
        if (pStgMedium->hMetaFilePict)
            size = HMETAFILEPICT_UserSize(pFlags, size, &pStgMedium->hMetaFilePict);
        break;
    case TYMED_ENHMF:
        TRACE("TYMED_ENHMF\n");
        if (pStgMedium->hEnhMetaFile)
            size = HENHMETAFILE_UserSize(pFlags, size, &pStgMedium->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 923 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->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 %ld\n", *(DWORD *)pBuffer);
                RpcRaiseException(RPC_S_INVALID_BOUND);
                return NULL;
            }
            pBuffer += sizeof(DWORD);
            variance = *(DWORD *)pBuffer;
            pBuffer += sizeof(DWORD);
            if (conformance != variance)
            {
                ERR("conformance (%ld) and variance (%ld) should be equal\n", conformance, variance);
                RpcRaiseException(RPC_S_INVALID_BOUND);
                return NULL;
            }
            if (conformance > 0x7fffffff)
            {
                ERR("conformance %#lx too large\n", conformance);
                RpcRaiseException(RPC_S_INVALID_BOUND);
                return NULL;
            }
            pStgMedium->lpszFileName = CoTaskMemAlloc(conformance * sizeof(WCHAR));
            if (!pStgMedium->lpszFileName) RpcRaiseException(ERROR_OUTOFMEMORY);
            TRACE("unmarshalled file name is %s\n", debugstr_wn((const WCHAR *)pBuffer, variance));
            memcpy(pStgMedium->lpszFileName, pBuffer, variance * sizeof(WCHAR));
            pBuffer += variance * sizeof(WCHAR);
        }
        else
            pStgMedium->lpszFileName = NULL;
        break;
    case TYMED_ISTREAM:
        TRACE("TYMED_ISTREAM\n");
        if (content)
        {
            pBuffer = WdtpInterfacePointer_UserUnmarshal(pFlags, pBuffer, (IUnknown**)&pStgMedium->pstm, &IID_IStream);
        }
        else
        {
            if (pStgMedium->pstm) IStream_Release( pStgMedium->pstm );
            pStgMedium->pstm = NULL;
        }
        break;
    case TYMED_ISTORAGE:
        TRACE("TYMED_ISTORAGE\n");
        if (content)
        {
            pBuffer = WdtpInterfacePointer_UserUnmarshal(pFlags, pBuffer, (IUnknown**)&pStgMedium->pstg, &IID_IStorage);
        }
        else
        {
            if (pStgMedium->pstg) IStorage_Release( pStgMedium->pstg );
            pStgMedium->pstg = NULL;
        }
        break;
    case TYMED_GDI:
        TRACE("TYMED_GDI\n");
        if (content)
            pBuffer = HBITMAP_UserUnmarshal(pFlags, pBuffer, &pStgMedium->hBitmap);
        else
            pStgMedium->hBitmap = NULL;
        break;
    case TYMED_MFPICT:
        TRACE("TYMED_MFPICT\n");
        if (content)
            pBuffer = HMETAFILEPICT_UserUnmarshal(pFlags, pBuffer, &pStgMedium->hMetaFilePict);
        else
            pStgMedium->hMetaFilePict = NULL;
        break;
    case TYMED_ENHMF:
        TRACE("TYMED_ENHMF\n");
        if (content)
            pBuffer = HENHMETAFILE_UserUnmarshal(pFlags, pBuffer, &pStgMedium->hEnhMetaFile);
        else
            pStgMedium->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_UserMarshal()

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

Definition at line 917 of file usrmarshal.c.

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

WdtpInterfacePointer_UserSize()

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

Definition at line 882 of file usrmarshal.c.

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

WdtpInterfacePointer_UserUnmarshal()

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

Definition at line 974 of file usrmarshal.c.

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

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)