30 Jan
2019
30 Jan
'19
11:31 a.m.
https://git.reactos.org/?p=reactos.git;a=commitdiff;h=b6fdb56b9adf780902cc9…
commit b6fdb56b9adf780902cc9cf65af1f76365a96ce4
Author: Amine Khaldi <amine.khaldi(a)reactos.org>
AuthorDate: Wed Jan 30 12:31:33 2019 +0100
Commit: Amine Khaldi <amine.khaldi(a)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 ...