ndr_marshall.c

Go to the documentation of this file.

/*
 * Unit test suite for ndr marshalling functions
 *
 * Copyright 2006 Huw Davies
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#define COBJMACROS
 
#include <stdarg.h>
 
#include <windef.h>
#include <winbase.h>
#include <winnt.h>
#include <winerror.h>
#include <ole2.h>
 
#include "rpc.h"
#include "rpcdce.h"
#include "rpcproxy.h"
#include "midles.h"
#include "ndrtypes.h"
 
#include "wine/test.h"
 
static int my_alloc_called;
static int my_free_called;
static void * CALLBACK my_alloc(SIZE_T size)
{
    my_alloc_called++;
    return malloc(size);
}
 
static void CALLBACK my_free(void *ptr)
{
    my_free_called++;
    free(ptr);
}
 
static const MIDL_STUB_DESC Object_StubDesc = 
    {
    NULL,
    my_alloc,
    my_free,
    { 0 },
    0,
    0,
    0,
    0,
    NULL, /* format string, filled in by tests */
    1, /* -error bounds_check flag */
    0x20000, /* Ndr library version */
    0,
    0x50100a4, /* MIDL Version 5.1.164 */
    0,
    NULL,
    0,  /* notify & notify_flag routine table */
    1,  /* Flags */
    0,  /* Reserved3 */
    0,  /* Reserved4 */
    0   /* Reserved5 */
    };
 
static RPC_DISPATCH_FUNCTION IFoo_table[] =
{
    0
};
 
static RPC_DISPATCH_TABLE IFoo_v0_0_DispatchTable =
{
    0,
    IFoo_table
};
 
static const RPC_SERVER_INTERFACE IFoo___RpcServerInterface =
{
    sizeof(RPC_SERVER_INTERFACE),
    {{0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x12,0x34}},{0,0}},
    {{0x8a885d04,0x1ceb,0x11c9,{0x9f,0xe8,0x08,0x00,0x2b,0x10,0x48,0x60}},{2,0}},
    &IFoo_v0_0_DispatchTable,
    0,
    0,
    0,
    0,
    0,
};
 
static RPC_IF_HANDLE IFoo_v0_0_s_ifspec = (RPC_IF_HANDLE)& IFoo___RpcServerInterface;
static BOOL use_pointer_ids = FALSE;
 
static void determine_pointer_marshalling_style(void)
{
    RPC_MESSAGE RpcMessage;
    MIDL_STUB_MESSAGE StubMsg;
    MIDL_STUB_DESC StubDesc;
    char ch = 0xde;
 
    static const unsigned char fmtstr_up_char[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0x2,            /* FC_CHAR */
        0x5c,           /* FC_PAD */
    };
 
    StubDesc = Object_StubDesc;
    StubDesc.pFormatTypes = NULL;
 
    NdrClientInitializeNew(
                           &RpcMessage,
                           &StubMsg,
                           &StubDesc,
                           0);
 
    StubMsg.BufferLength = 8;
    StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = NdrOleAllocate(StubMsg.BufferLength);
    NdrPointerMarshall(&StubMsg, (unsigned char*)&ch, fmtstr_up_char);
    ok(StubMsg.Buffer == StubMsg.BufferStart + 5, "%p %p\n", StubMsg.Buffer, StubMsg.BufferStart);
 
    use_pointer_ids = (*(unsigned int *)StubMsg.BufferStart != (UINT_PTR)&ch);
    trace("Pointer marshalling using %s\n", use_pointer_ids ? "pointer ids" : "pointer value");
 
    NdrOleFree(StubMsg.BufferStart);
}
 
static void test_ndr_simple_type(void)
{
    RPC_MESSAGE RpcMessage;
    MIDL_STUB_MESSAGE StubMsg;
    MIDL_STUB_DESC StubDesc;
    LONG l, l2 = 0;
 
    StubDesc = Object_StubDesc;
    StubDesc.pFormatTypes = NULL;
 
    NdrClientInitializeNew(
                           &RpcMessage,
                           &StubMsg,
                           &StubDesc,
                           0);
 
    StubMsg.BufferLength = 16;
    StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = NdrOleAllocate(StubMsg.BufferLength);
    StubMsg.BufferEnd = StubMsg.Buffer + StubMsg.BufferLength;
    l = 0xcafebabe;
    NdrSimpleTypeMarshall(&StubMsg, (unsigned char*)&l, FC_LONG);
    ok(StubMsg.Buffer == StubMsg.BufferStart + 4, "%p %p\n", StubMsg.Buffer, StubMsg.BufferStart);
    ok(*(LONG*)StubMsg.BufferStart == l, "%ld\n", *(LONG*)StubMsg.BufferStart);
 
    StubMsg.Buffer = StubMsg.BufferStart + 1;
    NdrSimpleTypeMarshall(&StubMsg, (unsigned char*)&l, FC_LONG);
    ok(StubMsg.Buffer == StubMsg.BufferStart + 8, "%p %p\n", StubMsg.Buffer, StubMsg.BufferStart);
    ok(*(LONG*)(StubMsg.BufferStart + 4) == l, "%ld\n", *(LONG*)StubMsg.BufferStart);
 
    StubMsg.Buffer = StubMsg.BufferStart + 1;
    NdrSimpleTypeUnmarshall(&StubMsg, (unsigned char*)&l2, FC_LONG);
    ok(StubMsg.Buffer == StubMsg.BufferStart + 8, "%p %p\n", StubMsg.Buffer, StubMsg.BufferStart);
    ok(l2 == l, "%ld\n", l2);
 
    NdrOleFree(StubMsg.BufferStart);
}
 
