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