usrmarshal.c File Reference

#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 "typelib.h"
#include "ocidl.h"
#include "wine/debug.h"

Include dependency graph for usrmarshal.c:

Go to the source code of this file.

Classes
struct	bstr_wire_t
struct	variant_wire_t

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	CLS_FUNCDESC   'f'
#define	CLS_LIBATTR   'l'
#define	CLS_TYPEATTR   't'
#define	CLS_VARDESC   'v'
#define	FADF_AUTOSETFLAGS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
ULONG __RPC_USER	WdtpInterfacePointer_UserSize (ULONG *, ULONG, ULONG, IUnknown *, REFIID)
unsigned char *__RPC_USER	WdtpInterfacePointer_UserMarshal (ULONG *, ULONG, unsigned char *, IUnknown *, REFIID)
unsigned char *__RPC_USER	WdtpInterfacePointer_UserUnmarshal (ULONG *, unsigned char *, IUnknown **, REFIID)
static void	dump_user_flags (const ULONG *pFlags)
ULONG WINAPI	CLEANLOCALSTORAGE_UserSize (ULONG *pFlags, ULONG Start, CLEANLOCALSTORAGE *pstg)
unsigned char *WINAPI	CLEANLOCALSTORAGE_UserMarshal (ULONG *pFlags, unsigned char *Buffer, CLEANLOCALSTORAGE *pstg)
unsigned char *WINAPI	CLEANLOCALSTORAGE_UserUnmarshal (ULONG *pFlags, unsigned char *Buffer, CLEANLOCALSTORAGE *pstr)
void WINAPI	CLEANLOCALSTORAGE_UserFree (ULONG *pFlags, CLEANLOCALSTORAGE *pstr)
ULONG WINAPI	BSTR_UserSize (ULONG *pFlags, ULONG Start, BSTR *pstr)
unsigned char *WINAPI	BSTR_UserMarshal (ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
unsigned char *WINAPI	BSTR_UserUnmarshal (ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
void WINAPI	BSTR_UserFree (ULONG *pFlags, BSTR *pstr)
unsigned int	get_type_size (ULONG *pFlags, VARTYPE vt)
static unsigned int	get_type_alignment (ULONG *pFlags, VARTYPE vt)
static unsigned	interface_variant_size (ULONG *pFlags, REFIID riid, IUnknown *punk)
static ULONG	wire_extra_user_size (ULONG *pFlags, ULONG Start, VARIANT *pvar)
static unsigned char *	interface_variant_marshal (ULONG *pFlags, unsigned char *Buffer, REFIID riid, IUnknown *punk)
static unsigned char *	interface_variant_unmarshal (ULONG *pFlags, unsigned char *Buffer, REFIID riid, IUnknown **ppunk)
ULONG WINAPI	VARIANT_UserSize (ULONG *pFlags, ULONG Start, VARIANT *pvar)
unsigned char *WINAPI	VARIANT_UserMarshal (ULONG *pFlags, unsigned char *Buffer, VARIANT *pvar)
unsigned char *WINAPI	VARIANT_UserUnmarshal (ULONG *pFlags, unsigned char *Buffer, VARIANT *pvar)
void WINAPI	VARIANT_UserFree (ULONG *pFlags, VARIANT *pvar)
static ULONG	SAFEARRAY_GetCellCount (const SAFEARRAY *psa)
static SF_TYPE	SAFEARRAY_GetUnionType (SAFEARRAY *psa)
static DWORD	elem_wire_size (LPSAFEARRAY lpsa, SF_TYPE sftype)
static DWORD	elem_mem_size (wireSAFEARRAY wiresa, SF_TYPE sftype)
ULONG WINAPI	LPSAFEARRAY_UserSize (ULONG *pFlags, ULONG StartingSize, LPSAFEARRAY *ppsa)
unsigned char *WINAPI	LPSAFEARRAY_UserMarshal (ULONG *pFlags, unsigned char *Buffer, LPSAFEARRAY *ppsa)
unsigned char *WINAPI	LPSAFEARRAY_UserUnmarshal (ULONG *pFlags, unsigned char *Buffer, LPSAFEARRAY *ppsa)
void WINAPI	LPSAFEARRAY_UserFree (ULONG *pFlags, LPSAFEARRAY *ppsa)
ULONG WINAPI	HFONT_UserSize (ULONG *pFlags, ULONG Start, HFONT *phfont)
unsigned char *WINAPI	HFONT_UserMarshal (ULONG *pFlags, unsigned char *Buffer, HFONT *phfont)
unsigned char *WINAPI	HFONT_UserUnmarshal (ULONG *pFlags, unsigned char *Buffer, HFONT *phfont)
void WINAPI	HFONT_UserFree (ULONG *pFlags, HFONT *phfont)
HRESULT CALLBACK	IDispatch_Invoke_Proxy (IDispatch *This, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
HRESULT __RPC_STUB	IDispatch_Invoke_Stub (IDispatch *This, DISPID dispIdMember, REFIID riid, LCID lcid, DWORD dwFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *pArgErr, UINT cVarRef, UINT *rgVarRefIdx, VARIANTARG *rgVarRef)
HRESULT CALLBACK	IEnumVARIANT_Next_Proxy (IEnumVARIANT *This, ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
HRESULT __RPC_STUB	IEnumVARIANT_Next_Stub (IEnumVARIANT *This, ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
static void	free_embedded_typedesc (TYPEDESC *tdesc)
static void	free_embedded_arraydesc (ARRAYDESC *adesc)
static void	free_embedded_elemdesc (ELEMDESC *edesc)
HRESULT CALLBACK	ITypeComp_Bind_Proxy (ITypeComp *This, LPOLESTR name, ULONG lHashVal, WORD flags, ITypeInfo **ti, DESCKIND *desckind, BINDPTR *bindptr)
HRESULT __RPC_STUB	ITypeComp_Bind_Stub (ITypeComp *This, LPOLESTR name, ULONG lHashVal, WORD flags, ITypeInfo **ti, DESCKIND *desckind, FUNCDESC **funcdesc, VARDESC **vardesc, ITypeComp **typecomp, CLEANLOCALSTORAGE *stg)
HRESULT CALLBACK	ITypeComp_BindType_Proxy (ITypeComp *This, LPOLESTR name, ULONG lHashVal, ITypeInfo **ti, ITypeComp **typecomp)
HRESULT __RPC_STUB	ITypeComp_BindType_Stub (ITypeComp *This, LPOLESTR name, ULONG lHashVal, ITypeInfo **ti)
HRESULT CALLBACK	ITypeInfo_GetTypeAttr_Proxy (ITypeInfo *This, TYPEATTR **ppTypeAttr)
HRESULT __RPC_STUB	ITypeInfo_GetTypeAttr_Stub (ITypeInfo *This, LPTYPEATTR *ppTypeAttr, CLEANLOCALSTORAGE *pDummy)
HRESULT CALLBACK	ITypeInfo_GetFuncDesc_Proxy (ITypeInfo *This, UINT index, FUNCDESC **ppFuncDesc)
HRESULT __RPC_STUB	ITypeInfo_GetFuncDesc_Stub (ITypeInfo *This, UINT index, LPFUNCDESC *ppFuncDesc, CLEANLOCALSTORAGE *pDummy)
HRESULT CALLBACK	ITypeInfo_GetVarDesc_Proxy (ITypeInfo *This, UINT index, VARDESC **ppVarDesc)
HRESULT __RPC_STUB	ITypeInfo_GetVarDesc_Stub (ITypeInfo *This, UINT index, LPVARDESC *ppVarDesc, CLEANLOCALSTORAGE *pDummy)
HRESULT CALLBACK	ITypeInfo_GetNames_Proxy (ITypeInfo *This, MEMBERID memid, BSTR *rgBstrNames, UINT cMaxNames, UINT *pcNames)
HRESULT __RPC_STUB	ITypeInfo_GetNames_Stub (ITypeInfo *This, MEMBERID memid, BSTR *rgBstrNames, UINT cMaxNames, UINT *pcNames)
HRESULT CALLBACK	ITypeInfo_GetIDsOfNames_Proxy (ITypeInfo *This, LPOLESTR *rgszNames, UINT cNames, MEMBERID *pMemId)
HRESULT __RPC_STUB	ITypeInfo_GetIDsOfNames_Stub (ITypeInfo *This)
HRESULT CALLBACK	ITypeInfo_Invoke_Proxy (ITypeInfo *This, PVOID pvInstance, MEMBERID memid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
HRESULT __RPC_STUB	ITypeInfo_Invoke_Stub (ITypeInfo *This)
HRESULT CALLBACK	ITypeInfo_GetDocumentation_Proxy (ITypeInfo *This, MEMBERID memid, BSTR *name, BSTR *doc_string, DWORD *help_context, BSTR *help_file)
HRESULT __RPC_STUB	ITypeInfo_GetDocumentation_Stub (ITypeInfo *This, MEMBERID memid, DWORD flags, BSTR *name, BSTR *doc_string, DWORD *help_context, BSTR *help_file)
HRESULT CALLBACK	ITypeInfo_GetDllEntry_Proxy (ITypeInfo *This, MEMBERID memid, INVOKEKIND invkind, BSTR *dll_name, BSTR *name, WORD *ordinal)
HRESULT __RPC_STUB	ITypeInfo_GetDllEntry_Stub (ITypeInfo *This, MEMBERID memid, INVOKEKIND invkind, DWORD flags, BSTR *dll_name, BSTR *name, WORD *ordinal)
HRESULT CALLBACK	ITypeInfo_AddressOfMember_Proxy (ITypeInfo *This, MEMBERID memid, INVOKEKIND invKind, PVOID *ppv)
HRESULT __RPC_STUB	ITypeInfo_AddressOfMember_Stub (ITypeInfo *This)
HRESULT CALLBACK	ITypeInfo_CreateInstance_Proxy (ITypeInfo *This, IUnknown *pUnkOuter, REFIID riid, PVOID *ppvObj)
HRESULT __RPC_STUB	ITypeInfo_CreateInstance_Stub (ITypeInfo *This, REFIID riid, IUnknown **ppvObj)
HRESULT CALLBACK	ITypeInfo_GetContainingTypeLib_Proxy (ITypeInfo *This, ITypeLib **ppTLib, UINT *pIndex)
HRESULT __RPC_STUB	ITypeInfo_GetContainingTypeLib_Stub (ITypeInfo *This, ITypeLib **ppTLib, UINT *pIndex)
void CALLBACK	ITypeInfo_ReleaseTypeAttr_Proxy (ITypeInfo *This, TYPEATTR *pTypeAttr)
HRESULT __RPC_STUB	ITypeInfo_ReleaseTypeAttr_Stub (ITypeInfo *This)
void CALLBACK	ITypeInfo_ReleaseFuncDesc_Proxy (ITypeInfo *This, FUNCDESC *pFuncDesc)
HRESULT __RPC_STUB	ITypeInfo_ReleaseFuncDesc_Stub (ITypeInfo *This)
void CALLBACK	ITypeInfo_ReleaseVarDesc_Proxy (ITypeInfo *This, VARDESC *pVarDesc)
HRESULT __RPC_STUB	ITypeInfo_ReleaseVarDesc_Stub (ITypeInfo *This)
HRESULT CALLBACK	ITypeInfo2_GetDocumentation2_Proxy (ITypeInfo2 *This, MEMBERID memid, LCID lcid, BSTR *help_string, DWORD *help_context, BSTR *help_dll)
HRESULT __RPC_STUB	ITypeInfo2_GetDocumentation2_Stub (ITypeInfo2 *This, MEMBERID memid, LCID lcid, DWORD flags, BSTR *help_string, DWORD *help_context, BSTR *help_dll)
UINT CALLBACK	ITypeLib_GetTypeInfoCount_Proxy (ITypeLib *This)
HRESULT __RPC_STUB	ITypeLib_GetTypeInfoCount_Stub (ITypeLib *This, UINT *pcTInfo)
HRESULT CALLBACK	ITypeLib_GetLibAttr_Proxy (ITypeLib *This, TLIBATTR **ppTLibAttr)
HRESULT __RPC_STUB	ITypeLib_GetLibAttr_Stub (ITypeLib *This, LPTLIBATTR *ppTLibAttr, CLEANLOCALSTORAGE *pDummy)
HRESULT CALLBACK	ITypeLib_GetDocumentation_Proxy (ITypeLib *This, INT index, BSTR *name, BSTR *doc_string, DWORD *help_context, BSTR *help_file)
HRESULT __RPC_STUB	ITypeLib_GetDocumentation_Stub (ITypeLib *This, INT index, DWORD flags, BSTR *name, BSTR *doc_string, DWORD *help_context, BSTR *help_file)
HRESULT CALLBACK	ITypeLib_IsName_Proxy (ITypeLib *This, LPOLESTR szNameBuf, ULONG lHashVal, BOOL *pfName)
HRESULT __RPC_STUB	ITypeLib_IsName_Stub (ITypeLib *This, LPOLESTR szNameBuf, ULONG lHashVal, BOOL *pfName, BSTR *pBstrLibName)
HRESULT CALLBACK	ITypeLib_FindName_Proxy (ITypeLib *This, LPOLESTR szNameBuf, ULONG lHashVal, ITypeInfo **ppTInfo, MEMBERID *rgMemId, USHORT *pcFound)
HRESULT __RPC_STUB	ITypeLib_FindName_Stub (ITypeLib *This, LPOLESTR szNameBuf, ULONG lHashVal, ITypeInfo **ppTInfo, MEMBERID *rgMemId, USHORT *pcFound, BSTR *pBstrLibName)
void CALLBACK	ITypeLib_ReleaseTLibAttr_Proxy (ITypeLib *This, TLIBATTR *pTLibAttr)
HRESULT __RPC_STUB	ITypeLib_ReleaseTLibAttr_Stub (ITypeLib *This)
HRESULT CALLBACK	ITypeLib2_GetLibStatistics_Proxy (ITypeLib2 *This, ULONG *pcUniqueNames, ULONG *pcchUniqueNames)
HRESULT __RPC_STUB	ITypeLib2_GetLibStatistics_Stub (ITypeLib2 *This, ULONG *pcUniqueNames, ULONG *pcchUniqueNames)
HRESULT CALLBACK	ITypeLib2_GetDocumentation2_Proxy (ITypeLib2 *This, INT index, LCID lcid, BSTR *help_string, DWORD *help_context, BSTR *help_dll)
HRESULT __RPC_STUB	ITypeLib2_GetDocumentation2_Stub (ITypeLib2 *This, INT index, LCID lcid, DWORD flags, BSTR *help_string, DWORD *help_context, BSTR *help_dll)
HRESULT CALLBACK	IPropertyBag_Read_Proxy (IPropertyBag *This, LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog)
HRESULT __RPC_STUB	IPropertyBag_Read_Stub (IPropertyBag *This, LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog, DWORD varType, IUnknown *pUnkObj)
HRESULT CALLBACK	IClassFactory2_CreateInstanceLic_Proxy (IClassFactory2 *This, IUnknown *pUnkOuter, IUnknown *pUnkReserved, REFIID riid, BSTR bstrKey, PVOID *ppvObj)
HRESULT __RPC_STUB	IClassFactory2_CreateInstanceLic_Stub (IClassFactory2 *This, REFIID riid, BSTR bstrKey, IUnknown **ppvObj)
HRESULT CALLBACK	IEnumConnections_Next_Proxy (IEnumConnections *This, ULONG cConnections, LPCONNECTDATA rgcd, ULONG *pcFetched)
HRESULT __RPC_STUB	IEnumConnections_Next_Stub (IEnumConnections *This, ULONG cConnections, LPCONNECTDATA rgcd, ULONG *pcFetched)
HRESULT CALLBACK	IEnumConnectionPoints_Next_Proxy (IEnumConnectionPoints *This, ULONG cConnections, IConnectionPoint **ppCP, ULONG *pcFetched)
HRESULT __RPC_STUB	IEnumConnectionPoints_Next_Stub (IEnumConnectionPoints *This, ULONG cConnections, IConnectionPoint **ppCP, ULONG *pcFetched)
HRESULT CALLBACK	IPersistMemory_Load_Proxy (IPersistMemory *This, LPVOID pMem, ULONG cbSize)
HRESULT __RPC_STUB	IPersistMemory_Load_Stub (IPersistMemory *This, BYTE *pMem, ULONG cbSize)
HRESULT CALLBACK	IPersistMemory_Save_Proxy (IPersistMemory *This, LPVOID pMem, BOOL fClearDirty, ULONG cbSize)
HRESULT __RPC_STUB	IPersistMemory_Save_Stub (IPersistMemory *This, BYTE *pMem, BOOL fClearDirty, ULONG cbSize)
void CALLBACK	IAdviseSinkEx_OnViewStatusChange_Proxy (IAdviseSinkEx *This, DWORD dwViewStatus)
HRESULT __RPC_STUB	IAdviseSinkEx_OnViewStatusChange_Stub (IAdviseSinkEx *This, DWORD dwViewStatus)
HRESULT CALLBACK	IEnumOleUndoUnits_Next_Proxy (IEnumOleUndoUnits *This, ULONG cElt, IOleUndoUnit **rgElt, ULONG *pcEltFetched)
HRESULT __RPC_STUB	IEnumOleUndoUnits_Next_Stub (IEnumOleUndoUnits *This, ULONG cElt, IOleUndoUnit **rgElt, ULONG *pcEltFetched)
HRESULT CALLBACK	IQuickActivate_QuickActivate_Proxy (IQuickActivate *This, QACONTAINER *pQaContainer, QACONTROL *pQaControl)
HRESULT __RPC_STUB	IQuickActivate_QuickActivate_Stub (IQuickActivate *This, QACONTAINER *pQaContainer, QACONTROL *pQaControl)

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.

CLS_FUNCDESC

#define CLS_FUNCDESC   'f'

Definition at line 70 of file usrmarshal.c.

CLS_LIBATTR

#define CLS_LIBATTR   'l'

Definition at line 71 of file usrmarshal.c.

CLS_TYPEATTR

#define CLS_TYPEATTR   't'

Definition at line 72 of file usrmarshal.c.

CLS_VARDESC

#define CLS_VARDESC   'v'

Definition at line 73 of file usrmarshal.c.

COBJMACROS

#define COBJMACROS

Definition at line 25 of file usrmarshal.c.

FADF_AUTOSETFLAGS

#define FADF_AUTOSETFLAGS

Value:

                           (FADF_HAVEIID | FADF_RECORD | FADF_HAVEVARTYPE | \
                           FADF_BSTR | FADF_UNKNOWN | FADF_DISPATCH | \
                           FADF_VARIANT | FADF_CREATEVECTOR)

Definition at line 1120 of file usrmarshal.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 26 of file usrmarshal.c.

Function Documentation

BSTR_UserFree()

void WINAPI BSTR_UserFree	(	ULONG *	pFlags,
		BSTR *	pstr
	)

Definition at line 189 of file usrmarshal.c.

{
    TRACE("(%x,%p) => %p\n", *pFlags, pstr, *pstr);
    SysFreeString(*pstr);
    *pstr = NULL;
}

Referenced by test_marshal_BSTR(), and VARIANT_UserFree().

BSTR_UserMarshal()

unsigned char *WINAPI BSTR_UserMarshal	(	ULONG *	pFlags,
		unsigned char *	Buffer,
		BSTR *	pstr
	)

Definition at line 146 of file usrmarshal.c.

{
    bstr_wire_t *header;
    DWORD len = SysStringByteLen(*pstr);
 
    TRACE("(%x,%p,%p) => %p\n", *pFlags, Buffer, pstr, *pstr);
    if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
 
    ALIGN_POINTER(Buffer, 3);
    header = (bstr_wire_t*)Buffer;
    header->len = header->len2 = (len + 1) / 2;
    if (*pstr)
    {
        header->byte_len = len;
        memcpy(header + 1, *pstr, header->len * 2);
    }
    else
        header->byte_len = 0xffffffff; /* special case for a null bstr */
 
    return Buffer + sizeof(*header) + sizeof(OLECHAR) * header->len;
}

Referenced by LPSAFEARRAY_UserMarshal(), test_marshal_BSTR(), and VARIANT_UserMarshal().

BSTR_UserSize()

ULONG WINAPI BSTR_UserSize	(	ULONG *	pFlags,
		ULONG	Start,
		BSTR *	pstr
	)

Definition at line 136 of file usrmarshal.c.

{
    TRACE("(%x,%d,%p) => %p\n", *pFlags, Start, pstr, *pstr);
    if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
    ALIGN_LENGTH(Start, 3);
    Start += sizeof(bstr_wire_t) + ((SysStringByteLen(*pstr) + 1) & ~1);
    TRACE("returning %d\n", Start);
    return Start;
}

Referenced by LPSAFEARRAY_UserSize(), test_marshal_BSTR(), and wire_extra_user_size().

BSTR_UserUnmarshal()

unsigned char *WINAPI BSTR_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	Buffer,
		BSTR *	pstr
	)

Definition at line 168 of file usrmarshal.c.

{
    bstr_wire_t *header;
    TRACE("(%x,%p,%p) => %p\n", *pFlags, Buffer, pstr, *pstr);
 
    ALIGN_POINTER(Buffer, 3);
    header = (bstr_wire_t*)Buffer;
    if(header->len != header->len2)
        FIXME("len %08x != len2 %08x\n", header->len, header->len2);
 
    if (header->byte_len == 0xffffffff)
    {
        SysFreeString(*pstr);
        *pstr = NULL;
    }
    else SysReAllocStringLen( pstr, (OLECHAR *)(header + 1), header->len );
 
    if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
    return Buffer + sizeof(*header) + sizeof(OLECHAR) * header->len;
}

Referenced by LPSAFEARRAY_UserUnmarshal(), test_marshal_BSTR(), and VARIANT_UserUnmarshal().

CLEANLOCALSTORAGE_UserFree()

void WINAPI CLEANLOCALSTORAGE_UserFree	(	ULONG *	pFlags,
		CLEANLOCALSTORAGE *	pstr
	)

Definition at line 122 of file usrmarshal.c.

{
    /* Nothing to do */
}

CLEANLOCALSTORAGE_UserMarshal()

unsigned char *WINAPI CLEANLOCALSTORAGE_UserMarshal	(	ULONG *	pFlags,
		unsigned char *	Buffer,
		CLEANLOCALSTORAGE *	pstg
	)

Definition at line 81 of file usrmarshal.c.

{
    ALIGN_POINTER(Buffer, 3);
    *(DWORD*)Buffer = pstg->flags;
 
    if (!pstg->pInterface)
        return Buffer + sizeof(DWORD);
 
    switch(pstg->flags)
    {
    case CLS_LIBATTR:
        ITypeLib_ReleaseTLibAttr((ITypeLib*)pstg->pInterface, *(TLIBATTR**)pstg->pStorage);
        break;
    case CLS_TYPEATTR:
        ITypeInfo_ReleaseTypeAttr((ITypeInfo*)pstg->pInterface, *(TYPEATTR**)pstg->pStorage); 
        break;
    case CLS_FUNCDESC:
        ITypeInfo_ReleaseFuncDesc((ITypeInfo*)pstg->pInterface, *(FUNCDESC**)pstg->pStorage); 
        break;
    case CLS_VARDESC:
        ITypeInfo_ReleaseVarDesc((ITypeInfo*)pstg->pInterface, *(VARDESC**)pstg->pStorage);
        break;
 
    default:
        ERR("Unknown type %x\n", pstg->flags);
    }
 
    *(VOID**)pstg->pStorage = NULL;
    IUnknown_Release(pstg->pInterface);
    pstg->pInterface = NULL;
 
    return Buffer + sizeof(DWORD);
}

CLEANLOCALSTORAGE_UserSize()

ULONG WINAPI CLEANLOCALSTORAGE_UserSize	(	ULONG *	pFlags,
		ULONG	Start,
		CLEANLOCALSTORAGE *	pstg
	)

Definition at line 75 of file usrmarshal.c.

{
    ALIGN_LENGTH(Start, 3);
    return Start + sizeof(DWORD);
}

CLEANLOCALSTORAGE_UserUnmarshal()

unsigned char *WINAPI CLEANLOCALSTORAGE_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	Buffer,
		CLEANLOCALSTORAGE *	pstr
	)

Definition at line 115 of file usrmarshal.c.

{
    ALIGN_POINTER(Buffer, 3);
    pstr->flags = *(DWORD*)Buffer;
    return Buffer + sizeof(DWORD);
}

dump_user_flags()

static void dump_user_flags ( const ULONG *  pFlags )

static

Definition at line 52 of file usrmarshal.c.

{
    if (HIWORD(*pFlags) == NDR_LOCAL_DATA_REPRESENTATION)
        TRACE("MAKELONG(NDR_LOCAL_REPRESENTATION, ");
    else
        TRACE("MAKELONG(0x%04x, ", HIWORD(*pFlags));
    switch (LOWORD(*pFlags))
    {
        case MSHCTX_LOCAL: TRACE("MSHCTX_LOCAL)"); break;
        case MSHCTX_NOSHAREDMEM: TRACE("MSHCTX_NOSHAREDMEM)"); break;
        case MSHCTX_DIFFERENTMACHINE: TRACE("MSHCTX_DIFFERENTMACHINE)"); break;
        case MSHCTX_INPROC: TRACE("MSHCTX_INPROC)"); break;
        default: TRACE("%d)", LOWORD(*pFlags));
    }
}

Referenced by LPSAFEARRAY_UserFree(), LPSAFEARRAY_UserMarshal(), LPSAFEARRAY_UserSize(), and LPSAFEARRAY_UserUnmarshal().

elem_mem_size()

static DWORD elem_mem_size ( wireSAFEARRAY  wiresa, SF_TYPE  sftype  )

static

Definition at line 830 of file usrmarshal.c.

{
#ifdef __REACTOS__
    switch (sftype)
    {
    case SF_HAVEIID:
    case SF_UNKNOWN:
    case SF_DISPATCH:
        return sizeof(void *);
 
    case SF_BSTR:
#else
    if (sftype == SF_BSTR)
#endif
        return sizeof(BSTR);
#ifdef __REACTOS__
 
    case SF_VARIANT:
#else
    else if (sftype == SF_VARIANT)
#endif
        return sizeof(VARIANT);
#ifdef __REACTOS__
 
    default:
#else
    else
#endif
        return wiresa->cbElements;
#ifdef __REACTOS__
    }
#endif
}

Referenced by LPSAFEARRAY_UserUnmarshal().

elem_wire_size()

static DWORD elem_wire_size ( LPSAFEARRAY  lpsa, SF_TYPE  sftype  )

static

Definition at line 798 of file usrmarshal.c.

{
#ifdef __REACTOS__
    switch (sftype)
    {
    case SF_BSTR:
    case SF_HAVEIID:
    case SF_UNKNOWN:
    case SF_DISPATCH:
#else
    if (sftype == SF_BSTR)
#endif
        return sizeof(DWORD);
#ifdef __REACTOS__
 
    case SF_VARIANT:
#else
    else if (sftype == SF_VARIANT)
#endif
        return sizeof(variant_wire_t) - sizeof(DWORD);
#ifdef __REACTOS__
 
    default:
#else
    else
#endif
        return lpsa->cbElements;
#ifdef __REACTOS__
    }
#endif
}

Referenced by check_safearray(), and LPSAFEARRAY_UserMarshal().

free_embedded_arraydesc()

static void free_embedded_arraydesc ( ARRAYDESC *  adesc )

static

Definition at line 1549 of file usrmarshal.c.

{
    switch(adesc->tdescElem.vt)
    {
    case VT_PTR:
    case VT_SAFEARRAY:
        free_embedded_typedesc(adesc->tdescElem.u.lptdesc);
        CoTaskMemFree(adesc->tdescElem.u.lptdesc);
        break;
    case VT_CARRAY:
        free_embedded_arraydesc(adesc->tdescElem.u.lpadesc);
        CoTaskMemFree(adesc->tdescElem.u.lpadesc);
        break;
    }
}

Referenced by free_embedded_arraydesc(), and free_embedded_typedesc().

free_embedded_elemdesc()

static void free_embedded_elemdesc ( ELEMDESC *  edesc )

static

Definition at line 1581 of file usrmarshal.c.

{
    free_embedded_typedesc(&edesc->tdesc);
    if(edesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
        CoTaskMemFree(edesc->u.paramdesc.pparamdescex);
}

Referenced by ITypeInfo_ReleaseFuncDesc_Proxy(), and ITypeInfo_ReleaseVarDesc_Proxy().

free_embedded_typedesc()

static void free_embedded_typedesc ( TYPEDESC *  tdesc )

static

Definition at line 1565 of file usrmarshal.c.

{
    switch(tdesc->vt)
    {
    case VT_PTR:
    case VT_SAFEARRAY:
        free_embedded_typedesc(tdesc->u.lptdesc);
        CoTaskMemFree(tdesc->u.lptdesc);
        break;
    case VT_CARRAY:
        free_embedded_arraydesc(tdesc->u.lpadesc);
        CoTaskMemFree(tdesc->u.lpadesc);
        break;
    }
}

Referenced by free_embedded_arraydesc(), free_embedded_elemdesc(), free_embedded_typedesc(), and ITypeInfo_ReleaseTypeAttr_Proxy().

get_type_alignment()

static unsigned int get_type_alignment ( ULONG *  pFlags, VARTYPE  vt  )

static

Definition at line 261 of file usrmarshal.c.

{
    unsigned int size = get_type_size(pFlags, vt);
    if(vt & VT_BYREF) return 3;
    if(size == 0) return 0;
    if(size <= 4) return size - 1;
    return 7;
}

Referenced by VARIANT_UserMarshal(), VARIANT_UserSize(), and VARIANT_UserUnmarshal().

get_type_size()

unsigned int get_type_size	(	ULONG *	pFlags,
		VARTYPE	vt
	)

Definition at line 209 of file usrmarshal.c.

{
    if (vt & VT_ARRAY) return 4;
 
    switch (vt & ~VT_BYREF) {
    case VT_EMPTY:
    case VT_NULL:
        return 0;
    case VT_I1:
    case VT_UI1:
        return sizeof(CHAR);
    case VT_I2:
    case VT_UI2:
        return sizeof(SHORT);
    case VT_I4:
    case VT_UI4:
    case VT_HRESULT:
        return sizeof(LONG);
    case VT_INT:
    case VT_UINT:
        return sizeof(INT);
    case VT_I8:
    case VT_UI8:
        return sizeof(LONGLONG);
    case VT_R4:
        return sizeof(FLOAT);
    case VT_R8:
        return sizeof(DOUBLE);
    case VT_BOOL:
        return sizeof(VARIANT_BOOL);
    case VT_ERROR:
        return sizeof(SCODE);
    case VT_DATE:
        return sizeof(DATE);
    case VT_CY:
        return sizeof(CY);
    case VT_DECIMAL:
        return sizeof(DECIMAL);
    case VT_BSTR:
        return sizeof(ULONG);
    case VT_VARIANT:
        return sizeof(VARIANT);
    case VT_UNKNOWN:
    case VT_DISPATCH:
    case VT_RECORD:
        return 0;
    default:
        FIXME("unhandled VT %d\n", vt);
        return 0;
    }
}

Referenced by create_signature_columns_and_data(), get_type_alignment(), IRecordInfoImpl_RecordCopy(), to_array(), VARIANT_UserMarshal(), VARIANT_UserSize(), and VARIANT_UserUnmarshal().

HFONT_UserFree()

void WINAPI HFONT_UserFree	(	ULONG *	pFlags,
		HFONT *	phfont
	)

Definition at line 1335 of file usrmarshal.c.

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

HFONT_UserMarshal()

unsigned char *WINAPI HFONT_UserMarshal	(	ULONG *	pFlags,
		unsigned char *	Buffer,
		HFONT *	phfont
	)

Definition at line 1323 of file usrmarshal.c.

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

HFONT_UserSize()

ULONG WINAPI HFONT_UserSize	(	ULONG *	pFlags,
		ULONG	Start,
		HFONT *	phfont
	)

Definition at line 1317 of file usrmarshal.c.

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

HFONT_UserUnmarshal()

unsigned char *WINAPI HFONT_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	Buffer,
		HFONT *	phfont
	)

Definition at line 1329 of file usrmarshal.c.

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

IAdviseSinkEx_OnViewStatusChange_Proxy()

void CALLBACK IAdviseSinkEx_OnViewStatusChange_Proxy	(	IAdviseSinkEx *	This,
		DWORD	dwViewStatus
	)

Definition at line 2626 of file usrmarshal.c.

{
    TRACE("(%p, 0x%08x)\n", This, dwViewStatus);
    IAdviseSinkEx_RemoteOnViewStatusChange_Proxy(This, dwViewStatus);
}

IAdviseSinkEx_OnViewStatusChange_Stub()

HRESULT __RPC_STUB IAdviseSinkEx_OnViewStatusChange_Stub	(	IAdviseSinkEx *	This,
		DWORD	dwViewStatus
	)

Definition at line 2634 of file usrmarshal.c.

{
    TRACE("(%p, 0x%08x)\n", This, dwViewStatus);
    IAdviseSinkEx_OnViewStatusChange(This, dwViewStatus);
    return S_OK;
}

IClassFactory2_CreateInstanceLic_Proxy()

HRESULT CALLBACK IClassFactory2_CreateInstanceLic_Proxy	(	IClassFactory2 *	This,
		IUnknown *	pUnkOuter,
		IUnknown *	pUnkReserved,
		REFIID	riid,
		BSTR	bstrKey,
		PVOID *	ppvObj
	)

Definition at line 2481 of file usrmarshal.c.

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

IClassFactory2_CreateInstanceLic_Stub()

HRESULT __RPC_STUB IClassFactory2_CreateInstanceLic_Stub	(	IClassFactory2 *	This,
		REFIID	riid,
		BSTR	bstrKey,
		IUnknown **	ppvObj
	)

Definition at line 2502 of file usrmarshal.c.

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

IDispatch_Invoke_Proxy()

HRESULT CALLBACK IDispatch_Invoke_Proxy	(	IDispatch *	This,
		DISPID	dispIdMember,
		REFIID	riid,
		LCID	lcid,
		WORD	wFlags,
		DISPPARAMS *	pDispParams,
		VARIANT *	pVarResult,
		EXCEPINFO *	pExcepInfo,
		UINT *	puArgErr
	)

Definition at line 1346 of file usrmarshal.c.

{
  HRESULT hr;
  VARIANT VarResult;
  UINT* rgVarRefIdx = NULL;
  VARIANTARG* rgVarRef = NULL;
  UINT u, cVarRef;
  UINT uArgErr;
  EXCEPINFO ExcepInfo;
 
  TRACE("(%p)->(%d,%s,%x,%x,%p,%p,%p,%p)\n", This,
        dispIdMember, debugstr_guid(riid),
        lcid, wFlags, pDispParams, pVarResult,
        pExcepInfo, puArgErr);
 
  /* [out] args can't be null, use dummy vars if needed */
  if (!pVarResult) pVarResult = &VarResult;
  if (!puArgErr) puArgErr = &uArgErr;
  if (!pExcepInfo) pExcepInfo = &ExcepInfo;
 
  /* count by-ref args */
  for (cVarRef=0,u=0; u<pDispParams->cArgs; u++) {
    VARIANTARG* arg = &pDispParams->rgvarg[u];
    if (V_ISBYREF(arg)) {
      cVarRef++;
    }
  }
  if (cVarRef) {
    rgVarRefIdx = CoTaskMemAlloc(sizeof(UINT)*cVarRef);
    rgVarRef = CoTaskMemAlloc(sizeof(VARIANTARG)*cVarRef);
    /* make list of by-ref args */
    for (cVarRef=0,u=0; u<pDispParams->cArgs; u++) {
      VARIANTARG* arg = &pDispParams->rgvarg[u];
      if (V_ISBYREF(arg)) {
    rgVarRefIdx[cVarRef] = u;
    VariantInit(&rgVarRef[cVarRef]);
    VariantCopy(&rgVarRef[cVarRef], arg);
    VariantClear(arg);
    cVarRef++;
      }
    }
  } else {
    /* [out] args still can't be null,
     * but we can point these anywhere in this case,
     * since they won't be written to when cVarRef is 0 */
    rgVarRefIdx = puArgErr;
    rgVarRef = pVarResult;
  }
  TRACE("passed by ref: %d args\n", cVarRef);
  hr = IDispatch_RemoteInvoke_Proxy(This,
                    dispIdMember,
                    riid,
                    lcid,
                    wFlags,
                    pDispParams,
                    pVarResult,
                    pExcepInfo,
                    puArgErr,
                    cVarRef,
                    rgVarRefIdx,
                    rgVarRef);
  if (cVarRef) {
    for (u=0; u<cVarRef; u++) {
      unsigned i = rgVarRefIdx[u];
      VariantCopy(&pDispParams->rgvarg[i],
          &rgVarRef[u]);
      VariantClear(&rgVarRef[u]);
    }
    CoTaskMemFree(rgVarRef);
    CoTaskMemFree(rgVarRefIdx);
  }
 
  if(pExcepInfo == &ExcepInfo)
  {
    SysFreeString(pExcepInfo->bstrSource);
    SysFreeString(pExcepInfo->bstrDescription);
    SysFreeString(pExcepInfo->bstrHelpFile);
  }
  return hr;
}

IDispatch_Invoke_Stub()

HRESULT __RPC_STUB IDispatch_Invoke_Stub	(	IDispatch *	This,
		DISPID	dispIdMember,
		REFIID	riid,
		LCID	lcid,
		DWORD	dwFlags,
		DISPPARAMS *	pDispParams,
		VARIANT *	pVarResult,
		EXCEPINFO *	pExcepInfo,
		UINT *	pArgErr,
		UINT	cVarRef,
		UINT *	rgVarRefIdx,
		VARIANTARG *	rgVarRef
	)

Definition at line 1436 of file usrmarshal.c.

{
  HRESULT hr = S_OK;
  VARIANTARG *rgvarg, *arg;
  UINT u;
 
  /* initialize out parameters, so that they can be marshalled
   * in case the real Invoke doesn't initialize them */
  VariantInit(pVarResult);
  memset(pExcepInfo, 0, sizeof(*pExcepInfo));
  *pArgErr = 0;
 
  /* let the real Invoke operate on a copy of the in parameters,
   * so we don't risk losing pointers to allocated memory */
  rgvarg = pDispParams->rgvarg;
  arg = CoTaskMemAlloc(sizeof(VARIANTARG)*pDispParams->cArgs);
  if (!arg) return E_OUTOFMEMORY;
 
  /* init all args so we can call VariantClear on all the args if the copy
   * below fails */
  for (u = 0; u < pDispParams->cArgs; u++)
    VariantInit(&arg[u]);
 
  for (u = 0; u < pDispParams->cArgs; u++) {
    hr = VariantCopy(&arg[u], &rgvarg[u]);
    if (FAILED(hr))
        break;
  }
 
  if (SUCCEEDED(hr)) {
    /* copy ref args to arg array */
    for (u=0; u<cVarRef; u++) {
      unsigned i = rgVarRefIdx[u];
      VariantCopy(&arg[i], &rgVarRef[u]);
    }
 
    pDispParams->rgvarg = arg;
 
    hr = IDispatch_Invoke(This,
              dispIdMember,
              riid,
              lcid,
              dwFlags,
              pDispParams,
              pVarResult,
              pExcepInfo,
              pArgErr);
 
    /* copy ref args from arg array */
    for (u=0; u<cVarRef; u++) {
      unsigned i = rgVarRefIdx[u];
      VariantCopy(&rgVarRef[u], &arg[i]);
    }
  }
 
  /* clear the duplicate argument list */
  for (u=0; u<pDispParams->cArgs; u++)
    VariantClear(&arg[u]);
 
  pDispParams->rgvarg = rgvarg;
  CoTaskMemFree(arg);
 
  return hr;
}

IEnumConnectionPoints_Next_Proxy()

HRESULT CALLBACK IEnumConnectionPoints_Next_Proxy	(	IEnumConnectionPoints *	This,
		ULONG	cConnections,
		IConnectionPoint **	ppCP,
		ULONG *	pcFetched
	)

Definition at line 2546 of file usrmarshal.c.

{
    ULONG fetched;
 
    TRACE("(%u, %p %p)\n", cConnections, ppCP, pcFetched);
 
    if (!pcFetched)
        pcFetched = &fetched;
 
    return IEnumConnectionPoints_RemoteNext_Proxy(This, cConnections, ppCP, pcFetched);
}

IEnumConnectionPoints_Next_Stub()

HRESULT __RPC_STUB IEnumConnectionPoints_Next_Stub	(	IEnumConnectionPoints *	This,
		ULONG	cConnections,
		IConnectionPoint **	ppCP,
		ULONG *	pcFetched
	)

Definition at line 2562 of file usrmarshal.c.

{
    HRESULT hr;
 
    TRACE("(%u, %p, %p)\n", cConnections, ppCP, pcFetched);
 
    *pcFetched = 0;
    hr = IEnumConnectionPoints_Next(This, cConnections, ppCP, pcFetched);
    if (hr == S_OK)
        *pcFetched = cConnections;
 
    return hr;
}

IEnumConnections_Next_Proxy()

HRESULT CALLBACK IEnumConnections_Next_Proxy	(	IEnumConnections *	This,
		ULONG	cConnections,
		LPCONNECTDATA	rgcd,
		ULONG *	pcFetched
	)

Definition at line 2512 of file usrmarshal.c.

{
    ULONG fetched;
 
    TRACE("(%u, %p %p)\n", cConnections, rgcd, pcFetched);
 
    if (!pcFetched)
        pcFetched = &fetched;
 
    return IEnumConnections_RemoteNext_Proxy(This, cConnections, rgcd, pcFetched);
}

IEnumConnections_Next_Stub()

HRESULT __RPC_STUB IEnumConnections_Next_Stub	(	IEnumConnections *	This,
		ULONG	cConnections,
		LPCONNECTDATA	rgcd,
		ULONG *	pcFetched
	)

Definition at line 2528 of file usrmarshal.c.

{
    HRESULT hr;
 
    TRACE("(%u, %p, %p)\n", cConnections, rgcd, pcFetched);
 
    *pcFetched = 0;
    hr = IEnumConnections_Next(This, cConnections, rgcd, pcFetched);
    if (hr == S_OK)
        *pcFetched = cConnections;
 
    return hr;
}

IEnumOleUndoUnits_Next_Proxy()

HRESULT CALLBACK IEnumOleUndoUnits_Next_Proxy	(	IEnumOleUndoUnits *	This,
		ULONG	cElt,
		IOleUndoUnit **	rgElt,
		ULONG *	pcEltFetched
	)

Definition at line 2643 of file usrmarshal.c.

{
    ULONG fetched;
 
    TRACE("(%u, %p %p)\n", cElt, rgElt, pcEltFetched);
 
    if (!pcEltFetched)
        pcEltFetched = &fetched;
 
    return IEnumOleUndoUnits_RemoteNext_Proxy(This, cElt, rgElt, pcEltFetched);
}

IEnumOleUndoUnits_Next_Stub()

HRESULT __RPC_STUB IEnumOleUndoUnits_Next_Stub	(	IEnumOleUndoUnits *	This,
		ULONG	cElt,
		IOleUndoUnit **	rgElt,
		ULONG *	pcEltFetched
	)

Definition at line 2659 of file usrmarshal.c.

{
    HRESULT hr;
 
    TRACE("(%u, %p, %p)\n", cElt, rgElt, pcEltFetched);
 
    *pcEltFetched = 0;
    hr = IEnumOleUndoUnits_Next(This, cElt, rgElt, pcEltFetched);
    if (hr == S_OK)
        *pcEltFetched = cElt;
 
    return hr;
}

IEnumVARIANT_Next_Proxy()

HRESULT CALLBACK IEnumVARIANT_Next_Proxy	(	IEnumVARIANT *	This,
		ULONG	celt,
		VARIANT *	rgVar,
		ULONG *	pCeltFetched
	)

Definition at line 1515 of file usrmarshal.c.

{
  ULONG fetched;
  if (!pCeltFetched)
    pCeltFetched = &fetched;
  return IEnumVARIANT_RemoteNext_Proxy(This,
                       celt,
                       rgVar,
                       pCeltFetched);
}

IEnumVARIANT_Next_Stub()

HRESULT __RPC_STUB IEnumVARIANT_Next_Stub	(	IEnumVARIANT *	This,
		ULONG	celt,
		VARIANT *	rgVar,
		ULONG *	pCeltFetched
	)

Definition at line 1530 of file usrmarshal.c.

{
  HRESULT hr;
  *pCeltFetched = 0;
  hr = IEnumVARIANT_Next(This,
             celt,
             rgVar,
             pCeltFetched);
  if (hr == S_OK) *pCeltFetched = celt;
  return hr;
}

interface_variant_marshal()

static unsigned char * interface_variant_marshal ( ULONG *  pFlags, unsigned char *  Buffer, REFIID  riid, IUnknown *  punk  )

static

Definition at line 354 of file usrmarshal.c.

{
  TRACE("pFlags=%d, Buffer=%p, pUnk=%p\n", *pFlags, Buffer, punk);
 
  /* first DWORD is used to store pointer itself, truncated on win64 */
  if(!punk)
  {
      memset(Buffer, 0, sizeof(ULONG));
      return Buffer + sizeof(ULONG);
  }
  else
  {
      *(DWORD*)Buffer = (DWORD_PTR)punk;
      Buffer += sizeof(DWORD);
  }
 
  return WdtpInterfacePointer_UserMarshal(pFlags, LOWORD(*pFlags), Buffer, punk, riid);
}

Referenced by VARIANT_UserMarshal().

interface_variant_size()

static unsigned interface_variant_size ( ULONG *  pFlags, REFIID  riid, IUnknown *  punk  )

static

Definition at line 274 of file usrmarshal.c.

{
    ULONG size = 0;
 
    if (punk)
    {
        size = WdtpInterfacePointer_UserSize(pFlags, LOWORD(*pFlags), 0, punk, riid);
        if (!size)
        {
            ERR("interface variant buffer size calculation failed\n");
            return 0;
        }
    }
    size += sizeof(ULONG);
    TRACE("wire-size extra of interface variant is %d\n", size);
#ifdef __REACTOS__
    return Start + size;
#else
    return size;
#endif
}

Referenced by wire_extra_user_size().

interface_variant_unmarshal()

static unsigned char * interface_variant_unmarshal ( ULONG *  pFlags, unsigned char *  Buffer, REFIID  riid, IUnknown **  ppunk  )

static

Definition at line 379 of file usrmarshal.c.

{
  DWORD ptr;
  
  TRACE("pFlags=%d, Buffer=%p, ppUnk=%p\n", *pFlags, Buffer, ppunk);
 
  /* skip pointer part itself */
  ptr = *(DWORD*)Buffer;
  Buffer += sizeof(DWORD);
 
  if(!ptr)
      return Buffer;
 
  return WdtpInterfacePointer_UserUnmarshal(pFlags, Buffer, ppunk, riid);
}

Referenced by VARIANT_UserUnmarshal().

IPersistMemory_Load_Proxy()

HRESULT CALLBACK IPersistMemory_Load_Proxy	(	IPersistMemory *	This,
		LPVOID	pMem,
		ULONG	cbSize
	)

Definition at line 2580 of file usrmarshal.c.

{
    TRACE("(%p, %u)\n", pMem, cbSize);
 
    if (!pMem)
        return E_POINTER;
 
    return IPersistMemory_RemoteLoad_Proxy(This, pMem, cbSize);
}

IPersistMemory_Load_Stub()

HRESULT __RPC_STUB IPersistMemory_Load_Stub	(	IPersistMemory *	This,
		BYTE *	pMem,
		ULONG	cbSize
	)

Definition at line 2593 of file usrmarshal.c.

{
    TRACE("(%p, %u)\n", pMem, cbSize);
    return IPersistMemory_Load(This, pMem, cbSize);
}

IPersistMemory_Save_Proxy()

HRESULT CALLBACK IPersistMemory_Save_Proxy	(	IPersistMemory *	This,
		LPVOID	pMem,
		BOOL	fClearDirty,
		ULONG	cbSize
	)

Definition at line 2602 of file usrmarshal.c.

{
    TRACE("(%p, %d, %u)\n", pMem, fClearDirty, cbSize);
 
    if (!pMem)
        return E_POINTER;
 
    return IPersistMemory_RemoteSave_Proxy(This, pMem, fClearDirty, cbSize);
}

IPersistMemory_Save_Stub()

HRESULT __RPC_STUB IPersistMemory_Save_Stub	(	IPersistMemory *	This,
		BYTE *	pMem,
		BOOL	fClearDirty,
		ULONG	cbSize
	)

Definition at line 2616 of file usrmarshal.c.

{
    TRACE("(%p, %d, %u)\n", pMem, fClearDirty, cbSize);
    return IPersistMemory_Save(This, pMem, fClearDirty, cbSize);
}

IPropertyBag_Read_Proxy()

HRESULT CALLBACK IPropertyBag_Read_Proxy	(	IPropertyBag *	This,
		LPCOLESTR	pszPropName,
		VARIANT *	pVar,
		IErrorLog *	pErrorLog
	)

Definition at line 2392 of file usrmarshal.c.

{
  IUnknown *pUnk = NULL;
  TRACE("(%p, %s, %p, %p)\n", This, debugstr_w(pszPropName), pVar, pErrorLog);
 
  if(!pVar)
    return E_POINTER;
 
  if(V_VT(pVar) & (VT_BYREF | VT_ARRAY | VT_VECTOR))
  {
    FIXME("Variant type %x is byref, array or vector. Not implemented.\n", V_VT(pVar));
    return E_NOTIMPL;
  }
 
  switch(V_VT(pVar))
  {
    case VT_DISPATCH:
      pUnk = (IUnknown*)V_DISPATCH(pVar);
      break;
    case VT_UNKNOWN:
      pUnk = V_UNKNOWN(pVar);
      break;
    case VT_SAFEARRAY:
      FIXME("Safearray support not yet implemented.\n");
      return E_NOTIMPL;
    default:
      FIXME("Unknown V_VT %d - support not yet implemented.\n", V_VT(pVar));
      return E_NOTIMPL;
  }
 
  return IPropertyBag_RemoteRead_Proxy(This, pszPropName, pVar, pErrorLog,
                                       V_VT(pVar), pUnk);
}

IPropertyBag_Read_Stub()

HRESULT __RPC_STUB IPropertyBag_Read_Stub	(	IPropertyBag *	This,
		LPCOLESTR	pszPropName,
		VARIANT *	pVar,
		IErrorLog *	pErrorLog,
		DWORD	varType,
		IUnknown *	pUnkObj
	)

Definition at line 2430 of file usrmarshal.c.

{
  static const WCHAR emptyWstr[] = {0};
  IDispatch *disp;
  HRESULT hr;
  TRACE("(%p, %s, %p, %p, %x, %p)\n", This, debugstr_w(pszPropName), pVar,
                                     pErrorLog, varType, pUnkObj);
 
  if(varType & (VT_BYREF | VT_ARRAY | VT_VECTOR))
  {
    FIXME("Variant type %x is byref, array or vector. Not implemented.\n", V_VT(pVar));
    return E_NOTIMPL;
  }
 
  V_VT(pVar) = varType;
  switch(varType)
  {
    case VT_DISPATCH:
      hr = IUnknown_QueryInterface(pUnkObj, &IID_IDispatch, (LPVOID*)&disp);
      if(FAILED(hr))
        return hr;
      IUnknown_Release(pUnkObj);
      V_DISPATCH(pVar) = disp;
      break;
    case VT_UNKNOWN:
      V_UNKNOWN(pVar) = pUnkObj;
      break;
    case VT_BSTR:
      V_BSTR(pVar) = SysAllocString(emptyWstr);
      break;
    case VT_SAFEARRAY:
      FIXME("Safearray support not yet implemented.\n");
      return E_NOTIMPL;
    default:
      break;
  }
  hr = IPropertyBag_Read(This, pszPropName, pVar, pErrorLog);
  if(FAILED(hr))
    VariantClear(pVar);
 
  return hr;
}

IQuickActivate_QuickActivate_Proxy()

HRESULT CALLBACK IQuickActivate_QuickActivate_Proxy	(	IQuickActivate *	This,
		QACONTAINER *	pQaContainer,
		QACONTROL *	pQaControl
	)

Definition at line 2677 of file usrmarshal.c.

{
    FIXME("not implemented\n");
    return E_NOTIMPL;
}

IQuickActivate_QuickActivate_Stub()

HRESULT __RPC_STUB IQuickActivate_QuickActivate_Stub	(	IQuickActivate *	This,
		QACONTAINER *	pQaContainer,
		QACONTROL *	pQaControl
	)

Definition at line 2686 of file usrmarshal.c.

{
    FIXME("not implemented\n");
    return E_NOTIMPL;
}

ITypeComp_Bind_Proxy()

HRESULT CALLBACK ITypeComp_Bind_Proxy	(	ITypeComp *	This,
		LPOLESTR	name,
		ULONG	lHashVal,
		WORD	flags,
		ITypeInfo **	ti,
		DESCKIND *	desckind,
		BINDPTR *	bindptr
	)

Definition at line 1590 of file usrmarshal.c.

{
    CLEANLOCALSTORAGE stg = { 0 };
    ITypeComp *typecomp;
    FUNCDESC *funcdesc;
    VARDESC *vardesc;
    HRESULT hr;
 
    TRACE("(%p, %s, %#x, %#x, %p, %p, %p)\n", This, debugstr_w(name), lHashVal, flags, ti,
        desckind, bindptr);
 
    *desckind = DESCKIND_NONE;
    memset(bindptr, 0, sizeof(*bindptr));
 
    hr = ITypeComp_RemoteBind_Proxy(This, name, lHashVal, flags, ti, desckind,
        &funcdesc, &vardesc, &typecomp, &stg);
 
    if (hr == S_OK)
    {
        switch (*desckind)
        {
        case DESCKIND_FUNCDESC:
            bindptr->lpfuncdesc = funcdesc;
            break;
        case DESCKIND_VARDESC:
        case DESCKIND_IMPLICITAPPOBJ:
            bindptr->lpvardesc = vardesc;
            break;
        case DESCKIND_TYPECOMP:
            bindptr->lptcomp = typecomp;
            break;
        default:
            ;
        }
    }
 
    return hr;
}

ITypeComp_Bind_Stub()

HRESULT __RPC_STUB ITypeComp_Bind_Stub	(	ITypeComp *	This,
		LPOLESTR	name,
		ULONG	lHashVal,
		WORD	flags,
		ITypeInfo **	ti,
		DESCKIND *	desckind,
		FUNCDESC **	funcdesc,
		VARDESC **	vardesc,
		ITypeComp **	typecomp,
		CLEANLOCALSTORAGE *	stg
	)

Definition at line 1636 of file usrmarshal.c.

{
    BINDPTR bindptr;
    HRESULT hr;
 
    TRACE("(%p, %s, %#x, %#x, %p, %p, %p, %p, %p, %p)\n", This, debugstr_w(name),
        lHashVal, flags, ti, desckind, funcdesc, vardesc, typecomp, stg);
 
    memset(stg, 0, sizeof(*stg));
    memset(&bindptr, 0, sizeof(bindptr));
 
    *funcdesc = NULL;
    *vardesc = NULL;
    *typecomp = NULL;
    *ti = NULL;
 
    hr = ITypeComp_Bind(This, name, lHashVal, flags, ti, desckind, &bindptr);
    if(hr != S_OK)
        return hr;
 
    switch (*desckind)
    {
    case DESCKIND_FUNCDESC:
        *funcdesc = bindptr.lpfuncdesc;
        stg->pInterface = (IUnknown*)*ti;
        stg->pStorage = funcdesc;
        stg->flags = CLS_FUNCDESC;
        break;
    case DESCKIND_VARDESC:
    case DESCKIND_IMPLICITAPPOBJ:
        *vardesc = bindptr.lpvardesc;
        stg->pInterface = (IUnknown*)*ti;
        stg->pStorage = vardesc;
        stg->flags = CLS_VARDESC;
        break;
    case DESCKIND_TYPECOMP:
        *typecomp = bindptr.lptcomp;
        break;
    default:
        ;
    }
 
    if (stg->pInterface)
        IUnknown_AddRef(stg->pInterface);
 
    return hr;
}

ITypeComp_BindType_Proxy()

HRESULT CALLBACK ITypeComp_BindType_Proxy	(	ITypeComp *	This,
		LPOLESTR	name,
		ULONG	lHashVal,
		ITypeInfo **	ti,
		ITypeComp **	typecomp
	)

Definition at line 1694 of file usrmarshal.c.

{
    HRESULT hr;
 
    TRACE("(%p, %s, %#x, %p, %p)\n", This, debugstr_w(name), lHashVal, ti, typecomp);
 
    hr = ITypeComp_RemoteBindType_Proxy(This, name, lHashVal, ti);
    if (hr == S_OK)
        ITypeInfo_GetTypeComp(*ti, typecomp);
    else if (typecomp)
        *typecomp = NULL;
 
    return hr;
}

ITypeComp_BindType_Stub()

HRESULT __RPC_STUB ITypeComp_BindType_Stub	(	ITypeComp *	This,
		LPOLESTR	name,
		ULONG	lHashVal,
		ITypeInfo **	ti
	)

Definition at line 1714 of file usrmarshal.c.

{
    ITypeComp *typecomp = NULL;
    HRESULT hr;
 
    TRACE("(%p, %s, %#x, %p)\n", This, debugstr_w(name), lHashVal, ti);
 
    hr = ITypeComp_BindType(This, name, lHashVal, ti, &typecomp);
 
    if (typecomp)
        ITypeComp_Release(typecomp);
 
    return hr;
}

ITypeInfo2_GetDocumentation2_Proxy()

HRESULT CALLBACK ITypeInfo2_GetDocumentation2_Proxy	(	ITypeInfo2 *	This,
		MEMBERID	memid,
		LCID	lcid,
		BSTR *	help_string,
		DWORD *	help_context,
		BSTR *	help_dll
	)

Definition at line 2127 of file usrmarshal.c.

{
    DWORD dummy_help_context, flags = 0;
    BSTR dummy_help_string, dummy_help_dll;
    HRESULT hr;
    TRACE("(%p, %08x, %08x, %p, %p, %p)\n", This, memid, lcid, help_string, help_context, help_dll);
 
    if(!help_string) help_string = &dummy_help_string;
    else flags = 1;
 
    if(!help_context) help_context = &dummy_help_context;
    else flags |= 2;
 
    if(!help_dll) help_dll = &dummy_help_dll;
    else flags |= 4;
 
    hr = ITypeInfo2_RemoteGetDocumentation2_Proxy(This, memid, lcid, flags, help_string, help_context, help_dll);
 
    /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
 
    return hr;
}

ITypeInfo2_GetDocumentation2_Stub()

HRESULT __RPC_STUB ITypeInfo2_GetDocumentation2_Stub	(	ITypeInfo2 *	This,
		MEMBERID	memid,
		LCID	lcid,
		DWORD	flags,
		BSTR *	help_string,
		DWORD *	help_context,
		BSTR *	help_dll
	)

Definition at line 2152 of file usrmarshal.c.

{
    TRACE("(%p, %08x, %08x, %08x, %p, %p, %p)\n", This, memid, lcid, flags, help_string, help_context, help_dll);
 
    *help_string = *help_dll = NULL;
    *help_context = 0;
 
    if(!(flags & 1)) help_string = NULL;
    if(!(flags & 2)) help_context = NULL;
    if(!(flags & 4)) help_dll = NULL;
 
    return ITypeInfo2_GetDocumentation2(This, memid, lcid, help_string, help_context, help_dll);
}

ITypeInfo_AddressOfMember_Proxy()

HRESULT CALLBACK ITypeInfo_AddressOfMember_Proxy	(	ITypeInfo *	This,
		MEMBERID	memid,
		INVOKEKIND	invKind,
		PVOID *	ppv
	)

Definition at line 1989 of file usrmarshal.c.

{
  FIXME("not implemented\n");
  return E_FAIL;
}

ITypeInfo_AddressOfMember_Stub()

HRESULT __RPC_STUB ITypeInfo_AddressOfMember_Stub

(

ITypeInfo *

This

)

Definition at line 1999 of file usrmarshal.c.

{
  FIXME("not implemented\n");
  return E_FAIL;
}

ITypeInfo_CreateInstance_Proxy()

HRESULT CALLBACK ITypeInfo_CreateInstance_Proxy	(	ITypeInfo *	This,
		IUnknown *	pUnkOuter,
		REFIID	riid,
		PVOID *	ppvObj
	)

Definition at line 2006 of file usrmarshal.c.

{
  FIXME("not implemented\n");
  return E_FAIL;
}

ITypeInfo_CreateInstance_Stub()

HRESULT __RPC_STUB ITypeInfo_CreateInstance_Stub	(	ITypeInfo *	This,
		REFIID	riid,
		IUnknown **	ppvObj
	)

Definition at line 2016 of file usrmarshal.c.

{
  FIXME("not implemented\n");
  return E_FAIL;
}

ITypeInfo_GetContainingTypeLib_Proxy()

HRESULT CALLBACK ITypeInfo_GetContainingTypeLib_Proxy	(	ITypeInfo *	This,
		ITypeLib **	ppTLib,
		UINT *	pIndex
	)

Definition at line 2025 of file usrmarshal.c.

{
    ITypeLib *pTL;
    UINT index;
    HRESULT hr;
 
    TRACE("(%p, %p, %p)\n", This, ppTLib, pIndex );
    
    hr = ITypeInfo_RemoteGetContainingTypeLib_Proxy(This, &pTL, &index);
    if(SUCCEEDED(hr))
    {
        if(pIndex)
            *pIndex = index;
 
        if(ppTLib)
            *ppTLib = pTL;
        else
            ITypeLib_Release(pTL);
    }
    return hr;
}

ITypeInfo_GetContainingTypeLib_Stub()

HRESULT __RPC_STUB ITypeInfo_GetContainingTypeLib_Stub	(	ITypeInfo *	This,
		ITypeLib **	ppTLib,
		UINT *	pIndex
	)

Definition at line 2050 of file usrmarshal.c.

{
    TRACE("(%p, %p, %p)\n", This, ppTLib, pIndex );
    return ITypeInfo_GetContainingTypeLib(This, ppTLib, pIndex);
}

ITypeInfo_GetDllEntry_Proxy()

HRESULT CALLBACK ITypeInfo_GetDllEntry_Proxy	(	ITypeInfo *	This,
		MEMBERID	memid,
		INVOKEKIND	invkind,
		BSTR *	dll_name,
		BSTR *	name,
		WORD *	ordinal
	)

Definition at line 1946 of file usrmarshal.c.

{
    DWORD flags = 0;
    BSTR dummy_dll_name, dummy_name;
    WORD dummy_ordinal;
    HRESULT hr;
    TRACE("(%p, %08x, %x, %p, %p, %p)\n", This, memid, invkind, dll_name, name, ordinal);
 
    if(!dll_name) dll_name = &dummy_dll_name;
    else flags = 1;
 
    if(!name) name = &dummy_name;
    else flags |= 2;
 
    if(!ordinal) ordinal = &dummy_ordinal;
    else flags |= 4;
 
    hr = ITypeInfo_RemoteGetDllEntry_Proxy(This, memid, invkind, flags, dll_name, name, ordinal);
 
    /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
 
    return hr;
}

ITypeInfo_GetDllEntry_Stub()

HRESULT __RPC_STUB ITypeInfo_GetDllEntry_Stub	(	ITypeInfo *	This,
		MEMBERID	memid,
		INVOKEKIND	invkind,
		DWORD	flags,
		BSTR *	dll_name,
		BSTR *	name,
		WORD *	ordinal
	)

Definition at line 1972 of file usrmarshal.c.

{
    TRACE("(%p, %08x, %x, %p, %p, %p)\n", This, memid, invkind, dll_name, name, ordinal);
 
    *dll_name = *name = NULL;
    *ordinal = 0;
 
    if(!(flags & 1)) dll_name = NULL;
    if(!(flags & 2)) name = NULL;
    if(!(flags & 4)) ordinal = NULL;
 
    return ITypeInfo_GetDllEntry(This, memid, invkind, dll_name, name, ordinal);
}

ITypeInfo_GetDocumentation_Proxy()

HRESULT CALLBACK ITypeInfo_GetDocumentation_Proxy	(	ITypeInfo *	This,
		MEMBERID	memid,
		BSTR *	name,
		BSTR *	doc_string,
		DWORD *	help_context,
		BSTR *	help_file
	)

Definition at line 1901 of file usrmarshal.c.

{
    DWORD dummy_help_context, flags = 0;
    BSTR dummy_name, dummy_doc_string, dummy_help_file;
    HRESULT hr;
    TRACE("(%p, %08x, %p, %p, %p, %p)\n", This, memid, name, doc_string, help_context, help_file);
 
    if(!name) name = &dummy_name;
    else flags = 1;
 
    if(!doc_string) doc_string = &dummy_doc_string;
    else flags |= 2;
 
    if(!help_context) help_context = &dummy_help_context;
    else flags |= 4;
 
    if(!help_file) help_file = &dummy_help_file;
    else flags |= 8;
 
    hr = ITypeInfo_RemoteGetDocumentation_Proxy(This, memid, flags, name, doc_string, help_context, help_file);
 
    /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
 
    return hr;
}

ITypeInfo_GetDocumentation_Stub()

HRESULT __RPC_STUB ITypeInfo_GetDocumentation_Stub	(	ITypeInfo *	This,
		MEMBERID	memid,
		DWORD	flags,
		BSTR *	name,
		BSTR *	doc_string,
		DWORD *	help_context,
		BSTR *	help_file
	)

Definition at line 1929 of file usrmarshal.c.

{
    TRACE("(%p, %08x, %08x, %p, %p, %p, %p)\n", This, memid, flags, name, doc_string, help_context, help_file);
 
    *name = *doc_string = *help_file = NULL;
    *help_context = 0;
 
    if(!(flags & 1)) name = NULL;
    if(!(flags & 2)) doc_string = NULL;
    if(!(flags & 4)) help_context = NULL;
    if(!(flags & 8)) help_file = NULL;
 
    return ITypeInfo_GetDocumentation(This, memid, name, doc_string, help_context, help_file);
}

ITypeInfo_GetFuncDesc_Proxy()

HRESULT CALLBACK ITypeInfo_GetFuncDesc_Proxy	(	ITypeInfo *	This,
		UINT	index,
		FUNCDESC **	ppFuncDesc
	)

Definition at line 1769 of file usrmarshal.c.

{
    CLEANLOCALSTORAGE stg;
    TRACE("(%p, %d, %p)\n", This, index, ppFuncDesc);
 
    stg.flags = 0;
    stg.pStorage = NULL;
    stg.pInterface = NULL;
 
    return ITypeInfo_RemoteGetFuncDesc_Proxy(This, index, ppFuncDesc, &stg);
}

ITypeInfo_GetFuncDesc_Stub()

HRESULT __RPC_STUB ITypeInfo_GetFuncDesc_Stub	(	ITypeInfo *	This,
		UINT	index,
		LPFUNCDESC *	ppFuncDesc,
		CLEANLOCALSTORAGE *	pDummy
	)

Definition at line 1784 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("(%p, %d, %p)\n", This, index, ppFuncDesc);
 
    hr = ITypeInfo_GetFuncDesc(This, index, ppFuncDesc);
    if(hr != S_OK)
        return hr;
 
    pDummy->flags = CLS_FUNCDESC;
    ITypeInfo_AddRef(This);
    pDummy->pInterface = (IUnknown*)This;
    pDummy->pStorage = ppFuncDesc;
    return hr;
}

ITypeInfo_GetIDsOfNames_Proxy()

HRESULT CALLBACK ITypeInfo_GetIDsOfNames_Proxy	(	ITypeInfo *	This,
		LPOLESTR *	rgszNames,
		UINT	cNames,
		MEMBERID *	pMemId
	)

Definition at line 1863 of file usrmarshal.c.

{
  FIXME("not implemented\n");
  return E_FAIL;
}

ITypeInfo_GetIDsOfNames_Stub()

HRESULT __RPC_STUB ITypeInfo_GetIDsOfNames_Stub

(

ITypeInfo *

This

)

Definition at line 1873 of file usrmarshal.c.

{
  FIXME("not implemented\n");
  return E_FAIL;
}

ITypeInfo_GetNames_Proxy()

HRESULT CALLBACK ITypeInfo_GetNames_Proxy	(	ITypeInfo *	This,
		MEMBERID	memid,
		BSTR *	rgBstrNames,
		UINT	cMaxNames,
		UINT *	pcNames
	)

Definition at line 1839 of file usrmarshal.c.

{
    TRACE("(%p, %08x, %p, %d, %p)\n", This, memid, rgBstrNames, cMaxNames, pcNames);
 
    return ITypeInfo_RemoteGetNames_Proxy(This, memid, rgBstrNames, cMaxNames, pcNames);
}

ITypeInfo_GetNames_Stub()

HRESULT __RPC_STUB ITypeInfo_GetNames_Stub	(	ITypeInfo *	This,
		MEMBERID	memid,
		BSTR *	rgBstrNames,
		UINT	cMaxNames,
		UINT *	pcNames
	)

Definition at line 1851 of file usrmarshal.c.

{
    TRACE("(%p, %08x, %p, %d, %p)\n", This, memid, rgBstrNames, cMaxNames, pcNames);
 
    return ITypeInfo_GetNames(This, memid, rgBstrNames, cMaxNames, pcNames);
}

ITypeInfo_GetTypeAttr_Proxy()

HRESULT CALLBACK ITypeInfo_GetTypeAttr_Proxy	(	ITypeInfo *	This,
		TYPEATTR **	ppTypeAttr
	)

Definition at line 1735 of file usrmarshal.c.

{
    CLEANLOCALSTORAGE stg;
    TRACE("(%p, %p)\n", This, ppTypeAttr);
 
    stg.flags = 0;
    stg.pStorage = NULL;
    stg.pInterface = NULL;
 
    return ITypeInfo_RemoteGetTypeAttr_Proxy(This, ppTypeAttr, &stg);
}

ITypeInfo_GetTypeAttr_Stub()

HRESULT __RPC_STUB ITypeInfo_GetTypeAttr_Stub	(	ITypeInfo *	This,
		LPTYPEATTR *	ppTypeAttr,
		CLEANLOCALSTORAGE *	pDummy
	)

Definition at line 1750 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("(%p, %p)\n", This, ppTypeAttr);
 
    hr = ITypeInfo_GetTypeAttr(This, ppTypeAttr);
    if(hr != S_OK)
        return hr;
 
    pDummy->flags = CLS_TYPEATTR;
    ITypeInfo_AddRef(This);
    pDummy->pInterface = (IUnknown*)This;
    pDummy->pStorage = ppTypeAttr;
    return hr;
}

ITypeInfo_GetVarDesc_Proxy()

HRESULT CALLBACK ITypeInfo_GetVarDesc_Proxy	(	ITypeInfo *	This,
		UINT	index,
		VARDESC **	ppVarDesc
	)

Definition at line 1804 of file usrmarshal.c.

{
    CLEANLOCALSTORAGE stg;
    TRACE("(%p, %d, %p)\n", This, index, ppVarDesc);
 
    stg.flags = 0;
    stg.pStorage = NULL;
    stg.pInterface = NULL;
 
    return ITypeInfo_RemoteGetVarDesc_Proxy(This, index, ppVarDesc, &stg);
}

ITypeInfo_GetVarDesc_Stub()

HRESULT __RPC_STUB ITypeInfo_GetVarDesc_Stub	(	ITypeInfo *	This,
		UINT	index,
		LPVARDESC *	ppVarDesc,
		CLEANLOCALSTORAGE *	pDummy
	)

Definition at line 1819 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("(%p, %d, %p)\n", This, index, ppVarDesc);
 
    hr = ITypeInfo_GetVarDesc(This, index, ppVarDesc);
    if(hr != S_OK)
        return hr;
 
    pDummy->flags = CLS_VARDESC;
    ITypeInfo_AddRef(This);
    pDummy->pInterface = (IUnknown*)This;
    pDummy->pStorage = ppVarDesc;
    return hr;
}

ITypeInfo_Invoke_Proxy()

HRESULT CALLBACK ITypeInfo_Invoke_Proxy	(	ITypeInfo *	This,
		PVOID	pvInstance,
		MEMBERID	memid,
		WORD	wFlags,
		DISPPARAMS *	pDispParams,
		VARIANT *	pVarResult,
		EXCEPINFO *	pExcepInfo,
		UINT *	puArgErr
	)

Definition at line 1880 of file usrmarshal.c.

{
  FIXME("not implemented\n");
  return E_FAIL;
}

ITypeInfo_Invoke_Stub()

HRESULT __RPC_STUB ITypeInfo_Invoke_Stub

(

ITypeInfo *

This

)

Definition at line 1894 of file usrmarshal.c.

{
  FIXME("not implemented\n");
  return E_FAIL;
}

ITypeInfo_ReleaseFuncDesc_Proxy()

void CALLBACK ITypeInfo_ReleaseFuncDesc_Proxy	(	ITypeInfo *	This,
		FUNCDESC *	pFuncDesc
	)

Definition at line 2075 of file usrmarshal.c.

{
    SHORT param;
    TRACE("(%p, %p)\n", This, pFuncDesc);
 
    for(param = 0; param < pFuncDesc->cParams; param++)
        free_embedded_elemdesc(pFuncDesc->lprgelemdescParam + param);
    if(param)
        CoTaskMemFree(pFuncDesc->lprgelemdescParam);
 
    free_embedded_elemdesc(&pFuncDesc->elemdescFunc);
 
    if(pFuncDesc->cScodes != 0 && pFuncDesc->cScodes != -1)
        CoTaskMemFree(pFuncDesc->lprgscode);
 
    CoTaskMemFree(pFuncDesc);
}

ITypeInfo_ReleaseFuncDesc_Stub()

HRESULT __RPC_STUB ITypeInfo_ReleaseFuncDesc_Stub

(

ITypeInfo *

This

)

Definition at line 2095 of file usrmarshal.c.

{
    TRACE("nothing to do\n");
    return S_OK;
}

ITypeInfo_ReleaseTypeAttr_Proxy()

void CALLBACK ITypeInfo_ReleaseTypeAttr_Proxy	(	ITypeInfo *	This,
		TYPEATTR *	pTypeAttr
	)

Definition at line 2059 of file usrmarshal.c.

{
    TRACE("(%p, %p)\n", This, pTypeAttr);
    free_embedded_typedesc(&pTypeAttr->tdescAlias);
    CoTaskMemFree(pTypeAttr);
}

ITypeInfo_ReleaseTypeAttr_Stub()

HRESULT __RPC_STUB ITypeInfo_ReleaseTypeAttr_Stub

(

ITypeInfo *

This

)

Definition at line 2068 of file usrmarshal.c.

{
    TRACE("nothing to do\n");
    return S_OK;
}

ITypeInfo_ReleaseVarDesc_Proxy()

void CALLBACK ITypeInfo_ReleaseVarDesc_Proxy	(	ITypeInfo *	This,
		VARDESC *	pVarDesc
	)

Definition at line 2102 of file usrmarshal.c.

{
    TRACE("(%p, %p)\n", This, pVarDesc);
 
    CoTaskMemFree(pVarDesc->lpstrSchema);
 
    if(pVarDesc->varkind == VAR_CONST)
        CoTaskMemFree(pVarDesc->u.lpvarValue);
 
    free_embedded_elemdesc(&pVarDesc->elemdescVar);
    CoTaskMemFree(pVarDesc);
}

ITypeInfo_ReleaseVarDesc_Stub()

HRESULT __RPC_STUB ITypeInfo_ReleaseVarDesc_Stub

(

ITypeInfo *

This

)

Definition at line 2117 of file usrmarshal.c.

{
    TRACE("nothing to do\n");
    return S_OK;
}

ITypeLib2_GetDocumentation2_Proxy()

HRESULT CALLBACK ITypeLib2_GetDocumentation2_Proxy	(	ITypeLib2 *	This,
		INT	index,
		LCID	lcid,
		BSTR *	help_string,
		DWORD *	help_context,
		BSTR *	help_dll
	)

Definition at line 2351 of file usrmarshal.c.

{
    DWORD dummy_help_context, flags = 0;
    BSTR dummy_help_string, dummy_help_dll;
    HRESULT hr;
    TRACE("(%p, %d, %08x, %p, %p, %p)\n", This, index, lcid, help_string, help_context, help_dll);
 
    if(!help_string) help_string = &dummy_help_string;
    else flags = 1;
 
    if(!help_context) help_context = &dummy_help_context;
    else flags |= 2;
 
    if(!help_dll) help_dll = &dummy_help_dll;
    else flags |= 4;
 
    hr = ITypeLib2_RemoteGetDocumentation2_Proxy(This, index, lcid, flags, help_string, help_context, help_dll);
 
    /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
 
    return hr;
}

ITypeLib2_GetDocumentation2_Stub()

HRESULT __RPC_STUB ITypeLib2_GetDocumentation2_Stub	(	ITypeLib2 *	This,
		INT	index,
		LCID	lcid,
		DWORD	flags,
		BSTR *	help_string,
		DWORD *	help_context,
		BSTR *	help_dll
	)

Definition at line 2376 of file usrmarshal.c.

{
    TRACE("(%p, %d, %08x, %08x, %p, %p, %p)\n", This, index, lcid, flags, help_string, help_context, help_dll);
 
    *help_string = *help_dll = NULL;
    *help_context = 0;
 
    if(!(flags & 1)) help_string = NULL;
    if(!(flags & 2)) help_context = NULL;
    if(!(flags & 4)) help_dll = NULL;
 
    return ITypeLib2_GetDocumentation2(This, index, lcid, help_string, help_context, help_dll);
}

ITypeLib2_GetLibStatistics_Proxy()

HRESULT CALLBACK ITypeLib2_GetLibStatistics_Proxy	(	ITypeLib2 *	This,
		ULONG *	pcUniqueNames,
		ULONG *	pcchUniqueNames
	)

Definition at line 2333 of file usrmarshal.c.

{
  FIXME("not implemented\n");
  return E_FAIL;
}

ITypeLib2_GetLibStatistics_Stub()

HRESULT __RPC_STUB ITypeLib2_GetLibStatistics_Stub	(	ITypeLib2 *	This,
		ULONG *	pcUniqueNames,
		ULONG *	pcchUniqueNames
	)

Definition at line 2342 of file usrmarshal.c.

{
  FIXME("not implemented\n");
  return E_FAIL;
}

ITypeLib_FindName_Proxy()

HRESULT CALLBACK ITypeLib_FindName_Proxy	(	ITypeLib *	This,
		LPOLESTR	szNameBuf,
		ULONG	lHashVal,
		ITypeInfo **	ppTInfo,
		MEMBERID *	rgMemId,
		USHORT *	pcFound
	)

Definition at line 2290 of file usrmarshal.c.

{
  FIXME("not implemented\n");
  return E_FAIL;
}

ITypeLib_FindName_Stub()

HRESULT __RPC_STUB ITypeLib_FindName_Stub	(	ITypeLib *	This,
		LPOLESTR	szNameBuf,
		ULONG	lHashVal,
		ITypeInfo **	ppTInfo,
		MEMBERID *	rgMemId,
		USHORT *	pcFound,
		BSTR *	pBstrLibName
	)

Definition at line 2302 of file usrmarshal.c.

{
  FIXME("not implemented\n");
  return E_FAIL;
}

ITypeLib_GetDocumentation_Proxy()

HRESULT CALLBACK ITypeLib_GetDocumentation_Proxy	(	ITypeLib *	This,
		INT	index,
		BSTR *	name,
		BSTR *	doc_string,
		DWORD *	help_context,
		BSTR *	help_file
	)

Definition at line 2224 of file usrmarshal.c.

{
    DWORD dummy_help_context, flags = 0;
    BSTR dummy_name, dummy_doc_string, dummy_help_file;
    HRESULT hr;
    TRACE("(%p, %d, %p, %p, %p, %p)\n", This, index, name, doc_string, help_context, help_file);
 
    if(!name) name = &dummy_name;
    else flags = 1;
 
    if(!doc_string) doc_string = &dummy_doc_string;
    else flags |= 2;
 
    if(!help_context) help_context = &dummy_help_context;
    else flags |= 4;
 
    if(!help_file) help_file = &dummy_help_file;
    else flags |= 8;
 
    hr = ITypeLib_RemoteGetDocumentation_Proxy(This, index, flags, name, doc_string, help_context, help_file);
 
    /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
 
    return hr;
}

ITypeLib_GetDocumentation_Stub()

HRESULT __RPC_STUB ITypeLib_GetDocumentation_Stub	(	ITypeLib *	This,
		INT	index,
		DWORD	flags,
		BSTR *	name,
		BSTR *	doc_string,
		DWORD *	help_context,
		BSTR *	help_file
	)

Definition at line 2252 of file usrmarshal.c.

{
    TRACE("(%p, %d, %08x, %p, %p, %p, %p)\n", This, index, flags, name, doc_string, help_context, help_file);
 
    *name = *doc_string = *help_file = NULL;
    *help_context = 0;
 
    if(!(flags & 1)) name = NULL;
    if(!(flags & 2)) doc_string = NULL;
    if(!(flags & 4)) help_context = NULL;
    if(!(flags & 8)) help_file = NULL;
 
    return ITypeLib_GetDocumentation(This, index, name, doc_string, help_context, help_file);
}

ITypeLib_GetLibAttr_Proxy()

HRESULT CALLBACK ITypeLib_GetLibAttr_Proxy	(	ITypeLib *	This,
		TLIBATTR **	ppTLibAttr
	)

Definition at line 2191 of file usrmarshal.c.

{
    CLEANLOCALSTORAGE stg;
    TRACE("(%p, %p)\n", This, ppTLibAttr);
 
    stg.flags = 0;
    stg.pStorage = NULL;
    stg.pInterface = NULL;
 
    return ITypeLib_RemoteGetLibAttr_Proxy(This, ppTLibAttr, &stg);    
}

ITypeLib_GetLibAttr_Stub()

HRESULT __RPC_STUB ITypeLib_GetLibAttr_Stub	(	ITypeLib *	This,
		LPTLIBATTR *	ppTLibAttr,
		CLEANLOCALSTORAGE *	pDummy
	)

Definition at line 2205 of file usrmarshal.c.

{
    HRESULT hr;
    TRACE("(%p, %p)\n", This, ppTLibAttr);
    
    hr = ITypeLib_GetLibAttr(This, ppTLibAttr);
    if(hr != S_OK)
        return hr;
 
    pDummy->flags = CLS_LIBATTR;
    ITypeLib_AddRef(This);
    pDummy->pInterface = (IUnknown*)This;
    pDummy->pStorage = ppTLibAttr;
    return hr;
}

ITypeLib_GetTypeInfoCount_Proxy()

UINT CALLBACK ITypeLib_GetTypeInfoCount_Proxy

(

ITypeLib *

This

)

Definition at line 2171 of file usrmarshal.c.

{
    UINT count = 0;
    TRACE("(%p)\n", This);
 
    ITypeLib_RemoteGetTypeInfoCount_Proxy(This, &count);
    
    return count;
}

ITypeLib_GetTypeInfoCount_Stub()

HRESULT __RPC_STUB ITypeLib_GetTypeInfoCount_Stub	(	ITypeLib *	This,
		UINT *	pcTInfo
	)

Definition at line 2182 of file usrmarshal.c.

{
    TRACE("(%p, %p)\n", This, pcTInfo);
    *pcTInfo = ITypeLib_GetTypeInfoCount(This);
    return S_OK;
}

ITypeLib_IsName_Proxy()

HRESULT CALLBACK ITypeLib_IsName_Proxy	(	ITypeLib *	This,
		LPOLESTR	szNameBuf,
		ULONG	lHashVal,
		BOOL *	pfName
	)

Definition at line 2269 of file usrmarshal.c.

{
  FIXME("not implemented\n");
  return E_FAIL;
}

ITypeLib_IsName_Stub()

HRESULT __RPC_STUB ITypeLib_IsName_Stub	(	ITypeLib *	This,
		LPOLESTR	szNameBuf,
		ULONG	lHashVal,
		BOOL *	pfName,
		BSTR *	pBstrLibName
	)

Definition at line 2279 of file usrmarshal.c.

{
  FIXME("not implemented\n");
  return E_FAIL;
}

ITypeLib_ReleaseTLibAttr_Proxy()

void CALLBACK ITypeLib_ReleaseTLibAttr_Proxy	(	ITypeLib *	This,
		TLIBATTR *	pTLibAttr
	)

Definition at line 2315 of file usrmarshal.c.

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

ITypeLib_ReleaseTLibAttr_Stub()

HRESULT __RPC_STUB ITypeLib_ReleaseTLibAttr_Stub

(

ITypeLib *

This

)

Definition at line 2323 of file usrmarshal.c.

{
    TRACE("nothing to do\n");
    return S_OK;
}

LPSAFEARRAY_UserFree()

void WINAPI LPSAFEARRAY_UserFree	(	ULONG *	pFlags,
		LPSAFEARRAY *	ppsa
	)

Definition at line 1308 of file usrmarshal.c.

{
    TRACE("("); dump_user_flags(pFlags); TRACE(", &%p\n", *ppsa);
 
    SafeArrayDestroy(*ppsa);
    *ppsa = NULL;
}

Referenced by test_marshal_LPSAFEARRAY(), and VARIANT_UserFree().

LPSAFEARRAY_UserMarshal()

unsigned char *WINAPI LPSAFEARRAY_UserMarshal	(	ULONG *	pFlags,
		unsigned char *	Buffer,
		LPSAFEARRAY *	ppsa
	)

Definition at line 972 of file usrmarshal.c.

{
    HRESULT hr;
 
    TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &%p\n", Buffer, *ppsa);
 
    ALIGN_POINTER(Buffer, 3);
    *(ULONG *)Buffer = *ppsa ? 0x1 : 0x0;
    Buffer += sizeof(ULONG);
    if (*ppsa)
    {
        VARTYPE vt;
        SAFEARRAY *psa = *ppsa;
        ULONG ulCellCount = SAFEARRAY_GetCellCount(psa);
        SAFEARRAYBOUND *bound;
        SF_TYPE sftype;
        GUID guid;
        INT i;
 
        sftype = SAFEARRAY_GetUnionType(psa);
 
        *(ULONG *)Buffer = psa->cDims;
        Buffer += sizeof(ULONG);
        *(USHORT *)Buffer = psa->cDims;
        Buffer += sizeof(USHORT);
        *(USHORT *)Buffer = psa->fFeatures;
        Buffer += sizeof(USHORT);
        *(ULONG *)Buffer = elem_wire_size(psa, sftype);
        Buffer += sizeof(ULONG);
 
        hr = SafeArrayGetVartype(psa, &vt);
#ifdef __REACTOS__
        if ((psa->fFeatures & FADF_HAVEIID) || FAILED(hr)) vt = 0;
#else
        if (FAILED(hr)) vt = 0;
#endif
 
        *(ULONG *)Buffer = (USHORT)psa->cLocks | (vt << 16);
        Buffer += sizeof(ULONG);
 
        *(ULONG *)Buffer = sftype;
        Buffer += sizeof(ULONG);
 
        *(ULONG *)Buffer = ulCellCount;
        Buffer += sizeof(ULONG);
        *(ULONG *)Buffer = psa->pvData ? 0x2 : 0x0;
        Buffer += sizeof(ULONG);
        if (sftype == SF_HAVEIID)
        {
            SafeArrayGetIID(psa, &guid);
            memcpy(Buffer, &guid, sizeof(guid));
            Buffer += sizeof(guid);
        }
 
        /* bounds are marshaled in opposite order comparing to storage layout */
        bound = (SAFEARRAYBOUND*)Buffer;
        for (i = 0; i < psa->cDims; i++)
        {
            memcpy(bound++, &psa->rgsabound[psa->cDims-i-1], sizeof(psa->rgsabound[0]));
        }
        Buffer += sizeof(psa->rgsabound[0]) * psa->cDims;
 
        *(ULONG *)Buffer = ulCellCount;
        Buffer += sizeof(ULONG);
 
        if (psa->pvData)
        {
            switch (sftype)
            {
                case SF_BSTR:
                {
                    BSTR* lpBstr;
 
                    for (lpBstr = psa->pvData; ulCellCount; ulCellCount--, lpBstr++)
                        Buffer = BSTR_UserMarshal(pFlags, Buffer, lpBstr);
 
                    break;
                }
                case SF_DISPATCH:
                case SF_UNKNOWN:
                case SF_HAVEIID:
#ifdef __REACTOS__
                {
                    IUnknown **lpUnk;
                    const GUID *iid;
 
                    if (sftype == SF_HAVEIID)
                        iid = &guid;
                    else if (sftype == SF_UNKNOWN)
                        iid = &IID_IUnknown;
                    else
                        iid = &IID_IDispatch;
 
                    for (lpUnk = psa->pvData; ulCellCount; ulCellCount--, lpUnk++)
                            Buffer = interface_user_marshal(pFlags, Buffer, iid, *lpUnk);
 
#else
                    FIXME("marshal interfaces\n");
#endif
                    break;
#ifdef __REACTOS__
                }
#endif
                case SF_VARIANT:
                {
                    VARIANT* lpVariant;
 
                    for (lpVariant = psa->pvData; ulCellCount; ulCellCount--, lpVariant++)
                        Buffer = VARIANT_UserMarshal(pFlags, Buffer, lpVariant);
 
                    break;
                }
                case SF_RECORD:
                {
                    IRecordInfo* pRecInfo = NULL;
 
                    hr = SafeArrayGetRecordInfo(psa, &pRecInfo);
                    if (FAILED(hr))
                        RpcRaiseException(hr);
 
                    if (pRecInfo)
                    {
                        FIXME("write record info %p\n", pRecInfo);
 
                        IRecordInfo_Release(pRecInfo);
                    }
                    break;
                }
 
                case SF_I8:
                    ALIGN_POINTER(Buffer, 7);
                    /* fallthrough */
                case SF_I1:
                case SF_I2:
                case SF_I4:
                    /* Just copy the data over */
                    memcpy(Buffer, psa->pvData, ulCellCount * psa->cbElements);
                    Buffer += ulCellCount * psa->cbElements;
                    break;
                default:
                    break;
            }
        }
 
    }
    return Buffer;
}

Referenced by test_marshal_LPSAFEARRAY(), and VARIANT_UserMarshal().

LPSAFEARRAY_UserSize()

ULONG WINAPI LPSAFEARRAY_UserSize	(	ULONG *	pFlags,
		ULONG	StartingSize,
		LPSAFEARRAY *	ppsa
	)

Definition at line 864 of file usrmarshal.c.

{
    ULONG size = StartingSize;
 
    TRACE("("); dump_user_flags(pFlags); TRACE(", %d, %p\n", StartingSize, *ppsa);
 
    ALIGN_LENGTH(size, 3);
    size += sizeof(ULONG);
    if (*ppsa)
    {
        SAFEARRAY *psa = *ppsa;
        ULONG ulCellCount = SAFEARRAY_GetCellCount(psa);
        SF_TYPE sftype;
        HRESULT hr;
 
        size += sizeof(ULONG);
        size += 2 * sizeof(USHORT) + 2 * sizeof(ULONG);
 
        sftype = SAFEARRAY_GetUnionType(psa);
        size += sizeof(ULONG);
 
        size += sizeof(ULONG);
        size += sizeof(ULONG);
        if (sftype == SF_HAVEIID)
            size += sizeof(IID);
 
        size += sizeof(psa->rgsabound[0]) * psa->cDims;
 
        size += sizeof(ULONG);
 
        switch (sftype)
        {
            case SF_BSTR:
            {
                BSTR* lpBstr;
 
                for (lpBstr = psa->pvData; ulCellCount; ulCellCount--, lpBstr++)
                    size = BSTR_UserSize(pFlags, size, lpBstr);
 
                break;
            }
            case SF_DISPATCH:
            case SF_UNKNOWN:
            case SF_HAVEIID:
#ifdef __REACTOS__
            {
                IUnknown **lpUnk;
                GUID guid;
 
                if (sftype == SF_HAVEIID)
                    SafeArrayGetIID(psa, &guid);
                else if (sftype == SF_UNKNOWN)
                    guid = IID_IUnknown;
                else
                    guid = IID_IDispatch;
 
                for (lpUnk = psa->pvData; ulCellCount; ulCellCount--, lpUnk++)
                    size = interface_user_size(pFlags, size, &guid, *lpUnk);
 
#else
                FIXME("size interfaces\n");
#endif
                break;
#ifdef __REACTOS__
            }
#endif
            case SF_VARIANT:
            {
                VARIANT* lpVariant;
 
                for (lpVariant = psa->pvData; ulCellCount; ulCellCount--, lpVariant++)
                    size = VARIANT_UserSize(pFlags, size, lpVariant);
 
                break;
            }
            case SF_RECORD:
            {
                IRecordInfo* pRecInfo = NULL;
 
                hr = SafeArrayGetRecordInfo(psa, &pRecInfo);
                if (FAILED(hr))
                    RpcRaiseException(hr);
 
                if (pRecInfo)
                {
                    FIXME("size record info %p\n", pRecInfo);
 
                    IRecordInfo_Release(pRecInfo);
                }
                break;
            }
            case SF_I8:
                ALIGN_LENGTH(size, 7);
                /* fallthrough */
            case SF_I1:
            case SF_I2:
            case SF_I4:
                size += ulCellCount * psa->cbElements;
                break;
            default:
                break;
        }
 
    }
 
    return size;
}

Referenced by test_marshal_LPSAFEARRAY(), and wire_extra_user_size().

LPSAFEARRAY_UserUnmarshal()

unsigned char *WINAPI LPSAFEARRAY_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	Buffer,
		LPSAFEARRAY *	ppsa
	)