static void test_pointer_marshal(const unsigned char *formattypes,
                                 void *memsrc, DWORD srcsize,
                                 const void *wiredata,
                                 ULONG wiredatalen,
                                 int(*cmp)(const void*,const void*,size_t),
                                 int num_additional_allocs,
                                 const char *msgpfx)
{
    RPC_MESSAGE RpcMessage;
    MIDL_STUB_MESSAGE StubMsg;
    MIDL_STUB_DESC StubDesc;
    DWORD size;
    void *ptr;
    unsigned char *mem, *mem_orig;
 
    if(!cmp)
        cmp = memcmp;
 
    StubDesc = Object_StubDesc;
    StubDesc.pFormatTypes = formattypes;
 
    NdrClientInitializeNew(
                           &RpcMessage,
                           &StubMsg,
                           &StubDesc,
                           0);
 
    StubMsg.BufferLength = 0;
    NdrPointerBufferSize( &StubMsg,
                          memsrc,
                          formattypes );
    ok(StubMsg.BufferLength >= wiredatalen, "%s: length %ld\n", msgpfx, StubMsg.BufferLength);
 
    /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
    StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = NdrOleAllocate(StubMsg.BufferLength);
    StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
 
    memset(StubMsg.BufferStart, 0x0, StubMsg.BufferLength); /* This is a hack to clear the padding between the ptr and longlong/double */
 
    ptr = NdrPointerMarshall( &StubMsg,  memsrc, formattypes );
    ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
    if (srcsize == 8 && wiredatalen == 16 && StubMsg.Buffer - StubMsg.BufferStart == 12)
    {
        /* win9x doesn't align 8-byte types properly */
        wiredatalen = 12;
    }
    else
    {
        ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %ld\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
        ok(!memcmp(StubMsg.BufferStart, wiredata, wiredatalen), "%s: incorrectly marshaled\n", msgpfx);
    }
 
    StubMsg.Buffer = StubMsg.BufferStart;
    StubMsg.MemorySize = 0;
 
    size = NdrPointerMemorySize( &StubMsg, formattypes );
    ok(size == StubMsg.MemorySize, "%s: mem size %lu size %lu\n", msgpfx, StubMsg.MemorySize, size);
    ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %ld\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
    if (formattypes[1] & FC_POINTER_DEREF)
        ok(size == srcsize + sizeof(void *), "%s: mem size %lu\n", msgpfx, size);
    else
        ok(size == srcsize, "%s: mem size %lu\n", msgpfx, size);
 
    StubMsg.Buffer = StubMsg.BufferStart;
    StubMsg.MemorySize = 16;
    size = NdrPointerMemorySize( &StubMsg, formattypes );
    ok(size == StubMsg.MemorySize, "%s: mem size %lu size %lu\n", msgpfx, StubMsg.MemorySize, size);
    ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %ld\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
    if (formattypes[1] & FC_POINTER_DEREF)
        ok(size == srcsize + sizeof(void *) + 16, "%s: mem size %lu\n", msgpfx, size);
    else
        ok(size == srcsize + 16, "%s: mem size %lu\n", msgpfx, size);
 
    StubMsg.Buffer = StubMsg.BufferStart;
    StubMsg.MemorySize = 1;
    size = NdrPointerMemorySize( &StubMsg, formattypes );
    ok(size == StubMsg.MemorySize, "%s: mem size %lu size %lu\n", msgpfx, StubMsg.MemorySize, size);
    ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %ld\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
    if (formattypes[1] & FC_POINTER_DEREF)
        ok(size == srcsize + sizeof(void *) + (srcsize == 8 ? 8 : sizeof(void *)), "%s: mem size %lu\n", msgpfx, size);
    else
        ok(size == srcsize + (srcsize == 8 ? 8 : sizeof(void *)), "%s: mem size %lu\n", msgpfx, size);
 
    size = srcsize;
    if (formattypes[1] & FC_POINTER_DEREF) size += 4;
 
    StubMsg.Buffer = StubMsg.BufferStart;
    StubMsg.MemorySize = 0;
    /* Using my_alloc() here is necessary to prevent a crash in Windows 7+. */
    mem_orig = mem = my_alloc(size);
    memset(mem, 0, size);
    my_alloc_called = my_free_called = 0;
    if (formattypes[1] & FC_POINTER_DEREF)
        *(void**)mem = NULL;
    ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
    ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
    ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
    ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
    ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %ld\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
    ok(StubMsg.MemorySize == 0, "%s: memorysize %ld\n", msgpfx, StubMsg.MemorySize);
    ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
    /* On Windows 7+ unmarshalling may involve calls to StubMsg.pfnFree, for unclear reasons. */
    my_free_called = 0;
 
    NdrPointerFree(&StubMsg, mem, formattypes);
    if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
    {
        /* In this case the top-level pointer is not freed. */
        ok(my_free_called == num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
        free(mem);
    }
    else
        ok(my_free_called == 1 + num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
 
    /* reset the buffer and call with must alloc */
    my_alloc_called = my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    mem_orig = mem = calloc(1, size);
    if (formattypes[1] & FC_POINTER_DEREF)
        *(void**)mem = NULL;
    ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 1 );
    ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
    /* doesn't allocate mem in this case */
    ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
    ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
    ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %ld\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
    ok(StubMsg.MemorySize == 0, "%s: memorysize %ld\n", msgpfx, StubMsg.MemorySize);
    ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called); 
    ok(!my_free_called, "%s: my_free got called %d times\n", msgpfx, my_free_called);
 
    NdrPointerFree(&StubMsg, mem, formattypes);
    if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
    {
        /* In this case the top-level pointer is not freed. */
        ok(my_free_called == num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
        free(mem);
    }
    else
        ok(my_free_called == 1 + num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
 
    if (formattypes[0] != FC_RP)
    {
        /* now pass the address of a NULL ptr */
        mem = NULL;
        my_alloc_called = my_free_called = 0;
        StubMsg.Buffer = StubMsg.BufferStart;
        ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
        ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
        ok(mem != StubMsg.BufferStart + wiredatalen - srcsize, "%s: mem points to buffer %p %p\n", msgpfx, mem, StubMsg.BufferStart);
        ok(!cmp(mem, memsrc, size), "%s: incorrectly unmarshaled\n", msgpfx);
        ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %ld\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
        ok(StubMsg.MemorySize == 0, "%s: memorysize %ld\n", msgpfx, StubMsg.MemorySize);
        ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called); 
        my_alloc_called = 0;
        NdrPointerFree(&StubMsg, mem, formattypes);
 
        /* again pass address of NULL ptr, but pretend we're a server */
        if (0)  /* crashes on Win9x and NT4 */
        {
            mem = NULL;
            StubMsg.Buffer = StubMsg.BufferStart;
            StubMsg.IsClient = 0;
            ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
            ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
            if (formattypes[2] == FC_ENUM16)
                ok(mem != StubMsg.BufferStart + wiredatalen - srcsize, "%s: mem points to buffer %p %p\n", msgpfx, mem, StubMsg.BufferStart);
            else
                ok(mem == StubMsg.BufferStart + wiredatalen - srcsize, "%s: mem doesn't point to buffer %p %p\n", msgpfx, mem, StubMsg.BufferStart);
            ok(!cmp(mem, memsrc, size), "%s: incorrectly unmarshaled\n", msgpfx);
            ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %ld\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
            ok(StubMsg.MemorySize == 0, "%s: memorysize %ld\n", msgpfx, StubMsg.MemorySize);
            if (formattypes[2] != FC_ENUM16)
            {
                ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
                my_alloc_called = 0;
            }
        }
    }
 
    /* Server */
    StubMsg.IsClient = 0;
 
    /* For most basetypes (but not enum16), memory will not be allocated but
     * instead point directly to the buffer. */
    my_alloc_called = my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    mem = NULL;
    ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
    ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
    ok(!!mem, "%s: mem was not allocated\n", msgpfx);
    ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
    ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %ld\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
    ok(StubMsg.MemorySize == 0, "%s: memorysize %ld\n", msgpfx, StubMsg.MemorySize);
    if (formattypes[2] == FC_ENUM16)
        ok(my_alloc_called == 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
    else
        ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
    ok(!my_free_called, "%s: my_free got called %d times\n", msgpfx, my_free_called);
 
    NdrPointerFree(&StubMsg, mem, formattypes);
    if (formattypes[2] == FC_ENUM16)
        ok(my_free_called == 1, "%s: my_free got called %d times\n", msgpfx, my_free_called);
    else if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
    {
        /* In theory this should be freed to correspond with the allocation, but
         * FC_ALLOCED_ON_STACK is set, and NdrPointerFree() has no way of
         * knowing that the memory allocated by NdrPointerUnmarshall() isn't
         * stack memory. In practice it always *is* stack memory if ON_STACK is
         * set, so this leak isn't a concern. */
        ok(my_free_called == 0, "%s: my_free got called %d times\n", msgpfx, my_free_called);
        free(mem);
    }
    else
        ok(my_free_called == num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
 
    /* reset the buffer and call with must alloc */
    my_alloc_called = my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    mem = NULL;
    ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 1 );
    ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
    ok(!!mem, "%s: mem was not allocated\n", msgpfx);
    ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
    ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %ld\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
    ok(StubMsg.MemorySize == 0, "%s: memorysize %ld\n", msgpfx, StubMsg.MemorySize);
    if (formattypes[2] == FC_ENUM16)
        ok(my_alloc_called == 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
    else
        ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
    ok(!my_free_called, "%s: my_free got called %d times\n", msgpfx, my_free_called);
 
    NdrPointerFree(&StubMsg, mem, formattypes);
    if (formattypes[2] == FC_ENUM16)
        ok(my_free_called == 1, "%s: my_free got called %d times\n", msgpfx, my_free_called);
    else if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
    {
        ok(my_free_called == 0, "%s: my_free got called %d times\n", msgpfx, my_free_called);
        free(mem);
    }
    else
        ok(my_free_called == num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
 
    /* Τest with an existing pointer. Unless it's a stack pointer (and deref'd)
     * a new pointer will be allocated anyway (in fact, an invalid pointer works
     * in every such case). */
 
    my_alloc_called = my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    mem_orig = mem = calloc(1, size);
    if (formattypes[1] & FC_POINTER_DEREF)
        *(void**)mem = NULL;
    ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 0 );
    ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
    if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
        ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
    else
    {
        ok(mem != mem_orig, "%s: mem has not changed\n", msgpfx);
        free(mem_orig);
    }
    ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
    ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %ld\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
    ok(StubMsg.MemorySize == 0, "%s: memorysize %ld\n", msgpfx, StubMsg.MemorySize);
    if (formattypes[2] == FC_ENUM16)
        ok(my_alloc_called == 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
    else if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
        ok(my_alloc_called == 0, "%s: my_alloc got called %d times\n", msgpfx, my_free_called);
    else
        ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
    ok(!my_free_called, "%s: my_free got called %d times\n", msgpfx, my_free_called);
 
    NdrPointerFree(&StubMsg, mem, formattypes);
    if (formattypes[2] == FC_ENUM16)
        ok(my_free_called == 1, "%s: my_free got called %d times\n", msgpfx, my_free_called);
    else if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
    {
        ok(my_free_called == 0, "%s: my_free got called %d times\n", msgpfx, my_free_called);
        free(mem);
    }
    else
        ok(my_free_called == num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
 
    /* reset the buffer and call with must alloc */
    my_alloc_called = my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    mem_orig = mem = calloc(1, size);
    if (formattypes[1] & FC_POINTER_DEREF)
        *(void**)mem = NULL;
    ptr = NdrPointerUnmarshall( &StubMsg, &mem, formattypes, 1 );
    ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
    if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
        ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
    else
    {
        ok(mem != mem_orig, "%s: mem has not changed\n", msgpfx);
        free(mem_orig);
    }
    ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
    ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p len %ld\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart, wiredatalen);
    ok(StubMsg.MemorySize == 0, "%s: memorysize %ld\n", msgpfx, StubMsg.MemorySize);
    if (formattypes[2] == FC_ENUM16)
        ok(my_alloc_called == 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
    else if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
        ok(my_alloc_called == 0, "%s: my_alloc got called %d times\n", msgpfx, my_free_called);
    else
        ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
    ok(!my_free_called, "%s: my_free got called %d times\n", msgpfx, my_free_called);
 
    NdrPointerFree(&StubMsg, mem, formattypes);
    if (formattypes[2] == FC_ENUM16)
        ok(my_free_called == 1, "%s: my_free got called %d times\n", msgpfx, my_free_called);
    else if ((formattypes[1] & FC_ALLOCED_ON_STACK) && (formattypes[1] & FC_POINTER_DEREF))
    {
        ok(my_free_called == 0, "%s: my_free got called %d times\n", msgpfx, my_free_called);
        free(mem);
    }
    else
        ok(my_free_called == num_additional_allocs, "%s: my_free got called %d times\n", msgpfx, my_free_called);
 
    NdrOleFree(StubMsg.BufferStart);
}
 
static int deref_cmp(const void *s1, const void *s2, size_t num)
{
    return memcmp(*(const void *const *)s1, *(const void *const *)s2, num);
}
 
 
static void test_simple_types(void)
{
    unsigned char wiredata[16];
    unsigned char ch;
    unsigned char *ch_ptr;
    unsigned short s;
    unsigned int i;
    ULONG l;
    ULONGLONG ll;
    float f;
    double d;
 
    static const unsigned char fmtstr_up_char[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0x2,            /* FC_CHAR */
        0x5c,           /* FC_PAD */
    };
    static const unsigned char fmtstr_up_byte[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0x1,            /* FC_BYTE */
        0x5c,           /* FC_PAD */
    };
    static const unsigned char fmtstr_up_small[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0x3,            /* FC_SMALL */
        0x5c,           /* FC_PAD */
    };
    static const unsigned char fmtstr_up_usmall[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0x4,            /* FC_USMALL */
        0x5c,           /* FC_PAD */
    };  
    static const unsigned char fmtstr_rp_char[] =
    {
        0x11, 0x8,      /* FC_RP [simple_pointer] */
        0x2,            /* FC_CHAR */
        0x5c,           /* FC_PAD */
    };
    static const unsigned char fmtstr_rpup_char_onstack_deref[] =
    {
        0x11, 0x14,     /* FC_RP [alloced_on_stack] [pointer_deref] */
        NdrFcShort( 0x2 ),      /* Offset= 2 (4) */
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0x2,            /* FC_CHAR */
        0x5c,           /* FC_PAD */
    };
    static const unsigned char fmtstr_rpup_char_onstack[] =
    {
        0x11, 0x04,     /* FC_RP [alloced_on_stack] */
        NdrFcShort( 0x2 ),      /* Offset= 2 (4) */
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0x2,            /* FC_CHAR */
        0x5c,           /* FC_PAD */
    };
    static const unsigned char fmtstr_rpup_char_deref[] =
    {
        0x11, 0x10,     /* FC_RP [pointer_deref] */
        NdrFcShort( 0x2 ),      /* Offset= 2 (4) */
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0x2,            /* FC_CHAR */
        0x5c,           /* FC_PAD */
    };
 
    static const unsigned char fmtstr_up_wchar[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0x5,            /* FC_WCHAR */
        0x5c,           /* FC_PAD */
    };
    static const unsigned char fmtstr_up_short[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0x6,            /* FC_SHORT */
        0x5c,           /* FC_PAD */
    };
    static const unsigned char fmtstr_up_ushort[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0x7,            /* FC_USHORT */
        0x5c,           /* FC_PAD */
    };
    static const unsigned char fmtstr_up_enum16[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0xd,            /* FC_ENUM16 */
        0x5c,           /* FC_PAD */
    };
    static const unsigned char fmtstr_up_long[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0x8,            /* FC_LONG */
        0x5c,           /* FC_PAD */
    };
    static const unsigned char fmtstr_up_ulong[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0x9,            /* FC_ULONG */
        0x5c,           /* FC_PAD */
    };
    static const unsigned char fmtstr_up_enum32[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0xe,            /* FC_ENUM32 */
        0x5c,           /* FC_PAD */
    };
    static const unsigned char fmtstr_up_errorstatus[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0x10,           /* FC_ERROR_STATUS_T */
        0x5c,           /* FC_PAD */
    };
 
    static const unsigned char fmtstr_up_longlong[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0xb,            /* FC_HYPER */
        0x5c,           /* FC_PAD */
    };
    static const unsigned char fmtstr_up_float[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0xa,            /* FC_FLOAT */
        0x5c,           /* FC_PAD */
    };
    static const unsigned char fmtstr_up_double[] =
    {
        0x12, 0x8,      /* FC_UP [simple_pointer] */
        0xc,            /* FC_DOUBLE */
        0x5c,           /* FC_PAD */
    };
 
    ch = 0xa5;
    ch_ptr = &ch;
    if (use_pointer_ids)
        *(unsigned int *)wiredata = 0x20000;
    else
        *(unsigned int *)wiredata = (UINT_PTR)ch_ptr;
    wiredata[4] = ch;
 
    test_pointer_marshal(fmtstr_up_char, ch_ptr, 1, wiredata, 5, NULL, 0, "up_char");
    test_pointer_marshal(fmtstr_up_byte, ch_ptr, 1, wiredata, 5, NULL, 0, "up_byte");
    test_pointer_marshal(fmtstr_up_small, ch_ptr, 1, wiredata, 5, NULL, 0,  "up_small");
    test_pointer_marshal(fmtstr_up_usmall, ch_ptr, 1, wiredata, 5, NULL, 0, "up_usmall");
 
    test_pointer_marshal(fmtstr_rp_char, ch_ptr, 1, &ch, 1, NULL, 0, "rp_char");
 
    test_pointer_marshal(fmtstr_rpup_char_onstack_deref, &ch_ptr, 1, wiredata, 5, deref_cmp, 1, "rpup_char_onstack_deref");
    test_pointer_marshal(fmtstr_rpup_char_onstack, ch_ptr, 1, wiredata, 5, NULL, 0, "rpup_char_onstack");
    test_pointer_marshal(fmtstr_rpup_char_deref, &ch_ptr, 1, wiredata, 5, deref_cmp, 1, "rpup_char_deref");
 
    s = 0xa597;
    if (use_pointer_ids)
        *(unsigned int *)wiredata = 0x20000;
    else
        *(unsigned int *)wiredata = (UINT_PTR)&s;
    *(unsigned short*)(wiredata + 4) = s;
 
    test_pointer_marshal(fmtstr_up_wchar, &s, 2, wiredata, 6, NULL, 0, "up_wchar");
    test_pointer_marshal(fmtstr_up_short, &s, 2, wiredata, 6, NULL, 0, "up_short");
    test_pointer_marshal(fmtstr_up_ushort, &s, 2, wiredata, 6, NULL, 0, "up_ushort");
 
    i = 0x7fff;
    if (use_pointer_ids)
        *(unsigned int *)wiredata = 0x20000;
    else
        *(unsigned int *)wiredata = (UINT_PTR)&i;
    *(unsigned short*)(wiredata + 4) = i;
    test_pointer_marshal(fmtstr_up_enum16, &i, 4, wiredata, 6, NULL, 0, "up_enum16");
 
    l = 0xcafebabe;
    if (use_pointer_ids)
        *(unsigned int *)wiredata = 0x20000;
    else
        *(unsigned int *)wiredata = (UINT_PTR)&l;
    *(ULONG*)(wiredata + 4) = l;
 
    test_pointer_marshal(fmtstr_up_long, &l, 4, wiredata, 8, NULL, 0, "up_long");
    test_pointer_marshal(fmtstr_up_ulong, &l, 4, wiredata, 8, NULL, 0,  "up_ulong");
    test_pointer_marshal(fmtstr_up_enum32, &l, 4, wiredata, 8, NULL, 0,  "up_emun32");
    test_pointer_marshal(fmtstr_up_errorstatus, &l, 4, wiredata, 8, NULL, 0,  "up_errorstatus");
 
    ll = ((ULONGLONG)0xcafebabe) << 32 | 0xdeadbeef;
    if (use_pointer_ids)
        *(unsigned int *)wiredata = 0x20000;
    else
        *(unsigned int *)wiredata = (UINT_PTR)&ll;
    *(unsigned int *)(wiredata + 4) = 0;
    *(ULONGLONG*)(wiredata + 8) = ll;
    test_pointer_marshal(fmtstr_up_longlong, &ll, 8, wiredata, 16, NULL, 0, "up_longlong");
 
    f = 3.1415f;
    if (use_pointer_ids)
        *(unsigned int *)wiredata = 0x20000;
    else
        *(unsigned int *)wiredata = (UINT_PTR)&f;
    *(float*)(wiredata + 4) = f;
    test_pointer_marshal(fmtstr_up_float, &f, 4, wiredata, 8, NULL, 0, "up_float");
 
    d = 3.1415;
    if (use_pointer_ids)
        *(unsigned int *)wiredata = 0x20000;
    else
        *(unsigned int *)wiredata = (UINT_PTR)&d;
    *(unsigned int *)(wiredata + 4) = 0;
    *(double*)(wiredata + 8) = d;
    test_pointer_marshal(fmtstr_up_double, &d, 8, wiredata, 16, NULL, 0,  "up_double");
 
}
 
static void test_nontrivial_pointer_types(void)
{
    RPC_MESSAGE RpcMessage;
    MIDL_STUB_MESSAGE StubMsg;
    MIDL_STUB_DESC StubDesc;
    DWORD size;
    void *ptr;
    char **p1;
    char *p2;
    char ch;
    unsigned char *mem, *mem_orig;
 
    static const unsigned char fmtstr_ref_unique_out[] =
    {
        0x12, 0x8,  /* FC_UP [simple_pointer] */
        0x2,        /* FC_CHAR */
        0x5c,       /* FC_PAD */
        0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */
        NdrFcShort( 0xfffffffa ),   /* Offset= -6 (0) */
    };
 
    p1 = &p2;
    p2 = &ch;
    ch = 0x22;
 
    StubDesc = Object_StubDesc;
    StubDesc.pFormatTypes = fmtstr_ref_unique_out;
 
    NdrClientInitializeNew(
                           &RpcMessage,
                           &StubMsg,
                           &StubDesc,
                           0);
 
    StubMsg.BufferLength = 0;
    NdrPointerBufferSize( &StubMsg,
                          (unsigned char *)p1,
                          &fmtstr_ref_unique_out[4] );
 
    /* Windows overestimates the buffer size */
    ok(StubMsg.BufferLength >= 5, "length %ld\n", StubMsg.BufferLength);
 
    /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
    StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = NdrOleAllocate(StubMsg.BufferLength);
    StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
 
    ptr = NdrPointerMarshall( &StubMsg, (unsigned char *)p1, &fmtstr_ref_unique_out[4] );
    ok(ptr == NULL, "ret %p\n", ptr);
    size = StubMsg.Buffer - StubMsg.BufferStart;
    ok(size == 5, "Buffer %p Start %p len %ld\n", StubMsg.Buffer, StubMsg.BufferStart, size);
    ok(*(unsigned int *)StubMsg.BufferStart != 0, "pointer ID marshalled incorrectly\n");
    ok(*(unsigned char *)(StubMsg.BufferStart + 4) == 0x22, "char data marshalled incorrectly: 0x%x\n",
       *(unsigned char *)(StubMsg.BufferStart + 4));
 
    StubMsg.Buffer = StubMsg.BufferStart;
    StubMsg.MemorySize = 0;
    mem = NULL;
 
    /* Client */
    my_alloc_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    mem = mem_orig = malloc(sizeof(void *));
    *(void **)mem = NULL;
    NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 0);
    ok(mem == mem_orig, "mem alloced\n");
    ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
 
    my_alloc_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 1);
    ok(mem == mem_orig, "mem alloced\n");
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
    ok(my_free_called == 1, "free called %d\n", my_free_called);
 
    mem = my_alloc(sizeof(void *));
    *(void **)mem = NULL;
    my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
    ok(my_free_called == 0, "free called %d\n", my_free_called);
    my_free(mem);
 
    mem = my_alloc(sizeof(void *));
    *(void **)mem = my_alloc(sizeof(char));
    my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
    ok(my_free_called == 1, "free called %d\n", my_free_called);
    my_free(mem);
 
    /* Server */
    my_alloc_called = 0;
    my_free_called = 0;
    StubMsg.IsClient = 0;
    mem = NULL;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 0);
    ok(mem != StubMsg.BufferStart, "mem pointing at buffer\n");
    ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
    NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
    ok(my_free_called == 0, "free called %d\n", my_free_called);
    my_free(mem);
 
    my_alloc_called = 0;
    my_free_called = 0;
    mem = NULL;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 1);
    ok(mem != StubMsg.BufferStart, "mem pointing at buffer\n");
    ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
    NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
    ok(my_free_called == 0, "free called %d\n", my_free_called);
    my_free(mem);
 
    my_alloc_called = 0;
    mem = mem_orig;
    *(void **)mem = NULL;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 0);
    ok(mem == mem_orig, "mem alloced\n");
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    my_alloc_called = 0;
    mem = mem_orig;
    *(void **)mem = NULL;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerUnmarshall( &StubMsg, &mem, &fmtstr_ref_unique_out[4], 1);
    ok(mem == mem_orig, "mem alloced\n");
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    mem = my_alloc(sizeof(void *));
    *(void **)mem = NULL;
    my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
    ok(my_free_called == 0, "free called %d\n", my_free_called);
    my_free(mem);
 
    mem = my_alloc(sizeof(void *));
    *(void **)mem = my_alloc(sizeof(char));
    my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerFree( &StubMsg, mem, &fmtstr_ref_unique_out[4] );
    ok(my_free_called == 1, "free called %d\n", my_free_called);
    my_free(mem);
 
    free(mem_orig);
    NdrOleFree(StubMsg.RpcMsg->Buffer);
}
 
