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