Definition at line 1124 of file usrmarshal.c.

{
    ULONG ptr;
    wireSAFEARRAY wiresa;
    ULONG cDims;
    HRESULT hr;
    SF_TYPE sftype;
    ULONG cell_count;
    GUID guid;
    VARTYPE vt;
    SAFEARRAYBOUND *wiresab;
 
    TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", Buffer, ppsa);
 
    ALIGN_POINTER(Buffer, 3);
    ptr = *(ULONG *)Buffer;
    Buffer += sizeof(ULONG);
 
    if (!ptr)
    {
        SafeArrayDestroy(*ppsa);
        *ppsa = NULL;
 
        TRACE("NULL safe array unmarshaled\n");
 
        return Buffer;
    }
 
    cDims = *(ULONG *)Buffer;
    Buffer += sizeof(ULONG);
 
    wiresa = (wireSAFEARRAY)Buffer;
    Buffer += 2 * sizeof(USHORT) + 2 * sizeof(ULONG);
 
    if (cDims != wiresa->cDims)
        RpcRaiseException(RPC_S_INVALID_BOUND);
 
    /* FIXME: there should be a limit on how large cDims can be */
 
    vt = HIWORD(wiresa->cLocks);
 
    sftype = *(ULONG *)Buffer;
    Buffer += sizeof(ULONG);
 
    cell_count = *(ULONG *)Buffer;
    Buffer += sizeof(ULONG);
    ptr = *(ULONG *)Buffer;
    Buffer += sizeof(ULONG);
    if (sftype == SF_HAVEIID)
    {
        memcpy(&guid, Buffer, sizeof(guid));
        Buffer += sizeof(guid);
    }
 
    wiresab = (SAFEARRAYBOUND *)Buffer;
    Buffer += sizeof(wiresab[0]) * wiresa->cDims;
 
    if(*ppsa && (*ppsa)->cDims==wiresa->cDims)
    {
        if(((*ppsa)->fFeatures & ~FADF_AUTOSETFLAGS) != (wiresa->fFeatures & ~FADF_AUTOSETFLAGS))
            RpcRaiseException(DISP_E_BADCALLEE);
 
        if(SAFEARRAY_GetCellCount(*ppsa)*(*ppsa)->cbElements != cell_count*elem_mem_size(wiresa, sftype))
        {
            if((*ppsa)->fFeatures & (FADF_AUTO|FADF_STATIC|FADF_EMBEDDED|FADF_FIXEDSIZE))
                RpcRaiseException(DISP_E_BADCALLEE);
 
            hr = SafeArrayDestroyData(*ppsa);
            if(FAILED(hr))
                RpcRaiseException(hr);
        }
        memcpy((*ppsa)->rgsabound, wiresab, sizeof(*wiresab)*wiresa->cDims);
 
        if((*ppsa)->fFeatures & FADF_HAVEVARTYPE)
            ((DWORD*)(*ppsa))[-1] = vt;
    }
    else if(vt)
    {
        SafeArrayDestroy(*ppsa);
        *ppsa = SafeArrayCreateEx(vt, wiresa->cDims, wiresab, NULL);
        if (!*ppsa) RpcRaiseException(E_OUTOFMEMORY);
    }
    else
    {
        SafeArrayDestroy(*ppsa);
        if (FAILED(SafeArrayAllocDescriptor(wiresa->cDims, ppsa)))
            RpcRaiseException(E_OUTOFMEMORY);
        memcpy((*ppsa)->rgsabound, wiresab, sizeof(SAFEARRAYBOUND) * wiresa->cDims);
    }
 
    /* be careful about which flags we set since they could be a security
     * risk */
    (*ppsa)->fFeatures &= FADF_AUTOSETFLAGS;
    (*ppsa)->fFeatures |= (wiresa->fFeatures & ~(FADF_AUTOSETFLAGS));
    /* FIXME: there should be a limit on how large wiresa->cbElements can be */
    (*ppsa)->cbElements = elem_mem_size(wiresa, sftype);
 
    /* SafeArrayCreateEx allocates the data for us, but
     * SafeArrayAllocDescriptor doesn't */
    if(!(*ppsa)->pvData)
    {
        hr = SafeArrayAllocData(*ppsa);
        if (FAILED(hr))
            RpcRaiseException(hr);
    }
 
    if ((*(ULONG *)Buffer != cell_count) || (SAFEARRAY_GetCellCount(*ppsa) != cell_count))
        RpcRaiseException(RPC_S_INVALID_BOUND);
    Buffer += sizeof(ULONG);
 
    if (ptr)
    {
        switch (sftype)
        {
            case SF_BSTR:
            {
                BSTR* lpBstr;
 
                for (lpBstr = (*ppsa)->pvData; cell_count; cell_count--, lpBstr++)
                    Buffer = BSTR_UserUnmarshal(pFlags, Buffer, lpBstr);
 
                break;
            }
            case SF_DISPATCH:
            case SF_UNKNOWN:
            case SF_HAVEIID:
#ifdef __REACTOS__
            {
                IUnknown **lpUnk;
                const GUID *iid;
 
                if (sftype == SF_HAVEIID)
                    iid = &guid;
                else if (sftype == SF_UNKNOWN)
                    iid = &IID_IUnknown;
                else
                    iid = &IID_IDispatch;
 
                for (lpUnk = (*ppsa)->pvData; cell_count; cell_count--, lpUnk++)
                    Buffer = interface_user_unmarshal(pFlags, Buffer, iid, lpUnk);
 
#else
                FIXME("marshal interfaces\n");
#endif
                break;
#ifdef __REACTOS__
            }
#endif
            case SF_VARIANT:
            {
                VARIANT* lpVariant;
 
                for (lpVariant = (*ppsa)->pvData; cell_count; cell_count--, lpVariant++)
                    Buffer = VARIANT_UserUnmarshal(pFlags, Buffer, lpVariant);
 
                break;
            }
            case SF_RECORD:
            {
                FIXME("set record info\n");
 
                break;
            }
 
            case SF_I8:
                ALIGN_POINTER(Buffer, 7);
                /* fallthrough */
            case SF_I1:
            case SF_I2:
            case SF_I4:
                /* Just copy the data over */
                memcpy((*ppsa)->pvData, Buffer, cell_count * (*ppsa)->cbElements);
                Buffer += cell_count * (*ppsa)->cbElements;
                break;
            default:
                break;
        }
    }
 
    TRACE("safe array unmarshaled: %p\n", *ppsa);
 
    return Buffer;
}