static void test_simple_struct_marshal(const unsigned char *formattypes,
                                       void *memsrc, DWORD srcsize,
                                       const void *wiredata,
                                       ULONG wiredatalen,
                                       int(*cmp)(const void*,const void*,size_t),
                                       int num_additional_allocs,
                                       const char *msgpfx)
{
    RPC_MESSAGE RpcMessage;
    MIDL_STUB_MESSAGE StubMsg;
    MIDL_STUB_DESC StubDesc;
    DWORD size;
    void *ptr;
    unsigned char *mem, *mem_orig;
 
    my_alloc_called = my_free_called = 0;
    if(!cmp)
        cmp = memcmp;
 
    StubDesc = Object_StubDesc;
    StubDesc.pFormatTypes = formattypes;
 
    NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 0);
 
    StubMsg.BufferLength = 0;
    NdrSimpleStructBufferSize( &StubMsg, memsrc, formattypes );
    ok(StubMsg.BufferLength >= wiredatalen, "%s: length %ld\n", msgpfx, StubMsg.BufferLength);
    StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = NdrOleAllocate(StubMsg.BufferLength);
    StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
    ptr = NdrSimpleStructMarshall( &StubMsg,  memsrc, formattypes );
    ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
    ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart);
    ok(!memcmp(StubMsg.BufferStart, wiredata, wiredatalen), "%s: incorrectly marshaled %08lx %08lx %08lx\n", msgpfx, *(DWORD*)StubMsg.BufferStart,*((DWORD*)StubMsg.BufferStart+1),*((DWORD*)StubMsg.BufferStart+2));
 
    StubMsg.Buffer = StubMsg.BufferStart;
    StubMsg.MemorySize = 0;
    size = NdrSimpleStructMemorySize( &StubMsg, formattypes );
    ok(size == StubMsg.MemorySize, "%s: size != MemorySize\n", msgpfx);
    ok(size == srcsize, "%s: mem size %lu\n", msgpfx, size);
    ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart);
 
    StubMsg.Buffer = StubMsg.BufferStart;
    size = NdrSimpleStructMemorySize( &StubMsg, formattypes );
    ok(size == StubMsg.MemorySize, "%s: size != MemorySize\n", msgpfx);
    ok(StubMsg.MemorySize == ((srcsize + 3) & ~3) + srcsize, "%s: mem size %lu\n", msgpfx, size);
    ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart);
    size = srcsize;
    /*** Unmarshalling first with must_alloc false ***/
 
    StubMsg.Buffer = StubMsg.BufferStart;
    StubMsg.MemorySize = 0;
    mem_orig = mem = calloc(1, srcsize);
    ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 0 );
    ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
    ok(StubMsg.Buffer - StubMsg.BufferStart == wiredatalen, "%s: Buffer %p Start %p\n", msgpfx, StubMsg.Buffer, StubMsg.BufferStart);
    ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
    ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
    ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called); 
    my_alloc_called = 0;
    my_free_called = 0;
    ok(StubMsg.MemorySize == 0, "%s: memorysize touched in unmarshal\n", msgpfx);
    NdrSimpleStructFree(&StubMsg, mem, formattypes );
    ok(my_free_called == num_additional_allocs, "free called %d\n", my_free_called);
 
    /* If we're a server we still use the supplied memory */
    StubMsg.Buffer = StubMsg.BufferStart;
    StubMsg.IsClient = 0;
    ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 0 );
    ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
    ok(mem == mem_orig, "%s: mem has changed %p %p\n", msgpfx, mem, mem_orig);
    ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx); 
    ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
    my_alloc_called = 0;
    my_free_called = 0;
    ok(StubMsg.MemorySize == 0, "%s: memorysize touched in unmarshal\n", msgpfx);
    NdrSimpleStructFree(&StubMsg, mem, formattypes );
    ok(my_free_called == num_additional_allocs, "free called %d\n", my_free_called);
 
    /* ...unless we pass a NULL ptr, then the buffer is used. 
       Passing a NULL ptr while we're a client && !must_alloc
       crashes on Windows, so we won't do that. */
 
    if (0)  /* crashes on Win9x and NT4 */
    {
        mem = NULL;
        StubMsg.IsClient = 0;
        StubMsg.Buffer = StubMsg.BufferStart;
        ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, FALSE );
        ok(ptr == NULL, "%s: ret %p\n", msgpfx, ptr);
        ok(mem == StubMsg.BufferStart, "%s: mem not equal buffer\n", msgpfx);
        ok(!cmp(mem, memsrc, srcsize), "%s: incorrectly unmarshaled\n", msgpfx);
        ok(my_alloc_called == num_additional_allocs, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
        my_alloc_called = 0;
        ok(StubMsg.MemorySize == 0, "%s: memorysize touched in unmarshal\n", msgpfx);
        NdrSimpleStructFree(&StubMsg, mem, formattypes );
        ok(my_free_called == num_additional_allocs, "free called %d\n", my_free_called);
    }
 
    /*** now must_alloc is true ***/
 
    /* with must_alloc set we always allocate new memory whether or not we're
       a server and also when passing NULL */
    mem = mem_orig;
    StubMsg.IsClient = 1;
    StubMsg.Buffer = StubMsg.BufferStart;
    ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
    ok(ptr == NULL, "ret %p\n", ptr);
    ok(mem != mem_orig, "mem not changed %p %p\n", mem, mem_orig);
    ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n");
    ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
    my_alloc_called = 0;
    my_free_called = 0;
    ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
    NdrSimpleStructFree(&StubMsg, mem, formattypes );
    ok(my_free_called == num_additional_allocs, "free called %d\n", my_free_called);
    my_free(mem);
 
    mem = NULL;
    StubMsg.Buffer = StubMsg.BufferStart;
    ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
    ok(ptr == NULL, "ret %p\n", ptr);
    ok(mem != mem_orig, "mem not changed %p %p\n", mem, mem_orig);
    ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n");
    ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
    my_alloc_called = 0;
    my_free_called = 0;
    ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
    NdrSimpleStructFree(&StubMsg, mem, formattypes );
    ok(my_free_called == num_additional_allocs, "free called %d\n", my_free_called);
    my_free(mem);
 
    mem = mem_orig;
    StubMsg.Buffer = StubMsg.BufferStart;
    StubMsg.IsClient = 0;
    StubMsg.ReuseBuffer = 1;
    ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
    ok(ptr == NULL, "ret %p\n", ptr);
    ok(mem != mem_orig, "mem not changed %p %p\n", mem, mem_orig);
    ok(mem != StubMsg.BufferStart, "mem is buffer mem\n");
    ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n");
    ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
    my_alloc_called = 0;
    my_free_called = 0;
    ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
    NdrSimpleStructFree(&StubMsg, mem, formattypes );
    ok(my_free_called == num_additional_allocs, "free called %d\n", my_free_called);
    my_free(mem);
 
    mem = NULL;
    StubMsg.Buffer = StubMsg.BufferStart;
    StubMsg.IsClient = 0;
    StubMsg.ReuseBuffer = 1;
    ptr = NdrSimpleStructUnmarshall( &StubMsg, &mem, formattypes, 1 );
    ok(ptr == NULL, "ret %p\n", ptr);
    ok(mem != StubMsg.BufferStart, "mem is buffer mem\n");
    ok(!cmp(mem, memsrc, srcsize), "incorrectly unmarshaled\n"); 
    ok(my_alloc_called == num_additional_allocs + 1, "%s: my_alloc got called %d times\n", msgpfx, my_alloc_called);
    my_alloc_called = 0;
    my_free_called = 0;
    ok(StubMsg.MemorySize == 0, "memorysize touched in unmarshal\n");
    NdrSimpleStructFree(&StubMsg, mem, formattypes );
    ok(my_free_called == num_additional_allocs, "free called %d\n", my_free_called);
    my_free(mem);
 
    free(mem_orig);
    NdrOleFree(StubMsg.BufferStart);
}
 
typedef struct
{
    LONG l1;
    LONG *pl1;
    char *pc1;
} ps1_t;
 
static int ps1_cmp(const void *s1, const void *s2, size_t num)
{
    const ps1_t *p1, *p2;
 
    p1 = s1;
    p2 = s2;
 
    if(p1->l1 != p2->l1)
        return 1;
 
    if(p1->pl1 && p2->pl1)
    {
        if(*p1->pl1 != *p2->pl1)
            return 1;
    }
    else if(p1->pl1 || p2->pl1)
        return 1;
 
    if(p1->pc1 && p2->pc1)
    {
        if(*p1->pc1 != *p2->pc1)
            return 1;
    }
    else if(p1->pc1 || p2->pc1)
        return 1;
 
    return 0;
}
 
static void test_simple_struct(void)
{
    unsigned char wiredata[28];
    ULONG wiredatalen;
    LONG l;
    char c;
    ps1_t ps1;
 
    static const unsigned char fmtstr_simple_struct[] =
    {
        0x12, 0x0,      /* FC_UP */
        NdrFcShort( 0x2 ), /* Offset=2 */
        0x15, 0x3,      /* FC_STRUCT [align 4] */
        NdrFcShort( 0x18 ),      /* [size 24] */
        0x6,            /* FC_SHORT */
        0x2,            /* FC_CHAR */ 
        0x38,       /* FC_ALIGNM4 */
    0x8,        /* FC_LONG */
    0x8,        /* FC_LONG */
        0x39,       /* FC_ALIGNM8 */
        0xb,        /* FC_HYPER */ 
        0x5b,       /* FC_END */
    };
    struct {
        short s;
        char c;
        LONG l1, l2;
        LONGLONG ll;
    } s1;
 
    static const unsigned char fmtstr_pointer_struct[] =
    { 
        0x12, 0x0,      /* FC_UP */
        NdrFcShort( 0x2 ), /* Offset=2 */
#ifdef _WIN64
        0x1a,   /* FC_BOGUS_STRUCT */
        0x3,    /* 3 */
        NdrFcShort(0x18),   /* [size 24] */
        NdrFcShort(0x0),
        NdrFcShort(0x8),    /* Offset= 8 (266) */
        0x08,   /* FC_LONG */
        0x39,   /* FC_ALIGNM8 */
        0x36,   /* FC_POINTER */
        0x36,   /* FC_POINTER */
        0x5c,       /* FC_PAD */
        0x5b,       /* FC_END */
        0x12, 0x8,  /* FC_UP [simple_pointer] */
        0x08,   /* FC_LONG */
        0x5c,   /* FC_PAD */
        0x12, 0x8,  /* FC_UP [simple_pointer] */
        0x02,   /* FC_CHAR */
        0x5c,   /* FC_PAD */
#else
        0x16, 0x3,      /* FC_PSTRUCT [align 4] */
        NdrFcShort( 0xc ),      /* [size 12] */
        0x4b,       /* FC_PP */
        0x5c,       /* FC_PAD */
        0x46,       /* FC_NO_REPEAT */
        0x5c,       /* FC_PAD */
        NdrFcShort( 0x4 ),  /* 4 */
    NdrFcShort( 0x4 ),  /* 4 */
        0x13, 0x8,  /* FC_OP [simple_pointer] */
        0x8,        /* FC_LONG */
        0x5c,       /* FC_PAD */
        0x46,       /* FC_NO_REPEAT */
        0x5c,       /* FC_PAD */
    NdrFcShort( 0x8 ),  /* 8 */
    NdrFcShort( 0x8 ),  /* 8 */
    0x13, 0x8,  /* FC_OP [simple_pointer] */
        0x2,        /* FC_CHAR */
        0x5c,       /* FC_PAD */
        0x5b,       /* FC_END */
        0x8,        /* FC_LONG */
        0x8,        /* FC_LONG */
        0x8,        /* FC_LONG */
        0x5c,       /* FC_PAD */
        0x5b,       /* FC_END */
#endif
    };
 
    /* zero the entire structure, including the holes */
    memset(&s1, 0, sizeof(s1));
 
    /* FC_STRUCT */
    s1.s = 0x1234;
    s1.c = 0xa5;
    s1.l1 = 0xdeadbeef;
    s1.l2 = 0xcafebabe;
    s1.ll = ((ULONGLONG) 0xbadefeed << 32) | 0x2468ace0;
 
    wiredatalen = 24;
    memcpy(wiredata, &s1, wiredatalen); 
    test_simple_struct_marshal(fmtstr_simple_struct + 4, &s1, 24, wiredata, 24, NULL, 0, "struct");
 
    if (use_pointer_ids)
        *(unsigned int *)wiredata = 0x20000;
    else
        *(unsigned int *)wiredata = (UINT_PTR)&s1;
    memcpy(wiredata + 4, &s1, wiredatalen);
    test_pointer_marshal(fmtstr_simple_struct, &s1, 24, wiredata, 28, NULL, 0, "struct");
 
    if (sizeof(void *) == 8) return;  /* it cannot be represented as a simple struct on Win64 */
 
    /* zero the entire structure, including the hole */
    memset(&ps1, 0, sizeof(ps1));
 
    /* FC_PSTRUCT */
    ps1.l1 = 0xdeadbeef;
    l = 0xcafebabe;
    ps1.pl1 = &l;
    c = 'a';
    ps1.pc1 = &c;
    *(unsigned int *)(wiredata + 4) = 0xdeadbeef;
    if (use_pointer_ids)
    {
    *(unsigned int *)(wiredata + 8) = 0x20000;
    *(unsigned int *)(wiredata + 12) = 0x20004;
    }
    else
    {
    *(unsigned int *)(wiredata + 8) = (UINT_PTR)&l;
    *(unsigned int *)(wiredata + 12) = (UINT_PTR)&c;
    }
    memcpy(wiredata + 16, &l, 4);
    memcpy(wiredata + 20, &c, 1);
 
    test_simple_struct_marshal(fmtstr_pointer_struct + 4, &ps1, 17, wiredata + 4, 17, ps1_cmp, 2, "pointer_struct");
    if (use_pointer_ids)
    {
        *(unsigned int *)wiredata = 0x20000;
    *(unsigned int *)(wiredata + 8) = 0x20004;
    *(unsigned int *)(wiredata + 12) = 0x20008;
    }
    else
        *(unsigned int *)wiredata = (UINT_PTR)&ps1;
    test_pointer_marshal(fmtstr_pointer_struct, &ps1, 17, wiredata, 21, ps1_cmp, 2, "pointer_struct");
}
 
struct aligned
{
    int a;
    LONGLONG b;
};
 
static void test_struct_align(void)
{
    RPC_MESSAGE RpcMessage;
    MIDL_STUB_MESSAGE StubMsg;
    MIDL_STUB_DESC StubDesc;
    void *ptr;
    struct aligned *memsrc_orig, *memsrc, *mem;
 
    /* force bogus struct so that members are marshalled individually */
    static const unsigned char fmtstr[] =
    {
        0x1a,   /* FC_BOGUS_STRUCT */
        0x7,    /* alignment 8 */
        NdrFcShort(0x10),   /* memory size 16 */
        NdrFcShort(0x0),
        NdrFcShort(0x0),
        0x08,   /* FC_LONG */
        0x39,   /* FC_ALIGNM8 */
        0x0b,   /* FC_HYPER */
        0x5b,   /* FC_END */
    };
 
    memsrc_orig = calloc(1, sizeof(struct aligned) + 8);
    /* intentionally mis-align memsrc */
    memsrc = (struct aligned *)((((ULONG_PTR)memsrc_orig + 7) & ~7) + 4);
 
    memsrc->a = 0xdeadbeef;
    memsrc->b = ((ULONGLONG) 0xbadefeed << 32) | 0x2468ace0;
 
    StubDesc = Object_StubDesc;
    StubDesc.pFormatTypes = fmtstr;
    NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 0);
 
    StubMsg.BufferLength = 0;
    NdrComplexStructBufferSize(&StubMsg, (unsigned char *)memsrc, fmtstr);
 
    StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = NdrOleAllocate(StubMsg.BufferLength);
    StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
 
    ptr = NdrComplexStructMarshall(&StubMsg, (unsigned char *)memsrc, fmtstr);
    ok(ptr == NULL, "ret %p\n", ptr);
 
    /* Server */
    StubMsg.IsClient = 0;
    mem = NULL;
    StubMsg.Buffer = StubMsg.BufferStart;
    ptr = NdrComplexStructUnmarshall(&StubMsg, (unsigned char **)&mem, fmtstr, 0);
    ok(ptr == NULL, "ret %p\n", ptr);
    ok(!memcmp(mem, memsrc, sizeof(*memsrc)), "struct wasn't unmarshalled correctly\n");
    StubMsg.pfnFree(mem);
 
    NdrOleFree(StubMsg.RpcMsg->Buffer);
    free(memsrc_orig);
}
 
