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