Referenced by test_marshal_LPSAFEARRAY(), and VARIANT_UserUnmarshal().

SAFEARRAY_GetCellCount()

static ULONG SAFEARRAY_GetCellCount ( const SAFEARRAY *  psa )

static

Definition at line 726 of file usrmarshal.c.

{
    const SAFEARRAYBOUND* psab = psa->rgsabound;
    USHORT cCount = psa->cDims;
    ULONG ulNumCells = 1;
 
    while (cCount--)
    {
        /* This is a valid bordercase. See testcases. -Marcus */
        if (!psab->cElements)
            return 0;
        ulNumCells *= psab->cElements;
        psab++;
    }
    return ulNumCells;
}

Referenced by LPSAFEARRAY_UserMarshal(), LPSAFEARRAY_UserSize(), and LPSAFEARRAY_UserUnmarshal().

SAFEARRAY_GetUnionType()

static SF_TYPE SAFEARRAY_GetUnionType ( SAFEARRAY *  psa )

inlinestatic

Definition at line 743 of file usrmarshal.c.

{
    VARTYPE vt;
    HRESULT hr;
 
    hr = SafeArrayGetVartype(psa, &vt);
    if (FAILED(hr))
    {
        if(psa->fFeatures & FADF_VARIANT) return SF_VARIANT;
 
        switch(psa->cbElements)
        {
        case 1: vt = VT_I1; break;
        case 2: vt = VT_I2; break;
        case 4: vt = VT_I4; break;
        case 8: vt = VT_I8; break;
        default:
            RpcRaiseException(hr);
        }
    }
 
    if (psa->fFeatures & FADF_HAVEIID)
        return SF_HAVEIID;
 
    switch (vt)
    {
    case VT_I1:
    case VT_UI1:      return SF_I1;
    case VT_BOOL:
    case VT_I2:
    case VT_UI2:      return SF_I2;
    case VT_INT:
    case VT_UINT:
    case VT_I4:
    case VT_UI4:
    case VT_R4:       return SF_I4;
    case VT_DATE:
    case VT_CY:
    case VT_R8:
    case VT_I8:
    case VT_UI8:      return SF_I8;
    case VT_INT_PTR:
    case VT_UINT_PTR: return (sizeof(UINT_PTR) == 4 ? SF_I4 : SF_I8);
    case VT_BSTR:     return SF_BSTR;
    case VT_DISPATCH: return SF_DISPATCH;
    case VT_VARIANT:  return SF_VARIANT;
    case VT_UNKNOWN:  return SF_UNKNOWN;
    /* Note: Return a non-zero size to indicate vt is valid. The actual size
     * of a UDT is taken from the result of IRecordInfo_GetSize().
     */
    case VT_RECORD:   return SF_RECORD;
    default:          return SF_ERROR;
    }
}