struct testiface
{
    IPersist IPersist_iface;
    LONG ref;
};
 
static struct testiface *impl_from_IPersist(IPersist *iface)
{
    return CONTAINING_RECORD(iface, struct testiface, IPersist_iface);
}
 
static HRESULT WINAPI test_persist_QueryInterface(IPersist *iface, REFIID iid, void **out)
{
    if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IPersist))
    {
        *out = iface;
        IPersist_AddRef(iface);
        return S_OK;
    }
 
    *out = NULL;
    return E_NOINTERFACE;
}
 
static ULONG WINAPI test_persist_AddRef(IPersist *iface)
{
    struct testiface *unk = impl_from_IPersist(iface);
    return ++unk->ref;
}
 
static ULONG WINAPI test_persist_Release(IPersist *iface)
{
    struct testiface *unk = impl_from_IPersist(iface);
    return --unk->ref;
}
 
static HRESULT WINAPI test_persist_GetClassId(IPersist *iface, GUID *clsid)
{
    *clsid = IID_IPersist;
    return S_OK;
}
 
static IPersistVtbl testiface_vtbl = {
    test_persist_QueryInterface,
    test_persist_AddRef,
    test_persist_Release,
    test_persist_GetClassId,
};
 
static void test_iface_ptr(void)
{
    struct testiface server_obj = {{&testiface_vtbl}, 1};
    struct testiface client_obj = {{&testiface_vtbl}, 1};
 
    MIDL_STUB_MESSAGE StubMsg;
    MIDL_STUB_DESC StubDesc;
    RPC_MESSAGE RpcMessage;
    IPersist *proxy;
    HRESULT hr;
    GUID clsid;
    void *ptr;
    LONG ref;
 
    static const unsigned char fmtstr_ip[] =
    {
        FC_IP,
        FC_CONSTANT_IID,
        NdrFcLong(0x0000010c),
        NdrFcShort(0x0000),
        NdrFcShort(0x0000),
        0xc0,
        0x00,
        0x00,
        0x00,
        0x00,
        0x00,
        0x00,
        0x46,
    };
 
    CoInitialize(NULL);
 
    StubDesc = Object_StubDesc;
    StubDesc.pFormatTypes = fmtstr_ip;
 
    NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 0);
    StubMsg.BufferLength = 0;
    NdrInterfacePointerBufferSize(&StubMsg, (unsigned char *)&client_obj.IPersist_iface, fmtstr_ip);
 
    StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = NdrOleAllocate(StubMsg.BufferLength);
    StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
 
    /* server -> client */
 
    StubMsg.IsClient = 0;
    my_alloc_called = my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    IPersist_AddRef(&server_obj.IPersist_iface);
    ptr = NdrInterfacePointerMarshall(&StubMsg, (unsigned char *)&server_obj.IPersist_iface, fmtstr_ip);
    ok(!ptr, "ret %p\n", ptr);
    ok(server_obj.ref > 2, "got %ld references\n", server_obj.ref);
    ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
    ok(!my_free_called, "free called %d\n", my_free_called);
 
    NdrInterfacePointerFree(&StubMsg, (unsigned char *)&server_obj.IPersist_iface, fmtstr_ip);
    ok(server_obj.ref > 1, "got %ld references\n", server_obj.ref);
 
    StubMsg.IsClient = 1;
    my_alloc_called = my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    proxy = NULL;
    ptr = NdrInterfacePointerUnmarshall(&StubMsg, (unsigned char **)&proxy, fmtstr_ip, 0);
    ok(!ptr, "ret %p\n", ptr);
    ok(!!proxy, "mem not alloced\n");
    ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
    ok(!my_free_called, "free called %d\n", my_free_called);
    ok(server_obj.ref > 1, "got %ld references\n", server_obj.ref);
 
    hr = IPersist_GetClassID(proxy, &clsid);
    ok(hr == S_OK, "got hr %#lx\n", hr);
    ok(IsEqualGUID(&clsid, &IID_IPersist), "wrong clsid %s\n", wine_dbgstr_guid(&clsid));
 
    ref = IPersist_Release(proxy);
    ok(ref == 1, "got %ld references\n", ref);
    ok(server_obj.ref == 1, "got %ld references\n", server_obj.ref);
 
    /* An existing interface pointer is released; this is necessary so that an
     * [in, out] pointer which changes does not leak references. */
 
    StubMsg.IsClient = 0;
    my_alloc_called = my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    IPersist_AddRef(&server_obj.IPersist_iface);
    ptr = NdrInterfacePointerMarshall(&StubMsg, (unsigned char *)&server_obj.IPersist_iface, fmtstr_ip);
    ok(!ptr, "ret %p\n", ptr);
    ok(server_obj.ref > 2, "got %ld references\n", server_obj.ref);
    ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
    ok(!my_free_called, "free called %d\n", my_free_called);
 
    NdrInterfacePointerFree(&StubMsg, (unsigned char *)&server_obj.IPersist_iface, fmtstr_ip);
    ok(server_obj.ref > 1, "got %ld references\n", server_obj.ref);
 
    StubMsg.IsClient = 1;
    my_alloc_called = my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    proxy = &client_obj.IPersist_iface;
    IPersist_AddRef(proxy);
    ptr = NdrInterfacePointerUnmarshall(&StubMsg, (unsigned char **)&proxy, fmtstr_ip, 0);
    ok(!ptr, "ret %p\n", ptr);
    ok(!!proxy && proxy != &client_obj.IPersist_iface, "mem not alloced\n");
    ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
    ok(!my_free_called, "free called %d\n", my_free_called);
    ok(server_obj.ref > 1, "got %ld references\n", server_obj.ref);
    ok(client_obj.ref == 1, "got %ld references\n", client_obj.ref);
 
    hr = IPersist_GetClassID(proxy, &clsid);
    ok(hr == S_OK, "got hr %#lx\n", hr);
    ok(IsEqualGUID(&clsid, &IID_IPersist), "wrong clsid %s\n", wine_dbgstr_guid(&clsid));
 
    ref = IPersist_Release(proxy);
    ok(ref == 1, "got %ld references\n", ref);
    ok(server_obj.ref == 1, "got %ld references\n", server_obj.ref);
 
    /* client -> server */
 
    StubMsg.IsClient = 1;
    my_alloc_called = my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    IPersist_AddRef(&client_obj.IPersist_iface);
    ptr = NdrInterfacePointerMarshall(&StubMsg, (unsigned char *)&client_obj.IPersist_iface, fmtstr_ip);
    ok(!ptr, "ret %p\n", ptr);
    ok(client_obj.ref > 2, "got %ld references\n", client_obj.ref);
    ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
    ok(!my_free_called, "free called %d\n", my_free_called);
 
    StubMsg.IsClient = 0;
    my_alloc_called = my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    proxy = NULL;
    ptr = NdrInterfacePointerUnmarshall(&StubMsg, (unsigned char **)&proxy, fmtstr_ip, 0);
    ok(!ptr, "ret %p\n", ptr);
    ok(!!proxy, "mem not alloced\n");
    ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
    ok(!my_free_called, "free called %d\n", my_free_called);
    ok(client_obj.ref > 2, "got %ld references\n", client_obj.ref);
 
    hr = IPersist_GetClassID(proxy, &clsid);
    ok(hr == S_OK, "got hr %#lx\n", hr);
    ok(IsEqualGUID(&clsid, &IID_IPersist), "wrong clsid %s\n", wine_dbgstr_guid(&clsid));
 
    ref = IPersist_Release(proxy);
    ok(client_obj.ref > 1, "got %ld references\n", client_obj.ref);
    ok(ref == client_obj.ref, "expected %ld references, got %ld\n", client_obj.ref, ref);
 
    NdrInterfacePointerFree(&StubMsg, (unsigned char *)proxy, fmtstr_ip);
    ok(client_obj.ref == 1, "got %ld references\n", client_obj.ref);
 
    /* same, but free the interface after calling NdrInterfacePointerFree */
 
    StubMsg.IsClient = 1;
    my_alloc_called = my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    IPersist_AddRef(&client_obj.IPersist_iface);
    ptr = NdrInterfacePointerMarshall(&StubMsg, (unsigned char *)&client_obj.IPersist_iface, fmtstr_ip);
    ok(!ptr, "ret %p\n", ptr);
    ok(client_obj.ref > 2, "got %ld references\n", client_obj.ref);
    ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
    ok(!my_free_called, "free called %d\n", my_free_called);
 
    StubMsg.IsClient = 0;
    my_alloc_called = my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    proxy = NULL;
    ptr = NdrInterfacePointerUnmarshall(&StubMsg, (unsigned char **)&proxy, fmtstr_ip, 0);
    ok(!ptr, "ret %p\n", ptr);
    ok(!!proxy, "mem not alloced\n");
    ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
    ok(!my_free_called, "free called %d\n", my_free_called);
    ok(client_obj.ref > 2, "got %ld references\n", client_obj.ref);
 
    NdrInterfacePointerFree(&StubMsg, (unsigned char *)proxy, fmtstr_ip);
    ok(client_obj.ref > 1, "got %ld references\n", client_obj.ref);
 
    hr = IPersist_GetClassID(proxy, &clsid);
    ok(hr == S_OK, "got hr %#lx\n", hr);
    ok(IsEqualGUID(&clsid, &IID_IPersist), "wrong clsid %s\n", wine_dbgstr_guid(&clsid));
 
    ref = IPersist_Release(proxy);
    ok(ref == 1, "got %ld references\n", ref);
    ok(client_obj.ref == 1, "got %ld references\n", client_obj.ref);
 
    /* An existing interface pointer is *not* released (in fact, it is ignored
     * and may be invalid). In practice it will always be NULL anyway. */
 
    StubMsg.IsClient = 1;
    my_alloc_called = my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    IPersist_AddRef(&client_obj.IPersist_iface);
    ptr = NdrInterfacePointerMarshall(&StubMsg, (unsigned char *)&client_obj.IPersist_iface, fmtstr_ip);
    ok(!ptr, "ret %p\n", ptr);
    ok(client_obj.ref > 2, "got %ld references\n", client_obj.ref);
    ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
    ok(!my_free_called, "free called %d\n", my_free_called);
 
    StubMsg.IsClient = 0;
    my_alloc_called = my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    proxy = &server_obj.IPersist_iface;
    IPersist_AddRef(proxy);
    ptr = NdrInterfacePointerUnmarshall(&StubMsg, (unsigned char **)&proxy, fmtstr_ip, 0);
    ok(!ptr, "ret %p\n", ptr);
    ok(!!proxy && proxy != &server_obj.IPersist_iface, "mem not alloced\n");
    ok(!my_alloc_called, "alloc called %d\n", my_alloc_called);
    ok(!my_free_called, "free called %d\n", my_free_called);
    ok(client_obj.ref > 2, "got %ld references\n", client_obj.ref);
    ok(server_obj.ref == 2, "got %ld references\n", server_obj.ref);
    IPersist_Release(&server_obj.IPersist_iface);
 
    hr = IPersist_GetClassID(proxy, &clsid);
    ok(hr == S_OK, "got hr %#lx\n", hr);
    ok(IsEqualGUID(&clsid, &IID_IPersist), "wrong clsid %s\n", wine_dbgstr_guid(&clsid));
 
    ref = IPersist_Release(proxy);
    ok(client_obj.ref > 1, "got %ld references\n", client_obj.ref);
    ok(ref == client_obj.ref, "expected %ld references, got %ld\n", client_obj.ref, ref);
 
    NdrInterfacePointerFree(&StubMsg, (unsigned char *)proxy, fmtstr_ip);
    ok(client_obj.ref == 1, "got %ld references\n", client_obj.ref);
 
    NdrOleFree(StubMsg.BufferStart);
 
    CoUninitialize();
}
 
static void test_fullpointer_xlat(void)
{
    PFULL_PTR_XLAT_TABLES pXlatTables;
    ULONG RefId;
    int ret;
    void *Pointer;
 
    pXlatTables = NdrFullPointerXlatInit(2, XLAT_CLIENT);
 
    /* "marshaling" phase */
 
    ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
    ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
    ok(RefId == 0x1, "RefId should be 0x1 instead of 0x%lx\n", RefId);
 
    ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 0, &RefId);
    ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
    ok(RefId == 0x1, "RefId should be 0x1 instead of 0x%lx\n", RefId);
 
    ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebabe, 0, &RefId);
    ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
    ok(RefId == 0x2, "RefId should be 0x2 instead of 0x%lx\n", RefId);
 
    ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 0, &RefId);
    ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
    ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%lx\n", RefId);
 
    ret = NdrFullPointerQueryPointer(pXlatTables, NULL, 0, &RefId);
    ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
    ok(RefId == 0, "RefId should be 0 instead of 0x%lx\n", RefId);
 
    /* "unmarshaling" phase */
 
    ret = NdrFullPointerQueryRefId(pXlatTables, 0x0, 0, &Pointer);
    ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
 
    ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 0, &Pointer);
    ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
    ok(Pointer == (void *)0xcafebabe, "Pointer should be 0xcafebabe instead of %p\n", Pointer);
 
    ret = NdrFullPointerQueryRefId(pXlatTables, 0x4, 0, &Pointer);
    ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
    ok(Pointer == NULL, "Pointer should be NULL instead of %p\n", Pointer);
 
    NdrFullPointerInsertRefId(pXlatTables, 0x4, (void *)0xdeadbabe);
 
    ret = NdrFullPointerQueryRefId(pXlatTables, 0x4, 1, &Pointer);
    ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
    ok(Pointer == (void *)0xdeadbabe, "Pointer should be (void *)0xdeadbabe instead of %p\n", Pointer);
 
    NdrFullPointerXlatFree(pXlatTables);
 
    pXlatTables = NdrFullPointerXlatInit(2, XLAT_SERVER);
 
    /* "unmarshaling" phase */
 
    ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 1, &Pointer);
    ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
    ok(Pointer == NULL, "Pointer should be NULL instead of %p\n", Pointer);
 
    NdrFullPointerInsertRefId(pXlatTables, 0x2, (void *)0xcafebabe);
 
    ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 0, &Pointer);
    ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
    ok(Pointer == (void *)0xcafebabe, "Pointer should be (void *)0xcafebabe instead of %p\n", Pointer);
 
    ret = NdrFullPointerQueryRefId(pXlatTables, 0x2, 1, &Pointer);
    ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
    ok(Pointer == (void *)0xcafebabe, "Pointer should be (void *)0xcafebabe instead of %p\n", Pointer);
 
    /* "marshaling" phase */
 
    ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
    ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
    ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%lx\n", RefId);
 
    ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
    ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
    ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%lx\n", RefId);
 
    ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 0, &RefId);
    ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
    ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%lx\n", RefId);
 
    ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebabe, 0, &RefId);
    ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
    ok(RefId == 0x2, "RefId should be 0x2 instead of 0x%lx\n", RefId);
 
    ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 0, &RefId);
    ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
    ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%lx\n", RefId);
 
    /* "freeing" phase */
 
    ret = NdrFullPointerFree(pXlatTables, (void *)0xcafebeef);
    ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
 
    ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 0x20, &RefId);
    ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
    ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%lx\n", RefId);
 
    ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xcafebeef, 1, &RefId);
    ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
    ok(RefId == 0x3, "RefId should be 0x3 instead of 0x%lx\n", RefId);
 
    ret = NdrFullPointerFree(pXlatTables, (void *)0xcafebabe);
    ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
 
    ret = NdrFullPointerFree(pXlatTables, (void *)0xdeadbeef);
    ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
 
    ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 0x20, &RefId);
    ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
    ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%lx\n", RefId);
 
    ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 1, &RefId);
    ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
    ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%lx\n", RefId);
 
    ret = NdrFullPointerQueryPointer(pXlatTables, (void *)0xdeadbeef, 1, &RefId);
    ok(ret == 1, "ret should be 1 instead of 0x%x\n", ret);
    ok(RefId == 0x4, "RefId should be 0x4 instead of 0x%lx\n", RefId);
 
    ret = NdrFullPointerFree(pXlatTables, (void *)0xdeadbeef);
    ok(ret == 0, "ret should be 0 instead of 0x%x\n", ret);
 
    NdrFullPointerXlatFree(pXlatTables);
}
 
