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

   1 /*
   2  * NDR data marshalling
   3  *
   4  * Copyright 2002 Greg Turner
   5  * Copyright 2003-2006 CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  * TODO:
  22  *  - String structs
  23  *  - Byte count pointers
  24  *  - transmit_as/represent as
  25  *  - Multi-dimensional arrays
  26  *  - Conversion functions (NdrConvert)
  27  *  - Checks for integer addition overflow in user marshall functions
  28  */
  29
  30 #include <stdarg.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <limits.h>
  34
  35 #define NONAMELESSUNION
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "winerror.h"
  39
  40 #include "ndr_misc.h"
  41 #include "rpcndr.h"
  42 #include "ndrtypes.h"
  43
  44 #include "wine/unicode.h"
  45 #include "wine/rpcfc.h"
  46
  47 #include "wine/debug.h"
  48
  49 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  50
  51 #if defined(__i386__)
  52 # define LITTLE_ENDIAN_UINT32_WRITE(pchar, uint32) \
  53     (*((UINT32 *)(pchar)) = (uint32))
  54
  55 # define LITTLE_ENDIAN_UINT32_READ(pchar) \
  56     (*((UINT32 *)(pchar)))
  57 #else
  58   /* these would work for i386 too, but less efficient */
  59 # define LITTLE_ENDIAN_UINT32_WRITE(pchar, uint32) \
  60     (*(pchar)     = LOBYTE(LOWORD(uint32)), \
  61      *((pchar)+1) = HIBYTE(LOWORD(uint32)), \
  62      *((pchar)+2) = LOBYTE(HIWORD(uint32)), \
  63      *((pchar)+3) = HIBYTE(HIWORD(uint32)))
  64
  65 # define LITTLE_ENDIAN_UINT32_READ(pchar) \
  66     (MAKELONG( \
  67       MAKEWORD(*(pchar), *((pchar)+1)), \
  68       MAKEWORD(*((pchar)+2), *((pchar)+3))))
  69 #endif
  70
  71 #define BIG_ENDIAN_UINT32_WRITE(pchar, uint32) \
  72   (*((pchar)+3) = LOBYTE(LOWORD(uint32)), \
  73    *((pchar)+2) = HIBYTE(LOWORD(uint32)), \
  74    *((pchar)+1) = LOBYTE(HIWORD(uint32)), \
  75    *(pchar)     = HIBYTE(HIWORD(uint32)))
  76
  77 #define BIG_ENDIAN_UINT32_READ(pchar) \
  78   (MAKELONG( \
  79     MAKEWORD(*((pchar)+3), *((pchar)+2)), \
  80     MAKEWORD(*((pchar)+1), *(pchar))))
  81
  82 #ifdef NDR_LOCAL_IS_BIG_ENDIAN
  83 # define NDR_LOCAL_UINT32_WRITE(pchar, uint32) \
  84     BIG_ENDIAN_UINT32_WRITE(pchar, uint32)
  85 # define NDR_LOCAL_UINT32_READ(pchar) \
  86     BIG_ENDIAN_UINT32_READ(pchar)
  87 #else
  88 # define NDR_LOCAL_UINT32_WRITE(pchar, uint32) \
  89     LITTLE_ENDIAN_UINT32_WRITE(pchar, uint32)
  90 # define NDR_LOCAL_UINT32_READ(pchar) \
  91     LITTLE_ENDIAN_UINT32_READ(pchar)
  92 #endif
  93
  94 /* _Align must be the desired alignment,
  95  * e.g. ALIGN_LENGTH(len, 4) to align on a dword boundary. */
  96 #define ALIGNED_LENGTH(_Len, _Align) (((_Len)+(_Align)-1)&~((_Align)-1))
  97 #define ALIGNED_POINTER(_Ptr, _Align) ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
  98 #define ALIGN_LENGTH(_Len, _Align) _Len = ALIGNED_LENGTH(_Len, _Align)
  99 #define ALIGN_POINTER(_Ptr, _Align) _Ptr = ALIGNED_POINTER(_Ptr, _Align)
 100 #define ALIGN_POINTER_CLEAR(_Ptr, _Align) \
 101     do { \
 102         memset((_Ptr), 0, ((_Align) - (ULONG_PTR)(_Ptr)) & ((_Align) - 1)); \
 103         ALIGN_POINTER(_Ptr, _Align); \
 104     } while(0)
 105
 106 #define STD_OVERFLOW_CHECK(_Msg) do { \
 107     TRACE("buffer=%d/%d\n", (ULONG)(_Msg->Buffer - (unsigned char *)_Msg->RpcMsg->Buffer), _Msg->BufferLength); \
 108     if (_Msg->Buffer > (unsigned char *)_Msg->RpcMsg->Buffer + _Msg->BufferLength) \
 109         ERR("buffer overflow %d bytes\n", (ULONG)(_Msg->Buffer - ((unsigned char *)_Msg->RpcMsg->Buffer + _Msg->BufferLength))); \
 110   } while (0)
 111
 112 #define NDR_POINTER_ID_BASE 0x20000
 113 #define NDR_POINTER_ID(pStubMsg) (NDR_POINTER_ID_BASE + ((pStubMsg)->UniquePtrCount++) * 4)
 114 #define NDR_TABLE_SIZE 128
 115 #define NDR_TABLE_MASK 127
 116
 117 #define NDRSContextFromValue(user_context) (NDR_SCONTEXT)((char *)(user_context) - (char *)NDRSContextValue((NDR_SCONTEXT)NULL))
 118
 119 static unsigned char *WINAPI NdrBaseTypeMarshall(PMIDL_STUB_MESSAGE, unsigned char *, PFORMAT_STRING);
 120 static unsigned char *WINAPI NdrBaseTypeUnmarshall(PMIDL_STUB_MESSAGE, unsigned char **, PFORMAT_STRING, unsigned char);
 121 static void WINAPI NdrBaseTypeBufferSize(PMIDL_STUB_MESSAGE, unsigned char *, PFORMAT_STRING);
 122 static void WINAPI NdrBaseTypeFree(PMIDL_STUB_MESSAGE, unsigned char *, PFORMAT_STRING);
 123 static ULONG WINAPI NdrBaseTypeMemorySize(PMIDL_STUB_MESSAGE, PFORMAT_STRING);
 124
 125 static unsigned char *WINAPI NdrContextHandleMarshall(PMIDL_STUB_MESSAGE, unsigned char *, PFORMAT_STRING);
 126 static void WINAPI NdrContextHandleBufferSize(PMIDL_STUB_MESSAGE, unsigned char *, PFORMAT_STRING);
 127 static unsigned char *WINAPI NdrContextHandleUnmarshall(PMIDL_STUB_MESSAGE, unsigned char **, PFORMAT_STRING, unsigned char);
 128
 129 static unsigned char *WINAPI NdrRangeMarshall(PMIDL_STUB_MESSAGE,unsigned char *, PFORMAT_STRING);
 130 static void WINAPI NdrRangeBufferSize(PMIDL_STUB_MESSAGE, unsigned char *, PFORMAT_STRING);
 131 static ULONG WINAPI NdrRangeMemorySize(PMIDL_STUB_MESSAGE, PFORMAT_STRING);
 132 static void WINAPI NdrRangeFree(PMIDL_STUB_MESSAGE, unsigned char *, PFORMAT_STRING);
 133
 134 static ULONG WINAPI NdrByteCountPointerMemorySize(PMIDL_STUB_MESSAGE, PFORMAT_STRING);
 135
 136 const NDR_MARSHALL NdrMarshaller[NDR_TABLE_SIZE] = {
 137   0,
 138   NdrBaseTypeMarshall, NdrBaseTypeMarshall, NdrBaseTypeMarshall,
 139   NdrBaseTypeMarshall, NdrBaseTypeMarshall, NdrBaseTypeMarshall, NdrBaseTypeMarshall,
 140   NdrBaseTypeMarshall, NdrBaseTypeMarshall, NdrBaseTypeMarshall, NdrBaseTypeMarshall,
 141   NdrBaseTypeMarshall, NdrBaseTypeMarshall, NdrBaseTypeMarshall, NdrBaseTypeMarshall,
 142   /* 0x10 */
 143   NdrBaseTypeMarshall,
 144   /* 0x11 */
 145   NdrPointerMarshall, NdrPointerMarshall,
 146   NdrPointerMarshall, NdrPointerMarshall,
 147   /* 0x15 */
 148   NdrSimpleStructMarshall, NdrSimpleStructMarshall,
 149   NdrConformantStructMarshall, NdrConformantStructMarshall,
 150   NdrConformantVaryingStructMarshall,
 151   NdrComplexStructMarshall,
 152   /* 0x1b */
 153   NdrConformantArrayMarshall,
 154   NdrConformantVaryingArrayMarshall,
 155   NdrFixedArrayMarshall, NdrFixedArrayMarshall,
 156   NdrVaryingArrayMarshall, NdrVaryingArrayMarshall,
 157   NdrComplexArrayMarshall,
 158   /* 0x22 */
 159   NdrConformantStringMarshall, 0, 0,
 160   NdrConformantStringMarshall,
 161   NdrNonConformantStringMarshall, 0, 0, 0,
 162   /* 0x2a */
 163   NdrEncapsulatedUnionMarshall,
 164   NdrNonEncapsulatedUnionMarshall,
 165   NdrByteCountPointerMarshall,
 166   NdrXmitOrRepAsMarshall, NdrXmitOrRepAsMarshall,
 167   /* 0x2f */
 168   NdrInterfacePointerMarshall,
 169   /* 0x30 */
 170   NdrContextHandleMarshall,
 171   /* 0xb1 */
 172   0, 0, 0,
 173   NdrUserMarshalMarshall,
 174   0, 0,
 175   /* 0xb7 */
 176   NdrRangeMarshall
 177 };
 178 const NDR_UNMARSHALL NdrUnmarshaller[NDR_TABLE_SIZE] = {
 179   0,
 180   NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall,
 181   NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall,
 182   NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall,
 183   NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall,
 184   /* 0x10 */
 185   NdrBaseTypeUnmarshall,
 186   /* 0x11 */
 187   NdrPointerUnmarshall, NdrPointerUnmarshall,
 188   NdrPointerUnmarshall, NdrPointerUnmarshall,
 189   /* 0x15 */
 190   NdrSimpleStructUnmarshall, NdrSimpleStructUnmarshall,
 191   NdrConformantStructUnmarshall, NdrConformantStructUnmarshall,
 192   NdrConformantVaryingStructUnmarshall,
 193   NdrComplexStructUnmarshall,
 194   /* 0x1b */
 195   NdrConformantArrayUnmarshall,
 196   NdrConformantVaryingArrayUnmarshall,
 197   NdrFixedArrayUnmarshall, NdrFixedArrayUnmarshall,
 198   NdrVaryingArrayUnmarshall, NdrVaryingArrayUnmarshall,
 199   NdrComplexArrayUnmarshall,
 200   /* 0x22 */
 201   NdrConformantStringUnmarshall, 0, 0,
 202   NdrConformantStringUnmarshall,
 203   NdrNonConformantStringUnmarshall, 0, 0, 0,
 204   /* 0x2a */
 205   NdrEncapsulatedUnionUnmarshall,
 206   NdrNonEncapsulatedUnionUnmarshall,
 207   NdrByteCountPointerUnmarshall,
 208   NdrXmitOrRepAsUnmarshall, NdrXmitOrRepAsUnmarshall,
 209   /* 0x2f */
 210   NdrInterfacePointerUnmarshall,
 211   /* 0x30 */
 212   NdrContextHandleUnmarshall,
 213   /* 0xb1 */
 214   0, 0, 0,
 215   NdrUserMarshalUnmarshall,
 216   0, 0,
 217   /* 0xb7 */
 218   NdrRangeUnmarshall
 219 };
 220 const NDR_BUFFERSIZE NdrBufferSizer[NDR_TABLE_SIZE] = {
 221   0,
 222   NdrBaseTypeBufferSize, NdrBaseTypeBufferSize, NdrBaseTypeBufferSize,
 223   NdrBaseTypeBufferSize, NdrBaseTypeBufferSize, NdrBaseTypeBufferSize, NdrBaseTypeBufferSize,
 224   NdrBaseTypeBufferSize, NdrBaseTypeBufferSize, NdrBaseTypeBufferSize, NdrBaseTypeBufferSize,
 225   NdrBaseTypeBufferSize, NdrBaseTypeBufferSize, NdrBaseTypeBufferSize, NdrBaseTypeBufferSize,
 226   /* 0x10 */
 227   NdrBaseTypeBufferSize,
 228   /* 0x11 */
 229   NdrPointerBufferSize, NdrPointerBufferSize,
 230   NdrPointerBufferSize, NdrPointerBufferSize,
 231   /* 0x15 */
 232   NdrSimpleStructBufferSize, NdrSimpleStructBufferSize,
 233   NdrConformantStructBufferSize, NdrConformantStructBufferSize,
 234   NdrConformantVaryingStructBufferSize,
 235   NdrComplexStructBufferSize,
 236   /* 0x1b */
 237   NdrConformantArrayBufferSize,
 238   NdrConformantVaryingArrayBufferSize,
 239   NdrFixedArrayBufferSize, NdrFixedArrayBufferSize,
 240   NdrVaryingArrayBufferSize, NdrVaryingArrayBufferSize,
 241   NdrComplexArrayBufferSize,
 242   /* 0x22 */
 243   NdrConformantStringBufferSize, 0, 0,
 244   NdrConformantStringBufferSize,
 245   NdrNonConformantStringBufferSize, 0, 0, 0,
 246   /* 0x2a */
 247   NdrEncapsulatedUnionBufferSize,
 248   NdrNonEncapsulatedUnionBufferSize,
 249   NdrByteCountPointerBufferSize,
 250   NdrXmitOrRepAsBufferSize, NdrXmitOrRepAsBufferSize,
 251   /* 0x2f */
 252   NdrInterfacePointerBufferSize,
 253   /* 0x30 */
 254   NdrContextHandleBufferSize,
 255   /* 0xb1 */
 256   0, 0, 0,
 257   NdrUserMarshalBufferSize,
 258   0, 0,
 259   /* 0xb7 */
 260   NdrRangeBufferSize
 261 };
 262 const NDR_MEMORYSIZE NdrMemorySizer[NDR_TABLE_SIZE] = {
 263   0,
 264   NdrBaseTypeMemorySize, NdrBaseTypeMemorySize, NdrBaseTypeMemorySize,
 265   NdrBaseTypeMemorySize, NdrBaseTypeMemorySize, NdrBaseTypeMemorySize, NdrBaseTypeMemorySize,
 266   NdrBaseTypeMemorySize, NdrBaseTypeMemorySize, NdrBaseTypeMemorySize, NdrBaseTypeMemorySize,
 267   NdrBaseTypeMemorySize, NdrBaseTypeMemorySize, NdrBaseTypeMemorySize, NdrBaseTypeMemorySize,
 268   /* 0x10 */
 269   NdrBaseTypeMemorySize,
 270   /* 0x11 */
 271   NdrPointerMemorySize, NdrPointerMemorySize,
 272   NdrPointerMemorySize, NdrPointerMemorySize,
 273   /* 0x15 */
 274   NdrSimpleStructMemorySize, NdrSimpleStructMemorySize,
 275   NdrConformantStructMemorySize, NdrConformantStructMemorySize,
 276   NdrConformantVaryingStructMemorySize,
 277   NdrComplexStructMemorySize,
 278   /* 0x1b */
 279   NdrConformantArrayMemorySize,
 280   NdrConformantVaryingArrayMemorySize,
 281   NdrFixedArrayMemorySize, NdrFixedArrayMemorySize,
 282   NdrVaryingArrayMemorySize, NdrVaryingArrayMemorySize,
 283   NdrComplexArrayMemorySize,
 284   /* 0x22 */
 285   NdrConformantStringMemorySize, 0, 0,
 286   NdrConformantStringMemorySize,
 287   NdrNonConformantStringMemorySize, 0, 0, 0,
 288   /* 0x2a */
 289   NdrEncapsulatedUnionMemorySize,
 290   NdrNonEncapsulatedUnionMemorySize,
 291   NdrByteCountPointerMemorySize,
 292   NdrXmitOrRepAsMemorySize, NdrXmitOrRepAsMemorySize,
 293   /* 0x2f */
 294   NdrInterfacePointerMemorySize,
 295   /* 0x30 */
 296   0,
 297   /* 0xb1 */
 298   0, 0, 0,
 299   NdrUserMarshalMemorySize,
 300   0, 0,
 301   /* 0xb7 */
 302   NdrRangeMemorySize
 303 };
 304 const NDR_FREE NdrFreer[NDR_TABLE_SIZE] = {
 305   0,
 306   NdrBaseTypeFree, NdrBaseTypeFree, NdrBaseTypeFree,
 307   NdrBaseTypeFree, NdrBaseTypeFree, NdrBaseTypeFree, NdrBaseTypeFree,
 308   NdrBaseTypeFree, NdrBaseTypeFree, NdrBaseTypeFree, NdrBaseTypeFree,
 309   NdrBaseTypeFree, NdrBaseTypeFree, NdrBaseTypeFree, NdrBaseTypeFree,
 310   /* 0x10 */
 311   NdrBaseTypeFree,
 312   /* 0x11 */
 313   NdrPointerFree, NdrPointerFree,
 314   NdrPointerFree, NdrPointerFree,
 315   /* 0x15 */
 316   NdrSimpleStructFree, NdrSimpleStructFree,
 317   NdrConformantStructFree, NdrConformantStructFree,
 318   NdrConformantVaryingStructFree,
 319   NdrComplexStructFree,
 320   /* 0x1b */
 321   NdrConformantArrayFree,
 322   NdrConformantVaryingArrayFree,
 323   NdrFixedArrayFree, NdrFixedArrayFree,
 324   NdrVaryingArrayFree, NdrVaryingArrayFree,
 325   NdrComplexArrayFree,
 326   /* 0x22 */
 327   0, 0, 0,
 328   0, 0, 0, 0, 0,
 329   /* 0x2a */
 330   NdrEncapsulatedUnionFree,
 331   NdrNonEncapsulatedUnionFree,
 332   0,
 333   NdrXmitOrRepAsFree, NdrXmitOrRepAsFree,
 334   /* 0x2f */
 335   NdrInterfacePointerFree,
 336   /* 0x30 */
 337   0,
 338   /* 0xb1 */
 339   0, 0, 0,
 340   NdrUserMarshalFree,
 341   0, 0,
 342   /* 0xb7 */
 343   NdrRangeFree
 344 };
 345
 346 typedef struct _NDR_MEMORY_LIST
 347 {
 348     ULONG magic;
 349     ULONG size;
 350     ULONG reserved;
 351     struct _NDR_MEMORY_LIST *next;
 352 } NDR_MEMORY_LIST;
 353
 354 #define MEML_MAGIC  ('M' << 24 | 'E' << 16 | 'M' << 8 | 'L')
 355
 356 /***********************************************************************
 357  *            NdrAllocate [RPCRT4.@]
 358  *
 359  * Allocates a block of memory using pStubMsg->pfnAllocate.
 360  *
 361  * PARAMS
 362  *  pStubMsg [I/O] MIDL_STUB_MESSAGE structure.
 363  *  len      [I]   Size of memory block to allocate.
 364  *
 365  * RETURNS
 366  *  The memory block of size len that was allocated.
 367  *
 368  * NOTES
 369  *  The memory block is always 8-byte aligned.
 370  *  If the function is unable to allocate memory an ERROR_OUTOFMEMORY
 371  *  exception is raised.
 372  */
 373 void * WINAPI NdrAllocate(MIDL_STUB_MESSAGE *pStubMsg, SIZE_T len)
 374 {
 375     SIZE_T aligned_len;
 376     SIZE_T adjusted_len;
 377     void *p;
 378     NDR_MEMORY_LIST *mem_list;
 379
 380     aligned_len = ALIGNED_LENGTH(len, 8);
 381     adjusted_len = aligned_len + sizeof(NDR_MEMORY_LIST);
 382     /* check for overflow */
 383     if (adjusted_len < len)
 384     {
 385         ERR("overflow of adjusted_len %ld, len %ld\n", adjusted_len, len);
 386         RpcRaiseException(RPC_X_BAD_STUB_DATA);
 387     }
 388
 389     p = pStubMsg->pfnAllocate(adjusted_len);
 390     if (!p) RpcRaiseException(ERROR_OUTOFMEMORY);
 391
 392     mem_list = (NDR_MEMORY_LIST *)((char *)p + aligned_len);
 393     mem_list->magic = MEML_MAGIC;
 394     mem_list->size = aligned_len;
 395     mem_list->reserved = 0;
 396     mem_list->next = pStubMsg->pMemoryList;
 397     pStubMsg->pMemoryList = mem_list;
 398
 399     TRACE("-- %p\n", p);
 400     return p;
 401 }
 402
 403 static void NdrFree(MIDL_STUB_MESSAGE *pStubMsg, unsigned char *Pointer)
 404 {
 405     TRACE("(%p, %p)\n", pStubMsg, Pointer);
 406
 407     pStubMsg->pfnFree(Pointer);
 408 }
 409
 410 static inline BOOL IsConformanceOrVariancePresent(PFORMAT_STRING pFormat)
 411 {
 412     return (*(const ULONG *)pFormat != -1);
 413 }
 414
 415 static PFORMAT_STRING ReadConformance(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat)
 416 {
 417   ALIGN_POINTER(pStubMsg->Buffer, 4);
 418   if (pStubMsg->Buffer + 4 > pStubMsg->BufferEnd)
 419       RpcRaiseException(RPC_X_BAD_STUB_DATA);
 420   pStubMsg->MaxCount = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer);
 421   pStubMsg->Buffer += 4;
 422   TRACE("unmarshalled conformance is %ld\n", pStubMsg->MaxCount);
 423   if (pStubMsg->fHasNewCorrDesc)
 424     return pFormat+6;
 425   else
 426     return pFormat+4;
 427 }
 428
 429 static inline PFORMAT_STRING ReadVariance(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat, ULONG MaxValue)
 430 {
 431   if (pFormat && !IsConformanceOrVariancePresent(pFormat))
 432   {
 433     pStubMsg->Offset = 0;
 434     pStubMsg->ActualCount = pStubMsg->MaxCount;
 435     goto done;
 436   }
 437
 438   ALIGN_POINTER(pStubMsg->Buffer, 4);
 439   if (pStubMsg->Buffer + 8 > pStubMsg->BufferEnd)
 440     RpcRaiseException(RPC_X_BAD_STUB_DATA);
 441   pStubMsg->Offset      = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer);
 442   pStubMsg->Buffer += 4;
 443   TRACE("offset is %d\n", pStubMsg->Offset);
 444   pStubMsg->ActualCount = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer);
 445   pStubMsg->Buffer += 4;
 446   TRACE("variance is %d\n", pStubMsg->ActualCount);
 447
 448   if ((pStubMsg->ActualCount > MaxValue) ||
 449       (pStubMsg->ActualCount + pStubMsg->Offset > MaxValue))
 450   {
 451     ERR("invalid array bound(s): ActualCount = %d, Offset = %d, MaxValue = %d\n",
 452         pStubMsg->ActualCount, pStubMsg->Offset, MaxValue);
 453     RpcRaiseException(RPC_S_INVALID_BOUND);
 454     return NULL;
 455   }
 456
 457 done:
 458   if (pStubMsg->fHasNewCorrDesc)
 459     return pFormat+6;
 460   else
 461     return pFormat+4;
 462 }
 463
 464 /* writes the conformance value to the buffer */
 465 static inline void WriteConformance(MIDL_STUB_MESSAGE *pStubMsg)
 466 {
 467     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
 468     if (pStubMsg->Buffer + 4 > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
 469         RpcRaiseException(RPC_X_BAD_STUB_DATA);
 470     NDR_LOCAL_UINT32_WRITE(pStubMsg->Buffer, pStubMsg->MaxCount);
 471     pStubMsg->Buffer += 4;
 472 }
 473
 474 /* writes the variance values to the buffer */
 475 static inline void WriteVariance(MIDL_STUB_MESSAGE *pStubMsg)
 476 {
 477     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
 478     if (pStubMsg->Buffer + 8 > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
 479         RpcRaiseException(RPC_X_BAD_STUB_DATA);
 480     NDR_LOCAL_UINT32_WRITE(pStubMsg->Buffer, pStubMsg->Offset);
 481     pStubMsg->Buffer += 4;
 482     NDR_LOCAL_UINT32_WRITE(pStubMsg->Buffer, pStubMsg->ActualCount);
 483     pStubMsg->Buffer += 4;
 484 }
 485
 486 /* requests buffer space for the conformance value */
 487 static inline void SizeConformance(MIDL_STUB_MESSAGE *pStubMsg)
 488 {
 489     ALIGN_LENGTH(pStubMsg->BufferLength, 4);
 490     if (pStubMsg->BufferLength + 4 < pStubMsg->BufferLength)
 491         RpcRaiseException(RPC_X_BAD_STUB_DATA);
 492     pStubMsg->BufferLength += 4;
 493 }
 494
 495 /* requests buffer space for the variance values */
 496 static inline void SizeVariance(MIDL_STUB_MESSAGE *pStubMsg)
 497 {
 498     ALIGN_LENGTH(pStubMsg->BufferLength, 4);
 499     if (pStubMsg->BufferLength + 8 < pStubMsg->BufferLength)
 500         RpcRaiseException(RPC_X_BAD_STUB_DATA);
 501     pStubMsg->BufferLength += 8;
 502 }
 503
 504 PFORMAT_STRING ComputeConformanceOrVariance(
 505     MIDL_STUB_MESSAGE *pStubMsg, unsigned char *pMemory,
 506     PFORMAT_STRING pFormat, ULONG_PTR def, ULONG_PTR *pCount)
 507 {
 508   BYTE dtype = pFormat[0] & 0xf;
 509   short ofs = *(const short *)&pFormat[2];
 510   LPVOID ptr = NULL;
 511   DWORD data = 0;
 512
 513   if (!IsConformanceOrVariancePresent(pFormat)) {
 514     /* null descriptor */
 515     *pCount = def;
 516     goto finish_conf;
 517   }
 518
 519   switch (pFormat[0] & 0xf0) {
 520   case RPC_FC_NORMAL_CONFORMANCE:
 521     TRACE("normal conformance, ofs=%d\n", ofs);
 522     ptr = pMemory;
 523     break;
 524   case RPC_FC_POINTER_CONFORMANCE:
 525     TRACE("pointer conformance, ofs=%d\n", ofs);
 526     ptr = pStubMsg->Memory;
 527     break;
 528   case RPC_FC_TOP_LEVEL_CONFORMANCE:
 529     TRACE("toplevel conformance, ofs=%d\n", ofs);
 530     if (pStubMsg->StackTop) {
 531       ptr = pStubMsg->StackTop;
 532     }
 533     else {
 534       /* -Os mode, *pCount is already set */
 535       goto finish_conf;
 536     }
 537     break;
 538   case RPC_FC_CONSTANT_CONFORMANCE:
 539     data = ofs | ((DWORD)pFormat[1] << 16);
 540     TRACE("constant conformance, val=%d\n", data);
 541     *pCount = data;
 542     goto finish_conf;
 543   case RPC_FC_TOP_LEVEL_MULTID_CONFORMANCE:
 544     FIXME("toplevel multidimensional conformance, ofs=%d\n", ofs);
 545     if (pStubMsg->StackTop) {
 546       ptr = pStubMsg->StackTop;
 547     }
 548     else {
 549       /* ? */
 550       goto done_conf_grab;
 551     }
 552     break;
 553   default:
 554     FIXME("unknown conformance type %x, expect crash.\n", pFormat[0] & 0xf0);
 555     goto finish_conf;
 556   }
 557
 558   switch (pFormat[1]) {
 559   case RPC_FC_DEREFERENCE:
 560     ptr = *(LPVOID*)((char *)ptr + ofs);
 561     break;
 562   case RPC_FC_CALLBACK:
 563   {
 564     unsigned char *old_stack_top = pStubMsg->StackTop;
 565     pStubMsg->StackTop = ptr;
 566
 567     /* ofs is index into StubDesc->apfnExprEval */
 568     TRACE("callback conformance into apfnExprEval[%d]\n", ofs);
 569     pStubMsg->StubDesc->apfnExprEval[ofs](pStubMsg);
 570
 571     pStubMsg->StackTop = old_stack_top;
 572
 573     /* the callback function always stores the computed value in MaxCount */
 574     *pCount = pStubMsg->MaxCount;
 575     goto finish_conf;
 576   }
 577   default:
 578     ptr = (char *)ptr + ofs;
 579     break;
 580   }
 581
 582   switch (dtype) {
 583   case RPC_FC_LONG:
 584   case RPC_FC_ULONG:
 585     data = *(DWORD*)ptr;
 586     break;
 587   case RPC_FC_SHORT:
 588     data = *(SHORT*)ptr;
 589     break;
 590   case RPC_FC_USHORT:
 591     data = *(USHORT*)ptr;
 592     break;
 593   case RPC_FC_CHAR:
 594   case RPC_FC_SMALL:
 595     data = *(CHAR*)ptr;
 596     break;
 597   case RPC_FC_BYTE:
 598   case RPC_FC_USMALL:
 599     data = *(UCHAR*)ptr;
 600     break;
 601   default:
 602     FIXME("unknown conformance data type %x\n", dtype);
 603     goto done_conf_grab;
 604   }
 605   TRACE("dereferenced data type %x at %p, got %d\n", dtype, ptr, data);
 606
 607 done_conf_grab:
 608   switch (pFormat[1]) {
 609   case RPC_FC_DEREFERENCE: /* already handled */
 610   case 0: /* no op */
 611     *pCount = data;
 612     break;
 613   case RPC_FC_ADD_1:
 614     *pCount = data + 1;
 615     break;
 616   case RPC_FC_SUB_1:
 617     *pCount = data - 1;
 618     break;
 619   case RPC_FC_MULT_2:
 620     *pCount = data * 2;
 621     break;
 622   case RPC_FC_DIV_2:
 623     *pCount = data / 2;
 624     break;
 625   default:
 626     FIXME("unknown conformance op %d\n", pFormat[1]);
 627     goto finish_conf;
 628   }
 629
 630 finish_conf:
 631   TRACE("resulting conformance is %ld\n", *pCount);
 632   if (pStubMsg->fHasNewCorrDesc)
 633     return pFormat+6;
 634   else
 635     return pFormat+4;
 636 }
 637
 638 static inline PFORMAT_STRING SkipConformance(PMIDL_STUB_MESSAGE pStubMsg,
 639                                              PFORMAT_STRING pFormat)
 640 {
 641   if (IsConformanceOrVariancePresent(pFormat))
 642   {
 643     if (pStubMsg->fHasNewCorrDesc)
 644       pFormat += 6;
 645     else
 646       pFormat += 4;
 647   }
 648   return pFormat;
 649 }
 650
 651 /* multiply two numbers together, raising an RPC_S_INVALID_BOUND exception if
 652  * the result overflows 32-bits */
 653 static inline ULONG safe_multiply(ULONG a, ULONG b)
 654 {
 655     ULONGLONG ret = (ULONGLONG)a * b;
 656     if (ret > 0xffffffff)
 657     {
 658         RpcRaiseException(RPC_S_INVALID_BOUND);
 659         return 0;
 660     }
 661     return ret;
 662 }
 663
 664 static inline void safe_buffer_increment(MIDL_STUB_MESSAGE *pStubMsg, ULONG size)
 665 {
 666     if ((pStubMsg->Buffer + size < pStubMsg->Buffer) || /* integer overflow of pStubMsg->Buffer */
 667         (pStubMsg->Buffer + size > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength))
 668         RpcRaiseException(RPC_X_BAD_STUB_DATA);
 669     pStubMsg->Buffer += size;
 670 }
 671
 672 static inline void safe_buffer_length_increment(MIDL_STUB_MESSAGE *pStubMsg, ULONG size)
 673 {
 674     if (pStubMsg->BufferLength + size < pStubMsg->BufferLength) /* integer overflow of pStubMsg->BufferSize */
 675     {
 676         ERR("buffer length overflow - BufferLength = %u, size = %u\n",
 677             pStubMsg->BufferLength, size);
 678         RpcRaiseException(RPC_X_BAD_STUB_DATA);
 679     }
 680     pStubMsg->BufferLength += size;
 681 }
 682
 683 /* copies data from the buffer, checking that there is enough data in the buffer
 684  * to do so */
 685 static inline void safe_copy_from_buffer(MIDL_STUB_MESSAGE *pStubMsg, void *p, ULONG size)
 686 {
 687     if ((pStubMsg->Buffer + size < pStubMsg->Buffer) || /* integer overflow of pStubMsg->Buffer */
 688         (pStubMsg->Buffer + size > pStubMsg->BufferEnd))
 689     {
 690         ERR("buffer overflow - Buffer = %p, BufferEnd = %p, size = %u\n",
 691             pStubMsg->Buffer, pStubMsg->BufferEnd, size);
 692         RpcRaiseException(RPC_X_BAD_STUB_DATA);
 693     }
 694     if (p == pStubMsg->Buffer)
 695         ERR("pointer is the same as the buffer\n");
 696     memcpy(p, pStubMsg->Buffer, size);
 697     pStubMsg->Buffer += size;
 698 }
 699
 700 /* copies data to the buffer, checking that there is enough space to do so */
 701 static inline void safe_copy_to_buffer(MIDL_STUB_MESSAGE *pStubMsg, const void *p, ULONG size)
 702 {
 703     if ((pStubMsg->Buffer + size < pStubMsg->Buffer) || /* integer overflow of pStubMsg->Buffer */
 704         (pStubMsg->Buffer + size > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength))
 705     {
 706         ERR("buffer overflow - Buffer = %p, BufferEnd = %p, size = %u\n",
 707             pStubMsg->Buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength,
 708             size);
 709         RpcRaiseException(RPC_X_BAD_STUB_DATA);
 710     }
 711     memcpy(pStubMsg->Buffer, p, size);
 712     pStubMsg->Buffer += size;
 713 }
 714
 715 /* verify that string data sitting in the buffer is valid and safe to
 716  * unmarshall */
 717 static void validate_string_data(MIDL_STUB_MESSAGE *pStubMsg, ULONG bufsize, ULONG esize)
 718 {
 719     ULONG i;
 720
 721     /* verify the buffer is safe to access */
 722     if ((pStubMsg->Buffer + bufsize < pStubMsg->Buffer) ||
 723         (pStubMsg->Buffer + bufsize > pStubMsg->BufferEnd))
 724     {
 725         ERR("bufsize 0x%x exceeded buffer end %p of buffer %p\n", bufsize,
 726             pStubMsg->BufferEnd, pStubMsg->Buffer);
 727         RpcRaiseException(RPC_X_BAD_STUB_DATA);
 728     }
 729
 730     /* strings must always have null terminating bytes */
 731     if (bufsize < esize)
 732     {
 733         ERR("invalid string length of %d\n", bufsize / esize);
 734         RpcRaiseException(RPC_S_INVALID_BOUND);
 735     }
 736
 737     for (i = bufsize - esize; i < bufsize; i++)
 738         if (pStubMsg->Buffer[i] != 0)
 739         {
 740             ERR("string not null-terminated at byte position %d, data is 0x%x\n",
 741                 i, pStubMsg->Buffer[i]);
 742             RpcRaiseException(RPC_S_INVALID_BOUND);
 743         }
 744 }
 745
 746 static inline void dump_pointer_attr(unsigned char attr)
 747 {
 748     if (attr & RPC_FC_P_ALLOCALLNODES)
 749         TRACE(" RPC_FC_P_ALLOCALLNODES");
 750     if (attr & RPC_FC_P_DONTFREE)
 751         TRACE(" RPC_FC_P_DONTFREE");
 752     if (attr & RPC_FC_P_ONSTACK)
 753         TRACE(" RPC_FC_P_ONSTACK");
 754     if (attr & RPC_FC_P_SIMPLEPOINTER)
 755         TRACE(" RPC_FC_P_SIMPLEPOINTER");
 756     if (attr & RPC_FC_P_DEREF)
 757         TRACE(" RPC_FC_P_DEREF");
 758     TRACE("\n");
 759 }
 760
 761 /***********************************************************************
 762  *           PointerMarshall [internal]
 763  */
 764 static void PointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
 765                             unsigned char *Buffer,
 766                             unsigned char *Pointer,
 767                             PFORMAT_STRING pFormat)
 768 {
 769   unsigned type = pFormat[0], attr = pFormat[1];
 770   PFORMAT_STRING desc;
 771   NDR_MARSHALL m;
 772   ULONG pointer_id;
 773   int pointer_needs_marshaling;
 774
 775   TRACE("(%p,%p,%p,%p)\n", pStubMsg, Buffer, Pointer, pFormat);
 776   TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
 777   pFormat += 2;
 778   if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
 779   else desc = pFormat + *(const SHORT*)pFormat;
 780
 781   switch (type) {
 782   case RPC_FC_RP: /* ref pointer (always non-null) */
 783     if (!Pointer)
 784     {
 785       ERR("NULL ref pointer is not allowed\n");
 786       RpcRaiseException(RPC_X_NULL_REF_POINTER);
 787     }
 788     pointer_needs_marshaling = 1;
 789     break;
 790   case RPC_FC_UP: /* unique pointer */
 791   case RPC_FC_OP: /* object pointer - same as unique here */
 792     if (Pointer)
 793       pointer_needs_marshaling = 1;
 794     else
 795       pointer_needs_marshaling = 0;
 796     pointer_id = Pointer ? NDR_POINTER_ID(pStubMsg) : 0;
 797     TRACE("writing 0x%08x to buffer\n", pointer_id);
 798     NDR_LOCAL_UINT32_WRITE(Buffer, pointer_id);
 799     break;
 800   case RPC_FC_FP:
 801     pointer_needs_marshaling = !NdrFullPointerQueryPointer(
 802       pStubMsg->FullPtrXlatTables, Pointer, 1, &pointer_id);
 803     TRACE("writing 0x%08x to buffer\n", pointer_id);
 804     NDR_LOCAL_UINT32_WRITE(Buffer, pointer_id);
 805     break;
 806   default:
 807     FIXME("unhandled ptr type=%02x\n", type);
 808     RpcRaiseException(RPC_X_BAD_STUB_DATA);
 809     return;
 810   }
 811
 812   TRACE("calling marshaller for type 0x%x\n", (int)*desc);
 813
 814   if (pointer_needs_marshaling) {
 815     if (attr & RPC_FC_P_DEREF) {
 816       Pointer = *(unsigned char**)Pointer;
 817       TRACE("deref => %p\n", Pointer);
 818     }
 819     m = NdrMarshaller[*desc & NDR_TABLE_MASK];
 820     if (m) m(pStubMsg, Pointer, desc);
 821     else FIXME("no marshaller for data type=%02x\n", *desc);
 822   }
 823
 824   STD_OVERFLOW_CHECK(pStubMsg);
 825 }
 826
 827 /***********************************************************************
 828  *           PointerUnmarshall [internal]
 829  */
 830 static void PointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
 831                               unsigned char *Buffer,
 832                               unsigned char **pPointer,
 833                               unsigned char *pSrcPointer,
 834                               PFORMAT_STRING pFormat,
 835                               unsigned char fMustAlloc)
 836 {
 837   unsigned type = pFormat[0], attr = pFormat[1];
 838   PFORMAT_STRING desc;
 839   NDR_UNMARSHALL m;
 840   DWORD pointer_id = 0;
 841   int pointer_needs_unmarshaling;
 842
 843   TRACE("(%p,%p,%p,%p,%p,%d)\n", pStubMsg, Buffer, pPointer, pSrcPointer, pFormat, fMustAlloc);
 844   TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
 845   pFormat += 2;
 846   if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
 847   else desc = pFormat + *(const SHORT*)pFormat;
 848
 849   switch (type) {
 850   case RPC_FC_RP: /* ref pointer (always non-null) */
 851     pointer_needs_unmarshaling = 1;
 852     break;
 853   case RPC_FC_UP: /* unique pointer */
 854     pointer_id = NDR_LOCAL_UINT32_READ(Buffer);
 855     TRACE("pointer_id is 0x%08x\n", pointer_id);
 856     if (pointer_id)
 857       pointer_needs_unmarshaling = 1;
 858     else {
 859       *pPointer = NULL;
 860       pointer_needs_unmarshaling = 0;
 861     }
 862     break;
 863   case RPC_FC_OP: /* object pointer - we must free data before overwriting it */
 864     pointer_id = NDR_LOCAL_UINT32_READ(Buffer);
 865     TRACE("pointer_id is 0x%08x\n", pointer_id);
 866     if (!fMustAlloc && pSrcPointer)
 867     {
 868         FIXME("free object pointer %p\n", pSrcPointer);
 869         fMustAlloc = TRUE;
 870     }
 871     if (pointer_id)
 872       pointer_needs_unmarshaling = 1;
 873     else
 874     {
 875       *pPointer = NULL;
 876       pointer_needs_unmarshaling = 0;
 877     }
 878     break;
 879   case RPC_FC_FP:
 880     pointer_id = NDR_LOCAL_UINT32_READ(Buffer);
 881     TRACE("pointer_id is 0x%08x\n", pointer_id);
 882     pointer_needs_unmarshaling = !NdrFullPointerQueryRefId(
 883       pStubMsg->FullPtrXlatTables, pointer_id, 1, (void **)pPointer);
 884     break;
 885   default:
 886     FIXME("unhandled ptr type=%02x\n", type);
 887     RpcRaiseException(RPC_X_BAD_STUB_DATA);
 888     return;
 889   }
 890
 891   if (pointer_needs_unmarshaling) {
 892     unsigned char *base_ptr_val = *pPointer;
 893     unsigned char **current_ptr = pPointer;
 894     if (pStubMsg->IsClient) {
 895       TRACE("client\n");
 896       /* if we aren't forcing allocation of memory then try to use the existing
 897        * (source) pointer to unmarshall the data into so that [in,out]
 898        * parameters behave correctly. it doesn't matter if the parameter is
 899        * [out] only since in that case the pointer will be NULL. we force
 900        * allocation when the source pointer is NULL here instead of in the type
 901        * unmarshalling routine for the benefit of the deref code below */
 902       if (!fMustAlloc) {
 903         if (pSrcPointer) {
 904           TRACE("setting *pPointer to %p\n", pSrcPointer);
 905           *pPointer = base_ptr_val = pSrcPointer;
 906         } else
 907           fMustAlloc = TRUE;
 908       }
 909     } else {
 910       TRACE("server\n");
 911       /* the memory in a stub is never initialised, so we have to work out here
 912        * whether we have to initialise it so we can use the optimisation of
 913        * setting the pointer to the buffer, if possible, or set fMustAlloc to
 914        * TRUE. */
 915       if (attr & RPC_FC_P_DEREF) {
 916         fMustAlloc = TRUE;
 917       } else {
 918         base_ptr_val = NULL;
 919         *current_ptr = NULL;
 920       }
 921     }
 922
 923     if (attr & RPC_FC_P_ALLOCALLNODES)
 924         FIXME("RPC_FC_P_ALLOCALLNODES not implemented\n");
 925
 926     if (attr & RPC_FC_P_DEREF) {
 927       if (fMustAlloc) {
 928         base_ptr_val = NdrAllocate(pStubMsg, sizeof(void *));
 929         *pPointer = base_ptr_val;
 930         current_ptr = (unsigned char **)base_ptr_val;
 931       } else
 932         current_ptr = *(unsigned char***)current_ptr;
 933       TRACE("deref => %p\n", current_ptr);
 934       if (!fMustAlloc && !*current_ptr) fMustAlloc = TRUE;
 935     }
 936     m = NdrUnmarshaller[*desc & NDR_TABLE_MASK];
 937     if (m) m(pStubMsg, current_ptr, desc, fMustAlloc);
 938     else FIXME("no unmarshaller for data type=%02x\n", *desc);
 939
 940     if (type == RPC_FC_FP)
 941       NdrFullPointerInsertRefId(pStubMsg->FullPtrXlatTables, pointer_id,
 942                                 *pPointer);
 943   }
 944
 945   TRACE("pointer=%p\n", *pPointer);
 946 }
 947
 948 /***********************************************************************
 949  *           PointerBufferSize [internal]
 950  */
 951 static void PointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
 952                               unsigned char *Pointer,
 953                               PFORMAT_STRING pFormat)
 954 {
 955   unsigned type = pFormat[0], attr = pFormat[1];
 956   PFORMAT_STRING desc;
 957   NDR_BUFFERSIZE m;
 958   int pointer_needs_sizing;
 959   ULONG pointer_id;
 960
 961   TRACE("(%p,%p,%p)\n", pStubMsg, Pointer, pFormat);
 962   TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
 963   pFormat += 2;
 964   if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
 965   else desc = pFormat + *(const SHORT*)pFormat;
 966
 967   switch (type) {
 968   case RPC_FC_RP: /* ref pointer (always non-null) */
 969     if (!Pointer)
 970     {
 971       ERR("NULL ref pointer is not allowed\n");
 972       RpcRaiseException(RPC_X_NULL_REF_POINTER);
 973     }
 974     break;
 975   case RPC_FC_OP:
 976   case RPC_FC_UP:
 977     /* NULL pointer has no further representation */
 978     if (!Pointer)
 979         return;
 980     break;
 981   case RPC_FC_FP:
 982     pointer_needs_sizing = !NdrFullPointerQueryPointer(
 983       pStubMsg->FullPtrXlatTables, Pointer, 0, &pointer_id);
 984     if (!pointer_needs_sizing)
 985       return;
 986     break;
 987   default:
 988     FIXME("unhandled ptr type=%02x\n", type);
 989     RpcRaiseException(RPC_X_BAD_STUB_DATA);
 990     return;
 991   }
 992
 993   if (attr & RPC_FC_P_DEREF) {
 994     Pointer = *(unsigned char**)Pointer;
 995     TRACE("deref => %p\n", Pointer);
 996   }
 997
 998   m = NdrBufferSizer[*desc & NDR_TABLE_MASK];
 999   if (m) m(pStubMsg, Pointer, desc);
1000   else FIXME("no buffersizer for data type=%02x\n", *desc);
1001 }
1002
1003 /***********************************************************************
1004  *           PointerMemorySize [internal]
1005  */
1006 static ULONG PointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
1007                                unsigned char *Buffer, PFORMAT_STRING pFormat)
1008 {
1009   unsigned type = pFormat[0], attr = pFormat[1];
1010   PFORMAT_STRING desc;
1011   NDR_MEMORYSIZE m;
1012   DWORD pointer_id = 0;
1013   int pointer_needs_sizing;
1014
1015   TRACE("(%p,%p,%p)\n", pStubMsg, Buffer, pFormat);
1016   TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
1017   pFormat += 2;
1018   if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
1019   else desc = pFormat + *(const SHORT*)pFormat;
1020
1021   switch (type) {
1022   case RPC_FC_RP: /* ref pointer (always non-null) */
1023     pointer_needs_sizing = 1;
1024     break;
1025   case RPC_FC_UP: /* unique pointer */
1026   case RPC_FC_OP: /* object pointer - we must free data before overwriting it */
1027     pointer_id = NDR_LOCAL_UINT32_READ(Buffer);
1028     TRACE("pointer_id is 0x%08x\n", pointer_id);
1029     if (pointer_id)
1030       pointer_needs_sizing = 1;
1031     else
1032       pointer_needs_sizing = 0;
1033     break;
1034   case RPC_FC_FP:
1035   {
1036     void *pointer;
1037     pointer_id = NDR_LOCAL_UINT32_READ(Buffer);
1038     TRACE("pointer_id is 0x%08x\n", pointer_id);
1039     pointer_needs_sizing = !NdrFullPointerQueryRefId(
1040       pStubMsg->FullPtrXlatTables, pointer_id, 1, &pointer);
1041     break;
1042   }
1043   default:
1044     FIXME("unhandled ptr type=%02x\n", type);
1045     RpcRaiseException(RPC_X_BAD_STUB_DATA);
1046     return 0;
1047   }
1048
1049   if (attr & RPC_FC_P_DEREF) {
1050     ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(void*));
1051     pStubMsg->MemorySize += sizeof(void*);
1052     TRACE("deref\n");
1053   }
1054
1055   if (pointer_needs_sizing) {
1056     m = NdrMemorySizer[*desc & NDR_TABLE_MASK];
1057     if (m) m(pStubMsg, desc);
1058     else FIXME("no memorysizer for data type=%02x\n", *desc);
1059   }
1060
1061   return pStubMsg->MemorySize;
1062 }
1063
1064 /***********************************************************************
1065  *           PointerFree [internal]
1066  */
1067 static void PointerFree(PMIDL_STUB_MESSAGE pStubMsg,
1068                         unsigned char *Pointer,
1069                         PFORMAT_STRING pFormat)
1070 {
1071   unsigned type = pFormat[0], attr = pFormat[1];
1072   PFORMAT_STRING desc;
1073   NDR_FREE m;
1074   unsigned char *current_pointer = Pointer;
1075
1076   TRACE("(%p,%p,%p)\n", pStubMsg, Pointer, pFormat);
1077   TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
1078   if (attr & RPC_FC_P_DONTFREE) return;
1079   pFormat += 2;
1080   if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
1081   else desc = pFormat + *(const SHORT*)pFormat;
1082
1083   if (!Pointer) return;
1084
1085   if (type == RPC_FC_FP) {
1086     int pointer_needs_freeing = NdrFullPointerFree(
1087       pStubMsg->FullPtrXlatTables, Pointer);
1088     if (!pointer_needs_freeing)
1089       return;
1090   }
1091
1092   if (attr & RPC_FC_P_DEREF) {
1093     current_pointer = *(unsigned char**)Pointer;
1094     TRACE("deref => %p\n", current_pointer);
1095   }
1096
1097   m = NdrFreer[*desc & NDR_TABLE_MASK];
1098   if (m) m(pStubMsg, current_pointer, desc);
1099
1100   /* this check stops us from trying to free buffer memory. we don't have to
1101    * worry about clients, since they won't call this function.
1102    * we don't have to check for the buffer being reallocated because
1103    * BufferStart and BufferEnd won't be reset when allocating memory for
1104    * sending the response. we don't have to check for the new buffer here as
1105    * it won't be used a type memory, only for buffer memory */
1106   if (Pointer >= pStubMsg->BufferStart && Pointer < pStubMsg->BufferEnd)
1107       goto notfree;
1108
1109   if (attr & RPC_FC_P_ONSTACK) {
1110     TRACE("not freeing stack ptr %p\n", Pointer);
1111     return;
1112   }
1113   TRACE("freeing %p\n", Pointer);
1114   NdrFree(pStubMsg, Pointer);
1115   return;
1116 notfree:
1117   TRACE("not freeing %p\n", Pointer);
1118 }
1119
1120 /***********************************************************************
1121  *           EmbeddedPointerMarshall
1122  */
1123 static unsigned char * EmbeddedPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
1124                                                unsigned char *pMemory,
1125                                                PFORMAT_STRING pFormat)
1126 {
1127   unsigned char *Mark = pStubMsg->BufferMark;
1128   unsigned rep, count, stride;
1129   unsigned i;
1130   unsigned char *saved_buffer = NULL;
1131
1132   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1133
1134   if (*pFormat != RPC_FC_PP) return NULL;
1135   pFormat += 2;
1136
1137   if (pStubMsg->PointerBufferMark)
1138   {
1139     saved_buffer = pStubMsg->Buffer;
1140     pStubMsg->Buffer = pStubMsg->PointerBufferMark;
1141     pStubMsg->PointerBufferMark = NULL;
1142   }
1143
1144   while (pFormat[0] != RPC_FC_END) {
1145     switch (pFormat[0]) {
1146     default:
1147       FIXME("unknown repeat type %d\n", pFormat[0]);
1148     case RPC_FC_NO_REPEAT:
1149       rep = 1;
1150       stride = 0;
1151       count = 1;
1152       pFormat += 2;
1153       break;
1154     case RPC_FC_FIXED_REPEAT:
1155       rep = *(const WORD*)&pFormat[2];
1156       stride = *(const WORD*)&pFormat[4];
1157       count = *(const WORD*)&pFormat[8];
1158       pFormat += 10;
1159       break;
1160     case RPC_FC_VARIABLE_REPEAT:
1161       rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
1162       stride = *(const WORD*)&pFormat[2];
1163       count = *(const WORD*)&pFormat[6];
1164       pFormat += 8;
1165       break;
1166     }
1167     for (i = 0; i < rep; i++) {
1168       PFORMAT_STRING info = pFormat;
1169       unsigned char *membase = pMemory + (i * stride);
1170       unsigned char *bufbase = Mark + (i * stride);
1171       unsigned u;
1172
1173       for (u=0; u<count; u++,info+=8) {
1174         unsigned char *memptr = membase + *(const SHORT*)&info[0];
1175         unsigned char *bufptr = bufbase + *(const SHORT*)&info[2];
1176         unsigned char *saved_memory = pStubMsg->Memory;
1177
1178         pStubMsg->Memory = pMemory;
1179         PointerMarshall(pStubMsg, bufptr, *(unsigned char**)memptr, info+4);
1180         pStubMsg->Memory = saved_memory;
1181       }
1182     }
1183     pFormat += 8 * count;
1184   }
1185
1186   if (saved_buffer)
1187   {
1188     pStubMsg->PointerBufferMark = pStubMsg->Buffer;
1189     pStubMsg->Buffer = saved_buffer;
1190   }
1191
1192   STD_OVERFLOW_CHECK(pStubMsg);
1193
1194   return NULL;
1195 }
1196
1197 /***********************************************************************
1198  *           EmbeddedPointerUnmarshall
1199  */
1200 static unsigned char * EmbeddedPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
1201                                                  unsigned char *pDstBuffer,
1202                                                  unsigned char *pSrcMemoryPtrs,
1203                                                  PFORMAT_STRING pFormat,
1204                                                  unsigned char fMustAlloc)
1205 {
1206   unsigned char *Mark = pStubMsg->BufferMark;
1207   unsigned rep, count, stride;
1208   unsigned i;
1209   unsigned char *saved_buffer = NULL;
1210
1211   TRACE("(%p,%p,%p,%p,%d)\n", pStubMsg, pDstBuffer, pSrcMemoryPtrs, pFormat, fMustAlloc);
1212
1213   if (*pFormat != RPC_FC_PP) return NULL;
1214   pFormat += 2;
1215
1216   if (pStubMsg->PointerBufferMark)
1217   {
1218     saved_buffer = pStubMsg->Buffer;
1219     pStubMsg->Buffer = pStubMsg->PointerBufferMark;
1220     pStubMsg->PointerBufferMark = NULL;
1221   }
1222
1223   while (pFormat[0] != RPC_FC_END) {
1224     TRACE("pFormat[0] = 0x%x\n", pFormat[0]);
1225     switch (pFormat[0]) {
1226     default:
1227       FIXME("unknown repeat type %d\n", pFormat[0]);
1228     case RPC_FC_NO_REPEAT:
1229       rep = 1;
1230       stride = 0;
1231       count = 1;
1232       pFormat += 2;
1233       break;
1234     case RPC_FC_FIXED_REPEAT:
1235       rep = *(const WORD*)&pFormat[2];
1236       stride = *(const WORD*)&pFormat[4];
1237       count = *(const WORD*)&pFormat[8];
1238       pFormat += 10;
1239       break;
1240     case RPC_FC_VARIABLE_REPEAT:
1241       rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
1242       stride = *(const WORD*)&pFormat[2];
1243       count = *(const WORD*)&pFormat[6];
1244       pFormat += 8;
1245       break;
1246     }
1247     for (i = 0; i < rep; i++) {
1248       PFORMAT_STRING info = pFormat;
1249       unsigned char *bufdstbase = pDstBuffer + (i * stride);
1250       unsigned char *memsrcbase = pSrcMemoryPtrs + (i * stride);
1251       unsigned char *bufbase = Mark + (i * stride);
1252       unsigned u;
1253
1254       for (u=0; u<count; u++,info+=8) {
1255         unsigned char **bufdstptr = (unsigned char **)(bufdstbase + *(const SHORT*)&info[2]);
1256         unsigned char **memsrcptr = (unsigned char **)(memsrcbase + *(const SHORT*)&info[0]);
1257         unsigned char *bufptr = bufbase + *(const SHORT*)&info[2];
1258         PointerUnmarshall(pStubMsg, bufptr, bufdstptr, *memsrcptr, info+4, fMustAlloc);
1259       }
1260     }
1261     pFormat += 8 * count;
1262   }
1263
1264   if (saved_buffer)
1265   {
1266     pStubMsg->PointerBufferMark = pStubMsg->Buffer;
1267     pStubMsg->Buffer = saved_buffer;
1268   }
1269
1270   return NULL;
1271 }
1272
1273 /***********************************************************************
1274  *           EmbeddedPointerBufferSize
1275  */
1276 static void EmbeddedPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
1277                                       unsigned char *pMemory,
1278                                       PFORMAT_STRING pFormat)
1279 {
1280   unsigned rep, count, stride;
1281   unsigned i;
1282   ULONG saved_buffer_length = 0;
1283
1284   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1285
1286   if (pStubMsg->IgnoreEmbeddedPointers) return;
1287
1288   if (*pFormat != RPC_FC_PP) return;
1289   pFormat += 2;
1290
1291   if (pStubMsg->PointerLength)
1292   {
1293     saved_buffer_length = pStubMsg->BufferLength;
1294     pStubMsg->BufferLength = pStubMsg->PointerLength;
1295     pStubMsg->PointerLength = 0;
1296   }
1297
1298   while (pFormat[0] != RPC_FC_END) {
1299     switch (pFormat[0]) {
1300     default:
1301       FIXME("unknown repeat type %d\n", pFormat[0]);
1302     case RPC_FC_NO_REPEAT:
1303       rep = 1;
1304       stride = 0;
1305       count = 1;
1306       pFormat += 2;
1307       break;
1308     case RPC_FC_FIXED_REPEAT:
1309       rep = *(const WORD*)&pFormat[2];
1310       stride = *(const WORD*)&pFormat[4];
1311       count = *(const WORD*)&pFormat[8];
1312       pFormat += 10;
1313       break;
1314     case RPC_FC_VARIABLE_REPEAT:
1315       rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
1316       stride = *(const WORD*)&pFormat[2];
1317       count = *(const WORD*)&pFormat[6];
1318       pFormat += 8;
1319       break;
1320     }
1321     for (i = 0; i < rep; i++) {
1322       PFORMAT_STRING info = pFormat;
1323       unsigned char *membase = pMemory + (i * stride);
1324       unsigned u;
1325
1326       for (u=0; u<count; u++,info+=8) {
1327         unsigned char *memptr = membase + *(const SHORT*)&info[0];
1328         unsigned char *saved_memory = pStubMsg->Memory;
1329
1330         pStubMsg->Memory = pMemory;
1331         PointerBufferSize(pStubMsg, *(unsigned char**)memptr, info+4);
1332         pStubMsg->Memory = saved_memory;
1333       }
1334     }
1335     pFormat += 8 * count;
1336   }
1337
1338   if (saved_buffer_length)
1339   {
1340     pStubMsg->PointerLength = pStubMsg->BufferLength;
1341     pStubMsg->BufferLength = saved_buffer_length;
1342   }
1343 }
1344
1345 /***********************************************************************
1346  *           EmbeddedPointerMemorySize [internal]
1347  */
1348 static ULONG EmbeddedPointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
1349                                        PFORMAT_STRING pFormat)
1350 {
1351   unsigned char *Mark = pStubMsg->BufferMark;
1352   unsigned rep, count, stride;
1353   unsigned i;
1354   unsigned char *saved_buffer = NULL;
1355
1356   TRACE("(%p,%p)\n", pStubMsg, pFormat);
1357
1358   if (pStubMsg->IgnoreEmbeddedPointers) return 0;
1359
1360   if (pStubMsg->PointerBufferMark)
1361   {
1362     saved_buffer = pStubMsg->Buffer;
1363     pStubMsg->Buffer = pStubMsg->PointerBufferMark;
1364     pStubMsg->PointerBufferMark = NULL;
1365   }
1366
1367   if (*pFormat != RPC_FC_PP) return 0;
1368   pFormat += 2;
1369
1370   while (pFormat[0] != RPC_FC_END) {
1371     switch (pFormat[0]) {
1372     default:
1373       FIXME("unknown repeat type %d\n", pFormat[0]);
1374     case RPC_FC_NO_REPEAT:
1375       rep = 1;
1376       stride = 0;
1377       count = 1;
1378       pFormat += 2;
1379       break;
1380     case RPC_FC_FIXED_REPEAT:
1381       rep = *(const WORD*)&pFormat[2];
1382       stride = *(const WORD*)&pFormat[4];
1383       count = *(const WORD*)&pFormat[8];
1384       pFormat += 10;
1385       break;
1386     case RPC_FC_VARIABLE_REPEAT:
1387       rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
1388       stride = *(const WORD*)&pFormat[2];
1389       count = *(const WORD*)&pFormat[6];
1390       pFormat += 8;
1391       break;
1392     }
1393     for (i = 0; i < rep; i++) {
1394       PFORMAT_STRING info = pFormat;
1395       unsigned char *bufbase = Mark + (i * stride);
1396       unsigned u;
1397       for (u=0; u<count; u++,info+=8) {
1398         unsigned char *bufptr = bufbase + *(const SHORT*)&info[2];
1399         PointerMemorySize(pStubMsg, bufptr, info+4);
1400       }
1401     }
1402     pFormat += 8 * count;
1403   }
1404
1405   if (saved_buffer)
1406   {
1407     pStubMsg->PointerBufferMark = pStubMsg->Buffer;
1408     pStubMsg->Buffer = saved_buffer;
1409   }
1410
1411   return 0;
1412 }
1413
1414 /***********************************************************************
1415  *           EmbeddedPointerFree [internal]
1416  */
1417 static void EmbeddedPointerFree(PMIDL_STUB_MESSAGE pStubMsg,
1418                                 unsigned char *pMemory,
1419                                 PFORMAT_STRING pFormat)
1420 {
1421   unsigned rep, count, stride;
1422   unsigned i;
1423
1424   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1425   if (*pFormat != RPC_FC_PP) return;
1426   pFormat += 2;
1427
1428   while (pFormat[0] != RPC_FC_END) {
1429     switch (pFormat[0]) {
1430     default:
1431       FIXME("unknown repeat type %d\n", pFormat[0]);
1432     case RPC_FC_NO_REPEAT:
1433       rep = 1;
1434       stride = 0;
1435       count = 1;
1436       pFormat += 2;
1437       break;
1438     case RPC_FC_FIXED_REPEAT:
1439       rep = *(const WORD*)&pFormat[2];
1440       stride = *(const WORD*)&pFormat[4];
1441       count = *(const WORD*)&pFormat[8];
1442       pFormat += 10;
1443       break;
1444     case RPC_FC_VARIABLE_REPEAT:
1445       rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
1446       stride = *(const WORD*)&pFormat[2];
1447       count = *(const WORD*)&pFormat[6];
1448       pFormat += 8;
1449       break;
1450     }
1451     for (i = 0; i < rep; i++) {
1452       PFORMAT_STRING info = pFormat;
1453       unsigned char *membase = pMemory + (i * stride);
1454       unsigned u;
1455
1456       for (u=0; u<count; u++,info+=8) {
1457         unsigned char *memptr = membase + *(const SHORT*)&info[0];
1458         unsigned char *saved_memory = pStubMsg->Memory;
1459
1460         pStubMsg->Memory = pMemory;
1461         PointerFree(pStubMsg, *(unsigned char**)memptr, info+4);
1462         pStubMsg->Memory = saved_memory;
1463       }
1464     }
1465     pFormat += 8 * count;
1466   }
1467 }
1468
1469 /***********************************************************************
1470  *           NdrPointerMarshall [RPCRT4.@]
1471  */
1472 unsigned char * WINAPI NdrPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
1473                                           unsigned char *pMemory,
1474                                           PFORMAT_STRING pFormat)
1475 {
1476   unsigned char *Buffer;
1477
1478   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1479
1480   /* Increment the buffer here instead of in PointerMarshall,
1481    * as that is used by embedded pointers which already handle the incrementing
1482    * the buffer, and shouldn't write any additional pointer data to the wire */
1483   if (*pFormat != RPC_FC_RP)
1484   {
1485     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
1486     Buffer = pStubMsg->Buffer;
1487     safe_buffer_increment(pStubMsg, 4);
1488   }
1489   else
1490     Buffer = pStubMsg->Buffer;
1491
1492   PointerMarshall(pStubMsg, Buffer, pMemory, pFormat);
1493
1494   return NULL;
1495 }
1496
1497 /***********************************************************************
1498  *           NdrPointerUnmarshall [RPCRT4.@]
1499  */
1500 unsigned char * WINAPI NdrPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
1501                                             unsigned char **ppMemory,
1502                                             PFORMAT_STRING pFormat,
1503                                             unsigned char fMustAlloc)
1504 {
1505   unsigned char *Buffer;
1506
1507   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
1508
1509   if (*pFormat == RPC_FC_RP)
1510   {
1511     Buffer = pStubMsg->Buffer;
1512     /* Do the NULL ref pointer check here because embedded pointers can be
1513      * NULL if the type the pointer is embedded in was allocated rather than
1514      * being passed in by the client */
1515     if (pStubMsg->IsClient && !*ppMemory)
1516     {
1517       ERR("NULL ref pointer is not allowed\n");
1518       RpcRaiseException(RPC_X_NULL_REF_POINTER);
1519     }
1520   }
1521   else
1522   {
1523     /* Increment the buffer here instead of in PointerUnmarshall,
1524      * as that is used by embedded pointers which already handle the incrementing
1525      * the buffer, and shouldn't read any additional pointer data from the
1526      * buffer */
1527     ALIGN_POINTER(pStubMsg->Buffer, 4);
1528     Buffer = pStubMsg->Buffer;
1529     safe_buffer_increment(pStubMsg, 4);
1530   }
1531
1532   PointerUnmarshall(pStubMsg, Buffer, ppMemory, *ppMemory, pFormat, fMustAlloc);
1533
1534   return NULL;
1535 }
1536
1537 /***********************************************************************
1538  *           NdrPointerBufferSize [RPCRT4.@]
1539  */
1540 void WINAPI NdrPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
1541                                       unsigned char *pMemory,
1542                                       PFORMAT_STRING pFormat)
1543 {
1544   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1545
1546   /* Increment the buffer length here instead of in PointerBufferSize,
1547    * as that is used by embedded pointers which already handle the buffer
1548    * length, and shouldn't write anything more to the wire */
1549   if (*pFormat != RPC_FC_RP)
1550   {
1551     ALIGN_LENGTH(pStubMsg->BufferLength, 4);
1552     safe_buffer_length_increment(pStubMsg, 4);
1553   }
1554
1555   PointerBufferSize(pStubMsg, pMemory, pFormat);
1556 }
1557
1558 /***********************************************************************
1559  *           NdrPointerMemorySize [RPCRT4.@]
1560  */
1561 ULONG WINAPI NdrPointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
1562                                   PFORMAT_STRING pFormat)
1563 {
1564     unsigned char *Buffer = pStubMsg->Buffer;
1565     if (*pFormat != RPC_FC_RP)
1566     {
1567         ALIGN_POINTER(pStubMsg->Buffer, 4);
1568         safe_buffer_increment(pStubMsg, 4);
1569     }
1570     ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(void *));
1571     return PointerMemorySize(pStubMsg, Buffer, pFormat);
1572 }
1573
1574 /***********************************************************************
1575  *           NdrPointerFree [RPCRT4.@]
1576  */
1577 void WINAPI NdrPointerFree(PMIDL_STUB_MESSAGE pStubMsg,
1578                            unsigned char *pMemory,
1579                            PFORMAT_STRING pFormat)
1580 {
1581   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1582   PointerFree(pStubMsg, pMemory, pFormat);
1583 }
1584
1585 /***********************************************************************
1586  *           NdrSimpleTypeMarshall [RPCRT4.@]
1587  */
1588 void WINAPI NdrSimpleTypeMarshall( PMIDL_STUB_MESSAGE pStubMsg, unsigned char* pMemory,
1589                                    unsigned char FormatChar )
1590 {
1591     NdrBaseTypeMarshall(pStubMsg, pMemory, &FormatChar);
1592 }
1593
1594 /***********************************************************************
1595  *           NdrSimpleTypeUnmarshall [RPCRT4.@]
1596  *
1597  * Unmarshall a base type.
1598  *
1599  * NOTES
1600  *  Doesn't check that the buffer is long enough before copying, so the caller
1601  * should do this.
1602  */
1603 void WINAPI NdrSimpleTypeUnmarshall( PMIDL_STUB_MESSAGE pStubMsg, unsigned char* pMemory,
1604                                      unsigned char FormatChar )
1605 {
1606 #define BASE_TYPE_UNMARSHALL(type) \
1607         ALIGN_POINTER(pStubMsg->Buffer, sizeof(type)); \
1608         TRACE("pMemory: %p\n", pMemory); \
1609         *(type *)pMemory = *(type *)pStubMsg->Buffer; \
1610         pStubMsg->Buffer += sizeof(type);
1611
1612     switch(FormatChar)
1613     {
1614     case RPC_FC_BYTE:
1615     case RPC_FC_CHAR:
1616     case RPC_FC_SMALL:
1617     case RPC_FC_USMALL:
1618         BASE_TYPE_UNMARSHALL(UCHAR);
1619         TRACE("value: 0x%02x\n", *pMemory);
1620         break;
1621     case RPC_FC_WCHAR:
1622     case RPC_FC_SHORT:
1623     case RPC_FC_USHORT:
1624         BASE_TYPE_UNMARSHALL(USHORT);
1625         TRACE("value: 0x%04x\n", *(USHORT *)pMemory);
1626         break;
1627     case RPC_FC_LONG:
1628     case RPC_FC_ULONG:
1629     case RPC_FC_ERROR_STATUS_T:
1630     case RPC_FC_ENUM32:
1631         BASE_TYPE_UNMARSHALL(ULONG);
1632         TRACE("value: 0x%08x\n", *(ULONG *)pMemory);
1633         break;
1634    case RPC_FC_FLOAT:
1635         BASE_TYPE_UNMARSHALL(float);
1636         TRACE("value: %f\n", *(float *)pMemory);
1637         break;
1638     case RPC_FC_DOUBLE:
1639         BASE_TYPE_UNMARSHALL(double);
1640         TRACE("value: %f\n", *(double *)pMemory);
1641         break;
1642     case RPC_FC_HYPER:
1643         BASE_TYPE_UNMARSHALL(ULONGLONG);
1644         TRACE("value: %s\n", wine_dbgstr_longlong(*(ULONGLONG *)pMemory));
1645         break;
1646     case RPC_FC_ENUM16:
1647         ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
1648         TRACE("pMemory: %p\n", pMemory);
1649         /* 16-bits on the wire, but int in memory */
1650         *(UINT *)pMemory = *(USHORT *)pStubMsg->Buffer;
1651         pStubMsg->Buffer += sizeof(USHORT);
1652         TRACE("value: 0x%08x\n", *(UINT *)pMemory);
1653         break;
1654     case RPC_FC_IGNORE:
1655         break;
1656     default:
1657         FIXME("Unhandled base type: 0x%02x\n", FormatChar);
1658     }
1659 #undef BASE_TYPE_UNMARSHALL
1660 }
1661
1662 /***********************************************************************
1663  *           NdrSimpleStructMarshall [RPCRT4.@]
1664  */
1665 unsigned char * WINAPI NdrSimpleStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
1666                                                unsigned char *pMemory,
1667                                                PFORMAT_STRING pFormat)
1668 {
1669   unsigned size = *(const WORD*)(pFormat+2);
1670   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1671
1672   ALIGN_POINTER_CLEAR(pStubMsg->Buffer, pFormat[1] + 1);
1673
1674   pStubMsg->BufferMark = pStubMsg->Buffer;
1675   safe_copy_to_buffer(pStubMsg, pMemory, size);
1676
1677   if (pFormat[0] != RPC_FC_STRUCT)
1678     EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat+4);
1679
1680   return NULL;
1681 }
1682
1683 /***********************************************************************
1684  *           NdrSimpleStructUnmarshall [RPCRT4.@]
1685  */
1686 unsigned char * WINAPI NdrSimpleStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
1687                                                  unsigned char **ppMemory,
1688                                                  PFORMAT_STRING pFormat,
1689                                                  unsigned char fMustAlloc)
1690 {
1691   unsigned size = *(const WORD*)(pFormat+2);
1692   unsigned char *saved_buffer;
1693   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
1694
1695   ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
1696
1697   if (fMustAlloc)
1698     *ppMemory = NdrAllocate(pStubMsg, size);
1699   else
1700   {
1701     if (!pStubMsg->IsClient && !*ppMemory)
1702       /* for servers, we just point straight into the RPC buffer */
1703       *ppMemory = pStubMsg->Buffer;
1704   }
1705
1706   saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer;
1707   safe_buffer_increment(pStubMsg, size);
1708   if (pFormat[0] == RPC_FC_PSTRUCT)
1709       EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat+4, fMustAlloc);
1710
1711   TRACE("copying %p to %p\n", saved_buffer, *ppMemory);
1712   if (*ppMemory != saved_buffer)
1713       memcpy(*ppMemory, saved_buffer, size);
1714
1715   return NULL;
1716 }
1717
1718 /***********************************************************************
1719  *           NdrSimpleStructBufferSize [RPCRT4.@]
1720  */
1721 void WINAPI NdrSimpleStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
1722                                       unsigned char *pMemory,
1723                                       PFORMAT_STRING pFormat)
1724 {
1725   unsigned size = *(const WORD*)(pFormat+2);
1726   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1727
1728   ALIGN_LENGTH(pStubMsg->BufferLength, pFormat[1] + 1);
1729
1730   safe_buffer_length_increment(pStubMsg, size);
1731   if (pFormat[0] != RPC_FC_STRUCT)
1732     EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat+4);
1733 }
1734
1735 /***********************************************************************
1736  *           NdrSimpleStructMemorySize [RPCRT4.@]
1737  */
1738 ULONG WINAPI NdrSimpleStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
1739                                        PFORMAT_STRING pFormat)
1740 {
1741   unsigned short size = *(const WORD *)(pFormat+2);
1742
1743   TRACE("(%p,%p)\n", pStubMsg, pFormat);
1744
1745   ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
1746   pStubMsg->MemorySize += size;
1747   safe_buffer_increment(pStubMsg, size);
1748
1749   if (pFormat[0] != RPC_FC_STRUCT)
1750     EmbeddedPointerMemorySize(pStubMsg, pFormat+4);
1751   return pStubMsg->MemorySize;
1752 }
1753
1754 /***********************************************************************
1755  *           NdrSimpleStructFree [RPCRT4.@]
1756  */
1757 void WINAPI NdrSimpleStructFree(PMIDL_STUB_MESSAGE pStubMsg,
1758                                 unsigned char *pMemory,
1759                                 PFORMAT_STRING pFormat)
1760 {
1761   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1762   if (pFormat[0] != RPC_FC_STRUCT)
1763     EmbeddedPointerFree(pStubMsg, pMemory, pFormat+4);
1764 }
1765
1766 /* Array helpers */
1767
1768 static inline void array_compute_and_size_conformance(
1769     unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory,
1770     PFORMAT_STRING pFormat)
1771 {
1772   switch (fc)
1773   {
1774   case RPC_FC_CARRAY:
1775     ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
1776     SizeConformance(pStubMsg);
1777     break;
1778   case RPC_FC_CVARRAY:
1779     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 4, 0);
1780     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
1781     SizeConformance(pStubMsg);
1782     break;
1783   case RPC_FC_C_CSTRING:
1784   case RPC_FC_C_WSTRING:
1785     if (fc == RPC_FC_C_CSTRING)
1786     {
1787       TRACE("string=%s\n", debugstr_a((const char *)pMemory));
1788       pStubMsg->ActualCount = strlen((const char *)pMemory)+1;
1789     }
1790     else
1791     {
1792       TRACE("string=%s\n", debugstr_w((LPCWSTR)pMemory));
1793       pStubMsg->ActualCount = strlenW((LPCWSTR)pMemory)+1;
1794     }
1795
1796     if (pFormat[1] == RPC_FC_STRING_SIZED)
1797       pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 2, 0);
1798     else
1799       pStubMsg->MaxCount = pStubMsg->ActualCount;
1800
1801     SizeConformance(pStubMsg);
1802     break;
1803   default:
1804     ERR("unknown array format 0x%x\n", fc);
1805     RpcRaiseException(RPC_X_BAD_STUB_DATA);
1806   }
1807 }
1808
1809 static inline void array_buffer_size(
1810     unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory,
1811     PFORMAT_STRING pFormat, unsigned char fHasPointers)
1812 {
1813   DWORD size;
1814   DWORD esize;
1815   unsigned char alignment;
1816
1817   switch (fc)
1818   {
1819   case RPC_FC_CARRAY:
1820     esize = *(const WORD*)(pFormat+2);
1821     alignment = pFormat[1] + 1;
1822
1823     pFormat = SkipConformance(pStubMsg, pFormat + 4);
1824
1825     ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
1826
1827     size = safe_multiply(esize, pStubMsg->MaxCount);
1828     /* conformance value plus array */
1829     safe_buffer_length_increment(pStubMsg, size);
1830
1831     if (fHasPointers)
1832       EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
1833     break;
1834   case RPC_FC_CVARRAY:
1835     esize = *(const WORD*)(pFormat+2);
1836     alignment = pFormat[1] + 1;
1837
1838     pFormat = SkipConformance(pStubMsg, pFormat + 4);
1839     pFormat = SkipConformance(pStubMsg, pFormat);
1840
1841     SizeVariance(pStubMsg);
1842
1843     ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
1844
1845     size = safe_multiply(esize, pStubMsg->ActualCount);
1846     safe_buffer_length_increment(pStubMsg, size);
1847
1848     if (fHasPointers)
1849       EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
1850     break;
1851   case RPC_FC_C_CSTRING:
1852   case RPC_FC_C_WSTRING:
1853     if (fc == RPC_FC_C_CSTRING)
1854       esize = 1;
1855     else
1856       esize = 2;
1857
1858     SizeVariance(pStubMsg);
1859
1860     size = safe_multiply(esize, pStubMsg->ActualCount);
1861     safe_buffer_length_increment(pStubMsg, size);
1862     break;
1863   default:
1864     ERR("unknown array format 0x%x\n", fc);
1865     RpcRaiseException(RPC_X_BAD_STUB_DATA);
1866   }
1867 }
1868
1869 static inline void array_compute_and_write_conformance(
1870     unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory,
1871     PFORMAT_STRING pFormat)
1872 {
1873   switch (fc)
1874   {
1875   case RPC_FC_CARRAY:
1876     ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
1877     WriteConformance(pStubMsg);
1878     break;
1879   case RPC_FC_CVARRAY:
1880     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 4, 0);
1881     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
1882     WriteConformance(pStubMsg);
1883     break;
1884   case RPC_FC_C_CSTRING:
1885   case RPC_FC_C_WSTRING:
1886     if (fc == RPC_FC_C_CSTRING)
1887     {
1888       TRACE("string=%s\n", debugstr_a((const char *)pMemory));
1889       pStubMsg->ActualCount = strlen((const char *)pMemory)+1;
1890     }
1891     else
1892     {
1893       TRACE("string=%s\n", debugstr_w((LPCWSTR)pMemory));
1894       pStubMsg->ActualCount = strlenW((LPCWSTR)pMemory)+1;
1895     }
1896     if (pFormat[1] == RPC_FC_STRING_SIZED)
1897       pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 2, 0);
1898     else
1899       pStubMsg->MaxCount = pStubMsg->ActualCount;
1900     pStubMsg->Offset = 0;
1901     WriteConformance(pStubMsg);
1902     break;
1903   default:
1904     ERR("unknown array format 0x%x\n", fc);
1905     RpcRaiseException(RPC_X_BAD_STUB_DATA);
1906   }
1907 }
1908
1909 static inline void array_write_variance_and_marshall(
1910     unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory,
1911     PFORMAT_STRING pFormat, unsigned char fHasPointers)
1912 {
1913   DWORD size;
1914   DWORD esize;
1915   unsigned char alignment;
1916
1917   switch (fc)
1918   {
1919   case RPC_FC_CARRAY:
1920     esize = *(const WORD*)(pFormat+2);
1921     alignment = pFormat[1] + 1;
1922
1923     pFormat = SkipConformance(pStubMsg, pFormat + 4);
1924
1925     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, alignment);
1926
1927     size = safe_multiply(esize, pStubMsg->MaxCount);
1928     if (fHasPointers)
1929       pStubMsg->BufferMark = pStubMsg->Buffer;
1930     safe_copy_to_buffer(pStubMsg, pMemory, size);
1931
1932     if (fHasPointers)
1933       EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
1934     break;
1935   case RPC_FC_CVARRAY:
1936     esize = *(const WORD*)(pFormat+2);
1937     alignment = pFormat[1] + 1;
1938
1939     /* conformance */
1940     pFormat = SkipConformance(pStubMsg, pFormat + 4);
1941     /* variance */
1942     pFormat = SkipConformance(pStubMsg, pFormat);
1943
1944     WriteVariance(pStubMsg);
1945
1946     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, alignment);
1947
1948     size = safe_multiply(esize, pStubMsg->ActualCount);
1949
1950     if (fHasPointers)
1951       pStubMsg->BufferMark = pStubMsg->Buffer;
1952     safe_copy_to_buffer(pStubMsg, pMemory + pStubMsg->Offset, size);
1953
1954     if (fHasPointers)
1955       EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
1956     break;
1957   case RPC_FC_C_CSTRING:
1958   case RPC_FC_C_WSTRING:
1959     if (fc == RPC_FC_C_CSTRING)
1960       esize = 1;
1961     else
1962       esize = 2;
1963
1964     WriteVariance(pStubMsg);
1965
1966     size = safe_multiply(esize, pStubMsg->ActualCount);
1967     safe_copy_to_buffer(pStubMsg, pMemory, size); /* the string itself */
1968     break;
1969   default:
1970     ERR("unknown array format 0x%x\n", fc);
1971     RpcRaiseException(RPC_X_BAD_STUB_DATA);
1972   }
1973 }
1974
1975 static inline ULONG array_read_conformance(
1976     unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
1977 {
1978   DWORD esize;
1979
1980   switch (fc)
1981   {
1982   case RPC_FC_CARRAY:
1983     esize = *(const WORD*)(pFormat+2);
1984     pFormat = ReadConformance(pStubMsg, pFormat+4);
1985     return safe_multiply(esize, pStubMsg->MaxCount);
1986   case RPC_FC_CVARRAY:
1987     esize = *(const WORD*)(pFormat+2);
1988     pFormat = ReadConformance(pStubMsg, pFormat+4);
1989     return safe_multiply(esize, pStubMsg->MaxCount);
1990   case RPC_FC_C_CSTRING:
1991   case RPC_FC_C_WSTRING:
1992     if (fc == RPC_FC_C_CSTRING)
1993       esize = 1;
1994     else
1995       esize = 2;
1996
1997     if (pFormat[1] == RPC_FC_STRING_SIZED)
1998       ReadConformance(pStubMsg, pFormat + 2);
1999     else
2000       ReadConformance(pStubMsg, NULL);
2001     return safe_multiply(esize, pStubMsg->MaxCount);
2002   default:
2003     ERR("unknown array format 0x%x\n", fc);
2004     RpcRaiseException(RPC_X_BAD_STUB_DATA);
2005   }
2006 }
2007
2008 static inline ULONG array_read_variance_and_unmarshall(
2009     unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory,
2010     PFORMAT_STRING pFormat, unsigned char fMustAlloc,
2011     unsigned char fUseBufferMemoryServer, unsigned char fUnmarshall)
2012 {
2013   ULONG bufsize, memsize;
2014   WORD esize;
2015   unsigned char alignment;
2016   unsigned char *saved_buffer;
2017   ULONG offset;
2018
2019   switch (fc)
2020   {
2021   case RPC_FC_CARRAY:
2022     esize = *(const WORD*)(pFormat+2);
2023     alignment = pFormat[1] + 1;
2024
2025     bufsize = memsize = safe_multiply(esize, pStubMsg->MaxCount);
2026
2027     pFormat = SkipConformance(pStubMsg, pFormat + 4);
2028
2029     ALIGN_POINTER(pStubMsg->Buffer, alignment);
2030
2031     if (fUnmarshall)
2032     {
2033       if (fMustAlloc)
2034         *ppMemory = NdrAllocate(pStubMsg, memsize);
2035       else
2036       {
2037         if (fUseBufferMemoryServer && !pStubMsg->IsClient && !*ppMemory)
2038           /* for servers, we just point straight into the RPC buffer */
2039           *ppMemory = pStubMsg->Buffer;
2040       }
2041
2042       saved_buffer = pStubMsg->Buffer;
2043       safe_buffer_increment(pStubMsg, bufsize);
2044
2045       pStubMsg->BufferMark = saved_buffer;
2046       EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat, fMustAlloc);
2047
2048       TRACE("copying %p to %p\n", saved_buffer, *ppMemory);
2049       if (*ppMemory != saved_buffer)
2050         memcpy(*ppMemory, saved_buffer, bufsize);
2051     }
2052     return bufsize;
2053   case RPC_FC_CVARRAY:
2054     esize = *(const WORD*)(pFormat+2);
2055     alignment = pFormat[1] + 1;
2056
2057     pFormat = SkipConformance(pStubMsg, pFormat + 4);
2058
2059     pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
2060
2061     ALIGN_POINTER(pStubMsg->Buffer, alignment);
2062
2063     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
2064     memsize = safe_multiply(esize, pStubMsg->MaxCount);
2065
2066     if (fUnmarshall)
2067     {
2068       offset = pStubMsg->Offset;
2069
2070       if (!fMustAlloc && !*ppMemory)
2071         fMustAlloc = TRUE;
2072       if (fMustAlloc)
2073         *ppMemory = NdrAllocate(pStubMsg, memsize);
2074       saved_buffer = pStubMsg->Buffer;
2075       safe_buffer_increment(pStubMsg, bufsize);
2076
2077       pStubMsg->BufferMark = saved_buffer;
2078       EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat,
2079                                 fMustAlloc);
2080
2081       memcpy(*ppMemory + offset, saved_buffer, bufsize);
2082     }
2083     return bufsize;
2084   case RPC_FC_C_CSTRING:
2085   case RPC_FC_C_WSTRING:
2086     if (fc == RPC_FC_C_CSTRING)
2087       esize = 1;
2088     else
2089       esize = 2;
2090
2091     ReadVariance(pStubMsg, NULL, pStubMsg->MaxCount);
2092
2093     if (pFormat[1] != RPC_FC_STRING_SIZED && (pStubMsg->MaxCount != pStubMsg->ActualCount))
2094     {
2095       ERR("buffer size %d must equal memory size %ld for non-sized conformant strings\n",
2096           pStubMsg->ActualCount, pStubMsg->MaxCount);
2097       RpcRaiseException(RPC_S_INVALID_BOUND);
2098     }
2099     if (pStubMsg->Offset)
2100     {
2101       ERR("conformant strings can't have Offset (%d)\n", pStubMsg->Offset);
2102       RpcRaiseException(RPC_S_INVALID_BOUND);
2103     }
2104
2105     memsize = safe_multiply(esize, pStubMsg->MaxCount);
2106     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
2107
2108     validate_string_data(pStubMsg, bufsize, esize);
2109
2110     if (fUnmarshall)
2111     {
2112       if (fMustAlloc)
2113         *ppMemory = NdrAllocate(pStubMsg, memsize);
2114       else
2115       {
2116         if (fUseBufferMemoryServer && !pStubMsg->IsClient &&
2117             !*ppMemory && (pStubMsg->MaxCount == pStubMsg->ActualCount))
2118           /* if the data in the RPC buffer is big enough, we just point
2119            * straight into it */
2120           *ppMemory = pStubMsg->Buffer;
2121         else if (!*ppMemory)
2122           *ppMemory = NdrAllocate(pStubMsg, memsize);
2123       }
2124
2125       if (*ppMemory == pStubMsg->Buffer)
2126         safe_buffer_increment(pStubMsg, bufsize);
2127       else
2128         safe_copy_from_buffer(pStubMsg, *ppMemory, bufsize);
2129
2130       if (*pFormat == RPC_FC_C_CSTRING)
2131         TRACE("string=%s\n", debugstr_a((char*)*ppMemory));
2132       else
2133         TRACE("string=%s\n", debugstr_w((LPWSTR)*ppMemory));
2134     }
2135     return bufsize;
2136   default:
2137     ERR("unknown array format 0x%x\n", fc);
2138     RpcRaiseException(RPC_X_BAD_STUB_DATA);
2139   }
2140 }
2141
2142 static inline void array_memory_size(
2143     unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat,
2144     unsigned char fHasPointers)
2145 {
2146   ULONG bufsize, memsize;
2147   DWORD esize;
2148   unsigned char alignment;
2149
2150   switch (fc)
2151   {
2152   case RPC_FC_CARRAY:
2153     esize = *(const WORD*)(pFormat+2);
2154     alignment = pFormat[1] + 1;
2155
2156     pFormat = SkipConformance(pStubMsg, pFormat + 4);
2157
2158     bufsize = memsize = safe_multiply(esize, pStubMsg->MaxCount);
2159     pStubMsg->MemorySize += memsize;
2160
2161     ALIGN_POINTER(pStubMsg->Buffer, alignment);
2162     if (fHasPointers)
2163       pStubMsg->BufferMark = pStubMsg->Buffer;
2164     safe_buffer_increment(pStubMsg, bufsize);
2165
2166     if (fHasPointers)
2167       EmbeddedPointerMemorySize(pStubMsg, pFormat);
2168     break;
2169   case RPC_FC_CVARRAY:
2170     esize = *(const WORD*)(pFormat+2);
2171     alignment = pFormat[1] + 1;
2172
2173     pFormat = SkipConformance(pStubMsg, pFormat + 4);
2174
2175     pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
2176
2177     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
2178     memsize = safe_multiply(esize, pStubMsg->MaxCount);
2179     pStubMsg->MemorySize += memsize;
2180
2181     ALIGN_POINTER(pStubMsg->Buffer, alignment);
2182     if (fHasPointers)
2183       pStubMsg->BufferMark = pStubMsg->Buffer;
2184     safe_buffer_increment(pStubMsg, bufsize);
2185
2186     if (fHasPointers)
2187       EmbeddedPointerMemorySize(pStubMsg, pFormat);
2188     break;
2189   case RPC_FC_C_CSTRING:
2190   case RPC_FC_C_WSTRING:
2191     if (fc == RPC_FC_C_CSTRING)
2192       esize = 1;
2193     else
2194       esize = 2;
2195
2196     ReadVariance(pStubMsg, NULL, pStubMsg->MaxCount);
2197
2198     if (pFormat[1] != RPC_FC_STRING_SIZED && (pStubMsg->MaxCount != pStubMsg->ActualCount))
2199     {
2200       ERR("buffer size %d must equal memory size %ld for non-sized conformant strings\n",
2201           pStubMsg->ActualCount, pStubMsg->MaxCount);
2202       RpcRaiseException(RPC_S_INVALID_BOUND);
2203     }
2204     if (pStubMsg->Offset)
2205     {
2206       ERR("conformant strings can't have Offset (%d)\n", pStubMsg->Offset);
2207       RpcRaiseException(RPC_S_INVALID_BOUND);
2208     }
2209
2210     memsize = safe_multiply(esize, pStubMsg->MaxCount);
2211     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
2212
2213     validate_string_data(pStubMsg, bufsize, esize);
2214
2215     safe_buffer_increment(pStubMsg, bufsize);
2216     pStubMsg->MemorySize += memsize;
2217     break;
2218   default:
2219     ERR("unknown array format 0x%x\n", fc);
2220     RpcRaiseException(RPC_X_BAD_STUB_DATA);
2221   }
2222 }
2223
2224 static inline void array_free(
2225     unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg,
2226     unsigned char *pMemory, PFORMAT_STRING pFormat, unsigned char fHasPointers)
2227 {
2228   switch (fc)
2229   {
2230   case RPC_FC_CARRAY:
2231     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
2232     if (fHasPointers)
2233       EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
2234     break;
2235   case RPC_FC_CVARRAY:
2236     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
2237     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
2238     if (fHasPointers)
2239       EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
2240     break;
2241   case RPC_FC_C_CSTRING:
2242   case RPC_FC_C_WSTRING:
2243     /* No embedded pointers so nothing to do */
2244     break;
2245   default:
2246     ERR("unknown array format 0x%x\n", fc);
2247     RpcRaiseException(RPC_X_BAD_STUB_DATA);
2248   }
2249 }
2250
2251 /*
2252  * NdrConformantString:
2253  *
2254  * What MS calls a ConformantString is, in DCE terminology,
2255  * a Varying-Conformant String.
2256  * [
2257  *   maxlen: DWORD (max # of CHARTYPE characters, inclusive of '\0')
2258  *   offset: DWORD (actual string data begins at (offset) CHARTYPE's
2259  *           into unmarshalled string)
2260  *   length: DWORD (# of CHARTYPE characters, inclusive of '\0')
2261  *   [
2262  *     data: CHARTYPE[maxlen]
2263  *   ]
2264  * ], where CHARTYPE is the appropriate character type (specified externally)
2265  *
2266  */
2267
2268 /***********************************************************************
2269  *            NdrConformantStringMarshall [RPCRT4.@]
2270  */
2271 unsigned char *WINAPI NdrConformantStringMarshall(MIDL_STUB_MESSAGE *pStubMsg,
2272   unsigned char *pszMessage, PFORMAT_STRING pFormat)
2273 {
2274   TRACE("(pStubMsg == ^%p, pszMessage == ^%p, pFormat == ^%p)\n", pStubMsg, pszMessage, pFormat);
2275
2276   if (pFormat[0] != RPC_FC_C_CSTRING && pFormat[0] != RPC_FC_C_WSTRING) {
2277     ERR("Unhandled string type: %#x\n", pFormat[0]);
2278     RpcRaiseException(RPC_X_BAD_STUB_DATA);
2279   }
2280
2281   /* allow compiler to optimise inline function by passing constant into
2282    * these functions */
2283   if (pFormat[0] == RPC_FC_C_CSTRING) {
2284     array_compute_and_write_conformance(RPC_FC_C_CSTRING, pStubMsg, pszMessage,
2285                                         pFormat);
2286     array_write_variance_and_marshall(RPC_FC_C_CSTRING, pStubMsg, pszMessage,
2287                                       pFormat, TRUE /* fHasPointers */);
2288   } else {
2289     array_compute_and_write_conformance(RPC_FC_C_WSTRING, pStubMsg, pszMessage,
2290                                         pFormat);
2291     array_write_variance_and_marshall(RPC_FC_C_WSTRING, pStubMsg, pszMessage,
2292                                       pFormat, TRUE /* fHasPointers */);
2293   }
2294
2295   return NULL;
2296 }
2297
2298 /***********************************************************************
2299  *           NdrConformantStringBufferSize [RPCRT4.@]
2300  */
2301 void WINAPI NdrConformantStringBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2302   unsigned char* pMemory, PFORMAT_STRING pFormat)
2303 {
2304   TRACE("(pStubMsg == ^%p, pMemory == ^%p, pFormat == ^%p)\n", pStubMsg, pMemory, pFormat);
2305
2306   if (pFormat[0] != RPC_FC_C_CSTRING && pFormat[0] != RPC_FC_C_WSTRING) {
2307     ERR("Unhandled string type: %#x\n", pFormat[0]);
2308     RpcRaiseException(RPC_X_BAD_STUB_DATA);
2309   }
2310
2311   /* allow compiler to optimise inline function by passing constant into
2312    * these functions */
2313   if (pFormat[0] == RPC_FC_C_CSTRING) {
2314     array_compute_and_size_conformance(RPC_FC_C_CSTRING, pStubMsg, pMemory,
2315                                        pFormat);
2316     array_buffer_size(RPC_FC_C_CSTRING, pStubMsg, pMemory, pFormat,
2317                       TRUE /* fHasPointers */);
2318   } else {
2319     array_compute_and_size_conformance(RPC_FC_C_WSTRING, pStubMsg, pMemory,
2320                                        pFormat);
2321     array_buffer_size(RPC_FC_C_WSTRING, pStubMsg, pMemory, pFormat,
2322                       TRUE /* fHasPointers */);
2323   }
2324 }
2325
2326 /************************************************************************
2327  *            NdrConformantStringMemorySize [RPCRT4.@]
2328  */
2329 ULONG WINAPI NdrConformantStringMemorySize( PMIDL_STUB_MESSAGE pStubMsg,
2330   PFORMAT_STRING pFormat )
2331 {
2332   TRACE("(pStubMsg == ^%p, pFormat == ^%p)\n", pStubMsg, pFormat);
2333
2334   if (pFormat[0] != RPC_FC_C_CSTRING && pFormat[0] != RPC_FC_C_WSTRING) {
2335     ERR("Unhandled string type: %#x\n", pFormat[0]);
2336     RpcRaiseException(RPC_X_BAD_STUB_DATA);
2337   }
2338
2339   /* allow compiler to optimise inline function by passing constant into
2340    * these functions */
2341   if (pFormat[0] == RPC_FC_C_CSTRING) {
2342     array_read_conformance(RPC_FC_C_CSTRING, pStubMsg, pFormat);
2343     array_memory_size(RPC_FC_C_CSTRING, pStubMsg, pFormat,
2344                       TRUE /* fHasPointers */);
2345   } else {
2346     array_read_conformance(RPC_FC_C_WSTRING, pStubMsg, pFormat);
2347     array_memory_size(RPC_FC_C_WSTRING, pStubMsg, pFormat,
2348                       TRUE /* fHasPointers */);
2349   }
2350
2351   return pStubMsg->MemorySize;
2352 }
2353
2354 /************************************************************************
2355  *           NdrConformantStringUnmarshall [RPCRT4.@]
2356  */
2357 unsigned char *WINAPI NdrConformantStringUnmarshall( PMIDL_STUB_MESSAGE pStubMsg,
2358   unsigned char** ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc )
2359 {
2360   TRACE("(pStubMsg == ^%p, *pMemory == ^%p, pFormat == ^%p, fMustAlloc == %u)\n",
2361     pStubMsg, *ppMemory, pFormat, fMustAlloc);
2362
2363   if (pFormat[0] != RPC_FC_C_CSTRING && pFormat[0] != RPC_FC_C_WSTRING) {
2364     ERR("Unhandled string type: %#x\n", *pFormat);
2365     RpcRaiseException(RPC_X_BAD_STUB_DATA);
2366   }
2367
2368   /* allow compiler to optimise inline function by passing constant into
2369    * these functions */
2370   if (pFormat[0] == RPC_FC_C_CSTRING) {
2371     array_read_conformance(RPC_FC_C_CSTRING, pStubMsg, pFormat);
2372     array_read_variance_and_unmarshall(RPC_FC_C_CSTRING, pStubMsg, ppMemory,
2373                                        pFormat, fMustAlloc,
2374                                        TRUE /* fUseBufferMemoryServer */,
2375                                        TRUE /* fUnmarshall */);
2376   } else {
2377     array_read_conformance(RPC_FC_C_WSTRING, pStubMsg, pFormat);
2378     array_read_variance_and_unmarshall(RPC_FC_C_WSTRING, pStubMsg, ppMemory,
2379                                        pFormat, fMustAlloc,
2380                                        TRUE /* fUseBufferMemoryServer */,
2381                                        TRUE /* fUnmarshall */);
2382   }
2383
2384   return NULL;
2385 }
2386
2387 /***********************************************************************
2388  *           NdrNonConformantStringMarshall [RPCRT4.@]
2389  */
2390 unsigned char *  WINAPI NdrNonConformantStringMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2391                                 unsigned char *pMemory,
2392                                 PFORMAT_STRING pFormat)
2393 {
2394   ULONG esize, size, maxsize;
2395
2396   TRACE("(pStubMsg == ^%p, pMemory == ^%p, pFormat == ^%p)\n", pStubMsg, pMemory, pFormat);
2397
2398   maxsize = *(USHORT *)&pFormat[2];
2399
2400   if (*pFormat == RPC_FC_CSTRING)
2401   {
2402     ULONG i;
2403     const char *str = (const char *)pMemory;
2404     for (i = 0; i < maxsize && *str; i++, str++)
2405         ;
2406     TRACE("string=%s\n", debugstr_an(str, i));
2407     pStubMsg->ActualCount = i + 1;
2408     esize = 1;
2409   }
2410   else if (*pFormat == RPC_FC_WSTRING)
2411   {
2412     ULONG i;
2413     const WCHAR *str = (const WCHAR *)pMemory;
2414     for (i = 0; i < maxsize && *str; i++, str++)
2415         ;
2416     TRACE("string=%s\n", debugstr_wn(str, i));
2417     pStubMsg->ActualCount = i + 1;
2418     esize = 2;
2419   }
2420   else
2421   {
2422     ERR("Unhandled string type: %#x\n", *pFormat);
2423     RpcRaiseException(RPC_X_BAD_STUB_DATA);
2424   }
2425
2426   pStubMsg->Offset = 0;
2427   WriteVariance(pStubMsg);
2428
2429   size = safe_multiply(esize, pStubMsg->ActualCount);
2430   safe_copy_to_buffer(pStubMsg, pMemory, size); /* the string itself */
2431
2432   return NULL;
2433 }
2434
2435 /***********************************************************************
2436  *           NdrNonConformantStringUnmarshall [RPCRT4.@]
2437  */
2438 unsigned char *  WINAPI NdrNonConformantStringUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2439                                 unsigned char **ppMemory,
2440                                 PFORMAT_STRING pFormat,
2441                                 unsigned char fMustAlloc)
2442 {
2443   ULONG bufsize, memsize, esize, maxsize;
2444
2445   TRACE("(pStubMsg == ^%p, *pMemory == ^%p, pFormat == ^%p, fMustAlloc == %u)\n",
2446     pStubMsg, *ppMemory, pFormat, fMustAlloc);
2447
2448   maxsize = *(USHORT *)&pFormat[2];
2449
2450   ReadVariance(pStubMsg, NULL, maxsize);
2451   if (pStubMsg->Offset)
2452   {
2453     ERR("non-conformant strings can't have Offset (%d)\n", pStubMsg->Offset);
2454     RpcRaiseException(RPC_S_INVALID_BOUND);
2455   }
2456
2457   if (*pFormat == RPC_FC_CSTRING) esize = 1;
2458   else if (*pFormat == RPC_FC_WSTRING) esize = 2;
2459   else
2460   {
2461     ERR("Unhandled string type: %#x\n", *pFormat);
2462     RpcRaiseException(RPC_X_BAD_STUB_DATA);
2463   }
2464
2465   memsize = esize * maxsize;
2466   bufsize = safe_multiply(esize, pStubMsg->ActualCount);
2467
2468   validate_string_data(pStubMsg, bufsize, esize);
2469
2470   if (!fMustAlloc && !*ppMemory)
2471     fMustAlloc = TRUE;
2472   if (fMustAlloc)
2473     *ppMemory = NdrAllocate(pStubMsg, memsize);
2474
2475   safe_copy_from_buffer(pStubMsg, *ppMemory, bufsize);
2476
2477   if (*pFormat == RPC_FC_CSTRING) {
2478     TRACE("string=%s\n", debugstr_an((char*)*ppMemory, pStubMsg->ActualCount));
2479   }
2480   else if (*pFormat == RPC_FC_WSTRING) {
2481     TRACE("string=%s\n", debugstr_wn((LPWSTR)*ppMemory, pStubMsg->ActualCount));
2482   }
2483
2484   return NULL;
2485 }
2486
2487 /***********************************************************************
2488  *           NdrNonConformantStringBufferSize [RPCRT4.@]
2489  */
2490 void WINAPI NdrNonConformantStringBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2491                                 unsigned char *pMemory,
2492                                 PFORMAT_STRING pFormat)
2493 {
2494   ULONG esize, maxsize;
2495
2496   TRACE("(pStubMsg == ^%p, pMemory == ^%p, pFormat == ^%p)\n", pStubMsg, pMemory, pFormat);
2497
2498   maxsize = *(USHORT *)&pFormat[2];
2499
2500   SizeVariance(pStubMsg);
2501
2502   if (*pFormat == RPC_FC_CSTRING)
2503   {
2504     ULONG i;
2505     const char *str = (const char *)pMemory;
2506     for (i = 0; i < maxsize && *str; i++, str++)
2507         ;
2508     TRACE("string=%s\n", debugstr_an(str, i));
2509     pStubMsg->ActualCount = i + 1;
2510     esize = 1;
2511   }
2512   else if (*pFormat == RPC_FC_WSTRING)
2513   {
2514     ULONG i;
2515     const WCHAR *str = (const WCHAR *)pMemory;
2516     for (i = 0; i < maxsize && *str; i++, str++)
2517         ;
2518     TRACE("string=%s\n", debugstr_wn(str, i));
2519     pStubMsg->ActualCount = i + 1;
2520     esize = 2;
2521   }
2522   else
2523   {
2524     ERR("Unhandled string type: %#x\n", *pFormat);
2525     RpcRaiseException(RPC_X_BAD_STUB_DATA);
2526   }
2527
2528   safe_buffer_length_increment(pStubMsg, safe_multiply(esize, pStubMsg->ActualCount));
2529 }
2530
2531 /***********************************************************************
2532  *           NdrNonConformantStringMemorySize [RPCRT4.@]
2533  */
2534 ULONG WINAPI NdrNonConformantStringMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2535                                 PFORMAT_STRING pFormat)
2536 {
2537   ULONG bufsize, memsize, esize, maxsize;
2538
2539   TRACE("(pStubMsg == ^%p, pFormat == ^%p)\n", pStubMsg, pFormat);
2540
2541   maxsize = *(USHORT *)&pFormat[2];
2542
2543   ReadVariance(pStubMsg, NULL, maxsize);
2544
2545   if (pStubMsg->Offset)
2546   {
2547     ERR("non-conformant strings can't have Offset (%d)\n", pStubMsg->Offset);
2548     RpcRaiseException(RPC_S_INVALID_BOUND);
2549   }
2550
2551   if (*pFormat == RPC_FC_CSTRING) esize = 1;
2552   else if (*pFormat == RPC_FC_WSTRING) esize = 2;
2553   else
2554   {
2555     ERR("Unhandled string type: %#x\n", *pFormat);
2556     RpcRaiseException(RPC_X_BAD_STUB_DATA);
2557   }
2558
2559   memsize = esize * maxsize;
2560   bufsize = safe_multiply(esize, pStubMsg->ActualCount);
2561
2562   validate_string_data(pStubMsg, bufsize, esize);
2563
2564   safe_buffer_increment(pStubMsg, bufsize);
2565   pStubMsg->MemorySize += memsize;
2566
2567   return pStubMsg->MemorySize;
2568 }
2569
2570 /* Complex types */
2571
2572 #include "pshpack1.h"
2573 typedef struct
2574 {
2575     unsigned char type;
2576     unsigned char flags_type; /* flags in upper nibble, type in lower nibble */
2577     ULONG low_value;
2578     ULONG high_value;
2579 } NDR_RANGE;
2580 #include "poppack.h"
2581
2582 static ULONG EmbeddedComplexSize(MIDL_STUB_MESSAGE *pStubMsg,
2583                                  PFORMAT_STRING pFormat)
2584 {
2585   switch (*pFormat) {
2586   case RPC_FC_STRUCT:
2587   case RPC_FC_PSTRUCT:
2588   case RPC_FC_CSTRUCT:
2589   case RPC_FC_BOGUS_STRUCT:
2590   case RPC_FC_SMFARRAY:
2591   case RPC_FC_SMVARRAY:
2592   case RPC_FC_CSTRING:
2593     return *(const WORD*)&pFormat[2];
2594   case RPC_FC_USER_MARSHAL:
2595     return *(const WORD*)&pFormat[4];
2596   case RPC_FC_RANGE: {
2597     switch (((const NDR_RANGE *)pFormat)->flags_type & 0xf) {
2598     case RPC_FC_BYTE:
2599     case RPC_FC_CHAR:
2600     case RPC_FC_SMALL:
2601     case RPC_FC_USMALL:
2602         return sizeof(UCHAR);
2603     case RPC_FC_WCHAR:
2604     case RPC_FC_SHORT:
2605     case RPC_FC_USHORT:
2606         return sizeof(USHORT);
2607     case RPC_FC_LONG:
2608     case RPC_FC_ULONG:
2609     case RPC_FC_ENUM32:
2610         return sizeof(ULONG);
2611     case RPC_FC_FLOAT:
2612         return sizeof(float);
2613     case RPC_FC_DOUBLE:
2614         return sizeof(double);
2615     case RPC_FC_HYPER:
2616         return sizeof(ULONGLONG);
2617     case RPC_FC_ENUM16:
2618         return sizeof(UINT);
2619     default:
2620         ERR("unknown type 0x%x\n", ((const NDR_RANGE *)pFormat)->flags_type & 0xf);
2621         RpcRaiseException(RPC_X_BAD_STUB_DATA);
2622     }
2623   }
2624   case RPC_FC_NON_ENCAPSULATED_UNION:
2625     pFormat += 2;
2626     if (pStubMsg->fHasNewCorrDesc)
2627         pFormat += 6;
2628     else
2629         pFormat += 4;
2630
2631     pFormat += *(const SHORT*)pFormat;
2632     return *(const SHORT*)pFormat;
2633   case RPC_FC_IP:
2634     return sizeof(void *);
2635   case RPC_FC_WSTRING:
2636     return *(const WORD*)&pFormat[2] * 2;
2637   default:
2638     FIXME("unhandled embedded type %02x\n", *pFormat);
2639   }
2640   return 0;
2641 }
2642
2643
2644 static ULONG EmbeddedComplexMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2645                                        PFORMAT_STRING pFormat)
2646 {
2647   NDR_MEMORYSIZE m = NdrMemorySizer[*pFormat & NDR_TABLE_MASK];
2648
2649   if (!m)
2650   {
2651     FIXME("no memorysizer for data type=%02x\n", *pFormat);
2652     return 0;
2653   }
2654
2655   return m(pStubMsg, pFormat);
2656 }
2657
2658
2659 static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2660                                        unsigned char *pMemory,
2661                                        PFORMAT_STRING pFormat,
2662                                        PFORMAT_STRING pPointer)
2663 {
2664   PFORMAT_STRING desc;
2665   NDR_MARSHALL m;
2666   ULONG size;
2667
2668   while (*pFormat != RPC_FC_END) {
2669     switch (*pFormat) {
2670     case RPC_FC_BYTE:
2671     case RPC_FC_CHAR:
2672     case RPC_FC_SMALL:
2673     case RPC_FC_USMALL:
2674       TRACE("byte=%d <= %p\n", *(WORD*)pMemory, pMemory);
2675       safe_copy_to_buffer(pStubMsg, pMemory, 1);
2676       pMemory += 1;
2677       break;
2678     case RPC_FC_WCHAR:
2679     case RPC_FC_SHORT:
2680     case RPC_FC_USHORT:
2681       TRACE("short=%d <= %p\n", *(WORD*)pMemory, pMemory);
2682       safe_copy_to_buffer(pStubMsg, pMemory, 2);
2683       pMemory += 2;
2684       break;
2685     case RPC_FC_ENUM16:
2686       TRACE("enum16=%d <= %p\n", *(DWORD*)pMemory, pMemory);
2687       if (32767 < *(DWORD*)pMemory)
2688         RpcRaiseException(RPC_X_ENUM_VALUE_OUT_OF_RANGE);
2689       safe_copy_to_buffer(pStubMsg, pMemory, 2);
2690       pMemory += 4;
2691       break;
2692     case RPC_FC_LONG:
2693     case RPC_FC_ULONG:
2694     case RPC_FC_ENUM32:
2695       TRACE("long=%d <= %p\n", *(DWORD*)pMemory, pMemory);
2696       safe_copy_to_buffer(pStubMsg, pMemory, 4);
2697       pMemory += 4;
2698       break;
2699     case RPC_FC_HYPER:
2700       TRACE("longlong=%s <= %p\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory), pMemory);
2701       safe_copy_to_buffer(pStubMsg, pMemory, 8);
2702       pMemory += 8;
2703       break;
2704     case RPC_FC_POINTER:
2705     {
2706       unsigned char *saved_buffer;
2707       int pointer_buffer_mark_set = 0;
2708       TRACE("pointer=%p <= %p\n", *(unsigned char**)pMemory, pMemory);
2709       TRACE("pStubMsg->Buffer before %p\n", pStubMsg->Buffer);
2710       if (*pPointer != RPC_FC_RP)
2711         ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
2712       saved_buffer = pStubMsg->Buffer;
2713       if (pStubMsg->PointerBufferMark)
2714       {
2715         pStubMsg->Buffer = pStubMsg->PointerBufferMark;
2716         pStubMsg->PointerBufferMark = NULL;
2717         pointer_buffer_mark_set = 1;
2718       }
2719       else if (*pPointer != RPC_FC_RP)
2720         safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
2721       PointerMarshall(pStubMsg, saved_buffer, *(unsigned char**)pMemory, pPointer);
2722       if (pointer_buffer_mark_set)
2723       {
2724         STD_OVERFLOW_CHECK(pStubMsg);
2725         pStubMsg->PointerBufferMark = pStubMsg->Buffer;
2726         pStubMsg->Buffer = saved_buffer;
2727         if (*pPointer != RPC_FC_RP)
2728           safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
2729       }
2730       TRACE("pStubMsg->Buffer after %p\n", pStubMsg->Buffer);
2731       pPointer += 4;
2732       pMemory += sizeof(void *);
2733       break;
2734     }
2735     case RPC_FC_ALIGNM2:
2736       ALIGN_POINTER(pMemory, 2);
2737       break;
2738     case RPC_FC_ALIGNM4:
2739       ALIGN_POINTER(pMemory, 4);
2740       break;
2741     case RPC_FC_ALIGNM8:
2742       ALIGN_POINTER(pMemory, 8);
2743       break;
2744     case RPC_FC_STRUCTPAD1:
2745     case RPC_FC_STRUCTPAD2:
2746     case RPC_FC_STRUCTPAD3:
2747     case RPC_FC_STRUCTPAD4:
2748     case RPC_FC_STRUCTPAD5:
2749     case RPC_FC_STRUCTPAD6:
2750     case RPC_FC_STRUCTPAD7:
2751       pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
2752       break;
2753     case RPC_FC_EMBEDDED_COMPLEX:
2754       pMemory += pFormat[1];
2755       pFormat += 2;
2756       desc = pFormat + *(const SHORT*)pFormat;
2757       size = EmbeddedComplexSize(pStubMsg, desc);
2758       TRACE("embedded complex (size=%d) <= %p\n", size, pMemory);
2759       m = NdrMarshaller[*desc & NDR_TABLE_MASK];
2760       if (m)
2761       {
2762         /* for some reason interface pointers aren't generated as
2763          * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet
2764          * they still need the derefencing treatment that pointers are
2765          * given */
2766         if (*desc == RPC_FC_IP)
2767           m(pStubMsg, *(unsigned char **)pMemory, desc);
2768         else
2769           m(pStubMsg, pMemory, desc);
2770       }
2771       else FIXME("no marshaller for embedded type %02x\n", *desc);
2772       pMemory += size;
2773       pFormat += 2;
2774       continue;
2775     case RPC_FC_PAD:
2776       break;
2777     default:
2778       FIXME("unhandled format 0x%02x\n", *pFormat);
2779     }
2780     pFormat++;
2781   }
2782
2783   return pMemory;
2784 }
2785
2786 static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2787                                          unsigned char *pMemory,
2788                                          PFORMAT_STRING pFormat,
2789                                          PFORMAT_STRING pPointer,
2790                                          unsigned char fMustAlloc)
2791 {
2792   PFORMAT_STRING desc;
2793   NDR_UNMARSHALL m;
2794   ULONG size;
2795
2796   while (*pFormat != RPC_FC_END) {
2797     switch (*pFormat) {
2798     case RPC_FC_BYTE:
2799     case RPC_FC_CHAR:
2800     case RPC_FC_SMALL:
2801     case RPC_FC_USMALL:
2802       safe_copy_from_buffer(pStubMsg, pMemory, 1);
2803       TRACE("byte=%d => %p\n", *(WORD*)pMemory, pMemory);
2804       pMemory += 1;
2805       break;
2806     case RPC_FC_WCHAR:
2807     case RPC_FC_SHORT:
2808     case RPC_FC_USHORT:
2809       safe_copy_from_buffer(pStubMsg, pMemory, 2);
2810       TRACE("short=%d => %p\n", *(WORD*)pMemory, pMemory);
2811       pMemory += 2;
2812       break;
2813     case RPC_FC_ENUM16:
2814       safe_copy_from_buffer(pStubMsg, pMemory, 2);
2815       *(DWORD*)pMemory &= 0xffff;
2816       TRACE("enum16=%d => %p\n", *(DWORD*)pMemory, pMemory);
2817       if (32767 < *(DWORD*)pMemory)
2818         RpcRaiseException(RPC_X_ENUM_VALUE_OUT_OF_RANGE);
2819       pMemory += 4;
2820       break;
2821     case RPC_FC_LONG:
2822     case RPC_FC_ULONG:
2823     case RPC_FC_ENUM32:
2824       safe_copy_from_buffer(pStubMsg, pMemory, 4);
2825       TRACE("long=%d => %p\n", *(DWORD*)pMemory, pMemory);
2826       pMemory += 4;
2827       break;
2828     case RPC_FC_HYPER:
2829       safe_copy_from_buffer(pStubMsg, pMemory, 8);
2830       TRACE("longlong=%s => %p\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory), pMemory);
2831       pMemory += 8;
2832       break;
2833     case RPC_FC_POINTER:
2834     {
2835       unsigned char *saved_buffer;
2836       int pointer_buffer_mark_set = 0;
2837       TRACE("pointer => %p\n", pMemory);
2838       if (*pPointer != RPC_FC_RP)
2839         ALIGN_POINTER(pStubMsg->Buffer, 4);
2840       saved_buffer = pStubMsg->Buffer;
2841       if (pStubMsg->PointerBufferMark)
2842       {
2843         pStubMsg->Buffer = pStubMsg->PointerBufferMark;
2844         pStubMsg->PointerBufferMark = NULL;
2845         pointer_buffer_mark_set = 1;
2846       }
2847       else if (*pPointer != RPC_FC_RP)
2848         safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
2849
2850       PointerUnmarshall(pStubMsg, saved_buffer, (unsigned char**)pMemory, *(unsigned char**)pMemory, pPointer, fMustAlloc);
2851       if (pointer_buffer_mark_set)
2852       {
2853         STD_OVERFLOW_CHECK(pStubMsg);
2854         pStubMsg->PointerBufferMark = pStubMsg->Buffer;
2855         pStubMsg->Buffer = saved_buffer;
2856         if (*pPointer != RPC_FC_RP)
2857           safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
2858       }
2859       pPointer += 4;
2860       pMemory += sizeof(void *);
2861       break;
2862     }
2863     case RPC_FC_ALIGNM2:
2864       ALIGN_POINTER_CLEAR(pMemory, 2);
2865       break;
2866     case RPC_FC_ALIGNM4:
2867       ALIGN_POINTER_CLEAR(pMemory, 4);
2868       break;
2869     case RPC_FC_ALIGNM8:
2870       ALIGN_POINTER_CLEAR(pMemory, 8);
2871       break;
2872     case RPC_FC_STRUCTPAD1:
2873     case RPC_FC_STRUCTPAD2:
2874     case RPC_FC_STRUCTPAD3:
2875     case RPC_FC_STRUCTPAD4:
2876     case RPC_FC_STRUCTPAD5:
2877     case RPC_FC_STRUCTPAD6:
2878     case RPC_FC_STRUCTPAD7:
2879       memset(pMemory, 0, *pFormat - RPC_FC_STRUCTPAD1 + 1);
2880       pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
2881       break;
2882     case RPC_FC_EMBEDDED_COMPLEX:
2883       pMemory += pFormat[1];
2884       pFormat += 2;
2885       desc = pFormat + *(const SHORT*)pFormat;
2886       size = EmbeddedComplexSize(pStubMsg, desc);
2887       TRACE("embedded complex (size=%d) => %p\n", size, pMemory);
2888       if (fMustAlloc)
2889         /* we can't pass fMustAlloc=TRUE into the marshaller for this type
2890          * since the type is part of the memory block that is encompassed by
2891          * the whole complex type. Memory is forced to allocate when pointers
2892          * are set to NULL, so we emulate that part of fMustAlloc=TRUE by
2893          * clearing the memory we pass in to the unmarshaller */
2894         memset(pMemory, 0, size);
2895       m = NdrUnmarshaller[*desc & NDR_TABLE_MASK];
2896       if (m)
2897       {
2898         /* for some reason interface pointers aren't generated as
2899          * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet
2900          * they still need the derefencing treatment that pointers are
2901          * given */
2902         if (*desc == RPC_FC_IP)
2903           m(pStubMsg, (unsigned char **)pMemory, desc, FALSE);
2904         else
2905           m(pStubMsg, &pMemory, desc, FALSE);
2906       }
2907       else FIXME("no unmarshaller for embedded type %02x\n", *desc);
2908       pMemory += size;
2909       pFormat += 2;
2910       continue;
2911     case RPC_FC_PAD:
2912       break;
2913     default:
2914       FIXME("unhandled format %d\n", *pFormat);
2915     }
2916     pFormat++;
2917   }
2918
2919   return pMemory;
2920 }
2921
2922 static unsigned char * ComplexBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2923                                          unsigned char *pMemory,
2924                                          PFORMAT_STRING pFormat,
2925                                          PFORMAT_STRING pPointer)
2926 {
2927   PFORMAT_STRING desc;
2928   NDR_BUFFERSIZE m;
2929   ULONG size;
2930
2931   while (*pFormat != RPC_FC_END) {
2932     switch (*pFormat) {
2933     case RPC_FC_BYTE:
2934     case RPC_FC_CHAR:
2935     case RPC_FC_SMALL:
2936     case RPC_FC_USMALL:
2937       safe_buffer_length_increment(pStubMsg, 1);
2938       pMemory += 1;
2939       break;
2940     case RPC_FC_WCHAR:
2941     case RPC_FC_SHORT:
2942     case RPC_FC_USHORT:
2943       safe_buffer_length_increment(pStubMsg, 2);
2944       pMemory += 2;
2945       break;
2946     case RPC_FC_ENUM16:
2947       safe_buffer_length_increment(pStubMsg, 2);
2948       pMemory += 4;
2949       break;
2950     case RPC_FC_LONG:
2951     case RPC_FC_ULONG:
2952     case RPC_FC_ENUM32:
2953       safe_buffer_length_increment(pStubMsg, 4);
2954       pMemory += 4;
2955       break;
2956     case RPC_FC_HYPER:
2957       safe_buffer_length_increment(pStubMsg, 8);
2958       pMemory += 8;
2959       break;
2960     case RPC_FC_POINTER:
2961       if (!pStubMsg->IgnoreEmbeddedPointers)
2962       {
2963         int saved_buffer_length = pStubMsg->BufferLength;
2964         pStubMsg->BufferLength = pStubMsg->PointerLength;
2965         pStubMsg->PointerLength = 0;
2966         if(!pStubMsg->BufferLength)
2967           ERR("BufferLength == 0??\n");
2968         PointerBufferSize(pStubMsg, *(unsigned char**)pMemory, pPointer);
2969         pStubMsg->PointerLength = pStubMsg->BufferLength;
2970         pStubMsg->BufferLength = saved_buffer_length;
2971       }
2972       if (*pPointer != RPC_FC_RP)
2973       {
2974         ALIGN_LENGTH(pStubMsg->BufferLength, 4);
2975         safe_buffer_length_increment(pStubMsg, 4);
2976       }
2977       pPointer += 4;
2978       pMemory += sizeof(void*);
2979       break;
2980     case RPC_FC_ALIGNM2:
2981       ALIGN_POINTER(pMemory, 2);
2982       break;
2983     case RPC_FC_ALIGNM4:
2984       ALIGN_POINTER(pMemory, 4);
2985       break;
2986     case RPC_FC_ALIGNM8:
2987       ALIGN_POINTER(pMemory, 8);
2988       break;
2989     case RPC_FC_STRUCTPAD1:
2990     case RPC_FC_STRUCTPAD2:
2991     case RPC_FC_STRUCTPAD3:
2992     case RPC_FC_STRUCTPAD4:
2993     case RPC_FC_STRUCTPAD5:
2994     case RPC_FC_STRUCTPAD6:
2995     case RPC_FC_STRUCTPAD7:
2996       pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
2997       break;
2998     case RPC_FC_EMBEDDED_COMPLEX:
2999       pMemory += pFormat[1];
3000       pFormat += 2;
3001       desc = pFormat + *(const SHORT*)pFormat;
3002       size = EmbeddedComplexSize(pStubMsg, desc);
3003       m = NdrBufferSizer[*desc & NDR_TABLE_MASK];
3004       if (m)
3005       {
3006         /* for some reason interface pointers aren't generated as
3007          * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet
3008          * they still need the derefencing treatment that pointers are
3009          * given */
3010         if (*desc == RPC_FC_IP)
3011           m(pStubMsg, *(unsigned char **)pMemory, desc);
3012         else
3013           m(pStubMsg, pMemory, desc);
3014       }
3015       else FIXME("no buffersizer for embedded type %02x\n", *desc);
3016       pMemory += size;
3017       pFormat += 2;
3018       continue;
3019     case RPC_FC_PAD:
3020       break;
3021     default:
3022       FIXME("unhandled format 0x%02x\n", *pFormat);
3023     }
3024     pFormat++;
3025   }
3026
3027   return pMemory;
3028 }
3029
3030 static unsigned char * ComplexFree(PMIDL_STUB_MESSAGE pStubMsg,
3031                                    unsigned char *pMemory,
3032                                    PFORMAT_STRING pFormat,
3033                                    PFORMAT_STRING pPointer)
3034 {
3035   PFORMAT_STRING desc;
3036   NDR_FREE m;
3037   ULONG size;
3038
3039   while (*pFormat != RPC_FC_END) {
3040     switch (*pFormat) {
3041     case RPC_FC_BYTE:
3042     case RPC_FC_CHAR:
3043     case RPC_FC_SMALL:
3044     case RPC_FC_USMALL:
3045       pMemory += 1;
3046       break;
3047     case RPC_FC_WCHAR:
3048     case RPC_FC_SHORT:
3049     case RPC_FC_USHORT:
3050       pMemory += 2;
3051       break;
3052     case RPC_FC_LONG:
3053     case RPC_FC_ULONG:
3054     case RPC_FC_ENUM16:
3055     case RPC_FC_ENUM32:
3056       pMemory += 4;
3057       break;
3058     case RPC_FC_HYPER:
3059       pMemory += 8;
3060       break;
3061     case RPC_FC_POINTER:
3062       NdrPointerFree(pStubMsg, *(unsigned char**)pMemory, pPointer);
3063       pPointer += 4;
3064       pMemory += sizeof(void *);
3065       break;
3066     case RPC_FC_ALIGNM2:
3067       ALIGN_POINTER(pMemory, 2);
3068       break;
3069     case RPC_FC_ALIGNM4:
3070       ALIGN_POINTER(pMemory, 4);
3071       break;
3072     case RPC_FC_ALIGNM8:
3073       ALIGN_POINTER(pMemory, 8);
3074       break;
3075     case RPC_FC_STRUCTPAD1:
3076     case RPC_FC_STRUCTPAD2:
3077     case RPC_FC_STRUCTPAD3:
3078     case RPC_FC_STRUCTPAD4:
3079     case RPC_FC_STRUCTPAD5:
3080     case RPC_FC_STRUCTPAD6:
3081     case RPC_FC_STRUCTPAD7:
3082       pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
3083       break;
3084     case RPC_FC_EMBEDDED_COMPLEX:
3085       pMemory += pFormat[1];
3086       pFormat += 2;
3087       desc = pFormat + *(const SHORT*)pFormat;
3088       size = EmbeddedComplexSize(pStubMsg, desc);
3089       m = NdrFreer[*desc & NDR_TABLE_MASK];
3090       if (m)
3091       {
3092         /* for some reason interface pointers aren't generated as
3093          * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet
3094          * they still need the derefencing treatment that pointers are
3095          * given */
3096         if (*desc == RPC_FC_IP)
3097           m(pStubMsg, *(unsigned char **)pMemory, desc);
3098         else
3099           m(pStubMsg, pMemory, desc);
3100       }
3101       pMemory += size;
3102       pFormat += 2;
3103       continue;
3104     case RPC_FC_PAD:
3105       break;
3106     default:
3107       FIXME("unhandled format 0x%02x\n", *pFormat);
3108     }
3109     pFormat++;
3110   }
3111
3112   return pMemory;
3113 }
3114
3115 static ULONG ComplexStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
3116                                      PFORMAT_STRING pFormat,
3117                                      PFORMAT_STRING pPointer)
3118 {
3119   PFORMAT_STRING desc;
3120   ULONG size = 0;
3121
3122   while (*pFormat != RPC_FC_END) {
3123     switch (*pFormat) {
3124     case RPC_FC_BYTE:
3125     case RPC_FC_CHAR:
3126     case RPC_FC_SMALL:
3127     case RPC_FC_USMALL:
3128       size += 1;
3129       safe_buffer_increment(pStubMsg, 1);
3130       break;
3131     case RPC_FC_WCHAR:
3132     case RPC_FC_SHORT:
3133     case RPC_FC_USHORT:
3134       size += 2;
3135       safe_buffer_increment(pStubMsg, 2);
3136       break;
3137     case RPC_FC_ENUM16:
3138       size += 4;
3139       safe_buffer_increment(pStubMsg, 2);
3140       break;
3141     case RPC_FC_LONG:
3142     case RPC_FC_ULONG:
3143     case RPC_FC_ENUM32:
3144       size += 4;
3145       safe_buffer_increment(pStubMsg, 4);
3146       break;
3147     case RPC_FC_HYPER:
3148       size += 8;
3149       safe_buffer_increment(pStubMsg, 8);
3150       break;
3151     case RPC_FC_POINTER:
3152     {
3153       unsigned char *saved_buffer;
3154       int pointer_buffer_mark_set = 0;
3155       if (*pPointer != RPC_FC_RP)
3156         ALIGN_POINTER(pStubMsg->Buffer, 4);
3157       saved_buffer = pStubMsg->Buffer;
3158       if (pStubMsg->PointerBufferMark)
3159       {
3160         pStubMsg->Buffer = pStubMsg->PointerBufferMark;
3161         pStubMsg->PointerBufferMark = NULL;
3162         pointer_buffer_mark_set = 1;
3163       }
3164       else if (*pPointer != RPC_FC_RP)
3165         safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
3166
3167       if (!pStubMsg->IgnoreEmbeddedPointers)
3168         PointerMemorySize(pStubMsg, saved_buffer, pPointer);
3169       if (pointer_buffer_mark_set)
3170       {
3171         STD_OVERFLOW_CHECK(pStubMsg);
3172         pStubMsg->PointerBufferMark = pStubMsg->Buffer;
3173         pStubMsg->Buffer = saved_buffer;
3174         if (*pPointer != RPC_FC_RP)
3175           safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
3176       }
3177       pPointer += 4;
3178       size += sizeof(void *);
3179       break;
3180     }
3181     case RPC_FC_ALIGNM2:
3182       ALIGN_LENGTH(size, 2);
3183       break;
3184     case RPC_FC_ALIGNM4:
3185       ALIGN_LENGTH(size, 4);
3186       break;
3187     case RPC_FC_ALIGNM8:
3188       ALIGN_LENGTH(size, 8);
3189       break;
3190     case RPC_FC_STRUCTPAD1:
3191     case RPC_FC_STRUCTPAD2:
3192     case RPC_FC_STRUCTPAD3:
3193     case RPC_FC_STRUCTPAD4:
3194     case RPC_FC_STRUCTPAD5:
3195     case RPC_FC_STRUCTPAD6:
3196     case RPC_FC_STRUCTPAD7:
3197       size += *pFormat - RPC_FC_STRUCTPAD1 + 1;
3198       break;
3199     case RPC_FC_EMBEDDED_COMPLEX:
3200       size += pFormat[1];
3201       pFormat += 2;
3202       desc = pFormat + *(const SHORT*)pFormat;
3203       size += EmbeddedComplexMemorySize(pStubMsg, desc);
3204       pFormat += 2;
3205       continue;
3206     case RPC_FC_PAD:
3207       break;
3208     default:
3209       FIXME("unhandled format 0x%02x\n", *pFormat);
3210     }
3211     pFormat++;
3212   }
3213
3214   return size;
3215 }
3216
3217 ULONG ComplexStructSize(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
3218 {
3219   PFORMAT_STRING desc;
3220   ULONG size = 0;
3221
3222   while (*pFormat != RPC_FC_END) {
3223     switch (*pFormat) {
3224     case RPC_FC_BYTE:
3225     case RPC_FC_CHAR:
3226     case RPC_FC_SMALL:
3227     case RPC_FC_USMALL:
3228       size += 1;
3229       break;
3230     case RPC_FC_WCHAR:
3231     case RPC_FC_SHORT:
3232     case RPC_FC_USHORT:
3233       size += 2;
3234       break;
3235     case RPC_FC_LONG:
3236     case RPC_FC_ULONG:
3237     case RPC_FC_ENUM16:
3238     case RPC_FC_ENUM32:
3239       size += 4;
3240       break;
3241     case RPC_FC_HYPER:
3242       size += 8;
3243       break;
3244     case RPC_FC_POINTER:
3245       size += sizeof(void *);
3246       break;
3247     case RPC_FC_ALIGNM2:
3248       ALIGN_LENGTH(size, 2);
3249       break;
3250     case RPC_FC_ALIGNM4:
3251       ALIGN_LENGTH(size, 4);
3252       break;
3253     case RPC_FC_ALIGNM8:
3254       ALIGN_LENGTH(size, 8);
3255       break;
3256     case RPC_FC_STRUCTPAD1:
3257     case RPC_FC_STRUCTPAD2:
3258     case RPC_FC_STRUCTPAD3:
3259     case RPC_FC_STRUCTPAD4:
3260     case RPC_FC_STRUCTPAD5:
3261     case RPC_FC_STRUCTPAD6:
3262     case RPC_FC_STRUCTPAD7:
3263       size += *pFormat - RPC_FC_STRUCTPAD1 + 1;
3264       break;
3265     case RPC_FC_EMBEDDED_COMPLEX:
3266       size += pFormat[1];
3267       pFormat += 2;
3268       desc = pFormat + *(const SHORT*)pFormat;
3269       size += EmbeddedComplexSize(pStubMsg, desc);
3270       pFormat += 2;
3271       continue;
3272     case RPC_FC_PAD:
3273       break;
3274     default:
3275       FIXME("unhandled format 0x%02x\n", *pFormat);
3276     }
3277     pFormat++;
3278   }
3279
3280   return size;
3281 }
3282
3283 /***********************************************************************
3284  *           NdrComplexStructMarshall [RPCRT4.@]
3285  */
3286 unsigned char * WINAPI NdrComplexStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
3287                                                 unsigned char *pMemory,
3288                                                 PFORMAT_STRING pFormat)
3289 {
3290   PFORMAT_STRING conf_array = NULL;
3291   PFORMAT_STRING pointer_desc = NULL;
3292   unsigned char *OldMemory = pStubMsg->Memory;
3293   int pointer_buffer_mark_set = 0;
3294   ULONG count = 0;
3295   ULONG max_count = 0;
3296   ULONG offset = 0;
3297
3298   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3299
3300   if (!pStubMsg->PointerBufferMark)
3301   {
3302     int saved_ignore_embedded = pStubMsg->IgnoreEmbeddedPointers;
3303     /* save buffer length */
3304     ULONG saved_buffer_length = pStubMsg->BufferLength;
3305
3306     /* get the buffer pointer after complex array data, but before
3307      * pointer data */
3308     pStubMsg->BufferLength = pStubMsg->Buffer - (unsigned char *)pStubMsg->RpcMsg->Buffer;
3309     pStubMsg->IgnoreEmbeddedPointers = 1;
3310     NdrComplexStructBufferSize(pStubMsg, pMemory, pFormat);
3311     pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded;
3312
3313     /* save it for use by embedded pointer code later */
3314     pStubMsg->PointerBufferMark = (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength;
3315     TRACE("difference = 0x%x\n", (ULONG)(pStubMsg->PointerBufferMark - pStubMsg->Buffer));
3316     pointer_buffer_mark_set = 1;
3317
3318     /* restore the original buffer length */
3319     pStubMsg->BufferLength = saved_buffer_length;
3320   }
3321
3322   ALIGN_POINTER_CLEAR(pStubMsg->Buffer, pFormat[1] + 1);
3323
3324   pFormat += 4;
3325   if (*(const SHORT*)pFormat) conf_array = pFormat + *(const SHORT*)pFormat;
3326   pFormat += 2;
3327   if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
3328   pFormat += 2;
3329
3330   pStubMsg->Memory = pMemory;
3331
3332   if (conf_array)
3333   {
3334     ULONG struct_size = ComplexStructSize(pStubMsg, pFormat);
3335     array_compute_and_write_conformance(conf_array[0], pStubMsg,
3336                                         pMemory + struct_size, conf_array);
3337     /* these could be changed in ComplexMarshall so save them for later */
3338     max_count = pStubMsg->MaxCount;
3339     count = pStubMsg->ActualCount;
3340     offset = pStubMsg->Offset;
3341   }
3342
3343   pMemory = ComplexMarshall(pStubMsg, pMemory, pFormat, pointer_desc);
3344
3345   if (conf_array)
3346   {
3347     pStubMsg->MaxCount = max_count;
3348     pStubMsg->ActualCount = count;
3349     pStubMsg->Offset = offset;
3350     array_write_variance_and_marshall(conf_array[0], pStubMsg, pMemory,
3351                                       conf_array, TRUE /* fHasPointers */);
3352   }
3353
3354   pStubMsg->Memory = OldMemory;
3355
3356   if (pointer_buffer_mark_set)
3357   {
3358     pStubMsg->Buffer = pStubMsg->PointerBufferMark;
3359     pStubMsg->PointerBufferMark = NULL;
3360   }
3361
3362   STD_OVERFLOW_CHECK(pStubMsg);
3363
3364   return NULL;
3365 }
3366
3367 /***********************************************************************
3368  *           NdrComplexStructUnmarshall [RPCRT4.@]
3369  */
3370 unsigned char * WINAPI NdrComplexStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
3371                                                   unsigned char **ppMemory,
3372                                                   PFORMAT_STRING pFormat,
3373                                                   unsigned char fMustAlloc)
3374 {
3375   unsigned size = *(const WORD*)(pFormat+2);
3376   PFORMAT_STRING conf_array = NULL;
3377   PFORMAT_STRING pointer_desc = NULL;
3378   unsigned char *pMemory;
3379   int pointer_buffer_mark_set = 0;
3380   ULONG count = 0;
3381   ULONG max_count = 0;
3382   ULONG offset = 0;
3383   ULONG array_size = 0;
3384
3385   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
3386
3387   if (!pStubMsg->PointerBufferMark)
3388   {
3389     int saved_ignore_embedded = pStubMsg->IgnoreEmbeddedPointers;
3390     /* save buffer pointer */
3391     unsigned char *saved_buffer = pStubMsg->Buffer;
3392
3393     /* get the buffer pointer after complex array data, but before
3394      * pointer data */
3395     pStubMsg->IgnoreEmbeddedPointers = 1;
3396     NdrComplexStructMemorySize(pStubMsg, pFormat);
3397     pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded;
3398
3399     /* save it for use by embedded pointer code later */
3400     pStubMsg->PointerBufferMark = pStubMsg->Buffer;
3401     TRACE("difference = 0x%x\n", (ULONG)(pStubMsg->PointerBufferMark - saved_buffer));
3402     pointer_buffer_mark_set = 1;
3403
3404     /* restore the original buffer */
3405     pStubMsg->Buffer = saved_buffer;
3406   }
3407
3408   ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
3409
3410   pFormat += 4;
3411   if (*(const SHORT*)pFormat) conf_array = pFormat + *(const SHORT*)pFormat;
3412   pFormat += 2;
3413   if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
3414   pFormat += 2;
3415
3416   if (conf_array)
3417   {
3418     array_size = array_read_conformance(conf_array[0], pStubMsg, conf_array);
3419     size += array_size;
3420
3421     /* these could be changed in ComplexMarshall so save them for later */
3422     max_count = pStubMsg->MaxCount;
3423     count = pStubMsg->ActualCount;
3424     offset = pStubMsg->Offset;
3425   }
3426
3427   if (!fMustAlloc && !*ppMemory)
3428     fMustAlloc = TRUE;
3429   if (fMustAlloc)
3430     *ppMemory = NdrAllocate(pStubMsg, size);
3431
3432   pMemory = ComplexUnmarshall(pStubMsg, *ppMemory, pFormat, pointer_desc, fMustAlloc);
3433
3434   if (conf_array)
3435   {
3436     pStubMsg->MaxCount = max_count;
3437     pStubMsg->ActualCount = count;
3438     pStubMsg->Offset = offset;
3439     if (fMustAlloc)
3440       memset(pMemory, 0, array_size);
3441     array_read_variance_and_unmarshall(conf_array[0], pStubMsg, &pMemory,
3442                                        conf_array, FALSE,
3443                                        FALSE /* fUseBufferMemoryServer */,
3444                                        TRUE /* fUnmarshall */);
3445   }
3446
3447   if (pointer_buffer_mark_set)
3448   {
3449     pStubMsg->Buffer = pStubMsg->PointerBufferMark;
3450     pStubMsg->PointerBufferMark = NULL;
3451   }
3452
3453   return NULL;
3454 }
3455
3456 /***********************************************************************
3457  *           NdrComplexStructBufferSize [RPCRT4.@]
3458  */
3459 void WINAPI NdrComplexStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
3460                                        unsigned char *pMemory,
3461                                        PFORMAT_STRING pFormat)
3462 {
3463   PFORMAT_STRING conf_array = NULL;
3464   PFORMAT_STRING pointer_desc = NULL;
3465   unsigned char *OldMemory = pStubMsg->Memory;
3466   int pointer_length_set = 0;
3467   ULONG count = 0;
3468   ULONG max_count = 0;
3469   ULONG offset = 0;
3470
3471   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3472
3473   ALIGN_LENGTH(pStubMsg->BufferLength, pFormat[1] + 1);
3474
3475   if(!pStubMsg->IgnoreEmbeddedPointers && !pStubMsg->PointerLength)
3476   {
3477     int saved_ignore_embedded = pStubMsg->IgnoreEmbeddedPointers;
3478     ULONG saved_buffer_length = pStubMsg->BufferLength;
3479
3480     /* get the buffer length after complex struct data, but before
3481      * pointer data */
3482     pStubMsg->IgnoreEmbeddedPointers = 1;
3483     NdrComplexStructBufferSize(pStubMsg, pMemory, pFormat);
3484     pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded;
3485
3486     /* save it for use by embedded pointer code later */
3487     pStubMsg->PointerLength = pStubMsg->BufferLength;
3488     pointer_length_set = 1;
3489     TRACE("difference = 0x%x\n", pStubMsg->PointerLength - saved_buffer_length);
3490
3491     /* restore the original buffer length */
3492     pStubMsg->BufferLength = saved_buffer_length;
3493   }
3494
3495   pFormat += 4;
3496   if (*(const SHORT*)pFormat) conf_array = pFormat + *(const SHORT*)pFormat;
3497   pFormat += 2;
3498   if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
3499   pFormat += 2;
3500
3501   pStubMsg->Memory = pMemory;
3502
3503   if (conf_array)
3504   {
3505     ULONG struct_size = ComplexStructSize(pStubMsg, pFormat);
3506     array_compute_and_size_conformance(conf_array[0], pStubMsg, pMemory + struct_size,
3507                                        conf_array);
3508
3509     /* these could be changed in ComplexMarshall so save them for later */
3510     max_count = pStubMsg->MaxCount;
3511     count = pStubMsg->ActualCount;
3512     offset = pStubMsg->Offset;
3513   }
3514
3515   pMemory = ComplexBufferSize(pStubMsg, pMemory, pFormat, pointer_desc);
3516
3517   if (conf_array)
3518   {
3519     pStubMsg->MaxCount = max_count;
3520     pStubMsg->ActualCount = count;
3521     pStubMsg->Offset = offset;
3522     array_buffer_size(conf_array[0], pStubMsg, pMemory, conf_array,
3523                       TRUE /* fHasPointers */);
3524   }
3525
3526   pStubMsg->Memory = OldMemory;
3527
3528   if(pointer_length_set)
3529   {
3530     pStubMsg->BufferLength = pStubMsg->PointerLength;
3531     pStubMsg->PointerLength = 0;
3532   }
3533
3534 }
3535
3536 /***********************************************************************
3537  *           NdrComplexStructMemorySize [RPCRT4.@]
3538  */
3539 ULONG WINAPI NdrComplexStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
3540                                         PFORMAT_STRING pFormat)
3541 {
3542   unsigned size = *(const WORD*)(pFormat+2);
3543   PFORMAT_STRING conf_array = NULL;
3544   PFORMAT_STRING pointer_desc = NULL;
3545   ULONG count = 0;
3546   ULONG max_count = 0;
3547   ULONG offset = 0;
3548
3549   TRACE("(%p,%p)\n", pStubMsg, pFormat);
3550
3551   ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
3552
3553   pFormat += 4;
3554   if (*(const SHORT*)pFormat) conf_array = pFormat + *(const SHORT*)pFormat;
3555   pFormat += 2;
3556   if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
3557   pFormat += 2;
3558
3559   if (conf_array)
3560   {
3561     array_read_conformance(conf_array[0], pStubMsg, conf_array);
3562
3563     /* these could be changed in ComplexStructMemorySize so save them for
3564      * later */
3565     max_count = pStubMsg->MaxCount;
3566     count = pStubMsg->ActualCount;
3567     offset = pStubMsg->Offset;
3568   }
3569
3570   ComplexStructMemorySize(pStubMsg, pFormat, pointer_desc);
3571
3572   if (conf_array)
3573   {
3574     pStubMsg->MaxCount = max_count;
3575     pStubMsg->ActualCount = count;
3576     pStubMsg->Offset = offset;
3577     array_memory_size(conf_array[0], pStubMsg, conf_array,
3578                       TRUE /* fHasPointers */);
3579   }
3580
3581   return size;
3582 }
3583
3584 /***********************************************************************
3585  *           NdrComplexStructFree [RPCRT4.@]
3586  */
3587 void WINAPI NdrComplexStructFree(PMIDL_STUB_MESSAGE pStubMsg,
3588                                  unsigned char *pMemory,
3589                                  PFORMAT_STRING pFormat)
3590 {
3591   PFORMAT_STRING conf_array = NULL;
3592   PFORMAT_STRING pointer_desc = NULL;
3593   unsigned char *OldMemory = pStubMsg->Memory;
3594
3595   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3596
3597   pFormat += 4;
3598   if (*(const SHORT*)pFormat) conf_array = pFormat + *(const SHORT*)pFormat;
3599   pFormat += 2;
3600   if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
3601   pFormat += 2;
3602
3603   pStubMsg->Memory = pMemory;
3604
3605   pMemory = ComplexFree(pStubMsg, pMemory, pFormat, pointer_desc);
3606
3607   if (conf_array)
3608     array_free(conf_array[0], pStubMsg, pMemory, conf_array,
3609                TRUE /* fHasPointers */);
3610
3611   pStubMsg->Memory = OldMemory;
3612 }
3613
3614 /***********************************************************************
3615  *           NdrConformantArrayMarshall [RPCRT4.@]
3616  */
3617 unsigned char * WINAPI NdrConformantArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
3618                                                   unsigned char *pMemory,
3619                                                   PFORMAT_STRING pFormat)
3620 {
3621   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3622   if (pFormat[0] != RPC_FC_CARRAY)
3623   {
3624     ERR("invalid format = 0x%x\n", pFormat[0]);
3625     RpcRaiseException(RPC_X_BAD_STUB_DATA);
3626   }
3627
3628   array_compute_and_write_conformance(RPC_FC_CARRAY, pStubMsg, pMemory,
3629                                       pFormat);
3630   array_write_variance_and_marshall(RPC_FC_CARRAY, pStubMsg, pMemory, pFormat,
3631                                     TRUE /* fHasPointers */);
3632
3633   return NULL;
3634 }
3635
3636 /***********************************************************************
3637  *           NdrConformantArrayUnmarshall [RPCRT4.@]
3638  */
3639 unsigned char * WINAPI NdrConformantArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
3640                                                     unsigned char **ppMemory,
3641                                                     PFORMAT_STRING pFormat,
3642                                                     unsigned char fMustAlloc)
3643 {
3644   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
3645   if (pFormat[0] != RPC_FC_CARRAY)
3646   {
3647     ERR("invalid format = 0x%x\n", pFormat[0]);
3648     RpcRaiseException(RPC_X_BAD_STUB_DATA);
3649   }
3650
3651   array_read_conformance(RPC_FC_CARRAY, pStubMsg, pFormat);
3652   array_read_variance_and_unmarshall(RPC_FC_CARRAY, pStubMsg, ppMemory, pFormat,
3653                                      fMustAlloc,
3654                                      TRUE /* fUseBufferMemoryServer */,
3655                                      TRUE /* fUnmarshall */);
3656
3657   return NULL;
3658 }
3659
3660 /***********************************************************************
3661  *           NdrConformantArrayBufferSize [RPCRT4.@]
3662  */
3663 void WINAPI NdrConformantArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
3664                                          unsigned char *pMemory,
3665                                          PFORMAT_STRING pFormat)
3666 {
3667   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3668   if (pFormat[0] != RPC_FC_CARRAY)
3669   {
3670     ERR("invalid format = 0x%x\n", pFormat[0]);
3671     RpcRaiseException(RPC_X_BAD_STUB_DATA);
3672   }
3673
3674   array_compute_and_size_conformance(RPC_FC_CARRAY, pStubMsg, pMemory, pFormat);
3675   array_buffer_size(RPC_FC_CARRAY, pStubMsg, pMemory, pFormat,
3676                     TRUE /* fHasPointers */);
3677 }
3678
3679 /***********************************************************************
3680  *           NdrConformantArrayMemorySize [RPCRT4.@]
3681  */
3682 ULONG WINAPI NdrConformantArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
3683                                           PFORMAT_STRING pFormat)
3684 {
3685   TRACE("(%p,%p)\n", pStubMsg, pFormat);
3686   if (pFormat[0] != RPC_FC_CARRAY)
3687   {
3688     ERR("invalid format = 0x%x\n", pFormat[0]);
3689     RpcRaiseException(RPC_X_BAD_STUB_DATA);
3690   }
3691
3692   array_read_conformance(RPC_FC_CARRAY, pStubMsg, pFormat);
3693   array_memory_size(RPC_FC_CARRAY, pStubMsg, pFormat, TRUE /* fHasPointers */);
3694
3695   return pStubMsg->MemorySize;
3696 }
3697
3698 /***********************************************************************
3699  *           NdrConformantArrayFree [RPCRT4.@]
3700  */
3701 void WINAPI NdrConformantArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
3702                                    unsigned char *pMemory,
3703                                    PFORMAT_STRING pFormat)
3704 {
3705   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3706   if (pFormat[0] != RPC_FC_CARRAY)
3707   {
3708     ERR("invalid format = 0x%x\n", pFormat[0]);
3709     RpcRaiseException(RPC_X_BAD_STUB_DATA);
3710   }
3711
3712   array_free(RPC_FC_CARRAY, pStubMsg, pMemory, pFormat,
3713              TRUE /* fHasPointers */);
3714 }
3715
3716
3717 /***********************************************************************
3718  *           NdrConformantVaryingArrayMarshall  [RPCRT4.@]
3719  */
3720 unsigned char* WINAPI NdrConformantVaryingArrayMarshall( PMIDL_STUB_MESSAGE pStubMsg,
3721                                                          unsigned char* pMemory,
3722                                                          PFORMAT_STRING pFormat )
3723 {
3724     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
3725
3726     if (pFormat[0] != RPC_FC_CVARRAY)
3727     {
3728         ERR("invalid format type %x\n", pFormat[0]);
3729         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3730         return NULL;
3731     }
3732
3733     array_compute_and_write_conformance(RPC_FC_CVARRAY, pStubMsg, pMemory,
3734                                         pFormat);
3735     array_write_variance_and_marshall(RPC_FC_CVARRAY, pStubMsg, pMemory,
3736                                       pFormat, TRUE /* fHasPointers */);
3737
3738     return NULL;
3739 }
3740
3741
3742 /***********************************************************************
3743  *           NdrConformantVaryingArrayUnmarshall  [RPCRT4.@]
3744  */
3745 unsigned char* WINAPI NdrConformantVaryingArrayUnmarshall( PMIDL_STUB_MESSAGE pStubMsg,
3746                                                            unsigned char** ppMemory,
3747                                                            PFORMAT_STRING pFormat,
3748                                                            unsigned char fMustAlloc )
3749 {
3750     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
3751
3752     if (pFormat[0] != RPC_FC_CVARRAY)
3753     {
3754         ERR("invalid format type %x\n", pFormat[0]);
3755         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3756         return NULL;
3757     }
3758
3759     array_read_conformance(RPC_FC_CVARRAY, pStubMsg, pFormat);
3760     array_read_variance_and_unmarshall(RPC_FC_CVARRAY, pStubMsg, ppMemory,
3761                                        pFormat, fMustAlloc,
3762                                        TRUE /* fUseBufferMemoryServer */,
3763                                        TRUE /* fUnmarshall */);
3764
3765     return NULL;
3766 }
3767
3768
3769 /***********************************************************************
3770  *           NdrConformantVaryingArrayFree  [RPCRT4.@]
3771  */
3772 void WINAPI NdrConformantVaryingArrayFree( PMIDL_STUB_MESSAGE pStubMsg,
3773                                            unsigned char* pMemory,
3774                                            PFORMAT_STRING pFormat )
3775 {
3776     TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3777
3778     if (pFormat[0] != RPC_FC_CVARRAY)
3779     {
3780         ERR("invalid format type %x\n", pFormat[0]);
3781         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3782         return;
3783     }
3784
3785     array_free(RPC_FC_CVARRAY, pStubMsg, pMemory, pFormat,
3786                TRUE /* fHasPointers */);
3787 }
3788
3789
3790 /***********************************************************************
3791  *           NdrConformantVaryingArrayBufferSize  [RPCRT4.@]
3792  */
3793 void WINAPI NdrConformantVaryingArrayBufferSize( PMIDL_STUB_MESSAGE pStubMsg,
3794                                                  unsigned char* pMemory, PFORMAT_STRING pFormat )
3795 {
3796     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
3797
3798     if (pFormat[0] != RPC_FC_CVARRAY)
3799     {
3800         ERR("invalid format type %x\n", pFormat[0]);
3801         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3802         return;
3803     }
3804
3805     array_compute_and_size_conformance(RPC_FC_CVARRAY, pStubMsg, pMemory,
3806                                        pFormat);
3807     array_buffer_size(RPC_FC_CVARRAY, pStubMsg, pMemory, pFormat,
3808                       TRUE /* fHasPointers */);
3809 }
3810
3811
3812 /***********************************************************************
3813  *           NdrConformantVaryingArrayMemorySize  [RPCRT4.@]
3814  */
3815 ULONG WINAPI NdrConformantVaryingArrayMemorySize( PMIDL_STUB_MESSAGE pStubMsg,
3816                                                   PFORMAT_STRING pFormat )
3817 {
3818     TRACE("(%p, %p)\n", pStubMsg, pFormat);
3819
3820     if (pFormat[0] != RPC_FC_CVARRAY)
3821     {
3822         ERR("invalid format type %x\n", pFormat[0]);
3823         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3824         return pStubMsg->MemorySize;
3825     }
3826
3827     array_read_conformance(RPC_FC_CVARRAY, pStubMsg, pFormat);
3828     array_memory_size(RPC_FC_CVARRAY, pStubMsg, pFormat,
3829                       TRUE /* fHasPointers */);
3830
3831     return pStubMsg->MemorySize;
3832 }
3833
3834
3835 /***********************************************************************
3836  *           NdrComplexArrayMarshall [RPCRT4.@]
3837  */
3838 unsigned char * WINAPI NdrComplexArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
3839                                                unsigned char *pMemory,
3840                                                PFORMAT_STRING pFormat)
3841 {
3842   ULONG i, count, def;
3843   BOOL variance_present;
3844   unsigned char alignment;
3845   int pointer_buffer_mark_set = 0;
3846
3847   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3848
3849   if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
3850   {
3851       ERR("invalid format type %x\n", pFormat[0]);
3852       RpcRaiseException(RPC_S_INTERNAL_ERROR);
3853       return NULL;
3854   }
3855
3856   alignment = pFormat[1] + 1;
3857
3858   if (!pStubMsg->PointerBufferMark)
3859   {
3860     /* save buffer fields that may be changed by buffer sizer functions
3861      * and that may be needed later on */
3862     int saved_ignore_embedded = pStubMsg->IgnoreEmbeddedPointers;
3863     ULONG saved_buffer_length = pStubMsg->BufferLength;
3864     ULONG_PTR saved_max_count = pStubMsg->MaxCount;
3865     ULONG saved_offset = pStubMsg->Offset;
3866     ULONG saved_actual_count = pStubMsg->ActualCount;
3867
3868     /* get the buffer pointer after complex array data, but before
3869      * pointer data */
3870     pStubMsg->BufferLength = pStubMsg->Buffer - (unsigned char *)pStubMsg->RpcMsg->Buffer;
3871     pStubMsg->IgnoreEmbeddedPointers = 1;
3872     NdrComplexArrayBufferSize(pStubMsg, pMemory, pFormat);
3873     pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded;
3874
3875     /* save it for use by embedded pointer code later */
3876     pStubMsg->PointerBufferMark = (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength;
3877     TRACE("difference = 0x%x\n", (ULONG)(pStubMsg->Buffer - (unsigned char *)pStubMsg->RpcMsg->Buffer));
3878     pointer_buffer_mark_set = 1;
3879
3880     /* restore fields */
3881     pStubMsg->ActualCount = saved_actual_count;
3882     pStubMsg->Offset = saved_offset;
3883     pStubMsg->MaxCount = saved_max_count;
3884     pStubMsg->BufferLength = saved_buffer_length;
3885   }
3886
3887   def = *(const WORD*)&pFormat[2];
3888   pFormat += 4;
3889
3890   pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
3891   TRACE("conformance = %ld\n", pStubMsg->MaxCount);
3892
3893   variance_present = IsConformanceOrVariancePresent(pFormat);
3894   pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
3895   TRACE("variance = %d\n", pStubMsg->ActualCount);
3896
3897   WriteConformance(pStubMsg);
3898   if (variance_present)
3899     WriteVariance(pStubMsg);
3900
3901   ALIGN_POINTER_CLEAR(pStubMsg->Buffer, alignment);
3902
3903   count = pStubMsg->ActualCount;
3904   for (i = 0; i < count; i++)
3905     pMemory = ComplexMarshall(pStubMsg, pMemory, pFormat, NULL);
3906
3907   STD_OVERFLOW_CHECK(pStubMsg);
3908
3909   if (pointer_buffer_mark_set)
3910   {
3911     pStubMsg->Buffer = pStubMsg->PointerBufferMark;
3912     pStubMsg->PointerBufferMark = NULL;
3913   }
3914
3915   return NULL;
3916 }
3917
3918 /***********************************************************************
3919  *           NdrComplexArrayUnmarshall [RPCRT4.@]
3920  */
3921 unsigned char * WINAPI NdrComplexArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
3922                                                  unsigned char **ppMemory,
3923                                                  PFORMAT_STRING pFormat,
3924                                                  unsigned char fMustAlloc)
3925 {
3926   ULONG i, count, size;
3927   unsigned char alignment;
3928   unsigned char *pMemory;
3929   unsigned char *saved_buffer;
3930   int pointer_buffer_mark_set = 0;
3931   int saved_ignore_embedded;
3932
3933   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
3934
3935   if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
3936   {
3937       ERR("invalid format type %x\n", pFormat[0]);
3938       RpcRaiseException(RPC_S_INTERNAL_ERROR);
3939       return NULL;
3940   }
3941
3942   alignment = pFormat[1] + 1;
3943
3944   saved_ignore_embedded = pStubMsg->IgnoreEmbeddedPointers;
3945   /* save buffer pointer */
3946   saved_buffer = pStubMsg->Buffer;
3947   /* get the buffer pointer after complex array data, but before
3948    * pointer data */
3949   pStubMsg->IgnoreEmbeddedPointers = 1;
3950   pStubMsg->MemorySize = 0;
3951   NdrComplexArrayMemorySize(pStubMsg, pFormat);
3952   size = pStubMsg->MemorySize;
3953   pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded;
3954
3955   TRACE("difference = 0x%x\n", (ULONG)(pStubMsg->Buffer - saved_buffer));
3956   if (!pStubMsg->PointerBufferMark)
3957   {
3958     /* save it for use by embedded pointer code later */
3959     pStubMsg->PointerBufferMark = pStubMsg->Buffer;
3960     pointer_buffer_mark_set = 1;
3961   }
3962   /* restore the original buffer */
3963   pStubMsg->Buffer = saved_buffer;
3964
3965   pFormat += 4;
3966
3967   pFormat = ReadConformance(pStubMsg, pFormat);
3968   pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
3969
3970   if (!fMustAlloc && !*ppMemory)
3971     fMustAlloc = TRUE;
3972   if (fMustAlloc)
3973     *ppMemory = NdrAllocate(pStubMsg, size);
3974
3975   ALIGN_POINTER(pStubMsg->Buffer, alignment);
3976
3977   pMemory = *ppMemory;
3978   count = pStubMsg->ActualCount;
3979   for (i = 0; i < count; i++)
3980     pMemory = ComplexUnmarshall(pStubMsg, pMemory, pFormat, NULL, fMustAlloc);
3981
3982   if (pointer_buffer_mark_set)
3983   {
3984     pStubMsg->Buffer = pStubMsg->PointerBufferMark;
3985     pStubMsg->PointerBufferMark = NULL;
3986   }
3987
3988   return NULL;
3989 }
3990
3991 /***********************************************************************
3992  *           NdrComplexArrayBufferSize [RPCRT4.@]
3993  */
3994 void WINAPI NdrComplexArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
3995                                       unsigned char *pMemory,
3996                                       PFORMAT_STRING pFormat)
3997 {
3998   ULONG i, count, def;
3999   unsigned char alignment;
4000   BOOL variance_present;
4001   int pointer_length_set = 0;
4002
4003   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
4004
4005   if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
4006   {
4007       ERR("invalid format type %x\n", pFormat[0]);
4008       RpcRaiseException(RPC_S_INTERNAL_ERROR);
4009       return;
4010   }
4011
4012   alignment = pFormat[1] + 1;
4013
4014   if (!pStubMsg->IgnoreEmbeddedPointers && !pStubMsg->PointerLength)
4015   {
4016     /* save buffer fields that may be changed by buffer sizer functions
4017      * and that may be needed later on */
4018     int saved_ignore_embedded = pStubMsg->IgnoreEmbeddedPointers;
4019     ULONG saved_buffer_length = pStubMsg->BufferLength;
4020     ULONG_PTR saved_max_count = pStubMsg->MaxCount;
4021     ULONG saved_offset = pStubMsg->Offset;
4022     ULONG saved_actual_count = pStubMsg->ActualCount;
4023
4024     /* get the buffer pointer after complex array data, but before
4025      * pointer data */
4026     pStubMsg->IgnoreEmbeddedPointers = 1;
4027     NdrComplexArrayBufferSize(pStubMsg, pMemory, pFormat);
4028     pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded;
4029
4030     /* save it for use by embedded pointer code later */
4031     pStubMsg->PointerLength = pStubMsg->BufferLength;
4032     pointer_length_set = 1;
4033
4034     /* restore fields */
4035     pStubMsg->ActualCount = saved_actual_count;
4036     pStubMsg->Offset = saved_offset;
4037     pStubMsg->MaxCount = saved_max_count;
4038     pStubMsg->BufferLength = saved_buffer_length;
4039   }
4040   def = *(const WORD*)&pFormat[2];
4041   pFormat += 4;
4042
4043   pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
4044   TRACE("conformance = %ld\n", pStubMsg->MaxCount);
4045   SizeConformance(pStubMsg);
4046
4047   variance_present = IsConformanceOrVariancePresent(pFormat);
4048   pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
4049   TRACE("variance = %d\n", pStubMsg->ActualCount);
4050
4051   if (variance_present)
4052     SizeVariance(pStubMsg);
4053
4054   ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
4055
4056   count = pStubMsg->ActualCount;
4057   for (i = 0; i < count; i++)
4058     pMemory = ComplexBufferSize(pStubMsg, pMemory, pFormat, NULL);
4059
4060   if(pointer_length_set)
4061   {
4062     pStubMsg->BufferLength = pStubMsg->PointerLength;
4063     pStubMsg->PointerLength = 0;
4064   }
4065 }
4066
4067 /***********************************************************************
4068  *           NdrComplexArrayMemorySize [RPCRT4.@]
4069  */
4070 ULONG WINAPI NdrComplexArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
4071                                        PFORMAT_STRING pFormat)
4072 {
4073   ULONG i, count, esize, SavedMemorySize, MemorySize;
4074   unsigned char alignment;
4075
4076   TRACE("(%p,%p)\n", pStubMsg, pFormat);
4077
4078   if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
4079   {
4080       ERR("invalid format type %x\n", pFormat[0]);
4081       RpcRaiseException(RPC_S_INTERNAL_ERROR);
4082       return 0;
4083   }
4084
4085   alignment = pFormat[1] + 1;
4086
4087   pFormat += 4;
4088
4089   pFormat = ReadConformance(pStubMsg, pFormat);
4090   pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
4091
4092   ALIGN_POINTER(pStubMsg->Buffer, alignment);
4093
4094   SavedMemorySize = pStubMsg->MemorySize;
4095
4096   esize = ComplexStructSize(pStubMsg, pFormat);
4097
4098   MemorySize = safe_multiply(pStubMsg->MaxCount, esize);
4099
4100   count = pStubMsg->ActualCount;
4101   for (i = 0; i < count; i++)
4102     ComplexStructMemorySize(pStubMsg, pFormat, NULL);
4103
4104   pStubMsg->MemorySize = SavedMemorySize;
4105
4106   pStubMsg->MemorySize += MemorySize;
4107   return MemorySize;
4108 }
4109
4110 /***********************************************************************
4111  *           NdrComplexArrayFree [RPCRT4.@]
4112  */
4113 void WINAPI NdrComplexArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
4114                                 unsigned char *pMemory,
4115                                 PFORMAT_STRING pFormat)
4116 {
4117   ULONG i, count, def;
4118
4119   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
4120
4121   if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
4122   {
4123       ERR("invalid format type %x\n", pFormat[0]);
4124       RpcRaiseException(RPC_S_INTERNAL_ERROR);
4125       return;
4126   }
4127
4128   def = *(const WORD*)&pFormat[2];
4129   pFormat += 4;
4130
4131   pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
4132   TRACE("conformance = %ld\n", pStubMsg->MaxCount);
4133
4134   pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
4135   TRACE("variance = %d\n", pStubMsg->ActualCount);
4136
4137   count = pStubMsg->ActualCount;
4138   for (i = 0; i < count; i++)
4139     pMemory = ComplexFree(pStubMsg, pMemory, pFormat, NULL);
4140 }
4141
4142 static void UserMarshalCB(PMIDL_STUB_MESSAGE pStubMsg,
4143                           USER_MARSHAL_CB_TYPE cbtype, PFORMAT_STRING pFormat,
4144                           USER_MARSHAL_CB *umcb)
4145 {
4146   umcb->Flags = MAKELONG(pStubMsg->dwDestContext,
4147                          pStubMsg->RpcMsg->DataRepresentation);
4148   umcb->pStubMsg = pStubMsg;
4149   umcb->pReserve = NULL;
4150   umcb->Signature = USER_MARSHAL_CB_SIGNATURE;
4151   umcb->CBType = cbtype;
4152   umcb->pFormat = pFormat;
4153   umcb->pTypeFormat = NULL /* FIXME */;
4154 }
4155
4156 #define USER_MARSHAL_PTR_PREFIX \
4157         ( (DWORD)'U'         | ( (DWORD)'s' << 8 ) | \
4158         ( (DWORD)'e' << 16 ) | ( (DWORD)'r' << 24 ) )
4159
4160 /***********************************************************************
4161  *           NdrUserMarshalMarshall [RPCRT4.@]
4162  */
4163 unsigned char * WINAPI NdrUserMarshalMarshall(PMIDL_STUB_MESSAGE pStubMsg,
4164                                               unsigned char *pMemory,
4165                                               PFORMAT_STRING pFormat)
4166 {
4167   unsigned flags = pFormat[1];
4168   unsigned index = *(const WORD*)&pFormat[2];
4169   unsigned char *saved_buffer = NULL;
4170   USER_MARSHAL_CB umcb;
4171
4172   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
4173   TRACE("index=%d\n", index);
4174
4175   UserMarshalCB(pStubMsg, USER_MARSHAL_CB_MARSHALL, pFormat, &umcb);
4176
4177   if (flags & USER_MARSHAL_POINTER)
4178   {
4179     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
4180     NDR_LOCAL_UINT32_WRITE(pStubMsg->Buffer, USER_MARSHAL_PTR_PREFIX);
4181     pStubMsg->Buffer += 4;
4182     if (pStubMsg->PointerBufferMark)
4183     {
4184       saved_buffer = pStubMsg->Buffer;
4185       pStubMsg->Buffer = pStubMsg->PointerBufferMark;
4186       pStubMsg->PointerBufferMark = NULL;
4187     }
4188     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 8);
4189   }
4190   else
4191     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, (flags & 0xf) + 1);
4192
4193   pStubMsg->Buffer =
4194     pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnMarshall(
4195       &umcb.Flags, pStubMsg->Buffer, pMemory);
4196
4197   if (saved_buffer)
4198   {
4199     STD_OVERFLOW_CHECK(pStubMsg);
4200     pStubMsg->PointerBufferMark = pStubMsg->Buffer;
4201     pStubMsg->Buffer = saved_buffer;
4202   }
4203
4204   STD_OVERFLOW_CHECK(pStubMsg);
4205
4206   return NULL;
4207 }
4208
4209 /***********************************************************************
4210  *           NdrUserMarshalUnmarshall [RPCRT4.@]
4211  */
4212 unsigned char * WINAPI NdrUserMarshalUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
4213                                                  unsigned char **ppMemory,
4214                                                  PFORMAT_STRING pFormat,
4215                                                  unsigned char fMustAlloc)
4216 {
4217   unsigned flags = pFormat[1];
4218   unsigned index = *(const WORD*)&pFormat[2];
4219   DWORD memsize = *(const WORD*)&pFormat[4];
4220   unsigned char *saved_buffer = NULL;
4221   USER_MARSHAL_CB umcb;
4222
4223   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
4224   TRACE("index=%d\n", index);
4225
4226   UserMarshalCB(pStubMsg, USER_MARSHAL_CB_UNMARSHALL, pFormat, &umcb);
4227
4228   if (flags & USER_MARSHAL_POINTER)
4229   {
4230     ALIGN_POINTER(pStubMsg->Buffer, 4);
4231     /* skip pointer prefix */
4232     pStubMsg->Buffer += 4;
4233     if (pStubMsg->PointerBufferMark)
4234     {
4235       saved_buffer = pStubMsg->Buffer;
4236       pStubMsg->Buffer = pStubMsg->PointerBufferMark;
4237       pStubMsg->PointerBufferMark = NULL;
4238     }
4239     ALIGN_POINTER(pStubMsg->Buffer, 8);
4240   }
4241   else
4242     ALIGN_POINTER(pStubMsg->Buffer, (flags & 0xf) + 1);
4243
4244   if (!fMustAlloc && !*ppMemory)
4245     fMustAlloc = TRUE;
4246   if (fMustAlloc)
4247   {
4248     *ppMemory = NdrAllocate(pStubMsg, memsize);
4249     memset(*ppMemory, 0, memsize);
4250   }
4251
4252   pStubMsg->Buffer =
4253     pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnUnmarshall(
4254       &umcb.Flags, pStubMsg->Buffer, *ppMemory);
4255
4256   if (saved_buffer)
4257   {
4258     STD_OVERFLOW_CHECK(pStubMsg);
4259     pStubMsg->PointerBufferMark = pStubMsg->Buffer;
4260     pStubMsg->Buffer = saved_buffer;
4261   }
4262
4263   return NULL;
4264 }
4265
4266 /***********************************************************************
4267  *           NdrUserMarshalBufferSize [RPCRT4.@]
4268  */
4269 void WINAPI NdrUserMarshalBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
4270                                       unsigned char *pMemory,
4271                                       PFORMAT_STRING pFormat)
4272 {
4273   unsigned flags = pFormat[1];
4274   unsigned index = *(const WORD*)&pFormat[2];
4275   DWORD bufsize = *(const WORD*)&pFormat[6];
4276   USER_MARSHAL_CB umcb;
4277   ULONG saved_buffer_length = 0;
4278
4279   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
4280   TRACE("index=%d\n", index);
4281
4282   UserMarshalCB(pStubMsg, USER_MARSHAL_CB_BUFFER_SIZE, pFormat, &umcb);
4283
4284   if (flags & USER_MARSHAL_POINTER)
4285   {
4286     ALIGN_LENGTH(pStubMsg->BufferLength, 4);
4287     /* skip pointer prefix */
4288     safe_buffer_length_increment(pStubMsg, 4);
4289     if (pStubMsg->IgnoreEmbeddedPointers)
4290       return;
4291     if (pStubMsg->PointerLength)
4292     {
4293       saved_buffer_length = pStubMsg->BufferLength;
4294       pStubMsg->BufferLength = pStubMsg->PointerLength;
4295       pStubMsg->PointerLength = 0;
4296     }
4297     ALIGN_LENGTH(pStubMsg->BufferLength, 8);
4298   }
4299   else
4300     ALIGN_LENGTH(pStubMsg->BufferLength, (flags & 0xf) + 1);
4301
4302   if (bufsize) {
4303     TRACE("size=%d\n", bufsize);
4304     safe_buffer_length_increment(pStubMsg, bufsize);
4305   }
4306   else
4307     pStubMsg->BufferLength =
4308         pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnBufferSize(
4309                              &umcb.Flags, pStubMsg->BufferLength, pMemory);
4310
4311   if (saved_buffer_length)
4312   {
4313     pStubMsg->PointerLength = pStubMsg->BufferLength;
4314     pStubMsg->BufferLength = saved_buffer_length;
4315   }
4316
4317 }
4318
4319 /***********************************************************************
4320  *           NdrUserMarshalMemorySize [RPCRT4.@]
4321  */
4322 ULONG WINAPI NdrUserMarshalMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
4323                                       PFORMAT_STRING pFormat)
4324 {
4325   unsigned flags = pFormat[1];
4326   unsigned index = *(const WORD*)&pFormat[2];
4327   DWORD memsize = *(const WORD*)&pFormat[4];
4328   DWORD bufsize = *(const WORD*)&pFormat[6];
4329
4330   TRACE("(%p,%p)\n", pStubMsg, pFormat);
4331   TRACE("index=%d\n", index);
4332
4333   pStubMsg->MemorySize += memsize;
4334
4335   if (flags & USER_MARSHAL_POINTER)
4336   {
4337     ALIGN_POINTER(pStubMsg->Buffer, 4);
4338     /* skip pointer prefix */
4339     pStubMsg->Buffer += 4;
4340     if (pStubMsg->IgnoreEmbeddedPointers)
4341       return pStubMsg->MemorySize;
4342     ALIGN_POINTER(pStubMsg->Buffer, 8);
4343   }
4344   else
4345     ALIGN_POINTER(pStubMsg->Buffer, (flags & 0xf) + 1);
4346
4347   if (!bufsize)
4348     FIXME("not implemented for varying buffer size\n");
4349
4350   pStubMsg->Buffer += bufsize;
4351
4352   return pStubMsg->MemorySize;
4353 }
4354
4355 /***********************************************************************
4356  *           NdrUserMarshalFree [RPCRT4.@]
4357  */
4358 void WINAPI NdrUserMarshalFree(PMIDL_STUB_MESSAGE pStubMsg,
4359                                 unsigned char *pMemory,
4360                                 PFORMAT_STRING pFormat)
4361 {
4362 /*  unsigned flags = pFormat[1]; */
4363   unsigned index = *(const WORD*)&pFormat[2];
4364   USER_MARSHAL_CB umcb;
4365
4366   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
4367   TRACE("index=%d\n", index);
4368
4369   UserMarshalCB(pStubMsg, USER_MARSHAL_CB_FREE, pFormat, &umcb);
4370
4371   pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnFree(
4372     &umcb.Flags, pMemory);
4373 }
4374
4375 /***********************************************************************
4376  *           NdrGetUserMarshalInfo [RPCRT4.@]
4377  */
4378 RPC_STATUS RPC_ENTRY NdrGetUserMarshalInfo(ULONG *flags, ULONG level, NDR_USER_MARSHAL_INFO *umi)
4379 {
4380     USER_MARSHAL_CB *umcb = CONTAINING_RECORD(flags, USER_MARSHAL_CB, Flags);
4381
4382     TRACE("(%p,%u,%p)\n", flags, level, umi);
4383
4384     if (level != 1)
4385         return RPC_S_INVALID_ARG;
4386
4387     memset(&umi->u1.Level1, 0, sizeof(umi->u1.Level1));
4388     umi->InformationLevel = level;
4389
4390     if (umcb->Signature != USER_MARSHAL_CB_SIGNATURE)
4391         return RPC_S_INVALID_ARG;
4392
4393     umi->u1.Level1.pfnAllocate = umcb->pStubMsg->pfnAllocate;
4394     umi->u1.Level1.pfnFree = umcb->pStubMsg->pfnFree;
4395     umi->u1.Level1.pRpcChannelBuffer = umcb->pStubMsg->pRpcChannelBuffer;
4396
4397     switch (umcb->CBType)
4398     {
4399     case USER_MARSHAL_CB_MARSHALL:
4400     case USER_MARSHAL_CB_UNMARSHALL:
4401     {
4402         RPC_MESSAGE *msg = umcb->pStubMsg->RpcMsg;
4403         unsigned char *buffer_start = msg->Buffer;
4404         unsigned char *buffer_end =
4405             (unsigned char *)msg->Buffer + msg->BufferLength;
4406
4407         if (umcb->pStubMsg->Buffer < buffer_start ||
4408             umcb->pStubMsg->Buffer > buffer_end)
4409             return ERROR_INVALID_USER_BUFFER;
4410
4411         umi->u1.Level1.Buffer = umcb->pStubMsg->Buffer;
4412         umi->u1.Level1.BufferSize = buffer_end - umcb->pStubMsg->Buffer;
4413         break;
4414     }
4415     case USER_MARSHAL_CB_BUFFER_SIZE:
4416     case USER_MARSHAL_CB_FREE:
4417         break;
4418     default:
4419         WARN("unrecognised CBType %d\n", umcb->CBType);
4420     }
4421
4422     return RPC_S_OK;
4423 }
4424
4425 /***********************************************************************
4426  *           NdrClearOutParameters [RPCRT4.@]
4427  */
4428 void WINAPI NdrClearOutParameters(PMIDL_STUB_MESSAGE pStubMsg,
4429                                   PFORMAT_STRING pFormat,
4430                                   void *ArgAddr)
4431 {
4432   FIXME("(%p,%p,%p): stub\n", pStubMsg, pFormat, ArgAddr);
4433 }
4434
4435 /***********************************************************************
4436  *           NdrConvert [RPCRT4.@]
4437  */
4438 void WINAPI NdrConvert( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat )
4439 {
4440   FIXME("(pStubMsg == ^%p, pFormat == ^%p): stub.\n", pStubMsg, pFormat);
4441   /* FIXME: since this stub doesn't do any converting, the proper behavior
4442      is to raise an exception */
4443 }
4444
4445 /***********************************************************************
4446  *           NdrConvert2 [RPCRT4.@]
4447  */
4448 void WINAPI NdrConvert2( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, LONG NumberParams )
4449 {
4450   FIXME("(pStubMsg == ^%p, pFormat == ^%p, NumberParams == %d): stub.\n",
4451     pStubMsg, pFormat, NumberParams);
4452   /* FIXME: since this stub doesn't do any converting, the proper behavior
4453      is to raise an exception */
4454 }
4455
4456 #include "pshpack1.h"
4457 typedef struct _NDR_CSTRUCT_FORMAT
4458 {
4459     unsigned char type;
4460     unsigned char alignment;
4461     unsigned short memory_size;
4462     short offset_to_array_description;
4463 } NDR_CSTRUCT_FORMAT, NDR_CVSTRUCT_FORMAT;
4464 #include "poppack.h"
4465
4466 /***********************************************************************
4467  *           NdrConformantStructMarshall [RPCRT4.@]
4468  */
4469 unsigned char *  WINAPI NdrConformantStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
4470                                 unsigned char *pMemory,
4471                                 PFORMAT_STRING pFormat)
4472 {
4473     const NDR_CSTRUCT_FORMAT *pCStructFormat = (const NDR_CSTRUCT_FORMAT *)pFormat;
4474     PFORMAT_STRING pCArrayFormat;
4475     ULONG esize, bufsize;
4476
4477     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4478
4479     pFormat += sizeof(NDR_CSTRUCT_FORMAT);
4480     if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT))
4481     {
4482         ERR("invalid format type %x\n", pCStructFormat->type);
4483         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4484         return NULL;
4485     }
4486
4487     pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description +
4488         pCStructFormat->offset_to_array_description;
4489     if (*pCArrayFormat != RPC_FC_CARRAY)
4490     {
4491         ERR("invalid array format type %x\n", pCStructFormat->type);
4492         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4493         return NULL;
4494     }
4495     esize = *(const WORD*)(pCArrayFormat+2);
4496
4497     ComputeConformance(pStubMsg, pMemory + pCStructFormat->memory_size,
4498                        pCArrayFormat + 4, 0);
4499
4500     WriteConformance(pStubMsg);
4501
4502     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, pCStructFormat->alignment + 1);
4503
4504     TRACE("memory_size = %d\n", pCStructFormat->memory_size);
4505
4506     bufsize = safe_multiply(esize, pStubMsg->MaxCount);
4507     if (pCStructFormat->memory_size + bufsize < pCStructFormat->memory_size) /* integer overflow */
4508     {
4509         ERR("integer overflow of memory_size %u with bufsize %u\n",
4510             pCStructFormat->memory_size, bufsize);
4511         RpcRaiseException(RPC_X_BAD_STUB_DATA);
4512     }
4513     /* copy constant sized part of struct */
4514     pStubMsg->BufferMark = pStubMsg->Buffer;
4515     safe_copy_to_buffer(pStubMsg, pMemory, pCStructFormat->memory_size + bufsize);
4516
4517     if (pCStructFormat->type == RPC_FC_CPSTRUCT)
4518         EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
4519
4520     return NULL;
4521 }
4522
4523 /***********************************************************************
4524  *           NdrConformantStructUnmarshall [RPCRT4.@]
4525  */
4526 unsigned char *  WINAPI NdrConformantStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
4527                                 unsigned char **ppMemory,
4528                                 PFORMAT_STRING pFormat,
4529                                 unsigned char fMustAlloc)
4530 {
4531     const NDR_CSTRUCT_FORMAT *pCStructFormat = (const NDR_CSTRUCT_FORMAT *)pFormat;
4532     PFORMAT_STRING pCArrayFormat;
4533     ULONG esize, bufsize;
4534     unsigned char *saved_buffer;
4535
4536     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
4537
4538     pFormat += sizeof(NDR_CSTRUCT_FORMAT);
4539     if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT))
4540     {
4541         ERR("invalid format type %x\n", pCStructFormat->type);
4542         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4543         return NULL;
4544     }
4545     pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description +
4546         pCStructFormat->offset_to_array_description;
4547     if (*pCArrayFormat != RPC_FC_CARRAY)
4548     {
4549         ERR("invalid array format type %x\n", pCStructFormat->type);
4550         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4551         return NULL;
4552     }
4553     esize = *(const WORD*)(pCArrayFormat+2);
4554
4555     pCArrayFormat = ReadConformance(pStubMsg, pCArrayFormat + 4);
4556
4557     ALIGN_POINTER(pStubMsg->Buffer, pCStructFormat->alignment + 1);
4558
4559     TRACE("memory_size = %d\n", pCStructFormat->memory_size);
4560
4561     bufsize = safe_multiply(esize, pStubMsg->MaxCount);
4562     if (pCStructFormat->memory_size + bufsize < pCStructFormat->memory_size) /* integer overflow */
4563     {
4564         ERR("integer overflow of memory_size %u with bufsize %u\n",
4565             pCStructFormat->memory_size, bufsize);
4566         RpcRaiseException(RPC_X_BAD_STUB_DATA);
4567     }
4568
4569     if (fMustAlloc)
4570     {
4571         SIZE_T size = pCStructFormat->memory_size + bufsize;
4572         *ppMemory = NdrAllocate(pStubMsg, size);
4573     }
4574     else
4575     {
4576         if (!pStubMsg->IsClient && !*ppMemory)
4577             /* for servers, we just point straight into the RPC buffer */
4578             *ppMemory = pStubMsg->Buffer;
4579     }
4580
4581     saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer;
4582     safe_buffer_increment(pStubMsg, pCStructFormat->memory_size + bufsize);
4583     if (pCStructFormat->type == RPC_FC_CPSTRUCT)
4584         EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat, fMustAlloc);
4585
4586     TRACE("copying %p to %p\n", saved_buffer, *ppMemory);
4587     if (*ppMemory != saved_buffer)
4588         memcpy(*ppMemory, saved_buffer, pCStructFormat->memory_size + bufsize);
4589
4590     return NULL;
4591 }
4592
4593 /***********************************************************************
4594  *           NdrConformantStructBufferSize [RPCRT4.@]
4595  */
4596 void WINAPI NdrConformantStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
4597                                 unsigned char *pMemory,
4598                                 PFORMAT_STRING pFormat)
4599 {
4600     const NDR_CSTRUCT_FORMAT * pCStructFormat = (const NDR_CSTRUCT_FORMAT *)pFormat;
4601     PFORMAT_STRING pCArrayFormat;
4602     ULONG esize;
4603
4604     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4605
4606     pFormat += sizeof(NDR_CSTRUCT_FORMAT);
4607     if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT))
4608     {
4609         ERR("invalid format type %x\n", pCStructFormat->type);
4610         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4611         return;
4612     }
4613     pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description +
4614         pCStructFormat->offset_to_array_description;
4615     if (*pCArrayFormat != RPC_FC_CARRAY)
4616     {
4617         ERR("invalid array format type %x\n", pCStructFormat->type);
4618         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4619         return;
4620     }
4621     esize = *(const WORD*)(pCArrayFormat+2);
4622
4623     pCArrayFormat = ComputeConformance(pStubMsg, pMemory + pCStructFormat->memory_size, pCArrayFormat+4, 0);
4624     SizeConformance(pStubMsg);
4625
4626     ALIGN_LENGTH(pStubMsg->BufferLength, pCStructFormat->alignment + 1);
4627
4628     TRACE("memory_size = %d\n", pCStructFormat->memory_size);
4629
4630     safe_buffer_length_increment(pStubMsg, pCStructFormat->memory_size);
4631     safe_buffer_length_increment(pStubMsg, safe_multiply(pStubMsg->MaxCount, esize));
4632
4633     if (pCStructFormat->type == RPC_FC_CPSTRUCT)
4634         EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
4635 }
4636
4637 /***********************************************************************
4638  *           NdrConformantStructMemorySize [RPCRT4.@]
4639  */
4640 ULONG WINAPI NdrConformantStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
4641                                 PFORMAT_STRING pFormat)
4642 {
4643     FIXME("stub\n");
4644     return 0;
4645 }
4646
4647 /***********************************************************************
4648  *           NdrConformantStructFree [RPCRT4.@]
4649  */
4650 void WINAPI NdrConformantStructFree(PMIDL_STUB_MESSAGE pStubMsg,
4651                                 unsigned char *pMemory,
4652                                 PFORMAT_STRING pFormat)
4653 {
4654     const NDR_CSTRUCT_FORMAT *pCStructFormat = (const NDR_CSTRUCT_FORMAT *)pFormat;
4655     PFORMAT_STRING pCArrayFormat;
4656
4657     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4658
4659     pFormat += sizeof(NDR_CSTRUCT_FORMAT);
4660     if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT))
4661     {
4662         ERR("invalid format type %x\n", pCStructFormat->type);
4663         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4664         return;
4665     }
4666
4667     pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description +
4668         pCStructFormat->offset_to_array_description;
4669     if (*pCArrayFormat != RPC_FC_CARRAY)
4670     {
4671         ERR("invalid array format type %x\n", pCStructFormat->type);
4672         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4673         return;
4674     }
4675
4676     ComputeConformance(pStubMsg, pMemory + pCStructFormat->memory_size,
4677                        pCArrayFormat + 4, 0);
4678
4679     TRACE("memory_size = %d\n", pCStructFormat->memory_size);
4680
4681     /* copy constant sized part of struct */
4682     pStubMsg->BufferMark = pStubMsg->Buffer;
4683
4684     if (pCStructFormat->type == RPC_FC_CPSTRUCT)
4685         EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
4686 }
4687
4688 /***********************************************************************
4689  *           NdrConformantVaryingStructMarshall [RPCRT4.@]
4690  */
4691 unsigned char *  WINAPI NdrConformantVaryingStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
4692                                 unsigned char *pMemory,
4693                                 PFORMAT_STRING pFormat)
4694 {
4695     const NDR_CVSTRUCT_FORMAT *pCVStructFormat = (const NDR_CVSTRUCT_FORMAT *)pFormat;
4696     PFORMAT_STRING pCVArrayFormat;
4697
4698     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4699
4700     pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
4701     if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
4702     {
4703         ERR("invalid format type %x\n", pCVStructFormat->type);
4704         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4705         return NULL;
4706     }
4707
4708     pCVArrayFormat = (const unsigned char *)&pCVStructFormat->offset_to_array_description +
4709         pCVStructFormat->offset_to_array_description;
4710
4711     array_compute_and_write_conformance(*pCVArrayFormat, pStubMsg,
4712                                         pMemory + pCVStructFormat->memory_size,
4713                                         pCVArrayFormat);
4714
4715     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, pCVStructFormat->alignment + 1);
4716
4717     TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
4718
4719     /* write constant sized part */
4720     pStubMsg->BufferMark = pStubMsg->Buffer;
4721     safe_copy_to_buffer(pStubMsg, pMemory, pCVStructFormat->memory_size);
4722
4723     array_write_variance_and_marshall(*pCVArrayFormat, pStubMsg,
4724                                       pMemory + pCVStructFormat->memory_size,
4725                                       pCVArrayFormat, FALSE /* fHasPointers */);
4726
4727     EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
4728
4729     return NULL;
4730 }
4731
4732 /***********************************************************************
4733  *           NdrConformantVaryingStructUnmarshall [RPCRT4.@]
4734  */
4735 unsigned char *  WINAPI NdrConformantVaryingStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
4736                                 unsigned char **ppMemory,
4737                                 PFORMAT_STRING pFormat,
4738                                 unsigned char fMustAlloc)
4739 {
4740     const NDR_CVSTRUCT_FORMAT *pCVStructFormat = (const NDR_CVSTRUCT_FORMAT *)pFormat;
4741     PFORMAT_STRING pCVArrayFormat;
4742     ULONG memsize, bufsize;
4743     unsigned char *saved_buffer, *saved_array_buffer;
4744     ULONG offset;
4745     unsigned char *array_memory;
4746
4747     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
4748
4749     pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
4750     if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
4751     {
4752         ERR("invalid format type %x\n", pCVStructFormat->type);
4753         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4754         return NULL;
4755     }
4756
4757     pCVArrayFormat = (const unsigned char *)&pCVStructFormat->offset_to_array_description +
4758         pCVStructFormat->offset_to_array_description;
4759
4760     memsize = array_read_conformance(*pCVArrayFormat, pStubMsg,
4761                                      pCVArrayFormat);
4762
4763     ALIGN_POINTER(pStubMsg->Buffer, pCVStructFormat->alignment + 1);
4764
4765     TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
4766
4767     /* work out how much memory to allocate if we need to do so */
4768     if (!fMustAlloc && !*ppMemory)
4769         fMustAlloc = TRUE;
4770     if (fMustAlloc)
4771     {
4772         SIZE_T size = pCVStructFormat->memory_size + memsize;
4773         *ppMemory = NdrAllocate(pStubMsg, size);
4774     }
4775
4776     /* mark the start of the constant data */
4777     saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer;
4778     safe_buffer_increment(pStubMsg, pCVStructFormat->memory_size);
4779
4780     array_memory = *ppMemory + pCVStructFormat->memory_size;
4781     bufsize = array_read_variance_and_unmarshall(*pCVArrayFormat, pStubMsg,
4782                                                  &array_memory, pCVArrayFormat,
4783                                                  FALSE /* fMustAlloc */,
4784                                                  FALSE /* fUseServerBufferMemory */,
4785                                                  FALSE /* fUnmarshall */);
4786
4787     /* save offset in case unmarshalling pointers changes it */
4788     offset = pStubMsg->Offset;
4789
4790     /* mark the start of the array data */
4791     saved_array_buffer = pStubMsg->Buffer;
4792     safe_buffer_increment(pStubMsg, bufsize);
4793
4794     EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat, fMustAlloc);
4795
4796     /* copy the constant data */
4797     memcpy(*ppMemory, saved_buffer, pCVStructFormat->memory_size);
4798     /* copy the array data */
4799     TRACE("copying %p to %p\n", saved_array_buffer, *ppMemory + pCVStructFormat->memory_size);
4800     memcpy(*ppMemory + pCVStructFormat->memory_size + offset,
4801            saved_array_buffer, bufsize);
4802
4803     if (*pCVArrayFormat == RPC_FC_C_CSTRING)
4804         TRACE("string=%s\n", debugstr_a((char *)(*ppMemory + pCVStructFormat->memory_size)));
4805     else if (*pCVArrayFormat == RPC_FC_C_WSTRING)
4806         TRACE("string=%s\n", debugstr_w((WCHAR *)(*ppMemory + pCVStructFormat->memory_size)));
4807
4808     return NULL;
4809 }
4810
4811 /***********************************************************************
4812  *           NdrConformantVaryingStructBufferSize [RPCRT4.@]
4813  */
4814 void WINAPI NdrConformantVaryingStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
4815                                 unsigned char *pMemory,
4816                                 PFORMAT_STRING pFormat)
4817 {
4818     const NDR_CVSTRUCT_FORMAT *pCVStructFormat = (const NDR_CVSTRUCT_FORMAT *)pFormat;
4819     PFORMAT_STRING pCVArrayFormat;
4820
4821     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4822
4823     pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
4824     if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
4825     {
4826         ERR("invalid format type %x\n", pCVStructFormat->type);
4827         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4828         return;
4829     }
4830
4831     pCVArrayFormat = (const unsigned char *)&pCVStructFormat->offset_to_array_description +
4832         pCVStructFormat->offset_to_array_description;
4833     array_compute_and_size_conformance(*pCVArrayFormat, pStubMsg,
4834                                        pMemory + pCVStructFormat->memory_size,
4835                                        pCVArrayFormat);
4836
4837     ALIGN_LENGTH(pStubMsg->BufferLength, pCVStructFormat->alignment + 1);
4838
4839     TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
4840
4841     safe_buffer_length_increment(pStubMsg, pCVStructFormat->memory_size);
4842
4843     array_buffer_size(*pCVArrayFormat, pStubMsg,
4844                       pMemory + pCVStructFormat->memory_size, pCVArrayFormat,
4845                       FALSE /* fHasPointers */);
4846
4847     EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
4848 }
4849
4850 /***********************************************************************
4851  *           NdrConformantVaryingStructMemorySize [RPCRT4.@]
4852  */
4853 ULONG WINAPI NdrConformantVaryingStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
4854                                 PFORMAT_STRING pFormat)
4855 {
4856     const NDR_CVSTRUCT_FORMAT *pCVStructFormat = (const NDR_CVSTRUCT_FORMAT *)pFormat;
4857     PFORMAT_STRING pCVArrayFormat;
4858
4859     TRACE("(%p, %p)\n", pStubMsg, pFormat);
4860
4861     pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
4862     if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
4863     {
4864         ERR("invalid format type %x\n", pCVStructFormat->type);
4865         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4866         return 0;
4867     }
4868
4869     pCVArrayFormat = (const unsigned char *)&pCVStructFormat->offset_to_array_description +
4870         pCVStructFormat->offset_to_array_description;
4871     array_read_conformance(*pCVArrayFormat, pStubMsg, pCVArrayFormat);
4872
4873     ALIGN_POINTER(pStubMsg->Buffer, pCVStructFormat->alignment + 1);
4874
4875     TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
4876
4877     safe_buffer_increment(pStubMsg, pCVStructFormat->memory_size);
4878     array_memory_size(*pCVArrayFormat, pStubMsg, pCVArrayFormat,
4879                       FALSE /* fHasPointers */);
4880
4881     pStubMsg->MemorySize += pCVStructFormat->memory_size;
4882
4883     EmbeddedPointerMemorySize(pStubMsg, pFormat);
4884
4885     return pStubMsg->MemorySize;
4886 }
4887
4888 /***********************************************************************
4889  *           NdrConformantVaryingStructFree [RPCRT4.@]
4890  */
4891 void WINAPI NdrConformantVaryingStructFree(PMIDL_STUB_MESSAGE pStubMsg,
4892                                 unsigned char *pMemory,
4893                                 PFORMAT_STRING pFormat)
4894 {
4895     const NDR_CVSTRUCT_FORMAT *pCVStructFormat = (const NDR_CVSTRUCT_FORMAT *)pFormat;
4896     PFORMAT_STRING pCVArrayFormat;
4897
4898     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4899
4900     pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
4901     if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
4902     {
4903         ERR("invalid format type %x\n", pCVStructFormat->type);
4904         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4905         return;
4906     }
4907
4908     pCVArrayFormat = (const unsigned char *)&pCVStructFormat->offset_to_array_description +
4909         pCVStructFormat->offset_to_array_description;
4910     array_free(*pCVArrayFormat, pStubMsg,
4911                pMemory + pCVStructFormat->memory_size, pCVArrayFormat,
4912                FALSE /* fHasPointers */);
4913
4914     TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
4915
4916     EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
4917 }
4918
4919 #include "pshpack1.h"
4920 typedef struct
4921 {
4922     unsigned char type;
4923     unsigned char alignment;
4924     unsigned short total_size;
4925 } NDR_SMFARRAY_FORMAT;
4926
4927 typedef struct
4928 {
4929     unsigned char type;
4930     unsigned char alignment;
4931     ULONG total_size;
4932 } NDR_LGFARRAY_FORMAT;
4933 #include "poppack.h"
4934
4935 /***********************************************************************
4936  *           NdrFixedArrayMarshall [RPCRT4.@]
4937  */
4938 unsigned char *  WINAPI NdrFixedArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
4939                                 unsigned char *pMemory,
4940                                 PFORMAT_STRING pFormat)
4941 {
4942     const NDR_SMFARRAY_FORMAT *pSmFArrayFormat = (const NDR_SMFARRAY_FORMAT *)pFormat;
4943     ULONG total_size;
4944
4945     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4946
4947     if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
4948         (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
4949     {
4950         ERR("invalid format type %x\n", pSmFArrayFormat->type);
4951         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4952         return NULL;
4953     }
4954
4955     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
4956
4957     if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
4958     {
4959         total_size = pSmFArrayFormat->total_size;
4960         pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
4961     }
4962     else
4963     {
4964         const NDR_LGFARRAY_FORMAT *pLgFArrayFormat = (const NDR_LGFARRAY_FORMAT *)pFormat;
4965         total_size = pLgFArrayFormat->total_size;
4966         pFormat = (const unsigned char *)(pLgFArrayFormat + 1);
4967     }
4968
4969     pStubMsg->BufferMark = pStubMsg->Buffer;
4970     safe_copy_to_buffer(pStubMsg, pMemory, total_size);
4971
4972     pFormat = EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
4973
4974     return NULL;
4975 }
4976
4977 /***********************************************************************
4978  *           NdrFixedArrayUnmarshall [RPCRT4.@]
4979  */
4980 unsigned char *  WINAPI NdrFixedArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
4981                                 unsigned char **ppMemory,
4982                                 PFORMAT_STRING pFormat,
4983                                 unsigned char fMustAlloc)
4984 {
4985     const NDR_SMFARRAY_FORMAT *pSmFArrayFormat = (const NDR_SMFARRAY_FORMAT *)pFormat;
4986     ULONG total_size;
4987     unsigned char *saved_buffer;
4988
4989     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
4990
4991     if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
4992         (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
4993     {
4994         ERR("invalid format type %x\n", pSmFArrayFormat->type);
4995         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4996         return NULL;
4997     }
4998
4999     ALIGN_POINTER(pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
5000
5001     if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
5002     {
5003         total_size = pSmFArrayFormat->total_size;
5004         pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
5005     }
5006     else
5007     {
5008         const NDR_LGFARRAY_FORMAT *pLgFArrayFormat = (const NDR_LGFARRAY_FORMAT *)pFormat;
5009         total_size = pLgFArrayFormat->total_size;
5010         pFormat = (const unsigned char *)(pLgFArrayFormat + 1);
5011     }
5012
5013     if (fMustAlloc)
5014         *ppMemory = NdrAllocate(pStubMsg, total_size);
5015     else
5016     {
5017         if (!pStubMsg->IsClient && !*ppMemory)
5018             /* for servers, we just point straight into the RPC buffer */
5019             *ppMemory = pStubMsg->Buffer;
5020     }
5021
5022     saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer;
5023     safe_buffer_increment(pStubMsg, total_size);
5024     pFormat = EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat, fMustAlloc);
5025
5026     TRACE("copying %p to %p\n", saved_buffer, *ppMemory);
5027     if (*ppMemory != saved_buffer)
5028         memcpy(*ppMemory, saved_buffer, total_size);
5029
5030     return NULL;
5031 }
5032
5033 /***********************************************************************
5034  *           NdrFixedArrayBufferSize [RPCRT4.@]
5035  */
5036 void WINAPI NdrFixedArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
5037                                 unsigned char *pMemory,
5038                                 PFORMAT_STRING pFormat)
5039 {
5040     const NDR_SMFARRAY_FORMAT *pSmFArrayFormat = (const NDR_SMFARRAY_FORMAT *)pFormat;
5041     ULONG total_size;
5042
5043     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5044
5045     if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
5046         (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
5047     {
5048         ERR("invalid format type %x\n", pSmFArrayFormat->type);
5049         RpcRaiseException(RPC_S_INTERNAL_ERROR);
5050         return;
5051     }
5052
5053     ALIGN_LENGTH(pStubMsg->BufferLength, pSmFArrayFormat->alignment + 1);
5054
5055     if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
5056     {
5057         total_size = pSmFArrayFormat->total_size;
5058         pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
5059     }
5060     else
5061     {
5062         const NDR_LGFARRAY_FORMAT *pLgFArrayFormat = (const NDR_LGFARRAY_FORMAT *)pFormat;
5063         total_size = pLgFArrayFormat->total_size;
5064         pFormat = (const unsigned char *)(pLgFArrayFormat + 1);
5065     }
5066     safe_buffer_length_increment(pStubMsg, total_size);
5067
5068     EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
5069 }
5070
5071 /***********************************************************************
5072  *           NdrFixedArrayMemorySize [RPCRT4.@]
5073  */
5074 ULONG WINAPI NdrFixedArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
5075                                 PFORMAT_STRING pFormat)
5076 {
5077     const NDR_SMFARRAY_FORMAT *pSmFArrayFormat = (const NDR_SMFARRAY_FORMAT *)pFormat;
5078     ULONG total_size;
5079
5080     TRACE("(%p, %p)\n", pStubMsg, pFormat);
5081
5082     if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
5083         (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
5084     {
5085         ERR("invalid format type %x\n", pSmFArrayFormat->type);
5086         RpcRaiseException(RPC_S_INTERNAL_ERROR);
5087         return 0;
5088     }
5089
5090     ALIGN_POINTER(pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
5091
5092     if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
5093     {
5094         total_size = pSmFArrayFormat->total_size;
5095         pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
5096     }
5097     else
5098     {
5099         const NDR_LGFARRAY_FORMAT *pLgFArrayFormat = (const NDR_LGFARRAY_FORMAT *)pFormat;
5100         total_size = pLgFArrayFormat->total_size;
5101         pFormat = (const unsigned char *)(pLgFArrayFormat + 1);
5102     }
5103     pStubMsg->BufferMark = pStubMsg->Buffer;
5104     safe_buffer_increment(pStubMsg, total_size);
5105     pStubMsg->MemorySize += total_size;
5106
5107     EmbeddedPointerMemorySize(pStubMsg, pFormat);
5108
5109     return total_size;
5110 }
5111
5112 /***********************************************************************
5113  *           NdrFixedArrayFree [RPCRT4.@]
5114  */
5115 void WINAPI NdrFixedArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
5116                                 unsigned char *pMemory,
5117                                 PFORMAT_STRING pFormat)
5118 {
5119     const NDR_SMFARRAY_FORMAT *pSmFArrayFormat = (const NDR_SMFARRAY_FORMAT *)pFormat;
5120
5121     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5122
5123     if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
5124         (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
5125     {
5126         ERR("invalid format type %x\n", pSmFArrayFormat->type);
5127         RpcRaiseException(RPC_S_INTERNAL_ERROR);
5128         return;
5129     }
5130
5131     if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
5132         pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
5133     else
5134     {
5135         const NDR_LGFARRAY_FORMAT *pLgFArrayFormat = (const NDR_LGFARRAY_FORMAT *)pFormat;
5136         pFormat = (const unsigned char *)(pLgFArrayFormat + 1);
5137     }
5138
5139     EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
5140 }
5141
5142 /***********************************************************************
5143  *           NdrVaryingArrayMarshall [RPCRT4.@]
5144  */
5145 unsigned char *  WINAPI NdrVaryingArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
5146                                 unsigned char *pMemory,
5147                                 PFORMAT_STRING pFormat)
5148 {
5149     unsigned char alignment;
5150     DWORD elements, esize;
5151     ULONG bufsize;
5152
5153     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5154
5155     if ((pFormat[0] != RPC_FC_SMVARRAY) &&
5156         (pFormat[0] != RPC_FC_LGVARRAY))
5157     {
5158         ERR("invalid format type %x\n", pFormat[0]);
5159         RpcRaiseException(RPC_S_INTERNAL_ERROR);
5160         return NULL;
5161     }
5162
5163     alignment = pFormat[1] + 1;
5164
5165     if (pFormat[0] == RPC_FC_SMVARRAY)
5166     {
5167         pFormat += 2;
5168         pFormat += sizeof(WORD);
5169         elements = *(const WORD*)pFormat;
5170         pFormat += sizeof(WORD);
5171     }
5172     else
5173     {
5174         pFormat += 2;
5175         pFormat += sizeof(DWORD);
5176         elements = *(const DWORD*)pFormat;
5177         pFormat += sizeof(DWORD);
5178     }
5179
5180     esize = *(const WORD*)pFormat;
5181     pFormat += sizeof(WORD);
5182
5183     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
5184     if ((pStubMsg->ActualCount > elements) ||
5185         (pStubMsg->ActualCount + pStubMsg->Offset > elements))
5186     {
5187         RpcRaiseException(RPC_S_INVALID_BOUND);
5188         return NULL;
5189     }
5190
5191     WriteVariance(pStubMsg);
5192
5193     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, alignment);
5194
5195     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
5196     pStubMsg->BufferMark = pStubMsg->Buffer;
5197     safe_copy_to_buffer(pStubMsg, pMemory + pStubMsg->Offset, bufsize);
5198
5199     EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
5200
5201     return NULL;
5202 }
5203
5204 /***********************************************************************
5205  *           NdrVaryingArrayUnmarshall [RPCRT4.@]
5206  */
5207 unsigned char *  WINAPI NdrVaryingArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
5208                                 unsigned char **ppMemory,
5209                                 PFORMAT_STRING pFormat,
5210                                 unsigned char fMustAlloc)
5211 {
5212     unsigned char alignment;
5213     DWORD size, elements, esize;
5214     ULONG bufsize;
5215     unsigned char *saved_buffer;
5216     ULONG offset;
5217
5218     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
5219
5220     if ((pFormat[0] != RPC_FC_SMVARRAY) &&
5221         (pFormat[0] != RPC_FC_LGVARRAY))
5222     {
5223         ERR("invalid format type %x\n", pFormat[0]);
5224         RpcRaiseException(RPC_S_INTERNAL_ERROR);
5225         return NULL;
5226     }
5227
5228     alignment = pFormat[1] + 1;
5229
5230     if (pFormat[0] == RPC_FC_SMVARRAY)
5231     {
5232         pFormat += 2;
5233         size = *(const WORD*)pFormat;
5234         pFormat += sizeof(WORD);
5235         elements = *(const WORD*)pFormat;
5236         pFormat += sizeof(WORD);
5237     }
5238     else
5239     {
5240         pFormat += 2;
5241         size = *(const DWORD*)pFormat;
5242         pFormat += sizeof(DWORD);
5243         elements = *(const DWORD*)pFormat;
5244         pFormat += sizeof(DWORD);
5245     }
5246
5247     esize = *(const WORD*)pFormat;
5248     pFormat += sizeof(WORD);
5249
5250     pFormat = ReadVariance(pStubMsg, pFormat, elements);
5251
5252     ALIGN_POINTER(pStubMsg->Buffer, alignment);
5253
5254     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
5255     offset = pStubMsg->Offset;
5256
5257     if (!fMustAlloc && !*ppMemory)
5258         fMustAlloc = TRUE;
5259     if (fMustAlloc)
5260         *ppMemory = NdrAllocate(pStubMsg, size);
5261     saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer;
5262     safe_buffer_increment(pStubMsg, bufsize);
5263
5264     EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat, fMustAlloc);
5265
5266     memcpy(*ppMemory + offset, saved_buffer, bufsize);
5267
5268     return NULL;
5269 }
5270
5271 /***********************************************************************
5272  *           NdrVaryingArrayBufferSize [RPCRT4.@]
5273  */
5274 void WINAPI NdrVaryingArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
5275                                 unsigned char *pMemory,
5276                                 PFORMAT_STRING pFormat)
5277 {
5278     unsigned char alignment;
5279     DWORD elements, esize;
5280
5281     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5282
5283     if ((pFormat[0] != RPC_FC_SMVARRAY) &&
5284         (pFormat[0] != RPC_FC_LGVARRAY))
5285     {
5286         ERR("invalid format type %x\n", pFormat[0]);
5287         RpcRaiseException(RPC_S_INTERNAL_ERROR);
5288         return;
5289     }
5290
5291     alignment = pFormat[1] + 1;
5292
5293     if (pFormat[0] == RPC_FC_SMVARRAY)
5294     {
5295         pFormat += 2;
5296         pFormat += sizeof(WORD);
5297         elements = *(const WORD*)pFormat;
5298         pFormat += sizeof(WORD);
5299     }
5300     else
5301     {
5302         pFormat += 2;
5303         pFormat += sizeof(DWORD);
5304         elements = *(const DWORD*)pFormat;
5305         pFormat += sizeof(DWORD);
5306     }
5307
5308     esize = *(const WORD*)pFormat;
5309     pFormat += sizeof(WORD);
5310
5311     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
5312     if ((pStubMsg->ActualCount > elements) ||
5313         (pStubMsg->ActualCount + pStubMsg->Offset > elements))
5314     {
5315         RpcRaiseException(RPC_S_INVALID_BOUND);
5316         return;
5317     }
5318
5319     SizeVariance(pStubMsg);
5320
5321     ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
5322
5323     safe_buffer_length_increment(pStubMsg, safe_multiply(esize, pStubMsg->ActualCount));
5324
5325     EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
5326 }
5327
5328 /***********************************************************************
5329  *           NdrVaryingArrayMemorySize [RPCRT4.@]
5330  */
5331 ULONG WINAPI NdrVaryingArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
5332                                 PFORMAT_STRING pFormat)
5333 {
5334     unsigned char alignment;
5335     DWORD size, elements, esize;
5336
5337     TRACE("(%p, %p)\n", pStubMsg, pFormat);
5338
5339     if ((pFormat[0] != RPC_FC_SMVARRAY) &&
5340         (pFormat[0] != RPC_FC_LGVARRAY))
5341     {
5342         ERR("invalid format type %x\n", pFormat[0]);
5343         RpcRaiseException(RPC_S_INTERNAL_ERROR);
5344         return 0;
5345     }
5346
5347     alignment = pFormat[1] + 1;
5348
5349     if (pFormat[0] == RPC_FC_SMVARRAY)
5350     {
5351         pFormat += 2;
5352         size = *(const WORD*)pFormat;
5353         pFormat += sizeof(WORD);
5354         elements = *(const WORD*)pFormat;
5355         pFormat += sizeof(WORD);
5356     }
5357     else
5358     {
5359         pFormat += 2;
5360         size = *(const DWORD*)pFormat;
5361         pFormat += sizeof(DWORD);
5362         elements = *(const DWORD*)pFormat;
5363         pFormat += sizeof(DWORD);
5364     }
5365
5366     esize = *(const WORD*)pFormat;
5367     pFormat += sizeof(WORD);
5368
5369     pFormat = ReadVariance(pStubMsg, pFormat, elements);
5370
5371     ALIGN_POINTER(pStubMsg->Buffer, alignment);
5372
5373     safe_buffer_increment(pStubMsg, safe_multiply(esize, pStubMsg->ActualCount));
5374     pStubMsg->MemorySize += size;
5375
5376     EmbeddedPointerMemorySize(pStubMsg, pFormat);
5377
5378     return pStubMsg->MemorySize;
5379 }
5380
5381 /***********************************************************************
5382  *           NdrVaryingArrayFree [RPCRT4.@]
5383  */
5384 void WINAPI NdrVaryingArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
5385                                 unsigned char *pMemory,
5386                                 PFORMAT_STRING pFormat)
5387 {
5388     DWORD elements;
5389
5390     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5391
5392     if ((pFormat[0] != RPC_FC_SMVARRAY) &&
5393         (pFormat[0] != RPC_FC_LGVARRAY))
5394     {
5395         ERR("invalid format type %x\n", pFormat[0]);
5396         RpcRaiseException(RPC_S_INTERNAL_ERROR);
5397         return;
5398     }
5399
5400     if (pFormat[0] == RPC_FC_SMVARRAY)
5401     {
5402         pFormat += 2;
5403         pFormat += sizeof(WORD);
5404         elements = *(const WORD*)pFormat;
5405         pFormat += sizeof(WORD);
5406     }
5407     else
5408     {
5409         pFormat += 2;
5410         pFormat += sizeof(DWORD);
5411         elements = *(const DWORD*)pFormat;
5412         pFormat += sizeof(DWORD);
5413     }
5414
5415     pFormat += sizeof(WORD);
5416
5417     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
5418     if ((pStubMsg->ActualCount > elements) ||
5419         (pStubMsg->ActualCount + pStubMsg->Offset > elements))
5420     {
5421         RpcRaiseException(RPC_S_INVALID_BOUND);
5422         return;
5423     }
5424
5425     EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
5426 }
5427
5428 static ULONG get_discriminant(unsigned char fc, const unsigned char *pMemory)
5429 {
5430     switch (fc)
5431     {
5432     case RPC_FC_BYTE:
5433     case RPC_FC_CHAR:
5434     case RPC_FC_SMALL:
5435     case RPC_FC_USMALL:
5436         return *pMemory;
5437     case RPC_FC_WCHAR:
5438     case RPC_FC_SHORT:
5439     case RPC_FC_USHORT:
5440     case RPC_FC_ENUM16:
5441         return *(const USHORT *)pMemory;
5442     case RPC_FC_LONG:
5443     case RPC_FC_ULONG:
5444     case RPC_FC_ENUM32:
5445         return *(const ULONG *)pMemory;
5446     default:
5447         FIXME("Unhandled base type: 0x%02x\n", fc);
5448         return 0;
5449     }
5450 }
5451
5452 static PFORMAT_STRING get_arm_offset_from_union_arm_selector(PMIDL_STUB_MESSAGE pStubMsg,
5453                                                              ULONG discriminant,
5454                                                              PFORMAT_STRING pFormat)
5455 {
5456     unsigned short num_arms, arm, type;
5457
5458     num_arms = *(const SHORT*)pFormat & 0x0fff;
5459     pFormat += 2;
5460     for(arm = 0; arm < num_arms; arm++)
5461     {
5462         if(discriminant == *(const ULONG*)pFormat)
5463         {
5464             pFormat += 4;
5465             break;
5466         }
5467         pFormat += 6;
5468     }
5469
5470     type = *(const unsigned short*)pFormat;
5471     TRACE("type %04x\n", type);
5472     if(arm == num_arms) /* default arm extras */
5473     {
5474         if(type == 0xffff)
5475         {
5476             ERR("no arm for 0x%x and no default case\n", discriminant);
5477             RpcRaiseException(RPC_S_INVALID_TAG);
5478             return NULL;
5479         }
5480         if(type == 0)
5481         {
5482             TRACE("falling back to empty default case for 0x%x\n", discriminant);
5483             return NULL;
5484         }
5485     }
5486     return pFormat;
5487 }
5488
5489 static unsigned char *union_arm_marshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, ULONG discriminant, PFORMAT_STRING pFormat)
5490 {
5491     unsigned short type;
5492
5493     pFormat += 2;
5494
5495     pFormat = get_arm_offset_from_union_arm_selector(pStubMsg, discriminant, pFormat);
5496     if(!pFormat)
5497         return NULL;
5498
5499     type = *(const unsigned short*)pFormat;
5500     if((type & 0xff00) == 0x8000)
5501     {
5502         unsigned char basetype = LOBYTE(type);
5503         return NdrBaseTypeMarshall(pStubMsg, pMemory, &basetype);
5504     }
5505     else
5506     {
5507         PFORMAT_STRING desc = pFormat + *(const SHORT*)pFormat;
5508         NDR_MARSHALL m = NdrMarshaller[*desc & NDR_TABLE_MASK];
5509         if (m)
5510         {
5511             unsigned char *saved_buffer = NULL;
5512             int pointer_buffer_mark_set = 0;
5513             switch(*desc)
5514             {
5515             case RPC_FC_RP:
5516             case RPC_FC_UP:
5517             case RPC_FC_OP:
5518             case RPC_FC_FP:
5519                 ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
5520                 saved_buffer = pStubMsg->Buffer;
5521                 if (pStubMsg->PointerBufferMark)
5522                 {
5523                   pStubMsg->Buffer = pStubMsg->PointerBufferMark;
5524                   pStubMsg->PointerBufferMark = NULL;
5525                   pointer_buffer_mark_set = 1;
5526                 }
5527                 else
5528                   safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
5529
5530                 PointerMarshall(pStubMsg, saved_buffer, *(unsigned char **)pMemory, desc);
5531                 if (pointer_buffer_mark_set)
5532                 {
5533                   STD_OVERFLOW_CHECK(pStubMsg);
5534                   pStubMsg->PointerBufferMark = pStubMsg->Buffer;
5535                   if (saved_buffer + 4 > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
5536                   {
5537                       ERR("buffer overflow - saved_buffer = %p, BufferEnd = %p\n",
5538                           saved_buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength);
5539                       RpcRaiseException(RPC_X_BAD_STUB_DATA);
5540                   }
5541                   pStubMsg->Buffer = saved_buffer + 4;
5542                 }
5543                 break;
5544             default:
5545                 m(pStubMsg, pMemory, desc);
5546             }
5547         }
5548         else FIXME("no marshaller for embedded type %02x\n", *desc);
5549     }
5550     return NULL;
5551 }
5552
5553 static unsigned char *union_arm_unmarshall(PMIDL_STUB_MESSAGE pStubMsg,
5554                                 unsigned char **ppMemory,
5555                                 ULONG discriminant,
5556                                 PFORMAT_STRING pFormat,
5557                                 unsigned char fMustAlloc)
5558 {
5559     unsigned short type;
5560
5561     pFormat += 2;
5562
5563     pFormat = get_arm_offset_from_union_arm_selector(pStubMsg, discriminant, pFormat);
5564     if(!pFormat)
5565         return NULL;
5566
5567     type = *(const unsigned short*)pFormat;
5568     if((type & 0xff00) == 0x8000)
5569     {
5570         unsigned char basetype = LOBYTE(type);
5571         return NdrBaseTypeUnmarshall(pStubMsg, ppMemory, &basetype, FALSE);
5572     }
5573     else
5574     {
5575         PFORMAT_STRING desc = pFormat + *(const SHORT*)pFormat;
5576         NDR_UNMARSHALL m = NdrUnmarshaller[*desc & NDR_TABLE_MASK];
5577         if (m)
5578         {
5579             unsigned char *saved_buffer = NULL;
5580             int pointer_buffer_mark_set = 0;
5581             switch(*desc)
5582             {
5583             case RPC_FC_RP:
5584             case RPC_FC_UP:
5585             case RPC_FC_OP:
5586             case RPC_FC_FP:
5587                 ALIGN_POINTER(pStubMsg->Buffer, 4);
5588                 saved_buffer = pStubMsg->Buffer;
5589                 if (pStubMsg->PointerBufferMark)
5590                 {
5591                   pStubMsg->Buffer = pStubMsg->PointerBufferMark;
5592                   pStubMsg->PointerBufferMark = NULL;
5593                   pointer_buffer_mark_set = 1;
5594                 }
5595                 else
5596                   pStubMsg->Buffer += 4; /* for pointer ID */
5597
5598                 if (saved_buffer + 4 > pStubMsg->BufferEnd)
5599                 {
5600                     ERR("buffer overflow - saved_buffer = %p, BufferEnd = %p\n",
5601                         saved_buffer, pStubMsg->BufferEnd);
5602                     RpcRaiseException(RPC_X_BAD_STUB_DATA);
5603                 }
5604
5605                 PointerUnmarshall(pStubMsg, saved_buffer, *(unsigned char ***)ppMemory, **(unsigned char ***)ppMemory, desc, fMustAlloc);
5606                 if (pointer_buffer_mark_set)
5607                 {
5608                   STD_OVERFLOW_CHECK(pStubMsg);
5609                   pStubMsg->PointerBufferMark = pStubMsg->Buffer;
5610                   pStubMsg->Buffer = saved_buffer + 4;
5611                 }
5612                 break;
5613             default:
5614                 m(pStubMsg, ppMemory, desc, fMustAlloc);
5615             }
5616         }
5617         else FIXME("no marshaller for embedded type %02x\n", *desc);
5618     }
5619     return NULL;
5620 }
5621
5622 static void union_arm_buffer_size(PMIDL_STUB_MESSAGE pStubMsg,
5623                                   unsigned char *pMemory,
5624                                   ULONG discriminant,
5625                                   PFORMAT_STRING pFormat)
5626 {
5627     unsigned short type;
5628
5629     pFormat += 2;
5630
5631     pFormat = get_arm_offset_from_union_arm_selector(pStubMsg, discriminant, pFormat);
5632     if(!pFormat)
5633         return;
5634
5635     type = *(const unsigned short*)pFormat;
5636     if((type & 0xff00) == 0x8000)
5637     {
5638         unsigned char basetype = LOBYTE(type);
5639         NdrBaseTypeBufferSize(pStubMsg, pMemory, &basetype);
5640     }
5641     else
5642     {
5643         PFORMAT_STRING desc = pFormat + *(const SHORT*)pFormat;
5644         NDR_BUFFERSIZE m = NdrBufferSizer[*desc & NDR_TABLE_MASK];
5645         if (m)
5646         {
5647             switch(*desc)
5648             {
5649             case RPC_FC_RP:
5650             case RPC_FC_UP:
5651             case RPC_FC_OP:
5652             case RPC_FC_FP:
5653                 ALIGN_LENGTH(pStubMsg->BufferLength, 4);
5654                 safe_buffer_length_increment(pStubMsg, 4); /* for pointer ID */
5655                 if (!pStubMsg->IgnoreEmbeddedPointers)
5656                 {
5657                     int saved_buffer_length = pStubMsg->BufferLength;
5658                     pStubMsg->BufferLength = pStubMsg->PointerLength;
5659                     pStubMsg->PointerLength = 0;
5660                     if(!pStubMsg->BufferLength)
5661                         ERR("BufferLength == 0??\n");
5662                     PointerBufferSize(pStubMsg, *(unsigned char **)pMemory, desc);
5663                     pStubMsg->PointerLength = pStubMsg->BufferLength;
5664                     pStubMsg->BufferLength = saved_buffer_length;
5665                 }
5666                 break;
5667             default:
5668                 m(pStubMsg, pMemory, desc);
5669             }
5670         }
5671         else FIXME("no buffersizer for embedded type %02x\n", *desc);
5672     }
5673 }
5674
5675 static ULONG union_arm_memory_size(PMIDL_STUB_MESSAGE pStubMsg,
5676                                    ULONG discriminant,
5677                                    PFORMAT_STRING pFormat)
5678 {
5679     unsigned short type, size;
5680
5681     size = *(const unsigned short*)pFormat;
5682     pStubMsg->Memory += size;
5683     pFormat += 2;
5684
5685     pFormat = get_arm_offset_from_union_arm_selector(pStubMsg, discriminant, pFormat);
5686     if(!pFormat)
5687         return 0;
5688
5689     type = *(const unsigned short*)pFormat;
5690     if((type & 0xff00) == 0x8000)
5691     {
5692         return NdrBaseTypeMemorySize(pStubMsg, pFormat);
5693     }
5694     else
5695     {
5696         PFORMAT_STRING desc = pFormat + *(const SHORT*)pFormat;
5697         NDR_MEMORYSIZE m = NdrMemorySizer[*desc & NDR_TABLE_MASK];
5698         unsigned char *saved_buffer;
5699         if (m)
5700         {
5701             switch(*desc)
5702             {
5703             case RPC_FC_RP:
5704             case RPC_FC_UP:
5705             case RPC_FC_OP:
5706             case RPC_FC_FP:
5707                 ALIGN_POINTER(pStubMsg->Buffer, 4);
5708                 saved_buffer = pStubMsg->Buffer;
5709                 safe_buffer_increment(pStubMsg, 4);
5710                 ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(void *));
5711                 pStubMsg->MemorySize += sizeof(void *);
5712                 if (!pStubMsg->IgnoreEmbeddedPointers)
5713                     PointerMemorySize(pStubMsg, saved_buffer, pFormat);
5714                 break;
5715             default:
5716                 return m(pStubMsg, desc);
5717             }
5718         }
5719         else FIXME("no marshaller for embedded type %02x\n", *desc);
5720     }
5721
5722     TRACE("size %d\n", size);
5723     return size;
5724 }
5725
5726 static void union_arm_free(PMIDL_STUB_MESSAGE pStubMsg,
5727                            unsigned char *pMemory,
5728                            ULONG discriminant,
5729                            PFORMAT_STRING pFormat)
5730 {
5731     unsigned short type;
5732
5733     pFormat += 2;
5734
5735     pFormat = get_arm_offset_from_union_arm_selector(pStubMsg, discriminant, pFormat);
5736     if(!pFormat)
5737         return;
5738
5739     type = *(const unsigned short*)pFormat;
5740     if((type & 0xff00) != 0x8000)
5741     {
5742         PFORMAT_STRING desc = pFormat + *(const SHORT*)pFormat;
5743         NDR_FREE m = NdrFreer[*desc & NDR_TABLE_MASK];
5744         if (m)
5745         {
5746             switch(*desc)
5747             {
5748             case RPC_FC_RP:
5749             case RPC_FC_UP:
5750             case RPC_FC_OP:
5751             case RPC_FC_FP:
5752                 PointerFree(pStubMsg, *(unsigned char **)pMemory, desc);
5753                 break;
5754             default:
5755                 m(pStubMsg, pMemory, desc);
5756             }
5757         }
5758     }
5759 }
5760
5761 /***********************************************************************
5762  *           NdrEncapsulatedUnionMarshall [RPCRT4.@]
5763  */
5764 unsigned char *  WINAPI NdrEncapsulatedUnionMarshall(PMIDL_STUB_MESSAGE pStubMsg,
5765                                 unsigned char *pMemory,
5766                                 PFORMAT_STRING pFormat)
5767 {
5768     unsigned char switch_type;
5769     unsigned char increment;
5770     ULONG switch_value;
5771
5772     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5773     pFormat++;
5774
5775     switch_type = *pFormat & 0xf;
5776     increment = (*pFormat & 0xf0) >> 4;
5777     pFormat++;
5778
5779     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, increment);
5780
5781     switch_value = get_discriminant(switch_type, pMemory);
5782     TRACE("got switch value 0x%x\n", switch_value);
5783
5784     NdrBaseTypeMarshall(pStubMsg, pMemory, &switch_type);
5785     pMemory += increment;
5786
5787     return union_arm_marshall(pStubMsg, pMemory, switch_value, pFormat);
5788 }
5789
5790 /***********************************************************************
5791  *           NdrEncapsulatedUnionUnmarshall [RPCRT4.@]
5792  */
5793 unsigned char *  WINAPI NdrEncapsulatedUnionUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
5794                                 unsigned char **ppMemory,
5795                                 PFORMAT_STRING pFormat,
5796                                 unsigned char fMustAlloc)
5797 {
5798     unsigned char switch_type;
5799     unsigned char increment;
5800     ULONG switch_value;
5801     unsigned short size;
5802     unsigned char *pMemoryArm;
5803
5804     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
5805     pFormat++;
5806
5807     switch_type = *pFormat & 0xf;
5808     increment = (*pFormat & 0xf0) >> 4;
5809     pFormat++;
5810
5811     ALIGN_POINTER(pStubMsg->Buffer, increment);
5812     switch_value = get_discriminant(switch_type, pStubMsg->Buffer);
5813     TRACE("got switch value 0x%x\n", switch_value);
5814
5815     size = *(const unsigned short*)pFormat + increment;
5816     if (!fMustAlloc && !*ppMemory)
5817         fMustAlloc = TRUE;
5818     if (fMustAlloc)
5819         *ppMemory = NdrAllocate(pStubMsg, size);
5820
5821     /* we can't pass fMustAlloc=TRUE into the marshaller for the arm
5822      * since the arm is part of the memory block that is encompassed by
5823      * the whole union. Memory is forced to allocate when pointers
5824      * are set to NULL, so we emulate that part of fMustAlloc=TRUE by
5825      * clearing the memory we pass in to the unmarshaller */
5826     if (fMustAlloc)
5827         memset(*ppMemory, 0, size);
5828
5829     NdrBaseTypeUnmarshall(pStubMsg, ppMemory, &switch_type, FALSE);
5830     pMemoryArm = *ppMemory + increment;
5831
5832     return union_arm_unmarshall(pStubMsg, &pMemoryArm, switch_value, pFormat, FALSE);
5833 }
5834
5835 /***********************************************************************
5836  *           NdrEncapsulatedUnionBufferSize [RPCRT4.@]
5837  */
5838 void WINAPI NdrEncapsulatedUnionBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
5839                                 unsigned char *pMemory,
5840                                 PFORMAT_STRING pFormat)
5841 {
5842     unsigned char switch_type;
5843     unsigned char increment;
5844     ULONG switch_value;
5845
5846     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5847     pFormat++;
5848
5849     switch_type = *pFormat & 0xf;
5850     increment = (*pFormat & 0xf0) >> 4;
5851     pFormat++;
5852
5853     ALIGN_LENGTH(pStubMsg->BufferLength, increment);
5854     switch_value = get_discriminant(switch_type, pMemory);
5855     TRACE("got switch value 0x%x\n", switch_value);
5856
5857     /* Add discriminant size */
5858     NdrBaseTypeBufferSize(pStubMsg, (unsigned char *)&switch_value, &switch_type);
5859     pMemory += increment;
5860
5861     union_arm_buffer_size(pStubMsg, pMemory, switch_value, pFormat);
5862 }
5863
5864 /***********************************************************************
5865  *           NdrEncapsulatedUnionMemorySize [RPCRT4.@]
5866  */
5867 ULONG WINAPI NdrEncapsulatedUnionMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
5868                                 PFORMAT_STRING pFormat)
5869 {
5870     unsigned char switch_type;
5871     unsigned char increment;
5872     ULONG switch_value;
5873
5874     switch_type = *pFormat & 0xf;
5875     increment = (*pFormat & 0xf0) >> 4;
5876     pFormat++;
5877
5878     ALIGN_POINTER(pStubMsg->Buffer, increment);
5879     switch_value = get_discriminant(switch_type, pStubMsg->Buffer);
5880     TRACE("got switch value 0x%x\n", switch_value);
5881
5882     pStubMsg->Memory += increment;
5883
5884     return increment + union_arm_memory_size(pStubMsg, switch_value, pFormat + *(const SHORT*)pFormat);
5885 }
5886
5887 /***********************************************************************
5888  *           NdrEncapsulatedUnionFree [RPCRT4.@]
5889  */
5890 void WINAPI NdrEncapsulatedUnionFree(PMIDL_STUB_MESSAGE pStubMsg,
5891                                 unsigned char *pMemory,
5892                                 PFORMAT_STRING pFormat)
5893 {
5894     unsigned char switch_type;
5895     unsigned char increment;
5896     ULONG switch_value;
5897
5898     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5899     pFormat++;
5900
5901     switch_type = *pFormat & 0xf;
5902     increment = (*pFormat & 0xf0) >> 4;
5903     pFormat++;
5904
5905     switch_value = get_discriminant(switch_type, pMemory);
5906     TRACE("got switch value 0x%x\n", switch_value);
5907
5908     pMemory += increment;
5909
5910     union_arm_free(pStubMsg, pMemory, switch_value, pFormat);
5911 }
5912
5913 /***********************************************************************
5914  *           NdrNonEncapsulatedUnionMarshall [RPCRT4.@]
5915  */
5916 unsigned char *  WINAPI NdrNonEncapsulatedUnionMarshall(PMIDL_STUB_MESSAGE pStubMsg,
5917                                 unsigned char *pMemory,
5918                                 PFORMAT_STRING pFormat)
5919 {
5920     unsigned char switch_type;
5921
5922     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5923     pFormat++;
5924
5925     switch_type = *pFormat;
5926     pFormat++;
5927
5928     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, 0);
5929     TRACE("got switch value 0x%lx\n", pStubMsg->MaxCount);
5930     /* Marshall discriminant */
5931     NdrBaseTypeMarshall(pStubMsg, (unsigned char *)&pStubMsg->MaxCount, &switch_type);
5932
5933     return union_arm_marshall(pStubMsg, pMemory, pStubMsg->MaxCount, pFormat + *(const SHORT*)pFormat);
5934 }
5935
5936 static LONG unmarshall_discriminant(PMIDL_STUB_MESSAGE pStubMsg,
5937                                     PFORMAT_STRING *ppFormat)
5938 {
5939     LONG discriminant = 0;
5940
5941     switch(**ppFormat)
5942     {
5943     case RPC_FC_BYTE:
5944     case RPC_FC_CHAR:
5945     case RPC_FC_SMALL:
5946     case RPC_FC_USMALL:
5947     {
5948         UCHAR d;
5949         safe_copy_from_buffer(pStubMsg, &d, sizeof(d));
5950         discriminant = d;
5951         break;
5952     }
5953     case RPC_FC_WCHAR:
5954     case RPC_FC_SHORT:
5955     case RPC_FC_USHORT:
5956     {
5957         USHORT d;
5958         ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
5959         safe_copy_from_buffer(pStubMsg, &d, sizeof(d));
5960         discriminant = d;
5961         break;
5962     }
5963     case RPC_FC_LONG:
5964     case RPC_FC_ULONG:
5965     {
5966         ULONG d;
5967         ALIGN_POINTER(pStubMsg->Buffer, sizeof(ULONG));
5968         safe_copy_from_buffer(pStubMsg, &d, sizeof(d));
5969         discriminant = d;
5970         break;
5971     }
5972     default:
5973         FIXME("Unhandled base type: 0x%02x\n", **ppFormat);
5974     }
5975     (*ppFormat)++;
5976
5977     if (pStubMsg->fHasNewCorrDesc)
5978         *ppFormat += 6;
5979     else
5980         *ppFormat += 4;
5981     return discriminant;
5982 }
5983
5984 /**********************************************************************
5985  *           NdrNonEncapsulatedUnionUnmarshall [RPCRT4.@]
5986  */
5987 unsigned char *  WINAPI NdrNonEncapsulatedUnionUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
5988                                 unsigned char **ppMemory,
5989                                 PFORMAT_STRING pFormat,
5990                                 unsigned char fMustAlloc)
5991 {
5992     LONG discriminant;
5993     unsigned short size;
5994
5995     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
5996     pFormat++;
5997
5998     /* Unmarshall discriminant */
5999     discriminant = unmarshall_discriminant(pStubMsg, &pFormat);
6000     TRACE("unmarshalled discriminant %x\n", discriminant);
6001
6002     pFormat += *(const SHORT*)pFormat;
6003
6004     size = *(const unsigned short*)pFormat;
6005
6006     if (!fMustAlloc && !*ppMemory)
6007         fMustAlloc = TRUE;
6008     if (fMustAlloc)
6009         *ppMemory = NdrAllocate(pStubMsg, size);
6010
6011     /* we can't pass fMustAlloc=TRUE into the marshaller for the arm
6012      * since the arm is part of the memory block that is encompassed by
6013      * the whole union. Memory is forced to allocate when pointers
6014      * are set to NULL, so we emulate that part of fMustAlloc=TRUE by
6015      * clearing the memory we pass in to the unmarshaller */
6016     if (fMustAlloc)
6017         memset(*ppMemory, 0, size);
6018
6019     return union_arm_unmarshall(pStubMsg, ppMemory, discriminant, pFormat, FALSE);
6020 }
6021
6022 /***********************************************************************
6023  *           NdrNonEncapsulatedUnionBufferSize [RPCRT4.@]
6024  */
6025 void WINAPI NdrNonEncapsulatedUnionBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
6026                                 unsigned char *pMemory,
6027                                 PFORMAT_STRING pFormat)
6028 {
6029     unsigned char switch_type;
6030
6031     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
6032     pFormat++;
6033
6034     switch_type = *pFormat;
6035     pFormat++;
6036
6037     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, 0);
6038     TRACE("got switch value 0x%lx\n", pStubMsg->MaxCount);
6039     /* Add discriminant size */
6040     NdrBaseTypeBufferSize(pStubMsg, (unsigned char *)&pStubMsg->MaxCount, &switch_type);
6041
6042     union_arm_buffer_size(pStubMsg, pMemory, pStubMsg->MaxCount, pFormat + *(const SHORT*)pFormat);
6043 }
6044
6045 /***********************************************************************
6046  *           NdrNonEncapsulatedUnionMemorySize [RPCRT4.@]
6047  */
6048 ULONG WINAPI NdrNonEncapsulatedUnionMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
6049                                 PFORMAT_STRING pFormat)
6050 {
6051     ULONG discriminant;
6052
6053     pFormat++;
6054     /* Unmarshall discriminant */
6055     discriminant = unmarshall_discriminant(pStubMsg, &pFormat);
6056     TRACE("unmarshalled discriminant 0x%x\n", discriminant);
6057
6058     return union_arm_memory_size(pStubMsg, discriminant, pFormat + *(const SHORT*)pFormat);
6059 }
6060
6061 /***********************************************************************
6062  *           NdrNonEncapsulatedUnionFree [RPCRT4.@]
6063  */
6064 void WINAPI NdrNonEncapsulatedUnionFree(PMIDL_STUB_MESSAGE pStubMsg,
6065                                 unsigned char *pMemory,
6066                                 PFORMAT_STRING pFormat)
6067 {
6068     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
6069     pFormat++;
6070     pFormat++;
6071
6072     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, 0);
6073     TRACE("got switch value 0x%lx\n", pStubMsg->MaxCount);
6074
6075     union_arm_free(pStubMsg, pMemory, pStubMsg->MaxCount, pFormat + *(const SHORT*)pFormat);
6076 }
6077
6078 /***********************************************************************
6079  *           NdrByteCountPointerMarshall [RPCRT4.@]
6080  */
6081 unsigned char *  WINAPI NdrByteCountPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
6082                                 unsigned char *pMemory,
6083                                 PFORMAT_STRING pFormat)
6084 {
6085     FIXME("stub\n");
6086     return NULL;
6087 }
6088
6089 /***********************************************************************
6090  *           NdrByteCountPointerUnmarshall [RPCRT4.@]
6091  */
6092 unsigned char *  WINAPI NdrByteCountPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
6093                                 unsigned char **ppMemory,
6094                                 PFORMAT_STRING pFormat,
6095                                 unsigned char fMustAlloc)
6096 {
6097     FIXME("stub\n");
6098     return NULL;
6099 }
6100
6101 /***********************************************************************
6102  *           NdrByteCountPointerBufferSize [RPCRT4.@]
6103  */
6104 void WINAPI NdrByteCountPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
6105                                 unsigned char *pMemory,
6106                                 PFORMAT_STRING pFormat)
6107 {
6108     FIXME("stub\n");
6109 }
6110
6111 /***********************************************************************
6112  *           NdrByteCountPointerMemorySize [internal]
6113  */
6114 static ULONG WINAPI NdrByteCountPointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
6115                                                   PFORMAT_STRING pFormat)
6116 {
6117     FIXME("stub\n");
6118     return 0;
6119 }
6120
6121 /***********************************************************************
6122  *           NdrByteCountPointerFree [RPCRT4.@]
6123  */
6124 void WINAPI NdrByteCountPointerFree(PMIDL_STUB_MESSAGE pStubMsg,
6125                                 unsigned char *pMemory,
6126                                 PFORMAT_STRING pFormat)
6127 {
6128     FIXME("stub\n");
6129 }
6130
6131 /***********************************************************************
6132  *           NdrXmitOrRepAsMarshall [RPCRT4.@]
6133  */
6134 unsigned char *  WINAPI NdrXmitOrRepAsMarshall(PMIDL_STUB_MESSAGE pStubMsg,
6135                                 unsigned char *pMemory,
6136                                 PFORMAT_STRING pFormat)
6137 {
6138     FIXME("stub\n");
6139     return NULL;
6140 }
6141
6142 /***********************************************************************
6143  *           NdrXmitOrRepAsUnmarshall [RPCRT4.@]
6144  */
6145 unsigned char *  WINAPI NdrXmitOrRepAsUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
6146                                 unsigned char **ppMemory,
6147                                 PFORMAT_STRING pFormat,
6148                                 unsigned char fMustAlloc)
6149 {
6150     FIXME("stub\n");
6151     return NULL;
6152 }
6153
6154 /***********************************************************************
6155  *           NdrXmitOrRepAsBufferSize [RPCRT4.@]
6156  */
6157 void WINAPI NdrXmitOrRepAsBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
6158                                 unsigned char *pMemory,
6159                                 PFORMAT_STRING pFormat)
6160 {
6161     FIXME("stub\n");
6162 }
6163
6164 /***********************************************************************
6165  *           NdrXmitOrRepAsMemorySize [RPCRT4.@]
6166  */
6167 ULONG WINAPI NdrXmitOrRepAsMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
6168                                 PFORMAT_STRING pFormat)
6169 {
6170     FIXME("stub\n");
6171     return 0;
6172 }
6173
6174 /***********************************************************************
6175  *           NdrXmitOrRepAsFree [RPCRT4.@]
6176  */
6177 void WINAPI NdrXmitOrRepAsFree(PMIDL_STUB_MESSAGE pStubMsg,
6178                                 unsigned char *pMemory,
6179                                 PFORMAT_STRING pFormat)
6180 {
6181     FIXME("stub\n");
6182 }
6183
6184 /***********************************************************************
6185  *           NdrRangeMarshall [internal]
6186  */
6187 static unsigned char *WINAPI NdrRangeMarshall(
6188     PMIDL_STUB_MESSAGE pStubMsg,
6189     unsigned char *pMemory,
6190     PFORMAT_STRING pFormat)
6191 {
6192     NDR_RANGE *pRange = (NDR_RANGE *)pFormat;
6193     unsigned char base_type;
6194
6195     TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
6196
6197     if (pRange->type != RPC_FC_RANGE)
6198     {
6199         ERR("invalid format type %x\n", pRange->type);
6200         RpcRaiseException(RPC_S_INTERNAL_ERROR);
6201         return NULL;
6202     }
6203
6204     base_type = pRange->flags_type & 0xf;
6205
6206     return NdrBaseTypeMarshall(pStubMsg, pMemory, &base_type);
6207 }
6208
6209 /***********************************************************************
6210  *           NdrRangeUnmarshall [RPCRT4.@]
6211  */
6212 unsigned char *WINAPI NdrRangeUnmarshall(
6213     PMIDL_STUB_MESSAGE pStubMsg,
6214     unsigned char **ppMemory,
6215     PFORMAT_STRING pFormat,
6216     unsigned char fMustAlloc)
6217 {
6218     NDR_RANGE *pRange = (NDR_RANGE *)pFormat;
6219     unsigned char base_type;
6220
6221     TRACE("pStubMsg: %p, ppMemory: %p, type: 0x%02x, fMustAlloc: %s\n", pStubMsg, ppMemory, *pFormat, fMustAlloc ? "true" : "false");
6222
6223     if (pRange->type != RPC_FC_RANGE)
6224     {
6225         ERR("invalid format type %x\n", pRange->type);
6226         RpcRaiseException(RPC_S_INTERNAL_ERROR);
6227         return NULL;
6228     }
6229     base_type = pRange->flags_type & 0xf;
6230
6231     TRACE("base_type = 0x%02x, low_value = %d, high_value = %d\n",
6232         base_type, pRange->low_value, pRange->high_value);
6233
6234 #define RANGE_UNMARSHALL(mem_type, wire_type, format_spec) \
6235     do \
6236     { \
6237         ALIGN_POINTER(pStubMsg->Buffer, sizeof(wire_type)); \
6238         if (!fMustAlloc && !*ppMemory) \
6239             fMustAlloc = TRUE; \
6240         if (fMustAlloc) \
6241             *ppMemory = NdrAllocate(pStubMsg, sizeof(mem_type)); \
6242         if (pStubMsg->Buffer + sizeof(wire_type) > pStubMsg->BufferEnd) \
6243         { \
6244             ERR("buffer overflow - Buffer = %p, BufferEnd = %p\n", \
6245                 pStubMsg->Buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength); \
6246             RpcRaiseException(RPC_X_BAD_STUB_DATA); \
6247         } \
6248         if ((*(wire_type *)pStubMsg->Buffer < (mem_type)pRange->low_value) || \
6249             (*(wire_type *)pStubMsg->Buffer > (mem_type)pRange->high_value)) \
6250         { \
6251             ERR("value exceeded bounds: " format_spec ", low: " format_spec ", high: " format_spec "\n", \
6252                 *(wire_type *)pStubMsg->Buffer, (mem_type)pRange->low_value, \
6253                 (mem_type)pRange->high_value); \
6254             RpcRaiseException(RPC_S_INVALID_BOUND); \
6255             return NULL; \
6256         } \
6257         TRACE("*ppMemory: %p\n", *ppMemory); \
6258         **(mem_type **)ppMemory = *(wire_type *)pStubMsg->Buffer; \
6259         pStubMsg->Buffer += sizeof(wire_type); \
6260     } while (0)
6261
6262     switch(base_type)
6263     {
6264     case RPC_FC_CHAR:
6265     case RPC_FC_SMALL:
6266         RANGE_UNMARSHALL(UCHAR, UCHAR, "%d");
6267         TRACE("value: 0x%02x\n", **ppMemory);
6268         break;
6269     case RPC_FC_BYTE:
6270     case RPC_FC_USMALL:
6271         RANGE_UNMARSHALL(CHAR, CHAR, "%u");
6272         TRACE("value: 0x%02x\n", **ppMemory);
6273         break;
6274     case RPC_FC_WCHAR: /* FIXME: valid? */
6275     case RPC_FC_USHORT:
6276         RANGE_UNMARSHALL(USHORT, USHORT, "%u");
6277         TRACE("value: 0x%04x\n", **(USHORT **)ppMemory);
6278         break;
6279     case RPC_FC_SHORT:
6280         RANGE_UNMARSHALL(SHORT, SHORT, "%d");
6281         TRACE("value: 0x%04x\n", **(USHORT **)ppMemory);
6282         break;
6283     case RPC_FC_LONG:
6284     case RPC_FC_ENUM32:
6285         RANGE_UNMARSHALL(LONG, LONG, "%d");
6286         TRACE("value: 0x%08x\n", **(ULONG **)ppMemory);
6287         break;
6288     case RPC_FC_ULONG:
6289         RANGE_UNMARSHALL(ULONG, ULONG, "%u");
6290         TRACE("value: 0x%08x\n", **(ULONG **)ppMemory);
6291         break;
6292     case RPC_FC_ENUM16:
6293         RANGE_UNMARSHALL(UINT, USHORT, "%u");
6294         TRACE("value: 0x%08x\n", **(UINT **)ppMemory);
6295         break;
6296     case RPC_FC_FLOAT:
6297     case RPC_FC_DOUBLE:
6298     case RPC_FC_HYPER:
6299     default:
6300         ERR("invalid range base type: 0x%02x\n", base_type);
6301         RpcRaiseException(RPC_S_INTERNAL_ERROR);
6302     }
6303
6304     return NULL;
6305 }
6306
6307 /***********************************************************************
6308  *           NdrRangeBufferSize [internal]
6309  */
6310 static void WINAPI NdrRangeBufferSize(
6311     PMIDL_STUB_MESSAGE pStubMsg,
6312     unsigned char *pMemory,
6313     PFORMAT_STRING pFormat)
6314 {
6315     NDR_RANGE *pRange = (NDR_RANGE *)pFormat;
6316     unsigned char base_type;
6317
6318     TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
6319
6320     if (pRange->type != RPC_FC_RANGE)
6321     {
6322         ERR("invalid format type %x\n", pRange->type);
6323         RpcRaiseException(RPC_S_INTERNAL_ERROR);
6324     }
6325     base_type = pRange->flags_type & 0xf;
6326
6327     NdrBaseTypeBufferSize(pStubMsg, pMemory, &base_type);
6328 }
6329
6330 /***********************************************************************
6331  *           NdrRangeMemorySize [internal]
6332  */
6333 static ULONG WINAPI NdrRangeMemorySize(
6334     PMIDL_STUB_MESSAGE pStubMsg,
6335     PFORMAT_STRING pFormat)
6336 {
6337     NDR_RANGE *pRange = (NDR_RANGE *)pFormat;
6338     unsigned char base_type;
6339
6340     if (pRange->type != RPC_FC_RANGE)
6341     {
6342         ERR("invalid format type %x\n", pRange->type);
6343         RpcRaiseException(RPC_S_INTERNAL_ERROR);
6344         return 0;
6345     }
6346     base_type = pRange->flags_type & 0xf;
6347
6348     return NdrBaseTypeMemorySize(pStubMsg, &base_type);
6349 }
6350
6351 /***********************************************************************
6352  *           NdrRangeFree [internal]
6353  */
6354 static void WINAPI NdrRangeFree(PMIDL_STUB_MESSAGE pStubMsg,
6355                                 unsigned char *pMemory,
6356                                 PFORMAT_STRING pFormat)
6357 {
6358    TRACE("pStubMsg %p pMemory %p type 0x%02x\n", pStubMsg, pMemory, *pFormat);
6359
6360    /* nothing to do */
6361 }
6362
6363 /***********************************************************************
6364  *           NdrBaseTypeMarshall [internal]
6365  */
6366 static unsigned char *WINAPI NdrBaseTypeMarshall(
6367     PMIDL_STUB_MESSAGE pStubMsg,
6368     unsigned char *pMemory,
6369     PFORMAT_STRING pFormat)
6370 {
6371     TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
6372
6373     switch(*pFormat)
6374     {
6375     case RPC_FC_BYTE:
6376     case RPC_FC_CHAR:
6377     case RPC_FC_SMALL:
6378     case RPC_FC_USMALL:
6379         safe_copy_to_buffer(pStubMsg, pMemory, sizeof(UCHAR));
6380         TRACE("value: 0x%02x\n", *pMemory);
6381         break;
6382     case RPC_FC_WCHAR:
6383     case RPC_FC_SHORT:
6384     case RPC_FC_USHORT:
6385         ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(USHORT));
6386         safe_copy_to_buffer(pStubMsg, pMemory, sizeof(USHORT));
6387         TRACE("value: 0x%04x\n", *(USHORT *)pMemory);
6388         break;
6389     case RPC_FC_LONG:
6390     case RPC_FC_ULONG:
6391     case RPC_FC_ERROR_STATUS_T:
6392     case RPC_FC_ENUM32:
6393         ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(ULONG));
6394         safe_copy_to_buffer(pStubMsg, pMemory, sizeof(ULONG));
6395         TRACE("value: 0x%08x\n", *(ULONG *)pMemory);
6396         break;
6397     case RPC_FC_FLOAT:
6398         ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(float));
6399         safe_copy_to_buffer(pStubMsg, pMemory, sizeof(float));
6400         break;
6401     case RPC_FC_DOUBLE:
6402         ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(double));
6403         safe_copy_to_buffer(pStubMsg, pMemory, sizeof(double));
6404         break;
6405     case RPC_FC_HYPER:
6406         ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(ULONGLONG));
6407         safe_copy_to_buffer(pStubMsg, pMemory, sizeof(ULONGLONG));
6408         TRACE("value: %s\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory));
6409         break;
6410     case RPC_FC_ENUM16:
6411         /* only 16-bits on the wire, so do a sanity check */
6412         if (*(UINT *)pMemory > SHRT_MAX)
6413             RpcRaiseException(RPC_X_ENUM_VALUE_OUT_OF_RANGE);
6414         ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(USHORT));
6415         if (pStubMsg->Buffer + sizeof(USHORT) > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
6416             RpcRaiseException(RPC_X_BAD_STUB_DATA);
6417         *(USHORT *)pStubMsg->Buffer = *(UINT *)pMemory;
6418         pStubMsg->Buffer += sizeof(USHORT);
6419         TRACE("value: 0x%04x\n", *(UINT *)pMemory);
6420         break;
6421     case RPC_FC_IGNORE:
6422         break;
6423     default:
6424         FIXME("Unhandled base type: 0x%02x\n", *pFormat);
6425     }
6426
6427     /* FIXME: what is the correct return value? */
6428     return NULL;
6429 }
6430
6431 /***********************************************************************
6432  *           NdrBaseTypeUnmarshall [internal]
6433  */
6434 static unsigned char *WINAPI NdrBaseTypeUnmarshall(
6435     PMIDL_STUB_MESSAGE pStubMsg,
6436     unsigned char **ppMemory,
6437     PFORMAT_STRING pFormat,
6438     unsigned char fMustAlloc)
6439 {
6440     TRACE("pStubMsg: %p, ppMemory: %p, type: 0x%02x, fMustAlloc: %s\n", pStubMsg, ppMemory, *pFormat, fMustAlloc ? "true" : "false");
6441
6442 #define BASE_TYPE_UNMARSHALL(type) \
6443         ALIGN_POINTER(pStubMsg->Buffer, sizeof(type)); \
6444         if (!fMustAlloc && !pStubMsg->IsClient && !*ppMemory) \
6445         { \
6446             *ppMemory = pStubMsg->Buffer; \
6447             TRACE("*ppMemory: %p\n", *ppMemory); \
6448             safe_buffer_increment(pStubMsg, sizeof(type)); \
6449         } \
6450         else \
6451         {  \
6452             if (fMustAlloc) \
6453                 *ppMemory = NdrAllocate(pStubMsg, sizeof(type)); \
6454             TRACE("*ppMemory: %p\n", *ppMemory); \
6455             safe_copy_from_buffer(pStubMsg, *ppMemory, sizeof(type)); \
6456         }
6457
6458     switch(*pFormat)
6459     {
6460     case RPC_FC_BYTE:
6461     case RPC_FC_CHAR:
6462     case RPC_FC_SMALL:
6463     case RPC_FC_USMALL:
6464         BASE_TYPE_UNMARSHALL(UCHAR);
6465         TRACE("value: 0x%02x\n", **ppMemory);
6466         break;
6467     case RPC_FC_WCHAR:
6468     case RPC_FC_SHORT:
6469     case RPC_FC_USHORT:
6470         BASE_TYPE_UNMARSHALL(USHORT);
6471         TRACE("value: 0x%04x\n", **(USHORT **)ppMemory);
6472         break;
6473     case RPC_FC_LONG:
6474     case RPC_FC_ULONG:
6475     case RPC_FC_ERROR_STATUS_T:
6476     case RPC_FC_ENUM32:
6477         BASE_TYPE_UNMARSHALL(ULONG);
6478         TRACE("value: 0x%08x\n", **(ULONG **)ppMemory);
6479         break;
6480    case RPC_FC_FLOAT:
6481         BASE_TYPE_UNMARSHALL(float);
6482         TRACE("value: %f\n", **(float **)ppMemory);
6483         break;
6484     case RPC_FC_DOUBLE:
6485         BASE_TYPE_UNMARSHALL(double);
6486         TRACE("value: %f\n", **(double **)ppMemory);
6487         break;
6488     case RPC_FC_HYPER:
6489         BASE_TYPE_UNMARSHALL(ULONGLONG);
6490         TRACE("value: %s\n", wine_dbgstr_longlong(**(ULONGLONG **)ppMemory));
6491         break;
6492     case RPC_FC_ENUM16:
6493         ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
6494         if (!fMustAlloc && !*ppMemory)
6495             fMustAlloc = TRUE;
6496         if (fMustAlloc)
6497             *ppMemory = NdrAllocate(pStubMsg, sizeof(UINT));
6498         if (pStubMsg->Buffer + sizeof(USHORT) > pStubMsg->BufferEnd)
6499             RpcRaiseException(RPC_X_BAD_STUB_DATA);
6500         TRACE("*ppMemory: %p\n", *ppMemory);
6501         /* 16-bits on the wire, but int in memory */
6502         **(UINT **)ppMemory = *(USHORT *)pStubMsg->Buffer;
6503         pStubMsg->Buffer += sizeof(USHORT);
6504         TRACE("value: 0x%08x\n", **(UINT **)ppMemory);
6505         break;
6506     case RPC_FC_IGNORE:
6507         break;
6508     default:
6509         FIXME("Unhandled base type: 0x%02x\n", *pFormat);
6510     }
6511 #undef BASE_TYPE_UNMARSHALL
6512
6513     /* FIXME: what is the correct return value? */
6514
6515     return NULL;
6516 }
6517
6518 /***********************************************************************
6519  *           NdrBaseTypeBufferSize [internal]
6520  */
6521 static void WINAPI NdrBaseTypeBufferSize(
6522     PMIDL_STUB_MESSAGE pStubMsg,
6523     unsigned char *pMemory,
6524     PFORMAT_STRING pFormat)
6525 {
6526     TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
6527
6528     switch(*pFormat)
6529     {
6530     case RPC_FC_BYTE:
6531     case RPC_FC_CHAR:
6532     case RPC_FC_SMALL:
6533     case RPC_FC_USMALL:
6534         safe_buffer_length_increment(pStubMsg, sizeof(UCHAR));
6535         break;
6536     case RPC_FC_WCHAR:
6537     case RPC_FC_SHORT:
6538     case RPC_FC_USHORT:
6539     case RPC_FC_ENUM16:
6540         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(USHORT));
6541         safe_buffer_length_increment(pStubMsg, sizeof(USHORT));
6542         break;
6543     case RPC_FC_LONG:
6544     case RPC_FC_ULONG:
6545     case RPC_FC_ENUM32:
6546         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(ULONG));
6547         safe_buffer_length_increment(pStubMsg, sizeof(ULONG));
6548         break;
6549     case RPC_FC_FLOAT:
6550         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(float));
6551         safe_buffer_length_increment(pStubMsg, sizeof(float));
6552         break;
6553     case RPC_FC_DOUBLE:
6554         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(double));
6555         safe_buffer_length_increment(pStubMsg, sizeof(double));
6556         break;
6557     case RPC_FC_HYPER:
6558         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(ULONGLONG));
6559         safe_buffer_length_increment(pStubMsg, sizeof(ULONGLONG));
6560         break;
6561     case RPC_FC_ERROR_STATUS_T:
6562         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(error_status_t));
6563         safe_buffer_length_increment(pStubMsg, sizeof(error_status_t));
6564         break;
6565     case RPC_FC_IGNORE:
6566         break;
6567     default:
6568         FIXME("Unhandled base type: 0x%02x\n", *pFormat);
6569     }
6570 }
6571
6572 /***********************************************************************
6573  *           NdrBaseTypeMemorySize [internal]
6574  */
6575 static ULONG WINAPI NdrBaseTypeMemorySize(
6576     PMIDL_STUB_MESSAGE pStubMsg,
6577     PFORMAT_STRING pFormat)
6578 {
6579     TRACE("pStubMsg %p, type 0x%02x\n", pStubMsg, *pFormat);
6580
6581     switch(*pFormat)
6582     {
6583     case RPC_FC_BYTE:
6584     case RPC_FC_CHAR:
6585     case RPC_FC_SMALL:
6586     case RPC_FC_USMALL:
6587         safe_buffer_increment(pStubMsg, sizeof(UCHAR));
6588         pStubMsg->MemorySize += sizeof(UCHAR);
6589         return sizeof(UCHAR);
6590     case RPC_FC_WCHAR:
6591     case RPC_FC_SHORT:
6592     case RPC_FC_USHORT:
6593         ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
6594         safe_buffer_increment(pStubMsg, sizeof(USHORT));
6595         ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(USHORT));
6596         pStubMsg->MemorySize += sizeof(USHORT);
6597         return sizeof(USHORT);
6598     case RPC_FC_LONG:
6599     case RPC_FC_ULONG:
6600     case RPC_FC_ENUM32:
6601         ALIGN_POINTER(pStubMsg->Buffer, sizeof(ULONG));
6602         safe_buffer_increment(pStubMsg, sizeof(ULONG));
6603         ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(ULONG));
6604         pStubMsg->MemorySize += sizeof(ULONG);
6605         return sizeof(ULONG);
6606     case RPC_FC_FLOAT:
6607         ALIGN_POINTER(pStubMsg->Buffer, sizeof(float));
6608         safe_buffer_increment(pStubMsg, sizeof(float));
6609         ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(float));
6610         pStubMsg->MemorySize += sizeof(float);
6611         return sizeof(float);
6612     case RPC_FC_DOUBLE:
6613         ALIGN_POINTER(pStubMsg->Buffer, sizeof(double));
6614         safe_buffer_increment(pStubMsg, sizeof(double));
6615         ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(double));
6616         pStubMsg->MemorySize += sizeof(double);
6617         return sizeof(double);
6618     case RPC_FC_HYPER:
6619         ALIGN_POINTER(pStubMsg->Buffer, sizeof(ULONGLONG));
6620         safe_buffer_increment(pStubMsg, sizeof(ULONGLONG));
6621         ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(ULONGLONG));
6622         pStubMsg->MemorySize += sizeof(ULONGLONG);
6623         return sizeof(ULONGLONG);
6624     case RPC_FC_ERROR_STATUS_T:
6625         ALIGN_POINTER(pStubMsg->Buffer, sizeof(error_status_t));
6626         safe_buffer_increment(pStubMsg, sizeof(error_status_t));
6627         ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(error_status_t));
6628         pStubMsg->MemorySize += sizeof(error_status_t);
6629         return sizeof(error_status_t);
6630     case RPC_FC_ENUM16:
6631         ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
6632         safe_buffer_increment(pStubMsg, sizeof(USHORT));
6633         ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(UINT));
6634         pStubMsg->MemorySize += sizeof(UINT);
6635         return sizeof(UINT);
6636     case RPC_FC_IGNORE:
6637         ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(void *));
6638         pStubMsg->MemorySize += sizeof(void *);
6639         return sizeof(void *);
6640     default:
6641         FIXME("Unhandled base type: 0x%02x\n", *pFormat);
6642        return 0;
6643     }
6644 }
6645
6646 /***********************************************************************
6647  *           NdrBaseTypeFree [internal]
6648  */
6649 static void WINAPI NdrBaseTypeFree(PMIDL_STUB_MESSAGE pStubMsg,
6650                                 unsigned char *pMemory,
6651                                 PFORMAT_STRING pFormat)
6652 {
6653    TRACE("pStubMsg %p pMemory %p type 0x%02x\n", pStubMsg, pMemory, *pFormat);
6654
6655    /* nothing to do */
6656 }
6657
6658 /***********************************************************************
6659  *           NdrContextHandleBufferSize [internal]
6660  */
6661 static void WINAPI NdrContextHandleBufferSize(
6662     PMIDL_STUB_MESSAGE pStubMsg,
6663     unsigned char *pMemory,
6664     PFORMAT_STRING pFormat)
6665 {
6666     TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
6667
6668     if (*pFormat != RPC_FC_BIND_CONTEXT)
6669     {
6670         ERR("invalid format type %x\n", *pFormat);
6671         RpcRaiseException(RPC_S_INTERNAL_ERROR);
6672     }
6673     ALIGN_LENGTH(pStubMsg->BufferLength, 4);
6674     safe_buffer_length_increment(pStubMsg, cbNDRContext);
6675 }
6676
6677 /***********************************************************************
6678  *           NdrContextHandleMarshall [internal]
6679  */
6680 static unsigned char *WINAPI NdrContextHandleMarshall(
6681     PMIDL_STUB_MESSAGE pStubMsg,
6682     unsigned char *pMemory,
6683     PFORMAT_STRING pFormat)
6684 {
6685     TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
6686
6687     if (*pFormat != RPC_FC_BIND_CONTEXT)
6688     {
6689         ERR("invalid format type %x\n", *pFormat);
6690         RpcRaiseException(RPC_S_INTERNAL_ERROR);
6691     }
6692     TRACE("flags: 0x%02x\n", pFormat[1]);
6693
6694     if (pStubMsg->IsClient)
6695     {
6696         if (pFormat[1] & HANDLE_PARAM_IS_VIA_PTR)
6697             NdrClientContextMarshall(pStubMsg, *(NDR_CCONTEXT **)pMemory, FALSE);
6698         else
6699             NdrClientContextMarshall(pStubMsg, pMemory, FALSE);
6700     }
6701     else
6702     {
6703         NDR_SCONTEXT ctxt = NDRSContextFromValue(pMemory);
6704         NDR_RUNDOWN rundown = pStubMsg->StubDesc->apfnNdrRundownRoutines[pFormat[2]];
6705         NdrServerContextNewMarshall(pStubMsg, ctxt, rundown, pFormat);
6706     }
6707
6708     return NULL;
6709 }
6710
6711 /***********************************************************************
6712  *           NdrContextHandleUnmarshall [internal]
6713  */
6714 static unsigned char *WINAPI NdrContextHandleUnmarshall(
6715     PMIDL_STUB_MESSAGE pStubMsg,
6716     unsigned char **ppMemory,
6717     PFORMAT_STRING pFormat,
6718     unsigned char fMustAlloc)
6719 {
6720     TRACE("pStubMsg %p, ppMemory %p, pFormat %p, fMustAlloc %s\n", pStubMsg,
6721         ppMemory, pFormat, fMustAlloc ? "TRUE": "FALSE");
6722
6723     if (*pFormat != RPC_FC_BIND_CONTEXT)
6724     {
6725         ERR("invalid format type %x\n", *pFormat);
6726         RpcRaiseException(RPC_S_INTERNAL_ERROR);
6727     }
6728     TRACE("flags: 0x%02x\n", pFormat[1]);
6729
6730     if (pStubMsg->IsClient)
6731     {
6732         /* [out]-only or [ret] param */
6733         if ((pFormat[1] & (HANDLE_PARAM_IS_IN|HANDLE_PARAM_IS_OUT)) == HANDLE_PARAM_IS_OUT)
6734             **(NDR_CCONTEXT **)ppMemory = NULL;
6735         NdrClientContextUnmarshall(pStubMsg, *(NDR_CCONTEXT **)ppMemory, pStubMsg->RpcMsg->Handle);
6736     }
6737     else
6738     {
6739         NDR_SCONTEXT ctxt;
6740         ctxt = NdrServerContextNewUnmarshall(pStubMsg, pFormat);
6741         if (pFormat[1] & HANDLE_PARAM_IS_VIA_PTR)
6742             *(void **)ppMemory = NDRSContextValue(ctxt);
6743         else
6744             *(void **)ppMemory = *NDRSContextValue(ctxt);
6745     }
6746
6747     return NULL;
6748 }
6749
6750 /***********************************************************************
6751  *           NdrClientContextMarshall [RPCRT4.@]
6752  */
6753 void WINAPI NdrClientContextMarshall(PMIDL_STUB_MESSAGE pStubMsg,
6754                                      NDR_CCONTEXT ContextHandle,
6755                                      int fCheck)
6756 {
6757     TRACE("(%p, %p, %d)\n", pStubMsg, ContextHandle, fCheck);
6758
6759     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
6760
6761     if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
6762     {
6763         ERR("buffer overflow - Buffer = %p, BufferEnd = %p\n",
6764             pStubMsg->Buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength);
6765         RpcRaiseException(RPC_X_BAD_STUB_DATA);
6766     }
6767
6768     /* FIXME: what does fCheck do? */
6769     NDRCContextMarshall(ContextHandle,
6770                         pStubMsg->Buffer);
6771
6772     pStubMsg->Buffer += cbNDRContext;
6773 }
6774
6775 /***********************************************************************
6776  *           NdrClientContextUnmarshall [RPCRT4.@]
6777  */
6778 void WINAPI NdrClientContextUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
6779                                        NDR_CCONTEXT * pContextHandle,
6780                                        RPC_BINDING_HANDLE BindHandle)
6781 {
6782     TRACE("(%p, %p, %p)\n", pStubMsg, pContextHandle, BindHandle);
6783
6784     ALIGN_POINTER(pStubMsg->Buffer, 4);
6785
6786     if (pStubMsg->Buffer + cbNDRContext > pStubMsg->BufferEnd)
6787         RpcRaiseException(RPC_X_BAD_STUB_DATA);
6788
6789     NDRCContextUnmarshall(pContextHandle,
6790                           BindHandle,
6791                           pStubMsg->Buffer,
6792                           pStubMsg->RpcMsg->DataRepresentation);
6793
6794     pStubMsg->Buffer += cbNDRContext;
6795 }
6796
6797 void WINAPI NdrServerContextMarshall(PMIDL_STUB_MESSAGE pStubMsg,
6798                                      NDR_SCONTEXT ContextHandle,
6799                                      NDR_RUNDOWN RundownRoutine )
6800 {
6801     TRACE("(%p, %p, %p)\n", pStubMsg, ContextHandle, RundownRoutine);
6802
6803     ALIGN_POINTER(pStubMsg->Buffer, 4);
6804
6805     if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
6806     {
6807         ERR("buffer overflow - Buffer = %p, BufferEnd = %p\n",
6808             pStubMsg->Buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength);
6809         RpcRaiseException(RPC_X_BAD_STUB_DATA);
6810     }
6811
6812     NDRSContextMarshall2(pStubMsg->RpcMsg->Handle, ContextHandle,
6813                          pStubMsg->Buffer, RundownRoutine, NULL,
6814                          RPC_CONTEXT_HANDLE_DEFAULT_FLAGS);
6815     pStubMsg->Buffer += cbNDRContext;
6816 }
6817
6818 NDR_SCONTEXT WINAPI NdrServerContextUnmarshall(PMIDL_STUB_MESSAGE pStubMsg)
6819 {
6820     NDR_SCONTEXT ContextHandle;
6821
6822     TRACE("(%p)\n", pStubMsg);
6823
6824     ALIGN_POINTER(pStubMsg->Buffer, 4);
6825
6826     if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
6827     {
6828         ERR("buffer overflow - Buffer = %p, BufferEnd = %p\n",
6829             pStubMsg->Buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength);
6830         RpcRaiseException(RPC_X_BAD_STUB_DATA);
6831     }
6832
6833     ContextHandle = NDRSContextUnmarshall2(pStubMsg->RpcMsg->Handle,
6834                                            pStubMsg->Buffer,
6835                                            pStubMsg->RpcMsg->DataRepresentation,
6836                                            NULL, RPC_CONTEXT_HANDLE_DEFAULT_FLAGS);
6837     pStubMsg->Buffer += cbNDRContext;
6838
6839     return ContextHandle;
6840 }
6841
6842 void WINAPI NdrContextHandleSize(PMIDL_STUB_MESSAGE pStubMsg,
6843                                  unsigned char* pMemory,
6844                                  PFORMAT_STRING pFormat)
6845 {
6846     FIXME("(%p, %p, %p): stub\n", pStubMsg, pMemory, pFormat);
6847 }
6848
6849 NDR_SCONTEXT WINAPI NdrContextHandleInitialize(PMIDL_STUB_MESSAGE pStubMsg,
6850                                                PFORMAT_STRING pFormat)
6851 {
6852     RPC_SYNTAX_IDENTIFIER *if_id = NULL;
6853     ULONG flags = RPC_CONTEXT_HANDLE_DEFAULT_FLAGS;
6854
6855     TRACE("(%p, %p)\n", pStubMsg, pFormat);
6856
6857     if (pFormat[1] & NDR_CONTEXT_HANDLE_SERIALIZE)
6858         flags |= RPC_CONTEXT_HANDLE_SERIALIZE;
6859     if (pFormat[1] & NDR_CONTEXT_HANDLE_NO_SERIALIZE)
6860         flags |= RPC_CONTEXT_HANDLE_DONT_SERIALIZE;
6861     if (pFormat[1] & NDR_STRICT_CONTEXT_HANDLE)
6862     {
6863         RPC_SERVER_INTERFACE *sif = pStubMsg->StubDesc->RpcInterfaceInformation;
6864         if_id = &sif->InterfaceId;
6865     }
6866
6867     return NDRSContextUnmarshall2(pStubMsg->RpcMsg->Handle, NULL,
6868                                   pStubMsg->RpcMsg->DataRepresentation, if_id,
6869                                   flags);
6870 }
6871
6872 void WINAPI NdrServerContextNewMarshall(PMIDL_STUB_MESSAGE pStubMsg,
6873                                         NDR_SCONTEXT ContextHandle,
6874                                         NDR_RUNDOWN RundownRoutine,
6875                                         PFORMAT_STRING pFormat)
6876 {
6877     RPC_SYNTAX_IDENTIFIER *if_id = NULL;
6878     ULONG flags = RPC_CONTEXT_HANDLE_DEFAULT_FLAGS;
6879
6880     TRACE("(%p, %p, %p, %p)\n", pStubMsg, ContextHandle, RundownRoutine, pFormat);
6881
6882     ALIGN_POINTER(pStubMsg->Buffer, 4);
6883
6884     if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
6885     {
6886         ERR("buffer overflow - Buffer = %p, BufferEnd = %p\n",
6887             pStubMsg->Buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength);
6888         RpcRaiseException(RPC_X_BAD_STUB_DATA);
6889     }
6890
6891     if (pFormat[1] & NDR_CONTEXT_HANDLE_SERIALIZE)
6892         flags |= RPC_CONTEXT_HANDLE_SERIALIZE;
6893     if (pFormat[1] & NDR_CONTEXT_HANDLE_NO_SERIALIZE)
6894         flags |= RPC_CONTEXT_HANDLE_DONT_SERIALIZE;
6895     if (pFormat[1] & NDR_STRICT_CONTEXT_HANDLE)
6896     {
6897         RPC_SERVER_INTERFACE *sif = pStubMsg->StubDesc->RpcInterfaceInformation;
6898         if_id = &sif->InterfaceId;
6899     }
6900
6901     NDRSContextMarshall2(pStubMsg->RpcMsg->Handle, ContextHandle,
6902                           pStubMsg->Buffer, RundownRoutine, if_id, flags);
6903     pStubMsg->Buffer += cbNDRContext;
6904 }
6905
6906 NDR_SCONTEXT WINAPI NdrServerContextNewUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
6907                                                   PFORMAT_STRING pFormat)
6908 {
6909     NDR_SCONTEXT ContextHandle;
6910     RPC_SYNTAX_IDENTIFIER *if_id = NULL;
6911     ULONG flags = RPC_CONTEXT_HANDLE_DEFAULT_FLAGS;
6912
6913     TRACE("(%p, %p)\n", pStubMsg, pFormat);
6914
6915     ALIGN_POINTER(pStubMsg->Buffer, 4);
6916
6917     if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
6918     {
6919         ERR("buffer overflow - Buffer = %p, BufferEnd = %p\n",
6920             pStubMsg->Buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength);
6921         RpcRaiseException(RPC_X_BAD_STUB_DATA);
6922     }
6923
6924     if (pFormat[1] & NDR_CONTEXT_HANDLE_SERIALIZE)
6925         flags |= RPC_CONTEXT_HANDLE_SERIALIZE;
6926     if (pFormat[1] & NDR_CONTEXT_HANDLE_NO_SERIALIZE)
6927         flags |= RPC_CONTEXT_HANDLE_DONT_SERIALIZE;
6928     if (pFormat[1] & NDR_STRICT_CONTEXT_HANDLE)
6929     {
6930         RPC_SERVER_INTERFACE *sif = pStubMsg->StubDesc->RpcInterfaceInformation;
6931         if_id = &sif->InterfaceId;
6932     }
6933
6934     ContextHandle = NDRSContextUnmarshall2(pStubMsg->RpcMsg->Handle,
6935                                            pStubMsg->Buffer,
6936                                            pStubMsg->RpcMsg->DataRepresentation,
6937                                            if_id, flags);
6938     pStubMsg->Buffer += cbNDRContext;
6939
6940     return ContextHandle;
6941 }
6942
6943 /***********************************************************************
6944  *           NdrCorrelationInitialize [RPCRT4.@]
6945  *
6946  * Initializes correlation validity checking.
6947  *
6948  * PARAMS
6949  *  pStubMsg    [I] MIDL_STUB_MESSAGE used during unmarshalling.
6950  *  pMemory     [I] Pointer to memory to use as a cache.
6951  *  CacheSize   [I] Size of the memory pointed to by pMemory.
6952  *  Flags       [I] Reserved. Set to zero.
6953  *
6954  * RETURNS
6955  *  Nothing.
6956  */
6957 void WINAPI NdrCorrelationInitialize(PMIDL_STUB_MESSAGE pStubMsg, void *pMemory, ULONG CacheSize, ULONG Flags)
6958 {
6959     FIXME("(%p, %p, %d, 0x%x): stub\n", pStubMsg, pMemory, CacheSize, Flags);
6960     pStubMsg->fHasNewCorrDesc = TRUE;
6961 }
6962
6963 /***********************************************************************
6964  *           NdrCorrelationPass [RPCRT4.@]
6965  *
6966  * Performs correlation validity checking.
6967  *
6968  * PARAMS
6969  *  pStubMsg    [I] MIDL_STUB_MESSAGE used during unmarshalling.
6970  *
6971  * RETURNS
6972  *  Nothing.
6973  */
6974 void WINAPI NdrCorrelationPass(PMIDL_STUB_MESSAGE pStubMsg)
6975 {
6976     FIXME("(%p): stub\n", pStubMsg);
6977 }
6978
6979 /***********************************************************************
6980  *           NdrCorrelationFree [RPCRT4.@]
6981  *
6982  * Frees any resources used while unmarshalling parameters that need
6983  * correlation validity checking.
6984  *
6985  * PARAMS
6986  *  pStubMsg    [I] MIDL_STUB_MESSAGE used during unmarshalling.
6987  *
6988  * RETURNS
6989  *  Nothing.
6990  */
6991 void WINAPI NdrCorrelationFree(PMIDL_STUB_MESSAGE pStubMsg)
6992 {
6993     FIXME("(%p): stub\n", pStubMsg);
6994 }