ReactOS  0.4.15-dev-439-g292f67a
ndr_marshall.c File Reference
#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <winnt.h>
#include <winerror.h>
#include <ole2.h>
#include "rpc.h"
#include "rpcdce.h"
#include "rpcproxy.h"
#include "midles.h"
#include "ndrtypes.h"
#include "wine/heap.h"
#include "wine/test.h"
Include dependency graph for ndr_marshall.c:

Go to the source code of this file.

Classes

struct  ps1_t
 
struct  aligned
 
struct  testiface
 

Macros

#define COBJMACROS
 
#define TEST_ZERO(field, fmt)   ok(stubMsg->field == 0, "%s: " #field " should have been set to zero instead of " fmt "\n", prefix, stubMsg->field)
 
#define TEST_POINTER_UNSET(field)   ok(stubMsg->field == unset_ptr, "%s: " #field " should have been unset instead of %p\n", prefix, stubMsg->field)
 
#define TEST_ULONG_UNSET(field)   ok(stubMsg->field == 0xcccccccc, "%s: " #field " should have been unset instead of 0x%x\n", prefix, stubMsg->field)
 
#define TEST_ULONG_PTR_UNSET(field)   ok(stubMsg->field == (ULONG_PTR)unset_ptr, "%s: " #field " should have been unset instead of 0x%lx\n", prefix, stubMsg->field)
 

Functions

static void *CALLBACK my_alloc (SIZE_T size)
 
static void CALLBACK my_free (void *ptr)
 
static void determine_pointer_marshalling_style (void)
 
static void test_ndr_simple_type (void)
 
static void test_pointer_marshal (const unsigned char *formattypes, void *memsrc, DWORD srcsize, const void *wiredata, ULONG wiredatalen, int(*cmp)(const void *, const void *, size_t), int num_additional_allocs, const char *msgpfx)
 
static int deref_cmp (const void *s1, const void *s2, size_t num)
 
static void test_simple_types (void)
 
static void test_nontrivial_pointer_types (void)
 
static void test_simple_struct_marshal (const unsigned char *formattypes, void *memsrc, DWORD srcsize, const void *wiredata, ULONG wiredatalen, int(*cmp)(const void *, const void *, size_t), int num_additional_allocs, const char *msgpfx)
 
static int ps1_cmp (const void *s1, const void *s2, size_t num)
 
static void test_simple_struct (void)
 
static void test_struct_align (void)
 
static struct testifaceimpl_from_IPersist (IPersist *iface)
 
static HRESULT WINAPI test_persist_QueryInterface (IPersist *iface, REFIID iid, void **out)
 
static ULONG WINAPI test_persist_AddRef (IPersist *iface)
 
static ULONG WINAPI test_persist_Release (IPersist *iface)
 
static HRESULT WINAPI test_persist_GetClassId (IPersist *iface, GUID *clsid)
 
static void test_iface_ptr (void)
 
static void test_fullpointer_xlat (void)
 
static void test_common_stub_data (const char *prefix, const MIDL_STUB_MESSAGE *stubMsg)
 
static void test_client_init (void)
 
static void test_server_init (void)
 
static void test_ndr_allocate (void)
 
static void test_conformant_array (void)
 
static void test_conformant_string (void)
 
static void test_nonconformant_string (void)
 
static void test_conf_complex_struct (void)
 
static void test_conf_complex_array (void)
 
static void test_ndr_buffer (void)
 
static void test_NdrMapCommAndFaultStatus (void)
 
static void test_NdrGetUserMarshalInfo (void)
 
static void test_MesEncodeFixedBufferHandleCreate (void)
 
static void test_NdrCorrelationInitialize (void)
 
 START_TEST (ndr_marshall)
 

Variables

static int my_alloc_called
 
static int my_free_called
 
static const MIDL_STUB_DESC Object_StubDesc
 
static RPC_DISPATCH_FUNCTION IFoo_table []
 
static RPC_DISPATCH_TABLE IFoo_v0_0_DispatchTable
 
static const RPC_SERVER_INTERFACE IFoo___RpcServerInterface
 
static RPC_IF_HANDLE IFoo_v0_0_s_ifspec = (RPC_IF_HANDLE)& IFoo___RpcServerInterface
 
static BOOL use_pointer_ids = FALSE
 
static IPersistVtbl testiface_vtbl
 

Macro Definition Documentation

◆ COBJMACROS

#define COBJMACROS

Definition at line 21 of file ndr_marshall.c.

◆ TEST_POINTER_UNSET

#define TEST_POINTER_UNSET (   field)    ok(stubMsg->field == unset_ptr, "%s: " #field " should have been unset instead of %p\n", prefix, stubMsg->field)

◆ TEST_ULONG_PTR_UNSET

#define TEST_ULONG_PTR_UNSET (   field)    ok(stubMsg->field == (ULONG_PTR)unset_ptr, "%s: " #field " should have been unset instead of 0x%lx\n", prefix, stubMsg->field)

◆ TEST_ULONG_UNSET

#define TEST_ULONG_UNSET (   field)    ok(stubMsg->field == 0xcccccccc, "%s: " #field " should have been unset instead of 0x%x\n", prefix, stubMsg->field)

◆ TEST_ZERO

#define TEST_ZERO (   field,
  fmt 
)    ok(stubMsg->field == 0, "%s: " #field " should have been set to zero instead of " fmt "\n", prefix, stubMsg->field)

Function Documentation

◆ deref_cmp()

static int deref_cmp ( const void s1,
const void s2,
size_t  num 
)
static

Definition at line 497 of file ndr_marshall.c.

498 {
499  return memcmp(*(const void *const *)s1, *(const void *const *)s2, num);
500 }
struct S2 s2
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
struct S1 s1
GLuint GLuint num
Definition: glext.h:9618

Referenced by test_simple_types().

◆ determine_pointer_marshalling_style()

static void determine_pointer_marshalling_style ( void  )
static

Definition at line 105 of file ndr_marshall.c.

106 {
107  RPC_MESSAGE RpcMessage;
108  MIDL_STUB_MESSAGE StubMsg;
109  MIDL_STUB_DESC StubDesc;
110  char ch = 0xde;
111 
112  static const unsigned char fmtstr_up_char[] =
113  {
114  0x12, 0x8, /* FC_UP [simple_pointer] */
115  0x2, /* FC_CHAR */
116  0x5c, /* FC_PAD */
117  };
118 
119  StubDesc = Object_StubDesc;
120  StubDesc.pFormatTypes = NULL;
121 
123  &RpcMessage,
124  &StubMsg,
125  &StubDesc,
126  0);
127 
128  StubMsg.BufferLength = 8;
129  StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
130  NdrPointerMarshall(&StubMsg, (unsigned char*)&ch, fmtstr_up_char);
131  ok(StubMsg.Buffer == StubMsg.BufferStart + 5, "%p %p\n", StubMsg.Buffer, StubMsg.BufferStart);
132 
133  use_pointer_ids = (*(unsigned int *)StubMsg.BufferStart != (UINT_PTR)&ch);
134  trace("Pointer marshalling using %s\n", use_pointer_ids ? "pointer ids" : "pointer value");
135 
136  HeapFree(GetProcessHeap(), 0, StubMsg.BufferStart);
137 }
static BOOL use_pointer_ids
Definition: ndr_marshall.c:103
unsigned char * Buffer
Definition: rpcndr.h:203
PRPC_MESSAGE RpcMsg
Definition: rpcndr.h:202
void * Buffer
Definition: rpcdcep.h:40
smooth NULL
Definition: ftsmooth.c:416
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
#define GetProcessHeap()
Definition: compat.h:404
#define trace
Definition: atltest.h:70
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned char *WINAPI NdrPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
const unsigned char * pFormatTypes
Definition: rpcndr.h:374
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
unsigned char * BufferStart
Definition: rpcndr.h:204
ULONG BufferLength
Definition: rpcndr.h:207
#define ok(value,...)
Definition: atltest.h:57
void WINAPI NdrClientInitializeNew(PRPC_MESSAGE pRpcMessage, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDesc, unsigned int ProcNum)
#define HeapFree(x, y, z)
Definition: compat.h:403

Referenced by START_TEST().

◆ impl_from_IPersist()

static struct testiface* impl_from_IPersist ( IPersist iface)
static

Definition at line 1279 of file ndr_marshall.c.

1280 {
1281  return CONTAINING_RECORD(iface, struct testiface, IPersist_iface);
1282 }
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560

Referenced by test_persist_AddRef(), and test_persist_Release().

◆ my_alloc()

static void* CALLBACK my_alloc ( SIZE_T  size)
static

Definition at line 42 of file ndr_marshall.c.

43 {
45  return NdrOleAllocate(size);
46 }
static int my_alloc_called
Definition: ndr_marshall.c:40
GLsizeiptr size
Definition: glext.h:5919
void *WINAPI NdrOleAllocate(SIZE_T Size)
Definition: ndr_ole.c:423

Referenced by test_common_stub_data(), test_conformant_string(), test_NdrGetUserMarshalInfo(), test_nontrivial_pointer_types(), and test_pointer_marshal().

◆ my_free()

static void CALLBACK my_free ( void ptr)
static

Definition at line 48 of file ndr_marshall.c.

49 {
51  NdrOleFree(ptr);
52 }
static int my_free_called
Definition: ndr_marshall.c:41
static PVOID ptr
Definition: dispmode.c:27
void WINAPI NdrOleFree(void *NodeToFree)
Definition: ndr_ole.c:432

Referenced by test_common_stub_data(), test_ndr_allocate(), test_NdrGetUserMarshalInfo(), test_nontrivial_pointer_types(), and test_simple_struct_marshal().

◆ ps1_cmp()

static int ps1_cmp ( const void s1,
const void s2,
size_t  num 
)
static

Definition at line 1045 of file ndr_marshall.c.

1046 {
1047  const ps1_t *p1, *p2;
1048 
1049  p1 = s1;
1050  p2 = s2;
1051 
1052  if(p1->l1 != p2->l1)
1053  return 1;
1054 
1055  if(p1->pl1 && p2->pl1)
1056  {
1057  if(*p1->pl1 != *p2->pl1)
1058  return 1;
1059  }
1060  else if(p1->pl1 || p2->pl1)
1061  return 1;
1062 
1063  if(p1->pc1 && p2->pc1)
1064  {
1065  if(*p1->pc1 != *p2->pc1)
1066  return 1;
1067  }
1068  else if(p1->pc1 || p2->pc1)
1069  return 1;
1070 
1071  return 0;
1072 }
LONG l1
struct S2 s2
LONG * pl1
char * pc1
struct S1 s1

Referenced by test_simple_struct().

◆ START_TEST()

START_TEST ( ndr_marshall  )

Definition at line 3003 of file ndr_marshall.c.

3004 {
3006 
3012  test_iface_ptr();
3014  test_client_init();
3015  test_server_init();
3022  test_ndr_buffer();
3027 }
static void test_simple_struct(void)
static void test_fullpointer_xlat(void)
static void test_conf_complex_struct(void)
static void test_ndr_buffer(void)
static void test_server_init(void)
static void test_NdrGetUserMarshalInfo(void)
static void test_iface_ptr(void)
static void test_MesEncodeFixedBufferHandleCreate(void)
static void test_nonconformant_string(void)
static void test_simple_types(void)
Definition: ndr_marshall.c:503
static void test_client_init(void)
static void test_struct_align(void)
static void test_NdrCorrelationInitialize(void)
static void test_conformant_array(void)
static void test_ndr_allocate(void)
static void test_NdrMapCommAndFaultStatus(void)
static void test_conf_complex_array(void)
static void test_nontrivial_pointer_types(void)
Definition: ndr_marshall.c:716
static void test_ndr_simple_type(void)
Definition: ndr_marshall.c:139
static void test_conformant_string(void)
static void determine_pointer_marshalling_style(void)
Definition: ndr_marshall.c:105

◆ test_client_init()

static void test_client_init ( void  )
static

Definition at line 1777 of file ndr_marshall.c.

1778 {
1779  MIDL_STUB_MESSAGE stubMsg;
1780  RPC_MESSAGE rpcMsg;
1781  void *unset_ptr;
1782 
1783  memset(&rpcMsg, 0xcc, sizeof(rpcMsg));
1784  memset(&stubMsg, 0xcc, sizeof(stubMsg));
1785  memset(&unset_ptr, 0xcc, sizeof(unset_ptr));
1786 
1787  NdrClientInitializeNew(&rpcMsg, &stubMsg, &Object_StubDesc, 1);
1788 
1789  test_common_stub_data( "NdrClientInitializeNew", &stubMsg );
1790 
1791  ok(stubMsg.RpcMsg == &rpcMsg, "stubMsg.RpcMsg should have been %p instead of %p\n", &rpcMsg, stubMsg.RpcMsg);
1792  ok(rpcMsg.Handle == NULL, "rpcMsg.Handle should have been NULL instead of %p\n", rpcMsg.Handle);
1793  ok(rpcMsg.Buffer == unset_ptr, "rpcMsg.Buffer should have been unset instead of %p\n",
1794  rpcMsg.Buffer);
1795  ok(rpcMsg.BufferLength == 0xcccccccc, "rpcMsg.BufferLength should have been unset instead of %d\n", rpcMsg.BufferLength);
1796  ok(rpcMsg.ProcNum == 0x8001, "rpcMsg.ProcNum should have been 0x8001 instead of 0x%x\n", rpcMsg.ProcNum);
1797  ok(rpcMsg.TransferSyntax == unset_ptr, "rpcMsg.TransferSyntax should have been unset instead of %p\n", rpcMsg.TransferSyntax);
1799  "rpcMsg.RpcInterfaceInformation should have been %p instead of %p\n",
1801  /* Note: ReservedForRuntime not tested */
1802  ok(rpcMsg.ManagerEpv == unset_ptr, "rpcMsg.ManagerEpv should have been unset instead of %p\n", rpcMsg.ManagerEpv);
1803  ok(rpcMsg.ImportContext == unset_ptr, "rpcMsg.ImportContext should have been unset instead of %p\n", rpcMsg.ImportContext);
1804  ok(rpcMsg.RpcFlags == 0, "rpcMsg.RpcFlags should have been 0 instead of 0x%x\n", rpcMsg.RpcFlags);
1805 
1806  ok(stubMsg.Buffer == unset_ptr, "stubMsg.Buffer should have been unset instead of %p\n",
1807  stubMsg.Buffer);
1808  ok(stubMsg.BufferStart == NULL, "stubMsg.BufferStart should have been NULL instead of %p\n",
1809  stubMsg.BufferStart);
1810  ok(stubMsg.BufferEnd == NULL, "stubMsg.BufferEnd should have been NULL instead of %p\n",
1811  stubMsg.BufferEnd);
1812  ok(stubMsg.BufferLength == 0, "stubMsg.BufferLength should have been 0 instead of %u\n",
1813  stubMsg.BufferLength);
1814  ok(stubMsg.IsClient == 1, "stubMsg.IsClient should have been 1 instead of %u\n", stubMsg.IsClient);
1815  ok(stubMsg.ReuseBuffer == 0, "stubMsg.ReuseBuffer should have been 0 instead of %d\n",
1816  stubMsg.ReuseBuffer);
1817  ok(stubMsg.CorrDespIncrement == 0, "stubMsg.CorrDespIncrement should have been 0 instead of %d\n",
1818  stubMsg.CorrDespIncrement);
1819  ok(stubMsg.FullPtrXlatTables == unset_ptr, "stubMsg.FullPtrXlatTables should have been unset instead of %p\n",
1820  stubMsg.FullPtrXlatTables);
1821 }
void * RpcInterfaceInformation
Definition: rpcdcep.h:44
void * RpcInterfaceInformation
Definition: rpcndr.h:362
unsigned char * Buffer
Definition: rpcndr.h:203
struct _FULL_PTR_XLAT_TABLES * FullPtrXlatTables
Definition: rpcndr.h:231
PRPC_MESSAGE RpcMsg
Definition: rpcndr.h:202
static void test_common_stub_data(const char *prefix, const MIDL_STUB_MESSAGE *stubMsg)
unsigned int BufferLength
Definition: rpcdcep.h:41
void * Buffer
Definition: rpcdcep.h:40
unsigned int ProcNum
Definition: rpcdcep.h:42
smooth NULL
Definition: ftsmooth.c:416
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
ULONG RpcFlags
Definition: rpcdcep.h:48
unsigned char * BufferStart
Definition: rpcndr.h:204
ULONG BufferLength
Definition: rpcndr.h:207
unsigned char * BufferEnd
Definition: rpcndr.h:205
PRPC_SYNTAX_IDENTIFIER TransferSyntax
Definition: rpcdcep.h:43
RPC_MGR_EPV * ManagerEpv
Definition: rpcdcep.h:46
unsigned char IsClient
Definition: rpcndr.h:210
#define ok(value,...)
Definition: atltest.h:57
unsigned char CorrDespIncrement
Definition: rpcndr.h:218
void * ImportContext
Definition: rpcdcep.h:47
void WINAPI NdrClientInitializeNew(PRPC_MESSAGE pRpcMessage, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDesc, unsigned int ProcNum)
#define memset(x, y, z)
Definition: compat.h:39
RPC_BINDING_HANDLE Handle
Definition: rpcdcep.h:38

Referenced by START_TEST().

◆ test_common_stub_data()

static void test_common_stub_data ( const char prefix,
const MIDL_STUB_MESSAGE stubMsg 
)
static

Definition at line 1677 of file ndr_marshall.c.