Referenced by LPSAFEARRAY_UserMarshal(), and LPSAFEARRAY_UserSize().

VARIANT_UserFree()

void WINAPI VARIANT_UserFree	(	ULONG *	pFlags,
		VARIANT *	pvar
	)

Definition at line 679 of file usrmarshal.c.

{
  VARTYPE vt = V_VT(pvar);
  PVOID ref = NULL;
 
  TRACE("(%x,%p)\n", *pFlags, pvar);
  TRACE("vt=%04x\n", V_VT(pvar));
 
  if (vt & VT_BYREF) ref = pvar->n1.n2.n3.byref;
 
  VariantClear(pvar);
  if (!ref) return;
 
  if(vt & VT_ARRAY)
  {
    if (vt & VT_BYREF)
      LPSAFEARRAY_UserFree(pFlags, V_ARRAYREF(pvar));
    else
      LPSAFEARRAY_UserFree(pFlags, &V_ARRAY(pvar));
  }
  else
  {
    switch (vt)
    {
    case VT_BSTR | VT_BYREF:
      BSTR_UserFree(pFlags, V_BSTRREF(pvar));
      break;
    case VT_VARIANT | VT_BYREF:
      VARIANT_UserFree(pFlags, V_VARIANTREF(pvar));
      break;
    case VT_RECORD | VT_BYREF:
      FIXME("handle BRECORD by ref\n");
      break;
    case VT_UNKNOWN | VT_BYREF:
    case VT_DISPATCH | VT_BYREF:
      if (*V_UNKNOWNREF(pvar))
        IUnknown_Release(*V_UNKNOWNREF(pvar));
      break;
    }
  }
 
  CoTaskMemFree(ref);
}