/* verify stub data that is identical between client and server */
static void test_common_stub_data( const char *prefix, const MIDL_STUB_MESSAGE *stubMsg )
{
    void *unset_ptr;
 
    memset(&unset_ptr, 0xcc, sizeof(unset_ptr));
 
#define TEST_ZERO(field, fmt) ok(stubMsg->field == 0, "%s: " #field " should have been set to zero instead of " fmt "\n", prefix, stubMsg->field)
#define TEST_POINTER_UNSET(field) ok(stubMsg->field == unset_ptr, "%s: " #field " should have been unset instead of %p\n", prefix, stubMsg->field)
#define TEST_ULONG_UNSET(field) ok(stubMsg->field == 0xcccccccc, "%s: " #field " should have been unset instead of 0x%lx\n", prefix, stubMsg->field)
#define TEST_ULONG_PTR_UNSET(field) ok(stubMsg->field == (ULONG_PTR)unset_ptr, "%s: " #field " should have been unset instead of 0x%Ix\n", prefix, stubMsg->field)
 
    TEST_POINTER_UNSET(BufferMark);
    TEST_ULONG_UNSET(MemorySize);
    TEST_POINTER_UNSET(Memory);
    TEST_ZERO(pAllocAllNodesContext, "%p");
    ok(stubMsg->pPointerQueueState == 0 ||
       broken(stubMsg->pPointerQueueState == unset_ptr), /* win2k */
       "%s: pPointerQueueState should have been unset instead of %p\n",
       prefix, stubMsg->pPointerQueueState);
    TEST_ZERO(IgnoreEmbeddedPointers, "%d");
    TEST_ZERO(PointerBufferMark, "%p");
    ok( stubMsg->uFlags == 0 ||
        broken(stubMsg->uFlags == 0xcc), /* win9x */
        "%s: uFlags should have been set to zero instead of 0x%x\n", prefix, stubMsg->uFlags );
    /* FIXME: UniquePtrCount */
    TEST_ULONG_PTR_UNSET(MaxCount);
    TEST_ULONG_UNSET(Offset);
    TEST_ULONG_UNSET(ActualCount);
    ok(stubMsg->pfnAllocate == my_alloc, "%s: pfnAllocate should have been %p instead of %p\n",
       prefix, my_alloc, stubMsg->pfnAllocate);
    ok(stubMsg->pfnFree == my_free, "%s: pfnFree should have been %p instead of %p\n",
       prefix, my_free, stubMsg->pfnFree);
    TEST_ZERO(StackTop, "%p");
    TEST_POINTER_UNSET(pPresentedType);
    TEST_POINTER_UNSET(pTransmitType);
    TEST_POINTER_UNSET(SavedHandle);
    ok(stubMsg->StubDesc == &Object_StubDesc, "%s: StubDesc should have been %p instead of %p\n",
       prefix, &Object_StubDesc, stubMsg->StubDesc);
    TEST_ZERO(FullPtrRefId, "%ld");
    ok( stubMsg->PointerLength == 0 ||
        broken(stubMsg->PointerLength == 1), /* win9x, nt4 */
        "%s: pAsyncMsg should have been set to zero instead of %ld\n", prefix, stubMsg->PointerLength );
    TEST_ZERO(fInDontFree, "%d");
    TEST_ZERO(fDontCallFreeInst, "%d");
    ok( stubMsg->fHasReturn == 0 || broken(stubMsg->fHasReturn), /* win9x, nt4 */
        "%s: fHasReturn should have been set to zero instead of %d\n", prefix, stubMsg->fHasReturn );
    TEST_ZERO(fHasExtensions, "%d");
    TEST_ZERO(fHasNewCorrDesc, "%d");
    ok(stubMsg->fIsIn == 0 || broken(stubMsg->fIsIn), /* win9x, nt4 */
       "%s: fIsIn should have been set to 0 instead of %d\n", prefix, stubMsg->fIsIn);
    TEST_ZERO(fIsOicf, "%d");
    ok(stubMsg->fBufferValid == 0,
       "%s: fBufferValid should have been set to 0 instead of %d\n", prefix, stubMsg->fBufferValid);
    TEST_ZERO(fNeedMCCP, "%d");
    ok(stubMsg->fUnused2 == 0 ||
       stubMsg->fUnused2 == -2, /* Vista */
       "%s: fUnused2 should have been set to 0 or -2 instead of %d\n", prefix, stubMsg->fUnused2);
    ok(stubMsg->fUnused3 == 0xffffcccc, "%s: fUnused3 should have been 0xffffcccc instead of 0x%x\n",
       prefix, stubMsg->fUnused3);
    ok(stubMsg->dwDestContext == MSHCTX_DIFFERENTMACHINE,
       "%s: dwDestContext should have been MSHCTX_DIFFERENTMACHINE instead of %ld\n",
       prefix, stubMsg->dwDestContext);
    TEST_ZERO(pvDestContext, "%p");
    TEST_POINTER_UNSET(SavedContextHandles);
    TEST_ULONG_UNSET(ParamNumber);
    TEST_ZERO(pRpcChannelBuffer, "%p");
    TEST_ZERO(pArrayInfo, "%p");
    TEST_POINTER_UNSET(SizePtrCountArray);
    TEST_POINTER_UNSET(SizePtrOffsetArray);
    TEST_POINTER_UNSET(SizePtrLengthArray);
    TEST_POINTER_UNSET(pArgQueue);
    TEST_ZERO(dwStubPhase, "%ld");
    /* FIXME: where does this value come from? */
    trace("%s: LowStackMark is %p\n", prefix, stubMsg->LowStackMark);
    ok( stubMsg->pAsyncMsg == 0 || broken(stubMsg->pAsyncMsg == unset_ptr), /* win9x, nt4 */
        "%s: pAsyncMsg should have been set to zero instead of %p\n", prefix, stubMsg->pAsyncMsg );
    ok( stubMsg->pCorrInfo == 0 || broken(stubMsg->pCorrInfo == unset_ptr), /* win9x, nt4 */
        "%s: pCorrInfo should have been set to zero instead of %p\n", prefix, stubMsg->pCorrInfo );
    ok( stubMsg->pCorrMemory == 0 || broken(stubMsg->pCorrMemory == unset_ptr), /* win9x, nt4 */
        "%s: pCorrMemory should have been set to zero instead of %p\n", prefix, stubMsg->pCorrMemory );
    ok( stubMsg->pMemoryList == 0 || broken(stubMsg->pMemoryList == unset_ptr), /* win9x, nt4 */
        "%s: pMemoryList should have been set to zero instead of %p\n", prefix, stubMsg->pMemoryList );
    TEST_POINTER_UNSET(pCSInfo);
    TEST_POINTER_UNSET(ConformanceMark);
    TEST_POINTER_UNSET(VarianceMark);
    ok(stubMsg->Unused == (ULONG_PTR)unset_ptr, "%s: Unused should have be unset instead of 0x%Ix\n",
       prefix, stubMsg->Unused);
    TEST_POINTER_UNSET(pContext);
    TEST_POINTER_UNSET(ContextHandleHash);
    TEST_POINTER_UNSET(pUserMarshalList);
    TEST_ULONG_PTR_UNSET(Reserved51_3);
    TEST_ULONG_PTR_UNSET(Reserved51_4);
    TEST_ULONG_PTR_UNSET(Reserved51_5);
 
#undef TEST_ULONG_PTR_UNSET
#undef TEST_ULONG_UNSET
#undef TEST_POINTER_UNSET
#undef TEST_ZERO
}
 
static void test_client_init(void)
{
    MIDL_STUB_MESSAGE stubMsg;
    RPC_MESSAGE rpcMsg;
    void *unset_ptr;
 
    memset(&rpcMsg, 0xcc, sizeof(rpcMsg));
    memset(&stubMsg, 0xcc, sizeof(stubMsg));
    memset(&unset_ptr, 0xcc, sizeof(unset_ptr));
 
    NdrClientInitializeNew(&rpcMsg, &stubMsg, &Object_StubDesc, 1);
 
    test_common_stub_data( "NdrClientInitializeNew", &stubMsg );
 
    ok(stubMsg.RpcMsg == &rpcMsg, "stubMsg.RpcMsg should have been %p instead of %p\n", &rpcMsg, stubMsg.RpcMsg);
    ok(rpcMsg.Handle == NULL, "rpcMsg.Handle should have been NULL instead of %p\n", rpcMsg.Handle);
    ok(rpcMsg.Buffer == unset_ptr, "rpcMsg.Buffer should have been unset instead of %p\n",
       rpcMsg.Buffer);
    ok(rpcMsg.BufferLength == 0xcccccccc, "rpcMsg.BufferLength should have been unset instead of %d\n", rpcMsg.BufferLength);
    ok(rpcMsg.ProcNum == 0x8001, "rpcMsg.ProcNum should have been 0x8001 instead of 0x%x\n", rpcMsg.ProcNum);
    ok(rpcMsg.TransferSyntax == unset_ptr, "rpcMsg.TransferSyntax should have been unset instead of %p\n", rpcMsg.TransferSyntax);
    ok(rpcMsg.RpcInterfaceInformation == Object_StubDesc.RpcInterfaceInformation,
        "rpcMsg.RpcInterfaceInformation should have been %p instead of %p\n",
        Object_StubDesc.RpcInterfaceInformation, rpcMsg.RpcInterfaceInformation);
    /* Note: ReservedForRuntime not tested */
    ok(rpcMsg.ManagerEpv == unset_ptr, "rpcMsg.ManagerEpv should have been unset instead of %p\n", rpcMsg.ManagerEpv);
    ok(rpcMsg.ImportContext == unset_ptr, "rpcMsg.ImportContext should have been unset instead of %p\n", rpcMsg.ImportContext);
    ok(rpcMsg.RpcFlags == 0, "rpcMsg.RpcFlags should have been 0 instead of 0x%lx\n", rpcMsg.RpcFlags);
 
    ok(stubMsg.Buffer == unset_ptr, "stubMsg.Buffer should have been unset instead of %p\n",
       stubMsg.Buffer);
    ok(stubMsg.BufferStart == NULL, "stubMsg.BufferStart should have been NULL instead of %p\n",
       stubMsg.BufferStart);
    ok(stubMsg.BufferEnd == NULL, "stubMsg.BufferEnd should have been NULL instead of %p\n",
       stubMsg.BufferEnd);
    ok(stubMsg.BufferLength == 0, "stubMsg.BufferLength should have been 0 instead of %lu\n",
       stubMsg.BufferLength);
    ok(stubMsg.IsClient == 1, "stubMsg.IsClient should have been 1 instead of %u\n", stubMsg.IsClient);
    ok(stubMsg.ReuseBuffer == 0, "stubMsg.ReuseBuffer should have been 0 instead of %d\n",
       stubMsg.ReuseBuffer);
    ok(stubMsg.CorrDespIncrement == 0, "stubMsg.CorrDespIncrement should have been 0 instead of %d\n",
       stubMsg.CorrDespIncrement);
    ok(stubMsg.FullPtrXlatTables == unset_ptr, "stubMsg.FullPtrXlatTables should have been unset instead of %p\n",
       stubMsg.FullPtrXlatTables);
}
 
static void test_server_init(void)
{
    MIDL_STUB_MESSAGE stubMsg;
    RPC_MESSAGE rpcMsg;
    unsigned char *ret;
    unsigned char buffer[256];
 
    memset(&rpcMsg, 0, sizeof(rpcMsg));
    rpcMsg.Buffer = buffer;
    rpcMsg.BufferLength = sizeof(buffer);
    rpcMsg.RpcFlags = RPC_BUFFER_COMPLETE;
 
    memset(&stubMsg, 0xcc, sizeof(stubMsg));
 
    ret = NdrServerInitializeNew(&rpcMsg, &stubMsg, &Object_StubDesc);
    ok(ret == NULL, "NdrServerInitializeNew should have returned NULL instead of %p\n", ret);
 
    test_common_stub_data( "NdrServerInitializeNew", &stubMsg );
 
    ok(stubMsg.RpcMsg == &rpcMsg, "stubMsg.RpcMsg should have been %p instead of %p\n", &rpcMsg, stubMsg.RpcMsg);
    ok(stubMsg.Buffer == buffer, "stubMsg.Buffer should have been %p instead of %p\n", buffer, stubMsg.Buffer);
    ok(stubMsg.BufferStart == buffer, "stubMsg.BufferStart should have been %p instead of %p\n", buffer, stubMsg.BufferStart);
    ok(stubMsg.BufferEnd == buffer + sizeof(buffer), "stubMsg.BufferEnd should have been %p instead of %p\n", buffer + sizeof(buffer), stubMsg.BufferEnd);
    todo_wine
    ok(stubMsg.BufferLength == 0, "stubMsg.BufferLength should have been 0 instead of %lu\n", stubMsg.BufferLength);
    ok(stubMsg.IsClient == 0, "stubMsg.IsClient should have been 0 instead of %u\n", stubMsg.IsClient);
    ok(stubMsg.ReuseBuffer == 0 ||
       broken(stubMsg.ReuseBuffer == 1), /* win2k */
       "stubMsg.ReuseBuffer should have been set to zero instead of %d\n", stubMsg.ReuseBuffer);
    ok(stubMsg.CorrDespIncrement == 0 ||
       broken(stubMsg.CorrDespIncrement == 0xcc), /* <= Win 2003 */
       "CorrDespIncrement should have been set to zero instead of 0x%x\n", stubMsg.CorrDespIncrement);
    ok(stubMsg.FullPtrXlatTables == 0, "stubMsg.BufferLength should have been 0 instead of %p\n", stubMsg.FullPtrXlatTables);
}
 