1678 {
1679  void *unset_ptr;
1680 
1681  memset(&unset_ptr, 0xcc, sizeof(unset_ptr));
1682 
1683 #define TEST_ZERO(field, fmt) ok(stubMsg->field == 0, "%s: " #field " should have been set to zero instead of " fmt "\n", prefix, stubMsg->field)
1684 #define TEST_POINTER_UNSET(field) ok(stubMsg->field == unset_ptr, "%s: " #field " should have been unset instead of %p\n", prefix, stubMsg->field)
1685 #define TEST_ULONG_UNSET(field) ok(stubMsg->field == 0xcccccccc, "%s: " #field " should have been unset instead of 0x%x\n", prefix, stubMsg->field)
1686 #define TEST_ULONG_PTR_UNSET(field) ok(stubMsg->field == (ULONG_PTR)unset_ptr, "%s: " #field " should have been unset instead of 0x%lx\n", prefix, stubMsg->field)
1687 
1688  TEST_POINTER_UNSET(BufferMark);
1691  TEST_ZERO(pAllocAllNodesContext, "%p");
1692  ok(stubMsg->pPointerQueueState == 0 ||
1693  broken(stubMsg->pPointerQueueState == unset_ptr), /* win2k */
1694  "%s: pPointerQueueState should have been unset instead of %p\n",
1695  prefix, stubMsg->pPointerQueueState);
1696  TEST_ZERO(IgnoreEmbeddedPointers, "%d");
1697  TEST_ZERO(PointerBufferMark, "%p");
1698  ok( stubMsg->uFlags == 0 ||
1699  broken(stubMsg->uFlags == 0xcc), /* win9x */
1700  "%s: uFlags should have been set to zero instead of 0x%x\n", prefix, stubMsg->uFlags );
1701  /* FIXME: UniquePtrCount */
1702  TEST_ULONG_PTR_UNSET(MaxCount);
1704  TEST_ULONG_UNSET(ActualCount);
1705  ok(stubMsg->pfnAllocate == my_alloc, "%s: pfnAllocate should have been %p instead of %p\n",
1706  prefix, my_alloc, stubMsg->pfnAllocate);
1707  ok(stubMsg->pfnFree == my_free, "%s: pfnFree should have been %p instead of %p\n",
1708  prefix, my_free, stubMsg->pfnFree);
1709  TEST_ZERO(StackTop, "%p");
1710  TEST_POINTER_UNSET(pPresentedType);
1711  TEST_POINTER_UNSET(pTransmitType);
1712  TEST_POINTER_UNSET(SavedHandle);
1713  ok(stubMsg->StubDesc == &Object_StubDesc, "%s: StubDesc should have been %p instead of %p\n",
1714  prefix, &Object_StubDesc, stubMsg->StubDesc);
1715  TEST_ZERO(FullPtrRefId, "%d");
1716  ok( stubMsg->PointerLength == 0 ||
1717  broken(stubMsg->PointerLength == 1), /* win9x, nt4 */
1718  "%s: pAsyncMsg should have been set to zero instead of %d\n", prefix, stubMsg->PointerLength );
1719  TEST_ZERO(fInDontFree, "%d");
1720  TEST_ZERO(fDontCallFreeInst, "%d");
1721  ok( stubMsg->fHasReturn == 0 || broken(stubMsg->fHasReturn), /* win9x, nt4 */
1722  "%s: fHasReturn should have been set to zero instead of %d\n", prefix, stubMsg->fHasReturn );
1723  TEST_ZERO(fHasExtensions, "%d");
1724  TEST_ZERO(fHasNewCorrDesc, "%d");
1725  ok(stubMsg->fIsIn == 0 || broken(stubMsg->fIsIn), /* win9x, nt4 */
1726  "%s: fIsIn should have been set to 0 instead of %d\n", prefix, stubMsg->fIsIn);
1727  TEST_ZERO(fIsOicf, "%d");
1728  ok(stubMsg->fBufferValid == 0,
1729  "%s: fBufferValid should have been set to 0 instead of %d\n", prefix, stubMsg->fBufferValid);
1730  TEST_ZERO(fNeedMCCP, "%d");
1731  ok(stubMsg->fUnused == 0 ||
1732  stubMsg->fUnused == -2, /* Vista */
1733  "%s: fUnused should have been set to 0 or -2 instead of %d\n", prefix, stubMsg->fUnused);
1734  ok(stubMsg->fUnused2 == 0xffffcccc, "%s: fUnused2 should have been 0xffffcccc instead of 0x%x\n",
1735  prefix, stubMsg->fUnused2);
1736  ok(stubMsg->dwDestContext == MSHCTX_DIFFERENTMACHINE,
1737  "%s: dwDestContext should have been MSHCTX_DIFFERENTMACHINE instead of %d\n",
1738  prefix, stubMsg->dwDestContext);
1739  TEST_ZERO(pvDestContext, "%p");
1740  TEST_POINTER_UNSET(SavedContextHandles);
1742  TEST_ZERO(pRpcChannelBuffer, "%p");
1743  TEST_ZERO(pArrayInfo, "%p");
1744  TEST_POINTER_UNSET(SizePtrCountArray);
1745  TEST_POINTER_UNSET(SizePtrOffsetArray);
1746  TEST_POINTER_UNSET(SizePtrLengthArray);
1747  TEST_POINTER_UNSET(pArgQueue);
1748  TEST_ZERO(dwStubPhase, "%d");
1749  /* FIXME: where does this value come from? */
1750  trace("%s: LowStackMark is %p\n", prefix, stubMsg->LowStackMark);
1751  ok( stubMsg->pAsyncMsg == 0 || broken(stubMsg->pAsyncMsg == unset_ptr), /* win9x, nt4 */
1752  "%s: pAsyncMsg should have been set to zero instead of %p\n", prefix, stubMsg->pAsyncMsg );
1753  ok( stubMsg->pCorrInfo == 0 || broken(stubMsg->pCorrInfo == unset_ptr), /* win9x, nt4 */
1754  "%s: pCorrInfo should have been set to zero instead of %p\n", prefix, stubMsg->pCorrInfo );
1755  ok( stubMsg->pCorrMemory == 0 || broken(stubMsg->pCorrMemory == unset_ptr), /* win9x, nt4 */
1756  "%s: pCorrMemory should have been set to zero instead of %p\n", prefix, stubMsg->pCorrMemory );
1757  ok( stubMsg->pMemoryList == 0 || broken(stubMsg->pMemoryList == unset_ptr), /* win9x, nt4 */
1758  "%s: pMemoryList should have been set to zero instead of %p\n", prefix, stubMsg->pMemoryList );
1759  TEST_POINTER_UNSET(pCSInfo);
1760  TEST_POINTER_UNSET(ConformanceMark);
1761  TEST_POINTER_UNSET(VarianceMark);
1762  ok(stubMsg->Unused == (ULONG_PTR)unset_ptr, "%s: Unused should have be unset instead of 0x%lx\n",
1763  prefix, stubMsg->Unused);
1764  TEST_POINTER_UNSET(pContext);
1765  TEST_POINTER_UNSET(ContextHandleHash);
1766  TEST_POINTER_UNSET(pUserMarshalList);
1767  TEST_ULONG_PTR_UNSET(Reserved51_3);
1768  TEST_ULONG_PTR_UNSET(Reserved51_4);
1769  TEST_ULONG_PTR_UNSET(Reserved51_5);
1770 
1771 #undef TEST_ULONG_PTR_UNSET
1772 #undef TEST_ULONG_UNSET
1773 #undef TEST_POINTER_UNSET
1774 #undef TEST_ZERO
1775 }
#define TEST_ULONG_UNSET(field)
static void CALLBACK my_free(void *ptr)
Definition: ndr_marshall.c:48
unsigned char * pCorrMemory
Definition: rpcndr.h:263
static ULONGLONG Memory
Definition: CcMapData_drv.c:35
const struct _MIDL_STUB_DESC * StubDesc
Definition: rpcndr.h:230
void * LowStackMark
Definition: rpcndr.h:260
uint32_t ULONG_PTR
Definition: typedefs.h:64
INT_PTR Unused
Definition: rpcndr.h:268
#define TEST_POINTER_UNSET(field)
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
DWORD dwDestContext
Definition: rpcndr.h:249
struct NDR_POINTER_QUEUE_STATE * pPointerQueueState
Definition: rpcndr.h:215
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
#define TEST_ZERO(field, fmt)
#define trace
Definition: atltest.h:70
void * pMemoryList
Definition: rpcndr.h:264
unsigned int fBufferValid
Definition: rpcndr.h:243
static CONST DWORD MemorySize[]
Definition: svga.c:32
PNDR_ASYNC_MESSAGE pAsyncMsg
Definition: rpcndr.h:261
#define broken(x)
Definition: _sntprintf.h:21
unsigned int fIsIn
Definition: rpcndr.h:240
PNDR_CORRELATION_INFO pCorrInfo
Definition: rpcndr.h:262
#define ok(value,...)
Definition: atltest.h:57
static void *CALLBACK my_alloc(SIZE_T size)
Definition: ndr_marshall.c:42
unsigned int fHasReturn
Definition: rpcndr.h:237
#define TEST_ULONG_PTR_UNSET(field)
unsigned char uFlags
Definition: rpcndr.h:219
#define memset(x, y, z)
Definition: compat.h:39
ULONG PointerLength
Definition: rpcndr.h:233

Referenced by test_client_init(), and test_server_init().

◆ test_conf_complex_array()

static void test_conf_complex_array ( void  )
static

Definition at line 2421 of file ndr_marshall.c.

2422 {
2423  RPC_MESSAGE RpcMessage;
2424  MIDL_STUB_MESSAGE StubMsg;
2425  MIDL_STUB_DESC StubDesc;
2426  void *ptr;
2427  unsigned int i, j;
2428  struct conf_complex
2429  {
2430  unsigned int dim1, dim2;
2431  DWORD **array;
2432  };
2433  struct conf_complex memsrc;
2434  struct conf_complex *mem;
2435  DWORD *buf, expected_length;
2436 
2437  static const unsigned char fmtstr_complex_array[] =
2438  {
2439 
2440 /* 0 */ 0x21, /* FC_BOGUS_ARRAY */
2441  0x3, /* 3 */
2442 /* 2 */ NdrFcShort( 0x0 ), /* 0 */
2443 /* 4 */ 0x19, 0x0, /* Corr desc: field pointer, FC_ULONG */
2444 /* 6 */ NdrFcShort( 0x4 ), /* 4 */
2445 /* 8 */ NdrFcLong( 0xffffffff ), /* -1 */
2446 /* 12 */ 0x8, /* FC_LONG */
2447  0x5b, /* FC_END */
2448 /* 14 */
2449  0x21, /* FC_BOGUS_ARRAY */
2450  0x3, /* 3 */
2451 /* 16 */ NdrFcShort( 0x0 ), /* 0 */
2452 /* 18 */ 0x19, /* Corr desc: field pointer, FC_ULONG */
2453  0x0, /* */
2454 /* 20 */ NdrFcShort( 0x0 ), /* 0 */
2455 /* 22 */ NdrFcLong( 0xffffffff ), /* -1 */
2456 /* 26 */ 0x12, 0x0, /* FC_UP */
2457 /* 28 */ NdrFcShort( 0xffe4 ), /* Offset= -28 (0) */
2458 /* 30 */ 0x5c, /* FC_PAD */
2459  0x5b, /* FC_END */
2460 
2461 #ifdef _WIN64
2462 /* 32 */ 0x1a, /* FC_BOGUS_STRUCT */
2463  0x3, /* 3 */
2464 /* 34 */ NdrFcShort( 0x10 ), /* 16 */
2465 /* 36 */ NdrFcShort( 0x0 ), /* 0 */
2466 /* 38 */ NdrFcShort( 0x6 ), /* Offset= 6 (44) */
2467 /* 40 */ 0x8, /* FC_LONG */
2468  0x8, /* FC_LONG */
2469 /* 42 */ 0x36, /* FC_POINTER */
2470  0x5b, /* FC_END */
2471 /* 44 */
2472  0x12, 0x0, /* FC_UP */
2473 /* 46 */ NdrFcShort( 0xffe0 ), /* Offset= -32 (14) */
2474 #else
2475 /* 32 */
2476  0x16, /* FC_PSTRUCT */
2477  0x3, /* 3 */
2478 /* 34 */ NdrFcShort( 0xc ), /* 12 */
2479 /* 36 */ 0x4b, /* FC_PP */
2480  0x5c, /* FC_PAD */
2481 /* 38 */ 0x46, /* FC_NO_REPEAT */
2482  0x5c, /* FC_PAD */
2483 /* 40 */ NdrFcShort( 0x8 ), /* 8 */
2484 /* 42 */ NdrFcShort( 0x8 ), /* 8 */
2485 /* 44 */ 0x12, 0x0, /* FC_UP */
2486 /* 46 */ NdrFcShort( 0xffe0 ), /* Offset= -32 (14) */
2487 /* 48 */ 0x5b, /* FC_END */
2488  0x8, /* FC_LONG */
2489 /* 50 */ 0x8, /* FC_LONG */
2490  0x8, /* FC_LONG */
2491 /* 52 */ 0x5c, /* FC_PAD */
2492  0x5b, /* FC_END */
2493 #endif
2494  };
2495 
2496  memsrc.dim1 = 5;
2497  memsrc.dim2 = 3;
2498 
2499  memsrc.array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, memsrc.dim1 * sizeof(DWORD*));
2500 
2501  for(i = 0; i < memsrc.dim1; i++)
2502  {
2503  memsrc.array[i] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, memsrc.dim2 * sizeof(DWORD));
2504  for(j = 0; j < memsrc.dim2; j++)
2505  memsrc.array[i][j] = i * memsrc.dim2 + j;
2506  }
2507 
2508  StubDesc = Object_StubDesc;
2509  StubDesc.pFormatTypes = fmtstr_complex_array;
2510 
2512  &RpcMessage,
2513  &StubMsg,
2514  &StubDesc,
2515  0);
2516 
2517  StubMsg.BufferLength = 0;
2518 
2519 #ifdef _WIN64
2520  NdrComplexStructBufferSize( &StubMsg,
2521  (unsigned char *)&memsrc,
2522  &fmtstr_complex_array[32] );
2523 #else
2524  NdrSimpleStructBufferSize( &StubMsg,
2525  (unsigned char *)&memsrc,
2526  &fmtstr_complex_array[32] );
2527 #endif
2528 
2529  expected_length = (4 + memsrc.dim1 * (2 + memsrc.dim2)) * 4;
2530  ok(StubMsg.BufferLength >= expected_length, "length %d\n", StubMsg.BufferLength);
2531 
2532  /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
2533  StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
2534  StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
2535 
2536 #ifdef _WIN64
2537  ptr = NdrComplexStructMarshall( &StubMsg, (unsigned char *)&memsrc,
2538  &fmtstr_complex_array[32] );
2539 #else
2540  ptr = NdrSimpleStructMarshall( &StubMsg, (unsigned char *)&memsrc,
2541  &fmtstr_complex_array[32] );
2542 #endif
2543 
2544  ok(ptr == NULL, "ret %p\n", ptr);
2545  ok((char*)StubMsg.Buffer == (char*)StubMsg.BufferStart + expected_length, "not at expected length\n");
2546 
2547  buf = (DWORD *)StubMsg.BufferStart;
2548 
2549  ok(*buf == memsrc.dim1, "dim1 should have been %d instead of %08x\n", memsrc.dim1, *buf);
2550  buf++;
2551  ok(*buf == memsrc.dim2, "dim2 should have been %d instead of %08x\n", memsrc.dim2, *buf);
2552  buf++;
2553  ok(*buf != 0, "pointer id should be non-zero\n");
2554  buf++;
2555  ok(*buf == memsrc.dim1, "Conformance should have been %d instead of %08x\n", memsrc.dim1, *buf);
2556  buf++;
2557  for(i = 0; i < memsrc.dim1; i++)
2558  {
2559  ok(*buf != 0, "pointer id[%d] should be non-zero\n", i);
2560  buf++;
2561  }
2562  for(i = 0; i < memsrc.dim1; i++)
2563  {
2564  ok(*buf == memsrc.dim2, "Conformance should have been %d instead of %08x\n", memsrc.dim2, *buf);
2565  buf++;
2566  for(j = 0; j < memsrc.dim2; j++)
2567  {
2568  ok(*buf == i * memsrc.dim2 + j, "got %08x\n", *buf);
2569  buf++;
2570  }
2571  }
2572 
2573  ok((void*)buf == StubMsg.Buffer, "not at end of buffer\n");
2574 
2575  /* Server */
2576  my_alloc_called = 0;
2577  StubMsg.IsClient = 0;
2578  mem = NULL;
2579  StubMsg.Buffer = StubMsg.BufferStart;
2580 #ifdef _WIN64
2581  ptr = NdrComplexStructUnmarshall( &StubMsg, (unsigned char **)&mem, &fmtstr_complex_array[32], 0);
2582 #else
2583  ptr = NdrSimpleStructUnmarshall( &StubMsg, (unsigned char **)&mem, &fmtstr_complex_array[32], 0);
2584 #endif
2585  ok(ptr == NULL, "ret %p\n", ptr);
2586  ok(mem->dim1 == memsrc.dim1, "mem->dim1 wasn't unmarshalled correctly (%d)\n", mem->dim1);
2587  ok(mem->dim2 == memsrc.dim2, "mem->dim2 wasn't unmarshalled correctly (%d)\n", mem->dim2);
2588  ok(mem->array[1][0] == memsrc.dim2, "mem->array[1][0] wasn't unmarshalled correctly (%d)\n", mem->array[1][0]);
2589 
2590  StubMsg.Buffer = StubMsg.BufferStart;
2591 #ifdef _WIN64
2592  NdrComplexStructFree( &StubMsg, (unsigned char*)mem, &fmtstr_complex_array[32]);
2593 #else
2594  NdrSimpleStructFree( &StubMsg, (unsigned char*)mem, &fmtstr_complex_array[32]);
2595 #endif
2596 
2597  HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
2598 
2599  for(i = 0; i < memsrc.dim1; i++)
2600  HeapFree(GetProcessHeap(), 0, memsrc.array[i]);
2601  HeapFree(GetProcessHeap(), 0, memsrc.array);
2602 }
unsigned char *WINAPI NdrSimpleStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
static int my_alloc_called
Definition: ndr_marshall.c:40
GLint x0
Definition: linetemp.h:95
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
void WINAPI NdrComplexStructFree(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char * Buffer
Definition: rpcndr.h:203
#define NdrFcShort(s)
Definition: rpcndr.h:134
void WINAPI NdrSimpleStructFree(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
PRPC_MESSAGE RpcMsg
Definition: rpcndr.h:202
unsigned char *WINAPI NdrComplexStructMarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
void * Buffer
Definition: rpcdcep.h:40
unsigned char *WINAPI NdrSimpleStructMarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
static PVOID ptr
Definition: dispmode.c:27
void WINAPI NdrSimpleStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
smooth NULL
Definition: ftsmooth.c:416
#define NdrFcLong(s)
Definition: rpcndr.h:135
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
#define GetProcessHeap()
Definition: compat.h:404
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned char *WINAPI NdrComplexStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
unsigned long DWORD
Definition: ntddk_ex.h:95
const unsigned char * pFormatTypes
Definition: rpcndr.h:374
unsigned char * BufferStart
Definition: rpcndr.h:204
ULONG BufferLength
Definition: rpcndr.h:207
unsigned char * BufferEnd
Definition: rpcndr.h:205
void WINAPI NdrComplexStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char IsClient
Definition: rpcndr.h:210
#define ok(value,...)
Definition: atltest.h:57
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
Definition: mem.c:156
void WINAPI NdrClientInitializeNew(PRPC_MESSAGE pRpcMessage, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDesc, unsigned int ProcNum)
#define HeapFree(x, y, z)
Definition: compat.h:403
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint GLenum GLenum GLenum GLint GLuint GLenum GLenum GLfloat GLenum GLfloat GLenum GLint const GLfloat GLenum GLint const GLushort GLint GLint GLsizei GLsizei GLenum GLsizei GLsizei GLenum GLenum const GLvoid GLenum GLdouble GLenum GLint GLenum GLenum GLint GLenum GLenum GLfloat GLenum GLenum GLfloat GLenum GLfloat GLenum GLushort const GLubyte GLenum GLenum GLenum GLint GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLvoid GLenum GLenum GLint GLenum GLint GLenum GLint GLuint GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble const GLfloat GLenum const GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble GLint GLint GLsizei GLsizei GLenum GLuint GLenum array
Definition: glfuncs.h:320

Referenced by START_TEST().

◆ test_conf_complex_struct()

static void test_conf_complex_struct ( void  )
static

Definition at line 2320 of file ndr_marshall.c.

2321 {
2322  RPC_MESSAGE RpcMessage;
2323  MIDL_STUB_MESSAGE StubMsg;
2324  MIDL_STUB_DESC StubDesc;
2325  void *ptr;
2326  unsigned int i;
2327  struct conf_complex
2328  {
2329  unsigned int size;
2330  unsigned int *array[1];
2331  };
2332  struct conf_complex *memsrc;
2333  struct conf_complex *mem;
2334 
2335  static const unsigned char fmtstr_complex_struct[] =
2336  {
2337 /* 0 */
2338  0x1b, /* FC_CARRAY */
2339  0x3, /* 3 */
2340 /* 2 */ NdrFcShort( 0x4 ), /* 4 */
2341 /* 4 */ 0x8, /* Corr desc: FC_LONG */
2342  0x0, /* */
2343 /* 6 */ NdrFcShort( 0xfffc ), /* -4 */
2344 /* 8 */
2345  0x4b, /* FC_PP */
2346  0x5c, /* FC_PAD */
2347 /* 10 */
2348  0x48, /* FC_VARIABLE_REPEAT */
2349  0x49, /* FC_FIXED_OFFSET */
2350 /* 12 */ NdrFcShort( 0x4 ), /* 4 */
2351 /* 14 */ NdrFcShort( 0x0 ), /* 0 */
2352 /* 16 */ NdrFcShort( 0x1 ), /* 1 */
2353 /* 18 */ NdrFcShort( 0x0 ), /* 0 */
2354 /* 20 */ NdrFcShort( 0x0 ), /* 0 */
2355 /* 22 */ 0x12, 0x8, /* FC_UP [simple_pointer] */
2356 /* 24 */ 0x8, /* FC_LONG */
2357  0x5c, /* FC_PAD */
2358 /* 26 */
2359  0x5b, /* FC_END */
2360 
2361  0x8, /* FC_LONG */
2362 /* 28 */ 0x5c, /* FC_PAD */
2363  0x5b, /* FC_END */
2364 /* 30 */
2365  0x1a, /* FC_BOGUS_STRUCT */
2366  0x3, /* 3 */
2367 /* 32 */ NdrFcShort( 0x4 ), /* 4 */
2368 /* 34 */ NdrFcShort( 0xffffffde ), /* Offset= -34 (0) */
2369 /* 36 */ NdrFcShort( 0x0 ), /* Offset= 0 (36) */
2370 /* 38 */ 0x8, /* FC_LONG */
2371  0x5b, /* FC_END */
2372  };
2373 
2375  FIELD_OFFSET(struct conf_complex, array[20]));
2376  memsrc->size = 20;
2377 
2378  StubDesc = Object_StubDesc;
2379  StubDesc.pFormatTypes = fmtstr_complex_struct;
2380 
2382  &RpcMessage,
2383  &StubMsg,
2384  &StubDesc,
2385  0);
2386 
2387  StubMsg.BufferLength = 0;
2388  NdrComplexStructBufferSize( &StubMsg,
2389  (unsigned char *)memsrc,
2390  &fmtstr_complex_struct[30] );
2391  ok(StubMsg.BufferLength >= 28, "length %d\n", StubMsg.BufferLength);
2392 
2393  /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
2394  StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
2395  StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
2396 
2397  ptr = NdrComplexStructMarshall( &StubMsg, (unsigned char *)memsrc,
2398  &fmtstr_complex_struct[30] );
2399  ok(ptr == NULL, "ret %p\n", ptr);
2400  ok(*(unsigned int *)StubMsg.BufferStart == 20, "Conformance should have been 20 instead of %d\n", *(unsigned int *)StubMsg.BufferStart);
2401  ok(*(unsigned int *)(StubMsg.BufferStart + 4) == 20, "conf_complex.size should have been 20 instead of %d\n", *(unsigned int *)(StubMsg.BufferStart + 4));
2402  for (i = 0; i < 20; i++)
2403  ok(*(unsigned int *)(StubMsg.BufferStart + 8 + i * 4) == 0, "pointer id for conf_complex.array[%d] should have been 0 instead of 0x%x\n", i, *(unsigned int *)(StubMsg.BufferStart + 8 + i * 4));
2404 
2405  /* Server */
2406  my_alloc_called = 0;
2407  StubMsg.IsClient = 0;
2408  mem = NULL;
2409  StubMsg.Buffer = StubMsg.BufferStart;
2410  ptr = NdrComplexStructUnmarshall( &StubMsg, (unsigned char **)&mem, &fmtstr_complex_struct[30], 0);
2411  ok(ptr == NULL, "ret %p\n", ptr);
2412  ok(mem->size == 20, "mem->size wasn't unmarshalled correctly (%d)\n", mem->size);
2413  ok(mem->array[0] == NULL, "mem->array[0] wasn't unmarshalled correctly (%p)\n", mem->array[0]);
2414  StubMsg.pfnFree(mem);
2415 
2416  HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
2417  HeapFree(GetProcessHeap(), 0, memsrc);
2418 }
static int my_alloc_called
Definition: ndr_marshall.c:40
GLint x0
Definition: linetemp.h:95
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3706
unsigned char * Buffer
Definition: rpcndr.h:203
#define NdrFcShort(s)
Definition: rpcndr.h:134
PRPC_MESSAGE RpcMsg
Definition: rpcndr.h:202
unsigned char *WINAPI NdrComplexStructMarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
void * Buffer
Definition: rpcdcep.h:40
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:404
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned char *WINAPI NdrComplexStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
const unsigned char * pFormatTypes
Definition: rpcndr.h:374
unsigned char * BufferStart
Definition: rpcndr.h:204
ULONG BufferLength
Definition: rpcndr.h:207
unsigned char * BufferEnd
Definition: rpcndr.h:205
void WINAPI NdrComplexStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char IsClient
Definition: rpcndr.h:210
#define ok(value,...)
Definition: atltest.h:57
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:254
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
Definition: mem.c:156
void WINAPI NdrClientInitializeNew(PRPC_MESSAGE pRpcMessage, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDesc, unsigned int ProcNum)
#define HeapFree(x, y, z)
Definition: compat.h:403

