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