static void test_ndr_allocate(void)
{
    RPC_MESSAGE RpcMessage;
    MIDL_STUB_MESSAGE StubMsg;
    MIDL_STUB_DESC StubDesc;
    void *p1, *p2;
    struct tag_mem_list_v2_t
    {
        DWORD magic;
        DWORD size;
        DWORD unknown;
        struct tag_mem_list_v2_t *next;
    } *mem_list_v2;
    const DWORD magic_MEML = 'M' << 24 | 'E' << 16 | 'M' << 8 | 'L';
 
    StubDesc = Object_StubDesc;
    NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 0);
 
    my_alloc_called = my_free_called = 0;
    p1 = NdrAllocate(&StubMsg, 10);
    p2 = NdrAllocate(&StubMsg, 24);
    ok(my_alloc_called == 2, "alloc called %d\n", my_alloc_called);
    ok(StubMsg.pMemoryList != NULL, "StubMsg.pMemoryList NULL\n");
    if(StubMsg.pMemoryList)
    {
        mem_list_v2 = StubMsg.pMemoryList;
        if (mem_list_v2->size == 24)
        {
            trace("v2 mem list format\n");
            ok((char *)mem_list_v2 == (char *)p2 + 24, "expected mem_list_v2 pointer %p, but got %p\n", (char *)p2 + 24, mem_list_v2);
            ok(mem_list_v2->magic == magic_MEML, "magic %08lx\n", mem_list_v2->magic);
            ok(mem_list_v2->size == 24, "wrong size for p2 %ld\n", mem_list_v2->size);
            ok(mem_list_v2->unknown == 0, "wrong unknown for p2 0x%lx\n", mem_list_v2->unknown);
            ok(mem_list_v2->next != NULL, "next NULL\n");
            mem_list_v2 = mem_list_v2->next;
            if(mem_list_v2)
            {
                ok((char *)mem_list_v2 == (char *)p1 + 16, "expected mem_list_v2 pointer %p, but got %p\n", (char *)p1 + 16, mem_list_v2);
                ok(mem_list_v2->magic == magic_MEML, "magic %08lx\n", mem_list_v2->magic);
                ok(mem_list_v2->size == 16, "wrong size for p1 %ld\n", mem_list_v2->size);
                ok(mem_list_v2->unknown == 0, "wrong unknown for p1 0x%lx\n", mem_list_v2->unknown);
                ok(mem_list_v2->next == NULL, "next %p\n", mem_list_v2->next);
            }
        }
        else win_skip("v1 mem list format\n");
    }
    /* NdrFree isn't exported so we can't test free'ing */
    my_free(p1);
    my_free(p2);
}
 
static void test_conformant_array(void)
{
    RPC_MESSAGE RpcMessage;
    MIDL_STUB_MESSAGE StubMsg;
    MIDL_STUB_DESC StubDesc;
    void *ptr;
    unsigned char *mem, *mem_orig;
    unsigned char memsrc[20];
    unsigned int i;
 
    static const unsigned char fmtstr_conf_array[] =
    {
        0x1b,              /* FC_CARRAY */
        0x0,               /* align */
        NdrFcShort( 0x1 ), /* elem size */
        0x40,              /* Corr desc:  const */
        0x0,
        NdrFcShort(0x10),  /* const = 0x10 */
        0x1,               /* FC_BYTE */
        0x5b               /* FC_END */
    };
 
    for (i = 0; i < sizeof(memsrc); i++)
        memsrc[i] = i * i;
 
    StubDesc = Object_StubDesc;
    StubDesc.pFormatTypes = fmtstr_conf_array;
 
    NdrClientInitializeNew(
                           &RpcMessage,
                           &StubMsg,
                           &StubDesc,
                           0);
 
    StubMsg.BufferLength = 0;
    NdrConformantArrayBufferSize( &StubMsg,
                          memsrc,
                          fmtstr_conf_array );
    ok(StubMsg.BufferLength >= 20, "length %ld\n", StubMsg.BufferLength);
 
    /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
    StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = NdrOleAllocate(StubMsg.BufferLength);
    StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
 
    ptr = NdrConformantArrayMarshall( &StubMsg,  memsrc, fmtstr_conf_array );
    ok(ptr == NULL, "ret %p\n", ptr);
    ok(StubMsg.Buffer - StubMsg.BufferStart == 20, "Buffer %p Start %p len %d\n", StubMsg.Buffer, StubMsg.BufferStart, 20);
    ok(!memcmp(StubMsg.BufferStart + 4, memsrc, 16), "incorrectly marshaled\n");
 
    StubMsg.Buffer = StubMsg.BufferStart;
    StubMsg.MemorySize = 0;
    mem = NULL;
 
    /* Client */
    my_alloc_called = 0;
    /* passing mem == NULL with must_alloc == 0 crashes under Windows */
    NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
    ok(mem != NULL, "mem not alloced\n");
    ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
    ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
 
    my_alloc_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    mem_orig = mem;
    NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
    ok(mem == mem_orig, "mem alloced\n");
    ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    my_alloc_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
    ok(mem != mem_orig, "mem not alloced\n");
    ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
    ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
 
    my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrConformantArrayFree( &StubMsg, mem, fmtstr_conf_array );
    ok(my_free_called == 0, "free called %d\n", my_free_called);
    StubMsg.pfnFree(mem);
 
    /* Server */
    my_alloc_called = 0;
    StubMsg.IsClient = 0;
    mem = NULL;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
    ok(mem == StubMsg.BufferStart + 4 || broken(!mem),  /* win9x, nt4 */
       "mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 4);
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
    my_alloc_called = 0;
    mem = NULL;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
    ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
    ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
    StubMsg.pfnFree(mem);
 
    my_alloc_called = 0;
    mem = mem_orig;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 0);
    ok(mem == mem_orig, "mem alloced\n");
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    my_alloc_called = 0;
    mem = mem_orig;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrConformantArrayUnmarshall( &StubMsg, &mem, fmtstr_conf_array, 1);
    ok(mem != StubMsg.BufferStart + 4, "mem pointing at buffer\n");
    ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
    StubMsg.pfnFree(mem);
    StubMsg.pfnFree(mem_orig);
 
    NdrOleFree(StubMsg.RpcMsg->Buffer);
}
 
static void test_conformant_string(void)
{
    RPC_MESSAGE RpcMessage;
    MIDL_STUB_MESSAGE StubMsg;
    MIDL_STUB_DESC StubDesc;
    DWORD size;
    void *ptr;
    unsigned char *mem, *mem_orig;
    char memsrc[] = "This is a test string";
 
    static const unsigned char fmtstr_conf_str[] =
    {
            0x11, 0x8,  /* FC_RP [simple_pointer] */
            0x22,       /* FC_C_CSTRING */
            0x5c,       /* FC_PAD */
    };
 
    StubDesc = Object_StubDesc;
    StubDesc.pFormatTypes = fmtstr_conf_str;
 
    memset( &StubMsg, 0, sizeof(StubMsg) );  /* needed on win9x and nt4 */
    NdrClientInitializeNew(
                           &RpcMessage,
                           &StubMsg,
                           &StubDesc,
                           0);
 
    StubMsg.BufferLength = 0;
    NdrPointerBufferSize( &StubMsg,
                          (unsigned char *)memsrc,
                          fmtstr_conf_str );
    ok(StubMsg.BufferLength >= sizeof(memsrc) + 12, "length %ld\n", StubMsg.BufferLength);
 
    /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
    StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = NdrOleAllocate(StubMsg.BufferLength);
    StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
 
    ptr = NdrPointerMarshall( &StubMsg, (unsigned char *)memsrc, fmtstr_conf_str );
    ok(ptr == NULL, "ret %p\n", ptr);
    size = StubMsg.Buffer - StubMsg.BufferStart;
    ok(size == sizeof(memsrc) + 12, "Buffer %p Start %p len %ld\n",
       StubMsg.Buffer, StubMsg.BufferStart, size);
    ok(!memcmp(StubMsg.BufferStart + 12, memsrc, sizeof(memsrc)), "incorrectly marshaled\n");
 
    StubMsg.Buffer = StubMsg.BufferStart;
    StubMsg.MemorySize = 0;
    mem = NULL;
 
    /* Client */
    my_alloc_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    mem = mem_orig = malloc(sizeof(memsrc));
    /* Windows apparently checks string length on the output buffer to determine its size... */
    memset( mem, 'x', sizeof(memsrc) - 1 );
    mem[sizeof(memsrc) - 1] = 0;
    NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
    ok(mem == mem_orig, "mem not alloced\n");
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    my_alloc_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
    ok(mem == mem_orig, "mem not alloced\n");
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    /* Prevent a memory leak when running with Wine.
       Remove once the todo_wine block above is fixed. */
    if (mem != mem_orig)
        free(mem_orig);
 
    my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
    ok(my_free_called == 1, "free called %d\n", my_free_called);
 
    mem = my_alloc(10);
    my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
    ok(my_free_called == 1, "free called %d\n", my_free_called);
 
    /* Server */
    my_alloc_called = 0;
    StubMsg.IsClient = 0;
    mem = NULL;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
    ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
       "mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    my_alloc_called = 0;
    mem = NULL;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
    ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
       "mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    my_alloc_called = 0;
    mem = mem_orig = malloc(sizeof(memsrc));
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 0);
    ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
       "mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    my_alloc_called = 0;
    mem = mem_orig;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerUnmarshall( &StubMsg, &mem, fmtstr_conf_str, 1);
    ok(mem == StubMsg.BufferStart + 12 || broken(!mem), /* win9x, nt4 */
       "mem not pointing at buffer %p/%p\n", mem, StubMsg.BufferStart + 12 );
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    mem = my_alloc(10);
    my_free_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrPointerFree( &StubMsg, mem, fmtstr_conf_str );
    ok(my_free_called == 1, "free called %d\n", my_free_called);
 
    free(mem_orig);
    NdrOleFree(StubMsg.RpcMsg->Buffer);
}
 
static void test_nonconformant_string(void)
{
    RPC_MESSAGE RpcMessage;
    MIDL_STUB_MESSAGE StubMsg;
    MIDL_STUB_DESC StubDesc;
    DWORD size;
    void *ptr;
    unsigned char *mem, *mem_orig;
    unsigned char memsrc[10] = "This is";
    unsigned char memsrc2[10] = "This is a";
 
    static const unsigned char fmtstr_nonconf_str[] =
    {
            0x26,       /* FC_CSTRING */
            0x5c,       /* FC_PAD */
            NdrFcShort( 0xa ),  /* 10 */
    };
 
    StubDesc = Object_StubDesc;
    StubDesc.pFormatTypes = fmtstr_nonconf_str;
 
    /* length < size */
    NdrClientInitializeNew(
                           &RpcMessage,
                           &StubMsg,
                           &StubDesc,
                           0);
 
    StubMsg.BufferLength = 0;
 
    NdrNonConformantStringBufferSize( &StubMsg, memsrc, fmtstr_nonconf_str );
    ok(StubMsg.BufferLength >= strlen((char *)memsrc) + 1 + 8, "length %ld\n", StubMsg.BufferLength);
 
    /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
    StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = NdrOleAllocate(StubMsg.BufferLength);
    StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
 
    ptr = NdrNonConformantStringMarshall( &StubMsg, memsrc, fmtstr_nonconf_str );
    ok(ptr == NULL, "ret %p\n", ptr);
    size = StubMsg.Buffer - StubMsg.BufferStart;
    ok(size == strlen((char *)memsrc) + 1 + 8, "Buffer %p Start %p len %ld\n",
       StubMsg.Buffer, StubMsg.BufferStart, size);
    ok(!memcmp(StubMsg.BufferStart + 8, memsrc, strlen((char *)memsrc) + 1), "incorrectly marshaled\n");
 
    StubMsg.Buffer = StubMsg.BufferStart;
    StubMsg.MemorySize = 0;
    mem = NULL;
 
    /* Client */
    my_alloc_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    mem = mem_orig = malloc(sizeof(memsrc));
    NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
    ok(mem == mem_orig, "mem alloced\n");
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    my_alloc_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
    todo_wine
    ok(mem == mem_orig, "mem alloced\n");
    todo_wine
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    /* Server */
    my_alloc_called = 0;
    StubMsg.IsClient = 0;
    mem = NULL;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
    ok(mem != mem_orig, "mem not alloced\n");
    ok(mem != StubMsg.BufferStart + 8, "mem pointing at buffer\n");
    ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
    free(mem);
 
    my_alloc_called = 0;
    mem = mem_orig;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
    ok(mem == mem_orig, "mem alloced\n");
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    my_alloc_called = 0;
    mem = mem_orig;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
    todo_wine
    ok(mem == mem_orig, "mem alloced\n");
    todo_wine
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    free(mem_orig);
    NdrOleFree(StubMsg.RpcMsg->Buffer);
 
    /* length = size */
    NdrClientInitializeNew(
                           &RpcMessage,
                           &StubMsg,
                           &StubDesc,
                           0);
 
    StubMsg.BufferLength = 0;
 
    NdrNonConformantStringBufferSize( &StubMsg, memsrc2, fmtstr_nonconf_str );
    ok(StubMsg.BufferLength >= strlen((char *)memsrc2) + 1 + 8, "length %ld\n", StubMsg.BufferLength);
 
    /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
    StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = NdrOleAllocate(StubMsg.BufferLength);
    StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
 
    ptr = NdrNonConformantStringMarshall( &StubMsg, memsrc2, fmtstr_nonconf_str );
    ok(ptr == NULL, "ret %p\n", ptr);
    size = StubMsg.Buffer - StubMsg.BufferStart;
    ok(size == strlen((char *)memsrc2) + 1 + 8, "Buffer %p Start %p len %ld\n",
       StubMsg.Buffer, StubMsg.BufferStart, size);
    ok(!memcmp(StubMsg.BufferStart + 8, memsrc2, strlen((char *)memsrc2) + 1), "incorrectly marshaled\n");
 
    StubMsg.Buffer = StubMsg.BufferStart;
    StubMsg.MemorySize = 0;
    mem = NULL;
 
    /* Client */
    my_alloc_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    mem = mem_orig = malloc(sizeof(memsrc));
    NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
    ok(mem == mem_orig, "mem alloced\n");
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    my_alloc_called = 0;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
    todo_wine
    ok(mem == mem_orig, "mem alloced\n");
    todo_wine
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    /* Server */
    my_alloc_called = 0;
    StubMsg.IsClient = 0;
    mem = NULL;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
    ok(mem != mem_orig, "mem not alloced\n");
    ok(mem != StubMsg.BufferStart + 8, "mem pointing at buffer\n");
    ok(my_alloc_called == 1, "alloc called %d\n", my_alloc_called);
    free(mem);
 
    my_alloc_called = 0;
    mem = mem_orig;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 0);
    ok(mem == mem_orig, "mem alloced\n");
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    my_alloc_called = 0;
    mem = mem_orig;
    StubMsg.Buffer = StubMsg.BufferStart;
    NdrNonConformantStringUnmarshall( &StubMsg, &mem, fmtstr_nonconf_str, 1);
    todo_wine
    ok(mem == mem_orig, "mem alloced\n");
    todo_wine
    ok(my_alloc_called == 0, "alloc called %d\n", my_alloc_called);
 
    free(mem_orig);
    NdrOleFree(StubMsg.RpcMsg->Buffer);
}
 
