?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rpcrt4: Don't set Buffer to NULL in I_RpcFreeBuffer.
[wine/wine64.git] / dlls / rpcrt4 / tests / ndr_marshall.c
blobd02135b9722aac3f0ac5fa025095120f74c6181a
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
101 static void test_ndr_simple_type(void)
102 {
103 RPC_MESSAGE RpcMessage;
104 MIDL_STUB_MESSAGE StubMsg;
105 MIDL_STUB_DESC StubDesc;
106 long l, l2 = 0;
107
108 StubDesc = Object_StubDesc;
109 StubDesc.pFormatTypes = NULL;
110
111 NdrClientInitializeNew(
112 &RpcMessage,
113 &StubMsg,
114 &StubDesc,
115 0);
116
117 StubMsg.BufferLength = 16;
118 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
119 l = 0xcafebabe;
120 NdrSimpleTypeMarshall(&StubMsg, (unsigned char*)&l, 8 /* FC_LONG */);
121 ok(StubMsg.Buffer == StubMsg.BufferStart + 4, "%p %p\n", StubMsg.Buffer, StubMsg.BufferStart);
122 ok(*(long*)StubMsg.BufferStart == l, "%ld\n", *(long*)StubMsg.BufferStart);
123
124 StubMsg.Buffer = StubMsg.BufferStart + 1;
125 NdrSimpleTypeMarshall(&StubMsg, (unsigned char*)&l, 8 /* FC_LONG */);
126 ok(StubMsg.Buffer == StubMsg.BufferStart + 8, "%p %p\n", StubMsg.Buffer, StubMsg.BufferStart);
127 ok(*(long*)(StubMsg.BufferStart + 4) == l, "%ld\n", *(long*)StubMsg.BufferStart);
128
129 StubMsg.Buffer = StubMsg.BufferStart + 1;
130 NdrSimpleTypeUnmarshall(&StubMsg, (unsigned char*)&l2, 8 /* FC_LONG */);
131 ok(StubMsg.Buffer == StubMsg.BufferStart + 8, "%p %p\n", StubMsg.Buffer, StubMsg.BufferStart);
132 ok(l2 == l, "%ld\n", l2);
133
134 HeapFree(GetProcessHeap(), 0, StubMsg.BufferStart);
135 }
136
137 static void test_pointer_marshal(const unsigned char *formattypes,
138 void *memsrc,
139 long srcsize,
140 const void *wiredata,
141 ULONG wiredatalen,
142 int(*cmp)(const void*,const void*,size_t),
143 long num_additional_allocs,
144 const char *msgpfx)
145 {
146 RPC_MESSAGE RpcMessage;
147 MIDL_STUB_MESSAGE StubMsg;
148 MIDL_STUB_DESC StubDesc;
149 DWORD size;
150 void *ptr;
151 unsigned char *mem, *mem_orig;
152
153 my_alloc_called = my_free_called = 0;
154 if(!cmp)
155 cmp = memcmp;
156
157 StubDesc = Object_StubDesc;
158 StubDesc.pFormatTypes = formattypes;
159
160 NdrClientInitializeNew(
161 &RpcMessage,
162 &StubMsg,
163 &StubDesc,
164 0);
165
166 StubMsg.BufferLength = 0;
167 NdrPointerBufferSize( &StubMsg,
168 memsrc,
169 formattypes );
170 ok(StubMsg.BufferLength >= wiredatalen, "%s: length %d\n", msgpfx, StubMsg.BufferLength);
171
172 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
173 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
174 StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
175
176 memset(StubMsg.BufferStart, 0x0, StubMsg.BufferLength); /* This is a hack to clear the padding between the ptr and longlong/double */
177
178 ptr = NdrPointerMarshall( &StubMsg, memsrc, formattypes );
179 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
180 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
181 ok(!memcmp(StubMsg.BufferStart, wiredata, wiredatalen), "%s: incorrectly marshaled\n", msgpfx);
182
183 StubMsg.Buffer = StubMsg.BufferStart;
184 StubMsg.MemorySize = 0;
185
186 if (0)
187 {
188 /* NdrPointerMemorySize crashes under Wine */
189 size = NdrPointerMemorySize( &StubMsg, formattypes );
190 ok(size == StubMsg.MemorySize, "%s: mem size %u size %u\n", msgpfx, StubMsg.MemorySize, size);
191 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
192 if(formattypes[1] & 0x10 /* FC_POINTER_DEREF */)
193 ok(size == srcsize + 4, "%s: mem size %u\n", msgpfx, size);
194 else
195 ok(size == srcsize, "%s: mem size %u\n", msgpfx, size);
196
197 StubMsg.Buffer = StubMsg.BufferStart;
198 StubMsg.MemorySize = 16;
199 size = NdrPointerMemorySize( &StubMsg, formattypes );
200 ok(size == StubMsg.MemorySize, "%s: mem size %u size %u\n", msgpfx, StubMsg.MemorySize, size);
201 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
202 if(formattypes[1] & 0x10 /* FC_POINTER_DEREF */)
203 ok(size == srcsize + 4 + 16, "%s: mem size %u\n", msgpfx, size);
204 else
205 ok(size == srcsize + 16, "%s: mem size %u\n", msgpfx, size);
206
207 StubMsg.Buffer = StubMsg.BufferStart;
208 StubMsg.MemorySize = 1;
209 size = NdrPointerMemorySize( &StubMsg, formattypes );
210 ok(size == StubMsg.MemorySize, "%s: mem size %u size %u\n", msgpfx, StubMsg.MemorySize, size);
211 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
212 if(formattypes[1] & 0x10 /* FC_POINTER_DEREF */)
213 ok(size == srcsize + 4 + (srcsize == 8 ? 8 : 4), "%s: mem size %u\n", msgpfx, size);
214 else
215 ok(size == srcsize + (srcsize == 8 ? 8 : 4), "%s: mem size %u\n", msgpfx, size);
216 }
217
218 size = srcsize;
219 if(formattypes[1] & 0x10) size += 4;
220
221 StubMsg.Buffer = StubMsg.BufferStart;
222 StubMsg.MemorySize = 0;
223 mem_orig = mem = HeapAlloc(GetProcessHeap(), 0, size);
224
225 if(formattypes[1] & 0x10 /* FC_POINTER_DEREF */)
226 *(void**)mem = NULL;
227 ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
228 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
229 ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
230 ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
231 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
232 ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
233 ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
234 my_alloc_called = 0;
235
236 /* reset the buffer and call with must alloc */
237 StubMsg.Buffer = StubMsg.BufferStart;
238 if(formattypes[1] & 0x10 /* FC_POINTER_DEREF */)
239 *(void**)mem = NULL;
240 ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 1 );
241 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
242 /* doesn't allocate mem in this case */
243 todo_wine {
244 ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
245 }
246 ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
247 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
248 ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
249
250 todo_wine {
251 ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
252 }
253 my_alloc_called = 0;
254 if(formattypes[0] != 0x11 /* FC_RP */)
255 {
256 /* now pass the address of a NULL ptr */
257 mem = NULL;
258 StubMsg.Buffer = StubMsg.BufferStart;
259 ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
260 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
261 ok(mem != StubMsg.BufferStart + wiredatalen - srcsize, "%s: mem points to buffer %p %p\n", msgpfx, mem, StubMsg.BufferStart);
262 ok(!cmp(mem, memsrc, size), "%s: incorrectly unmarshaled\n", msgpfx);
263 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
264 ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
265 ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
266 my_alloc_called = 0;
267 NdrPointerFree(&StubMsg, mem, formattypes);
268
269 /* again pass address of NULL ptr, but pretend we're a server */
270 mem = NULL;
271 StubMsg.Buffer = StubMsg.BufferStart;
272 StubMsg.IsClient = 0;
273 ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
274 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
275 if (formattypes[2] == 0xd /* FC_ENUM16 */)
276 ok(mem != StubMsg.BufferStart + wiredatalen - srcsize, "%s: mem points to buffer %p %p\n", msgpfx, mem, StubMsg.BufferStart);
277 else
278 ok(mem == StubMsg.BufferStart + wiredatalen - srcsize, "%s: mem doesn't point to buffer %p %p\n", msgpfx, mem, StubMsg.BufferStart);
279 ok(!cmp(mem, memsrc, size), "%s: incorrecly unmarshaled\n", msgpfx);
280 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %d\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
281 ok(StubMsg.MemorySize == 0, "%s: memorysize %d\n", msgpfx, StubMsg.MemorySize);
282 if (formattypes[2] != 0xd /* FC_ENUM16 */) {
283 ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
284 my_alloc_called = 0;
285 }
286 }
287 HeapFree(GetProcessHeap(), 0, mem_orig);
288 HeapFree(GetProcessHeap(), 0, StubMsg.BufferStart);
289 }
290
291 static int deref_cmp(const void *s1, const void *s2, size_t num)
292 {
293 return memcmp(*(const void *const *)s1, *(const void *const *)s2, num);
294 }
295
296
297 static void test_simple_types(void)
298 {
299 unsigned char wiredata[16];
300 unsigned char ch;
301 unsigned char *ch_ptr;
302 unsigned short s;
303 unsigned int i;
304 unsigned long l;
305 ULONGLONG ll;
306 float f;
307 double d;
308
309 static const unsigned char fmtstr_up_char[] =
310 {
311 0x12, 0x8, /* FC_UP [simple_pointer] */
312 0x2, /* FC_CHAR */
313 0x5c, /* FC_PAD */
314 };
315 static const unsigned char fmtstr_up_byte[] =
316 {
317 0x12, 0x8, /* FC_UP [simple_pointer] */
318 0x1, /* FC_BYTE */
319 0x5c, /* FC_PAD */
320 };
321 static const unsigned char fmtstr_up_small[] =
322 {
323 0x12, 0x8, /* FC_UP [simple_pointer] */
324 0x3, /* FC_SMALL */
325 0x5c, /* FC_PAD */
326 };
327 static const unsigned char fmtstr_up_usmall[] =
328 {
329 0x12, 0x8, /* FC_UP [simple_pointer] */
330 0x4, /* FC_USMALL */
331 0x5c, /* FC_PAD */
332 };
333 static const unsigned char fmtstr_rp_char[] =
334 {
335 0x11, 0x8, /* FC_RP [simple_pointer] */
336 0x2, /* FC_CHAR */
337 0x5c, /* FC_PAD */
338 };
339 static const unsigned char fmtstr_rpup_char[] =
340 {
341 0x11, 0x14, /* FC_RP [alloced_on_stack] */
342 NdrFcShort( 0x2 ), /* Offset= 2 (4) */
343 0x12, 0x8, /* FC_UP [simple_pointer] */
344 0x2, /* FC_CHAR */
345 0x5c, /* FC_PAD */
346 };
347 static const unsigned char fmtstr_rpup_char2[] =
348 {
349 0x11, 0x04, /* FC_RP [alloced_on_stack] */
350 NdrFcShort( 0x2 ), /* Offset= 2 (4) */
351 0x12, 0x8, /* FC_UP [simple_pointer] */
352 0x2, /* FC_CHAR */
353 0x5c, /* FC_PAD */
354 };
355
356 static const unsigned char fmtstr_up_wchar[] =
357 {
358 0x12, 0x8, /* FC_UP [simple_pointer] */
359 0x5, /* FC_WCHAR */
360 0x5c, /* FC_PAD */
361 };
362 static const unsigned char fmtstr_up_short[] =
363 {
364 0x12, 0x8, /* FC_UP [simple_pointer] */
365 0x6, /* FC_SHORT */
366 0x5c, /* FC_PAD */
367 };
368 static const unsigned char fmtstr_up_ushort[] =
369 {
370 0x12, 0x8, /* FC_UP [simple_pointer] */
371 0x7, /* FC_USHORT */
372 0x5c, /* FC_PAD */
373 };
374 static const unsigned char fmtstr_up_enum16[] =
375 {
376 0x12, 0x8, /* FC_UP [simple_pointer] */
377 0xd, /* FC_ENUM16 */
378 0x5c, /* FC_PAD */
379 };
380 static const unsigned char fmtstr_up_long[] =
381 {
382 0x12, 0x8, /* FC_UP [simple_pointer] */
383 0x8, /* FC_LONG */
384 0x5c, /* FC_PAD */
385 };
386 static const unsigned char fmtstr_up_ulong[] =
387 {
388 0x12, 0x8, /* FC_UP [simple_pointer] */
389 0x9, /* FC_ULONG */
390 0x5c, /* FC_PAD */
391 };
392 static const unsigned char fmtstr_up_enum32[] =
393 {
394 0x12, 0x8, /* FC_UP [simple_pointer] */
395 0xe, /* FC_ENUM32 */
396 0x5c, /* FC_PAD */
397 };
398 static const unsigned char fmtstr_up_errorstatus[] =
399 {
400 0x12, 0x8, /* FC_UP [simple_pointer] */
401 0x10, /* FC_ERROR_STATUS_T */
402 0x5c, /* FC_PAD */
403 };
404
405 static const unsigned char fmtstr_up_longlong[] =
406 {
407 0x12, 0x8, /* FC_UP [simple_pointer] */
408 0xb, /* FC_HYPER */
409 0x5c, /* FC_PAD */
410 };
411 static const unsigned char fmtstr_up_float[] =
412 {
413 0x12, 0x8, /* FC_UP [simple_pointer] */
414 0xa, /* FC_FLOAT */
415 0x5c, /* FC_PAD */
416 };
417 static const unsigned char fmtstr_up_double[] =
418 {
419 0x12, 0x8, /* FC_UP [simple_pointer] */
420 0xc, /* FC_DOUBLE */
421 0x5c, /* FC_PAD */
422 };
423
424 ch = 0xa5;
425 ch_ptr = &ch;
426 *(void**)wiredata = ch_ptr;
427 wiredata[sizeof(void*)] = ch;
428
429 test_pointer_marshal(fmtstr_up_char, ch_ptr, 1, wiredata, 5, NULL, 0, "up_char");
430 test_pointer_marshal(fmtstr_up_byte, ch_ptr, 1, wiredata, 5, NULL, 0, "up_byte");
431 test_pointer_marshal(fmtstr_up_small, ch_ptr, 1, wiredata, 5, NULL, 0, "up_small");
432 test_pointer_marshal(fmtstr_up_usmall, ch_ptr, 1, wiredata, 5, NULL, 0, "up_usmall");
433
434 test_pointer_marshal(fmtstr_rp_char, ch_ptr, 1, &ch, 1, NULL, 0, "rp_char");
435
436 test_pointer_marshal(fmtstr_rpup_char, &ch_ptr, 1, wiredata, 5, deref_cmp, 1, "rpup_char");
437 test_pointer_marshal(fmtstr_rpup_char2, ch_ptr, 1, wiredata, 5, NULL, 0, "rpup_char2");
438
439 s = 0xa597;
440 *(void**)wiredata = &s;
441 *(unsigned short*)(wiredata + sizeof(void*)) = s;
442
443 test_pointer_marshal(fmtstr_up_wchar, &s, 2, wiredata, 6, NULL, 0, "up_wchar");
444 test_pointer_marshal(fmtstr_up_short, &s, 2, wiredata, 6, NULL, 0, "up_short");
445 test_pointer_marshal(fmtstr_up_ushort, &s, 2, wiredata, 6, NULL, 0, "up_ushort");
446
447 i = 0x7fff;
448 *(void**)wiredata = &i;
449 *(unsigned short*)(wiredata + sizeof(void*)) = i;
450 test_pointer_marshal(fmtstr_up_enum16, &i, 2, wiredata, 6, NULL, 0, "up_enum16");
451
452 l = 0xcafebabe;
453 *(void**)wiredata = &l;
454 *(unsigned long*)(wiredata + sizeof(void*)) = l;
455
456 test_pointer_marshal(fmtstr_up_long, &l, 4, wiredata, 8, NULL, 0, "up_long");
457 test_pointer_marshal(fmtstr_up_ulong, &l, 4, wiredata, 8, NULL, 0, "up_ulong");
458 test_pointer_marshal(fmtstr_up_enum32, &l, 4, wiredata, 8, NULL, 0, "up_emun32");
459 test_pointer_marshal(fmtstr_up_errorstatus, &l, 4, wiredata, 8, NULL, 0, "up_errorstatus");
460
461 ll = ((ULONGLONG)0xcafebabe) << 32 | 0xdeadbeef;
462 *(void**)wiredata = &ll;
463 *(void**)(wiredata + sizeof(void*)) = NULL;
464 *(ULONGLONG*)(wiredata + 2 * sizeof(void*)) = ll;
465 test_pointer_marshal(fmtstr_up_longlong, &ll, 8, wiredata, 16, NULL, 0, "up_longlong");
466
467 f = 3.1415f;
468 *(void**)wiredata = &f;
469 *(float*)(wiredata + sizeof(void*)) = f;
470 test_pointer_marshal(fmtstr_up_float, &f, 4, wiredata, 8, NULL, 0, "up_float");
471
472 d = 3.1415;
473 *(void**)wiredata = &d;
474 *(void**)(wiredata + sizeof(void*)) = NULL;
475 *(double*)(wiredata + 2 * sizeof(void*)) = d;
476 test_pointer_marshal(fmtstr_up_double, &d, 8, wiredata, 16, NULL, 0, "up_double");
477
478 }
479
480 static void test_simple_struct_marshal(const unsigned char *formattypes,
481 void *memsrc,
482 long srcsize,
483 const void *wiredata,
484 ULONG wiredatalen,
485 int(*cmp)(const void*,const void*,size_t),
486 long num_additional_allocs,
487 const char *msgpfx)
488 {
489 RPC_MESSAGE RpcMessage;
490 MIDL_STUB_MESSAGE StubMsg;
491 MIDL_STUB_DESC StubDesc;
492 DWORD size;
493 void *ptr;
494 unsigned char *mem, *mem_orig;
495
496 my_alloc_called = my_free_called = 0;
497 if(!cmp)
498 cmp = memcmp;
499
500 StubDesc = Object_StubDesc;
501 StubDesc.pFormatTypes = formattypes;
502
503 NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 0);
504
505 StubMsg.BufferLength = 0;
506 NdrSimpleStructBufferSize( &StubMsg, (unsigned char *)memsrc, formattypes );
507 ok(StubMsg.BufferLength >= wiredatalen, "%s: length %d\n", msgpfx, StubMsg.BufferLength);
508 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
509 StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
510 ptr = NdrSimpleStructMarshall( &StubMsg, (unsigned char*)memsrc, formattypes );
511 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
512 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart);
513 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));
514
515 if (0)
516 {
517 /* FIXME: Causes Wine to crash */
518 StubMsg.Buffer = StubMsg.BufferStart;
519 StubMsg.MemorySize = 0;
520 size = NdrSimpleStructMemorySize( &StubMsg, formattypes );
521 ok(size == StubMsg.MemorySize, "%s: size != MemorySize\n", msgpfx);
522 ok(size == srcsize, "%s: mem size %u\n", msgpfx, size);
523 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart);
524
525 StubMsg.Buffer = StubMsg.BufferStart;
526 size = NdrSimpleStructMemorySize( &StubMsg, formattypes );
527 todo_wine {
528 ok(size == StubMsg.MemorySize, "%s: size != MemorySize\n", msgpfx);
529 }
530 ok(StubMsg.MemorySize == ((srcsize + 3) & ~3) + srcsize, "%s: mem size %u\n", msgpfx, size);
531 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart);
532 }
533 size = srcsize;
534 /*** Unmarshalling first with must_alloc false ***/
535
536 StubMsg.Buffer = StubMsg.BufferStart;
537 StubMsg.MemorySize = 0;
538 mem_orig = mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, srcsize);
539 ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 0 );
540 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
541 ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart);
542 ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
543 ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
544 ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
545 my_alloc_called = 0;
546 ok(StubMsg.MemorySize == 0, "%s: memorysize touched in unmarshal\n", msgpfx);
547
548 /* if we're a server we still use the suppiled memory */
549 StubMsg.Buffer = StubMsg.BufferStart;
550 StubMsg.IsClient = 0;
551 ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 0 );
552 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
553 ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
554 ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
555 ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
556 my_alloc_called = 0;
557 ok(StubMsg.MemorySize == 0, "%s: memorysize touched in unmarshal\n", msgpfx);
558
559 /* ...unless we pass a NULL ptr, then the buffer is used.
560 Passing a NULL ptr while we're a client && !must_alloc
561 crashes on Windows, so we won't do that. */
562
563 mem = NULL;
564 StubMsg.IsClient = 0;
565 StubMsg.Buffer = StubMsg.BufferStart;
566 ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 0 );
567 ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
568 ok(mem == StubMsg.BufferStart, "%s: mem not equal buffer\n", msgpfx);
569 ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
570 ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
571 my_alloc_called = 0;
572 ok(StubMsg.MemorySize == 0, "%s: memorysize touched in unmarshal\n", msgpfx);
573
574 /*** now must_alloc is true ***/
575
576 /* with must_alloc set we always allocate new memory whether or not we're
577 a server and also when passing NULL */
578 mem = mem_orig;
579 StubMsg.IsClient = 1;
580 StubMsg.Buffer = StubMsg.BufferStart;
581 ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
582 ok(ptr == NULL, "ret %p\n", ptr);
583 ok(mem != mem_orig, "mem not changed %p %p\n", mem, mem_orig);
584 ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n");
585 ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
586 my_alloc_called = 0;
587 ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
588
589 mem = NULL;
590 StubMsg.Buffer = StubMsg.BufferStart;
591 ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
592 ok(ptr == NULL, "ret %p\n", ptr);
593 ok(mem != mem_orig, "mem not changed %p %p\n", mem, mem_orig);
594 ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n");
595 ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
596 my_alloc_called = 0;
597 ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
598
599 mem = mem_orig;
600 StubMsg.Buffer = StubMsg.BufferStart;
601 StubMsg.IsClient = 0;
602 StubMsg.ReuseBuffer = 1;
603 ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
604 ok(ptr == NULL, "ret %p\n", ptr);
605 ok(mem != mem_orig, "mem not changed %p %p\n", mem, mem_orig);
606 ok(mem != StubMsg.BufferStart, "mem is buffer mem\n");
607 ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n");
608 ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
609 my_alloc_called = 0;
610 ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
611
612 mem = NULL;
613 StubMsg.Buffer = StubMsg.BufferStart;
614 StubMsg.IsClient = 0;
615 StubMsg.ReuseBuffer = 1;
616 ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
617 ok(ptr == NULL, "ret %p\n", ptr);
618 ok(mem != StubMsg.BufferStart, "mem is buffer mem\n");
619 ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n");
620 ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
621 my_alloc_called = 0;
622 ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
623
624 HeapFree(GetProcessHeap(), 0, mem_orig);
625 HeapFree(GetProcessHeap(), 0, StubMsg.BufferStart);
626 }
627
628 typedef struct
629 {
630 long l1;
631 long *pl1;
632 char *pc1;
633 } ps1_t;
634
635 static int ps1_cmp(const void *s1, const void *s2, size_t num)
636 {
637 const ps1_t *p1, *p2;
638
639 p1 = s1;
640 p2 = s2;
641
642 if(p1->l1 != p2->l1)
643 return 1;
644
645 if(p1->pl1 && p2->pl1)
646 {
647 if(*p1->pl1 != *p2->pl1)
648 return 1;
649 }
650 else if(p1->pl1 || p1->pl1)
651 return 1;
652
653 if(p1->pc1 && p2->pc1)
654 {
655 if(*p1->pc1 != *p2->pc1)
656 return 1;
657 }
658 else if(p1->pc1 || p1->pc1)
659 return 1;
660
661 return 0;
662 }
663
664 static void test_simple_struct(void)
665 {
666 unsigned char wiredata[28];
667 unsigned long wiredatalen;
668 long l;
669 char c;
670 ps1_t ps1;
671
672 static const unsigned char fmtstr_simple_struct[] =
673 {
674 0x12, 0x0, /* FC_UP */
675 NdrFcShort( 0x2 ), /* Offset=2 */
676 0x15, 0x3, /* FC_STRUCT [align 4] */
677 NdrFcShort( 0x18 ), /* [size 24] */
678 0x6, /* FC_SHORT */
679 0x2, /* FC_CHAR */
680 0x38, /* FC_ALIGNM4 */
681 0x8, /* FC_LONG */
682 0x8, /* FC_LONG */
683 0x39, /* FC_ALIGNM8 */
684 0xb, /* FC_HYPER */
685 0x5b, /* FC_END */
686 };
687 struct {
688 short s;
689 char c;
690 long l1, l2;
691 LONGLONG ll;
692 } s1;
693
694 static const unsigned char fmtstr_pointer_struct[] =
695 {
696 0x12, 0x0, /* FC_UP */
697 NdrFcShort( 0x2 ), /* Offset=2 */
698 0x16, 0x3, /* FC_PSTRUCT [align 4] */
699 NdrFcShort( 0xc ), /* [size 12] */
700 0x4b, /* FC_PP */
701 0x5c, /* FC_PAD */
702 0x46, /* FC_NO_REPEAT */
703 0x5c, /* FC_PAD */
704 NdrFcShort( 0x4 ), /* 4 */
705 NdrFcShort( 0x4 ), /* 4 */
706 0x13, 0x8, /* FC_OP [simple_pointer] */
707 0x8, /* FC_LONG */
708 0x5c, /* FC_PAD */
709 0x46, /* FC_NO_REPEAT */
710 0x5c, /* FC_PAD */
711 NdrFcShort( 0x8 ), /* 8 */
712 NdrFcShort( 0x8 ), /* 8 */
713 0x13, 0x8, /* FC_OP [simple_pointer] */
714 0x2, /* FC_CHAR */
715 0x5c, /* FC_PAD */
716 0x5b, /* FC_END */
717 0x8, /* FC_LONG */
718 0x8, /* FC_LONG */
719 0x8, /* FC_LONG */
720 0x5c, /* FC_PAD */
721 0x5b, /* FC_END */
722
723 };
724
725 /* FC_STRUCT */
726 s1.s = 0x1234;
727 s1.c = 0xa5;
728 s1.l1 = 0xdeadbeef;
729 s1.l2 = 0xcafebabe;
730 s1.ll = ((LONGLONG) 0xbadefeed << 32) | 0x2468ace0;
731
732 wiredatalen = 24;
733 memcpy(wiredata, &s1, wiredatalen);
734 test_simple_struct_marshal(fmtstr_simple_struct + 4, &s1, 24, wiredata, 24, NULL, 0, "struct");
735
736 *(void**)wiredata = &s1;
737 memcpy(wiredata + 4, &s1, wiredatalen);
738 if (0)
739 {
740 /* one of the unmarshallings crashes Wine */
741 test_pointer_marshal(fmtstr_simple_struct, &s1, 24, wiredata, 28, NULL, 0, "struct");
742 }
743
744 /* FC_PSTRUCT */
745 ps1.l1 = 0xdeadbeef;
746 l = 0xcafebabe;
747 ps1.pl1 = &l;
748 c = 'a';
749 ps1.pc1 = &c;
750 memcpy(wiredata + 4, &ps1, 12);
751 memcpy(wiredata + 16, &l, 4);
752 memcpy(wiredata + 20, &c, 1);
753
754 test_simple_struct_marshal(fmtstr_pointer_struct + 4, &ps1, 17, wiredata + 4, 17, ps1_cmp, 2, "pointer_struct");
755 *(void**)wiredata = &ps1;
756 if (0)
757 {
758 /* one of the unmarshallings crashes Wine */
759 test_pointer_marshal(fmtstr_pointer_struct, &ps1, 17, wiredata, 21, ps1_cmp, 2, "pointer_struct");
760 }
761 }
762
763 static void test_fullpointer_xlat(void)
764 {
765 PFULL_PTR_XLAT_TABLES pXlatTables;
766 ULONG RefId;
767 int ret;
768 void *Pointer;
769
770 pXlatTables = NdrFullPointerXlatInit(2, XLAT_CLIENT);
771
772 /* "marshaling" phase */
773
774 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
775 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
776 ok(RefId == 0x1, "RefId should be 0x1 instead of 0x%x\n", RefId);
777
778 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 0, &RefId);
779 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
780 ok(RefId == 0x1, "RefId should be 0x1 instead of 0x%x\n", RefId);
781
782 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebabe, 0, &RefId);
783 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
784 ok(RefId == 0x2, "RefId should be 0x2 instead of 0x%x\n", RefId);
785
786 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 0, &RefId);
787 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
788 ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
789
790 ret = NdrFullPointerQueryPointer(pXlatTables, NULL, 0, &RefId);
791 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
792 ok(RefId == 0, "RefId should be 0 instead of 0x%x\n", RefId);
793
794 /* "unmarshaling" phase */
795
796 ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 0, &Pointer);
797 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
798 ok(Pointer == (void *)0xcafebabe, "Pointer should be 0xcafebabe instead of %p\n", Pointer);
799
800 ret = NdrFullPointerQueryRefId(pXlatTables, 0x4, 0, &Pointer);
801 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
802 ok(Pointer == NULL, "Pointer should be NULL instead of %p\n", Pointer);
803
804 NdrFullPointerInsertRefId(pXlatTables, 0x4, (void *)0xdeadbabe);
805
806 ret = NdrFullPointerQueryRefId(pXlatTables, 0x4, 1, &Pointer);
807 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
808 ok(Pointer == (void *)0xdeadbabe, "Pointer should be (void *)0xdeadbabe instead of %p\n", Pointer);
809
810 NdrFullPointerXlatFree(pXlatTables);
811
812 pXlatTables = NdrFullPointerXlatInit(2, XLAT_SERVER);
813
814 /* "unmarshaling" phase */
815
816 ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 1, &Pointer);
817 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
818 ok(Pointer == NULL, "Pointer should be NULL instead of %p\n", Pointer);
819
820 NdrFullPointerInsertRefId(pXlatTables, 0x2, (void *)0xcafebabe);
821
822 ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 0, &Pointer);
823 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
824 ok(Pointer == (void *)0xcafebabe, "Pointer should be (void *)0xcafebabe instead of %p\n", Pointer);
825
826 ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 1, &Pointer);
827 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
828 ok(Pointer == (void *)0xcafebabe, "Pointer should be (void *)0xcafebabe instead of %p\n", Pointer);
829
830 /* "marshaling" phase */
831
832 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
833 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
834 ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
835
836 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
837 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
838 ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
839
840 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 0, &RefId);
841 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
842 ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
843
844 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebabe, 0, &RefId);
845 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
846 ok(RefId == 0x2, "RefId should be 0x2 instead of 0x%x\n", RefId);
847
848 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 0, &RefId);
849 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
850 ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
851
852 /* "freeing" phase */
853
854 ret = NdrFullPointerFree(pXlatTables, (void *)0xcafebeef);
855 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
856
857 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 0x20, &RefId);
858 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
859 ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
860
861 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
862 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
863 ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%x\n", RefId);
864
865 ret = NdrFullPointerFree(pXlatTables, (void *)0xcafebabe);
866 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
867
868 ret = NdrFullPointerFree(pXlatTables, (void *)0xdeadbeef);
869 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
870
871 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 0x20, &RefId);
872 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
873 ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
874
875 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 1, &RefId);
876 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
877 ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
878
879 ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 1, &RefId);
880 ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
881 ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%x\n", RefId);
882
883 ret = NdrFullPointerFree(pXlatTables, (void *)0xdeadbeef);
884 ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
885
886 NdrFullPointerXlatFree(pXlatTables);
887 }
888
889 static void test_client_init(void)
890 {
891 MIDL_STUB_MESSAGE stubMsg;
892 RPC_MESSAGE rpcMsg;
893
894 memset(&rpcMsg, 0, sizeof(rpcMsg));
895 memset(&stubMsg, 0xcc, sizeof(stubMsg));
896
897 NdrClientInitializeNew(&rpcMsg, &stubMsg, &Object_StubDesc, 1);
898
899 #define TEST_ZERO(field, fmt) ok(stubMsg.field == 0, #field " should have been set to zero instead of " fmt "\n", stubMsg.field)
900 #define TEST_POINTER_UNSET(field) ok(stubMsg.field == (void *)0xcccccccc, #field " should have been unset instead of %p\n", stubMsg.field)
901 #define TEST_ULONG_UNSET(field) ok(stubMsg.field == 0xcccccccc, #field " should have been unset instead of 0x%x\n", stubMsg.field)
902 #define TEST_ULONG_PTR_UNSET(field) ok(stubMsg.field == 0xcccccccc, #field " should have been unset instead of 0x%lx\n", stubMsg.field)
903
904 ok(stubMsg.RpcMsg == &rpcMsg, "stubMsg.RpcMsg should have been %p instead of %p\n", &rpcMsg, stubMsg.RpcMsg);
905 TEST_POINTER_UNSET(Buffer);
906 TEST_ZERO(BufferStart, "%p");
907 TEST_ZERO(BufferEnd, "%p");
908 TEST_POINTER_UNSET(BufferMark);
909 TEST_ZERO(BufferLength, "%d");
910 TEST_ULONG_UNSET(MemorySize);
911 TEST_POINTER_UNSET(Memory);
912 ok(stubMsg.IsClient == 1, "stubMsg.IsClient should have been 1 instead of %u\n", stubMsg.IsClient);
913 TEST_ZERO(ReuseBuffer, "%d");
914 TEST_ZERO(pAllocAllNodesContext, "%p");
915 TEST_ZERO(pPointerQueueState, "%p");
916 TEST_ZERO(IgnoreEmbeddedPointers, "%d");
917 TEST_ZERO(PointerBufferMark, "%p");
918 TEST_ZERO(fBufferValid, "%d");
919 TEST_ZERO(uFlags, "%d");
920 /* FIXME: UniquePtrCount */
921 TEST_ULONG_PTR_UNSET(MaxCount);
922 TEST_ULONG_UNSET(Offset);
923 TEST_ULONG_UNSET(ActualCount);
924 ok(stubMsg.pfnAllocate == my_alloc, "stubMsg.pfnAllocate should have been %p instead of %p\n", my_alloc, stubMsg.pfnAllocate);
925 ok(stubMsg.pfnFree == my_free, "stubMsg.pfnFree should have been %p instead of %p\n", my_free, stubMsg.pfnFree);
926 TEST_ZERO(StackTop, "%p");
927 TEST_POINTER_UNSET(pPresentedType);
928 TEST_POINTER_UNSET(pTransmitType);
929 TEST_POINTER_UNSET(SavedHandle);
930 ok(stubMsg.StubDesc == &Object_StubDesc, "stubMsg.StubDesc should have been %p instead of %p\n", &Object_StubDesc, stubMsg.StubDesc);
931 TEST_POINTER_UNSET(FullPtrXlatTables);
932 TEST_ZERO(FullPtrRefId, "%d");
933 TEST_ZERO(PointerLength, "%d");
934 TEST_ZERO(fInDontFree, "%d");
935 TEST_ZERO(fDontCallFreeInst, "%d");
936 TEST_ZERO(fInOnlyParam, "%d");
937 TEST_ZERO(fHasReturn, "%d");
938 TEST_ZERO(fHasExtensions, "%d");
939 TEST_ZERO(fHasNewCorrDesc, "%d");
940 TEST_ZERO(fUnused, "%d");
941 ok(stubMsg.fUnused2 == 0xffffcccc, "stubMsg.fUnused2 should have been 0xcccc instead of 0x%x\n", stubMsg.fUnused2);
942 ok(stubMsg.dwDestContext == MSHCTX_DIFFERENTMACHINE, "stubMsg.dwDestContext should have been MSHCTX_DIFFERENTMACHINE instead of %d\n", stubMsg.dwDestContext);
943 TEST_ZERO(pvDestContext, "%p");
944 TEST_POINTER_UNSET(SavedContextHandles);
945 TEST_ULONG_UNSET(ParamNumber);
946 TEST_ZERO(pRpcChannelBuffer, "%p");
947 TEST_ZERO(pArrayInfo, "%p");
948 TEST_POINTER_UNSET(SizePtrCountArray);
949 TEST_POINTER_UNSET(SizePtrOffsetArray);
950 TEST_POINTER_UNSET(SizePtrLengthArray);
951 TEST_POINTER_UNSET(pArgQueue);
952 TEST_ZERO(dwStubPhase, "%d");
953 /* FIXME: where does this value come from? */
954 trace("LowStackMark is %p\n", stubMsg.LowStackMark);
955 TEST_ZERO(pAsyncMsg, "%p");
956 TEST_ZERO(pCorrInfo, "%p");
957 TEST_ZERO(pCorrMemory, "%p");
958 TEST_ZERO(pMemoryList, "%p");
959 TEST_POINTER_UNSET(pCSInfo);
960 TEST_POINTER_UNSET(ConformanceMark);
961 TEST_POINTER_UNSET(VarianceMark);
962 ok(stubMsg.Unused == 0xcccccccc, "Unused should have be unset instead of 0x%lx\n", stubMsg.Unused);
963 TEST_POINTER_UNSET(pContext);
964 TEST_POINTER_UNSET(ContextHandleHash);
965 TEST_POINTER_UNSET(pUserMarshalList);
966 TEST_ULONG_PTR_UNSET(Reserved51_3);
967 TEST_ULONG_PTR_UNSET(Reserved51_4);
968 TEST_ULONG_PTR_UNSET(Reserved51_5);
969 #undef TEST_ULONG_UNSET
970 #undef TEST_POINTER_UNSET
971 #undef TEST_ZERO
972
973 }
974
975 static void test_server_init(void)
976 {
977 MIDL_STUB_MESSAGE stubMsg;
978 RPC_MESSAGE rpcMsg;
979 unsigned char *ret;
980 unsigned char buffer[256];
981
982 memset(&rpcMsg, 0, sizeof(rpcMsg));
983 rpcMsg.Buffer = buffer;
984 rpcMsg.BufferLength = sizeof(buffer);
985 rpcMsg.RpcFlags = RPC_BUFFER_COMPLETE;
986
987 memset(&stubMsg, 0xcc, sizeof(stubMsg));
988
989 ret = NdrServerInitializeNew(&rpcMsg, &stubMsg, &Object_StubDesc);
990 ok(ret == NULL, "NdrServerInitializeNew should have returned NULL instead of %p\n", ret);
991
992 #define TEST_ZERO(field, fmt) ok(stubMsg.field == 0, #field " should have been set to zero instead of " fmt "\n", stubMsg.field)
993 #define TEST_POINTER_UNSET(field) ok(stubMsg.field == (void *)0xcccccccc, #field " should have been unset instead of %p\n", stubMsg.field)
994 #define TEST_ULONG_UNSET(field) ok(stubMsg.field == 0xcccccccc, #field " should have been unset instead of 0x%x\n", stubMsg.field)
995 #define TEST_ULONG_PTR_UNSET(field) ok(stubMsg.field == 0xcccccccc, #field " should have been unset instead of 0x%lx\n", stubMsg.field)
996
997 ok(stubMsg.RpcMsg == &rpcMsg, "stubMsg.RpcMsg should have been %p instead of %p\n", &rpcMsg, stubMsg.RpcMsg);
998 ok(stubMsg.Buffer == buffer, "stubMsg.Buffer should have been %p instead of %p\n", buffer, stubMsg.Buffer);
999 ok(stubMsg.BufferStart == buffer, "stubMsg.BufferStart should have been %p instead of %p\n", buffer, stubMsg.BufferStart);
1000 ok(stubMsg.BufferEnd == buffer + sizeof(buffer), "stubMsg.BufferEnd should have been %p instead of %p\n", buffer + sizeof(buffer), stubMsg.BufferEnd);
1001 TEST_POINTER_UNSET(BufferMark);
1002 todo_wine
1003 TEST_ZERO(BufferLength, "%d");
1004 TEST_ULONG_UNSET(MemorySize);
1005 TEST_POINTER_UNSET(Memory);
1006 ok(stubMsg.IsClient == 0, "stubMsg.IsClient should have been 0 instead of %u\n", stubMsg.IsClient);
1007 TEST_ZERO(ReuseBuffer, "%d");
1008 TEST_ZERO(pAllocAllNodesContext, "%p");
1009 TEST_ZERO(pPointerQueueState, "%p");
1010 TEST_ZERO(IgnoreEmbeddedPointers, "%d");
1011 TEST_ZERO(PointerBufferMark, "%p");
1012 ok(stubMsg.fBufferValid == 0xcc, "fBufferValid should have been unset instead of 0x%x\n", stubMsg.fBufferValid);
1013 TEST_ZERO(uFlags, "%d");
1014 /* FIXME: UniquePtrCount */
1015 TEST_ULONG_PTR_UNSET(MaxCount);
1016 TEST_ULONG_UNSET(Offset);
1017 TEST_ULONG_UNSET(ActualCount);
1018 ok(stubMsg.pfnAllocate == my_alloc, "stubMsg.pfnAllocate should have been %p instead of %p\n", my_alloc, stubMsg.pfnAllocate);
1019 ok(stubMsg.pfnFree == my_free, "stubMsg.pfnFree should have been %p instead of %p\n", my_free, stubMsg.pfnFree);
1020 TEST_ZERO(StackTop, "%p");
1021 TEST_POINTER_UNSET(pPresentedType);
1022 TEST_POINTER_UNSET(pTransmitType);
1023 TEST_POINTER_UNSET(SavedHandle);
1024 ok(stubMsg.StubDesc == &Object_StubDesc, "stubMsg.StubDesc should have been %p instead of %p\n", &Object_StubDesc, stubMsg.StubDesc);
1025 TEST_ZERO(FullPtrXlatTables, "%p");
1026 TEST_ZERO(FullPtrRefId, "%d");
1027 TEST_ZERO(PointerLength, "%d");
1028 TEST_ZERO(fInDontFree, "%d");
1029 TEST_ZERO(fDontCallFreeInst, "%d");
1030 TEST_ZERO(fInOnlyParam, "%d");
1031 TEST_ZERO(fHasReturn, "%d");
1032 TEST_ZERO(fHasExtensions, "%d");
1033 TEST_ZERO(fHasNewCorrDesc, "%d");
1034 TEST_ZERO(fUnused, "%d");
1035 ok(stubMsg.fUnused2 == 0xffffcccc, "stubMsg.fUnused2 should have been 0xcccc instead of 0x%x\n", stubMsg.fUnused2);
1036 ok(stubMsg.dwDestContext == MSHCTX_DIFFERENTMACHINE, "stubMsg.dwDestContext should have been MSHCTX_DIFFERENTMACHINE instead of %d\n", stubMsg.dwDestContext);
1037 TEST_ZERO(pvDestContext, "%p");
1038 TEST_POINTER_UNSET(SavedContextHandles);
1039 TEST_ULONG_UNSET(ParamNumber);
1040 TEST_ZERO(pRpcChannelBuffer, "%p");
1041 TEST_ZERO(pArrayInfo, "%p");
1042 TEST_POINTER_UNSET(SizePtrCountArray);
1043 TEST_POINTER_UNSET(SizePtrOffsetArray);
1044 TEST_POINTER_UNSET(SizePtrLengthArray);
1045 TEST_POINTER_UNSET(pArgQueue);
1046 TEST_ZERO(dwStubPhase, "%d");
1047 /* FIXME: where does this value come from? */
1048 trace("LowStackMark is %p\n", stubMsg.LowStackMark);
1049 TEST_ZERO(pAsyncMsg, "%p");
1050 TEST_ZERO(pCorrInfo, "%p");
1051 TEST_ZERO(pCorrMemory, "%p");
1052 TEST_ZERO(pMemoryList, "%p");
1053 TEST_POINTER_UNSET(pCSInfo);
1054 TEST_POINTER_UNSET(ConformanceMark);
1055 TEST_POINTER_UNSET(VarianceMark);
1056 ok(stubMsg.Unused == 0xcccccccc, "Unused should have be unset instead of 0x%lx\n", stubMsg.Unused);
1057 TEST_POINTER_UNSET(pContext);
1058 TEST_POINTER_UNSET(ContextHandleHash);
1059 TEST_POINTER_UNSET(pUserMarshalList);
1060 TEST_ULONG_PTR_UNSET(Reserved51_3);
1061 TEST_ULONG_PTR_UNSET(Reserved51_4);
1062 TEST_ULONG_PTR_UNSET(Reserved51_5);
1063 #undef TEST_ULONG_UNSET
1064 #undef TEST_POINTER_UNSET
1065 #undef TEST_ZERO
1066
1067 }
1068
1069 static void test_ndr_allocate(void)
1070 {
1071 RPC_MESSAGE RpcMessage;
1072 MIDL_STUB_MESSAGE StubMsg;
1073 MIDL_STUB_DESC StubDesc;
1074 void *p1, *p2;
1075 struct tag_mem_list_v1_t
1076 {
1077 DWORD magic;
1078 void *ptr;
1079 struct tag_mem_list_v1_t *next;
1080 } *mem_list_v1;
1081 struct tag_mem_list_v2_t
1082 {
1083 DWORD magic;
1084 DWORD size;
1085 DWORD unknown;
1086 struct tag_mem_list_v2_t *next;
1087 } *mem_list_v2;
1088 const DWORD magic_MEML = 'M' << 24 | 'E' << 16 | 'M' << 8 | 'L';
1089
1090 StubDesc = Object_StubDesc;
1091 NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 0);
1092
1093 ok(StubMsg.pMemoryList == NULL, "memlist %p\n", StubMsg.pMemoryList);
1094 my_alloc_called = my_free_called = 0;
1095 p1 = NdrAllocate(&StubMsg, 10);
1096 p2 = NdrAllocate(&StubMsg, 24);
1097 ok(my_alloc_called == 2, "alloc called %d\n", my_alloc_called);
1098 ok(StubMsg.pMemoryList != NULL, "StubMsg.pMemoryList NULL\n");
1099 if(StubMsg.pMemoryList)
1100 {
1101 mem_list_v2 = StubMsg.pMemoryList;
1102 if (mem_list_v2->size == 24)
1103 {
1104 trace("v2 mem list format\n");
1105 ok((char *)mem_list_v2 == (char *)p2 + 24, "expected mem_list_v2 pointer %p, but got %p\n", (char *)p2 + 24, mem_list_v2);
1106 ok(mem_list_v2->magic == magic_MEML, "magic %08x\n", mem_list_v2->magic);
1107 ok(mem_list_v2->size == 24, "wrong size for p2 %d\n", mem_list_v2->size);
1108 ok(mem_list_v2->unknown == 0, "wrong unknown for p2 0x%x\n", mem_list_v2->unknown);
1109 ok(mem_list_v2->next != NULL, "next NULL\n");
1110 mem_list_v2 = mem_list_v2->next;
1111 if(mem_list_v2)
1112 {
1113 ok((char *)mem_list_v2 == (char *)p1 + 16, "expected mem_list_v2 pointer %p, but got %p\n", (char *)p1 + 16, mem_list_v2);
1114 ok(mem_list_v2->magic == magic_MEML, "magic %08x\n", mem_list_v2->magic);
1115 ok(mem_list_v2->size == 16, "wrong size for p1 %d\n", mem_list_v2->size);
1116 ok(mem_list_v2->unknown == 0, "wrong unknown for p1 0x%x\n", mem_list_v2->unknown);
1117 ok(mem_list_v2->next == NULL, "next %p\n", mem_list_v2->next);
1118 }
1119 }
1120 else
1121 {
1122 trace("v1 mem list format\n");
1123 mem_list_v1 = StubMsg.pMemoryList;
1124 ok(mem_list_v1->magic == magic_MEML, "magic %08x\n", mem_list_v1->magic);
1125 ok(mem_list_v1->ptr == p2, "ptr != p2\n");
1126 ok(mem_list_v1->next != NULL, "next NULL\n");
1127 mem_list_v1 = mem_list_v1->next;
1128 if(mem_list_v1)
1129 {
1130 ok(mem_list_v1->magic == magic_MEML, "magic %08x\n", mem_list_v1->magic);
1131 ok(mem_list_v1->ptr == p1, "ptr != p1\n");
1132 ok(mem_list_v1->next == NULL, "next %p\n", mem_list_v1->next);
1133 }
1134 }
1135 }
1136 /* NdrFree isn't exported so we can't test free'ing */
1137 }
1138
1139 static void test_conformant_array(void)
1140 {
1141 RPC_MESSAGE RpcMessage;
1142 MIDL_STUB_MESSAGE StubMsg;
1143 MIDL_STUB_DESC StubDesc;
1144 void *ptr;
1145 unsigned char *mem, *mem_orig;
1146 unsigned char memsrc[20];
1147
1148 static const unsigned char fmtstr_conf_array[] =
1149 {
1150 0x1b, /* FC_CARRAY */
1151 0x0, /* align */
1152 NdrFcShort( 0x1 ), /* elem size */
1153 0x40, /* Corr desc: const */
1154 0x0,
1155 NdrFcShort(0x10), /* const = 0x10 */
1156 0x1, /* FC_BYTE */
1157 0x5b /* FC_END */
1158 };
1159
1160 StubDesc = Object_StubDesc;
1161 StubDesc.pFormatTypes = fmtstr_conf_array;
1162
1163 NdrClientInitializeNew(
1164 &RpcMessage,
1165 &StubMsg,
1166 &StubDesc,
1167 0);
1168
1169 StubMsg.BufferLength = 0;
1170 NdrConformantArrayBufferSize( &StubMsg,
1171 memsrc,
1172 fmtstr_conf_array );
1173 ok(StubMsg.BufferLength >= 20, "length %d\n", StubMsg.BufferLength);
1174
1175 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1176 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
1177 StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
1178
1179 ptr = NdrConformantArrayMarshall( &StubMsg, memsrc, fmtstr_conf_array );
1180 ok(ptr == NULL, "ret %p\n", ptr);
1181 ok(StubMsg.Buffer - StubMsg.BufferStart == 20, "Buffer %p Start %p len %d\n", StubMsg.Buffer, StubMsg.BufferStart, 20);
1182 ok(!memcmp(StubMsg.BufferStart + 4, memsrc, 16), "incorrectly marshaled\n");
1183
1184 StubMsg.Buffer = StubMsg.BufferStart;
1185 StubMsg.MemorySize = 0;
1186 mem = NULL;
1187
1188 /* Client */
1189 my_alloc_called = 0;
1190 /* passing mem == NULL with must_alloc == 0 crashes under Windows */
1191 NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
1192 ok(mem != NULL, "mem not alloced\n");
1193 ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1194 ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1195
1196 my_alloc_called = 0;
1197 StubMsg.Buffer = StubMsg.BufferStart;
1198 mem_orig = mem;
1199 NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
1200 ok(mem == mem_orig, "mem alloced\n");
1201 ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1202 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1203
1204 my_alloc_called = 0;
1205 StubMsg.Buffer = StubMsg.BufferStart;
1206 NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
1207 ok(mem != mem_orig, "mem not alloced\n");
1208 ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1209 ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1210
1211 my_free_called = 0;
1212 StubMsg.Buffer = StubMsg.BufferStart;
1213 NdrConformantArrayFree( &StubMsg, mem, fmtstr_conf_array );
1214 ok(my_free_called == 0, "free called %d\n", my_free_called);
1215 StubMsg.pfnFree(mem);
1216
1217 /* Server */
1218 my_alloc_called = 0;
1219 StubMsg.IsClient = 0;
1220 mem = NULL;
1221 StubMsg.Buffer = StubMsg.BufferStart;
1222 NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
1223 ok(mem == StubMsg.BufferStart + 4, "mem not pointing at buffer\n");
1224 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1225 my_alloc_called = 0;
1226 mem = NULL;
1227 StubMsg.Buffer = StubMsg.BufferStart;
1228 NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
1229 ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1230 ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1231 StubMsg.pfnFree(mem);
1232
1233 my_alloc_called = 0;
1234 mem = mem_orig;
1235 StubMsg.Buffer = StubMsg.BufferStart;
1236 NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
1237 ok(mem == mem_orig, "mem alloced\n");
1238 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1239
1240 my_alloc_called = 0;
1241 mem = mem_orig;
1242 StubMsg.Buffer = StubMsg.BufferStart;
1243 NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
1244 ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1245 ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1246 StubMsg.pfnFree(mem);
1247 StubMsg.pfnFree(mem_orig);
1248
1249 HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
1250 }
1251
1252 static void test_conformant_string(void)
1253 {
1254 RPC_MESSAGE RpcMessage;
1255 MIDL_STUB_MESSAGE StubMsg;
1256 MIDL_STUB_DESC StubDesc;
1257 void *ptr;
1258 unsigned char *mem, *mem_orig;
1259 char memsrc[] = "This is a test string";
1260
1261 static const unsigned char fmtstr_conf_str[] =
1262 {
1263 0x11, 0x8, /* FC_RP [simple_pointer] */
1264 0x22, /* FC_C_CSTRING */
1265 0x5c, /* FC_PAD */
1266 };
1267
1268 StubDesc = Object_StubDesc;
1269 StubDesc.pFormatTypes = fmtstr_conf_str;
1270
1271 NdrClientInitializeNew(
1272 &RpcMessage,
1273 &StubMsg,
1274 &StubDesc,
1275 0);
1276
1277 StubMsg.BufferLength = 0;
1278 NdrPointerBufferSize( &StubMsg,
1279 (unsigned char *)memsrc,
1280 fmtstr_conf_str );
1281 ok(StubMsg.BufferLength >= sizeof(memsrc) + 12, "length %d\n", StubMsg.BufferLength);
1282
1283 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1284 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
1285 StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
1286
1287 ptr = NdrPointerMarshall( &StubMsg, (unsigned char *)memsrc, fmtstr_conf_str );
1288 ok(ptr == NULL, "ret %p\n", ptr);
1289 ok(StubMsg.Buffer - StubMsg.BufferStart == sizeof(memsrc) + 12, "Buffer %p Start %p len %d\n",
1290 StubMsg.Buffer, StubMsg.BufferStart, StubMsg.Buffer - StubMsg.BufferStart);
1291 ok(!memcmp(StubMsg.BufferStart + 12, memsrc, sizeof(memsrc)), "incorrectly marshaled\n");
1292
1293 StubMsg.Buffer = StubMsg.BufferStart;
1294 StubMsg.MemorySize = 0;
1295 mem = NULL;
1296
1297 /* Client */
1298 my_alloc_called = 0;
1299 StubMsg.Buffer = StubMsg.BufferStart;
1300 mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
1301 NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
1302 ok(mem == mem_orig, "mem not alloced\n");
1303 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1304
1305 my_alloc_called = 0;
1306 StubMsg.Buffer = StubMsg.BufferStart;
1307 NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
1308 todo_wine {
1309 ok(mem == mem_orig, "mem not alloced\n");
1310 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1311 }
1312
1313 my_free_called = 0;
1314 StubMsg.Buffer = StubMsg.BufferStart;
1315 NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
1316 ok(my_free_called == 1, "free called %d\n", my_free_called);
1317
1318 mem = my_alloc(10);
1319 my_free_called = 0;
1320 StubMsg.Buffer = StubMsg.BufferStart;
1321 NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
1322 ok(my_free_called == 1, "free called %d\n", my_free_called);
1323
1324 /* Server */
1325 my_alloc_called = 0;
1326 StubMsg.IsClient = 0;
1327 mem = NULL;
1328 StubMsg.Buffer = StubMsg.BufferStart;
1329 NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
1330 ok(mem == StubMsg.BufferStart + 12, "mem not pointing at buffer\n");
1331 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1332
1333 my_alloc_called = 0;
1334 mem = NULL;
1335 StubMsg.Buffer = StubMsg.BufferStart;
1336 NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
1337 todo_wine {
1338 ok(mem == StubMsg.BufferStart + 12, "mem not pointing at buffer\n");
1339 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1340 }
1341
1342 my_alloc_called = 0;
1343 mem = mem_orig;
1344 StubMsg.Buffer = StubMsg.BufferStart;
1345 NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
1346 ok(mem == StubMsg.BufferStart + 12, "mem not pointing at buffer\n");
1347 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1348
1349 my_alloc_called = 0;
1350 mem = mem_orig;
1351 StubMsg.Buffer = StubMsg.BufferStart;
1352 NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
1353 todo_wine {
1354 ok(mem == StubMsg.BufferStart + 12, "mem not pointing at buffer\n");
1355 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1356 }
1357
1358 mem = my_alloc(10);
1359 my_free_called = 0;
1360 StubMsg.Buffer = StubMsg.BufferStart;
1361 NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
1362 ok(my_free_called == 1, "free called %d\n", my_free_called);
1363
1364 HeapFree(GetProcessHeap(), 0, mem_orig);
1365 HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
1366 }
1367
1368 static void test_nonconformant_string(void)
1369 {
1370 RPC_MESSAGE RpcMessage;
1371 MIDL_STUB_MESSAGE StubMsg;
1372 MIDL_STUB_DESC StubDesc;
1373 void *ptr;
1374 unsigned char *mem, *mem_orig;
1375 unsigned char memsrc[10] = "This is";
1376 unsigned char memsrc2[10] = "This is a";
1377
1378 static const unsigned char fmtstr_nonconf_str[] =
1379 {
1380 0x26, /* FC_CSTRING */
1381 0x5c, /* FC_PAD */
1382 NdrFcShort( 0xa ), /* 10 */
1383 };
1384
1385 StubDesc = Object_StubDesc;
1386 StubDesc.pFormatTypes = fmtstr_nonconf_str;
1387
1388 /* length < size */
1389 NdrClientInitializeNew(
1390 &RpcMessage,
1391 &StubMsg,
1392 &StubDesc,
1393 0);
1394
1395 StubMsg.BufferLength = 0;
1396
1397 NdrNonConformantStringBufferSize( &StubMsg,
1398 (unsigned char *)memsrc,
1399 fmtstr_nonconf_str );
1400 ok(StubMsg.BufferLength >= strlen((char *)memsrc) + 1 + 8, "length %d\n", StubMsg.BufferLength);
1401
1402 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1403 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
1404 StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
1405
1406 ptr = NdrNonConformantStringMarshall( &StubMsg, (unsigned char *)memsrc, fmtstr_nonconf_str );
1407 ok(ptr == NULL, "ret %p\n", ptr);
1408 ok(StubMsg.Buffer - StubMsg.BufferStart == strlen((char *)memsrc) + 1 + 8, "Buffer %p Start %p len %d\n",
1409 StubMsg.Buffer, StubMsg.BufferStart, StubMsg.Buffer - StubMsg.BufferStart);
1410 ok(!memcmp(StubMsg.BufferStart + 8, memsrc, strlen((char *)memsrc) + 1), "incorrectly marshaled\n");
1411
1412 StubMsg.Buffer = StubMsg.BufferStart;
1413 StubMsg.MemorySize = 0;
1414 mem = NULL;
1415
1416 /* Client */
1417 my_alloc_called = 0;
1418 StubMsg.Buffer = StubMsg.BufferStart;
1419 mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
1420 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1421 ok(mem == mem_orig, "mem alloced\n");
1422 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1423
1424 my_alloc_called = 0;
1425 StubMsg.Buffer = StubMsg.BufferStart;
1426 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
1427 todo_wine
1428 ok(mem == mem_orig, "mem alloced\n");
1429 todo_wine
1430 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1431
1432 /* Server */
1433 my_alloc_called = 0;
1434 StubMsg.IsClient = 0;
1435 mem = NULL;
1436 StubMsg.Buffer = StubMsg.BufferStart;
1437 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1438 ok(mem != mem_orig, "mem not alloced\n");
1439 ok(mem != StubMsg.BufferStart + 8, "mem pointing at buffer\n");
1440 ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1441 NdrOleFree(mem);
1442
1443 my_alloc_called = 0;
1444 mem = mem_orig;
1445 StubMsg.Buffer = StubMsg.BufferStart;
1446 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1447 ok(mem == mem_orig, "mem alloced\n");
1448 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1449
1450 my_alloc_called = 0;
1451 mem = mem_orig;
1452 StubMsg.Buffer = StubMsg.BufferStart;
1453 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
1454 todo_wine
1455 ok(mem == mem_orig, "mem alloced\n");
1456 todo_wine
1457 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1458
1459 HeapFree(GetProcessHeap(), 0, mem_orig);
1460 HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
1461
1462 /* length = size */
1463 NdrClientInitializeNew(
1464 &RpcMessage,
1465 &StubMsg,
1466 &StubDesc,
1467 0);
1468
1469 StubMsg.BufferLength = 0;
1470
1471 NdrNonConformantStringBufferSize( &StubMsg,
1472 (unsigned char *)memsrc2,
1473 fmtstr_nonconf_str );
1474 ok(StubMsg.BufferLength >= strlen((char *)memsrc2) + 1 + 8, "length %d\n", StubMsg.BufferLength);
1475
1476 /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1477 StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
1478 StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
1479
1480 ptr = NdrNonConformantStringMarshall( &StubMsg, (unsigned char *)memsrc2, fmtstr_nonconf_str );
1481 ok(ptr == NULL, "ret %p\n", ptr);
1482 ok(StubMsg.Buffer - StubMsg.BufferStart == strlen((char *)memsrc2) + 1 + 8, "Buffer %p Start %p len %d\n",
1483 StubMsg.Buffer, StubMsg.BufferStart, StubMsg.Buffer - StubMsg.BufferStart);
1484 ok(!memcmp(StubMsg.BufferStart + 8, memsrc2, strlen((char *)memsrc2) + 1), "incorrectly marshaled\n");
1485
1486 StubMsg.Buffer = StubMsg.BufferStart;
1487 StubMsg.MemorySize = 0;
1488 mem = NULL;
1489
1490 /* Client */
1491 my_alloc_called = 0;
1492 StubMsg.Buffer = StubMsg.BufferStart;
1493 mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
1494 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1495 ok(mem == mem_orig, "mem alloced\n");
1496 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1497
1498 my_alloc_called = 0;
1499 StubMsg.Buffer = StubMsg.BufferStart;
1500 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
1501 todo_wine
1502 ok(mem == mem_orig, "mem alloced\n");
1503 todo_wine
1504 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1505
1506 /* Server */
1507 my_alloc_called = 0;
1508 StubMsg.IsClient = 0;
1509 mem = NULL;
1510 StubMsg.Buffer = StubMsg.BufferStart;
1511 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1512 ok(mem != mem_orig, "mem not alloced\n");
1513 ok(mem != StubMsg.BufferStart + 8, "mem pointing at buffer\n");
1514 ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1515 NdrOleFree(mem);
1516
1517 my_alloc_called = 0;
1518 mem = mem_orig;
1519 StubMsg.Buffer = StubMsg.BufferStart;
1520 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1521 ok(mem == mem_orig, "mem alloced\n");
1522 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1523
1524 my_alloc_called = 0;
1525 mem = mem_orig;
1526 StubMsg.Buffer = StubMsg.BufferStart;
1527 NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
1528 todo_wine
1529 ok(mem == mem_orig, "mem alloced\n");
1530 todo_wine
1531 ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1532
1533 HeapFree(GetProcessHeap(), 0, mem_orig);
1534 HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
1535 }
1536
1537 static void test_ndr_buffer(void)
1538 {
1539 static unsigned char ncalrpc[] = "ncalrpc";
1540 static unsigned char endpoint[] = "winetest:" __FILE__;
1541 RPC_MESSAGE RpcMessage;
1542 MIDL_STUB_MESSAGE StubMsg;
1543 MIDL_STUB_DESC StubDesc = Object_StubDesc;
1544 unsigned char *ret;
1545 unsigned char *binding;
1546 RPC_BINDING_HANDLE Handle;
1547 RPC_STATUS status;
1548
1549 StubDesc.RpcInterfaceInformation = (void *)&IFoo___RpcServerInterface;
1550
1551 ok(RPC_S_OK == RpcServerUseProtseqEp(ncalrpc, 20, endpoint, NULL), "RpcServerUseProtseqEp\n");
1552 ok(RPC_S_OK == RpcServerRegisterIf(IFoo_v0_0_s_ifspec, NULL, NULL), "RpcServerRegisterIf\n");
1553 ok(RPC_S_OK == RpcServerListen(1, 20, TRUE), "RpcServerListen\n");
1554
1555 status = RpcStringBindingCompose(NULL, ncalrpc, NULL, endpoint, NULL, &binding);
1556 ok(status == RPC_S_OK, "RpcStringBindingCompose failed (%lu)\n", status);
1557
1558 status = RpcBindingFromStringBinding(binding, &Handle);
1559 ok(status == RPC_S_OK, "RpcBindingFromStringBinding failed (%lu)\n", status);
1560
1561 NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 5);
1562
1563 ret = NdrGetBuffer(&StubMsg, 10, Handle);
1564 ok(ret == StubMsg.Buffer, "NdrGetBuffer should have returned the same value as StubMsg.Buffer instead of %p\n", ret);
1565 ok(RpcMessage.Handle != NULL, "RpcMessage.Handle should not have been NULL\n");
1566 ok(RpcMessage.Buffer != NULL, "RpcMessage.Buffer should not have been NULL\n");
1567 ok(RpcMessage.BufferLength == 10, "RpcMessage.BufferLength should have been 10 instead of %d\n", RpcMessage.BufferLength);
1568 ok(RpcMessage.RpcFlags == 0, "RpcMessage.RpcFlags should have been 0x0 instead of 0x%lx\n", RpcMessage.RpcFlags);
1569 ok(StubMsg.Buffer != NULL, "Buffer should not have been NULL\n");
1570 ok(!StubMsg.BufferStart, "BufferStart should have been NULL instead of %p\n", StubMsg.BufferStart);
1571 ok(!StubMsg.BufferEnd, "BufferEnd should have been NULL instead of %p\n", StubMsg.BufferEnd);
1572 todo_wine
1573 ok(StubMsg.BufferLength == 0, "BufferLength should have left as 0 instead of being set to %d\n", StubMsg.BufferLength);
1574 ok(StubMsg.fBufferValid == TRUE, "fBufferValid should have been TRUE instead of 0x%x\n", StubMsg.fBufferValid);
1575
1576 StubMsg.BufferLength = 1;
1577 NdrFreeBuffer(&StubMsg);
1578 ok(RpcMessage.Handle != NULL, "RpcMessage.Handle should not have been NULL\n");
1579 ok(RpcMessage.Buffer != NULL, "RpcMessage.Buffer should not have been NULL\n");
1580 ok(RpcMessage.BufferLength == 10, "RpcMessage.BufferLength should have been left as 10 instead of %d\n", RpcMessage.BufferLength);
1581 ok(StubMsg.Buffer != NULL, "Buffer should not have been NULL\n");
1582 ok(StubMsg.BufferLength == 1, "BufferLength should have left as 1 instead of being set to %d\n", StubMsg.BufferLength);
1583 ok(StubMsg.fBufferValid == FALSE, "fBufferValid should have been FALSE instead of 0x%x\n", StubMsg.fBufferValid);
1584
1585 /* attempt double-free */
1586 NdrFreeBuffer(&StubMsg);
1587
1588 status = RpcServerUnregisterIf(NULL, NULL, FALSE);
1589 ok(status == RPC_S_OK, "RpcServerUnregisterIf failed (%lu)\n", status);
1590 }
1591
1592 START_TEST( ndr_marshall )
1593 {
1594 test_ndr_simple_type();
1595 test_simple_types();
1596 test_simple_struct();
1597 test_fullpointer_xlat();
1598 test_client_init();
1599 test_server_init();
1600 test_ndr_allocate();
1601 test_conformant_array();
1602 test_conformant_string();
1603 test_nonconformant_string();
1604 test_ndr_buffer();
1605 }