Referenced by test_marshal_VARIANT(), and VARIANT_UserFree().

VARIANT_UserMarshal()

unsigned char *WINAPI VARIANT_UserMarshal	(	ULONG *	pFlags,
		unsigned char *	Buffer,
		VARIANT *	pvar
	)

Definition at line 420 of file usrmarshal.c.

{
    variant_wire_t *header;
    ULONG type_size;
    int align;
    unsigned char *Pos;
 
    TRACE("(%x,%p,%p)\n", *pFlags, Buffer, pvar);
    TRACE("vt=%04x\n", V_VT(pvar));
 
    ALIGN_POINTER(Buffer, 7);
 
    header = (variant_wire_t *)Buffer; 
 
    header->clSize = 0; /* fixed up at the end */
    header->rpcReserved = 0;
    header->vt = pvar->n1.n2.vt;
    header->wReserved1 = pvar->n1.n2.wReserved1;
    header->wReserved2 = pvar->n1.n2.wReserved2;
    header->wReserved3 = pvar->n1.n2.wReserved3;
    header->switch_is = pvar->n1.n2.vt;
    if(header->switch_is & VT_ARRAY)
        header->switch_is &= ~VT_TYPEMASK;
 
    Pos = (unsigned char*)(header + 1);
    type_size = get_type_size(pFlags, V_VT(pvar));
    align = get_type_alignment(pFlags, V_VT(pvar));
    ALIGN_POINTER(Pos, align);
 
    if(header->vt & VT_BYREF)
    {
        *(DWORD *)Pos = max(type_size, 4);
        Pos += 4;
        if((header->vt & VT_TYPEMASK) != VT_VARIANT)
        {
            memcpy(Pos, pvar->n1.n2.n3.byref, type_size);
            Pos += type_size;
        }
        else
        {
            *(DWORD*)Pos = 'U' | 's' << 8 | 'e' << 16 | 'r' << 24;
            Pos += 4;
        }
    } 
    else
    {
        if((header->vt & VT_TYPEMASK) == VT_DECIMAL)
            memcpy(Pos, pvar, type_size);
        else
            memcpy(Pos, &pvar->n1.n2.n3, type_size);
        Pos += type_size;
    }
 
    if(header->vt & VT_ARRAY)
    {
        if(header->vt & VT_BYREF)
            Pos = LPSAFEARRAY_UserMarshal(pFlags, Pos, V_ARRAYREF(pvar));
        else
            Pos = LPSAFEARRAY_UserMarshal(pFlags, Pos, &V_ARRAY(pvar));
    }
    else
    {
        switch (header->vt)
        {
        case VT_BSTR:
            Pos = BSTR_UserMarshal(pFlags, Pos, &V_BSTR(pvar));
            break;
        case VT_BSTR | VT_BYREF:
            Pos = BSTR_UserMarshal(pFlags, Pos, V_BSTRREF(pvar));
            break;
        case VT_VARIANT | VT_BYREF:
            Pos = VARIANT_UserMarshal(pFlags, Pos, V_VARIANTREF(pvar));
            break;
        case VT_UNKNOWN:
#ifdef __REACTOS__
            Pos = interface_user_marshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWN(pvar));
#else
            Pos = interface_variant_marshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWN(pvar));
#endif
            break;
        case VT_UNKNOWN | VT_BYREF:
#ifdef __REACTOS__
            Pos = interface_user_marshal(pFlags, Pos, &IID_IUnknown, *V_UNKNOWNREF(pvar));
#else
            Pos = interface_variant_marshal(pFlags, Pos, &IID_IUnknown, *V_UNKNOWNREF(pvar));
#endif
            break;
        case VT_DISPATCH:
#ifdef __REACTOS__
            Pos = interface_user_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
#else
            Pos = interface_variant_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
#endif
            break;
        case VT_DISPATCH | VT_BYREF:
#ifdef __REACTOS__
            Pos = interface_user_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
#else
            Pos = interface_variant_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
#endif
            break;
        case VT_RECORD:
            FIXME("handle BRECORD by val\n");
            break;
        case VT_RECORD | VT_BYREF:
            FIXME("handle BRECORD by ref\n");
            break;
        }
    }
    header->clSize = ((Pos - Buffer) + 7) >> 3;
    TRACE("marshalled size=%d\n", header->clSize);
    return Pos;
}