static void test_conf_complex_struct(void)
{
    RPC_MESSAGE RpcMessage;
    MIDL_STUB_MESSAGE StubMsg;
    MIDL_STUB_DESC StubDesc;
    void *ptr;
    unsigned int i;
    struct conf_complex
    {
        enum {dummy} enum16;
        unsigned int size;
        unsigned int array[1];
    };
    struct conf_complex *memsrc;
    struct conf_complex *mem;
 
    /*
        struct conf_complex
        {
            enum {dummy} enum16;
            int size;
            [size_is(size), unique] int array[];
        };
    */
    static const unsigned char fmtstr_complex_struct[] =
    {
        NdrFcShort(0x0),
/* 2 (int[]) */
        0x1b,   /* FC_CARRAY */
        0x3,    /* 3 */
        NdrFcShort(0x4),    /* 4 */
        0x8,    /* Corr desc: field size, FC_LONG */
        0x0,    /* no operators */
        NdrFcShort(0xfffc), /* offset = -4 */
        0x08,   /* FC_LONG */
        0x5b,   /* FC_END */
/* 12 (struct conf_complex) */
        0x1a,   /* FC_BOGUS_STRUCT */
        0x3,    /* 3 */
        NdrFcShort(0x8),    /* 8 */
        NdrFcShort(0xfff2), /* Offset= -14 (2) */
        NdrFcShort(0x0),    /* Offset= 0 (18) */
        0x0d,   /* FC_ENUM16 */
        0x08,   /* FC_LONG */
        0x5c,   /* FC_PAD */
        0x5b,   /* FC_END */
    };
 
    memsrc = calloc(1, FIELD_OFFSET(struct conf_complex, array[20]));
    memsrc->size = 20;
 
    StubDesc = Object_StubDesc;
    StubDesc.pFormatTypes = fmtstr_complex_struct;
 
    NdrClientInitializeNew(
                           &RpcMessage,
                           &StubMsg,
                           &StubDesc,
                           0);
 
    StubMsg.BufferLength = 0;
    NdrComplexStructBufferSize(&StubMsg, (unsigned char *)memsrc, &fmtstr_complex_struct[12]);
    ok(StubMsg.BufferLength >= 92, "length %ld\n", StubMsg.BufferLength);
 
    /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
    StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = NdrOleAllocate(StubMsg.BufferLength);
    StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
 
    ptr = NdrComplexStructMarshall(&StubMsg, (unsigned char *)memsrc, &fmtstr_complex_struct[12]);
    ok(ptr == NULL, "ret %p\n", ptr);
    ok(*(unsigned int *)StubMsg.BufferStart == 20, "Conformance should have been 20 instead of %u\n",
       *(unsigned int *)StubMsg.BufferStart);
    todo_wine
    ok(*(unsigned int *)(StubMsg.BufferStart + 8) == 20, "conf_complex.size should have been 20 instead of %u\n",
       *(unsigned int *)(StubMsg.BufferStart + 8));
    for (i = 0; i < 20; i++)
      ok(*(unsigned int *)(StubMsg.BufferStart + 12 + i * 4) == 0,
         "pointer id for conf_complex.array[%u] should have been 0 instead of 0x%x\n", i,
         *(unsigned int *)(StubMsg.BufferStart + 12 + i * 4));
 
    /* Server */
    my_alloc_called = 0;
    StubMsg.IsClient = 0;
    mem = NULL;
    StubMsg.Buffer = StubMsg.BufferStart;
    ptr = NdrComplexStructUnmarshall(&StubMsg, (unsigned char **)&mem, &fmtstr_complex_struct[12], 0);
    ok(ptr == NULL, "ret %p\n", ptr);
    ok(mem->size == 20, "mem->size wasn't unmarshalled correctly (%d)\n", mem->size);
    ok(mem->array[0] == 0, "mem->array[0] wasn't unmarshalled correctly (%u)\n", mem->array[0]);
    StubMsg.pfnFree(mem);
 
    NdrOleFree(StubMsg.RpcMsg->Buffer);
    free(memsrc);
}
 
 
static void test_conf_complex_array(void)
{
    RPC_MESSAGE RpcMessage;
    MIDL_STUB_MESSAGE StubMsg;
    MIDL_STUB_DESC StubDesc;
    void *ptr;
    unsigned int i, j;
    struct conf_complex
    {
        unsigned int dim1, dim2;
        DWORD **array;
    };
    struct conf_complex memsrc;
    struct conf_complex *mem;
    DWORD *buf, expected_length;
 
    static const unsigned char fmtstr_complex_array[] =
    {
 
/*  0 */        0x21,           /* FC_BOGUS_ARRAY */
                0x3,            /* 3 */
/*  2 */        NdrFcShort( 0x0 ),      /* 0 */
/*  4 */        0x19, 0x0,      /* Corr desc:  field pointer, FC_ULONG */
/*  6 */        NdrFcShort( 0x4 ),      /* 4 */
/*  8 */        NdrFcLong( 0xffffffff ),        /* -1 */
/* 12 */        0x8,            /* FC_LONG */
                0x5b,           /* FC_END */
/* 14 */
                0x21,           /* FC_BOGUS_ARRAY */
                0x3,            /* 3 */
/* 16 */        NdrFcShort( 0x0 ),      /* 0 */
/* 18 */        0x19,           /* Corr desc:  field pointer, FC_ULONG */
                0x0,            /*  */
/* 20 */        NdrFcShort( 0x0 ),      /* 0 */
/* 22 */        NdrFcLong( 0xffffffff ),        /* -1 */
/* 26 */        0x12, 0x0,      /* FC_UP */
/* 28 */        NdrFcShort( 0xffe4 ),   /* Offset= -28 (0) */
/* 30 */        0x5c,           /* FC_PAD */
                0x5b,           /* FC_END */
 
#ifdef _WIN64
/* 32 */        0x1a,           /* FC_BOGUS_STRUCT */
                0x3,            /* 3 */
/* 34 */        NdrFcShort( 0x10 ),     /* 16 */
/* 36 */        NdrFcShort( 0x0 ),      /* 0 */
/* 38 */        NdrFcShort( 0x6 ),      /* Offset= 6 (44) */
/* 40 */        0x8,            /* FC_LONG */
                0x8,            /* FC_LONG */
/* 42 */        0x36,           /* FC_POINTER */
                0x5b,           /* FC_END */
/* 44 */
                0x12, 0x0,      /* FC_UP */
/* 46 */        NdrFcShort( 0xffe0 ),   /* Offset= -32 (14) */
#else
/* 32 */
                0x16,           /* FC_PSTRUCT */
                0x3,            /* 3 */
/* 34 */        NdrFcShort( 0xc ),      /* 12 */
/* 36 */        0x4b,           /* FC_PP */
                0x5c,           /* FC_PAD */
/* 38 */        0x46,           /* FC_NO_REPEAT */
                0x5c,           /* FC_PAD */
/* 40 */        NdrFcShort( 0x8 ),      /* 8 */
/* 42 */        NdrFcShort( 0x8 ),      /* 8 */
/* 44 */        0x12, 0x0,      /* FC_UP */
/* 46 */        NdrFcShort( 0xffe0 ),   /* Offset= -32 (14) */
/* 48 */        0x5b,           /* FC_END */
                0x8,            /* FC_LONG */
/* 50 */        0x8,            /* FC_LONG */
                0x8,            /* FC_LONG */
/* 52 */        0x5c,           /* FC_PAD */
                0x5b,           /* FC_END */
#endif
    };
 
    memsrc.dim1 = 5;
    memsrc.dim2 = 3;
 
    memsrc.array = calloc(memsrc.dim1, sizeof(DWORD *));
 
    for(i = 0; i < memsrc.dim1; i++)
    {
        memsrc.array[i] = calloc(memsrc.dim2, sizeof(DWORD));
        for(j = 0; j < memsrc.dim2; j++)
            memsrc.array[i][j] = i * memsrc.dim2 + j;
    }
 
    StubDesc = Object_StubDesc;
    StubDesc.pFormatTypes = fmtstr_complex_array;
 
    NdrClientInitializeNew(
                           &RpcMessage,
                           &StubMsg,
                           &StubDesc,
                           0);
 
    StubMsg.BufferLength = 0;
 
#ifdef _WIN64
    NdrComplexStructBufferSize( &StubMsg,
                                (unsigned char *)&memsrc,
                                &fmtstr_complex_array[32] );
#else
    NdrSimpleStructBufferSize( &StubMsg,
                                (unsigned char *)&memsrc,
                                &fmtstr_complex_array[32] );
#endif
 
    expected_length = (4 + memsrc.dim1 * (2 + memsrc.dim2)) * 4;
    ok(StubMsg.BufferLength >= expected_length, "length %ld\n", StubMsg.BufferLength);
 
    /*NdrGetBuffer(&_StubMsg, _StubMsg.BufferLength, NULL);*/
    StubMsg.RpcMsg->Buffer = StubMsg.BufferStart = StubMsg.Buffer = NdrOleAllocate(StubMsg.BufferLength);
    StubMsg.BufferEnd = StubMsg.BufferStart + StubMsg.BufferLength;
 
#ifdef _WIN64
    ptr = NdrComplexStructMarshall( &StubMsg, (unsigned char *)&memsrc,
                                    &fmtstr_complex_array[32] );
#else
    ptr = NdrSimpleStructMarshall( &StubMsg, (unsigned char *)&memsrc,
                                    &fmtstr_complex_array[32] );
#endif
 
    ok(ptr == NULL, "ret %p\n", ptr);
    ok((char*)StubMsg.Buffer == (char*)StubMsg.BufferStart + expected_length, "not at expected length\n");
 
    buf = (DWORD *)StubMsg.BufferStart;
 
    ok(*buf == memsrc.dim1, "dim1 should have been %d instead of %08lx\n", memsrc.dim1, *buf);
    buf++;
    ok(*buf == memsrc.dim2, "dim2 should have been %d instead of %08lx\n", memsrc.dim2, *buf);
    buf++;
    ok(*buf != 0, "pointer id should be non-zero\n");
    buf++;
    ok(*buf == memsrc.dim1, "Conformance should have been %d instead of %08lx\n", memsrc.dim1, *buf);
    buf++;
    for(i = 0; i < memsrc.dim1; i++)
    {
        ok(*buf != 0, "pointer id[%d] should be non-zero\n", i);
        buf++;
    }
    for(i = 0; i < memsrc.dim1; i++)
    {
        ok(*buf == memsrc.dim2, "Conformance should have been %d instead of %08lx\n", memsrc.dim2, *buf);
        buf++;
        for(j = 0; j < memsrc.dim2; j++)
        {
            ok(*buf == i * memsrc.dim2 + j, "got %08lx\n", *buf);
            buf++;
        }
    }
 
    ok((void*)buf == StubMsg.Buffer, "not at end of buffer\n");
 
    /* Server */
    my_alloc_called = 0;
    StubMsg.IsClient = 0;
    mem = NULL;
    StubMsg.Buffer = StubMsg.BufferStart;
#ifdef _WIN64
    ptr = NdrComplexStructUnmarshall( &StubMsg, (unsigned char **)&mem, &fmtstr_complex_array[32], 0);
#else
    ptr = NdrSimpleStructUnmarshall( &StubMsg, (unsigned char **)&mem, &fmtstr_complex_array[32], 0);
#endif
    ok(ptr == NULL, "ret %p\n", ptr);
    ok(mem->dim1 == memsrc.dim1, "mem->dim1 wasn't unmarshalled correctly (%d)\n", mem->dim1);
    ok(mem->dim2 == memsrc.dim2, "mem->dim2 wasn't unmarshalled correctly (%d)\n", mem->dim2);
    ok(mem->array[1][0] == memsrc.dim2, "mem->array[1][0] wasn't unmarshalled correctly (%ld)\n", mem->array[1][0]);
 
    StubMsg.Buffer = StubMsg.BufferStart;
#ifdef _WIN64
    NdrComplexStructFree( &StubMsg, (unsigned char*)mem, &fmtstr_complex_array[32]);
#else
    NdrSimpleStructFree( &StubMsg, (unsigned char*)mem, &fmtstr_complex_array[32]);
#endif
 
    NdrOleFree(StubMsg.RpcMsg->Buffer);
 
    for(i = 0; i < memsrc.dim1; i++)
        free(memsrc.array[i]);
    free(memsrc.array);
}
 
static void test_ndr_buffer(void)
{
    static unsigned char ncalrpc[] = "ncalrpc";
    static unsigned char endpoint[] = "winetest:test_ndr_buffer";
    RPC_MESSAGE RpcMessage;
    MIDL_STUB_MESSAGE StubMsg;
    MIDL_STUB_DESC StubDesc = Object_StubDesc;
    unsigned char *ret;
    unsigned char *binding;
    RPC_BINDING_HANDLE Handle;
    RPC_STATUS status;
    ULONG prev_buffer_length;
    BOOL old_buffer_valid_location;
 
    StubDesc.RpcInterfaceInformation = (void *)&IFoo___RpcServerInterface;
 
    status = RpcServerUseProtseqEpA(ncalrpc, 20, endpoint, NULL);
    ok(RPC_S_OK == status, "RpcServerUseProtseqEp failed with status %lu\n", status);
    status = RpcServerRegisterIf(IFoo_v0_0_s_ifspec, NULL, NULL);
    ok(RPC_S_OK == status, "RpcServerRegisterIf failed with status %lu\n", status);
    status = RpcServerListen(1, 20, TRUE);
    ok(RPC_S_OK == status, "RpcServerListen failed with status %lu\n", status);
    if (status != RPC_S_OK)
    {
        /* Failed to create a server, running client tests is useless */
        return;
    }
 
    status = RpcStringBindingComposeA(NULL, ncalrpc, NULL, endpoint, NULL, &binding);
    ok(status == RPC_S_OK, "RpcStringBindingCompose failed (%lu)\n", status);
 
    status = RpcBindingFromStringBindingA(binding, &Handle);
    ok(status == RPC_S_OK, "RpcBindingFromStringBinding failed (%lu)\n", status);
    RpcStringFreeA(&binding);
 
    NdrClientInitializeNew(&RpcMessage, &StubMsg, &StubDesc, 5);
 
    my_alloc_called = 0;
    ret = NdrGetBuffer(&StubMsg, 10, Handle);
    ok(!my_alloc_called, "my_alloc got called\n");
    ok(ret == StubMsg.Buffer, "NdrGetBuffer should have returned the same value as StubMsg.Buffer instead of %p\n", ret);
    ok(RpcMessage.Handle != NULL, "RpcMessage.Handle should not have been NULL\n");
    ok(RpcMessage.Buffer != NULL, "RpcMessage.Buffer should not have been NULL\n");
    ok(RpcMessage.BufferLength == 10 ||
       broken(RpcMessage.BufferLength == 12), /* win2k */
       "RpcMessage.BufferLength should have been 10 instead of %d\n", RpcMessage.BufferLength);
    ok(RpcMessage.RpcFlags == 0, "RpcMessage.RpcFlags should have been 0x0 instead of 0x%lx\n", RpcMessage.RpcFlags);
    ok(StubMsg.Buffer != NULL, "Buffer should not have been NULL\n");
    ok(!StubMsg.BufferStart, "BufferStart should have been NULL instead of %p\n", StubMsg.BufferStart);
    ok(!StubMsg.BufferEnd, "BufferEnd should have been NULL instead of %p\n", StubMsg.BufferEnd);
    todo_wine
    ok(StubMsg.BufferLength == 0, "BufferLength should have left as 0 instead of being set to %ld\n", StubMsg.BufferLength);
    old_buffer_valid_location = !StubMsg.fBufferValid;
    if (old_buffer_valid_location)
        ok(broken(StubMsg.CorrDespIncrement == TRUE), "fBufferValid should have been TRUE instead of 0x%x\n", StubMsg.CorrDespIncrement);
    else
        ok(StubMsg.fBufferValid, "fBufferValid should have been non-zero instead of 0x%x\n", StubMsg.fBufferValid);
 
    prev_buffer_length = RpcMessage.BufferLength;
    StubMsg.BufferLength = 1;
    my_free_called = 0;
    NdrFreeBuffer(&StubMsg);
    ok(!my_free_called, "my_free got called\n");
    ok(RpcMessage.Handle != NULL, "RpcMessage.Handle should not have been NULL\n");
    ok(RpcMessage.Buffer != NULL, "RpcMessage.Buffer should not have been NULL\n");
    ok(RpcMessage.BufferLength == prev_buffer_length, "RpcMessage.BufferLength should have been left as %ld instead of %d\n", prev_buffer_length, RpcMessage.BufferLength);
    ok(StubMsg.Buffer != NULL, "Buffer should not have been NULL\n");
    ok(StubMsg.BufferLength == 1, "BufferLength should have left as 1 instead of being set to %ld\n", StubMsg.BufferLength);
    if (old_buffer_valid_location)
        ok(broken(StubMsg.CorrDespIncrement == FALSE), "fBufferValid should have been FALSE instead of 0x%x\n", StubMsg.CorrDespIncrement);
    else
        ok(!StubMsg.fBufferValid, "fBufferValid should have been FALSE instead of %d\n", StubMsg.fBufferValid);
 
    /* attempt double-free */
    NdrFreeBuffer(&StubMsg);
 
    RpcBindingFree(&Handle);
 
    status = RpcServerUnregisterIf(NULL, NULL, FALSE);
    ok(status == RPC_S_OK, "RpcServerUnregisterIf failed (%lu)\n", status);
}
 
