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

   1 /*
   2  * NDR data marshalling
   3  *
   4  * Copyright 2002 Greg Turner
   5  * Copyright 2003-2006 CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  * TODO:
  22  *  - String structs
  23  *  - Byte count pointers
  24  *  - transmit_as/represent as
  25  *  - Multi-dimensional arrays
  26  *  - Conversion functions (NdrConvert)
  27  *  - Checks for integer addition overflow in user marshall functions
  28  */
  29
  30 #include <stdarg.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <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   /* Increment 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  * Unmarshall a base type.
2008  *
2009  * NOTES
2010  *  Doesn't check that the buffer is long enough before copying, so the caller
2011  * should do this.
2012  */
2013 void WINAPI NdrSimpleTypeUnmarshall( PMIDL_STUB_MESSAGE pStubMsg, unsigned char* pMemory,
2014                                      unsigned char FormatChar )
2015 {
2016 #define BASE_TYPE_UNMARSHALL(type) \
2017         ALIGN_POINTER(pStubMsg->Buffer, sizeof(type)); \
2018         TRACE("pMemory: %p\n", pMemory); \
2019         *(type *)pMemory = *(type *)pStubMsg->Buffer; \
2020         pStubMsg->Buffer += sizeof(type);
2021
2022     switch(FormatChar)
2023     {
2024     case RPC_FC_BYTE:
2025     case RPC_FC_CHAR:
2026     case RPC_FC_SMALL:
2027     case RPC_FC_USMALL:
2028         BASE_TYPE_UNMARSHALL(UCHAR);
2029         TRACE("value: 0x%02x\n", *pMemory);
2030         break;
2031     case RPC_FC_WCHAR:
2032     case RPC_FC_SHORT:
2033     case RPC_FC_USHORT:
2034         BASE_TYPE_UNMARSHALL(USHORT);
2035         TRACE("value: 0x%04x\n", *(USHORT *)pMemory);
2036         break;
2037     case RPC_FC_LONG:
2038     case RPC_FC_ULONG:
2039     case RPC_FC_ERROR_STATUS_T:
2040     case RPC_FC_ENUM32:
2041         BASE_TYPE_UNMARSHALL(ULONG);
2042         TRACE("value: 0x%08x\n", *(ULONG *)pMemory);
2043         break;
2044    case RPC_FC_FLOAT:
2045         BASE_TYPE_UNMARSHALL(float);
2046         TRACE("value: %f\n", *(float *)pMemory);
2047         break;
2048     case RPC_FC_DOUBLE:
2049         BASE_TYPE_UNMARSHALL(double);
2050         TRACE("value: %f\n", *(double *)pMemory);
2051         break;
2052     case RPC_FC_HYPER:
2053         BASE_TYPE_UNMARSHALL(ULONGLONG);
2054         TRACE("value: %s\n", wine_dbgstr_longlong(*(ULONGLONG *)pMemory));
2055         break;
2056     case RPC_FC_ENUM16:
2057         ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
2058         TRACE("pMemory: %p\n", pMemory);
2059         /* 16-bits on the wire, but int in memory */
2060         *(UINT *)pMemory = *(USHORT *)pStubMsg->Buffer;
2061         pStubMsg->Buffer += sizeof(USHORT);
2062         TRACE("value: 0x%08x\n", *(UINT *)pMemory);
2063         break;
2064     case RPC_FC_IGNORE:
2065         break;
2066     default:
2067         FIXME("Unhandled base type: 0x%02x\n", FormatChar);
2068     }
2069 #undef BASE_TYPE_UNMARSHALL
2070 }
2071
2072 /***********************************************************************
2073  *           NdrSimpleStructMarshall [RPCRT4.@]
2074  */
2075 unsigned char * WINAPI NdrSimpleStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2076                                                unsigned char *pMemory,
2077                                                PFORMAT_STRING pFormat)
2078 {
2079   unsigned size = *(const WORD*)(pFormat+2);
2080   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2081
2082   ALIGN_POINTER_CLEAR(pStubMsg->Buffer, pFormat[1] + 1);
2083
2084   pStubMsg->BufferMark = pStubMsg->Buffer;
2085   safe_copy_to_buffer(pStubMsg, pMemory, size);
2086
2087   if (pFormat[0] != RPC_FC_STRUCT)
2088     EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat+4);
2089
2090   return NULL;
2091 }
2092
2093 /***********************************************************************
2094  *           NdrSimpleStructUnmarshall [RPCRT4.@]
2095  */
2096 unsigned char * WINAPI NdrSimpleStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2097                                                  unsigned char **ppMemory,
2098                                                  PFORMAT_STRING pFormat,
2099                                                  unsigned char fMustAlloc)
2100 {
2101   unsigned size = *(const WORD*)(pFormat+2);
2102   unsigned char *saved_buffer;
2103   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
2104
2105   ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
2106
2107   if (fMustAlloc)
2108     *ppMemory = NdrAllocate(pStubMsg, size);
2109   else
2110   {
2111     if (!pStubMsg->IsClient && !*ppMemory)
2112       /* for servers, we just point straight into the RPC buffer */
2113       *ppMemory = pStubMsg->Buffer;
2114   }
2115
2116   saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer;
2117   safe_buffer_increment(pStubMsg, size);
2118   if (pFormat[0] == RPC_FC_PSTRUCT)
2119       EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat+4, fMustAlloc);
2120
2121   TRACE("copying %p to %p\n", saved_buffer, *ppMemory);
2122   if (*ppMemory != saved_buffer)
2123       memcpy(*ppMemory, saved_buffer, size);
2124
2125   return NULL;
2126 }
2127
2128 /***********************************************************************
2129  *           NdrSimpleStructBufferSize [RPCRT4.@]
2130  */
2131 void WINAPI NdrSimpleStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2132                                       unsigned char *pMemory,
2133                                       PFORMAT_STRING pFormat)
2134 {
2135   unsigned size = *(const WORD*)(pFormat+2);
2136   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2137
2138   ALIGN_LENGTH(pStubMsg->BufferLength, pFormat[1] + 1);
2139
2140   safe_buffer_length_increment(pStubMsg, size);
2141   if (pFormat[0] != RPC_FC_STRUCT)
2142     EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat+4);
2143 }
2144
2145 /***********************************************************************
2146  *           NdrSimpleStructMemorySize [RPCRT4.@]
2147  */
2148 ULONG WINAPI NdrSimpleStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2149                                        PFORMAT_STRING pFormat)
2150 {
2151   unsigned short size = *(const WORD *)(pFormat+2);
2152
2153   TRACE("(%p,%p)\n", pStubMsg, pFormat);
2154
2155   ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
2156   pStubMsg->MemorySize += size;
2157   safe_buffer_increment(pStubMsg, size);
2158
2159   if (pFormat[0] != RPC_FC_STRUCT)
2160     EmbeddedPointerMemorySize(pStubMsg, pFormat+4);
2161   return pStubMsg->MemorySize;
2162 }
2163
2164 /***********************************************************************
2165  *           NdrSimpleStructFree [RPCRT4.@]
2166  */
2167 void WINAPI NdrSimpleStructFree(PMIDL_STUB_MESSAGE pStubMsg,
2168                                 unsigned char *pMemory,
2169                                 PFORMAT_STRING pFormat)
2170 {
2171   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2172   if (pFormat[0] != RPC_FC_STRUCT)
2173     EmbeddedPointerFree(pStubMsg, pMemory, pFormat+4);
2174 }
2175
2176
2177 static unsigned long EmbeddedComplexSize(const MIDL_STUB_MESSAGE *pStubMsg,
2178                                          PFORMAT_STRING pFormat)
2179 {
2180   switch (*pFormat) {
2181   case RPC_FC_STRUCT:
2182   case RPC_FC_PSTRUCT:
2183   case RPC_FC_CSTRUCT:
2184   case RPC_FC_BOGUS_STRUCT:
2185   case RPC_FC_SMFARRAY:
2186   case RPC_FC_SMVARRAY:
2187   case RPC_FC_CSTRING:
2188     return *(const WORD*)&pFormat[2];
2189   case RPC_FC_USER_MARSHAL:
2190     return *(const WORD*)&pFormat[4];
2191   case RPC_FC_NON_ENCAPSULATED_UNION:
2192     pFormat += 2;
2193     if (pStubMsg->fHasNewCorrDesc)
2194         pFormat += 6;
2195     else
2196         pFormat += 4;
2197
2198     pFormat += *(const SHORT*)pFormat;
2199     return *(const SHORT*)pFormat;
2200   case RPC_FC_IP:
2201     return sizeof(void *);
2202   case RPC_FC_WSTRING:
2203     return *(const WORD*)&pFormat[2] * 2;
2204   default:
2205     FIXME("unhandled embedded type %02x\n", *pFormat);
2206   }
2207   return 0;
2208 }
2209
2210
2211 static unsigned long EmbeddedComplexMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2212                                                PFORMAT_STRING pFormat)
2213 {
2214   NDR_MEMORYSIZE m = NdrMemorySizer[*pFormat & NDR_TABLE_MASK];
2215
2216   if (!m)
2217   {
2218     FIXME("no memorysizer for data type=%02x\n", *pFormat);
2219     return 0;
2220   }
2221
2222   return m(pStubMsg, pFormat);
2223 }
2224
2225
2226 static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2227                                        unsigned char *pMemory,
2228                                        PFORMAT_STRING pFormat,
2229                                        PFORMAT_STRING pPointer)
2230 {
2231   PFORMAT_STRING desc;
2232   NDR_MARSHALL m;
2233   unsigned long size;
2234
2235   while (*pFormat != RPC_FC_END) {
2236     switch (*pFormat) {
2237     case RPC_FC_BYTE:
2238     case RPC_FC_CHAR:
2239     case RPC_FC_SMALL:
2240     case RPC_FC_USMALL:
2241       TRACE("byte=%d <= %p\n", *(WORD*)pMemory, pMemory);
2242       safe_copy_to_buffer(pStubMsg, pMemory, 1);
2243       pMemory += 1;
2244       break;
2245     case RPC_FC_WCHAR:
2246     case RPC_FC_SHORT:
2247     case RPC_FC_USHORT:
2248       TRACE("short=%d <= %p\n", *(WORD*)pMemory, pMemory);
2249       safe_copy_to_buffer(pStubMsg, pMemory, 2);
2250       pMemory += 2;
2251       break;
2252     case RPC_FC_ENUM16:
2253       TRACE("enum16=%d <= %p\n", *(DWORD*)pMemory, pMemory);
2254       if (32767 < *(DWORD*)pMemory)
2255         RpcRaiseException(RPC_X_ENUM_VALUE_OUT_OF_RANGE);
2256       safe_copy_to_buffer(pStubMsg, pMemory, 2);
2257       pMemory += 4;
2258       break;
2259     case RPC_FC_LONG:
2260     case RPC_FC_ULONG:
2261     case RPC_FC_ENUM32:
2262       TRACE("long=%d <= %p\n", *(DWORD*)pMemory, pMemory);
2263       safe_copy_to_buffer(pStubMsg, pMemory, 4);
2264       pMemory += 4;
2265       break;
2266     case RPC_FC_HYPER:
2267       TRACE("longlong=%s <= %p\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory), pMemory);
2268       safe_copy_to_buffer(pStubMsg, pMemory, 8);
2269       pMemory += 8;
2270       break;
2271     case RPC_FC_POINTER:
2272     {
2273       unsigned char *saved_buffer;
2274       int pointer_buffer_mark_set = 0;
2275       TRACE("pointer=%p <= %p\n", *(unsigned char**)pMemory, pMemory);
2276       ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
2277       saved_buffer = pStubMsg->Buffer;
2278       if (pStubMsg->PointerBufferMark)
2279       {
2280         pStubMsg->Buffer = pStubMsg->PointerBufferMark;
2281         pStubMsg->PointerBufferMark = NULL;
2282         pointer_buffer_mark_set = 1;
2283       }
2284       else
2285         safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
2286       PointerMarshall(pStubMsg, saved_buffer, *(unsigned char**)pMemory, pPointer);
2287       if (pointer_buffer_mark_set)
2288       {
2289         STD_OVERFLOW_CHECK(pStubMsg);
2290         pStubMsg->PointerBufferMark = pStubMsg->Buffer;
2291         if (saved_buffer + 4 > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
2292         {
2293             ERR("buffer overflow - saved_buffer = %p, BufferEnd = %p\n",
2294                 saved_buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength);
2295             RpcRaiseException(RPC_X_BAD_STUB_DATA);
2296         }
2297         pStubMsg->Buffer = saved_buffer + 4;
2298       }
2299       pPointer += 4;
2300       pMemory += 4;
2301       break;
2302     }
2303     case RPC_FC_ALIGNM4:
2304       ALIGN_POINTER(pMemory, 4);
2305       break;
2306     case RPC_FC_ALIGNM8:
2307       ALIGN_POINTER(pMemory, 8);
2308       break;
2309     case RPC_FC_STRUCTPAD1:
2310     case RPC_FC_STRUCTPAD2:
2311     case RPC_FC_STRUCTPAD3:
2312     case RPC_FC_STRUCTPAD4:
2313     case RPC_FC_STRUCTPAD5:
2314     case RPC_FC_STRUCTPAD6:
2315     case RPC_FC_STRUCTPAD7:
2316       pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
2317       break;
2318     case RPC_FC_EMBEDDED_COMPLEX:
2319       pMemory += pFormat[1];
2320       pFormat += 2;
2321       desc = pFormat + *(const SHORT*)pFormat;
2322       size = EmbeddedComplexSize(pStubMsg, desc);
2323       TRACE("embedded complex (size=%ld) <= %p\n", size, pMemory);
2324       m = NdrMarshaller[*desc & NDR_TABLE_MASK];
2325       if (m)
2326       {
2327         /* for some reason interface pointers aren't generated as
2328          * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet
2329          * they still need the derefencing treatment that pointers are
2330          * given */
2331         if (*desc == RPC_FC_IP)
2332           m(pStubMsg, *(unsigned char **)pMemory, desc);
2333         else
2334           m(pStubMsg, pMemory, desc);
2335       }
2336       else FIXME("no marshaller for embedded type %02x\n", *desc);
2337       pMemory += size;
2338       pFormat += 2;
2339       continue;
2340     case RPC_FC_PAD:
2341       break;
2342     default:
2343       FIXME("unhandled format 0x%02x\n", *pFormat);
2344     }
2345     pFormat++;
2346   }
2347
2348   return pMemory;
2349 }
2350
2351 static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2352                                          unsigned char *pMemory,
2353                                          PFORMAT_STRING pFormat,
2354                                          PFORMAT_STRING pPointer)
2355 {
2356   PFORMAT_STRING desc;
2357   NDR_UNMARSHALL m;
2358   unsigned long size;
2359
2360   while (*pFormat != RPC_FC_END) {
2361     switch (*pFormat) {
2362     case RPC_FC_BYTE:
2363     case RPC_FC_CHAR:
2364     case RPC_FC_SMALL:
2365     case RPC_FC_USMALL:
2366       safe_copy_from_buffer(pStubMsg, pMemory, 1);
2367       TRACE("byte=%d => %p\n", *(WORD*)pMemory, pMemory);
2368       pMemory += 1;
2369       break;
2370     case RPC_FC_WCHAR:
2371     case RPC_FC_SHORT:
2372     case RPC_FC_USHORT:
2373       safe_copy_from_buffer(pStubMsg, pMemory, 2);
2374       TRACE("short=%d => %p\n", *(WORD*)pMemory, pMemory);
2375       pMemory += 2;
2376       break;
2377     case RPC_FC_ENUM16:
2378       safe_copy_from_buffer(pStubMsg, pMemory, 2);
2379       *(DWORD*)pMemory &= 0xffff;
2380       TRACE("enum16=%d => %p\n", *(DWORD*)pMemory, pMemory);
2381       if (32767 < *(DWORD*)pMemory)
2382         RpcRaiseException(RPC_X_ENUM_VALUE_OUT_OF_RANGE);
2383       pMemory += 4;
2384       break;
2385     case RPC_FC_LONG:
2386     case RPC_FC_ULONG:
2387     case RPC_FC_ENUM32:
2388       safe_copy_from_buffer(pStubMsg, pMemory, 4);
2389       TRACE("long=%d => %p\n", *(DWORD*)pMemory, pMemory);
2390       pMemory += 4;
2391       break;
2392     case RPC_FC_HYPER:
2393       safe_copy_from_buffer(pStubMsg, pMemory, 8);
2394       TRACE("longlong=%s => %p\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory), pMemory);
2395       pMemory += 8;
2396       break;
2397     case RPC_FC_POINTER:
2398     {
2399       unsigned char *saved_buffer;
2400       int pointer_buffer_mark_set = 0;
2401       TRACE("pointer => %p\n", pMemory);
2402       ALIGN_POINTER(pStubMsg->Buffer, 4);
2403       saved_buffer = pStubMsg->Buffer;
2404       if (pStubMsg->PointerBufferMark)
2405       {
2406         pStubMsg->Buffer = pStubMsg->PointerBufferMark;
2407         pStubMsg->PointerBufferMark = NULL;
2408         pointer_buffer_mark_set = 1;
2409       }
2410       else
2411         safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
2412
2413       PointerUnmarshall(pStubMsg, saved_buffer, (unsigned char**)pMemory, *(unsigned char**)pMemory, pPointer, TRUE);
2414       if (pointer_buffer_mark_set)
2415       {
2416         STD_OVERFLOW_CHECK(pStubMsg);
2417         pStubMsg->PointerBufferMark = pStubMsg->Buffer;
2418         if (saved_buffer + 4 > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
2419         {
2420             ERR("buffer overflow - saved_buffer = %p, BufferEnd = %p\n",
2421                 saved_buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength);
2422             RpcRaiseException(RPC_X_BAD_STUB_DATA);
2423         }
2424         pStubMsg->Buffer = saved_buffer + 4;
2425       }
2426       pPointer += 4;
2427       pMemory += 4;
2428       break;
2429     }
2430     case RPC_FC_ALIGNM4:
2431       ALIGN_POINTER_CLEAR(pMemory, 4);
2432       break;
2433     case RPC_FC_ALIGNM8:
2434       ALIGN_POINTER_CLEAR(pMemory, 8);
2435       break;
2436     case RPC_FC_STRUCTPAD1:
2437     case RPC_FC_STRUCTPAD2:
2438     case RPC_FC_STRUCTPAD3:
2439     case RPC_FC_STRUCTPAD4:
2440     case RPC_FC_STRUCTPAD5:
2441     case RPC_FC_STRUCTPAD6:
2442     case RPC_FC_STRUCTPAD7:
2443       memset(pMemory, 0, *pFormat - RPC_FC_STRUCTPAD1 + 1);
2444       pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
2445       break;
2446     case RPC_FC_EMBEDDED_COMPLEX:
2447       pMemory += pFormat[1];
2448       pFormat += 2;
2449       desc = pFormat + *(const SHORT*)pFormat;
2450       size = EmbeddedComplexSize(pStubMsg, desc);
2451       TRACE("embedded complex (size=%ld) => %p\n", size, pMemory);
2452       m = NdrUnmarshaller[*desc & NDR_TABLE_MASK];
2453       memset(pMemory, 0, size); /* just in case */
2454       if (m)
2455       {
2456         /* for some reason interface pointers aren't generated as
2457          * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet
2458          * they still need the derefencing treatment that pointers are
2459          * given */
2460         if (*desc == RPC_FC_IP)
2461           m(pStubMsg, (unsigned char **)pMemory, desc, FALSE);
2462         else
2463           m(pStubMsg, &pMemory, desc, FALSE);
2464       }
2465       else FIXME("no unmarshaller for embedded type %02x\n", *desc);
2466       pMemory += size;
2467       pFormat += 2;
2468       continue;
2469     case RPC_FC_PAD:
2470       break;
2471     default:
2472       FIXME("unhandled format %d\n", *pFormat);
2473     }
2474     pFormat++;
2475   }
2476
2477   return pMemory;
2478 }
2479
2480 static unsigned char * ComplexBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2481                                          unsigned char *pMemory,
2482                                          PFORMAT_STRING pFormat,
2483                                          PFORMAT_STRING pPointer)
2484 {
2485   PFORMAT_STRING desc;
2486   NDR_BUFFERSIZE m;
2487   unsigned long size;
2488
2489   while (*pFormat != RPC_FC_END) {
2490     switch (*pFormat) {
2491     case RPC_FC_BYTE:
2492     case RPC_FC_CHAR:
2493     case RPC_FC_SMALL:
2494     case RPC_FC_USMALL:
2495       safe_buffer_length_increment(pStubMsg, 1);
2496       pMemory += 1;
2497       break;
2498     case RPC_FC_WCHAR:
2499     case RPC_FC_SHORT:
2500     case RPC_FC_USHORT:
2501       safe_buffer_length_increment(pStubMsg, 2);
2502       pMemory += 2;
2503       break;
2504     case RPC_FC_ENUM16:
2505       safe_buffer_length_increment(pStubMsg, 2);
2506       pMemory += 4;
2507       break;
2508     case RPC_FC_LONG:
2509     case RPC_FC_ULONG:
2510     case RPC_FC_ENUM32:
2511       safe_buffer_length_increment(pStubMsg, 4);
2512       pMemory += 4;
2513       break;
2514     case RPC_FC_HYPER:
2515       safe_buffer_length_increment(pStubMsg, 8);
2516       pMemory += 8;
2517       break;
2518     case RPC_FC_POINTER:
2519       if (!pStubMsg->IgnoreEmbeddedPointers)
2520       {
2521         int saved_buffer_length = pStubMsg->BufferLength;
2522         pStubMsg->BufferLength = pStubMsg->PointerLength;
2523         pStubMsg->PointerLength = 0;
2524         if(!pStubMsg->BufferLength)
2525           ERR("BufferLength == 0??\n");
2526         PointerBufferSize(pStubMsg, *(unsigned char**)pMemory, pPointer);
2527         pStubMsg->PointerLength = pStubMsg->BufferLength;
2528         pStubMsg->BufferLength = saved_buffer_length;
2529       }
2530       safe_buffer_length_increment(pStubMsg, 4);
2531       pPointer += 4;
2532       pMemory += 4;
2533       break;
2534     case RPC_FC_ALIGNM4:
2535       ALIGN_POINTER(pMemory, 4);
2536       break;
2537     case RPC_FC_ALIGNM8:
2538       ALIGN_POINTER(pMemory, 8);
2539       break;
2540     case RPC_FC_STRUCTPAD1:
2541     case RPC_FC_STRUCTPAD2:
2542     case RPC_FC_STRUCTPAD3:
2543     case RPC_FC_STRUCTPAD4:
2544     case RPC_FC_STRUCTPAD5:
2545     case RPC_FC_STRUCTPAD6:
2546     case RPC_FC_STRUCTPAD7:
2547       pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
2548       break;
2549     case RPC_FC_EMBEDDED_COMPLEX:
2550       pMemory += pFormat[1];
2551       pFormat += 2;
2552       desc = pFormat + *(const SHORT*)pFormat;
2553       size = EmbeddedComplexSize(pStubMsg, desc);
2554       m = NdrBufferSizer[*desc & NDR_TABLE_MASK];
2555       if (m)
2556       {
2557         /* for some reason interface pointers aren't generated as
2558          * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet
2559          * they still need the derefencing treatment that pointers are
2560          * given */
2561         if (*desc == RPC_FC_IP)
2562           m(pStubMsg, *(unsigned char **)pMemory, desc);
2563         else
2564           m(pStubMsg, pMemory, desc);
2565       }
2566       else FIXME("no buffersizer for embedded type %02x\n", *desc);
2567       pMemory += size;
2568       pFormat += 2;
2569       continue;
2570     case RPC_FC_PAD:
2571       break;
2572     default:
2573       FIXME("unhandled format 0x%02x\n", *pFormat);
2574     }
2575     pFormat++;
2576   }
2577
2578   return pMemory;
2579 }
2580
2581 static unsigned char * ComplexFree(PMIDL_STUB_MESSAGE pStubMsg,
2582                                    unsigned char *pMemory,
2583                                    PFORMAT_STRING pFormat,
2584                                    PFORMAT_STRING pPointer)
2585 {
2586   PFORMAT_STRING desc;
2587   NDR_FREE m;
2588   unsigned long size;
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       pMemory += 1;
2597       break;
2598     case RPC_FC_WCHAR:
2599     case RPC_FC_SHORT:
2600     case RPC_FC_USHORT:
2601       pMemory += 2;
2602       break;
2603     case RPC_FC_LONG:
2604     case RPC_FC_ULONG:
2605     case RPC_FC_ENUM16:
2606     case RPC_FC_ENUM32:
2607       pMemory += 4;
2608       break;
2609     case RPC_FC_HYPER:
2610       pMemory += 8;
2611       break;
2612     case RPC_FC_POINTER:
2613       NdrPointerFree(pStubMsg, *(unsigned char**)pMemory, pPointer);
2614       pPointer += 4;
2615       pMemory += 4;
2616       break;
2617     case RPC_FC_ALIGNM4:
2618       ALIGN_POINTER(pMemory, 4);
2619       break;
2620     case RPC_FC_ALIGNM8:
2621       ALIGN_POINTER(pMemory, 8);
2622       break;
2623     case RPC_FC_STRUCTPAD1:
2624     case RPC_FC_STRUCTPAD2:
2625     case RPC_FC_STRUCTPAD3:
2626     case RPC_FC_STRUCTPAD4:
2627     case RPC_FC_STRUCTPAD5:
2628     case RPC_FC_STRUCTPAD6:
2629     case RPC_FC_STRUCTPAD7:
2630       pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
2631       break;
2632     case RPC_FC_EMBEDDED_COMPLEX:
2633       pMemory += pFormat[1];
2634       pFormat += 2;
2635       desc = pFormat + *(const SHORT*)pFormat;
2636       size = EmbeddedComplexSize(pStubMsg, desc);
2637       m = NdrFreer[*desc & NDR_TABLE_MASK];
2638       if (m)
2639       {
2640         /* for some reason interface pointers aren't generated as
2641          * RPC_FC_POINTER, but instead as RPC_FC_EMBEDDED_COMPLEX, yet
2642          * they still need the derefencing treatment that pointers are
2643          * given */
2644         if (*desc == RPC_FC_IP)
2645           m(pStubMsg, *(unsigned char **)pMemory, desc);
2646         else
2647           m(pStubMsg, pMemory, desc);
2648       }
2649       pMemory += size;
2650       pFormat += 2;
2651       continue;
2652     case RPC_FC_PAD:
2653       break;
2654     default:
2655       FIXME("unhandled format 0x%02x\n", *pFormat);
2656     }
2657     pFormat++;
2658   }
2659
2660   return pMemory;
2661 }
2662
2663 static unsigned long ComplexStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2664                                        PFORMAT_STRING pFormat)
2665 {
2666   PFORMAT_STRING desc;
2667   unsigned long size = 0;
2668
2669   while (*pFormat != RPC_FC_END) {
2670     switch (*pFormat) {
2671     case RPC_FC_BYTE:
2672     case RPC_FC_CHAR:
2673     case RPC_FC_SMALL:
2674     case RPC_FC_USMALL:
2675       size += 1;
2676       safe_buffer_increment(pStubMsg, 1);
2677       break;
2678     case RPC_FC_WCHAR:
2679     case RPC_FC_SHORT:
2680     case RPC_FC_USHORT:
2681       size += 2;
2682       safe_buffer_increment(pStubMsg, 2);
2683       break;
2684     case RPC_FC_ENUM16:
2685       size += 4;
2686       safe_buffer_increment(pStubMsg, 2);
2687       break;
2688     case RPC_FC_LONG:
2689     case RPC_FC_ULONG:
2690     case RPC_FC_ENUM32:
2691       size += 4;
2692       safe_buffer_increment(pStubMsg, 4);
2693       break;
2694     case RPC_FC_HYPER:
2695       size += 8;
2696       safe_buffer_increment(pStubMsg, 8);
2697       break;
2698     case RPC_FC_POINTER:
2699       size += 4;
2700       safe_buffer_increment(pStubMsg, 4);
2701       if (!pStubMsg->IgnoreEmbeddedPointers)
2702         FIXME("embedded pointers\n");
2703       break;
2704     case RPC_FC_ALIGNM4:
2705       ALIGN_LENGTH(size, 4);
2706       ALIGN_POINTER(pStubMsg->Buffer, 4);
2707       break;
2708     case RPC_FC_ALIGNM8:
2709       ALIGN_LENGTH(size, 8);
2710       ALIGN_POINTER(pStubMsg->Buffer, 8);
2711       break;
2712     case RPC_FC_STRUCTPAD1:
2713     case RPC_FC_STRUCTPAD2:
2714     case RPC_FC_STRUCTPAD3:
2715     case RPC_FC_STRUCTPAD4:
2716     case RPC_FC_STRUCTPAD5:
2717     case RPC_FC_STRUCTPAD6:
2718     case RPC_FC_STRUCTPAD7:
2719       size += *pFormat - RPC_FC_STRUCTPAD1 + 1;
2720       break;
2721     case RPC_FC_EMBEDDED_COMPLEX:
2722       size += pFormat[1];
2723       pFormat += 2;
2724       desc = pFormat + *(const SHORT*)pFormat;
2725       size += EmbeddedComplexMemorySize(pStubMsg, desc);
2726       pFormat += 2;
2727       continue;
2728     case RPC_FC_PAD:
2729       break;
2730     default:
2731       FIXME("unhandled format 0x%02x\n", *pFormat);
2732     }
2733     pFormat++;
2734   }
2735
2736   return size;
2737 }
2738
2739 unsigned long ComplexStructSize(PMIDL_STUB_MESSAGE pStubMsg,
2740                                 PFORMAT_STRING pFormat)
2741 {
2742   PFORMAT_STRING desc;
2743   unsigned long size = 0;
2744
2745   while (*pFormat != RPC_FC_END) {
2746     switch (*pFormat) {
2747     case RPC_FC_BYTE:
2748     case RPC_FC_CHAR:
2749     case RPC_FC_SMALL:
2750     case RPC_FC_USMALL:
2751       size += 1;
2752       break;
2753     case RPC_FC_WCHAR:
2754     case RPC_FC_SHORT:
2755     case RPC_FC_USHORT:
2756       size += 2;
2757       break;
2758     case RPC_FC_LONG:
2759     case RPC_FC_ULONG:
2760     case RPC_FC_ENUM16:
2761     case RPC_FC_ENUM32:
2762       size += 4;
2763       break;
2764     case RPC_FC_HYPER:
2765       size += 8;
2766       break;
2767     case RPC_FC_POINTER:
2768       size += sizeof(void *);
2769       break;
2770     case RPC_FC_ALIGNM4:
2771       ALIGN_LENGTH(size, 4);
2772       break;
2773     case RPC_FC_ALIGNM8:
2774       ALIGN_LENGTH(size, 8);
2775       break;
2776     case RPC_FC_STRUCTPAD1:
2777     case RPC_FC_STRUCTPAD2:
2778     case RPC_FC_STRUCTPAD3:
2779     case RPC_FC_STRUCTPAD4:
2780     case RPC_FC_STRUCTPAD5:
2781     case RPC_FC_STRUCTPAD6:
2782     case RPC_FC_STRUCTPAD7:
2783       size += *pFormat - RPC_FC_STRUCTPAD1 + 1;
2784       break;
2785     case RPC_FC_EMBEDDED_COMPLEX:
2786       size += pFormat[1];
2787       pFormat += 2;
2788       desc = pFormat + *(const SHORT*)pFormat;
2789       size += EmbeddedComplexSize(pStubMsg, desc);
2790       pFormat += 2;
2791       continue;
2792     case RPC_FC_PAD:
2793       break;
2794     default:
2795       FIXME("unhandled format 0x%02x\n", *pFormat);
2796     }
2797     pFormat++;
2798   }
2799
2800   return size;
2801 }
2802
2803 /***********************************************************************
2804  *           NdrComplexStructMarshall [RPCRT4.@]
2805  */
2806 unsigned char * WINAPI NdrComplexStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2807                                                 unsigned char *pMemory,
2808                                                 PFORMAT_STRING pFormat)
2809 {
2810   PFORMAT_STRING conf_array = NULL;
2811   PFORMAT_STRING pointer_desc = NULL;
2812   unsigned char *OldMemory = pStubMsg->Memory;
2813   int pointer_buffer_mark_set = 0;
2814
2815   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2816
2817   if (!pStubMsg->PointerBufferMark)
2818   {
2819     int saved_ignore_embedded = pStubMsg->IgnoreEmbeddedPointers;
2820     /* save buffer length */
2821     unsigned long saved_buffer_length = pStubMsg->BufferLength;
2822
2823     /* get the buffer pointer after complex array data, but before
2824      * pointer data */
2825     pStubMsg->BufferLength = pStubMsg->Buffer - pStubMsg->BufferStart;
2826     pStubMsg->IgnoreEmbeddedPointers = 1;
2827     NdrComplexStructBufferSize(pStubMsg, pMemory, pFormat);
2828     pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded;
2829
2830     /* save it for use by embedded pointer code later */
2831     pStubMsg->PointerBufferMark = pStubMsg->BufferStart + pStubMsg->BufferLength;
2832     TRACE("difference = 0x%x\n", pStubMsg->PointerBufferMark - pStubMsg->Buffer);
2833     pointer_buffer_mark_set = 1;
2834
2835     /* restore the original buffer length */
2836     pStubMsg->BufferLength = saved_buffer_length;
2837   }
2838
2839   ALIGN_POINTER_CLEAR(pStubMsg->Buffer, pFormat[1] + 1);
2840
2841   pFormat += 4;
2842   if (*(const WORD*)pFormat) conf_array = pFormat + *(const WORD*)pFormat;
2843   pFormat += 2;
2844   if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
2845   pFormat += 2;
2846
2847   pStubMsg->Memory = pMemory;
2848
2849   ComplexMarshall(pStubMsg, pMemory, pFormat, pointer_desc);
2850
2851   if (conf_array)
2852     NdrConformantArrayMarshall(pStubMsg, pMemory, conf_array);
2853
2854   pStubMsg->Memory = OldMemory;
2855
2856   if (pointer_buffer_mark_set)
2857   {
2858     pStubMsg->Buffer = pStubMsg->PointerBufferMark;
2859     pStubMsg->PointerBufferMark = NULL;
2860   }
2861
2862   STD_OVERFLOW_CHECK(pStubMsg);
2863
2864   return NULL;
2865 }
2866
2867 /***********************************************************************
2868  *           NdrComplexStructUnmarshall [RPCRT4.@]
2869  */
2870 unsigned char * WINAPI NdrComplexStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2871                                                   unsigned char **ppMemory,
2872                                                   PFORMAT_STRING pFormat,
2873                                                   unsigned char fMustAlloc)
2874 {
2875   unsigned size = *(const WORD*)(pFormat+2);
2876   PFORMAT_STRING conf_array = NULL;
2877   PFORMAT_STRING pointer_desc = NULL;
2878   unsigned char *pMemory;
2879   int pointer_buffer_mark_set = 0;
2880
2881   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
2882
2883   if (!pStubMsg->PointerBufferMark)
2884   {
2885     int saved_ignore_embedded = pStubMsg->IgnoreEmbeddedPointers;
2886     /* save buffer pointer */
2887     unsigned char *saved_buffer = pStubMsg->Buffer;
2888
2889     /* get the buffer pointer after complex array data, but before
2890      * pointer data */
2891     pStubMsg->IgnoreEmbeddedPointers = 1;
2892     NdrComplexStructMemorySize(pStubMsg, pFormat);
2893     pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded;
2894
2895     /* save it for use by embedded pointer code later */
2896     pStubMsg->PointerBufferMark = pStubMsg->Buffer;
2897     TRACE("difference = 0x%lx\n", (unsigned long)(pStubMsg->PointerBufferMark - saved_buffer));
2898     pointer_buffer_mark_set = 1;
2899
2900     /* restore the original buffer */
2901     pStubMsg->Buffer = saved_buffer;
2902   }
2903
2904   ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
2905
2906   if (fMustAlloc || !*ppMemory)
2907   {
2908     *ppMemory = NdrAllocate(pStubMsg, size);
2909     memset(*ppMemory, 0, size);
2910   }
2911
2912   pFormat += 4;
2913   if (*(const WORD*)pFormat) conf_array = pFormat + *(const WORD*)pFormat;
2914   pFormat += 2;
2915   if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
2916   pFormat += 2;
2917
2918   pMemory = ComplexUnmarshall(pStubMsg, *ppMemory, pFormat, pointer_desc);
2919
2920   if (conf_array)
2921     NdrConformantArrayUnmarshall(pStubMsg, &pMemory, conf_array, fMustAlloc);
2922
2923   if (pointer_buffer_mark_set)
2924   {
2925     pStubMsg->Buffer = pStubMsg->PointerBufferMark;
2926     pStubMsg->PointerBufferMark = NULL;
2927   }
2928
2929   return NULL;
2930 }
2931
2932 /***********************************************************************
2933  *           NdrComplexStructBufferSize [RPCRT4.@]
2934  */
2935 void WINAPI NdrComplexStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2936                                        unsigned char *pMemory,
2937                                        PFORMAT_STRING pFormat)
2938 {
2939   PFORMAT_STRING conf_array = NULL;
2940   PFORMAT_STRING pointer_desc = NULL;
2941   unsigned char *OldMemory = pStubMsg->Memory;
2942   int pointer_length_set = 0;
2943
2944   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2945
2946   ALIGN_LENGTH(pStubMsg->BufferLength, pFormat[1] + 1);
2947
2948   if(!pStubMsg->IgnoreEmbeddedPointers && !pStubMsg->PointerLength)
2949   {
2950     int saved_ignore_embedded = pStubMsg->IgnoreEmbeddedPointers;
2951     unsigned long saved_buffer_length = pStubMsg->BufferLength;
2952
2953     /* get the buffer length after complex struct data, but before
2954      * pointer data */
2955     pStubMsg->IgnoreEmbeddedPointers = 1;
2956     NdrComplexStructBufferSize(pStubMsg, pMemory, pFormat);
2957     pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded;
2958
2959     /* save it for use by embedded pointer code later */
2960     pStubMsg->PointerLength = pStubMsg->BufferLength;
2961     pointer_length_set = 1;
2962     TRACE("difference = 0x%lx\n", pStubMsg->PointerLength - saved_buffer_length);
2963
2964     /* restore the original buffer length */
2965     pStubMsg->BufferLength = saved_buffer_length;
2966   }
2967
2968   pFormat += 4;
2969   if (*(const WORD*)pFormat) conf_array = pFormat + *(const WORD*)pFormat;
2970   pFormat += 2;
2971   if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
2972   pFormat += 2;
2973
2974   pStubMsg->Memory = pMemory;
2975
2976   pMemory = ComplexBufferSize(pStubMsg, pMemory, pFormat, pointer_desc);
2977
2978   if (conf_array)
2979     NdrConformantArrayBufferSize(pStubMsg, pMemory, conf_array);
2980
2981   pStubMsg->Memory = OldMemory;
2982
2983   if(pointer_length_set)
2984   {
2985     pStubMsg->BufferLength = pStubMsg->PointerLength;
2986     pStubMsg->PointerLength = 0;
2987   }
2988
2989 }
2990
2991 /***********************************************************************
2992  *           NdrComplexStructMemorySize [RPCRT4.@]
2993  */
2994 ULONG WINAPI NdrComplexStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2995                                         PFORMAT_STRING pFormat)
2996 {
2997   unsigned size = *(const WORD*)(pFormat+2);
2998   PFORMAT_STRING conf_array = NULL;
2999   PFORMAT_STRING pointer_desc = NULL;
3000
3001   TRACE("(%p,%p)\n", pStubMsg, pFormat);
3002
3003   ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
3004
3005   pFormat += 4;
3006   if (*(const WORD*)pFormat) conf_array = pFormat + *(const WORD*)pFormat;
3007   pFormat += 2;
3008   if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
3009   pFormat += 2;
3010
3011   ComplexStructMemorySize(pStubMsg, pFormat);
3012
3013   if (conf_array)
3014     NdrConformantArrayMemorySize(pStubMsg, conf_array);
3015
3016   return size;
3017 }
3018
3019 /***********************************************************************
3020  *           NdrComplexStructFree [RPCRT4.@]
3021  */
3022 void WINAPI NdrComplexStructFree(PMIDL_STUB_MESSAGE pStubMsg,
3023                                  unsigned char *pMemory,
3024                                  PFORMAT_STRING pFormat)
3025 {
3026   PFORMAT_STRING conf_array = NULL;
3027   PFORMAT_STRING pointer_desc = NULL;
3028   unsigned char *OldMemory = pStubMsg->Memory;
3029
3030   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3031
3032   pFormat += 4;
3033   if (*(const WORD*)pFormat) conf_array = pFormat + *(const WORD*)pFormat;
3034   pFormat += 2;
3035   if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
3036   pFormat += 2;
3037
3038   pStubMsg->Memory = pMemory;
3039
3040   pMemory = ComplexFree(pStubMsg, pMemory, pFormat, pointer_desc);
3041
3042   if (conf_array)
3043     NdrConformantArrayFree(pStubMsg, pMemory, conf_array);
3044
3045   pStubMsg->Memory = OldMemory;
3046 }
3047
3048 /***********************************************************************
3049  *           NdrConformantArrayMarshall [RPCRT4.@]
3050  */
3051 unsigned char * WINAPI NdrConformantArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
3052                                                   unsigned char *pMemory,
3053                                                   PFORMAT_STRING pFormat)
3054 {
3055   DWORD size = 0, esize = *(const WORD*)(pFormat+2);
3056   unsigned char alignment = pFormat[1] + 1;
3057
3058   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3059   if (pFormat[0] != RPC_FC_CARRAY) FIXME("format=%d\n", pFormat[0]);
3060
3061   pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
3062
3063   WriteConformance(pStubMsg);
3064
3065   ALIGN_POINTER_CLEAR(pStubMsg->Buffer, alignment);
3066
3067   size = safe_multiply(esize, pStubMsg->MaxCount);
3068   pStubMsg->BufferMark = pStubMsg->Buffer;
3069   safe_copy_to_buffer(pStubMsg, pMemory, size);
3070
3071   EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
3072
3073   return NULL;
3074 }
3075
3076 /***********************************************************************
3077  *           NdrConformantArrayUnmarshall [RPCRT4.@]
3078  */
3079 unsigned char * WINAPI NdrConformantArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
3080                                                     unsigned char **ppMemory,
3081                                                     PFORMAT_STRING pFormat,
3082                                                     unsigned char fMustAlloc)
3083 {
3084   DWORD size, esize = *(const WORD*)(pFormat+2);
3085   unsigned char alignment = pFormat[1] + 1;
3086   unsigned char *saved_buffer;
3087
3088   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
3089   if (pFormat[0] != RPC_FC_CARRAY) FIXME("format=%d\n", pFormat[0]);
3090
3091   pFormat = ReadConformance(pStubMsg, pFormat+4);
3092
3093   size = safe_multiply(esize, pStubMsg->MaxCount);
3094   ALIGN_POINTER(pStubMsg->Buffer, alignment);
3095
3096   if (fMustAlloc)
3097     *ppMemory = NdrAllocate(pStubMsg, size);
3098   else
3099   {
3100     if (!pStubMsg->IsClient && !*ppMemory)
3101       /* for servers, we just point straight into the RPC buffer */
3102       *ppMemory = pStubMsg->Buffer;
3103   }
3104
3105   saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer;
3106   safe_buffer_increment(pStubMsg, size);
3107   EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat, fMustAlloc);
3108
3109   TRACE("copying %p to %p\n", saved_buffer, *ppMemory);
3110   if (*ppMemory != saved_buffer)
3111       memcpy(*ppMemory, saved_buffer, size);
3112
3113   return NULL;
3114 }
3115
3116 /***********************************************************************
3117  *           NdrConformantArrayBufferSize [RPCRT4.@]
3118  */
3119 void WINAPI NdrConformantArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
3120                                          unsigned char *pMemory,
3121                                          PFORMAT_STRING pFormat)
3122 {
3123   DWORD size, esize = *(const WORD*)(pFormat+2);
3124   unsigned char alignment = pFormat[1] + 1;
3125
3126   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3127   if (pFormat[0] != RPC_FC_CARRAY) FIXME("format=%d\n", pFormat[0]);
3128
3129   pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
3130
3131   SizeConformance(pStubMsg);
3132
3133   ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
3134
3135   size = safe_multiply(esize, pStubMsg->MaxCount);
3136   /* conformance value plus array */
3137   safe_buffer_length_increment(pStubMsg, size);
3138
3139   EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
3140 }
3141
3142 /***********************************************************************
3143  *           NdrConformantArrayMemorySize [RPCRT4.@]
3144  */
3145 ULONG WINAPI NdrConformantArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
3146                                           PFORMAT_STRING pFormat)
3147 {
3148   DWORD size = 0, esize = *(const WORD*)(pFormat+2);
3149   unsigned char alignment = pFormat[1] + 1;
3150
3151   TRACE("(%p,%p)\n", pStubMsg, pFormat);
3152   if (pFormat[0] != RPC_FC_CARRAY) FIXME("format=%d\n", pFormat[0]);
3153
3154   pFormat = ReadConformance(pStubMsg, pFormat+4);
3155   size = safe_multiply(esize, pStubMsg->MaxCount);
3156   pStubMsg->MemorySize += size;
3157
3158   ALIGN_POINTER(pStubMsg->Buffer, alignment);
3159   pStubMsg->BufferMark = pStubMsg->Buffer;
3160   safe_buffer_increment(pStubMsg, size);
3161
3162   EmbeddedPointerMemorySize(pStubMsg, pFormat);
3163
3164   return pStubMsg->MemorySize;
3165 }
3166
3167 /***********************************************************************
3168  *           NdrConformantArrayFree [RPCRT4.@]
3169  */
3170 void WINAPI NdrConformantArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
3171                                    unsigned char *pMemory,
3172                                    PFORMAT_STRING pFormat)
3173 {
3174   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3175   if (pFormat[0] != RPC_FC_CARRAY) FIXME("format=%d\n", pFormat[0]);
3176
3177   pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
3178
3179   EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
3180 }
3181
3182
3183 /***********************************************************************
3184  *           NdrConformantVaryingArrayMarshall  [RPCRT4.@]
3185  */
3186 unsigned char* WINAPI NdrConformantVaryingArrayMarshall( PMIDL_STUB_MESSAGE pStubMsg,
3187                                                          unsigned char* pMemory,
3188                                                          PFORMAT_STRING pFormat )
3189 {
3190     ULONG bufsize;
3191     unsigned char alignment = pFormat[1] + 1;
3192     DWORD esize = *(const WORD*)(pFormat+2);
3193
3194     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
3195
3196     if (pFormat[0] != RPC_FC_CVARRAY)
3197     {
3198         ERR("invalid format type %x\n", pFormat[0]);
3199         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3200         return NULL;
3201     }
3202
3203     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
3204     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
3205
3206     WriteConformance(pStubMsg);
3207     WriteVariance(pStubMsg);
3208
3209     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, alignment);
3210
3211     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
3212
3213     pStubMsg->BufferMark = pStubMsg->Buffer;
3214     safe_copy_to_buffer(pStubMsg, pMemory + pStubMsg->Offset, bufsize);
3215
3216     EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
3217
3218     return NULL;
3219 }
3220
3221
3222 /***********************************************************************
3223  *           NdrConformantVaryingArrayUnmarshall  [RPCRT4.@]
3224  */
3225 unsigned char* WINAPI NdrConformantVaryingArrayUnmarshall( PMIDL_STUB_MESSAGE pStubMsg,
3226                                                            unsigned char** ppMemory,
3227                                                            PFORMAT_STRING pFormat,
3228                                                            unsigned char fMustAlloc )
3229 {
3230     ULONG bufsize, memsize;
3231     unsigned char alignment = pFormat[1] + 1;
3232     DWORD esize = *(const WORD*)(pFormat+2);
3233     unsigned char *saved_buffer;
3234     ULONG offset;
3235
3236     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
3237
3238     if (pFormat[0] != RPC_FC_CVARRAY)
3239     {
3240         ERR("invalid format type %x\n", pFormat[0]);
3241         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3242         return NULL;
3243     }
3244
3245     pFormat = ReadConformance(pStubMsg, pFormat+4);
3246     pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
3247
3248     ALIGN_POINTER(pStubMsg->Buffer, alignment);
3249
3250     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
3251     memsize = safe_multiply(esize, pStubMsg->MaxCount);
3252     offset = pStubMsg->Offset;
3253
3254     if (!*ppMemory || fMustAlloc)
3255         *ppMemory = NdrAllocate(pStubMsg, memsize);
3256     saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer;
3257     safe_buffer_increment(pStubMsg, bufsize);
3258
3259     EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat, fMustAlloc);
3260
3261     memcpy(*ppMemory + offset, saved_buffer, bufsize);
3262
3263     return NULL;
3264 }
3265
3266
3267 /***********************************************************************
3268  *           NdrConformantVaryingArrayFree  [RPCRT4.@]
3269  */
3270 void WINAPI NdrConformantVaryingArrayFree( PMIDL_STUB_MESSAGE pStubMsg,
3271                                            unsigned char* pMemory,
3272                                            PFORMAT_STRING pFormat )
3273 {
3274     TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3275
3276     if (pFormat[0] != RPC_FC_CVARRAY)
3277     {
3278         ERR("invalid format type %x\n", pFormat[0]);
3279         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3280         return;
3281     }
3282
3283     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
3284     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
3285
3286     EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
3287 }
3288
3289
3290 /***********************************************************************
3291  *           NdrConformantVaryingArrayBufferSize  [RPCRT4.@]
3292  */
3293 void WINAPI NdrConformantVaryingArrayBufferSize( PMIDL_STUB_MESSAGE pStubMsg,
3294                                                  unsigned char* pMemory, PFORMAT_STRING pFormat )
3295 {
3296     unsigned char alignment = pFormat[1] + 1;
3297     DWORD esize = *(const WORD*)(pFormat+2);
3298
3299     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
3300
3301     if (pFormat[0] != RPC_FC_CVARRAY)
3302     {
3303         ERR("invalid format type %x\n", pFormat[0]);
3304         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3305         return;
3306     }
3307
3308     /* compute size */
3309     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
3310     /* compute length */
3311     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
3312
3313     SizeConformance(pStubMsg);
3314     SizeVariance(pStubMsg);
3315
3316     ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
3317
3318     safe_buffer_length_increment(pStubMsg, safe_multiply(esize, pStubMsg->ActualCount));
3319
3320     EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
3321 }
3322
3323
3324 /***********************************************************************
3325  *           NdrConformantVaryingArrayMemorySize  [RPCRT4.@]
3326  */
3327 ULONG WINAPI NdrConformantVaryingArrayMemorySize( PMIDL_STUB_MESSAGE pStubMsg,
3328                                                   PFORMAT_STRING pFormat )
3329 {
3330     ULONG bufsize, memsize;
3331     unsigned char alignment = pFormat[1] + 1;
3332     DWORD esize = *(const WORD*)(pFormat+2);
3333
3334     TRACE("(%p, %p)\n", pStubMsg, pFormat);
3335
3336     if (pFormat[0] != RPC_FC_CVARRAY)
3337     {
3338         ERR("invalid format type %x\n", pFormat[0]);
3339         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3340         return pStubMsg->MemorySize;
3341     }
3342
3343     pFormat = ReadConformance(pStubMsg, pFormat+4);
3344     pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
3345
3346     ALIGN_POINTER(pStubMsg->Buffer, alignment);
3347
3348     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
3349     memsize = safe_multiply(esize, pStubMsg->MaxCount);
3350
3351     safe_buffer_increment(pStubMsg, bufsize);
3352     pStubMsg->MemorySize += memsize;
3353
3354     EmbeddedPointerMemorySize(pStubMsg, pFormat);
3355
3356     return pStubMsg->MemorySize;
3357 }
3358
3359
3360 /***********************************************************************
3361  *           NdrComplexArrayMarshall [RPCRT4.@]
3362  */
3363 unsigned char * WINAPI NdrComplexArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
3364                                                unsigned char *pMemory,
3365                                                PFORMAT_STRING pFormat)
3366 {
3367   ULONG i, count, def;
3368   BOOL variance_present;
3369   unsigned char alignment;
3370   int pointer_buffer_mark_set = 0;
3371
3372   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3373
3374   if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
3375   {
3376       ERR("invalid format type %x\n", pFormat[0]);
3377       RpcRaiseException(RPC_S_INTERNAL_ERROR);
3378       return NULL;
3379   }
3380
3381   alignment = pFormat[1] + 1;
3382
3383   if (!pStubMsg->PointerBufferMark)
3384   {
3385     /* save buffer fields that may be changed by buffer sizer functions
3386      * and that may be needed later on */
3387     int saved_ignore_embedded = pStubMsg->IgnoreEmbeddedPointers;
3388     unsigned long saved_buffer_length = pStubMsg->BufferLength;
3389     unsigned long saved_max_count = pStubMsg->MaxCount;
3390     unsigned long saved_offset = pStubMsg->Offset;
3391     unsigned long saved_actual_count = pStubMsg->ActualCount;
3392
3393     /* get the buffer pointer after complex array data, but before
3394      * pointer data */
3395     pStubMsg->BufferLength = pStubMsg->Buffer - pStubMsg->BufferStart;
3396     pStubMsg->IgnoreEmbeddedPointers = 1;
3397     NdrComplexArrayBufferSize(pStubMsg, pMemory, pFormat);
3398     pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded;
3399
3400     /* save it for use by embedded pointer code later */
3401     pStubMsg->PointerBufferMark = pStubMsg->BufferStart + pStubMsg->BufferLength;
3402     TRACE("difference = 0x%x\n", pStubMsg->Buffer - pStubMsg->BufferStart);
3403     pointer_buffer_mark_set = 1;
3404
3405     /* restore fields */
3406     pStubMsg->ActualCount = saved_actual_count;
3407     pStubMsg->Offset = saved_offset;
3408     pStubMsg->MaxCount = saved_max_count;
3409     pStubMsg->BufferLength = saved_buffer_length;
3410   }
3411
3412   def = *(const WORD*)&pFormat[2];
3413   pFormat += 4;
3414
3415   pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
3416   TRACE("conformance = %ld\n", pStubMsg->MaxCount);
3417
3418   variance_present = IsConformanceOrVariancePresent(pFormat);
3419   pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
3420   TRACE("variance = %d\n", pStubMsg->ActualCount);
3421
3422   WriteConformance(pStubMsg);
3423   if (variance_present)
3424     WriteVariance(pStubMsg);
3425
3426   ALIGN_POINTER_CLEAR(pStubMsg->Buffer, alignment);
3427
3428   count = pStubMsg->ActualCount;
3429   for (i = 0; i < count; i++)
3430     pMemory = ComplexMarshall(pStubMsg, pMemory, pFormat, NULL);
3431
3432   STD_OVERFLOW_CHECK(pStubMsg);
3433
3434   if (pointer_buffer_mark_set)
3435   {
3436     pStubMsg->Buffer = pStubMsg->PointerBufferMark;
3437     pStubMsg->PointerBufferMark = NULL;
3438   }
3439
3440   return NULL;
3441 }
3442
3443 /***********************************************************************
3444  *           NdrComplexArrayUnmarshall [RPCRT4.@]
3445  */
3446 unsigned char * WINAPI NdrComplexArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
3447                                                  unsigned char **ppMemory,
3448                                                  PFORMAT_STRING pFormat,
3449                                                  unsigned char fMustAlloc)
3450 {
3451   ULONG i, count, size;
3452   unsigned char alignment;
3453   unsigned char *pMemory;
3454   unsigned char *saved_buffer;
3455   int pointer_buffer_mark_set = 0;
3456   int saved_ignore_embedded;
3457
3458   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
3459
3460   if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
3461   {
3462       ERR("invalid format type %x\n", pFormat[0]);
3463       RpcRaiseException(RPC_S_INTERNAL_ERROR);
3464       return NULL;
3465   }
3466
3467   alignment = pFormat[1] + 1;
3468
3469   saved_ignore_embedded = pStubMsg->IgnoreEmbeddedPointers;
3470   /* save buffer pointer */
3471   saved_buffer = pStubMsg->Buffer;
3472   /* get the buffer pointer after complex array data, but before
3473    * pointer data */
3474   pStubMsg->IgnoreEmbeddedPointers = 1;
3475   pStubMsg->MemorySize = 0;
3476   NdrComplexArrayMemorySize(pStubMsg, pFormat);
3477   size = pStubMsg->MemorySize;
3478   pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded;
3479
3480   TRACE("difference = 0x%lx\n", (unsigned long)(pStubMsg->Buffer - saved_buffer));
3481   if (!pStubMsg->PointerBufferMark)
3482   {
3483     /* save it for use by embedded pointer code later */
3484     pStubMsg->PointerBufferMark = pStubMsg->Buffer;
3485     pointer_buffer_mark_set = 1;
3486   }
3487   /* restore the original buffer */
3488   pStubMsg->Buffer = saved_buffer;
3489
3490   pFormat += 4;
3491
3492   pFormat = ReadConformance(pStubMsg, pFormat);
3493   pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
3494
3495   if (fMustAlloc || !*ppMemory)
3496   {
3497     *ppMemory = NdrAllocate(pStubMsg, size);
3498     memset(*ppMemory, 0, size);
3499   }
3500
3501   ALIGN_POINTER(pStubMsg->Buffer, alignment);
3502
3503   pMemory = *ppMemory;
3504   count = pStubMsg->ActualCount;
3505   for (i = 0; i < count; i++)
3506     pMemory = ComplexUnmarshall(pStubMsg, pMemory, pFormat, NULL);
3507
3508   if (pointer_buffer_mark_set)
3509   {
3510     pStubMsg->Buffer = pStubMsg->PointerBufferMark;
3511     pStubMsg->PointerBufferMark = NULL;
3512   }
3513
3514   return NULL;
3515 }
3516
3517 /***********************************************************************
3518  *           NdrComplexArrayBufferSize [RPCRT4.@]
3519  */
3520 void WINAPI NdrComplexArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
3521                                       unsigned char *pMemory,
3522                                       PFORMAT_STRING pFormat)
3523 {
3524   ULONG i, count, def;
3525   unsigned char alignment;
3526   BOOL variance_present;
3527   int pointer_length_set = 0;
3528
3529   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3530
3531   if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
3532   {
3533       ERR("invalid format type %x\n", pFormat[0]);
3534       RpcRaiseException(RPC_S_INTERNAL_ERROR);
3535       return;
3536   }
3537
3538   alignment = pFormat[1] + 1;
3539
3540   if (!pStubMsg->IgnoreEmbeddedPointers && !pStubMsg->PointerLength)
3541   {
3542     /* save buffer fields that may be changed by buffer sizer functions
3543      * and that may be needed later on */
3544     int saved_ignore_embedded = pStubMsg->IgnoreEmbeddedPointers;
3545     unsigned long saved_buffer_length = pStubMsg->BufferLength;
3546     unsigned long saved_max_count = pStubMsg->MaxCount;
3547     unsigned long saved_offset = pStubMsg->Offset;
3548     unsigned long saved_actual_count = pStubMsg->ActualCount;
3549
3550     /* get the buffer pointer after complex array data, but before
3551      * pointer data */
3552     pStubMsg->IgnoreEmbeddedPointers = 1;
3553     NdrComplexArrayBufferSize(pStubMsg, pMemory, pFormat);
3554     pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded;
3555
3556     /* save it for use by embedded pointer code later */
3557     pStubMsg->PointerLength = pStubMsg->BufferLength;
3558     pointer_length_set = 1;
3559
3560     /* restore fields */
3561     pStubMsg->ActualCount = saved_actual_count;
3562     pStubMsg->Offset = saved_offset;
3563     pStubMsg->MaxCount = saved_max_count;
3564     pStubMsg->BufferLength = saved_buffer_length;
3565   }
3566   def = *(const WORD*)&pFormat[2];
3567   pFormat += 4;
3568
3569   pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
3570   TRACE("conformance = %ld\n", pStubMsg->MaxCount);
3571   SizeConformance(pStubMsg);
3572
3573   variance_present = IsConformanceOrVariancePresent(pFormat);
3574   pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
3575   TRACE("variance = %d\n", pStubMsg->ActualCount);
3576
3577   if (variance_present)
3578     SizeVariance(pStubMsg);
3579
3580   ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
3581
3582   count = pStubMsg->ActualCount;
3583   for (i = 0; i < count; i++)
3584     pMemory = ComplexBufferSize(pStubMsg, pMemory, pFormat, NULL);
3585
3586   if(pointer_length_set)
3587   {
3588     pStubMsg->BufferLength = pStubMsg->PointerLength;
3589     pStubMsg->PointerLength = 0;
3590   }
3591 }
3592
3593 /***********************************************************************
3594  *           NdrComplexArrayMemorySize [RPCRT4.@]
3595  */
3596 ULONG WINAPI NdrComplexArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
3597                                        PFORMAT_STRING pFormat)
3598 {
3599   ULONG i, count, esize, SavedMemorySize, MemorySize;
3600   unsigned char alignment;
3601
3602   TRACE("(%p,%p)\n", pStubMsg, pFormat);
3603
3604   if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
3605   {
3606       ERR("invalid format type %x\n", pFormat[0]);
3607       RpcRaiseException(RPC_S_INTERNAL_ERROR);
3608       return 0;
3609   }
3610
3611   alignment = pFormat[1] + 1;
3612
3613   pFormat += 4;
3614
3615   pFormat = ReadConformance(pStubMsg, pFormat);
3616   pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
3617
3618   ALIGN_POINTER(pStubMsg->Buffer, alignment);
3619
3620   SavedMemorySize = pStubMsg->MemorySize;
3621
3622   esize = ComplexStructSize(pStubMsg, pFormat);
3623
3624   MemorySize = safe_multiply(pStubMsg->MaxCount, esize);
3625
3626   count = pStubMsg->ActualCount;
3627   for (i = 0; i < count; i++)
3628     ComplexStructMemorySize(pStubMsg, pFormat);
3629
3630   pStubMsg->MemorySize = SavedMemorySize;
3631
3632   pStubMsg->MemorySize += MemorySize;
3633   return MemorySize;
3634 }
3635
3636 /***********************************************************************
3637  *           NdrComplexArrayFree [RPCRT4.@]
3638  */
3639 void WINAPI NdrComplexArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
3640                                 unsigned char *pMemory,
3641                                 PFORMAT_STRING pFormat)
3642 {
3643   ULONG i, count, def;
3644
3645   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3646
3647   if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
3648   {
3649       ERR("invalid format type %x\n", pFormat[0]);
3650       RpcRaiseException(RPC_S_INTERNAL_ERROR);
3651       return;
3652   }
3653
3654   def = *(const WORD*)&pFormat[2];
3655   pFormat += 4;
3656
3657   pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
3658   TRACE("conformance = %ld\n", pStubMsg->MaxCount);
3659
3660   pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
3661   TRACE("variance = %d\n", pStubMsg->ActualCount);
3662
3663   count = pStubMsg->ActualCount;
3664   for (i = 0; i < count; i++)
3665     pMemory = ComplexFree(pStubMsg, pMemory, pFormat, NULL);
3666 }
3667
3668 static void UserMarshalCB(PMIDL_STUB_MESSAGE pStubMsg,
3669                           USER_MARSHAL_CB_TYPE cbtype, PFORMAT_STRING pFormat,
3670                           USER_MARSHAL_CB *umcb)
3671 {
3672   umcb->Flags = MAKELONG(pStubMsg->dwDestContext,
3673                          pStubMsg->RpcMsg->DataRepresentation);
3674   umcb->pStubMsg = pStubMsg;
3675   umcb->pReserve = NULL;
3676   umcb->Signature = USER_MARSHAL_CB_SIGNATURE;
3677   umcb->CBType = cbtype;
3678   umcb->pFormat = pFormat;
3679   umcb->pTypeFormat = NULL /* FIXME */;
3680 }
3681
3682 #define USER_MARSHAL_PTR_PREFIX \
3683         ( (DWORD)'U'         | ( (DWORD)'s' << 8 ) | \
3684         ( (DWORD)'e' << 16 ) | ( (DWORD)'r' << 24 ) )
3685
3686 /***********************************************************************
3687  *           NdrUserMarshalMarshall [RPCRT4.@]
3688  */
3689 unsigned char * WINAPI NdrUserMarshalMarshall(PMIDL_STUB_MESSAGE pStubMsg,
3690                                               unsigned char *pMemory,
3691                                               PFORMAT_STRING pFormat)
3692 {
3693   unsigned flags = pFormat[1];
3694   unsigned index = *(const WORD*)&pFormat[2];
3695   unsigned char *saved_buffer = NULL;
3696   USER_MARSHAL_CB umcb;
3697
3698   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3699   TRACE("index=%d\n", index);
3700
3701   UserMarshalCB(pStubMsg, USER_MARSHAL_CB_MARSHALL, pFormat, &umcb);
3702
3703   if (flags & USER_MARSHAL_POINTER)
3704   {
3705     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
3706     NDR_LOCAL_UINT32_WRITE(pStubMsg->Buffer, USER_MARSHAL_PTR_PREFIX);
3707     pStubMsg->Buffer += 4;
3708     if (pStubMsg->PointerBufferMark)
3709     {
3710       saved_buffer = pStubMsg->Buffer;
3711       pStubMsg->Buffer = pStubMsg->PointerBufferMark;
3712       pStubMsg->PointerBufferMark = NULL;
3713     }
3714     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 8);
3715   }
3716   else
3717     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, (flags & 0xf) + 1);
3718
3719   pStubMsg->Buffer =
3720     pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnMarshall(
3721       &umcb.Flags, pStubMsg->Buffer, pMemory);
3722
3723   if (saved_buffer)
3724   {
3725     STD_OVERFLOW_CHECK(pStubMsg);
3726     pStubMsg->PointerBufferMark = pStubMsg->Buffer;
3727     pStubMsg->Buffer = saved_buffer;
3728   }
3729
3730   STD_OVERFLOW_CHECK(pStubMsg);
3731
3732   return NULL;
3733 }
3734
3735 /***********************************************************************
3736  *           NdrUserMarshalUnmarshall [RPCRT4.@]
3737  */
3738 unsigned char * WINAPI NdrUserMarshalUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
3739                                                  unsigned char **ppMemory,
3740                                                  PFORMAT_STRING pFormat,
3741                                                  unsigned char fMustAlloc)
3742 {
3743   unsigned flags = pFormat[1];
3744   unsigned index = *(const WORD*)&pFormat[2];
3745   DWORD memsize = *(const WORD*)&pFormat[4];
3746   unsigned char *saved_buffer = NULL;
3747   USER_MARSHAL_CB umcb;
3748
3749   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
3750   TRACE("index=%d\n", index);
3751
3752   UserMarshalCB(pStubMsg, USER_MARSHAL_CB_UNMARSHALL, pFormat, &umcb);
3753
3754   if (flags & USER_MARSHAL_POINTER)
3755   {
3756     ALIGN_POINTER(pStubMsg->Buffer, 4);
3757     /* skip pointer prefix */
3758     pStubMsg->Buffer += 4;
3759     if (pStubMsg->PointerBufferMark)
3760     {
3761       saved_buffer = pStubMsg->Buffer;
3762       pStubMsg->Buffer = pStubMsg->PointerBufferMark;
3763       pStubMsg->PointerBufferMark = NULL;
3764     }
3765     ALIGN_POINTER(pStubMsg->Buffer, 8);
3766   }
3767   else
3768     ALIGN_POINTER(pStubMsg->Buffer, (flags & 0xf) + 1);
3769
3770   if (fMustAlloc || !*ppMemory)
3771     *ppMemory = NdrAllocate(pStubMsg, memsize);
3772
3773   pStubMsg->Buffer =
3774     pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnUnmarshall(
3775       &umcb.Flags, pStubMsg->Buffer, *ppMemory);
3776
3777   if (saved_buffer)
3778   {
3779     STD_OVERFLOW_CHECK(pStubMsg);
3780     pStubMsg->PointerBufferMark = pStubMsg->Buffer;
3781     pStubMsg->Buffer = saved_buffer;
3782   }
3783
3784   return NULL;
3785 }
3786
3787 /***********************************************************************
3788  *           NdrUserMarshalBufferSize [RPCRT4.@]
3789  */
3790 void WINAPI NdrUserMarshalBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
3791                                       unsigned char *pMemory,
3792                                       PFORMAT_STRING pFormat)
3793 {
3794   unsigned flags = pFormat[1];
3795   unsigned index = *(const WORD*)&pFormat[2];
3796   DWORD bufsize = *(const WORD*)&pFormat[6];
3797   USER_MARSHAL_CB umcb;
3798   unsigned long saved_buffer_length = 0;
3799
3800   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3801   TRACE("index=%d\n", index);
3802
3803   UserMarshalCB(pStubMsg, USER_MARSHAL_CB_BUFFER_SIZE, pFormat, &umcb);
3804
3805   if (flags & USER_MARSHAL_POINTER)
3806   {
3807     ALIGN_LENGTH(pStubMsg->BufferLength, 4);
3808     /* skip pointer prefix */
3809     safe_buffer_length_increment(pStubMsg, 4);
3810     if (pStubMsg->IgnoreEmbeddedPointers)
3811       return;
3812     if (pStubMsg->PointerLength)
3813     {
3814       saved_buffer_length = pStubMsg->BufferLength;
3815       pStubMsg->BufferLength = pStubMsg->PointerLength;
3816       pStubMsg->PointerLength = 0;
3817     }
3818     ALIGN_LENGTH(pStubMsg->BufferLength, 8);
3819   }
3820   else
3821     ALIGN_LENGTH(pStubMsg->BufferLength, (flags & 0xf) + 1);
3822
3823   if (bufsize) {
3824     TRACE("size=%d\n", bufsize);
3825     safe_buffer_length_increment(pStubMsg, bufsize);
3826   }
3827   else
3828     pStubMsg->BufferLength =
3829         pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnBufferSize(
3830                              &umcb.Flags, pStubMsg->BufferLength, pMemory);
3831
3832   if (saved_buffer_length)
3833   {
3834     pStubMsg->PointerLength = pStubMsg->BufferLength;
3835     pStubMsg->BufferLength = saved_buffer_length;
3836   }
3837
3838 }
3839
3840 /***********************************************************************
3841  *           NdrUserMarshalMemorySize [RPCRT4.@]
3842  */
3843 ULONG WINAPI NdrUserMarshalMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
3844                                       PFORMAT_STRING pFormat)
3845 {
3846   unsigned flags = pFormat[1];
3847   unsigned index = *(const WORD*)&pFormat[2];
3848   DWORD memsize = *(const WORD*)&pFormat[4];
3849   DWORD bufsize = *(const WORD*)&pFormat[6];
3850
3851   TRACE("(%p,%p)\n", pStubMsg, pFormat);
3852   TRACE("index=%d\n", index);
3853
3854   pStubMsg->MemorySize += memsize;
3855
3856   if (flags & USER_MARSHAL_POINTER)
3857   {
3858     ALIGN_POINTER(pStubMsg->Buffer, 4);
3859     /* skip pointer prefix */
3860     pStubMsg->Buffer += 4;
3861     if (pStubMsg->IgnoreEmbeddedPointers)
3862       return pStubMsg->MemorySize;
3863     ALIGN_POINTER(pStubMsg->Buffer, 8);
3864   }
3865   else
3866     ALIGN_POINTER(pStubMsg->Buffer, (flags & 0xf) + 1);
3867
3868   if (!bufsize)
3869     FIXME("not implemented for varying buffer size\n");
3870
3871   pStubMsg->Buffer += bufsize;
3872
3873   return pStubMsg->MemorySize;
3874 }
3875
3876 /***********************************************************************
3877  *           NdrUserMarshalFree [RPCRT4.@]
3878  */
3879 void WINAPI NdrUserMarshalFree(PMIDL_STUB_MESSAGE pStubMsg,
3880                                 unsigned char *pMemory,
3881                                 PFORMAT_STRING pFormat)
3882 {
3883 /*  unsigned flags = pFormat[1]; */
3884   unsigned index = *(const WORD*)&pFormat[2];
3885   USER_MARSHAL_CB umcb;
3886
3887   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
3888   TRACE("index=%d\n", index);
3889
3890   UserMarshalCB(pStubMsg, USER_MARSHAL_CB_FREE, pFormat, &umcb);
3891
3892   pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnFree(
3893     &umcb.Flags, pMemory);
3894 }
3895
3896 /***********************************************************************
3897  *           NdrClearOutParameters [RPCRT4.@]
3898  */
3899 void WINAPI NdrClearOutParameters(PMIDL_STUB_MESSAGE pStubMsg,
3900                                   PFORMAT_STRING pFormat,
3901                                   void *ArgAddr)
3902 {
3903   FIXME("(%p,%p,%p): stub\n", pStubMsg, pFormat, ArgAddr);
3904 }
3905
3906 /***********************************************************************
3907  *           NdrConvert [RPCRT4.@]
3908  */
3909 void WINAPI NdrConvert( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat )
3910 {
3911   FIXME("(pStubMsg == ^%p, pFormat == ^%p): stub.\n", pStubMsg, pFormat);
3912   /* FIXME: since this stub doesn't do any converting, the proper behavior
3913      is to raise an exception */
3914 }
3915
3916 /***********************************************************************
3917  *           NdrConvert2 [RPCRT4.@]
3918  */
3919 void WINAPI NdrConvert2( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, LONG NumberParams )
3920 {
3921   FIXME("(pStubMsg == ^%p, pFormat == ^%p, NumberParams == %d): stub.\n",
3922     pStubMsg, pFormat, NumberParams);
3923   /* FIXME: since this stub doesn't do any converting, the proper behavior
3924      is to raise an exception */
3925 }
3926
3927 #include "pshpack1.h"
3928 typedef struct _NDR_CSTRUCT_FORMAT
3929 {
3930     unsigned char type;
3931     unsigned char alignment;
3932     unsigned short memory_size;
3933     short offset_to_array_description;
3934 } NDR_CSTRUCT_FORMAT, NDR_CVSTRUCT_FORMAT;
3935 #include "poppack.h"
3936
3937 /***********************************************************************
3938  *           NdrConformantStructMarshall [RPCRT4.@]
3939  */
3940 unsigned char *  WINAPI NdrConformantStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
3941                                 unsigned char *pMemory,
3942                                 PFORMAT_STRING pFormat)
3943 {
3944     const NDR_CSTRUCT_FORMAT *pCStructFormat = (const NDR_CSTRUCT_FORMAT *)pFormat;
3945     PFORMAT_STRING pCArrayFormat;
3946     ULONG esize, bufsize;
3947
3948     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
3949
3950     pFormat += sizeof(NDR_CSTRUCT_FORMAT);
3951     if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT))
3952     {
3953         ERR("invalid format type %x\n", pCStructFormat->type);
3954         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3955         return NULL;
3956     }
3957
3958     pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description +
3959         pCStructFormat->offset_to_array_description;
3960     if (*pCArrayFormat != RPC_FC_CARRAY)
3961     {
3962         ERR("invalid array format type %x\n", pCStructFormat->type);
3963         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3964         return NULL;
3965     }
3966     esize = *(const WORD*)(pCArrayFormat+2);
3967
3968     ComputeConformance(pStubMsg, pMemory + pCStructFormat->memory_size,
3969                        pCArrayFormat + 4, 0);
3970
3971     WriteConformance(pStubMsg);
3972
3973     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, pCStructFormat->alignment + 1);
3974
3975     TRACE("memory_size = %d\n", pCStructFormat->memory_size);
3976
3977     bufsize = safe_multiply(esize, pStubMsg->MaxCount);
3978     if (pCStructFormat->memory_size + bufsize < pCStructFormat->memory_size) /* integer overflow */
3979     {
3980         ERR("integer overflow of memory_size %u with bufsize %u\n",
3981             pCStructFormat->memory_size, bufsize);
3982         RpcRaiseException(RPC_X_BAD_STUB_DATA);
3983     }
3984     /* copy constant sized part of struct */
3985     pStubMsg->BufferMark = pStubMsg->Buffer;
3986     safe_copy_to_buffer(pStubMsg, pMemory, pCStructFormat->memory_size + bufsize);
3987
3988     if (pCStructFormat->type == RPC_FC_CPSTRUCT)
3989         EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
3990
3991     return NULL;
3992 }
3993
3994 /***********************************************************************
3995  *           NdrConformantStructUnmarshall [RPCRT4.@]
3996  */
3997 unsigned char *  WINAPI NdrConformantStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
3998                                 unsigned char **ppMemory,
3999                                 PFORMAT_STRING pFormat,
4000                                 unsigned char fMustAlloc)
4001 {
4002     const NDR_CSTRUCT_FORMAT *pCStructFormat = (const NDR_CSTRUCT_FORMAT *)pFormat;
4003     PFORMAT_STRING pCArrayFormat;
4004     ULONG esize, bufsize;
4005     unsigned char *saved_buffer;
4006
4007     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
4008
4009     pFormat += sizeof(NDR_CSTRUCT_FORMAT);
4010     if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT))
4011     {
4012         ERR("invalid format type %x\n", pCStructFormat->type);
4013         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4014         return NULL;
4015     }
4016     pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description +
4017         pCStructFormat->offset_to_array_description;
4018     if (*pCArrayFormat != RPC_FC_CARRAY)
4019     {
4020         ERR("invalid array format type %x\n", pCStructFormat->type);
4021         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4022         return NULL;
4023     }
4024     esize = *(const WORD*)(pCArrayFormat+2);
4025
4026     pCArrayFormat = ReadConformance(pStubMsg, pCArrayFormat + 4);
4027
4028     ALIGN_POINTER(pStubMsg->Buffer, pCStructFormat->alignment + 1);
4029
4030     TRACE("memory_size = %d\n", pCStructFormat->memory_size);
4031
4032     bufsize = safe_multiply(esize, pStubMsg->MaxCount);
4033     if (pCStructFormat->memory_size + bufsize < pCStructFormat->memory_size) /* integer overflow */
4034     {
4035         ERR("integer overflow of memory_size %u with bufsize %u\n",
4036             pCStructFormat->memory_size, bufsize);
4037         RpcRaiseException(RPC_X_BAD_STUB_DATA);
4038     }
4039
4040     if (fMustAlloc)
4041     {
4042         SIZE_T size = pCStructFormat->memory_size + bufsize;
4043         *ppMemory = NdrAllocate(pStubMsg, size);
4044     }
4045     else
4046     {
4047         if (!pStubMsg->IsClient && !*ppMemory)
4048             /* for servers, we just point straight into the RPC buffer */
4049             *ppMemory = pStubMsg->Buffer;
4050     }
4051
4052     saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer;
4053     safe_buffer_increment(pStubMsg, pCStructFormat->memory_size + bufsize);
4054     if (pCStructFormat->type == RPC_FC_CPSTRUCT)
4055         EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat, fMustAlloc);
4056
4057     TRACE("copying %p to %p\n", saved_buffer, *ppMemory);
4058     if (*ppMemory != saved_buffer)
4059         memcpy(*ppMemory, saved_buffer, pCStructFormat->memory_size + bufsize);
4060
4061     return NULL;
4062 }
4063
4064 /***********************************************************************
4065  *           NdrConformantStructBufferSize [RPCRT4.@]
4066  */
4067 void WINAPI NdrConformantStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
4068                                 unsigned char *pMemory,
4069                                 PFORMAT_STRING pFormat)
4070 {
4071     const NDR_CSTRUCT_FORMAT * pCStructFormat = (const NDR_CSTRUCT_FORMAT *)pFormat;
4072     PFORMAT_STRING pCArrayFormat;
4073     ULONG esize;
4074
4075     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4076
4077     pFormat += sizeof(NDR_CSTRUCT_FORMAT);
4078     if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT))
4079     {
4080         ERR("invalid format type %x\n", pCStructFormat->type);
4081         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4082         return;
4083     }
4084     pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description +
4085         pCStructFormat->offset_to_array_description;
4086     if (*pCArrayFormat != RPC_FC_CARRAY)
4087     {
4088         ERR("invalid array format type %x\n", pCStructFormat->type);
4089         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4090         return;
4091     }
4092     esize = *(const WORD*)(pCArrayFormat+2);
4093
4094     pCArrayFormat = ComputeConformance(pStubMsg, pMemory + pCStructFormat->memory_size, pCArrayFormat+4, 0);
4095     SizeConformance(pStubMsg);
4096
4097     ALIGN_LENGTH(pStubMsg->BufferLength, pCStructFormat->alignment + 1);
4098
4099     TRACE("memory_size = %d\n", pCStructFormat->memory_size);
4100
4101     safe_buffer_length_increment(pStubMsg, pCStructFormat->memory_size);
4102     safe_buffer_length_increment(pStubMsg, safe_multiply(pStubMsg->MaxCount, esize));
4103
4104     if (pCStructFormat->type == RPC_FC_CPSTRUCT)
4105         EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
4106 }
4107
4108 /***********************************************************************
4109  *           NdrConformantStructMemorySize [RPCRT4.@]
4110  */
4111 ULONG WINAPI NdrConformantStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
4112                                 PFORMAT_STRING pFormat)
4113 {
4114     FIXME("stub\n");
4115     return 0;
4116 }
4117
4118 /***********************************************************************
4119  *           NdrConformantStructFree [RPCRT4.@]
4120  */
4121 void WINAPI NdrConformantStructFree(PMIDL_STUB_MESSAGE pStubMsg,
4122                                 unsigned char *pMemory,
4123                                 PFORMAT_STRING pFormat)
4124 {
4125     const NDR_CSTRUCT_FORMAT *pCStructFormat = (const NDR_CSTRUCT_FORMAT *)pFormat;
4126     PFORMAT_STRING pCArrayFormat;
4127     ULONG esize;
4128
4129     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4130
4131     pFormat += sizeof(NDR_CSTRUCT_FORMAT);
4132     if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT))
4133     {
4134         ERR("invalid format type %x\n", pCStructFormat->type);
4135         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4136         return;
4137     }
4138
4139     pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description +
4140         pCStructFormat->offset_to_array_description;
4141     if (*pCArrayFormat != RPC_FC_CARRAY)
4142     {
4143         ERR("invalid array format type %x\n", pCStructFormat->type);
4144         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4145         return;
4146     }
4147     esize = *(const WORD*)(pCArrayFormat+2);
4148
4149     ComputeConformance(pStubMsg, pMemory + pCStructFormat->memory_size,
4150                        pCArrayFormat + 4, 0);
4151
4152     TRACE("memory_size = %d\n", pCStructFormat->memory_size);
4153
4154     /* copy constant sized part of struct */
4155     pStubMsg->BufferMark = pStubMsg->Buffer;
4156
4157     if (pCStructFormat->type == RPC_FC_CPSTRUCT)
4158         EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
4159 }
4160
4161 /***********************************************************************
4162  *           NdrConformantVaryingStructMarshall [RPCRT4.@]
4163  */
4164 unsigned char *  WINAPI NdrConformantVaryingStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
4165                                 unsigned char *pMemory,
4166                                 PFORMAT_STRING pFormat)
4167 {
4168     const NDR_CVSTRUCT_FORMAT *pCVStructFormat = (const NDR_CVSTRUCT_FORMAT *)pFormat;
4169     PFORMAT_STRING pCVArrayFormat;
4170     ULONG esize, bufsize;
4171
4172     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4173
4174     pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
4175     if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
4176     {
4177         ERR("invalid format type %x\n", pCVStructFormat->type);
4178         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4179         return NULL;
4180     }
4181
4182     pCVArrayFormat = (const unsigned char *)&pCVStructFormat->offset_to_array_description +
4183         pCVStructFormat->offset_to_array_description;
4184     switch (*pCVArrayFormat)
4185     {
4186     case RPC_FC_CVARRAY:
4187         esize = *(const WORD*)(pCVArrayFormat+2);
4188
4189         pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
4190                                             pCVArrayFormat + 4, 0);
4191         pCVArrayFormat = ComputeVariance(pStubMsg, pMemory + pCVStructFormat->memory_size,
4192                                          pCVArrayFormat, 0);
4193         break;
4194     case RPC_FC_C_CSTRING:
4195         TRACE("string=%s\n", debugstr_a((char*)pMemory + pCVStructFormat->memory_size));
4196         pStubMsg->ActualCount = strlen((char*)pMemory + pCVStructFormat->memory_size)+1;
4197         esize = sizeof(char);
4198         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
4199             pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
4200                                                 pCVArrayFormat + 2, 0);
4201         else
4202             pStubMsg->MaxCount = pStubMsg->ActualCount;
4203         break;
4204     case RPC_FC_C_WSTRING:
4205         TRACE("string=%s\n", debugstr_w((LPWSTR)pMemory + pCVStructFormat->memory_size));
4206         pStubMsg->ActualCount = strlenW((LPWSTR)pMemory + pCVStructFormat->memory_size)+1;
4207         esize = sizeof(WCHAR);
4208         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
4209             pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
4210                                                 pCVArrayFormat + 2, 0);
4211         else
4212             pStubMsg->MaxCount = pStubMsg->ActualCount;
4213         break;
4214     default:
4215         ERR("invalid array format type %x\n", *pCVArrayFormat);
4216         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4217         return NULL;
4218     }
4219
4220     WriteConformance(pStubMsg);
4221
4222     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, pCVStructFormat->alignment + 1);
4223
4224     TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
4225
4226     /* write constant sized part */
4227     pStubMsg->BufferMark = pStubMsg->Buffer;
4228     safe_copy_to_buffer(pStubMsg, pMemory, pCVStructFormat->memory_size);
4229
4230     WriteVariance(pStubMsg);
4231
4232     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
4233
4234     /* write array part */
4235     safe_copy_to_buffer(pStubMsg, pMemory + pCVStructFormat->memory_size, bufsize);
4236
4237     EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
4238
4239     return NULL;
4240 }
4241
4242 /***********************************************************************
4243  *           NdrConformantVaryingStructUnmarshall [RPCRT4.@]
4244  */
4245 unsigned char *  WINAPI NdrConformantVaryingStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
4246                                 unsigned char **ppMemory,
4247                                 PFORMAT_STRING pFormat,
4248                                 unsigned char fMustAlloc)
4249 {
4250     const NDR_CVSTRUCT_FORMAT *pCVStructFormat = (const NDR_CVSTRUCT_FORMAT *)pFormat;
4251     PFORMAT_STRING pCVArrayFormat;
4252     ULONG esize, bufsize;
4253     unsigned char cvarray_type;
4254
4255     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
4256
4257     pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
4258     if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
4259     {
4260         ERR("invalid format type %x\n", pCVStructFormat->type);
4261         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4262         return NULL;
4263     }
4264
4265     pCVArrayFormat = (const unsigned char *)&pCVStructFormat->offset_to_array_description +
4266         pCVStructFormat->offset_to_array_description;
4267     cvarray_type = *pCVArrayFormat;
4268     switch (cvarray_type)
4269     {
4270     case RPC_FC_CVARRAY:
4271         esize = *(const WORD*)(pCVArrayFormat+2);
4272         pCVArrayFormat = ReadConformance(pStubMsg, pCVArrayFormat + 4);
4273         break;
4274     case RPC_FC_C_CSTRING:
4275         esize = sizeof(char);
4276         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
4277             pCVArrayFormat = ReadConformance(pStubMsg, pCVArrayFormat + 2);
4278         else
4279             pCVArrayFormat = ReadConformance(pStubMsg, NULL);
4280         break;
4281     case RPC_FC_C_WSTRING:
4282         esize = sizeof(WCHAR);
4283         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
4284             pCVArrayFormat = ReadConformance(pStubMsg, pCVArrayFormat + 2);
4285         else
4286             pCVArrayFormat = ReadConformance(pStubMsg, NULL);
4287         break;
4288     default:
4289         ERR("invalid array format type %x\n", *pCVArrayFormat);
4290         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4291         return NULL;
4292     }
4293
4294     ALIGN_POINTER(pStubMsg->Buffer, pCVStructFormat->alignment + 1);
4295
4296     TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
4297
4298     /* work out how much memory to allocate if we need to do so */
4299     if (!*ppMemory || fMustAlloc)
4300     {
4301         SIZE_T size = pCVStructFormat->memory_size + safe_multiply(esize, pStubMsg->MaxCount);
4302         *ppMemory = NdrAllocate(pStubMsg, size);
4303     }
4304
4305     /* copy the constant data */
4306     pStubMsg->BufferMark = pStubMsg->Buffer;
4307     safe_copy_from_buffer(pStubMsg, *ppMemory, pCVStructFormat->memory_size);
4308
4309     pCVArrayFormat = ReadVariance(pStubMsg, pCVArrayFormat, pStubMsg->MaxCount);
4310
4311     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
4312
4313     if ((cvarray_type == RPC_FC_C_CSTRING) ||
4314         (cvarray_type == RPC_FC_C_WSTRING))
4315     {
4316         ULONG i;
4317         /* strings must always have null terminating bytes */
4318         if (bufsize < esize)
4319         {
4320             ERR("invalid string length of %d\n", pStubMsg->ActualCount);
4321             RpcRaiseException(RPC_S_INVALID_BOUND);
4322             return NULL;
4323         }
4324         for (i = bufsize - esize; i < bufsize; i++)
4325             if (pStubMsg->Buffer[i] != 0)
4326             {
4327                 ERR("string not null-terminated at byte position %d, data is 0x%x\n",
4328                     i, pStubMsg->Buffer[i]);
4329                 RpcRaiseException(RPC_S_INVALID_BOUND);
4330                 return NULL;
4331             }
4332     }
4333
4334     /* copy the array data */
4335     safe_copy_from_buffer(pStubMsg, *ppMemory + pCVStructFormat->memory_size, bufsize);
4336
4337     if (cvarray_type == RPC_FC_C_CSTRING)
4338         TRACE("string=%s\n", debugstr_a((char *)(*ppMemory + pCVStructFormat->memory_size)));
4339     else if (cvarray_type == RPC_FC_C_WSTRING)
4340         TRACE("string=%s\n", debugstr_w((WCHAR *)(*ppMemory + pCVStructFormat->memory_size)));
4341
4342     EmbeddedPointerUnmarshall(pStubMsg, *ppMemory, *ppMemory, pFormat, TRUE /* FIXME */);
4343
4344     return NULL;
4345 }
4346
4347 /***********************************************************************
4348  *           NdrConformantVaryingStructBufferSize [RPCRT4.@]
4349  */
4350 void WINAPI NdrConformantVaryingStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
4351                                 unsigned char *pMemory,
4352                                 PFORMAT_STRING pFormat)
4353 {
4354     const NDR_CVSTRUCT_FORMAT *pCVStructFormat = (const NDR_CVSTRUCT_FORMAT *)pFormat;
4355     PFORMAT_STRING pCVArrayFormat;
4356     ULONG esize;
4357
4358     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4359
4360     pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
4361     if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
4362     {
4363         ERR("invalid format type %x\n", pCVStructFormat->type);
4364         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4365         return;
4366     }
4367
4368     pCVArrayFormat = (const unsigned char *)&pCVStructFormat->offset_to_array_description +
4369         pCVStructFormat->offset_to_array_description;
4370     switch (*pCVArrayFormat)
4371     {
4372     case RPC_FC_CVARRAY:
4373         esize = *(const WORD*)(pCVArrayFormat+2);
4374
4375         pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
4376                                             pCVArrayFormat + 4, 0);
4377         pCVArrayFormat = ComputeVariance(pStubMsg, pMemory + pCVStructFormat->memory_size,
4378                                          pCVArrayFormat, 0);
4379         break;
4380     case RPC_FC_C_CSTRING:
4381         TRACE("string=%s\n", debugstr_a((char*)pMemory + pCVStructFormat->memory_size));
4382         pStubMsg->ActualCount = strlen((char*)pMemory + pCVStructFormat->memory_size)+1;
4383         esize = sizeof(char);
4384         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
4385             pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
4386                                                 pCVArrayFormat + 2, 0);
4387         else
4388             pStubMsg->MaxCount = pStubMsg->ActualCount;
4389         break;
4390     case RPC_FC_C_WSTRING:
4391         TRACE("string=%s\n", debugstr_w((LPWSTR)pMemory + pCVStructFormat->memory_size));
4392         pStubMsg->ActualCount = strlenW((LPWSTR)pMemory + pCVStructFormat->memory_size)+1;
4393         esize = sizeof(WCHAR);
4394         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
4395             pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
4396                                                 pCVArrayFormat + 2, 0);
4397         else
4398             pStubMsg->MaxCount = pStubMsg->ActualCount;
4399         break;
4400     default:
4401         ERR("invalid array format type %x\n", *pCVArrayFormat);
4402         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4403         return;
4404     }
4405
4406     SizeConformance(pStubMsg);
4407
4408     ALIGN_LENGTH(pStubMsg->BufferLength, pCVStructFormat->alignment + 1);
4409
4410     TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
4411
4412     safe_buffer_length_increment(pStubMsg, pCVStructFormat->memory_size);
4413     SizeVariance(pStubMsg);
4414     safe_buffer_length_increment(pStubMsg, safe_multiply(pStubMsg->MaxCount, esize));
4415
4416     EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
4417 }
4418
4419 /***********************************************************************
4420  *           NdrConformantVaryingStructMemorySize [RPCRT4.@]
4421  */
4422 ULONG WINAPI NdrConformantVaryingStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
4423                                 PFORMAT_STRING pFormat)
4424 {
4425     const NDR_CVSTRUCT_FORMAT *pCVStructFormat = (const NDR_CVSTRUCT_FORMAT *)pFormat;
4426     PFORMAT_STRING pCVArrayFormat;
4427     ULONG esize;
4428     unsigned char cvarray_type;
4429
4430     TRACE("(%p, %p)\n", pStubMsg, pFormat);
4431
4432     pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
4433     if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
4434     {
4435         ERR("invalid format type %x\n", pCVStructFormat->type);
4436         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4437         return 0;
4438     }
4439
4440     pCVArrayFormat = (const unsigned char *)&pCVStructFormat->offset_to_array_description +
4441         pCVStructFormat->offset_to_array_description;
4442     cvarray_type = *pCVArrayFormat;
4443     switch (cvarray_type)
4444     {
4445     case RPC_FC_CVARRAY:
4446         esize = *(const WORD*)(pCVArrayFormat+2);
4447         pCVArrayFormat = ReadConformance(pStubMsg, pCVArrayFormat + 4);
4448         break;
4449     case RPC_FC_C_CSTRING:
4450         esize = sizeof(char);
4451         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
4452             pCVArrayFormat = ReadConformance(pStubMsg, pCVArrayFormat + 2);
4453         else
4454             pCVArrayFormat = ReadConformance(pStubMsg, NULL);
4455         break;
4456     case RPC_FC_C_WSTRING:
4457         esize = sizeof(WCHAR);
4458         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
4459             pCVArrayFormat = ReadConformance(pStubMsg, pCVArrayFormat + 2);
4460         else
4461             pCVArrayFormat = ReadConformance(pStubMsg, NULL);
4462         break;
4463     default:
4464         ERR("invalid array format type %x\n", *pCVArrayFormat);
4465         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4466         return 0;
4467     }
4468
4469     ALIGN_POINTER(pStubMsg->Buffer, pCVStructFormat->alignment + 1);
4470
4471     TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
4472
4473     safe_buffer_increment(pStubMsg, pCVStructFormat->memory_size);
4474     pCVArrayFormat = ReadVariance(pStubMsg, pCVArrayFormat, pStubMsg->MaxCount);
4475     safe_buffer_increment(pStubMsg, safe_multiply(esize, pStubMsg->ActualCount));
4476
4477     pStubMsg->MemorySize += pCVStructFormat->memory_size + safe_multiply(esize, pStubMsg->MaxCount);
4478
4479     EmbeddedPointerMemorySize(pStubMsg, pFormat);
4480
4481     return pCVStructFormat->memory_size + pStubMsg->MaxCount * esize;
4482 }
4483
4484 /***********************************************************************
4485  *           NdrConformantVaryingStructFree [RPCRT4.@]
4486  */
4487 void WINAPI NdrConformantVaryingStructFree(PMIDL_STUB_MESSAGE pStubMsg,
4488                                 unsigned char *pMemory,
4489                                 PFORMAT_STRING pFormat)
4490 {
4491     const NDR_CVSTRUCT_FORMAT *pCVStructFormat = (const NDR_CVSTRUCT_FORMAT *)pFormat;
4492     PFORMAT_STRING pCVArrayFormat;
4493     ULONG esize;
4494
4495     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4496
4497     pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
4498     if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
4499     {
4500         ERR("invalid format type %x\n", pCVStructFormat->type);
4501         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4502         return;
4503     }
4504
4505     pCVArrayFormat = (const unsigned char *)&pCVStructFormat->offset_to_array_description +
4506         pCVStructFormat->offset_to_array_description;
4507     switch (*pCVArrayFormat)
4508     {
4509     case RPC_FC_CVARRAY:
4510         esize = *(const WORD*)(pCVArrayFormat+2);
4511
4512         pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
4513                                             pCVArrayFormat + 4, 0);
4514         pCVArrayFormat = ComputeVariance(pStubMsg, pMemory + pCVStructFormat->memory_size,
4515                                          pCVArrayFormat, 0);
4516         break;
4517     case RPC_FC_C_CSTRING:
4518         TRACE("string=%s\n", debugstr_a((char*)pMemory + pCVStructFormat->memory_size));
4519         pStubMsg->ActualCount = strlen((char*)pMemory + pCVStructFormat->memory_size)+1;
4520         esize = sizeof(char);
4521         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
4522             pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
4523                                                 pCVArrayFormat + 2, 0);
4524         else
4525             pStubMsg->MaxCount = pStubMsg->ActualCount;
4526         break;
4527     case RPC_FC_C_WSTRING:
4528         TRACE("string=%s\n", debugstr_w((LPWSTR)pMemory + pCVStructFormat->memory_size));
4529         pStubMsg->ActualCount = strlenW((LPWSTR)pMemory + pCVStructFormat->memory_size)+1;
4530         esize = sizeof(WCHAR);
4531         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
4532             pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
4533                                                 pCVArrayFormat + 2, 0);
4534         else
4535             pStubMsg->MaxCount = pStubMsg->ActualCount;
4536         break;
4537     default:
4538         ERR("invalid array format type %x\n", *pCVArrayFormat);
4539         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4540         return;
4541     }
4542
4543     TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
4544
4545     EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
4546 }
4547
4548 #include "pshpack1.h"
4549 typedef struct
4550 {
4551     unsigned char type;
4552     unsigned char alignment;
4553     unsigned short total_size;
4554 } NDR_SMFARRAY_FORMAT;
4555
4556 typedef struct
4557 {
4558     unsigned char type;
4559     unsigned char alignment;
4560     unsigned long total_size;
4561 } NDR_LGFARRAY_FORMAT;
4562 #include "poppack.h"
4563
4564 /***********************************************************************
4565  *           NdrFixedArrayMarshall [RPCRT4.@]
4566  */
4567 unsigned char *  WINAPI NdrFixedArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
4568                                 unsigned char *pMemory,
4569                                 PFORMAT_STRING pFormat)
4570 {
4571     const NDR_SMFARRAY_FORMAT *pSmFArrayFormat = (const NDR_SMFARRAY_FORMAT *)pFormat;
4572     unsigned long total_size;
4573
4574     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4575
4576     if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
4577         (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
4578     {
4579         ERR("invalid format type %x\n", pSmFArrayFormat->type);
4580         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4581         return NULL;
4582     }
4583
4584     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
4585
4586     if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
4587     {
4588         total_size = pSmFArrayFormat->total_size;
4589         pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
4590     }
4591     else
4592     {
4593         const NDR_LGFARRAY_FORMAT *pLgFArrayFormat = (const NDR_LGFARRAY_FORMAT *)pFormat;
4594         total_size = pLgFArrayFormat->total_size;
4595         pFormat = (const unsigned char *)(pLgFArrayFormat + 1);
4596     }
4597
4598     pStubMsg->BufferMark = pStubMsg->Buffer;
4599     safe_copy_to_buffer(pStubMsg, pMemory, total_size);
4600
4601     pFormat = EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
4602
4603     return NULL;
4604 }
4605
4606 /***********************************************************************
4607  *           NdrFixedArrayUnmarshall [RPCRT4.@]
4608  */
4609 unsigned char *  WINAPI NdrFixedArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
4610                                 unsigned char **ppMemory,
4611                                 PFORMAT_STRING pFormat,
4612                                 unsigned char fMustAlloc)
4613 {
4614     const NDR_SMFARRAY_FORMAT *pSmFArrayFormat = (const NDR_SMFARRAY_FORMAT *)pFormat;
4615     unsigned long total_size;
4616     unsigned char *saved_buffer;
4617
4618     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
4619
4620     if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
4621         (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
4622     {
4623         ERR("invalid format type %x\n", pSmFArrayFormat->type);
4624         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4625         return NULL;
4626     }
4627
4628     ALIGN_POINTER(pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
4629
4630     if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
4631     {
4632         total_size = pSmFArrayFormat->total_size;
4633         pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
4634     }
4635     else
4636     {
4637         const NDR_LGFARRAY_FORMAT *pLgFArrayFormat = (const NDR_LGFARRAY_FORMAT *)pFormat;
4638         total_size = pLgFArrayFormat->total_size;
4639         pFormat = (const unsigned char *)(pLgFArrayFormat + 1);
4640     }
4641
4642     if (fMustAlloc)
4643         *ppMemory = NdrAllocate(pStubMsg, total_size);
4644     else
4645     {
4646         if (!pStubMsg->IsClient && !*ppMemory)
4647             /* for servers, we just point straight into the RPC buffer */
4648             *ppMemory = pStubMsg->Buffer;
4649     }
4650
4651     saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer;
4652     safe_buffer_increment(pStubMsg, total_size);
4653     pFormat = EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat, fMustAlloc);
4654
4655     TRACE("copying %p to %p\n", saved_buffer, *ppMemory);
4656     if (*ppMemory != saved_buffer)
4657         memcpy(*ppMemory, saved_buffer, total_size);
4658
4659     return NULL;
4660 }
4661
4662 /***********************************************************************
4663  *           NdrFixedArrayBufferSize [RPCRT4.@]
4664  */
4665 void WINAPI NdrFixedArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
4666                                 unsigned char *pMemory,
4667                                 PFORMAT_STRING pFormat)
4668 {
4669     const NDR_SMFARRAY_FORMAT *pSmFArrayFormat = (const NDR_SMFARRAY_FORMAT *)pFormat;
4670     unsigned long total_size;
4671
4672     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4673
4674     if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
4675         (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
4676     {
4677         ERR("invalid format type %x\n", pSmFArrayFormat->type);
4678         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4679         return;
4680     }
4681
4682     ALIGN_LENGTH(pStubMsg->BufferLength, pSmFArrayFormat->alignment + 1);
4683
4684     if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
4685     {
4686         total_size = pSmFArrayFormat->total_size;
4687         pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
4688     }
4689     else
4690     {
4691         const NDR_LGFARRAY_FORMAT *pLgFArrayFormat = (const NDR_LGFARRAY_FORMAT *)pFormat;
4692         total_size = pLgFArrayFormat->total_size;
4693         pFormat = (const unsigned char *)(pLgFArrayFormat + 1);
4694     }
4695     safe_buffer_length_increment(pStubMsg, total_size);
4696
4697     EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
4698 }
4699
4700 /***********************************************************************
4701  *           NdrFixedArrayMemorySize [RPCRT4.@]
4702  */
4703 ULONG WINAPI NdrFixedArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
4704                                 PFORMAT_STRING pFormat)
4705 {
4706     const NDR_SMFARRAY_FORMAT *pSmFArrayFormat = (const NDR_SMFARRAY_FORMAT *)pFormat;
4707     ULONG total_size;
4708
4709     TRACE("(%p, %p)\n", pStubMsg, pFormat);
4710
4711     if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
4712         (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
4713     {
4714         ERR("invalid format type %x\n", pSmFArrayFormat->type);
4715         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4716         return 0;
4717     }
4718
4719     ALIGN_POINTER(pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
4720
4721     if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
4722     {
4723         total_size = pSmFArrayFormat->total_size;
4724         pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
4725     }
4726     else
4727     {
4728         const NDR_LGFARRAY_FORMAT *pLgFArrayFormat = (const NDR_LGFARRAY_FORMAT *)pFormat;
4729         total_size = pLgFArrayFormat->total_size;
4730         pFormat = (const unsigned char *)(pLgFArrayFormat + 1);
4731     }
4732     pStubMsg->BufferMark = pStubMsg->Buffer;
4733     safe_buffer_increment(pStubMsg, total_size);
4734     pStubMsg->MemorySize += total_size;
4735
4736     EmbeddedPointerMemorySize(pStubMsg, pFormat);
4737
4738     return total_size;
4739 }
4740
4741 /***********************************************************************
4742  *           NdrFixedArrayFree [RPCRT4.@]
4743  */
4744 void WINAPI NdrFixedArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
4745                                 unsigned char *pMemory,
4746                                 PFORMAT_STRING pFormat)
4747 {
4748     const NDR_SMFARRAY_FORMAT *pSmFArrayFormat = (const NDR_SMFARRAY_FORMAT *)pFormat;
4749
4750     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4751
4752     if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
4753         (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
4754     {
4755         ERR("invalid format type %x\n", pSmFArrayFormat->type);
4756         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4757         return;
4758     }
4759
4760     if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
4761         pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
4762     else
4763     {
4764         const NDR_LGFARRAY_FORMAT *pLgFArrayFormat = (const NDR_LGFARRAY_FORMAT *)pFormat;
4765         pFormat = (const unsigned char *)(pLgFArrayFormat + 1);
4766     }
4767
4768     EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
4769 }
4770
4771 /***********************************************************************
4772  *           NdrVaryingArrayMarshall [RPCRT4.@]
4773  */
4774 unsigned char *  WINAPI NdrVaryingArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
4775                                 unsigned char *pMemory,
4776                                 PFORMAT_STRING pFormat)
4777 {
4778     unsigned char alignment;
4779     DWORD elements, esize;
4780     ULONG bufsize;
4781
4782     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4783
4784     if ((pFormat[0] != RPC_FC_SMVARRAY) &&
4785         (pFormat[0] != RPC_FC_LGVARRAY))
4786     {
4787         ERR("invalid format type %x\n", pFormat[0]);
4788         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4789         return NULL;
4790     }
4791
4792     alignment = pFormat[1] + 1;
4793
4794     if (pFormat[0] == RPC_FC_SMVARRAY)
4795     {
4796         pFormat += 2;
4797         pFormat += sizeof(WORD);
4798         elements = *(const WORD*)pFormat;
4799         pFormat += sizeof(WORD);
4800     }
4801     else
4802     {
4803         pFormat += 2;
4804         pFormat += sizeof(DWORD);
4805         elements = *(const DWORD*)pFormat;
4806         pFormat += sizeof(DWORD);
4807     }
4808
4809     esize = *(const WORD*)pFormat;
4810     pFormat += sizeof(WORD);
4811
4812     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
4813     if ((pStubMsg->ActualCount > elements) ||
4814         (pStubMsg->ActualCount + pStubMsg->Offset > elements))
4815     {
4816         RpcRaiseException(RPC_S_INVALID_BOUND);
4817         return NULL;
4818     }
4819
4820     WriteVariance(pStubMsg);
4821
4822     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, alignment);
4823
4824     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
4825     pStubMsg->BufferMark = pStubMsg->Buffer;
4826     safe_copy_to_buffer(pStubMsg, pMemory + pStubMsg->Offset, bufsize);
4827
4828     EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
4829
4830     return NULL;
4831 }
4832
4833 /***********************************************************************
4834  *           NdrVaryingArrayUnmarshall [RPCRT4.@]
4835  */
4836 unsigned char *  WINAPI NdrVaryingArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
4837                                 unsigned char **ppMemory,
4838                                 PFORMAT_STRING pFormat,
4839                                 unsigned char fMustAlloc)
4840 {
4841     unsigned char alignment;
4842     DWORD size, elements, esize;
4843     ULONG bufsize;
4844     unsigned char *saved_buffer;
4845     ULONG offset;
4846
4847     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
4848
4849     if ((pFormat[0] != RPC_FC_SMVARRAY) &&
4850         (pFormat[0] != RPC_FC_LGVARRAY))
4851     {
4852         ERR("invalid format type %x\n", pFormat[0]);
4853         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4854         return NULL;
4855     }
4856
4857     alignment = pFormat[1] + 1;
4858
4859     if (pFormat[0] == RPC_FC_SMVARRAY)
4860     {
4861         pFormat += 2;
4862         size = *(const WORD*)pFormat;
4863         pFormat += sizeof(WORD);
4864         elements = *(const WORD*)pFormat;
4865         pFormat += sizeof(WORD);
4866     }
4867     else
4868     {
4869         pFormat += 2;
4870         size = *(const DWORD*)pFormat;
4871         pFormat += sizeof(DWORD);
4872         elements = *(const DWORD*)pFormat;
4873         pFormat += sizeof(DWORD);
4874     }
4875
4876     esize = *(const WORD*)pFormat;
4877     pFormat += sizeof(WORD);
4878
4879     pFormat = ReadVariance(pStubMsg, pFormat, elements);
4880
4881     ALIGN_POINTER(pStubMsg->Buffer, alignment);
4882
4883     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
4884     offset = pStubMsg->Offset;
4885
4886     if (!*ppMemory || fMustAlloc)
4887         *ppMemory = NdrAllocate(pStubMsg, size);
4888     saved_buffer = pStubMsg->BufferMark = pStubMsg->Buffer;
4889     safe_buffer_increment(pStubMsg, bufsize);
4890
4891     EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat, fMustAlloc);
4892
4893     memcpy(*ppMemory + offset, saved_buffer, bufsize);
4894
4895     return NULL;
4896 }
4897
4898 /***********************************************************************
4899  *           NdrVaryingArrayBufferSize [RPCRT4.@]
4900  */
4901 void WINAPI NdrVaryingArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
4902                                 unsigned char *pMemory,
4903                                 PFORMAT_STRING pFormat)
4904 {
4905     unsigned char alignment;
4906     DWORD elements, esize;
4907
4908     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4909
4910     if ((pFormat[0] != RPC_FC_SMVARRAY) &&
4911         (pFormat[0] != RPC_FC_LGVARRAY))
4912     {
4913         ERR("invalid format type %x\n", pFormat[0]);
4914         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4915         return;
4916     }
4917
4918     alignment = pFormat[1] + 1;
4919
4920     if (pFormat[0] == RPC_FC_SMVARRAY)
4921     {
4922         pFormat += 2;
4923         pFormat += sizeof(WORD);
4924         elements = *(const WORD*)pFormat;
4925         pFormat += sizeof(WORD);
4926     }
4927     else
4928     {
4929         pFormat += 2;
4930         pFormat += sizeof(DWORD);
4931         elements = *(const DWORD*)pFormat;
4932         pFormat += sizeof(DWORD);
4933     }
4934
4935     esize = *(const WORD*)pFormat;
4936     pFormat += sizeof(WORD);
4937
4938     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
4939     if ((pStubMsg->ActualCount > elements) ||
4940         (pStubMsg->ActualCount + pStubMsg->Offset > elements))
4941     {
4942         RpcRaiseException(RPC_S_INVALID_BOUND);
4943         return;
4944     }
4945
4946     SizeVariance(pStubMsg);
4947
4948     ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
4949
4950     safe_buffer_length_increment(pStubMsg, safe_multiply(esize, pStubMsg->ActualCount));
4951
4952     EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
4953 }
4954
4955 /***********************************************************************
4956  *           NdrVaryingArrayMemorySize [RPCRT4.@]
4957  */
4958 ULONG WINAPI NdrVaryingArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
4959                                 PFORMAT_STRING pFormat)
4960 {
4961     unsigned char alignment;
4962     DWORD size, elements, esize;
4963
4964     TRACE("(%p, %p)\n", pStubMsg, pFormat);
4965
4966     if ((pFormat[0] != RPC_FC_SMVARRAY) &&
4967         (pFormat[0] != RPC_FC_LGVARRAY))
4968     {
4969         ERR("invalid format type %x\n", pFormat[0]);
4970         RpcRaiseException(RPC_S_INTERNAL_ERROR);
4971         return 0;
4972     }
4973
4974     alignment = pFormat[1] + 1;
4975
4976     if (pFormat[0] == RPC_FC_SMVARRAY)
4977     {
4978         pFormat += 2;
4979         size = *(const WORD*)pFormat;
4980         pFormat += sizeof(WORD);
4981         elements = *(const WORD*)pFormat;
4982         pFormat += sizeof(WORD);
4983     }
4984     else
4985     {
4986         pFormat += 2;
4987         size = *(const DWORD*)pFormat;
4988         pFormat += sizeof(DWORD);
4989         elements = *(const DWORD*)pFormat;
4990         pFormat += sizeof(DWORD);
4991     }
4992
4993     esize = *(const WORD*)pFormat;
4994     pFormat += sizeof(WORD);
4995
4996     pFormat = ReadVariance(pStubMsg, pFormat, elements);
4997
4998     ALIGN_POINTER(pStubMsg->Buffer, alignment);
4999
5000     safe_buffer_increment(pStubMsg, safe_multiply(esize, pStubMsg->ActualCount));
5001     pStubMsg->MemorySize += size;
5002
5003     EmbeddedPointerMemorySize(pStubMsg, pFormat);
5004
5005     return pStubMsg->MemorySize;
5006 }
5007
5008 /***********************************************************************
5009  *           NdrVaryingArrayFree [RPCRT4.@]
5010  */
5011 void WINAPI NdrVaryingArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
5012                                 unsigned char *pMemory,
5013                                 PFORMAT_STRING pFormat)
5014 {
5015     unsigned char alignment;
5016     DWORD elements;
5017
5018     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5019
5020     if ((pFormat[0] != RPC_FC_SMVARRAY) &&
5021         (pFormat[0] != RPC_FC_LGVARRAY))
5022     {
5023         ERR("invalid format type %x\n", pFormat[0]);
5024         RpcRaiseException(RPC_S_INTERNAL_ERROR);
5025         return;
5026     }
5027
5028     alignment = pFormat[1] + 1;
5029
5030     if (pFormat[0] == RPC_FC_SMVARRAY)
5031     {
5032         pFormat += 2;
5033         pFormat += sizeof(WORD);
5034         elements = *(const WORD*)pFormat;
5035         pFormat += sizeof(WORD);
5036     }
5037     else
5038     {
5039         pFormat += 2;
5040         pFormat += sizeof(DWORD);
5041         elements = *(const DWORD*)pFormat;
5042         pFormat += sizeof(DWORD);
5043     }
5044
5045     pFormat += sizeof(WORD);
5046
5047     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
5048     if ((pStubMsg->ActualCount > elements) ||
5049         (pStubMsg->ActualCount + pStubMsg->Offset > elements))
5050     {
5051         RpcRaiseException(RPC_S_INVALID_BOUND);
5052         return;
5053     }
5054
5055     EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
5056 }
5057
5058 static ULONG get_discriminant(unsigned char fc, const unsigned char *pMemory)
5059 {
5060     switch (fc)
5061     {
5062     case RPC_FC_BYTE:
5063     case RPC_FC_CHAR:
5064     case RPC_FC_SMALL:
5065     case RPC_FC_USMALL:
5066         return *pMemory;
5067     case RPC_FC_WCHAR:
5068     case RPC_FC_SHORT:
5069     case RPC_FC_USHORT:
5070     case RPC_FC_ENUM16:
5071         return *(const USHORT *)pMemory;
5072     case RPC_FC_LONG:
5073     case RPC_FC_ULONG:
5074     case RPC_FC_ENUM32:
5075         return *(const ULONG *)pMemory;
5076     default:
5077         FIXME("Unhandled base type: 0x%02x\n", fc);
5078         return 0;
5079     }
5080 }
5081
5082 static PFORMAT_STRING get_arm_offset_from_union_arm_selector(PMIDL_STUB_MESSAGE pStubMsg,
5083                                                              unsigned long discriminant,
5084                                                              PFORMAT_STRING pFormat)
5085 {
5086     unsigned short num_arms, arm, type;
5087
5088     num_arms = *(const SHORT*)pFormat & 0x0fff;
5089     pFormat += 2;
5090     for(arm = 0; arm < num_arms; arm++)
5091     {
5092         if(discriminant == *(const ULONG*)pFormat)
5093         {
5094             pFormat += 4;
5095             break;
5096         }
5097         pFormat += 6;
5098     }
5099
5100     type = *(const unsigned short*)pFormat;
5101     TRACE("type %04x\n", type);
5102     if(arm == num_arms) /* default arm extras */
5103     {
5104         if(type == 0xffff)
5105         {
5106             ERR("no arm for 0x%lx and no default case\n", discriminant);
5107             RpcRaiseException(RPC_S_INVALID_TAG);
5108             return NULL;
5109         }
5110         if(type == 0)
5111         {
5112             TRACE("falling back to empty default case for 0x%lx\n", discriminant);
5113             return NULL;
5114         }
5115     }
5116     return pFormat;
5117 }
5118
5119 static unsigned char *union_arm_marshall(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, ULONG discriminant, PFORMAT_STRING pFormat)
5120 {
5121     unsigned short type;
5122
5123     pFormat += 2;
5124
5125     pFormat = get_arm_offset_from_union_arm_selector(pStubMsg, discriminant, pFormat);
5126     if(!pFormat)
5127         return NULL;
5128
5129     type = *(const unsigned short*)pFormat;
5130     if((type & 0xff00) == 0x8000)
5131     {
5132         unsigned char basetype = LOBYTE(type);
5133         return NdrBaseTypeMarshall(pStubMsg, pMemory, &basetype);
5134     }
5135     else
5136     {
5137         PFORMAT_STRING desc = pFormat + *(const SHORT*)pFormat;
5138         NDR_MARSHALL m = NdrMarshaller[*desc & NDR_TABLE_MASK];
5139         if (m)
5140         {
5141             unsigned char *saved_buffer = NULL;
5142             int pointer_buffer_mark_set = 0;
5143             switch(*desc)
5144             {
5145             case RPC_FC_RP:
5146             case RPC_FC_UP:
5147             case RPC_FC_OP:
5148             case RPC_FC_FP:
5149                 ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
5150                 saved_buffer = pStubMsg->Buffer;
5151                 if (pStubMsg->PointerBufferMark)
5152                 {
5153                   pStubMsg->Buffer = pStubMsg->PointerBufferMark;
5154                   pStubMsg->PointerBufferMark = NULL;
5155                   pointer_buffer_mark_set = 1;
5156                 }
5157                 else
5158                   safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
5159
5160                 PointerMarshall(pStubMsg, saved_buffer, *(unsigned char **)pMemory, desc);
5161                 if (pointer_buffer_mark_set)
5162                 {
5163                   STD_OVERFLOW_CHECK(pStubMsg);
5164                   pStubMsg->PointerBufferMark = pStubMsg->Buffer;
5165                   if (saved_buffer + 4 > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
5166                   {
5167                       ERR("buffer overflow - saved_buffer = %p, BufferEnd = %p\n",
5168                           saved_buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength);
5169                       RpcRaiseException(RPC_X_BAD_STUB_DATA);
5170                   }
5171                   pStubMsg->Buffer = saved_buffer + 4;
5172                 }
5173                 break;
5174             default:
5175                 m(pStubMsg, pMemory, desc);
5176             }
5177         }
5178         else FIXME("no marshaller for embedded type %02x\n", *desc);
5179     }
5180     return NULL;
5181 }
5182
5183 static unsigned char *union_arm_unmarshall(PMIDL_STUB_MESSAGE pStubMsg,
5184                                 unsigned char **ppMemory,
5185                                 ULONG discriminant,
5186                                 PFORMAT_STRING pFormat,
5187                                 unsigned char fMustAlloc)
5188 {
5189     unsigned short type;
5190
5191     pFormat += 2;
5192
5193     pFormat = get_arm_offset_from_union_arm_selector(pStubMsg, discriminant, pFormat);
5194     if(!pFormat)
5195         return NULL;
5196
5197     type = *(const unsigned short*)pFormat;
5198     if((type & 0xff00) == 0x8000)
5199     {
5200         unsigned char basetype = LOBYTE(type);
5201         return NdrBaseTypeUnmarshall(pStubMsg, ppMemory, &basetype, FALSE);
5202     }
5203     else
5204     {
5205         PFORMAT_STRING desc = pFormat + *(const SHORT*)pFormat;
5206         NDR_UNMARSHALL m = NdrUnmarshaller[*desc & NDR_TABLE_MASK];
5207         if (m)
5208         {
5209             unsigned char *saved_buffer = NULL;
5210             int pointer_buffer_mark_set = 0;
5211             switch(*desc)
5212             {
5213             case RPC_FC_RP:
5214             case RPC_FC_UP:
5215             case RPC_FC_OP:
5216             case RPC_FC_FP:
5217                 **(void***)ppMemory = NULL;
5218                 ALIGN_POINTER(pStubMsg->Buffer, 4);
5219                 saved_buffer = pStubMsg->Buffer;
5220                 if (pStubMsg->PointerBufferMark)
5221                 {
5222                   pStubMsg->Buffer = pStubMsg->PointerBufferMark;
5223                   pStubMsg->PointerBufferMark = NULL;
5224                   pointer_buffer_mark_set = 1;
5225                 }
5226                 else
5227                   pStubMsg->Buffer += 4; /* for pointer ID */
5228
5229                 if (saved_buffer + 4 > pStubMsg->BufferEnd)
5230                 {
5231                     ERR("buffer overflow - saved_buffer = %p, BufferEnd = %p\n",
5232                         saved_buffer, pStubMsg->BufferEnd);
5233                     RpcRaiseException(RPC_X_BAD_STUB_DATA);
5234                 }
5235
5236                 PointerUnmarshall(pStubMsg, saved_buffer, *(unsigned char ***)ppMemory, **(unsigned char ***)ppMemory, desc, fMustAlloc);
5237                 if (pointer_buffer_mark_set)
5238                 {
5239                   STD_OVERFLOW_CHECK(pStubMsg);
5240                   pStubMsg->PointerBufferMark = pStubMsg->Buffer;
5241                   pStubMsg->Buffer = saved_buffer + 4;
5242                 }
5243                 break;
5244             default:
5245                 m(pStubMsg, ppMemory, desc, fMustAlloc);
5246             }
5247         }
5248         else FIXME("no marshaller for embedded type %02x\n", *desc);
5249     }
5250     return NULL;
5251 }
5252
5253 static void union_arm_buffer_size(PMIDL_STUB_MESSAGE pStubMsg,
5254                                   unsigned char *pMemory,
5255                                   ULONG discriminant,
5256                                   PFORMAT_STRING pFormat)
5257 {
5258     unsigned short type;
5259
5260     pFormat += 2;
5261
5262     pFormat = get_arm_offset_from_union_arm_selector(pStubMsg, discriminant, pFormat);
5263     if(!pFormat)
5264         return;
5265
5266     type = *(const unsigned short*)pFormat;
5267     if((type & 0xff00) == 0x8000)
5268     {
5269         unsigned char basetype = LOBYTE(type);
5270         NdrBaseTypeBufferSize(pStubMsg, pMemory, &basetype);
5271     }
5272     else
5273     {
5274         PFORMAT_STRING desc = pFormat + *(const SHORT*)pFormat;
5275         NDR_BUFFERSIZE m = NdrBufferSizer[*desc & NDR_TABLE_MASK];
5276         if (m)
5277         {
5278             switch(*desc)
5279             {
5280             case RPC_FC_RP:
5281             case RPC_FC_UP:
5282             case RPC_FC_OP:
5283             case RPC_FC_FP:
5284                 ALIGN_LENGTH(pStubMsg->BufferLength, 4);
5285                 safe_buffer_length_increment(pStubMsg, 4); /* for pointer ID */
5286                 if (!pStubMsg->IgnoreEmbeddedPointers)
5287                 {
5288                     int saved_buffer_length = pStubMsg->BufferLength;
5289                     pStubMsg->BufferLength = pStubMsg->PointerLength;
5290                     pStubMsg->PointerLength = 0;
5291                     if(!pStubMsg->BufferLength)
5292                         ERR("BufferLength == 0??\n");
5293                     PointerBufferSize(pStubMsg, *(unsigned char **)pMemory, desc);
5294                     pStubMsg->PointerLength = pStubMsg->BufferLength;
5295                     pStubMsg->BufferLength = saved_buffer_length;
5296                 }
5297                 break;
5298             default:
5299                 m(pStubMsg, pMemory, desc);
5300             }
5301         }
5302         else FIXME("no buffersizer for embedded type %02x\n", *desc);
5303     }
5304 }
5305
5306 static ULONG union_arm_memory_size(PMIDL_STUB_MESSAGE pStubMsg,
5307                                    ULONG discriminant,
5308                                    PFORMAT_STRING pFormat)
5309 {
5310     unsigned short type, size;
5311
5312     size = *(const unsigned short*)pFormat;
5313     pStubMsg->Memory += size;
5314     pFormat += 2;
5315
5316     pFormat = get_arm_offset_from_union_arm_selector(pStubMsg, discriminant, pFormat);
5317     if(!pFormat)
5318         return 0;
5319
5320     type = *(const unsigned short*)pFormat;
5321     if((type & 0xff00) == 0x8000)
5322     {
5323         return NdrBaseTypeMemorySize(pStubMsg, pFormat);
5324     }
5325     else
5326     {
5327         PFORMAT_STRING desc = pFormat + *(const SHORT*)pFormat;
5328         NDR_MEMORYSIZE m = NdrMemorySizer[*desc & NDR_TABLE_MASK];
5329         unsigned char *saved_buffer;
5330         if (m)
5331         {
5332             switch(*desc)
5333             {
5334             case RPC_FC_RP:
5335             case RPC_FC_UP:
5336             case RPC_FC_OP:
5337             case RPC_FC_FP:
5338                 ALIGN_POINTER(pStubMsg->Buffer, 4);
5339                 saved_buffer = pStubMsg->Buffer;
5340                 safe_buffer_increment(pStubMsg, 4);
5341                 ALIGN_LENGTH(pStubMsg->MemorySize, 4);
5342                 pStubMsg->MemorySize += 4;
5343                 if (!pStubMsg->IgnoreEmbeddedPointers)
5344                     PointerMemorySize(pStubMsg, saved_buffer, pFormat);
5345                 break;
5346             default:
5347                 return m(pStubMsg, desc);
5348             }
5349         }
5350         else FIXME("no marshaller for embedded type %02x\n", *desc);
5351     }
5352
5353     TRACE("size %d\n", size);
5354     return size;
5355 }
5356
5357 static void union_arm_free(PMIDL_STUB_MESSAGE pStubMsg,
5358                            unsigned char *pMemory,
5359                            ULONG discriminant,
5360                            PFORMAT_STRING pFormat)
5361 {
5362     unsigned short type;
5363
5364     pFormat += 2;
5365
5366     pFormat = get_arm_offset_from_union_arm_selector(pStubMsg, discriminant, pFormat);
5367     if(!pFormat)
5368         return;
5369
5370     type = *(const unsigned short*)pFormat;
5371     if((type & 0xff00) != 0x8000)
5372     {
5373         PFORMAT_STRING desc = pFormat + *(const SHORT*)pFormat;
5374         NDR_FREE m = NdrFreer[*desc & NDR_TABLE_MASK];
5375         if (m)
5376         {
5377             switch(*desc)
5378             {
5379             case RPC_FC_RP:
5380             case RPC_FC_UP:
5381             case RPC_FC_OP:
5382             case RPC_FC_FP:
5383                 PointerFree(pStubMsg, *(unsigned char **)pMemory, desc);
5384                 break;
5385             default:
5386                 m(pStubMsg, pMemory, desc);
5387             }
5388         }
5389     }
5390 }
5391
5392 /***********************************************************************
5393  *           NdrEncapsulatedUnionMarshall [RPCRT4.@]
5394  */
5395 unsigned char *  WINAPI NdrEncapsulatedUnionMarshall(PMIDL_STUB_MESSAGE pStubMsg,
5396                                 unsigned char *pMemory,
5397                                 PFORMAT_STRING pFormat)
5398 {
5399     unsigned char switch_type;
5400     unsigned char increment;
5401     ULONG switch_value;
5402
5403     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5404     pFormat++;
5405
5406     switch_type = *pFormat & 0xf;
5407     increment = (*pFormat & 0xf0) >> 4;
5408     pFormat++;
5409
5410     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, increment);
5411
5412     switch_value = get_discriminant(switch_type, pMemory);
5413     TRACE("got switch value 0x%x\n", switch_value);
5414
5415     NdrBaseTypeMarshall(pStubMsg, pMemory, &switch_type);
5416     pMemory += increment;
5417
5418     return union_arm_marshall(pStubMsg, pMemory, switch_value, pFormat);
5419 }
5420
5421 /***********************************************************************
5422  *           NdrEncapsulatedUnionUnmarshall [RPCRT4.@]
5423  */
5424 unsigned char *  WINAPI NdrEncapsulatedUnionUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
5425                                 unsigned char **ppMemory,
5426                                 PFORMAT_STRING pFormat,
5427                                 unsigned char fMustAlloc)
5428 {
5429     unsigned char switch_type;
5430     unsigned char increment;
5431     ULONG switch_value;
5432     unsigned short size;
5433     unsigned char *pMemoryArm;
5434
5435     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
5436     pFormat++;
5437
5438     switch_type = *pFormat & 0xf;
5439     increment = (*pFormat & 0xf0) >> 4;
5440     pFormat++;
5441
5442     ALIGN_POINTER(pStubMsg->Buffer, increment);
5443     switch_value = get_discriminant(switch_type, pStubMsg->Buffer);
5444     TRACE("got switch value 0x%x\n", switch_value);
5445
5446     size = *(const unsigned short*)pFormat + increment;
5447     if(!*ppMemory || fMustAlloc)
5448         *ppMemory = NdrAllocate(pStubMsg, size);
5449
5450     NdrBaseTypeUnmarshall(pStubMsg, ppMemory, &switch_type, FALSE);
5451     pMemoryArm = *ppMemory + increment;
5452
5453     return union_arm_unmarshall(pStubMsg, &pMemoryArm, switch_value, pFormat, fMustAlloc);
5454 }
5455
5456 /***********************************************************************
5457  *           NdrEncapsulatedUnionBufferSize [RPCRT4.@]
5458  */
5459 void WINAPI NdrEncapsulatedUnionBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
5460                                 unsigned char *pMemory,
5461                                 PFORMAT_STRING pFormat)
5462 {
5463     unsigned char switch_type;
5464     unsigned char increment;
5465     ULONG switch_value;
5466
5467     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5468     pFormat++;
5469
5470     switch_type = *pFormat & 0xf;
5471     increment = (*pFormat & 0xf0) >> 4;
5472     pFormat++;
5473
5474     ALIGN_LENGTH(pStubMsg->BufferLength, increment);
5475     switch_value = get_discriminant(switch_type, pMemory);
5476     TRACE("got switch value 0x%x\n", switch_value);
5477
5478     /* Add discriminant size */
5479     NdrBaseTypeBufferSize(pStubMsg, (unsigned char *)&switch_value, &switch_type);
5480     pMemory += increment;
5481
5482     union_arm_buffer_size(pStubMsg, pMemory, switch_value, pFormat);
5483 }
5484
5485 /***********************************************************************
5486  *           NdrEncapsulatedUnionMemorySize [RPCRT4.@]
5487  */
5488 ULONG WINAPI NdrEncapsulatedUnionMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
5489                                 PFORMAT_STRING pFormat)
5490 {
5491     unsigned char switch_type;
5492     unsigned char increment;
5493     ULONG switch_value;
5494
5495     switch_type = *pFormat & 0xf;
5496     increment = (*pFormat & 0xf0) >> 4;
5497     pFormat++;
5498
5499     ALIGN_POINTER(pStubMsg->Buffer, increment);
5500     switch_value = get_discriminant(switch_type, pStubMsg->Buffer);
5501     TRACE("got switch value 0x%x\n", switch_value);
5502
5503     pStubMsg->Memory += increment;
5504
5505     return increment + union_arm_memory_size(pStubMsg, switch_value, pFormat + *(const SHORT*)pFormat);
5506 }
5507
5508 /***********************************************************************
5509  *           NdrEncapsulatedUnionFree [RPCRT4.@]
5510  */
5511 void WINAPI NdrEncapsulatedUnionFree(PMIDL_STUB_MESSAGE pStubMsg,
5512                                 unsigned char *pMemory,
5513                                 PFORMAT_STRING pFormat)
5514 {
5515     unsigned char switch_type;
5516     unsigned char increment;
5517     ULONG switch_value;
5518
5519     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5520     pFormat++;
5521
5522     switch_type = *pFormat & 0xf;
5523     increment = (*pFormat & 0xf0) >> 4;
5524     pFormat++;
5525
5526     switch_value = get_discriminant(switch_type, pMemory);
5527     TRACE("got switch value 0x%x\n", switch_value);
5528
5529     pMemory += increment;
5530
5531     union_arm_free(pStubMsg, pMemory, switch_value, pFormat);
5532 }
5533
5534 /***********************************************************************
5535  *           NdrNonEncapsulatedUnionMarshall [RPCRT4.@]
5536  */
5537 unsigned char *  WINAPI NdrNonEncapsulatedUnionMarshall(PMIDL_STUB_MESSAGE pStubMsg,
5538                                 unsigned char *pMemory,
5539                                 PFORMAT_STRING pFormat)
5540 {
5541     unsigned char switch_type;
5542
5543     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5544     pFormat++;
5545
5546     switch_type = *pFormat;
5547     pFormat++;
5548
5549     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, 0);
5550     TRACE("got switch value 0x%lx\n", pStubMsg->MaxCount);
5551     /* Marshall discriminant */
5552     NdrBaseTypeMarshall(pStubMsg, (unsigned char *)&pStubMsg->MaxCount, &switch_type);
5553
5554     return union_arm_marshall(pStubMsg, pMemory, pStubMsg->MaxCount, pFormat + *(const SHORT*)pFormat);
5555 }
5556
5557 static long unmarshall_discriminant(PMIDL_STUB_MESSAGE pStubMsg,
5558                                     PFORMAT_STRING *ppFormat)
5559 {
5560     long discriminant = 0;
5561
5562     switch(**ppFormat)
5563     {
5564     case RPC_FC_BYTE:
5565     case RPC_FC_CHAR:
5566     case RPC_FC_SMALL:
5567     case RPC_FC_USMALL:
5568     {
5569         UCHAR d;
5570         safe_copy_from_buffer(pStubMsg, &d, sizeof(d));
5571         discriminant = d;
5572         break;
5573     }
5574     case RPC_FC_WCHAR:
5575     case RPC_FC_SHORT:
5576     case RPC_FC_USHORT:
5577     {
5578         USHORT d;
5579         ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
5580         safe_copy_from_buffer(pStubMsg, &d, sizeof(d));
5581         discriminant = d;
5582         break;
5583     }
5584     case RPC_FC_LONG:
5585     case RPC_FC_ULONG:
5586     {
5587         ULONG d;
5588         ALIGN_POINTER(pStubMsg->Buffer, sizeof(ULONG));
5589         safe_copy_from_buffer(pStubMsg, &d, sizeof(d));
5590         discriminant = d;
5591         break;
5592     }
5593     default:
5594         FIXME("Unhandled base type: 0x%02x\n", **ppFormat);
5595     }
5596     (*ppFormat)++;
5597
5598     if (pStubMsg->fHasNewCorrDesc)
5599         *ppFormat += 6;
5600     else
5601         *ppFormat += 4;
5602     return discriminant;
5603 }
5604
5605 /**********************************************************************
5606  *           NdrNonEncapsulatedUnionUnmarshall [RPCRT4.@]
5607  */
5608 unsigned char *  WINAPI NdrNonEncapsulatedUnionUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
5609                                 unsigned char **ppMemory,
5610                                 PFORMAT_STRING pFormat,
5611                                 unsigned char fMustAlloc)
5612 {
5613     long discriminant;
5614     unsigned short size;
5615
5616     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
5617     pFormat++;
5618
5619     /* Unmarshall discriminant */
5620     discriminant = unmarshall_discriminant(pStubMsg, &pFormat);
5621     TRACE("unmarshalled discriminant %lx\n", discriminant);
5622
5623     pFormat += *(const SHORT*)pFormat;
5624
5625     size = *(const unsigned short*)pFormat;
5626
5627     if(!*ppMemory || fMustAlloc)
5628         *ppMemory = NdrAllocate(pStubMsg, size);
5629
5630     return union_arm_unmarshall(pStubMsg, ppMemory, discriminant, pFormat, fMustAlloc);
5631 }
5632
5633 /***********************************************************************
5634  *           NdrNonEncapsulatedUnionBufferSize [RPCRT4.@]
5635  */
5636 void WINAPI NdrNonEncapsulatedUnionBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
5637                                 unsigned char *pMemory,
5638                                 PFORMAT_STRING pFormat)
5639 {
5640     unsigned char switch_type;
5641
5642     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5643     pFormat++;
5644
5645     switch_type = *pFormat;
5646     pFormat++;
5647
5648     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, 0);
5649     TRACE("got switch value 0x%lx\n", pStubMsg->MaxCount);
5650     /* Add discriminant size */
5651     NdrBaseTypeBufferSize(pStubMsg, (unsigned char *)&pStubMsg->MaxCount, &switch_type);
5652
5653     union_arm_buffer_size(pStubMsg, pMemory, pStubMsg->MaxCount, pFormat + *(const SHORT*)pFormat);
5654 }
5655
5656 /***********************************************************************
5657  *           NdrNonEncapsulatedUnionMemorySize [RPCRT4.@]
5658  */
5659 ULONG WINAPI NdrNonEncapsulatedUnionMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
5660                                 PFORMAT_STRING pFormat)
5661 {
5662     ULONG discriminant;
5663
5664     pFormat++;
5665     /* Unmarshall discriminant */
5666     discriminant = unmarshall_discriminant(pStubMsg, &pFormat);
5667     TRACE("unmarshalled discriminant 0x%x\n", discriminant);
5668
5669     return union_arm_memory_size(pStubMsg, discriminant, pFormat + *(const SHORT*)pFormat);
5670 }
5671
5672 /***********************************************************************
5673  *           NdrNonEncapsulatedUnionFree [RPCRT4.@]
5674  */
5675 void WINAPI NdrNonEncapsulatedUnionFree(PMIDL_STUB_MESSAGE pStubMsg,
5676                                 unsigned char *pMemory,
5677                                 PFORMAT_STRING pFormat)
5678 {
5679     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
5680     pFormat++;
5681     pFormat++;
5682
5683     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, 0);
5684     TRACE("got switch value 0x%lx\n", pStubMsg->MaxCount);
5685
5686     union_arm_free(pStubMsg, pMemory, pStubMsg->MaxCount, pFormat + *(const SHORT*)pFormat);
5687 }
5688
5689 /***********************************************************************
5690  *           NdrByteCountPointerMarshall [RPCRT4.@]
5691  */
5692 unsigned char *  WINAPI NdrByteCountPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
5693                                 unsigned char *pMemory,
5694                                 PFORMAT_STRING pFormat)
5695 {
5696     FIXME("stub\n");
5697     return NULL;
5698 }
5699
5700 /***********************************************************************
5701  *           NdrByteCountPointerUnmarshall [RPCRT4.@]
5702  */
5703 unsigned char *  WINAPI NdrByteCountPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
5704                                 unsigned char **ppMemory,
5705                                 PFORMAT_STRING pFormat,
5706                                 unsigned char fMustAlloc)
5707 {
5708     FIXME("stub\n");
5709     return NULL;
5710 }
5711
5712 /***********************************************************************
5713  *           NdrByteCountPointerBufferSize [RPCRT4.@]
5714  */
5715 void WINAPI NdrByteCountPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
5716                                 unsigned char *pMemory,
5717                                 PFORMAT_STRING pFormat)
5718 {
5719     FIXME("stub\n");
5720 }
5721
5722 /***********************************************************************
5723  *           NdrByteCountPointerMemorySize [RPCRT4.@]
5724  */
5725 ULONG WINAPI NdrByteCountPointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
5726                                 PFORMAT_STRING pFormat)
5727 {
5728     FIXME("stub\n");
5729     return 0;
5730 }
5731
5732 /***********************************************************************
5733  *           NdrByteCountPointerFree [RPCRT4.@]
5734  */
5735 void WINAPI NdrByteCountPointerFree(PMIDL_STUB_MESSAGE pStubMsg,
5736                                 unsigned char *pMemory,
5737                                 PFORMAT_STRING pFormat)
5738 {
5739     FIXME("stub\n");
5740 }
5741
5742 /***********************************************************************
5743  *           NdrXmitOrRepAsMarshall [RPCRT4.@]
5744  */
5745 unsigned char *  WINAPI NdrXmitOrRepAsMarshall(PMIDL_STUB_MESSAGE pStubMsg,
5746                                 unsigned char *pMemory,
5747                                 PFORMAT_STRING pFormat)
5748 {
5749     FIXME("stub\n");
5750     return NULL;
5751 }
5752
5753 /***********************************************************************
5754  *           NdrXmitOrRepAsUnmarshall [RPCRT4.@]
5755  */
5756 unsigned char *  WINAPI NdrXmitOrRepAsUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
5757                                 unsigned char **ppMemory,
5758                                 PFORMAT_STRING pFormat,
5759                                 unsigned char fMustAlloc)
5760 {
5761     FIXME("stub\n");
5762     return NULL;
5763 }
5764
5765 /***********************************************************************
5766  *           NdrXmitOrRepAsBufferSize [RPCRT4.@]
5767  */
5768 void WINAPI NdrXmitOrRepAsBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
5769                                 unsigned char *pMemory,
5770                                 PFORMAT_STRING pFormat)
5771 {
5772     FIXME("stub\n");
5773 }
5774
5775 /***********************************************************************
5776  *           NdrXmitOrRepAsMemorySize [RPCRT4.@]
5777  */
5778 ULONG WINAPI NdrXmitOrRepAsMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
5779                                 PFORMAT_STRING pFormat)
5780 {
5781     FIXME("stub\n");
5782     return 0;
5783 }
5784
5785 /***********************************************************************
5786  *           NdrXmitOrRepAsFree [RPCRT4.@]
5787  */
5788 void WINAPI NdrXmitOrRepAsFree(PMIDL_STUB_MESSAGE pStubMsg,
5789                                 unsigned char *pMemory,
5790                                 PFORMAT_STRING pFormat)
5791 {
5792     FIXME("stub\n");
5793 }
5794
5795 #include "pshpack1.h"
5796 typedef struct
5797 {
5798     unsigned char type;
5799     unsigned char flags_type; /* flags in upper nibble, type in lower nibble */
5800     ULONG low_value;
5801     ULONG high_value;
5802 } NDR_RANGE;
5803 #include "poppack.h"
5804
5805 /***********************************************************************
5806  *           NdrRangeMarshall [internal]
5807  */
5808 unsigned char *WINAPI NdrRangeMarshall(
5809     PMIDL_STUB_MESSAGE pStubMsg,
5810     unsigned char *pMemory,
5811     PFORMAT_STRING pFormat)
5812 {
5813     NDR_RANGE *pRange = (NDR_RANGE *)pFormat;
5814     unsigned char base_type;
5815
5816     TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
5817
5818     if (pRange->type != RPC_FC_RANGE)
5819     {
5820         ERR("invalid format type %x\n", pRange->type);
5821         RpcRaiseException(RPC_S_INTERNAL_ERROR);
5822         return NULL;
5823     }
5824
5825     base_type = pRange->flags_type & 0xf;
5826
5827     return NdrBaseTypeMarshall(pStubMsg, pMemory, &base_type);
5828 }
5829
5830 /***********************************************************************
5831  *           NdrRangeUnmarshall
5832  */
5833 unsigned char *WINAPI NdrRangeUnmarshall(
5834     PMIDL_STUB_MESSAGE pStubMsg,
5835     unsigned char **ppMemory,
5836     PFORMAT_STRING pFormat,
5837     unsigned char fMustAlloc)
5838 {
5839     NDR_RANGE *pRange = (NDR_RANGE *)pFormat;
5840     unsigned char base_type;
5841
5842     TRACE("pStubMsg: %p, ppMemory: %p, type: 0x%02x, fMustAlloc: %s\n", pStubMsg, ppMemory, *pFormat, fMustAlloc ? "true" : "false");
5843
5844     if (pRange->type != RPC_FC_RANGE)
5845     {
5846         ERR("invalid format type %x\n", pRange->type);
5847         RpcRaiseException(RPC_S_INTERNAL_ERROR);
5848         return NULL;
5849     }
5850     base_type = pRange->flags_type & 0xf;
5851
5852     TRACE("base_type = 0x%02x, low_value = %d, high_value = %d\n",
5853         base_type, pRange->low_value, pRange->high_value);
5854
5855 #define RANGE_UNMARSHALL(type, format_spec) \
5856     do \
5857     { \
5858         ALIGN_POINTER(pStubMsg->Buffer, sizeof(type)); \
5859         if (fMustAlloc || !*ppMemory) \
5860             *ppMemory = NdrAllocate(pStubMsg, sizeof(type)); \
5861         if (pStubMsg->Buffer + sizeof(type) > pStubMsg->BufferEnd) \
5862         { \
5863             ERR("buffer overflow - Buffer = %p, BufferEnd = %p\n", \
5864                 pStubMsg->Buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength); \
5865             RpcRaiseException(RPC_X_BAD_STUB_DATA); \
5866         } \
5867         if ((*(type *)pStubMsg->Buffer < (type)pRange->low_value) || \
5868             (*(type *)pStubMsg->Buffer > (type)pRange->high_value)) \
5869         { \
5870             ERR("value exceeded bounds: " format_spec ", low: " format_spec ", high: " format_spec "\n", \
5871                 *(type *)pStubMsg->Buffer, (type)pRange->low_value, \
5872                 (type)pRange->high_value); \
5873             RpcRaiseException(RPC_S_INVALID_BOUND); \
5874             return NULL; \
5875         } \
5876         TRACE("*ppMemory: %p\n", *ppMemory); \
5877         **(type **)ppMemory = *(type *)pStubMsg->Buffer; \
5878         pStubMsg->Buffer += sizeof(type); \
5879     } while (0)
5880
5881     switch(base_type)
5882     {
5883     case RPC_FC_CHAR:
5884     case RPC_FC_SMALL:
5885         RANGE_UNMARSHALL(UCHAR, "%d");
5886         TRACE("value: 0x%02x\n", **ppMemory);
5887         break;
5888     case RPC_FC_BYTE:
5889     case RPC_FC_USMALL:
5890         RANGE_UNMARSHALL(CHAR, "%u");
5891         TRACE("value: 0x%02x\n", **ppMemory);
5892         break;
5893     case RPC_FC_WCHAR: /* FIXME: valid? */
5894     case RPC_FC_USHORT:
5895         RANGE_UNMARSHALL(USHORT, "%u");
5896         TRACE("value: 0x%04x\n", **(USHORT **)ppMemory);
5897         break;
5898     case RPC_FC_SHORT:
5899         RANGE_UNMARSHALL(SHORT, "%d");
5900         TRACE("value: 0x%04x\n", **(USHORT **)ppMemory);
5901         break;
5902     case RPC_FC_LONG:
5903         RANGE_UNMARSHALL(LONG, "%d");
5904         TRACE("value: 0x%08x\n", **(ULONG **)ppMemory);
5905         break;
5906     case RPC_FC_ULONG:
5907         RANGE_UNMARSHALL(ULONG, "%u");
5908         TRACE("value: 0x%08x\n", **(ULONG **)ppMemory);
5909         break;
5910     case RPC_FC_ENUM16:
5911     case RPC_FC_ENUM32:
5912         FIXME("Unhandled enum type\n");
5913         break;
5914     case RPC_FC_ERROR_STATUS_T: /* FIXME: valid? */
5915     case RPC_FC_FLOAT:
5916     case RPC_FC_DOUBLE:
5917     case RPC_FC_HYPER:
5918     default:
5919         ERR("invalid range base type: 0x%02x\n", base_type);
5920         RpcRaiseException(RPC_S_INTERNAL_ERROR);
5921     }
5922
5923     return NULL;
5924 }
5925
5926 /***********************************************************************
5927  *           NdrRangeBufferSize [internal]
5928  */
5929 void WINAPI NdrRangeBufferSize(
5930     PMIDL_STUB_MESSAGE pStubMsg,
5931     unsigned char *pMemory,
5932     PFORMAT_STRING pFormat)
5933 {
5934     NDR_RANGE *pRange = (NDR_RANGE *)pFormat;
5935     unsigned char base_type;
5936
5937     TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
5938
5939     if (pRange->type != RPC_FC_RANGE)
5940     {
5941         ERR("invalid format type %x\n", pRange->type);
5942         RpcRaiseException(RPC_S_INTERNAL_ERROR);
5943     }
5944     base_type = pRange->flags_type & 0xf;
5945
5946     NdrBaseTypeBufferSize(pStubMsg, pMemory, &base_type);
5947 }
5948
5949 /***********************************************************************
5950  *           NdrRangeMemorySize [internal]
5951  */
5952 ULONG WINAPI NdrRangeMemorySize(
5953     PMIDL_STUB_MESSAGE pStubMsg,
5954     PFORMAT_STRING pFormat)
5955 {
5956     NDR_RANGE *pRange = (NDR_RANGE *)pFormat;
5957     unsigned char base_type;
5958
5959     if (pRange->type != RPC_FC_RANGE)
5960     {
5961         ERR("invalid format type %x\n", pRange->type);
5962         RpcRaiseException(RPC_S_INTERNAL_ERROR);
5963         return 0;
5964     }
5965     base_type = pRange->flags_type & 0xf;
5966
5967     return NdrBaseTypeMemorySize(pStubMsg, &base_type);
5968 }
5969
5970 /***********************************************************************
5971  *           NdrRangeFree [internal]
5972  */
5973 void WINAPI NdrRangeFree(PMIDL_STUB_MESSAGE pStubMsg,
5974                                 unsigned char *pMemory,
5975                                 PFORMAT_STRING pFormat)
5976 {
5977    TRACE("pStubMsg %p pMemory %p type 0x%02x\n", pStubMsg, pMemory, *pFormat);
5978
5979    /* nothing to do */
5980 }
5981
5982 /***********************************************************************
5983  *           NdrBaseTypeMarshall [internal]
5984  */
5985 static unsigned char *WINAPI NdrBaseTypeMarshall(
5986     PMIDL_STUB_MESSAGE pStubMsg,
5987     unsigned char *pMemory,
5988     PFORMAT_STRING pFormat)
5989 {
5990     TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
5991
5992     switch(*pFormat)
5993     {
5994     case RPC_FC_BYTE:
5995     case RPC_FC_CHAR:
5996     case RPC_FC_SMALL:
5997     case RPC_FC_USMALL:
5998         safe_copy_to_buffer(pStubMsg, pMemory, sizeof(UCHAR));
5999         TRACE("value: 0x%02x\n", *pMemory);
6000         break;
6001     case RPC_FC_WCHAR:
6002     case RPC_FC_SHORT:
6003     case RPC_FC_USHORT:
6004         ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(USHORT));
6005         safe_copy_to_buffer(pStubMsg, pMemory, sizeof(USHORT));
6006         TRACE("value: 0x%04x\n", *(USHORT *)pMemory);
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         ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(ULONG));
6013         safe_copy_to_buffer(pStubMsg, pMemory, sizeof(ULONG));
6014         TRACE("value: 0x%08x\n", *(ULONG *)pMemory);
6015         break;
6016     case RPC_FC_FLOAT:
6017         ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(float));
6018         safe_copy_to_buffer(pStubMsg, pMemory, sizeof(float));
6019         break;
6020     case RPC_FC_DOUBLE:
6021         ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(double));
6022         safe_copy_to_buffer(pStubMsg, pMemory, sizeof(double));
6023         break;
6024     case RPC_FC_HYPER:
6025         ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(ULONGLONG));
6026         safe_copy_to_buffer(pStubMsg, pMemory, sizeof(ULONGLONG));
6027         TRACE("value: %s\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory));
6028         break;
6029     case RPC_FC_ENUM16:
6030         /* only 16-bits on the wire, so do a sanity check */
6031         if (*(UINT *)pMemory > SHRT_MAX)
6032             RpcRaiseException(RPC_X_ENUM_VALUE_OUT_OF_RANGE);
6033         ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(USHORT));
6034         if (pStubMsg->Buffer + sizeof(USHORT) > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
6035             RpcRaiseException(RPC_X_BAD_STUB_DATA);
6036         *(USHORT *)pStubMsg->Buffer = *(UINT *)pMemory;
6037         pStubMsg->Buffer += sizeof(USHORT);
6038         TRACE("value: 0x%04x\n", *(UINT *)pMemory);
6039         break;
6040     case RPC_FC_IGNORE:
6041         break;
6042     default:
6043         FIXME("Unhandled base type: 0x%02x\n", *pFormat);
6044     }
6045
6046     /* FIXME: what is the correct return value? */
6047     return NULL;
6048 }
6049
6050 /***********************************************************************
6051  *           NdrBaseTypeUnmarshall [internal]
6052  */
6053 static unsigned char *WINAPI NdrBaseTypeUnmarshall(
6054     PMIDL_STUB_MESSAGE pStubMsg,
6055     unsigned char **ppMemory,
6056     PFORMAT_STRING pFormat,
6057     unsigned char fMustAlloc)
6058 {
6059     TRACE("pStubMsg: %p, ppMemory: %p, type: 0x%02x, fMustAlloc: %s\n", pStubMsg, ppMemory, *pFormat, fMustAlloc ? "true" : "false");
6060
6061 #define BASE_TYPE_UNMARSHALL(type) \
6062         ALIGN_POINTER(pStubMsg->Buffer, sizeof(type)); \
6063         if (!fMustAlloc && !pStubMsg->IsClient && !*ppMemory) \
6064         { \
6065             *ppMemory = pStubMsg->Buffer; \
6066             TRACE("*ppMemory: %p\n", *ppMemory); \
6067         } \
6068         else \
6069         {  \
6070             if (fMustAlloc) \
6071                 *ppMemory = NdrAllocate(pStubMsg, sizeof(type)); \
6072             TRACE("*ppMemory: %p\n", *ppMemory); \
6073             **(type **)ppMemory = *(type *)pStubMsg->Buffer; \
6074         } \
6075         safe_buffer_increment(pStubMsg, sizeof(type));
6076
6077     switch(*pFormat)
6078     {
6079     case RPC_FC_BYTE:
6080     case RPC_FC_CHAR:
6081     case RPC_FC_SMALL:
6082     case RPC_FC_USMALL:
6083         BASE_TYPE_UNMARSHALL(UCHAR);
6084         TRACE("value: 0x%02x\n", **ppMemory);
6085         break;
6086     case RPC_FC_WCHAR:
6087     case RPC_FC_SHORT:
6088     case RPC_FC_USHORT:
6089         BASE_TYPE_UNMARSHALL(USHORT);
6090         TRACE("value: 0x%04x\n", **(USHORT **)ppMemory);
6091         break;
6092     case RPC_FC_LONG:
6093     case RPC_FC_ULONG:
6094     case RPC_FC_ERROR_STATUS_T:
6095     case RPC_FC_ENUM32:
6096         BASE_TYPE_UNMARSHALL(ULONG);
6097         TRACE("value: 0x%08x\n", **(ULONG **)ppMemory);
6098         break;
6099    case RPC_FC_FLOAT:
6100         BASE_TYPE_UNMARSHALL(float);
6101         TRACE("value: %f\n", **(float **)ppMemory);
6102         break;
6103     case RPC_FC_DOUBLE:
6104         BASE_TYPE_UNMARSHALL(double);
6105         TRACE("value: %f\n", **(double **)ppMemory);
6106         break;
6107     case RPC_FC_HYPER:
6108         BASE_TYPE_UNMARSHALL(ULONGLONG);
6109         TRACE("value: %s\n", wine_dbgstr_longlong(**(ULONGLONG **)ppMemory));
6110         break;
6111     case RPC_FC_ENUM16:
6112         ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
6113         if (fMustAlloc || !*ppMemory)
6114             *ppMemory = NdrAllocate(pStubMsg, sizeof(UINT));
6115         if (pStubMsg->Buffer + sizeof(USHORT) > pStubMsg->BufferEnd)
6116             RpcRaiseException(RPC_X_BAD_STUB_DATA);
6117         TRACE("*ppMemory: %p\n", *ppMemory);
6118         /* 16-bits on the wire, but int in memory */
6119         **(UINT **)ppMemory = *(USHORT *)pStubMsg->Buffer;
6120         pStubMsg->Buffer += sizeof(USHORT);
6121         TRACE("value: 0x%08x\n", **(UINT **)ppMemory);
6122         break;
6123     case RPC_FC_IGNORE:
6124         break;
6125     default:
6126         FIXME("Unhandled base type: 0x%02x\n", *pFormat);
6127     }
6128 #undef BASE_TYPE_UNMARSHALL
6129
6130     /* FIXME: what is the correct return value? */
6131
6132     return NULL;
6133 }
6134
6135 /***********************************************************************
6136  *           NdrBaseTypeBufferSize [internal]
6137  */
6138 static void WINAPI NdrBaseTypeBufferSize(
6139     PMIDL_STUB_MESSAGE pStubMsg,
6140     unsigned char *pMemory,
6141     PFORMAT_STRING pFormat)
6142 {
6143     TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
6144
6145     switch(*pFormat)
6146     {
6147     case RPC_FC_BYTE:
6148     case RPC_FC_CHAR:
6149     case RPC_FC_SMALL:
6150     case RPC_FC_USMALL:
6151         safe_buffer_length_increment(pStubMsg, sizeof(UCHAR));
6152         break;
6153     case RPC_FC_WCHAR:
6154     case RPC_FC_SHORT:
6155     case RPC_FC_USHORT:
6156     case RPC_FC_ENUM16:
6157         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(USHORT));
6158         safe_buffer_length_increment(pStubMsg, sizeof(USHORT));
6159         break;
6160     case RPC_FC_LONG:
6161     case RPC_FC_ULONG:
6162     case RPC_FC_ENUM32:
6163         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(ULONG));
6164         safe_buffer_length_increment(pStubMsg, sizeof(ULONG));
6165         break;
6166     case RPC_FC_FLOAT:
6167         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(float));
6168         safe_buffer_length_increment(pStubMsg, sizeof(float));
6169         break;
6170     case RPC_FC_DOUBLE:
6171         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(double));
6172         safe_buffer_length_increment(pStubMsg, sizeof(double));
6173         break;
6174     case RPC_FC_HYPER:
6175         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(ULONGLONG));
6176         safe_buffer_length_increment(pStubMsg, sizeof(ULONGLONG));
6177         break;
6178     case RPC_FC_ERROR_STATUS_T:
6179         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(error_status_t));
6180         safe_buffer_length_increment(pStubMsg, sizeof(error_status_t));
6181         break;
6182     case RPC_FC_IGNORE:
6183         break;
6184     default:
6185         FIXME("Unhandled base type: 0x%02x\n", *pFormat);
6186     }
6187 }
6188
6189 /***********************************************************************
6190  *           NdrBaseTypeMemorySize [internal]
6191  */
6192 static ULONG WINAPI NdrBaseTypeMemorySize(
6193     PMIDL_STUB_MESSAGE pStubMsg,
6194     PFORMAT_STRING pFormat)
6195 {
6196     TRACE("pStubMsg %p, type 0x%02x\n", pStubMsg, *pFormat);
6197
6198     switch(*pFormat)
6199     {
6200     case RPC_FC_BYTE:
6201     case RPC_FC_CHAR:
6202     case RPC_FC_SMALL:
6203     case RPC_FC_USMALL:
6204         safe_buffer_increment(pStubMsg, sizeof(UCHAR));
6205         pStubMsg->MemorySize += sizeof(UCHAR);
6206         return sizeof(UCHAR);
6207     case RPC_FC_WCHAR:
6208     case RPC_FC_SHORT:
6209     case RPC_FC_USHORT:
6210         safe_buffer_increment(pStubMsg, sizeof(USHORT));
6211         pStubMsg->MemorySize += sizeof(USHORT);
6212         return sizeof(USHORT);
6213     case RPC_FC_LONG:
6214     case RPC_FC_ULONG:
6215     case RPC_FC_ENUM32:
6216         safe_buffer_increment(pStubMsg, sizeof(ULONG));
6217         pStubMsg->MemorySize += sizeof(ULONG);
6218         return sizeof(ULONG);
6219     case RPC_FC_FLOAT:
6220         safe_buffer_increment(pStubMsg, sizeof(float));
6221         pStubMsg->MemorySize += sizeof(float);
6222         return sizeof(float);
6223     case RPC_FC_DOUBLE:
6224         safe_buffer_increment(pStubMsg, sizeof(double));
6225         pStubMsg->MemorySize += sizeof(double);
6226         return sizeof(double);
6227     case RPC_FC_HYPER:
6228         safe_buffer_increment(pStubMsg, sizeof(ULONGLONG));
6229         pStubMsg->MemorySize += sizeof(ULONGLONG);
6230         return sizeof(ULONGLONG);
6231     case RPC_FC_ERROR_STATUS_T:
6232         safe_buffer_increment(pStubMsg, sizeof(error_status_t));
6233         pStubMsg->MemorySize += sizeof(error_status_t);
6234         return sizeof(error_status_t);
6235     case RPC_FC_ENUM16:
6236         safe_buffer_increment(pStubMsg, sizeof(USHORT));
6237         pStubMsg->MemorySize += sizeof(UINT);
6238         return sizeof(UINT);
6239     case RPC_FC_IGNORE:
6240         pStubMsg->MemorySize += sizeof(void *);
6241         return sizeof(void *);
6242     default:
6243         FIXME("Unhandled base type: 0x%02x\n", *pFormat);
6244        return 0;
6245     }
6246 }
6247
6248 /***********************************************************************
6249  *           NdrBaseTypeFree [internal]
6250  */
6251 static void WINAPI NdrBaseTypeFree(PMIDL_STUB_MESSAGE pStubMsg,
6252                                 unsigned char *pMemory,
6253                                 PFORMAT_STRING pFormat)
6254 {
6255    TRACE("pStubMsg %p pMemory %p type 0x%02x\n", pStubMsg, pMemory, *pFormat);
6256
6257    /* nothing to do */
6258 }
6259
6260 /***********************************************************************
6261  *           NdrContextHandleBufferSize [internal]
6262  */
6263 static void WINAPI NdrContextHandleBufferSize(
6264     PMIDL_STUB_MESSAGE pStubMsg,
6265     unsigned char *pMemory,
6266     PFORMAT_STRING pFormat)
6267 {
6268     TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
6269
6270     if (*pFormat != RPC_FC_BIND_CONTEXT)
6271     {
6272         ERR("invalid format type %x\n", *pFormat);
6273         RpcRaiseException(RPC_S_INTERNAL_ERROR);
6274     }
6275     ALIGN_LENGTH(pStubMsg->BufferLength, 4);
6276     safe_buffer_length_increment(pStubMsg, cbNDRContext);
6277 }
6278
6279 /***********************************************************************
6280  *           NdrContextHandleMarshall [internal]
6281  */
6282 static unsigned char *WINAPI NdrContextHandleMarshall(
6283     PMIDL_STUB_MESSAGE pStubMsg,
6284     unsigned char *pMemory,
6285     PFORMAT_STRING pFormat)
6286 {
6287     TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
6288
6289     if (*pFormat != RPC_FC_BIND_CONTEXT)
6290     {
6291         ERR("invalid format type %x\n", *pFormat);
6292         RpcRaiseException(RPC_S_INTERNAL_ERROR);
6293     }
6294     TRACE("flags: 0x%02x\n", pFormat[1]);
6295
6296     if (pFormat[1] & 0x80)
6297         NdrClientContextMarshall(pStubMsg, *(NDR_CCONTEXT **)pMemory, FALSE);
6298     else
6299         NdrClientContextMarshall(pStubMsg, (NDR_CCONTEXT *)pMemory, FALSE);
6300
6301     return NULL;
6302 }
6303
6304 /***********************************************************************
6305  *           NdrContextHandleUnmarshall [internal]
6306  */
6307 static unsigned char *WINAPI NdrContextHandleUnmarshall(
6308     PMIDL_STUB_MESSAGE pStubMsg,
6309     unsigned char **ppMemory,
6310     PFORMAT_STRING pFormat,
6311     unsigned char fMustAlloc)
6312 {
6313     TRACE("pStubMsg %p, ppMemory %p, pFormat %p, fMustAlloc %s\n", pStubMsg,
6314         ppMemory, pFormat, fMustAlloc ? "TRUE": "FALSE");
6315
6316     if (*pFormat != RPC_FC_BIND_CONTEXT)
6317     {
6318         ERR("invalid format type %x\n", *pFormat);
6319         RpcRaiseException(RPC_S_INTERNAL_ERROR);
6320     }
6321     TRACE("flags: 0x%02x\n", pFormat[1]);
6322
6323     /* [out]-only or [ret] param */
6324     if ((pFormat[1] & 0x60) == 0x20)
6325         **(NDR_CCONTEXT **)ppMemory = NULL;
6326     NdrClientContextUnmarshall(pStubMsg, *(NDR_CCONTEXT **)ppMemory, pStubMsg->RpcMsg->Handle);
6327
6328     return NULL;
6329 }
6330
6331 /***********************************************************************
6332  *           NdrClientContextMarshall [RPCRT4.@]
6333  */
6334 void WINAPI NdrClientContextMarshall(PMIDL_STUB_MESSAGE pStubMsg,
6335                                      NDR_CCONTEXT ContextHandle,
6336                                      int fCheck)
6337 {
6338     TRACE("(%p, %p, %d)\n", pStubMsg, ContextHandle, fCheck);
6339
6340     ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
6341
6342     if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
6343     {
6344         ERR("buffer overflow - Buffer = %p, BufferEnd = %p\n",
6345             pStubMsg->Buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength);
6346         RpcRaiseException(RPC_X_BAD_STUB_DATA);
6347     }
6348
6349     /* FIXME: what does fCheck do? */
6350     NDRCContextMarshall(ContextHandle,
6351                         pStubMsg->Buffer);
6352
6353     pStubMsg->Buffer += cbNDRContext;
6354 }
6355
6356 /***********************************************************************
6357  *           NdrClientContextUnmarshall [RPCRT4.@]
6358  */
6359 void WINAPI NdrClientContextUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
6360                                        NDR_CCONTEXT * pContextHandle,
6361                                        RPC_BINDING_HANDLE BindHandle)
6362 {
6363     TRACE("(%p, %p, %p)\n", pStubMsg, pContextHandle, BindHandle);
6364
6365     ALIGN_POINTER(pStubMsg->Buffer, 4);
6366
6367     if (pStubMsg->Buffer + cbNDRContext > pStubMsg->BufferEnd)
6368         RpcRaiseException(RPC_X_BAD_STUB_DATA);
6369
6370     NDRCContextUnmarshall(pContextHandle,
6371                           BindHandle,
6372                           pStubMsg->Buffer,
6373                           pStubMsg->RpcMsg->DataRepresentation);
6374
6375     pStubMsg->Buffer += cbNDRContext;
6376 }
6377
6378 void WINAPI NdrServerContextMarshall(PMIDL_STUB_MESSAGE pStubMsg,
6379                                      NDR_SCONTEXT ContextHandle,
6380                                      NDR_RUNDOWN RundownRoutine )
6381 {
6382     TRACE("(%p, %p, %p)\n", pStubMsg, ContextHandle, RundownRoutine);
6383
6384     ALIGN_POINTER(pStubMsg->Buffer, 4);
6385
6386     if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
6387     {
6388         ERR("buffer overflow - Buffer = %p, BufferEnd = %p\n",
6389             pStubMsg->Buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength);
6390         RpcRaiseException(RPC_X_BAD_STUB_DATA);
6391     }
6392
6393     NDRSContextMarshall2(pStubMsg->RpcMsg->Handle, ContextHandle,
6394                          pStubMsg->Buffer, RundownRoutine, NULL,
6395                          RPC_CONTEXT_HANDLE_DEFAULT_FLAGS);
6396     pStubMsg->Buffer += cbNDRContext;
6397 }
6398
6399 NDR_SCONTEXT WINAPI NdrServerContextUnmarshall(PMIDL_STUB_MESSAGE pStubMsg)
6400 {
6401     NDR_SCONTEXT ContextHandle;
6402
6403     TRACE("(%p)\n", pStubMsg);
6404
6405     ALIGN_POINTER(pStubMsg->Buffer, 4);
6406
6407     if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
6408     {
6409         ERR("buffer overflow - Buffer = %p, BufferEnd = %p\n",
6410             pStubMsg->Buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength);
6411         RpcRaiseException(RPC_X_BAD_STUB_DATA);
6412     }
6413
6414     ContextHandle = NDRSContextUnmarshall2(pStubMsg->RpcMsg->Handle,
6415                                            pStubMsg->Buffer,
6416                                            pStubMsg->RpcMsg->DataRepresentation,
6417                                            NULL, RPC_CONTEXT_HANDLE_DEFAULT_FLAGS);
6418     pStubMsg->Buffer += cbNDRContext;
6419
6420     return ContextHandle;
6421 }
6422
6423 void WINAPI NdrContextHandleSize(PMIDL_STUB_MESSAGE pStubMsg,
6424                                  unsigned char* pMemory,
6425                                  PFORMAT_STRING pFormat)
6426 {
6427     FIXME("(%p, %p, %p): stub\n", pStubMsg, pMemory, pFormat);
6428 }
6429
6430 NDR_SCONTEXT WINAPI NdrContextHandleInitialize(PMIDL_STUB_MESSAGE pStubMsg,
6431                                                PFORMAT_STRING pFormat)
6432 {
6433     RPC_SYNTAX_IDENTIFIER *if_id = NULL;
6434     ULONG flags = RPC_CONTEXT_HANDLE_DEFAULT_FLAGS;
6435
6436     TRACE("(%p, %p)\n", pStubMsg, pFormat);
6437
6438     if (pFormat[1] & NDR_CONTEXT_HANDLE_SERIALIZE)
6439         flags |= RPC_CONTEXT_HANDLE_SERIALIZE;
6440     if (pFormat[1] & NDR_CONTEXT_HANDLE_NO_SERIALIZE)
6441         flags |= RPC_CONTEXT_HANDLE_DONT_SERIALIZE;
6442     if (pFormat[1] & NDR_STRICT_CONTEXT_HANDLE)
6443     {
6444         RPC_SERVER_INTERFACE *sif = pStubMsg->StubDesc->RpcInterfaceInformation;
6445         if_id = &sif->InterfaceId;
6446     }
6447
6448     return NDRSContextUnmarshall2(pStubMsg->RpcMsg->Handle, NULL,
6449                                   pStubMsg->RpcMsg->DataRepresentation, if_id,
6450                                   flags);
6451 }
6452
6453 void WINAPI NdrServerContextNewMarshall(PMIDL_STUB_MESSAGE pStubMsg,
6454                                         NDR_SCONTEXT ContextHandle,
6455                                         NDR_RUNDOWN RundownRoutine,
6456                                         PFORMAT_STRING pFormat)
6457 {
6458     RPC_SYNTAX_IDENTIFIER *if_id = NULL;
6459     ULONG flags = RPC_CONTEXT_HANDLE_DEFAULT_FLAGS;
6460
6461     TRACE("(%p, %p, %p, %p)\n", pStubMsg, ContextHandle, RundownRoutine, pFormat);
6462
6463     ALIGN_POINTER(pStubMsg->Buffer, 4);
6464
6465     if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
6466     {
6467         ERR("buffer overflow - Buffer = %p, BufferEnd = %p\n",
6468             pStubMsg->Buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength);
6469         RpcRaiseException(RPC_X_BAD_STUB_DATA);
6470     }
6471
6472     if (pFormat[1] & NDR_CONTEXT_HANDLE_SERIALIZE)
6473         flags |= RPC_CONTEXT_HANDLE_SERIALIZE;
6474     if (pFormat[1] & NDR_CONTEXT_HANDLE_NO_SERIALIZE)
6475         flags |= RPC_CONTEXT_HANDLE_DONT_SERIALIZE;
6476     if (pFormat[1] & NDR_STRICT_CONTEXT_HANDLE)
6477     {
6478         RPC_SERVER_INTERFACE *sif = pStubMsg->StubDesc->RpcInterfaceInformation;
6479         if_id = &sif->InterfaceId;
6480     }
6481
6482     NDRSContextMarshall2(pStubMsg->RpcMsg->Handle, ContextHandle,
6483                           pStubMsg->Buffer, RundownRoutine, if_id, flags);
6484     pStubMsg->Buffer += cbNDRContext;
6485 }
6486
6487 NDR_SCONTEXT WINAPI NdrServerContextNewUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
6488                                                   PFORMAT_STRING pFormat)
6489 {
6490     NDR_SCONTEXT ContextHandle;
6491     RPC_SYNTAX_IDENTIFIER *if_id = NULL;
6492     ULONG flags = RPC_CONTEXT_HANDLE_DEFAULT_FLAGS;
6493
6494     TRACE("(%p, %p)\n", pStubMsg, pFormat);
6495
6496     ALIGN_POINTER(pStubMsg->Buffer, 4);
6497
6498     if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
6499     {
6500         ERR("buffer overflow - Buffer = %p, BufferEnd = %p\n",
6501             pStubMsg->Buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength);
6502         RpcRaiseException(RPC_X_BAD_STUB_DATA);
6503     }
6504
6505     if (pFormat[1] & NDR_CONTEXT_HANDLE_SERIALIZE)
6506         flags |= RPC_CONTEXT_HANDLE_SERIALIZE;
6507     if (pFormat[1] & NDR_CONTEXT_HANDLE_NO_SERIALIZE)
6508         flags |= RPC_CONTEXT_HANDLE_DONT_SERIALIZE;
6509     if (pFormat[1] & NDR_STRICT_CONTEXT_HANDLE)
6510     {
6511         RPC_SERVER_INTERFACE *sif = pStubMsg->StubDesc->RpcInterfaceInformation;
6512         if_id = &sif->InterfaceId;
6513     }
6514
6515     ContextHandle = NDRSContextUnmarshall2(pStubMsg->RpcMsg->Handle,
6516                                            pStubMsg->Buffer,
6517                                            pStubMsg->RpcMsg->DataRepresentation,
6518                                            if_id, flags);
6519     pStubMsg->Buffer += cbNDRContext;
6520
6521     return ContextHandle;
6522 }
6523
6524 /***********************************************************************
6525  *           NdrCorrelationInitialize [RPCRT4.@]
6526  *
6527  * Initializes correlation validity checking.
6528  *
6529  * PARAMS
6530  *  pStubMsg    [I] MIDL_STUB_MESSAGE used during unmarshalling.
6531  *  pMemory     [I] Pointer to memory to use as a cache.
6532  *  CacheSize   [I] Size of the memory pointed to by pMemory.
6533  *  Flags       [I] Reserved. Set to zero.
6534  *
6535  * RETURNS
6536  *  Nothing.
6537  */
6538 void WINAPI NdrCorrelationInitialize(PMIDL_STUB_MESSAGE pStubMsg, void *pMemory, ULONG CacheSize, ULONG Flags)
6539 {
6540     FIXME("(%p, %p, %d, 0x%x): stub\n", pStubMsg, pMemory, CacheSize, Flags);
6541     pStubMsg->fHasNewCorrDesc = TRUE;
6542 }
6543
6544 /***********************************************************************
6545  *           NdrCorrelationPass [RPCRT4.@]
6546  *
6547  * Performs correlation validity checking.
6548  *
6549  * PARAMS
6550  *  pStubMsg    [I] MIDL_STUB_MESSAGE used during unmarshalling.
6551  *
6552  * RETURNS
6553  *  Nothing.
6554  */
6555 void WINAPI NdrCorrelationPass(PMIDL_STUB_MESSAGE pStubMsg)
6556 {
6557     FIXME("(%p): stub\n", pStubMsg);
6558 }
6559
6560 /***********************************************************************
6561  *           NdrCorrelationFree [RPCRT4.@]
6562  *
6563  * Frees any resources used while unmarshalling parameters that need
6564  * correlation validity checking.
6565  *
6566  * PARAMS
6567  *  pStubMsg    [I] MIDL_STUB_MESSAGE used during unmarshalling.
6568  *
6569  * RETURNS
6570  *  Nothing.
6571  */
6572 void WINAPI NdrCorrelationFree(PMIDL_STUB_MESSAGE pStubMsg)
6573 {
6574     FIXME("(%p): stub\n", pStubMsg);
6575 }