?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
quartz: Free two assert calls from having side effects.
[wine/testsucceed.git] / dlls / rpcrt4 / tests / ndr_marshall.c
blob549d09ee87d4a50f56761bf4b0e271e7c2635fbb
1 /*
2 * Unit test suite for ndr marshalling functions
3 *
4 * Copyright 2006 Huw Davies
5 *
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.
10 *
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.
15 *
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
19 */
20
21 #include <stdarg.h>
22
23 #define NTDDI_WIN2K 0x05000000
24 #define NTDDI_VERSION NTDDI_WIN2K /* for some MIDL_STUB_MESSAGE fields */
25
26 #include "wine/test.h"
27 #include <windef.h>
28 #include <winbase.h>
29 #include <winnt.h>
30 #include <winerror.h>
31
32 #include "rpc.h"
33 #include "rpcdce.h"
34 #include "rpcproxy.h"
35
36
37 static int my_alloc_called;
38 static int my_free_called;
39 static void * CALLBACK my_alloc(SIZE_T size)
40 {
41 my_alloc_called++;
42 return NdrOleAllocate(size);
43 }
44
45 static void CALLBACK my_free(void *ptr)
46 {
47 my_free_called++;
48 NdrOleFree(ptr);
49 }
50
51 static const MIDL_STUB_DESC Object_StubDesc =
52 {
53 NULL,
54 my_alloc,
55 my_free,
56 { 0 },
57 0,
58 0,
59 0,
60 0,
61 NULL, /* format string, filled in by tests */
62 1, /* -error bounds_check flag */
63 0x20000, /* Ndr library version */
64 0,
65 0x50100a4, /* MIDL Version 5.1.164 */
66 0,
67 NULL,
68 0, /* notify & notify_flag routine table */
69 1, /* Flags */
70 0, /* Reserved3 */
71 0, /* Reserved4 */
72 0 /* Reserved5 */
73 };
74
75 static RPC_DISPATCH_FUNCTION IFoo_table[] =
76 {
77 0
78 };
79
80 static RPC_DISPATCH_TABLE IFoo_v0_0_DispatchTable =
81 {
82 0,
83 IFoo_table
84 };
85
86 static const RPC_SERVER_INTERFACE IFoo___RpcServerInterface =
87 {
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,
92 0,
93 0,
94 0,
95 0,
96 0,
97 };
98
99 static RPC_IF_HANDLE IFoo_v0_0_s_ifspec = (RPC_IF_HANDLE)& IFoo___RpcServerInterface;
100 static BOOL use_pointer_ids = FALSE;
101
102 static void determine_pointer_marshalling_style(void)
103 {
104 RPC_MESSAGE RpcMessage;
105 MIDL_STUB_MESSAGE StubMsg;
106 MIDL_STUB_DESC StubDesc;
107 char ch = 0xde;
108
109 static const unsigned char fmtstr_up_char[] =
110 {
111 0x12, 0x8, /* FC_UP [simple_pointer] */
112 0x2, /* FC_CHAR */
113 0x5c, /* FC_PAD */
114 };
115
116 StubDesc = Object_StubDesc;
117 StubDesc.pFormatTypes = NULL;
118
119 NdrClientInitializeNew(
120 &RpcMessage,
121 &StubMsg,
122 &StubDesc,
123 0);
124
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);
129
130 use_pointer_ids = (*(unsigned int *)StubMsg.BufferStart != (UINT_PTR)&ch);
131 trace("Pointer marshalling using %s\n", use_pointer_ids ? "pointer ids" : "pointer value");
132
133 HeapFree(GetProcessHeap(), 0, StubMsg.BufferStart);
134 }
135
136 static void test_ndr_simple_type(void)
137 {
138 RPC_MESSAGE RpcMessage;
139 MIDL_STUB_MESSAGE StubMsg;
140 MIDL_STUB_DESC StubDesc;
141 LONG l, l2 = 0;
142
143 StubDesc = Object_StubDesc;
144 StubDesc.pFormatTypes = NULL;
145
146 NdrClientInitializeNew(
147 &RpcMessage,
148 &StubMsg,
149 &StubDesc,
150 0);
151
152 StubMsg.BufferLength = 16;
153 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
154 l = 0xcafebabe;
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, "%d\n", *(LONG*)StubMsg.BufferStart);
158
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, "%d\n", *(LONG*)StubMsg.BufferStart);
163
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, "%d\n", l2);
168
169 HeapFree(GetProcessHeap(), 0, StubMsg.BufferStart);
170 }
171
172 static void test_pointer_marshal(const unsigned char *formattypes,
173 void *memsrc, DWORD srcsize,
174 const void *wiredata,
175 ULONG wiredatalen,
176 int(*cmp)(const void*,const void*,size_t),
177 int num_additional_allocs,
178 const char *msgpfx)
179 {
180 RPC_MESSAGE RpcMessage;
181 MIDL_STUB_MESSAGE StubMsg;
182 MIDL_STUB_DESC StubDesc;
183 DWORD size;
184 void *ptr;
185 unsigned char *mem, *mem_orig;
186
187 my_alloc_called = my_free_called = 0;
188 if(!cmp)
189 cmp = memcmp;
190
191 StubDesc = Object_StubDesc;
192 StubDesc.pFormatTypes = formattypes;
193
194 NdrClientInitializeNew(
195 &RpcMessage,
196 &StubMsg,
197 &StubDesc,
198 0);
199
200 StubMsg.BufferLength = 0;
201 NdrPointerBufferSize( &StubMsg,
202 memsrc,
203 formattypes );
204 ok(StubMsg.BufferLength >= wiredatalen, "%s: length %d\n", msgpfx, StubMsg.BufferLength);
205
206 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
207 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
208 StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
209
210 memset(StubMsg.BufferStart, 0x0, StubMsg.BufferLength); /* This is a hack to clear the padding between the ptr and longlong/double */
211
212 ptr = NdrPointerMarshall( &StubMsg, memsrc, formattypes );
213 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
214 if (srcsize == 8 && wiredatalen == 16 && StubMsg.Buffer - StubMsg.BufferStart == 12)
215 {
216 /* win9x doesn't align 8-byte types properly */
217 wiredatalen = 12;
218 }
219 else
220 {
221 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
222 ok(!memcmp(StubMsg.BufferStart, wiredata, wiredatalen), "%s: incorrectly marshaled\n", msgpfx);
223 }
224
225 StubMsg.Buffer = StubMsg.BufferStart;
226 StubMsg.MemorySize = 0;
227
228 size = NdrPointerMemorySize( &StubMsg, formattypes );
229 ok(size == StubMsg.MemorySize, "%s: mem size %u size %u\n", msgpfx, StubMsg.MemorySize, size);
230 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
231 if(formattypes[1] & 0x10 /* FC_POINTER_DEREF */)
232 ok(size == srcsize + sizeof(void *), "%s: mem size %u\n", msgpfx, size);
233 else
234 ok(size == srcsize, "%s: mem size %u\n", msgpfx, size);
235
236 StubMsg.Buffer = StubMsg.BufferStart;
237 StubMsg.MemorySize = 16;
238 size = NdrPointerMemorySize( &StubMsg, formattypes );
239 ok(size == StubMsg.MemorySize, "%s: mem size %u size %u\n", msgpfx, StubMsg.MemorySize, size);
240 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
241 if(formattypes[1] & 0x10 /* FC_POINTER_DEREF */)
242 ok(size == srcsize + sizeof(void *) + 16, "%s: mem size %u\n", msgpfx, size);
243 else
244 ok(size == srcsize + 16, "%s: mem size %u\n", msgpfx, size);
245
246 StubMsg.Buffer = StubMsg.BufferStart;
247 StubMsg.MemorySize = 1;
248 size = NdrPointerMemorySize( &StubMsg, formattypes );
249 ok(size == StubMsg.MemorySize, "%s: mem size %u size %u\n", msgpfx, StubMsg.MemorySize, size);
250 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
251 if(formattypes[1] & 0x10 /* FC_POINTER_DEREF */)
252 ok(size == srcsize + sizeof(void *) + (srcsize == 8 ? 8 : sizeof(void *)), "%s: mem size %u\n", msgpfx, size);
253 else
254 ok(size == srcsize + (srcsize == 8 ? 8 : sizeof(void *)), "%s: mem size %u\n", msgpfx, size);
255
256 size = srcsize;
257 if(formattypes[1] & 0x10) size += 4;
258
259 StubMsg.Buffer = StubMsg.BufferStart;
260 StubMsg.MemorySize = 0;
261 mem_orig = mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
262
263 if(formattypes[1] & 0x10 /* FC_POINTER_DEREF */)
264 *(void**)mem = NULL;
265 ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
266 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
267 ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
268 ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
269 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
270 ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
271 ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
272 my_alloc_called = 0;
273
274 /* reset the buffer and call with must alloc */
275 StubMsg.Buffer = StubMsg.BufferStart;
276 if(formattypes[1] & 0x10 /* FC_POINTER_DEREF */)
277 *(void**)mem = NULL;
278 ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 1 );
279 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
280 /* doesn't allocate mem in this case */
281 todo_wine {
282 ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
283 }
284 ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
285 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
286 ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
287
288 todo_wine {
289 ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
290 }
291 my_alloc_called = 0;
292 if(formattypes[0] != 0x11 /* FC_RP */)
293 {
294 /* now pass the address of a NULL ptr */
295 mem = NULL;
296 StubMsg.Buffer = StubMsg.BufferStart;
297 ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
298 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
299 ok(mem != StubMsg.BufferStart + wiredatalen - srcsize, "%s: mem points to buffer %p %p\n", msgpfx, mem, StubMsg.BufferStart);
300 ok(!cmp(mem, memsrc, size), "%s: incorrectly unmarshaled\n", msgpfx);
301 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
302 ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
303 ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
304 my_alloc_called = 0;
305 NdrPointerFree(&StubMsg, mem, formattypes);
306
307 /* again pass address of NULL ptr, but pretend we're a server */
308 if (0) /* crashes on Win9x and NT4 */
309 {
310 mem = NULL;
311 StubMsg.Buffer = StubMsg.BufferStart;
312 StubMsg.IsClient = 0;
313 ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
314 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
315 if (formattypes[2] == 0xd /* FC_ENUM16 */)
316 ok(mem != StubMsg.BufferStart + wiredatalen - srcsize, "%s: mem points to buffer %p %p\n", msgpfx, mem, StubMsg.BufferStart);
317 else
318 ok(mem == StubMsg.BufferStart + wiredatalen - srcsize, "%s: mem doesn't point to buffer %p %p\n", msgpfx, mem, StubMsg.BufferStart);
319 ok(!cmp(mem, memsrc, size), "%s: incorrectly unmarshaled\n", msgpfx);
320 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
321 ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
322 if (formattypes[2] != 0xd /* FC_ENUM16 */) {
323 ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
324 my_alloc_called = 0;
325 }
326 }
327 }
328 HeapFree(GetProcessHeap(), 0, mem_orig);
329 HeapFree(GetProcessHeap(), 0, StubMsg.BufferStart);
330 }
331
332 static int deref_cmp(const void *s1, const void *s2, size_t num)
333 {
334 return memcmp(*(const void *const *)s1, *(const void *const *)s2, num);
335 }
336
337
338 static void test_simple_types(void)
339 {
340 unsigned char wiredata[16];
341 unsigned char ch;
342 unsigned char *ch_ptr;
343 unsigned short s;
344 unsigned int i;
345 ULONG l;
346 ULONGLONG ll;
347 float f;
348 double d;
349
350 static const unsigned char fmtstr_up_char[] =
351 {
352 0x12, 0x8, /* FC_UP [simple_pointer] */
353 0x2, /* FC_CHAR */
354 0x5c, /* FC_PAD */
355 };
356 static const unsigned char fmtstr_up_byte[] =
357 {
358 0x12, 0x8, /* FC_UP [simple_pointer] */
359 0x1, /* FC_BYTE */
360 0x5c, /* FC_PAD */
361 };
362 static const unsigned char fmtstr_up_small[] =
363 {
364 0x12, 0x8, /* FC_UP [simple_pointer] */
365 0x3, /* FC_SMALL */
366 0x5c, /* FC_PAD */
367 };
368 static const unsigned char fmtstr_up_usmall[] =
369 {
370 0x12, 0x8, /* FC_UP [simple_pointer] */
371 0x4, /* FC_USMALL */
372 0x5c, /* FC_PAD */
373 };
374 static const unsigned char fmtstr_rp_char[] =
375 {
376 0x11, 0x8, /* FC_RP [simple_pointer] */
377 0x2, /* FC_CHAR */
378 0x5c, /* FC_PAD */
379 };
380 static const unsigned char fmtstr_rpup_char[] =
381 {
382 0x11, 0x14, /* FC_RP [alloced_on_stack] */
383 NdrFcShort( 0x2 ), /* Offset= 2 (4) */
384 0x12, 0x8, /* FC_UP [simple_pointer] */
385 0x2, /* FC_CHAR */
386 0x5c, /* FC_PAD */
387 };
388 static const unsigned char fmtstr_rpup_char2[] =
389 {
390 0x11, 0x04, /* FC_RP [alloced_on_stack] */
391 NdrFcShort( 0x2 ), /* Offset= 2 (4) */
392 0x12, 0x8, /* FC_UP [simple_pointer] */
393 0x2, /* FC_CHAR */
394 0x5c, /* FC_PAD */
395 };
396
397 static const unsigned char fmtstr_up_wchar[] =
398 {
399 0x12, 0x8, /* FC_UP [simple_pointer] */
400 0x5, /* FC_WCHAR */
401 0x5c, /* FC_PAD */
402 };
403 static const unsigned char fmtstr_up_short[] =
404 {
405 0x12, 0x8, /* FC_UP [simple_pointer] */
406 0x6, /* FC_SHORT */
407 0x5c, /* FC_PAD */
408 };
409 static const unsigned char fmtstr_up_ushort[] =
410 {
411 0x12, 0x8, /* FC_UP [simple_pointer] */
412 0x7, /* FC_USHORT */
413 0x5c, /* FC_PAD */
414 };
415 static const unsigned char fmtstr_up_enum16[] =
416 {
417 0x12, 0x8, /* FC_UP [simple_pointer] */
418 0xd, /* FC_ENUM16 */
419 0x5c, /* FC_PAD */
420 };
421 static const unsigned char fmtstr_up_long[] =
422 {
423 0x12, 0x8, /* FC_UP [simple_pointer] */
424 0x8, /* FC_LONG */
425 0x5c, /* FC_PAD */
426 };
427 static const unsigned char fmtstr_up_ulong[] =
428 {
429 0x12, 0x8, /* FC_UP [simple_pointer] */
430 0x9, /* FC_ULONG */
431 0x5c, /* FC_PAD */
432 };
433 static const unsigned char fmtstr_up_enum32[] =
434 {
435 0x12, 0x8, /* FC_UP [simple_pointer] */
436 0xe, /* FC_ENUM32 */
437 0x5c, /* FC_PAD */
438 };
439 static const unsigned char fmtstr_up_errorstatus[] =
440 {
441 0x12, 0x8, /* FC_UP [simple_pointer] */
442 0x10, /* FC_ERROR_STATUS_T */
443 0x5c, /* FC_PAD */
444 };
445
446 static const unsigned char fmtstr_up_longlong[] =
447 {
448 0x12, 0x8, /* FC_UP [simple_pointer] */
449 0xb, /* FC_HYPER */
450 0x5c, /* FC_PAD */
451 };
452 static const unsigned char fmtstr_up_float[] =
453 {
454 0x12, 0x8, /* FC_UP [simple_pointer] */
455 0xa, /* FC_FLOAT */
456 0x5c, /* FC_PAD */
457 };
458 static const unsigned char fmtstr_up_double[] =
459 {
460 0x12, 0x8, /* FC_UP [simple_pointer] */
461 0xc, /* FC_DOUBLE */
462 0x5c, /* FC_PAD */
463 };
464
465 ch = 0xa5;
466 ch_ptr = &ch;
467 if (use_pointer_ids)
468 *(unsigned int *)wiredata = 0x20000;
469 else
470 *(unsigned int *)wiredata = (UINT_PTR)ch_ptr;
471 wiredata[4] = ch;
472
473 test_pointer_marshal(fmtstr_up_char, ch_ptr, 1, wiredata, 5, NULL, 0, "up_char");
474 test_pointer_marshal(fmtstr_up_byte, ch_ptr, 1, wiredata, 5, NULL, 0, "up_byte");
475 test_pointer_marshal(fmtstr_up_small, ch_ptr, 1, wiredata, 5, NULL, 0, "up_small");
476 test_pointer_marshal(fmtstr_up_usmall, ch_ptr, 1, wiredata, 5, NULL, 0, "up_usmall");
477
478 test_pointer_marshal(fmtstr_rp_char, ch_ptr, 1, &ch, 1, NULL, 0, "rp_char");
479
480 test_pointer_marshal(fmtstr_rpup_char, &ch_ptr, 1, wiredata, 5, deref_cmp, 1, "rpup_char");
481 test_pointer_marshal(fmtstr_rpup_char2, ch_ptr, 1, wiredata, 5, NULL, 0, "rpup_char2");
482
483 s = 0xa597;
484 if (use_pointer_ids)
485 *(unsigned int *)wiredata = 0x20000;
486 else
487 *(unsigned int *)wiredata = (UINT_PTR)&s;
488 *(unsigned short*)(wiredata + 4) = s;
489
490 test_pointer_marshal(fmtstr_up_wchar, &s, 2, wiredata, 6, NULL, 0, "up_wchar");
491 test_pointer_marshal(fmtstr_up_short, &s, 2, wiredata, 6, NULL, 0, "up_short");
492 test_pointer_marshal(fmtstr_up_ushort, &s, 2, wiredata, 6, NULL, 0, "up_ushort");
493
494 i = 0x7fff;
495 if (use_pointer_ids)
496 *(unsigned int *)wiredata = 0x20000;
497 else
498 *(unsigned int *)wiredata = (UINT_PTR)&i;
499 *(unsigned short*)(wiredata + 4) = i;
500 test_pointer_marshal(fmtstr_up_enum16, &i, 4, wiredata, 6, NULL, 0, "up_enum16");
501
502 l = 0xcafebabe;
503 if (use_pointer_ids)
504 *(unsigned int *)wiredata = 0x20000;
505 else
506 *(unsigned int *)wiredata = (UINT_PTR)&l;
507 *(ULONG*)(wiredata + 4) = l;
508
509 test_pointer_marshal(fmtstr_up_long, &l, 4, wiredata, 8, NULL, 0, "up_long");
510 test_pointer_marshal(fmtstr_up_ulong, &l, 4, wiredata, 8, NULL, 0, "up_ulong");
511 test_pointer_marshal(fmtstr_up_enum32, &l, 4, wiredata, 8, NULL, 0, "up_emun32");
512 test_pointer_marshal(fmtstr_up_errorstatus, &l, 4, wiredata, 8, NULL, 0, "up_errorstatus");
513
514 ll = ((ULONGLONG)0xcafebabe) << 32 | 0xdeadbeef;
515 if (use_pointer_ids)
516 *(unsigned int *)wiredata = 0x20000;
517 else
518 *(unsigned int *)wiredata = (UINT_PTR)&ll;
519 *(unsigned int *)(wiredata + 4) = 0;
520 *(ULONGLONG*)(wiredata + 8) = ll;
521 test_pointer_marshal(fmtstr_up_longlong, &ll, 8, wiredata, 16, NULL, 0, "up_longlong");
522
523 f = 3.1415f;
524 if (use_pointer_ids)
525 *(unsigned int *)wiredata = 0x20000;
526 else
527 *(unsigned int *)wiredata = (UINT_PTR)&f;
528 *(float*)(wiredata + 4) = f;
529 test_pointer_marshal(fmtstr_up_float, &f, 4, wiredata, 8, NULL, 0, "up_float");
530
531 d = 3.1415;
532 if (use_pointer_ids)
533 *(unsigned int *)wiredata = 0x20000;
534 else
535 *(unsigned int *)wiredata = (UINT_PTR)&d;
536 *(unsigned int *)(wiredata + 4) = 0;
537 *(double*)(wiredata + 8) = d;
538 test_pointer_marshal(fmtstr_up_double, &d, 8, wiredata, 16, NULL, 0, "up_double");
539
540 }
541
542 static void test_nontrivial_pointer_types(void)
543 {
544 RPC_MESSAGE RpcMessage;
545 MIDL_STUB_MESSAGE StubMsg;
546 MIDL_STUB_DESC StubDesc;
547 DWORD size;
548 void *ptr;
549 char **p1;
550 char *p2;
551 char ch;
552 unsigned char *mem, *mem_orig;
553
554 static const unsigned char fmtstr_ref_unique_out[] =
555 {
556 0x12, 0x8, /* FC_UP [simple_pointer] */
557 0x2, /* FC_CHAR */
558 0x5c, /* FC_PAD */
559 0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */
560 NdrFcShort( 0xfffffffa ), /* Offset= -6 (0) */
561 };
562
563 p1 = &p2;
564 p2 = &ch;
565 ch = 0x22;
566
567 StubDesc = Object_StubDesc;
568 StubDesc.pFormatTypes = fmtstr_ref_unique_out;
569
570 NdrClientInitializeNew(
571 &RpcMessage,
572 &StubMsg,
573 &StubDesc,
574 0);
575
576 StubMsg.BufferLength = 0;
577 NdrPointerBufferSize( &StubMsg,
578 (unsigned char *)p1,
579 &fmtstr_ref_unique_out[4] );
580
581 /* Windows overestimates the buffer size */
582 ok(StubMsg.BufferLength >= 5, "length %d\n", StubMsg.BufferLength);
583
584 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
585 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
586 StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
587
588 ptr = NdrPointerMarshall( &StubMsg, (unsigned char *)p1, &fmtstr_ref_unique_out[4] );
589 ok(ptr == NULL, "ret %p\n", ptr);
590 size = StubMsg.Buffer - StubMsg.BufferStart;
591 ok(size == 5, "Buffer %p Start %p len %d\n", StubMsg.Buffer, StubMsg.BufferStart, size);
592 ok(*(unsigned int *)StubMsg.BufferStart != 0, "pointer ID marshalled incorrectly\n");
593 ok(*(unsigned char *)(StubMsg.BufferStart + 4) == 0x22, "char data marshalled incorrectly: 0x%x\n",
594 *(unsigned char *)(StubMsg.BufferStart + 4));
595
596 StubMsg.Buffer = StubMsg.BufferStart;
597 StubMsg.MemorySize = 0;
598 mem = NULL;
599
600 /* Client */
601 my_alloc_called = 0;
602 StubMsg.Buffer = StubMsg.BufferStart;
603 mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(void *));
604 *(void **)mem = NULL;
605 NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 0);
606 ok(mem == mem_orig, "mem alloced\n");
607 ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
608
609 my_alloc_called = 0;
610 StubMsg.Buffer = StubMsg.BufferStart;
611 NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 1);
612 todo_wine {
613 ok(mem == mem_orig, "mem alloced\n");
614 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
615 }
616
617 my_free_called = 0;
618 StubMsg.Buffer = StubMsg.BufferStart;
619 NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
620 ok(my_free_called == 1, "free called %d\n", my_free_called);
621
622 mem = my_alloc(sizeof(void *));
623 *(void **)mem = NULL;
624 my_free_called = 0;
625 StubMsg.Buffer = StubMsg.BufferStart;
626 NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
627 ok(my_free_called == 0, "free called %d\n", my_free_called);
628 my_free(mem);
629
630 mem = my_alloc(sizeof(void *));
631 *(void **)mem = my_alloc(sizeof(char));
632 my_free_called = 0;
633 StubMsg.Buffer = StubMsg.BufferStart;
634 NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
635 ok(my_free_called == 1, "free called %d\n", my_free_called);
636 my_free(mem);
637
638 /* Server */
639 my_alloc_called = 0;
640 StubMsg.IsClient = 0;
641 mem = NULL;
642 StubMsg.Buffer = StubMsg.BufferStart;
643 NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 0);
644 ok(mem != StubMsg.BufferStart, "mem pointing at buffer\n");
645 todo_wine
646 ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
647 NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
648
649 my_alloc_called = 0;
650 mem = NULL;
651 StubMsg.Buffer = StubMsg.BufferStart;
652 NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 1);
653 ok(mem != StubMsg.BufferStart, "mem pointing at buffer\n");
654 todo_wine
655 ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
656 NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
657
658 my_alloc_called = 0;
659 mem = mem_orig;
660 *(void **)mem = NULL;
661 StubMsg.Buffer = StubMsg.BufferStart;
662 NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 0);
663 todo_wine {
664 ok(mem == mem_orig, "mem alloced\n");
665 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
666 }
667
668 my_alloc_called = 0;
669 mem = mem_orig;
670 *(void **)mem = NULL;
671 StubMsg.Buffer = StubMsg.BufferStart;
672 NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 1);
673 todo_wine {
674 ok(mem == mem_orig, "mem alloced\n");
675 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
676 }
677
678 mem = my_alloc(sizeof(void *));
679 *(void **)mem = NULL;
680 my_free_called = 0;
681 StubMsg.Buffer = StubMsg.BufferStart;
682 NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
683 ok(my_free_called == 0, "free called %d\n", my_free_called);
684 my_free(mem);
685
686 mem = my_alloc(sizeof(void *));
687 *(void **)mem = my_alloc(sizeof(char));
688 my_free_called = 0;
689 StubMsg.Buffer = StubMsg.BufferStart;
690 NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
691 ok(my_free_called == 1, "free called %d\n", my_free_called);
692 my_free(mem);
693
694 HeapFree(GetProcessHeap(), 0, mem_orig);
695 HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
696 }
697
698 static void test_simple_struct_marshal(const unsigned char *formattypes,
699 void *memsrc, DWORD srcsize,
700 const void *wiredata,
701 ULONG wiredatalen,
702 int(*cmp)(const void*,const void*,size_t),
703 int num_additional_allocs,
704 const char *msgpfx)
705 {
706 RPC_MESSAGE RpcMessage;
707 MIDL_STUB_MESSAGE StubMsg;
708 MIDL_STUB_DESC StubDesc;
709 DWORD size;
710 void *ptr;
711 unsigned char *mem, *mem_orig;
712
713 my_alloc_called = my_free_called = 0;
714 if(!cmp)
715 cmp = memcmp;
716
717 StubDesc = Object_StubDesc;
718 StubDesc.pFormatTypes = formattypes;
719
720 NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 0);
721
722 StubMsg.BufferLength = 0;
723 NdrSimpleStructBufferSize( &StubMsg, memsrc, formattypes );
724 ok(StubMsg.BufferLength >= wiredatalen, "%s: length %d\n", msgpfx, StubMsg.BufferLength);
725 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
726 StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
727 ptr = NdrSimpleStructMarshall( &StubMsg, memsrc, formattypes );
728 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
729 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart);
730 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));
731
732 StubMsg.Buffer = StubMsg.BufferStart;
733 StubMsg.MemorySize = 0;
734 size = NdrSimpleStructMemorySize( &StubMsg, formattypes );
735 ok(size == StubMsg.MemorySize, "%s: size != MemorySize\n", msgpfx);
736 ok(size == srcsize, "%s: mem size %u\n", msgpfx, size);
737 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart);
738
739 StubMsg.Buffer = StubMsg.BufferStart;
740 size = NdrSimpleStructMemorySize( &StubMsg, formattypes );
741 ok(size == StubMsg.MemorySize, "%s: size != MemorySize\n", msgpfx);
742 ok(StubMsg.MemorySize == ((srcsize + 3) & ~3) + srcsize, "%s: mem size %u\n", msgpfx, size);
743 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart);
744 size = srcsize;
745 /*** Unmarshalling first with must_alloc false ***/
746
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);
756 my_alloc_called = 0;
757 ok(StubMsg.MemorySize == 0, "%s: memorysize touched in unmarshal\n", msgpfx);
758
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);
767 my_alloc_called = 0;
768 ok(StubMsg.MemorySize == 0, "%s: memorysize touched in unmarshal\n", msgpfx);
769
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. */
773
774 if (0) /* crashes on Win9x and NT4 */
775 {
776 mem = NULL;
777 StubMsg.IsClient = 0;
778 StubMsg.Buffer = StubMsg.BufferStart;
779 ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, FALSE );
780 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
781 ok(mem == StubMsg.BufferStart, "%s: mem not equal buffer\n", msgpfx);
782 ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
783 ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
784 my_alloc_called = 0;
785 ok(StubMsg.MemorySize == 0, "%s: memorysize touched in unmarshal\n", msgpfx);
786 }
787
788 /*** now must_alloc is true ***/
789
790 /* with must_alloc set we always allocate new memory whether or not we're
791 a server and also when passing NULL */
792 mem = mem_orig;
793 StubMsg.IsClient = 1;
794 StubMsg.Buffer = StubMsg.BufferStart;
795 ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
796 ok(ptr == NULL, "ret %p\n", ptr);
797 ok(mem != mem_orig, "mem not changed %p %p\n", mem, mem_orig);
798 ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n");
799 ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
800 my_alloc_called = 0;
801 ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
802
803 mem = NULL;
804 StubMsg.Buffer = StubMsg.BufferStart;
805 ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
806 ok(ptr == NULL, "ret %p\n", ptr);
807 ok(mem != mem_orig, "mem not changed %p %p\n", mem, mem_orig);
808 ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n");
809 ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
810 my_alloc_called = 0;
811 ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
812
813 mem = mem_orig;
814 StubMsg.Buffer = StubMsg.BufferStart;
815 StubMsg.IsClient = 0;
816 StubMsg.ReuseBuffer = 1;
817 ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
818 ok(ptr == NULL, "ret %p\n", ptr);
819 ok(mem != mem_orig, "mem not changed %p %p\n", mem, mem_orig);
820 ok(mem != StubMsg.BufferStart, "mem is buffer mem\n");
821 ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n");
822 ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
823 my_alloc_called = 0;
824 ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
825
826 mem = NULL;
827 StubMsg.Buffer = StubMsg.BufferStart;
828 StubMsg.IsClient = 0;
829 StubMsg.ReuseBuffer = 1;
830 ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
831 ok(ptr == NULL, "ret %p\n", ptr);
832 ok(mem != StubMsg.BufferStart, "mem is buffer mem\n");
833 ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n");
834 ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
835 my_alloc_called = 0;
836 ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
837
838 HeapFree(GetProcessHeap(), 0, mem_orig);
839 HeapFree(GetProcessHeap(), 0, StubMsg.BufferStart);
840 }
841
842 typedef struct
843 {
844 LONG l1;
845 LONG *pl1;
846 char *pc1;
847 } ps1_t;
848
849 static int ps1_cmp(const void *s1, const void *s2, size_t num)
850 {
851 const ps1_t *p1, *p2;
852
853 p1 = s1;
854 p2 = s2;
855
856 if(p1->l1 != p2->l1)
857 return 1;
858
859 if(p1->pl1 && p2->pl1)
860 {
861 if(*p1->pl1 != *p2->pl1)
862 return 1;
863 }
864 else if(p1->pl1 || p2->pl1)
865 return 1;
866
867 if(p1->pc1 && p2->pc1)
868 {
869 if(*p1->pc1 != *p2->pc1)
870 return 1;
871 }
872 else if(p1->pc1 || p2->pc1)
873 return 1;
874
875 return 0;
876 }
877
878 static void test_simple_struct(void)
879 {
880 unsigned char wiredata[28];
881 ULONG wiredatalen;
882 LONG l;
883 char c;
884 ps1_t ps1;
885
886 static const unsigned char fmtstr_simple_struct[] =
887 {
888 0x12, 0x0, /* FC_UP */
889 NdrFcShort( 0x2 ), /* Offset=2 */
890 0x15, 0x3, /* FC_STRUCT [align 4] */
891 NdrFcShort( 0x18 ), /* [size 24] */
892 0x6, /* FC_SHORT */
893 0x2, /* FC_CHAR */
894 0x38, /* FC_ALIGNM4 */
895 0x8, /* FC_LONG */
896 0x8, /* FC_LONG */
897 0x39, /* FC_ALIGNM8 */
898 0xb, /* FC_HYPER */
899 0x5b, /* FC_END */
900 };
901 struct {
902 short s;
903 char c;
904 LONG l1, l2;
905 LONGLONG ll;
906 } s1;
907
908 static const unsigned char fmtstr_pointer_struct[] =
909 {
910 0x12, 0x0, /* FC_UP */
911 NdrFcShort( 0x2 ), /* Offset=2 */
912 #ifdef _WIN64
913 0x1a, /* FC_BOGUS_STRUCT */
914 0x3, /* 3 */
915 NdrFcShort(0x18), /* [size 24] */
916 NdrFcShort(0x0),
917 NdrFcShort(0x8), /* Offset= 8 (266) */
918 0x08, /* FC_LONG */
919 0x39, /* FC_ALIGNM8 */
920 0x36, /* FC_POINTER */
921 0x36, /* FC_POINTER */
922 0x5c, /* FC_PAD */
923 0x5b, /* FC_END */
924 0x12, 0x8, /* FC_UP [simple_pointer] */
925 0x08, /* FC_LONG */
926 0x5c, /* FC_PAD */
927 0x12, 0x8, /* FC_UP [simple_pointer] */
928 0x02, /* FC_CHAR */
929 0x5c, /* FC_PAD */
930 #else
931 0x16, 0x3, /* FC_PSTRUCT [align 4] */
932 NdrFcShort( 0xc ), /* [size 12] */
933 0x4b, /* FC_PP */
934 0x5c, /* FC_PAD */
935 0x46, /* FC_NO_REPEAT */
936 0x5c, /* FC_PAD */
937 NdrFcShort( 0x4 ), /* 4 */
938 NdrFcShort( 0x4 ), /* 4 */
939 0x13, 0x8, /* FC_OP [simple_pointer] */
940 0x8, /* FC_LONG */
941 0x5c, /* FC_PAD */
942 0x46, /* FC_NO_REPEAT */
943 0x5c, /* FC_PAD */
944 NdrFcShort( 0x8 ), /* 8 */
945 NdrFcShort( 0x8 ), /* 8 */
946 0x13, 0x8, /* FC_OP [simple_pointer] */
947 0x2, /* FC_CHAR */
948 0x5c, /* FC_PAD */
949 0x5b, /* FC_END */
950 0x8, /* FC_LONG */
951 0x8, /* FC_LONG */
952 0x8, /* FC_LONG */
953 0x5c, /* FC_PAD */
954 0x5b, /* FC_END */
955 #endif
956 };
957
958 /* zero the entire structure, including the holes */
959 memset(&s1, 0, sizeof(s1));
960
961 /* FC_STRUCT */
962 s1.s = 0x1234;
963 s1.c = 0xa5;
964 s1.l1 = 0xdeadbeef;
965 s1.l2 = 0xcafebabe;
966 s1.ll = ((LONGLONG) 0xbadefeed << 32) | 0x2468ace0;
967
968 wiredatalen = 24;
969 memcpy(wiredata, &s1, wiredatalen);
970 test_simple_struct_marshal(fmtstr_simple_struct + 4, &s1, 24, wiredata, 24, NULL, 0, "struct");
971
972 if (use_pointer_ids)
973 *(unsigned int *)wiredata = 0x20000;
974 else
975 *(unsigned int *)wiredata = (UINT_PTR)&s1;
976 memcpy(wiredata + 4, &s1, wiredatalen);
977 test_pointer_marshal(fmtstr_simple_struct, &s1, 24, wiredata, 28, NULL, 0, "struct");
978
979 if (sizeof(void *) == 8) return; /* it cannot be represented as a simple struct on Win64 */
980
981 /* zero the entire structure, including the hole */
982 memset(&ps1, 0, sizeof(ps1));
983
984 /* FC_PSTRUCT */
985 ps1.l1 = 0xdeadbeef;
986 l = 0xcafebabe;
987 ps1.pl1 = &l;
988 c = 'a';
989 ps1.pc1 = &c;
990 *(unsigned int *)(wiredata + 4) = 0xdeadbeef;
991 if (use_pointer_ids)
992 {
993 *(unsigned int *)(wiredata + 8) = 0x20000;
994 *(unsigned int *)(wiredata + 12) = 0x20004;
995 }
996 else
997 {
998 *(unsigned int *)(wiredata + 8) = (UINT_PTR)&l;
999 *(unsigned int *)(wiredata + 12) = (UINT_PTR)&c;
1000 }
1001 memcpy(wiredata + 16, &l, 4);
1002 memcpy(wiredata + 20, &c, 1);
1003
1004 test_simple_struct_marshal(fmtstr_pointer_struct + 4, &ps1, 17, wiredata + 4, 17, ps1_cmp, 2, "pointer_struct");
1005 if (use_pointer_ids)
1006 {
1007 *(unsigned int *)wiredata = 0x20000;
1008 *(unsigned int *)(wiredata + 8) = 0x20004;
1009 *(unsigned int *)(wiredata + 12) = 0x20008;
1010 }
1011 else
1012 *(unsigned int *)wiredata = (UINT_PTR)&ps1;
1013 test_pointer_marshal(fmtstr_pointer_struct, &ps1, 17, wiredata, 21, ps1_cmp, 2, "pointer_struct");
1014 }
1015
1016 static void test_fullpointer_xlat(void)
1017 {
1018 PFULL_PTR_XLAT_TABLES pXlatTables;
1019 ULONG RefId;
1020 int ret;
1021 void *Pointer;
1022
1023 pXlatTables = NdrFullPointerXlatInit(2, XLAT_CLIENT);
1024
1025 /* "marshaling" phase */
1026
1027 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
1028 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1029 ok(RefId == 0x1, "RefId should be 0x1 instead of 0x%x\n", RefId);
1030
1031 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 0, &RefId);
1032 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1033 ok(RefId == 0x1, "RefId should be 0x1 instead of 0x%x\n", RefId);
1034
1035 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebabe, 0, &RefId);
1036 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1037 ok(RefId == 0x2, "RefId should be 0x2 instead of 0x%x\n", RefId);
1038
1039 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 0, &RefId);
1040 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1041 ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
1042
1043 ret = NdrFullPointerQueryPointer(pXlatTables, NULL, 0, &RefId);
1044 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1045 ok(RefId == 0, "RefId should be 0 instead of 0x%x\n", RefId);
1046
1047 /* "unmarshaling" phase */
1048
1049 ret = NdrFullPointerQueryRefId(pXlatTables, 0x0, 0, &Pointer);
1050 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1051
1052 ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 0, &Pointer);
1053 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1054 ok(Pointer == (void *)0xcafebabe, "Pointer should be 0xcafebabe instead of %p\n", Pointer);
1055
1056 ret = NdrFullPointerQueryRefId(pXlatTables, 0x4, 0, &Pointer);
1057 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1058 ok(Pointer == NULL, "Pointer should be NULL instead of %p\n", Pointer);
1059
1060 NdrFullPointerInsertRefId(pXlatTables, 0x4, (void *)0xdeadbabe);
1061
1062 ret = NdrFullPointerQueryRefId(pXlatTables, 0x4, 1, &Pointer);
1063 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1064 ok(Pointer == (void *)0xdeadbabe, "Pointer should be (void *)0xdeadbabe instead of %p\n", Pointer);
1065
1066 NdrFullPointerXlatFree(pXlatTables);
1067
1068 pXlatTables = NdrFullPointerXlatInit(2, XLAT_SERVER);
1069
1070 /* "unmarshaling" phase */
1071
1072 ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 1, &Pointer);
1073 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1074 ok(Pointer == NULL, "Pointer should be NULL instead of %p\n", Pointer);
1075
1076 NdrFullPointerInsertRefId(pXlatTables, 0x2, (void *)0xcafebabe);
1077
1078 ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 0, &Pointer);
1079 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1080 ok(Pointer == (void *)0xcafebabe, "Pointer should be (void *)0xcafebabe instead of %p\n", Pointer);
1081
1082 ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 1, &Pointer);
1083 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1084 ok(Pointer == (void *)0xcafebabe, "Pointer should be (void *)0xcafebabe instead of %p\n", Pointer);
1085
1086 /* "marshaling" phase */
1087
1088 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
1089 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1090 ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
1091
1092 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
1093 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1094 ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
1095
1096 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 0, &RefId);
1097 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1098 ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
1099
1100 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebabe, 0, &RefId);
1101 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1102 ok(RefId == 0x2, "RefId should be 0x2 instead of 0x%x\n", RefId);
1103
1104 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 0, &RefId);
1105 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1106 ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
1107
1108 /* "freeing" phase */
1109
1110 ret = NdrFullPointerFree(pXlatTables, (void *)0xcafebeef);
1111 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1112
1113 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 0x20, &RefId);
1114 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1115 ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
1116
1117 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
1118 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1119 ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
1120
1121 ret = NdrFullPointerFree(pXlatTables, (void *)0xcafebabe);
1122 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1123
1124 ret = NdrFullPointerFree(pXlatTables, (void *)0xdeadbeef);
1125 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1126
1127 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 0x20, &RefId);
1128 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1129 ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
1130
1131 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 1, &RefId);
1132 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1133 ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
1134
1135 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 1, &RefId);
1136 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
1137 ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
1138
1139 ret = NdrFullPointerFree(pXlatTables, (void *)0xdeadbeef);
1140 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
1141
1142 NdrFullPointerXlatFree(pXlatTables);
1143 }
1144
1145 /* verify stub data that is identical between client and server */
1146 static void test_common_stub_data( const char *prefix, const MIDL_STUB_MESSAGE *stubMsg )
1147 {
1148 void *unset_ptr;
1149
1150 memset(&unset_ptr, 0xcc, sizeof(unset_ptr));
1151
1152 #define TEST_ZERO(field, fmt) ok(stubMsg->field == 0, "%s: " #field " should have been set to zero instead of " fmt "\n", prefix, stubMsg->field)
1153 #define TEST_POINTER_UNSET(field) ok(stubMsg->field == unset_ptr, "%s: " #field " should have been unset instead of %p\n", prefix, stubMsg->field)
1154 #define TEST_ULONG_UNSET(field) ok(stubMsg->field == 0xcccccccc, "%s: " #field " should have been unset instead of 0x%x\n", prefix, stubMsg->field)
1155 #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)
1156
1157 TEST_POINTER_UNSET(BufferMark);
1158 TEST_ULONG_UNSET(MemorySize);
1159 TEST_POINTER_UNSET(Memory);
1160 TEST_ZERO(pAllocAllNodesContext, "%p");
1161 ok(stubMsg->pPointerQueueState == 0 ||
1162 broken(stubMsg->pPointerQueueState == unset_ptr), /* win2k */
1163 "%s: pPointerQueueState should have been unset instead of %p\n",
1164 prefix, stubMsg->pPointerQueueState);
1165 TEST_ZERO(IgnoreEmbeddedPointers, "%d");
1166 TEST_ZERO(PointerBufferMark, "%p");
1167 ok( stubMsg->uFlags == 0 ||
1168 broken(stubMsg->uFlags == 0xcc), /* win9x */
1169 "%s: uFlags should have been set to zero instead of 0x%x\n", prefix, stubMsg->uFlags );
1170 /* FIXME: UniquePtrCount */
1171 TEST_ULONG_PTR_UNSET(MaxCount);
1172 TEST_ULONG_UNSET(Offset);
1173 TEST_ULONG_UNSET(ActualCount);
1174 ok(stubMsg->pfnAllocate == my_alloc, "%s: pfnAllocate should have been %p instead of %p\n",
1175 prefix, my_alloc, stubMsg->pfnAllocate);
1176 ok(stubMsg->pfnFree == my_free, "%s: pfnFree should have been %p instead of %p\n",
1177 prefix, my_free, stubMsg->pfnFree);
1178 TEST_ZERO(StackTop, "%p");
1179 TEST_POINTER_UNSET(pPresentedType);
1180 TEST_POINTER_UNSET(pTransmitType);
1181 TEST_POINTER_UNSET(SavedHandle);
1182 ok(stubMsg->StubDesc == &Object_StubDesc, "%s: StubDesc should have been %p instead of %p\n",
1183 prefix, &Object_StubDesc, stubMsg->StubDesc);
1184 TEST_ZERO(FullPtrRefId, "%d");
1185 ok( stubMsg->PointerLength == 0 ||
1186 broken(stubMsg->PointerLength == 1), /* win9x, nt4 */
1187 "%s: pAsyncMsg should have been set to zero instead of %d\n", prefix, stubMsg->PointerLength );
1188 TEST_ZERO(fInDontFree, "%d");
1189 TEST_ZERO(fDontCallFreeInst, "%d");
1190 ok( stubMsg->fHasReturn == 0 || broken(stubMsg->fHasReturn), /* win9x, nt4 */
1191 "%s: fHasReturn should have been set to zero instead of %d\n", prefix, stubMsg->fHasReturn );
1192 TEST_ZERO(fHasExtensions, "%d");
1193 TEST_ZERO(fHasNewCorrDesc, "%d");
1194 ok(stubMsg->fIsIn == 0 || broken(stubMsg->fIsIn), /* win9x, nt4 */
1195 "%s: fIsIn should have been set to 0 instead of %d\n", prefix, stubMsg->fIsIn);
1196 TEST_ZERO(fIsOicf, "%d");
1197 ok(stubMsg->fBufferValid == 0,
1198 "%s: fBufferValid should have been set to 0 instead of %d\n", prefix, stubMsg->fBufferValid);
1199 TEST_ZERO(fNeedMCCP, "%d");
1200 ok(stubMsg->fUnused == 0 ||
1201 stubMsg->fUnused == -2, /* Vista */
1202 "%s: fUnused should have been set to 0 or -2 instead of %d\n", prefix, stubMsg->fUnused);
1203 ok(stubMsg->fUnused2 == 0xffffcccc, "%s: fUnused2 should have been 0xffffcccc instead of 0x%x\n",
1204 prefix, stubMsg->fUnused2);
1205 ok(stubMsg->dwDestContext == MSHCTX_DIFFERENTMACHINE,
1206 "%s: dwDestContext should have been MSHCTX_DIFFERENTMACHINE instead of %d\n",
1207 prefix, stubMsg->dwDestContext);
1208 TEST_ZERO(pvDestContext, "%p");
1209 TEST_POINTER_UNSET(SavedContextHandles);
1210 TEST_ULONG_UNSET(ParamNumber);
1211 TEST_ZERO(pRpcChannelBuffer, "%p");
1212 TEST_ZERO(pArrayInfo, "%p");
1213 TEST_POINTER_UNSET(SizePtrCountArray);
1214 TEST_POINTER_UNSET(SizePtrOffsetArray);
1215 TEST_POINTER_UNSET(SizePtrLengthArray);
1216 TEST_POINTER_UNSET(pArgQueue);
1217 TEST_ZERO(dwStubPhase, "%d");
1218 /* FIXME: where does this value come from? */
1219 trace("%s: LowStackMark is %p\n", prefix, stubMsg->LowStackMark);
1220 ok( stubMsg->pAsyncMsg == 0 || broken(stubMsg->pAsyncMsg == unset_ptr), /* win9x, nt4 */
1221 "%s: pAsyncMsg should have been set to zero instead of %p\n", prefix, stubMsg->pAsyncMsg );
1222 ok( stubMsg->pCorrInfo == 0 || broken(stubMsg->pCorrInfo == unset_ptr), /* win9x, nt4 */
1223 "%s: pCorrInfo should have been set to zero instead of %p\n", prefix, stubMsg->pCorrInfo );
1224 ok( stubMsg->pCorrMemory == 0 || broken(stubMsg->pCorrMemory == unset_ptr), /* win9x, nt4 */
1225 "%s: pCorrMemory should have been set to zero instead of %p\n", prefix, stubMsg->pCorrMemory );
1226 ok( stubMsg->pMemoryList == 0 || broken(stubMsg->pMemoryList == unset_ptr), /* win9x, nt4 */
1227 "%s: pMemoryList should have been set to zero instead of %p\n", prefix, stubMsg->pMemoryList );
1228 TEST_POINTER_UNSET(pCSInfo);
1229 TEST_POINTER_UNSET(ConformanceMark);
1230 TEST_POINTER_UNSET(VarianceMark);
1231 ok(stubMsg->Unused == (ULONG_PTR)unset_ptr, "%s: Unused should have be unset instead of 0x%lx\n",
1232 prefix, stubMsg->Unused);
1233 TEST_POINTER_UNSET(pContext);
1234 TEST_POINTER_UNSET(ContextHandleHash);
1235 TEST_POINTER_UNSET(pUserMarshalList);
1236 TEST_ULONG_PTR_UNSET(Reserved51_3);
1237 TEST_ULONG_PTR_UNSET(Reserved51_4);
1238 TEST_ULONG_PTR_UNSET(Reserved51_5);
1239
1240 #undef TEST_ULONG_PTR_UNSET
1241 #undef TEST_ULONG_UNSET
1242 #undef TEST_POINTER_UNSET
1243 #undef TEST_ZERO
1244 }
1245
1246 static void test_client_init(void)
1247 {
1248 MIDL_STUB_MESSAGE stubMsg;
1249 RPC_MESSAGE rpcMsg;
1250 void *unset_ptr;
1251
1252 memset(&rpcMsg, 0xcc, sizeof(rpcMsg));
1253 memset(&stubMsg, 0xcc, sizeof(stubMsg));
1254 memset(&unset_ptr, 0xcc, sizeof(unset_ptr));
1255
1256 NdrClientInitializeNew(&rpcMsg, &stubMsg, &Object_StubDesc, 1);
1257
1258 test_common_stub_data( "NdrClientInitializeNew", &stubMsg );
1259
1260 ok(stubMsg.RpcMsg == &rpcMsg, "stubMsg.RpcMsg should have been %p instead of %p\n", &rpcMsg, stubMsg.RpcMsg);
1261 ok(rpcMsg.Handle == NULL, "rpcMsg.Handle should have been NULL instead of %p\n", rpcMsg.Handle);
1262 ok(rpcMsg.Buffer == unset_ptr, "rpcMsg.Buffer should have been unset instead of %p\n",
1263 rpcMsg.Buffer);
1264 ok(rpcMsg.BufferLength == 0xcccccccc, "rpcMsg.BufferLength should have been unset instead of %d\n", rpcMsg.BufferLength);
1265 ok(rpcMsg.ProcNum == 0x8001, "rpcMsg.ProcNum should have been 0x8001 instead of 0x%x\n", rpcMsg.ProcNum);
1266 ok(rpcMsg.TransferSyntax == unset_ptr, "rpcMsg.TransferSyntax should have been unset instead of %p\n", rpcMsg.TransferSyntax);
1267 ok(rpcMsg.RpcInterfaceInformation == Object_StubDesc.RpcInterfaceInformation,
1268 "rpcMsg.RpcInterfaceInformation should have been %p instead of %p\n",
1269 Object_StubDesc.RpcInterfaceInformation, rpcMsg.RpcInterfaceInformation);
1270 /* Note: ReservedForRuntime not tested */
1271 ok(rpcMsg.ManagerEpv == unset_ptr, "rpcMsg.ManagerEpv should have been unset instead of %p\n", rpcMsg.ManagerEpv);
1272 ok(rpcMsg.ImportContext == unset_ptr, "rpcMsg.ImportContext should have been unset instead of %p\n", rpcMsg.ImportContext);
1273 ok(rpcMsg.RpcFlags == 0, "rpcMsg.RpcFlags should have been 0 instead of 0x%x\n", rpcMsg.RpcFlags);
1274
1275 ok(stubMsg.Buffer == unset_ptr, "stubMsg.Buffer should have been unset instead of %p\n",
1276 stubMsg.Buffer);
1277 ok(stubMsg.BufferStart == NULL, "stubMsg.BufferStart should have been NULL instead of %p\n",
1278 stubMsg.BufferStart);
1279 ok(stubMsg.BufferEnd == NULL, "stubMsg.BufferEnd should have been NULL instead of %p\n",
1280 stubMsg.BufferEnd);
1281 ok(stubMsg.BufferLength == 0, "stubMsg.BufferLength should have been 0 instead of %u\n",
1282 stubMsg.BufferLength);
1283 ok(stubMsg.IsClient == 1, "stubMsg.IsClient should have been 1 instead of %u\n", stubMsg.IsClient);
1284 ok(stubMsg.ReuseBuffer == 0, "stubMsg.ReuseBuffer should have been 0 instead of %d\n",
1285 stubMsg.ReuseBuffer);
1286 ok(stubMsg.CorrDespIncrement == 0, "stubMsg.CorrDespIncrement should have been 0 instead of %d\n",
1287 stubMsg.CorrDespIncrement);
1288 ok(stubMsg.FullPtrXlatTables == unset_ptr, "stubMsg.FullPtrXlatTables should have been unset instead of %p\n",
1289 stubMsg.FullPtrXlatTables);
1290 }
1291
1292 static void test_server_init(void)
1293 {
1294 MIDL_STUB_MESSAGE stubMsg;
1295 RPC_MESSAGE rpcMsg;
1296 unsigned char *ret;
1297 unsigned char buffer[256];
1298
1299 memset(&rpcMsg, 0, sizeof(rpcMsg));
1300 rpcMsg.Buffer = buffer;
1301 rpcMsg.BufferLength = sizeof(buffer);
1302 rpcMsg.RpcFlags = RPC_BUFFER_COMPLETE;
1303
1304 memset(&stubMsg, 0xcc, sizeof(stubMsg));
1305
1306 ret = NdrServerInitializeNew(&rpcMsg, &stubMsg, &Object_StubDesc);
1307 ok(ret == NULL, "NdrServerInitializeNew should have returned NULL instead of %p\n", ret);
1308
1309 test_common_stub_data( "NdrServerInitializeNew", &stubMsg );
1310
1311 ok(stubMsg.RpcMsg == &rpcMsg, "stubMsg.RpcMsg should have been %p instead of %p\n", &rpcMsg, stubMsg.RpcMsg);
1312 ok(stubMsg.Buffer == buffer, "stubMsg.Buffer should have been %p instead of %p\n", buffer, stubMsg.Buffer);
1313 ok(stubMsg.BufferStart == buffer, "stubMsg.BufferStart should have been %p instead of %p\n", buffer, stubMsg.BufferStart);
1314 ok(stubMsg.BufferEnd == buffer + sizeof(buffer), "stubMsg.BufferEnd should have been %p instead of %p\n", buffer + sizeof(buffer), stubMsg.BufferEnd);
1315 todo_wine
1316 ok(stubMsg.BufferLength == 0, "stubMsg.BufferLength should have been 0 instead of %u\n", stubMsg.BufferLength);
1317 ok(stubMsg.IsClient == 0, "stubMsg.IsClient should have been 0 instead of %u\n", stubMsg.IsClient);
1318 ok(stubMsg.ReuseBuffer == 0 ||
1319 broken(stubMsg.ReuseBuffer == 1), /* win2k */
1320 "stubMsg.ReuseBuffer should have been set to zero instead of %d\n", stubMsg.ReuseBuffer);
1321 ok(stubMsg.CorrDespIncrement == 0xcc ||
1322 stubMsg.CorrDespIncrement == 0,
1323 "CorrDespIncrement should have been unset instead of 0x%x\n", stubMsg.CorrDespIncrement);
1324 ok(stubMsg.FullPtrXlatTables == 0, "stubMsg.BufferLength should have been 0 instead of %p\n", stubMsg.FullPtrXlatTables);
1325 }
1326
1327 static void test_ndr_allocate(void)
1328 {
1329 RPC_MESSAGE RpcMessage;
1330 MIDL_STUB_MESSAGE StubMsg;
1331 MIDL_STUB_DESC StubDesc;
1332 void *p1, *p2;
1333 struct tag_mem_list_v2_t
1334 {
1335 DWORD magic;
1336 DWORD size;
1337 DWORD unknown;
1338 struct tag_mem_list_v2_t *next;
1339 } *mem_list_v2;
1340 const DWORD magic_MEML = 'M' << 24 | 'E' << 16 | 'M' << 8 | 'L';
1341
1342 StubDesc = Object_StubDesc;
1343 NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 0);
1344
1345 my_alloc_called = my_free_called = 0;
1346 p1 = NdrAllocate(&StubMsg, 10);
1347 p2 = NdrAllocate(&StubMsg, 24);
1348 ok(my_alloc_called == 2, "alloc called %d\n", my_alloc_called);
1349 ok(StubMsg.pMemoryList != NULL, "StubMsg.pMemoryList NULL\n");
1350 if(StubMsg.pMemoryList)
1351 {
1352 mem_list_v2 = StubMsg.pMemoryList;
1353 if (mem_list_v2->size == 24)
1354 {
1355 trace("v2 mem list format\n");
1356 ok((char *)mem_list_v2 == (char *)p2 + 24, "expected mem_list_v2 pointer %p, but got %p\n", (char *)p2 + 24, mem_list_v2);
1357 ok(mem_list_v2->magic == magic_MEML, "magic %08x\n", mem_list_v2->magic);
1358 ok(mem_list_v2->size == 24, "wrong size for p2 %d\n", mem_list_v2->size);
1359 ok(mem_list_v2->unknown == 0, "wrong unknown for p2 0x%x\n", mem_list_v2->unknown);
1360 ok(mem_list_v2->next != NULL, "next NULL\n");
1361 mem_list_v2 = mem_list_v2->next;
1362 if(mem_list_v2)
1363 {
1364 ok((char *)mem_list_v2 == (char *)p1 + 16, "expected mem_list_v2 pointer %p, but got %p\n", (char *)p1 + 16, mem_list_v2);
1365 ok(mem_list_v2->magic == magic_MEML, "magic %08x\n", mem_list_v2->magic);
1366 ok(mem_list_v2->size == 16, "wrong size for p1 %d\n", mem_list_v2->size);
1367 ok(mem_list_v2->unknown == 0, "wrong unknown for p1 0x%x\n", mem_list_v2->unknown);
1368 ok(mem_list_v2->next == NULL, "next %p\n", mem_list_v2->next);
1369 }
1370 }
1371 else win_skip("v1 mem list format\n");
1372 }
1373 /* NdrFree isn't exported so we can't test free'ing */
1374 }
1375
1376 static void test_conformant_array(void)
1377 {
1378 RPC_MESSAGE RpcMessage;
1379 MIDL_STUB_MESSAGE StubMsg;
1380 MIDL_STUB_DESC StubDesc;
1381 void *ptr;
1382 unsigned char *mem, *mem_orig;
1383 unsigned char memsrc[20];
1384 unsigned int i;
1385
1386 static const unsigned char fmtstr_conf_array[] =
1387 {
1388 0x1b, /* FC_CARRAY */
1389 0x0, /* align */
1390 NdrFcShort( 0x1 ), /* elem size */
1391 0x40, /* Corr desc: const */
1392 0x0,
1393 NdrFcShort(0x10), /* const = 0x10 */
1394 0x1, /* FC_BYTE */
1395 0x5b /* FC_END */
1396 };
1397
1398 for (i = 0; i < sizeof(memsrc); i++)
1399 memsrc[i] = i * i;
1400
1401 StubDesc = Object_StubDesc;
1402 StubDesc.pFormatTypes = fmtstr_conf_array;
1403
1404 NdrClientInitializeNew(
1405 &RpcMessage,
1406 &StubMsg,
1407 &StubDesc,
1408 0);
1409
1410 StubMsg.BufferLength = 0;
1411 NdrConformantArrayBufferSize( &StubMsg,
1412 memsrc,
1413 fmtstr_conf_array );
1414 ok(StubMsg.BufferLength >= 20, "length %d\n", StubMsg.BufferLength);
1415
1416 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1417 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
1418 StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
1419
1420 ptr = NdrConformantArrayMarshall( &StubMsg, memsrc, fmtstr_conf_array );
1421 ok(ptr == NULL, "ret %p\n", ptr);
1422 ok(StubMsg.Buffer - StubMsg.BufferStart == 20, "Buffer %p Start %p len %d\n", StubMsg.Buffer, StubMsg.BufferStart, 20);
1423 ok(!memcmp(StubMsg.BufferStart + 4, memsrc, 16), "incorrectly marshaled\n");
1424
1425 StubMsg.Buffer = StubMsg.BufferStart;
1426 StubMsg.MemorySize = 0;
1427 mem = NULL;
1428
1429 /* Client */
1430 my_alloc_called = 0;
1431 /* passing mem == NULL with must_alloc == 0 crashes under Windows */
1432 NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
1433 ok(mem != NULL, "mem not alloced\n");
1434 ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1435 ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1436
1437 my_alloc_called = 0;
1438 StubMsg.Buffer = StubMsg.BufferStart;
1439 mem_orig = mem;
1440 NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
1441 ok(mem == mem_orig, "mem alloced\n");
1442 ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1443 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1444
1445 my_alloc_called = 0;
1446 StubMsg.Buffer = StubMsg.BufferStart;
1447 NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
1448 ok(mem != mem_orig, "mem not alloced\n");
1449 ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1450 ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1451
1452 my_free_called = 0;
1453 StubMsg.Buffer = StubMsg.BufferStart;
1454 NdrConformantArrayFree( &StubMsg, mem, fmtstr_conf_array );
1455 ok(my_free_called == 0, "free called %d\n", my_free_called);
1456 StubMsg.pfnFree(mem);
1457
1458 /* Server */
1459 my_alloc_called = 0;
1460 StubMsg.IsClient = 0;
1461 mem = NULL;
1462 StubMsg.Buffer = StubMsg.BufferStart;
1463 NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
1464 ok(mem == StubMsg.BufferStart + 4 || broken(!mem), /* win9x, nt4 */
1465 "mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 4);
1466 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1467 my_alloc_called = 0;
1468 mem = NULL;
1469 StubMsg.Buffer = StubMsg.BufferStart;
1470 NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
1471 ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1472 ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1473 StubMsg.pfnFree(mem);
1474
1475 my_alloc_called = 0;
1476 mem = mem_orig;
1477 StubMsg.Buffer = StubMsg.BufferStart;
1478 NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
1479 ok(mem == mem_orig, "mem alloced\n");
1480 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1481
1482 my_alloc_called = 0;
1483 mem = mem_orig;
1484 StubMsg.Buffer = StubMsg.BufferStart;
1485 NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
1486 ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1487 ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1488 StubMsg.pfnFree(mem);
1489 StubMsg.pfnFree(mem_orig);
1490
1491 HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
1492 }
1493
1494 static void test_conformant_string(void)
1495 {
1496 RPC_MESSAGE RpcMessage;
1497 MIDL_STUB_MESSAGE StubMsg;
1498 MIDL_STUB_DESC StubDesc;
1499 DWORD size;
1500 void *ptr;
1501 unsigned char *mem, *mem_orig;
1502 char memsrc[] = "This is a test string";
1503
1504 static const unsigned char fmtstr_conf_str[] =
1505 {
1506 0x11, 0x8, /* FC_RP [simple_pointer] */
1507 0x22, /* FC_C_CSTRING */
1508 0x5c, /* FC_PAD */
1509 };
1510
1511 StubDesc = Object_StubDesc;
1512 StubDesc.pFormatTypes = fmtstr_conf_str;
1513
1514 memset( &StubMsg, 0, sizeof(StubMsg) ); /* needed on win9x and nt4 */
1515 NdrClientInitializeNew(
1516 &RpcMessage,
1517 &StubMsg,
1518 &StubDesc,
1519 0);
1520
1521 StubMsg.BufferLength = 0;
1522 NdrPointerBufferSize( &StubMsg,
1523 (unsigned char *)memsrc,
1524 fmtstr_conf_str );
1525 ok(StubMsg.BufferLength >= sizeof(memsrc) + 12, "length %d\n", StubMsg.BufferLength);
1526
1527 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1528 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
1529 StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
1530
1531 ptr = NdrPointerMarshall( &StubMsg, (unsigned char *)memsrc, fmtstr_conf_str );
1532 ok(ptr == NULL, "ret %p\n", ptr);
1533 size = StubMsg.Buffer - StubMsg.BufferStart;
1534 ok(size == sizeof(memsrc) + 12, "Buffer %p Start %p len %d\n",
1535 StubMsg.Buffer, StubMsg.BufferStart, size);
1536 ok(!memcmp(StubMsg.BufferStart + 12, memsrc, sizeof(memsrc)), "incorrectly marshaled\n");
1537
1538 StubMsg.Buffer = StubMsg.BufferStart;
1539 StubMsg.MemorySize = 0;
1540 mem = NULL;
1541
1542 /* Client */
1543 my_alloc_called = 0;
1544 StubMsg.Buffer = StubMsg.BufferStart;
1545 mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
1546 /* Windows apparently checks string length on the output buffer to determine its size... */
1547 memset( mem, 'x', sizeof(memsrc) - 1 );
1548 mem[sizeof(memsrc) - 1] = 0;
1549 NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
1550 ok(mem == mem_orig, "mem not alloced\n");
1551 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1552
1553 my_alloc_called = 0;
1554 StubMsg.Buffer = StubMsg.BufferStart;
1555 NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
1556 todo_wine {
1557 ok(mem == mem_orig, "mem not alloced\n");
1558 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1559 }
1560
1561 my_free_called = 0;
1562 StubMsg.Buffer = StubMsg.BufferStart;
1563 NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
1564 ok(my_free_called == 1, "free called %d\n", my_free_called);
1565
1566 mem = my_alloc(10);
1567 my_free_called = 0;
1568 StubMsg.Buffer = StubMsg.BufferStart;
1569 NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
1570 ok(my_free_called == 1, "free called %d\n", my_free_called);
1571
1572 /* Server */
1573 my_alloc_called = 0;
1574 StubMsg.IsClient = 0;
1575 mem = NULL;
1576 StubMsg.Buffer = StubMsg.BufferStart;
1577 NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
1578 ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
1579 "mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
1580 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1581
1582 my_alloc_called = 0;
1583 mem = NULL;
1584 StubMsg.Buffer = StubMsg.BufferStart;
1585 NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
1586 todo_wine {
1587 ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
1588 "mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
1589 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1590 }
1591
1592 my_alloc_called = 0;
1593 mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
1594 StubMsg.Buffer = StubMsg.BufferStart;
1595 NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
1596 ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
1597 "mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
1598 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1599
1600 my_alloc_called = 0;
1601 mem = mem_orig;
1602 StubMsg.Buffer = StubMsg.BufferStart;
1603 NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
1604 todo_wine {
1605 ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
1606 "mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
1607 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1608 }
1609
1610 mem = my_alloc(10);
1611 my_free_called = 0;
1612 StubMsg.Buffer = StubMsg.BufferStart;
1613 NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
1614 ok(my_free_called == 1, "free called %d\n", my_free_called);
1615
1616 HeapFree(GetProcessHeap(), 0, mem_orig);
1617 HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
1618 }
1619
1620 static void test_nonconformant_string(void)
1621 {
1622 RPC_MESSAGE RpcMessage;
1623 MIDL_STUB_MESSAGE StubMsg;
1624 MIDL_STUB_DESC StubDesc;
1625 DWORD size;
1626 void *ptr;
1627 unsigned char *mem, *mem_orig;
1628 unsigned char memsrc[10] = "This is";
1629 unsigned char memsrc2[10] = "This is a";
1630
1631 static const unsigned char fmtstr_nonconf_str[] =
1632 {
1633 0x26, /* FC_CSTRING */
1634 0x5c, /* FC_PAD */
1635 NdrFcShort( 0xa ), /* 10 */
1636 };
1637
1638 StubDesc = Object_StubDesc;
1639 StubDesc.pFormatTypes = fmtstr_nonconf_str;
1640
1641 /* length < size */
1642 NdrClientInitializeNew(
1643 &RpcMessage,
1644 &StubMsg,
1645 &StubDesc,
1646 0);
1647
1648 StubMsg.BufferLength = 0;
1649
1650 NdrNonConformantStringBufferSize( &StubMsg, memsrc, fmtstr_nonconf_str );
1651 ok(StubMsg.BufferLength >= strlen((char *)memsrc) + 1 + 8, "length %d\n", StubMsg.BufferLength);
1652
1653 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1654 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
1655 StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
1656
1657 ptr = NdrNonConformantStringMarshall( &StubMsg, memsrc, fmtstr_nonconf_str );
1658 ok(ptr == NULL, "ret %p\n", ptr);
1659 size = StubMsg.Buffer - StubMsg.BufferStart;
1660 ok(size == strlen((char *)memsrc) + 1 + 8, "Buffer %p Start %p len %d\n",
1661 StubMsg.Buffer, StubMsg.BufferStart, size);
1662 ok(!memcmp(StubMsg.BufferStart + 8, memsrc, strlen((char *)memsrc) + 1), "incorrectly marshaled\n");
1663
1664 StubMsg.Buffer = StubMsg.BufferStart;
1665 StubMsg.MemorySize = 0;
1666 mem = NULL;
1667
1668 /* Client */
1669 my_alloc_called = 0;
1670 StubMsg.Buffer = StubMsg.BufferStart;
1671 mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
1672 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1673 ok(mem == mem_orig, "mem alloced\n");
1674 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1675
1676 my_alloc_called = 0;
1677 StubMsg.Buffer = StubMsg.BufferStart;
1678 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
1679 todo_wine
1680 ok(mem == mem_orig, "mem alloced\n");
1681 todo_wine
1682 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1683
1684 /* Server */
1685 my_alloc_called = 0;
1686 StubMsg.IsClient = 0;
1687 mem = NULL;
1688 StubMsg.Buffer = StubMsg.BufferStart;
1689 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1690 ok(mem != mem_orig, "mem not alloced\n");
1691 ok(mem != StubMsg.BufferStart + 8, "mem pointing at buffer\n");
1692 ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1693 NdrOleFree(mem);
1694
1695 my_alloc_called = 0;
1696 mem = mem_orig;
1697 StubMsg.Buffer = StubMsg.BufferStart;
1698 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1699 ok(mem == mem_orig, "mem alloced\n");
1700 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1701
1702 my_alloc_called = 0;
1703 mem = mem_orig;
1704 StubMsg.Buffer = StubMsg.BufferStart;
1705 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
1706 todo_wine
1707 ok(mem == mem_orig, "mem alloced\n");
1708 todo_wine
1709 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1710
1711 HeapFree(GetProcessHeap(), 0, mem_orig);
1712 HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
1713
1714 /* length = size */
1715 NdrClientInitializeNew(
1716 &RpcMessage,
1717 &StubMsg,
1718 &StubDesc,
1719 0);
1720
1721 StubMsg.BufferLength = 0;
1722
1723 NdrNonConformantStringBufferSize( &StubMsg, memsrc2, fmtstr_nonconf_str );
1724 ok(StubMsg.BufferLength >= strlen((char *)memsrc2) + 1 + 8, "length %d\n", StubMsg.BufferLength);
1725
1726 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1727 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
1728 StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
1729
1730 ptr = NdrNonConformantStringMarshall( &StubMsg, memsrc2, fmtstr_nonconf_str );
1731 ok(ptr == NULL, "ret %p\n", ptr);
1732 size = StubMsg.Buffer - StubMsg.BufferStart;
1733 ok(size == strlen((char *)memsrc2) + 1 + 8, "Buffer %p Start %p len %d\n",
1734 StubMsg.Buffer, StubMsg.BufferStart, size);
1735 ok(!memcmp(StubMsg.BufferStart + 8, memsrc2, strlen((char *)memsrc2) + 1), "incorrectly marshaled\n");
1736
1737 StubMsg.Buffer = StubMsg.BufferStart;
1738 StubMsg.MemorySize = 0;
1739 mem = NULL;
1740
1741 /* Client */
1742 my_alloc_called = 0;
1743 StubMsg.Buffer = StubMsg.BufferStart;
1744 mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
1745 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1746 ok(mem == mem_orig, "mem alloced\n");
1747 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1748
1749 my_alloc_called = 0;
1750 StubMsg.Buffer = StubMsg.BufferStart;
1751 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
1752 todo_wine
1753 ok(mem == mem_orig, "mem alloced\n");
1754 todo_wine
1755 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1756
1757 /* Server */
1758 my_alloc_called = 0;
1759 StubMsg.IsClient = 0;
1760 mem = NULL;
1761 StubMsg.Buffer = StubMsg.BufferStart;
1762 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1763 ok(mem != mem_orig, "mem not alloced\n");
1764 ok(mem != StubMsg.BufferStart + 8, "mem pointing at buffer\n");
1765 ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1766 NdrOleFree(mem);
1767
1768 my_alloc_called = 0;
1769 mem = mem_orig;
1770 StubMsg.Buffer = StubMsg.BufferStart;
1771 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1772 ok(mem == mem_orig, "mem alloced\n");
1773 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1774
1775 my_alloc_called = 0;
1776 mem = mem_orig;
1777 StubMsg.Buffer = StubMsg.BufferStart;
1778 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
1779 todo_wine
1780 ok(mem == mem_orig, "mem alloced\n");
1781 todo_wine
1782 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1783
1784 HeapFree(GetProcessHeap(), 0, mem_orig);
1785 HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
1786 }
1787
1788 static void test_conf_complex_struct(void)
1789 {
1790 RPC_MESSAGE RpcMessage;
1791 MIDL_STUB_MESSAGE StubMsg;
1792 MIDL_STUB_DESC StubDesc;
1793 void *ptr;
1794 unsigned int i;
1795 struct conf_complex
1796 {
1797 unsigned int size;
1798 unsigned int *array[1];
1799 };
1800 struct conf_complex *memsrc;
1801 struct conf_complex *mem;
1802
1803 static const unsigned char fmtstr_complex_struct[] =
1804 {
1805 /* 0 */
1806 0x1b, /* FC_CARRAY */
1807 0x3, /* 3 */
1808 /* 2 */ NdrFcShort( 0x4 ), /* 4 */
1809 /* 4 */ 0x8, /* Corr desc: FC_LONG */
1810 0x0, /* */
1811 /* 6 */ NdrFcShort( 0xfffc ), /* -4 */
1812 /* 8 */
1813 0x4b, /* FC_PP */
1814 0x5c, /* FC_PAD */
1815 /* 10 */
1816 0x48, /* FC_VARIABLE_REPEAT */
1817 0x49, /* FC_FIXED_OFFSET */
1818 /* 12 */ NdrFcShort( 0x4 ), /* 4 */
1819 /* 14 */ NdrFcShort( 0x0 ), /* 0 */
1820 /* 16 */ NdrFcShort( 0x1 ), /* 1 */
1821 /* 18 */ NdrFcShort( 0x0 ), /* 0 */
1822 /* 20 */ NdrFcShort( 0x0 ), /* 0 */
1823 /* 22 */ 0x12, 0x8, /* FC_UP [simple_pointer] */
1824 /* 24 */ 0x8, /* FC_LONG */
1825 0x5c, /* FC_PAD */
1826 /* 26 */
1827 0x5b, /* FC_END */
1828
1829 0x8, /* FC_LONG */
1830 /* 28 */ 0x5c, /* FC_PAD */
1831 0x5b, /* FC_END */
1832 /* 30 */
1833 0x1a, /* FC_BOGUS_STRUCT */
1834 0x3, /* 3 */
1835 /* 32 */ NdrFcShort( 0x4 ), /* 4 */
1836 /* 34 */ NdrFcShort( 0xffffffde ), /* Offset= -34 (0) */
1837 /* 36 */ NdrFcShort( 0x0 ), /* Offset= 0 (36) */
1838 /* 38 */ 0x8, /* FC_LONG */
1839 0x5b, /* FC_END */
1840 };
1841
1842 memsrc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1843 FIELD_OFFSET(struct conf_complex, array[20]));
1844 memsrc->size = 20;
1845
1846 StubDesc = Object_StubDesc;
1847 StubDesc.pFormatTypes = fmtstr_complex_struct;
1848
1849 NdrClientInitializeNew(
1850 &RpcMessage,
1851 &StubMsg,
1852 &StubDesc,
1853 0);
1854
1855 StubMsg.BufferLength = 0;
1856 NdrComplexStructBufferSize( &StubMsg,
1857 (unsigned char *)memsrc,
1858 &fmtstr_complex_struct[30] );
1859 ok(StubMsg.BufferLength >= 28, "length %d\n", StubMsg.BufferLength);
1860
1861 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1862 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
1863 StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
1864
1865 ptr = NdrComplexStructMarshall( &StubMsg, (unsigned char *)memsrc,
1866 &fmtstr_complex_struct[30] );
1867 ok(ptr == NULL, "ret %p\n", ptr);
1868 ok(*(unsigned int *)StubMsg.BufferStart == 20, "Conformance should have been 20 instead of %d\n", *(unsigned int *)StubMsg.BufferStart);
1869 ok(*(unsigned int *)(StubMsg.BufferStart + 4) == 20, "conf_complex.size should have been 20 instead of %d\n", *(unsigned int *)(StubMsg.BufferStart + 4));
1870 for (i = 0; i < 20; i++)
1871 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));
1872
1873 /* Server */
1874 my_alloc_called = 0;
1875 StubMsg.IsClient = 0;
1876 mem = NULL;
1877 StubMsg.Buffer = StubMsg.BufferStart;
1878 ptr = NdrComplexStructUnmarshall( &StubMsg, (unsigned char **)&mem, &fmtstr_complex_struct[30], 0);
1879 ok(ptr == NULL, "ret %p\n", ptr);
1880 ok(mem->size == 20, "mem->size wasn't unmarshalled correctly (%d)\n", mem->size);
1881 ok(mem->array[0] == NULL, "mem->array[0] wasn't unmarshalled correctly (%p)\n", mem->array[0]);
1882 StubMsg.pfnFree(mem);
1883
1884 HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
1885 HeapFree(GetProcessHeap(), 0, memsrc);
1886 }
1887
1888
1889 static void test_conf_complex_array(void)
1890 {
1891 RPC_MESSAGE RpcMessage;
1892 MIDL_STUB_MESSAGE StubMsg;
1893 MIDL_STUB_DESC StubDesc;
1894 void *ptr;
1895 unsigned int i, j;
1896 struct conf_complex
1897 {
1898 unsigned int dim1, dim2;
1899 DWORD **array;
1900 };
1901 struct conf_complex memsrc;
1902 struct conf_complex *mem;
1903 DWORD *buf, expected_length;
1904
1905 static const unsigned char fmtstr_complex_array[] =
1906 {
1907
1908 /* 0 */ 0x21, /* FC_BOGUS_ARRAY */
1909 0x3, /* 3 */
1910 /* 2 */ NdrFcShort( 0x0 ), /* 0 */
1911 /* 4 */ 0x19, 0x0, /* Corr desc: field pointer, FC_ULONG */
1912 /* 6 */ NdrFcShort( 0x4 ), /* 4 */
1913 /* 8 */ NdrFcLong( 0xffffffff ), /* -1 */
1914 /* 12 */ 0x8, /* FC_LONG */
1915 0x5b, /* FC_END */
1916 /* 14 */
1917 0x21, /* FC_BOGUS_ARRAY */
1918 0x3, /* 3 */
1919 /* 16 */ NdrFcShort( 0x0 ), /* 0 */
1920 /* 18 */ 0x19, /* Corr desc: field pointer, FC_ULONG */
1921 0x0, /* */
1922 /* 20 */ NdrFcShort( 0x0 ), /* 0 */
1923 /* 22 */ NdrFcLong( 0xffffffff ), /* -1 */
1924 /* 26 */ 0x12, 0x0, /* FC_UP */
1925 /* 28 */ NdrFcShort( 0xffe4 ), /* Offset= -28 (0) */
1926 /* 30 */ 0x5c, /* FC_PAD */
1927 0x5b, /* FC_END */
1928
1929 #ifdef _WIN64
1930 /* 32 */ 0x1a, /* FC_BOGUS_STRUCT */
1931 0x3, /* 3 */
1932 /* 34 */ NdrFcShort( 0x10 ), /* 16 */
1933 /* 36 */ NdrFcShort( 0x0 ), /* 0 */
1934 /* 38 */ NdrFcShort( 0x6 ), /* Offset= 6 (44) */
1935 /* 40 */ 0x8, /* FC_LONG */
1936 0x8, /* FC_LONG */
1937 /* 42 */ 0x36, /* FC_POINTER */
1938 0x5b, /* FC_END */
1939 /* 44 */
1940 0x12, 0x0, /* FC_UP */
1941 /* 46 */ NdrFcShort( 0xffe0 ), /* Offset= -32 (14) */
1942 #else
1943 /* 32 */
1944 0x16, /* FC_PSTRUCT */
1945 0x3, /* 3 */
1946 /* 34 */ NdrFcShort( 0xc ), /* 12 */
1947 /* 36 */ 0x4b, /* FC_PP */
1948 0x5c, /* FC_PAD */
1949 /* 38 */ 0x46, /* FC_NO_REPEAT */
1950 0x5c, /* FC_PAD */
1951 /* 40 */ NdrFcShort( 0x8 ), /* 8 */
1952 /* 42 */ NdrFcShort( 0x8 ), /* 8 */
1953 /* 44 */ 0x12, 0x0, /* FC_UP */
1954 /* 46 */ NdrFcShort( 0xffe0 ), /* Offset= -32 (14) */
1955 /* 48 */ 0x5b, /* FC_END */
1956 0x8, /* FC_LONG */
1957 /* 50 */ 0x8, /* FC_LONG */
1958 0x8, /* FC_LONG */
1959 /* 52 */ 0x5c, /* FC_PAD */
1960 0x5b, /* FC_END */
1961 #endif
1962 };
1963
1964 memsrc.dim1 = 5;
1965 memsrc.dim2 = 3;
1966
1967 memsrc.array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, memsrc.dim1 * sizeof(DWORD*));
1968
1969 for(i = 0; i < memsrc.dim1; i++)
1970 {
1971 memsrc.array[i] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, memsrc.dim2 * sizeof(DWORD));
1972 for(j = 0; j < memsrc.dim2; j++)
1973 memsrc.array[i][j] = i * memsrc.dim2 + j;
1974 }
1975
1976 StubDesc = Object_StubDesc;
1977 StubDesc.pFormatTypes = fmtstr_complex_array;
1978
1979 NdrClientInitializeNew(
1980 &RpcMessage,
1981 &StubMsg,
1982 &StubDesc,
1983 0);
1984
1985 StubMsg.BufferLength = 0;
1986
1987 #ifdef _WIN64
1988 NdrComplexStructBufferSize( &StubMsg,
1989 (unsigned char *)&memsrc,
1990 &fmtstr_complex_array[32] );
1991 #else
1992 NdrSimpleStructBufferSize( &StubMsg,
1993 (unsigned char *)&memsrc,
1994 &fmtstr_complex_array[32] );
1995 #endif
1996
1997 expected_length = (4 + memsrc.dim1 * (2 + memsrc.dim2)) * 4;
1998 if (StubMsg.BufferLength == 96)
1999 {
2000 win_skip("Tests crash on Win9x, WinMe and NT4\n");
2001 goto cleanup;
2002 }
2003 ok(StubMsg.BufferLength >= expected_length, "length %d\n", StubMsg.BufferLength);
2004
2005 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
2006 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
2007 StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
2008
2009 #ifdef _WIN64
2010 ptr = NdrComplexStructMarshall( &StubMsg, (unsigned char *)&memsrc,
2011 &fmtstr_complex_array[32] );
2012 #else
2013 ptr = NdrSimpleStructMarshall( &StubMsg, (unsigned char *)&memsrc,
2014 &fmtstr_complex_array[32] );
2015 #endif
2016
2017 ok(ptr == NULL, "ret %p\n", ptr);
2018 ok((char*)StubMsg.Buffer == (char*)StubMsg.BufferStart + expected_length, "not at expected length\n");
2019
2020 buf = (DWORD *)StubMsg.BufferStart;
2021
2022 ok(*buf == memsrc.dim1, "dim1 should have been %d instead of %08x\n", memsrc.dim1, *buf);
2023 buf++;
2024 ok(*buf == memsrc.dim2, "dim2 should have been %d instead of %08x\n", memsrc.dim2, *buf);
2025 buf++;
2026 ok(*buf != 0, "pointer id should be non-zero\n");
2027 buf++;
2028 ok(*buf == memsrc.dim1, "Conformance should have been %d instead of %08x\n", memsrc.dim1, *buf);
2029 buf++;
2030 for(i = 0; i < memsrc.dim1; i++)
2031 {
2032 ok(*buf != 0, "pointer id[%d] should be non-zero\n", i);
2033 buf++;
2034 }
2035 for(i = 0; i < memsrc.dim1; i++)
2036 {
2037 ok(*buf == memsrc.dim2, "Conformance should have been %d instead of %08x\n", memsrc.dim2, *buf);
2038 buf++;
2039 for(j = 0; j < memsrc.dim2; j++)
2040 {
2041 ok(*buf == i * memsrc.dim2 + j, "got %08x\n", *buf);
2042 buf++;
2043 }
2044 }
2045
2046 ok((void*)buf == StubMsg.Buffer, "not at end of buffer\n");
2047
2048 /* Server */
2049 my_alloc_called = 0;
2050 StubMsg.IsClient = 0;
2051 mem = NULL;
2052 StubMsg.Buffer = StubMsg.BufferStart;
2053 #ifdef _WIN64
2054 ptr = NdrComplexStructUnmarshall( &StubMsg, (unsigned char **)&mem, &fmtstr_complex_array[32], 0);
2055 #else
2056 ptr = NdrSimpleStructUnmarshall( &StubMsg, (unsigned char **)&mem, &fmtstr_complex_array[32], 0);
2057 #endif
2058 ok(ptr == NULL, "ret %p\n", ptr);
2059 ok(mem->dim1 == memsrc.dim1, "mem->dim1 wasn't unmarshalled correctly (%d)\n", mem->dim1);
2060 ok(mem->dim2 == memsrc.dim2, "mem->dim2 wasn't unmarshalled correctly (%d)\n", mem->dim2);
2061 ok(mem->array[1][0] == memsrc.dim2, "mem->array[1][0] wasn't unmarshalled correctly (%d)\n", mem->array[1][0]);
2062
2063 StubMsg.Buffer = StubMsg.BufferStart;
2064 #ifdef _WIN64
2065 NdrComplexStructFree( &StubMsg, (unsigned char*)mem, &fmtstr_complex_array[32]);
2066 #else
2067 NdrSimpleStructFree( &StubMsg, (unsigned char*)mem, &fmtstr_complex_array[32]);
2068 #endif
2069
2070 HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
2071
2072 cleanup:
2073 for(i = 0; i < memsrc.dim1; i++)
2074 HeapFree(GetProcessHeap(), 0, memsrc.array[i]);
2075 HeapFree(GetProcessHeap(), 0, memsrc.array);
2076 }
2077
2078 static void test_ndr_buffer(void)
2079 {
2080 static unsigned char ncalrpc[] = "ncalrpc";
2081 static unsigned char endpoint[] = "winetest:test_ndr_buffer";
2082 RPC_MESSAGE RpcMessage;
2083 MIDL_STUB_MESSAGE StubMsg;
2084 MIDL_STUB_DESC StubDesc = Object_StubDesc;
2085 unsigned char *ret;
2086 unsigned char *binding;
2087 RPC_BINDING_HANDLE Handle;
2088 RPC_STATUS status;
2089 ULONG prev_buffer_length;
2090 BOOL old_buffer_valid_location;
2091
2092 StubDesc.RpcInterfaceInformation = (void *)&IFoo___RpcServerInterface;
2093
2094 status = RpcServerUseProtseqEp(ncalrpc, 20, endpoint, NULL);
2095 ok(RPC_S_OK == status, "RpcServerUseProtseqEp failed with status %u\n", status);
2096 status = RpcServerRegisterIf(IFoo_v0_0_s_ifspec, NULL, NULL);
2097 ok(RPC_S_OK == status, "RpcServerRegisterIf failed with status %u\n", status);
2098 status = RpcServerListen(1, 20, TRUE);
2099 ok(RPC_S_OK == status, "RpcServerListen failed with status %u\n", status);
2100 if (status != RPC_S_OK)
2101 {
2102 /* Failed to create a server, running client tests is useless */
2103 return;
2104 }
2105
2106 status = RpcStringBindingCompose(NULL, ncalrpc, NULL, endpoint, NULL, &binding);
2107 ok(status == RPC_S_OK, "RpcStringBindingCompose failed (%u)\n", status);
2108
2109 status = RpcBindingFromStringBinding(binding, &Handle);
2110 ok(status == RPC_S_OK, "RpcBindingFromStringBinding failed (%u)\n", status);
2111 RpcStringFree(&binding);
2112
2113 NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 5);
2114
2115 ret = NdrGetBuffer(&StubMsg, 10, Handle);
2116 ok(ret == StubMsg.Buffer, "NdrGetBuffer should have returned the same value as StubMsg.Buffer instead of %p\n", ret);
2117 ok(RpcMessage.Handle != NULL, "RpcMessage.Handle should not have been NULL\n");
2118 ok(RpcMessage.Buffer != NULL, "RpcMessage.Buffer should not have been NULL\n");
2119 ok(RpcMessage.BufferLength == 10 ||
2120 broken(RpcMessage.BufferLength == 12), /* win2k */
2121 "RpcMessage.BufferLength should have been 10 instead of %d\n", RpcMessage.BufferLength);
2122 ok(RpcMessage.RpcFlags == 0, "RpcMessage.RpcFlags should have been 0x0 instead of 0x%x\n", RpcMessage.RpcFlags);
2123 ok(StubMsg.Buffer != NULL, "Buffer should not have been NULL\n");
2124 ok(!StubMsg.BufferStart, "BufferStart should have been NULL instead of %p\n", StubMsg.BufferStart);
2125 ok(!StubMsg.BufferEnd, "BufferEnd should have been NULL instead of %p\n", StubMsg.BufferEnd);
2126 todo_wine
2127 ok(StubMsg.BufferLength == 0, "BufferLength should have left as 0 instead of being set to %d\n", StubMsg.BufferLength);
2128 old_buffer_valid_location = !StubMsg.fBufferValid;
2129 if (old_buffer_valid_location)
2130 ok(broken(StubMsg.CorrDespIncrement == TRUE), "fBufferValid should have been TRUE instead of 0x%x\n", StubMsg.CorrDespIncrement);
2131 else
2132 ok(StubMsg.fBufferValid, "fBufferValid should have been non-zero instead of 0x%x\n", StubMsg.fBufferValid);
2133
2134 prev_buffer_length = RpcMessage.BufferLength;
2135 StubMsg.BufferLength = 1;
2136 NdrFreeBuffer(&StubMsg);
2137 ok(RpcMessage.Handle != NULL, "RpcMessage.Handle should not have been NULL\n");
2138 ok(RpcMessage.Buffer != NULL, "RpcMessage.Buffer should not have been NULL\n");
2139 ok(RpcMessage.BufferLength == prev_buffer_length, "RpcMessage.BufferLength should have been left as %d instead of %d\n", prev_buffer_length, RpcMessage.BufferLength);
2140 ok(StubMsg.Buffer != NULL, "Buffer should not have been NULL\n");
2141 ok(StubMsg.BufferLength == 1, "BufferLength should have left as 1 instead of being set to %d\n", StubMsg.BufferLength);
2142 if (old_buffer_valid_location)
2143 ok(broken(StubMsg.CorrDespIncrement == FALSE), "fBufferValid should have been FALSE instead of 0x%x\n", StubMsg.CorrDespIncrement);
2144 else
2145 ok(!StubMsg.fBufferValid, "fBufferValid should have been FALSE instead of %d\n", StubMsg.fBufferValid);
2146
2147 /* attempt double-free */
2148 NdrFreeBuffer(&StubMsg);
2149
2150 RpcBindingFree(&Handle);
2151
2152 status = RpcServerUnregisterIf(NULL, NULL, FALSE);
2153 ok(status == RPC_S_OK, "RpcServerUnregisterIf failed (%u)\n", status);
2154 }
2155
2156 static void test_NdrMapCommAndFaultStatus(void)
2157 {
2158 RPC_STATUS rpc_status;
2159 MIDL_STUB_MESSAGE StubMsg;
2160 RPC_MESSAGE RpcMessage;
2161
2162 NdrClientInitializeNew(&RpcMessage, &StubMsg, &Object_StubDesc, 5);
2163
2164 for (rpc_status = 0; rpc_status < 10000; rpc_status++)
2165 {
2166 RPC_STATUS status;
2167 ULONG comm_status = 0;
2168 ULONG fault_status = 0;
2169 ULONG expected_comm_status = 0;
2170 ULONG expected_fault_status = 0;
2171 status = NdrMapCommAndFaultStatus(&StubMsg, &comm_status, &fault_status, rpc_status);
2172 ok(status == RPC_S_OK, "NdrMapCommAndFaultStatus failed with error %d\n", status);
2173 switch (rpc_status)
2174 {
2175 case ERROR_INVALID_HANDLE:
2176 case RPC_S_INVALID_BINDING:
2177 case RPC_S_UNKNOWN_IF:
2178 case RPC_S_SERVER_UNAVAILABLE:
2179 case RPC_S_SERVER_TOO_BUSY:
2180 case RPC_S_CALL_FAILED_DNE:
2181 case RPC_S_PROTOCOL_ERROR:
2182 case RPC_S_UNSUPPORTED_TRANS_SYN:
2183 case RPC_S_UNSUPPORTED_TYPE:
2184 case RPC_S_PROCNUM_OUT_OF_RANGE:
2185 case EPT_S_NOT_REGISTERED:
2186 case RPC_S_COMM_FAILURE:
2187 expected_comm_status = rpc_status;
2188 break;
2189 default:
2190 expected_fault_status = rpc_status;
2191 }
2192 ok(comm_status == expected_comm_status, "NdrMapCommAndFaultStatus should have mapped %d to comm status %d instead of %d\n",
2193 rpc_status, expected_comm_status, comm_status);
2194 ok(fault_status == expected_fault_status, "NdrMapCommAndFaultStatus should have mapped %d to fault status %d instead of %d\n",
2195 rpc_status, expected_fault_status, fault_status);
2196 }
2197 }
2198
2199 static void test_NdrGetUserMarshalInfo(void)
2200 {
2201 RPC_STATUS status;
2202 MIDL_STUB_MESSAGE stubmsg;
2203 USER_MARSHAL_CB umcb;
2204 NDR_USER_MARSHAL_INFO umi;
2205 unsigned char buffer[16];
2206 void *rpc_channel_buffer = (void *)(ULONG_PTR)0xcafebabe;
2207 RPC_MESSAGE rpc_msg;
2208 RPC_STATUS (RPC_ENTRY *pNdrGetUserMarshalInfo)(ULONG *,ULONG,NDR_USER_MARSHAL_INFO *);
2209
2210 pNdrGetUserMarshalInfo = (void *)GetProcAddress(GetModuleHandle("rpcrt4.dll"), "NdrGetUserMarshalInfo");
2211 if (!pNdrGetUserMarshalInfo)
2212 {
2213 skip("NdrGetUserMarshalInfo not exported\n");
2214 return;
2215 }
2216
2217 /* unmarshall */
2218
2219 memset(&rpc_msg, 0xcc, sizeof(rpc_msg));
2220 rpc_msg.Buffer = buffer;
2221 rpc_msg.BufferLength = 16;
2222
2223 memset(&stubmsg, 0xcc, sizeof(stubmsg));
2224 stubmsg.RpcMsg = &rpc_msg;
2225 stubmsg.dwDestContext = MSHCTX_INPROC;
2226 stubmsg.pvDestContext = NULL;
2227 stubmsg.Buffer = buffer + 15;
2228 stubmsg.BufferLength = 0;
2229 stubmsg.BufferEnd = NULL;
2230 stubmsg.pRpcChannelBuffer = rpc_channel_buffer;
2231 stubmsg.StubDesc = NULL;
2232 stubmsg.pfnAllocate = my_alloc;
2233 stubmsg.pfnFree = my_free;
2234
2235 memset(&umcb, 0xcc, sizeof(umcb));
2236 umcb.Flags = MAKELONG(MSHCTX_INPROC, NDR_LOCAL_DATA_REPRESENTATION);
2237 umcb.pStubMsg = &stubmsg;
2238 umcb.Signature = USER_MARSHAL_CB_SIGNATURE;
2239 umcb.CBType = USER_MARSHAL_CB_UNMARSHALL;
2240
2241 memset(&umi, 0xaa, sizeof(umi));
2242
2243 status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2244 ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
2245 ok( umi.InformationLevel == 1,
2246 "umi.InformationLevel was %u instead of 1\n",
2247 umi.InformationLevel);
2248 ok( U1(umi).Level1.Buffer == buffer + 15,
2249 "umi.Level1.Buffer was %p instead of %p\n",
2250 U1(umi).Level1.Buffer, buffer);
2251 ok( U1(umi).Level1.BufferSize == 1,
2252 "umi.Level1.BufferSize was %u instead of 1\n",
2253 U1(umi).Level1.BufferSize);
2254 ok( U1(umi).Level1.pfnAllocate == my_alloc,
2255 "umi.Level1.pfnAllocate was %p instead of %p\n",
2256 U1(umi).Level1.pfnAllocate, my_alloc);
2257 ok( U1(umi).Level1.pfnFree == my_free,
2258 "umi.Level1.pfnFree was %p instead of %p\n",
2259 U1(umi).Level1.pfnFree, my_free);
2260 ok( U1(umi).Level1.pRpcChannelBuffer == rpc_channel_buffer,
2261 "umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
2262 U1(umi).Level1.pRpcChannelBuffer, rpc_channel_buffer);
2263
2264 /* buffer size */
2265
2266 rpc_msg.Buffer = buffer;
2267 rpc_msg.BufferLength = 16;
2268
2269 stubmsg.Buffer = buffer;
2270 stubmsg.BufferLength = 16;
2271 stubmsg.BufferEnd = NULL;
2272
2273 umcb.CBType = USER_MARSHAL_CB_BUFFER_SIZE;
2274
2275 memset(&umi, 0xaa, sizeof(umi));
2276
2277 status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2278 ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
2279 ok( umi.InformationLevel == 1,
2280 "umi.InformationLevel was %u instead of 1\n",
2281 umi.InformationLevel);
2282 ok( U1(umi).Level1.Buffer == NULL,
2283 "umi.Level1.Buffer was %p instead of NULL\n",
2284 U1(umi).Level1.Buffer);
2285 ok( U1(umi).Level1.BufferSize == 0,
2286 "umi.Level1.BufferSize was %u instead of 0\n",
2287 U1(umi).Level1.BufferSize);
2288 ok( U1(umi).Level1.pfnAllocate == my_alloc,
2289 "umi.Level1.pfnAllocate was %p instead of %p\n",
2290 U1(umi).Level1.pfnAllocate, my_alloc);
2291 ok( U1(umi).Level1.pfnFree == my_free,
2292 "umi.Level1.pfnFree was %p instead of %p\n",
2293 U1(umi).Level1.pfnFree, my_free);
2294 ok( U1(umi).Level1.pRpcChannelBuffer == rpc_channel_buffer,
2295 "umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
2296 U1(umi).Level1.pRpcChannelBuffer, rpc_channel_buffer);
2297
2298 /* marshall */
2299
2300 rpc_msg.Buffer = buffer;
2301 rpc_msg.BufferLength = 16;
2302
2303 stubmsg.Buffer = buffer + 15;
2304 stubmsg.BufferLength = 0;
2305 stubmsg.BufferEnd = NULL;
2306
2307 umcb.CBType = USER_MARSHAL_CB_MARSHALL;
2308
2309 memset(&umi, 0xaa, sizeof(umi));
2310
2311 status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2312 ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
2313 ok( umi.InformationLevel == 1,
2314 "umi.InformationLevel was %u instead of 1\n",
2315 umi.InformationLevel);
2316 ok( U1(umi).Level1.Buffer == buffer + 15,
2317 "umi.Level1.Buffer was %p instead of %p\n",
2318 U1(umi).Level1.Buffer, buffer);
2319 ok( U1(umi).Level1.BufferSize == 1,
2320 "umi.Level1.BufferSize was %u instead of 1\n",
2321 U1(umi).Level1.BufferSize);
2322 ok( U1(umi).Level1.pfnAllocate == my_alloc,
2323 "umi.Level1.pfnAllocate was %p instead of %p\n",
2324 U1(umi).Level1.pfnAllocate, my_alloc);
2325 ok( U1(umi).Level1.pfnFree == my_free,
2326 "umi.Level1.pfnFree was %p instead of %p\n",
2327 U1(umi).Level1.pfnFree, my_free);
2328 ok( U1(umi).Level1.pRpcChannelBuffer == rpc_channel_buffer,
2329 "umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
2330 U1(umi).Level1.pRpcChannelBuffer, rpc_channel_buffer);
2331
2332 /* free */
2333
2334 rpc_msg.Buffer = buffer;
2335 rpc_msg.BufferLength = 16;
2336
2337 stubmsg.Buffer = buffer;
2338 stubmsg.BufferLength = 16;
2339 stubmsg.BufferEnd = NULL;
2340
2341 umcb.CBType = USER_MARSHAL_CB_FREE;
2342
2343 memset(&umi, 0xaa, sizeof(umi));
2344
2345 status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2346 ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
2347 ok( umi.InformationLevel == 1,
2348 "umi.InformationLevel was %u instead of 1\n",
2349 umi.InformationLevel);
2350 ok( U1(umi).Level1.Buffer == NULL,
2351 "umi.Level1.Buffer was %p instead of NULL\n",
2352 U1(umi).Level1.Buffer);
2353 ok( U1(umi).Level1.BufferSize == 0,
2354 "umi.Level1.BufferSize was %u instead of 0\n",
2355 U1(umi).Level1.BufferSize);
2356 ok( U1(umi).Level1.pfnAllocate == my_alloc,
2357 "umi.Level1.pfnAllocate was %p instead of %p\n",
2358 U1(umi).Level1.pfnAllocate, my_alloc);
2359 ok( U1(umi).Level1.pfnFree == my_free,
2360 "umi.Level1.pfnFree was %p instead of %p\n",
2361 U1(umi).Level1.pfnFree, my_free);
2362 ok( U1(umi).Level1.pRpcChannelBuffer == rpc_channel_buffer,
2363 "umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
2364 U1(umi).Level1.pRpcChannelBuffer, rpc_channel_buffer);
2365
2366 /* boundary test */
2367
2368 rpc_msg.Buffer = buffer;
2369 rpc_msg.BufferLength = 15;
2370
2371 stubmsg.Buffer = buffer + 15;
2372 stubmsg.BufferLength = 0;
2373 stubmsg.BufferEnd = NULL;
2374
2375 umcb.CBType = USER_MARSHAL_CB_MARSHALL;
2376
2377 status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2378 ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
2379 ok( U1(umi).Level1.BufferSize == 0,
2380 "umi.Level1.BufferSize was %u instead of 0\n",
2381 U1(umi).Level1.BufferSize);
2382
2383 /* error conditions */
2384
2385 rpc_msg.BufferLength = 14;
2386 status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2387 ok(status == ERROR_INVALID_USER_BUFFER,
2388 "NdrGetUserMarshalInfo should have failed with ERROR_INVALID_USER_BUFFER instead of %d\n", status);
2389
2390 rpc_msg.BufferLength = 15;
2391 status = pNdrGetUserMarshalInfo(&umcb.Flags, 9999, &umi);
2392 ok(status == RPC_S_INVALID_ARG,
2393 "NdrGetUserMarshalInfo should have failed with RPC_S_INVALID_ARG instead of %d\n", status);
2394
2395 umcb.CBType = 9999;
2396 status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2397 ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %d\n", status);
2398
2399 umcb.CBType = USER_MARSHAL_CB_MARSHALL;
2400 umcb.Signature = 0;
2401 status = pNdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
2402 ok(status == RPC_S_INVALID_ARG,
2403 "NdrGetUserMarshalInfo should have failed with RPC_S_INVALID_ARG instead of %d\n", status);
2404 }
2405
2406 START_TEST( ndr_marshall )
2407 {
2408 determine_pointer_marshalling_style();
2409
2410 test_ndr_simple_type();
2411 test_simple_types();
2412 test_nontrivial_pointer_types();
2413 test_simple_struct();
2414 test_fullpointer_xlat();
2415 test_client_init();
2416 test_server_init();
2417 test_ndr_allocate();
2418 test_conformant_array();
2419 test_conformant_string();
2420 test_nonconformant_string();
2421 test_conf_complex_struct();
2422 test_conf_complex_array();
2423 test_ndr_buffer();
2424 test_NdrMapCommAndFaultStatus();
2425 test_NdrGetUserMarshalInfo();
2426 }
Quick hack tree for wine patches julliard doesn't want to commit