Referenced by START_TEST().

◆ test_conformant_array()

static void test_conformant_array ( void  )
static

Definition at line 1909 of file ndr_marshall.c.

1910 {
1911  RPC_MESSAGE RpcMessage;
1912  MIDL_STUB_MESSAGE StubMsg;
1913  MIDL_STUB_DESC StubDesc;
1914  void *ptr;
1915  unsigned char *mem, *mem_orig;
1916  unsigned char memsrc[20];
1917  unsigned int i;
1918 
1919  static const unsigned char fmtstr_conf_array[] =
1920  {
1921  0x1b, /* FC_CARRAY */
1922  0x0, /* align */
1923  NdrFcShort( 0x1 ), /* elem size */
1924  0x40, /* Corr desc: const */
1925  0x0,
1926  NdrFcShort(0x10), /* const = 0x10 */
1927  0x1, /* FC_BYTE */
1928  0x5b /* FC_END */
1929  };
1930 
1931  for (i = 0; i < sizeof(memsrc); i++)
1932  memsrc[i] = i * i;
1933 
1934  StubDesc = Object_StubDesc;
1935  StubDesc.pFormatTypes = fmtstr_conf_array;
1936 
1938  &RpcMessage,
1939  &StubMsg,
1940  &StubDesc,
1941  0);
1942 
1943  StubMsg.BufferLength = 0;
1944  NdrConformantArrayBufferSize( &StubMsg,
1945  memsrc,
1946  fmtstr_conf_array );
1947  ok(StubMsg.BufferLength >= 20, "length %d\n", StubMsg.BufferLength);
1948 
1949  /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1950  StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
1951  StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
1952 
1953  ptr = NdrConformantArrayMarshall( &StubMsg, memsrc, fmtstr_conf_array );
1954  ok(ptr == NULL, "ret %p\n", ptr);
1955  ok(StubMsg.Buffer - StubMsg.BufferStart == 20, "Buffer %p Start %p len %d\n", StubMsg.Buffer, StubMsg.BufferStart, 20);
1956  ok(!memcmp(StubMsg.BufferStart + 4, memsrc, 16), "incorrectly marshaled\n");
1957 
1958  StubMsg.Buffer = StubMsg.BufferStart;
1959  StubMsg.MemorySize = 0;
1960  mem = NULL;
1961 
1962  /* Client */
1963  my_alloc_called = 0;
1964  /* passing mem == NULL with must_alloc == 0 crashes under Windows */
1965  NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
1966  ok(mem != NULL, "mem not alloced\n");
1967  ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1968  ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1969 
1970  my_alloc_called = 0;
1971  StubMsg.Buffer = StubMsg.BufferStart;
1972  mem_orig = mem;
1973  NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
1974  ok(mem == mem_orig, "mem alloced\n");
1975  ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1976  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1977 
1978  my_alloc_called = 0;
1979  StubMsg.Buffer = StubMsg.BufferStart;
1980  NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
1981  ok(mem != mem_orig, "mem not alloced\n");
1982  ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1983  ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1984 
1985  my_free_called = 0;
1986  StubMsg.Buffer = StubMsg.BufferStart;
1987  NdrConformantArrayFree( &StubMsg, mem, fmtstr_conf_array );
1988  ok(my_free_called == 0, "free called %d\n", my_free_called);
1989  StubMsg.pfnFree(mem);
1990 
1991  /* Server */
1992  my_alloc_called = 0;
1993  StubMsg.IsClient = 0;
1994  mem = NULL;
1995  StubMsg.Buffer = StubMsg.BufferStart;
1996  NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
1997  ok(mem == StubMsg.BufferStart + 4 || broken(!mem), /* win9x, nt4 */
1998  "mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 4);
1999  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2000  my_alloc_called = 0;
2001  mem = NULL;
2002  StubMsg.Buffer = StubMsg.BufferStart;
2003  NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
2004  ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
2005  ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
2006  StubMsg.pfnFree(mem);
2007 
2008  my_alloc_called = 0;
2009  mem = mem_orig;
2010  StubMsg.Buffer = StubMsg.BufferStart;
2011  NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
2012  ok(mem == mem_orig, "mem alloced\n");
2013  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2014 
2015  my_alloc_called = 0;
2016  mem = mem_orig;
2017  StubMsg.Buffer = StubMsg.BufferStart;
2018  NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
2019  ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
2020  ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
2021  StubMsg.pfnFree(mem);
2022  StubMsg.pfnFree(mem_orig);
2023 
2024  HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
2025 }
static int my_alloc_called
Definition: ndr_marshall.c:40
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ULONG MemorySize
Definition: rpcndr.h:208
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3706
unsigned char * Buffer
Definition: rpcndr.h:203
static int my_free_called
Definition: ndr_marshall.c:41
#define NdrFcShort(s)
Definition: rpcndr.h:134
PRPC_MESSAGE RpcMsg
Definition: rpcndr.h:202
void WINAPI NdrConformantArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
void * Buffer
Definition: rpcdcep.h:40
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
unsigned char *WINAPI NdrConformantArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
#define GetProcessHeap()
Definition: compat.h:404
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
const unsigned char * pFormatTypes
Definition: rpcndr.h:374
unsigned char * BufferStart
Definition: rpcndr.h:204
ULONG BufferLength
Definition: rpcndr.h:207
unsigned char * BufferEnd
Definition: rpcndr.h:205
#define broken(x)
Definition: _sntprintf.h:21
unsigned char IsClient
Definition: rpcndr.h:210
#define ok(value,...)
Definition: atltest.h:57
Definition: mem.c:156
void WINAPI NdrClientInitializeNew(PRPC_MESSAGE pRpcMessage, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDesc, unsigned int ProcNum)
#define HeapFree(x, y, z)
Definition: compat.h:403
unsigned char *WINAPI NdrConformantArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
void WINAPI NdrConformantArrayFree(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)

Referenced by START_TEST().

◆ test_conformant_string()

static void test_conformant_string ( void  )
static

Definition at line 2027 of file ndr_marshall.c.

2028 {
2029  RPC_MESSAGE RpcMessage;
2030  MIDL_STUB_MESSAGE StubMsg;
2031  MIDL_STUB_DESC StubDesc;
2032  DWORD size;
2033  void *ptr;
2034  unsigned char *mem, *mem_orig;
2035  char memsrc[] = "This is a test string";
2036 
2037  static const unsigned char fmtstr_conf_str[] =
2038  {
2039  0x11, 0x8, /* FC_RP [simple_pointer] */
2040  0x22, /* FC_C_CSTRING */
2041  0x5c, /* FC_PAD */
2042  };
2043 
2044  StubDesc = Object_StubDesc;
2045  StubDesc.pFormatTypes = fmtstr_conf_str;
2046 
2047  memset( &StubMsg, 0, sizeof(StubMsg) ); /* needed on win9x and nt4 */
2049  &RpcMessage,
2050  &StubMsg,
2051  &StubDesc,
2052  0);
2053 
2054  StubMsg.BufferLength = 0;
2055  NdrPointerBufferSize( &StubMsg,
2056  (unsigned char *)memsrc,
2057  fmtstr_conf_str );
2058  ok(StubMsg.BufferLength >= sizeof(memsrc) + 12, "length %d\n", StubMsg.BufferLength);
2059 
2060  /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
2061  StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
2062  StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
2063 
2064  ptr = NdrPointerMarshall( &StubMsg, (unsigned char *)memsrc, fmtstr_conf_str );
2065  ok(ptr == NULL, "ret %p\n", ptr);
2066  size = StubMsg.Buffer - StubMsg.BufferStart;
2067  ok(size == sizeof(memsrc) + 12, "Buffer %p Start %p len %d\n",
2068  StubMsg.Buffer, StubMsg.BufferStart, size);
2069  ok(!memcmp(StubMsg.BufferStart + 12, memsrc, sizeof(memsrc)), "incorrectly marshaled\n");
2070 
2071  StubMsg.Buffer = StubMsg.BufferStart;
2072  StubMsg.MemorySize = 0;
2073  mem = NULL;
2074 
2075  /* Client */
2076  my_alloc_called = 0;
2077  StubMsg.Buffer = StubMsg.BufferStart;
2078  mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
2079  /* Windows apparently checks string length on the output buffer to determine its size... */
2080  memset( mem, 'x', sizeof(memsrc) - 1 );
2081  mem[sizeof(memsrc) - 1] = 0;
2082  NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
2083  ok(mem == mem_orig, "mem not alloced\n");
2084  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2085 
2086  my_alloc_called = 0;
2087  StubMsg.Buffer = StubMsg.BufferStart;
2088  NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
2089  ok(mem == mem_orig, "mem not alloced\n");
2090  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2091 
2092  /* Prevent a memory leak when running with Wine.
2093  Remove once the todo_wine block above is fixed. */
2094  if (mem != mem_orig)
2095  HeapFree(GetProcessHeap(), 0, mem_orig);
2096 
2097  my_free_called = 0;
2098  StubMsg.Buffer = StubMsg.BufferStart;
2099  NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
2100  ok(my_free_called == 1, "free called %d\n", my_free_called);
2101 
2102  mem = my_alloc(10);
2103  my_free_called = 0;
2104  StubMsg.Buffer = StubMsg.BufferStart;
2105  NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
2106  ok(my_free_called == 1, "free called %d\n", my_free_called);
2107 
2108  /* Server */
2109  my_alloc_called = 0;
2110  StubMsg.IsClient = 0;
2111  mem = NULL;
2112  StubMsg.Buffer = StubMsg.BufferStart;
2113  NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
2114  ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
2115  "mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
2116  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2117 
2118  my_alloc_called = 0;
2119  mem = NULL;
2120  StubMsg.Buffer = StubMsg.BufferStart;
2121  NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
2122  ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
2123  "mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
2124  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2125 
2126  my_alloc_called = 0;
2127  mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
2128  StubMsg.Buffer = StubMsg.BufferStart;
2129  NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
2130  ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
2131  "mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
2132  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2133 
2134  my_alloc_called = 0;
2135  mem = mem_orig;
2136  StubMsg.Buffer = StubMsg.BufferStart;
2137  NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
2138  ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
2139  "mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
2140  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2141 
2142  mem = my_alloc(10);
2143  my_free_called = 0;
2144  StubMsg.Buffer = StubMsg.BufferStart;
2145  NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
2146  ok(my_free_called == 1, "free called %d\n", my_free_called);
2147 
2148  HeapFree(GetProcessHeap(), 0, mem_orig);
2149  HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
2150 }
void WINAPI NdrPointerFree(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
static int my_alloc_called
Definition: ndr_marshall.c:40
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ULONG MemorySize
Definition: rpcndr.h:208
unsigned char * Buffer
Definition: rpcndr.h:203
static int my_free_called
Definition: ndr_marshall.c:41
PRPC_MESSAGE RpcMsg
Definition: rpcndr.h:202
void * Buffer
Definition: rpcdcep.h:40
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:404
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned char *WINAPI NdrPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned char *WINAPI NdrPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
const unsigned char * pFormatTypes
Definition: rpcndr.h:374
void WINAPI NdrPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char * BufferStart
Definition: rpcndr.h:204
ULONG BufferLength
Definition: rpcndr.h:207
unsigned char * BufferEnd
Definition: rpcndr.h:205
#define broken(x)
Definition: _sntprintf.h:21
unsigned char IsClient
Definition: rpcndr.h:210
#define ok(value,...)
Definition: atltest.h:57
static void *CALLBACK my_alloc(SIZE_T size)
Definition: ndr_marshall.c:42
Definition: mem.c:156
void WINAPI NdrClientInitializeNew(PRPC_MESSAGE pRpcMessage, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDesc, unsigned int ProcNum)
#define memset(x, y, z)
Definition: compat.h:39
#define HeapFree(x, y, z)
Definition: compat.h:403

Referenced by START_TEST().

◆ test_fullpointer_xlat()

static void test_fullpointer_xlat ( void  )
static

Definition at line 1547 of file ndr_marshall.c.

1548 {
1549  PFULL_PTR_XLAT_TABLES pXlatTables;
1550  ULONG RefId;
1551  int ret;
1552  void *Pointer;
1553 
1554  pXlatTables = NdrFullPointerXlatInit(2, XLAT_CLIENT);
1555 
1556  /* "marshaling" phase */
1557 
1558  ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
1559  ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1560  ok(RefId == 0x1, "RefId should be 0x1 instead of 0x%x\n", RefId);
1561 
1562  ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 0, &RefId);
1563  ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1564  ok(RefId == 0x1, "RefId should be 0x1 instead of 0x%x\n", RefId);
1565 
1566  ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebabe, 0, &RefId);
1567  ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1568  ok(RefId == 0x2, "RefId should be 0x2 instead of 0x%x\n", RefId);
1569 
1570  ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 0, &RefId);
1571  ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1572  ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
1573 
1574  ret = NdrFullPointerQueryPointer(pXlatTables, NULL, 0, &RefId);
1575  ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1576  ok(RefId == 0, "RefId should be 0 instead of 0x%x\n", RefId);
1577 
1578  /* "unmarshaling" phase */
1579 
1580  ret = NdrFullPointerQueryRefId(pXlatTables, 0x0, 0, &Pointer);
1581  ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1582 
1583  ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 0, &Pointer);
1584  ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1585  ok(Pointer == (void *)0xcafebabe, "Pointer should be 0xcafebabe instead of %p\n", Pointer);
1586 
1587  ret = NdrFullPointerQueryRefId(pXlatTables, 0x4, 0, &Pointer);
1588  ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1589  ok(Pointer == NULL, "Pointer should be NULL instead of %p\n", Pointer);
1590 
1591  NdrFullPointerInsertRefId(pXlatTables, 0x4, (void *)0xdeadbabe);
1592 
1593  ret = NdrFullPointerQueryRefId(pXlatTables, 0x4, 1, &Pointer);
1594  ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1595  ok(Pointer == (void *)0xdeadbabe, "Pointer should be (void *)0xdeadbabe instead of %p\n", Pointer);
1596 
1597  NdrFullPointerXlatFree(pXlatTables);
1598 
1599  pXlatTables = NdrFullPointerXlatInit(2, XLAT_SERVER);
1600 
1601  /* "unmarshaling" phase */
1602 
1603  ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 1, &Pointer);
1604  ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1605  ok(Pointer == NULL, "Pointer should be NULL instead of %p\n", Pointer);
1606 
1607  NdrFullPointerInsertRefId(pXlatTables, 0x2, (void *)0xcafebabe);
1608 
1609  ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 0, &Pointer);
1610  ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1611  ok(Pointer == (void *)0xcafebabe, "Pointer should be (void *)0xcafebabe instead of %p\n", Pointer);
1612 
1613  ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 1, &Pointer);
1614  ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1615  ok(Pointer == (void *)0xcafebabe, "Pointer should be (void *)0xcafebabe instead of %p\n", Pointer);
1616 
1617  /* "marshaling" phase */
1618 
1619  ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
1620  ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1621  ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
1622 
1623  ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
1624  ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1625  ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
1626 
1627  ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 0, &RefId);
1628  ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1629  ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
1630 
1631  ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebabe, 0, &RefId);
1632  ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1633  ok(RefId == 0x2, "RefId should be 0x2 instead of 0x%x\n", RefId);
1634 
1635  ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 0, &RefId);
1636  ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1637  ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
1638 
1639  /* "freeing" phase */
1640 
1641  ret = NdrFullPointerFree(pXlatTables, (void *)0xcafebeef);
1642  ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1643 
1644  ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 0x20, &RefId);
1645  ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1646  ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
1647 
1648  ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
1649  ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1650  ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
1651 
1652  ret = NdrFullPointerFree(pXlatTables, (void *)0xcafebabe);
1653  ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1654 
1655  ret = NdrFullPointerFree(pXlatTables, (void *)0xdeadbeef);
1656  ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1657 
1658  ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 0x20, &RefId);
1659  ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1660  ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
1661 
1662  ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 1, &RefId);
1663  ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1664  ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
1665 
1666  ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 1, &RefId);
1667  ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1668  ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
1669 
1670  ret = NdrFullPointerFree(pXlatTables, (void *)0xdeadbeef);
1671  ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1672 
1673  NdrFullPointerXlatFree(pXlatTables);
1674 }
int WINAPI NdrFullPointerQueryRefId(PFULL_PTR_XLAT_TABLES pXlatTables, ULONG RefId, unsigned char QueryType, void **ppPointer)
GLint x0
Definition: linetemp.h:95
void WINAPI NdrFullPointerXlatFree(PFULL_PTR_XLAT_TABLES pXlatTables)
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3706
int WINAPI NdrFullPointerFree(PFULL_PTR_XLAT_TABLES pXlatTables, void *Pointer)
smooth NULL
Definition: ftsmooth.c:416
int ret
PFULL_PTR_XLAT_TABLES WINAPI NdrFullPointerXlatInit(ULONG NumberOfPointers, XLAT_SIDE XlatSide)
#define ok(value,...)
Definition: atltest.h:57
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG x2
Definition: winddi.h:3706
void WINAPI NdrFullPointerInsertRefId(PFULL_PTR_XLAT_TABLES pXlatTables, ULONG RefId, void *pPointer)
unsigned int ULONG
Definition: retypes.h:1
int WINAPI NdrFullPointerQueryPointer(PFULL_PTR_XLAT_TABLES pXlatTables, void *pPointer, unsigned char QueryType, ULONG *pRefId)

