2 * Unit test suite for ndr marshalling functions
4 * Copyright 2006 Huw Davies
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #define NTDDI_WIN2K 0x05000000
24 #define NTDDI_VERSION NTDDI_WIN2K /* for some MIDL_STUB_MESSAGE fields */
26 #include "wine/test.h"
37 static int my_alloc_called
;
38 static int my_free_called
;
39 static void * CALLBACK
my_alloc(size_t size
)
42 return NdrOleAllocate(size
);
45 static void CALLBACK
my_free(void *ptr
)
51 static const MIDL_STUB_DESC Object_StubDesc
=
61 NULL
, /* format string, filled in by tests */
62 1, /* -error bounds_check flag */
63 0x20000, /* Ndr library version */
65 0x50100a4, /* MIDL Version 5.1.164 */
68 0, /* notify & notify_flag routine table */
75 static RPC_DISPATCH_FUNCTION IFoo_table
[] =
80 static RPC_DISPATCH_TABLE IFoo_v0_0_DispatchTable
=
86 static const RPC_SERVER_INTERFACE IFoo___RpcServerInterface
=
88 sizeof(RPC_SERVER_INTERFACE
),
89 {{0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x12,0x34}},{0,0}},
90 {{0x8a885d04,0x1ceb,0x11c9,{0x9f,0xe8,0x08,0x00,0x2b,0x10,0x48,0x60}},{2,0}},
91 &IFoo_v0_0_DispatchTable
,
99 static RPC_IF_HANDLE IFoo_v0_0_s_ifspec
= (RPC_IF_HANDLE
)& IFoo___RpcServerInterface
;
100 static BOOL use_pointer_ids
= FALSE
;
102 static void determine_pointer_marshalling_style(void)
104 RPC_MESSAGE RpcMessage
;
105 MIDL_STUB_MESSAGE StubMsg
;
106 MIDL_STUB_DESC StubDesc
;
109 static const unsigned char fmtstr_up_char
[] =
111 0x12, 0x8, /* FC_UP [simple_pointer] */
116 StubDesc
= Object_StubDesc
;
117 StubDesc
.pFormatTypes
= NULL
;
119 NdrClientInitializeNew(
125 StubMsg
.BufferLength
= 8;
126 StubMsg
.RpcMsg
->Buffer
= StubMsg
.BufferStart
= StubMsg
.Buffer
= HeapAlloc(GetProcessHeap(), 0, StubMsg
.BufferLength
);
127 NdrPointerMarshall(&StubMsg
, (unsigned char*)&ch
, fmtstr_up_char
);
128 ok(StubMsg
.Buffer
== StubMsg
.BufferStart
+ 5, "%p %p\n", StubMsg
.Buffer
, StubMsg
.BufferStart
);
130 use_pointer_ids
= (*(unsigned int *)StubMsg
.BufferStart
!= (unsigned int)&ch
);
131 trace("Pointer marshalling using %s\n", use_pointer_ids
? "pointer ids" : "pointer value");
133 HeapFree(GetProcessHeap(), 0, StubMsg
.BufferStart
);
136 static void test_ndr_simple_type(void)
138 RPC_MESSAGE RpcMessage
;
139 MIDL_STUB_MESSAGE StubMsg
;
140 MIDL_STUB_DESC StubDesc
;
143 StubDesc
= Object_StubDesc
;
144 StubDesc
.pFormatTypes
= NULL
;
146 NdrClientInitializeNew(
152 StubMsg
.BufferLength
= 16;
153 StubMsg
.RpcMsg
->Buffer
= StubMsg
.BufferStart
= StubMsg
.Buffer
= HeapAlloc(GetProcessHeap(), 0, StubMsg
.BufferLength
);
155 NdrSimpleTypeMarshall(&StubMsg
, (unsigned char*)&l
, 8 /* FC_LONG */);
156 ok(StubMsg
.Buffer
== StubMsg
.BufferStart
+ 4, "%p %p\n", StubMsg
.Buffer
, StubMsg
.BufferStart
);
157 ok(*(long*)StubMsg
.BufferStart
== l
, "%ld\n", *(long*)StubMsg
.BufferStart
);
159 StubMsg
.Buffer
= StubMsg
.BufferStart
+ 1;
160 NdrSimpleTypeMarshall(&StubMsg
, (unsigned char*)&l
, 8 /* FC_LONG */);
161 ok(StubMsg
.Buffer
== StubMsg
.BufferStart
+ 8, "%p %p\n", StubMsg
.Buffer
, StubMsg
.BufferStart
);
162 ok(*(long*)(StubMsg
.BufferStart
+ 4) == l
, "%ld\n", *(long*)StubMsg
.BufferStart
);
164 StubMsg
.Buffer
= StubMsg
.BufferStart
+ 1;
165 NdrSimpleTypeUnmarshall(&StubMsg
, (unsigned char*)&l2
, 8 /* FC_LONG */);
166 ok(StubMsg
.Buffer
== StubMsg
.BufferStart
+ 8, "%p %p\n", StubMsg
.Buffer
, StubMsg
.BufferStart
);
167 ok(l2
== l
, "%ld\n", l2
);
169 HeapFree(GetProcessHeap(), 0, StubMsg
.BufferStart
);
172 static void test_pointer_marshal(const unsigned char *formattypes
,
175 const void *wiredata
,
177 int(*cmp
)(const void*,const void*,size_t),
178 long num_additional_allocs
,
181 RPC_MESSAGE RpcMessage
;
182 MIDL_STUB_MESSAGE StubMsg
;
183 MIDL_STUB_DESC StubDesc
;
186 unsigned char *mem
, *mem_orig
;
188 my_alloc_called
= my_free_called
= 0;
192 StubDesc
= Object_StubDesc
;
193 StubDesc
.pFormatTypes
= formattypes
;
195 NdrClientInitializeNew(
201 StubMsg
.BufferLength
= 0;
202 NdrPointerBufferSize( &StubMsg
,
205 ok(StubMsg
.BufferLength
>= wiredatalen
, "%s: length %d\n", msgpfx
, StubMsg
.BufferLength
);
207 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
208 StubMsg
.RpcMsg
->Buffer
= StubMsg
.BufferStart
= StubMsg
.Buffer
= HeapAlloc(GetProcessHeap(), 0, StubMsg
.BufferLength
);
209 StubMsg
.BufferEnd
= StubMsg
.BufferStart
+ StubMsg
.BufferLength
;
211 memset(StubMsg
.BufferStart
, 0x0, StubMsg
.BufferLength
); /* This is a hack to clear the padding between the ptr and longlong/double */
213 ptr
= NdrPointerMarshall( &StubMsg
, memsrc
, formattypes
);
214 ok(ptr
== NULL
, "%s: ret %p\n", msgpfx
, ptr
);
215 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== wiredatalen
, "%s: Buffer %p Start %p len %d\n", msgpfx
, StubMsg
.Buffer
, StubMsg
.BufferStart
, wiredatalen
);
216 ok(!memcmp(StubMsg
.BufferStart
, wiredata
, wiredatalen
), "%s: incorrectly marshaled\n", msgpfx
);
218 StubMsg
.Buffer
= StubMsg
.BufferStart
;
219 StubMsg
.MemorySize
= 0;
223 /* NdrPointerMemorySize crashes under Wine */
224 size
= NdrPointerMemorySize( &StubMsg
, formattypes
);
225 ok(size
== StubMsg
.MemorySize
, "%s: mem size %u size %u\n", msgpfx
, StubMsg
.MemorySize
, size
);
226 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== wiredatalen
, "%s: Buffer %p Start %p len %d\n", msgpfx
, StubMsg
.Buffer
, StubMsg
.BufferStart
, wiredatalen
);
227 if(formattypes
[1] & 0x10 /* FC_POINTER_DEREF */)
228 ok(size
== srcsize
+ 4, "%s: mem size %u\n", msgpfx
, size
);
230 ok(size
== srcsize
, "%s: mem size %u\n", msgpfx
, size
);
232 StubMsg
.Buffer
= StubMsg
.BufferStart
;
233 StubMsg
.MemorySize
= 16;
234 size
= NdrPointerMemorySize( &StubMsg
, formattypes
);
235 ok(size
== StubMsg
.MemorySize
, "%s: mem size %u size %u\n", msgpfx
, StubMsg
.MemorySize
, size
);
236 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== wiredatalen
, "%s: Buffer %p Start %p len %d\n", msgpfx
, StubMsg
.Buffer
, StubMsg
.BufferStart
, wiredatalen
);
237 if(formattypes
[1] & 0x10 /* FC_POINTER_DEREF */)
238 ok(size
== srcsize
+ 4 + 16, "%s: mem size %u\n", msgpfx
, size
);
240 ok(size
== srcsize
+ 16, "%s: mem size %u\n", msgpfx
, size
);
242 StubMsg
.Buffer
= StubMsg
.BufferStart
;
243 StubMsg
.MemorySize
= 1;
244 size
= NdrPointerMemorySize( &StubMsg
, formattypes
);
245 ok(size
== StubMsg
.MemorySize
, "%s: mem size %u size %u\n", msgpfx
, StubMsg
.MemorySize
, size
);
246 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== wiredatalen
, "%s: Buffer %p Start %p len %d\n", msgpfx
, StubMsg
.Buffer
, StubMsg
.BufferStart
, wiredatalen
);
247 if(formattypes
[1] & 0x10 /* FC_POINTER_DEREF */)
248 ok(size
== srcsize
+ 4 + (srcsize
== 8 ? 8 : 4), "%s: mem size %u\n", msgpfx
, size
);
250 ok(size
== srcsize
+ (srcsize
== 8 ? 8 : 4), "%s: mem size %u\n", msgpfx
, size
);
254 if(formattypes
[1] & 0x10) size
+= 4;
256 StubMsg
.Buffer
= StubMsg
.BufferStart
;
257 StubMsg
.MemorySize
= 0;
258 mem_orig
= mem
= HeapAlloc(GetProcessHeap(), 0, size
);
260 if(formattypes
[1] & 0x10 /* FC_POINTER_DEREF */)
262 ptr
= NdrPointerUnmarshall( &StubMsg
, &mem
, formattypes
, 0 );
263 ok(ptr
== NULL
, "%s: ret %p\n", msgpfx
, ptr
);
264 ok(mem
== mem_orig
, "%s: mem has changed %p %p\n", msgpfx
, mem
, mem_orig
);
265 ok(!cmp(mem
, memsrc
, srcsize
), "%s: incorrectly unmarshaled\n", msgpfx
);
266 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== wiredatalen
, "%s: Buffer %p Start %p len %d\n", msgpfx
, StubMsg
.Buffer
, StubMsg
.BufferStart
, wiredatalen
);
267 ok(StubMsg
.MemorySize
== 0, "%s: memorysize %d\n", msgpfx
, StubMsg
.MemorySize
);
268 ok(my_alloc_called
== num_additional_allocs
, "%s: my_alloc got called %d times\n", msgpfx
, my_alloc_called
);
271 /* reset the buffer and call with must alloc */
272 StubMsg
.Buffer
= StubMsg
.BufferStart
;
273 if(formattypes
[1] & 0x10 /* FC_POINTER_DEREF */)
275 ptr
= NdrPointerUnmarshall( &StubMsg
, &mem
, formattypes
, 1 );
276 ok(ptr
== NULL
, "%s: ret %p\n", msgpfx
, ptr
);
277 /* doesn't allocate mem in this case */
279 ok(mem
== mem_orig
, "%s: mem has changed %p %p\n", msgpfx
, mem
, mem_orig
);
281 ok(!cmp(mem
, memsrc
, srcsize
), "%s: incorrectly unmarshaled\n", msgpfx
);
282 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== wiredatalen
, "%s: Buffer %p Start %p len %d\n", msgpfx
, StubMsg
.Buffer
, StubMsg
.BufferStart
, wiredatalen
);
283 ok(StubMsg
.MemorySize
== 0, "%s: memorysize %d\n", msgpfx
, StubMsg
.MemorySize
);
286 ok(my_alloc_called
== num_additional_allocs
, "%s: my_alloc got called %d times\n", msgpfx
, my_alloc_called
);
289 if(formattypes
[0] != 0x11 /* FC_RP */)
291 /* now pass the address of a NULL ptr */
293 StubMsg
.Buffer
= StubMsg
.BufferStart
;
294 ptr
= NdrPointerUnmarshall( &StubMsg
, &mem
, formattypes
, 0 );
295 ok(ptr
== NULL
, "%s: ret %p\n", msgpfx
, ptr
);
296 ok(mem
!= StubMsg
.BufferStart
+ wiredatalen
- srcsize
, "%s: mem points to buffer %p %p\n", msgpfx
, mem
, StubMsg
.BufferStart
);
297 ok(!cmp(mem
, memsrc
, size
), "%s: incorrectly unmarshaled\n", msgpfx
);
298 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== wiredatalen
, "%s: Buffer %p Start %p len %d\n", msgpfx
, StubMsg
.Buffer
, StubMsg
.BufferStart
, wiredatalen
);
299 ok(StubMsg
.MemorySize
== 0, "%s: memorysize %d\n", msgpfx
, StubMsg
.MemorySize
);
300 ok(my_alloc_called
== num_additional_allocs
+ 1, "%s: my_alloc got called %d times\n", msgpfx
, my_alloc_called
);
302 NdrPointerFree(&StubMsg
, mem
, formattypes
);
304 /* again pass address of NULL ptr, but pretend we're a server */
306 StubMsg
.Buffer
= StubMsg
.BufferStart
;
307 StubMsg
.IsClient
= 0;
308 ptr
= NdrPointerUnmarshall( &StubMsg
, &mem
, formattypes
, 0 );
309 ok(ptr
== NULL
, "%s: ret %p\n", msgpfx
, ptr
);
310 if (formattypes
[2] == 0xd /* FC_ENUM16 */)
311 ok(mem
!= StubMsg
.BufferStart
+ wiredatalen
- srcsize
, "%s: mem points to buffer %p %p\n", msgpfx
, mem
, StubMsg
.BufferStart
);
313 ok(mem
== StubMsg
.BufferStart
+ wiredatalen
- srcsize
, "%s: mem doesn't point to buffer %p %p\n", msgpfx
, mem
, StubMsg
.BufferStart
);
314 ok(!cmp(mem
, memsrc
, size
), "%s: incorrectly unmarshaled\n", msgpfx
);
315 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== wiredatalen
, "%s: Buffer %p Start %p len %d\n", msgpfx
, StubMsg
.Buffer
, StubMsg
.BufferStart
, wiredatalen
);
316 ok(StubMsg
.MemorySize
== 0, "%s: memorysize %d\n", msgpfx
, StubMsg
.MemorySize
);
317 if (formattypes
[2] != 0xd /* FC_ENUM16 */) {
318 ok(my_alloc_called
== num_additional_allocs
, "%s: my_alloc got called %d times\n", msgpfx
, my_alloc_called
);
322 HeapFree(GetProcessHeap(), 0, mem_orig
);
323 HeapFree(GetProcessHeap(), 0, StubMsg
.BufferStart
);
326 static int deref_cmp(const void *s1
, const void *s2
, size_t num
)
328 return memcmp(*(const void *const *)s1
, *(const void *const *)s2
, num
);
332 static void test_simple_types(void)
334 unsigned char wiredata
[16];
336 unsigned char *ch_ptr
;
344 static const unsigned char fmtstr_up_char
[] =
346 0x12, 0x8, /* FC_UP [simple_pointer] */
350 static const unsigned char fmtstr_up_byte
[] =
352 0x12, 0x8, /* FC_UP [simple_pointer] */
356 static const unsigned char fmtstr_up_small
[] =
358 0x12, 0x8, /* FC_UP [simple_pointer] */
362 static const unsigned char fmtstr_up_usmall
[] =
364 0x12, 0x8, /* FC_UP [simple_pointer] */
368 static const unsigned char fmtstr_rp_char
[] =
370 0x11, 0x8, /* FC_RP [simple_pointer] */
374 static const unsigned char fmtstr_rpup_char
[] =
376 0x11, 0x14, /* FC_RP [alloced_on_stack] */
377 NdrFcShort( 0x2 ), /* Offset= 2 (4) */
378 0x12, 0x8, /* FC_UP [simple_pointer] */
382 static const unsigned char fmtstr_rpup_char2
[] =
384 0x11, 0x04, /* FC_RP [alloced_on_stack] */
385 NdrFcShort( 0x2 ), /* Offset= 2 (4) */
386 0x12, 0x8, /* FC_UP [simple_pointer] */
391 static const unsigned char fmtstr_up_wchar
[] =
393 0x12, 0x8, /* FC_UP [simple_pointer] */
397 static const unsigned char fmtstr_up_short
[] =
399 0x12, 0x8, /* FC_UP [simple_pointer] */
403 static const unsigned char fmtstr_up_ushort
[] =
405 0x12, 0x8, /* FC_UP [simple_pointer] */
409 static const unsigned char fmtstr_up_enum16
[] =
411 0x12, 0x8, /* FC_UP [simple_pointer] */
415 static const unsigned char fmtstr_up_long
[] =
417 0x12, 0x8, /* FC_UP [simple_pointer] */
421 static const unsigned char fmtstr_up_ulong
[] =
423 0x12, 0x8, /* FC_UP [simple_pointer] */
427 static const unsigned char fmtstr_up_enum32
[] =
429 0x12, 0x8, /* FC_UP [simple_pointer] */
433 static const unsigned char fmtstr_up_errorstatus
[] =
435 0x12, 0x8, /* FC_UP [simple_pointer] */
436 0x10, /* FC_ERROR_STATUS_T */
440 static const unsigned char fmtstr_up_longlong
[] =
442 0x12, 0x8, /* FC_UP [simple_pointer] */
446 static const unsigned char fmtstr_up_float
[] =
448 0x12, 0x8, /* FC_UP [simple_pointer] */
452 static const unsigned char fmtstr_up_double
[] =
454 0x12, 0x8, /* FC_UP [simple_pointer] */
462 *(unsigned int *)wiredata
= 0x20000;
464 *(unsigned int *)wiredata
= (unsigned int)ch_ptr
;
467 test_pointer_marshal(fmtstr_up_char
, ch_ptr
, 1, wiredata
, 5, NULL
, 0, "up_char");
468 test_pointer_marshal(fmtstr_up_byte
, ch_ptr
, 1, wiredata
, 5, NULL
, 0, "up_byte");
469 test_pointer_marshal(fmtstr_up_small
, ch_ptr
, 1, wiredata
, 5, NULL
, 0, "up_small");
470 test_pointer_marshal(fmtstr_up_usmall
, ch_ptr
, 1, wiredata
, 5, NULL
, 0, "up_usmall");
472 test_pointer_marshal(fmtstr_rp_char
, ch_ptr
, 1, &ch
, 1, NULL
, 0, "rp_char");
474 test_pointer_marshal(fmtstr_rpup_char
, &ch_ptr
, 1, wiredata
, 5, deref_cmp
, 1, "rpup_char");
475 test_pointer_marshal(fmtstr_rpup_char2
, ch_ptr
, 1, wiredata
, 5, NULL
, 0, "rpup_char2");
479 *(unsigned int *)wiredata
= 0x20000;
481 *(unsigned int *)wiredata
= (unsigned int)&s
;
482 *(unsigned short*)(wiredata
+ 4) = s
;
484 test_pointer_marshal(fmtstr_up_wchar
, &s
, 2, wiredata
, 6, NULL
, 0, "up_wchar");
485 test_pointer_marshal(fmtstr_up_short
, &s
, 2, wiredata
, 6, NULL
, 0, "up_short");
486 test_pointer_marshal(fmtstr_up_ushort
, &s
, 2, wiredata
, 6, NULL
, 0, "up_ushort");
490 *(unsigned int *)wiredata
= 0x20000;
492 *(unsigned int *)wiredata
= (unsigned int)&i
;
493 *(unsigned short*)(wiredata
+ 4) = i
;
494 test_pointer_marshal(fmtstr_up_enum16
, &i
, 2, wiredata
, 6, NULL
, 0, "up_enum16");
498 *(unsigned int *)wiredata
= 0x20000;
500 *(unsigned int *)wiredata
= (unsigned int)&l
;
501 *(unsigned long*)(wiredata
+ 4) = l
;
503 test_pointer_marshal(fmtstr_up_long
, &l
, 4, wiredata
, 8, NULL
, 0, "up_long");
504 test_pointer_marshal(fmtstr_up_ulong
, &l
, 4, wiredata
, 8, NULL
, 0, "up_ulong");
505 test_pointer_marshal(fmtstr_up_enum32
, &l
, 4, wiredata
, 8, NULL
, 0, "up_emun32");
506 test_pointer_marshal(fmtstr_up_errorstatus
, &l
, 4, wiredata
, 8, NULL
, 0, "up_errorstatus");
508 ll
= ((ULONGLONG
)0xcafebabe) << 32 | 0xdeadbeef;
510 *(unsigned int *)wiredata
= 0x20000;
512 *(unsigned int *)wiredata
= (unsigned int)&ll
;
513 *(unsigned int **)(wiredata
+ 4) = 0;
514 *(ULONGLONG
*)(wiredata
+ 8) = ll
;
515 test_pointer_marshal(fmtstr_up_longlong
, &ll
, 8, wiredata
, 16, NULL
, 0, "up_longlong");
519 *(unsigned int *)wiredata
= 0x20000;
521 *(unsigned int *)wiredata
= (unsigned int)&f
;
522 *(float*)(wiredata
+ 4) = f
;
523 test_pointer_marshal(fmtstr_up_float
, &f
, 4, wiredata
, 8, NULL
, 0, "up_float");
527 *(unsigned int *)wiredata
= 0x20000;
529 *(unsigned int *)wiredata
= (unsigned int)&d
;
530 *(unsigned int *)(wiredata
+ 4) = 0;
531 *(double*)(wiredata
+ 8) = d
;
532 test_pointer_marshal(fmtstr_up_double
, &d
, 8, wiredata
, 16, NULL
, 0, "up_double");
536 static void test_nontrivial_pointer_types(void)
538 RPC_MESSAGE RpcMessage
;
539 MIDL_STUB_MESSAGE StubMsg
;
540 MIDL_STUB_DESC StubDesc
;
545 unsigned char *mem
, *mem_orig
;
547 static const unsigned char fmtstr_ref_unique_out
[] =
549 0x12, 0x8, /* FC_UP [simple_pointer] */
552 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */
553 NdrFcShort( 0xfffffffa ), /* Offset= -6 (0) */
560 StubDesc
= Object_StubDesc
;
561 StubDesc
.pFormatTypes
= fmtstr_ref_unique_out
;
563 NdrClientInitializeNew(
569 StubMsg
.BufferLength
= 0;
570 NdrPointerBufferSize( &StubMsg
,
572 &fmtstr_ref_unique_out
[4] );
574 /* Windows overestimates the buffer size */
575 ok(StubMsg
.BufferLength
>= 5, "length %d\n", StubMsg
.BufferLength
);
577 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
578 StubMsg
.RpcMsg
->Buffer
= StubMsg
.BufferStart
= StubMsg
.Buffer
= HeapAlloc(GetProcessHeap(), 0, StubMsg
.BufferLength
);
579 StubMsg
.BufferEnd
= StubMsg
.BufferStart
+ StubMsg
.BufferLength
;
581 ptr
= NdrPointerMarshall( &StubMsg
, (unsigned char *)p1
, &fmtstr_ref_unique_out
[4] );
582 ok(ptr
== NULL
, "ret %p\n", ptr
);
583 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== 5, "Buffer %p Start %p len %d\n",
584 StubMsg
.Buffer
, StubMsg
.BufferStart
, StubMsg
.Buffer
- StubMsg
.BufferStart
);
585 ok(*(unsigned int *)StubMsg
.BufferStart
!= 0, "pointer ID marshalled incorrectly\n");
586 ok(*(unsigned char *)(StubMsg
.BufferStart
+ 4) == 0x22, "char data marshalled incorrectly: 0x%x\n",
587 *(unsigned char *)(StubMsg
.BufferStart
+ 4));
589 StubMsg
.Buffer
= StubMsg
.BufferStart
;
590 StubMsg
.MemorySize
= 0;
595 StubMsg
.Buffer
= StubMsg
.BufferStart
;
596 mem
= mem_orig
= HeapAlloc(GetProcessHeap(), 0, sizeof(void *));
597 *(void **)mem
= NULL
;
598 NdrPointerUnmarshall( &StubMsg
, &mem
, &fmtstr_ref_unique_out
[4], 0);
599 ok(mem
== mem_orig
, "mem alloced\n");
600 ok(my_alloc_called
== 1, "alloc called %d\n", my_alloc_called
);
603 StubMsg
.Buffer
= StubMsg
.BufferStart
;
604 NdrPointerUnmarshall( &StubMsg
, &mem
, &fmtstr_ref_unique_out
[4], 1);
606 ok(mem
== mem_orig
, "mem alloced\n");
607 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
611 StubMsg
.Buffer
= StubMsg
.BufferStart
;
612 NdrPointerFree( &StubMsg
, mem
, &fmtstr_ref_unique_out
[4] );
613 ok(my_free_called
== 1, "free called %d\n", my_free_called
);
615 mem
= my_alloc(sizeof(void *));
616 *(void **)mem
= NULL
;
618 StubMsg
.Buffer
= StubMsg
.BufferStart
;
619 NdrPointerFree( &StubMsg
, mem
, &fmtstr_ref_unique_out
[4] );
620 ok(my_free_called
== 0, "free called %d\n", my_free_called
);
623 mem
= my_alloc(sizeof(void *));
624 *(void **)mem
= my_alloc(sizeof(char));
626 StubMsg
.Buffer
= StubMsg
.BufferStart
;
627 NdrPointerFree( &StubMsg
, mem
, &fmtstr_ref_unique_out
[4] );
628 ok(my_free_called
== 1, "free called %d\n", my_free_called
);
633 StubMsg
.IsClient
= 0;
635 StubMsg
.Buffer
= StubMsg
.BufferStart
;
636 NdrPointerUnmarshall( &StubMsg
, &mem
, &fmtstr_ref_unique_out
[4], 0);
637 ok(mem
!= StubMsg
.BufferStart
, "mem pointing at buffer\n");
639 ok(my_alloc_called
== 1, "alloc called %d\n", my_alloc_called
);
640 NdrPointerFree( &StubMsg
, mem
, &fmtstr_ref_unique_out
[4] );
644 StubMsg
.Buffer
= StubMsg
.BufferStart
;
645 NdrPointerUnmarshall( &StubMsg
, &mem
, &fmtstr_ref_unique_out
[4], 1);
646 ok(mem
!= StubMsg
.BufferStart
, "mem pointing at buffer\n");
648 ok(my_alloc_called
== 1, "alloc called %d\n", my_alloc_called
);
649 NdrPointerFree( &StubMsg
, mem
, &fmtstr_ref_unique_out
[4] );
653 *(void **)mem
= NULL
;
654 StubMsg
.Buffer
= StubMsg
.BufferStart
;
655 NdrPointerUnmarshall( &StubMsg
, &mem
, &fmtstr_ref_unique_out
[4], 0);
657 ok(mem
== mem_orig
, "mem alloced\n");
658 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
663 *(void **)mem
= NULL
;
664 StubMsg
.Buffer
= StubMsg
.BufferStart
;
665 NdrPointerUnmarshall( &StubMsg
, &mem
, &fmtstr_ref_unique_out
[4], 1);
667 ok(mem
== mem_orig
, "mem alloced\n");
668 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
671 mem
= my_alloc(sizeof(void *));
672 *(void **)mem
= NULL
;
674 StubMsg
.Buffer
= StubMsg
.BufferStart
;
675 NdrPointerFree( &StubMsg
, mem
, &fmtstr_ref_unique_out
[4] );
676 ok(my_free_called
== 0, "free called %d\n", my_free_called
);
679 mem
= my_alloc(sizeof(void *));
680 *(void **)mem
= my_alloc(sizeof(char));
682 StubMsg
.Buffer
= StubMsg
.BufferStart
;
683 NdrPointerFree( &StubMsg
, mem
, &fmtstr_ref_unique_out
[4] );
684 ok(my_free_called
== 1, "free called %d\n", my_free_called
);
687 HeapFree(GetProcessHeap(), 0, mem_orig
);
688 HeapFree(GetProcessHeap(), 0, StubMsg
.RpcMsg
->Buffer
);
691 static void test_simple_struct_marshal(const unsigned char *formattypes
,
694 const void *wiredata
,
696 int(*cmp
)(const void*,const void*,size_t),
697 long num_additional_allocs
,
700 RPC_MESSAGE RpcMessage
;
701 MIDL_STUB_MESSAGE StubMsg
;
702 MIDL_STUB_DESC StubDesc
;
705 unsigned char *mem
, *mem_orig
;
707 my_alloc_called
= my_free_called
= 0;
711 StubDesc
= Object_StubDesc
;
712 StubDesc
.pFormatTypes
= formattypes
;
714 NdrClientInitializeNew(&RpcMessage
, &StubMsg
, &StubDesc
, 0);
716 StubMsg
.BufferLength
= 0;
717 NdrSimpleStructBufferSize( &StubMsg
, (unsigned char *)memsrc
, formattypes
);
718 ok(StubMsg
.BufferLength
>= wiredatalen
, "%s: length %d\n", msgpfx
, StubMsg
.BufferLength
);
719 StubMsg
.RpcMsg
->Buffer
= StubMsg
.BufferStart
= StubMsg
.Buffer
= HeapAlloc(GetProcessHeap(), 0, StubMsg
.BufferLength
);
720 StubMsg
.BufferEnd
= StubMsg
.BufferStart
+ StubMsg
.BufferLength
;
721 ptr
= NdrSimpleStructMarshall( &StubMsg
, (unsigned char*)memsrc
, formattypes
);
722 ok(ptr
== NULL
, "%s: ret %p\n", msgpfx
, ptr
);
723 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== wiredatalen
, "%s: Buffer %p Start %p\n", msgpfx
, StubMsg
.Buffer
, StubMsg
.BufferStart
);
724 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));
728 /* FIXME: Causes Wine to crash */
729 StubMsg
.Buffer
= StubMsg
.BufferStart
;
730 StubMsg
.MemorySize
= 0;
731 size
= NdrSimpleStructMemorySize( &StubMsg
, formattypes
);
732 ok(size
== StubMsg
.MemorySize
, "%s: size != MemorySize\n", msgpfx
);
733 ok(size
== srcsize
, "%s: mem size %u\n", msgpfx
, size
);
734 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== wiredatalen
, "%s: Buffer %p Start %p\n", msgpfx
, StubMsg
.Buffer
, StubMsg
.BufferStart
);
736 StubMsg
.Buffer
= StubMsg
.BufferStart
;
737 size
= NdrSimpleStructMemorySize( &StubMsg
, formattypes
);
739 ok(size
== StubMsg
.MemorySize
, "%s: size != MemorySize\n", msgpfx
);
741 ok(StubMsg
.MemorySize
== ((srcsize
+ 3) & ~3) + srcsize
, "%s: mem size %u\n", msgpfx
, size
);
742 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== wiredatalen
, "%s: Buffer %p Start %p\n", msgpfx
, StubMsg
.Buffer
, StubMsg
.BufferStart
);
745 /*** Unmarshalling first with must_alloc false ***/
747 StubMsg
.Buffer
= StubMsg
.BufferStart
;
748 StubMsg
.MemorySize
= 0;
749 mem_orig
= mem
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, srcsize
);
750 ptr
= NdrSimpleStructUnmarshall( &StubMsg
, &mem
, formattypes
, 0 );
751 ok(ptr
== NULL
, "%s: ret %p\n", msgpfx
, ptr
);
752 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== wiredatalen
, "%s: Buffer %p Start %p\n", msgpfx
, StubMsg
.Buffer
, StubMsg
.BufferStart
);
753 ok(mem
== mem_orig
, "%s: mem has changed %p %p\n", msgpfx
, mem
, mem_orig
);
754 ok(!cmp(mem
, memsrc
, srcsize
), "%s: incorrectly unmarshaled\n", msgpfx
);
755 ok(my_alloc_called
== num_additional_allocs
, "%s: my_alloc got called %d times\n", msgpfx
, my_alloc_called
);
757 ok(StubMsg
.MemorySize
== 0, "%s: memorysize touched in unmarshal\n", msgpfx
);
759 /* If we're a server we still use the supplied memory */
760 StubMsg
.Buffer
= StubMsg
.BufferStart
;
761 StubMsg
.IsClient
= 0;
762 ptr
= NdrSimpleStructUnmarshall( &StubMsg
, &mem
, formattypes
, 0 );
763 ok(ptr
== NULL
, "%s: ret %p\n", msgpfx
, ptr
);
764 ok(mem
== mem_orig
, "%s: mem has changed %p %p\n", msgpfx
, mem
, mem_orig
);
765 ok(!cmp(mem
, memsrc
, srcsize
), "%s: incorrectly unmarshaled\n", msgpfx
);
766 ok(my_alloc_called
== num_additional_allocs
, "%s: my_alloc got called %d times\n", msgpfx
, my_alloc_called
);
768 ok(StubMsg
.MemorySize
== 0, "%s: memorysize touched in unmarshal\n", msgpfx
);
770 /* ...unless we pass a NULL ptr, then the buffer is used.
771 Passing a NULL ptr while we're a client && !must_alloc
772 crashes on Windows, so we won't do that. */
775 StubMsg
.IsClient
= 0;
776 StubMsg
.Buffer
= StubMsg
.BufferStart
;
777 ptr
= NdrSimpleStructUnmarshall( &StubMsg
, &mem
, formattypes
, 0 );
778 ok(ptr
== NULL
, "%s: ret %p\n", msgpfx
, ptr
);
779 ok(mem
== StubMsg
.BufferStart
, "%s: mem not equal buffer\n", msgpfx
);
780 ok(!cmp(mem
, memsrc
, srcsize
), "%s: incorrectly unmarshaled\n", msgpfx
);
781 ok(my_alloc_called
== num_additional_allocs
, "%s: my_alloc got called %d times\n", msgpfx
, my_alloc_called
);
783 ok(StubMsg
.MemorySize
== 0, "%s: memorysize touched in unmarshal\n", msgpfx
);
785 /*** now must_alloc is true ***/
787 /* with must_alloc set we always allocate new memory whether or not we're
788 a server and also when passing NULL */
790 StubMsg
.IsClient
= 1;
791 StubMsg
.Buffer
= StubMsg
.BufferStart
;
792 ptr
= NdrSimpleStructUnmarshall( &StubMsg
, &mem
, formattypes
, 1 );
793 ok(ptr
== NULL
, "ret %p\n", ptr
);
794 ok(mem
!= mem_orig
, "mem not changed %p %p\n", mem
, mem_orig
);
795 ok(!cmp(mem
, memsrc
, srcsize
), "incorrectly unmarshaled\n");
796 ok(my_alloc_called
== num_additional_allocs
+ 1, "%s: my_alloc got called %d times\n", msgpfx
, my_alloc_called
);
798 ok(StubMsg
.MemorySize
== 0, "memorysize touched in unmarshal\n");
801 StubMsg
.Buffer
= StubMsg
.BufferStart
;
802 ptr
= NdrSimpleStructUnmarshall( &StubMsg
, &mem
, formattypes
, 1 );
803 ok(ptr
== NULL
, "ret %p\n", ptr
);
804 ok(mem
!= mem_orig
, "mem not changed %p %p\n", mem
, mem_orig
);
805 ok(!cmp(mem
, memsrc
, srcsize
), "incorrectly unmarshaled\n");
806 ok(my_alloc_called
== num_additional_allocs
+ 1, "%s: my_alloc got called %d times\n", msgpfx
, my_alloc_called
);
808 ok(StubMsg
.MemorySize
== 0, "memorysize touched in unmarshal\n");
811 StubMsg
.Buffer
= StubMsg
.BufferStart
;
812 StubMsg
.IsClient
= 0;
813 StubMsg
.ReuseBuffer
= 1;
814 ptr
= NdrSimpleStructUnmarshall( &StubMsg
, &mem
, formattypes
, 1 );
815 ok(ptr
== NULL
, "ret %p\n", ptr
);
816 ok(mem
!= mem_orig
, "mem not changed %p %p\n", mem
, mem_orig
);
817 ok(mem
!= StubMsg
.BufferStart
, "mem is buffer mem\n");
818 ok(!cmp(mem
, memsrc
, srcsize
), "incorrectly unmarshaled\n");
819 ok(my_alloc_called
== num_additional_allocs
+ 1, "%s: my_alloc got called %d times\n", msgpfx
, my_alloc_called
);
821 ok(StubMsg
.MemorySize
== 0, "memorysize touched in unmarshal\n");
824 StubMsg
.Buffer
= StubMsg
.BufferStart
;
825 StubMsg
.IsClient
= 0;
826 StubMsg
.ReuseBuffer
= 1;
827 ptr
= NdrSimpleStructUnmarshall( &StubMsg
, &mem
, formattypes
, 1 );
828 ok(ptr
== NULL
, "ret %p\n", ptr
);
829 ok(mem
!= StubMsg
.BufferStart
, "mem is buffer mem\n");
830 ok(!cmp(mem
, memsrc
, srcsize
), "incorrectly unmarshaled\n");
831 ok(my_alloc_called
== num_additional_allocs
+ 1, "%s: my_alloc got called %d times\n", msgpfx
, my_alloc_called
);
833 ok(StubMsg
.MemorySize
== 0, "memorysize touched in unmarshal\n");
835 HeapFree(GetProcessHeap(), 0, mem_orig
);
836 HeapFree(GetProcessHeap(), 0, StubMsg
.BufferStart
);
846 static int ps1_cmp(const void *s1
, const void *s2
, size_t num
)
848 const ps1_t
*p1
, *p2
;
856 if(p1
->pl1
&& p2
->pl1
)
858 if(*p1
->pl1
!= *p2
->pl1
)
861 else if(p1
->pl1
|| p1
->pl1
)
864 if(p1
->pc1
&& p2
->pc1
)
866 if(*p1
->pc1
!= *p2
->pc1
)
869 else if(p1
->pc1
|| p1
->pc1
)
875 static void test_simple_struct(void)
877 unsigned char wiredata
[28];
878 unsigned long wiredatalen
;
883 static const unsigned char fmtstr_simple_struct
[] =
885 0x12, 0x0, /* FC_UP */
886 NdrFcShort( 0x2 ), /* Offset=2 */
887 0x15, 0x3, /* FC_STRUCT [align 4] */
888 NdrFcShort( 0x18 ), /* [size 24] */
891 0x38, /* FC_ALIGNM4 */
894 0x39, /* FC_ALIGNM8 */
905 static const unsigned char fmtstr_pointer_struct
[] =
907 0x12, 0x0, /* FC_UP */
908 NdrFcShort( 0x2 ), /* Offset=2 */
909 0x16, 0x3, /* FC_PSTRUCT [align 4] */
910 NdrFcShort( 0xc ), /* [size 12] */
913 0x46, /* FC_NO_REPEAT */
915 NdrFcShort( 0x4 ), /* 4 */
916 NdrFcShort( 0x4 ), /* 4 */
917 0x13, 0x8, /* FC_OP [simple_pointer] */
920 0x46, /* FC_NO_REPEAT */
922 NdrFcShort( 0x8 ), /* 8 */
923 NdrFcShort( 0x8 ), /* 8 */
924 0x13, 0x8, /* FC_OP [simple_pointer] */
936 /* zero the entire structure, including the holes */
937 memset(&s1
, 0, sizeof(s1
));
944 s1
.ll
= ((LONGLONG
) 0xbadefeed << 32) | 0x2468ace0;
947 memcpy(wiredata
, &s1
, wiredatalen
);
948 test_simple_struct_marshal(fmtstr_simple_struct
+ 4, &s1
, 24, wiredata
, 24, NULL
, 0, "struct");
951 *(unsigned int *)wiredata
= 0x20000;
953 *(unsigned int *)wiredata
= (unsigned int)&s1
;
954 memcpy(wiredata
+ 4, &s1
, wiredatalen
);
957 /* one of the unmarshallings crashes Wine */
958 test_pointer_marshal(fmtstr_simple_struct
, &s1
, 24, wiredata
, 28, NULL
, 0, "struct");
961 /* zero the entire structure, including the hole */
962 memset(&ps1
, 0, sizeof(ps1
));
970 *(unsigned int *)(wiredata
+ 4) = 0xdeadbeef;
973 *(unsigned int *)(wiredata
+ 8) = 0x20000;
974 *(unsigned int *)(wiredata
+ 12) = 0x20004;
978 *(unsigned int *)(wiredata
+ 8) = (unsigned int)&l
;
979 *(unsigned int *)(wiredata
+ 12) = (unsigned int)&c
;
981 memcpy(wiredata
+ 16, &l
, 4);
982 memcpy(wiredata
+ 20, &c
, 1);
984 test_simple_struct_marshal(fmtstr_pointer_struct
+ 4, &ps1
, 17, wiredata
+ 4, 17, ps1_cmp
, 2, "pointer_struct");
986 *(unsigned int *)wiredata
= 0x20000;
988 *(unsigned int *)wiredata
= (unsigned int)&ps1
;
991 /* one of the unmarshallings crashes Wine */
992 test_pointer_marshal(fmtstr_pointer_struct
, &ps1
, 17, wiredata
, 21, ps1_cmp
, 2, "pointer_struct");
996 static void test_fullpointer_xlat(void)
998 PFULL_PTR_XLAT_TABLES pXlatTables
;
1003 pXlatTables
= NdrFullPointerXlatInit(2, XLAT_CLIENT
);
1005 /* "marshaling" phase */
1007 ret
= NdrFullPointerQueryPointer(pXlatTables
, (void *)0xcafebeef, 1, &RefId
);
1008 ok(ret
== 0, "ret should be 0 instead of 0x%x\n", ret
);
1009 ok(RefId
== 0x1, "RefId should be 0x1 instead of 0x%x\n", RefId
);
1011 ret
= NdrFullPointerQueryPointer(pXlatTables
, (void *)0xcafebeef, 0, &RefId
);
1012 ok(ret
== 0, "ret should be 0 instead of 0x%x\n", ret
);
1013 ok(RefId
== 0x1, "RefId should be 0x1 instead of 0x%x\n", RefId
);
1015 ret
= NdrFullPointerQueryPointer(pXlatTables
, (void *)0xcafebabe, 0, &RefId
);
1016 ok(ret
== 0, "ret should be 0 instead of 0x%x\n", ret
);
1017 ok(RefId
== 0x2, "RefId should be 0x2 instead of 0x%x\n", RefId
);
1019 ret
= NdrFullPointerQueryPointer(pXlatTables
, (void *)0xdeadbeef, 0, &RefId
);
1020 ok(ret
== 0, "ret should be 0 instead of 0x%x\n", ret
);
1021 ok(RefId
== 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId
);
1023 ret
= NdrFullPointerQueryPointer(pXlatTables
, NULL
, 0, &RefId
);
1024 ok(ret
== 1, "ret should be 1 instead of 0x%x\n", ret
);
1025 ok(RefId
== 0, "RefId should be 0 instead of 0x%x\n", RefId
);
1027 /* "unmarshaling" phase */
1029 ret
= NdrFullPointerQueryRefId(pXlatTables
, 0x2, 0, &Pointer
);
1030 ok(ret
== 0, "ret should be 0 instead of 0x%x\n", ret
);
1031 ok(Pointer
== (void *)0xcafebabe, "Pointer should be 0xcafebabe instead of %p\n", Pointer
);
1033 ret
= NdrFullPointerQueryRefId(pXlatTables
, 0x4, 0, &Pointer
);
1034 ok(ret
== 0, "ret should be 0 instead of 0x%x\n", ret
);
1035 ok(Pointer
== NULL
, "Pointer should be NULL instead of %p\n", Pointer
);
1037 NdrFullPointerInsertRefId(pXlatTables
, 0x4, (void *)0xdeadbabe);
1039 ret
= NdrFullPointerQueryRefId(pXlatTables
, 0x4, 1, &Pointer
);
1040 ok(ret
== 0, "ret should be 0 instead of 0x%x\n", ret
);
1041 ok(Pointer
== (void *)0xdeadbabe, "Pointer should be (void *)0xdeadbabe instead of %p\n", Pointer
);
1043 NdrFullPointerXlatFree(pXlatTables
);
1045 pXlatTables
= NdrFullPointerXlatInit(2, XLAT_SERVER
);
1047 /* "unmarshaling" phase */
1049 ret
= NdrFullPointerQueryRefId(pXlatTables
, 0x2, 1, &Pointer
);
1050 ok(ret
== 0, "ret should be 0 instead of 0x%x\n", ret
);
1051 ok(Pointer
== NULL
, "Pointer should be NULL instead of %p\n", Pointer
);
1053 NdrFullPointerInsertRefId(pXlatTables
, 0x2, (void *)0xcafebabe);
1055 ret
= NdrFullPointerQueryRefId(pXlatTables
, 0x2, 0, &Pointer
);
1056 ok(ret
== 0, "ret should be 0 instead of 0x%x\n", ret
);
1057 ok(Pointer
== (void *)0xcafebabe, "Pointer should be (void *)0xcafebabe instead of %p\n", Pointer
);
1059 ret
= NdrFullPointerQueryRefId(pXlatTables
, 0x2, 1, &Pointer
);
1060 ok(ret
== 1, "ret should be 1 instead of 0x%x\n", ret
);
1061 ok(Pointer
== (void *)0xcafebabe, "Pointer should be (void *)0xcafebabe instead of %p\n", Pointer
);
1063 /* "marshaling" phase */
1065 ret
= NdrFullPointerQueryPointer(pXlatTables
, (void *)0xcafebeef, 1, &RefId
);
1066 ok(ret
== 0, "ret should be 0 instead of 0x%x\n", ret
);
1067 ok(RefId
== 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId
);
1069 ret
= NdrFullPointerQueryPointer(pXlatTables
, (void *)0xcafebeef, 1, &RefId
);
1070 ok(ret
== 1, "ret should be 1 instead of 0x%x\n", ret
);
1071 ok(RefId
== 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId
);
1073 ret
= NdrFullPointerQueryPointer(pXlatTables
, (void *)0xcafebeef, 0, &RefId
);
1074 ok(ret
== 0, "ret should be 0 instead of 0x%x\n", ret
);
1075 ok(RefId
== 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId
);
1077 ret
= NdrFullPointerQueryPointer(pXlatTables
, (void *)0xcafebabe, 0, &RefId
);
1078 ok(ret
== 0, "ret should be 0 instead of 0x%x\n", ret
);
1079 ok(RefId
== 0x2, "RefId should be 0x2 instead of 0x%x\n", RefId
);
1081 ret
= NdrFullPointerQueryPointer(pXlatTables
, (void *)0xdeadbeef, 0, &RefId
);
1082 ok(ret
== 0, "ret should be 0 instead of 0x%x\n", ret
);
1083 ok(RefId
== 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId
);
1085 /* "freeing" phase */
1087 ret
= NdrFullPointerFree(pXlatTables
, (void *)0xcafebeef);
1088 ok(ret
== 1, "ret should be 1 instead of 0x%x\n", ret
);
1090 ret
= NdrFullPointerQueryPointer(pXlatTables
, (void *)0xcafebeef, 0x20, &RefId
);
1091 ok(ret
== 1, "ret should be 1 instead of 0x%x\n", ret
);
1092 ok(RefId
== 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId
);
1094 ret
= NdrFullPointerQueryPointer(pXlatTables
, (void *)0xcafebeef, 1, &RefId
);
1095 ok(ret
== 1, "ret should be 1 instead of 0x%x\n", ret
);
1096 ok(RefId
== 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId
);
1098 ret
= NdrFullPointerFree(pXlatTables
, (void *)0xcafebabe);
1099 ok(ret
== 1, "ret should be 1 instead of 0x%x\n", ret
);
1101 ret
= NdrFullPointerFree(pXlatTables
, (void *)0xdeadbeef);
1102 ok(ret
== 1, "ret should be 1 instead of 0x%x\n", ret
);
1104 ret
= NdrFullPointerQueryPointer(pXlatTables
, (void *)0xdeadbeef, 0x20, &RefId
);
1105 ok(ret
== 1, "ret should be 1 instead of 0x%x\n", ret
);
1106 ok(RefId
== 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId
);
1108 ret
= NdrFullPointerQueryPointer(pXlatTables
, (void *)0xdeadbeef, 1, &RefId
);
1109 ok(ret
== 0, "ret should be 0 instead of 0x%x\n", ret
);
1110 ok(RefId
== 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId
);
1112 ret
= NdrFullPointerQueryPointer(pXlatTables
, (void *)0xdeadbeef, 1, &RefId
);
1113 ok(ret
== 1, "ret should be 1 instead of 0x%x\n", ret
);
1114 ok(RefId
== 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId
);
1116 ret
= NdrFullPointerFree(pXlatTables
, (void *)0xdeadbeef);
1117 ok(ret
== 0, "ret should be 0 instead of 0x%x\n", ret
);
1119 NdrFullPointerXlatFree(pXlatTables
);
1122 static void test_client_init(void)
1124 MIDL_STUB_MESSAGE stubMsg
;
1127 memset(&rpcMsg
, 0xcc, sizeof(rpcMsg
));
1128 memset(&stubMsg
, 0xcc, sizeof(stubMsg
));
1130 NdrClientInitializeNew(&rpcMsg
, &stubMsg
, &Object_StubDesc
, 1);
1132 #define TEST_POINTER_UNSET(field) ok(rpcMsg.field == (void *)0xcccccccc, #field " should have been unset instead of %p\n", rpcMsg.field)
1134 ok(rpcMsg
.Handle
== NULL
, "rpcMsg.Handle should have been NULL instead of %p\n", rpcMsg
.Handle
);
1135 TEST_POINTER_UNSET(Buffer
);
1136 ok(rpcMsg
.BufferLength
== 0xcccccccc, "rpcMsg.BufferLength should have been unset instead of %d\n", rpcMsg
.BufferLength
);
1137 ok(rpcMsg
.ProcNum
== 0x8001, "rpcMsg.ProcNum should have been 0x8001 instead of 0x%x\n", rpcMsg
.ProcNum
);
1138 TEST_POINTER_UNSET(TransferSyntax
);
1139 ok(rpcMsg
.RpcInterfaceInformation
== Object_StubDesc
.RpcInterfaceInformation
,
1140 "rpcMsg.RpcInterfaceInformation should have been %p instead of %p\n",
1141 Object_StubDesc
.RpcInterfaceInformation
, rpcMsg
.RpcInterfaceInformation
);
1142 /* Note: ReservedForRuntime not tested */
1143 TEST_POINTER_UNSET(ManagerEpv
);
1144 TEST_POINTER_UNSET(ImportContext
);
1145 ok(rpcMsg
.RpcFlags
== 0, "rpcMsg.RpcFlags should have been 0 instead of 0x%lx\n", rpcMsg
.RpcFlags
);
1146 #undef TEST_POINTER_UNSET
1148 #define TEST_ZERO(field, fmt) ok(stubMsg.field == 0, #field " should have been set to zero instead of " fmt "\n", stubMsg.field)
1149 #define TEST_POINTER_UNSET(field) ok(stubMsg.field == (void *)0xcccccccc, #field " should have been unset instead of %p\n", stubMsg.field)
1150 #define TEST_ULONG_UNSET(field) ok(stubMsg.field == 0xcccccccc, #field " should have been unset instead of 0x%x\n", stubMsg.field)
1151 #define TEST_ULONG_PTR_UNSET(field) ok(stubMsg.field == 0xcccccccc, #field " should have been unset instead of 0x%lx\n", stubMsg.field)
1153 ok(stubMsg
.RpcMsg
== &rpcMsg
, "stubMsg.RpcMsg should have been %p instead of %p\n", &rpcMsg
, stubMsg
.RpcMsg
);
1154 TEST_POINTER_UNSET(Buffer
);
1155 TEST_ZERO(BufferStart
, "%p");
1156 TEST_ZERO(BufferEnd
, "%p");
1157 TEST_POINTER_UNSET(BufferMark
);
1158 TEST_ZERO(BufferLength
, "%d");
1159 TEST_ULONG_UNSET(MemorySize
);
1160 TEST_POINTER_UNSET(Memory
);
1161 ok(stubMsg
.IsClient
== 1, "stubMsg.IsClient should have been 1 instead of %u\n", stubMsg
.IsClient
);
1162 TEST_ZERO(ReuseBuffer
, "%d");
1163 TEST_ZERO(pAllocAllNodesContext
, "%p");
1164 ok(stubMsg
.pPointerQueueState
== 0 ||
1165 broken(stubMsg
.pPointerQueueState
== (void *)0xcccccccc), /* win2k */
1166 "stubMsg.pPointerQueueState should have been unset instead of %p\n", stubMsg
.pPointerQueueState
);
1167 TEST_ZERO(IgnoreEmbeddedPointers
, "%d");
1168 TEST_ZERO(PointerBufferMark
, "%p");
1169 TEST_ZERO(CorrDespIncrement
, "%d");
1170 TEST_ZERO(uFlags
, "%d");
1171 /* FIXME: UniquePtrCount */
1172 TEST_ULONG_PTR_UNSET(MaxCount
);
1173 TEST_ULONG_UNSET(Offset
);
1174 TEST_ULONG_UNSET(ActualCount
);
1175 ok(stubMsg
.pfnAllocate
== my_alloc
, "stubMsg.pfnAllocate should have been %p instead of %p\n", my_alloc
, stubMsg
.pfnAllocate
);
1176 ok(stubMsg
.pfnFree
== my_free
, "stubMsg.pfnFree should have been %p instead of %p\n", my_free
, stubMsg
.pfnFree
);
1177 TEST_ZERO(StackTop
, "%p");
1178 TEST_POINTER_UNSET(pPresentedType
);
1179 TEST_POINTER_UNSET(pTransmitType
);
1180 TEST_POINTER_UNSET(SavedHandle
);
1181 ok(stubMsg
.StubDesc
== &Object_StubDesc
, "stubMsg.StubDesc should have been %p instead of %p\n", &Object_StubDesc
, stubMsg
.StubDesc
);
1182 TEST_POINTER_UNSET(FullPtrXlatTables
);
1183 TEST_ZERO(FullPtrRefId
, "%d");
1184 TEST_ZERO(PointerLength
, "%d");
1185 TEST_ZERO(fInDontFree
, "%d");
1186 TEST_ZERO(fDontCallFreeInst
, "%d");
1187 ok(stubMsg
.fInOnlyParam
== 0 ||
1188 stubMsg
.fInOnlyParam
== -1, /* Vista */
1189 "fInOnlyParam should have been set to 0 or -1 instead of %d\n", stubMsg
.fInOnlyParam
);
1190 TEST_ZERO(fHasReturn
, "%d");
1191 TEST_ZERO(fHasExtensions
, "%d");
1192 TEST_ZERO(fHasNewCorrDesc
, "%d");
1193 TEST_ZERO(fIsIn
, "%d");
1194 ok(stubMsg
.fIsOut
== 0 ||
1195 stubMsg
.fIsOut
== -1, /* XP-SP3 */
1196 "fIsOut should have been set to 0 or -1 instead of %d\n", stubMsg
.fIsOut
);
1197 TEST_ZERO(fIsOicf
, "%d");
1198 TEST_ZERO(fBufferValid
, "%d");
1199 ok(stubMsg
.fHasMemoryValidateCallback
== 0 ||
1200 stubMsg
.fHasMemoryValidateCallback
== -1, /* XP-SP3 */
1201 "fHasMemoryValidateCallback should have been set to 0 or -1 instead of %d\n", stubMsg
.fHasMemoryValidateCallback
);
1202 ok(stubMsg
.fInFree
== 0 ||
1203 stubMsg
.fInFree
== -1, /* XP-SP3 */
1204 "fInFree should have been set to 0 or -1 instead of %d\n", stubMsg
.fInFree
);
1205 TEST_ZERO(fNeedMCCP
, "%d");
1206 ok(stubMsg
.fUnused
== 0 ||
1207 stubMsg
.fUnused
== -2, /* Vista */
1208 "fUnused should have been set to 0 or -2 instead of %d\n", stubMsg
.fUnused
);
1209 ok(stubMsg
.fUnused2
== 0xffffcccc, "stubMsg.fUnused2 should have been 0xffffcccc instead of 0x%x\n", stubMsg
.fUnused2
);
1210 ok(stubMsg
.dwDestContext
== MSHCTX_DIFFERENTMACHINE
, "stubMsg.dwDestContext should have been MSHCTX_DIFFERENTMACHINE instead of %d\n", stubMsg
.dwDestContext
);
1211 TEST_ZERO(pvDestContext
, "%p");
1212 TEST_POINTER_UNSET(SavedContextHandles
);
1213 TEST_ULONG_UNSET(ParamNumber
);
1214 TEST_ZERO(pRpcChannelBuffer
, "%p");
1215 TEST_ZERO(pArrayInfo
, "%p");
1216 TEST_POINTER_UNSET(SizePtrCountArray
);
1217 TEST_POINTER_UNSET(SizePtrOffsetArray
);
1218 TEST_POINTER_UNSET(SizePtrLengthArray
);
1219 TEST_POINTER_UNSET(pArgQueue
);
1220 TEST_ZERO(dwStubPhase
, "%d");
1221 /* FIXME: where does this value come from? */
1222 trace("LowStackMark is %p\n", stubMsg
.LowStackMark
);
1223 TEST_ZERO(pAsyncMsg
, "%p");
1224 TEST_ZERO(pCorrInfo
, "%p");
1225 TEST_ZERO(pCorrMemory
, "%p");
1226 TEST_ZERO(pMemoryList
, "%p");
1227 TEST_POINTER_UNSET(pCSInfo
);
1228 TEST_POINTER_UNSET(ConformanceMark
);
1229 TEST_POINTER_UNSET(VarianceMark
);
1230 ok(stubMsg
.Unused
== 0xcccccccc, "Unused should have be unset instead of 0x%lx\n", stubMsg
.Unused
);
1231 TEST_POINTER_UNSET(pContext
);
1232 TEST_POINTER_UNSET(ContextHandleHash
);
1233 TEST_POINTER_UNSET(pUserMarshalList
);
1234 TEST_ULONG_PTR_UNSET(Reserved51_3
);
1235 TEST_ULONG_PTR_UNSET(Reserved51_4
);
1236 TEST_ULONG_PTR_UNSET(Reserved51_5
);
1237 #undef TEST_ULONG_UNSET
1238 #undef TEST_POINTER_UNSET
1243 static void test_server_init(void)
1245 MIDL_STUB_MESSAGE stubMsg
;
1248 unsigned char buffer
[256];
1250 memset(&rpcMsg
, 0, sizeof(rpcMsg
));
1251 rpcMsg
.Buffer
= buffer
;
1252 rpcMsg
.BufferLength
= sizeof(buffer
);
1253 rpcMsg
.RpcFlags
= RPC_BUFFER_COMPLETE
;
1255 memset(&stubMsg
, 0xcc, sizeof(stubMsg
));
1257 ret
= NdrServerInitializeNew(&rpcMsg
, &stubMsg
, &Object_StubDesc
);
1258 ok(ret
== NULL
, "NdrServerInitializeNew should have returned NULL instead of %p\n", ret
);
1260 #define TEST_ZERO(field, fmt) ok(stubMsg.field == 0, #field " should have been set to zero instead of " fmt "\n", stubMsg.field)
1261 #define TEST_POINTER_UNSET(field) ok(stubMsg.field == (void *)0xcccccccc, #field " should have been unset instead of %p\n", stubMsg.field)
1262 #define TEST_ULONG_UNSET(field) ok(stubMsg.field == 0xcccccccc, #field " should have been unset instead of 0x%x\n", stubMsg.field)
1263 #define TEST_ULONG_PTR_UNSET(field) ok(stubMsg.field == 0xcccccccc, #field " should have been unset instead of 0x%lx\n", stubMsg.field)
1265 ok(stubMsg
.RpcMsg
== &rpcMsg
, "stubMsg.RpcMsg should have been %p instead of %p\n", &rpcMsg
, stubMsg
.RpcMsg
);
1266 ok(stubMsg
.Buffer
== buffer
, "stubMsg.Buffer should have been %p instead of %p\n", buffer
, stubMsg
.Buffer
);
1267 ok(stubMsg
.BufferStart
== buffer
, "stubMsg.BufferStart should have been %p instead of %p\n", buffer
, stubMsg
.BufferStart
);
1268 ok(stubMsg
.BufferEnd
== buffer
+ sizeof(buffer
), "stubMsg.BufferEnd should have been %p instead of %p\n", buffer
+ sizeof(buffer
), stubMsg
.BufferEnd
);
1269 TEST_POINTER_UNSET(BufferMark
);
1271 TEST_ZERO(BufferLength
, "%d");
1272 TEST_ULONG_UNSET(MemorySize
);
1273 TEST_POINTER_UNSET(Memory
);
1274 ok(stubMsg
.IsClient
== 0, "stubMsg.IsClient should have been 0 instead of %u\n", stubMsg
.IsClient
);
1275 ok(stubMsg
.ReuseBuffer
== 0 ||
1276 broken(stubMsg
.ReuseBuffer
== 1), /* win2k */
1277 "stubMsg.ReuseBuffer should have been set to zero instead of %d\n", stubMsg
.ReuseBuffer
);
1278 TEST_ZERO(pAllocAllNodesContext
, "%p");
1279 ok(stubMsg
.pPointerQueueState
== 0 ||
1280 broken(stubMsg
.pPointerQueueState
== (void *)0xcccccccc), /* win2k */
1281 "stubMsg.pPointerQueueState should have been unset instead of %p\n", stubMsg
.pPointerQueueState
);
1282 TEST_ZERO(IgnoreEmbeddedPointers
, "%d");
1283 TEST_ZERO(PointerBufferMark
, "%p");
1284 ok(stubMsg
.CorrDespIncrement
== 0xcc ||
1285 stubMsg
.CorrDespIncrement
== 0,
1286 "CorrDespIncrement should have been unset instead of 0x%x\n", stubMsg
.CorrDespIncrement
);
1287 TEST_ZERO(uFlags
, "%d");
1288 /* FIXME: UniquePtrCount */
1289 TEST_ULONG_PTR_UNSET(MaxCount
);
1290 TEST_ULONG_UNSET(Offset
);
1291 TEST_ULONG_UNSET(ActualCount
);
1292 ok(stubMsg
.pfnAllocate
== my_alloc
, "stubMsg.pfnAllocate should have been %p instead of %p\n", my_alloc
, stubMsg
.pfnAllocate
);
1293 ok(stubMsg
.pfnFree
== my_free
, "stubMsg.pfnFree should have been %p instead of %p\n", my_free
, stubMsg
.pfnFree
);
1294 TEST_ZERO(StackTop
, "%p");
1295 TEST_POINTER_UNSET(pPresentedType
);
1296 TEST_POINTER_UNSET(pTransmitType
);
1297 TEST_POINTER_UNSET(SavedHandle
);
1298 ok(stubMsg
.StubDesc
== &Object_StubDesc
, "stubMsg.StubDesc should have been %p instead of %p\n", &Object_StubDesc
, stubMsg
.StubDesc
);
1299 TEST_ZERO(FullPtrXlatTables
, "%p");
1300 TEST_ZERO(FullPtrRefId
, "%d");
1301 TEST_ZERO(PointerLength
, "%d");
1302 TEST_ZERO(fInDontFree
, "%d");
1303 TEST_ZERO(fDontCallFreeInst
, "%d");
1304 ok(stubMsg
.fInOnlyParam
== 0 ||
1305 stubMsg
.fInOnlyParam
== -1, /* Vista */
1306 "fInOnlyParam should have been set to 0 or -1 instead of %d\n", stubMsg
.fInOnlyParam
);
1307 TEST_ZERO(fHasReturn
, "%d");
1308 TEST_ZERO(fHasExtensions
, "%d");
1309 TEST_ZERO(fHasNewCorrDesc
, "%d");
1310 TEST_ZERO(fIsIn
, "%d");
1311 ok(stubMsg
.fIsOut
== 0 ||
1312 stubMsg
.fIsOut
== -1, /* XP-SP3 */
1313 "fIsOut should have been set to 0 or -1 instead of %d\n", stubMsg
.fIsOut
);
1314 TEST_ZERO(fIsOicf
, "%d");
1315 trace("fBufferValid = %d\n", stubMsg
.fBufferValid
);
1316 ok(stubMsg
.fHasMemoryValidateCallback
== 0 ||
1317 stubMsg
.fHasMemoryValidateCallback
== -1, /* XP-SP3 */
1318 "fHasMemoryValidateCallback should have been set to 0 or -1 instead of %d\n", stubMsg
.fHasMemoryValidateCallback
);
1319 ok(stubMsg
.fInFree
== 0 ||
1320 stubMsg
.fInFree
== -1, /* XP-SP3 */
1321 "fInFree should have been set to 0 or -1 instead of %d\n", stubMsg
.fInFree
);
1322 TEST_ZERO(fNeedMCCP
, "%d");
1323 ok(stubMsg
.fUnused
== 0 ||
1324 stubMsg
.fUnused
== -2, /* Vista */
1325 "fUnused should have been set to 0 or -2 instead of %d\n", stubMsg
.fUnused
);
1326 ok(stubMsg
.fUnused2
== 0xffffcccc, "stubMsg.fUnused2 should have been 0xffffcccc instead of 0x%x\n", stubMsg
.fUnused2
);
1327 ok(stubMsg
.dwDestContext
== MSHCTX_DIFFERENTMACHINE
, "stubMsg.dwDestContext should have been MSHCTX_DIFFERENTMACHINE instead of %d\n", stubMsg
.dwDestContext
);
1328 TEST_ZERO(pvDestContext
, "%p");
1329 TEST_POINTER_UNSET(SavedContextHandles
);
1330 TEST_ULONG_UNSET(ParamNumber
);
1331 TEST_ZERO(pRpcChannelBuffer
, "%p");
1332 TEST_ZERO(pArrayInfo
, "%p");
1333 TEST_POINTER_UNSET(SizePtrCountArray
);
1334 TEST_POINTER_UNSET(SizePtrOffsetArray
);
1335 TEST_POINTER_UNSET(SizePtrLengthArray
);
1336 TEST_POINTER_UNSET(pArgQueue
);
1337 TEST_ZERO(dwStubPhase
, "%d");
1338 /* FIXME: where does this value come from? */
1339 trace("LowStackMark is %p\n", stubMsg
.LowStackMark
);
1340 TEST_ZERO(pAsyncMsg
, "%p");
1341 TEST_ZERO(pCorrInfo
, "%p");
1342 TEST_ZERO(pCorrMemory
, "%p");
1343 TEST_ZERO(pMemoryList
, "%p");
1344 TEST_POINTER_UNSET(pCSInfo
);
1345 TEST_POINTER_UNSET(ConformanceMark
);
1346 TEST_POINTER_UNSET(VarianceMark
);
1347 ok(stubMsg
.Unused
== 0xcccccccc, "Unused should have be unset instead of 0x%lx\n", stubMsg
.Unused
);
1348 TEST_POINTER_UNSET(pContext
);
1349 TEST_POINTER_UNSET(ContextHandleHash
);
1350 TEST_POINTER_UNSET(pUserMarshalList
);
1351 TEST_ULONG_PTR_UNSET(Reserved51_3
);
1352 TEST_ULONG_PTR_UNSET(Reserved51_4
);
1353 TEST_ULONG_PTR_UNSET(Reserved51_5
);
1354 #undef TEST_ULONG_UNSET
1355 #undef TEST_POINTER_UNSET
1360 static void test_ndr_allocate(void)
1362 RPC_MESSAGE RpcMessage
;
1363 MIDL_STUB_MESSAGE StubMsg
;
1364 MIDL_STUB_DESC StubDesc
;
1366 struct tag_mem_list_v1_t
1370 struct tag_mem_list_v1_t
*next
;
1372 struct tag_mem_list_v2_t
1377 struct tag_mem_list_v2_t
*next
;
1379 const DWORD magic_MEML
= 'M' << 24 | 'E' << 16 | 'M' << 8 | 'L';
1381 StubDesc
= Object_StubDesc
;
1382 NdrClientInitializeNew(&RpcMessage
, &StubMsg
, &StubDesc
, 0);
1384 ok(StubMsg
.pMemoryList
== NULL
, "memlist %p\n", StubMsg
.pMemoryList
);
1385 my_alloc_called
= my_free_called
= 0;
1386 p1
= NdrAllocate(&StubMsg
, 10);
1387 p2
= NdrAllocate(&StubMsg
, 24);
1388 ok(my_alloc_called
== 2, "alloc called %d\n", my_alloc_called
);
1389 ok(StubMsg
.pMemoryList
!= NULL
, "StubMsg.pMemoryList NULL\n");
1390 if(StubMsg
.pMemoryList
)
1392 mem_list_v2
= StubMsg
.pMemoryList
;
1393 if (mem_list_v2
->size
== 24)
1395 trace("v2 mem list format\n");
1396 ok((char *)mem_list_v2
== (char *)p2
+ 24, "expected mem_list_v2 pointer %p, but got %p\n", (char *)p2
+ 24, mem_list_v2
);
1397 ok(mem_list_v2
->magic
== magic_MEML
, "magic %08x\n", mem_list_v2
->magic
);
1398 ok(mem_list_v2
->size
== 24, "wrong size for p2 %d\n", mem_list_v2
->size
);
1399 ok(mem_list_v2
->unknown
== 0, "wrong unknown for p2 0x%x\n", mem_list_v2
->unknown
);
1400 ok(mem_list_v2
->next
!= NULL
, "next NULL\n");
1401 mem_list_v2
= mem_list_v2
->next
;
1404 ok((char *)mem_list_v2
== (char *)p1
+ 16, "expected mem_list_v2 pointer %p, but got %p\n", (char *)p1
+ 16, mem_list_v2
);
1405 ok(mem_list_v2
->magic
== magic_MEML
, "magic %08x\n", mem_list_v2
->magic
);
1406 ok(mem_list_v2
->size
== 16, "wrong size for p1 %d\n", mem_list_v2
->size
);
1407 ok(mem_list_v2
->unknown
== 0, "wrong unknown for p1 0x%x\n", mem_list_v2
->unknown
);
1408 ok(mem_list_v2
->next
== NULL
, "next %p\n", mem_list_v2
->next
);
1413 trace("v1 mem list format\n");
1414 mem_list_v1
= StubMsg
.pMemoryList
;
1415 ok(mem_list_v1
->magic
== magic_MEML
, "magic %08x\n", mem_list_v1
->magic
);
1416 ok(mem_list_v1
->ptr
== p2
, "ptr != p2\n");
1417 ok(mem_list_v1
->next
!= NULL
, "next NULL\n");
1418 mem_list_v1
= mem_list_v1
->next
;
1421 ok(mem_list_v1
->magic
== magic_MEML
, "magic %08x\n", mem_list_v1
->magic
);
1422 ok(mem_list_v1
->ptr
== p1
, "ptr != p1\n");
1423 ok(mem_list_v1
->next
== NULL
, "next %p\n", mem_list_v1
->next
);
1427 /* NdrFree isn't exported so we can't test free'ing */
1430 static void test_conformant_array(void)
1432 RPC_MESSAGE RpcMessage
;
1433 MIDL_STUB_MESSAGE StubMsg
;
1434 MIDL_STUB_DESC StubDesc
;
1436 unsigned char *mem
, *mem_orig
;
1437 unsigned char memsrc
[20];
1440 static const unsigned char fmtstr_conf_array
[] =
1442 0x1b, /* FC_CARRAY */
1444 NdrFcShort( 0x1 ), /* elem size */
1445 0x40, /* Corr desc: const */
1447 NdrFcShort(0x10), /* const = 0x10 */
1452 for (i
= 0; i
< sizeof(memsrc
); i
++)
1455 StubDesc
= Object_StubDesc
;
1456 StubDesc
.pFormatTypes
= fmtstr_conf_array
;
1458 NdrClientInitializeNew(
1464 StubMsg
.BufferLength
= 0;
1465 NdrConformantArrayBufferSize( &StubMsg
,
1467 fmtstr_conf_array
);
1468 ok(StubMsg
.BufferLength
>= 20, "length %d\n", StubMsg
.BufferLength
);
1470 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1471 StubMsg
.RpcMsg
->Buffer
= StubMsg
.BufferStart
= StubMsg
.Buffer
= HeapAlloc(GetProcessHeap(), 0, StubMsg
.BufferLength
);
1472 StubMsg
.BufferEnd
= StubMsg
.BufferStart
+ StubMsg
.BufferLength
;
1474 ptr
= NdrConformantArrayMarshall( &StubMsg
, memsrc
, fmtstr_conf_array
);
1475 ok(ptr
== NULL
, "ret %p\n", ptr
);
1476 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== 20, "Buffer %p Start %p len %d\n", StubMsg
.Buffer
, StubMsg
.BufferStart
, 20);
1477 ok(!memcmp(StubMsg
.BufferStart
+ 4, memsrc
, 16), "incorrectly marshaled\n");
1479 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1480 StubMsg
.MemorySize
= 0;
1484 my_alloc_called
= 0;
1485 /* passing mem == NULL with must_alloc == 0 crashes under Windows */
1486 NdrConformantArrayUnmarshall( &StubMsg
, &mem
, fmtstr_conf_array
, 1);
1487 ok(mem
!= NULL
, "mem not alloced\n");
1488 ok(mem
!= StubMsg
.BufferStart
+ 4, "mem pointing at buffer\n");
1489 ok(my_alloc_called
== 1, "alloc called %d\n", my_alloc_called
);
1491 my_alloc_called
= 0;
1492 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1494 NdrConformantArrayUnmarshall( &StubMsg
, &mem
, fmtstr_conf_array
, 0);
1495 ok(mem
== mem_orig
, "mem alloced\n");
1496 ok(mem
!= StubMsg
.BufferStart
+ 4, "mem pointing at buffer\n");
1497 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1499 my_alloc_called
= 0;
1500 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1501 NdrConformantArrayUnmarshall( &StubMsg
, &mem
, fmtstr_conf_array
, 1);
1502 ok(mem
!= mem_orig
, "mem not alloced\n");
1503 ok(mem
!= StubMsg
.BufferStart
+ 4, "mem pointing at buffer\n");
1504 ok(my_alloc_called
== 1, "alloc called %d\n", my_alloc_called
);
1507 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1508 NdrConformantArrayFree( &StubMsg
, mem
, fmtstr_conf_array
);
1509 ok(my_free_called
== 0, "free called %d\n", my_free_called
);
1510 StubMsg
.pfnFree(mem
);
1513 my_alloc_called
= 0;
1514 StubMsg
.IsClient
= 0;
1516 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1517 NdrConformantArrayUnmarshall( &StubMsg
, &mem
, fmtstr_conf_array
, 0);
1518 ok(mem
== StubMsg
.BufferStart
+ 4, "mem not pointing at buffer\n");
1519 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1520 my_alloc_called
= 0;
1522 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1523 NdrConformantArrayUnmarshall( &StubMsg
, &mem
, fmtstr_conf_array
, 1);
1524 ok(mem
!= StubMsg
.BufferStart
+ 4, "mem pointing at buffer\n");
1525 ok(my_alloc_called
== 1, "alloc called %d\n", my_alloc_called
);
1526 StubMsg
.pfnFree(mem
);
1528 my_alloc_called
= 0;
1530 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1531 NdrConformantArrayUnmarshall( &StubMsg
, &mem
, fmtstr_conf_array
, 0);
1532 ok(mem
== mem_orig
, "mem alloced\n");
1533 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1535 my_alloc_called
= 0;
1537 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1538 NdrConformantArrayUnmarshall( &StubMsg
, &mem
, fmtstr_conf_array
, 1);
1539 ok(mem
!= StubMsg
.BufferStart
+ 4, "mem pointing at buffer\n");
1540 ok(my_alloc_called
== 1, "alloc called %d\n", my_alloc_called
);
1541 StubMsg
.pfnFree(mem
);
1542 StubMsg
.pfnFree(mem_orig
);
1544 HeapFree(GetProcessHeap(), 0, StubMsg
.RpcMsg
->Buffer
);
1547 static void test_conformant_string(void)
1549 RPC_MESSAGE RpcMessage
;
1550 MIDL_STUB_MESSAGE StubMsg
;
1551 MIDL_STUB_DESC StubDesc
;
1553 unsigned char *mem
, *mem_orig
;
1554 char memsrc
[] = "This is a test string";
1556 static const unsigned char fmtstr_conf_str
[] =
1558 0x11, 0x8, /* FC_RP [simple_pointer] */
1559 0x22, /* FC_C_CSTRING */
1563 StubDesc
= Object_StubDesc
;
1564 StubDesc
.pFormatTypes
= fmtstr_conf_str
;
1566 NdrClientInitializeNew(
1572 StubMsg
.BufferLength
= 0;
1573 NdrPointerBufferSize( &StubMsg
,
1574 (unsigned char *)memsrc
,
1576 ok(StubMsg
.BufferLength
>= sizeof(memsrc
) + 12, "length %d\n", StubMsg
.BufferLength
);
1578 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1579 StubMsg
.RpcMsg
->Buffer
= StubMsg
.BufferStart
= StubMsg
.Buffer
= HeapAlloc(GetProcessHeap(), 0, StubMsg
.BufferLength
);
1580 StubMsg
.BufferEnd
= StubMsg
.BufferStart
+ StubMsg
.BufferLength
;
1582 ptr
= NdrPointerMarshall( &StubMsg
, (unsigned char *)memsrc
, fmtstr_conf_str
);
1583 ok(ptr
== NULL
, "ret %p\n", ptr
);
1584 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== sizeof(memsrc
) + 12, "Buffer %p Start %p len %d\n",
1585 StubMsg
.Buffer
, StubMsg
.BufferStart
, StubMsg
.Buffer
- StubMsg
.BufferStart
);
1586 ok(!memcmp(StubMsg
.BufferStart
+ 12, memsrc
, sizeof(memsrc
)), "incorrectly marshaled\n");
1588 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1589 StubMsg
.MemorySize
= 0;
1593 my_alloc_called
= 0;
1594 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1595 mem
= mem_orig
= HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc
));
1596 NdrPointerUnmarshall( &StubMsg
, &mem
, fmtstr_conf_str
, 0);
1597 ok(mem
== mem_orig
, "mem not alloced\n");
1598 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1600 my_alloc_called
= 0;
1601 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1602 NdrPointerUnmarshall( &StubMsg
, &mem
, fmtstr_conf_str
, 1);
1604 ok(mem
== mem_orig
, "mem not alloced\n");
1605 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1609 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1610 NdrPointerFree( &StubMsg
, mem
, fmtstr_conf_str
);
1611 ok(my_free_called
== 1, "free called %d\n", my_free_called
);
1615 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1616 NdrPointerFree( &StubMsg
, mem
, fmtstr_conf_str
);
1617 ok(my_free_called
== 1, "free called %d\n", my_free_called
);
1620 my_alloc_called
= 0;
1621 StubMsg
.IsClient
= 0;
1623 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1624 NdrPointerUnmarshall( &StubMsg
, &mem
, fmtstr_conf_str
, 0);
1625 ok(mem
== StubMsg
.BufferStart
+ 12, "mem not pointing at buffer\n");
1626 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1628 my_alloc_called
= 0;
1630 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1631 NdrPointerUnmarshall( &StubMsg
, &mem
, fmtstr_conf_str
, 1);
1633 ok(mem
== StubMsg
.BufferStart
+ 12, "mem not pointing at buffer\n");
1634 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1637 my_alloc_called
= 0;
1639 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1640 NdrPointerUnmarshall( &StubMsg
, &mem
, fmtstr_conf_str
, 0);
1641 ok(mem
== StubMsg
.BufferStart
+ 12, "mem not pointing at buffer\n");
1642 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1644 my_alloc_called
= 0;
1646 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1647 NdrPointerUnmarshall( &StubMsg
, &mem
, fmtstr_conf_str
, 1);
1649 ok(mem
== StubMsg
.BufferStart
+ 12, "mem not pointing at buffer\n");
1650 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1655 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1656 NdrPointerFree( &StubMsg
, mem
, fmtstr_conf_str
);
1657 ok(my_free_called
== 1, "free called %d\n", my_free_called
);
1659 HeapFree(GetProcessHeap(), 0, mem_orig
);
1660 HeapFree(GetProcessHeap(), 0, StubMsg
.RpcMsg
->Buffer
);
1663 static void test_nonconformant_string(void)
1665 RPC_MESSAGE RpcMessage
;
1666 MIDL_STUB_MESSAGE StubMsg
;
1667 MIDL_STUB_DESC StubDesc
;
1669 unsigned char *mem
, *mem_orig
;
1670 unsigned char memsrc
[10] = "This is";
1671 unsigned char memsrc2
[10] = "This is a";
1673 static const unsigned char fmtstr_nonconf_str
[] =
1675 0x26, /* FC_CSTRING */
1677 NdrFcShort( 0xa ), /* 10 */
1680 StubDesc
= Object_StubDesc
;
1681 StubDesc
.pFormatTypes
= fmtstr_nonconf_str
;
1684 NdrClientInitializeNew(
1690 StubMsg
.BufferLength
= 0;
1692 NdrNonConformantStringBufferSize( &StubMsg
,
1693 (unsigned char *)memsrc
,
1694 fmtstr_nonconf_str
);
1695 ok(StubMsg
.BufferLength
>= strlen((char *)memsrc
) + 1 + 8, "length %d\n", StubMsg
.BufferLength
);
1697 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1698 StubMsg
.RpcMsg
->Buffer
= StubMsg
.BufferStart
= StubMsg
.Buffer
= HeapAlloc(GetProcessHeap(), 0, StubMsg
.BufferLength
);
1699 StubMsg
.BufferEnd
= StubMsg
.BufferStart
+ StubMsg
.BufferLength
;
1701 ptr
= NdrNonConformantStringMarshall( &StubMsg
, (unsigned char *)memsrc
, fmtstr_nonconf_str
);
1702 ok(ptr
== NULL
, "ret %p\n", ptr
);
1703 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== strlen((char *)memsrc
) + 1 + 8, "Buffer %p Start %p len %d\n",
1704 StubMsg
.Buffer
, StubMsg
.BufferStart
, StubMsg
.Buffer
- StubMsg
.BufferStart
);
1705 ok(!memcmp(StubMsg
.BufferStart
+ 8, memsrc
, strlen((char *)memsrc
) + 1), "incorrectly marshaled\n");
1707 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1708 StubMsg
.MemorySize
= 0;
1712 my_alloc_called
= 0;
1713 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1714 mem
= mem_orig
= HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc
));
1715 NdrNonConformantStringUnmarshall( &StubMsg
, &mem
, fmtstr_nonconf_str
, 0);
1716 ok(mem
== mem_orig
, "mem alloced\n");
1717 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1719 my_alloc_called
= 0;
1720 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1721 NdrNonConformantStringUnmarshall( &StubMsg
, &mem
, fmtstr_nonconf_str
, 1);
1723 ok(mem
== mem_orig
, "mem alloced\n");
1725 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1728 my_alloc_called
= 0;
1729 StubMsg
.IsClient
= 0;
1731 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1732 NdrNonConformantStringUnmarshall( &StubMsg
, &mem
, fmtstr_nonconf_str
, 0);
1733 ok(mem
!= mem_orig
, "mem not alloced\n");
1734 ok(mem
!= StubMsg
.BufferStart
+ 8, "mem pointing at buffer\n");
1735 ok(my_alloc_called
== 1, "alloc called %d\n", my_alloc_called
);
1738 my_alloc_called
= 0;
1740 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1741 NdrNonConformantStringUnmarshall( &StubMsg
, &mem
, fmtstr_nonconf_str
, 0);
1742 ok(mem
== mem_orig
, "mem alloced\n");
1743 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1745 my_alloc_called
= 0;
1747 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1748 NdrNonConformantStringUnmarshall( &StubMsg
, &mem
, fmtstr_nonconf_str
, 1);
1750 ok(mem
== mem_orig
, "mem alloced\n");
1752 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1754 HeapFree(GetProcessHeap(), 0, mem_orig
);
1755 HeapFree(GetProcessHeap(), 0, StubMsg
.RpcMsg
->Buffer
);
1758 NdrClientInitializeNew(
1764 StubMsg
.BufferLength
= 0;
1766 NdrNonConformantStringBufferSize( &StubMsg
,
1767 (unsigned char *)memsrc2
,
1768 fmtstr_nonconf_str
);
1769 ok(StubMsg
.BufferLength
>= strlen((char *)memsrc2
) + 1 + 8, "length %d\n", StubMsg
.BufferLength
);
1771 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1772 StubMsg
.RpcMsg
->Buffer
= StubMsg
.BufferStart
= StubMsg
.Buffer
= HeapAlloc(GetProcessHeap(), 0, StubMsg
.BufferLength
);
1773 StubMsg
.BufferEnd
= StubMsg
.BufferStart
+ StubMsg
.BufferLength
;
1775 ptr
= NdrNonConformantStringMarshall( &StubMsg
, (unsigned char *)memsrc2
, fmtstr_nonconf_str
);
1776 ok(ptr
== NULL
, "ret %p\n", ptr
);
1777 ok(StubMsg
.Buffer
- StubMsg
.BufferStart
== strlen((char *)memsrc2
) + 1 + 8, "Buffer %p Start %p len %d\n",
1778 StubMsg
.Buffer
, StubMsg
.BufferStart
, StubMsg
.Buffer
- StubMsg
.BufferStart
);
1779 ok(!memcmp(StubMsg
.BufferStart
+ 8, memsrc2
, strlen((char *)memsrc2
) + 1), "incorrectly marshaled\n");
1781 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1782 StubMsg
.MemorySize
= 0;
1786 my_alloc_called
= 0;
1787 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1788 mem
= mem_orig
= HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc
));
1789 NdrNonConformantStringUnmarshall( &StubMsg
, &mem
, fmtstr_nonconf_str
, 0);
1790 ok(mem
== mem_orig
, "mem alloced\n");
1791 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1793 my_alloc_called
= 0;
1794 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1795 NdrNonConformantStringUnmarshall( &StubMsg
, &mem
, fmtstr_nonconf_str
, 1);
1797 ok(mem
== mem_orig
, "mem alloced\n");
1799 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1802 my_alloc_called
= 0;
1803 StubMsg
.IsClient
= 0;
1805 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1806 NdrNonConformantStringUnmarshall( &StubMsg
, &mem
, fmtstr_nonconf_str
, 0);
1807 ok(mem
!= mem_orig
, "mem not alloced\n");
1808 ok(mem
!= StubMsg
.BufferStart
+ 8, "mem pointing at buffer\n");
1809 ok(my_alloc_called
== 1, "alloc called %d\n", my_alloc_called
);
1812 my_alloc_called
= 0;
1814 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1815 NdrNonConformantStringUnmarshall( &StubMsg
, &mem
, fmtstr_nonconf_str
, 0);
1816 ok(mem
== mem_orig
, "mem alloced\n");
1817 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1819 my_alloc_called
= 0;
1821 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1822 NdrNonConformantStringUnmarshall( &StubMsg
, &mem
, fmtstr_nonconf_str
, 1);
1824 ok(mem
== mem_orig
, "mem alloced\n");
1826 ok(my_alloc_called
== 0, "alloc called %d\n", my_alloc_called
);
1828 HeapFree(GetProcessHeap(), 0, mem_orig
);
1829 HeapFree(GetProcessHeap(), 0, StubMsg
.RpcMsg
->Buffer
);
1832 static void test_conf_complex_struct(void)
1834 RPC_MESSAGE RpcMessage
;
1835 MIDL_STUB_MESSAGE StubMsg
;
1836 MIDL_STUB_DESC StubDesc
;
1842 unsigned int *array
[1];
1844 struct conf_complex
*memsrc
;
1845 struct conf_complex
*mem
;
1847 static const unsigned char fmtstr_complex_struct
[] =
1850 0x1b, /* FC_CARRAY */
1852 /* 2 */ NdrFcShort( 0x4 ), /* 4 */
1853 /* 4 */ 0x8, /* Corr desc: FC_LONG */
1855 /* 6 */ NdrFcShort( 0xfffc ), /* -4 */
1860 0x48, /* FC_VARIABLE_REPEAT */
1861 0x49, /* FC_FIXED_OFFSET */
1862 /* 12 */ NdrFcShort( 0x4 ), /* 4 */
1863 /* 14 */ NdrFcShort( 0x0 ), /* 0 */
1864 /* 16 */ NdrFcShort( 0x1 ), /* 1 */
1865 /* 18 */ NdrFcShort( 0x0 ), /* 0 */
1866 /* 20 */ NdrFcShort( 0x0 ), /* 0 */
1867 /* 22 */ 0x12, 0x8, /* FC_UP [simple_pointer] */
1868 /* 24 */ 0x8, /* FC_LONG */
1874 /* 28 */ 0x5c, /* FC_PAD */
1877 0x1a, /* FC_BOGUS_STRUCT */
1879 /* 32 */ NdrFcShort( 0x4 ), /* 4 */
1880 /* 34 */ NdrFcShort( 0xffffffde ), /* Offset= -34 (0) */
1881 /* 36 */ NdrFcShort( 0x0 ), /* Offset= 0 (36) */
1882 /* 38 */ 0x8, /* FC_LONG */
1886 memsrc
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
1887 FIELD_OFFSET(struct conf_complex
, array
[20]));
1890 StubDesc
= Object_StubDesc
;
1891 StubDesc
.pFormatTypes
= fmtstr_complex_struct
;
1893 NdrClientInitializeNew(
1899 StubMsg
.BufferLength
= 0;
1900 NdrComplexStructBufferSize( &StubMsg
,
1901 (unsigned char *)memsrc
,
1902 &fmtstr_complex_struct
[30] );
1903 ok(StubMsg
.BufferLength
>= 28, "length %d\n", StubMsg
.BufferLength
);
1905 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1906 StubMsg
.RpcMsg
->Buffer
= StubMsg
.BufferStart
= StubMsg
.Buffer
= HeapAlloc(GetProcessHeap(), 0, StubMsg
.BufferLength
);
1907 StubMsg
.BufferEnd
= StubMsg
.BufferStart
+ StubMsg
.BufferLength
;
1909 ptr
= NdrComplexStructMarshall( &StubMsg
, (unsigned char *)memsrc
,
1910 &fmtstr_complex_struct
[30] );
1911 ok(ptr
== NULL
, "ret %p\n", ptr
);
1912 ok(*(unsigned int *)StubMsg
.BufferStart
== 20, "Conformance should have been 20 instead of %d\n", (unsigned int)StubMsg
.BufferStart
);
1913 ok(*(unsigned int *)(StubMsg
.BufferStart
+ 4) == 20, "conf_complex.size should have been 20 instead of %d\n", (unsigned int)(StubMsg
.BufferStart
+ 4));
1914 for (i
= 0; i
< 20; i
++)
1915 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));
1918 my_alloc_called
= 0;
1919 StubMsg
.IsClient
= 0;
1921 StubMsg
.Buffer
= StubMsg
.BufferStart
;
1922 ptr
= NdrComplexStructUnmarshall( &StubMsg
, (unsigned char **)&mem
, &fmtstr_complex_struct
[30], 0);
1923 ok(ptr
== NULL
, "ret %p\n", ptr
);
1924 ok(mem
->size
== 20, "mem->size wasn't unmarshalled correctly (%d)\n", mem
->size
);
1925 ok(mem
->array
[0] == NULL
, "mem->array[0] wasn't unmarshalled correctly (%p)\n", mem
->array
[0]);
1926 StubMsg
.pfnFree(mem
);
1928 HeapFree(GetProcessHeap(), 0, StubMsg
.RpcMsg
->Buffer
);
1931 static void test_ndr_buffer(void)
1933 static unsigned char ncalrpc
[] = "ncalrpc";
1934 static unsigned char endpoint
[] = "winetest:test_ndr_buffer";
1935 RPC_MESSAGE RpcMessage
;
1936 MIDL_STUB_MESSAGE StubMsg
;
1937 MIDL_STUB_DESC StubDesc
= Object_StubDesc
;
1939 unsigned char *binding
;
1940 RPC_BINDING_HANDLE Handle
;
1942 ULONG prev_buffer_length
;
1943 BOOL old_buffer_valid_location
;
1945 StubDesc
.RpcInterfaceInformation
= (void *)&IFoo___RpcServerInterface
;
1947 status
= RpcServerUseProtseqEp(ncalrpc
, 20, endpoint
, NULL
);
1948 ok(RPC_S_OK
== status
, "RpcServerUseProtseqEp failed with status %u\n", status
);
1949 status
= RpcServerRegisterIf(IFoo_v0_0_s_ifspec
, NULL
, NULL
);
1950 ok(RPC_S_OK
== status
, "RpcServerRegisterIf failed with status %u\n", status
);
1951 status
= RpcServerListen(1, 20, TRUE
);
1952 ok(RPC_S_OK
== status
, "RpcServerListen failed with status %u\n", status
);
1953 if (status
!= RPC_S_OK
)
1955 /* Failed to create a server, running client tests is useless */
1959 status
= RpcStringBindingCompose(NULL
, ncalrpc
, NULL
, endpoint
, NULL
, &binding
);
1960 ok(status
== RPC_S_OK
, "RpcStringBindingCompose failed (%u)\n", status
);
1962 status
= RpcBindingFromStringBinding(binding
, &Handle
);
1963 ok(status
== RPC_S_OK
, "RpcBindingFromStringBinding failed (%u)\n", status
);
1964 RpcStringFree(&binding
);
1966 NdrClientInitializeNew(&RpcMessage
, &StubMsg
, &StubDesc
, 5);
1968 ret
= NdrGetBuffer(&StubMsg
, 10, Handle
);
1969 ok(ret
== StubMsg
.Buffer
, "NdrGetBuffer should have returned the same value as StubMsg.Buffer instead of %p\n", ret
);
1970 ok(RpcMessage
.Handle
!= NULL
, "RpcMessage.Handle should not have been NULL\n");
1971 ok(RpcMessage
.Buffer
!= NULL
, "RpcMessage.Buffer should not have been NULL\n");
1972 ok(RpcMessage
.BufferLength
== 10 ||
1973 broken(RpcMessage
.BufferLength
== 12), /* win2k */
1974 "RpcMessage.BufferLength should have been 10 instead of %d\n", RpcMessage
.BufferLength
);
1975 ok(RpcMessage
.RpcFlags
== 0, "RpcMessage.RpcFlags should have been 0x0 instead of 0x%lx\n", RpcMessage
.RpcFlags
);
1976 ok(StubMsg
.Buffer
!= NULL
, "Buffer should not have been NULL\n");
1977 ok(!StubMsg
.BufferStart
, "BufferStart should have been NULL instead of %p\n", StubMsg
.BufferStart
);
1978 ok(!StubMsg
.BufferEnd
, "BufferEnd should have been NULL instead of %p\n", StubMsg
.BufferEnd
);
1980 ok(StubMsg
.BufferLength
== 0, "BufferLength should have left as 0 instead of being set to %d\n", StubMsg
.BufferLength
);
1981 old_buffer_valid_location
= !StubMsg
.fBufferValid
;
1982 if (old_buffer_valid_location
)
1983 ok(broken(StubMsg
.CorrDespIncrement
== TRUE
), "fBufferValid should have been TRUE instead of 0x%x\n", StubMsg
.CorrDespIncrement
);
1985 ok(StubMsg
.fBufferValid
, "fBufferValid should have been non-zero instead of 0x%x\n", StubMsg
.fBufferValid
);
1987 prev_buffer_length
= RpcMessage
.BufferLength
;
1988 StubMsg
.BufferLength
= 1;
1989 NdrFreeBuffer(&StubMsg
);
1990 ok(RpcMessage
.Handle
!= NULL
, "RpcMessage.Handle should not have been NULL\n");
1991 ok(RpcMessage
.Buffer
!= NULL
, "RpcMessage.Buffer should not have been NULL\n");
1992 ok(RpcMessage
.BufferLength
== prev_buffer_length
, "RpcMessage.BufferLength should have been left as %d instead of %d\n", prev_buffer_length
, RpcMessage
.BufferLength
);
1993 ok(StubMsg
.Buffer
!= NULL
, "Buffer should not have been NULL\n");
1994 ok(StubMsg
.BufferLength
== 1, "BufferLength should have left as 1 instead of being set to %d\n", StubMsg
.BufferLength
);
1995 if (old_buffer_valid_location
)
1996 ok(broken(StubMsg
.CorrDespIncrement
== FALSE
), "fBufferValid should have been FALSE instead of 0x%x\n", StubMsg
.CorrDespIncrement
);
1998 ok(!StubMsg
.fBufferValid
, "fBufferValid should have been FALSE instead of %d\n", StubMsg
.fBufferValid
);
2000 /* attempt double-free */
2001 NdrFreeBuffer(&StubMsg
);
2003 RpcBindingFree(&Handle
);
2005 status
= RpcServerUnregisterIf(NULL
, NULL
, FALSE
);
2006 ok(status
== RPC_S_OK
, "RpcServerUnregisterIf failed (%u)\n", status
);
2009 static void test_NdrMapCommAndFaultStatus(void)
2011 RPC_STATUS rpc_status
;
2012 MIDL_STUB_MESSAGE StubMsg
;
2013 RPC_MESSAGE RpcMessage
;
2015 NdrClientInitializeNew(&RpcMessage
, &StubMsg
, &Object_StubDesc
, 5);
2017 for (rpc_status
= 0; rpc_status
< 10000; rpc_status
++)
2020 ULONG comm_status
= 0;
2021 ULONG fault_status
= 0;
2022 ULONG expected_comm_status
= 0;
2023 ULONG expected_fault_status
= 0;
2024 status
= NdrMapCommAndFaultStatus(&StubMsg
, &comm_status
, &fault_status
, rpc_status
);
2025 ok(status
== RPC_S_OK
, "NdrMapCommAndFaultStatus failed with error %d\n", status
);
2028 case ERROR_INVALID_HANDLE
:
2029 case RPC_S_INVALID_BINDING
:
2030 case RPC_S_UNKNOWN_IF
:
2031 case RPC_S_SERVER_UNAVAILABLE
:
2032 case RPC_S_SERVER_TOO_BUSY
:
2033 case RPC_S_CALL_FAILED_DNE
:
2034 case RPC_S_PROTOCOL_ERROR
:
2035 case RPC_S_UNSUPPORTED_TRANS_SYN
:
2036 case RPC_S_UNSUPPORTED_TYPE
:
2037 case RPC_S_PROCNUM_OUT_OF_RANGE
:
2038 case EPT_S_NOT_REGISTERED
:
2039 case RPC_S_COMM_FAILURE
:
2040 expected_comm_status
= rpc_status
;
2043 expected_fault_status
= rpc_status
;
2045 ok(comm_status
== expected_comm_status
, "NdrMapCommAndFaultStatus should have mapped %d to comm status %d instead of %d\n",
2046 rpc_status
, expected_comm_status
, comm_status
);
2047 ok(fault_status
== expected_fault_status
, "NdrMapCommAndFaultStatus should have mapped %d to fault status %d instead of %d\n",
2048 rpc_status
, expected_fault_status
, fault_status
);
2052 START_TEST( ndr_marshall
)
2054 determine_pointer_marshalling_style();
2056 test_ndr_simple_type();
2057 test_simple_types();
2058 test_nontrivial_pointer_types();
2059 test_simple_struct();
2060 test_fullpointer_xlat();
2063 test_ndr_allocate();
2064 test_conformant_array();
2065 test_conformant_string();
2066 test_nonconformant_string();
2067 test_conf_complex_struct();
2069 test_NdrMapCommAndFaultStatus();