mirror of
https://github.com/reactos/reactos.git
synced 2024-08-19 18:02:55 +00:00
2515 lines
96 KiB
C
2515 lines
96 KiB
C
/*
|
|
* Unit test suite for ndr marshalling functions
|
|
*
|
|
* Copyright 2006 Huw Davies
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#define _WIN32_WINNT 0x0500
|
|
#define NTDDI_WIN2K 0x05000000
|
|
#define NTDDI_VERSION NTDDI_WIN2K /* for some MIDL_STUB_MESSAGE fields */
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include "wine/test.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"
|
|
|
|
static int my_alloc_called;
|
|
static int my_free_called;
|
|
static void * CALLBACK my_alloc(SIZE_T size)
|
|
{
|
|
my_alloc_called++;
|
|
return NdrOleAllocate(size);
|
|
}
|
|
|
|
static void CALLBACK my_free(void *ptr)
|
|
{
|
|
my_free_called++;
|
|
NdrOleFree(ptr);
|
|
}
|
|
|
|
static const MIDL_STUB_DESC Object_StubDesc =
|
|
{
|
|
NULL,
|
|
my_alloc,
|
|
my_free,
|
|
{ 0 },
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
NULL, /* format string, filled in by tests */
|
|
1, /* -error bounds_check flag */
|
|
0x20000, /* Ndr library version */
|
|
0,
|
|
0x50100a4, /* MIDL Version 5.1.164 */
|
|
0,
|
|
NULL,
|
|
0, /* notify & notify_flag routine table */
|
|
1, /* Flags */
|
|
0, /* Reserved3 */
|
|
0, /* Reserved4 */
|
|
0 /* Reserved5 */
|
|
};
|
|
|
|
static RPC_DISPATCH_FUNCTION IFoo_table[] =
|
|
{
|
|
0
|
|
};
|
|
|
|
static RPC_DISPATCH_TABLE IFoo_v0_0_DispatchTable =
|
|
{
|
|
0,
|
|
IFoo_table
|
|
};
|
|
|
|
static const RPC_SERVER_INTERFACE IFoo___RpcServerInterface =
|
|
{
|
|
sizeof(RPC_SERVER_INTERFACE),
|
|
{{0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x12,0x34}},{0,0}},
|
|
{{0x8a885d04,0x1ceb,0x11c9,{0x9f,0xe8,0x08,0x00,0x2b,0x10,0x48,0x60}},{2,0}},
|
|
&IFoo_v0_0_DispatchTable,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
};
|
|
|
|
static RPC_IF_HANDLE IFoo_v0_0_s_ifspec = (RPC_IF_HANDLE)& IFoo___RpcServerInterface;
|
|
static BOOL use_pointer_ids = FALSE;
|
|
|
|
static void determine_pointer_marshalling_style(void)
|
|
{
|
|
RPC_MESSAGE RpcMessage;
|
|
MIDL_STUB_MESSAGE StubMsg;
|
|
MIDL_STUB_DESC StubDesc;
|
|
char ch = 0xde;
|
|
|
|
static const unsigned char fmtstr_up_char[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x2, /* FC_CHAR */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
|
|
StubDesc = Object_StubDesc;
|
|
StubDesc.pFormatTypes = NULL;
|
|
|
|
NdrClientInitializeNew(
|
|
&RpcMessage,
|
|
&StubMsg,
|
|
&StubDesc,
|
|
0);
|
|
|
|
StubMsg.BufferLength = 8;
|
|
StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
|
|
NdrPointerMarshall(&StubMsg, (unsigned char*)&ch, fmtstr_up_char);
|
|
ok(StubMsg.Buffer == StubMsg.BufferStart + 5, "%p %p\n", StubMsg.Buffer, StubMsg.BufferStart);
|
|
|
|
use_pointer_ids = (*(unsigned int *)StubMsg.BufferStart != (UINT_PTR)&ch);
|
|
trace("Pointer marshalling using %s\n", use_pointer_ids ? "pointer ids" : "pointer value");
|
|
|
|
HeapFree(GetProcessHeap(), 0, StubMsg.BufferStart);
|
|
}
|
|
|
|
static void test_ndr_simple_type(void)
|
|
{
|
|
RPC_MESSAGE RpcMessage;
|
|
MIDL_STUB_MESSAGE StubMsg;
|
|
MIDL_STUB_DESC StubDesc;
|
|
LONG l, l2 = 0;
|
|
|
|
StubDesc = Object_StubDesc;
|
|
StubDesc.pFormatTypes = NULL;
|
|
|
|
NdrClientInitializeNew(
|
|
&RpcMessage,
|
|
&StubMsg,
|
|
&StubDesc,
|
|
0);
|
|
|
|
StubMsg.BufferLength = 16;
|
|
StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
|
|
l = 0xcafebabe;
|
|
NdrSimpleTypeMarshall(&StubMsg, (unsigned char*)&l, 8 /* FC_LONG */);
|
|
ok(StubMsg.Buffer == StubMsg.BufferStart + 4, "%p %p\n", StubMsg.Buffer, StubMsg.BufferStart);
|
|
ok(*(LONG*)StubMsg.BufferStart == l, "%d\n", *(LONG*)StubMsg.BufferStart);
|
|
|
|
StubMsg.Buffer = StubMsg.BufferStart + 1;
|
|
NdrSimpleTypeMarshall(&StubMsg, (unsigned char*)&l, 8 /* FC_LONG */);
|
|
ok(StubMsg.Buffer == StubMsg.BufferStart + 8, "%p %p\n", StubMsg.Buffer, StubMsg.BufferStart);
|
|
ok(*(LONG*)(StubMsg.BufferStart + 4) == l, "%d\n", *(LONG*)StubMsg.BufferStart);
|
|
|
|
StubMsg.Buffer = StubMsg.BufferStart + 1;
|
|
NdrSimpleTypeUnmarshall(&StubMsg, (unsigned char*)&l2, 8 /* FC_LONG */);
|
|
ok(StubMsg.Buffer == StubMsg.BufferStart + 8, "%p %p\n", StubMsg.Buffer, StubMsg.BufferStart);
|
|
ok(l2 == l, "%d\n", l2);
|
|
|
|
HeapFree(GetProcessHeap(), 0, StubMsg.BufferStart);
|
|
}
|
|
|
|
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)
|
|
{
|
|
RPC_MESSAGE RpcMessage;
|
|
MIDL_STUB_MESSAGE StubMsg;
|
|
MIDL_STUB_DESC StubDesc;
|
|
DWORD size;
|
|
void *ptr;
|
|
unsigned char *mem, *mem_orig;
|
|
|
|
my_alloc_called = my_free_called = 0;
|
|
if(!cmp)
|
|
cmp = memcmp;
|
|
|
|
StubDesc = Object_StubDesc;
|
|
StubDesc.pFormatTypes = formattypes;
|
|
|
|
NdrClientInitializeNew(
|
|
&RpcMessage,
|
|
&StubMsg,
|
|
&StubDesc,
|
|
0);
|
|
|
|
StubMsg.BufferLength = 0;
|
|
NdrPointerBufferSize( &StubMsg,
|
|
memsrc,
|
|
formattypes );
|
|
ok(StubMsg.BufferLength >= wiredatalen, "%s: length %d\n", msgpfx, StubMsg.BufferLength);
|
|
|
|
/*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
|
|
StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
|
|
StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
|
|
|
|
memset(StubMsg.BufferStart, 0x0, StubMsg.BufferLength); /* This is a hack to clear the padding between the ptr and longlong/double */
|
|
|
|
ptr = NdrPointerMarshall( &StubMsg, memsrc, formattypes );
|
|
ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
|
|
if (srcsize == 8 && wiredatalen == 16 && StubMsg.Buffer - StubMsg.BufferStart == 12)
|
|
{
|
|
/* win9x doesn't align 8-byte types properly */
|
|
wiredatalen = 12;
|
|
}
|
|
else
|
|
{
|
|
ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
|
|
ok(!memcmp(StubMsg.BufferStart, wiredata, wiredatalen), "%s: incorrectly marshaled\n", msgpfx);
|
|
}
|
|
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
StubMsg.MemorySize = 0;
|
|
|
|
size = NdrPointerMemorySize( &StubMsg, formattypes );
|
|
ok(size == StubMsg.MemorySize, "%s: mem size %u size %u\n", msgpfx, StubMsg.MemorySize, size);
|
|
ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
|
|
if(formattypes[1] & 0x10 /* FC_POINTER_DEREF */)
|
|
ok(size == srcsize + sizeof(void *), "%s: mem size %u\n", msgpfx, size);
|
|
else
|
|
ok(size == srcsize, "%s: mem size %u\n", msgpfx, size);
|
|
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
StubMsg.MemorySize = 16;
|
|
size = NdrPointerMemorySize( &StubMsg, formattypes );
|
|
ok(size == StubMsg.MemorySize, "%s: mem size %u size %u\n", msgpfx, StubMsg.MemorySize, size);
|
|
ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
|
|
if(formattypes[1] & 0x10 /* FC_POINTER_DEREF */)
|
|
ok(size == srcsize + sizeof(void *) + 16, "%s: mem size %u\n", msgpfx, size);
|
|
else
|
|
ok(size == srcsize + 16, "%s: mem size %u\n", msgpfx, size);
|
|
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
StubMsg.MemorySize = 1;
|
|
size = NdrPointerMemorySize( &StubMsg, formattypes );
|
|
ok(size == StubMsg.MemorySize, "%s: mem size %u size %u\n", msgpfx, StubMsg.MemorySize, size);
|
|
ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
|
|
if(formattypes[1] & 0x10 /* FC_POINTER_DEREF */)
|
|
ok(size == srcsize + sizeof(void *) + (srcsize == 8 ? 8 : sizeof(void *)), "%s: mem size %u\n", msgpfx, size);
|
|
else
|
|
ok(size == srcsize + (srcsize == 8 ? 8 : sizeof(void *)), "%s: mem size %u\n", msgpfx, size);
|
|
|
|
size = srcsize;
|
|
if(formattypes[1] & 0x10) size += 4;
|
|
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
StubMsg.MemorySize = 0;
|
|
mem_orig = mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
|
|
|
|
if(formattypes[1] & 0x10 /* FC_POINTER_DEREF */)
|
|
*(void**)mem = NULL;
|
|
ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
|
|
ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
|
|
ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
|
|
ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
|
|
ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
|
|
ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
|
|
ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
|
|
my_alloc_called = 0;
|
|
|
|
/* reset the buffer and call with must alloc */
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
if(formattypes[1] & 0x10 /* FC_POINTER_DEREF */)
|
|
*(void**)mem = NULL;
|
|
ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 1 );
|
|
ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
|
|
/* doesn't allocate mem in this case */
|
|
todo_wine {
|
|
ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
|
|
}
|
|
ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
|
|
ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
|
|
ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
|
|
|
|
todo_wine {
|
|
ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
|
|
}
|
|
my_alloc_called = 0;
|
|
if(formattypes[0] != 0x11 /* FC_RP */)
|
|
{
|
|
/* now pass the address of a NULL ptr */
|
|
mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
|
|
ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
|
|
ok(mem != StubMsg.BufferStart + wiredatalen - srcsize, "%s: mem points to buffer %p %p\n", msgpfx, mem, StubMsg.BufferStart);
|
|
ok(!cmp(mem, memsrc, size), "%s: incorrectly unmarshaled\n", msgpfx);
|
|
ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
|
|
ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
|
|
ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
|
|
my_alloc_called = 0;
|
|
NdrPointerFree(&StubMsg, mem, formattypes);
|
|
|
|
/* again pass address of NULL ptr, but pretend we're a server */
|
|
if (0) /* crashes on Win9x and NT4 */
|
|
{
|
|
mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
StubMsg.IsClient = 0;
|
|
ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
|
|
ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
|
|
if (formattypes[2] == 0xd /* FC_ENUM16 */)
|
|
ok(mem != StubMsg.BufferStart + wiredatalen - srcsize, "%s: mem points to buffer %p %p\n", msgpfx, mem, StubMsg.BufferStart);
|
|
else
|
|
ok(mem == StubMsg.BufferStart + wiredatalen - srcsize, "%s: mem doesn't point to buffer %p %p\n", msgpfx, mem, StubMsg.BufferStart);
|
|
ok(!cmp(mem, memsrc, size), "%s: incorrectly unmarshaled\n", msgpfx);
|
|
ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
|
|
ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
|
|
if (formattypes[2] != 0xd /* FC_ENUM16 */) {
|
|
ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
|
|
my_alloc_called = 0;
|
|
}
|
|
}
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, mem_orig);
|
|
HeapFree(GetProcessHeap(), 0, StubMsg.BufferStart);
|
|
}
|
|
|
|
static int deref_cmp(const void *s1, const void *s2, size_t num)
|
|
{
|
|
return memcmp(*(const void *const *)s1, *(const void *const *)s2, num);
|
|
}
|
|
|
|
|
|
static void test_simple_types(void)
|
|
{
|
|
unsigned char wiredata[16];
|
|
unsigned char ch;
|
|
unsigned char *ch_ptr;
|
|
unsigned short s;
|
|
unsigned int i;
|
|
ULONG l;
|
|
ULONGLONG ll;
|
|
float f;
|
|
double d;
|
|
|
|
static const unsigned char fmtstr_up_char[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x2, /* FC_CHAR */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
static const unsigned char fmtstr_up_byte[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x1, /* FC_BYTE */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
static const unsigned char fmtstr_up_small[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x3, /* FC_SMALL */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
static const unsigned char fmtstr_up_usmall[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x4, /* FC_USMALL */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
static const unsigned char fmtstr_rp_char[] =
|
|
{
|
|
0x11, 0x8, /* FC_RP [simple_pointer] */
|
|
0x2, /* FC_CHAR */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
static const unsigned char fmtstr_rpup_char[] =
|
|
{
|
|
0x11, 0x14, /* FC_RP [alloced_on_stack] */
|
|
NdrFcShort( 0x2 ), /* Offset= 2 (4) */
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x2, /* FC_CHAR */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
static const unsigned char fmtstr_rpup_char2[] =
|
|
{
|
|
0x11, 0x04, /* FC_RP [alloced_on_stack] */
|
|
NdrFcShort( 0x2 ), /* Offset= 2 (4) */
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x2, /* FC_CHAR */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
|
|
static const unsigned char fmtstr_up_wchar[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x5, /* FC_WCHAR */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
static const unsigned char fmtstr_up_short[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x6, /* FC_SHORT */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
static const unsigned char fmtstr_up_ushort[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x7, /* FC_USHORT */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
static const unsigned char fmtstr_up_enum16[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0xd, /* FC_ENUM16 */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
static const unsigned char fmtstr_up_long[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x8, /* FC_LONG */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
static const unsigned char fmtstr_up_ulong[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x9, /* FC_ULONG */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
static const unsigned char fmtstr_up_enum32[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0xe, /* FC_ENUM32 */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
static const unsigned char fmtstr_up_errorstatus[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x10, /* FC_ERROR_STATUS_T */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
|
|
static const unsigned char fmtstr_up_longlong[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0xb, /* FC_HYPER */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
static const unsigned char fmtstr_up_float[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0xa, /* FC_FLOAT */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
static const unsigned char fmtstr_up_double[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0xc, /* FC_DOUBLE */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
|
|
ch = 0xa5;
|
|
ch_ptr = &ch;
|
|
if (use_pointer_ids)
|
|
*(unsigned int *)wiredata = 0x20000;
|
|
else
|
|
*(unsigned int *)wiredata = (UINT_PTR)ch_ptr;
|
|
wiredata[4] = ch;
|
|
|
|
test_pointer_marshal(fmtstr_up_char, ch_ptr, 1, wiredata, 5, NULL, 0, "up_char");
|
|
test_pointer_marshal(fmtstr_up_byte, ch_ptr, 1, wiredata, 5, NULL, 0, "up_byte");
|
|
test_pointer_marshal(fmtstr_up_small, ch_ptr, 1, wiredata, 5, NULL, 0, "up_small");
|
|
test_pointer_marshal(fmtstr_up_usmall, ch_ptr, 1, wiredata, 5, NULL, 0, "up_usmall");
|
|
|
|
test_pointer_marshal(fmtstr_rp_char, ch_ptr, 1, &ch, 1, NULL, 0, "rp_char");
|
|
|
|
test_pointer_marshal(fmtstr_rpup_char, &ch_ptr, 1, wiredata, 5, deref_cmp, 1, "rpup_char");
|
|
test_pointer_marshal(fmtstr_rpup_char2, ch_ptr, 1, wiredata, 5, NULL, 0, "rpup_char2");
|
|
|
|
s = 0xa597;
|
|
if (use_pointer_ids)
|
|
*(unsigned int *)wiredata = 0x20000;
|
|
else
|
|
*(unsigned int *)wiredata = (UINT_PTR)&s;
|
|
*(unsigned short*)(wiredata + 4) = s;
|
|
|
|
test_pointer_marshal(fmtstr_up_wchar, &s, 2, wiredata, 6, NULL, 0, "up_wchar");
|
|
test_pointer_marshal(fmtstr_up_short, &s, 2, wiredata, 6, NULL, 0, "up_short");
|
|
test_pointer_marshal(fmtstr_up_ushort, &s, 2, wiredata, 6, NULL, 0, "up_ushort");
|
|
|
|
i = 0x7fff;
|
|
if (use_pointer_ids)
|
|
*(unsigned int *)wiredata = 0x20000;
|
|
else
|
|
*(unsigned int *)wiredata = (UINT_PTR)&i;
|
|
*(unsigned short*)(wiredata + 4) = i;
|
|
test_pointer_marshal(fmtstr_up_enum16, &i, 4, wiredata, 6, NULL, 0, "up_enum16");
|
|
|
|
l = 0xcafebabe;
|
|
if (use_pointer_ids)
|
|
*(unsigned int *)wiredata = 0x20000;
|
|
else
|
|
*(unsigned int *)wiredata = (UINT_PTR)&l;
|
|
*(ULONG*)(wiredata + 4) = l;
|
|
|
|
test_pointer_marshal(fmtstr_up_long, &l, 4, wiredata, 8, NULL, 0, "up_long");
|
|
test_pointer_marshal(fmtstr_up_ulong, &l, 4, wiredata, 8, NULL, 0, "up_ulong");
|
|
test_pointer_marshal(fmtstr_up_enum32, &l, 4, wiredata, 8, NULL, 0, "up_emun32");
|
|
test_pointer_marshal(fmtstr_up_errorstatus, &l, 4, wiredata, 8, NULL, 0, "up_errorstatus");
|
|
|
|
ll = ((ULONGLONG)0xcafebabe) << 32 | 0xdeadbeef;
|
|
if (use_pointer_ids)
|
|
*(unsigned int *)wiredata = 0x20000;
|
|
else
|
|
*(unsigned int *)wiredata = (UINT_PTR)≪
|
|
*(unsigned int *)(wiredata + 4) = 0;
|
|
*(ULONGLONG*)(wiredata + 8) = ll;
|
|
test_pointer_marshal(fmtstr_up_longlong, &ll, 8, wiredata, 16, NULL, 0, "up_longlong");
|
|
|
|
f = 3.1415f;
|
|
if (use_pointer_ids)
|
|
*(unsigned int *)wiredata = 0x20000;
|
|
else
|
|
*(unsigned int *)wiredata = (UINT_PTR)&f;
|
|
*(float*)(wiredata + 4) = f;
|
|
test_pointer_marshal(fmtstr_up_float, &f, 4, wiredata, 8, NULL, 0, "up_float");
|
|
|
|
d = 3.1415;
|
|
if (use_pointer_ids)
|
|
*(unsigned int *)wiredata = 0x20000;
|
|
else
|
|
*(unsigned int *)wiredata = (UINT_PTR)&d;
|
|
*(unsigned int *)(wiredata + 4) = 0;
|
|
*(double*)(wiredata + 8) = d;
|
|
test_pointer_marshal(fmtstr_up_double, &d, 8, wiredata, 16, NULL, 0, "up_double");
|
|
|
|
}
|
|
|
|
static void test_nontrivial_pointer_types(void)
|
|
{
|
|
RPC_MESSAGE RpcMessage;
|
|
MIDL_STUB_MESSAGE StubMsg;
|
|
MIDL_STUB_DESC StubDesc;
|
|
DWORD size;
|
|
void *ptr;
|
|
char **p1;
|
|
char *p2;
|
|
char ch;
|
|
unsigned char *mem, *mem_orig;
|
|
|
|
static const unsigned char fmtstr_ref_unique_out[] =
|
|
{
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x2, /* FC_CHAR */
|
|
0x5c, /* FC_PAD */
|
|
0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */
|
|
NdrFcShort( 0xfffffffa ), /* Offset= -6 (0) */
|
|
};
|
|
|
|
p1 = &p2;
|
|
p2 = &ch;
|
|
ch = 0x22;
|
|
|
|
StubDesc = Object_StubDesc;
|
|
StubDesc.pFormatTypes = fmtstr_ref_unique_out;
|
|
|
|
NdrClientInitializeNew(
|
|
&RpcMessage,
|
|
&StubMsg,
|
|
&StubDesc,
|
|
0);
|
|
|
|
StubMsg.BufferLength = 0;
|
|
NdrPointerBufferSize( &StubMsg,
|
|
(unsigned char *)p1,
|
|
&fmtstr_ref_unique_out[4] );
|
|
|
|
/* Windows overestimates the buffer size */
|
|
ok(StubMsg.BufferLength >= 5, "length %d\n", StubMsg.BufferLength);
|
|
|
|
/*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
|
|
StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
|
|
StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
|
|
|
|
ptr = NdrPointerMarshall( &StubMsg, (unsigned char *)p1, &fmtstr_ref_unique_out[4] );
|
|
ok(ptr == NULL, "ret %p\n", ptr);
|
|
size = StubMsg.Buffer - StubMsg.BufferStart;
|
|
ok(size == 5, "Buffer %p Start %p len %d\n", StubMsg.Buffer, StubMsg.BufferStart, size);
|
|
ok(*(unsigned int *)StubMsg.BufferStart != 0, "pointer ID marshalled incorrectly\n");
|
|
ok(*(unsigned char *)(StubMsg.BufferStart + 4) == 0x22, "char data marshalled incorrectly: 0x%x\n",
|
|
*(unsigned char *)(StubMsg.BufferStart + 4));
|
|
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
StubMsg.MemorySize = 0;
|
|
mem = NULL;
|
|
|
|
/* Client */
|
|
my_alloc_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(void *));
|
|
*(void **)mem = NULL;
|
|
NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 0);
|
|
ok(mem == mem_orig, "mem alloced\n");
|
|
ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
|
|
|
|
my_alloc_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 1);
|
|
todo_wine {
|
|
ok(mem == mem_orig, "mem alloced\n");
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
}
|
|
|
|
my_free_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
|
|
ok(my_free_called == 1, "free called %d\n", my_free_called);
|
|
|
|
mem = my_alloc(sizeof(void *));
|
|
*(void **)mem = NULL;
|
|
my_free_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
|
|
ok(my_free_called == 0, "free called %d\n", my_free_called);
|
|
my_free(mem);
|
|
|
|
mem = my_alloc(sizeof(void *));
|
|
*(void **)mem = my_alloc(sizeof(char));
|
|
my_free_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
|
|
ok(my_free_called == 1, "free called %d\n", my_free_called);
|
|
my_free(mem);
|
|
|
|
/* Server */
|
|
my_alloc_called = 0;
|
|
StubMsg.IsClient = 0;
|
|
mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 0);
|
|
ok(mem != StubMsg.BufferStart, "mem pointing at buffer\n");
|
|
todo_wine
|
|
ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
|
|
NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
|
|
|
|
my_alloc_called = 0;
|
|
mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 1);
|
|
ok(mem != StubMsg.BufferStart, "mem pointing at buffer\n");
|
|
todo_wine
|
|
ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
|
|
NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
|
|
|
|
my_alloc_called = 0;
|
|
mem = mem_orig;
|
|
*(void **)mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 0);
|
|
todo_wine {
|
|
ok(mem == mem_orig, "mem alloced\n");
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
}
|
|
|
|
my_alloc_called = 0;
|
|
mem = mem_orig;
|
|
*(void **)mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 1);
|
|
todo_wine {
|
|
ok(mem == mem_orig, "mem alloced\n");
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
}
|
|
|
|
mem = my_alloc(sizeof(void *));
|
|
*(void **)mem = NULL;
|
|
my_free_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
|
|
ok(my_free_called == 0, "free called %d\n", my_free_called);
|
|
my_free(mem);
|
|
|
|
mem = my_alloc(sizeof(void *));
|
|
*(void **)mem = my_alloc(sizeof(char));
|
|
my_free_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
|
|
ok(my_free_called == 1, "free called %d\n", my_free_called);
|
|
my_free(mem);
|
|
|
|
HeapFree(GetProcessHeap(), 0, mem_orig);
|
|
HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
|
|
}
|
|
|
|
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)
|
|
{
|
|
RPC_MESSAGE RpcMessage;
|
|
MIDL_STUB_MESSAGE StubMsg;
|
|
MIDL_STUB_DESC StubDesc;
|
|
DWORD size;
|
|
void *ptr;
|
|
unsigned char *mem, *mem_orig;
|
|
|
|
my_alloc_called = my_free_called = 0;
|
|
if(!cmp)
|
|
cmp = memcmp;
|
|
|
|
StubDesc = Object_StubDesc;
|
|
StubDesc.pFormatTypes = formattypes;
|
|
|
|
NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 0);
|
|
|
|
StubMsg.BufferLength = 0;
|
|
NdrSimpleStructBufferSize( &StubMsg, memsrc, formattypes );
|
|
ok(StubMsg.BufferLength >= wiredatalen, "%s: length %d\n", msgpfx, StubMsg.BufferLength);
|
|
StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
|
|
StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
|
|
ptr = NdrSimpleStructMarshall( &StubMsg, memsrc, formattypes );
|
|
ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
|
|
ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart);
|
|
ok(!memcmp(StubMsg.BufferStart, wiredata, wiredatalen), "%s: incorrectly marshaled %08x %08x %08x\n", msgpfx, *(DWORD*)StubMsg.BufferStart,*((DWORD*)StubMsg.BufferStart+1),*((DWORD*)StubMsg.BufferStart+2));
|
|
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
StubMsg.MemorySize = 0;
|
|
size = NdrSimpleStructMemorySize( &StubMsg, formattypes );
|
|
ok(size == StubMsg.MemorySize, "%s: size != MemorySize\n", msgpfx);
|
|
ok(size == srcsize, "%s: mem size %u\n", msgpfx, size);
|
|
ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart);
|
|
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
size = NdrSimpleStructMemorySize( &StubMsg, formattypes );
|
|
ok(size == StubMsg.MemorySize, "%s: size != MemorySize\n", msgpfx);
|
|
ok(StubMsg.MemorySize == ((srcsize + 3) & ~3) + srcsize, "%s: mem size %u\n", msgpfx, size);
|
|
ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart);
|
|
size = srcsize;
|
|
/*** Unmarshalling first with must_alloc false ***/
|
|
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
StubMsg.MemorySize = 0;
|
|
mem_orig = mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, srcsize);
|
|
ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 0 );
|
|
ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
|
|
ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart);
|
|
ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
|
|
ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
|
|
ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
|
|
my_alloc_called = 0;
|
|
ok(StubMsg.MemorySize == 0, "%s: memorysize touched in unmarshal\n", msgpfx);
|
|
|
|
/* If we're a server we still use the supplied memory */
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
StubMsg.IsClient = 0;
|
|
ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 0 );
|
|
ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
|
|
ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
|
|
ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
|
|
ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
|
|
my_alloc_called = 0;
|
|
ok(StubMsg.MemorySize == 0, "%s: memorysize touched in unmarshal\n", msgpfx);
|
|
|
|
/* ...unless we pass a NULL ptr, then the buffer is used.
|
|
Passing a NULL ptr while we're a client && !must_alloc
|
|
crashes on Windows, so we won't do that. */
|
|
|
|
if (0) /* crashes on Win9x and NT4 */
|
|
{
|
|
mem = NULL;
|
|
StubMsg.IsClient = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, FALSE );
|
|
ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
|
|
ok(mem == StubMsg.BufferStart, "%s: mem not equal buffer\n", msgpfx);
|
|
ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
|
|
ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
|
|
my_alloc_called = 0;
|
|
ok(StubMsg.MemorySize == 0, "%s: memorysize touched in unmarshal\n", msgpfx);
|
|
}
|
|
|
|
/*** now must_alloc is true ***/
|
|
|
|
/* with must_alloc set we always allocate new memory whether or not we're
|
|
a server and also when passing NULL */
|
|
mem = mem_orig;
|
|
StubMsg.IsClient = 1;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
|
|
ok(ptr == NULL, "ret %p\n", ptr);
|
|
ok(mem != mem_orig, "mem not changed %p %p\n", mem, mem_orig);
|
|
ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n");
|
|
ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
|
|
my_alloc_called = 0;
|
|
ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
|
|
|
|
mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
|
|
ok(ptr == NULL, "ret %p\n", ptr);
|
|
ok(mem != mem_orig, "mem not changed %p %p\n", mem, mem_orig);
|
|
ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n");
|
|
ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
|
|
my_alloc_called = 0;
|
|
ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
|
|
|
|
mem = mem_orig;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
StubMsg.IsClient = 0;
|
|
StubMsg.ReuseBuffer = 1;
|
|
ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
|
|
ok(ptr == NULL, "ret %p\n", ptr);
|
|
ok(mem != mem_orig, "mem not changed %p %p\n", mem, mem_orig);
|
|
ok(mem != StubMsg.BufferStart, "mem is buffer mem\n");
|
|
ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n");
|
|
ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
|
|
my_alloc_called = 0;
|
|
ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
|
|
|
|
mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
StubMsg.IsClient = 0;
|
|
StubMsg.ReuseBuffer = 1;
|
|
ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
|
|
ok(ptr == NULL, "ret %p\n", ptr);
|
|
ok(mem != StubMsg.BufferStart, "mem is buffer mem\n");
|
|
ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n");
|
|
ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
|
|
my_alloc_called = 0;
|
|
ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
|
|
|
|
HeapFree(GetProcessHeap(), 0, mem_orig);
|
|
HeapFree(GetProcessHeap(), 0, StubMsg.BufferStart);
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
LONG l1;
|
|
LONG *pl1;
|
|
char *pc1;
|
|
} ps1_t;
|
|
|
|
static int ps1_cmp(const void *s1, const void *s2, size_t num)
|
|
{
|
|
const ps1_t *p1, *p2;
|
|
|
|
p1 = s1;
|
|
p2 = s2;
|
|
|
|
if(p1->l1 != p2->l1)
|
|
return 1;
|
|
|
|
if(p1->pl1 && p2->pl1)
|
|
{
|
|
if(*p1->pl1 != *p2->pl1)
|
|
return 1;
|
|
}
|
|
else if(p1->pl1 || p2->pl1)
|
|
return 1;
|
|
|
|
if(p1->pc1 && p2->pc1)
|
|
{
|
|
if(*p1->pc1 != *p2->pc1)
|
|
return 1;
|
|
}
|
|
else if(p1->pc1 || p2->pc1)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void test_simple_struct(void)
|
|
{
|
|
unsigned char wiredata[28];
|
|
ULONG wiredatalen;
|
|
LONG l;
|
|
char c;
|
|
ps1_t ps1;
|
|
|
|
static const unsigned char fmtstr_simple_struct[] =
|
|
{
|
|
0x12, 0x0, /* FC_UP */
|
|
NdrFcShort( 0x2 ), /* Offset=2 */
|
|
0x15, 0x3, /* FC_STRUCT [align 4] */
|
|
NdrFcShort( 0x18 ), /* [size 24] */
|
|
0x6, /* FC_SHORT */
|
|
0x2, /* FC_CHAR */
|
|
0x38, /* FC_ALIGNM4 */
|
|
0x8, /* FC_LONG */
|
|
0x8, /* FC_LONG */
|
|
0x39, /* FC_ALIGNM8 */
|
|
0xb, /* FC_HYPER */
|
|
0x5b, /* FC_END */
|
|
};
|
|
struct {
|
|
short s;
|
|
char c;
|
|
LONG l1, l2;
|
|
LONGLONG ll;
|
|
} s1;
|
|
|
|
static const unsigned char fmtstr_pointer_struct[] =
|
|
{
|
|
0x12, 0x0, /* FC_UP */
|
|
NdrFcShort( 0x2 ), /* Offset=2 */
|
|
#ifdef _WIN64
|
|
0x1a, /* FC_BOGUS_STRUCT */
|
|
0x3, /* 3 */
|
|
NdrFcShort(0x18), /* [size 24] */
|
|
NdrFcShort(0x0),
|
|
NdrFcShort(0x8), /* Offset= 8 (266) */
|
|
0x08, /* FC_LONG */
|
|
0x39, /* FC_ALIGNM8 */
|
|
0x36, /* FC_POINTER */
|
|
0x36, /* FC_POINTER */
|
|
0x5c, /* FC_PAD */
|
|
0x5b, /* FC_END */
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x08, /* FC_LONG */
|
|
0x5c, /* FC_PAD */
|
|
0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
0x02, /* FC_CHAR */
|
|
0x5c, /* FC_PAD */
|
|
#else
|
|
0x16, 0x3, /* FC_PSTRUCT [align 4] */
|
|
NdrFcShort( 0xc ), /* [size 12] */
|
|
0x4b, /* FC_PP */
|
|
0x5c, /* FC_PAD */
|
|
0x46, /* FC_NO_REPEAT */
|
|
0x5c, /* FC_PAD */
|
|
NdrFcShort( 0x4 ), /* 4 */
|
|
NdrFcShort( 0x4 ), /* 4 */
|
|
0x13, 0x8, /* FC_OP [simple_pointer] */
|
|
0x8, /* FC_LONG */
|
|
0x5c, /* FC_PAD */
|
|
0x46, /* FC_NO_REPEAT */
|
|
0x5c, /* FC_PAD */
|
|
NdrFcShort( 0x8 ), /* 8 */
|
|
NdrFcShort( 0x8 ), /* 8 */
|
|
0x13, 0x8, /* FC_OP [simple_pointer] */
|
|
0x2, /* FC_CHAR */
|
|
0x5c, /* FC_PAD */
|
|
0x5b, /* FC_END */
|
|
0x8, /* FC_LONG */
|
|
0x8, /* FC_LONG */
|
|
0x8, /* FC_LONG */
|
|
0x5c, /* FC_PAD */
|
|
0x5b, /* FC_END */
|
|
#endif
|
|
};
|
|
|
|
/* zero the entire structure, including the holes */
|
|
memset(&s1, 0, sizeof(s1));
|
|
|
|
/* FC_STRUCT */
|
|
s1.s = 0x1234;
|
|
s1.c = 0xa5;
|
|
s1.l1 = 0xdeadbeef;
|
|
s1.l2 = 0xcafebabe;
|
|
s1.ll = ((ULONGLONG) 0xbadefeed << 32) | 0x2468ace0;
|
|
|
|
wiredatalen = 24;
|
|
memcpy(wiredata, &s1, wiredatalen);
|
|
test_simple_struct_marshal(fmtstr_simple_struct + 4, &s1, 24, wiredata, 24, NULL, 0, "struct");
|
|
|
|
if (use_pointer_ids)
|
|
*(unsigned int *)wiredata = 0x20000;
|
|
else
|
|
*(unsigned int *)wiredata = (UINT_PTR)&s1;
|
|
memcpy(wiredata + 4, &s1, wiredatalen);
|
|
test_pointer_marshal(fmtstr_simple_struct, &s1, 24, wiredata, 28, NULL, 0, "struct");
|
|
|
|
if (sizeof(void *) == 8) return; /* it cannot be represented as a simple struct on Win64 */
|
|
|
|
/* zero the entire structure, including the hole */
|
|
memset(&ps1, 0, sizeof(ps1));
|
|
|
|
/* FC_PSTRUCT */
|
|
ps1.l1 = 0xdeadbeef;
|
|
l = 0xcafebabe;
|
|
ps1.pl1 = &l;
|
|
c = 'a';
|
|
ps1.pc1 = &c;
|
|
*(unsigned int *)(wiredata + 4) = 0xdeadbeef;
|
|
if (use_pointer_ids)
|
|
{
|
|
*(unsigned int *)(wiredata + 8) = 0x20000;
|
|
*(unsigned int *)(wiredata + 12) = 0x20004;
|
|
}
|
|
else
|
|
{
|
|
*(unsigned int *)(wiredata + 8) = (UINT_PTR)&l;
|
|
*(unsigned int *)(wiredata + 12) = (UINT_PTR)&c;
|
|
}
|
|
memcpy(wiredata + 16, &l, 4);
|
|
memcpy(wiredata + 20, &c, 1);
|
|
|
|
test_simple_struct_marshal(fmtstr_pointer_struct + 4, &ps1, 17, wiredata + 4, 17, ps1_cmp, 2, "pointer_struct");
|
|
if (use_pointer_ids)
|
|
{
|
|
*(unsigned int *)wiredata = 0x20000;
|
|
*(unsigned int *)(wiredata + 8) = 0x20004;
|
|
*(unsigned int *)(wiredata + 12) = 0x20008;
|
|
}
|
|
else
|
|
*(unsigned int *)wiredata = (UINT_PTR)&ps1;
|
|
test_pointer_marshal(fmtstr_pointer_struct, &ps1, 17, wiredata, 21, ps1_cmp, 2, "pointer_struct");
|
|
}
|
|
|
|
static void test_fullpointer_xlat(void)
|
|
{
|
|
PFULL_PTR_XLAT_TABLES pXlatTables;
|
|
ULONG RefId;
|
|
int ret;
|
|
void *Pointer;
|
|
|
|
pXlatTables = NdrFullPointerXlatInit(2, XLAT_CLIENT);
|
|
|
|
/* "marshaling" phase */
|
|
|
|
ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
|
|
ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
|
|
ok(RefId == 0x1, "RefId should be 0x1 instead of 0x%x\n", RefId);
|
|
|
|
ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 0, &RefId);
|
|
ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
|
|
ok(RefId == 0x1, "RefId should be 0x1 instead of 0x%x\n", RefId);
|
|
|
|
ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebabe, 0, &RefId);
|
|
ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
|
|
ok(RefId == 0x2, "RefId should be 0x2 instead of 0x%x\n", RefId);
|
|
|
|
ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 0, &RefId);
|
|
ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
|
|
ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
|
|
|
|
ret = NdrFullPointerQueryPointer(pXlatTables, NULL, 0, &RefId);
|
|
ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
|
|
ok(RefId == 0, "RefId should be 0 instead of 0x%x\n", RefId);
|
|
|
|
/* "unmarshaling" phase */
|
|
|
|
ret = NdrFullPointerQueryRefId(pXlatTables, 0x0, 0, &Pointer);
|
|
ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
|
|
|
|
ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 0, &Pointer);
|
|
ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
|
|
ok(Pointer == (void *)0xcafebabe, "Pointer should be 0xcafebabe instead of %p\n", Pointer);
|
|
|
|
ret = NdrFullPointerQueryRefId(pXlatTables, 0x4, 0, &Pointer);
|
|
ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
|
|
ok(Pointer == NULL, "Pointer should be NULL instead of %p\n", Pointer);
|
|
|
|
NdrFullPointerInsertRefId(pXlatTables, 0x4, (void *)0xdeadbabe);
|
|
|
|
ret = NdrFullPointerQueryRefId(pXlatTables, 0x4, 1, &Pointer);
|
|
ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
|
|
ok(Pointer == (void *)0xdeadbabe, "Pointer should be (void *)0xdeadbabe instead of %p\n", Pointer);
|
|
|
|
NdrFullPointerXlatFree(pXlatTables);
|
|
|
|
pXlatTables = NdrFullPointerXlatInit(2, XLAT_SERVER);
|
|
|
|
/* "unmarshaling" phase */
|
|
|
|
ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 1, &Pointer);
|
|
ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
|
|
ok(Pointer == NULL, "Pointer should be NULL instead of %p\n", Pointer);
|
|
|
|
NdrFullPointerInsertRefId(pXlatTables, 0x2, (void *)0xcafebabe);
|
|
|
|
ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 0, &Pointer);
|
|
ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
|
|
ok(Pointer == (void *)0xcafebabe, "Pointer should be (void *)0xcafebabe instead of %p\n", Pointer);
|
|
|
|
ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 1, &Pointer);
|
|
ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
|
|
ok(Pointer == (void *)0xcafebabe, "Pointer should be (void *)0xcafebabe instead of %p\n", Pointer);
|
|
|
|
/* "marshaling" phase */
|
|
|
|
ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
|
|
ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
|
|
ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
|
|
|
|
ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
|
|
ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
|
|
ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
|
|
|
|
ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 0, &RefId);
|
|
ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
|
|
ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
|
|
|
|
ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebabe, 0, &RefId);
|
|
ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
|
|
ok(RefId == 0x2, "RefId should be 0x2 instead of 0x%x\n", RefId);
|
|
|
|
ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 0, &RefId);
|
|
ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
|
|
ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
|
|
|
|
/* "freeing" phase */
|
|
|
|
ret = NdrFullPointerFree(pXlatTables, (void *)0xcafebeef);
|
|
ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
|
|
|
|
ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 0x20, &RefId);
|
|
ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
|
|
ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
|
|
|
|
ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
|
|
ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
|
|
ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
|
|
|
|
ret = NdrFullPointerFree(pXlatTables, (void *)0xcafebabe);
|
|
ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
|
|
|
|
ret = NdrFullPointerFree(pXlatTables, (void *)0xdeadbeef);
|
|
ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
|
|
|
|
ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 0x20, &RefId);
|
|
ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
|
|
ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
|
|
|
|
ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 1, &RefId);
|
|
ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
|
|
ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
|
|
|
|
ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 1, &RefId);
|
|
ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
|
|
ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
|
|
|
|
ret = NdrFullPointerFree(pXlatTables, (void *)0xdeadbeef);
|
|
ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
|
|
|
|
NdrFullPointerXlatFree(pXlatTables);
|
|
}
|
|
|
|
/* verify stub data that is identical between client and server */
|
|
static void test_common_stub_data( const char *prefix, const MIDL_STUB_MESSAGE *stubMsg )
|
|
{
|
|
void *unset_ptr;
|
|
|
|
memset(&unset_ptr, 0xcc, sizeof(unset_ptr));
|
|
|
|
#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)
|
|
|
|
TEST_POINTER_UNSET(BufferMark);
|
|
TEST_ULONG_UNSET(MemorySize);
|
|
TEST_POINTER_UNSET(Memory);
|
|
TEST_ZERO(pAllocAllNodesContext, "%p");
|
|
ok(stubMsg->pPointerQueueState == 0 ||
|
|
broken(stubMsg->pPointerQueueState == unset_ptr), /* win2k */
|
|
"%s: pPointerQueueState should have been unset instead of %p\n",
|
|
prefix, stubMsg->pPointerQueueState);
|
|
TEST_ZERO(IgnoreEmbeddedPointers, "%d");
|
|
TEST_ZERO(PointerBufferMark, "%p");
|
|
ok( stubMsg->uFlags == 0 ||
|
|
broken(stubMsg->uFlags == 0xcc), /* win9x */
|
|
"%s: uFlags should have been set to zero instead of 0x%x\n", prefix, stubMsg->uFlags );
|
|
/* FIXME: UniquePtrCount */
|
|
TEST_ULONG_PTR_UNSET(MaxCount);
|
|
TEST_ULONG_UNSET(Offset);
|
|
TEST_ULONG_UNSET(ActualCount);
|
|
ok(stubMsg->pfnAllocate == my_alloc, "%s: pfnAllocate should have been %p instead of %p\n",
|
|
prefix, my_alloc, stubMsg->pfnAllocate);
|
|
ok(stubMsg->pfnFree == my_free, "%s: pfnFree should have been %p instead of %p\n",
|
|
prefix, my_free, stubMsg->pfnFree);
|
|
TEST_ZERO(StackTop, "%p");
|
|
TEST_POINTER_UNSET(pPresentedType);
|
|
TEST_POINTER_UNSET(pTransmitType);
|
|
TEST_POINTER_UNSET(SavedHandle);
|
|
ok(stubMsg->StubDesc == &Object_StubDesc, "%s: StubDesc should have been %p instead of %p\n",
|
|
prefix, &Object_StubDesc, stubMsg->StubDesc);
|
|
TEST_ZERO(FullPtrRefId, "%d");
|
|
ok( stubMsg->PointerLength == 0 ||
|
|
broken(stubMsg->PointerLength == 1), /* win9x, nt4 */
|
|
"%s: pAsyncMsg should have been set to zero instead of %d\n", prefix, stubMsg->PointerLength );
|
|
TEST_ZERO(fInDontFree, "%d");
|
|
TEST_ZERO(fDontCallFreeInst, "%d");
|
|
ok( stubMsg->fHasReturn == 0 || broken(stubMsg->fHasReturn), /* win9x, nt4 */
|
|
"%s: fHasReturn should have been set to zero instead of %d\n", prefix, stubMsg->fHasReturn );
|
|
TEST_ZERO(fHasExtensions, "%d");
|
|
TEST_ZERO(fHasNewCorrDesc, "%d");
|
|
ok(stubMsg->fIsIn == 0 || broken(stubMsg->fIsIn), /* win9x, nt4 */
|
|
"%s: fIsIn should have been set to 0 instead of %d\n", prefix, stubMsg->fIsIn);
|
|
TEST_ZERO(fIsOicf, "%d");
|
|
ok(stubMsg->fBufferValid == 0,
|
|
"%s: fBufferValid should have been set to 0 instead of %d\n", prefix, stubMsg->fBufferValid);
|
|
TEST_ZERO(fNeedMCCP, "%d");
|
|
ok(stubMsg->fUnused == 0 ||
|
|
stubMsg->fUnused == -2, /* Vista */
|
|
"%s: fUnused should have been set to 0 or -2 instead of %d\n", prefix, stubMsg->fUnused);
|
|
ok(stubMsg->fUnused2 == 0xffffcccc, "%s: fUnused2 should have been 0xffffcccc instead of 0x%x\n",
|
|
prefix, stubMsg->fUnused2);
|
|
ok(stubMsg->dwDestContext == MSHCTX_DIFFERENTMACHINE,
|
|
"%s: dwDestContext should have been MSHCTX_DIFFERENTMACHINE instead of %d\n",
|
|
prefix, stubMsg->dwDestContext);
|
|
TEST_ZERO(pvDestContext, "%p");
|
|
TEST_POINTER_UNSET(SavedContextHandles);
|
|
TEST_ULONG_UNSET(ParamNumber);
|
|
TEST_ZERO(pRpcChannelBuffer, "%p");
|
|
TEST_ZERO(pArrayInfo, "%p");
|
|
TEST_POINTER_UNSET(SizePtrCountArray);
|
|
TEST_POINTER_UNSET(SizePtrOffsetArray);
|
|
TEST_POINTER_UNSET(SizePtrLengthArray);
|
|
TEST_POINTER_UNSET(pArgQueue);
|
|
TEST_ZERO(dwStubPhase, "%d");
|
|
/* FIXME: where does this value come from? */
|
|
trace("%s: LowStackMark is %p\n", prefix, stubMsg->LowStackMark);
|
|
ok( stubMsg->pAsyncMsg == 0 || broken(stubMsg->pAsyncMsg == unset_ptr), /* win9x, nt4 */
|
|
"%s: pAsyncMsg should have been set to zero instead of %p\n", prefix, stubMsg->pAsyncMsg );
|
|
ok( stubMsg->pCorrInfo == 0 || broken(stubMsg->pCorrInfo == unset_ptr), /* win9x, nt4 */
|
|
"%s: pCorrInfo should have been set to zero instead of %p\n", prefix, stubMsg->pCorrInfo );
|
|
ok( stubMsg->pCorrMemory == 0 || broken(stubMsg->pCorrMemory == unset_ptr), /* win9x, nt4 */
|
|
"%s: pCorrMemory should have been set to zero instead of %p\n", prefix, stubMsg->pCorrMemory );
|
|
ok( stubMsg->pMemoryList == 0 || broken(stubMsg->pMemoryList == unset_ptr), /* win9x, nt4 */
|
|
"%s: pMemoryList should have been set to zero instead of %p\n", prefix, stubMsg->pMemoryList );
|
|
TEST_POINTER_UNSET(pCSInfo);
|
|
TEST_POINTER_UNSET(ConformanceMark);
|
|
TEST_POINTER_UNSET(VarianceMark);
|
|
ok(stubMsg->Unused == (ULONG_PTR)unset_ptr, "%s: Unused should have be unset instead of 0x%lx\n",
|
|
prefix, stubMsg->Unused);
|
|
TEST_POINTER_UNSET(pContext);
|
|
TEST_POINTER_UNSET(ContextHandleHash);
|
|
TEST_POINTER_UNSET(pUserMarshalList);
|
|
TEST_ULONG_PTR_UNSET(Reserved51_3);
|
|
TEST_ULONG_PTR_UNSET(Reserved51_4);
|
|
TEST_ULONG_PTR_UNSET(Reserved51_5);
|
|
|
|
#undef TEST_ULONG_PTR_UNSET
|
|
#undef TEST_ULONG_UNSET
|
|
#undef TEST_POINTER_UNSET
|
|
#undef TEST_ZERO
|
|
}
|
|
|
|
static void test_client_init(void)
|
|
{
|
|
MIDL_STUB_MESSAGE stubMsg;
|
|
RPC_MESSAGE rpcMsg;
|
|
void *unset_ptr;
|
|
|
|
memset(&rpcMsg, 0xcc, sizeof(rpcMsg));
|
|
memset(&stubMsg, 0xcc, sizeof(stubMsg));
|
|
memset(&unset_ptr, 0xcc, sizeof(unset_ptr));
|
|
|
|
NdrClientInitializeNew(&rpcMsg, &stubMsg, &Object_StubDesc, 1);
|
|
|
|
test_common_stub_data( "NdrClientInitializeNew", &stubMsg );
|
|
|
|
ok(stubMsg.RpcMsg == &rpcMsg, "stubMsg.RpcMsg should have been %p instead of %p\n", &rpcMsg, stubMsg.RpcMsg);
|
|
ok(rpcMsg.Handle == NULL, "rpcMsg.Handle should have been NULL instead of %p\n", rpcMsg.Handle);
|
|
ok(rpcMsg.Buffer == unset_ptr, "rpcMsg.Buffer should have been unset instead of %p\n",
|
|
rpcMsg.Buffer);
|
|
ok(rpcMsg.BufferLength == 0xcccccccc, "rpcMsg.BufferLength should have been unset instead of %d\n", rpcMsg.BufferLength);
|
|
ok(rpcMsg.ProcNum == 0x8001, "rpcMsg.ProcNum should have been 0x8001 instead of 0x%x\n", rpcMsg.ProcNum);
|
|
ok(rpcMsg.TransferSyntax == unset_ptr, "rpcMsg.TransferSyntax should have been unset instead of %p\n", rpcMsg.TransferSyntax);
|
|
ok(rpcMsg.RpcInterfaceInformation == Object_StubDesc.RpcInterfaceInformation,
|
|
"rpcMsg.RpcInterfaceInformation should have been %p instead of %p\n",
|
|
Object_StubDesc.RpcInterfaceInformation, rpcMsg.RpcInterfaceInformation);
|
|
/* Note: ReservedForRuntime not tested */
|
|
ok(rpcMsg.ManagerEpv == unset_ptr, "rpcMsg.ManagerEpv should have been unset instead of %p\n", rpcMsg.ManagerEpv);
|
|
ok(rpcMsg.ImportContext == unset_ptr, "rpcMsg.ImportContext should have been unset instead of %p\n", rpcMsg.ImportContext);
|
|
ok(rpcMsg.RpcFlags == 0, "rpcMsg.RpcFlags should have been 0 instead of 0x%x\n", rpcMsg.RpcFlags);
|
|
|
|
ok(stubMsg.Buffer == unset_ptr, "stubMsg.Buffer should have been unset instead of %p\n",
|
|
stubMsg.Buffer);
|
|
ok(stubMsg.BufferStart == NULL, "stubMsg.BufferStart should have been NULL instead of %p\n",
|
|
stubMsg.BufferStart);
|
|
ok(stubMsg.BufferEnd == NULL, "stubMsg.BufferEnd should have been NULL instead of %p\n",
|
|
stubMsg.BufferEnd);
|
|
ok(stubMsg.BufferLength == 0, "stubMsg.BufferLength should have been 0 instead of %u\n",
|
|
stubMsg.BufferLength);
|
|
ok(stubMsg.IsClient == 1, "stubMsg.IsClient should have been 1 instead of %u\n", stubMsg.IsClient);
|
|
ok(stubMsg.ReuseBuffer == 0, "stubMsg.ReuseBuffer should have been 0 instead of %d\n",
|
|
stubMsg.ReuseBuffer);
|
|
ok(stubMsg.CorrDespIncrement == 0, "stubMsg.CorrDespIncrement should have been 0 instead of %d\n",
|
|
stubMsg.CorrDespIncrement);
|
|
ok(stubMsg.FullPtrXlatTables == unset_ptr, "stubMsg.FullPtrXlatTables should have been unset instead of %p\n",
|
|
stubMsg.FullPtrXlatTables);
|
|
}
|
|
|
|
static void test_server_init(void)
|
|
{
|
|
MIDL_STUB_MESSAGE stubMsg;
|
|
RPC_MESSAGE rpcMsg;
|
|
unsigned char *ret;
|
|
unsigned char buffer[256];
|
|
|
|
memset(&rpcMsg, 0, sizeof(rpcMsg));
|
|
rpcMsg.Buffer = buffer;
|
|
rpcMsg.BufferLength = sizeof(buffer);
|
|
rpcMsg.RpcFlags = RPC_BUFFER_COMPLETE;
|
|
|
|
memset(&stubMsg, 0xcc, sizeof(stubMsg));
|
|
|
|
ret = NdrServerInitializeNew(&rpcMsg, &stubMsg, &Object_StubDesc);
|
|
ok(ret == NULL, "NdrServerInitializeNew should have returned NULL instead of %p\n", ret);
|
|
|
|
test_common_stub_data( "NdrServerInitializeNew", &stubMsg );
|
|
|
|
ok(stubMsg.RpcMsg == &rpcMsg, "stubMsg.RpcMsg should have been %p instead of %p\n", &rpcMsg, stubMsg.RpcMsg);
|
|
ok(stubMsg.Buffer == buffer, "stubMsg.Buffer should have been %p instead of %p\n", buffer, stubMsg.Buffer);
|
|
ok(stubMsg.BufferStart == buffer, "stubMsg.BufferStart should have been %p instead of %p\n", buffer, stubMsg.BufferStart);
|
|
ok(stubMsg.BufferEnd == buffer + sizeof(buffer), "stubMsg.BufferEnd should have been %p instead of %p\n", buffer + sizeof(buffer), stubMsg.BufferEnd);
|
|
todo_wine
|
|
ok(stubMsg.BufferLength == 0, "stubMsg.BufferLength should have been 0 instead of %u\n", stubMsg.BufferLength);
|
|
ok(stubMsg.IsClient == 0, "stubMsg.IsClient should have been 0 instead of %u\n", stubMsg.IsClient);
|
|
ok(stubMsg.ReuseBuffer == 0 ||
|
|
broken(stubMsg.ReuseBuffer == 1), /* win2k */
|
|
"stubMsg.ReuseBuffer should have been set to zero instead of %d\n", stubMsg.ReuseBuffer);
|
|
ok(stubMsg.CorrDespIncrement == 0 ||
|
|
broken(stubMsg.CorrDespIncrement == 0xcc), /* <= Win 2003 */
|
|
"CorrDespIncrement should have been set to zero instead of 0x%x\n", stubMsg.CorrDespIncrement);
|
|
ok(stubMsg.FullPtrXlatTables == 0, "stubMsg.BufferLength should have been 0 instead of %p\n", stubMsg.FullPtrXlatTables);
|
|
}
|
|
|
|
static void test_ndr_allocate(void)
|
|
{
|
|
RPC_MESSAGE RpcMessage;
|
|
MIDL_STUB_MESSAGE StubMsg;
|
|
MIDL_STUB_DESC StubDesc;
|
|
void *p1, *p2;
|
|
struct tag_mem_list_v2_t
|
|
{
|
|
DWORD magic;
|
|
DWORD size;
|
|
DWORD unknown;
|
|
struct tag_mem_list_v2_t *next;
|
|
} *mem_list_v2;
|
|
const DWORD magic_MEML = 'M' << 24 | 'E' << 16 | 'M' << 8 | 'L';
|
|
|
|
StubDesc = Object_StubDesc;
|
|
NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 0);
|
|
|
|
my_alloc_called = my_free_called = 0;
|
|
p1 = NdrAllocate(&StubMsg, 10);
|
|
p2 = NdrAllocate(&StubMsg, 24);
|
|
ok(my_alloc_called == 2, "alloc called %d\n", my_alloc_called);
|
|
ok(StubMsg.pMemoryList != NULL, "StubMsg.pMemoryList NULL\n");
|
|
if(StubMsg.pMemoryList)
|
|
{
|
|
mem_list_v2 = StubMsg.pMemoryList;
|
|
if (mem_list_v2->size == 24)
|
|
{
|
|
trace("v2 mem list format\n");
|
|
ok((char *)mem_list_v2 == (char *)p2 + 24, "expected mem_list_v2 pointer %p, but got %p\n", (char *)p2 + 24, mem_list_v2);
|
|
ok(mem_list_v2->magic == magic_MEML, "magic %08x\n", mem_list_v2->magic);
|
|
ok(mem_list_v2->size == 24, "wrong size for p2 %d\n", mem_list_v2->size);
|
|
ok(mem_list_v2->unknown == 0, "wrong unknown for p2 0x%x\n", mem_list_v2->unknown);
|
|
ok(mem_list_v2->next != NULL, "next NULL\n");
|
|
mem_list_v2 = mem_list_v2->next;
|
|
if(mem_list_v2)
|
|
{
|
|
ok((char *)mem_list_v2 == (char *)p1 + 16, "expected mem_list_v2 pointer %p, but got %p\n", (char *)p1 + 16, mem_list_v2);
|
|
ok(mem_list_v2->magic == magic_MEML, "magic %08x\n", mem_list_v2->magic);
|
|
ok(mem_list_v2->size == 16, "wrong size for p1 %d\n", mem_list_v2->size);
|
|
ok(mem_list_v2->unknown == 0, "wrong unknown for p1 0x%x\n", mem_list_v2->unknown);
|
|
ok(mem_list_v2->next == NULL, "next %p\n", mem_list_v2->next);
|
|
}
|
|
}
|
|
else win_skip("v1 mem list format\n");
|
|
}
|
|
/* NdrFree isn't exported so we can't test free'ing */
|
|
}
|
|
|
|
static void test_conformant_array(void)
|
|
{
|
|
RPC_MESSAGE RpcMessage;
|
|
MIDL_STUB_MESSAGE StubMsg;
|
|
MIDL_STUB_DESC StubDesc;
|
|
void *ptr;
|
|
unsigned char *mem, *mem_orig;
|
|
unsigned char memsrc[20];
|
|
unsigned int i;
|
|
|
|
static const unsigned char fmtstr_conf_array[] =
|
|
{
|
|
0x1b, /* FC_CARRAY */
|
|
0x0, /* align */
|
|
NdrFcShort( 0x1 ), /* elem size */
|
|
0x40, /* Corr desc: const */
|
|
0x0,
|
|
NdrFcShort(0x10), /* const = 0x10 */
|
|
0x1, /* FC_BYTE */
|
|
0x5b /* FC_END */
|
|
};
|
|
|
|
for (i = 0; i < sizeof(memsrc); i++)
|
|
memsrc[i] = i * i;
|
|
|
|
StubDesc = Object_StubDesc;
|
|
StubDesc.pFormatTypes = fmtstr_conf_array;
|
|
|
|
NdrClientInitializeNew(
|
|
&RpcMessage,
|
|
&StubMsg,
|
|
&StubDesc,
|
|
0);
|
|
|
|
StubMsg.BufferLength = 0;
|
|
NdrConformantArrayBufferSize( &StubMsg,
|
|
memsrc,
|
|
fmtstr_conf_array );
|
|
ok(StubMsg.BufferLength >= 20, "length %d\n", StubMsg.BufferLength);
|
|
|
|
/*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
|
|
StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
|
|
StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
|
|
|
|
ptr = NdrConformantArrayMarshall( &StubMsg, memsrc, fmtstr_conf_array );
|
|
ok(ptr == NULL, "ret %p\n", ptr);
|
|
ok(StubMsg.Buffer - StubMsg.BufferStart == 20, "Buffer %p Start %p len %d\n", StubMsg.Buffer, StubMsg.BufferStart, 20);
|
|
ok(!memcmp(StubMsg.BufferStart + 4, memsrc, 16), "incorrectly marshaled\n");
|
|
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
StubMsg.MemorySize = 0;
|
|
mem = NULL;
|
|
|
|
/* Client */
|
|
my_alloc_called = 0;
|
|
/* passing mem == NULL with must_alloc == 0 crashes under Windows */
|
|
NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
|
|
ok(mem != NULL, "mem not alloced\n");
|
|
ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
|
|
ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
|
|
|
|
my_alloc_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
mem_orig = mem;
|
|
NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
|
|
ok(mem == mem_orig, "mem alloced\n");
|
|
ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
|
|
my_alloc_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
|
|
ok(mem != mem_orig, "mem not alloced\n");
|
|
ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
|
|
ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
|
|
|
|
my_free_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrConformantArrayFree( &StubMsg, mem, fmtstr_conf_array );
|
|
ok(my_free_called == 0, "free called %d\n", my_free_called);
|
|
StubMsg.pfnFree(mem);
|
|
|
|
/* Server */
|
|
my_alloc_called = 0;
|
|
StubMsg.IsClient = 0;
|
|
mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
|
|
ok(mem == StubMsg.BufferStart + 4 || broken(!mem), /* win9x, nt4 */
|
|
"mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 4);
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
my_alloc_called = 0;
|
|
mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
|
|
ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
|
|
ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
|
|
StubMsg.pfnFree(mem);
|
|
|
|
my_alloc_called = 0;
|
|
mem = mem_orig;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
|
|
ok(mem == mem_orig, "mem alloced\n");
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
|
|
my_alloc_called = 0;
|
|
mem = mem_orig;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
|
|
ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
|
|
ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
|
|
StubMsg.pfnFree(mem);
|
|
StubMsg.pfnFree(mem_orig);
|
|
|
|
HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
|
|
}
|
|
|
|
static void test_conformant_string(void)
|
|
{
|
|
RPC_MESSAGE RpcMessage;
|
|
MIDL_STUB_MESSAGE StubMsg;
|
|
MIDL_STUB_DESC StubDesc;
|
|
DWORD size;
|
|
void *ptr;
|
|
unsigned char *mem, *mem_orig;
|
|
char memsrc[] = "This is a test string";
|
|
|
|
static const unsigned char fmtstr_conf_str[] =
|
|
{
|
|
0x11, 0x8, /* FC_RP [simple_pointer] */
|
|
0x22, /* FC_C_CSTRING */
|
|
0x5c, /* FC_PAD */
|
|
};
|
|
|
|
StubDesc = Object_StubDesc;
|
|
StubDesc.pFormatTypes = fmtstr_conf_str;
|
|
|
|
memset( &StubMsg, 0, sizeof(StubMsg) ); /* needed on win9x and nt4 */
|
|
NdrClientInitializeNew(
|
|
&RpcMessage,
|
|
&StubMsg,
|
|
&StubDesc,
|
|
0);
|
|
|
|
StubMsg.BufferLength = 0;
|
|
NdrPointerBufferSize( &StubMsg,
|
|
(unsigned char *)memsrc,
|
|
fmtstr_conf_str );
|
|
ok(StubMsg.BufferLength >= sizeof(memsrc) + 12, "length %d\n", StubMsg.BufferLength);
|
|
|
|
/*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
|
|
StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
|
|
StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
|
|
|
|
ptr = NdrPointerMarshall( &StubMsg, (unsigned char *)memsrc, fmtstr_conf_str );
|
|
ok(ptr == NULL, "ret %p\n", ptr);
|
|
size = StubMsg.Buffer - StubMsg.BufferStart;
|
|
ok(size == sizeof(memsrc) + 12, "Buffer %p Start %p len %d\n",
|
|
StubMsg.Buffer, StubMsg.BufferStart, size);
|
|
ok(!memcmp(StubMsg.BufferStart + 12, memsrc, sizeof(memsrc)), "incorrectly marshaled\n");
|
|
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
StubMsg.MemorySize = 0;
|
|
mem = NULL;
|
|
|
|
/* Client */
|
|
my_alloc_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
|
|
/* Windows apparently checks string length on the output buffer to determine its size... */
|
|
memset( mem, 'x', sizeof(memsrc) - 1 );
|
|
mem[sizeof(memsrc) - 1] = 0;
|
|
NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
|
|
ok(mem == mem_orig, "mem not alloced\n");
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
|
|
my_alloc_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
|
|
todo_wine {
|
|
ok(mem == mem_orig, "mem not alloced\n");
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
}
|
|
|
|
/* Prevent a memory leak when running with Wine.
|
|
Remove once the todo_wine block above is fixed. */
|
|
if (mem != mem_orig)
|
|
HeapFree(GetProcessHeap(), 0, mem_orig);
|
|
|
|
my_free_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
|
|
ok(my_free_called == 1, "free called %d\n", my_free_called);
|
|
|
|
mem = my_alloc(10);
|
|
my_free_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
|
|
ok(my_free_called == 1, "free called %d\n", my_free_called);
|
|
|
|
/* Server */
|
|
my_alloc_called = 0;
|
|
StubMsg.IsClient = 0;
|
|
mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
|
|
ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
|
|
"mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
|
|
my_alloc_called = 0;
|
|
mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
|
|
todo_wine {
|
|
ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
|
|
"mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
}
|
|
|
|
my_alloc_called = 0;
|
|
mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
|
|
ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
|
|
"mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
|
|
my_alloc_called = 0;
|
|
mem = mem_orig;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
|
|
todo_wine {
|
|
ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
|
|
"mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
}
|
|
|
|
mem = my_alloc(10);
|
|
my_free_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
|
|
ok(my_free_called == 1, "free called %d\n", my_free_called);
|
|
|
|
HeapFree(GetProcessHeap(), 0, mem_orig);
|
|
HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
|
|
}
|
|
|
|
static void test_nonconformant_string(void)
|
|
{
|
|
RPC_MESSAGE RpcMessage;
|
|
MIDL_STUB_MESSAGE StubMsg;
|
|
MIDL_STUB_DESC StubDesc;
|
|
DWORD size;
|
|
void *ptr;
|
|
unsigned char *mem, *mem_orig;
|
|
unsigned char memsrc[10] = "This is";
|
|
unsigned char memsrc2[10] = "This is a";
|
|
|
|
static const unsigned char fmtstr_nonconf_str[] =
|
|
{
|
|
0x26, /* FC_CSTRING */
|
|
0x5c, /* FC_PAD */
|
|
NdrFcShort( 0xa ), /* 10 */
|
|
};
|
|
|
|
StubDesc = Object_StubDesc;
|
|
StubDesc.pFormatTypes = fmtstr_nonconf_str;
|
|
|
|
/* length < size */
|
|
NdrClientInitializeNew(
|
|
&RpcMessage,
|
|
&StubMsg,
|
|
&StubDesc,
|
|
0);
|
|
|
|
StubMsg.BufferLength = 0;
|
|
|
|
NdrNonConformantStringBufferSize( &StubMsg, memsrc, fmtstr_nonconf_str );
|
|
ok(StubMsg.BufferLength >= strlen((char *)memsrc) + 1 + 8, "length %d\n", StubMsg.BufferLength);
|
|
|
|
/*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
|
|
StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
|
|
StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
|
|
|
|
ptr = NdrNonConformantStringMarshall( &StubMsg, memsrc, fmtstr_nonconf_str );
|
|
ok(ptr == NULL, "ret %p\n", ptr);
|
|
size = StubMsg.Buffer - StubMsg.BufferStart;
|
|
ok(size == strlen((char *)memsrc) + 1 + 8, "Buffer %p Start %p len %d\n",
|
|
StubMsg.Buffer, StubMsg.BufferStart, size);
|
|
ok(!memcmp(StubMsg.BufferStart + 8, memsrc, strlen((char *)memsrc) + 1), "incorrectly marshaled\n");
|
|
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
StubMsg.MemorySize = 0;
|
|
mem = NULL;
|
|
|
|
/* Client */
|
|
my_alloc_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
|
|
NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
|
|
ok(mem == mem_orig, "mem alloced\n");
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
|
|
my_alloc_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
|
|
todo_wine
|
|
ok(mem == mem_orig, "mem alloced\n");
|
|
todo_wine
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
|
|
/* Server */
|
|
my_alloc_called = 0;
|
|
StubMsg.IsClient = 0;
|
|
mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
|
|
ok(mem != mem_orig, "mem not alloced\n");
|
|
ok(mem != StubMsg.BufferStart + 8, "mem pointing at buffer\n");
|
|
ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
|
|
NdrOleFree(mem);
|
|
|
|
my_alloc_called = 0;
|
|
mem = mem_orig;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
|
|
ok(mem == mem_orig, "mem alloced\n");
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
|
|
my_alloc_called = 0;
|
|
mem = mem_orig;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
|
|
todo_wine
|
|
ok(mem == mem_orig, "mem alloced\n");
|
|
todo_wine
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
|
|
HeapFree(GetProcessHeap(), 0, mem_orig);
|
|
HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
|
|
|
|
/* length = size */
|
|
NdrClientInitializeNew(
|
|
&RpcMessage,
|
|
&StubMsg,
|
|
&StubDesc,
|
|
0);
|
|
|
|
StubMsg.BufferLength = 0;
|
|
|
|
NdrNonConformantStringBufferSize( &StubMsg, memsrc2, fmtstr_nonconf_str );
|
|
ok(StubMsg.BufferLength >= strlen((char *)memsrc2) + 1 + 8, "length %d\n", StubMsg.BufferLength);
|
|
|
|
/*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
|
|
StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
|
|
StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
|
|
|
|
ptr = NdrNonConformantStringMarshall( &StubMsg, memsrc2, fmtstr_nonconf_str );
|
|
ok(ptr == NULL, "ret %p\n", ptr);
|
|
size = StubMsg.Buffer - StubMsg.BufferStart;
|
|
ok(size == strlen((char *)memsrc2) + 1 + 8, "Buffer %p Start %p len %d\n",
|
|
StubMsg.Buffer, StubMsg.BufferStart, size);
|
|
ok(!memcmp(StubMsg.BufferStart + 8, memsrc2, strlen((char *)memsrc2) + 1), "incorrectly marshaled\n");
|
|
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
StubMsg.MemorySize = 0;
|
|
mem = NULL;
|
|
|
|
/* Client */
|
|
my_alloc_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
|
|
NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
|
|
ok(mem == mem_orig, "mem alloced\n");
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
|
|
my_alloc_called = 0;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
|
|
todo_wine
|
|
ok(mem == mem_orig, "mem alloced\n");
|
|
todo_wine
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
|
|
/* Server */
|
|
my_alloc_called = 0;
|
|
StubMsg.IsClient = 0;
|
|
mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
|
|
ok(mem != mem_orig, "mem not alloced\n");
|
|
ok(mem != StubMsg.BufferStart + 8, "mem pointing at buffer\n");
|
|
ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
|
|
NdrOleFree(mem);
|
|
|
|
my_alloc_called = 0;
|
|
mem = mem_orig;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
|
|
ok(mem == mem_orig, "mem alloced\n");
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
|
|
my_alloc_called = 0;
|
|
mem = mem_orig;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
|
|
todo_wine
|
|
ok(mem == mem_orig, "mem alloced\n");
|
|
todo_wine
|
|
ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
|
|
|
|
HeapFree(GetProcessHeap(), 0, mem_orig);
|
|
HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
|
|
}
|
|
|
|
static void test_conf_complex_struct(void)
|
|
{
|
|
RPC_MESSAGE RpcMessage;
|
|
MIDL_STUB_MESSAGE StubMsg;
|
|
MIDL_STUB_DESC StubDesc;
|
|
void *ptr;
|
|
unsigned int i;
|
|
struct conf_complex
|
|
{
|
|
unsigned int size;
|
|
unsigned int *array[1];
|
|
};
|
|
struct conf_complex *memsrc;
|
|
struct conf_complex *mem;
|
|
|
|
static const unsigned char fmtstr_complex_struct[] =
|
|
{
|
|
/* 0 */
|
|
0x1b, /* FC_CARRAY */
|
|
0x3, /* 3 */
|
|
/* 2 */ NdrFcShort( 0x4 ), /* 4 */
|
|
/* 4 */ 0x8, /* Corr desc: FC_LONG */
|
|
0x0, /* */
|
|
/* 6 */ NdrFcShort( 0xfffc ), /* -4 */
|
|
/* 8 */
|
|
0x4b, /* FC_PP */
|
|
0x5c, /* FC_PAD */
|
|
/* 10 */
|
|
0x48, /* FC_VARIABLE_REPEAT */
|
|
0x49, /* FC_FIXED_OFFSET */
|
|
/* 12 */ NdrFcShort( 0x4 ), /* 4 */
|
|
/* 14 */ NdrFcShort( 0x0 ), /* 0 */
|
|
/* 16 */ NdrFcShort( 0x1 ), /* 1 */
|
|
/* 18 */ NdrFcShort( 0x0 ), /* 0 */
|
|
/* 20 */ NdrFcShort( 0x0 ), /* 0 */
|
|
/* 22 */ 0x12, 0x8, /* FC_UP [simple_pointer] */
|
|
/* 24 */ 0x8, /* FC_LONG */
|
|
0x5c, /* FC_PAD */
|
|
/* 26 */
|
|
0x5b, /* FC_END */
|
|
|
|
0x8, /* FC_LONG */
|
|
/* 28 */ 0x5c, /* FC_PAD */
|
|
0x5b, /* FC_END */
|
|
/* 30 */
|
|
0x1a, /* FC_BOGUS_STRUCT */
|
|
0x3, /* 3 */
|
|
/* 32 */ NdrFcShort( 0x4 ), /* 4 */
|
|
/* 34 */ NdrFcShort( 0xffffffde ), /* Offset= -34 (0) */
|
|
/* 36 */ NdrFcShort( 0x0 ), /* Offset= 0 (36) */
|
|
/* 38 */ 0x8, /* FC_LONG */
|
|
0x5b, /* FC_END */
|
|
};
|
|
|
|
memsrc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
FIELD_OFFSET(struct conf_complex, array[20]));
|
|
memsrc->size = 20;
|
|
|
|
StubDesc = Object_StubDesc;
|
|
StubDesc.pFormatTypes = fmtstr_complex_struct;
|
|
|
|
NdrClientInitializeNew(
|
|
&RpcMessage,
|
|
&StubMsg,
|
|
&StubDesc,
|
|
0);
|
|
|
|
StubMsg.BufferLength = 0;
|
|
NdrComplexStructBufferSize( &StubMsg,
|
|
(unsigned char *)memsrc,
|
|
&fmtstr_complex_struct[30] );
|
|
ok(StubMsg.BufferLength >= 28, "length %d\n", StubMsg.BufferLength);
|
|
|
|
/*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
|
|
StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
|
|
StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
|
|
|
|
ptr = NdrComplexStructMarshall( &StubMsg, (unsigned char *)memsrc,
|
|
&fmtstr_complex_struct[30] );
|
|
ok(ptr == NULL, "ret %p\n", ptr);
|
|
ok(*(unsigned int *)StubMsg.BufferStart == 20, "Conformance should have been 20 instead of %d\n", *(unsigned int *)StubMsg.BufferStart);
|
|
ok(*(unsigned int *)(StubMsg.BufferStart + 4) == 20, "conf_complex.size should have been 20 instead of %d\n", *(unsigned int *)(StubMsg.BufferStart + 4));
|
|
for (i = 0; i < 20; i++)
|
|
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));
|
|
|
|
/* Server */
|
|
my_alloc_called = 0;
|
|
StubMsg.IsClient = 0;
|
|
mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
ptr = NdrComplexStructUnmarshall( &StubMsg, (unsigned char **)&mem, &fmtstr_complex_struct[30], 0);
|
|
ok(ptr == NULL, "ret %p\n", ptr);
|
|
ok(mem->size == 20, "mem->size wasn't unmarshalled correctly (%d)\n", mem->size);
|
|
ok(mem->array[0] == NULL, "mem->array[0] wasn't unmarshalled correctly (%p)\n", mem->array[0]);
|
|
StubMsg.pfnFree(mem);
|
|
|
|
HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
|
|
HeapFree(GetProcessHeap(), 0, memsrc);
|
|
}
|
|
|
|
|
|
static void test_conf_complex_array(void)
|
|
{
|
|
RPC_MESSAGE RpcMessage;
|
|
MIDL_STUB_MESSAGE StubMsg;
|
|
MIDL_STUB_DESC StubDesc;
|
|
void *ptr;
|
|
unsigned int i, j;
|
|
struct conf_complex
|
|
{
|
|
unsigned int dim1, dim2;
|
|
DWORD **array;
|
|
};
|
|
struct conf_complex memsrc;
|
|
struct conf_complex *mem;
|
|
DWORD *buf, expected_length;
|
|
|
|
static const unsigned char fmtstr_complex_array[] =
|
|
{
|
|
|
|
/* 0 */ 0x21, /* FC_BOGUS_ARRAY */
|
|
0x3, /* 3 */
|
|
/* 2 */ NdrFcShort( 0x0 ), /* 0 */
|
|
/* 4 */ 0x19, 0x0, /* Corr desc: field pointer, FC_ULONG */
|
|
/* 6 */ NdrFcShort( 0x4 ), /* 4 */
|
|
/* 8 */ NdrFcLong( 0xffffffff ), /* -1 */
|
|
/* 12 */ 0x8, /* FC_LONG */
|
|
0x5b, /* FC_END */
|
|
/* 14 */
|
|
0x21, /* FC_BOGUS_ARRAY */
|
|
0x3, /* 3 */
|
|
/* 16 */ NdrFcShort( 0x0 ), /* 0 */
|
|
/* 18 */ 0x19, /* Corr desc: field pointer, FC_ULONG */
|
|
0x0, /* */
|
|
/* 20 */ NdrFcShort( 0x0 ), /* 0 */
|
|
/* 22 */ NdrFcLong( 0xffffffff ), /* -1 */
|
|
/* 26 */ 0x12, 0x0, /* FC_UP */
|
|
/* 28 */ NdrFcShort( 0xffe4 ), /* Offset= -28 (0) */
|
|
/* 30 */ 0x5c, /* FC_PAD */
|
|
0x5b, /* FC_END */
|
|
|
|
#ifdef _WIN64
|
|
/* 32 */ 0x1a, /* FC_BOGUS_STRUCT */
|
|
0x3, /* 3 */
|
|
/* 34 */ NdrFcShort( 0x10 ), /* 16 */
|
|
/* 36 */ NdrFcShort( 0x0 ), /* 0 */
|
|
/* 38 */ NdrFcShort( 0x6 ), /* Offset= 6 (44) */
|
|
/* 40 */ 0x8, /* FC_LONG */
|
|
0x8, /* FC_LONG */
|
|
/* 42 */ 0x36, /* FC_POINTER */
|
|
0x5b, /* FC_END */
|
|
/* 44 */
|
|
0x12, 0x0, /* FC_UP */
|
|
/* 46 */ NdrFcShort( 0xffe0 ), /* Offset= -32 (14) */
|
|
#else
|
|
/* 32 */
|
|
0x16, /* FC_PSTRUCT */
|
|
0x3, /* 3 */
|
|
/* 34 */ NdrFcShort( 0xc ), /* 12 */
|
|
/* 36 */ 0x4b, /* FC_PP */
|
|
0x5c, /* FC_PAD */
|
|
/* 38 */ 0x46, /* FC_NO_REPEAT */
|
|
0x5c, /* FC_PAD */
|
|
/* 40 */ NdrFcShort( 0x8 ), /* 8 */
|
|
/* 42 */ NdrFcShort( 0x8 ), /* 8 */
|
|
/* 44 */ 0x12, 0x0, /* FC_UP */
|
|
/* 46 */ NdrFcShort( 0xffe0 ), /* Offset= -32 (14) */
|
|
/* 48 */ 0x5b, /* FC_END */
|
|
0x8, /* FC_LONG */
|
|
/* 50 */ 0x8, /* FC_LONG */
|
|
0x8, /* FC_LONG */
|
|
/* 52 */ 0x5c, /* FC_PAD */
|
|
0x5b, /* FC_END */
|
|
#endif
|
|
};
|
|
|
|
memsrc.dim1 = 5;
|
|
memsrc.dim2 = 3;
|
|
|
|
memsrc.array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, memsrc.dim1 * sizeof(DWORD*));
|
|
|
|
for(i = 0; i < memsrc.dim1; i++)
|
|
{
|
|
memsrc.array[i] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, memsrc.dim2 * sizeof(DWORD));
|
|
for(j = 0; j < memsrc.dim2; j++)
|
|
memsrc.array[i][j] = i * memsrc.dim2 + j;
|
|
}
|
|
|
|
StubDesc = Object_StubDesc;
|
|
StubDesc.pFormatTypes = fmtstr_complex_array;
|
|
|
|
NdrClientInitializeNew(
|
|
&RpcMessage,
|
|
&StubMsg,
|
|
&StubDesc,
|
|
0);
|
|
|
|
StubMsg.BufferLength = 0;
|
|
|
|
#ifdef _WIN64
|
|
NdrComplexStructBufferSize( &StubMsg,
|
|
(unsigned char *)&memsrc,
|
|
&fmtstr_complex_array[32] );
|
|
#else
|
|
NdrSimpleStructBufferSize( &StubMsg,
|
|
(unsigned char *)&memsrc,
|
|
&fmtstr_complex_array[32] );
|
|
#endif
|
|
|
|
expected_length = (4 + memsrc.dim1 * (2 + memsrc.dim2)) * 4;
|
|
if (StubMsg.BufferLength == 96)
|
|
{
|
|
win_skip("Tests crash on Win9x, WinMe and NT4\n");
|
|
goto cleanup;
|
|
}
|
|
ok(StubMsg.BufferLength >= expected_length, "length %d\n", StubMsg.BufferLength);
|
|
|
|
/*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
|
|
StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
|
|
StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
|
|
|
|
#ifdef _WIN64
|
|
ptr = NdrComplexStructMarshall( &StubMsg, (unsigned char *)&memsrc,
|
|
&fmtstr_complex_array[32] );
|
|
#else
|
|
ptr = NdrSimpleStructMarshall( &StubMsg, (unsigned char *)&memsrc,
|
|
&fmtstr_complex_array[32] );
|
|
#endif
|
|
|
|
ok(ptr == NULL, "ret %p\n", ptr);
|
|
ok((char*)StubMsg.Buffer == (char*)StubMsg.BufferStart + expected_length, "not at expected length\n");
|
|
|
|
buf = (DWORD *)StubMsg.BufferStart;
|
|
|
|
ok(*buf == memsrc.dim1, "dim1 should have been %d instead of %08x\n", memsrc.dim1, *buf);
|
|
buf++;
|
|
ok(*buf == memsrc.dim2, "dim2 should have been %d instead of %08x\n", memsrc.dim2, *buf);
|
|
buf++;
|
|
ok(*buf != 0, "pointer id should be non-zero\n");
|
|
buf++;
|
|
ok(*buf == memsrc.dim1, "Conformance should have been %d instead of %08x\n", memsrc.dim1, *buf);
|
|
buf++;
|
|
for(i = 0; i < memsrc.dim1; i++)
|
|
{
|
|
ok(*buf != 0, "pointer id[%d] should be non-zero\n", i);
|
|
buf++;
|
|
}
|
|
for(i = 0; i < memsrc.dim1; i++)
|
|
{
|
|
ok(*buf == memsrc.dim2, "Conformance should have been %d instead of %08x\n", memsrc.dim2, *buf);
|
|
buf++;
|
|
for(j = 0; j < memsrc.dim2; j++)
|
|
{
|
|
ok(*buf == i * memsrc.dim2 + j, "got %08x\n", *buf);
|
|
buf++;
|
|
}
|
|
}
|
|
|
|
ok((void*)buf == StubMsg.Buffer, "not at end of buffer\n");
|
|
|
|
/* Server */
|
|
my_alloc_called = 0;
|
|
StubMsg.IsClient = 0;
|
|
mem = NULL;
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
#ifdef _WIN64
|
|
ptr = NdrComplexStructUnmarshall( &StubMsg, (unsigned char **)&mem, &fmtstr_complex_array[32], 0);
|
|
#else
|
|
ptr = NdrSimpleStructUnmarshall( &StubMsg, (unsigned char **)&mem, &fmtstr_complex_array[32], 0);
|
|
#endif
|
|
ok(ptr == NULL, "ret %p\n", ptr);
|
|
ok(mem->dim1 == memsrc.dim1, "mem->dim1 wasn't unmarshalled correctly (%d)\n", mem->dim1);
|
|
ok(mem->dim2 == memsrc.dim2, "mem->dim2 wasn't unmarshalled correctly (%d)\n", mem->dim2);
|
|
ok(mem->array[1][0] == memsrc.dim2, "mem->array[1][0] wasn't unmarshalled correctly (%d)\n", mem->array[1][0]);
|
|
|
|
StubMsg.Buffer = StubMsg.BufferStart;
|
|
#ifdef _WIN64
|
|
NdrComplexStructFree( &StubMsg, (unsigned char*)mem, &fmtstr_complex_array[32]);
|
|
#else
|
|
NdrSimpleStructFree( &StubMsg, (unsigned char*)mem, &fmtstr_complex_array[32]);
|
|
#endif
|
|
|
|
HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
|
|
|
|
cleanup:
|
|
for(i = 0; i < memsrc.dim1; i++)
|
|
HeapFree(GetProcessHeap(), 0, memsrc.array[i]);
|
|
HeapFree(GetProcessHeap(), 0, memsrc.array);
|
|
}
|
|
|
|
static void test_ndr_buffer(void)
|
|
{
|
|
static unsigned char ncalrpc[] = "ncalrpc";
|
|
static unsigned char endpoint[] = "winetest:test_ndr_buffer";
|
|
RPC_MESSAGE RpcMessage;
|
|
MIDL_STUB_MESSAGE StubMsg;
|
|
MIDL_STUB_DESC StubDesc = Object_StubDesc;
|
|
unsigned char *ret;
|
|
unsigned char *binding;
|
|
RPC_BINDING_HANDLE Handle;
|
|
RPC_STATUS status;
|
|
ULONG prev_buffer_length;
|
|
BOOL old_buffer_valid_location;
|
|
|
|
StubDesc.RpcInterfaceInformation = (void *)&IFoo___RpcServerInterface;
|
|
|
|
status = RpcServerUseProtseqEpA(ncalrpc, 20, endpoint, NULL);
|
|
ok(RPC_S_OK == status, "RpcServerUseProtseqEp failed with status %u\n", status);
|
|
status = RpcServerRegisterIf(IFoo_v0_0_s_ifspec, NULL, NULL);
|
|
ok(RPC_S_OK == status, "RpcServerRegisterIf failed with status %u\n", status);
|
|
status = RpcServerListen(1, 20, TRUE);
|
|
ok(RPC_S_OK == status, "RpcServerListen failed with status %u\n", status);
|
|
if (status != RPC_S_OK)
|
|
{
|
|
/* Failed to create a server, running client tests is useless */
|
|
return;
|
|
}
|
|
|
|
status = RpcStringBindingComposeA(NULL, ncalrpc, NULL, endpoint, NULL, &binding);
|
|
ok(status == RPC_S_OK, "RpcStringBindingCompose failed (%u)\n", status);
|
|
|
|
status = RpcBindingFromStringBindingA(binding, &Handle);
|
|
ok(status == RPC_S_OK, "RpcBindingFromStringBinding failed (%u)\n", status);
|
|
RpcStringFreeA(&binding);
|
|
|
|
NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 5);
|
|
|
|
ret = NdrGetBuffer(&StubMsg, 10, Handle);
|
|
ok(ret == StubMsg.Buffer, "NdrGetBuffer should have returned the same value as StubMsg.Buffer instead of %p\n", ret);
|
|
ok(RpcMessage.Handle != NULL, "RpcMessage.Handle should not have been NULL\n");
|
|
ok(RpcMessage.Buffer != NULL, "RpcMessage.Buffer should not have been NULL\n");
|
|
ok(RpcMessage.BufferLength == 10 ||
|
|
broken(RpcMessage.BufferLength == 12), /* win2k */
|
|
"RpcMessage.BufferLength should have been 10 instead of %d\n", RpcMessage.BufferLength);
|
|
ok(RpcMessage.RpcFlags == 0, "RpcMessage.RpcFlags should have been 0x0 instead of 0x%x\n", RpcMessage.RpcFlags);
|
|
ok(StubMsg.Buffer != NULL, "Buffer should not have been NULL\n");
|
|
ok(!StubMsg.BufferStart, "BufferStart should have been NULL instead of %p\n", StubMsg.BufferStart);
|
|
ok(!StubMsg.BufferEnd, "BufferEnd should have been NULL instead of %p\n", StubMsg.BufferEnd);
|
|
todo_wine
|
|
ok(StubMsg.BufferLength == 0, "BufferLength should have left as 0 instead of being set to %d\n", StubMsg.BufferLength);
|
|
old_buffer_valid_location = !StubMsg.fBufferValid;
|
|
if (old_buffer_valid_location)
|
|
ok(broken(StubMsg.CorrDespIncrement == TRUE), "fBufferValid should have been TRUE instead of 0x%x\n", StubMsg.CorrDespIncrement);
|
|
else
|
|
ok(StubMsg.fBufferValid, "fBufferValid should have been non-zero instead of 0x%x\n", StubMsg.fBufferValid);
|
|
|
|
prev_buffer_length = RpcMessage.BufferLength;
|
|
StubMsg.BufferLength = 1;
|
|
NdrFreeBuffer(&StubMsg);
|
|
ok(RpcMessage.Handle != NULL, "RpcMessage.Handle should not have been NULL\n");
|
|
ok(RpcMessage.Buffer != NULL, "RpcMessage.Buffer should not have been NULL\n");
|
|
ok(RpcMessage.BufferLength == prev_buffer_length, "RpcMessage.BufferLength should have been left as %d instead of %d\n", prev_buffer_length, RpcMessage.BufferLength);
|
|
ok(StubMsg.Buffer != NULL, "Buffer should not have been NULL\n");
|
|
ok(StubMsg.BufferLength == 1, "BufferLength should have left as 1 instead of being set to %d\n", StubMsg.BufferLength);
|
|
if (old_buffer_valid_location)
|
|
ok(broken(StubMsg.CorrDespIncrement == FALSE), "fBufferValid should have been FALSE instead of 0x%x\n", StubMsg.CorrDespIncrement);
|
|
else
|
|
ok(!StubMsg.fBufferValid, "fBufferValid should have been FALSE instead of %d\n", StubMsg.fBufferValid);
|
|
|
|
/* attempt double-free */
|
|
NdrFreeBuffer(&StubMsg);
|
|
|
|
RpcBindingFree(&Handle);
|
|
|
|
status = RpcServerUnregisterIf(NULL, NULL, FALSE);
|
|
ok(status == RPC_S_OK, "RpcServerUnregisterIf failed (%u)\n", status);
|
|
}
|
|
|
|
static void test_NdrMapCommAndFaultStatus(void)
|
|
{
|
|
RPC_STATUS rpc_status;
|
|
MIDL_STUB_MESSAGE StubMsg;
|
|
RPC_MESSAGE RpcMessage;
|
|
|
|
NdrClientInitializeNew(&RpcMessage, &StubMsg, &Object_StubDesc, 5);
|
|
|
|
for (rpc_status = 0; rpc_status < 10000; rpc_status++)
|
|
{
|
|
RPC_STATUS status;
|
|
ULONG comm_status = 0;
|
|
ULONG fault_status = 0;
|
|
ULONG expected_comm_status = 0;
|
|
ULONG expected_fault_status = 0;
|
|
status = NdrMapCommAndFaultStatus(&StubMsg, &comm_status, &fault_status, rpc_status);
|
|
ok(status == RPC_S_OK, "NdrMapCommAndFaultStatus failed with error %d\n", status);
|
|
switch (rpc_status)
|
|
{
|
|
case ERROR_INVALID_HANDLE:
|
|
case RPC_S_INVALID_BINDING:
|
|
case RPC_S_UNKNOWN_IF:
|
|
case RPC_S_SERVER_UNAVAILABLE:
|
|
case RPC_S_SERVER_TOO_BUSY:
|
|
case RPC_S_CALL_FAILED_DNE:
|
|
case RPC_S_PROTOCOL_ERROR:
|
|
case RPC_S_UNSUPPORTED_TRANS_SYN:
|
|
case RPC_S_UNSUPPORTED_TYPE:
|
|
case RPC_S_PROCNUM_OUT_OF_RANGE:
|
|
case EPT_S_NOT_REGISTERED:
|
|
case RPC_S_COMM_FAILURE:
|
|
expected_comm_status = rpc_status;
|
|
break;
|
|
default:
|
|
expected_fault_status = rpc_status;
|
|
}
|
|
ok(comm_status == expected_comm_status, "NdrMapCommAndFaultStatus should have mapped %d to comm status %d instead of %d\n",
|
|
rpc_status, expected_comm_status, comm_status);
|
|
ok(fault_status == expected_fault_status, "NdrMapCommAndFaultStatus should have mapped %d to fault status %d instead of %d\n",
|
|
rpc_status, expected_fault_status, fault_status);
|
|
}
|
|
}
|
|
|
|
static void test_NdrGetUserMarshalInfo(void)
|
|
{
|
|
RPC_STATUS status;
|
|
MIDL_STUB_MESSAGE stubmsg;
|
|
USER_MARSHAL_CB umcb;
|
|
NDR_USER_MARSHAL_INFO umi;
|
|
unsigned char buffer[16];
|
|
void *rpc_channel_buffer = (void *)(ULONG_PTR)0xcafebabe;
|
|
RPC_MESSAGE rpc_msg;
|
|
RPC_STATUS (RPC_ENTRY *pNdrGetUserMarshalInfo)(ULONG *,ULONG,NDR_USER_MARSHAL_INFO *);
|
|
|
|
pNdrGetUserMarshalInfo = (void *)GetProcAddress(GetModuleHandleA("rpcrt4.dll"), "NdrGetUserMarshalInfo");
|
|
if (!pNdrGetUserMarshalInfo)
|
|
{
|
|
skip("NdrGetUserMarshalInfo not exported\n");
|
|
return;
|
|
}
|
|
|
|
/* unmarshall */
|
|
|
|
memset(&rpc_msg, 0xcc, sizeof(rpc_msg));
|
|
rpc_msg.Buffer = buffer;
|
|
rpc_msg.BufferLength = 16;
|
|
|
|
memset(&stubmsg, 0xcc, sizeof(stubmsg));
|
|
stubmsg.RpcMsg = &rpc_msg;
|
|
stubmsg.dwDestContext = MSHCTX_INPROC;
|
|
stubmsg.pvDestContext = NULL;
|
|
stubmsg.Buffer = buffer + 15;
|
|
stubmsg.BufferLength = 0;
|
|
stubmsg.BufferEnd = NULL;
|
|
stubmsg.pRpcChannelBuffer = rpc_channel_buffer;
|
|
stubmsg.StubDesc = NULL;
|
|
stubmsg.pfnAllocate = my_alloc;
|
|
stubmsg.pfnFree = my_free;
|
|
|
|
memset(&umcb, 0xcc, sizeof(umcb));
|
|
umcb.Flags = MAKELONG(MSHCTX_INPROC, NDR_LOCAL_DATA_REPRESENTATION);
|
|
umcb.pStubMsg = &stubmsg;
|
|
umcb.Signature = USER_MARSHAL_CB_SIGNATURE;
|
|
umcb.CBType = USER_MARSHAL_CB_UNMARSHALL;
|
|
|
|
memset(&umi, 0xaa, sizeof(umi));
|
|
|
|
status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
|
|
ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
|
|
ok( umi.InformationLevel == 1,
|
|
"umi.InformationLevel was %u instead of 1\n",
|
|
umi.InformationLevel);
|
|
ok( U1(umi).Level1.Buffer == buffer + 15,
|
|
"umi.Level1.Buffer was %p instead of %p\n",
|
|
U1(umi).Level1.Buffer, buffer);
|
|
ok( U1(umi).Level1.BufferSize == 1,
|
|
"umi.Level1.BufferSize was %u instead of 1\n",
|
|
U1(umi).Level1.BufferSize);
|
|
ok( U1(umi).Level1.pfnAllocate == my_alloc,
|
|
"umi.Level1.pfnAllocate was %p instead of %p\n",
|
|
U1(umi).Level1.pfnAllocate, my_alloc);
|
|
ok( U1(umi).Level1.pfnFree == my_free,
|
|
"umi.Level1.pfnFree was %p instead of %p\n",
|
|
U1(umi).Level1.pfnFree, my_free);
|
|
ok( U1(umi).Level1.pRpcChannelBuffer == rpc_channel_buffer,
|
|
"umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
|
|
U1(umi).Level1.pRpcChannelBuffer, rpc_channel_buffer);
|
|
|
|
/* buffer size */
|
|
|
|
rpc_msg.Buffer = buffer;
|
|
rpc_msg.BufferLength = 16;
|
|
|
|
stubmsg.Buffer = buffer;
|
|
stubmsg.BufferLength = 16;
|
|
stubmsg.BufferEnd = NULL;
|
|
|
|
umcb.CBType = USER_MARSHAL_CB_BUFFER_SIZE;
|
|
|
|
memset(&umi, 0xaa, sizeof(umi));
|
|
|
|
status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
|
|
ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
|
|
ok( umi.InformationLevel == 1,
|
|
"umi.InformationLevel was %u instead of 1\n",
|
|
umi.InformationLevel);
|
|
ok( U1(umi).Level1.Buffer == NULL,
|
|
"umi.Level1.Buffer was %p instead of NULL\n",
|
|
U1(umi).Level1.Buffer);
|
|
ok( U1(umi).Level1.BufferSize == 0,
|
|
"umi.Level1.BufferSize was %u instead of 0\n",
|
|
U1(umi).Level1.BufferSize);
|
|
ok( U1(umi).Level1.pfnAllocate == my_alloc,
|
|
"umi.Level1.pfnAllocate was %p instead of %p\n",
|
|
U1(umi).Level1.pfnAllocate, my_alloc);
|
|
ok( U1(umi).Level1.pfnFree == my_free,
|
|
"umi.Level1.pfnFree was %p instead of %p\n",
|
|
U1(umi).Level1.pfnFree, my_free);
|
|
ok( U1(umi).Level1.pRpcChannelBuffer == rpc_channel_buffer,
|
|
"umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
|
|
U1(umi).Level1.pRpcChannelBuffer, rpc_channel_buffer);
|
|
|
|
/* marshall */
|
|
|
|
rpc_msg.Buffer = buffer;
|
|
rpc_msg.BufferLength = 16;
|
|
|
|
stubmsg.Buffer = buffer + 15;
|
|
stubmsg.BufferLength = 0;
|
|
stubmsg.BufferEnd = NULL;
|
|
|
|
umcb.CBType = USER_MARSHAL_CB_MARSHALL;
|
|
|
|
memset(&umi, 0xaa, sizeof(umi));
|
|
|
|
status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
|
|
ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
|
|
ok( umi.InformationLevel == 1,
|
|
"umi.InformationLevel was %u instead of 1\n",
|
|
umi.InformationLevel);
|
|
ok( U1(umi).Level1.Buffer == buffer + 15,
|
|
"umi.Level1.Buffer was %p instead of %p\n",
|
|
U1(umi).Level1.Buffer, buffer);
|
|
ok( U1(umi).Level1.BufferSize == 1,
|
|
"umi.Level1.BufferSize was %u instead of 1\n",
|
|
U1(umi).Level1.BufferSize);
|
|
ok( U1(umi).Level1.pfnAllocate == my_alloc,
|
|
"umi.Level1.pfnAllocate was %p instead of %p\n",
|
|
U1(umi).Level1.pfnAllocate, my_alloc);
|
|
ok( U1(umi).Level1.pfnFree == my_free,
|
|
"umi.Level1.pfnFree was %p instead of %p\n",
|
|
U1(umi).Level1.pfnFree, my_free);
|
|
ok( U1(umi).Level1.pRpcChannelBuffer == rpc_channel_buffer,
|
|
"umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
|
|
U1(umi).Level1.pRpcChannelBuffer, rpc_channel_buffer);
|
|
|
|
/* free */
|
|
|
|
rpc_msg.Buffer = buffer;
|
|
rpc_msg.BufferLength = 16;
|
|
|
|
stubmsg.Buffer = buffer;
|
|
stubmsg.BufferLength = 16;
|
|
stubmsg.BufferEnd = NULL;
|
|
|
|
umcb.CBType = USER_MARSHAL_CB_FREE;
|
|
|
|
memset(&umi, 0xaa, sizeof(umi));
|
|
|
|
status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
|
|
ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
|
|
ok( umi.InformationLevel == 1,
|
|
"umi.InformationLevel was %u instead of 1\n",
|
|
umi.InformationLevel);
|
|
ok( U1(umi).Level1.Buffer == NULL,
|
|
"umi.Level1.Buffer was %p instead of NULL\n",
|
|
U1(umi).Level1.Buffer);
|
|
ok( U1(umi).Level1.BufferSize == 0,
|
|
"umi.Level1.BufferSize was %u instead of 0\n",
|
|
U1(umi).Level1.BufferSize);
|
|
ok( U1(umi).Level1.pfnAllocate == my_alloc,
|
|
"umi.Level1.pfnAllocate was %p instead of %p\n",
|
|
U1(umi).Level1.pfnAllocate, my_alloc);
|
|
ok( U1(umi).Level1.pfnFree == my_free,
|
|
"umi.Level1.pfnFree was %p instead of %p\n",
|
|
U1(umi).Level1.pfnFree, my_free);
|
|
ok( U1(umi).Level1.pRpcChannelBuffer == rpc_channel_buffer,
|
|
"umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
|
|
U1(umi).Level1.pRpcChannelBuffer, rpc_channel_buffer);
|
|
|
|
/* boundary test */
|
|
|
|
rpc_msg.Buffer = buffer;
|
|
rpc_msg.BufferLength = 15;
|
|
|
|
stubmsg.Buffer = buffer + 15;
|
|
stubmsg.BufferLength = 0;
|
|
stubmsg.BufferEnd = NULL;
|
|
|
|
umcb.CBType = USER_MARSHAL_CB_MARSHALL;
|
|
|
|
status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
|
|
ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
|
|
ok( U1(umi).Level1.BufferSize == 0,
|
|
"umi.Level1.BufferSize was %u instead of 0\n",
|
|
U1(umi).Level1.BufferSize);
|
|
|
|
/* error conditions */
|
|
|
|
rpc_msg.BufferLength = 14;
|
|
status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
|
|
ok(status == ERROR_INVALID_USER_BUFFER,
|
|
"NdrGetUserMarshalInfo should have failed with ERROR_INVALID_USER_BUFFER instead of %d\n", status);
|
|
|
|
rpc_msg.BufferLength = 15;
|
|
status = pNdrGetUserMarshalInfo(&umcb.Flags, 9999, &umi);
|
|
ok(status == RPC_S_INVALID_ARG,
|
|
"NdrGetUserMarshalInfo should have failed with RPC_S_INVALID_ARG instead of %d\n", status);
|
|
|
|
umcb.CBType = 9999;
|
|
status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
|
|
ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
|
|
|
|
umcb.CBType = USER_MARSHAL_CB_MARSHALL;
|
|
umcb.Signature = 0;
|
|
status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
|
|
ok(status == RPC_S_INVALID_ARG,
|
|
"NdrGetUserMarshalInfo should have failed with RPC_S_INVALID_ARG instead of %d\n", status);
|
|
}
|
|
|
|
static void test_MesEncodeFixedBufferHandleCreate(void)
|
|
{
|
|
ULONG encoded_size;
|
|
RPC_STATUS status;
|
|
handle_t handle;
|
|
char *buffer;
|
|
|
|
status = MesEncodeFixedBufferHandleCreate(NULL, 0, NULL, NULL);
|
|
ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
|
|
|
|
status = MesEncodeFixedBufferHandleCreate(NULL, 0, NULL, &handle);
|
|
ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
|
|
|
|
status = MesEncodeFixedBufferHandleCreate((char*)0xdeadbeef, 0, NULL, &handle);
|
|
ok(status == RPC_X_INVALID_BUFFER, "got %d\n", status);
|
|
|
|
buffer = (void*)((0xdeadbeef + 7) & ~7);
|
|
status = MesEncodeFixedBufferHandleCreate(buffer, 0, NULL, &handle);
|
|
ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
|
|
|
|
status = MesEncodeFixedBufferHandleCreate(buffer, 0, &encoded_size, &handle);
|
|
todo_wine
|
|
ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
|
|
if (status == RPC_S_OK)
|
|
MesHandleFree(handle);
|
|
|
|
status = MesEncodeFixedBufferHandleCreate(buffer, 32, NULL, &handle);
|
|
ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
|
|
|
|
status = MesEncodeFixedBufferHandleCreate(buffer, 32, &encoded_size, &handle);
|
|
ok(status == RPC_S_OK, "got %d\n", status);
|
|
|
|
status = MesBufferHandleReset(NULL, MES_DYNAMIC_BUFFER_HANDLE, MES_ENCODE,
|
|
&buffer, 32, &encoded_size);
|
|
ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
|
|
|
|
/* convert to dynamic buffer handle */
|
|
status = MesBufferHandleReset(handle, MES_DYNAMIC_BUFFER_HANDLE, MES_ENCODE,
|
|
&buffer, 32, &encoded_size);
|
|
ok(status == RPC_S_OK, "got %d\n", status);
|
|
|
|
status = MesBufferHandleReset(handle, MES_DYNAMIC_BUFFER_HANDLE, MES_ENCODE,
|
|
NULL, 32, &encoded_size);
|
|
ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
|
|
|
|
status = MesBufferHandleReset(handle, MES_DYNAMIC_BUFFER_HANDLE, MES_ENCODE,
|
|
&buffer, 32, NULL);
|
|
ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
|
|
|
|
/* invalid handle type */
|
|
status = MesBufferHandleReset(handle, MES_DYNAMIC_BUFFER_HANDLE+1, MES_ENCODE,
|
|
&buffer, 32, &encoded_size);
|
|
ok(status == RPC_S_INVALID_ARG, "got %d\n", status);
|
|
|
|
status = MesHandleFree(handle);
|
|
ok(status == RPC_S_OK, "got %d\n", status);
|
|
}
|
|
|
|
static void test_NdrCorrelationInitialize(void)
|
|
{
|
|
MIDL_STUB_MESSAGE stub_msg;
|
|
BYTE buf[256];
|
|
|
|
memset( &stub_msg, 0, sizeof(stub_msg) );
|
|
memset( buf, 0, sizeof(buf) );
|
|
|
|
NdrCorrelationInitialize( &stub_msg, buf, sizeof(buf), 0 );
|
|
ok( stub_msg.CorrDespIncrement == 2 ||
|
|
broken(stub_msg.CorrDespIncrement == 0), /* <= Win 2003 */
|
|
"got %d\n", stub_msg.CorrDespIncrement );
|
|
|
|
memset( &stub_msg, 0, sizeof(stub_msg) );
|
|
memset( buf, 0, sizeof(buf) );
|
|
|
|
stub_msg.CorrDespIncrement = 1;
|
|
NdrCorrelationInitialize( &stub_msg, buf, sizeof(buf), 0 );
|
|
ok( stub_msg.CorrDespIncrement == 1, "got %d\n", stub_msg.CorrDespIncrement );
|
|
}
|
|
|
|
START_TEST( ndr_marshall )
|
|
{
|
|
determine_pointer_marshalling_style();
|
|
|
|
test_ndr_simple_type();
|
|
test_simple_types();
|
|
test_nontrivial_pointer_types();
|
|
test_simple_struct();
|
|
test_fullpointer_xlat();
|
|
test_client_init();
|
|
test_server_init();
|
|
test_ndr_allocate();
|
|
test_conformant_array();
|
|
test_conformant_string();
|
|
test_nonconformant_string();
|
|
test_conf_complex_struct();
|
|
test_conf_complex_array();
|
|
test_ndr_buffer();
|
|
test_NdrMapCommAndFaultStatus();
|
|
test_NdrGetUserMarshalInfo();
|
|
test_MesEncodeFixedBufferHandleCreate();
|
|
test_NdrCorrelationInitialize();
|
|
}
|