Referenced by START_TEST().

◆ test_iface_ptr()

static void test_iface_ptr ( void  )
static

Definition at line 1322 of file ndr_marshall.c.

1323 {
1324  struct testiface server_obj = {{&testiface_vtbl}, 1};
1325  struct testiface client_obj = {{&testiface_vtbl}, 1};
1326 
1327  MIDL_STUB_MESSAGE StubMsg;
1328  MIDL_STUB_DESC StubDesc;
1329  RPC_MESSAGE RpcMessage;
1330  IPersist *proxy;
1331  HRESULT hr;
1332  GUID clsid;
1333  void *ptr;
1334  LONG ref;
1335 
1336  static const unsigned char fmtstr_ip[] =
1337  {
1338  FC_IP,
1340  NdrFcLong(0x0000010c),
1341  NdrFcShort(0x0000),
1342  NdrFcShort(0x0000),
1343  0xc0,
1344  0x00,
1345  0x00,
1346  0x00,
1347  0x00,
1348  0x00,
1349  0x00,
1350  0x46,
1351  };
1352 
1353  CoInitialize(NULL);
1354 
1355  StubDesc = Object_StubDesc;
1356  StubDesc.pFormatTypes = fmtstr_ip;
1357 
1358  NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 0);
1359  StubMsg.BufferLength = 0;
1360  NdrInterfacePointerBufferSize(&StubMsg, (unsigned char *)&client_obj.IPersist_iface, fmtstr_ip);
1361 
1362  StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
1363  StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
1364 
1365  /* server -> client */
1366 
1367  StubMsg.IsClient = 0;
1369  StubMsg.Buffer = StubMsg.BufferStart;
1370  IPersist_AddRef(&server_obj.IPersist_iface);
1371  ptr = NdrInterfacePointerMarshall(&StubMsg, (unsigned char *)&server_obj.IPersist_iface, fmtstr_ip);
1372  ok(!ptr, "ret %p\n", ptr);
1373  ok(server_obj.ref > 2, "got %d references\n", server_obj.ref);
1374  ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
1375  ok(!my_free_called, "free called %d\n", my_free_called);
1376 
1377  NdrInterfacePointerFree(&StubMsg, (unsigned char *)&server_obj.IPersist_iface, fmtstr_ip);
1378  ok(server_obj.ref > 1, "got %d references\n", server_obj.ref);
1379 
1380  StubMsg.IsClient = 1;
1382  StubMsg.Buffer = StubMsg.BufferStart;
1383  proxy = NULL;
1384  ptr = NdrInterfacePointerUnmarshall(&StubMsg, (unsigned char **)&proxy, fmtstr_ip, 0);
1385  ok(!ptr, "ret %p\n", ptr);
1386  ok(!!proxy, "mem not alloced\n");
1387  ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
1388  ok(!my_free_called, "free called %d\n", my_free_called);
1389  ok(server_obj.ref > 1, "got %d references\n", server_obj.ref);
1390 
1391  hr = IPersist_GetClassID(proxy, &clsid);
1392  ok(hr == S_OK, "got hr %#x\n", hr);
1393  ok(IsEqualGUID(&clsid, &IID_IPersist), "wrong clsid %s\n", wine_dbgstr_guid(&clsid));
1394 
1395  ref = IPersist_Release(proxy);
1396  ok(ref == 1, "got %d references\n", ref);
1397  ok(server_obj.ref == 1, "got %d references\n", server_obj.ref);
1398 
1399  /* An existing interface pointer is released; this is necessary so that an
1400  * [in, out] pointer which changes does not leak references. */
1401 
1402  StubMsg.IsClient = 0;
1404  StubMsg.Buffer = StubMsg.BufferStart;
1405  IPersist_AddRef(&server_obj.IPersist_iface);
1406  ptr = NdrInterfacePointerMarshall(&StubMsg, (unsigned char *)&server_obj.IPersist_iface, fmtstr_ip);
1407  ok(!ptr, "ret %p\n", ptr);
1408  ok(server_obj.ref > 2, "got %d references\n", server_obj.ref);
1409  ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
1410  ok(!my_free_called, "free called %d\n", my_free_called);
1411 
1412  NdrInterfacePointerFree(&StubMsg, (unsigned char *)&server_obj.IPersist_iface, fmtstr_ip);
1413  ok(server_obj.ref > 1, "got %d references\n", server_obj.ref);
1414 
1415  StubMsg.IsClient = 1;
1417  StubMsg.Buffer = StubMsg.BufferStart;
1418  proxy = &client_obj.IPersist_iface;
1419  IPersist_AddRef(proxy);
1420  ptr = NdrInterfacePointerUnmarshall(&StubMsg, (unsigned char **)&proxy, fmtstr_ip, 0);
1421  ok(!ptr, "ret %p\n", ptr);
1422  ok(!!proxy && proxy != &client_obj.IPersist_iface, "mem not alloced\n");
1423  ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
1424  ok(!my_free_called, "free called %d\n", my_free_called);
1425  ok(server_obj.ref > 1, "got %d references\n", server_obj.ref);
1426  ok(client_obj.ref == 1, "got %d references\n", client_obj.ref);
1427 
1428  hr = IPersist_GetClassID(proxy, &clsid);
1429  ok(hr == S_OK, "got hr %#x\n", hr);
1430  ok(IsEqualGUID(&clsid, &IID_IPersist), "wrong clsid %s\n", wine_dbgstr_guid(&clsid));
1431 
1432  ref = IPersist_Release(proxy);
1433  ok(ref == 1, "got %d references\n", ref);
1434  ok(server_obj.ref == 1, "got %d references\n", server_obj.ref);
1435 
1436  /* client -> server */
1437 
1438  StubMsg.IsClient = 1;
1440  StubMsg.Buffer = StubMsg.BufferStart;
1441  IPersist_AddRef(&client_obj.IPersist_iface);
1442  ptr = NdrInterfacePointerMarshall(&StubMsg, (unsigned char *)&client_obj.IPersist_iface, fmtstr_ip);
1443  ok(!ptr, "ret %p\n", ptr);
1444  ok(client_obj.ref > 2, "got %d references\n", client_obj.ref);
1445  ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
1446  ok(!my_free_called, "free called %d\n", my_free_called);
1447 
1448  StubMsg.IsClient = 0;
1450  StubMsg.Buffer = StubMsg.BufferStart;
1451  proxy = NULL;
1452  ptr = NdrInterfacePointerUnmarshall(&StubMsg, (unsigned char **)&proxy, fmtstr_ip, 0);
1453  ok(!ptr, "ret %p\n", ptr);
1454  ok(!!proxy, "mem not alloced\n");
1455  ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
1456  ok(!my_free_called, "free called %d\n", my_free_called);
1457  ok(client_obj.ref > 2, "got %d references\n", client_obj.ref);
1458 
1459  hr = IPersist_GetClassID(proxy, &clsid);
1460  ok(hr == S_OK, "got hr %#x\n", hr);
1461  ok(IsEqualGUID(&clsid, &IID_IPersist), "wrong clsid %s\n", wine_dbgstr_guid(&clsid));
1462 
1463  ref = IPersist_Release(proxy);
1464  ok(client_obj.ref > 1, "got %d references\n", client_obj.ref);
1465  ok(ref == client_obj.ref, "expected %d references, got %d\n", client_obj.ref, ref);
1466 
1467  NdrInterfacePointerFree(&StubMsg, (unsigned char *)proxy, fmtstr_ip);
1468  ok(client_obj.ref == 1, "got %d references\n", client_obj.ref);
1469 
1470  /* same, but free the interface after calling NdrInterfacePointerFree */
1471 
1472  StubMsg.IsClient = 1;
1474  StubMsg.Buffer = StubMsg.BufferStart;
1475  IPersist_AddRef(&client_obj.IPersist_iface);
1476  ptr = NdrInterfacePointerMarshall(&StubMsg, (unsigned char *)&client_obj.IPersist_iface, fmtstr_ip);
1477  ok(!ptr, "ret %p\n", ptr);
1478  ok(client_obj.ref > 2, "got %d references\n", client_obj.ref);
1479  ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
1480  ok(!my_free_called, "free called %d\n", my_free_called);
1481 
1482  StubMsg.IsClient = 0;
1484  StubMsg.Buffer = StubMsg.BufferStart;
1485  proxy = NULL;
1486  ptr = NdrInterfacePointerUnmarshall(&StubMsg, (unsigned char **)&proxy, fmtstr_ip, 0);
1487  ok(!ptr, "ret %p\n", ptr);
1488  ok(!!proxy, "mem not alloced\n");
1489  ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
1490  ok(!my_free_called, "free called %d\n", my_free_called);
1491  ok(client_obj.ref > 2, "got %d references\n", client_obj.ref);
1492 
1493  NdrInterfacePointerFree(&StubMsg, (unsigned char *)proxy, fmtstr_ip);
1494  ok(client_obj.ref > 1, "got %d references\n", client_obj.ref);
1495 
1496  hr = IPersist_GetClassID(proxy, &clsid);
1497  ok(hr == S_OK, "got hr %#x\n", hr);
1498  ok(IsEqualGUID(&clsid, &IID_IPersist), "wrong clsid %s\n", wine_dbgstr_guid(&clsid));
1499 
1500  ref = IPersist_Release(proxy);
1501  ok(ref == 1, "got %d references\n", ref);
1502  ok(client_obj.ref == 1, "got %d references\n", client_obj.ref);
1503 
1504  /* An existing interface pointer is *not* released (in fact, it is ignored
1505  * and may be invalid). In practice it will always be NULL anyway. */
1506 
1507  StubMsg.IsClient = 1;
1509  StubMsg.Buffer = StubMsg.BufferStart;
1510  IPersist_AddRef(&client_obj.IPersist_iface);
1511  ptr = NdrInterfacePointerMarshall(&StubMsg, (unsigned char *)&client_obj.IPersist_iface, fmtstr_ip);
1512  ok(!ptr, "ret %p\n", ptr);
1513  ok(client_obj.ref > 2, "got %d references\n", client_obj.ref);
1514  ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
1515  ok(!my_free_called, "free called %d\n", my_free_called);
1516 
1517  StubMsg.IsClient = 0;
1519  StubMsg.Buffer = StubMsg.BufferStart;
1520  proxy = &server_obj.IPersist_iface;
1521  IPersist_AddRef(proxy);
1522  ptr = NdrInterfacePointerUnmarshall(&StubMsg, (unsigned char **)&proxy, fmtstr_ip, 0);
1523  ok(!ptr, "ret %p\n", ptr);
1524  ok(!!proxy && proxy != &server_obj.IPersist_iface, "mem not alloced\n");
1525  ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
1526  ok(!my_free_called, "free called %d\n", my_free_called);
1527  ok(client_obj.ref > 2, "got %d references\n", client_obj.ref);
1528  ok(server_obj.ref == 2, "got %d references\n", server_obj.ref);
1529  IPersist_Release(&server_obj.IPersist_iface);
1530 
1531  hr = IPersist_GetClassID(proxy, &clsid);
1532  ok(hr == S_OK, "got hr %#x\n", hr);
1533  ok(IsEqualGUID(&clsid, &IID_IPersist), "wrong clsid %s\n", wine_dbgstr_guid(&clsid));
1534 
1535  ref = IPersist_Release(proxy);
1536  ok(client_obj.ref > 1, "got %d references\n", client_obj.ref);
1537  ok(ref == client_obj.ref, "expected %d references, got %d\n", client_obj.ref, ref);
1538 
1539  NdrInterfacePointerFree(&StubMsg, (unsigned char *)proxy, fmtstr_ip);
1540  ok(client_obj.ref == 1, "got %d references\n", client_obj.ref);
1541 
1542  HeapFree(GetProcessHeap(), 0, StubMsg.BufferStart);
1543 
1544  CoUninitialize();
1545 }
void WINAPI NdrInterfacePointerFree(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
Definition: ndr_ole.c:411
int proxy
Definition: main.c:67
static int my_alloc_called
Definition: ndr_marshall.c:40
HRESULT hr
Definition: shlfolder.c:183
unsigned char *WINAPI NdrInterfacePointerMarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
Definition: ndr_ole.c:306
const GUID IID_IPersist
Definition: proxy.cpp:14
unsigned char * Buffer
Definition: rpcndr.h:203
static int my_free_called
Definition: ndr_marshall.c:41
const char * wine_dbgstr_guid(const GUID *guid)
#define NdrFcShort(s)
Definition: rpcndr.h:134
PRPC_MESSAGE RpcMsg
Definition: rpcndr.h:202
Definition: send.c:48
void * Buffer
Definition: rpcdcep.h:40
long LONG
Definition: pedump.c:60
GLenum GLint ref
Definition: glext.h:6028
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
#define NdrFcLong(s)
Definition: rpcndr.h:135
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
#define GetProcessHeap()
Definition: compat.h:404
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
LONG HRESULT
Definition: typedefs.h:78
const unsigned char * pFormatTypes
Definition: rpcndr.h:374
unsigned char * BufferStart
Definition: rpcndr.h:204
ULONG BufferLength
Definition: rpcndr.h:207
unsigned char * BufferEnd
Definition: rpcndr.h:205
IPersist IPersist_iface
REFCLSID clsid
Definition: msctf.c:82
#define S_OK
Definition: intsafe.h:59
unsigned char IsClient
Definition: rpcndr.h:210
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
#define ok(value,...)
Definition: atltest.h:57
void WINAPI NdrInterfacePointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
Definition: ndr_ole.c:373
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112
HRESULT WINAPI CoInitialize(LPVOID lpReserved)
Definition: compobj.c:1964
unsigned char *WINAPI NdrInterfacePointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
Definition: ndr_ole.c:336
void WINAPI NdrClientInitializeNew(PRPC_MESSAGE pRpcMessage, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDesc, unsigned int ProcNum)
static IPersistVtbl testiface_vtbl
#define HeapFree(x, y, z)
Definition: compat.h:403

Referenced by START_TEST().

◆ test_MesEncodeFixedBufferHandleCreate()

static void test_MesEncodeFixedBufferHandleCreate ( void  )
static

Definition at line 2924 of file ndr_marshall.c.

2925 {
2926  ULONG encoded_size;
2928  handle_t handle;
2929  char *buffer;
2930 
2932  ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
2933 
2935  ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
2936 
2937  status = MesEncodeFixedBufferHandleCreate((char*)0xdeadbeef, 0, NULL, &handle);
2938  ok(status == RPC_X_INVALID_BUFFER, "got %d\n", status);
2939 
2940  buffer = (void*)((0xdeadbeef + 7) & ~7);
2942  ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
2943 
2944  status = MesEncodeFixedBufferHandleCreate(buffer, 0, &encoded_size, &handle);
2945 todo_wine
2946  ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
2947 if (status == RPC_S_OK) {
2949 }
2951  ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
2952 
2953  status = MesEncodeFixedBufferHandleCreate(buffer, 32, &encoded_size, &handle);
2954  ok(status == RPC_S_OK, "got %d\n", status);
2955 
2957  &buffer, 32, &encoded_size);
2958  ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
2959 
2960  /* convert to dynamic buffer handle */
2962  &buffer, 32, &encoded_size);
2963  ok(status == RPC_S_OK, "got %d\n", status);
2964 
2966  NULL, 32, &encoded_size);
2967  ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
2968 
2970  &buffer, 32, NULL);
2971  ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
2972 
2973  /* invalid handle type */
2975  &buffer, 32, &encoded_size);
2976  ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
2977 
2979  ok(status == RPC_S_OK, "got %d\n", status);
2980 }
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED LPLOOKUPSERVICE_COMPLETION_ROUTINE HANDLE * handle
Definition: sock.c:82
RPC_STATUS WINAPI MesHandleFree(handle_t Handle)
Definition: ndr_es.c:162
#define RPC_S_INVALID_ARG
Definition: rpcnterr.h:23
GLuint buffer
Definition: glext.h:5915
#define RPC_X_INVALID_BUFFER
Definition: rpcnterr.h:40
long RPC_STATUS
Definition: rpc.h:52
smooth NULL
Definition: ftsmooth.c:416
RPC_STATUS WINAPI MesBufferHandleReset(handle_t Handle, ULONG HandleStyle, MIDL_ES_CODE Operation, char **Buffer, ULONG BufferSize, ULONG *EncodedSize)
Definition: ndr_es.c:128
#define todo_wine
Definition: test.h:162
#define ok(value,...)
Definition: atltest.h:57
RPC_STATUS RPC_ENTRY MesEncodeFixedBufferHandleCreate(char *Buffer, ULONG BufferSize, ULONG *pEncodedSize, handle_t *pHandle)
Definition: ndr_es.c:183
unsigned int ULONG
Definition: retypes.h:1
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by START_TEST().

