git.oblomov.eu Git - wine/blob - dlls/rpcrt4/tests/ndr_marshall.c

   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     TEST_ZERO(pPointerQueueState, "%p");
1165     TEST_ZERO(IgnoreEmbeddedPointers, "%d");
1166     TEST_ZERO(PointerBufferMark, "%p");
1167     TEST_ZERO(CorrDespIncrement, "%d");
1168     TEST_ZERO(uFlags, "%d");
1169     /* FIXME: UniquePtrCount */
1170     TEST_ULONG_PTR_UNSET(MaxCount);
1171     TEST_ULONG_UNSET(Offset);
1172     TEST_ULONG_UNSET(ActualCount);
1173     ok(stubMsg.pfnAllocate == my_alloc, "stubMsg.pfnAllocate should have been %p instead of %p\n", my_alloc, stubMsg.pfnAllocate);
1174     ok(stubMsg.pfnFree == my_free, "stubMsg.pfnFree should have been %p instead of %p\n", my_free, stubMsg.pfnFree);
1175     TEST_ZERO(StackTop, "%p");
1176     TEST_POINTER_UNSET(pPresentedType);
1177     TEST_POINTER_UNSET(pTransmitType);
1178     TEST_POINTER_UNSET(SavedHandle);
1179     ok(stubMsg.StubDesc == &Object_StubDesc, "stubMsg.StubDesc should have been %p instead of %p\n", &Object_StubDesc, stubMsg.StubDesc);
1180     TEST_POINTER_UNSET(FullPtrXlatTables);
1181     TEST_ZERO(FullPtrRefId, "%d");
1182     TEST_ZERO(PointerLength, "%d");
1183     TEST_ZERO(fInDontFree, "%d");
1184     TEST_ZERO(fDontCallFreeInst, "%d");
1185     TEST_ZERO(fInOnlyParam, "%d");
1186     TEST_ZERO(fHasReturn, "%d");
1187     TEST_ZERO(fHasExtensions, "%d");
1188     TEST_ZERO(fHasNewCorrDesc, "%d");
1189     TEST_ZERO(fIsIn, "%d");
1190     TEST_ZERO(fIsOut, "%d");
1191     TEST_ZERO(fIsOicf, "%d");
1192     TEST_ZERO(fBufferValid, "%d");
1193     TEST_ZERO(fHasMemoryValidateCallback, "%d");
1194     TEST_ZERO(fInFree, "%d");
1195     TEST_ZERO(fNeedMCCP, "%d");
1196     TEST_ZERO(fUnused, "0x%x");
1197     ok(stubMsg.fUnused2 == 0xffffcccc, "stubMsg.fUnused2 should have been 0xffffcccc instead of 0x%x\n", stubMsg.fUnused2);
1198     ok(stubMsg.dwDestContext == MSHCTX_DIFFERENTMACHINE, "stubMsg.dwDestContext should have been MSHCTX_DIFFERENTMACHINE instead of %d\n", stubMsg.dwDestContext);
1199     TEST_ZERO(pvDestContext, "%p");
1200     TEST_POINTER_UNSET(SavedContextHandles);
1201     TEST_ULONG_UNSET(ParamNumber);
1202     TEST_ZERO(pRpcChannelBuffer, "%p");
1203     TEST_ZERO(pArrayInfo, "%p");
1204     TEST_POINTER_UNSET(SizePtrCountArray);
1205     TEST_POINTER_UNSET(SizePtrOffsetArray);
1206     TEST_POINTER_UNSET(SizePtrLengthArray);
1207     TEST_POINTER_UNSET(pArgQueue);
1208     TEST_ZERO(dwStubPhase, "%d");
1209     /* FIXME: where does this value come from? */
1210     trace("LowStackMark is %p\n", stubMsg.LowStackMark);
1211     TEST_ZERO(pAsyncMsg, "%p");
1212     TEST_ZERO(pCorrInfo, "%p");
1213     TEST_ZERO(pCorrMemory, "%p");
1214     TEST_ZERO(pMemoryList, "%p");
1215     TEST_POINTER_UNSET(pCSInfo);
1216     TEST_POINTER_UNSET(ConformanceMark);
1217     TEST_POINTER_UNSET(VarianceMark);
1218     ok(stubMsg.Unused == 0xcccccccc, "Unused should have be unset instead of 0x%lx\n", stubMsg.Unused);
1219     TEST_POINTER_UNSET(pContext);
1220     TEST_POINTER_UNSET(ContextHandleHash);
1221     TEST_POINTER_UNSET(pUserMarshalList);
1222     TEST_ULONG_PTR_UNSET(Reserved51_3);
1223     TEST_ULONG_PTR_UNSET(Reserved51_4);
1224     TEST_ULONG_PTR_UNSET(Reserved51_5);
1225 #undef TEST_ULONG_UNSET
1226 #undef TEST_POINTER_UNSET
1227 #undef TEST_ZERO
1228
1229 }
1230
1231 static void test_server_init(void)
1232 {
1233     MIDL_STUB_MESSAGE stubMsg;
1234     RPC_MESSAGE rpcMsg;
1235     unsigned char *ret;
1236     unsigned char buffer[256];
1237
1238     memset(&rpcMsg, 0, sizeof(rpcMsg));
1239     rpcMsg.Buffer = buffer;
1240     rpcMsg.BufferLength = sizeof(buffer);
1241     rpcMsg.RpcFlags = RPC_BUFFER_COMPLETE;
1242
1243     memset(&stubMsg, 0xcc, sizeof(stubMsg));
1244
1245     ret = NdrServerInitializeNew(&rpcMsg, &stubMsg, &Object_StubDesc);
1246     ok(ret == NULL, "NdrServerInitializeNew should have returned NULL instead of %p\n", ret);
1247
1248 #define TEST_ZERO(field, fmt) ok(stubMsg.field == 0, #field " should have been set to zero instead of " fmt "\n", stubMsg.field)
1249 #define TEST_POINTER_UNSET(field) ok(stubMsg.field == (void *)0xcccccccc, #field " should have been unset instead of %p\n", stubMsg.field)
1250 #define TEST_ULONG_UNSET(field) ok(stubMsg.field == 0xcccccccc, #field " should have been unset instead of 0x%x\n", stubMsg.field)
1251 #define TEST_ULONG_PTR_UNSET(field) ok(stubMsg.field == 0xcccccccc, #field " should have been unset instead of 0x%lx\n", stubMsg.field)
1252
1253     ok(stubMsg.RpcMsg == &rpcMsg, "stubMsg.RpcMsg should have been %p instead of %p\n", &rpcMsg, stubMsg.RpcMsg);
1254     ok(stubMsg.Buffer == buffer, "stubMsg.Buffer should have been %p instead of %p\n", buffer, stubMsg.Buffer);
1255     ok(stubMsg.BufferStart == buffer, "stubMsg.BufferStart should have been %p instead of %p\n", buffer, stubMsg.BufferStart);
1256     ok(stubMsg.BufferEnd == buffer + sizeof(buffer), "stubMsg.BufferEnd should have been %p instead of %p\n", buffer + sizeof(buffer), stubMsg.BufferEnd);
1257     TEST_POINTER_UNSET(BufferMark);
1258 todo_wine
1259     TEST_ZERO(BufferLength, "%d");
1260     TEST_ULONG_UNSET(MemorySize);
1261     TEST_POINTER_UNSET(Memory);
1262     ok(stubMsg.IsClient == 0, "stubMsg.IsClient should have been 0 instead of %u\n", stubMsg.IsClient);
1263     TEST_ZERO(ReuseBuffer, "%d");
1264     TEST_ZERO(pAllocAllNodesContext, "%p");
1265     TEST_ZERO(pPointerQueueState, "%p");
1266     TEST_ZERO(IgnoreEmbeddedPointers, "%d");
1267     TEST_ZERO(PointerBufferMark, "%p");
1268     ok(stubMsg.CorrDespIncrement == 0xcc, "CorrDespIncrement should have been unset instead of 0x%x\n", stubMsg.CorrDespIncrement);
1269     TEST_ZERO(uFlags, "%d");
1270     /* FIXME: UniquePtrCount */
1271     TEST_ULONG_PTR_UNSET(MaxCount);
1272     TEST_ULONG_UNSET(Offset);
1273     TEST_ULONG_UNSET(ActualCount);
1274     ok(stubMsg.pfnAllocate == my_alloc, "stubMsg.pfnAllocate should have been %p instead of %p\n", my_alloc, stubMsg.pfnAllocate);
1275     ok(stubMsg.pfnFree == my_free, "stubMsg.pfnFree should have been %p instead of %p\n", my_free, stubMsg.pfnFree);
1276     TEST_ZERO(StackTop, "%p");
1277     TEST_POINTER_UNSET(pPresentedType);
1278     TEST_POINTER_UNSET(pTransmitType);
1279     TEST_POINTER_UNSET(SavedHandle);
1280     ok(stubMsg.StubDesc == &Object_StubDesc, "stubMsg.StubDesc should have been %p instead of %p\n", &Object_StubDesc, stubMsg.StubDesc);
1281     TEST_ZERO(FullPtrXlatTables, "%p");
1282     TEST_ZERO(FullPtrRefId, "%d");
1283     TEST_ZERO(PointerLength, "%d");
1284     TEST_ZERO(fInDontFree, "%d");
1285     TEST_ZERO(fDontCallFreeInst, "%d");
1286     TEST_ZERO(fInOnlyParam, "%d");
1287     TEST_ZERO(fHasReturn, "%d");
1288     TEST_ZERO(fHasExtensions, "%d");
1289     TEST_ZERO(fHasNewCorrDesc, "%d");
1290     TEST_ZERO(fIsIn, "%d");
1291     TEST_ZERO(fIsOut, "%d");
1292     TEST_ZERO(fIsOicf, "%d");
1293     trace("fBufferValid = %d\n", stubMsg.fBufferValid);
1294     TEST_ZERO(fHasMemoryValidateCallback, "%d");
1295     TEST_ZERO(fInFree, "%d");
1296     TEST_ZERO(fNeedMCCP, "%d");
1297     TEST_ZERO(fUnused, "0x%x");
1298     ok(stubMsg.fUnused2 == 0xffffcccc, "stubMsg.fUnused2 should have been 0xffffcccc instead of 0x%x\n", stubMsg.fUnused2);
1299     ok(stubMsg.dwDestContext == MSHCTX_DIFFERENTMACHINE, "stubMsg.dwDestContext should have been MSHCTX_DIFFERENTMACHINE instead of %d\n", stubMsg.dwDestContext);
1300     TEST_ZERO(pvDestContext, "%p");
1301     TEST_POINTER_UNSET(SavedContextHandles);
1302     TEST_ULONG_UNSET(ParamNumber);
1303     TEST_ZERO(pRpcChannelBuffer, "%p");
1304     TEST_ZERO(pArrayInfo, "%p");
1305     TEST_POINTER_UNSET(SizePtrCountArray);
1306     TEST_POINTER_UNSET(SizePtrOffsetArray);
1307     TEST_POINTER_UNSET(SizePtrLengthArray);
1308     TEST_POINTER_UNSET(pArgQueue);
1309     TEST_ZERO(dwStubPhase, "%d");
1310     /* FIXME: where does this value come from? */
1311     trace("LowStackMark is %p\n", stubMsg.LowStackMark);
1312     TEST_ZERO(pAsyncMsg, "%p");
1313     TEST_ZERO(pCorrInfo, "%p");
1314     TEST_ZERO(pCorrMemory, "%p");
1315     TEST_ZERO(pMemoryList, "%p");
1316     TEST_POINTER_UNSET(pCSInfo);
1317     TEST_POINTER_UNSET(ConformanceMark);
1318     TEST_POINTER_UNSET(VarianceMark);
1319     ok(stubMsg.Unused == 0xcccccccc, "Unused should have be unset instead of 0x%lx\n", stubMsg.Unused);
1320     TEST_POINTER_UNSET(pContext);
1321     TEST_POINTER_UNSET(ContextHandleHash);
1322     TEST_POINTER_UNSET(pUserMarshalList);
1323     TEST_ULONG_PTR_UNSET(Reserved51_3);
1324     TEST_ULONG_PTR_UNSET(Reserved51_4);
1325     TEST_ULONG_PTR_UNSET(Reserved51_5);
1326 #undef TEST_ULONG_UNSET
1327 #undef TEST_POINTER_UNSET
1328 #undef TEST_ZERO
1329
1330 }
1331
1332 static void test_ndr_allocate(void)
1333 {
1334     RPC_MESSAGE RpcMessage;
1335     MIDL_STUB_MESSAGE StubMsg;
1336     MIDL_STUB_DESC StubDesc;
1337     void *p1, *p2;
1338     struct tag_mem_list_v1_t
1339     {
1340         DWORD magic;
1341         void *ptr;
1342         struct tag_mem_list_v1_t *next;
1343     } *mem_list_v1;
1344     struct tag_mem_list_v2_t
1345     {
1346         DWORD magic;
1347         DWORD size;
1348         DWORD unknown;
1349         struct tag_mem_list_v2_t *next;
1350     } *mem_list_v2;
1351     const DWORD magic_MEML = 'M' << 24 | 'E' << 16 | 'M' << 8 | 'L';
1352
1353     StubDesc = Object_StubDesc;
1354     NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 0);
1355
1356     ok(StubMsg.pMemoryList == NULL, "memlist %p\n", StubMsg.pMemoryList);
1357     my_alloc_called = my_free_called = 0;
1358     p1 = NdrAllocate(&StubMsg, 10);
1359     p2 = NdrAllocate(&StubMsg, 24);
1360     ok(my_alloc_called == 2, "alloc called %d\n", my_alloc_called);
1361     ok(StubMsg.pMemoryList != NULL, "StubMsg.pMemoryList NULL\n");
1362     if(StubMsg.pMemoryList)
1363     {
1364         mem_list_v2 = StubMsg.pMemoryList;
1365         if (mem_list_v2->size == 24)
1366         {
1367             trace("v2 mem list format\n");
1368             ok((char *)mem_list_v2 == (char *)p2 + 24, "expected mem_list_v2 pointer %p, but got %p\n", (char *)p2 + 24, mem_list_v2);
1369             ok(mem_list_v2->magic == magic_MEML, "magic %08x\n", mem_list_v2->magic);
1370             ok(mem_list_v2->size == 24, "wrong size for p2 %d\n", mem_list_v2->size);
1371             ok(mem_list_v2->unknown == 0, "wrong unknown for p2 0x%x\n", mem_list_v2->unknown);
1372             ok(mem_list_v2->next != NULL, "next NULL\n");
1373             mem_list_v2 = mem_list_v2->next;
1374             if(mem_list_v2)
1375             {
1376                 ok((char *)mem_list_v2 == (char *)p1 + 16, "expected mem_list_v2 pointer %p, but got %p\n", (char *)p1 + 16, mem_list_v2);
1377                 ok(mem_list_v2->magic == magic_MEML, "magic %08x\n", mem_list_v2->magic);
1378                 ok(mem_list_v2->size == 16, "wrong size for p1 %d\n", mem_list_v2->size);
1379                 ok(mem_list_v2->unknown == 0, "wrong unknown for p1 0x%x\n", mem_list_v2->unknown);
1380                 ok(mem_list_v2->next == NULL, "next %p\n", mem_list_v2->next);
1381             }
1382         }
1383         else
1384         {
1385             trace("v1 mem list format\n");
1386             mem_list_v1 = StubMsg.pMemoryList;
1387             ok(mem_list_v1->magic == magic_MEML, "magic %08x\n", mem_list_v1->magic);
1388             ok(mem_list_v1->ptr == p2, "ptr != p2\n");
1389             ok(mem_list_v1->next != NULL, "next NULL\n");
1390             mem_list_v1 = mem_list_v1->next;
1391             if(mem_list_v1)
1392             {
1393                 ok(mem_list_v1->magic == magic_MEML, "magic %08x\n", mem_list_v1->magic);
1394                 ok(mem_list_v1->ptr == p1, "ptr != p1\n");
1395                 ok(mem_list_v1->next == NULL, "next %p\n", mem_list_v1->next);
1396             }
1397         }
1398     }
1399     /* NdrFree isn't exported so we can't test free'ing */
1400 }
1401
1402 static void test_conformant_array(void)
1403 {
1404     RPC_MESSAGE RpcMessage;
1405     MIDL_STUB_MESSAGE StubMsg;
1406     MIDL_STUB_DESC StubDesc;
1407     void *ptr;
1408     unsigned char *mem, *mem_orig;
1409     unsigned char memsrc[20];
1410     unsigned int i;
1411
1412     static const unsigned char fmtstr_conf_array[] =
1413     {
1414         0x1b,              /* FC_CARRAY */
1415         0x0,               /* align */
1416         NdrFcShort( 0x1 ), /* elem size */
1417         0x40,              /* Corr desc:  const */
1418         0x0,
1419         NdrFcShort(0x10),  /* const = 0x10 */
1420         0x1,               /* FC_BYTE */
1421         0x5b               /* FC_END */
1422     };
1423
1424     for (i = 0; i < sizeof(memsrc); i++)
1425         memsrc[i] = i * i;
1426
1427     StubDesc = Object_StubDesc;
1428     StubDesc.pFormatTypes = fmtstr_conf_array;
1429
1430     NdrClientInitializeNew(
1431                            &RpcMessage,
1432                            &StubMsg,
1433                            &StubDesc,
1434                            0);
1435
1436     StubMsg.BufferLength = 0;
1437     NdrConformantArrayBufferSize( &StubMsg,
1438                           memsrc,
1439                           fmtstr_conf_array );
1440     ok(StubMsg.BufferLength >= 20, "length %d\n", StubMsg.BufferLength);
1441
1442     /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1443     StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
1444     StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
1445
1446     ptr = NdrConformantArrayMarshall( &StubMsg,  memsrc, fmtstr_conf_array );
1447     ok(ptr == NULL, "ret %p\n", ptr);
1448     ok(StubMsg.Buffer - StubMsg.BufferStart == 20, "Buffer %p Start %p len %d\n", StubMsg.Buffer, StubMsg.BufferStart, 20);
1449     ok(!memcmp(StubMsg.BufferStart + 4, memsrc, 16), "incorrectly marshaled\n");
1450
1451     StubMsg.Buffer = StubMsg.BufferStart;
1452     StubMsg.MemorySize = 0;
1453     mem = NULL;
1454
1455     /* Client */
1456     my_alloc_called = 0;
1457     /* passing mem == NULL with must_alloc == 0 crashes under Windows */
1458     NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
1459     ok(mem != NULL, "mem not alloced\n");
1460     ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1461     ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1462
1463     my_alloc_called = 0;
1464     StubMsg.Buffer = StubMsg.BufferStart;
1465     mem_orig = mem;
1466     NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
1467     ok(mem == mem_orig, "mem alloced\n");
1468     ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1469     ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1470
1471     my_alloc_called = 0;
1472     StubMsg.Buffer = StubMsg.BufferStart;
1473     NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
1474     ok(mem != mem_orig, "mem not alloced\n");
1475     ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1476     ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1477
1478     my_free_called = 0;
1479     StubMsg.Buffer = StubMsg.BufferStart;
1480     NdrConformantArrayFree( &StubMsg, mem, fmtstr_conf_array );
1481     ok(my_free_called == 0, "free called %d\n", my_free_called);
1482     StubMsg.pfnFree(mem);
1483
1484     /* Server */
1485     my_alloc_called = 0;
1486     StubMsg.IsClient = 0;
1487     mem = NULL;
1488     StubMsg.Buffer = StubMsg.BufferStart;
1489     NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
1490     ok(mem == StubMsg.BufferStart + 4, "mem not pointing at buffer\n");
1491     ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1492     my_alloc_called = 0;
1493     mem = NULL;
1494     StubMsg.Buffer = StubMsg.BufferStart;
1495     NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
1496     ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1497     ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1498     StubMsg.pfnFree(mem);
1499
1500     my_alloc_called = 0;
1501     mem = mem_orig;
1502     StubMsg.Buffer = StubMsg.BufferStart;
1503     NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
1504     ok(mem == mem_orig, "mem alloced\n");
1505     ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1506
1507     my_alloc_called = 0;
1508     mem = mem_orig;
1509     StubMsg.Buffer = StubMsg.BufferStart;
1510     NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
1511     ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
1512     ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1513     StubMsg.pfnFree(mem);
1514     StubMsg.pfnFree(mem_orig);
1515
1516     HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
1517 }
1518
1519 static void test_conformant_string(void)
1520 {
1521     RPC_MESSAGE RpcMessage;
1522     MIDL_STUB_MESSAGE StubMsg;
1523     MIDL_STUB_DESC StubDesc;
1524     void *ptr;
1525     unsigned char *mem, *mem_orig;
1526     char memsrc[] = "This is a test string";
1527
1528     static const unsigned char fmtstr_conf_str[] =
1529     {
1530                         0x11, 0x8,      /* FC_RP [simple_pointer] */
1531                         0x22,           /* FC_C_CSTRING */
1532                         0x5c,           /* FC_PAD */
1533     };
1534
1535     StubDesc = Object_StubDesc;
1536     StubDesc.pFormatTypes = fmtstr_conf_str;
1537
1538     NdrClientInitializeNew(
1539                            &RpcMessage,
1540                            &StubMsg,
1541                            &StubDesc,
1542                            0);
1543
1544     StubMsg.BufferLength = 0;
1545     NdrPointerBufferSize( &StubMsg,
1546                           (unsigned char *)memsrc,
1547                           fmtstr_conf_str );
1548     ok(StubMsg.BufferLength >= sizeof(memsrc) + 12, "length %d\n", StubMsg.BufferLength);
1549
1550     /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1551     StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
1552     StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
1553
1554     ptr = NdrPointerMarshall( &StubMsg, (unsigned char *)memsrc, fmtstr_conf_str );
1555     ok(ptr == NULL, "ret %p\n", ptr);
1556     ok(StubMsg.Buffer - StubMsg.BufferStart == sizeof(memsrc) + 12, "Buffer %p Start %p len %d\n",
1557        StubMsg.Buffer, StubMsg.BufferStart, StubMsg.Buffer - StubMsg.BufferStart);
1558     ok(!memcmp(StubMsg.BufferStart + 12, memsrc, sizeof(memsrc)), "incorrectly marshaled\n");
1559
1560     StubMsg.Buffer = StubMsg.BufferStart;
1561     StubMsg.MemorySize = 0;
1562     mem = NULL;
1563
1564     /* Client */
1565     my_alloc_called = 0;
1566     StubMsg.Buffer = StubMsg.BufferStart;
1567     mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
1568     NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
1569     ok(mem == mem_orig, "mem not alloced\n");
1570     ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1571
1572     my_alloc_called = 0;
1573     StubMsg.Buffer = StubMsg.BufferStart;
1574     NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
1575 todo_wine {
1576     ok(mem == mem_orig, "mem not alloced\n");
1577     ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1578 }
1579
1580     my_free_called = 0;
1581     StubMsg.Buffer = StubMsg.BufferStart;
1582     NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
1583     ok(my_free_called == 1, "free called %d\n", my_free_called);
1584
1585     mem = my_alloc(10);
1586     my_free_called = 0;
1587     StubMsg.Buffer = StubMsg.BufferStart;
1588     NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
1589     ok(my_free_called == 1, "free called %d\n", my_free_called);
1590
1591     /* Server */
1592     my_alloc_called = 0;
1593     StubMsg.IsClient = 0;
1594     mem = NULL;
1595     StubMsg.Buffer = StubMsg.BufferStart;
1596     NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
1597     ok(mem == StubMsg.BufferStart + 12, "mem not pointing at buffer\n");
1598     ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1599
1600     my_alloc_called = 0;
1601     mem = NULL;
1602     StubMsg.Buffer = StubMsg.BufferStart;
1603     NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
1604 todo_wine {
1605     ok(mem == StubMsg.BufferStart + 12, "mem not pointing at buffer\n");
1606     ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1607 }
1608
1609     my_alloc_called = 0;
1610     mem = mem_orig;
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 = mem_orig;
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     mem = my_alloc(10);
1626     my_free_called = 0;
1627     StubMsg.Buffer = StubMsg.BufferStart;
1628     NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
1629     ok(my_free_called == 1, "free called %d\n", my_free_called);
1630
1631     HeapFree(GetProcessHeap(), 0, mem_orig);
1632     HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
1633 }
1634
1635 static void test_nonconformant_string(void)
1636 {
1637     RPC_MESSAGE RpcMessage;
1638     MIDL_STUB_MESSAGE StubMsg;
1639     MIDL_STUB_DESC StubDesc;
1640     void *ptr;
1641     unsigned char *mem, *mem_orig;
1642     unsigned char memsrc[10] = "This is";
1643     unsigned char memsrc2[10] = "This is a";
1644
1645     static const unsigned char fmtstr_nonconf_str[] =
1646     {
1647                         0x26,           /* FC_CSTRING */
1648                         0x5c,           /* FC_PAD */
1649                         NdrFcShort( 0xa ),      /* 10 */
1650     };
1651
1652     StubDesc = Object_StubDesc;
1653     StubDesc.pFormatTypes = fmtstr_nonconf_str;
1654
1655     /* length < size */
1656     NdrClientInitializeNew(
1657                            &RpcMessage,
1658                            &StubMsg,
1659                            &StubDesc,
1660                            0);
1661
1662     StubMsg.BufferLength = 0;
1663
1664     NdrNonConformantStringBufferSize( &StubMsg,
1665                           (unsigned char *)memsrc,
1666                           fmtstr_nonconf_str );
1667     ok(StubMsg.BufferLength >= strlen((char *)memsrc) + 1 + 8, "length %d\n", StubMsg.BufferLength);
1668
1669     /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1670     StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
1671     StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
1672
1673     ptr = NdrNonConformantStringMarshall( &StubMsg, (unsigned char *)memsrc, fmtstr_nonconf_str );
1674     ok(ptr == NULL, "ret %p\n", ptr);
1675     ok(StubMsg.Buffer - StubMsg.BufferStart == strlen((char *)memsrc) + 1 + 8, "Buffer %p Start %p len %d\n",
1676        StubMsg.Buffer, StubMsg.BufferStart, StubMsg.Buffer - StubMsg.BufferStart);
1677     ok(!memcmp(StubMsg.BufferStart + 8, memsrc, strlen((char *)memsrc) + 1), "incorrectly marshaled\n");
1678
1679     StubMsg.Buffer = StubMsg.BufferStart;
1680     StubMsg.MemorySize = 0;
1681     mem = NULL;
1682
1683     /* Client */
1684     my_alloc_called = 0;
1685     StubMsg.Buffer = StubMsg.BufferStart;
1686     mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
1687     NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1688     ok(mem == mem_orig, "mem alloced\n");
1689     ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1690
1691     my_alloc_called = 0;
1692     StubMsg.Buffer = StubMsg.BufferStart;
1693     NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
1694     todo_wine
1695     ok(mem == mem_orig, "mem alloced\n");
1696     todo_wine
1697     ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1698
1699     /* Server */
1700     my_alloc_called = 0;
1701     StubMsg.IsClient = 0;
1702     mem = NULL;
1703     StubMsg.Buffer = StubMsg.BufferStart;
1704     NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1705     ok(mem != mem_orig, "mem not alloced\n");
1706     ok(mem != StubMsg.BufferStart + 8, "mem pointing at buffer\n");
1707     ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1708     NdrOleFree(mem);
1709
1710     my_alloc_called = 0;
1711     mem = mem_orig;
1712     StubMsg.Buffer = StubMsg.BufferStart;
1713     NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1714     ok(mem == mem_orig, "mem alloced\n");
1715     ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1716
1717     my_alloc_called = 0;
1718     mem = mem_orig;
1719     StubMsg.Buffer = StubMsg.BufferStart;
1720     NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
1721     todo_wine
1722     ok(mem == mem_orig, "mem alloced\n");
1723     todo_wine
1724     ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1725
1726     HeapFree(GetProcessHeap(), 0, mem_orig);
1727     HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
1728
1729     /* length = size */
1730     NdrClientInitializeNew(
1731                            &RpcMessage,
1732                            &StubMsg,
1733                            &StubDesc,
1734                            0);
1735
1736     StubMsg.BufferLength = 0;
1737
1738     NdrNonConformantStringBufferSize( &StubMsg,
1739                           (unsigned char *)memsrc2,
1740                           fmtstr_nonconf_str );
1741     ok(StubMsg.BufferLength >= strlen((char *)memsrc2) + 1 + 8, "length %d\n", StubMsg.BufferLength);
1742
1743     /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
1744     StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = HeapAlloc(GetProcessHeap(), 0, StubMsg.BufferLength);
1745     StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
1746
1747     ptr = NdrNonConformantStringMarshall( &StubMsg, (unsigned char *)memsrc2, fmtstr_nonconf_str );
1748     ok(ptr == NULL, "ret %p\n", ptr);
1749     ok(StubMsg.Buffer - StubMsg.BufferStart == strlen((char *)memsrc2) + 1 + 8, "Buffer %p Start %p len %d\n",
1750        StubMsg.Buffer, StubMsg.BufferStart, StubMsg.Buffer - StubMsg.BufferStart);
1751     ok(!memcmp(StubMsg.BufferStart + 8, memsrc2, strlen((char *)memsrc2) + 1), "incorrectly marshaled\n");
1752
1753     StubMsg.Buffer = StubMsg.BufferStart;
1754     StubMsg.MemorySize = 0;
1755     mem = NULL;
1756
1757     /* Client */
1758     my_alloc_called = 0;
1759     StubMsg.Buffer = StubMsg.BufferStart;
1760     mem = mem_orig = HeapAlloc(GetProcessHeap(), 0, sizeof(memsrc));
1761     NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1762     ok(mem == mem_orig, "mem alloced\n");
1763     ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1764
1765     my_alloc_called = 0;
1766     StubMsg.Buffer = StubMsg.BufferStart;
1767     NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
1768     todo_wine
1769     ok(mem == mem_orig, "mem alloced\n");
1770     todo_wine
1771     ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1772
1773     /* Server */
1774     my_alloc_called = 0;
1775     StubMsg.IsClient = 0;
1776     mem = NULL;
1777     StubMsg.Buffer = StubMsg.BufferStart;
1778     NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1779     ok(mem != mem_orig, "mem not alloced\n");
1780     ok(mem != StubMsg.BufferStart + 8, "mem pointing at buffer\n");
1781     ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
1782     NdrOleFree(mem);
1783
1784     my_alloc_called = 0;
1785     mem = mem_orig;
1786     StubMsg.Buffer = StubMsg.BufferStart;
1787     NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
1788     ok(mem == mem_orig, "mem alloced\n");
1789     ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1790
1791     my_alloc_called = 0;
1792     mem = mem_orig;
1793     StubMsg.Buffer = StubMsg.BufferStart;
1794     NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
1795     todo_wine
1796     ok(mem == mem_orig, "mem alloced\n");
1797     todo_wine
1798     ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
1799
1800     HeapFree(GetProcessHeap(), 0, mem_orig);
1801     HeapFree(GetProcessHeap(), 0, StubMsg.RpcMsg->Buffer);
1802 }
1803
1804 static void test_ndr_buffer(void)
1805 {
1806     static unsigned char ncalrpc[] = "ncalrpc";
1807     static unsigned char endpoint[] = "winetest:test_ndr_buffer";
1808     RPC_MESSAGE RpcMessage;
1809     MIDL_STUB_MESSAGE StubMsg;
1810     MIDL_STUB_DESC StubDesc = Object_StubDesc;
1811     unsigned char *ret;
1812     unsigned char *binding;
1813     RPC_BINDING_HANDLE Handle;
1814     RPC_STATUS status;
1815     ULONG prev_buffer_length;
1816     BOOL old_buffer_valid_location;
1817
1818     StubDesc.RpcInterfaceInformation = (void *)&IFoo___RpcServerInterface;
1819
1820     status = RpcServerUseProtseqEp(ncalrpc, 20, endpoint, NULL);
1821     ok(RPC_S_OK == status, "RpcServerUseProtseqEp failed with status %lu\n", status);
1822     status = RpcServerRegisterIf(IFoo_v0_0_s_ifspec, NULL, NULL);
1823     ok(RPC_S_OK == status, "RpcServerRegisterIf failed with status %lu\n", status);
1824     status = RpcServerListen(1, 20, TRUE);
1825     ok(RPC_S_OK == status, "RpcServerListen failed with status %lu\n", status);
1826     if (status != RPC_S_OK)
1827     {
1828         /* Failed to create a server, running client tests is useless */
1829         return;
1830     }
1831
1832     status = RpcStringBindingCompose(NULL, ncalrpc, NULL, endpoint, NULL, &binding);
1833     ok(status == RPC_S_OK, "RpcStringBindingCompose failed (%lu)\n", status);
1834
1835     status = RpcBindingFromStringBinding(binding, &Handle);
1836     ok(status == RPC_S_OK, "RpcBindingFromStringBinding failed (%lu)\n", status);
1837     RpcStringFree(&binding);
1838
1839     NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 5);
1840
1841     ret = NdrGetBuffer(&StubMsg, 10, Handle);
1842     ok(ret == StubMsg.Buffer, "NdrGetBuffer should have returned the same value as StubMsg.Buffer instead of %p\n", ret);
1843     ok(RpcMessage.Handle != NULL, "RpcMessage.Handle should not have been NULL\n");
1844     ok(RpcMessage.Buffer != NULL, "RpcMessage.Buffer should not have been NULL\n");
1845     ok(RpcMessage.BufferLength == 10, "RpcMessage.BufferLength should have been 10 instead of %d\n", RpcMessage.BufferLength);
1846     ok(RpcMessage.RpcFlags == 0, "RpcMessage.RpcFlags should have been 0x0 instead of 0x%lx\n", RpcMessage.RpcFlags);
1847     ok(StubMsg.Buffer != NULL, "Buffer should not have been NULL\n");
1848     ok(!StubMsg.BufferStart, "BufferStart should have been NULL instead of %p\n", StubMsg.BufferStart);
1849     ok(!StubMsg.BufferEnd, "BufferEnd should have been NULL instead of %p\n", StubMsg.BufferEnd);
1850 todo_wine
1851     ok(StubMsg.BufferLength == 0, "BufferLength should have left as 0 instead of being set to %d\n", StubMsg.BufferLength);
1852     old_buffer_valid_location = !StubMsg.fBufferValid;
1853     if (old_buffer_valid_location)
1854         ok(broken(StubMsg.CorrDespIncrement == TRUE), "fBufferValid should have been TRUE instead of 0x%x\n", StubMsg.CorrDespIncrement);
1855     else
1856         ok(StubMsg.fBufferValid, "fBufferValid should have been non-zero instead of 0x%x\n", StubMsg.fBufferValid);
1857
1858     prev_buffer_length = RpcMessage.BufferLength;
1859     StubMsg.BufferLength = 1;
1860     NdrFreeBuffer(&StubMsg);
1861     ok(RpcMessage.Handle != NULL, "RpcMessage.Handle should not have been NULL\n");
1862     ok(RpcMessage.Buffer != NULL, "RpcMessage.Buffer should not have been NULL\n");
1863     ok(RpcMessage.BufferLength == prev_buffer_length, "RpcMessage.BufferLength should have been left as %d instead of %d\n", prev_buffer_length, RpcMessage.BufferLength);
1864     ok(StubMsg.Buffer != NULL, "Buffer should not have been NULL\n");
1865     ok(StubMsg.BufferLength == 1, "BufferLength should have left as 1 instead of being set to %d\n", StubMsg.BufferLength);
1866     if (old_buffer_valid_location)
1867         ok(broken(StubMsg.CorrDespIncrement == FALSE), "fBufferValid should have been FALSE instead of 0x%x\n", StubMsg.CorrDespIncrement);
1868     else
1869         ok(!StubMsg.fBufferValid, "fBufferValid should have been FALSE instead of %d\n", StubMsg.fBufferValid);
1870
1871     /* attempt double-free */
1872     NdrFreeBuffer(&StubMsg);
1873
1874     RpcBindingFree(&Handle);
1875
1876     status = RpcServerUnregisterIf(NULL, NULL, FALSE);
1877     ok(status == RPC_S_OK, "RpcServerUnregisterIf failed (%lu)\n", status);
1878 }
1879
1880 static void test_NdrMapCommAndFaultStatus(void)
1881 {
1882     RPC_STATUS rpc_status;
1883     MIDL_STUB_MESSAGE StubMsg;
1884     RPC_MESSAGE RpcMessage;
1885
1886     NdrClientInitializeNew(&RpcMessage, &StubMsg, &Object_StubDesc, 5);
1887
1888     for (rpc_status = 0; rpc_status < 10000; rpc_status++)
1889     {
1890         RPC_STATUS status;
1891         ULONG comm_status = 0;
1892         ULONG fault_status = 0;
1893         ULONG expected_comm_status = 0;
1894         ULONG expected_fault_status = 0;
1895         status = NdrMapCommAndFaultStatus(&StubMsg, &comm_status, &fault_status, rpc_status);
1896         ok(status == RPC_S_OK, "NdrMapCommAndFaultStatus failed with error %ld\n", status);
1897         switch (rpc_status)
1898         {
1899         case ERROR_INVALID_HANDLE:
1900         case RPC_S_INVALID_BINDING:
1901         case RPC_S_UNKNOWN_IF:
1902         case RPC_S_SERVER_UNAVAILABLE:
1903         case RPC_S_SERVER_TOO_BUSY:
1904         case RPC_S_CALL_FAILED_DNE:
1905         case RPC_S_PROTOCOL_ERROR:
1906         case RPC_S_UNSUPPORTED_TRANS_SYN:
1907         case RPC_S_UNSUPPORTED_TYPE:
1908         case RPC_S_PROCNUM_OUT_OF_RANGE:
1909         case EPT_S_NOT_REGISTERED:
1910         case RPC_S_COMM_FAILURE:
1911             expected_comm_status = rpc_status;
1912             break;
1913         default:
1914             expected_fault_status = rpc_status;
1915         }
1916         ok(comm_status == expected_comm_status, "NdrMapCommAndFaultStatus should have mapped %ld to comm status %d instead of %d\n",
1917             rpc_status, expected_comm_status, comm_status);
1918         ok(fault_status == expected_fault_status, "NdrMapCommAndFaultStatus should have mapped %ld to fault status %d instead of %d\n",
1919             rpc_status, expected_fault_status, fault_status);
1920     }
1921 }
1922
1923 START_TEST( ndr_marshall )
1924 {
1925     determine_pointer_marshalling_style();
1926
1927     test_ndr_simple_type();
1928     test_simple_types();
1929     test_nontrivial_pointer_types();
1930     test_simple_struct();
1931     test_fullpointer_xlat();
1932     test_client_init();
1933     test_server_init();
1934     test_ndr_allocate();
1935     test_conformant_array();
1936     test_conformant_string();
1937     test_nonconformant_string();
1938     test_ndr_buffer();
1939     test_NdrMapCommAndFaultStatus();
1940 }