Referenced by LPSAFEARRAY_UserMarshal(), test_marshal_VARIANT(), and VARIANT_UserMarshal().

VARIANT_UserSize()

ULONG WINAPI VARIANT_UserSize	(	ULONG *	pFlags,
		ULONG	Start,
		VARIANT *	pvar
	)

Definition at line 397 of file usrmarshal.c.

{
    int align;
    TRACE("(%x,%d,%p)\n", *pFlags, Start, pvar);
    TRACE("vt=%04x\n", V_VT(pvar));
 
    ALIGN_LENGTH(Start, 7);
    Start += sizeof(variant_wire_t);
    if(V_VT(pvar) & VT_BYREF)
        Start += 4;
 
    align = get_type_alignment(pFlags, V_VT(pvar));
    ALIGN_LENGTH(Start, align);
    if(V_VT(pvar) == (VT_VARIANT | VT_BYREF))
        Start += 4;
    else
        Start += get_type_size(pFlags, V_VT(pvar));
    Start = wire_extra_user_size(pFlags, Start, pvar);
 
    TRACE("returning %d\n", Start);
    return Start;
}

Referenced by LPSAFEARRAY_UserSize(), test_marshal_LPSAFEARRAY(), test_marshal_VARIANT(), and wire_extra_user_size().