◆ test_ndr_allocate()

static void test_ndr_allocate ( void  )
static

Definition at line 1858 of file ndr_marshall.c.

1859 {
1860  RPC_MESSAGE RpcMessage;
1861  MIDL_STUB_MESSAGE StubMsg;
1862  MIDL_STUB_DESC StubDesc;
1863  void *p1, *p2;
1864  struct tag_mem_list_v2_t
1865  {
1866  DWORD magic;
1867  DWORD size;
1868  DWORD unknown;
1869  struct tag_mem_list_v2_t *next;
1870  } *mem_list_v2;
1871  const DWORD magic_MEML = 'M' << 24 | 'E' << 16 | 'M' << 8 | 'L';
1872 
1873  StubDesc = Object_StubDesc;
1874  NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 0);
1875 
1877  p1 = NdrAllocate(&StubMsg, 10);
1878  p2 = NdrAllocate(&StubMsg, 24);
1879  ok(my_alloc_called == 2, "alloc called %d\n", my_alloc_called);
1880  ok(StubMsg.pMemoryList != NULL, "StubMsg.pMemoryList NULL\n");
1881  if(StubMsg.pMemoryList)
1882  {
1883  mem_list_v2 = StubMsg.pMemoryList;
1884  if (mem_list_v2->size == 24)
1885  {
1886  trace("v2 mem list format\n");
1887  ok((char *)mem_list_v2 == (char *)p2 + 24, "expected mem_list_v2 pointer %p, but got %p\n", (char *)p2 + 24, mem_list_v2);
1888  ok(mem_list_v2->magic == magic_MEML, "magic %08x\n", mem_list_v2->magic);
1889  ok(mem_list_v2->size == 24, "wrong size for p2 %d\n", mem_list_v2->size);
1890  ok(mem_list_v2->unknown == 0, "wrong unknown for p2 0x%x\n", mem_list_v2->unknown);
1891  ok(mem_list_v2->next != NULL, "next NULL\n");
1892  mem_list_v2 = mem_list_v2->next;
1893  if(mem_list_v2)
1894  {
1895  ok((char *)mem_list_v2 == (char *)p1 + 16, "expected mem_list_v2 pointer %p, but got %p\n", (char *)p1 + 16, mem_list_v2);
1896  ok(mem_list_v2->magic == magic_MEML, "magic %08x\n", mem_list_v2->magic);
1897  ok(mem_list_v2->size == 16, "wrong size for p1 %d\n", mem_list_v2->size);
1898  ok(mem_list_v2->unknown == 0, "wrong unknown for p1 0x%x\n", mem_list_v2->unknown);
1899  ok(mem_list_v2->next == NULL, "next %p\n", mem_list_v2->next);
1900  }
1901  }
1902  else win_skip("v1 mem list format\n");
1903  }
1904  /* NdrFree isn't exported so we can't test free'ing */
1905  my_free(p1);
1906  my_free(p2);
1907 }
static int my_alloc_called
Definition: ndr_marshall.c:40
static void CALLBACK my_free(void *ptr)
Definition: ndr_marshall.c:48
static int my_free_called
Definition: ndr_marshall.c:41
u32_t magic(void)
void *WINAPI NdrAllocate(MIDL_STUB_MESSAGE *pStubMsg, SIZE_T len)
Definition: ndr_marshall.c:419
smooth NULL
Definition: ftsmooth.c:416
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
GLsizeiptr size
Definition: glext.h:5919
#define trace
Definition: atltest.h:70
unsigned long DWORD
Definition: ntddk_ex.h:95
Definition: id3.c:95
void * pMemoryList
Definition: rpcndr.h:264
static unsigned __int64 next
Definition: rand_nt.c:6
#define ok(value,...)
Definition: atltest.h:57
void WINAPI NdrClientInitializeNew(PRPC_MESSAGE pRpcMessage, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDesc, unsigned int ProcNum)
#define win_skip
Definition: test.h:149

Referenced by START_TEST().

◆ test_ndr_buffer()

static void test_ndr_buffer ( void  )
static

Definition at line 2604 of file ndr_marshall.c.

2605 {
2606  static unsigned char ncalrpc[] = "ncalrpc";
2607  static unsigned char endpoint[] = "winetest:test_ndr_buffer";
2608  RPC_MESSAGE RpcMessage;
2609  MIDL_STUB_MESSAGE StubMsg;
2610  MIDL_STUB_DESC StubDesc = Object_StubDesc;
2611  unsigned char *ret;
2612  unsigned char *binding;
2615  ULONG prev_buffer_length;
2616  BOOL old_buffer_valid_location;
2617 
2619 
2620  status = RpcServerUseProtseqEpA(ncalrpc, 20, endpoint, NULL);
2621  ok(RPC_S_OK == status, "RpcServerUseProtseqEp failed with status %u\n", status);
2623  ok(RPC_S_OK == status, "RpcServerRegisterIf failed with status %u\n", status);
2624  status = RpcServerListen(1, 20, TRUE);
2625  ok(RPC_S_OK == status, "RpcServerListen failed with status %u\n", status);
2626  if (status != RPC_S_OK)
2627  {
2628  /* Failed to create a server, running client tests is useless */
2629  return;
2630  }
2631 
2632  status = RpcStringBindingComposeA(NULL, ncalrpc, NULL, endpoint, NULL, &binding);
2633  ok(status == RPC_S_OK, "RpcStringBindingCompose failed (%u)\n", status);
2634 
2636  ok(status == RPC_S_OK, "RpcBindingFromStringBinding failed (%u)\n", status);
2637  RpcStringFreeA(&binding);
2638 
2639  NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 5);
2640 
2641  ret = NdrGetBuffer(&StubMsg, 10, Handle);
2642  ok(ret == StubMsg.Buffer, "NdrGetBuffer should have returned the same value as StubMsg.Buffer instead of %p\n", ret);
2643  ok(RpcMessage.Handle != NULL, "RpcMessage.Handle should not have been NULL\n");
2644  ok(RpcMessage.Buffer != NULL, "RpcMessage.Buffer should not have been NULL\n");
2645  ok(RpcMessage.BufferLength == 10 ||
2646  broken(RpcMessage.BufferLength == 12), /* win2k */
2647  "RpcMessage.BufferLength should have been 10 instead of %d\n", RpcMessage.BufferLength);
2648  ok(RpcMessage.RpcFlags == 0, "RpcMessage.RpcFlags should have been 0x0 instead of 0x%x\n", RpcMessage.RpcFlags);
2649  ok(StubMsg.Buffer != NULL, "Buffer should not have been NULL\n");
2650  ok(!StubMsg.BufferStart, "BufferStart should have been NULL instead of %p\n", StubMsg.BufferStart);
2651  ok(!StubMsg.BufferEnd, "BufferEnd should have been NULL instead of %p\n", StubMsg.BufferEnd);
2652 todo_wine
2653  ok(StubMsg.BufferLength == 0, "BufferLength should have left as 0 instead of being set to %d\n", StubMsg.BufferLength);
2654  old_buffer_valid_location = !StubMsg.fBufferValid;
2655  if (old_buffer_valid_location)
2656  ok(broken(StubMsg.CorrDespIncrement == TRUE), "fBufferValid should have been TRUE instead of 0x%x\n", StubMsg.CorrDespIncrement);
2657  else
2658  ok(StubMsg.fBufferValid, "fBufferValid should have been non-zero instead of 0x%x\n", StubMsg.fBufferValid);
2659 
2660  prev_buffer_length = RpcMessage.BufferLength;
2661  StubMsg.BufferLength = 1;
2662  NdrFreeBuffer(&StubMsg);
2663  ok(RpcMessage.Handle != NULL, "RpcMessage.Handle should not have been NULL\n");
2664  ok(RpcMessage.Buffer != NULL, "RpcMessage.Buffer should not have been NULL\n");
2665  ok(RpcMessage.BufferLength == prev_buffer_length, "RpcMessage.BufferLength should have been left as %d instead of %d\n", prev_buffer_length, RpcMessage.BufferLength);
2666  ok(StubMsg.Buffer != NULL, "Buffer should not have been NULL\n");
2667  ok(StubMsg.BufferLength == 1, "BufferLength should have left as 1 instead of being set to %d\n", StubMsg.BufferLength);
2668  if (old_buffer_valid_location)
2669  ok(broken(StubMsg.CorrDespIncrement == FALSE), "fBufferValid should have been FALSE instead of 0x%x\n", StubMsg.CorrDespIncrement);
2670  else
2671  ok(!StubMsg.fBufferValid, "fBufferValid should have been FALSE instead of %d\n", StubMsg.fBufferValid);
2672 
2673  /* attempt double-free */
2674  NdrFreeBuffer(&StubMsg);
2675 
2677 
2679  ok(status == RPC_S_OK, "RpcServerUnregisterIf failed (%u)\n", status);
2680 }
void * RpcInterfaceInformation
Definition: rpcndr.h:362
RPC_STATUS WINAPI RpcBindingFree(RPC_BINDING_HANDLE *Binding)
Definition: rpc_binding.c:783
#define TRUE
Definition: types.h:120
RPC_STATUS WINAPI RpcStringBindingComposeA(RPC_CSTR ObjUuid, RPC_CSTR Protseq, RPC_CSTR NetworkAddr, RPC_CSTR Endpoint, RPC_CSTR Options, RPC_CSTR *StringBinding)
Definition: rpc_binding.c:457
unsigned char * Buffer
Definition: rpcndr.h:203
RPC_STATUS WINAPI RpcStringFreeA(RPC_CSTR *String)
Definition: rpcrt4_main.c:158
RPC_STATUS WINAPI RpcServerUnregisterIf(RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, UINT WaitForCallsToComplete)
Definition: rpc_server.c:1202
unsigned int BufferLength
Definition: rpcdcep.h:41
long RPC_STATUS
Definition: rpc.h:52
void * Buffer
Definition: rpcdcep.h:40
unsigned int BOOL
Definition: ntddk_ex.h:94
RPC_STATUS WINAPI RpcServerListen(UINT MinimumCallThreads, UINT MaxCalls, UINT DontWait)
Definition: rpc_server.c:1520
smooth NULL
Definition: ftsmooth.c:416
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
_In_ HANDLE Handle
Definition: extypes.h:390
RPC_STATUS WINAPI RpcBindingFromStringBindingA(RPC_CSTR StringBinding, RPC_BINDING_HANDLE *Binding)
Definition: rpc_binding.c:836
RPC_STATUS WINAPI RpcServerUseProtseqEpA(RPC_CSTR Protseq, UINT MaxCalls, RPC_CSTR Endpoint, LPVOID SecurityDescriptor)
Definition: rpc_server.c:910
ULONG RpcFlags
Definition: rpcdcep.h:48
RPC_STATUS WINAPI RpcServerRegisterIf(RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, RPC_MGR_EPV *MgrEpv)
Definition: rpc_server.c:1116
unsigned char * BufferStart
Definition: rpcndr.h:204
ULONG BufferLength
Definition: rpcndr.h:207
unsigned char * BufferEnd
Definition: rpcndr.h:205
int ret
static RPC_IF_HANDLE IFoo_v0_0_s_ifspec
Definition: ndr_marshall.c:102
unsigned int fBufferValid
Definition: rpcndr.h:243
#define todo_wine
Definition: test.h:162
static const RPC_SERVER_INTERFACE IFoo___RpcServerInterface
Definition: ndr_marshall.c:89
#define broken(x)
Definition: _sntprintf.h:21
Definition: nis.h:10
void WINAPI NdrFreeBuffer(PMIDL_STUB_MESSAGE pStubMsg)
#define ok(value,...)
Definition: atltest.h:57
unsigned char *WINAPI NdrGetBuffer(PMIDL_STUB_MESSAGE stubmsg, ULONG buflen, RPC_BINDING_HANDLE handle)
unsigned char CorrDespIncrement
Definition: rpcndr.h:218
void WINAPI NdrClientInitializeNew(PRPC_MESSAGE pRpcMessage, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDesc, unsigned int ProcNum)
unsigned int ULONG
Definition: retypes.h:1
static SERVICE_STATUS status
Definition: service.c:31
RPC_BINDING_HANDLE Handle
Definition: rpcdcep.h:38
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by START_TEST().

◆ test_ndr_simple_type()

static void test_ndr_simple_type ( void  )
static

Definition at line 139 of file ndr_marshall.c.

140 {
141  RPC_MESSAGE RpcMessage;
142  MIDL_STUB_MESSAGE StubMsg;
143  MIDL_STUB_DESC StubDesc;
144  LONG l, l2 = 0;
145 
146  StubDesc = Object_StubDesc;
147  StubDesc.pFormatTypes = NULL;
148 
150  &RpcMessage,
151  &StubMsg,
152  &StubDesc,
153  0);
154 
155  StubMsg.BufferLength = 16;
156  StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
157  l = 0xcafebabe;
158  NdrSimpleTypeMarshall(&StubMsg, (unsigned char*)&l, FC_LONG);
159  ok(StubMsg.Buffer == StubMsg.BufferStart + 4, "%p %p\n", StubMsg.Buffer, StubMsg.BufferStart);
160  ok(*(LONG*)StubMsg.BufferStart == l, "%d\n", *(LONG*)StubMsg.BufferStart);
161 
162  StubMsg.Buffer = StubMsg.BufferStart + 1;
163  NdrSimpleTypeMarshall(&StubMsg, (unsigned char*)&l, FC_LONG);
164  ok(StubMsg.Buffer == StubMsg.BufferStart + 8, "%p %p\n", StubMsg.Buffer, StubMsg.BufferStart);
165  ok(*(LONG*)(StubMsg.BufferStart + 4) == l, "%d\n", *(LONG*)StubMsg.BufferStart);
166 
167  StubMsg.Buffer = StubMsg.BufferStart + 1;
168  NdrSimpleTypeUnmarshall(&StubMsg, (unsigned char*)&l2, FC_LONG);
169  ok(StubMsg.Buffer == StubMsg.BufferStart + 8, "%p %p\n", StubMsg.Buffer, StubMsg.BufferStart);
170  ok(l2 == l, "%d\n", l2);
171 
172  HeapFree(GetProcessHeap(), 0, StubMsg.BufferStart);
173 }
void WINAPI NdrSimpleTypeMarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, unsigned char FormatChar)
unsigned char * Buffer
Definition: rpcndr.h:203
PRPC_MESSAGE RpcMsg
Definition: rpcndr.h:202
void * Buffer
Definition: rpcdcep.h:40
long LONG
Definition: pedump.c:60
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
#define GetProcessHeap()
Definition: compat.h:404
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
const unsigned char * pFormatTypes
Definition: rpcndr.h:374
unsigned char * BufferStart
Definition: rpcndr.h:204
ULONG BufferLength
Definition: rpcndr.h:207
#define ok(value,...)
Definition: atltest.h:57
void WINAPI NdrSimpleTypeUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, unsigned char FormatChar)
void WINAPI NdrClientInitializeNew(PRPC_MESSAGE pRpcMessage, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDesc, unsigned int ProcNum)
#define HeapFree(x, y, z)
Definition: compat.h:403

Referenced by START_TEST().

◆ test_NdrCorrelationInitialize()

static void test_NdrCorrelationInitialize ( void  )
static

Definition at line 2982 of file ndr_marshall.c.

2983 {
2984  MIDL_STUB_MESSAGE stub_msg;
2985  BYTE buf[256];
2986 
2987  memset( &stub_msg, 0, sizeof(stub_msg) );
2988  memset( buf, 0, sizeof(buf) );
2989 
2990  NdrCorrelationInitialize( &stub_msg, buf, sizeof(buf), 0 );
2991  ok( stub_msg.CorrDespIncrement == 2 ||
2992  broken(stub_msg.CorrDespIncrement == 0), /* <= Win 2003 */
2993  "got %d\n", stub_msg.CorrDespIncrement );
2994 
2995  memset( &stub_msg, 0, sizeof(stub_msg) );
2996  memset( buf, 0, sizeof(buf) );
2997 
2998  stub_msg.CorrDespIncrement = 1;
2999  NdrCorrelationInitialize( &stub_msg, buf, sizeof(buf), 0 );
3000  ok( stub_msg.CorrDespIncrement == 1, "got %d\n", stub_msg.CorrDespIncrement );
3001 }
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
void WINAPI NdrCorrelationInitialize(PMIDL_STUB_MESSAGE pStubMsg, void *pMemory, ULONG CacheSize, ULONG Flags)
unsigned char BYTE
Definition: xxhash.c:193
#define broken(x)
Definition: _sntprintf.h:21
#define ok(value,...)
Definition: atltest.h:57
unsigned char CorrDespIncrement
Definition: rpcndr.h:218
#define memset(x, y, z)
Definition: compat.h:39

