https://git.reactos.org/?p=reactos.git;a=commitdiff;h=b6fdb56b9adf780902cc9c...
commit b6fdb56b9adf780902cc9cf65af1f76365a96ce4 Author: Amine Khaldi amine.khaldi@reactos.org AuthorDate: Wed Jan 30 12:31:33 2019 +0100 Commit: Amine Khaldi amine.khaldi@reactos.org CommitDate: Wed Jan 30 12:31:33 2019 +0100
[RPCRT4] Sync with Wine Staging 4.0. CORE-15682 --- dll/win32/rpcrt4/CMakeLists.txt | 27 +- dll/win32/rpcrt4/cproxy.c | 118 +-- dll/win32/rpcrt4/cpsf.c | 2 +- dll/win32/rpcrt4/cpsf.h | 30 + dll/win32/rpcrt4/cstub.c | 25 +- dll/win32/rpcrt4/ndr_contexthandle.c | 2 - dll/win32/rpcrt4/ndr_es.c | 15 +- dll/win32/rpcrt4/ndr_marshall.c | 1574 +++++++++++++++++----------------- dll/win32/rpcrt4/ndr_ole.c | 16 +- dll/win32/rpcrt4/ndr_stubless.c | 304 ++++--- dll/win32/rpcrt4/ndr_stubless.h | 16 +- dll/win32/rpcrt4/ndr_typelib.c | 1207 ++++++++++++++++++++++++++ dll/win32/rpcrt4/ndr_types.idl | 30 + dll/win32/rpcrt4/rpc_assoc.c | 23 +- dll/win32/rpcrt4/rpc_assoc.h | 4 +- dll/win32/rpcrt4/rpc_binding.c | 4 +- dll/win32/rpcrt4/rpc_binding.h | 3 +- dll/win32/rpcrt4/rpc_epmap.c | 4 +- dll/win32/rpcrt4/rpc_message.c | 48 +- dll/win32/rpcrt4/rpc_transport.c | 82 +- dll/win32/rpcrt4/rpcrt4.spec | 2 +- dll/win32/rpcrt4/rpcrt4_main.c | 3 +- media/doc/README.WINE | 2 +- 23 files changed, 2457 insertions(+), 1084 deletions(-)
diff --git a/dll/win32/rpcrt4/CMakeLists.txt b/dll/win32/rpcrt4/CMakeLists.txt index 9d642696f0..212231a3a2 100644 --- a/dll/win32/rpcrt4/CMakeLists.txt +++ b/dll/win32/rpcrt4/CMakeLists.txt @@ -2,9 +2,21 @@ remove_definitions(-D_WIN32_WINNT=0x502) add_definitions(-D_WIN32_WINNT=0x600)
+add_definitions( + -D__WINESRC__ + -D_RPCRT4_ + -DCOM_NO_WINDOWS_H + -DMSWMSG) + include_directories(BEFORE ${REACTOS_SOURCE_DIR}/sdk/include/reactos/wine) spec2def(rpcrt4.dll rpcrt4.spec ADD_IMPORTLIB) + add_rpc_files(client epm.idl) +add_idl_headers(ndr_types_header ndr_types.idl) + +set(IDL_FLAGS ${IDL_FLAGS} -Oicf) +add_rpcproxy_files(ndr_types.idl) +unset(IDL_FLAGS)
list(APPEND SOURCE cproxy.c @@ -29,21 +41,15 @@ list(APPEND SOURCE precomp.h ${CMAKE_CURRENT_BINARY_DIR}/epm_c.c)
-remove_definitions(-D_WIN32_WINNT=0x502) -add_definitions(-D_WIN32_WINNT=0x600) - -add_definitions( - -D__WINESRC__ - -D_RPCRT4_ - -DCOM_NO_WINDOWS_H - -DMSWMSG) - if(MSVC AND NOT ARCH STREQUAL "arm") add_asm_files(rpcrt4_asm msvc.S) endif()
add_library(rpcrt4 SHARED ${SOURCE} + ndr_typelib.c + ${CMAKE_CURRENT_BINARY_DIR}/ndr_types_p.c + ${CMAKE_CURRENT_BINARY_DIR}/proxy.dlldata.c ${rpcrt4_asm} rpcrt4.rc ${CMAKE_CURRENT_BINARY_DIR}/rpcrt4_stubs.c @@ -51,7 +57,8 @@ add_library(rpcrt4 SHARED
set_module_type(rpcrt4 win32dll) target_link_libraries(rpcrt4 wine uuid ${PSEH_LIB}) -add_delay_importlibs(rpcrt4 iphlpapi wininet secur32 user32) +add_delay_importlibs(rpcrt4 iphlpapi wininet secur32 user32 oleaut32) add_importlibs(rpcrt4 advapi32 advapi32_vista kernel32_vista ws2_32 msvcrt kernel32 ntdll) +add_dependencies(rpcrt4 ndr_types_header) add_pch(rpcrt4 precomp.h SOURCE) add_cd_file(TARGET rpcrt4 DESTINATION reactos/system32 FOR all) diff --git a/dll/win32/rpcrt4/cproxy.c b/dll/win32/rpcrt4/cproxy.c index 4f5b4f2b1c..56ef84d273 100644 --- a/dll/win32/rpcrt4/cproxy.c +++ b/dll/win32/rpcrt4/cproxy.c @@ -17,8 +17,6 @@ * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA - * - * TODO: Handle non-i386 architectures */
#include "config.h" @@ -42,21 +40,6 @@
WINE_DEFAULT_DEBUG_CHANNEL(ole);
-/* I don't know what MS's std proxy structure looks like, - so this probably doesn't match, but that shouldn't matter */ -typedef struct { - IRpcProxyBuffer IRpcProxyBuffer_iface; - LPVOID *PVtbl; - LONG RefCount; - const IID* piid; - LPUNKNOWN pUnkOuter; - IUnknown *base_object; /* must be at offset 0x10 from PVtbl */ - IRpcProxyBuffer *base_proxy; - PCInterfaceName name; - LPPSFACTORYBUFFER pPSFactory; - LPRPCCHANNELBUFFER pChannel; -} StdProxyImpl; - static const IRpcProxyBufferVtbl StdProxy_Vtbl;
static inline StdProxyImpl *impl_from_IRpcProxyBuffer(IRpcProxyBuffer *iface) @@ -79,7 +62,10 @@ __ASM_GLOBAL_FUNC(call_stubless_func, "movl 8(%ecx),%edx\n\t" /* info->FormatStringOffset */ "movzwl (%edx,%eax,2),%edx\n\t" /* FormatStringOffset[index] */ "addl 4(%ecx),%edx\n\t" /* info->ProcFormatString + offset */ - "movzwl 8(%edx),%eax\n\t" /* arguments size */ + "movzbl 1(%edx),%eax\n\t" /* Oi_flags */ + "andl $0x08,%eax\n\t" /* Oi_HAS_RPCFLAGS */ + "shrl $1,%eax\n\t" + "movzwl 4(%edx,%eax),%eax\n\t" /* arguments size */ "pushl %eax\n\t" __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t") "leal 8(%esp),%eax\n\t" /* &This */ @@ -171,24 +157,43 @@ static inline void init_thunk( struct thunk *thunk, unsigned int index )
extern void call_stubless_func(void); __ASM_GLOBAL_FUNC(call_stubless_func, - "DCD 0xDEFC\n\t" // _assertfail - "" ); + "push {r0-r3}\n\t" + "mov r2, sp\n\t" /* stack_top */ + "push {fp,lr}\n\t" + "mov fp, sp\n\t" + "ldr r0, [r0]\n\t" /* This->lpVtbl */ + "ldr r0, [r0,#-8]\n\t" /* MIDL_STUBLESS_PROXY_INFO */ + "ldr r1, [r0,#8]\n\t" /* info->FormatStringOffset */ + "ldrh r1, [r1,ip]\n\t" /* info->FormatStringOffset[index] */ + "ldr ip, [r0,#4]\n\t" /* info->ProcFormatString */ + "add r1, ip\n\t" /* info->ProcFormatString + offset */ + "ldr r0, [r0]\n\t" /* info->pStubDesc */ +#ifdef __SOFTFP__ + "mov r3, #0\n\t" +#else + "vpush {s0-s15}\n\t" /* store the s0-s15/d0-d7 arguments */ + "mov r3, sp\n\t" /* fpu_stack */ +#endif + "bl " __ASM_NAME("ndr_client_call") "\n\t" + "mov sp, fp\n\t" + "pop {fp,lr}\n\t" + "add sp, #16\n\t" + "bx lr" );
-#include "pshpack1.h" struct thunk { - DWORD assertfail; -}; -#include "poppack.h" - -static const struct thunk thunk_template = -{ - { 0xDEFC } /* _assertfail */ + DWORD ldr_ip; /* ldr ip,[pc] */ + DWORD ldr_pc; /* ldr pc,[pc] */ + DWORD index; + void *func; };
static inline void init_thunk( struct thunk *thunk, unsigned int index ) { - *thunk = thunk_template; + thunk->ldr_ip = 0xe59fc000; /* ldr ip,[pc] */ + thunk->ldr_pc = 0xe59ff000; /* ldr pc,[pc] */ + thunk->index = index * sizeof(unsigned short); + thunk->func = call_stubless_func; }
#else /* __i386__ */ @@ -233,7 +238,7 @@ static const struct thunk *allocate_block( unsigned int num ) return block; }
-static BOOL fill_stubless_table( IUnknownVtbl *vtbl, DWORD num ) +BOOL fill_stubless_table( IUnknownVtbl *vtbl, DWORD num ) { const void **entry = (const void **)(vtbl + 1); DWORD i, j; @@ -317,9 +322,7 @@ HRESULT StdProxy_Construct(REFIID riid, return S_OK; }
-static HRESULT WINAPI StdProxy_QueryInterface(LPRPCPROXYBUFFER iface, - REFIID riid, - LPVOID *obj) +HRESULT WINAPI StdProxy_QueryInterface(IRpcProxyBuffer *iface, REFIID riid, void **obj) { StdProxyImpl *This = impl_from_IRpcProxyBuffer(iface); TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(riid),obj); @@ -340,7 +343,7 @@ static HRESULT WINAPI StdProxy_QueryInterface(LPRPCPROXYBUFFER iface, return E_NOINTERFACE; }
-static ULONG WINAPI StdProxy_AddRef(LPRPCPROXYBUFFER iface) +ULONG WINAPI StdProxy_AddRef(IRpcProxyBuffer *iface) { StdProxyImpl *This = impl_from_IRpcProxyBuffer(iface); TRACE("(%p)->AddRef()\n",This); @@ -370,8 +373,7 @@ static ULONG WINAPI StdProxy_Release(LPRPCPROXYBUFFER iface) return refs; }
-static HRESULT WINAPI StdProxy_Connect(LPRPCPROXYBUFFER iface, - LPRPCCHANNELBUFFER pChannel) +HRESULT WINAPI StdProxy_Connect(IRpcProxyBuffer *iface, IRpcChannelBuffer *pChannel) { StdProxyImpl *This = impl_from_IRpcProxyBuffer(iface); TRACE("(%p)->Connect(%p)\n",This,pChannel); @@ -382,7 +384,7 @@ static HRESULT WINAPI StdProxy_Connect(LPRPCPROXYBUFFER iface, return S_OK; }
-static VOID WINAPI StdProxy_Disconnect(LPRPCPROXYBUFFER iface) +void WINAPI StdProxy_Disconnect(IRpcProxyBuffer *iface) { StdProxyImpl *This = impl_from_IRpcProxyBuffer(iface); TRACE("(%p)->Disconnect()\n",This); @@ -551,45 +553,3 @@ HRESULT WINAPI NdrProxyErrorHandler(DWORD dwExceptionCode) else return HRESULT_FROM_WIN32(dwExceptionCode); } - -HRESULT WINAPI -CreateProxyFromTypeInfo( LPTYPEINFO pTypeInfo, LPUNKNOWN pUnkOuter, REFIID riid, - LPRPCPROXYBUFFER *ppProxy, LPVOID *ppv ) -{ - typedef INT (WINAPI *MessageBoxA)(HWND,LPCSTR,LPCSTR,UINT); - HMODULE hUser32 = LoadLibraryA("user32"); - MessageBoxA pMessageBoxA = (void *)GetProcAddress(hUser32, "MessageBoxA"); - - FIXME("%p %p %s %p %p\n", pTypeInfo, pUnkOuter, debugstr_guid(riid), ppProxy, ppv); - if (pMessageBoxA) - { - pMessageBoxA(NULL, - "The native implementation of OLEAUT32.DLL cannot be used " - "with Wine's RPCRT4.DLL. Remove OLEAUT32.DLL and try again.\n", - "Wine: Unimplemented CreateProxyFromTypeInfo", - 0x10); - ExitProcess(1); - } - return E_NOTIMPL; -} - -HRESULT WINAPI -CreateStubFromTypeInfo(ITypeInfo *pTypeInfo, REFIID riid, IUnknown *pUnkServer, - IRpcStubBuffer **ppStub ) -{ - typedef INT (WINAPI *MessageBoxA)(HWND,LPCSTR,LPCSTR,UINT); - HMODULE hUser32 = LoadLibraryA("user32"); - MessageBoxA pMessageBoxA = (void *)GetProcAddress(hUser32, "MessageBoxA"); - - FIXME("%p %s %p %p\n", pTypeInfo, debugstr_guid(riid), pUnkServer, ppStub); - if (pMessageBoxA) - { - pMessageBoxA(NULL, - "The native implementation of OLEAUT32.DLL cannot be used " - "with Wine's RPCRT4.DLL. Remove OLEAUT32.DLL and try again.\n", - "Wine: Unimplemented CreateProxyFromTypeInfo", - 0x10); - ExitProcess(1); - } - return E_NOTIMPL; -} diff --git a/dll/win32/rpcrt4/cpsf.c b/dll/win32/rpcrt4/cpsf.c index 9375c40fa4..e92d226498 100644 --- a/dll/win32/rpcrt4/cpsf.c +++ b/dll/win32/rpcrt4/cpsf.c @@ -279,7 +279,7 @@ HRESULT WINAPI NdrDllRegisterProxy(HMODULE hDll, /* register clsid to point to module */ strcpyW( keyname, clsidW ); strcatW( keyname, clsid ); - len = GetModuleFileNameW(hDll, module, sizeof(module)/sizeof(WCHAR)); + len = GetModuleFileNameW(hDll, module, ARRAY_SIZE(module)); if (len && len < sizeof(module)) { TRACE("registering CLSID %s => %s\n", debugstr_w(clsid), debugstr_w(module)); if (RegCreateKeyW(HKEY_CLASSES_ROOT, keyname, &key) == ERROR_SUCCESS) { diff --git a/dll/win32/rpcrt4/cpsf.h b/dll/win32/rpcrt4/cpsf.h index 964fb4551f..3cfbf77ff6 100644 --- a/dll/win32/rpcrt4/cpsf.h +++ b/dll/win32/rpcrt4/cpsf.h @@ -21,9 +21,36 @@ #ifndef __WINE_CPSF_H #define __WINE_CPSF_H
+typedef struct +{ + IRpcProxyBuffer IRpcProxyBuffer_iface; + void **PVtbl; + LONG RefCount; + const IID *piid; + IUnknown *pUnkOuter; + /* offset of base_object from PVtbl must match assembly thunks; see + * fill_delegated_proxy_table() */ + IUnknown *base_object; + IRpcProxyBuffer *base_proxy; + PCInterfaceName name; + IPSFactoryBuffer *pPSFactory; + IRpcChannelBuffer *pChannel; +} StdProxyImpl; + +typedef struct +{ + IUnknownVtbl *base_obj; + IRpcStubBuffer *base_stub; + CStdStubBuffer stub_buffer; +} cstdstubbuffer_delegating_t; + HRESULT StdProxy_Construct(REFIID riid, LPUNKNOWN pUnkOuter, const ProxyFileInfo *ProxyInfo, int Index, LPPSFACTORYBUFFER pPSFactory, LPRPCPROXYBUFFER *ppProxy, LPVOID *ppvObj) DECLSPEC_HIDDEN; +HRESULT WINAPI StdProxy_QueryInterface(IRpcProxyBuffer *iface, REFIID iid, void **obj) DECLSPEC_HIDDEN; +ULONG WINAPI StdProxy_AddRef(IRpcProxyBuffer *iface) DECLSPEC_HIDDEN; +HRESULT WINAPI StdProxy_Connect(IRpcProxyBuffer *iface, IRpcChannelBuffer *channel) DECLSPEC_HIDDEN; +void WINAPI StdProxy_Disconnect(IRpcProxyBuffer *iface) DECLSPEC_HIDDEN;
HRESULT CStdStubBuffer_Construct(REFIID riid, LPUNKNOWN pUnkServer, PCInterfaceName name, CInterfaceStubVtbl *vtbl, LPPSFACTORYBUFFER pPSFactory, @@ -41,5 +68,8 @@ extern const IRpcStubBufferVtbl CStdStubBuffer_Delegating_Vtbl DECLSPEC_HIDDEN; BOOL fill_delegated_proxy_table(IUnknownVtbl *vtbl, DWORD num) DECLSPEC_HIDDEN; HRESULT create_proxy(REFIID iid, IUnknown *pUnkOuter, IRpcProxyBuffer **pproxy, void **ppv) DECLSPEC_HIDDEN; HRESULT create_stub(REFIID iid, IUnknown *pUnk, IRpcStubBuffer **ppstub) DECLSPEC_HIDDEN; +BOOL fill_stubless_table(IUnknownVtbl *vtbl, DWORD num) DECLSPEC_HIDDEN; +IUnknownVtbl *get_delegating_vtbl(DWORD num_methods) DECLSPEC_HIDDEN; +void release_delegating_vtbl(IUnknownVtbl *vtbl) DECLSPEC_HIDDEN;
#endif /* __WINE_CPSF_H */ diff --git a/dll/win32/rpcrt4/cstub.c b/dll/win32/rpcrt4/cstub.c index dc279b7534..e33d499b15 100644 --- a/dll/win32/rpcrt4/cstub.c +++ b/dll/win32/rpcrt4/cstub.c @@ -50,13 +50,6 @@ static LONG WINAPI stub_filter(EXCEPTION_POINTERS *eptr) return EXCEPTION_EXECUTE_HANDLER; }
-typedef struct -{ - IUnknownVtbl *base_obj; - IRpcStubBuffer *base_stub; - CStdStubBuffer stub_buffer; -} cstdstubbuffer_delegating_t; - static inline cstdstubbuffer_delegating_t *impl_from_delegating( IRpcStubBuffer *iface ) { return CONTAINING_RECORD((void *)iface, cstdstubbuffer_delegating_t, stub_buffer); @@ -175,11 +168,23 @@ typedef struct static const BYTE opcodes[16] = { 0x48, 0x8b, 0x49, 0x20, 0x48, 0x8b, 0x01, 0xff, 0xa0, 0, 0, 0, 0, 0x48, 0x8d, 0x36 }; #elif defined(__arm__) + +static const DWORD opcodes[] = +{ + 0xe52d4004, /* push {r4} */ + 0xe5900010, /* ldr r0, [r0, #16] */ + 0xe5904000, /* ldr r4, [r0] */ + 0xe59fc008, /* ldr ip, [pc, #8] */ + 0xe08cc004, /* add ip, ip, r4 */ + 0xe49d4004, /* pop {r4} */ + 0xe59cf000 /* ldr pc, [ip] */ +}; + typedef struct { + DWORD opcodes[ARRAY_SIZE(opcodes)]; DWORD offset; } vtbl_method_t; -static const BYTE opcodes[1];
#else
@@ -267,7 +272,7 @@ BOOL fill_delegated_proxy_table(IUnknownVtbl *vtbl, DWORD num) return TRUE; }
-static IUnknownVtbl *get_delegating_vtbl(DWORD num_methods) +IUnknownVtbl *get_delegating_vtbl(DWORD num_methods) { IUnknownVtbl *ret;
@@ -303,7 +308,7 @@ static IUnknownVtbl *get_delegating_vtbl(DWORD num_methods) return ret; }
-static void release_delegating_vtbl(IUnknownVtbl *vtbl) +void release_delegating_vtbl(IUnknownVtbl *vtbl) { ref_counted_vtbl *table = (ref_counted_vtbl*)((DWORD *)vtbl - 1);
diff --git a/dll/win32/rpcrt4/ndr_contexthandle.c b/dll/win32/rpcrt4/ndr_contexthandle.c index 3b262854b7..a5e1ffc253 100644 --- a/dll/win32/rpcrt4/ndr_contexthandle.c +++ b/dll/win32/rpcrt4/ndr_contexthandle.c @@ -23,8 +23,6 @@ #include "rpc_assoc.h" #include "rpcndr.h"
-#include "wine/rpcfc.h" - #include "wine/debug.h" #include "wine/list.h"
diff --git a/dll/win32/rpcrt4/ndr_es.c b/dll/win32/rpcrt4/ndr_es.c index 59ea8166f0..158bc7cda2 100644 --- a/dll/win32/rpcrt4/ndr_es.c +++ b/dll/win32/rpcrt4/ndr_es.c @@ -32,7 +32,6 @@ #include "ndr_stubless.h"
#include "wine/debug.h" -#include "wine/rpcfc.h"
WINE_DEFAULT_DEBUG_CHANNEL(ole);
@@ -424,7 +423,7 @@ void WINAPIV NdrMesProcEncodeDecode(handle_t Handle, const MIDL_STUB_DESC * pStu client_interface = pStubDesc->RpcInterfaceInformation; pEsMsg->InterfaceId = client_interface->InterfaceId;
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS) + if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS) { const NDR_PROC_HEADER_RPC *header_rpc = (const NDR_PROC_HEADER_RPC *)&pFormat[0]; stack_size = header_rpc->stack_size; @@ -438,17 +437,17 @@ void WINAPIV NdrMesProcEncodeDecode(handle_t Handle, const MIDL_STUB_DESC * pStu pFormat += sizeof(NDR_PROC_HEADER); }
- if (pProcHeader->handle_type == RPC_FC_BIND_EXPLICIT) + if (pProcHeader->handle_type == 0) { switch (*pFormat) /* handle_type */ { - case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */ + case FC_BIND_PRIMITIVE: /* explicit primitive */ pFormat += sizeof(NDR_EHD_PRIMITIVE); break; - case RPC_FC_BIND_GENERIC: /* explicit generic */ + case FC_BIND_GENERIC: /* explicit generic */ pFormat += sizeof(NDR_EHD_GENERIC); break; - case RPC_FC_BIND_CONTEXT: /* explicit context */ + case FC_BIND_CONTEXT: /* explicit context */ pFormat += sizeof(NDR_EHD_CONTEXT); break; default: @@ -467,7 +466,7 @@ void WINAPIV NdrMesProcEncodeDecode(handle_t Handle, const MIDL_STUB_DESC * pStu pEsMsg->StubMsg.pfnFree = pStubDesc->pfnFree;
/* create the full pointer translation tables, if requested */ - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR) + if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED) pEsMsg->StubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags); @@ -510,7 +509,7 @@ void WINAPIV NdrMesProcEncodeDecode(handle_t Handle, const MIDL_STUB_DESC * pStu return; } /* free the full pointer translation tables */ - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR) + if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED) NdrFullPointerXlatFree(pEsMsg->StubMsg.FullPtrXlatTables); }
diff --git a/dll/win32/rpcrt4/ndr_marshall.c b/dll/win32/rpcrt4/ndr_marshall.c index 6356fb9d98..77bbf986ff 100644 --- a/dll/win32/rpcrt4/ndr_marshall.c +++ b/dll/win32/rpcrt4/ndr_marshall.c @@ -43,8 +43,6 @@ #include "ndrtypes.h"
#include "wine/unicode.h" -#include "wine/rpcfc.h" - #include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(ole); @@ -110,6 +108,19 @@ static inline void align_pointer_clear( unsigned char **ptr, unsigned int align *ptr = (unsigned char *)(((ULONG_PTR)*ptr + mask) & ~mask); }
+static inline void align_pointer_offset( unsigned char **ptr, unsigned char *base, unsigned int align ) +{ + ULONG_PTR mask = align - 1; + *ptr = base + (((ULONG_PTR)(*ptr - base) + mask) & ~mask); +} + +static inline void align_pointer_offset_clear( unsigned char **ptr, unsigned char *base, unsigned int align ) +{ + ULONG_PTR mask = align - 1; + memset( *ptr, 0, (align - (ULONG_PTR)(*ptr - base)) & mask ); + *ptr = base + (((ULONG_PTR)(*ptr - base) + mask) & ~mask); +} + #define STD_OVERFLOW_CHECK(_Msg) do { \ TRACE("buffer=%d/%d\n", (ULONG)(_Msg->Buffer - (unsigned char *)_Msg->RpcMsg->Buffer), _Msg->BufferLength); \ if (_Msg->Buffer > (unsigned char *)_Msg->RpcMsg->Buffer + _Msg->BufferLength) \ @@ -438,6 +449,13 @@ void * WINAPI NdrAllocate(MIDL_STUB_MESSAGE *pStubMsg, SIZE_T len) return p; }
+static void *NdrAllocateZero(MIDL_STUB_MESSAGE *stubmsg, SIZE_T len) +{ + void *mem = NdrAllocate(stubmsg, len); + memset(mem, 0, len); + return mem; +} + static void NdrFree(MIDL_STUB_MESSAGE *pStubMsg, unsigned char *Pointer) { TRACE("(%p, %p)\n", pStubMsg, Pointer); @@ -554,15 +572,15 @@ PFORMAT_STRING ComputeConformanceOrVariance( }
switch (pFormat[0] & 0xf0) { - case RPC_FC_NORMAL_CONFORMANCE: + case FC_NORMAL_CONFORMANCE: TRACE("normal conformance, ofs=%d\n", ofs); ptr = pMemory; break; - case RPC_FC_POINTER_CONFORMANCE: + case FC_POINTER_CONFORMANCE: TRACE("pointer conformance, ofs=%d\n", ofs); ptr = pStubMsg->Memory; break; - case RPC_FC_TOP_LEVEL_CONFORMANCE: + case FC_TOP_LEVEL_CONFORMANCE: TRACE("toplevel conformance, ofs=%d\n", ofs); if (pStubMsg->StackTop) { ptr = pStubMsg->StackTop; @@ -572,12 +590,12 @@ PFORMAT_STRING ComputeConformanceOrVariance( goto finish_conf; } break; - case RPC_FC_CONSTANT_CONFORMANCE: + case FC_CONSTANT_CONFORMANCE: data = ofs | ((DWORD)pFormat[1] << 16); TRACE("constant conformance, val=%ld\n", data); *pCount = data; goto finish_conf; - case RPC_FC_TOP_LEVEL_MULTID_CONFORMANCE: + case FC_TOP_LEVEL_MULTID_CONFORMANCE: FIXME("toplevel multidimensional conformance, ofs=%d\n", ofs); if (pStubMsg->StackTop) { ptr = pStubMsg->StackTop; @@ -593,10 +611,10 @@ PFORMAT_STRING ComputeConformanceOrVariance( }
switch (pFormat[1]) { - case RPC_FC_DEREFERENCE: + case FC_DEREFERENCE: ptr = *(LPVOID*)((char *)ptr + ofs); break; - case RPC_FC_CALLBACK: + case FC_CALLBACK: { unsigned char *old_stack_top = pStubMsg->StackTop; ULONG_PTR max_count, old_max_count = pStubMsg->MaxCount; @@ -621,25 +639,25 @@ PFORMAT_STRING ComputeConformanceOrVariance( }
switch (dtype) { - case RPC_FC_LONG: - case RPC_FC_ULONG: + case FC_LONG: + case FC_ULONG: data = *(DWORD*)ptr; break; - case RPC_FC_SHORT: + case FC_SHORT: data = *(SHORT*)ptr; break; - case RPC_FC_USHORT: + case FC_USHORT: data = *(USHORT*)ptr; break; - case RPC_FC_CHAR: - case RPC_FC_SMALL: + case FC_CHAR: + case FC_SMALL: data = *(CHAR*)ptr; break; - case RPC_FC_BYTE: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_USMALL: data = *(UCHAR*)ptr; break; - case RPC_FC_HYPER: + case FC_HYPER: data = *(ULONGLONG *)ptr; break; default: @@ -650,20 +668,20 @@ PFORMAT_STRING ComputeConformanceOrVariance(
done_conf_grab: switch (pFormat[1]) { - case RPC_FC_DEREFERENCE: /* already handled */ + case FC_DEREFERENCE: /* already handled */ case 0: /* no op */ *pCount = data; break; - case RPC_FC_ADD_1: + case FC_ADD_1: *pCount = data + 1; break; - case RPC_FC_SUB_1: + case FC_SUB_1: *pCount = data - 1; break; - case RPC_FC_MULT_2: + case FC_MULT_2: *pCount = data * 2; break; - case RPC_FC_DIV_2: + case FC_DIV_2: *pCount = data / 2; break; default: @@ -779,16 +797,16 @@ static void validate_string_data(MIDL_STUB_MESSAGE *pStubMsg, ULONG bufsize, ULO
static inline void dump_pointer_attr(unsigned char attr) { - if (attr & RPC_FC_P_ALLOCALLNODES) - TRACE(" RPC_FC_P_ALLOCALLNODES"); - if (attr & RPC_FC_P_DONTFREE) - TRACE(" RPC_FC_P_DONTFREE"); - if (attr & RPC_FC_P_ONSTACK) - TRACE(" RPC_FC_P_ONSTACK"); - if (attr & RPC_FC_P_SIMPLEPOINTER) - TRACE(" RPC_FC_P_SIMPLEPOINTER"); - if (attr & RPC_FC_P_DEREF) - TRACE(" RPC_FC_P_DEREF"); + if (attr & FC_ALLOCATE_ALL_NODES) + TRACE(" FC_ALLOCATE_ALL_NODES"); + if (attr & FC_DONT_FREE) + TRACE(" FC_DONT_FREE"); + if (attr & FC_ALLOCED_ON_STACK) + TRACE(" FC_ALLOCED_ON_STACK"); + if (attr & FC_SIMPLE_POINTER) + TRACE(" FC_SIMPLE_POINTER"); + if (attr & FC_POINTER_DEREF) + TRACE(" FC_POINTER_DEREF"); TRACE("\n"); }
@@ -809,11 +827,11 @@ static void PointerMarshall(PMIDL_STUB_MESSAGE pStubMsg, TRACE("(%p,%p,%p,%p)\n", pStubMsg, Buffer, Pointer, pFormat); TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr); pFormat += 2; - if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat; + if (attr & FC_SIMPLE_POINTER) desc = pFormat; else desc = pFormat + *(const SHORT*)pFormat;
switch (type) { - case RPC_FC_RP: /* ref pointer (always non-null) */ + case FC_RP: /* ref pointer (always non-null) */ if (!Pointer) { ERR("NULL ref pointer is not allowed\n"); @@ -821,8 +839,8 @@ static void PointerMarshall(PMIDL_STUB_MESSAGE pStubMsg, } pointer_needs_marshaling = TRUE; break; - case RPC_FC_UP: /* unique pointer */ - case RPC_FC_OP: /* object pointer - same as unique here */ + case FC_UP: /* unique pointer */ + case FC_OP: /* object pointer - same as unique here */ if (Pointer) pointer_needs_marshaling = TRUE; else @@ -831,7 +849,7 @@ static void PointerMarshall(PMIDL_STUB_MESSAGE pStubMsg, TRACE("writing 0x%08x to buffer\n", pointer_id); NDR_LOCAL_UINT32_WRITE(Buffer, pointer_id); break; - case RPC_FC_FP: + case FC_FP: pointer_needs_marshaling = !NdrFullPointerQueryPointer( pStubMsg->FullPtrXlatTables, Pointer, 1, &pointer_id); TRACE("writing 0x%08x to buffer\n", pointer_id); @@ -846,7 +864,7 @@ static void PointerMarshall(PMIDL_STUB_MESSAGE pStubMsg, TRACE("calling marshaller for type 0x%x\n", (int)*desc);
if (pointer_needs_marshaling) { - if (attr & RPC_FC_P_DEREF) { + if (attr & FC_POINTER_DEREF) { Pointer = *(unsigned char**)Pointer; TRACE("deref => %p\n", Pointer); } @@ -858,9 +876,13 @@ static void PointerMarshall(PMIDL_STUB_MESSAGE pStubMsg, STD_OVERFLOW_CHECK(pStubMsg); }
-/*********************************************************************** - * PointerUnmarshall [internal] - */ +/* pPointer is the pointer that we will unmarshal into; pSrcPointer is the + * pointer to memory which we may attempt to reuse if non-NULL. Usually these + * are the same; for the case when they aren't, see EmbeddedPointerUnmarshall(). + * + * fMustAlloc seems to determine whether we can allocate from the buffer (if we + * are on the server side). It's ignored here, since we can't allocate a pointer + * from the buffer. */ static void PointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *Buffer, unsigned char **pPointer, @@ -872,19 +894,19 @@ static void PointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING desc; NDR_UNMARSHALL m; DWORD pointer_id = 0; - BOOL pointer_needs_unmarshaling; + BOOL pointer_needs_unmarshaling, need_alloc = FALSE, inner_must_alloc = FALSE;
TRACE("(%p,%p,%p,%p,%p,%d)\n", pStubMsg, Buffer, pPointer, pSrcPointer, pFormat, fMustAlloc); TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr); pFormat += 2; - if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat; + if (attr & FC_SIMPLE_POINTER) desc = pFormat; else desc = pFormat + *(const SHORT*)pFormat;
switch (type) { - case RPC_FC_RP: /* ref pointer (always non-null) */ + case FC_RP: /* ref pointer (always non-null) */ pointer_needs_unmarshaling = TRUE; break; - case RPC_FC_UP: /* unique pointer */ + case FC_UP: /* unique pointer */ pointer_id = NDR_LOCAL_UINT32_READ(Buffer); TRACE("pointer_id is 0x%08x\n", pointer_id); if (pointer_id) @@ -894,14 +916,16 @@ static void PointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, pointer_needs_unmarshaling = FALSE; } break; - case RPC_FC_OP: /* object pointer - we must free data before overwriting it */ + case FC_OP: /* object pointer - we must free data before overwriting it */ pointer_id = NDR_LOCAL_UINT32_READ(Buffer); TRACE("pointer_id is 0x%08x\n", pointer_id); - if (!fMustAlloc && pSrcPointer) - { + + /* An object pointer always allocates new memory (it cannot point to the + * buffer). */ + inner_must_alloc = TRUE; + + if (pSrcPointer) FIXME("free object pointer %p\n", pSrcPointer); - fMustAlloc = TRUE; - } if (pointer_id) pointer_needs_unmarshaling = TRUE; else @@ -910,7 +934,7 @@ static void PointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, pointer_needs_unmarshaling = FALSE; } break; - case RPC_FC_FP: + case FC_FP: pointer_id = NDR_LOCAL_UINT32_READ(Buffer); TRACE("pointer_id is 0x%08x\n", pointer_id); pointer_needs_unmarshaling = !NdrFullPointerQueryRefId( @@ -926,50 +950,51 @@ static void PointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char **current_ptr = pPointer; if (pStubMsg->IsClient) { TRACE("client\n"); - /* if we aren't forcing allocation of memory then try to use the existing - * (source) pointer to unmarshall the data into so that [in,out] - * parameters behave correctly. it doesn't matter if the parameter is - * [out] only since in that case the pointer will be NULL. we force - * allocation when the source pointer is NULL here instead of in the type - * unmarshalling routine for the benefit of the deref code below */ - if (!fMustAlloc) { - if (pSrcPointer) { - TRACE("setting *pPointer to %p\n", pSrcPointer); - *pPointer = pSrcPointer; - } else - fMustAlloc = TRUE; + /* Try to use the existing (source) pointer to unmarshall the data into + * so that [in, out] or [out, ref] parameters behave correctly. If the + * source pointer is NULL and we are not dereferencing, we must force the + * inner marshalling routine to allocate, since otherwise it will crash. */ + if (pSrcPointer) + { + TRACE("setting *pPointer to %p\n", pSrcPointer); + *pPointer = pSrcPointer; } + else + need_alloc = inner_must_alloc = TRUE; } else { TRACE("server\n"); - /* the memory in a stub is never initialised, so we have to work out here - * whether we have to initialise it so we can use the optimisation of - * setting the pointer to the buffer, if possible, or set fMustAlloc to - * TRUE. */ - if (attr & RPC_FC_P_DEREF) { - fMustAlloc = TRUE; - } else { - *current_ptr = NULL; + /* We can use an existing source pointer here only if it is on-stack, + * probably since otherwise NdrPointerFree() might later try to free a + * pointer we don't know the provenance of. Otherwise we must always + * allocate if we are dereferencing. We never need to force the inner + * routine to allocate here, since it will either write into an existing + * pointer, or use a pointer to the buffer. */ + if (attr & FC_POINTER_DEREF) + { + if (pSrcPointer && (attr & FC_ALLOCED_ON_STACK)) + *pPointer = pSrcPointer; + else + need_alloc = TRUE; } + else + *pPointer = NULL; }
- if (attr & RPC_FC_P_ALLOCALLNODES) - FIXME("RPC_FC_P_ALLOCALLNODES not implemented\n"); + if (attr & FC_ALLOCATE_ALL_NODES) + FIXME("FC_ALLOCATE_ALL_NODES not implemented\n"); + + if (attr & FC_POINTER_DEREF) { + if (need_alloc) + *pPointer = NdrAllocateZero(pStubMsg, sizeof(void *));
- if (attr & RPC_FC_P_DEREF) { - if (fMustAlloc) { - unsigned char *base_ptr_val = NdrAllocate(pStubMsg, sizeof(void *)); - *pPointer = base_ptr_val; - current_ptr = (unsigned char **)base_ptr_val; - } else - current_ptr = *(unsigned char***)current_ptr; + current_ptr = *(unsigned char***)current_ptr; TRACE("deref => %p\n", current_ptr); - if (!fMustAlloc && !*current_ptr) fMustAlloc = TRUE; } m = NdrUnmarshaller[*desc & NDR_TABLE_MASK]; - if (m) m(pStubMsg, current_ptr, desc, fMustAlloc); + if (m) m(pStubMsg, current_ptr, desc, inner_must_alloc); else FIXME("no unmarshaller for data type=%02x\n", *desc);
- if (type == RPC_FC_FP) + if (type == FC_FP) NdrFullPointerInsertRefId(pStubMsg->FullPtrXlatTables, pointer_id, *pPointer); } @@ -993,24 +1018,24 @@ static void PointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg, TRACE("(%p,%p,%p)\n", pStubMsg, Pointer, pFormat); TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr); pFormat += 2; - if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat; + if (attr & FC_SIMPLE_POINTER) desc = pFormat; else desc = pFormat + *(const SHORT*)pFormat;
switch (type) { - case RPC_FC_RP: /* ref pointer (always non-null) */ + case FC_RP: /* ref pointer (always non-null) */ if (!Pointer) { ERR("NULL ref pointer is not allowed\n"); RpcRaiseException(RPC_X_NULL_REF_POINTER); } break; - case RPC_FC_OP: - case RPC_FC_UP: + case FC_OP: + case FC_UP: /* NULL pointer has no further representation */ if (!Pointer) return; break; - case RPC_FC_FP: + case FC_FP: pointer_needs_sizing = !NdrFullPointerQueryPointer( pStubMsg->FullPtrXlatTables, Pointer, 0, &pointer_id); if (!pointer_needs_sizing) @@ -1022,7 +1047,7 @@ static void PointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg, return; }
- if (attr & RPC_FC_P_DEREF) { + if (attr & FC_POINTER_DEREF) { Pointer = *(unsigned char**)Pointer; TRACE("deref => %p\n", Pointer); } @@ -1047,15 +1072,15 @@ static ULONG PointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg, TRACE("(%p,%p,%p)\n", pStubMsg, Buffer, pFormat); TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr); pFormat += 2; - if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat; + if (attr & FC_SIMPLE_POINTER) desc = pFormat; else desc = pFormat + *(const SHORT*)pFormat;
switch (type) { - case RPC_FC_RP: /* ref pointer (always non-null) */ + case FC_RP: /* ref pointer (always non-null) */ pointer_needs_sizing = TRUE; break; - case RPC_FC_UP: /* unique pointer */ - case RPC_FC_OP: /* object pointer - we must free data before overwriting it */ + case FC_UP: /* unique pointer */ + case FC_OP: /* object pointer - we must free data before overwriting it */ pointer_id = NDR_LOCAL_UINT32_READ(Buffer); TRACE("pointer_id is 0x%08x\n", pointer_id); if (pointer_id) @@ -1063,7 +1088,7 @@ static ULONG PointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg, else pointer_needs_sizing = FALSE; break; - case RPC_FC_FP: + case FC_FP: { void *pointer; pointer_id = NDR_LOCAL_UINT32_READ(Buffer); @@ -1078,7 +1103,7 @@ static ULONG PointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg, return 0; }
- if (attr & RPC_FC_P_DEREF) { + if (attr & FC_POINTER_DEREF) { align_length(&pStubMsg->MemorySize, sizeof(void*)); pStubMsg->MemorySize += sizeof(void*); TRACE("deref\n"); @@ -1107,21 +1132,21 @@ static void PointerFree(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p)\n", pStubMsg, Pointer, pFormat); TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr); - if (attr & RPC_FC_P_DONTFREE) return; + if (attr & FC_DONT_FREE) return; pFormat += 2; - if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat; + if (attr & FC_SIMPLE_POINTER) desc = pFormat; else desc = pFormat + *(const SHORT*)pFormat;
if (!Pointer) return;
- if (type == RPC_FC_FP) { + if (type == FC_FP) { int pointer_needs_freeing = NdrFullPointerFree( pStubMsg->FullPtrXlatTables, Pointer); if (!pointer_needs_freeing) return; }
- if (attr & RPC_FC_P_DEREF) { + if (attr & FC_POINTER_DEREF) { current_pointer = *(unsigned char**)Pointer; TRACE("deref => %p\n", current_pointer); } @@ -1138,7 +1163,7 @@ static void PointerFree(PMIDL_STUB_MESSAGE pStubMsg, if (Pointer >= pStubMsg->BufferStart && Pointer <= pStubMsg->BufferEnd) goto notfree;
- if (attr & RPC_FC_P_ONSTACK) { + if (attr & FC_ALLOCED_ON_STACK) { TRACE("not freeing stack ptr %p\n", Pointer); return; } @@ -1163,7 +1188,7 @@ static unsigned char * EmbeddedPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- if (*pFormat != RPC_FC_PP) return NULL; + if (*pFormat != FC_PP) return NULL; pFormat += 2;
if (pStubMsg->PointerBufferMark) @@ -1173,25 +1198,25 @@ static unsigned char * EmbeddedPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->PointerBufferMark = NULL; }
- while (pFormat[0] != RPC_FC_END) { + while (pFormat[0] != FC_END) { switch (pFormat[0]) { default: FIXME("unknown repeat type %d; assuming no repeat\n", pFormat[0]); /* fallthrough */ - case RPC_FC_NO_REPEAT: + case FC_NO_REPEAT: rep = 1; stride = 0; count = 1; pFormat += 2; break; - case RPC_FC_FIXED_REPEAT: + case FC_FIXED_REPEAT: rep = *(const WORD*)&pFormat[2]; stride = *(const WORD*)&pFormat[4]; count = *(const WORD*)&pFormat[8]; pFormat += 10; break; - case RPC_FC_VARIABLE_REPEAT: - rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount; + case FC_VARIABLE_REPEAT: + rep = (pFormat[1] == FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount; stride = *(const WORD*)&pFormat[2]; count = *(const WORD*)&pFormat[6]; pFormat += 8; @@ -1227,9 +1252,14 @@ static unsigned char * EmbeddedPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg, return NULL; }
-/*********************************************************************** - * EmbeddedPointerUnmarshall - */ +/* rpcrt4 does something bizarre with embedded pointers: instead of copying the + * struct/array/union from the buffer to memory and then unmarshalling pointers + * into it, it unmarshals pointers into the buffer itself and then copies it to + * memory. However, it will still attempt to use a user-supplied pointer where + * appropriate (i.e. one on stack). Therefore we need to pass both pointers to + * this function and to PointerUnmarshall: the pointer (to the buffer) that we + * will actually unmarshal into (pDstBuffer), and the pointer (to memory) that + * we will attempt to use for storage if possible (pSrcMemoryPtrs). */ static unsigned char * EmbeddedPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pDstBuffer, unsigned char *pSrcMemoryPtrs, @@ -1243,7 +1273,7 @@ static unsigned char * EmbeddedPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p,%p,%d)\n", pStubMsg, pDstBuffer, pSrcMemoryPtrs, pFormat, fMustAlloc);
- if (*pFormat != RPC_FC_PP) return NULL; + if (*pFormat != FC_PP) return NULL; pFormat += 2;
if (pStubMsg->PointerBufferMark) @@ -1253,26 +1283,26 @@ static unsigned char * EmbeddedPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->PointerBufferMark = NULL; }
- while (pFormat[0] != RPC_FC_END) { + while (pFormat[0] != FC_END) { TRACE("pFormat[0] = 0x%x\n", pFormat[0]); switch (pFormat[0]) { default: FIXME("unknown repeat type %d; assuming no repeat\n", pFormat[0]); /* fallthrough */ - case RPC_FC_NO_REPEAT: + case FC_NO_REPEAT: rep = 1; stride = 0; count = 1; pFormat += 2; break; - case RPC_FC_FIXED_REPEAT: + case FC_FIXED_REPEAT: rep = *(const WORD*)&pFormat[2]; stride = *(const WORD*)&pFormat[4]; count = *(const WORD*)&pFormat[8]; pFormat += 10; break; - case RPC_FC_VARIABLE_REPEAT: - rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount; + case FC_VARIABLE_REPEAT: + rep = (pFormat[1] == FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount; stride = *(const WORD*)&pFormat[2]; count = *(const WORD*)&pFormat[6]; pFormat += 8; @@ -1319,7 +1349,7 @@ static void EmbeddedPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
if (pStubMsg->IgnoreEmbeddedPointers) return;
- if (*pFormat != RPC_FC_PP) return; + if (*pFormat != FC_PP) return; pFormat += 2;
if (pStubMsg->PointerLength) @@ -1329,25 +1359,25 @@ static void EmbeddedPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->PointerLength = 0; }
- while (pFormat[0] != RPC_FC_END) { + while (pFormat[0] != FC_END) { switch (pFormat[0]) { default: FIXME("unknown repeat type %d; assuming no repeat\n", pFormat[0]); /* fallthrough */ - case RPC_FC_NO_REPEAT: + case FC_NO_REPEAT: rep = 1; stride = 0; count = 1; pFormat += 2; break; - case RPC_FC_FIXED_REPEAT: + case FC_FIXED_REPEAT: rep = *(const WORD*)&pFormat[2]; stride = *(const WORD*)&pFormat[4]; count = *(const WORD*)&pFormat[8]; pFormat += 10; break; - case RPC_FC_VARIABLE_REPEAT: - rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount; + case FC_VARIABLE_REPEAT: + rep = (pFormat[1] == FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount; stride = *(const WORD*)&pFormat[2]; count = *(const WORD*)&pFormat[6]; pFormat += 8; @@ -1399,28 +1429,28 @@ static ULONG EmbeddedPointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->PointerBufferMark = NULL; }
- if (*pFormat != RPC_FC_PP) return 0; + if (*pFormat != FC_PP) return 0; pFormat += 2;
- while (pFormat[0] != RPC_FC_END) { + while (pFormat[0] != FC_END) { switch (pFormat[0]) { default: FIXME("unknown repeat type %d; assuming no repeat\n", pFormat[0]); /* fallthrough */ - case RPC_FC_NO_REPEAT: + case FC_NO_REPEAT: rep = 1; stride = 0; count = 1; pFormat += 2; break; - case RPC_FC_FIXED_REPEAT: + case FC_FIXED_REPEAT: rep = *(const WORD*)&pFormat[2]; stride = *(const WORD*)&pFormat[4]; count = *(const WORD*)&pFormat[8]; pFormat += 10; break; - case RPC_FC_VARIABLE_REPEAT: - rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount; + case FC_VARIABLE_REPEAT: + rep = (pFormat[1] == FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount; stride = *(const WORD*)&pFormat[2]; count = *(const WORD*)&pFormat[6]; pFormat += 8; @@ -1458,28 +1488,28 @@ static void EmbeddedPointerFree(PMIDL_STUB_MESSAGE pStubMsg, unsigned i;
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat); - if (*pFormat != RPC_FC_PP) return; + if (*pFormat != FC_PP) return; pFormat += 2;
- while (pFormat[0] != RPC_FC_END) { + while (pFormat[0] != FC_END) { switch (pFormat[0]) { default: FIXME("unknown repeat type %d; assuming no repeat\n", pFormat[0]); /* fallthrough */ - case RPC_FC_NO_REPEAT: + case FC_NO_REPEAT: rep = 1; stride = 0; count = 1; pFormat += 2; break; - case RPC_FC_FIXED_REPEAT: + case FC_FIXED_REPEAT: rep = *(const WORD*)&pFormat[2]; stride = *(const WORD*)&pFormat[4]; count = *(const WORD*)&pFormat[8]; pFormat += 10; break; - case RPC_FC_VARIABLE_REPEAT: - rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount; + case FC_VARIABLE_REPEAT: + rep = (pFormat[1] == FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount; stride = *(const WORD*)&pFormat[2]; count = *(const WORD*)&pFormat[6]; pFormat += 8; @@ -1517,7 +1547,7 @@ unsigned char * WINAPI NdrPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg, /* Increment the buffer here instead of in PointerMarshall, * as that is used by embedded pointers which already handle the incrementing * the buffer, and shouldn't write any additional pointer data to the wire */ - if (*pFormat != RPC_FC_RP) + if (*pFormat != FC_RP) { align_pointer_clear(&pStubMsg->Buffer, 4); Buffer = pStubMsg->Buffer; @@ -1543,7 +1573,7 @@ unsigned char * WINAPI NdrPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
- if (*pFormat == RPC_FC_RP) + if (*pFormat == FC_RP) { Buffer = pStubMsg->Buffer; /* Do the NULL ref pointer check here because embedded pointers can be @@ -1583,7 +1613,7 @@ void WINAPI NdrPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg, /* Increment the buffer length here instead of in PointerBufferSize, * as that is used by embedded pointers which already handle the buffer * length, and shouldn't write anything more to the wire */ - if (*pFormat != RPC_FC_RP) + if (*pFormat != FC_RP) { align_length(&pStubMsg->BufferLength, 4); safe_buffer_length_increment(pStubMsg, 4); @@ -1599,7 +1629,7 @@ ULONG WINAPI NdrPointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat) { unsigned char *Buffer = pStubMsg->Buffer; - if (*pFormat != RPC_FC_RP) + if (*pFormat != FC_RP) { align_pointer(&pStubMsg->Buffer, 4); safe_buffer_increment(pStubMsg, 4); @@ -1648,39 +1678,39 @@ void WINAPI NdrSimpleTypeUnmarshall( PMIDL_STUB_MESSAGE pStubMsg, unsigned char*
switch(FormatChar) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: BASE_TYPE_UNMARSHALL(UCHAR); TRACE("value: 0x%02x\n", *pMemory); break; - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: BASE_TYPE_UNMARSHALL(USHORT); TRACE("value: 0x%04x\n", *(USHORT *)pMemory); break; - case RPC_FC_LONG: - case RPC_FC_ULONG: - case RPC_FC_ERROR_STATUS_T: - case RPC_FC_ENUM32: + case FC_LONG: + case FC_ULONG: + case FC_ERROR_STATUS_T: + case FC_ENUM32: BASE_TYPE_UNMARSHALL(ULONG); TRACE("value: 0x%08x\n", *(ULONG *)pMemory); break; - case RPC_FC_FLOAT: + case FC_FLOAT: BASE_TYPE_UNMARSHALL(float); TRACE("value: %f\n", *(float *)pMemory); break; - case RPC_FC_DOUBLE: + case FC_DOUBLE: BASE_TYPE_UNMARSHALL(double); TRACE("value: %f\n", *(double *)pMemory); break; - case RPC_FC_HYPER: + case FC_HYPER: BASE_TYPE_UNMARSHALL(ULONGLONG); TRACE("value: %s\n", wine_dbgstr_longlong(*(ULONGLONG *)pMemory)); break; - case RPC_FC_ENUM16: + case FC_ENUM16: align_pointer(&pStubMsg->Buffer, sizeof(USHORT)); TRACE("pMemory: %p\n", pMemory); /* 16-bits on the wire, but int in memory */ @@ -1688,21 +1718,21 @@ void WINAPI NdrSimpleTypeUnmarshall( PMIDL_STUB_MESSAGE pStubMsg, unsigned char* pStubMsg->Buffer += sizeof(USHORT); TRACE("value: 0x%08x\n", *(UINT *)pMemory); break; - case RPC_FC_INT3264: + case FC_INT3264: align_pointer(&pStubMsg->Buffer, sizeof(INT)); /* 32-bits on the wire, but int_ptr in memory */ *(INT_PTR *)pMemory = *(INT *)pStubMsg->Buffer; pStubMsg->Buffer += sizeof(INT); TRACE("value: 0x%08lx\n", *(INT_PTR *)pMemory); break; - case RPC_FC_UINT3264: + case FC_UINT3264: align_pointer(&pStubMsg->Buffer, sizeof(UINT)); /* 32-bits on the wire, but int_ptr in memory */ *(UINT_PTR *)pMemory = *(UINT *)pStubMsg->Buffer; pStubMsg->Buffer += sizeof(UINT); TRACE("value: 0x%08lx\n", *(UINT_PTR *)pMemory); break; - case RPC_FC_IGNORE: + case FC_IGNORE: break; default: FIXME("Unhandled base type: 0x%02x\n", FormatChar); @@ -1725,7 +1755,7 @@ unsigned char * WINAPI NdrSimpleStructMarshall(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->BufferMark = pStubMsg->Buffer; safe_copy_to_buffer(pStubMsg, pMemory, size);
- if (pFormat[0] != RPC_FC_STRUCT) + if (pFormat[0] != FC_STRUCT) EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat+4);
return NULL; @@ -1746,7 +1776,7 @@ unsigned char * WINAPI NdrSimpleStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, align_pointer(&pStubMsg->Buffer, pFormat[1] + 1);
if (fMustAlloc) - *ppMemory = NdrAllocate(pStubMsg, size); + *ppMemory = NdrAllocateZero(pStubMsg, size); else { if (!pStubMsg->IsClient && !*ppMemory) @@ -1756,7 +1786,7 @@ unsigned char * WINAPI NdrSimpleStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer; safe_buffer_increment(pStubMsg, size); - if (pFormat[0] == RPC_FC_PSTRUCT) + if (pFormat[0] == FC_PSTRUCT) EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat+4, fMustAlloc);
TRACE("copying %p to %p\n", saved_buffer, *ppMemory); @@ -1779,7 +1809,7 @@ void WINAPI NdrSimpleStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg, align_length(&pStubMsg->BufferLength, pFormat[1] + 1);
safe_buffer_length_increment(pStubMsg, size); - if (pFormat[0] != RPC_FC_STRUCT) + if (pFormat[0] != FC_STRUCT) EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat+4); }
@@ -1797,7 +1827,7 @@ ULONG WINAPI NdrSimpleStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->MemorySize += size; safe_buffer_increment(pStubMsg, size);
- if (pFormat[0] != RPC_FC_STRUCT) + if (pFormat[0] != FC_STRUCT) EmbeddedPointerMemorySize(pStubMsg, pFormat+4); return pStubMsg->MemorySize; } @@ -1810,7 +1840,7 @@ void WINAPI NdrSimpleStructFree(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat) { TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat); - if (pFormat[0] != RPC_FC_STRUCT) + if (pFormat[0] != FC_STRUCT) EmbeddedPointerFree(pStubMsg, pMemory, pFormat+4); }
@@ -1824,18 +1854,18 @@ static inline void array_compute_and_size_conformance(
switch (fc) { - case RPC_FC_CARRAY: + case FC_CARRAY: ComputeConformance(pStubMsg, pMemory, pFormat+4, 0); SizeConformance(pStubMsg); break; - case RPC_FC_CVARRAY: + case FC_CVARRAY: pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 4, 0); pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0); SizeConformance(pStubMsg); break; - case RPC_FC_C_CSTRING: - case RPC_FC_C_WSTRING: - if (fc == RPC_FC_C_CSTRING) + case FC_C_CSTRING: + case FC_C_WSTRING: + if (fc == FC_C_CSTRING) { TRACE("string=%s\n", debugstr_a((const char *)pMemory)); pStubMsg->ActualCount = strlen((const char *)pMemory)+1; @@ -1846,14 +1876,14 @@ static inline void array_compute_and_size_conformance( pStubMsg->ActualCount = strlenW((LPCWSTR)pMemory)+1; }
- if (pFormat[1] == RPC_FC_STRING_SIZED) + if (pFormat[1] == FC_STRING_SIZED) pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 2, 0); else pStubMsg->MaxCount = pStubMsg->ActualCount;
SizeConformance(pStubMsg); break; - case RPC_FC_BOGUS_ARRAY: + case FC_BOGUS_ARRAY: count = *(const WORD *)(pFormat + 2); pFormat += 4; if (IsConformanceOrVariancePresent(pFormat)) SizeConformance(pStubMsg); @@ -1876,7 +1906,7 @@ static inline void array_buffer_size(
switch (fc) { - case RPC_FC_CARRAY: + case FC_CARRAY: esize = *(const WORD*)(pFormat+2); alignment = pFormat[1] + 1;
@@ -1891,7 +1921,7 @@ static inline void array_buffer_size( if (fHasPointers) EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat); break; - case RPC_FC_CVARRAY: + case FC_CVARRAY: esize = *(const WORD*)(pFormat+2); alignment = pFormat[1] + 1;
@@ -1908,9 +1938,9 @@ static inline void array_buffer_size( if (fHasPointers) EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat); break; - case RPC_FC_C_CSTRING: - case RPC_FC_C_WSTRING: - if (fc == RPC_FC_C_CSTRING) + case FC_C_CSTRING: + case FC_C_WSTRING: + if (fc == FC_C_CSTRING) esize = 1; else esize = 2; @@ -1920,7 +1950,7 @@ static inline void array_buffer_size( size = safe_multiply(esize, pStubMsg->ActualCount); safe_buffer_length_increment(pStubMsg, size); break; - case RPC_FC_BOGUS_ARRAY: + case FC_BOGUS_ARRAY: alignment = pFormat[1] + 1; pFormat = SkipConformance(pStubMsg, pFormat + 4); if (IsConformanceOrVariancePresent(pFormat)) SizeVariance(pStubMsg); @@ -1947,18 +1977,18 @@ static inline void array_compute_and_write_conformance(
switch (fc) { - case RPC_FC_CARRAY: + case FC_CARRAY: ComputeConformance(pStubMsg, pMemory, pFormat+4, 0); WriteConformance(pStubMsg); break; - case RPC_FC_CVARRAY: + case FC_CVARRAY: pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 4, 0); pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0); WriteConformance(pStubMsg); break; - case RPC_FC_C_CSTRING: - case RPC_FC_C_WSTRING: - if (fc == RPC_FC_C_CSTRING) + case FC_C_CSTRING: + case FC_C_WSTRING: + if (fc == FC_C_CSTRING) { TRACE("string=%s\n", debugstr_a((const char *)pMemory)); pStubMsg->ActualCount = strlen((const char *)pMemory)+1; @@ -1968,14 +1998,14 @@ static inline void array_compute_and_write_conformance( TRACE("string=%s\n", debugstr_w((LPCWSTR)pMemory)); pStubMsg->ActualCount = strlenW((LPCWSTR)pMemory)+1; } - if (pFormat[1] == RPC_FC_STRING_SIZED) + if (pFormat[1] == FC_STRING_SIZED) pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 2, 0); else pStubMsg->MaxCount = pStubMsg->ActualCount; pStubMsg->Offset = 0; WriteConformance(pStubMsg); break; - case RPC_FC_BOGUS_ARRAY: + case FC_BOGUS_ARRAY: def = *(const WORD *)(pFormat + 2); pFormat += 4; conformance_present = IsConformanceOrVariancePresent(pFormat); @@ -1999,7 +2029,7 @@ static inline void array_write_variance_and_marshall(
switch (fc) { - case RPC_FC_CARRAY: + case FC_CARRAY: esize = *(const WORD*)(pFormat+2); alignment = pFormat[1] + 1;
@@ -2015,7 +2045,7 @@ static inline void array_write_variance_and_marshall( if (fHasPointers) EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat); break; - case RPC_FC_CVARRAY: + case FC_CVARRAY: esize = *(const WORD*)(pFormat+2); alignment = pFormat[1] + 1;
@@ -2035,9 +2065,9 @@ static inline void array_write_variance_and_marshall( if (fHasPointers) EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat); break; - case RPC_FC_C_CSTRING: - case RPC_FC_C_WSTRING: - if (fc == RPC_FC_C_CSTRING) + case FC_C_CSTRING: + case FC_C_WSTRING: + if (fc == FC_C_CSTRING) esize = 1; else esize = 2; @@ -2047,7 +2077,7 @@ static inline void array_write_variance_and_marshall( size = safe_multiply(esize, pStubMsg->ActualCount); safe_copy_to_buffer(pStubMsg, pMemory, size); /* the string itself */ break; - case RPC_FC_BOGUS_ARRAY: + case FC_BOGUS_ARRAY: alignment = pFormat[1] + 1; pFormat = SkipConformance(pStubMsg, pFormat + 4); if (IsConformanceOrVariancePresent(pFormat)) WriteVariance(pStubMsg); @@ -2072,27 +2102,27 @@ static inline ULONG array_read_conformance(
switch (fc) { - case RPC_FC_CARRAY: + case FC_CARRAY: esize = *(const WORD*)(pFormat+2); pFormat = ReadConformance(pStubMsg, pFormat+4); return safe_multiply(esize, pStubMsg->MaxCount); - case RPC_FC_CVARRAY: + case FC_CVARRAY: esize = *(const WORD*)(pFormat+2); pFormat = ReadConformance(pStubMsg, pFormat+4); return safe_multiply(esize, pStubMsg->MaxCount); - case RPC_FC_C_CSTRING: - case RPC_FC_C_WSTRING: - if (fc == RPC_FC_C_CSTRING) + case FC_C_CSTRING: + case FC_C_WSTRING: + if (fc == FC_C_CSTRING) esize = 1; else esize = 2;
- if (pFormat[1] == RPC_FC_STRING_SIZED) + if (pFormat[1] == FC_STRING_SIZED) ReadConformance(pStubMsg, pFormat + 2); else ReadConformance(pStubMsg, NULL); return safe_multiply(esize, pStubMsg->MaxCount); - case RPC_FC_BOGUS_ARRAY: + case FC_BOGUS_ARRAY: def = *(const WORD *)(pFormat + 2); pFormat += 4; if (IsConformanceOrVariancePresent(pFormat)) pFormat = ReadConformance(pStubMsg, pFormat); @@ -2124,7 +2154,7 @@ static inline ULONG array_read_variance_and_unmarshall(
switch (fc) { - case RPC_FC_CARRAY: + case FC_CARRAY: esize = *(const WORD*)(pFormat+2); alignment = pFormat[1] + 1;
@@ -2137,7 +2167,7 @@ static inline ULONG array_read_variance_and_unmarshall( if (fUnmarshall) { if (fMustAlloc) - *ppMemory = NdrAllocate(pStubMsg, memsize); + *ppMemory = NdrAllocateZero(pStubMsg, memsize); else { if (fUseBufferMemoryServer && !pStubMsg->IsClient && !*ppMemory) @@ -2156,7 +2186,7 @@ static inline ULONG array_read_variance_and_unmarshall( memcpy(*ppMemory, saved_buffer, bufsize); } return bufsize; - case RPC_FC_CVARRAY: + case FC_CVARRAY: esize = *(const WORD*)(pFormat+2); alignment = pFormat[1] + 1;
@@ -2176,7 +2206,7 @@ static inline ULONG array_read_variance_and_unmarshall( if (!fMustAlloc && !*ppMemory) fMustAlloc = TRUE; if (fMustAlloc) - *ppMemory = NdrAllocate(pStubMsg, memsize); + *ppMemory = NdrAllocateZero(pStubMsg, memsize); saved_buffer = pStubMsg->Buffer; safe_buffer_increment(pStubMsg, bufsize);
@@ -2187,16 +2217,16 @@ static inline ULONG array_read_variance_and_unmarshall( memcpy(*ppMemory + offset, saved_buffer, bufsize); } return bufsize; - case RPC_FC_C_CSTRING: - case RPC_FC_C_WSTRING: - if (fc == RPC_FC_C_CSTRING) + case FC_C_CSTRING: + case FC_C_WSTRING: + if (fc == FC_C_CSTRING) esize = 1; else esize = 2;
ReadVariance(pStubMsg, NULL, pStubMsg->MaxCount);
- if (pFormat[1] != RPC_FC_STRING_SIZED && (pStubMsg->MaxCount != pStubMsg->ActualCount)) + if (pFormat[1] != FC_STRING_SIZED && (pStubMsg->MaxCount != pStubMsg->ActualCount)) { ERR("buffer size %d must equal memory size %ld for non-sized conformant strings\n", pStubMsg->ActualCount, pStubMsg->MaxCount); @@ -2233,14 +2263,14 @@ static inline ULONG array_read_variance_and_unmarshall( else safe_copy_from_buffer(pStubMsg, *ppMemory, bufsize);
- if (*pFormat == RPC_FC_C_CSTRING) + if (*pFormat == FC_C_CSTRING) TRACE("string=%s\n", debugstr_a((char*)*ppMemory)); else TRACE("string=%s\n", debugstr_w((LPWSTR)*ppMemory)); } return bufsize;
- case RPC_FC_BOGUS_ARRAY: + case FC_BOGUS_ARRAY: alignment = pFormat[1] + 1; pFormat = SkipConformance(pStubMsg, pFormat + 4); pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount); @@ -2253,7 +2283,7 @@ static inline ULONG array_read_variance_and_unmarshall( if (!fMustAlloc && !*ppMemory) fMustAlloc = TRUE; if (fMustAlloc) - *ppMemory = NdrAllocate(pStubMsg, memsize); + *ppMemory = NdrAllocateZero(pStubMsg, memsize);
align_pointer(&pStubMsg->Buffer, alignment); saved_buffer = pStubMsg->Buffer; @@ -2281,7 +2311,7 @@ static inline void array_memory_size(
switch (fc) { - case RPC_FC_CARRAY: + case FC_CARRAY: esize = *(const WORD*)(pFormat+2); alignment = pFormat[1] + 1;
@@ -2298,7 +2328,7 @@ static inline void array_memory_size( if (fHasPointers) EmbeddedPointerMemorySize(pStubMsg, pFormat); break; - case RPC_FC_CVARRAY: + case FC_CVARRAY: esize = *(const WORD*)(pFormat+2); alignment = pFormat[1] + 1;
@@ -2318,16 +2348,16 @@ static inline void array_memory_size( if (fHasPointers) EmbeddedPointerMemorySize(pStubMsg, pFormat); break; - case RPC_FC_C_CSTRING: - case RPC_FC_C_WSTRING: - if (fc == RPC_FC_C_CSTRING) + case FC_C_CSTRING: + case FC_C_WSTRING: + if (fc == FC_C_CSTRING) esize = 1; else esize = 2;
ReadVariance(pStubMsg, NULL, pStubMsg->MaxCount);
- if (pFormat[1] != RPC_FC_STRING_SIZED && (pStubMsg->MaxCount != pStubMsg->ActualCount)) + if (pFormat[1] != FC_STRING_SIZED && (pStubMsg->MaxCount != pStubMsg->ActualCount)) { ERR("buffer size %d must equal memory size %ld for non-sized conformant strings\n", pStubMsg->ActualCount, pStubMsg->MaxCount); @@ -2347,7 +2377,7 @@ static inline void array_memory_size( safe_buffer_increment(pStubMsg, bufsize); pStubMsg->MemorySize += memsize; break; - case RPC_FC_BOGUS_ARRAY: + case FC_BOGUS_ARRAY: alignment = pFormat[1] + 1; pFormat = SkipConformance(pStubMsg, pFormat + 4); pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount); @@ -2379,22 +2409,22 @@ static inline void array_free(
switch (fc) { - case RPC_FC_CARRAY: + case FC_CARRAY: pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0); if (fHasPointers) EmbeddedPointerFree(pStubMsg, pMemory, pFormat); break; - case RPC_FC_CVARRAY: + case FC_CVARRAY: pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0); pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0); if (fHasPointers) EmbeddedPointerFree(pStubMsg, pMemory, pFormat); break; - case RPC_FC_C_CSTRING: - case RPC_FC_C_WSTRING: + case FC_C_CSTRING: + case FC_C_WSTRING: /* No embedded pointers so nothing to do */ break; - case RPC_FC_BOGUS_ARRAY: + case FC_BOGUS_ARRAY: count = *(const WORD *)(pFormat + 2); pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 4, count); pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount); @@ -2434,22 +2464,22 @@ unsigned char *WINAPI NdrConformantStringMarshall(MIDL_STUB_MESSAGE *pStubMsg, { TRACE("(pStubMsg == ^%p, pszMessage == ^%p, pFormat == ^%p)\n", pStubMsg, pszMessage, pFormat);
- if (pFormat[0] != RPC_FC_C_CSTRING && pFormat[0] != RPC_FC_C_WSTRING) { + if (pFormat[0] != FC_C_CSTRING && pFormat[0] != FC_C_WSTRING) { ERR("Unhandled string type: %#x\n", pFormat[0]); RpcRaiseException(RPC_X_BAD_STUB_DATA); }
/* allow compiler to optimise inline function by passing constant into * these functions */ - if (pFormat[0] == RPC_FC_C_CSTRING) { - array_compute_and_write_conformance(RPC_FC_C_CSTRING, pStubMsg, pszMessage, + if (pFormat[0] == FC_C_CSTRING) { + array_compute_and_write_conformance(FC_C_CSTRING, pStubMsg, pszMessage, pFormat); - array_write_variance_and_marshall(RPC_FC_C_CSTRING, pStubMsg, pszMessage, + array_write_variance_and_marshall(FC_C_CSTRING, pStubMsg, pszMessage, pFormat, TRUE /* fHasPointers */); } else { - array_compute_and_write_conformance(RPC_FC_C_WSTRING, pStubMsg, pszMessage, + array_compute_and_write_conformance(FC_C_WSTRING, pStubMsg, pszMessage, pFormat); - array_write_variance_and_marshall(RPC_FC_C_WSTRING, pStubMsg, pszMessage, + array_write_variance_and_marshall(FC_C_WSTRING, pStubMsg, pszMessage, pFormat, TRUE /* fHasPointers */); }
@@ -2464,22 +2494,22 @@ void WINAPI NdrConformantStringBufferSize(PMIDL_STUB_MESSAGE pStubMsg, { TRACE("(pStubMsg == ^%p, pMemory == ^%p, pFormat == ^%p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_C_CSTRING && pFormat[0] != RPC_FC_C_WSTRING) { + if (pFormat[0] != FC_C_CSTRING && pFormat[0] != FC_C_WSTRING) { ERR("Unhandled string type: %#x\n", pFormat[0]); RpcRaiseException(RPC_X_BAD_STUB_DATA); }
/* allow compiler to optimise inline function by passing constant into * these functions */ - if (pFormat[0] == RPC_FC_C_CSTRING) { - array_compute_and_size_conformance(RPC_FC_C_CSTRING, pStubMsg, pMemory, + if (pFormat[0] == FC_C_CSTRING) { + array_compute_and_size_conformance(FC_C_CSTRING, pStubMsg, pMemory, pFormat); - array_buffer_size(RPC_FC_C_CSTRING, pStubMsg, pMemory, pFormat, + array_buffer_size(FC_C_CSTRING, pStubMsg, pMemory, pFormat, TRUE /* fHasPointers */); } else { - array_compute_and_size_conformance(RPC_FC_C_WSTRING, pStubMsg, pMemory, + array_compute_and_size_conformance(FC_C_WSTRING, pStubMsg, pMemory, pFormat); - array_buffer_size(RPC_FC_C_WSTRING, pStubMsg, pMemory, pFormat, + array_buffer_size(FC_C_WSTRING, pStubMsg, pMemory, pFormat, TRUE /* fHasPointers */); } } @@ -2492,20 +2522,20 @@ ULONG WINAPI NdrConformantStringMemorySize( PMIDL_STUB_MESSAGE pStubMsg, { TRACE("(pStubMsg == ^%p, pFormat == ^%p)\n", pStubMsg, pFormat);
- if (pFormat[0] != RPC_FC_C_CSTRING && pFormat[0] != RPC_FC_C_WSTRING) { + if (pFormat[0] != FC_C_CSTRING && pFormat[0] != FC_C_WSTRING) { ERR("Unhandled string type: %#x\n", pFormat[0]); RpcRaiseException(RPC_X_BAD_STUB_DATA); }
/* allow compiler to optimise inline function by passing constant into * these functions */ - if (pFormat[0] == RPC_FC_C_CSTRING) { - array_read_conformance(RPC_FC_C_CSTRING, pStubMsg, pFormat); - array_memory_size(RPC_FC_C_CSTRING, pStubMsg, pFormat, + if (pFormat[0] == FC_C_CSTRING) { + array_read_conformance(FC_C_CSTRING, pStubMsg, pFormat); + array_memory_size(FC_C_CSTRING, pStubMsg, pFormat, TRUE /* fHasPointers */); } else { - array_read_conformance(RPC_FC_C_WSTRING, pStubMsg, pFormat); - array_memory_size(RPC_FC_C_WSTRING, pStubMsg, pFormat, + array_read_conformance(FC_C_WSTRING, pStubMsg, pFormat); + array_memory_size(FC_C_WSTRING, pStubMsg, pFormat, TRUE /* fHasPointers */); }
@@ -2521,22 +2551,22 @@ unsigned char *WINAPI NdrConformantStringUnmarshall( PMIDL_STUB_MESSAGE pStubMsg TRACE("(pStubMsg == ^%p, *pMemory == ^%p, pFormat == ^%p, fMustAlloc == %u)\n", pStubMsg, *ppMemory, pFormat, fMustAlloc);
- if (pFormat[0] != RPC_FC_C_CSTRING && pFormat[0] != RPC_FC_C_WSTRING) { + if (pFormat[0] != FC_C_CSTRING && pFormat[0] != FC_C_WSTRING) { ERR("Unhandled string type: %#x\n", *pFormat); RpcRaiseException(RPC_X_BAD_STUB_DATA); }
/* allow compiler to optimise inline function by passing constant into * these functions */ - if (pFormat[0] == RPC_FC_C_CSTRING) { - array_read_conformance(RPC_FC_C_CSTRING, pStubMsg, pFormat); - array_read_variance_and_unmarshall(RPC_FC_C_CSTRING, pStubMsg, ppMemory, + if (pFormat[0] == FC_C_CSTRING) { + array_read_conformance(FC_C_CSTRING, pStubMsg, pFormat); + array_read_variance_and_unmarshall(FC_C_CSTRING, pStubMsg, ppMemory, pFormat, fMustAlloc, TRUE /* fUseBufferMemoryServer */, TRUE /* fUnmarshall */); } else { - array_read_conformance(RPC_FC_C_WSTRING, pStubMsg, pFormat); - array_read_variance_and_unmarshall(RPC_FC_C_WSTRING, pStubMsg, ppMemory, + array_read_conformance(FC_C_WSTRING, pStubMsg, pFormat); + array_read_variance_and_unmarshall(FC_C_WSTRING, pStubMsg, ppMemory, pFormat, fMustAlloc, TRUE /* fUseBufferMemoryServer */, TRUE /* fUnmarshall */); @@ -2558,7 +2588,7 @@ unsigned char * WINAPI NdrNonConformantStringMarshall(PMIDL_STUB_MESSAGE pStubM
maxsize = *(const USHORT *)&pFormat[2];
- if (*pFormat == RPC_FC_CSTRING) + if (*pFormat == FC_CSTRING) { ULONG i = 0; const char *str = (const char *)pMemory; @@ -2567,7 +2597,7 @@ unsigned char * WINAPI NdrNonConformantStringMarshall(PMIDL_STUB_MESSAGE pStubM pStubMsg->ActualCount = i + 1; esize = 1; } - else if (*pFormat == RPC_FC_WSTRING) + else if (*pFormat == FC_WSTRING) { ULONG i = 0; const WCHAR *str = (const WCHAR *)pMemory; @@ -2613,8 +2643,8 @@ unsigned char * WINAPI NdrNonConformantStringUnmarshall(PMIDL_STUB_MESSAGE pStu RpcRaiseException(RPC_S_INVALID_BOUND); }
- if (*pFormat == RPC_FC_CSTRING) esize = 1; - else if (*pFormat == RPC_FC_WSTRING) esize = 2; + if (*pFormat == FC_CSTRING) esize = 1; + else if (*pFormat == FC_WSTRING) esize = 2; else { ERR("Unhandled string type: %#x\n", *pFormat); @@ -2633,10 +2663,10 @@ unsigned char * WINAPI NdrNonConformantStringUnmarshall(PMIDL_STUB_MESSAGE pStu
safe_copy_from_buffer(pStubMsg, *ppMemory, bufsize);
- if (*pFormat == RPC_FC_CSTRING) { + if (*pFormat == FC_CSTRING) { TRACE("string=%s\n", debugstr_an((char*)*ppMemory, pStubMsg->ActualCount)); } - else if (*pFormat == RPC_FC_WSTRING) { + else if (*pFormat == FC_WSTRING) { TRACE("string=%s\n", debugstr_wn((LPWSTR)*ppMemory, pStubMsg->ActualCount)); }
@@ -2658,7 +2688,7 @@ void WINAPI NdrNonConformantStringBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
SizeVariance(pStubMsg);
- if (*pFormat == RPC_FC_CSTRING) + if (*pFormat == FC_CSTRING) { ULONG i = 0; const char *str = (const char *)pMemory; @@ -2667,7 +2697,7 @@ void WINAPI NdrNonConformantStringBufferSize(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->ActualCount = i + 1; esize = 1; } - else if (*pFormat == RPC_FC_WSTRING) + else if (*pFormat == FC_WSTRING) { ULONG i = 0; const WCHAR *str = (const WCHAR *)pMemory; @@ -2705,8 +2735,8 @@ ULONG WINAPI NdrNonConformantStringMemorySize(PMIDL_STUB_MESSAGE pStubMsg, RpcRaiseException(RPC_S_INVALID_BOUND); }
- if (*pFormat == RPC_FC_CSTRING) esize = 1; - else if (*pFormat == RPC_FC_WSTRING) esize = 2; + if (*pFormat == FC_CSTRING) esize = 1; + else if (*pFormat == FC_WSTRING) esize = 2; else { ERR("Unhandled string type: %#x\n", *pFormat); @@ -2740,54 +2770,55 @@ static ULONG EmbeddedComplexSize(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat) { switch (*pFormat) { - case RPC_FC_STRUCT: - case RPC_FC_PSTRUCT: - case RPC_FC_CSTRUCT: - case RPC_FC_BOGUS_STRUCT: - case RPC_FC_SMFARRAY: - case RPC_FC_SMVARRAY: - case RPC_FC_CSTRING: + case FC_STRUCT: + case FC_PSTRUCT: + case FC_CSTRUCT: + case FC_BOGUS_STRUCT: + case FC_SMFARRAY: + case FC_SMVARRAY: + case FC_CSTRING: return *(const WORD*)&pFormat[2]; - case RPC_FC_USER_MARSHAL: + case FC_LGFARRAY: + case FC_LGVARRAY: + return *(const ULONG*)&pFormat[2]; + case FC_USER_MARSHAL: return *(const WORD*)&pFormat[4]; - case RPC_FC_RANGE: { + case FC_RANGE: { switch (((const NDR_RANGE *)pFormat)->flags_type & 0xf) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: return sizeof(UCHAR); - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: return sizeof(USHORT); - case RPC_FC_LONG: - case RPC_FC_ULONG: - case RPC_FC_ENUM32: - case RPC_FC_INT3264: - case RPC_FC_UINT3264: + case FC_LONG: + case FC_ULONG: + case FC_ENUM32: return sizeof(ULONG); - case RPC_FC_FLOAT: + case FC_FLOAT: return sizeof(float); - case RPC_FC_DOUBLE: + case FC_DOUBLE: return sizeof(double); - case RPC_FC_HYPER: + case FC_HYPER: return sizeof(ULONGLONG); - case RPC_FC_ENUM16: + case FC_ENUM16: return sizeof(UINT); default: ERR("unknown type 0x%x\n", ((const NDR_RANGE *)pFormat)->flags_type & 0xf); RpcRaiseException(RPC_X_BAD_STUB_DATA); } } - case RPC_FC_NON_ENCAPSULATED_UNION: + case FC_NON_ENCAPSULATED_UNION: pFormat += 2; pFormat = SkipConformance(pStubMsg, pFormat); pFormat += *(const SHORT*)pFormat; return *(const SHORT*)pFormat; - case RPC_FC_IP: + case FC_IP: return sizeof(void *); - case RPC_FC_WSTRING: + case FC_WSTRING: return *(const WORD*)&pFormat[2] * 2; default: FIXME("unhandled embedded type %02x\n", *pFormat); @@ -2816,28 +2847,29 @@ static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, PFORMAT_STRING pPointer) { + unsigned char *mem_base = pMemory; PFORMAT_STRING desc; NDR_MARSHALL m; ULONG size;
- while (*pFormat != RPC_FC_END) { + while (*pFormat != FC_END) { switch (*pFormat) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: TRACE("byte=%d <= %p\n", *(WORD*)pMemory, pMemory); safe_copy_to_buffer(pStubMsg, pMemory, 1); pMemory += 1; break; - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: TRACE("short=%d <= %p\n", *(WORD*)pMemory, pMemory); safe_copy_to_buffer(pStubMsg, pMemory, 2); pMemory += 2; break; - case RPC_FC_ENUM16: + case FC_ENUM16: { USHORT val = *(DWORD *)pMemory; TRACE("enum16=%d <= %p\n", *(DWORD*)pMemory, pMemory); @@ -2847,15 +2879,15 @@ static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg, pMemory += 4; break; } - case RPC_FC_LONG: - case RPC_FC_ULONG: - case RPC_FC_ENUM32: + case FC_LONG: + case FC_ULONG: + case FC_ENUM32: TRACE("long=%d <= %p\n", *(DWORD*)pMemory, pMemory); safe_copy_to_buffer(pStubMsg, pMemory, 4); pMemory += 4; break; - case RPC_FC_INT3264: - case RPC_FC_UINT3264: + case FC_INT3264: + case FC_UINT3264: { UINT val = *(UINT_PTR *)pMemory; TRACE("int3264=%ld <= %p\n", *(UINT_PTR *)pMemory, pMemory); @@ -2863,34 +2895,34 @@ static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg, pMemory += sizeof(UINT_PTR); break; } - case RPC_FC_FLOAT: + case FC_FLOAT: TRACE("float=%f <= %p\n", *(float*)pMemory, pMemory); safe_copy_to_buffer(pStubMsg, pMemory, sizeof(float)); pMemory += sizeof(float); break; - case RPC_FC_HYPER: + case FC_HYPER: TRACE("longlong=%s <= %p\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory), pMemory); safe_copy_to_buffer(pStubMsg, pMemory, 8); pMemory += 8; break; - case RPC_FC_DOUBLE: + case FC_DOUBLE: TRACE("double=%f <= %p\n", *(double*)pMemory, pMemory); safe_copy_to_buffer(pStubMsg, pMemory, sizeof(double)); pMemory += sizeof(double); break; - case RPC_FC_RP: - case RPC_FC_UP: - case RPC_FC_OP: - case RPC_FC_FP: - case RPC_FC_POINTER: + case FC_RP: + case FC_UP: + case FC_OP: + case FC_FP: + case FC_POINTER: { unsigned char *saved_buffer; BOOL pointer_buffer_mark_set = FALSE; TRACE("pointer=%p <= %p\n", *(unsigned char**)pMemory, pMemory); TRACE("pStubMsg->Buffer before %p\n", pStubMsg->Buffer); - if (*pFormat != RPC_FC_POINTER) + if (*pFormat != FC_POINTER) pPointer = pFormat; - if (*pPointer != RPC_FC_RP) + if (*pPointer != FC_RP) align_pointer_clear(&pStubMsg->Buffer, 4); saved_buffer = pStubMsg->Buffer; if (pStubMsg->PointerBufferMark) @@ -2899,7 +2931,7 @@ static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->PointerBufferMark = NULL; pointer_buffer_mark_set = TRUE; } - else if (*pPointer != RPC_FC_RP) + else if (*pPointer != FC_RP) safe_buffer_increment(pStubMsg, 4); /* for pointer ID */ PointerMarshall(pStubMsg, saved_buffer, *(unsigned char**)pMemory, pPointer); if (pointer_buffer_mark_set) @@ -2907,36 +2939,36 @@ static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg, STD_OVERFLOW_CHECK(pStubMsg); pStubMsg->PointerBufferMark = pStubMsg->Buffer; pStubMsg->Buffer = saved_buffer; - if (*pPointer != RPC_FC_RP) + if (*pPointer != FC_RP) safe_buffer_increment(pStubMsg, 4); /* for pointer ID */ } TRACE("pStubMsg->Buffer after %p\n", pStubMsg->Buffer); - if (*pFormat == RPC_FC_POINTER) + if (*pFormat == FC_POINTER) pPointer += 4; else pFormat += 4; pMemory += sizeof(void *); break; } - case RPC_FC_ALIGNM2: - align_pointer(&pMemory, 2); + case FC_ALIGNM2: + align_pointer_offset(&pMemory, mem_base, 2); break; - case RPC_FC_ALIGNM4: - align_pointer(&pMemory, 4); + case FC_ALIGNM4: + align_pointer_offset(&pMemory, mem_base, 4); break; - case RPC_FC_ALIGNM8: - align_pointer(&pMemory, 8); + case FC_ALIGNM8: + align_pointer_offset(&pMemory, mem_base, 8); break; - case RPC_FC_STRUCTPAD1: - case RPC_FC_STRUCTPAD2: - case RPC_FC_STRUCTPAD3: - case RPC_FC_STRUCTPAD4: - case RPC_FC_STRUCTPAD5: - case RPC_FC_STRUCTPAD6: - case RPC_FC_STRUCTPAD7: - pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1; + case FC_STRUCTPAD1: + case FC_STRUCTPAD2: + case FC_STRUCTPAD3: + case FC_STRUCTPAD4: + case FC_STRUCTPAD5: + case FC_STRUCTPAD6: + case FC_STRUCTPAD7: + pMemory += *pFormat - FC_STRUCTPAD1 + 1; break; - case RPC_FC_EMBEDDED_COMPLEX: + case FC_EMBEDDED_COMPLEX: pMemory += pFormat[1]; pFormat += 2; desc = pFormat + *(const SHORT*)pFormat; @@ -2946,10 +2978,10 @@ static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg, if (m) { /* for some reason interface pointers aren't generated as - * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet + * FC_POINTER, but instead as FC_EMBEDDED_COMPLEX, yet * they still need the dereferencing treatment that pointers are * given */ - if (*desc == RPC_FC_IP) + if (*desc == FC_IP) m(pStubMsg, *(unsigned char **)pMemory, desc); else m(pStubMsg, pMemory, desc); @@ -2958,7 +2990,7 @@ static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg, pMemory += size; pFormat += 2; continue; - case RPC_FC_PAD: + case FC_PAD: break; default: FIXME("unhandled format 0x%02x\n", *pFormat); @@ -2975,28 +3007,29 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pPointer, unsigned char fMustAlloc) { + unsigned char *mem_base = pMemory; PFORMAT_STRING desc; NDR_UNMARSHALL m; ULONG size;
- while (*pFormat != RPC_FC_END) { + while (*pFormat != FC_END) { switch (*pFormat) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: safe_copy_from_buffer(pStubMsg, pMemory, 1); TRACE("byte=%d => %p\n", *(WORD*)pMemory, pMemory); pMemory += 1; break; - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: safe_copy_from_buffer(pStubMsg, pMemory, 2); TRACE("short=%d => %p\n", *(WORD*)pMemory, pMemory); pMemory += 2; break; - case RPC_FC_ENUM16: + case FC_ENUM16: { WORD val; safe_copy_from_buffer(pStubMsg, &val, 2); @@ -3007,14 +3040,14 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, pMemory += 4; break; } - case RPC_FC_LONG: - case RPC_FC_ULONG: - case RPC_FC_ENUM32: + case FC_LONG: + case FC_ULONG: + case FC_ENUM32: safe_copy_from_buffer(pStubMsg, pMemory, 4); TRACE("long=%d => %p\n", *(DWORD*)pMemory, pMemory); pMemory += 4; break; - case RPC_FC_INT3264: + case FC_INT3264: { INT val; safe_copy_from_buffer(pStubMsg, &val, 4); @@ -3023,7 +3056,7 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, pMemory += sizeof(INT_PTR); break; } - case RPC_FC_UINT3264: + case FC_UINT3264: { UINT val; safe_copy_from_buffer(pStubMsg, &val, 4); @@ -3032,33 +3065,33 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, pMemory += sizeof(UINT_PTR); break; } - case RPC_FC_FLOAT: + case FC_FLOAT: safe_copy_from_buffer(pStubMsg, pMemory, sizeof(float)); TRACE("float=%f => %p\n", *(float*)pMemory, pMemory); pMemory += sizeof(float); break; - case RPC_FC_HYPER: + case FC_HYPER: safe_copy_from_buffer(pStubMsg, pMemory, 8); TRACE("longlong=%s => %p\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory), pMemory); pMemory += 8; break; - case RPC_FC_DOUBLE: + case FC_DOUBLE: safe_copy_from_buffer(pStubMsg, pMemory, sizeof(double)); TRACE("double=%f => %p\n", *(double*)pMemory, pMemory); pMemory += sizeof(double); break; - case RPC_FC_RP: - case RPC_FC_UP: - case RPC_FC_OP: - case RPC_FC_FP: - case RPC_FC_POINTER: + case FC_RP: + case FC_UP: + case FC_OP: + case FC_FP: + case FC_POINTER: { unsigned char *saved_buffer; BOOL pointer_buffer_mark_set = FALSE; TRACE("pointer => %p\n", pMemory); - if (*pFormat != RPC_FC_POINTER) + if (*pFormat != FC_POINTER) pPointer = pFormat; - if (*pPointer != RPC_FC_RP) + if (*pPointer != FC_RP) align_pointer(&pStubMsg->Buffer, 4); saved_buffer = pStubMsg->Buffer; if (pStubMsg->PointerBufferMark) @@ -3067,7 +3100,7 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->PointerBufferMark = NULL; pointer_buffer_mark_set = TRUE; } - else if (*pPointer != RPC_FC_RP) + else if (*pPointer != FC_RP) safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
PointerUnmarshall(pStubMsg, saved_buffer, (unsigned char**)pMemory, *(unsigned char**)pMemory, pPointer, fMustAlloc); @@ -3076,36 +3109,36 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, STD_OVERFLOW_CHECK(pStubMsg); pStubMsg->PointerBufferMark = pStubMsg->Buffer; pStubMsg->Buffer = saved_buffer; - if (*pPointer != RPC_FC_RP) + if (*pPointer != FC_RP) safe_buffer_increment(pStubMsg, 4); /* for pointer ID */ } - if (*pFormat == RPC_FC_POINTER) + if (*pFormat == FC_POINTER) pPointer += 4; else pFormat += 4; pMemory += sizeof(void *); break; } - case RPC_FC_ALIGNM2: - align_pointer_clear(&pMemory, 2); + case FC_ALIGNM2: + align_pointer_offset_clear(&pMemory, mem_base, 2); break; - case RPC_FC_ALIGNM4: - align_pointer_clear(&pMemory, 4); + case FC_ALIGNM4: + align_pointer_offset_clear(&pMemory, mem_base, 4); break; - case RPC_FC_ALIGNM8: - align_pointer_clear(&pMemory, 8); + case FC_ALIGNM8: + align_pointer_offset_clear(&pMemory, mem_base, 8); break; - case RPC_FC_STRUCTPAD1: - case RPC_FC_STRUCTPAD2: - case RPC_FC_STRUCTPAD3: - case RPC_FC_STRUCTPAD4: - case RPC_FC_STRUCTPAD5: - case RPC_FC_STRUCTPAD6: - case RPC_FC_STRUCTPAD7: - memset(pMemory, 0, *pFormat - RPC_FC_STRUCTPAD1 + 1); - pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1; + case FC_STRUCTPAD1: + case FC_STRUCTPAD2: + case FC_STRUCTPAD3: + case FC_STRUCTPAD4: + case FC_STRUCTPAD5: + case FC_STRUCTPAD6: + case FC_STRUCTPAD7: + memset(pMemory, 0, *pFormat - FC_STRUCTPAD1 + 1); + pMemory += *pFormat - FC_STRUCTPAD1 + 1; break; - case RPC_FC_EMBEDDED_COMPLEX: + case FC_EMBEDDED_COMPLEX: pMemory += pFormat[1]; pFormat += 2; desc = pFormat + *(const SHORT*)pFormat; @@ -3122,10 +3155,10 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, if (m) { /* for some reason interface pointers aren't generated as - * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet + * FC_POINTER, but instead as FC_EMBEDDED_COMPLEX, yet * they still need the dereferencing treatment that pointers are * given */ - if (*desc == RPC_FC_IP) + if (*desc == FC_IP) m(pStubMsg, (unsigned char **)pMemory, desc, FALSE); else m(pStubMsg, &pMemory, desc, FALSE); @@ -3134,7 +3167,7 @@ static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, pMemory += size; pFormat += 2; continue; - case RPC_FC_PAD: + case FC_PAD: break; default: FIXME("unhandled format %d\n", *pFormat); @@ -3150,52 +3183,53 @@ static unsigned char * ComplexBufferSize(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, PFORMAT_STRING pPointer) { + unsigned char *mem_base = pMemory; PFORMAT_STRING desc; NDR_BUFFERSIZE m; ULONG size;
- while (*pFormat != RPC_FC_END) { + while (*pFormat != FC_END) { switch (*pFormat) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: safe_buffer_length_increment(pStubMsg, 1); pMemory += 1; break; - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: safe_buffer_length_increment(pStubMsg, 2); pMemory += 2; break; - case RPC_FC_ENUM16: + case FC_ENUM16: safe_buffer_length_increment(pStubMsg, 2); pMemory += 4; break; - case RPC_FC_LONG: - case RPC_FC_ULONG: - case RPC_FC_ENUM32: - case RPC_FC_FLOAT: + case FC_LONG: + case FC_ULONG: + case FC_ENUM32: + case FC_FLOAT: safe_buffer_length_increment(pStubMsg, 4); pMemory += 4; break; - case RPC_FC_INT3264: - case RPC_FC_UINT3264: + case FC_INT3264: + case FC_UINT3264: safe_buffer_length_increment(pStubMsg, 4); pMemory += sizeof(INT_PTR); break; - case RPC_FC_HYPER: - case RPC_FC_DOUBLE: + case FC_HYPER: + case FC_DOUBLE: safe_buffer_length_increment(pStubMsg, 8); pMemory += 8; break; - case RPC_FC_RP: - case RPC_FC_UP: - case RPC_FC_OP: - case RPC_FC_FP: - case RPC_FC_POINTER: - if (*pFormat != RPC_FC_POINTER) + case FC_RP: + case FC_UP: + case FC_OP: + case FC_FP: + case FC_POINTER: + if (*pFormat != FC_POINTER) pPointer = pFormat; if (!pStubMsg->IgnoreEmbeddedPointers) { @@ -3208,36 +3242,36 @@ static unsigned char * ComplexBufferSize(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->PointerLength = pStubMsg->BufferLength; pStubMsg->BufferLength = saved_buffer_length; } - if (*pPointer != RPC_FC_RP) + if (*pPointer != FC_RP) { align_length(&pStubMsg->BufferLength, 4); safe_buffer_length_increment(pStubMsg, 4); } - if (*pFormat == RPC_FC_POINTER) + if (*pFormat == FC_POINTER) pPointer += 4; else pFormat += 4; pMemory += sizeof(void*); break; - case RPC_FC_ALIGNM2: - align_pointer(&pMemory, 2); + case FC_ALIGNM2: + align_pointer_offset(&pMemory, mem_base, 2); break; - case RPC_FC_ALIGNM4: - align_pointer(&pMemory, 4); + case FC_ALIGNM4: + align_pointer_offset(&pMemory, mem_base, 4); break; - case RPC_FC_ALIGNM8: - align_pointer(&pMemory, 8); + case FC_ALIGNM8: + align_pointer_offset(&pMemory, mem_base, 8); break; - case RPC_FC_STRUCTPAD1: - case RPC_FC_STRUCTPAD2: - case RPC_FC_STRUCTPAD3: - case RPC_FC_STRUCTPAD4: - case RPC_FC_STRUCTPAD5: - case RPC_FC_STRUCTPAD6: - case RPC_FC_STRUCTPAD7: - pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1; + case FC_STRUCTPAD1: + case FC_STRUCTPAD2: + case FC_STRUCTPAD3: + case FC_STRUCTPAD4: + case FC_STRUCTPAD5: + case FC_STRUCTPAD6: + case FC_STRUCTPAD7: + pMemory += *pFormat - FC_STRUCTPAD1 + 1; break; - case RPC_FC_EMBEDDED_COMPLEX: + case FC_EMBEDDED_COMPLEX: pMemory += pFormat[1]; pFormat += 2; desc = pFormat + *(const SHORT*)pFormat; @@ -3246,10 +3280,10 @@ static unsigned char * ComplexBufferSize(PMIDL_STUB_MESSAGE pStubMsg, if (m) { /* for some reason interface pointers aren't generated as - * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet + * FC_POINTER, but instead as FC_EMBEDDED_COMPLEX, yet * they still need the dereferencing treatment that pointers are * given */ - if (*desc == RPC_FC_IP) + if (*desc == FC_IP) m(pStubMsg, *(unsigned char **)pMemory, desc); else m(pStubMsg, pMemory, desc); @@ -3258,7 +3292,7 @@ static unsigned char * ComplexBufferSize(PMIDL_STUB_MESSAGE pStubMsg, pMemory += size; pFormat += 2; continue; - case RPC_FC_PAD: + case FC_PAD: break; default: FIXME("unhandled format 0x%02x\n", *pFormat); @@ -3274,71 +3308,72 @@ static unsigned char * ComplexFree(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, PFORMAT_STRING pPointer) { + unsigned char *mem_base = pMemory; PFORMAT_STRING desc; NDR_FREE m; ULONG size;
- while (*pFormat != RPC_FC_END) { + while (*pFormat != FC_END) { switch (*pFormat) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: pMemory += 1; break; - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: pMemory += 2; break; - case RPC_FC_LONG: - case RPC_FC_ULONG: - case RPC_FC_ENUM16: - case RPC_FC_ENUM32: - case RPC_FC_FLOAT: + case FC_LONG: + case FC_ULONG: + case FC_ENUM16: + case FC_ENUM32: + case FC_FLOAT: pMemory += 4; break; - case RPC_FC_INT3264: - case RPC_FC_UINT3264: + case FC_INT3264: + case FC_UINT3264: pMemory += sizeof(INT_PTR); break; - case RPC_FC_HYPER: - case RPC_FC_DOUBLE: + case FC_HYPER: + case FC_DOUBLE: pMemory += 8; break; - case RPC_FC_RP: - case RPC_FC_UP: - case RPC_FC_OP: - case RPC_FC_FP: - case RPC_FC_POINTER: - if (*pFormat != RPC_FC_POINTER) + case FC_RP: + case FC_UP: + case FC_OP: + case FC_FP: + case FC_POINTER: + if (*pFormat != FC_POINTER) pPointer = pFormat; NdrPointerFree(pStubMsg, *(unsigned char**)pMemory, pPointer); - if (*pFormat == RPC_FC_POINTER) + if (*pFormat == FC_POINTER) pPointer += 4; else pFormat += 4; pMemory += sizeof(void *); break; - case RPC_FC_ALIGNM2: - align_pointer(&pMemory, 2); + case FC_ALIGNM2: + align_pointer_offset(&pMemory, mem_base, 2); break; - case RPC_FC_ALIGNM4: - align_pointer(&pMemory, 4); + case FC_ALIGNM4: + align_pointer_offset(&pMemory, mem_base, 4); break; - case RPC_FC_ALIGNM8: - align_pointer(&pMemory, 8); + case FC_ALIGNM8: + align_pointer_offset(&pMemory, mem_base, 8); break; - case RPC_FC_STRUCTPAD1: - case RPC_FC_STRUCTPAD2: - case RPC_FC_STRUCTPAD3: - case RPC_FC_STRUCTPAD4: - case RPC_FC_STRUCTPAD5: - case RPC_FC_STRUCTPAD6: - case RPC_FC_STRUCTPAD7: - pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1; + case FC_STRUCTPAD1: + case FC_STRUCTPAD2: + case FC_STRUCTPAD3: + case FC_STRUCTPAD4: + case FC_STRUCTPAD5: + case FC_STRUCTPAD6: + case FC_STRUCTPAD7: + pMemory += *pFormat - FC_STRUCTPAD1 + 1; break; - case RPC_FC_EMBEDDED_COMPLEX: + case FC_EMBEDDED_COMPLEX: pMemory += pFormat[1]; pFormat += 2; desc = pFormat + *(const SHORT*)pFormat; @@ -3347,10 +3382,10 @@ static unsigned char * ComplexFree(PMIDL_STUB_MESSAGE pStubMsg, if (m) { /* for some reason interface pointers aren't generated as - * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet + * FC_POINTER, but instead as FC_EMBEDDED_COMPLEX, yet * they still need the dereferencing treatment that pointers are * given */ - if (*desc == RPC_FC_IP) + if (*desc == FC_IP) m(pStubMsg, *(unsigned char **)pMemory, desc); else m(pStubMsg, pMemory, desc); @@ -3358,7 +3393,7 @@ static unsigned char * ComplexFree(PMIDL_STUB_MESSAGE pStubMsg, pMemory += size; pFormat += 2; continue; - case RPC_FC_PAD: + case FC_PAD: break; default: FIXME("unhandled format 0x%02x\n", *pFormat); @@ -3376,53 +3411,53 @@ static ULONG ComplexStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING desc; ULONG size = 0;
- while (*pFormat != RPC_FC_END) { + while (*pFormat != FC_END) { switch (*pFormat) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: size += 1; safe_buffer_increment(pStubMsg, 1); break; - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: size += 2; safe_buffer_increment(pStubMsg, 2); break; - case RPC_FC_ENUM16: + case FC_ENUM16: size += 4; safe_buffer_increment(pStubMsg, 2); break; - case RPC_FC_LONG: - case RPC_FC_ULONG: - case RPC_FC_ENUM32: - case RPC_FC_FLOAT: + case FC_LONG: + case FC_ULONG: + case FC_ENUM32: + case FC_FLOAT: size += 4; safe_buffer_increment(pStubMsg, 4); break; - case RPC_FC_INT3264: - case RPC_FC_UINT3264: + case FC_INT3264: + case FC_UINT3264: size += sizeof(INT_PTR); safe_buffer_increment(pStubMsg, 4); break; - case RPC_FC_HYPER: - case RPC_FC_DOUBLE: + case FC_HYPER: + case FC_DOUBLE: size += 8; safe_buffer_increment(pStubMsg, 8); break; - case RPC_FC_RP: - case RPC_FC_UP: - case RPC_FC_OP: - case RPC_FC_FP: - case RPC_FC_POINTER: + case FC_RP: + case FC_UP: + case FC_OP: + case FC_FP: + case FC_POINTER: { unsigned char *saved_buffer; BOOL pointer_buffer_mark_set = FALSE; - if (*pFormat != RPC_FC_POINTER) + if (*pFormat != FC_POINTER) pPointer = pFormat; - if (*pPointer != RPC_FC_RP) + if (*pPointer != FC_RP) align_pointer(&pStubMsg->Buffer, 4); saved_buffer = pStubMsg->Buffer; if (pStubMsg->PointerBufferMark) @@ -3431,7 +3466,7 @@ static ULONG ComplexStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->PointerBufferMark = NULL; pointer_buffer_mark_set = TRUE; } - else if (*pPointer != RPC_FC_RP) + else if (*pPointer != FC_RP) safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
if (!pStubMsg->IgnoreEmbeddedPointers) @@ -3441,42 +3476,42 @@ static ULONG ComplexStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg, STD_OVERFLOW_CHECK(pStubMsg); pStubMsg->PointerBufferMark = pStubMsg->Buffer; pStubMsg->Buffer = saved_buffer; - if (*pPointer != RPC_FC_RP) + if (*pPointer != FC_RP) safe_buffer_increment(pStubMsg, 4); /* for pointer ID */ } - if (*pFormat == RPC_FC_POINTER) + if (*pFormat == FC_POINTER) pPointer += 4; else pFormat += 4; size += sizeof(void *); break; } - case RPC_FC_ALIGNM2: + case FC_ALIGNM2: align_length(&size, 2); break; - case RPC_FC_ALIGNM4: + case FC_ALIGNM4: align_length(&size, 4); break; - case RPC_FC_ALIGNM8: + case FC_ALIGNM8: align_length(&size, 8); break; - case RPC_FC_STRUCTPAD1: - case RPC_FC_STRUCTPAD2: - case RPC_FC_STRUCTPAD3: - case RPC_FC_STRUCTPAD4: - case RPC_FC_STRUCTPAD5: - case RPC_FC_STRUCTPAD6: - case RPC_FC_STRUCTPAD7: - size += *pFormat - RPC_FC_STRUCTPAD1 + 1; + case FC_STRUCTPAD1: + case FC_STRUCTPAD2: + case FC_STRUCTPAD3: + case FC_STRUCTPAD4: + case FC_STRUCTPAD5: + case FC_STRUCTPAD6: + case FC_STRUCTPAD7: + size += *pFormat - FC_STRUCTPAD1 + 1; break; - case RPC_FC_EMBEDDED_COMPLEX: + case FC_EMBEDDED_COMPLEX: size += pFormat[1]; pFormat += 2; desc = pFormat + *(const SHORT*)pFormat; size += EmbeddedComplexMemorySize(pStubMsg, desc); pFormat += 2; continue; - case RPC_FC_PAD: + case FC_PAD: break; default: FIXME("unhandled format 0x%02x\n", *pFormat); @@ -3492,69 +3527,69 @@ ULONG ComplexStructSize(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat) PFORMAT_STRING desc; ULONG size = 0;
- while (*pFormat != RPC_FC_END) { + while (*pFormat != FC_END) { switch (*pFormat) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: size += 1; break; - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: size += 2; break; - case RPC_FC_LONG: - case RPC_FC_ULONG: - case RPC_FC_ENUM16: - case RPC_FC_ENUM32: - case RPC_FC_FLOAT: + case FC_LONG: + case FC_ULONG: + case FC_ENUM16: + case FC_ENUM32: + case FC_FLOAT: size += 4; break; - case RPC_FC_INT3264: - case RPC_FC_UINT3264: + case FC_INT3264: + case FC_UINT3264: size += sizeof(INT_PTR); break; - case RPC_FC_HYPER: - case RPC_FC_DOUBLE: + case FC_HYPER: + case FC_DOUBLE: size += 8; break; - case RPC_FC_RP: - case RPC_FC_UP: - case RPC_FC_OP: - case RPC_FC_FP: - case RPC_FC_POINTER: + case FC_RP: + case FC_UP: + case FC_OP: + case FC_FP: + case FC_POINTER: size += sizeof(void *); - if (*pFormat != RPC_FC_POINTER) + if (*pFormat != FC_POINTER) pFormat += 4; break; - case RPC_FC_ALIGNM2: + case FC_ALIGNM2: align_length(&size, 2); break; - case RPC_FC_ALIGNM4: + case FC_ALIGNM4: align_length(&size, 4); break; - case RPC_FC_ALIGNM8: + case FC_ALIGNM8: align_length(&size, 8); break; - case RPC_FC_STRUCTPAD1: - case RPC_FC_STRUCTPAD2: - case RPC_FC_STRUCTPAD3: - case RPC_FC_STRUCTPAD4: - case RPC_FC_STRUCTPAD5: - case RPC_FC_STRUCTPAD6: - case RPC_FC_STRUCTPAD7: - size += *pFormat - RPC_FC_STRUCTPAD1 + 1; + case FC_STRUCTPAD1: + case FC_STRUCTPAD2: + case FC_STRUCTPAD3: + case FC_STRUCTPAD4: + case FC_STRUCTPAD5: + case FC_STRUCTPAD6: + case FC_STRUCTPAD7: + size += *pFormat - FC_STRUCTPAD1 + 1; break; - case RPC_FC_EMBEDDED_COMPLEX: + case FC_EMBEDDED_COMPLEX: size += pFormat[1]; pFormat += 2; desc = pFormat + *(const SHORT*)pFormat; size += EmbeddedComplexSize(pStubMsg, desc); pFormat += 2; continue; - case RPC_FC_PAD: + case FC_PAD: break; default: FIXME("unhandled format 0x%02x\n", *pFormat); @@ -3712,7 +3747,7 @@ unsigned char * WINAPI NdrComplexStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, if (!fMustAlloc && !*ppMemory) fMustAlloc = TRUE; if (fMustAlloc) - *ppMemory = NdrAllocate(pStubMsg, size); + *ppMemory = NdrAllocateZero(pStubMsg, size);
pMemory = ComplexUnmarshall(pStubMsg, *ppMemory, pFormat, pointer_desc, fMustAlloc);
@@ -3904,15 +3939,15 @@ unsigned char * WINAPI NdrConformantArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat) { TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat); - if (pFormat[0] != RPC_FC_CARRAY) + if (pFormat[0] != FC_CARRAY) { ERR("invalid format = 0x%x\n", pFormat[0]); RpcRaiseException(RPC_X_BAD_STUB_DATA); }
- array_compute_and_write_conformance(RPC_FC_CARRAY, pStubMsg, pMemory, + array_compute_and_write_conformance(FC_CARRAY, pStubMsg, pMemory, pFormat); - array_write_variance_and_marshall(RPC_FC_CARRAY, pStubMsg, pMemory, pFormat, + array_write_variance_and_marshall(FC_CARRAY, pStubMsg, pMemory, pFormat, TRUE /* fHasPointers */);
return NULL; @@ -3927,14 +3962,14 @@ unsigned char * WINAPI NdrConformantArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char fMustAlloc) { TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc); - if (pFormat[0] != RPC_FC_CARRAY) + if (pFormat[0] != FC_CARRAY) { ERR("invalid format = 0x%x\n", pFormat[0]); RpcRaiseException(RPC_X_BAD_STUB_DATA); }
- array_read_conformance(RPC_FC_CARRAY, pStubMsg, pFormat); - array_read_variance_and_unmarshall(RPC_FC_CARRAY, pStubMsg, ppMemory, pFormat, + array_read_conformance(FC_CARRAY, pStubMsg, pFormat); + array_read_variance_and_unmarshall(FC_CARRAY, pStubMsg, ppMemory, pFormat, fMustAlloc, TRUE /* fUseBufferMemoryServer */, TRUE /* fUnmarshall */); @@ -3950,14 +3985,14 @@ void WINAPI NdrConformantArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat) { TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat); - if (pFormat[0] != RPC_FC_CARRAY) + if (pFormat[0] != FC_CARRAY) { ERR("invalid format = 0x%x\n", pFormat[0]); RpcRaiseException(RPC_X_BAD_STUB_DATA); }
- array_compute_and_size_conformance(RPC_FC_CARRAY, pStubMsg, pMemory, pFormat); - array_buffer_size(RPC_FC_CARRAY, pStubMsg, pMemory, pFormat, + array_compute_and_size_conformance(FC_CARRAY, pStubMsg, pMemory, pFormat); + array_buffer_size(FC_CARRAY, pStubMsg, pMemory, pFormat, TRUE /* fHasPointers */); }
@@ -3968,14 +4003,14 @@ ULONG WINAPI NdrConformantArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat) { TRACE("(%p,%p)\n", pStubMsg, pFormat); - if (pFormat[0] != RPC_FC_CARRAY) + if (pFormat[0] != FC_CARRAY) { ERR("invalid format = 0x%x\n", pFormat[0]); RpcRaiseException(RPC_X_BAD_STUB_DATA); }
- array_read_conformance(RPC_FC_CARRAY, pStubMsg, pFormat); - array_memory_size(RPC_FC_CARRAY, pStubMsg, pFormat, TRUE /* fHasPointers */); + array_read_conformance(FC_CARRAY, pStubMsg, pFormat); + array_memory_size(FC_CARRAY, pStubMsg, pFormat, TRUE /* fHasPointers */);
return pStubMsg->MemorySize; } @@ -3988,13 +4023,13 @@ void WINAPI NdrConformantArrayFree(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat) { TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat); - if (pFormat[0] != RPC_FC_CARRAY) + if (pFormat[0] != FC_CARRAY) { ERR("invalid format = 0x%x\n", pFormat[0]); RpcRaiseException(RPC_X_BAD_STUB_DATA); }
- array_free(RPC_FC_CARRAY, pStubMsg, pMemory, pFormat, + array_free(FC_CARRAY, pStubMsg, pMemory, pFormat, TRUE /* fHasPointers */); }
@@ -4008,16 +4043,16 @@ unsigned char* WINAPI NdrConformantVaryingArrayMarshall( PMIDL_STUB_MESSAGE pStu { TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_CVARRAY) + if (pFormat[0] != FC_CVARRAY) { ERR("invalid format type %x\n", pFormat[0]); RpcRaiseException(RPC_S_INTERNAL_ERROR); return NULL; }
- array_compute_and_write_conformance(RPC_FC_CVARRAY, pStubMsg, pMemory, + array_compute_and_write_conformance(FC_CVARRAY, pStubMsg, pMemory, pFormat); - array_write_variance_and_marshall(RPC_FC_CVARRAY, pStubMsg, pMemory, + array_write_variance_and_marshall(FC_CVARRAY, pStubMsg, pMemory, pFormat, TRUE /* fHasPointers */);
return NULL; @@ -4034,15 +4069,15 @@ unsigned char* WINAPI NdrConformantVaryingArrayUnmarshall( PMIDL_STUB_MESSAGE pS { TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
- if (pFormat[0] != RPC_FC_CVARRAY) + if (pFormat[0] != FC_CVARRAY) { ERR("invalid format type %x\n", pFormat[0]); RpcRaiseException(RPC_S_INTERNAL_ERROR); return NULL; }
- array_read_conformance(RPC_FC_CVARRAY, pStubMsg, pFormat); - array_read_variance_and_unmarshall(RPC_FC_CVARRAY, pStubMsg, ppMemory, + array_read_conformance(FC_CVARRAY, pStubMsg, pFormat); + array_read_variance_and_unmarshall(FC_CVARRAY, pStubMsg, ppMemory, pFormat, fMustAlloc, TRUE /* fUseBufferMemoryServer */, TRUE /* fUnmarshall */); @@ -4060,14 +4095,14 @@ void WINAPI NdrConformantVaryingArrayFree( PMIDL_STUB_MESSAGE pStubMsg, { TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_CVARRAY) + if (pFormat[0] != FC_CVARRAY) { ERR("invalid format type %x\n", pFormat[0]); RpcRaiseException(RPC_S_INTERNAL_ERROR); return; }
- array_free(RPC_FC_CVARRAY, pStubMsg, pMemory, pFormat, + array_free(FC_CVARRAY, pStubMsg, pMemory, pFormat, TRUE /* fHasPointers */); }
@@ -4080,16 +4115,16 @@ void WINAPI NdrConformantVaryingArrayBufferSize( PMIDL_STUB_MESSAGE pStubMsg, { TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_CVARRAY) + if (pFormat[0] != FC_CVARRAY) { ERR("invalid format type %x\n", pFormat[0]); RpcRaiseException(RPC_S_INTERNAL_ERROR); return; }
- array_compute_and_size_conformance(RPC_FC_CVARRAY, pStubMsg, pMemory, + array_compute_and_size_conformance(FC_CVARRAY, pStubMsg, pMemory, pFormat); - array_buffer_size(RPC_FC_CVARRAY, pStubMsg, pMemory, pFormat, + array_buffer_size(FC_CVARRAY, pStubMsg, pMemory, pFormat, TRUE /* fHasPointers */); }
@@ -4102,15 +4137,15 @@ ULONG WINAPI NdrConformantVaryingArrayMemorySize( PMIDL_STUB_MESSAGE pStubMsg, { TRACE("(%p, %p)\n", pStubMsg, pFormat);
- if (pFormat[0] != RPC_FC_CVARRAY) + if (pFormat[0] != FC_CVARRAY) { ERR("invalid format type %x\n", pFormat[0]); RpcRaiseException(RPC_S_INTERNAL_ERROR); return pStubMsg->MemorySize; }
- array_read_conformance(RPC_FC_CVARRAY, pStubMsg, pFormat); - array_memory_size(RPC_FC_CVARRAY, pStubMsg, pFormat, + array_read_conformance(FC_CVARRAY, pStubMsg, pFormat); + array_memory_size(FC_CVARRAY, pStubMsg, pFormat, TRUE /* fHasPointers */);
return pStubMsg->MemorySize; @@ -4128,7 +4163,7 @@ unsigned char * WINAPI NdrComplexArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_BOGUS_ARRAY) + if (pFormat[0] != FC_BOGUS_ARRAY) { ERR("invalid format type %x\n", pFormat[0]); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -4164,8 +4199,8 @@ unsigned char * WINAPI NdrComplexArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->BufferLength = saved_buffer_length; }
- array_compute_and_write_conformance(RPC_FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat); - array_write_variance_and_marshall(RPC_FC_BOGUS_ARRAY, pStubMsg, + array_compute_and_write_conformance(FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat); + array_write_variance_and_marshall(FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat, TRUE /* fHasPointers */);
STD_OVERFLOW_CHECK(pStubMsg); @@ -4193,7 +4228,7 @@ unsigned char * WINAPI NdrComplexArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
- if (pFormat[0] != RPC_FC_BOGUS_ARRAY) + if (pFormat[0] != FC_BOGUS_ARRAY) { ERR("invalid format type %x\n", pFormat[0]); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -4220,8 +4255,8 @@ unsigned char * WINAPI NdrComplexArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, /* restore the original buffer */ pStubMsg->Buffer = saved_buffer;
- array_read_conformance(RPC_FC_BOGUS_ARRAY, pStubMsg, pFormat); - array_read_variance_and_unmarshall(RPC_FC_BOGUS_ARRAY, pStubMsg, ppMemory, pFormat, fMustAlloc, + array_read_conformance(FC_BOGUS_ARRAY, pStubMsg, pFormat); + array_read_variance_and_unmarshall(FC_BOGUS_ARRAY, pStubMsg, ppMemory, pFormat, fMustAlloc, TRUE /* fUseBufferMemoryServer */, TRUE /* fUnmarshall */);
if (pointer_buffer_mark_set) @@ -4244,7 +4279,7 @@ void WINAPI NdrComplexArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_BOGUS_ARRAY) + if (pFormat[0] != FC_BOGUS_ARRAY) { ERR("invalid format type %x\n", pFormat[0]); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -4278,8 +4313,8 @@ void WINAPI NdrComplexArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->BufferLength = saved_buffer_length; }
- array_compute_and_size_conformance(RPC_FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat); - array_buffer_size(RPC_FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat, TRUE /* fHasPointers */); + array_compute_and_size_conformance(FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat); + array_buffer_size(FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat, TRUE /* fHasPointers */);
if(pointer_length_set) { @@ -4296,15 +4331,15 @@ ULONG WINAPI NdrComplexArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg, { TRACE("(%p,%p)\n", pStubMsg, pFormat);
- if (pFormat[0] != RPC_FC_BOGUS_ARRAY) + if (pFormat[0] != FC_BOGUS_ARRAY) { ERR("invalid format type %x\n", pFormat[0]); RpcRaiseException(RPC_S_INTERNAL_ERROR); return 0; }
- array_read_conformance(RPC_FC_BOGUS_ARRAY, pStubMsg, pFormat); - array_memory_size(RPC_FC_BOGUS_ARRAY, pStubMsg, pFormat, TRUE /* fHasPointers */); + array_read_conformance(FC_BOGUS_ARRAY, pStubMsg, pFormat); + array_memory_size(FC_BOGUS_ARRAY, pStubMsg, pFormat, TRUE /* fHasPointers */); return pStubMsg->MemorySize; }
@@ -4319,7 +4354,7 @@ void WINAPI NdrComplexArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- if (pFormat[0] != RPC_FC_BOGUS_ARRAY) + if (pFormat[0] != FC_BOGUS_ARRAY) { ERR("invalid format type %x\n", pFormat[0]); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -4678,7 +4713,7 @@ unsigned char * WINAPI NdrConformantStructMarshall(PMIDL_STUB_MESSAGE pStubMsg, TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
pFormat += sizeof(NDR_CSTRUCT_FORMAT); - if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT)) + if ((pCStructFormat->type != FC_CPSTRUCT) && (pCStructFormat->type != FC_CSTRUCT)) { ERR("invalid format type %x\n", pCStructFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -4687,7 +4722,7 @@ unsigned char * WINAPI NdrConformantStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description + pCStructFormat->offset_to_array_description; - if (*pCArrayFormat != RPC_FC_CARRAY) + if (*pCArrayFormat != FC_CARRAY) { ERR("invalid array format type %x\n", pCStructFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -4715,7 +4750,7 @@ unsigned char * WINAPI NdrConformantStructMarshall(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->BufferMark = pStubMsg->Buffer; safe_copy_to_buffer(pStubMsg, pMemory, pCStructFormat->memory_size + bufsize);
- if (pCStructFormat->type == RPC_FC_CPSTRUCT) + if (pCStructFormat->type == FC_CPSTRUCT) EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
return NULL; @@ -4737,7 +4772,7 @@ unsigned char * WINAPI NdrConformantStructUnmarshall(PMIDL_STUB_MESSAGE pStubMs TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
pFormat += sizeof(NDR_CSTRUCT_FORMAT); - if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT)) + if ((pCStructFormat->type != FC_CPSTRUCT) && (pCStructFormat->type != FC_CSTRUCT)) { ERR("invalid format type %x\n", pCStructFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -4745,7 +4780,7 @@ unsigned char * WINAPI NdrConformantStructUnmarshall(PMIDL_STUB_MESSAGE pStubMs } pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description + pCStructFormat->offset_to_array_description; - if (*pCArrayFormat != RPC_FC_CARRAY) + if (*pCArrayFormat != FC_CARRAY) { ERR("invalid array format type %x\n", pCStructFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -4770,7 +4805,7 @@ unsigned char * WINAPI NdrConformantStructUnmarshall(PMIDL_STUB_MESSAGE pStubMs if (fMustAlloc) { SIZE_T size = pCStructFormat->memory_size + bufsize; - *ppMemory = NdrAllocate(pStubMsg, size); + *ppMemory = NdrAllocateZero(pStubMsg, size); } else { @@ -4781,7 +4816,7 @@ unsigned char * WINAPI NdrConformantStructUnmarshall(PMIDL_STUB_MESSAGE pStubMs
saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer; safe_buffer_increment(pStubMsg, pCStructFormat->memory_size + bufsize); - if (pCStructFormat->type == RPC_FC_CPSTRUCT) + if (pCStructFormat->type == FC_CPSTRUCT) EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat, fMustAlloc);
TRACE("copying %p to %p\n", saved_buffer, *ppMemory); @@ -4805,7 +4840,7 @@ void WINAPI NdrConformantStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg, TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
pFormat += sizeof(NDR_CSTRUCT_FORMAT); - if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT)) + if ((pCStructFormat->type != FC_CPSTRUCT) && (pCStructFormat->type != FC_CSTRUCT)) { ERR("invalid format type %x\n", pCStructFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -4813,7 +4848,7 @@ void WINAPI NdrConformantStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg, } pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description + pCStructFormat->offset_to_array_description; - if (*pCArrayFormat != RPC_FC_CARRAY) + if (*pCArrayFormat != FC_CARRAY) { ERR("invalid array format type %x\n", pCStructFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -4831,7 +4866,7 @@ void WINAPI NdrConformantStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg, safe_buffer_length_increment(pStubMsg, pCStructFormat->memory_size); safe_buffer_length_increment(pStubMsg, safe_multiply(pStubMsg->MaxCount, esize));
- if (pCStructFormat->type == RPC_FC_CPSTRUCT) + if (pCStructFormat->type == FC_CPSTRUCT) EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat); }
@@ -4858,7 +4893,7 @@ void WINAPI NdrConformantStructFree(PMIDL_STUB_MESSAGE pStubMsg, TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
pFormat += sizeof(NDR_CSTRUCT_FORMAT); - if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT)) + if ((pCStructFormat->type != FC_CPSTRUCT) && (pCStructFormat->type != FC_CSTRUCT)) { ERR("invalid format type %x\n", pCStructFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -4867,7 +4902,7 @@ void WINAPI NdrConformantStructFree(PMIDL_STUB_MESSAGE pStubMsg,
pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description + pCStructFormat->offset_to_array_description; - if (*pCArrayFormat != RPC_FC_CARRAY) + if (*pCArrayFormat != FC_CARRAY) { ERR("invalid array format type %x\n", pCStructFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -4882,7 +4917,7 @@ void WINAPI NdrConformantStructFree(PMIDL_STUB_MESSAGE pStubMsg, /* copy constant sized part of struct */ pStubMsg->BufferMark = pStubMsg->Buffer;
- if (pCStructFormat->type == RPC_FC_CPSTRUCT) + if (pCStructFormat->type == FC_CPSTRUCT) EmbeddedPointerFree(pStubMsg, pMemory, pFormat); }
@@ -4899,7 +4934,7 @@ unsigned char * WINAPI NdrConformantVaryingStructMarshall(PMIDL_STUB_MESSAGE pS TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
pFormat += sizeof(NDR_CVSTRUCT_FORMAT); - if (pCVStructFormat->type != RPC_FC_CVSTRUCT) + if (pCVStructFormat->type != FC_CVSTRUCT) { ERR("invalid format type %x\n", pCVStructFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -4948,7 +4983,7 @@ unsigned char * WINAPI NdrConformantVaryingStructUnmarshall(PMIDL_STUB_MESSAGE TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
pFormat += sizeof(NDR_CVSTRUCT_FORMAT); - if (pCVStructFormat->type != RPC_FC_CVSTRUCT) + if (pCVStructFormat->type != FC_CVSTRUCT) { ERR("invalid format type %x\n", pCVStructFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -4971,7 +5006,7 @@ unsigned char * WINAPI NdrConformantVaryingStructUnmarshall(PMIDL_STUB_MESSAGE if (fMustAlloc) { SIZE_T size = pCVStructFormat->memory_size + memsize; - *ppMemory = NdrAllocate(pStubMsg, size); + *ppMemory = NdrAllocateZero(pStubMsg, size); }
/* mark the start of the constant data */ @@ -5001,9 +5036,9 @@ unsigned char * WINAPI NdrConformantVaryingStructUnmarshall(PMIDL_STUB_MESSAGE memcpy(*ppMemory + pCVStructFormat->memory_size + offset, saved_array_buffer, bufsize);
- if (*pCVArrayFormat == RPC_FC_C_CSTRING) + if (*pCVArrayFormat == FC_C_CSTRING) TRACE("string=%s\n", debugstr_a((char *)(*ppMemory + pCVStructFormat->memory_size))); - else if (*pCVArrayFormat == RPC_FC_C_WSTRING) + else if (*pCVArrayFormat == FC_C_WSTRING) TRACE("string=%s\n", debugstr_w((WCHAR *)(*ppMemory + pCVStructFormat->memory_size)));
return NULL; @@ -5022,7 +5057,7 @@ void WINAPI NdrConformantVaryingStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg, TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
pFormat += sizeof(NDR_CVSTRUCT_FORMAT); - if (pCVStructFormat->type != RPC_FC_CVSTRUCT) + if (pCVStructFormat->type != FC_CVSTRUCT) { ERR("invalid format type %x\n", pCVStructFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -5060,7 +5095,7 @@ ULONG WINAPI NdrConformantVaryingStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg, TRACE("(%p, %p)\n", pStubMsg, pFormat);
pFormat += sizeof(NDR_CVSTRUCT_FORMAT); - if (pCVStructFormat->type != RPC_FC_CVSTRUCT) + if (pCVStructFormat->type != FC_CVSTRUCT) { ERR("invalid format type %x\n", pCVStructFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -5099,7 +5134,7 @@ void WINAPI NdrConformantVaryingStructFree(PMIDL_STUB_MESSAGE pStubMsg, TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
pFormat += sizeof(NDR_CVSTRUCT_FORMAT); - if (pCVStructFormat->type != RPC_FC_CVSTRUCT) + if (pCVStructFormat->type != FC_CVSTRUCT) { ERR("invalid format type %x\n", pCVStructFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -5145,8 +5180,8 @@ unsigned char * WINAPI NdrFixedArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) && - (pSmFArrayFormat->type != RPC_FC_LGFARRAY)) + if ((pSmFArrayFormat->type != FC_SMFARRAY) && + (pSmFArrayFormat->type != FC_LGFARRAY)) { ERR("invalid format type %x\n", pSmFArrayFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -5155,7 +5190,7 @@ unsigned char * WINAPI NdrFixedArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
align_pointer_clear(&pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
- if (pSmFArrayFormat->type == RPC_FC_SMFARRAY) + if (pSmFArrayFormat->type == FC_SMFARRAY) { total_size = pSmFArrayFormat->total_size; pFormat = (const unsigned char *)(pSmFArrayFormat + 1); @@ -5189,8 +5224,8 @@ unsigned char * WINAPI NdrFixedArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
- if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) && - (pSmFArrayFormat->type != RPC_FC_LGFARRAY)) + if ((pSmFArrayFormat->type != FC_SMFARRAY) && + (pSmFArrayFormat->type != FC_LGFARRAY)) { ERR("invalid format type %x\n", pSmFArrayFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -5199,7 +5234,7 @@ unsigned char * WINAPI NdrFixedArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
align_pointer(&pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
- if (pSmFArrayFormat->type == RPC_FC_SMFARRAY) + if (pSmFArrayFormat->type == FC_SMFARRAY) { total_size = pSmFArrayFormat->total_size; pFormat = (const unsigned char *)(pSmFArrayFormat + 1); @@ -5212,7 +5247,7 @@ unsigned char * WINAPI NdrFixedArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, }
if (fMustAlloc) - *ppMemory = NdrAllocate(pStubMsg, total_size); + *ppMemory = NdrAllocateZero(pStubMsg, total_size); else { if (!pStubMsg->IsClient && !*ppMemory) @@ -5243,8 +5278,8 @@ void WINAPI NdrFixedArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) && - (pSmFArrayFormat->type != RPC_FC_LGFARRAY)) + if ((pSmFArrayFormat->type != FC_SMFARRAY) && + (pSmFArrayFormat->type != FC_LGFARRAY)) { ERR("invalid format type %x\n", pSmFArrayFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -5253,7 +5288,7 @@ void WINAPI NdrFixedArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
align_length(&pStubMsg->BufferLength, pSmFArrayFormat->alignment + 1);
- if (pSmFArrayFormat->type == RPC_FC_SMFARRAY) + if (pSmFArrayFormat->type == FC_SMFARRAY) { total_size = pSmFArrayFormat->total_size; pFormat = (const unsigned char *)(pSmFArrayFormat + 1); @@ -5280,8 +5315,8 @@ ULONG WINAPI NdrFixedArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p)\n", pStubMsg, pFormat);
- if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) && - (pSmFArrayFormat->type != RPC_FC_LGFARRAY)) + if ((pSmFArrayFormat->type != FC_SMFARRAY) && + (pSmFArrayFormat->type != FC_LGFARRAY)) { ERR("invalid format type %x\n", pSmFArrayFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -5290,7 +5325,7 @@ ULONG WINAPI NdrFixedArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
align_pointer(&pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
- if (pSmFArrayFormat->type == RPC_FC_SMFARRAY) + if (pSmFArrayFormat->type == FC_SMFARRAY) { total_size = pSmFArrayFormat->total_size; pFormat = (const unsigned char *)(pSmFArrayFormat + 1); @@ -5321,15 +5356,15 @@ void WINAPI NdrFixedArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) && - (pSmFArrayFormat->type != RPC_FC_LGFARRAY)) + if ((pSmFArrayFormat->type != FC_SMFARRAY) && + (pSmFArrayFormat->type != FC_LGFARRAY)) { ERR("invalid format type %x\n", pSmFArrayFormat->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); return; }
- if (pSmFArrayFormat->type == RPC_FC_SMFARRAY) + if (pSmFArrayFormat->type == FC_SMFARRAY) pFormat = (const unsigned char *)(pSmFArrayFormat + 1); else { @@ -5353,8 +5388,8 @@ unsigned char * WINAPI NdrVaryingArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if ((pFormat[0] != RPC_FC_SMVARRAY) && - (pFormat[0] != RPC_FC_LGVARRAY)) + if ((pFormat[0] != FC_SMVARRAY) && + (pFormat[0] != FC_LGVARRAY)) { ERR("invalid format type %x\n", pFormat[0]); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -5363,7 +5398,7 @@ unsigned char * WINAPI NdrVaryingArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
alignment = pFormat[1] + 1;
- if (pFormat[0] == RPC_FC_SMVARRAY) + if (pFormat[0] == FC_SMVARRAY) { pFormat += 2; pFormat += sizeof(WORD); @@ -5418,8 +5453,8 @@ unsigned char * WINAPI NdrVaryingArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
- if ((pFormat[0] != RPC_FC_SMVARRAY) && - (pFormat[0] != RPC_FC_LGVARRAY)) + if ((pFormat[0] != FC_SMVARRAY) && + (pFormat[0] != FC_LGVARRAY)) { ERR("invalid format type %x\n", pFormat[0]); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -5428,7 +5463,7 @@ unsigned char * WINAPI NdrVaryingArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
alignment = pFormat[1] + 1;
- if (pFormat[0] == RPC_FC_SMVARRAY) + if (pFormat[0] == FC_SMVARRAY) { pFormat += 2; size = *(const WORD*)pFormat; @@ -5458,7 +5493,7 @@ unsigned char * WINAPI NdrVaryingArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, if (!fMustAlloc && !*ppMemory) fMustAlloc = TRUE; if (fMustAlloc) - *ppMemory = NdrAllocate(pStubMsg, size); + *ppMemory = NdrAllocateZero(pStubMsg, size); saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer; safe_buffer_increment(pStubMsg, bufsize);
@@ -5481,8 +5516,8 @@ void WINAPI NdrVaryingArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if ((pFormat[0] != RPC_FC_SMVARRAY) && - (pFormat[0] != RPC_FC_LGVARRAY)) + if ((pFormat[0] != FC_SMVARRAY) && + (pFormat[0] != FC_LGVARRAY)) { ERR("invalid format type %x\n", pFormat[0]); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -5491,7 +5526,7 @@ void WINAPI NdrVaryingArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
alignment = pFormat[1] + 1;
- if (pFormat[0] == RPC_FC_SMVARRAY) + if (pFormat[0] == FC_SMVARRAY) { pFormat += 2; pFormat += sizeof(WORD); @@ -5537,8 +5572,8 @@ ULONG WINAPI NdrVaryingArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p)\n", pStubMsg, pFormat);
- if ((pFormat[0] != RPC_FC_SMVARRAY) && - (pFormat[0] != RPC_FC_LGVARRAY)) + if ((pFormat[0] != FC_SMVARRAY) && + (pFormat[0] != FC_LGVARRAY)) { ERR("invalid format type %x\n", pFormat[0]); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -5547,7 +5582,7 @@ ULONG WINAPI NdrVaryingArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
alignment = pFormat[1] + 1;
- if (pFormat[0] == RPC_FC_SMVARRAY) + if (pFormat[0] == FC_SMVARRAY) { pFormat += 2; size = *(const WORD*)pFormat; @@ -5590,15 +5625,15 @@ void WINAPI NdrVaryingArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
- if ((pFormat[0] != RPC_FC_SMVARRAY) && - (pFormat[0] != RPC_FC_LGVARRAY)) + if ((pFormat[0] != FC_SMVARRAY) && + (pFormat[0] != FC_LGVARRAY)) { ERR("invalid format type %x\n", pFormat[0]); RpcRaiseException(RPC_S_INTERNAL_ERROR); return; }
- if (pFormat[0] == RPC_FC_SMVARRAY) + if (pFormat[0] == FC_SMVARRAY) { pFormat += 2; pFormat += sizeof(WORD); @@ -5630,23 +5665,20 @@ static ULONG get_discriminant(unsigned char fc, const unsigned char *pMemory) { switch (fc) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: return *pMemory; - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: - case RPC_FC_ENUM16: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: + case FC_ENUM16: return *(const USHORT *)pMemory; - case RPC_FC_LONG: - case RPC_FC_ULONG: - case RPC_FC_ENUM32: + case FC_LONG: + case FC_ULONG: + case FC_ENUM32: return *(const ULONG *)pMemory; - case RPC_FC_INT3264: - case RPC_FC_UINT3264: - return *(const ULONG_PTR *)pMemory; default: FIXME("Unhandled base type: 0x%02x\n", fc); return 0; @@ -5716,10 +5748,10 @@ static unsigned char *union_arm_marshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned c BOOL pointer_buffer_mark_set = FALSE; switch(*desc) { - case RPC_FC_RP: - case RPC_FC_UP: - case RPC_FC_OP: - case RPC_FC_FP: + case FC_RP: + case FC_UP: + case FC_OP: + case FC_FP: align_pointer_clear(&pStubMsg->Buffer, 4); saved_buffer = pStubMsg->Buffer; if (pStubMsg->PointerBufferMark) @@ -5745,7 +5777,7 @@ static unsigned char *union_arm_marshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned c pStubMsg->Buffer = saved_buffer + 4; } break; - case RPC_FC_IP: + case FC_IP: /* must be dereferenced first */ m(pStubMsg, *(unsigned char **)pMemory, desc); break; @@ -5789,10 +5821,10 @@ static unsigned char *union_arm_unmarshall(PMIDL_STUB_MESSAGE pStubMsg, BOOL pointer_buffer_mark_set = FALSE; switch(*desc) { - case RPC_FC_RP: - case RPC_FC_UP: - case RPC_FC_OP: - case RPC_FC_FP: + case FC_RP: + case FC_UP: + case FC_OP: + case FC_FP: align_pointer(&pStubMsg->Buffer, 4); saved_buffer = pStubMsg->Buffer; if (pStubMsg->PointerBufferMark) @@ -5819,7 +5851,7 @@ static unsigned char *union_arm_unmarshall(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->Buffer = saved_buffer + 4; } break; - case RPC_FC_IP: + case FC_IP: /* must be dereferenced first */ m(pStubMsg, *(unsigned char ***)ppMemory, desc, fMustAlloc); break; @@ -5860,10 +5892,10 @@ static void union_arm_buffer_size(PMIDL_STUB_MESSAGE pStubMsg, { switch(*desc) { - case RPC_FC_RP: - case RPC_FC_UP: - case RPC_FC_OP: - case RPC_FC_FP: + case FC_RP: + case FC_UP: + case FC_OP: + case FC_FP: align_length(&pStubMsg->BufferLength, 4); safe_buffer_length_increment(pStubMsg, 4); /* for pointer ID */ if (!pStubMsg->IgnoreEmbeddedPointers) @@ -5878,7 +5910,7 @@ static void union_arm_buffer_size(PMIDL_STUB_MESSAGE pStubMsg, pStubMsg->BufferLength = saved_buffer_length; } break; - case RPC_FC_IP: + case FC_IP: /* must be dereferenced first */ m(pStubMsg, *(unsigned char **)pMemory, desc); break; @@ -5919,10 +5951,10 @@ static ULONG union_arm_memory_size(PMIDL_STUB_MESSAGE pStubMsg, { switch(*desc) { - case RPC_FC_RP: - case RPC_FC_UP: - case RPC_FC_OP: - case RPC_FC_FP: + case FC_RP: + case FC_UP: + case FC_OP: + case FC_FP: align_pointer(&pStubMsg->Buffer, 4); saved_buffer = pStubMsg->Buffer; safe_buffer_increment(pStubMsg, 4); @@ -5965,13 +5997,13 @@ static void union_arm_free(PMIDL_STUB_MESSAGE pStubMsg, { switch(*desc) { - case RPC_FC_RP: - case RPC_FC_UP: - case RPC_FC_OP: - case RPC_FC_FP: + case FC_RP: + case FC_UP: + case FC_OP: + case FC_FP: PointerFree(pStubMsg, *(unsigned char **)pMemory, desc); break; - case RPC_FC_IP: + case FC_IP: /* must be dereferenced first */ m(pStubMsg, *(unsigned char **)pMemory, desc); break; @@ -6164,20 +6196,20 @@ static LONG unmarshall_discriminant(PMIDL_STUB_MESSAGE pStubMsg,
switch(**ppFormat) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: { UCHAR d; safe_copy_from_buffer(pStubMsg, &d, sizeof(d)); discriminant = d; break; } - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: - case RPC_FC_ENUM16: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: + case FC_ENUM16: { USHORT d; align_pointer(&pStubMsg->Buffer, sizeof(USHORT)); @@ -6185,8 +6217,8 @@ static LONG unmarshall_discriminant(PMIDL_STUB_MESSAGE pStubMsg, discriminant = d; break; } - case RPC_FC_LONG: - case RPC_FC_ULONG: + case FC_LONG: + case FC_ULONG: { ULONG d; align_pointer(&pStubMsg->Buffer, sizeof(ULONG)); @@ -6416,7 +6448,7 @@ static unsigned char *WINAPI NdrRangeMarshall(
TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
- if (pRange->type != RPC_FC_RANGE) + if (pRange->type != FC_RANGE) { ERR("invalid format type %x\n", pRange->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -6442,7 +6474,7 @@ unsigned char *WINAPI NdrRangeUnmarshall(
TRACE("pStubMsg: %p, ppMemory: %p, type: 0x%02x, fMustAlloc: %s\n", pStubMsg, ppMemory, *pFormat, fMustAlloc ? "true" : "false");
- if (pRange->type != RPC_FC_RANGE) + if (pRange->type != FC_RANGE) { ERR("invalid format type %x\n", pRange->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -6483,41 +6515,41 @@ unsigned char *WINAPI NdrRangeUnmarshall(
switch(base_type) { - case RPC_FC_CHAR: - case RPC_FC_SMALL: + case FC_CHAR: + case FC_SMALL: RANGE_UNMARSHALL(UCHAR, UCHAR, "%d"); TRACE("value: 0x%02x\n", **ppMemory); break; - case RPC_FC_BYTE: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_USMALL: RANGE_UNMARSHALL(CHAR, CHAR, "%u"); TRACE("value: 0x%02x\n", **ppMemory); break; - case RPC_FC_WCHAR: /* FIXME: valid? */ - case RPC_FC_USHORT: + case FC_WCHAR: /* FIXME: valid? */ + case FC_USHORT: RANGE_UNMARSHALL(USHORT, USHORT, "%u"); TRACE("value: 0x%04x\n", **(USHORT **)ppMemory); break; - case RPC_FC_SHORT: + case FC_SHORT: RANGE_UNMARSHALL(SHORT, SHORT, "%d"); TRACE("value: 0x%04x\n", **(USHORT **)ppMemory); break; - case RPC_FC_LONG: - case RPC_FC_ENUM32: + case FC_LONG: + case FC_ENUM32: RANGE_UNMARSHALL(LONG, LONG, "%d"); TRACE("value: 0x%08x\n", **(ULONG **)ppMemory); break; - case RPC_FC_ULONG: + case FC_ULONG: RANGE_UNMARSHALL(ULONG, ULONG, "%u"); TRACE("value: 0x%08x\n", **(ULONG **)ppMemory); break; - case RPC_FC_ENUM16: + case FC_ENUM16: RANGE_UNMARSHALL(UINT, USHORT, "%u"); TRACE("value: 0x%08x\n", **(UINT **)ppMemory); break; - case RPC_FC_FLOAT: - case RPC_FC_DOUBLE: - case RPC_FC_HYPER: + case FC_FLOAT: + case FC_DOUBLE: + case FC_HYPER: default: ERR("invalid range base type: 0x%02x\n", base_type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -6539,7 +6571,7 @@ static void WINAPI NdrRangeBufferSize(
TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
- if (pRange->type != RPC_FC_RANGE) + if (pRange->type != FC_RANGE) { ERR("invalid format type %x\n", pRange->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -6559,7 +6591,7 @@ static ULONG WINAPI NdrRangeMemorySize( const NDR_RANGE *pRange = (const NDR_RANGE *)pFormat; unsigned char base_type;
- if (pRange->type != RPC_FC_RANGE) + if (pRange->type != FC_RANGE) { ERR("invalid format type %x\n", pRange->type); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -6594,42 +6626,42 @@ static unsigned char *WINAPI NdrBaseTypeMarshall(
switch(*pFormat) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: safe_copy_to_buffer(pStubMsg, pMemory, sizeof(UCHAR)); TRACE("value: 0x%02x\n", *pMemory); break; - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: align_pointer_clear(&pStubMsg->Buffer, sizeof(USHORT)); safe_copy_to_buffer(pStubMsg, pMemory, sizeof(USHORT)); TRACE("value: 0x%04x\n", *(USHORT *)pMemory); break; - case RPC_FC_LONG: - case RPC_FC_ULONG: - case RPC_FC_ERROR_STATUS_T: - case RPC_FC_ENUM32: + case FC_LONG: + case FC_ULONG: + case FC_ERROR_STATUS_T: + case FC_ENUM32: align_pointer_clear(&pStubMsg->Buffer, sizeof(ULONG)); safe_copy_to_buffer(pStubMsg, pMemory, sizeof(ULONG)); TRACE("value: 0x%08x\n", *(ULONG *)pMemory); break; - case RPC_FC_FLOAT: + case FC_FLOAT: align_pointer_clear(&pStubMsg->Buffer, sizeof(float)); safe_copy_to_buffer(pStubMsg, pMemory, sizeof(float)); break; - case RPC_FC_DOUBLE: + case FC_DOUBLE: align_pointer_clear(&pStubMsg->Buffer, sizeof(double)); safe_copy_to_buffer(pStubMsg, pMemory, sizeof(double)); break; - case RPC_FC_HYPER: + case FC_HYPER: align_pointer_clear(&pStubMsg->Buffer, sizeof(ULONGLONG)); safe_copy_to_buffer(pStubMsg, pMemory, sizeof(ULONGLONG)); TRACE("value: %s\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory)); break; - case RPC_FC_ENUM16: + case FC_ENUM16: { USHORT val = *(UINT *)pMemory; /* only 16-bits on the wire, so do a sanity check */ @@ -6640,15 +6672,15 @@ static unsigned char *WINAPI NdrBaseTypeMarshall( TRACE("value: 0x%04x\n", *(UINT *)pMemory); break; } - case RPC_FC_INT3264: - case RPC_FC_UINT3264: + case FC_INT3264: + case FC_UINT3264: { UINT val = *(UINT_PTR *)pMemory; align_pointer_clear(&pStubMsg->Buffer, sizeof(UINT)); safe_copy_to_buffer(pStubMsg, &val, sizeof(val)); break; } - case RPC_FC_IGNORE: + case FC_IGNORE: break; default: FIXME("Unhandled base type: 0x%02x\n", *pFormat); @@ -6688,39 +6720,39 @@ static unsigned char *WINAPI NdrBaseTypeUnmarshall(
switch(*pFormat) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: BASE_TYPE_UNMARSHALL(UCHAR); TRACE("value: 0x%02x\n", **ppMemory); break; - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: BASE_TYPE_UNMARSHALL(USHORT); TRACE("value: 0x%04x\n", **(USHORT **)ppMemory); break; - case RPC_FC_LONG: - case RPC_FC_ULONG: - case RPC_FC_ERROR_STATUS_T: - case RPC_FC_ENUM32: + case FC_LONG: + case FC_ULONG: + case FC_ERROR_STATUS_T: + case FC_ENUM32: BASE_TYPE_UNMARSHALL(ULONG); TRACE("value: 0x%08x\n", **(ULONG **)ppMemory); break; - case RPC_FC_FLOAT: + case FC_FLOAT: BASE_TYPE_UNMARSHALL(float); TRACE("value: %f\n", **(float **)ppMemory); break; - case RPC_FC_DOUBLE: + case FC_DOUBLE: BASE_TYPE_UNMARSHALL(double); TRACE("value: %f\n", **(double **)ppMemory); break; - case RPC_FC_HYPER: + case FC_HYPER: BASE_TYPE_UNMARSHALL(ULONGLONG); TRACE("value: %s\n", wine_dbgstr_longlong(**(ULONGLONG **)ppMemory)); break; - case RPC_FC_ENUM16: + case FC_ENUM16: { USHORT val; align_pointer(&pStubMsg->Buffer, sizeof(USHORT)); @@ -6734,7 +6766,7 @@ static unsigned char *WINAPI NdrBaseTypeUnmarshall( TRACE("value: 0x%08x\n", **(UINT **)ppMemory); break; } - case RPC_FC_INT3264: + case FC_INT3264: if (sizeof(INT_PTR) == sizeof(INT)) BASE_TYPE_UNMARSHALL(INT); else { @@ -6749,7 +6781,7 @@ static unsigned char *WINAPI NdrBaseTypeUnmarshall( TRACE("value: 0x%08lx\n", **(INT_PTR **)ppMemory); } break; - case RPC_FC_UINT3264: + case FC_UINT3264: if (sizeof(UINT_PTR) == sizeof(UINT)) BASE_TYPE_UNMARSHALL(UINT); else { @@ -6764,7 +6796,7 @@ static unsigned char *WINAPI NdrBaseTypeUnmarshall( TRACE("value: 0x%08lx\n", **(UINT_PTR **)ppMemory); } break; - case RPC_FC_IGNORE: + case FC_IGNORE: break; default: FIXME("Unhandled base type: 0x%02x\n", *pFormat); @@ -6788,44 +6820,44 @@ static void WINAPI NdrBaseTypeBufferSize(
switch(*pFormat) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: safe_buffer_length_increment(pStubMsg, sizeof(UCHAR)); break; - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: - case RPC_FC_ENUM16: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: + case FC_ENUM16: align_length(&pStubMsg->BufferLength, sizeof(USHORT)); safe_buffer_length_increment(pStubMsg, sizeof(USHORT)); break; - case RPC_FC_LONG: - case RPC_FC_ULONG: - case RPC_FC_ENUM32: - case RPC_FC_INT3264: - case RPC_FC_UINT3264: + case FC_LONG: + case FC_ULONG: + case FC_ENUM32: + case FC_INT3264: + case FC_UINT3264: align_length(&pStubMsg->BufferLength, sizeof(ULONG)); safe_buffer_length_increment(pStubMsg, sizeof(ULONG)); break; - case RPC_FC_FLOAT: + case FC_FLOAT: align_length(&pStubMsg->BufferLength, sizeof(float)); safe_buffer_length_increment(pStubMsg, sizeof(float)); break; - case RPC_FC_DOUBLE: + case FC_DOUBLE: align_length(&pStubMsg->BufferLength, sizeof(double)); safe_buffer_length_increment(pStubMsg, sizeof(double)); break; - case RPC_FC_HYPER: + case FC_HYPER: align_length(&pStubMsg->BufferLength, sizeof(ULONGLONG)); safe_buffer_length_increment(pStubMsg, sizeof(ULONGLONG)); break; - case RPC_FC_ERROR_STATUS_T: + case FC_ERROR_STATUS_T: align_length(&pStubMsg->BufferLength, sizeof(error_status_t)); safe_buffer_length_increment(pStubMsg, sizeof(error_status_t)); break; - case RPC_FC_IGNORE: + case FC_IGNORE: break; default: FIXME("Unhandled base type: 0x%02x\n", *pFormat); @@ -6843,67 +6875,67 @@ static ULONG WINAPI NdrBaseTypeMemorySize(
switch(*pFormat) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: safe_buffer_increment(pStubMsg, sizeof(UCHAR)); pStubMsg->MemorySize += sizeof(UCHAR); return sizeof(UCHAR); - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: align_pointer(&pStubMsg->Buffer, sizeof(USHORT)); safe_buffer_increment(pStubMsg, sizeof(USHORT)); align_length(&pStubMsg->MemorySize, sizeof(USHORT)); pStubMsg->MemorySize += sizeof(USHORT); return sizeof(USHORT); - case RPC_FC_LONG: - case RPC_FC_ULONG: - case RPC_FC_ENUM32: + case FC_LONG: + case FC_ULONG: + case FC_ENUM32: align_pointer(&pStubMsg->Buffer, sizeof(ULONG)); safe_buffer_increment(pStubMsg, sizeof(ULONG)); align_length(&pStubMsg->MemorySize, sizeof(ULONG)); pStubMsg->MemorySize += sizeof(ULONG); return sizeof(ULONG); - case RPC_FC_FLOAT: + case FC_FLOAT: align_pointer(&pStubMsg->Buffer, sizeof(float)); safe_buffer_increment(pStubMsg, sizeof(float)); align_length(&pStubMsg->MemorySize, sizeof(float)); pStubMsg->MemorySize += sizeof(float); return sizeof(float); - case RPC_FC_DOUBLE: + case FC_DOUBLE: align_pointer(&pStubMsg->Buffer, sizeof(double)); safe_buffer_increment(pStubMsg, sizeof(double)); align_length(&pStubMsg->MemorySize, sizeof(double)); pStubMsg->MemorySize += sizeof(double); return sizeof(double); - case RPC_FC_HYPER: + case FC_HYPER: align_pointer(&pStubMsg->Buffer, sizeof(ULONGLONG)); safe_buffer_increment(pStubMsg, sizeof(ULONGLONG)); align_length(&pStubMsg->MemorySize, sizeof(ULONGLONG)); pStubMsg->MemorySize += sizeof(ULONGLONG); return sizeof(ULONGLONG); - case RPC_FC_ERROR_STATUS_T: + case FC_ERROR_STATUS_T: align_pointer(&pStubMsg->Buffer, sizeof(error_status_t)); safe_buffer_increment(pStubMsg, sizeof(error_status_t)); align_length(&pStubMsg->MemorySize, sizeof(error_status_t)); pStubMsg->MemorySize += sizeof(error_status_t); return sizeof(error_status_t); - case RPC_FC_ENUM16: + case FC_ENUM16: align_pointer(&pStubMsg->Buffer, sizeof(USHORT)); safe_buffer_increment(pStubMsg, sizeof(USHORT)); align_length(&pStubMsg->MemorySize, sizeof(UINT)); pStubMsg->MemorySize += sizeof(UINT); return sizeof(UINT); - case RPC_FC_INT3264: - case RPC_FC_UINT3264: + case FC_INT3264: + case FC_UINT3264: align_pointer(&pStubMsg->Buffer, sizeof(UINT)); safe_buffer_increment(pStubMsg, sizeof(UINT)); align_length(&pStubMsg->MemorySize, sizeof(UINT_PTR)); pStubMsg->MemorySize += sizeof(UINT_PTR); return sizeof(UINT_PTR); - case RPC_FC_IGNORE: + case FC_IGNORE: align_length(&pStubMsg->MemorySize, sizeof(void *)); pStubMsg->MemorySize += sizeof(void *); return sizeof(void *); @@ -6935,7 +6967,7 @@ static void WINAPI NdrContextHandleBufferSize( { TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
- if (*pFormat != RPC_FC_BIND_CONTEXT) + if (*pFormat != FC_BIND_CONTEXT) { ERR("invalid format type %x\n", *pFormat); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -6954,7 +6986,7 @@ static unsigned char *WINAPI NdrContextHandleMarshall( { TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
- if (*pFormat != RPC_FC_BIND_CONTEXT) + if (*pFormat != FC_BIND_CONTEXT) { ERR("invalid format type %x\n", *pFormat); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -6990,7 +7022,7 @@ static unsigned char *WINAPI NdrContextHandleUnmarshall( TRACE("pStubMsg %p, ppMemory %p, pFormat %p, fMustAlloc %s\n", pStubMsg, ppMemory, pFormat, fMustAlloc ? "TRUE": "FALSE");
- if (*pFormat != RPC_FC_BIND_CONTEXT) + if (*pFormat != FC_BIND_CONTEXT) { ERR("invalid format type %x\n", *pFormat); RpcRaiseException(RPC_S_INTERNAL_ERROR); @@ -7126,7 +7158,7 @@ NDR_SCONTEXT WINAPI NdrContextHandleInitialize(PMIDL_STUB_MESSAGE pStubMsg,
if (pFormat[1] & NDR_CONTEXT_HANDLE_SERIALIZE) flags |= RPC_CONTEXT_HANDLE_SERIALIZE; - if (pFormat[1] & NDR_CONTEXT_HANDLE_NO_SERIALIZE) + if (pFormat[1] & NDR_CONTEXT_HANDLE_NOSERIALIZE) flags |= RPC_CONTEXT_HANDLE_DONT_SERIALIZE; if (pFormat[1] & NDR_STRICT_CONTEXT_HANDLE) { @@ -7160,7 +7192,7 @@ void WINAPI NdrServerContextNewMarshall(PMIDL_STUB_MESSAGE pStubMsg,
if (pFormat[1] & NDR_CONTEXT_HANDLE_SERIALIZE) flags |= RPC_CONTEXT_HANDLE_SERIALIZE; - if (pFormat[1] & NDR_CONTEXT_HANDLE_NO_SERIALIZE) + if (pFormat[1] & NDR_CONTEXT_HANDLE_NOSERIALIZE) flags |= RPC_CONTEXT_HANDLE_DONT_SERIALIZE; if (pFormat[1] & NDR_STRICT_CONTEXT_HANDLE) { @@ -7193,7 +7225,7 @@ NDR_SCONTEXT WINAPI NdrServerContextNewUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
if (pFormat[1] & NDR_CONTEXT_HANDLE_SERIALIZE) flags |= RPC_CONTEXT_HANDLE_SERIALIZE; - if (pFormat[1] & NDR_CONTEXT_HANDLE_NO_SERIALIZE) + if (pFormat[1] & NDR_CONTEXT_HANDLE_NOSERIALIZE) flags |= RPC_CONTEXT_HANDLE_DONT_SERIALIZE; if (pFormat[1] & NDR_STRICT_CONTEXT_HANDLE) { diff --git a/dll/win32/rpcrt4/ndr_ole.c b/dll/win32/rpcrt4/ndr_ole.c index 0f0b7e7df2..c8026c0ff1 100644 --- a/dll/win32/rpcrt4/ndr_ole.c +++ b/dll/win32/rpcrt4/ndr_ole.c @@ -36,8 +36,8 @@
#include "ndr_misc.h" #include "rpcndr.h" +#include "ndrtypes.h" #include "rpcproxy.h" -#include "wine/rpcfc.h" #include "cpsf.h"
#include "wine/debug.h" @@ -288,8 +288,8 @@ static const IID* get_ip_iid(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory const IID *riid; if (!pFormat) return &IID_IUnknown; TRACE("format=%02x %02x\n", pFormat[0], pFormat[1]); - if (pFormat[0] != RPC_FC_IP) FIXME("format=%d\n", pFormat[0]); - if (pFormat[1] == RPC_FC_CONSTANT_IID) { + if (pFormat[0] != FC_IP) FIXME("format=%d\n", pFormat[0]); + if (pFormat[1] == FC_CONSTANT_IID) { riid = (const IID *)&pFormat[2]; } else { ComputeConformance(pStubMsg, pMemory, pFormat+2, 0); @@ -338,19 +338,25 @@ unsigned char * WINAPI NdrInterfacePointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg PFORMAT_STRING pFormat, unsigned char fMustAlloc) { + IUnknown **unk = (IUnknown **)ppMemory; LPSTREAM stream; HRESULT hr;
TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc); if (!LoadCOM()) return NULL; - *(LPVOID*)ppMemory = NULL; + + /* Avoid reference leaks for [in, out] pointers. */ + if (pStubMsg->IsClient && *unk) + IUnknown_Release(*unk); + + *unk = NULL; if (pStubMsg->Buffer + sizeof(DWORD) < (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength) { ULONG size;
hr = RpcStream_Create(pStubMsg, FALSE, &size, &stream); if (hr == S_OK) { if (size != 0) - hr = COM_UnmarshalInterface(stream, &IID_NULL, (LPVOID*)ppMemory); + hr = COM_UnmarshalInterface(stream, &IID_NULL, (void **)unk);
IStream_Release(stream); } diff --git a/dll/win32/rpcrt4/ndr_stubless.c b/dll/win32/rpcrt4/ndr_stubless.c index f84c61751a..c2f260c764 100644 --- a/dll/win32/rpcrt4/ndr_stubless.c +++ b/dll/win32/rpcrt4/ndr_stubless.c @@ -40,7 +40,6 @@
#include "wine/exception.h" #include "wine/debug.h" -#include "wine/rpcfc.h"
#include "cpsf.h" #include "ndr_misc.h" @@ -154,61 +153,60 @@ static DWORD calc_arg_size(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat) DWORD size; switch(*pFormat) { - case RPC_FC_RP: - if (pFormat[1] & RPC_FC_P_SIMPLEPOINTER) + case FC_RP: + if (pFormat[1] & FC_SIMPLE_POINTER) { - FIXME("Simple reference pointer (type %#x).\n", pFormat[2]); - size = sizeof(void *); + size = 0; break; } size = calc_arg_size(pStubMsg, &pFormat[2] + *(const SHORT*)&pFormat[2]); break; - case RPC_FC_STRUCT: - case RPC_FC_PSTRUCT: + case FC_STRUCT: + case FC_PSTRUCT: size = *(const WORD*)(pFormat + 2); break; - case RPC_FC_BOGUS_STRUCT: + case FC_BOGUS_STRUCT: size = *(const WORD*)(pFormat + 2); if(*(const WORD*)(pFormat + 4)) FIXME("Unhandled conformant description\n"); break; - case RPC_FC_CARRAY: - case RPC_FC_CVARRAY: + case FC_CARRAY: + case FC_CVARRAY: size = *(const WORD*)(pFormat + 2); ComputeConformance(pStubMsg, NULL, pFormat + 4, 0); size *= pStubMsg->MaxCount; break; - case RPC_FC_SMFARRAY: - case RPC_FC_SMVARRAY: + case FC_SMFARRAY: + case FC_SMVARRAY: size = *(const WORD*)(pFormat + 2); break; - case RPC_FC_LGFARRAY: - case RPC_FC_LGVARRAY: + case FC_LGFARRAY: + case FC_LGVARRAY: size = *(const DWORD*)(pFormat + 2); break; - case RPC_FC_BOGUS_ARRAY: + case FC_BOGUS_ARRAY: pFormat = ComputeConformance(pStubMsg, NULL, pFormat + 4, *(const WORD*)&pFormat[2]); TRACE("conformance = %ld\n", pStubMsg->MaxCount); pFormat = ComputeVariance(pStubMsg, NULL, pFormat, pStubMsg->MaxCount); size = ComplexStructSize(pStubMsg, pFormat); size *= pStubMsg->MaxCount; break; - case RPC_FC_USER_MARSHAL: + case FC_USER_MARSHAL: size = *(const WORD*)(pFormat + 4); break; - case RPC_FC_CSTRING: + case FC_CSTRING: size = *(const WORD*)(pFormat + 2); break; - case RPC_FC_WSTRING: + case FC_WSTRING: size = *(const WORD*)(pFormat + 2) * sizeof(WCHAR); break; - case RPC_FC_C_CSTRING: - case RPC_FC_C_WSTRING: - if (*pFormat == RPC_FC_C_CSTRING) + case FC_C_CSTRING: + case FC_C_WSTRING: + if (*pFormat == FC_C_CSTRING) size = sizeof(CHAR); else size = sizeof(WCHAR); - if (pFormat[1] == RPC_FC_STRING_SIZED) + if (pFormat[1] == FC_STRING_SIZED) ComputeConformance(pStubMsg, NULL, pFormat + 2, 0); else pStubMsg->MaxCount = 0; @@ -217,7 +215,10 @@ static DWORD calc_arg_size(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat) default: FIXME("Unhandled type %02x\n", *pFormat); /* fallthrough */ - case RPC_FC_IP: + case FC_UP: + case FC_OP: + case FC_FP: + case FC_IP: size = sizeof(void *); break; } @@ -279,10 +280,10 @@ static PFORMAT_STRING client_get_handle( switch (pProcHeader->handle_type) { /* explicit binding: parse additional section */ - case RPC_FC_BIND_EXPLICIT: + case 0: switch (*pFormat) /* handle_type */ { - case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */ + case FC_BIND_PRIMITIVE: /* explicit primitive */ { const NDR_EHD_PRIMITIVE *pDesc = (const NDR_EHD_PRIMITIVE *)pFormat;
@@ -294,7 +295,7 @@ static PFORMAT_STRING client_get_handle( *phBinding = *(handle_t *)ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset); return pFormat + sizeof(NDR_EHD_PRIMITIVE); } - case RPC_FC_BIND_GENERIC: /* explicit generic */ + case FC_BIND_GENERIC: /* explicit generic */ { const NDR_EHD_GENERIC *pDesc = (const NDR_EHD_GENERIC *)pFormat; void *pObject = NULL; @@ -312,7 +313,7 @@ static PFORMAT_STRING client_get_handle( *phBinding = pGenPair->pfnBind(pObject); return pFormat + sizeof(NDR_EHD_GENERIC); } - case RPC_FC_BIND_CONTEXT: /* explicit context */ + case FC_BIND_CONTEXT: /* explicit context */ { const NDR_EHD_CONTEXT *pDesc = (const NDR_EHD_CONTEXT *)pFormat; NDR_CCONTEXT context_handle; @@ -340,22 +341,22 @@ static PFORMAT_STRING client_get_handle( RpcRaiseException(RPC_X_BAD_STUB_DATA); } break; - case RPC_FC_BIND_GENERIC: /* implicit generic */ - FIXME("RPC_FC_BIND_GENERIC\n"); + case FC_BIND_GENERIC: /* implicit generic */ + FIXME("FC_BIND_GENERIC\n"); RpcRaiseException(RPC_X_BAD_STUB_DATA); /* FIXME: remove when implemented */ break; - case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */ + case FC_BIND_PRIMITIVE: /* implicit primitive */ TRACE("Implicit primitive handle\n"); *phBinding = *pStubMsg->StubDesc->IMPLICIT_HANDLE_INFO.pPrimitiveHandle; break; - case RPC_FC_CALLBACK_HANDLE: /* implicit callback */ - TRACE("RPC_FC_CALLBACK_HANDLE\n"); + case FC_CALLBACK_HANDLE: /* implicit callback */ + TRACE("FC_CALLBACK_HANDLE\n"); /* server calls callback procedures only in response to remote call, and most recent binding handle is used. Calling back to a client can potentially result in another callback with different current handle. */ *phBinding = I_RpcGetCurrentCallHandle(); break; - case RPC_FC_AUTO_HANDLE: /* implicit auto handle */ + case FC_AUTO_HANDLE: /* implicit auto handle */ /* strictly speaking, it isn't necessary to set hBinding here * since it isn't actually used (hence the automatic in its name), * but then why does MIDL generate a valid entry in the @@ -378,10 +379,10 @@ static void client_free_handle( switch (pProcHeader->handle_type) { /* explicit binding: parse additional section */ - case RPC_FC_BIND_EXPLICIT: + case 0: switch (*pFormat) /* handle_type */ { - case RPC_FC_BIND_GENERIC: /* explicit generic */ + case FC_BIND_GENERIC: /* explicit generic */ { const NDR_EHD_GENERIC *pDesc = (const NDR_EHD_GENERIC *)pFormat; void *pObject = NULL; @@ -399,21 +400,21 @@ static void client_free_handle( pGenPair->pfnUnbind(pObject, hBinding); break; } - case RPC_FC_BIND_CONTEXT: /* explicit context */ - case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */ + case FC_BIND_CONTEXT: /* explicit context */ + case FC_BIND_PRIMITIVE: /* explicit primitive */ break; default: ERR("bad explicit binding handle type (0x%02x)\n", pProcHeader->handle_type); RpcRaiseException(RPC_X_BAD_STUB_DATA); } break; - case RPC_FC_BIND_GENERIC: /* implicit generic */ - FIXME("RPC_FC_BIND_GENERIC\n"); + case FC_BIND_GENERIC: /* implicit generic */ + FIXME("FC_BIND_GENERIC\n"); RpcRaiseException(RPC_X_BAD_STUB_DATA); /* FIXME: remove when implemented */ break; - case RPC_FC_CALLBACK_HANDLE: /* implicit callback */ - case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */ - case RPC_FC_AUTO_HANDLE: /* implicit auto handle */ + case FC_CALLBACK_HANDLE: /* implicit callback */ + case FC_BIND_PRIMITIVE: /* implicit primitive */ + case FC_AUTO_HANDLE: /* implicit auto handle */ break; default: ERR("bad implicit binding handle type (0x%02x)\n", pProcHeader->handle_type); @@ -421,6 +422,50 @@ static void client_free_handle( } }
+static inline BOOL param_needs_alloc( PARAM_ATTRIBUTES attr ) +{ + return attr.IsOut && !attr.IsIn && !attr.IsBasetype && !attr.IsByValue; +} + +static inline BOOL param_is_out_basetype( PARAM_ATTRIBUTES attr ) +{ + return attr.IsOut && !attr.IsIn && attr.IsBasetype && attr.IsSimpleRef; +} + +static size_t basetype_arg_size( unsigned char fc ) +{ + switch (fc) + { + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: + return sizeof(char); + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: + return sizeof(short); + case FC_LONG: + case FC_ULONG: + case FC_ENUM16: + case FC_ENUM32: + case FC_ERROR_STATUS_T: + return sizeof(int); + case FC_FLOAT: + return sizeof(float); + case FC_HYPER: + return sizeof(LONGLONG); + case FC_DOUBLE: + return sizeof(double); + case FC_INT3264: + case FC_UINT3264: + return sizeof(INT_PTR); + default: + FIXME("Unhandled basetype %#x.\n", fc); + return 0; + } +} + void client_do_args( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, enum stubless_phase phase, void **fpu_args, unsigned short number_of_params, unsigned char *pRetVal ) { @@ -436,7 +481,7 @@ void client_do_args( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, enum s float f;
if (params[i].attr.IsBasetype && - params[i].u.type_format_char == RPC_FC_FLOAT && + params[i].u.type_format_char == FC_FLOAT && !params[i].attr.IsSimpleRef && !fpu_args) { @@ -452,10 +497,12 @@ void client_do_args( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, enum s switch (phase) { case STUBLESS_INITOUT: - if (!params[i].attr.IsBasetype && params[i].attr.IsOut && - !params[i].attr.IsIn && !params[i].attr.IsByValue) + if (*(unsigned char **)pArg) { - memset( *(unsigned char **)pArg, 0, calc_arg_size( pStubMsg, pTypeFormat )); + if (param_needs_alloc(params[i].attr)) + memset( *(unsigned char **)pArg, 0, calc_arg_size( pStubMsg, pTypeFormat )); + else if (param_is_out_basetype(params[i].attr)) + memset( *(unsigned char **)pArg, 0, basetype_arg_size( params[i].u.type_format_char )); } break; case STUBLESS_CALCSIZE: @@ -487,26 +534,26 @@ static unsigned int type_stack_size(unsigned char fc) { switch (fc) { - case RPC_FC_BYTE: - case RPC_FC_CHAR: - case RPC_FC_SMALL: - case RPC_FC_USMALL: - case RPC_FC_WCHAR: - case RPC_FC_SHORT: - case RPC_FC_USHORT: - case RPC_FC_LONG: - case RPC_FC_ULONG: - case RPC_FC_INT3264: - case RPC_FC_UINT3264: - case RPC_FC_ENUM16: - case RPC_FC_ENUM32: - case RPC_FC_FLOAT: - case RPC_FC_ERROR_STATUS_T: - case RPC_FC_IGNORE: + case FC_BYTE: + case FC_CHAR: + case FC_SMALL: + case FC_USMALL: + case FC_WCHAR: + case FC_SHORT: + case FC_USHORT: + case FC_LONG: + case FC_ULONG: + case FC_INT3264: + case FC_UINT3264: + case FC_ENUM16: + case FC_ENUM32: + case FC_FLOAT: + case FC_ERROR_STATUS_T: + case FC_IGNORE: return sizeof(void *); - case RPC_FC_DOUBLE: + case FC_DOUBLE: return sizeof(double); - case RPC_FC_HYPER: + case FC_HYPER: return sizeof(ULONGLONG); default: ERR("invalid base type 0x%x\n", fc); @@ -518,13 +565,13 @@ static BOOL is_by_value( PFORMAT_STRING format ) { switch (*format) { - case RPC_FC_USER_MARSHAL: - case RPC_FC_STRUCT: - case RPC_FC_PSTRUCT: - case RPC_FC_CSTRUCT: - case RPC_FC_CPSTRUCT: - case RPC_FC_CVSTRUCT: - case RPC_FC_BOGUS_STRUCT: + case FC_USER_MARSHAL: + case FC_STRUCT: + case FC_PSTRUCT: + case FC_CSTRUCT: + case FC_CPSTRUCT: + case FC_CVSTRUCT: + case FC_BOGUS_STRUCT: return TRUE; default: return FALSE; @@ -554,32 +601,32 @@ PFORMAT_STRING convert_old_args( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFo
switch (param->param_direction) { - case RPC_FC_IN_PARAM_BASETYPE: + case FC_IN_PARAM_BASETYPE: args[i].attr.IsIn = 1; args[i].attr.IsBasetype = 1; break; - case RPC_FC_RETURN_PARAM_BASETYPE: + case FC_RETURN_PARAM_BASETYPE: args[i].attr.IsOut = 1; args[i].attr.IsReturn = 1; args[i].attr.IsBasetype = 1; break; - case RPC_FC_IN_PARAM: + case FC_IN_PARAM: args[i].attr.IsIn = 1; args[i].attr.MustFree = 1; break; - case RPC_FC_IN_PARAM_NO_FREE_INST: + case FC_IN_PARAM_NO_FREE_INST: args[i].attr.IsIn = 1; args[i].attr.IsDontCallFreeInst = 1; break; - case RPC_FC_IN_OUT_PARAM: + case FC_IN_OUT_PARAM: args[i].attr.IsIn = 1; args[i].attr.IsOut = 1; args[i].attr.MustFree = 1; break; - case RPC_FC_OUT_PARAM: + case FC_OUT_PARAM: args[i].attr.IsOut = 1; break; - case RPC_FC_RETURN_PARAM: + case FC_RETURN_PARAM: args[i].attr.IsOut = 1; args[i].attr.IsReturn = 1; break; @@ -633,7 +680,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
TRACE("NDR Version: 0x%x\n", pStubDesc->Version);
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS) + if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS) { const NDR_PROC_HEADER_RPC *header_rpc = (const NDR_PROC_HEADER_RPC *)&pFormat[0]; stack_size = header_rpc->stack_size; @@ -650,10 +697,10 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM TRACE("proc num: %d\n", procedure_number);
/* create the full pointer translation tables, if requested */ - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR) + if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED) stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT) + if (pProcHeader->Oi_flags & Oi_OBJECT_PROC) { /* object is always the first argument */ This = stack_top[0]; @@ -669,7 +716,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM pHandleFormat = pFormat;
/* we only need a handle if this isn't an object method */ - if (!(pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)) + if (!(pProcHeader->Oi_flags & Oi_OBJECT_PROC)) { pFormat = client_get_handle(&stubMsg, pProcHeader, pHandleFormat, &hBinding); if (!pFormat) goto done; @@ -710,7 +757,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM else { pFormat = convert_old_args( &stubMsg, pFormat, stack_size, - pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT, + pProcHeader->Oi_flags & Oi_OBJECT_PROC, /* reuse the correlation cache, it's not needed for v1 format */ NdrCorrCache, sizeof(NdrCorrCache), &number_of_params ); } @@ -718,11 +765,11 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM stubMsg.BufferLength = 0;
/* store the RPC flags away */ - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS) + if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS) rpcMsg.RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
/* use alternate memory allocation routines */ - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC) + if (pProcHeader->Oi_flags & Oi_RPCSS_ALLOC_USED) NdrRpcSmSetClientToOsf(&stubMsg);
if (Oif_flags.HasPipes) @@ -749,11 +796,11 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM * 6. UNMARSHAL - unmarshal [out] params from buffer * 7. FREE - clear [out] parameters (for proxies, and only on error) */ - if ((pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT) || - (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_HAS_COMM_OR_FAULT)) + if ((pProcHeader->Oi_flags & Oi_OBJECT_PROC) || + (pProcHeader->Oi_flags & Oi_HAS_COMM_OR_FAULT)) { /* 1. INITOUT */ - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT) + if (pProcHeader->Oi_flags & Oi_OBJECT_PROC) { TRACE( "INITOUT\n" ); client_do_args(&stubMsg, pFormat, STUBLESS_INITOUT, fpu_stack, @@ -769,7 +816,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
/* 3. GETBUFFER */ TRACE( "GETBUFFER\n" ); - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT) + if (pProcHeader->Oi_flags & Oi_OBJECT_PROC) { /* allocate the buffer */ NdrProxyGetBuffer(This, &stubMsg); @@ -782,7 +829,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM FIXME("pipes not supported yet\n"); else { - if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE) + if (pProcHeader->handle_type == FC_AUTO_HANDLE) #if 0 NdrNsGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding); #else @@ -800,7 +847,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM
/* 5. SENDRECEIVE */ TRACE( "SENDRECEIVE\n" ); - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT) + if (pProcHeader->Oi_flags & Oi_OBJECT_PROC) { /* send the [in] params and receive the [out] and [retval] * params */ @@ -815,7 +862,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM FIXME("pipes not supported yet\n"); else { - if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE) + if (pProcHeader->handle_type == FC_AUTO_HANDLE) #if 0 NdrNsSendReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle); #else @@ -838,7 +885,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM } __EXCEPT_ALL { - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT) + if (pProcHeader->Oi_flags & Oi_OBJECT_PROC) { /* 7. FREE */ TRACE( "FREE\n" ); @@ -888,7 +935,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM FIXME("pipes not supported yet\n"); else { - if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE) + if (pProcHeader->handle_type == FC_AUTO_HANDLE) #if 0 NdrNsGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding); #else @@ -910,7 +957,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM FIXME("pipes not supported yet\n"); else { - if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE) + if (pProcHeader->handle_type == FC_AUTO_HANDLE) #if 0 NdrNsSendReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle); #else @@ -943,11 +990,11 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORM }
/* free the full pointer translation tables */ - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR) + if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED) NdrFullPointerXlatFree(stubMsg.FullPtrXlatTables);
/* free marshalling buffer */ - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT) + if (pProcHeader->Oi_flags & Oi_OBJECT_PROC) NdrProxyFreeBuffer(This, &stubMsg); else { @@ -1137,11 +1184,6 @@ LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, uns } #endif
-static inline BOOL param_needs_alloc( PARAM_ATTRIBUTES attr ) -{ - return attr.IsOut && !attr.IsIn && !attr.IsBasetype && !attr.IsByValue; -} - static LONG_PTR *stub_do_args(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat, enum stubless_phase phase, unsigned short number_of_params) @@ -1180,13 +1222,13 @@ static LONG_PTR *stub_do_args(MIDL_STUB_MESSAGE *pStubMsg, else if (param_needs_alloc(params[i].attr) && (!params[i].attr.MustFree || params[i].attr.IsSimpleRef)) { - if (*pTypeFormat != RPC_FC_BIND_CONTEXT) pStubMsg->pfnFree(*(void **)pArg); + if (*pTypeFormat != FC_BIND_CONTEXT) pStubMsg->pfnFree(*(void **)pArg); } break; case STUBLESS_INITOUT: if (param_needs_alloc(params[i].attr) && !params[i].attr.ServerAllocSize) { - if (*pTypeFormat == RPC_FC_BIND_CONTEXT) + if (*pTypeFormat == FC_BIND_CONTEXT) { NDR_SCONTEXT ctxt = NdrContextHandleInitialize(pStubMsg, pTypeFormat); *(void **)pArg = NDRSContextValue(ctxt); @@ -1276,7 +1318,7 @@ LONG WINAPI NdrStubCall2(
TRACE("NDR Version: 0x%x\n", pStubDesc->Version);
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS) + if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS) { const NDR_PROC_HEADER_RPC *header_rpc = (const NDR_PROC_HEADER_RPC *)&pFormat[0]; stack_size = header_rpc->stack_size; @@ -1295,16 +1337,16 @@ LONG WINAPI NdrStubCall2( switch (pProcHeader->handle_type) { /* explicit binding: parse additional section */ - case RPC_FC_BIND_EXPLICIT: + case 0: switch (*pFormat) /* handle_type */ { - case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */ + case FC_BIND_PRIMITIVE: /* explicit primitive */ pFormat += sizeof(NDR_EHD_PRIMITIVE); break; - case RPC_FC_BIND_GENERIC: /* explicit generic */ + case FC_BIND_GENERIC: /* explicit generic */ pFormat += sizeof(NDR_EHD_GENERIC); break; - case RPC_FC_BIND_CONTEXT: /* explicit context */ + case FC_BIND_CONTEXT: /* explicit context */ pFormat += sizeof(NDR_EHD_CONTEXT); break; default: @@ -1312,31 +1354,31 @@ LONG WINAPI NdrStubCall2( RpcRaiseException(RPC_X_BAD_STUB_DATA); } break; - case RPC_FC_BIND_GENERIC: /* implicit generic */ - case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */ - case RPC_FC_CALLBACK_HANDLE: /* implicit callback */ - case RPC_FC_AUTO_HANDLE: /* implicit auto handle */ + case FC_BIND_GENERIC: /* implicit generic */ + case FC_BIND_PRIMITIVE: /* implicit primitive */ + case FC_CALLBACK_HANDLE: /* implicit callback */ + case FC_AUTO_HANDLE: /* implicit auto handle */ break; default: ERR("bad implicit binding handle type (0x%02x)\n", pProcHeader->handle_type); RpcRaiseException(RPC_X_BAD_STUB_DATA); }
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT) + if (pProcHeader->Oi_flags & Oi_OBJECT_PROC) NdrStubInitialize(pRpcMsg, &stubMsg, pStubDesc, pChannel); else NdrServerInitializeNew(pRpcMsg, &stubMsg, pStubDesc);
/* create the full pointer translation tables, if requested */ - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR) + if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED) stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_SERVER);
/* store the RPC flags away */ - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS) + if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS) pRpcMsg->RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
/* use alternate memory allocation routines */ - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC) + if (pProcHeader->Oi_flags & Oi_RPCSS_ALLOC_USED) #if 0 NdrRpcSsEnableAllocate(&stubMsg); #else @@ -1389,7 +1431,7 @@ LONG WINAPI NdrStubCall2( else { pFormat = convert_old_args( &stubMsg, pFormat, stack_size, - pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT, + pProcHeader->Oi_flags & Oi_OBJECT_PROC, /* reuse the correlation cache, it's not needed for v1 format */ NdrCorrCache, sizeof(NdrCorrCache), &number_of_params ); } @@ -1413,7 +1455,7 @@ LONG WINAPI NdrStubCall2( SERVER_ROUTINE func; LONG_PTR retval;
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT) + if (pProcHeader->Oi_flags & Oi_OBJECT_PROC) { SERVER_ROUTINE *vtbl = *(SERVER_ROUTINE **)((CStdStubBuffer *)pThis)->pvServerObject; func = vtbl[pRpcMsg->ProcNum]; @@ -1438,7 +1480,7 @@ LONG WINAPI NdrStubCall2(
break; case STUBLESS_GETBUFFER: - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT) + if (pProcHeader->Oi_flags & Oi_OBJECT_PROC) NdrStubGetBuffer(pThis, pChannel, &stubMsg); else { @@ -1480,7 +1522,7 @@ LONG WINAPI NdrStubCall2( }
/* free the full pointer translation tables */ - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR) + if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED) NdrFullPointerXlatFree(stubMsg.FullPtrXlatTables);
/* free server function stack */ @@ -1565,7 +1607,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_async_client_call( PMIDL_STUB_DESC pStubDesc, async_call_data->pStubMsg = pStubMsg = (PMIDL_STUB_MESSAGE)(async_call_data + 1); pRpcMsg = (PRPC_MESSAGE)(pStubMsg + 1);
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS) + if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS) { const NDR_PROC_HEADER_RPC *header_rpc = (const NDR_PROC_HEADER_RPC *)&pFormat[0]; async_call_data->stack_size = header_rpc->stack_size; @@ -1582,10 +1624,10 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_async_client_call( PMIDL_STUB_DESC pStubDesc, TRACE("proc num: %d\n", procedure_number);
/* create the full pointer translation tables, if requested */ - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR) + if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED) pStubMsg->FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT) + if (pProcHeader->Oi_flags & Oi_OBJECT_PROC) { ERR("objects not supported\n"); I_RpcFree(async_call_data); @@ -1631,7 +1673,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_async_client_call( PMIDL_STUB_DESC pStubDesc, else { pFormat = convert_old_args( pStubMsg, pFormat, async_call_data->stack_size, - pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT, + pProcHeader->Oi_flags & Oi_OBJECT_PROC, async_call_data->NdrCorrCache, sizeof(async_call_data->NdrCorrCache), &async_call_data->number_of_params ); } @@ -1641,11 +1683,11 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_async_client_call( PMIDL_STUB_DESC pStubDesc, pStubMsg->BufferLength = 0;
/* store the RPC flags away */ - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS) + if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS) pRpcMsg->RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
/* use alternate memory allocation routines */ - if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC) + if (pProcHeader->Oi_flags & Oi_RPCSS_ALLOC_USED) NdrRpcSmSetClientToOsf(pStubMsg);
if (Oif_flags.HasPipes) @@ -1684,7 +1726,7 @@ LONG_PTR CDECL DECLSPEC_HIDDEN ndr_async_client_call( PMIDL_STUB_DESC pStubDesc, FIXME("pipes not supported yet\n"); else { - if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE) + if (pProcHeader->handle_type == FC_AUTO_HANDLE) #if 0 ... 1861 lines suppressed ...
-
Amine Khaldi