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