VARIANT_UserUnmarshal()

unsigned char *WINAPI VARIANT_UserUnmarshal	(	ULONG *	pFlags,
		unsigned char *	Buffer,
		VARIANT *	pvar
	)

Definition at line 534 of file usrmarshal.c.

{
    variant_wire_t *header;
    ULONG type_size;
    int align;
    unsigned char *Pos;
 
    TRACE("(%x,%p,%p)\n", *pFlags, Buffer, pvar);
 
    ALIGN_POINTER(Buffer, 7);
 
    header = (variant_wire_t *)Buffer; 
    
    Pos = (unsigned char*)(header + 1);
    type_size = get_type_size(pFlags, header->vt);
    align = get_type_alignment(pFlags, header->vt);
    ALIGN_POINTER(Pos, align);
 
    if(header->vt & VT_BYREF)
    {
        ULONG mem_size;
        Pos += 4;
 
        switch (header->vt & ~VT_BYREF)
        {
        /* these types have a different memory size compared to wire size */
        case VT_UNKNOWN:
        case VT_DISPATCH:
        case VT_BSTR:
            mem_size = sizeof(void *);
            break;
        default:
            mem_size = type_size;
            break;
        }
 
        if (V_VT(pvar) != header->vt)
        {
            VariantClear(pvar);
            V_BYREF(pvar) = CoTaskMemAlloc(mem_size);
            memset(V_BYREF(pvar), 0, mem_size);
        }
        else if (!V_BYREF(pvar))
        {
            V_BYREF(pvar) = CoTaskMemAlloc(mem_size);
            memset(V_BYREF(pvar), 0, mem_size);
        }
 
        if(!(header->vt & VT_ARRAY)
                && (header->vt & VT_TYPEMASK) != VT_BSTR
                && (header->vt & VT_TYPEMASK) != VT_VARIANT
                && (header->vt & VT_TYPEMASK) != VT_UNKNOWN
                && (header->vt & VT_TYPEMASK) != VT_DISPATCH
                && (header->vt & VT_TYPEMASK) != VT_RECORD)
            memcpy(V_BYREF(pvar), Pos, type_size);
 
        if((header->vt & VT_TYPEMASK) != VT_VARIANT)
            Pos += type_size;
        else
            Pos += 4;
    }
    else
    {
        VariantClear(pvar);
        if(header->vt & VT_ARRAY)
            V_ARRAY(pvar) = NULL;
        else if((header->vt & VT_TYPEMASK) == VT_BSTR)
            V_BSTR(pvar) = NULL;
        else if((header->vt & VT_TYPEMASK) == VT_UNKNOWN)
            V_UNKNOWN(pvar) = NULL;
        else if((header->vt & VT_TYPEMASK) == VT_DISPATCH)
            V_DISPATCH(pvar) = NULL;
        else if((header->vt & VT_TYPEMASK) == VT_RECORD)
            V_RECORD(pvar) = NULL;
        else if((header->vt & VT_TYPEMASK) == VT_DECIMAL)
            memcpy(pvar, Pos, type_size);
        else
            memcpy(&pvar->n1.n2.n3, Pos, type_size);
        Pos += type_size;
    }
 
    pvar->n1.n2.vt = header->vt;
    pvar->n1.n2.wReserved1 = header->wReserved1;
    pvar->n1.n2.wReserved2 = header->wReserved2;
    pvar->n1.n2.wReserved3 = header->wReserved3;
 
    if(header->vt & VT_ARRAY)
    {
        if(header->vt & VT_BYREF)
            Pos = LPSAFEARRAY_UserUnmarshal(pFlags, Pos, V_ARRAYREF(pvar));
        else
            Pos = LPSAFEARRAY_UserUnmarshal(pFlags, Pos, &V_ARRAY(pvar));
    }
    else
    {
        switch (header->vt)
        {
        case VT_BSTR:
            Pos = BSTR_UserUnmarshal(pFlags, Pos, &V_BSTR(pvar));
            break;
        case VT_BSTR | VT_BYREF:
            Pos = BSTR_UserUnmarshal(pFlags, Pos, V_BSTRREF(pvar));
            break;
        case VT_VARIANT | VT_BYREF:
            Pos = VARIANT_UserUnmarshal(pFlags, Pos, V_VARIANTREF(pvar));
            break;
        case VT_UNKNOWN:
#ifdef __REACTOS__
            Pos = interface_user_unmarshal(pFlags, Pos, &IID_IUnknown, &V_UNKNOWN(pvar));
#else
            Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IUnknown, &V_UNKNOWN(pvar));
#endif
            break;
        case VT_UNKNOWN | VT_BYREF:
#ifdef __REACTOS__
            Pos = interface_user_unmarshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWNREF(pvar));
#else
            Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWNREF(pvar));