static void test_NdrMapCommAndFaultStatus(void)
{
    RPC_STATUS rpc_status;
    MIDL_STUB_MESSAGE StubMsg;
    RPC_MESSAGE RpcMessage;
 
    NdrClientInitializeNew(&RpcMessage, &StubMsg, &Object_StubDesc, 5);
 
    for (rpc_status = 0; rpc_status < 10000; rpc_status++)
    {
        RPC_STATUS status;
        ULONG comm_status = 0;
        ULONG fault_status = 0;
        ULONG expected_comm_status = 0;
        ULONG expected_fault_status = 0;
        status = NdrMapCommAndFaultStatus(&StubMsg, &comm_status, &fault_status, rpc_status);
        ok(status == RPC_S_OK, "NdrMapCommAndFaultStatus failed with error %ld\n", status);
        switch (rpc_status)
        {
        case ERROR_INVALID_HANDLE:
        case RPC_S_INVALID_BINDING:
        case RPC_S_UNKNOWN_IF:
        case RPC_S_SERVER_UNAVAILABLE:
        case RPC_S_SERVER_TOO_BUSY:
        case RPC_S_CALL_FAILED_DNE:
        case RPC_S_PROTOCOL_ERROR:
        case RPC_S_UNSUPPORTED_TRANS_SYN:
        case RPC_S_UNSUPPORTED_TYPE:
        case RPC_S_PROCNUM_OUT_OF_RANGE:
        case EPT_S_NOT_REGISTERED:
        case RPC_S_COMM_FAILURE:
            expected_comm_status = rpc_status;
            break;
        default:
            expected_fault_status = rpc_status;
        }
        ok(comm_status == expected_comm_status, "NdrMapCommAndFaultStatus should have mapped %ld to comm status %ld instead of %ld\n",
            rpc_status, expected_comm_status, comm_status);
        ok(fault_status == expected_fault_status, "NdrMapCommAndFaultStatus should have mapped %ld to fault status %ld instead of %ld\n",
            rpc_status, expected_fault_status, fault_status);
    }
}
 
static void test_NdrGetUserMarshalInfo(void)
{
    RPC_STATUS status;
    MIDL_STUB_MESSAGE stubmsg;
    USER_MARSHAL_CB umcb;
    NDR_USER_MARSHAL_INFO umi;
    unsigned char buffer[16];
    void *rpc_channel_buffer = (void *)(ULONG_PTR)0xcafebabe;
    RPC_MESSAGE rpc_msg;
 
    /* unmarshall */
 
    memset(&rpc_msg, 0xcc, sizeof(rpc_msg));
    rpc_msg.Buffer = buffer;
    rpc_msg.BufferLength = 16;
 
    memset(&stubmsg, 0xcc, sizeof(stubmsg));
    stubmsg.RpcMsg = &rpc_msg;
    stubmsg.dwDestContext = MSHCTX_INPROC;
    stubmsg.pvDestContext = NULL;
    stubmsg.Buffer = buffer + 15;
    stubmsg.BufferLength = 0;
    stubmsg.BufferEnd = NULL;
    stubmsg.pRpcChannelBuffer = rpc_channel_buffer;
    stubmsg.StubDesc = NULL;
    stubmsg.pfnAllocate = my_alloc;
    stubmsg.pfnFree = my_free;
 
    memset(&umcb, 0xcc, sizeof(umcb));
    umcb.Flags = MAKELONG(MSHCTX_INPROC, NDR_LOCAL_DATA_REPRESENTATION);
    umcb.pStubMsg = &stubmsg;
    umcb.Signature = USER_MARSHAL_CB_SIGNATURE;
    umcb.CBType = USER_MARSHAL_CB_UNMARSHALL;
 
    memset(&umi, 0xaa, sizeof(umi));
 
    status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
    ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %ld\n", status);
    ok( umi.InformationLevel == 1,
       "umi.InformationLevel was %lu instead of 1\n",
        umi.InformationLevel);
    ok( umi.Level1.Buffer == buffer + 15,
       "umi.Level1.Buffer was %p instead of %p\n",
        umi.Level1.Buffer, buffer);
    ok( umi.Level1.BufferSize == 1,
       "umi.Level1.BufferSize was %lu instead of 1\n",
        umi.Level1.BufferSize);
    ok( umi.Level1.pfnAllocate == my_alloc,
       "umi.Level1.pfnAllocate was %p instead of %p\n",
        umi.Level1.pfnAllocate, my_alloc);
    ok( umi.Level1.pfnFree == my_free,
       "umi.Level1.pfnFree was %p instead of %p\n",
        umi.Level1.pfnFree, my_free);
    ok( umi.Level1.pRpcChannelBuffer == rpc_channel_buffer,
       "umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
        umi.Level1.pRpcChannelBuffer, rpc_channel_buffer);
 
    /* buffer size */
 
    rpc_msg.Buffer = buffer;
    rpc_msg.BufferLength = 16;
 
    stubmsg.Buffer = buffer;
    stubmsg.BufferLength = 16;
    stubmsg.BufferEnd = NULL;
 
    umcb.CBType = USER_MARSHAL_CB_BUFFER_SIZE;
 
    memset(&umi, 0xaa, sizeof(umi));
 
    status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
    ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %ld\n", status);
    ok( umi.InformationLevel == 1,
       "umi.InformationLevel was %lu instead of 1\n",
        umi.InformationLevel);
    ok( umi.Level1.Buffer == NULL,
       "umi.Level1.Buffer was %p instead of NULL\n",
        umi.Level1.Buffer);
    ok( umi.Level1.BufferSize == 0,
       "umi.Level1.BufferSize was %lu instead of 0\n",
        umi.Level1.BufferSize);
    ok( umi.Level1.pfnAllocate == my_alloc,
       "umi.Level1.pfnAllocate was %p instead of %p\n",
        umi.Level1.pfnAllocate, my_alloc);
    ok( umi.Level1.pfnFree == my_free,
       "umi.Level1.pfnFree was %p instead of %p\n",
        umi.Level1.pfnFree, my_free);
    ok( umi.Level1.pRpcChannelBuffer == rpc_channel_buffer,
       "umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
        umi.Level1.pRpcChannelBuffer, rpc_channel_buffer);
 
    /* marshall */
 
    rpc_msg.Buffer = buffer;
    rpc_msg.BufferLength = 16;
 
    stubmsg.Buffer = buffer + 15;
    stubmsg.BufferLength = 0;
    stubmsg.BufferEnd = NULL;
 
    umcb.CBType = USER_MARSHAL_CB_MARSHALL;
 
    memset(&umi, 0xaa, sizeof(umi));
 
    status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
    ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %ld\n", status);
    ok( umi.InformationLevel == 1,
       "umi.InformationLevel was %lu instead of 1\n",
        umi.InformationLevel);
    ok( umi.Level1.Buffer == buffer + 15,
       "umi.Level1.Buffer was %p instead of %p\n",
        umi.Level1.Buffer, buffer);
    ok( umi.Level1.BufferSize == 1,
       "umi.Level1.BufferSize was %lu instead of 1\n",
        umi.Level1.BufferSize);
    ok( umi.Level1.pfnAllocate == my_alloc,
       "umi.Level1.pfnAllocate was %p instead of %p\n",
        umi.Level1.pfnAllocate, my_alloc);
    ok( umi.Level1.pfnFree == my_free,
       "umi.Level1.pfnFree was %p instead of %p\n",
        umi.Level1.pfnFree, my_free);
    ok( umi.Level1.pRpcChannelBuffer == rpc_channel_buffer,
       "umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
        umi.Level1.pRpcChannelBuffer, rpc_channel_buffer);
 
    /* free */
 
    rpc_msg.Buffer = buffer;
    rpc_msg.BufferLength = 16;
 
    stubmsg.Buffer = buffer;
    stubmsg.BufferLength = 16;
    stubmsg.BufferEnd = NULL;
 
    umcb.CBType = USER_MARSHAL_CB_FREE;
 
    memset(&umi, 0xaa, sizeof(umi));
 
    status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
    ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %ld\n", status);
    ok( umi.InformationLevel == 1,
       "umi.InformationLevel was %lu instead of 1\n",
        umi.InformationLevel);
    ok( umi.Level1.Buffer == NULL,
       "umi.Level1.Buffer was %p instead of NULL\n",
        umi.Level1.Buffer);
    ok( umi.Level1.BufferSize == 0,
       "umi.Level1.BufferSize was %lu instead of 0\n",
        umi.Level1.BufferSize);
    ok( umi.Level1.pfnAllocate == my_alloc,
       "umi.Level1.pfnAllocate was %p instead of %p\n",
        umi.Level1.pfnAllocate, my_alloc);
    ok( umi.Level1.pfnFree == my_free,
       "umi.Level1.pfnFree was %p instead of %p\n",
        umi.Level1.pfnFree, my_free);
    ok( umi.Level1.pRpcChannelBuffer == rpc_channel_buffer,
       "umi.Level1.pRpcChannelBuffer was %p instead of %p\n",
        umi.Level1.pRpcChannelBuffer, rpc_channel_buffer);
 
    /* boundary test */
 
    rpc_msg.Buffer = buffer;
    rpc_msg.BufferLength = 15;
 
    stubmsg.Buffer = buffer + 15;
    stubmsg.BufferLength = 0;
    stubmsg.BufferEnd = NULL;
 
    umcb.CBType = USER_MARSHAL_CB_MARSHALL;
 
    status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
    ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %ld\n", status);
    ok( umi.Level1.BufferSize == 0,
       "umi.Level1.BufferSize was %lu instead of 0\n",
        umi.Level1.BufferSize);
 
    /* error conditions */
 
    rpc_msg.BufferLength = 14;
    status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
    ok(status == ERROR_INVALID_USER_BUFFER,
        "NdrGetUserMarshalInfo should have failed with ERROR_INVALID_USER_BUFFER instead of %ld\n", status);
 
    rpc_msg.BufferLength = 15;
    status = NdrGetUserMarshalInfo(&umcb.Flags, 9999, &umi);
    ok(status == RPC_S_INVALID_ARG,
        "NdrGetUserMarshalInfo should have failed with RPC_S_INVALID_ARG instead of %ld\n", status);
 
    umcb.CBType = 9999;
    status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
    ok(status == RPC_S_OK, "NdrGetUserMarshalInfo failed with error %ld\n", status);
 
    umcb.CBType = USER_MARSHAL_CB_MARSHALL;
    umcb.Signature = 0;
    status = NdrGetUserMarshalInfo(&umcb.Flags, 1, &umi);
    ok(status == RPC_S_INVALID_ARG,
        "NdrGetUserMarshalInfo should have failed with RPC_S_INVALID_ARG instead of %ld\n", status);
}
 
static void test_MesEncodeFixedBufferHandleCreate(void)
{
    ULONG encoded_size;
    RPC_STATUS status;
    handle_t handle;
    char *buffer;
 
    status = MesEncodeFixedBufferHandleCreate(NULL, 0, NULL, NULL);
    ok(status == RPC_S_INVALID_ARG, "got %ld\n", status);
 
    status = MesEncodeFixedBufferHandleCreate(NULL, 0, NULL, &handle);
    ok(status == RPC_S_INVALID_ARG, "got %ld\n", status);
 
    status = MesEncodeFixedBufferHandleCreate((char*)0xdeadbeef, 0, NULL, &handle);
    ok(status == RPC_X_INVALID_BUFFER, "got %ld\n", status);
 
    buffer = (void*)((0xdeadbeef + 7) & ~7);
    status = MesEncodeFixedBufferHandleCreate(buffer, 0, NULL, &handle);
    ok(status == RPC_S_INVALID_ARG, "got %ld\n", status);
 
    status = MesEncodeFixedBufferHandleCreate(buffer, 0, &encoded_size, &handle);
    todo_wine
    ok(status == RPC_S_INVALID_ARG, "got %ld\n", status);
if (status == RPC_S_OK) {
    MesHandleFree(handle);
}
    status = MesEncodeFixedBufferHandleCreate(buffer, 32, NULL, &handle);
    ok(status == RPC_S_INVALID_ARG, "got %ld\n", status);
 
    status = MesEncodeFixedBufferHandleCreate(buffer, 32, &encoded_size, &handle);
    ok(status == RPC_S_OK, "got %ld\n", status);
 
    status = MesBufferHandleReset(NULL, MES_DYNAMIC_BUFFER_HANDLE, MES_ENCODE,
        &buffer, 32, &encoded_size);
    ok(status == RPC_S_INVALID_ARG, "got %ld\n", status);
 
    /* convert to dynamic buffer handle */
    status = MesBufferHandleReset(handle, MES_DYNAMIC_BUFFER_HANDLE, MES_ENCODE,
        &buffer, 32, &encoded_size);
    ok(status == RPC_S_OK, "got %ld\n", status);
 
    status = MesBufferHandleReset(handle, MES_DYNAMIC_BUFFER_HANDLE, MES_ENCODE,
        NULL, 32, &encoded_size);
    ok(status == RPC_S_INVALID_ARG, "got %ld\n", status);
 
    status = MesBufferHandleReset(handle, MES_DYNAMIC_BUFFER_HANDLE, MES_ENCODE,
        &buffer, 32, NULL);
    ok(status == RPC_S_INVALID_ARG, "got %ld\n", status);
 
    /* invalid handle type */
    status = MesBufferHandleReset(handle, MES_DYNAMIC_BUFFER_HANDLE+1, MES_ENCODE,
        &buffer, 32, &encoded_size);
    ok(status == RPC_S_INVALID_ARG, "got %ld\n", status);
 
    status = MesHandleFree(handle);
    ok(status == RPC_S_OK, "got %ld\n", status);
}
 
static void test_NdrCorrelationInitialize(void)
{
    MIDL_STUB_MESSAGE stub_msg;
    BYTE buf[256];
 
    memset( &stub_msg, 0, sizeof(stub_msg) );
    memset( buf, 0, sizeof(buf) );
 
    NdrCorrelationInitialize( &stub_msg, buf, sizeof(buf), 0 );
    ok( stub_msg.CorrDespIncrement == 2 ||
        broken(stub_msg.CorrDespIncrement == 0), /* <= Win 2003 */
        "got %d\n", stub_msg.CorrDespIncrement );
 
    memset( &stub_msg, 0, sizeof(stub_msg) );
    memset( buf, 0, sizeof(buf) );
 
    stub_msg.CorrDespIncrement = 1;
    NdrCorrelationInitialize( &stub_msg, buf, sizeof(buf), 0 );
    ok( stub_msg.CorrDespIncrement == 1, "got %d\n", stub_msg.CorrDespIncrement );
}
 
START_TEST( ndr_marshall )
{
    determine_pointer_marshalling_style();
 
    test_ndr_simple_type();
    test_simple_types();
    test_nontrivial_pointer_types();
    test_simple_struct();
    test_struct_align();
    test_iface_ptr();
    test_fullpointer_xlat();
    test_client_init();
    test_server_init();
    test_ndr_allocate();
    test_conformant_array();
    test_conformant_string();
    test_nonconformant_string();
    test_conf_complex_struct();
    test_conf_complex_array();
    test_ndr_buffer();
    test_NdrMapCommAndFaultStatus();
    test_NdrGetUserMarshalInfo();
    test_MesEncodeFixedBufferHandleCreate();
    test_NdrCorrelationInitialize();
}