Referenced by START_TEST().

◆ test_NdrGetUserMarshalInfo()

static void test_NdrGetUserMarshalInfo ( void  )
static

Definition at line 2725 of file ndr_marshall.c.

2726 {
2728  MIDL_STUB_MESSAGE stubmsg;
2729  USER_MARSHAL_CB umcb;
2731  unsigned char buffer[16];
2732  void *rpc_channel_buffer = (void *)(ULONG_PTR)0xcafebabe;
2734 
2735  /* unmarshall */
2736 
2737  memset(&rpc_msg, 0xcc, sizeof(rpc_msg));
2738  rpc_msg.Buffer = buffer;
2739  rpc_msg.BufferLength = 16;
2740 
2741  memset(&stubmsg, 0xcc, sizeof(stubmsg));
2742  stubmsg.RpcMsg = &rpc_msg;
2743  stubmsg.dwDestContext = MSHCTX_INPROC;
2744  stubmsg.pvDestContext = NULL;
2745  stubmsg.Buffer = buffer + 15;
2746  stubmsg.BufferLength = 0;
2747  stubmsg.BufferEnd = NULL;
2748  stubmsg.pRpcChannelBuffer = rpc_channel_buffer;
2749  stubmsg.StubDesc = NULL;
2750  stubmsg.pfnAllocate = my_alloc;
2751  stubmsg.pfnFree = my_free;
2752 
2753  memset(&umcb, 0xcc, sizeof(umcb));
2754  umcb.Flags = MAKELONG(MSHCTX_INPROC, NDR_LOCAL_DATA_REPRESENTATION);
2755  umcb.pStubMsg = &stubmsg;
2758 
2759  memset(&umi, 0xaa, sizeof(umi));
2760 
2761  status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2762  ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
2763  ok( umi.InformationLevel == 1,
2764  "umi.InformationLevel was %u instead of 1\n",
2765  umi.InformationLevel);
2766  ok( U1(umi).Level1.Buffer == buffer + 15,
2767  "umi.Level1.Buffer was %p instead of %p\n",
2768  U1(umi).Level1.Buffer, buffer);
2769  ok( U1(umi).Level1.BufferSize == 1,
2770  "umi.Level1.BufferSize was %u instead of 1\n",
2771  U1(umi).Level1.BufferSize);
2772  ok( U1(umi).Level1.pfnAllocate == my_alloc,
2773  "umi.Level1.pfnAllocate was %p instead of %p\n",
2774  U1(umi).Level1.pfnAllocate, my_alloc);
2775  ok( U1(umi).Level1.pfnFree == my_free,
2776  "umi.Level1.pfnFree was %p instead of %p\n",
2777  U1(umi).Level1.pfnFree, my_free);
2778  ok( U1(umi).Level1.pRpcChannelBuffer == rpc_channel_buffer,
2779  "umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
2780  U1(umi).Level1.pRpcChannelBuffer, rpc_channel_buffer);
2781 
2782  /* buffer size */
2783 
2784  rpc_msg.Buffer = buffer;
2785  rpc_msg.BufferLength = 16;
2786 
2787  stubmsg.Buffer = buffer;
2788  stubmsg.BufferLength = 16;
2789  stubmsg.BufferEnd = NULL;
2790 
2792 
2793  memset(&umi, 0xaa, sizeof(umi));
2794 
2795  status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2796  ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
2797  ok( umi.InformationLevel == 1,
2798  "umi.InformationLevel was %u instead of 1\n",
2799  umi.InformationLevel);
2800  ok( U1(umi).Level1.Buffer == NULL,
2801  "umi.Level1.Buffer was %p instead of NULL\n",
2802  U1(umi).Level1.Buffer);
2803  ok( U1(umi).Level1.BufferSize == 0,
2804  "umi.Level1.BufferSize was %u instead of 0\n",
2805  U1(umi).Level1.BufferSize);
2806  ok( U1(umi).Level1.pfnAllocate == my_alloc,
2807  "umi.Level1.pfnAllocate was %p instead of %p\n",
2808  U1(umi).Level1.pfnAllocate, my_alloc);
2809  ok( U1(umi).Level1.pfnFree == my_free,
2810  "umi.Level1.pfnFree was %p instead of %p\n",
2811  U1(umi).Level1.pfnFree, my_free);
2812  ok( U1(umi).Level1.pRpcChannelBuffer == rpc_channel_buffer,
2813  "umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
2814  U1(umi).Level1.pRpcChannelBuffer, rpc_channel_buffer);
2815 
2816  /* marshall */
2817 
2818  rpc_msg.Buffer = buffer;
2819  rpc_msg.BufferLength = 16;
2820 
2821  stubmsg.Buffer = buffer + 15;
2822  stubmsg.BufferLength = 0;
2823  stubmsg.BufferEnd = NULL;
2824 
2826 
2827  memset(&umi, 0xaa, sizeof(umi));
2828 
2829  status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2830  ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
2831  ok( umi.InformationLevel == 1,
2832  "umi.InformationLevel was %u instead of 1\n",
2833  umi.InformationLevel);
2834  ok( U1(umi).Level1.Buffer == buffer + 15,
2835  "umi.Level1.Buffer was %p instead of %p\n",
2836  U1(umi).Level1.Buffer, buffer);
2837  ok( U1(umi).Level1.BufferSize == 1,
2838  "umi.Level1.BufferSize was %u instead of 1\n",
2839  U1(umi).Level1.BufferSize);
2840  ok( U1(umi).Level1.pfnAllocate == my_alloc,
2841  "umi.Level1.pfnAllocate was %p instead of %p\n",
2842  U1(umi).Level1.pfnAllocate, my_alloc);
2843  ok( U1(umi).Level1.pfnFree == my_free,
2844  "umi.Level1.pfnFree was %p instead of %p\n",
2845  U1(umi).Level1.pfnFree, my_free);
2846  ok( U1(umi).Level1.pRpcChannelBuffer == rpc_channel_buffer,
2847  "umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
2848  U1(umi).Level1.pRpcChannelBuffer, rpc_channel_buffer);
2849 
2850  /* free */
2851 
2852  rpc_msg.Buffer = buffer;
2853  rpc_msg.BufferLength = 16;
2854 
2855  stubmsg.Buffer = buffer;
2856  stubmsg.BufferLength = 16;
2857  stubmsg.BufferEnd = NULL;
2858 
2860 
2861  memset(&umi, 0xaa, sizeof(umi));
2862 
2863  status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2864  ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
2865  ok( umi.InformationLevel == 1,
2866  "umi.InformationLevel was %u instead of 1\n",
2867  umi.InformationLevel);
2868  ok( U1(umi).Level1.Buffer == NULL,
2869  "umi.Level1.Buffer was %p instead of NULL\n",
2870  U1(umi).Level1.Buffer);
2871  ok( U1(umi).Level1.BufferSize == 0,
2872  "umi.Level1.BufferSize was %u instead of 0\n",
2873  U1(umi).Level1.BufferSize);
2874  ok( U1(umi).Level1.pfnAllocate == my_alloc,
2875  "umi.Level1.pfnAllocate was %p instead of %p\n",
2876  U1(umi).Level1.pfnAllocate, my_alloc);
2877  ok( U1(umi).Level1.pfnFree == my_free,
2878  "umi.Level1.pfnFree was %p instead of %p\n",
2879  U1(umi).Level1.pfnFree, my_free);
2880  ok( U1(umi).Level1.pRpcChannelBuffer == rpc_channel_buffer,
2881  "umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
2882  U1(umi).Level1.pRpcChannelBuffer, rpc_channel_buffer);
2883 
2884  /* boundary test */
2885 
2886  rpc_msg.Buffer = buffer;
2887  rpc_msg.BufferLength = 15;
2888 
2889  stubmsg.Buffer = buffer + 15;
2890  stubmsg.BufferLength = 0;
2891  stubmsg.BufferEnd = NULL;
2892 
2894 
2895  status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2896  ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
2897  ok( U1(umi).Level1.BufferSize == 0,
2898  "umi.Level1.BufferSize was %u instead of 0\n",
2899  U1(umi).Level1.BufferSize);
2900 
2901  /* error conditions */
2902 
2903  rpc_msg.BufferLength = 14;
2904  status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2906  "NdrGetUserMarshalInfo should have failed with ERROR_INVALID_USER_BUFFER instead of %d\n", status);
2907 
2908  rpc_msg.BufferLength = 15;
2909  status = NdrGetUserMarshalInfo(&umcb.Flags, 9999, &umi);
2911  "NdrGetUserMarshalInfo should have failed with RPC_S_INVALID_ARG instead of %d\n", status);
2912 
2913  umcb.CBType = 9999;
2914  status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2915  ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
2916 
2918  umcb.Signature = 0;
2919  status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2921  "NdrGetUserMarshalInfo should have failed with RPC_S_INVALID_ARG instead of %d\n", status);
2922 }
RPC_STATUS RPC_ENTRY NdrGetUserMarshalInfo(ULONG *flags, ULONG level, NDR_USER_MARSHAL_INFO *umi)
#define U1(x)
Definition: test.h:188
static void CALLBACK my_free(void *ptr)
Definition: ndr_marshall.c:48
unsigned char * Buffer
Definition: rpcndr.h:203
#define RPC_S_INVALID_ARG
Definition: rpcnterr.h:23
const struct _MIDL_STUB_DESC * StubDesc
Definition: rpcndr.h:230
GLuint buffer
Definition: glext.h:5915
PRPC_MESSAGE RpcMsg
Definition: rpcndr.h:202
uint32_t ULONG_PTR
Definition: typedefs.h:64
#define ERROR_INVALID_USER_BUFFER
Definition: winerror.h:1091
long RPC_STATUS
Definition: rpc.h:52
DWORD dwDestContext
Definition: rpcndr.h:249
#define MAKELONG(a, b)
Definition: typedefs.h:248
smooth NULL
Definition: ftsmooth.c:416
void * pvDestContext
Definition: rpcndr.h:250
ULONG BufferLength
Definition: rpcndr.h:207
unsigned char * BufferEnd
Definition: rpcndr.h:205
USER_MARSHAL_CB_TYPE CBType
Definition: rpcndr.h:336
#define NDR_LOCAL_DATA_REPRESENTATION
Definition: rpcndr.h:107
#define USER_MARSHAL_CB_SIGNATURE
Definition: rpcndr.h:318
#define ok(value,...)
Definition: atltest.h:57
static void *CALLBACK my_alloc(SIZE_T size)
Definition: ndr_marshall.c:42
ULONG Signature
Definition: rpcndr.h:335
PMIDL_STUB_MESSAGE pStubMsg
Definition: rpcndr.h:333
#define memset(x, y, z)
Definition: compat.h:39
static SERVICE_STATUS status
Definition: service.c:31
struct IRpcChannelBuffer * pRpcChannelBuffer
Definition: rpcndr.h:253
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by START_TEST().

◆ test_NdrMapCommAndFaultStatus()

static void test_NdrMapCommAndFaultStatus ( void  )
static

Definition at line 2682 of file ndr_marshall.c.

2683 {
2684  RPC_STATUS rpc_status;
2685  MIDL_STUB_MESSAGE StubMsg;
2686  RPC_MESSAGE RpcMessage;
2687 
2688  NdrClientInitializeNew(&RpcMessage, &StubMsg, &Object_StubDesc, 5);
2689 
2690  for (rpc_status = 0; rpc_status < 10000; rpc_status++)
2691  {
2693  ULONG comm_status = 0;
2694  ULONG fault_status = 0;
2695  ULONG expected_comm_status = 0;
2696  ULONG expected_fault_status = 0;
2697  status = NdrMapCommAndFaultStatus(&StubMsg, &comm_status, &fault_status, rpc_status);
2698  ok(status == RPC_S_OK, "NdrMapCommAndFaultStatus failed with error %d\n", status);
2699  switch (rpc_status)
2700  {
2701  case ERROR_INVALID_HANDLE:
2702  case RPC_S_INVALID_BINDING:
2703  case RPC_S_UNKNOWN_IF:
2705  case RPC_S_SERVER_TOO_BUSY:
2706  case RPC_S_CALL_FAILED_DNE:
2707  case RPC_S_PROTOCOL_ERROR:
2711  case EPT_S_NOT_REGISTERED:
2712  case RPC_S_COMM_FAILURE:
2713  expected_comm_status = rpc_status;
2714  break;
2715  default:
2716  expected_fault_status = rpc_status;
2717  }
2718  ok(comm_status == expected_comm_status, "NdrMapCommAndFaultStatus should have mapped %d to comm status %d instead of %d\n",
2719  rpc_status, expected_comm_status, comm_status);
2720  ok(fault_status == expected_fault_status, "NdrMapCommAndFaultStatus should have mapped %d to fault status %d instead of %d\n",
2721  rpc_status, expected_fault_status, fault_status);
2722  }
2723 }
#define RPC_S_UNKNOWN_IF
Definition: winerror.h:1028
#define RPC_S_UNSUPPORTED_TRANS_SYN
Definition: winerror.h:1040
#define RPC_S_PROCNUM_OUT_OF_RANGE
Definition: winerror.h:1053
#define ERROR_INVALID_HANDLE
Definition: compat.h:88
#define RPC_S_SERVER_UNAVAILABLE
Definition: winerror.h:1033
long RPC_STATUS
Definition: rpc.h:52
#define RPC_S_CALL_FAILED_DNE
Definition: winerror.h:1038
#define RPC_S_INVALID_BINDING
Definition: winerror.h:1013
#define RPC_S_PROTOCOL_ERROR
Definition: winerror.h:1039
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
#define RPC_S_UNSUPPORTED_TYPE
Definition: winerror.h:1041
#define RPC_S_COMM_FAILURE
Definition: winerror.h:1127
#define RPC_S_SERVER_TOO_BUSY
Definition: winerror.h:1034
#define ok(value,...)
Definition: atltest.h:57
#define EPT_S_NOT_REGISTERED
Definition: winerror.h:1061
void WINAPI NdrClientInitializeNew(PRPC_MESSAGE pRpcMessage, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDesc, unsigned int ProcNum)
unsigned int ULONG
Definition: retypes.h:1
RPC_STATUS RPC_ENTRY NdrMapCommAndFaultStatus(PMIDL_STUB_MESSAGE pStubMsg, ULONG *pCommStatus, ULONG *pFaultStatus, RPC_STATUS Status)
static SERVICE_STATUS status
Definition: service.c:31
#define RPC_S_OK
Definition: rpcnterr.h:22
Definition: ps.c:97

Referenced by START_TEST().

◆ test_nonconformant_string()

static void test_nonconformant_string ( void  )
static

Definition at line 2152 of file ndr_marshall.c.

2153 {
2154  RPC_MESSAGE RpcMessage;
2155  MIDL_STUB_MESSAGE StubMsg;
2156  MIDL_STUB_DESC StubDesc;
2157  DWORD size;
2158  void *ptr;
2159  unsigned char *mem, *mem_orig;
2160  unsigned char memsrc[10] = "This is";
2161  unsigned char memsrc2[10] = "This is a";
2162 
2163  static const unsigned char fmtstr_nonconf_str[] =
2164  {
2165  0x26, /* FC_CSTRING */
2166  0x5c, /* FC_PAD */
2167  NdrFcShort( 0xa ), /* 10 */
2168  };
2169 
2170  StubDesc = Object_StubDesc;
2171  StubDesc.pFormatTypes = fmtstr_nonconf_str;
2172 
2173  /* length < size */
2175  &RpcMessage,
2176  &StubMsg,
2177  &StubDesc,
2178  0);
2179 
2180  StubMsg.BufferLength = 0;
2181 
2182  NdrNonConformantStringBufferSize( &StubMsg, memsrc, fmtstr_nonconf_str );
2183  ok(StubMsg.BufferLength >= strlen((char *)memsrc) + 1 + 8, "length %d\n", StubMsg.BufferLength);
2184 
2185  /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
2186  StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
2187  StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
2188 
2189  ptr = NdrNonConformantStringMarshall( &StubMsg, memsrc, fmtstr_nonconf_str );
2190  ok(ptr == NULL, "ret %p\n", ptr);
2191  size = StubMsg.Buffer - StubMsg.BufferStart;
2192  ok(size == strlen((char *)memsrc) + 1 + 8, "Buffer %p Start %p len %d\n",
2193  StubMsg.Buffer, StubMsg.BufferStart, size);
2194  ok(!memcmp(StubMsg.BufferStart + 8, memsrc, strlen((char *)memsrc) + 1), "incorrectly marshaled\n");
2195 
2196  StubMsg.Buffer = StubMsg.BufferStart;
2197  StubMsg.MemorySize = 0;
2198  mem = NULL;
2199 
2200  /* Client */
2201  my_alloc_called = 0;
2202  StubMsg.Buffer = StubMsg.BufferStart;
2203  mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
2204  NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
2205  ok(mem == mem_orig, "mem alloced\n");
2206  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2207 
2208  my_alloc_called = 0;
2209  StubMsg.Buffer = StubMsg.BufferStart;
2210  NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
2211  todo_wine
2212  ok(mem == mem_orig, "mem alloced\n");
2213  todo_wine
2214  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2215 
2216  /* Server */
2217  my_alloc_called = 0;
2218  StubMsg.IsClient = 0;
2219  mem = NULL;
2220  StubMsg.Buffer = StubMsg.BufferStart;
2221  NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
2222  ok(mem != mem_orig, "mem not alloced\n");
2223  ok(mem != StubMsg.BufferStart + 8, "mem pointing at buffer\n");
2224  ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
2225  NdrOleFree(mem);
2226 
2227  my_alloc_called = 0;
2228  mem = mem_orig;
2229  StubMsg.Buffer = StubMsg.BufferStart;
2230  NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
2231  ok(mem == mem_orig, "mem alloced\n");
2232  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2233 
2234  my_alloc_called = 0;
2235  mem = mem_orig;
2236  StubMsg.Buffer = StubMsg.BufferStart;
2237  NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
2238  todo_wine
2239  ok(mem == mem_orig, "mem alloced\n");
2240  todo_wine
2241  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2242 
2243  HeapFree(GetProcessHeap(), 0, mem_orig);
2244  HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
2245 
2246  /* length = size */
2248  &RpcMessage,
2249  &StubMsg,
2250  &StubDesc,
2251  0);
2252 
2253  StubMsg.BufferLength = 0;
2254 
2255  NdrNonConformantStringBufferSize( &StubMsg, memsrc2, fmtstr_nonconf_str );
2256  ok(StubMsg.BufferLength >= strlen((char *)memsrc2) + 1 + 8, "length %d\n", StubMsg.BufferLength);
2257 
2258  /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
2259  StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
2260  StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
2261 
2262  ptr = NdrNonConformantStringMarshall( &StubMsg, memsrc2, fmtstr_nonconf_str );
2263  ok(ptr == NULL, "ret %p\n", ptr);
2264  size = StubMsg.Buffer - StubMsg.BufferStart;
2265  ok(size == strlen((char *)memsrc2) + 1 + 8, "Buffer %p Start %p len %d\n",
2266  StubMsg.Buffer, StubMsg.BufferStart, size);
2267  ok(!memcmp(StubMsg.BufferStart + 8, memsrc2, strlen((char *)memsrc2) + 1), "incorrectly marshaled\n");
2268 
2269  StubMsg.Buffer = StubMsg.BufferStart;
2270  StubMsg.MemorySize = 0;
2271  mem = NULL;
2272 
2273  /* Client */
2274  my_alloc_called = 0;
2275  StubMsg.Buffer = StubMsg.BufferStart;
2276  mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
2277  NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
2278  ok(mem == mem_orig, "mem alloced\n");
2279  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2280 
2281  my_alloc_called = 0;
2282  StubMsg.Buffer = StubMsg.BufferStart;
2283  NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
2284  todo_wine
2285  ok(mem == mem_orig, "mem alloced\n");
2286  todo_wine
2287  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2288 
2289  /* Server */
2290  my_alloc_called = 0;
2291  StubMsg.IsClient = 0;
2292  mem = NULL;
2293  StubMsg.Buffer = StubMsg.BufferStart;
2294  NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
2295  ok(mem != mem_orig, "mem not alloced\n");
2296  ok(mem != StubMsg.BufferStart + 8, "mem pointing at buffer\n");
2297  ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
2298  NdrOleFree(mem);
2299 
2300  my_alloc_called = 0;
2301  mem = mem_orig;
2302  StubMsg.Buffer = StubMsg.BufferStart;
2303  NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
2304  ok(mem == mem_orig, "mem alloced\n");
2305  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2306 
2307  my_alloc_called = 0;
2308  mem = mem_orig;
2309  StubMsg.Buffer = StubMsg.BufferStart;
2310  NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
2311  todo_wine
2312  ok(mem == mem_orig, "mem alloced\n");
2313  todo_wine
2314  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
2315 
2316  HeapFree(GetProcessHeap(), 0, mem_orig);
2317  HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
2318 }
static int my_alloc_called
Definition: ndr_marshall.c:40
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ULONG MemorySize
Definition: rpcndr.h:208
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
unsigned char * Buffer
Definition: rpcndr.h:203
#define NdrFcShort(s)
Definition: rpcndr.h:134
PRPC_MESSAGE RpcMsg
Definition: rpcndr.h:202
void * Buffer
Definition: rpcdcep.h:40
unsigned char *WINAPI NdrNonConformantStringUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
unsigned char *WINAPI NdrNonConformantStringMarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:404
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
const unsigned char * pFormatTypes
Definition: rpcndr.h:374
unsigned char * BufferStart
Definition: rpcndr.h:204
ULONG BufferLength
Definition: rpcndr.h:207
unsigned char * BufferEnd
Definition: rpcndr.h:205
#define todo_wine
Definition: test.h:162
unsigned char IsClient
Definition: rpcndr.h:210
void WINAPI NdrOleFree(void *NodeToFree)
Definition: ndr_ole.c:432
#define ok(value,...)
Definition: atltest.h:57
Definition: mem.c:156
void WINAPI NdrClientInitializeNew(PRPC_MESSAGE pRpcMessage, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDesc, unsigned int ProcNum)
#define HeapFree(x, y, z)
Definition: compat.h:403
void WINAPI NdrNonConformantStringBufferSize(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)