#endif
            break;
        case VT_DISPATCH:
#ifdef __REACTOS__
            Pos = interface_user_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)&V_DISPATCH(pvar));
#else
            Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)&V_DISPATCH(pvar));
#endif
            break;
        case VT_DISPATCH | VT_BYREF:
#ifdef __REACTOS__
            Pos = interface_user_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)V_DISPATCHREF(pvar));
#else
            Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)V_DISPATCHREF(pvar));
#endif
            break;
        case VT_RECORD:
            FIXME("handle BRECORD by val\n");
            break;
        case VT_RECORD | VT_BYREF:
            FIXME("handle BRECORD by ref\n");
            break;
        }
    }
    return Pos;
}

Referenced by LPSAFEARRAY_UserUnmarshal(), test_marshal_VARIANT(), and VARIANT_UserUnmarshal().

WdtpInterfacePointer_UserMarshal()

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

Definition at line 1550 of file usrmarshal.c.

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

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

WdtpInterfacePointer_UserUnmarshal()

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

Definition at line 1607 of file usrmarshal.c.

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

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)

wire_extra_user_size()

static ULONG wire_extra_user_size ( ULONG *  pFlags, ULONG  Start, VARIANT *  pvar  )

static

Definition at line 297 of file usrmarshal.c.

{
  if (V_ISARRAY(pvar))
  {
    if (V_ISBYREF(pvar))
      return LPSAFEARRAY_UserSize(pFlags, Start, V_ARRAYREF(pvar));
    else 
      return LPSAFEARRAY_UserSize(pFlags, Start, &V_ARRAY(pvar));
  }
 
  switch (V_VT(pvar)) {
  case VT_BSTR:
    return BSTR_UserSize(pFlags, Start, &V_BSTR(pvar));
  case VT_BSTR | VT_BYREF:
    return BSTR_UserSize(pFlags, Start, V_BSTRREF(pvar));
  case VT_VARIANT | VT_BYREF:
    return VARIANT_UserSize(pFlags, Start, V_VARIANTREF(pvar));
  case VT_UNKNOWN:
#ifdef __REACTOS__
    return interface_user_size(pFlags, Start, &IID_IUnknown, V_UNKNOWN(pvar));
#else
    return Start + interface_variant_size(pFlags, &IID_IUnknown, V_UNKNOWN(pvar));
#endif
  case VT_UNKNOWN | VT_BYREF:
#ifdef __REACTOS__
    return interface_user_size(pFlags, Start, &IID_IUnknown, *V_UNKNOWNREF(pvar));
#else
    return Start + interface_variant_size(pFlags, &IID_IUnknown, *V_UNKNOWNREF(pvar));
#endif
  case VT_DISPATCH:
#ifdef __REACTOS__
    return interface_user_size(pFlags, Start, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
#else
    return Start + interface_variant_size(pFlags, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
#endif
  case VT_DISPATCH | VT_BYREF:
#ifdef __REACTOS__
    return interface_user_size(pFlags, Start, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
#else
    return Start + interface_variant_size(pFlags, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
#endif
  case VT_RECORD:
    FIXME("wire-size record\n");
    return Start;
  case VT_SAFEARRAY:
  case VT_SAFEARRAY | VT_BYREF:
    FIXME("wire-size safearray: shouldn't be marshaling this\n");
    return Start;
  default:
    return Start;
  }
}

Referenced by VARIANT_UserSize().