Referenced by START_TEST().

◆ test_nontrivial_pointer_types()

static void test_nontrivial_pointer_types ( void  )
static

Definition at line 716 of file ndr_marshall.c.

717 {
718  RPC_MESSAGE RpcMessage;
719  MIDL_STUB_MESSAGE StubMsg;
720  MIDL_STUB_DESC StubDesc;
721  DWORD size;
722  void *ptr;
723  char **p1;
724  char *p2;
725  char ch;
726  unsigned char *mem, *mem_orig;
727 
728  static const unsigned char fmtstr_ref_unique_out[] =
729  {
730  0x12, 0x8, /* FC_UP [simple_pointer] */
731  0x2, /* FC_CHAR */
732  0x5c, /* FC_PAD */
733  0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */
734  NdrFcShort( 0xfffffffa ), /* Offset= -6 (0) */
735  };
736 
737  p1 = &p2;
738  p2 = &ch;
739  ch = 0x22;
740 
741  StubDesc = Object_StubDesc;
742  StubDesc.pFormatTypes = fmtstr_ref_unique_out;
743 
745  &RpcMessage,
746  &StubMsg,
747  &StubDesc,
748  0);
749 
750  StubMsg.BufferLength = 0;
751  NdrPointerBufferSize( &StubMsg,
752  (unsigned char *)p1,
753  &fmtstr_ref_unique_out[4] );
754 
755  /* Windows overestimates the buffer size */
756  ok(StubMsg.BufferLength >= 5, "length %d\n", StubMsg.BufferLength);
757 
758  /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
759  StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
760  StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
761 
762  ptr = NdrPointerMarshall( &StubMsg, (unsigned char *)p1, &fmtstr_ref_unique_out[4] );
763  ok(ptr == NULL, "ret %p\n", ptr);
764  size = StubMsg.Buffer - StubMsg.BufferStart;
765  ok(size == 5, "Buffer %p Start %p len %d\n", StubMsg.Buffer, StubMsg.BufferStart, size);
766  ok(*(unsigned int *)StubMsg.BufferStart != 0, "pointer ID marshalled incorrectly\n");
767  ok(*(unsigned char *)(StubMsg.BufferStart + 4) == 0x22, "char data marshalled incorrectly: 0x%x\n",
768  *(unsigned char *)(StubMsg.BufferStart + 4));
769 
770  StubMsg.Buffer = StubMsg.BufferStart;
771  StubMsg.MemorySize = 0;
772  mem = NULL;
773 
774  /* Client */
775  my_alloc_called = 0;
776  StubMsg.Buffer = StubMsg.BufferStart;
777  mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(void *));
778  *(void **)mem = NULL;
779  NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 0);
780  ok(mem == mem_orig, "mem alloced\n");
781  ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
782 
783  my_alloc_called = 0;
784  StubMsg.Buffer = StubMsg.BufferStart;
785  NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 1);
786  ok(mem == mem_orig, "mem alloced\n");
787  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
788 
789  my_free_called = 0;
790  StubMsg.Buffer = StubMsg.BufferStart;
791  NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
792  ok(my_free_called == 1, "free called %d\n", my_free_called);
793 
794  mem = my_alloc(sizeof(void *));
795  *(void **)mem = NULL;
796  my_free_called = 0;
797  StubMsg.Buffer = StubMsg.BufferStart;
798  NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
799  ok(my_free_called == 0, "free called %d\n", my_free_called);
800  my_free(mem);
801 
802  mem = my_alloc(sizeof(void *));
803  *(void **)mem = my_alloc(sizeof(char));
804  my_free_called = 0;
805  StubMsg.Buffer = StubMsg.BufferStart;
806  NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
807  ok(my_free_called == 1, "free called %d\n", my_free_called);
808  my_free(mem);
809 
810  /* Server */
811  my_alloc_called = 0;
812  my_free_called = 0;
813  StubMsg.IsClient = 0;
814  mem = NULL;
815  StubMsg.Buffer = StubMsg.BufferStart;
816  NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 0);
817  ok(mem != StubMsg.BufferStart, "mem pointing at buffer\n");
818  ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
819  NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
820  ok(my_free_called == 0, "free called %d\n", my_free_called);
821  my_free(mem);
822 
823  my_alloc_called = 0;
824  my_free_called = 0;
825  mem = NULL;
826  StubMsg.Buffer = StubMsg.BufferStart;
827  NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 1);
828  ok(mem != StubMsg.BufferStart, "mem pointing at buffer\n");
829  ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
830  NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
831  ok(my_free_called == 0, "free called %d\n", my_free_called);
832  my_free(mem);
833 
834  my_alloc_called = 0;
835  mem = mem_orig;
836  *(void **)mem = NULL;
837  StubMsg.Buffer = StubMsg.BufferStart;
838  NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 0);
839  ok(mem == mem_orig, "mem alloced\n");
840  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
841 
842  my_alloc_called = 0;
843  mem = mem_orig;
844  *(void **)mem = NULL;
845  StubMsg.Buffer = StubMsg.BufferStart;
846  NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 1);
847  ok(mem == mem_orig, "mem alloced\n");
848  ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
849 
850  mem = my_alloc(sizeof(void *));
851  *(void **)mem = NULL;
852  my_free_called = 0;
853  StubMsg.Buffer = StubMsg.BufferStart;
854  NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
855  ok(my_free_called == 0, "free called %d\n", my_free_called);
856  my_free(mem);
857 
858  mem = my_alloc(sizeof(void *));
859  *(void **)mem = my_alloc(sizeof(char));
860  my_free_called = 0;
861  StubMsg.Buffer = StubMsg.BufferStart;
862  NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
863  ok(my_free_called == 1, "free called %d\n", my_free_called);
864  my_free(mem);
865 
866  HeapFree(GetProcessHeap(), 0, mem_orig);
867  HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
868 }
void WINAPI NdrPointerFree(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
static int my_alloc_called
Definition: ndr_marshall.c:40
ULONG MemorySize
Definition: rpcndr.h:208
static void CALLBACK my_free(void *ptr)
Definition: ndr_marshall.c:48
unsigned char * Buffer
Definition: rpcndr.h:203
static int my_free_called
Definition: ndr_marshall.c:41
#define NdrFcShort(s)
Definition: rpcndr.h:134
PRPC_MESSAGE RpcMsg
Definition: rpcndr.h:202
void * Buffer
Definition: rpcdcep.h:40
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:404
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned char *WINAPI NdrPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned char *WINAPI NdrPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
const unsigned char * pFormatTypes
Definition: rpcndr.h:374
void WINAPI NdrPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char * BufferStart
Definition: rpcndr.h:204
ULONG BufferLength
Definition: rpcndr.h:207
unsigned char * BufferEnd
Definition: rpcndr.h:205
unsigned char IsClient
Definition: rpcndr.h:210
#define ok(value,...)
Definition: atltest.h:57
static void *CALLBACK my_alloc(SIZE_T size)
Definition: ndr_marshall.c:42
Definition: mem.c:156
void WINAPI NdrClientInitializeNew(PRPC_MESSAGE pRpcMessage, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDesc, unsigned int ProcNum)
#define HeapFree(x, y, z)
Definition: compat.h:403

Referenced by START_TEST().

◆ test_persist_AddRef()

static ULONG WINAPI test_persist_AddRef ( IPersist iface)
static

Definition at line 1297 of file ndr_marshall.c.

1298 {
1299  struct testiface *unk = impl_from_IPersist(iface);
1300  return ++unk->ref;
1301 }
static struct testiface * impl_from_IPersist(IPersist *iface)

◆ test_persist_GetClassId()

static HRESULT WINAPI test_persist_GetClassId ( IPersist iface,
GUID clsid 
)
static

Definition at line 1309 of file ndr_marshall.c.

1310 {
1311  *clsid = IID_IPersist;
1312  return S_OK;
1313 }
const GUID IID_IPersist
Definition: proxy.cpp:14
REFCLSID clsid
Definition: msctf.c:82
#define S_OK
Definition: intsafe.h:59

◆ test_persist_QueryInterface()

static HRESULT WINAPI test_persist_QueryInterface ( IPersist iface,
REFIID  iid,
void **  out 
)
static

Definition at line 1284 of file ndr_marshall.c.

1285 {
1286  if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IPersist))
1287  {
1288  *out = iface;
1289  IPersist_AddRef(iface);
1290  return S_OK;
1291  }
1292 
1293  *out = NULL;
1294  return E_NOINTERFACE;
1295 }
#define E_NOINTERFACE
Definition: winerror.h:2364
const GUID IID_IPersist
Definition: proxy.cpp:14
smooth NULL
Definition: ftsmooth.c:416
const GUID IID_IUnknown
static FILE * out
Definition: regtests2xml.c:44
#define S_OK
Definition: intsafe.h:59
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112

◆ test_persist_Release()

static ULONG WINAPI test_persist_Release ( IPersist iface)
static

Definition at line 1303 of file ndr_marshall.c.

1304 {
1305  struct testiface *unk = impl_from_IPersist(iface);
1306  return --unk->ref;
1307 }
static struct testiface * impl_from_IPersist(IPersist *iface)

◆ test_pointer_marshal()

static void test_pointer_marshal ( const unsigned char formattypes,
void memsrc,
DWORD  srcsize,
const void wiredata,
ULONG  wiredatalen,
int(*)(const void *, const void *, size_t cmp,
int  num_additional_allocs,
const char msgpfx 
)
static

Definition at line 175 of file ndr_marshall.c.

182 {
183  RPC_MESSAGE RpcMessage;
184  MIDL_STUB_MESSAGE StubMsg;
185  MIDL_STUB_DESC StubDesc;
186  DWORD size;
187  void *ptr;
188  unsigned char *mem, *mem_orig;
189 
190  if(!cmp)
191  cmp = memcmp;
192 
193  StubDesc = Object_StubDesc;
194  StubDesc.pFormatTypes = formattypes;
195 
197  &RpcMessage,
198  &StubMsg,
199  &StubDesc,
200  0);
201 
202  StubMsg.BufferLength = 0;
203  NdrPointerBufferSize( &StubMsg,
204  memsrc,
205  formattypes );
206  ok(StubMsg.BufferLength >= wiredatalen, "%s: length %d\n", msgpfx, StubMsg.BufferLength);
207 
208  /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
209  StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
210  StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
211 
212  memset(StubMsg.BufferStart, 0x0, StubMsg.BufferLength); /* This is a hack to clear the padding between the ptr and longlong/double */
213 
214  ptr = NdrPointerMarshall( &StubMsg, memsrc, formattypes );
215  ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
216  if (srcsize == 8 && wiredatalen == 16 && StubMsg.Buffer - StubMsg.BufferStart == 12)
217  {
218  /* win9x doesn't align 8-byte types properly */
219  wiredatalen = 12;
220  }
221  else
222  {
223  ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
224  ok(!memcmp(StubMsg.BufferStart, wiredata, wiredatalen), "%s: incorrectly marshaled\n", msgpfx);
225  }
226 
227  StubMsg.Buffer = StubMsg.BufferStart;
228  StubMsg.MemorySize = 0;
229 
230  size = NdrPointerMemorySize( &StubMsg, formattypes );
231  ok(size == StubMsg.MemorySize, "%s: mem size %u size %u\n", msgpfx, StubMsg.MemorySize, size);
232  ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
233  if (formattypes[1] & FC_POINTER_DEREF)
234  ok(size == srcsize + sizeof(void *), "%s: mem size %u\n", msgpfx, size);
235  else
236  ok(size == srcsize, "%s: mem size %u\n", msgpfx, size);
237 
238  StubMsg.Buffer = StubMsg.BufferStart;
239  StubMsg.MemorySize = 16;
240  size = NdrPointerMemorySize( &StubMsg, formattypes );
241  ok(size == StubMsg.MemorySize, "%s: mem size %u size %u\n", msgpfx, StubMsg.MemorySize, size);
242  ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
243  if (formattypes[1] & FC_POINTER_DEREF)
244  ok(size == srcsize + sizeof(void *) + 16, "%s: mem size %u\n", msgpfx, size);
245  else
246  ok(size == srcsize + 16, "%s: mem size %u\n", msgpfx, size);
247 
248  StubMsg.Buffer = StubMsg.BufferStart;
249  StubMsg.MemorySize = 1;
250  size = NdrPointerMemorySize( &StubMsg, formattypes );
251  ok(size == StubMsg.MemorySize, "%s: mem size %u size %u\n", msgpfx, StubMsg.MemorySize, size);
252  ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
253  if (formattypes[1] & FC_POINTER_DEREF)
254  ok(size == srcsize + sizeof(void *) + (srcsize == 8 ? 8 : sizeof(void *)), "%s: mem size %u\n", msgpfx, size);
255  else
256  ok(size == srcsize + (srcsize == 8 ? 8 : sizeof(void *)), "%s: mem size %u\n", msgpfx, size);
257 
258  size = srcsize;
259  if (formattypes[1] & FC_POINTER_DEREF) size += 4;
260 
261  StubMsg.Buffer = StubMsg.BufferStart;
262  StubMsg.MemorySize = 0;
263  /* Using my_alloc() here is necessary to prevent a crash in Windows 7+. */
264  mem_orig = mem = my_alloc(size);
265  memset(mem, 0, size);
267  if (formattypes[1] & FC_POINTER_DEREF)
268  *(void**)mem = NULL;
269  ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
270  ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
271  ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
272  ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
273  ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
274  ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
275  ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
276  /* On Windows 7+ unmarshalling may involve calls to NdrFree, for unclear reasons. */
277  my_free_called = 0;
278 
279  NdrPointerFree(&StubMsg, mem, formattypes);
280  if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
281  {
282  /* In this case the top-level pointer is not freed. */
283  ok(my_free_called == num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
284  HeapFree(GetProcessHeap(), 0, mem);
285  }
286  else
287  ok(my_free_called == 1 + num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
288 
289  /* reset the buffer and call with must alloc */
291  StubMsg.Buffer = StubMsg.BufferStart;
293  if (formattypes[1] & FC_POINTER_DEREF)
294  *(void**)mem = NULL;
295  ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 1 );
296  ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
297  /* doesn't allocate mem in this case */
298  ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
299  ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
300  ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
301  ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
302  ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
303  ok(!my_free_called, "%s: my_free got called %d times\n", msgpfx, my_free_called);
304 
305  NdrPointerFree(&StubMsg, mem, formattypes);
306  if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
307  {
308  /* In this case the top-level pointer is not freed. */
309  ok(my_free_called == num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
310  HeapFree(GetProcessHeap(), 0, mem);
311  }
312  else
313  ok(my_free_called == 1 + num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
314 
315  if (formattypes[0] != FC_RP)
316  {
317  /* now pass the address of a NULL ptr */
318  mem = NULL;
320  StubMsg.Buffer = StubMsg.BufferStart;
321  ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
322  ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
323  ok(mem != StubMsg.BufferStart + wiredatalen - srcsize, "%s: mem points to buffer %p %p\n", msgpfx, mem, StubMsg.BufferStart);
324  ok(!cmp(mem, memsrc, size), "%s: incorrectly unmarshaled\n", msgpfx);
325  ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
326  ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
327  ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
328  my_alloc_called = 0;
329  NdrPointerFree(&StubMsg, mem, formattypes);
330 
331  /* again pass address of NULL ptr, but pretend we're a server */
332  if (0) /* crashes on Win9x and NT4 */
333  {
334  mem = NULL;
335  StubMsg.Buffer = StubMsg.BufferStart;
336  StubMsg.IsClient = 0;
337  ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
338  ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
339  if (formattypes[2] == FC_ENUM16)
340  ok(mem != StubMsg.BufferStart + wiredatalen - srcsize, "%s: mem points to buffer %p %p\n", msgpfx, mem, StubMsg.BufferStart);
341  else
342  ok(mem == StubMsg.BufferStart + wiredatalen - srcsize, "%s: mem doesn't point to buffer %p %p\n", msgpfx, mem, StubMsg.BufferStart);
343  ok(!cmp(mem, memsrc, size), "%s: incorrectly unmarshaled\n", msgpfx);
344  ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
345  ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
346  if (formattypes[2] != FC_ENUM16)
347  {
348  ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
349  my_alloc_called = 0;
350  }
351  }
352  }
353 
354  /* Server */
355  StubMsg.IsClient = 0;
356 
357  /* For most basetypes (but not enum16), memory will not be allocated but
358  * instead point directly to the buffer. */
360  StubMsg.Buffer = StubMsg.BufferStart;
361  mem = NULL;
362  ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
363  ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
364  ok(!!mem, "%s: mem was not allocated\n", msgpfx);
365  ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
366  ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
367  ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
368  if (formattypes[2] == FC_ENUM16)
369  ok(my_alloc_called == 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
370  else
371  ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
372  ok(!my_free_called, "%s: my_free got called %d times\n", msgpfx, my_free_called);
373 
374  NdrPointerFree(&StubMsg, mem, formattypes);
375  if (formattypes[2] == FC_ENUM16)
376  ok(my_free_called == 1, "%s: my_free got called %d times\n", msgpfx, my_free_called);
377  else if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
378  {
379  /* In theory this should be freed to correspond with the allocation, but
380  * FC_ALLOCED_ON_STACK is set, and NdrPointerFree() has no way of
381  * knowing that the memory allocated by NdrPointerUnmarshall() isn't
382  * stack memory. In practice it always *is* stack memory if ON_STACK is
383  * set, so this leak isn't a concern. */
384  ok(my_free_called == 0, "%s: my_free got called %d times\n", msgpfx, my_free_called);
385  HeapFree(GetProcessHeap(), 0, mem);
386  }
387  else
388  ok(my_free_called == num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
389 
390  /* reset the buffer and call with must alloc */
392  StubMsg.Buffer = StubMsg.BufferStart;
393  mem = NULL;
394  ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 1 );
395  ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
396  ok(!!mem, "%s: mem was not allocated\n", msgpfx);
397  ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
398  ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
399  ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
400  if (formattypes[2] == FC_ENUM16)
401  ok(my_alloc_called == 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
402  else
403  ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
404  ok(!my_free_called, "%s: my_free got called %d times\n", msgpfx, my_free_called);
405 
406  NdrPointerFree(&StubMsg, mem, formattypes);
407  if (formattypes[2] == FC_ENUM16)
408  ok(my_free_called == 1, "%s: my_free got called %d times\n", msgpfx, my_free_called);
409  else if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
410  {
411  ok(my_free_called == 0, "%s: my_free got called %d times\n", msgpfx, my_free_called);
412  HeapFree(GetProcessHeap(), 0, mem);
413  }
414  else
415  ok(my_free_called == num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
416 
417  /* Ξ€est with an existing pointer. Unless it's a stack pointer (and deref'd)
418  * a new pointer will be allocated anyway (in fact, an invalid pointer works
419  * in every such case). */
420 
422  StubMsg.Buffer = StubMsg.BufferStart;
424  if (formattypes[1] & FC_POINTER_DEREF)
425  *(void**)mem = NULL;
426  ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
427  ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
428  if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
429  ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
430  else
431  {
432  ok(mem != mem_orig, "%s: mem has not changed\n", msgpfx);
433  HeapFree(GetProcessHeap(), 0, mem_orig);
434  }
435  ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
436  ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
437  ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
438  if (formattypes[2] == FC_ENUM16)
439  ok(my_alloc_called == 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
440  else if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
441  ok(my_alloc_called == 0, "%s: my_alloc got called %d times\n", msgpfx, my_free_called);
442  else
443  ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
444  ok(!my_free_called, "%s: my_free got called %d times\n", msgpfx, my_free_called);
445 
446  NdrPointerFree(&StubMsg, mem, formattypes);
447  if (formattypes[2] == FC_ENUM16)
448  ok(my_free_called == 1, "%s: my_free got called %d times\n", msgpfx, my_free_called);
449  else if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
450  {
451  ok(my_free_called == 0, "%s: my_free got called %d times\n", msgpfx, my_free_called);
452  HeapFree(GetProcessHeap(), 0, mem);
453  }
454  else
455  ok(my_free_called == num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
456 
457  /* reset the buffer and call with must alloc */
459  StubMsg.Buffer = StubMsg.BufferStart;
461  if (formattypes[1] & FC_POINTER_DEREF)
462  *(void**)mem = NULL;
463  ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 1 );
464  ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
465  if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
466  ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
467  else
468  {
469  ok(mem != mem_orig, "%s: mem has not changed\n", msgpfx);
470  HeapFree(GetProcessHeap(), 0, mem_orig);
471  }
472  ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
473  ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
474  ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
475  if (formattypes[2] == FC_ENUM16)
476  ok(my_alloc_called == 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
477  else if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
478  ok(my_alloc_called == 0, "%s: my_alloc got called %d times\n", msgpfx, my_free_called);
479  else
480  ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
481  ok(!my_free_called, "%s: my_free got called %d times\n", msgpfx, my_free_called);
482 
483  NdrPointerFree(&StubMsg, mem, formattypes);
484  if (formattypes[2] == FC_ENUM16)
485  ok(my_free_called == 1, "%s: my_free got called %d times\n", msgpfx, my_free_called);
486  else if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
487  {
488  ok(my_free_called == 0, "%s: my_free got called %d times\n", msgpfx, my_free_called);
489  HeapFree(GetProcessHeap(), 0, mem);
490  }
491  else
492  ok(my_free_called == num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
493 
494  HeapFree(GetProcessHeap(), 0, StubMsg.BufferStart);
495 }
void WINAPI NdrPointerFree(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
#define FC_POINTER_DEREF
Definition: ndrtypes.h:276
static int my_alloc_called
Definition: ndr_marshall.c:40
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
GLint x0
Definition: linetemp.h:95
ULONG MemorySize
Definition: rpcndr.h:208
unsigned char * Buffer
Definition: rpcndr.h:203
static int my_free_called
Definition: ndr_marshall.c:41
PRPC_MESSAGE RpcMsg
Definition: rpcndr.h:202
#define cmp(status, error)
Definition: error.c:114
void * Buffer
Definition: rpcdcep.h:40
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
#define FC_ALLOCED_ON_STACK
Definition: ndrtypes.h:274
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:404
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned char *WINAPI NdrPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned char *WINAPI NdrPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
const unsigned char * pFormatTypes
Definition: rpcndr.h:374
void WINAPI NdrPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char * BufferStart
Definition: rpcndr.h:204
ULONG BufferLength
Definition: rpcndr.h:207
unsigned char * BufferEnd
Definition: rpcndr.h:205
unsigned char IsClient
Definition: rpcndr.h:210
ULONG WINAPI NdrPointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
#define ok(value,...)
Definition: atltest.h:57
static void *CALLBACK my_alloc(SIZE_T size)
Definition: ndr_marshall.c:42
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
Definition: mem.c:156
void WINAPI NdrClientInitializeNew(PRPC_MESSAGE pRpcMessage, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDesc, unsigned int ProcNum)
#define memset(x, y, z)
Definition: compat.h:39
#define HeapFree(x, y, z)
Definition: compat.h:403

Referenced by test_simple_struct(), and test_simple_types().

◆ test_server_init()

static void test_server_init ( void  )
static

Definition at line 1823 of file ndr_marshall.c.

1824 {
1825  MIDL_STUB_MESSAGE stubMsg;
1826  RPC_MESSAGE rpcMsg;
1827  unsigned char *ret;
1828  unsigned char buffer[256];
1829 
1830  memset(&rpcMsg, 0, sizeof(rpcMsg));
1831  rpcMsg.Buffer = buffer;
1832  rpcMsg.BufferLength = sizeof(buffer);
1833  rpcMsg.RpcFlags = RPC_BUFFER_COMPLETE;
1834 
1835  memset(&stubMsg, 0xcc, sizeof(stubMsg));
1836 
1837  ret = NdrServerInitializeNew(&rpcMsg, &stubMsg, &Object_StubDesc);
1838  ok(ret == NULL, "NdrServerInitializeNew should have returned NULL instead of %p\n", ret);
1839 
1840  test_common_stub_data( "NdrServerInitializeNew", &stubMsg );
1841 
1842  ok(stubMsg.RpcMsg == &rpcMsg, "stubMsg.RpcMsg should have been %p instead of %p\n", &rpcMsg, stubMsg.RpcMsg);
1843  ok(stubMsg.Buffer == buffer, "stubMsg.Buffer should have been %p instead of %p\n", buffer, stubMsg.Buffer);
1844  ok(stubMsg.BufferStart == buffer, "stubMsg.BufferStart should have been %p instead of %p\n", buffer, stubMsg.BufferStart);
1845  ok(stubMsg.BufferEnd == buffer + sizeof(buffer), "stubMsg.BufferEnd should have been %p instead of %p\n", buffer + sizeof(buffer), stubMsg.BufferEnd);
1846 todo_wine
1847  ok(stubMsg.BufferLength == 0, "stubMsg.BufferLength should have been 0 instead of %u\n", stubMsg.BufferLength);
1848  ok(stubMsg.IsClient == 0, "stubMsg.IsClient should have been 0 instead of %u\n", stubMsg.IsClient);
1849  ok(stubMsg.ReuseBuffer == 0 ||
1850  broken(stubMsg.ReuseBuffer == 1), /* win2k */
1851  "stubMsg.ReuseBuffer should have been set to zero instead of %d\n", stubMsg.ReuseBuffer);
1852  ok(stubMsg.CorrDespIncrement == 0 ||
1853  broken(stubMsg.CorrDespIncrement == 0xcc), /* <= Win 2003 */
1854  "CorrDespIncrement should have been set to zero instead of 0x%x\n", stubMsg.CorrDespIncrement);
1855  ok(stubMsg.FullPtrXlatTables == 0, "stubMsg.BufferLength should have been 0 instead of %p\n", stubMsg.FullPtrXlatTables);
1856 }
unsigned char *WINAPI NdrServerInitializeNew(PRPC_MESSAGE pRpcMsg, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDesc)
unsigned char * Buffer
Definition: rpcndr.h:203
struct _FULL_PTR_XLAT_TABLES * FullPtrXlatTables
Definition: rpcndr.h:231
GLuint buffer
Definition: glext.h:5915
PRPC_MESSAGE RpcMsg
Definition: rpcndr.h:202
static void test_common_stub_data(const char *prefix, const MIDL_STUB_MESSAGE *stubMsg)
unsigned int BufferLength
Definition: rpcdcep.h:41
void * Buffer
Definition: rpcdcep.h:40
smooth NULL
Definition: ftsmooth.c:416
static const MIDL_STUB_DESC Object_StubDesc
Definition: ndr_marshall.c:54
ULONG RpcFlags
Definition: rpcdcep.h:48
unsigned char * BufferStart
Definition: rpcndr.h:204
ULONG BufferLength
Definition: rpcndr.h:207
unsigned char * BufferEnd
Definition: rpcndr.h:205
int ret
#define todo_wine
Definition: test.h:162
#define broken(x)
Definition: _sntprintf.h:21
#define RPC_BUFFER_COMPLETE
Definition: rpcdcep.h:67
unsigned char IsClient
Definition: rpcndr.h:210
#define ok(value,...)
Definition: atltest.h:57
unsigned char CorrDespIncrement
Definition: rpcndr.h:218
#define memset(x, y, z)
Definition: compat.h:39

Referenced by START_TEST().

◆ test_simple_struct()

static void test_simple_struct ( void  )
static

Definition at line 1074 of file ndr_marshall.c.

1075 {
1076  unsigned char wiredata[28];
1077  ULONG wiredatalen;
1078  LONG l;
1079  char c;
1080  ps1_t ps1;
1081 
1082  static const unsigned char fmtstr_simple_struct[] =
1083  {
1084  0x12, 0x0, /* FC_UP */
1085  NdrFcShort( 0x2 ), /* Offset=2 */
1086  0x15, 0x3, /* FC_STRUCT [align 4] */
1087  NdrFcShort( 0x18 ), /* [size 24] */
1088  0x6, /* FC_SHORT */
1089  0x2, /* FC_CHAR */
1090  0x38, /* FC_ALIGNM4 */
1091  0x8, /* FC_LONG */
1092  0x8, /* FC_LONG */
1093  0x39, /* FC_ALIGNM8 */
1094  0xb, /* FC_HYPER */
1095  0x5b, /* FC_END */
1096  };
1097  struct {
1098  short s;
1099  char c;
1100  LONG l1, l2;
1101  LONGLONG ll;
1102  } s1;
1103 
1104  static const unsigned char fmtstr_pointer_struct[] =
1105  {
1106  0x12, 0x0, /* FC_UP */
1107  NdrFcShort( 0x2 ), /* Offset=2 */
1108 #ifdef _WIN64
1109  0x1a, /* FC_BOGUS_STRUCT */
1110  0x3, /* 3 */
1111  NdrFcShort(0x18), /* [size 24] */
1112  NdrFcShort(0x0),
1113  NdrFcShort(0x8), /* Offset= 8 (266) */
1114  0x08, /* FC_LONG */
1115  0x39, /* FC_ALIGNM8 */
1116  0x36, /* FC_POINTER */
1117  0x36, /* FC_POINTER */
1118  0x5c, /* FC_PAD */
1119  0x5b, /* FC_END */
1120  0x12, 0x8, /* FC_UP [simple_pointer] */
1121  0x08, /* FC_LONG */
1122  0x5c, /* FC_PAD */
1123  0x12, 0x8, /* FC_UP [simple_pointer] */
1124  0x02, /* FC_CHAR */
1125  0x5c, /* FC_PAD */
1126 #else
1127  0x16, 0x3, /* FC_PSTRUCT [align 4] */
1128  NdrFcShort( 0xc ), /* [size 12] */
1129  0x4b, /* FC_PP */
1130  0x5c, /* FC_PAD */
1131  0x46, /* FC_NO_REPEAT */
1132  0x5c, /* FC_PAD */
1133  NdrFcShort( 0x4 ), /* 4 */
1134  NdrFcShort( 0x4 ), /* 4 */
1135  0x13, 0x8, /* FC_OP [simple_pointer] */
1136  0x8, /* FC_LONG */
1137  0x5c, /* FC_PAD */
1138  0x46, /* FC_NO_REPEAT */
1139  0x5c, /* FC_PAD */
1140  NdrFcShort( 0x8 ), /* 8 */
1141  NdrFcShort( 0x8 ), /* 8 */
1142  0x13, 0x8, /* FC_OP [simple_pointer] */
1143  0x2, /* FC_CHAR */
1144  0x5c, /* FC_PAD */
1145  0x5b, /* FC_END */
1146  0x8, /* FC_LONG */
1147  0x8, /* FC_LONG */
1148  0x8, /* FC_LONG */
1149  0x5c, /* FC_PAD */
1150  0x5b, /* FC_END */
1151 #endif
1152  };
1153 
1154  /* zero the entire structure, including the holes */
1155  memset(&s1, 0, sizeof(s1));
1156 
1157  /* FC_STRUCT */
1158  s1.s = 0x1234;
1159  s1.c = 0xa5;
1160  s1.l1 = 0xdeadbeef;
1161  s1.l2 = 0xcafebabe;
1162  s1.ll = ((ULONGLONG) 0xbadefeed << 32) | 0x2468ace0;
1163 
1164  wiredatalen = 24;
1165  memcpy(wiredata, &s1, wiredatalen);
1166  test_simple_struct_marshal(fmtstr_simple_struct + 4, &s1, 24, wiredata, 24, NULL, 0, "struct");
1167 
1168  if (use_pointer_ids)
1169  *(unsigned int *)wiredata = 0x20000;
1170  else
1171  *(unsigned int *)wiredata = (UINT_PTR)&s1;
1172  memcpy(wiredata + 4, &s1, wiredatalen);
1173  test_pointer_marshal(fmtstr_simple_struct, &s1, 24, wiredata, 28, NULL, 0, "struct");
1174 
1175  if (sizeof(void *) == 8) return; /* it cannot be represented as a simple struct on Win64 */
1176 
1177  /* zero the entire structure, including the hole */
1178  memset(&ps1, 0, sizeof(ps1));
1179 
1180  /* FC_PSTRUCT */
1181  ps1.l1 = 0xdeadbeef;
1182  l = 0xcafebabe;
1183  ps1.pl1 = &l;
1184  c = 'a';
1185  ps1.pc1 = &c;
1186  *(unsigned int *)(wiredata + 4) = 0xdeadbeef;
1187  if (use_pointer_ids)
1188  {
1189  *(unsigned int *)(wiredata + 8) = 0x20000;
1190  *(unsigned int *)(wiredata + 12) = 0x20004;
1191  }
1192  else
1193  {
1194  *(unsigned int *)(wiredata + 8) = (UINT_PTR)&l;
1195  *(unsigned int *)(wiredata + 12) = (UINT_PTR)&c;
1196  }
1197  memcpy(wiredata + 16, &l, 4);
1198  memcpy(wiredata + 20, &c, 1);
1199 
1200  test_simple_struct_marshal(fmtstr_pointer_struct + 4, &ps1, 17, wiredata + 4, 17, ps1_cmp, 2, "pointer_struct");
1201  if (use_pointer_ids)
1202  {
1203  *(unsigned int *)wiredata = 0x20000;
1204  *(unsigned int *)(wiredata + 8) = 0x20004;
1205  *(unsigned int *)(wiredata + 12) = 0x20008;
1206  }
1207  else
1208  *(unsigned int *)wiredata = (UINT_PTR)&ps1;
1209  test_pointer_marshal(fmtstr_pointer_struct, &ps1, 17, wiredata, 21, ps1_cmp, 2, "pointer_struct");
1210 }
unsigned __int3264 UINT_PTR
Definition: activex.cpp:275
LONG l1
static void test_simple_struct_marshal(const unsigned char *formattypes, void *memsrc, DWORD srcsize, const void *wiredata, ULONG wiredatalen, int(*cmp)(const void *, const void *, size_t), int num_additional_allocs, const char *msgpfx)
Definition: ndr_marshall.c:870
static BOOL use_pointer_ids
Definition: ndr_marshall.c:103
GLint x0
Definition: linetemp.h:95
static void test_pointer_marshal(const unsigned char *formattypes, void *memsrc, DWORD srcsize, const void *wiredata, ULONG wiredatalen, int(*cmp)(const void *, const void *, size_t), int num_additional_allocs, const char *msgpfx)
Definition: ndr_marshall.c:175
#define NdrFcShort(s)
Definition: rpcndr.h:134
LONG * pl1
long LONG
Definition: pedump.c:60
smooth NULL
Definition: ftsmooth.c:416
char * pc1
r l[0]
Definition: byte_order.h:167
int64_t LONGLONG
Definition: typedefs.h:67