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  *  - Non-conformant strings
  23  *  - String structs
  24  *  - Encapsulated unions
  25  *  - Byte count pointers
  26  *  - transmit_as/represent as
  27  *  - Multi-dimensional arrays
  28  *  - Conversion functions (NdrConvert)
  29  *  - Checks for integer addition overflow
  30  *  - Checks for out-of-memory conditions
  31  */
  32
  33 #include <stdarg.h>
  34 #include <stdio.h>
  35 #include <string.h>
  36 #include <assert.h>
  37 #include <limits.h>
  38
  39 #include "windef.h"
  40 #include "winbase.h"
  41 #include "winerror.h"
  42 #include "winreg.h"
  43
  44 #include "ndr_misc.h"
  45 #include "rpcndr.h"
  46
  47 #include "wine/unicode.h"
  48 #include "wine/rpcfc.h"
  49
  50 #include "wine/debug.h"
  51 #include "wine/list.h"
  52
  53 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  54
  55 #if defined(__i386__)
  56 # define LITTLE_ENDIAN_UINT32_WRITE(pchar, uint32) \
  57     (*((UINT32 *)(pchar)) = (uint32))
  58
  59 # define LITTLE_ENDIAN_UINT32_READ(pchar) \
  60     (*((UINT32 *)(pchar)))
  61 #else
  62   /* these would work for i386 too, but less efficient */
  63 # define LITTLE_ENDIAN_UINT32_WRITE(pchar, uint32) \
  64     (*(pchar)     = LOBYTE(LOWORD(uint32)), \
  65      *((pchar)+1) = HIBYTE(LOWORD(uint32)), \
  66      *((pchar)+2) = LOBYTE(HIWORD(uint32)), \
  67      *((pchar)+3) = HIBYTE(HIWORD(uint32)), \
  68      (uint32)) /* allow as r-value */
  69
  70 # define LITTLE_ENDIAN_UINT32_READ(pchar) \
  71     (MAKELONG( \
  72       MAKEWORD(*(pchar), *((pchar)+1)), \
  73       MAKEWORD(*((pchar)+2), *((pchar)+3))))
  74 #endif
  75
  76 #define BIG_ENDIAN_UINT32_WRITE(pchar, uint32) \
  77   (*((pchar)+3) = LOBYTE(LOWORD(uint32)), \
  78    *((pchar)+2) = HIBYTE(LOWORD(uint32)), \
  79    *((pchar)+1) = LOBYTE(HIWORD(uint32)), \
  80    *(pchar)     = HIBYTE(HIWORD(uint32)), \
  81    (uint32)) /* allow as r-value */
  82
  83 #define BIG_ENDIAN_UINT32_READ(pchar) \
  84   (MAKELONG( \
  85     MAKEWORD(*((pchar)+3), *((pchar)+2)), \
  86     MAKEWORD(*((pchar)+1), *(pchar))))
  87
  88 #ifdef NDR_LOCAL_IS_BIG_ENDIAN
  89 # define NDR_LOCAL_UINT32_WRITE(pchar, uint32) \
  90     BIG_ENDIAN_UINT32_WRITE(pchar, uint32)
  91 # define NDR_LOCAL_UINT32_READ(pchar) \
  92     BIG_ENDIAN_UINT32_READ(pchar)
  93 #else
  94 # define NDR_LOCAL_UINT32_WRITE(pchar, uint32) \
  95     LITTLE_ENDIAN_UINT32_WRITE(pchar, uint32)
  96 # define NDR_LOCAL_UINT32_READ(pchar) \
  97     LITTLE_ENDIAN_UINT32_READ(pchar)
  98 #endif
  99
 100 /* _Align must be the desired alignment,
 101  * e.g. ALIGN_LENGTH(len, 4) to align on a dword boundary. */
 102 #define ALIGNED_LENGTH(_Len, _Align) (((_Len)+(_Align)-1)&~((_Align)-1))
 103 #define ALIGNED_POINTER(_Ptr, _Align) ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
 104 #define ALIGN_LENGTH(_Len, _Align) _Len = ALIGNED_LENGTH(_Len, _Align)
 105 #define ALIGN_POINTER(_Ptr, _Align) _Ptr = ALIGNED_POINTER(_Ptr, _Align)
 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 const NDR_MARSHALL NdrMarshaller[NDR_TABLE_SIZE] = {
 123   0,
 124   NdrBaseTypeMarshall, NdrBaseTypeMarshall, NdrBaseTypeMarshall,
 125   NdrBaseTypeMarshall, NdrBaseTypeMarshall, NdrBaseTypeMarshall, NdrBaseTypeMarshall,
 126   NdrBaseTypeMarshall, NdrBaseTypeMarshall, NdrBaseTypeMarshall, NdrBaseTypeMarshall,
 127   NdrBaseTypeMarshall, NdrBaseTypeMarshall, NdrBaseTypeMarshall, NdrBaseTypeMarshall,
 128   /* 0x10 */
 129   NdrBaseTypeMarshall,
 130   /* 0x11 */
 131   NdrPointerMarshall, NdrPointerMarshall,
 132   NdrPointerMarshall, NdrPointerMarshall,
 133   /* 0x15 */
 134   NdrSimpleStructMarshall, NdrSimpleStructMarshall,
 135   NdrConformantStructMarshall, NdrConformantStructMarshall,
 136   NdrConformantVaryingStructMarshall,
 137   NdrComplexStructMarshall,
 138   /* 0x1b */
 139   NdrConformantArrayMarshall,
 140   NdrConformantVaryingArrayMarshall,
 141   NdrFixedArrayMarshall, NdrFixedArrayMarshall,
 142   NdrVaryingArrayMarshall, NdrVaryingArrayMarshall,
 143   NdrComplexArrayMarshall,
 144   /* 0x22 */
 145   NdrConformantStringMarshall, 0, 0,
 146   NdrConformantStringMarshall,
 147   NdrNonConformantStringMarshall, 0, 0, 0,
 148   /* 0x2a */
 149   NdrEncapsulatedUnionMarshall,
 150   NdrNonEncapsulatedUnionMarshall,
 151   NdrByteCountPointerMarshall,
 152   NdrXmitOrRepAsMarshall, NdrXmitOrRepAsMarshall,
 153   /* 0x2f */
 154   NdrInterfacePointerMarshall,
 155   /* 0xb0 */
 156   0, 0, 0, 0,
 157   NdrUserMarshalMarshall
 158 };
 159 const NDR_UNMARSHALL NdrUnmarshaller[NDR_TABLE_SIZE] = {
 160   0,
 161   NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall,
 162   NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall,
 163   NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall,
 164   NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall, NdrBaseTypeUnmarshall,
 165   /* 0x10 */
 166   NdrBaseTypeUnmarshall,
 167   /* 0x11 */
 168   NdrPointerUnmarshall, NdrPointerUnmarshall,
 169   NdrPointerUnmarshall, NdrPointerUnmarshall,
 170   /* 0x15 */
 171   NdrSimpleStructUnmarshall, NdrSimpleStructUnmarshall,
 172   NdrConformantStructUnmarshall, NdrConformantStructUnmarshall,
 173   NdrConformantVaryingStructUnmarshall,
 174   NdrComplexStructUnmarshall,
 175   /* 0x1b */
 176   NdrConformantArrayUnmarshall,
 177   NdrConformantVaryingArrayUnmarshall,
 178   NdrFixedArrayUnmarshall, NdrFixedArrayUnmarshall,
 179   NdrVaryingArrayUnmarshall, NdrVaryingArrayUnmarshall,
 180   NdrComplexArrayUnmarshall,
 181   /* 0x22 */
 182   NdrConformantStringUnmarshall, 0, 0,
 183   NdrConformantStringUnmarshall,
 184   NdrNonConformantStringUnmarshall, 0, 0, 0,
 185   /* 0x2a */
 186   NdrEncapsulatedUnionUnmarshall,
 187   NdrNonEncapsulatedUnionUnmarshall,
 188   NdrByteCountPointerUnmarshall,
 189   NdrXmitOrRepAsUnmarshall, NdrXmitOrRepAsUnmarshall,
 190   /* 0x2f */
 191   NdrInterfacePointerUnmarshall,
 192   /* 0xb0 */
 193   0, 0, 0, 0,
 194   NdrUserMarshalUnmarshall
 195 };
 196 const NDR_BUFFERSIZE NdrBufferSizer[NDR_TABLE_SIZE] = {
 197   0,
 198   NdrBaseTypeBufferSize, NdrBaseTypeBufferSize, NdrBaseTypeBufferSize,
 199   NdrBaseTypeBufferSize, NdrBaseTypeBufferSize, NdrBaseTypeBufferSize, NdrBaseTypeBufferSize,
 200   NdrBaseTypeBufferSize, NdrBaseTypeBufferSize, NdrBaseTypeBufferSize, NdrBaseTypeBufferSize,
 201   NdrBaseTypeBufferSize, NdrBaseTypeBufferSize, NdrBaseTypeBufferSize, NdrBaseTypeBufferSize,
 202   /* 0x10 */
 203   NdrBaseTypeBufferSize,
 204   /* 0x11 */
 205   NdrPointerBufferSize, NdrPointerBufferSize,
 206   NdrPointerBufferSize, NdrPointerBufferSize,
 207   /* 0x15 */
 208   NdrSimpleStructBufferSize, NdrSimpleStructBufferSize,
 209   NdrConformantStructBufferSize, NdrConformantStructBufferSize,
 210   NdrConformantVaryingStructBufferSize,
 211   NdrComplexStructBufferSize,
 212   /* 0x1b */
 213   NdrConformantArrayBufferSize,
 214   NdrConformantVaryingArrayBufferSize,
 215   NdrFixedArrayBufferSize, NdrFixedArrayBufferSize,
 216   NdrVaryingArrayBufferSize, NdrVaryingArrayBufferSize,
 217   NdrComplexArrayBufferSize,
 218   /* 0x22 */
 219   NdrConformantStringBufferSize, 0, 0,
 220   NdrConformantStringBufferSize,
 221   NdrNonConformantStringBufferSize, 0, 0, 0,
 222   /* 0x2a */
 223   NdrEncapsulatedUnionBufferSize,
 224   NdrNonEncapsulatedUnionBufferSize,
 225   NdrByteCountPointerBufferSize,
 226   NdrXmitOrRepAsBufferSize, NdrXmitOrRepAsBufferSize,
 227   /* 0x2f */
 228   NdrInterfacePointerBufferSize,
 229   /* 0xb0 */
 230   0, 0, 0, 0,
 231   NdrUserMarshalBufferSize
 232 };
 233 const NDR_MEMORYSIZE NdrMemorySizer[NDR_TABLE_SIZE] = {
 234   0,
 235   NdrBaseTypeMemorySize, NdrBaseTypeMemorySize, NdrBaseTypeMemorySize,
 236   NdrBaseTypeMemorySize, NdrBaseTypeMemorySize, NdrBaseTypeMemorySize, NdrBaseTypeMemorySize,
 237   NdrBaseTypeMemorySize, NdrBaseTypeMemorySize, NdrBaseTypeMemorySize, NdrBaseTypeMemorySize,
 238   NdrBaseTypeMemorySize, NdrBaseTypeMemorySize, NdrBaseTypeMemorySize, NdrBaseTypeMemorySize,
 239   /* 0x10 */
 240   NdrBaseTypeMemorySize,
 241   /* 0x11 */
 242   NdrPointerMemorySize, NdrPointerMemorySize,
 243   NdrPointerMemorySize, NdrPointerMemorySize,
 244   /* 0x15 */
 245   NdrSimpleStructMemorySize, NdrSimpleStructMemorySize,
 246   NdrConformantStructMemorySize, NdrConformantStructMemorySize,
 247   NdrConformantVaryingStructMemorySize,
 248   NdrComplexStructMemorySize,
 249   /* 0x1b */
 250   NdrConformantArrayMemorySize,
 251   NdrConformantVaryingArrayMemorySize,
 252   NdrFixedArrayMemorySize, NdrFixedArrayMemorySize,
 253   NdrVaryingArrayMemorySize, NdrVaryingArrayMemorySize,
 254   NdrComplexArrayMemorySize,
 255   /* 0x22 */
 256   NdrConformantStringMemorySize, 0, 0,
 257   NdrConformantStringMemorySize,
 258   NdrNonConformantStringMemorySize, 0, 0, 0,
 259   /* 0x2a */
 260   NdrEncapsulatedUnionMemorySize,
 261   NdrNonEncapsulatedUnionMemorySize,
 262   NdrByteCountPointerMemorySize,
 263   NdrXmitOrRepAsMemorySize, NdrXmitOrRepAsMemorySize,
 264   /* 0x2f */
 265   NdrInterfacePointerMemorySize,
 266   /* 0xb0 */
 267   0, 0, 0, 0,
 268   NdrUserMarshalMemorySize
 269 };
 270 const NDR_FREE NdrFreer[NDR_TABLE_SIZE] = {
 271   0,
 272   NdrBaseTypeFree, NdrBaseTypeFree, NdrBaseTypeFree,
 273   NdrBaseTypeFree, NdrBaseTypeFree, NdrBaseTypeFree, NdrBaseTypeFree,
 274   NdrBaseTypeFree, NdrBaseTypeFree, NdrBaseTypeFree, NdrBaseTypeFree,
 275   NdrBaseTypeFree, NdrBaseTypeFree, NdrBaseTypeFree, NdrBaseTypeFree,
 276   /* 0x10 */
 277   NdrBaseTypeFree,
 278   /* 0x11 */
 279   NdrPointerFree, NdrPointerFree,
 280   NdrPointerFree, NdrPointerFree,
 281   /* 0x15 */
 282   NdrSimpleStructFree, NdrSimpleStructFree,
 283   NdrConformantStructFree, NdrConformantStructFree,
 284   NdrConformantVaryingStructFree,
 285   NdrComplexStructFree,
 286   /* 0x1b */
 287   NdrConformantArrayFree,
 288   NdrConformantVaryingArrayFree,
 289   NdrFixedArrayFree, NdrFixedArrayFree,
 290   NdrVaryingArrayFree, NdrVaryingArrayFree,
 291   NdrComplexArrayFree,
 292   /* 0x22 */
 293   0, 0, 0,
 294   0, 0, 0, 0, 0,
 295   /* 0x2a */
 296   NdrEncapsulatedUnionFree,
 297   NdrNonEncapsulatedUnionFree,
 298   0,
 299   NdrXmitOrRepAsFree, NdrXmitOrRepAsFree,
 300   /* 0x2f */
 301   NdrInterfacePointerFree,
 302   /* 0xb0 */
 303   0, 0, 0, 0,
 304   NdrUserMarshalFree
 305 };
 306
 307 void * WINAPI NdrAllocate(MIDL_STUB_MESSAGE *pStubMsg, size_t len)
 308 {
 309   /* hmm, this is probably supposed to do more? */
 310   return pStubMsg->pfnAllocate(len);
 311 }
 312
 313 static void WINAPI NdrFree(MIDL_STUB_MESSAGE *pStubMsg, unsigned char *Pointer)
 314 {
 315   pStubMsg->pfnFree(Pointer);
 316 }
 317
 318 static inline BOOL IsConformanceOrVariancePresent(PFORMAT_STRING pFormat)
 319 {
 320     return (*(const ULONG *)pFormat != -1);
 321 }
 322
 323 static PFORMAT_STRING ReadConformance(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat)
 324 {
 325   ALIGN_POINTER(pStubMsg->Buffer, 4);
 326   pStubMsg->MaxCount = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer);
 327   pStubMsg->Buffer += 4;
 328   TRACE("unmarshalled conformance is %ld\n", pStubMsg->MaxCount);
 329   if (pStubMsg->fHasNewCorrDesc)
 330     return pFormat+6;
 331   else
 332     return pFormat+4;
 333 }
 334
 335 static inline PFORMAT_STRING ReadVariance(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat, ULONG MaxValue)
 336 {
 337   if (pFormat && !IsConformanceOrVariancePresent(pFormat))
 338   {
 339     pStubMsg->Offset = 0;
 340     pStubMsg->ActualCount = pStubMsg->MaxCount;
 341     goto done;
 342   }
 343
 344   ALIGN_POINTER(pStubMsg->Buffer, 4);
 345   pStubMsg->Offset      = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer);
 346   pStubMsg->Buffer += 4;
 347   TRACE("offset is %d\n", pStubMsg->Offset);
 348   pStubMsg->ActualCount = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer);
 349   pStubMsg->Buffer += 4;
 350   TRACE("variance is %d\n", pStubMsg->ActualCount);
 351
 352   if ((pStubMsg->ActualCount > MaxValue) ||
 353       (pStubMsg->ActualCount + pStubMsg->Offset > MaxValue))
 354   {
 355     ERR("invalid array bound(s): ActualCount = %d, Offset = %d, MaxValue = %d\n",
 356         pStubMsg->ActualCount, pStubMsg->Offset, MaxValue);
 357     RpcRaiseException(RPC_S_INVALID_BOUND);
 358     return NULL;
 359   }
 360
 361 done:
 362   if (pStubMsg->fHasNewCorrDesc)
 363     return pFormat+6;
 364   else
 365     return pFormat+4;
 366 }
 367
 368 /* writes the conformance value to the buffer */
 369 static inline void WriteConformance(MIDL_STUB_MESSAGE *pStubMsg)
 370 {
 371     ALIGN_POINTER(pStubMsg->Buffer, 4);
 372     NDR_LOCAL_UINT32_WRITE(pStubMsg->Buffer, pStubMsg->MaxCount);
 373     pStubMsg->Buffer += 4;
 374 }
 375
 376 /* writes the variance values to the buffer */
 377 static inline void WriteVariance(MIDL_STUB_MESSAGE *pStubMsg)
 378 {
 379     ALIGN_POINTER(pStubMsg->Buffer, 4);
 380     NDR_LOCAL_UINT32_WRITE(pStubMsg->Buffer, pStubMsg->Offset);
 381     pStubMsg->Buffer += 4;
 382     NDR_LOCAL_UINT32_WRITE(pStubMsg->Buffer, pStubMsg->ActualCount);
 383     pStubMsg->Buffer += 4;
 384 }
 385
 386 /* requests buffer space for the conformance value */
 387 static inline void SizeConformance(MIDL_STUB_MESSAGE *pStubMsg)
 388 {
 389     ALIGN_LENGTH(pStubMsg->BufferLength, 4);
 390     pStubMsg->BufferLength += 4;
 391 }
 392
 393 /* requests buffer space for the variance values */
 394 static inline void SizeVariance(MIDL_STUB_MESSAGE *pStubMsg)
 395 {
 396     ALIGN_LENGTH(pStubMsg->BufferLength, 4);
 397     pStubMsg->BufferLength += 8;
 398 }
 399
 400 PFORMAT_STRING ComputeConformanceOrVariance(
 401     MIDL_STUB_MESSAGE *pStubMsg, unsigned char *pMemory,
 402     PFORMAT_STRING pFormat, ULONG_PTR def, ULONG_PTR *pCount)
 403 {
 404   BYTE dtype = pFormat[0] & 0xf;
 405   short ofs = *(const short *)&pFormat[2];
 406   LPVOID ptr = NULL;
 407   DWORD data = 0;
 408
 409   if (!IsConformanceOrVariancePresent(pFormat)) {
 410     /* null descriptor */
 411     *pCount = def;
 412     goto finish_conf;
 413   }
 414
 415   switch (pFormat[0] & 0xf0) {
 416   case RPC_FC_NORMAL_CONFORMANCE:
 417     TRACE("normal conformance, ofs=%d\n", ofs);
 418     ptr = pMemory;
 419     break;
 420   case RPC_FC_POINTER_CONFORMANCE:
 421     TRACE("pointer conformance, ofs=%d\n", ofs);
 422     ptr = pStubMsg->Memory;
 423     break;
 424   case RPC_FC_TOP_LEVEL_CONFORMANCE:
 425     TRACE("toplevel conformance, ofs=%d\n", ofs);
 426     if (pStubMsg->StackTop) {
 427       ptr = pStubMsg->StackTop;
 428     }
 429     else {
 430       /* -Os mode, *pCount is already set */
 431       goto finish_conf;
 432     }
 433     break;
 434   case RPC_FC_CONSTANT_CONFORMANCE:
 435     data = ofs | ((DWORD)pFormat[1] << 16);
 436     TRACE("constant conformance, val=%d\n", data);
 437     *pCount = data;
 438     goto finish_conf;
 439   case RPC_FC_TOP_LEVEL_MULTID_CONFORMANCE:
 440     FIXME("toplevel multidimensional conformance, ofs=%d\n", ofs);
 441     if (pStubMsg->StackTop) {
 442       ptr = pStubMsg->StackTop;
 443     }
 444     else {
 445       /* ? */
 446       goto done_conf_grab;
 447     }
 448     break;
 449   default:
 450     FIXME("unknown conformance type %x\n", pFormat[0] & 0xf0);
 451   }
 452
 453   switch (pFormat[1]) {
 454   case RPC_FC_DEREFERENCE:
 455     ptr = *(LPVOID*)((char *)ptr + ofs);
 456     break;
 457   case RPC_FC_CALLBACK:
 458   {
 459     unsigned char *old_stack_top = pStubMsg->StackTop;
 460     pStubMsg->StackTop = ptr;
 461
 462     /* ofs is index into StubDesc->apfnExprEval */
 463     TRACE("callback conformance into apfnExprEval[%d]\n", ofs);
 464     pStubMsg->StubDesc->apfnExprEval[ofs](pStubMsg);
 465
 466     pStubMsg->StackTop = old_stack_top;
 467
 468     /* the callback function always stores the computed value in MaxCount */
 469     *pCount = pStubMsg->MaxCount;
 470     goto finish_conf;
 471   }
 472   default:
 473     ptr = (char *)ptr + ofs;
 474     break;
 475   }
 476
 477   switch (dtype) {
 478   case RPC_FC_LONG:
 479   case RPC_FC_ULONG:
 480     data = *(DWORD*)ptr;
 481     break;
 482   case RPC_FC_SHORT:
 483     data = *(SHORT*)ptr;
 484     break;
 485   case RPC_FC_USHORT:
 486     data = *(USHORT*)ptr;
 487     break;
 488   case RPC_FC_CHAR:
 489   case RPC_FC_SMALL:
 490     data = *(CHAR*)ptr;
 491     break;
 492   case RPC_FC_BYTE:
 493   case RPC_FC_USMALL:
 494     data = *(UCHAR*)ptr;
 495     break;
 496   default:
 497     FIXME("unknown conformance data type %x\n", dtype);
 498     goto done_conf_grab;
 499   }
 500   TRACE("dereferenced data type %x at %p, got %d\n", dtype, ptr, data);
 501
 502 done_conf_grab:
 503   switch (pFormat[1]) {
 504   case RPC_FC_DEREFERENCE: /* already handled */
 505   case 0: /* no op */
 506     *pCount = data;
 507     break;
 508   case RPC_FC_ADD_1:
 509     *pCount = data + 1;
 510     break;
 511   case RPC_FC_SUB_1:
 512     *pCount = data - 1;
 513     break;
 514   case RPC_FC_MULT_2:
 515     *pCount = data * 2;
 516     break;
 517   case RPC_FC_DIV_2:
 518     *pCount = data / 2;
 519     break;
 520   default:
 521     FIXME("unknown conformance op %d\n", pFormat[1]);
 522     goto finish_conf;
 523   }
 524
 525 finish_conf:
 526   TRACE("resulting conformance is %ld\n", *pCount);
 527   if (pStubMsg->fHasNewCorrDesc)
 528     return pFormat+6;
 529   else
 530     return pFormat+4;
 531 }
 532
 533 /* multiply two numbers together, raising an RPC_S_INVALID_BOUND exception if
 534  * the result overflows 32-bits */
 535 inline static ULONG safe_multiply(ULONG a, ULONG b)
 536 {
 537     ULONGLONG ret = (ULONGLONG)a * b;
 538     if (ret > 0xffffffff)
 539     {
 540         RpcRaiseException(RPC_S_INVALID_BOUND);
 541         return 0;
 542     }
 543     return ret;
 544 }
 545
 546
 547 /*
 548  * NdrConformantString:
 549  *
 550  * What MS calls a ConformantString is, in DCE terminology,
 551  * a Varying-Conformant String.
 552  * [
 553  *   maxlen: DWORD (max # of CHARTYPE characters, inclusive of '\0')
 554  *   offset: DWORD (actual string data begins at (offset) CHARTYPE's
 555  *           into unmarshalled string)
 556  *   length: DWORD (# of CHARTYPE characters, inclusive of '\0')
 557  *   [
 558  *     data: CHARTYPE[maxlen]
 559  *   ]
 560  * ], where CHARTYPE is the appropriate character type (specified externally)
 561  *
 562  */
 563
 564 /***********************************************************************
 565  *            NdrConformantStringMarshall [RPCRT4.@]
 566  */
 567 unsigned char *WINAPI NdrConformantStringMarshall(MIDL_STUB_MESSAGE *pStubMsg,
 568   unsigned char *pszMessage, PFORMAT_STRING pFormat)
 569 {
 570   ULONG esize, size;
 571
 572   TRACE("(pStubMsg == ^%p, pszMessage == ^%p, pFormat == ^%p)\n", pStubMsg, pszMessage, pFormat);
 573
 574   if (*pFormat == RPC_FC_C_CSTRING) {
 575     TRACE("string=%s\n", debugstr_a((char*)pszMessage));
 576     pStubMsg->ActualCount = strlen((char*)pszMessage)+1;
 577     esize = 1;
 578   }
 579   else if (*pFormat == RPC_FC_C_WSTRING) {
 580     TRACE("string=%s\n", debugstr_w((LPWSTR)pszMessage));
 581     pStubMsg->ActualCount = strlenW((LPWSTR)pszMessage)+1;
 582     esize = 2;
 583   }
 584   else {
 585     ERR("Unhandled string type: %#x\n", *pFormat);
 586     /* FIXME: raise an exception. */
 587     return NULL;
 588   }
 589
 590   if (pFormat[1] == RPC_FC_STRING_SIZED)
 591     pFormat = ComputeConformance(pStubMsg, pszMessage, pFormat + 2, 0);
 592   else
 593     pStubMsg->MaxCount = pStubMsg->ActualCount;
 594   pStubMsg->Offset = 0;
 595   WriteConformance(pStubMsg);
 596   WriteVariance(pStubMsg);
 597
 598   size = safe_multiply(esize, pStubMsg->ActualCount);
 599   memcpy(pStubMsg->Buffer, pszMessage, size); /* the string itself */
 600   pStubMsg->Buffer += size;
 601
 602   STD_OVERFLOW_CHECK(pStubMsg);
 603
 604   /* success */
 605   return NULL; /* is this always right? */
 606 }
 607
 608 /***********************************************************************
 609  *           NdrConformantStringBufferSize [RPCRT4.@]
 610  */
 611 void WINAPI NdrConformantStringBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
 612   unsigned char* pMemory, PFORMAT_STRING pFormat)
 613 {
 614   ULONG esize;
 615
 616   TRACE("(pStubMsg == ^%p, pMemory == ^%p, pFormat == ^%p)\n", pStubMsg, pMemory, pFormat);
 617
 618   SizeConformance(pStubMsg);
 619   SizeVariance(pStubMsg);
 620
 621   if (*pFormat == RPC_FC_C_CSTRING) {
 622     TRACE("string=%s\n", debugstr_a((char*)pMemory));
 623     pStubMsg->ActualCount = strlen((char*)pMemory)+1;
 624     esize = 1;
 625   }
 626   else if (*pFormat == RPC_FC_C_WSTRING) {
 627     TRACE("string=%s\n", debugstr_w((LPWSTR)pMemory));
 628     pStubMsg->ActualCount = strlenW((LPWSTR)pMemory)+1;
 629     esize = 2;
 630   }
 631   else {
 632     ERR("Unhandled string type: %#x\n", *pFormat);
 633     /* FIXME: raise an exception */
 634     return;
 635   }
 636
 637   if (pFormat[1] == RPC_FC_STRING_SIZED)
 638     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 2, 0);
 639   else
 640     pStubMsg->MaxCount = pStubMsg->ActualCount;
 641
 642   pStubMsg->BufferLength += safe_multiply(esize, pStubMsg->ActualCount);
 643 }
 644
 645 /************************************************************************
 646  *            NdrConformantStringMemorySize [RPCRT4.@]
 647  */
 648 ULONG WINAPI NdrConformantStringMemorySize( PMIDL_STUB_MESSAGE pStubMsg,
 649   PFORMAT_STRING pFormat )
 650 {
 651   ULONG rslt = 0;
 652
 653   FIXME("(pStubMsg == ^%p, pFormat == ^%p)\n", pStubMsg, pFormat);
 654
 655   assert(pStubMsg && pFormat);
 656
 657   if (*pFormat == RPC_FC_C_CSTRING) {
 658     rslt = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer); /* maxlen */
 659   }
 660   else if (*pFormat == RPC_FC_C_WSTRING) {
 661     rslt = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer)*2; /* maxlen */
 662   }
 663   else {
 664     ERR("Unhandled string type: %#x\n", *pFormat);
 665     /* FIXME: raise an exception */
 666   }
 667
 668   if (pFormat[1] != RPC_FC_PAD) {
 669     FIXME("sized string format=%d\n", pFormat[1]);
 670   }
 671
 672   TRACE("  --> %u\n", rslt);
 673   return rslt;
 674 }
 675
 676 /************************************************************************
 677  *           NdrConformantStringUnmarshall [RPCRT4.@]
 678  */
 679 unsigned char *WINAPI NdrConformantStringUnmarshall( PMIDL_STUB_MESSAGE pStubMsg,
 680   unsigned char** ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc )
 681 {
 682   ULONG bufsize, memsize, esize, i;
 683
 684   TRACE("(pStubMsg == ^%p, *pMemory == ^%p, pFormat == ^%p, fMustAlloc == %u)\n",
 685     pStubMsg, *ppMemory, pFormat, fMustAlloc);
 686
 687   assert(pFormat && ppMemory && pStubMsg);
 688
 689   ReadConformance(pStubMsg, NULL);
 690   ReadVariance(pStubMsg, NULL, pStubMsg->MaxCount);
 691
 692   if (*pFormat == RPC_FC_C_CSTRING) esize = 1;
 693   else if (*pFormat == RPC_FC_C_WSTRING) esize = 2;
 694   else {
 695     ERR("Unhandled string type: %#x\n", *pFormat);
 696     /* FIXME: raise an exception */
 697     esize = 0;
 698   }
 699
 700   memsize = safe_multiply(esize, pStubMsg->MaxCount);
 701   bufsize = safe_multiply(esize, pStubMsg->ActualCount);
 702
 703   /* strings must always have null terminating bytes */
 704   if (bufsize < esize)
 705   {
 706     ERR("invalid string length of %d\n", pStubMsg->ActualCount);
 707     RpcRaiseException(RPC_S_INVALID_BOUND);
 708     return NULL;
 709   }
 710   for (i = bufsize - esize; i < bufsize; i++)
 711     if (pStubMsg->Buffer[i] != 0)
 712     {
 713       ERR("string not null-terminated at byte position %d, data is 0x%x\n",
 714         i, pStubMsg->Buffer[i]);
 715       RpcRaiseException(RPC_S_INVALID_BOUND);
 716       return NULL;
 717     }
 718
 719   if (fMustAlloc || !*ppMemory)
 720     *ppMemory = NdrAllocate(pStubMsg, memsize);
 721
 722   memcpy(*ppMemory, pStubMsg->Buffer, bufsize);
 723
 724   pStubMsg->Buffer += bufsize;
 725
 726   if (*pFormat == RPC_FC_C_CSTRING) {
 727     TRACE("string=%s\n", debugstr_a((char*)*ppMemory));
 728   }
 729   else if (*pFormat == RPC_FC_C_WSTRING) {
 730     TRACE("string=%s\n", debugstr_w((LPWSTR)*ppMemory));
 731   }
 732
 733   return NULL; /* FIXME: is this always right? */
 734 }
 735
 736 /***********************************************************************
 737  *           NdrNonConformantStringMarshall [RPCRT4.@]
 738  */
 739 unsigned char *  WINAPI NdrNonConformantStringMarshall(PMIDL_STUB_MESSAGE pStubMsg,
 740                                 unsigned char *pMemory,
 741                                 PFORMAT_STRING pFormat)
 742 {
 743     FIXME("stub\n");
 744     return NULL;
 745 }
 746
 747 /***********************************************************************
 748  *           NdrNonConformantStringUnmarshall [RPCRT4.@]
 749  */
 750 unsigned char *  WINAPI NdrNonConformantStringUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
 751                                 unsigned char **ppMemory,
 752                                 PFORMAT_STRING pFormat,
 753                                 unsigned char fMustAlloc)
 754 {
 755     FIXME("stub\n");
 756     return NULL;
 757 }
 758
 759 /***********************************************************************
 760  *           NdrNonConformantStringBufferSize [RPCRT4.@]
 761  */
 762 void WINAPI NdrNonConformantStringBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
 763                                 unsigned char *pMemory,
 764                                 PFORMAT_STRING pFormat)
 765 {
 766     FIXME("stub\n");
 767 }
 768
 769 /***********************************************************************
 770  *           NdrNonConformantStringMemorySize [RPCRT4.@]
 771  */
 772 ULONG WINAPI NdrNonConformantStringMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
 773                                 PFORMAT_STRING pFormat)
 774 {
 775     FIXME("stub\n");
 776     return 0;
 777 }
 778
 779 static inline void dump_pointer_attr(unsigned char attr)
 780 {
 781     if (attr & RPC_FC_P_ALLOCALLNODES)
 782         TRACE(" RPC_FC_P_ALLOCALLNODES");
 783     if (attr & RPC_FC_P_DONTFREE)
 784         TRACE(" RPC_FC_P_DONTFREE");
 785     if (attr & RPC_FC_P_ONSTACK)
 786         TRACE(" RPC_FC_P_ONSTACK");
 787     if (attr & RPC_FC_P_SIMPLEPOINTER)
 788         TRACE(" RPC_FC_P_SIMPLEPOINTER");
 789     if (attr & RPC_FC_P_DEREF)
 790         TRACE(" RPC_FC_P_DEREF");
 791     TRACE("\n");
 792 }
 793
 794 /***********************************************************************
 795  *           PointerMarshall [internal]
 796  */
 797 static void PointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
 798                             unsigned char *Buffer,
 799                             unsigned char *Pointer,
 800                             PFORMAT_STRING pFormat)
 801 {
 802   unsigned type = pFormat[0], attr = pFormat[1];
 803   PFORMAT_STRING desc;
 804   NDR_MARSHALL m;
 805   ULONG pointer_id;
 806   int pointer_needs_marshaling;
 807
 808   TRACE("(%p,%p,%p,%p)\n", pStubMsg, Buffer, Pointer, pFormat);
 809   TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
 810   pFormat += 2;
 811   if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
 812   else desc = pFormat + *(const SHORT*)pFormat;
 813
 814   switch (type) {
 815   case RPC_FC_RP: /* ref pointer (always non-null) */
 816 #if 0 /* this causes problems for InstallShield so is disabled - we need more tests */
 817     if (!Pointer)
 818       RpcRaiseException(RPC_X_NULL_REF_POINTER);
 819 #endif
 820     pointer_needs_marshaling = 1;
 821     break;
 822   case RPC_FC_UP: /* unique pointer */
 823   case RPC_FC_OP: /* object pointer - same as unique here */
 824     if (Pointer)
 825       pointer_needs_marshaling = 1;
 826     else
 827       pointer_needs_marshaling = 0;
 828     pointer_id = (ULONG)Pointer;
 829     TRACE("writing 0x%08x to buffer\n", pointer_id);
 830     NDR_LOCAL_UINT32_WRITE(Buffer, pointer_id);
 831     break;
 832   case RPC_FC_FP:
 833     pointer_needs_marshaling = !NdrFullPointerQueryPointer(
 834       pStubMsg->FullPtrXlatTables, Pointer, 1, &pointer_id);
 835     TRACE("writing 0x%08x to buffer\n", pointer_id);
 836     NDR_LOCAL_UINT32_WRITE(Buffer, pointer_id);
 837     break;
 838   default:
 839     FIXME("unhandled ptr type=%02x\n", type);
 840     RpcRaiseException(RPC_X_BAD_STUB_DATA);
 841     return;
 842   }
 843
 844   TRACE("calling marshaller for type 0x%x\n", (int)*desc);
 845
 846   if (pointer_needs_marshaling) {
 847     if (attr & RPC_FC_P_DEREF) {
 848       Pointer = *(unsigned char**)Pointer;
 849       TRACE("deref => %p\n", Pointer);
 850     }
 851     m = NdrMarshaller[*desc & NDR_TABLE_MASK];
 852     if (m) m(pStubMsg, Pointer, desc);
 853     else FIXME("no marshaller for data type=%02x\n", *desc);
 854   }
 855
 856   STD_OVERFLOW_CHECK(pStubMsg);
 857 }
 858
 859 /***********************************************************************
 860  *           PointerUnmarshall [internal]
 861  */
 862 static void PointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
 863                               unsigned char *Buffer,
 864                               unsigned char **pPointer,
 865                               PFORMAT_STRING pFormat,
 866                               unsigned char fMustAlloc)
 867 {
 868   unsigned type = pFormat[0], attr = pFormat[1];
 869   PFORMAT_STRING desc;
 870   NDR_UNMARSHALL m;
 871   DWORD pointer_id = 0;
 872   int pointer_needs_unmarshaling;
 873
 874   TRACE("(%p,%p,%p,%p,%d)\n", pStubMsg, Buffer, pPointer, pFormat, fMustAlloc);
 875   TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
 876   pFormat += 2;
 877   if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
 878   else desc = pFormat + *(const SHORT*)pFormat;
 879
 880   switch (type) {
 881   case RPC_FC_RP: /* ref pointer (always non-null) */
 882     pointer_needs_unmarshaling = 1;
 883     break;
 884   case RPC_FC_UP: /* unique pointer */
 885     pointer_id = NDR_LOCAL_UINT32_READ(Buffer);
 886     TRACE("pointer_id is 0x%08x\n", pointer_id);
 887     if (pointer_id)
 888       pointer_needs_unmarshaling = 1;
 889     else {
 890       *pPointer = NULL;
 891       pointer_needs_unmarshaling = 0;
 892     }
 893     break;
 894   case RPC_FC_OP: /* object pointer - we must free data before overwriting it */
 895     pointer_id = NDR_LOCAL_UINT32_READ(Buffer);
 896     TRACE("pointer_id is 0x%08x\n", pointer_id);
 897     if (!fMustAlloc && *pPointer)
 898     {
 899         FIXME("free object pointer %p\n", *pPointer);
 900         *pPointer = NULL;
 901     }
 902     if (pointer_id)
 903       pointer_needs_unmarshaling = 1;
 904     else
 905       pointer_needs_unmarshaling = 0;
 906     break;
 907   case RPC_FC_FP:
 908     pointer_id = NDR_LOCAL_UINT32_READ(Buffer);
 909     TRACE("pointer_id is 0x%08x\n", pointer_id);
 910     pointer_needs_unmarshaling = !NdrFullPointerQueryRefId(
 911       pStubMsg->FullPtrXlatTables, pointer_id, 1, (void **)pPointer);
 912     break;
 913   default:
 914     FIXME("unhandled ptr type=%02x\n", type);
 915     RpcRaiseException(RPC_X_BAD_STUB_DATA);
 916     return;
 917   }
 918
 919   if (pointer_needs_unmarshaling) {
 920     if (attr & RPC_FC_P_DEREF) {
 921       if (!*pPointer || fMustAlloc)
 922         *pPointer = NdrAllocate(pStubMsg, sizeof(void *));
 923       pPointer = *(unsigned char***)pPointer;
 924       TRACE("deref => %p\n", pPointer);
 925     }
 926     m = NdrUnmarshaller[*desc & NDR_TABLE_MASK];
 927     if (m) m(pStubMsg, pPointer, desc, fMustAlloc);
 928     else FIXME("no unmarshaller for data type=%02x\n", *desc);
 929
 930     if (type == RPC_FC_FP)
 931       NdrFullPointerInsertRefId(pStubMsg->FullPtrXlatTables, pointer_id,
 932                                 *pPointer);
 933   }
 934
 935   TRACE("pointer=%p\n", *pPointer);
 936 }
 937
 938 /***********************************************************************
 939  *           PointerBufferSize [internal]
 940  */
 941 static void PointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
 942                               unsigned char *Pointer,
 943                               PFORMAT_STRING pFormat)
 944 {
 945   unsigned type = pFormat[0], attr = pFormat[1];
 946   PFORMAT_STRING desc;
 947   NDR_BUFFERSIZE m;
 948   int pointer_needs_sizing;
 949   ULONG pointer_id;
 950
 951   TRACE("(%p,%p,%p)\n", pStubMsg, Pointer, pFormat);
 952   TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
 953   pFormat += 2;
 954   if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
 955   else desc = pFormat + *(const SHORT*)pFormat;
 956
 957   switch (type) {
 958   case RPC_FC_RP: /* ref pointer (always non-null) */
 959     break;
 960   case RPC_FC_OP:
 961   case RPC_FC_UP:
 962     /* NULL pointer has no further representation */
 963     if (!Pointer)
 964         return;
 965     break;
 966   case RPC_FC_FP:
 967     pointer_needs_sizing = !NdrFullPointerQueryPointer(
 968       pStubMsg->FullPtrXlatTables, Pointer, 0, &pointer_id);
 969     if (!pointer_needs_sizing)
 970       return;
 971     break;
 972   default:
 973     FIXME("unhandled ptr type=%02x\n", type);
 974     RpcRaiseException(RPC_X_BAD_STUB_DATA);
 975     return;
 976   }
 977
 978   if (attr & RPC_FC_P_DEREF) {
 979     Pointer = *(unsigned char**)Pointer;
 980     TRACE("deref => %p\n", Pointer);
 981   }
 982
 983   m = NdrBufferSizer[*desc & NDR_TABLE_MASK];
 984   if (m) m(pStubMsg, Pointer, desc);
 985   else FIXME("no buffersizer for data type=%02x\n", *desc);
 986 }
 987
 988 /***********************************************************************
 989  *           PointerMemorySize [internal]
 990  */
 991 static unsigned long PointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
 992                                        unsigned char *Buffer,
 993                                        PFORMAT_STRING pFormat)
 994 {
 995   unsigned type = pFormat[0], attr = pFormat[1];
 996   PFORMAT_STRING desc;
 997   NDR_MEMORYSIZE m;
 998
 999   FIXME("(%p,%p,%p): stub\n", pStubMsg, Buffer, pFormat);
1000   TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
1001   pFormat += 2;
1002   if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
1003   else desc = pFormat + *(const SHORT*)pFormat;
1004
1005   switch (type) {
1006   case RPC_FC_RP: /* ref pointer (always non-null) */
1007     break;
1008   default:
1009     FIXME("unhandled ptr type=%02x\n", type);
1010     RpcRaiseException(RPC_X_BAD_STUB_DATA);
1011   }
1012
1013   if (attr & RPC_FC_P_DEREF) {
1014     TRACE("deref\n");
1015   }
1016
1017   m = NdrMemorySizer[*desc & NDR_TABLE_MASK];
1018   if (m) m(pStubMsg, desc);
1019   else FIXME("no memorysizer for data type=%02x\n", *desc);
1020
1021   return 0;
1022 }
1023
1024 /***********************************************************************
1025  *           PointerFree [internal]
1026  */
1027 static void PointerFree(PMIDL_STUB_MESSAGE pStubMsg,
1028                         unsigned char *Pointer,
1029                         PFORMAT_STRING pFormat)
1030 {
1031   unsigned type = pFormat[0], attr = pFormat[1];
1032   PFORMAT_STRING desc;
1033   NDR_FREE m;
1034
1035   TRACE("(%p,%p,%p)\n", pStubMsg, Pointer, pFormat);
1036   TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
1037   if (attr & RPC_FC_P_DONTFREE) return;
1038   pFormat += 2;
1039   if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
1040   else desc = pFormat + *(const SHORT*)pFormat;
1041
1042   if (!Pointer) return;
1043
1044   if (type == RPC_FC_FP) {
1045     int pointer_needs_freeing = NdrFullPointerFree(
1046       pStubMsg->FullPtrXlatTables, Pointer);
1047     if (!pointer_needs_freeing)
1048       return;
1049   }
1050
1051   if (attr & RPC_FC_P_DEREF) {
1052     Pointer = *(unsigned char**)Pointer;
1053     TRACE("deref => %p\n", Pointer);
1054   }
1055
1056   m = NdrFreer[*desc & NDR_TABLE_MASK];
1057   if (m) m(pStubMsg, Pointer, desc);
1058
1059   /* hmm... is this sensible?
1060    * perhaps we should check if the memory comes from NdrAllocate,
1061    * and deallocate only if so - checking if the pointer is between
1062    * BufferStart and BufferEnd is probably no good since the buffer
1063    * may be reallocated when the server wants to marshal the reply */
1064   switch (*desc) {
1065   case RPC_FC_BOGUS_STRUCT:
1066   case RPC_FC_BOGUS_ARRAY:
1067   case RPC_FC_USER_MARSHAL:
1068   case RPC_FC_CARRAY:
1069   case RPC_FC_CVARRAY:
1070     break;
1071   default:
1072     FIXME("unhandled data type=%02x\n", *desc);
1073     break;
1074   case RPC_FC_C_CSTRING:
1075   case RPC_FC_C_WSTRING:
1076     if (pStubMsg->ReuseBuffer) goto notfree;
1077     break;
1078   case RPC_FC_IP:
1079     goto notfree;
1080   }
1081
1082   if (attr & RPC_FC_P_ONSTACK) {
1083     TRACE("not freeing stack ptr %p\n", Pointer);
1084     return;
1085   }
1086   TRACE("freeing %p\n", Pointer);
1087   NdrFree(pStubMsg, Pointer);
1088   return;
1089 notfree:
1090   TRACE("not freeing %p\n", Pointer);
1091 }
1092
1093 /***********************************************************************
1094  *           EmbeddedPointerMarshall
1095  */
1096 static unsigned char * EmbeddedPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
1097                                                unsigned char *pMemory,
1098                                                PFORMAT_STRING pFormat)
1099 {
1100   unsigned char *Mark = pStubMsg->BufferMark;
1101   unsigned long Offset = pStubMsg->Offset;
1102   unsigned ofs, rep, count, stride, xofs;
1103   unsigned i;
1104
1105   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1106
1107   if (*pFormat != RPC_FC_PP) return NULL;
1108   pFormat += 2;
1109
1110   while (pFormat[0] != RPC_FC_END) {
1111     switch (pFormat[0]) {
1112     default:
1113       FIXME("unknown repeat type %d\n", pFormat[0]);
1114     case RPC_FC_NO_REPEAT:
1115       rep = 1;
1116       stride = 0;
1117       ofs = 0;
1118       count = 1;
1119       xofs = 0;
1120       pFormat += 2;
1121       break;
1122     case RPC_FC_FIXED_REPEAT:
1123       rep = *(const WORD*)&pFormat[2];
1124       stride = *(const WORD*)&pFormat[4];
1125       ofs = *(const WORD*)&pFormat[6];
1126       count = *(const WORD*)&pFormat[8];
1127       xofs = 0;
1128       pFormat += 10;
1129       break;
1130     case RPC_FC_VARIABLE_REPEAT:
1131       rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
1132       stride = *(const WORD*)&pFormat[2];
1133       ofs = *(const WORD*)&pFormat[4];
1134       count = *(const WORD*)&pFormat[6];
1135       xofs = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? Offset * stride : 0;
1136       pFormat += 8;
1137       break;
1138     }
1139     for (i = 0; i < rep; i++) {
1140       PFORMAT_STRING info = pFormat;
1141       unsigned char *membase = pMemory + (i * stride);
1142       unsigned char *bufbase = Mark + (i * stride);
1143       unsigned u;
1144       /* ofs doesn't seem to matter in this context */
1145       for (u=0; u<count; u++,info+=8) {
1146         unsigned char *memptr = membase + *(const SHORT*)&info[0];
1147         unsigned char *bufptr = bufbase + *(const SHORT*)&info[2];
1148         unsigned char *saved_memory = pStubMsg->Memory;
1149
1150         pStubMsg->Memory = pMemory;
1151         PointerMarshall(pStubMsg, bufptr, *(unsigned char**)memptr, info+4);
1152         pStubMsg->Memory = saved_memory;
1153       }
1154     }
1155     pFormat += 8 * count;
1156   }
1157
1158   STD_OVERFLOW_CHECK(pStubMsg);
1159
1160   return NULL;
1161 }
1162
1163 /***********************************************************************
1164  *           EmbeddedPointerUnmarshall
1165  */
1166 static unsigned char * EmbeddedPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
1167                                                  unsigned char **ppMemory,
1168                                                  PFORMAT_STRING pFormat,
1169                                                  unsigned char fMustAlloc)
1170 {
1171   unsigned char *Mark = pStubMsg->BufferMark;
1172   unsigned long Offset = pStubMsg->Offset;
1173   unsigned ofs, rep, count, stride, xofs;
1174   unsigned i;
1175
1176   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
1177
1178   if (*pFormat != RPC_FC_PP) return NULL;
1179   pFormat += 2;
1180
1181   while (pFormat[0] != RPC_FC_END) {
1182     TRACE("pFormat[0] = 0x%x\n", pFormat[0]);
1183     switch (pFormat[0]) {
1184     default:
1185       FIXME("unknown repeat type %d\n", pFormat[0]);
1186     case RPC_FC_NO_REPEAT:
1187       rep = 1;
1188       stride = 0;
1189       ofs = 0;
1190       count = 1;
1191       xofs = 0;
1192       pFormat += 2;
1193       break;
1194     case RPC_FC_FIXED_REPEAT:
1195       rep = *(const WORD*)&pFormat[2];
1196       stride = *(const WORD*)&pFormat[4];
1197       ofs = *(const WORD*)&pFormat[6];
1198       count = *(const WORD*)&pFormat[8];
1199       xofs = 0;
1200       pFormat += 10;
1201       break;
1202     case RPC_FC_VARIABLE_REPEAT:
1203       rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
1204       stride = *(const WORD*)&pFormat[2];
1205       ofs = *(const WORD*)&pFormat[4];
1206       count = *(const WORD*)&pFormat[6];
1207       xofs = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? Offset * stride : 0;
1208       pFormat += 8;
1209       break;
1210     }
1211     /* ofs doesn't seem to matter in this context */
1212     for (i = 0; i < rep; i++) {
1213       PFORMAT_STRING info = pFormat;
1214       unsigned char *membase = *ppMemory + (i * stride);
1215       unsigned char *bufbase = Mark + (i * stride);
1216       unsigned u;
1217       for (u=0; u<count; u++,info+=8) {
1218         unsigned char *memptr = membase + *(const SHORT*)&info[0];
1219         unsigned char *bufptr = bufbase + *(const SHORT*)&info[2];
1220         PointerUnmarshall(pStubMsg, bufptr, (unsigned char**)memptr, info+4, TRUE);
1221       }
1222     }
1223     pFormat += 8 * count;
1224   }
1225
1226   return NULL;
1227 }
1228
1229 /***********************************************************************
1230  *           EmbeddedPointerBufferSize
1231  */
1232 static void EmbeddedPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
1233                                       unsigned char *pMemory,
1234                                       PFORMAT_STRING pFormat)
1235 {
1236   unsigned long Offset = pStubMsg->Offset;
1237   unsigned ofs, rep, count, stride, xofs;
1238   unsigned i;
1239
1240   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1241
1242   if (pStubMsg->IgnoreEmbeddedPointers) return;
1243
1244   if (*pFormat != RPC_FC_PP) return;
1245   pFormat += 2;
1246
1247   while (pFormat[0] != RPC_FC_END) {
1248     switch (pFormat[0]) {
1249     default:
1250       FIXME("unknown repeat type %d\n", pFormat[0]);
1251     case RPC_FC_NO_REPEAT:
1252       rep = 1;
1253       stride = 0;
1254       ofs = 0;
1255       count = 1;
1256       xofs = 0;
1257       pFormat += 2;
1258       break;
1259     case RPC_FC_FIXED_REPEAT:
1260       rep = *(const WORD*)&pFormat[2];
1261       stride = *(const WORD*)&pFormat[4];
1262       ofs = *(const WORD*)&pFormat[6];
1263       count = *(const WORD*)&pFormat[8];
1264       xofs = 0;
1265       pFormat += 10;
1266       break;
1267     case RPC_FC_VARIABLE_REPEAT:
1268       rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
1269       stride = *(const WORD*)&pFormat[2];
1270       ofs = *(const WORD*)&pFormat[4];
1271       count = *(const WORD*)&pFormat[6];
1272       xofs = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? Offset * stride : 0;
1273       pFormat += 8;
1274       break;
1275     }
1276     /* ofs doesn't seem to matter in this context */
1277     for (i = 0; i < rep; i++) {
1278       PFORMAT_STRING info = pFormat;
1279       unsigned char *membase = pMemory + (i * stride);
1280       unsigned u;
1281       for (u=0; u<count; u++,info+=8) {
1282         unsigned char *memptr = membase + *(const SHORT*)&info[0];
1283         unsigned char *saved_memory = pStubMsg->Memory;
1284
1285         pStubMsg->Memory = pMemory;
1286         PointerBufferSize(pStubMsg, *(unsigned char**)memptr, info+4);
1287         pStubMsg->Memory = saved_memory;
1288       }
1289     }
1290     pFormat += 8 * count;
1291   }
1292 }
1293
1294 /***********************************************************************
1295  *           EmbeddedPointerMemorySize [internal]
1296  */
1297 static unsigned long EmbeddedPointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
1298                                                PFORMAT_STRING pFormat)
1299 {
1300   unsigned long Offset = pStubMsg->Offset;
1301   unsigned char *Mark = pStubMsg->BufferMark;
1302   unsigned ofs, rep, count, stride, xofs;
1303   unsigned i;
1304
1305   FIXME("(%p,%p): stub\n", pStubMsg, pFormat);
1306
1307   if (*pFormat != RPC_FC_PP) return 0;
1308   pFormat += 2;
1309
1310   while (pFormat[0] != RPC_FC_END) {
1311     switch (pFormat[0]) {
1312     default:
1313       FIXME("unknown repeat type %d\n", pFormat[0]);
1314     case RPC_FC_NO_REPEAT:
1315       rep = 1;
1316       stride = 0;
1317       ofs = 0;
1318       count = 1;
1319       xofs = 0;
1320       pFormat += 2;
1321       break;
1322     case RPC_FC_FIXED_REPEAT:
1323       rep = *(const WORD*)&pFormat[2];
1324       stride = *(const WORD*)&pFormat[4];
1325       ofs = *(const WORD*)&pFormat[6];
1326       count = *(const WORD*)&pFormat[8];
1327       xofs = 0;
1328       pFormat += 10;
1329       break;
1330     case RPC_FC_VARIABLE_REPEAT:
1331       rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
1332       stride = *(const WORD*)&pFormat[2];
1333       ofs = *(const WORD*)&pFormat[4];
1334       count = *(const WORD*)&pFormat[6];
1335       xofs = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? Offset * stride : 0;
1336       pFormat += 8;
1337       break;
1338     }
1339     /* ofs doesn't seem to matter in this context */
1340     for (i = 0; i < rep; i++) {
1341       PFORMAT_STRING info = pFormat;
1342       unsigned char *bufbase = Mark + (i * stride);
1343       unsigned u;
1344       for (u=0; u<count; u++,info+=8) {
1345         unsigned char *bufptr = bufbase + *(const SHORT*)&info[2];
1346         PointerMemorySize(pStubMsg, bufptr, info+4);
1347       }
1348     }
1349     pFormat += 8 * count;
1350   }
1351
1352   return 0;
1353 }
1354
1355 /***********************************************************************
1356  *           EmbeddedPointerFree [internal]
1357  */
1358 static void EmbeddedPointerFree(PMIDL_STUB_MESSAGE pStubMsg,
1359                                 unsigned char *pMemory,
1360                                 PFORMAT_STRING pFormat)
1361 {
1362   unsigned long Offset = pStubMsg->Offset;
1363   unsigned ofs, rep, count, stride, xofs;
1364   unsigned i;
1365
1366   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1367   if (*pFormat != RPC_FC_PP) return;
1368   pFormat += 2;
1369
1370   while (pFormat[0] != RPC_FC_END) {
1371     switch (pFormat[0]) {
1372     default:
1373       FIXME("unknown repeat type %d\n", pFormat[0]);
1374     case RPC_FC_NO_REPEAT:
1375       rep = 1;
1376       stride = 0;
1377       ofs = 0;
1378       count = 1;
1379       xofs = 0;
1380       pFormat += 2;
1381       break;
1382     case RPC_FC_FIXED_REPEAT:
1383       rep = *(const WORD*)&pFormat[2];
1384       stride = *(const WORD*)&pFormat[4];
1385       ofs = *(const WORD*)&pFormat[6];
1386       count = *(const WORD*)&pFormat[8];
1387       xofs = 0;
1388       pFormat += 10;
1389       break;
1390     case RPC_FC_VARIABLE_REPEAT:
1391       rep = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
1392       stride = *(const WORD*)&pFormat[2];
1393       ofs = *(const WORD*)&pFormat[4];
1394       count = *(const WORD*)&pFormat[6];
1395       xofs = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? Offset * stride : 0;
1396       pFormat += 8;
1397       break;
1398     }
1399     /* ofs doesn't seem to matter in this context */
1400     for (i = 0; i < rep; i++) {
1401       PFORMAT_STRING info = pFormat;
1402       unsigned char *membase = pMemory + (i * stride);
1403       unsigned u;
1404       for (u=0; u<count; u++,info+=8) {
1405         unsigned char *memptr = membase + *(const SHORT*)&info[0];
1406         unsigned char *saved_memory = pStubMsg->Memory;
1407
1408         pStubMsg->Memory = pMemory;
1409         PointerFree(pStubMsg, *(unsigned char**)memptr, info+4);
1410         pStubMsg->Memory = saved_memory;
1411       }
1412     }
1413     pFormat += 8 * count;
1414   }
1415 }
1416
1417 /***********************************************************************
1418  *           NdrPointerMarshall [RPCRT4.@]
1419  */
1420 unsigned char * WINAPI NdrPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
1421                                           unsigned char *pMemory,
1422                                           PFORMAT_STRING pFormat)
1423 {
1424   unsigned char *Buffer;
1425
1426   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1427
1428   /* incremement the buffer here instead of in PointerMarshall,
1429    * as that is used by embedded pointers which already handle the incrementing
1430    * the buffer, and shouldn't write any additional pointer data to the wire */
1431   if (*pFormat != RPC_FC_RP)
1432   {
1433     ALIGN_POINTER(pStubMsg->Buffer, 4);
1434     Buffer = pStubMsg->Buffer;
1435     pStubMsg->Buffer += 4;
1436   }
1437   else
1438     Buffer = pStubMsg->Buffer;
1439
1440   PointerMarshall(pStubMsg, Buffer, pMemory, pFormat);
1441
1442   STD_OVERFLOW_CHECK(pStubMsg);
1443
1444   return NULL;
1445 }
1446
1447 /***********************************************************************
1448  *           NdrPointerUnmarshall [RPCRT4.@]
1449  */
1450 unsigned char * WINAPI NdrPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
1451                                             unsigned char **ppMemory,
1452                                             PFORMAT_STRING pFormat,
1453                                             unsigned char fMustAlloc)
1454 {
1455   unsigned char *Buffer;
1456
1457   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
1458
1459   /* incremement the buffer here instead of in PointerUnmarshall,
1460    * as that is used by embedded pointers which already handle the incrementing
1461    * the buffer, and shouldn't read any additional pointer data from the
1462    * buffer */
1463   if (*pFormat != RPC_FC_RP)
1464   {
1465     ALIGN_POINTER(pStubMsg->Buffer, 4);
1466     Buffer = pStubMsg->Buffer;
1467     pStubMsg->Buffer += 4;
1468   }
1469   else
1470     Buffer = pStubMsg->Buffer;
1471
1472   PointerUnmarshall(pStubMsg, Buffer, ppMemory, pFormat, fMustAlloc);
1473
1474   return NULL;
1475 }
1476
1477 /***********************************************************************
1478  *           NdrPointerBufferSize [RPCRT4.@]
1479  */
1480 void WINAPI NdrPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
1481                                       unsigned char *pMemory,
1482                                       PFORMAT_STRING pFormat)
1483 {
1484   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1485
1486   /* incremement the buffer length here instead of in PointerBufferSize,
1487    * as that is used by embedded pointers which already handle the buffer
1488    * length, and shouldn't write anything more to the wire */
1489   if (*pFormat != RPC_FC_RP)
1490   {
1491     ALIGN_LENGTH(pStubMsg->BufferLength, 4);
1492     pStubMsg->BufferLength += 4;
1493   }
1494
1495   PointerBufferSize(pStubMsg, pMemory, pFormat);
1496 }
1497
1498 /***********************************************************************
1499  *           NdrPointerMemorySize [RPCRT4.@]
1500  */
1501 ULONG WINAPI NdrPointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
1502                                   PFORMAT_STRING pFormat)
1503 {
1504   /* unsigned size = *(LPWORD)(pFormat+2); */
1505   FIXME("(%p,%p): stub\n", pStubMsg, pFormat);
1506   PointerMemorySize(pStubMsg, pStubMsg->Buffer, pFormat);
1507   return 0;
1508 }
1509
1510 /***********************************************************************
1511  *           NdrPointerFree [RPCRT4.@]
1512  */
1513 void WINAPI NdrPointerFree(PMIDL_STUB_MESSAGE pStubMsg,
1514                            unsigned char *pMemory,
1515                            PFORMAT_STRING pFormat)
1516 {
1517   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1518   PointerFree(pStubMsg, pMemory, pFormat);
1519 }
1520
1521 /***********************************************************************
1522  *           NdrSimpleTypeMarshall [RPCRT4.@]
1523  */
1524 void WINAPI NdrSimpleTypeMarshall( PMIDL_STUB_MESSAGE pStubMsg, unsigned char* pMemory,
1525                                    unsigned char FormatChar )
1526 {
1527     FIXME("stub\n");
1528 }
1529
1530 /***********************************************************************
1531  *           NdrSimpleTypeUnmarshall [RPCRT4.@]
1532  */
1533 void WINAPI NdrSimpleTypeUnmarshall( PMIDL_STUB_MESSAGE pStubMsg, unsigned char* pMemory,
1534                                      unsigned char FormatChar )
1535 {
1536     FIXME("stub\n");
1537 }
1538
1539 /***********************************************************************
1540  *           NdrSimpleStructMarshall [RPCRT4.@]
1541  */
1542 unsigned char * WINAPI NdrSimpleStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
1543                                                unsigned char *pMemory,
1544                                                PFORMAT_STRING pFormat)
1545 {
1546   unsigned size = *(const WORD*)(pFormat+2);
1547   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1548
1549   ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
1550
1551   memcpy(pStubMsg->Buffer, pMemory, size);
1552   pStubMsg->BufferMark = pStubMsg->Buffer;
1553   pStubMsg->Buffer += size;
1554
1555   if (pFormat[0] != RPC_FC_STRUCT)
1556     EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat+4);
1557
1558   STD_OVERFLOW_CHECK(pStubMsg);
1559
1560   return NULL;
1561 }
1562
1563 /***********************************************************************
1564  *           NdrSimpleStructUnmarshall [RPCRT4.@]
1565  */
1566 unsigned char * WINAPI NdrSimpleStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
1567                                                  unsigned char **ppMemory,
1568                                                  PFORMAT_STRING pFormat,
1569                                                  unsigned char fMustAlloc)
1570 {
1571   unsigned size = *(const WORD*)(pFormat+2);
1572   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
1573
1574   ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
1575
1576   if (fMustAlloc) {
1577     *ppMemory = NdrAllocate(pStubMsg, size);
1578     memcpy(*ppMemory, pStubMsg->Buffer, size);
1579   } else {
1580     if (!pStubMsg->IsClient && !*ppMemory)
1581       /* for servers, we just point straight into the RPC buffer */
1582       *ppMemory = pStubMsg->Buffer;
1583     else
1584       /* for clients, memory should be provided by caller */
1585       memcpy(*ppMemory, pStubMsg->Buffer, size);
1586   }
1587
1588   pStubMsg->BufferMark = pStubMsg->Buffer;
1589   pStubMsg->Buffer += size;
1590
1591   if (pFormat[0] != RPC_FC_STRUCT)
1592     EmbeddedPointerUnmarshall(pStubMsg, ppMemory, pFormat+4, fMustAlloc);
1593
1594   return NULL;
1595 }
1596
1597 /***********************************************************************
1598  *           NdrSimpleStructBufferSize [RPCRT4.@]
1599  */
1600 void WINAPI NdrSimpleStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
1601                                       unsigned char *pMemory,
1602                                       PFORMAT_STRING pFormat)
1603 {
1604   unsigned size = *(const WORD*)(pFormat+2);
1605   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1606
1607   ALIGN_LENGTH(pStubMsg->BufferLength, pFormat[1] + 1);
1608
1609   pStubMsg->BufferLength += size;
1610   if (pFormat[0] != RPC_FC_STRUCT)
1611     EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat+4);
1612 }
1613
1614 /***********************************************************************
1615  *           NdrSimpleStructMemorySize [RPCRT4.@]
1616  */
1617 ULONG WINAPI NdrSimpleStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
1618                                        PFORMAT_STRING pFormat)
1619 {
1620   unsigned short size = *(const WORD *)(pFormat+2);
1621
1622   TRACE("(%p,%p)\n", pStubMsg, pFormat);
1623
1624   ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
1625   pStubMsg->MemorySize += size;
1626   pStubMsg->Buffer += size;
1627
1628   if (pFormat[0] != RPC_FC_STRUCT)
1629     EmbeddedPointerMemorySize(pStubMsg, pFormat+4);
1630   return size;
1631 }
1632
1633 /***********************************************************************
1634  *           NdrSimpleStructFree [RPCRT4.@]
1635  */
1636 void WINAPI NdrSimpleStructFree(PMIDL_STUB_MESSAGE pStubMsg,
1637                                 unsigned char *pMemory,
1638                                 PFORMAT_STRING pFormat)
1639 {
1640   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1641   if (pFormat[0] != RPC_FC_STRUCT)
1642     EmbeddedPointerFree(pStubMsg, pMemory, pFormat+4);
1643 }
1644
1645
1646 static unsigned long EmbeddedComplexSize(PMIDL_STUB_MESSAGE pStubMsg,
1647                                          PFORMAT_STRING pFormat)
1648 {
1649   switch (*pFormat) {
1650   case RPC_FC_STRUCT:
1651   case RPC_FC_PSTRUCT:
1652   case RPC_FC_CSTRUCT:
1653   case RPC_FC_BOGUS_STRUCT:
1654   case RPC_FC_SMFARRAY:
1655   case RPC_FC_SMVARRAY:
1656     return *(const WORD*)&pFormat[2];
1657   case RPC_FC_USER_MARSHAL:
1658     return *(const WORD*)&pFormat[4];
1659   case RPC_FC_NON_ENCAPSULATED_UNION:
1660     pFormat += 2;
1661     if (pStubMsg->fHasNewCorrDesc)
1662         pFormat += 6;
1663     else
1664         pFormat += 4;
1665
1666     pFormat += *(const SHORT*)pFormat;
1667     return *(const SHORT*)pFormat;
1668   case RPC_FC_IP:
1669     return sizeof(void *);
1670   default:
1671     FIXME("unhandled embedded type %02x\n", *pFormat);
1672   }
1673   return 0;
1674 }
1675
1676
1677 static unsigned long EmbeddedComplexMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
1678                                                PFORMAT_STRING pFormat)
1679 {
1680   NDR_MEMORYSIZE m = NdrMemorySizer[*pFormat & NDR_TABLE_MASK];
1681
1682   if (!m)
1683   {
1684     FIXME("no memorysizer for data type=%02x\n", *pFormat);
1685     return 0;
1686   }
1687
1688   return m(pStubMsg, pFormat);
1689 }
1690
1691
1692 static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg,
1693                                        unsigned char *pMemory,
1694                                        PFORMAT_STRING pFormat,
1695                                        PFORMAT_STRING pPointer)
1696 {
1697   PFORMAT_STRING desc;
1698   NDR_MARSHALL m;
1699   unsigned long size;
1700
1701   while (*pFormat != RPC_FC_END) {
1702     switch (*pFormat) {
1703     case RPC_FC_BYTE:
1704     case RPC_FC_CHAR:
1705     case RPC_FC_SMALL:
1706     case RPC_FC_USMALL:
1707       TRACE("byte=%d <= %p\n", *(WORD*)pMemory, pMemory);
1708       memcpy(pStubMsg->Buffer, pMemory, 1);
1709       pStubMsg->Buffer += 1;
1710       pMemory += 1;
1711       break;
1712     case RPC_FC_WCHAR:
1713     case RPC_FC_SHORT:
1714     case RPC_FC_USHORT:
1715       TRACE("short=%d <= %p\n", *(WORD*)pMemory, pMemory);
1716       memcpy(pStubMsg->Buffer, pMemory, 2);
1717       pStubMsg->Buffer += 2;
1718       pMemory += 2;
1719       break;
1720     case RPC_FC_LONG:
1721     case RPC_FC_ULONG:
1722     case RPC_FC_ENUM32:
1723       TRACE("long=%d <= %p\n", *(DWORD*)pMemory, pMemory);
1724       memcpy(pStubMsg->Buffer, pMemory, 4);
1725       pStubMsg->Buffer += 4;
1726       pMemory += 4;
1727       break;
1728     case RPC_FC_HYPER:
1729       TRACE("longlong=%s <= %p\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory), pMemory);
1730       memcpy(pStubMsg->Buffer, pMemory, 8);
1731       pStubMsg->Buffer += 8;
1732       pMemory += 8;
1733       break;
1734     case RPC_FC_POINTER:
1735       TRACE("pointer=%p <= %p\n", *(unsigned char**)pMemory, pMemory);
1736       NdrPointerMarshall(pStubMsg, *(unsigned char**)pMemory, pPointer);
1737       pPointer += 4;
1738       pMemory += 4;
1739       break;
1740     case RPC_FC_ALIGNM4:
1741       ALIGN_POINTER(pMemory, 4);
1742       break;
1743     case RPC_FC_ALIGNM8:
1744       ALIGN_POINTER(pMemory, 8);
1745       break;
1746     case RPC_FC_STRUCTPAD1:
1747     case RPC_FC_STRUCTPAD2:
1748     case RPC_FC_STRUCTPAD3:
1749     case RPC_FC_STRUCTPAD4:
1750     case RPC_FC_STRUCTPAD5:
1751     case RPC_FC_STRUCTPAD6:
1752     case RPC_FC_STRUCTPAD7:
1753       pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
1754       break;
1755     case RPC_FC_EMBEDDED_COMPLEX:
1756       pMemory += pFormat[1];
1757       pFormat += 2;
1758       desc = pFormat + *(const SHORT*)pFormat;
1759       size = EmbeddedComplexSize(pStubMsg, desc);
1760       TRACE("embedded complex (size=%ld) <= %p\n", size, pMemory);
1761       m = NdrMarshaller[*desc & NDR_TABLE_MASK];
1762       if (m) m(pStubMsg, pMemory, desc);
1763       else FIXME("no marshaller for embedded type %02x\n", *desc);
1764       pMemory += size;
1765       pFormat += 2;
1766       continue;
1767     case RPC_FC_PAD:
1768       break;
1769     default:
1770       FIXME("unhandled format 0x%02x\n", *pFormat);
1771     }
1772     pFormat++;
1773   }
1774
1775   return pMemory;
1776 }
1777
1778 static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
1779                                          unsigned char *pMemory,
1780                                          PFORMAT_STRING pFormat,
1781                                          PFORMAT_STRING pPointer)
1782 {
1783   PFORMAT_STRING desc;
1784   NDR_UNMARSHALL m;
1785   unsigned long size;
1786
1787   while (*pFormat != RPC_FC_END) {
1788     switch (*pFormat) {
1789     case RPC_FC_BYTE:
1790     case RPC_FC_CHAR:
1791     case RPC_FC_SMALL:
1792     case RPC_FC_USMALL:
1793       memcpy(pMemory, pStubMsg->Buffer, 1);
1794       TRACE("byte=%d => %p\n", *(WORD*)pMemory, pMemory);
1795       pStubMsg->Buffer += 1;
1796       pMemory += 1;
1797       break;
1798     case RPC_FC_WCHAR:
1799     case RPC_FC_SHORT:
1800     case RPC_FC_USHORT:
1801       memcpy(pMemory, pStubMsg->Buffer, 2);
1802       TRACE("short=%d => %p\n", *(WORD*)pMemory, pMemory);
1803       pStubMsg->Buffer += 2;
1804       pMemory += 2;
1805       break;
1806     case RPC_FC_LONG:
1807     case RPC_FC_ULONG:
1808     case RPC_FC_ENUM32:
1809       memcpy(pMemory, pStubMsg->Buffer, 4);
1810       TRACE("long=%d => %p\n", *(DWORD*)pMemory, pMemory);
1811       pStubMsg->Buffer += 4;
1812       pMemory += 4;
1813       break;
1814     case RPC_FC_HYPER:
1815       memcpy(pMemory, pStubMsg->Buffer, 8);
1816       TRACE("longlong=%s => %p\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory), pMemory);
1817       pStubMsg->Buffer += 8;
1818       pMemory += 8;
1819       break;
1820     case RPC_FC_POINTER:
1821       TRACE("pointer => %p\n", pMemory);
1822       NdrPointerUnmarshall(pStubMsg, (unsigned char**)pMemory, pPointer, TRUE);
1823       pPointer += 4;
1824       pMemory += 4;
1825       break;
1826     case RPC_FC_ALIGNM4:
1827       ALIGN_POINTER(pMemory, 4);
1828       break;
1829     case RPC_FC_ALIGNM8:
1830       ALIGN_POINTER(pMemory, 8);
1831       break;
1832     case RPC_FC_STRUCTPAD1:
1833     case RPC_FC_STRUCTPAD2:
1834     case RPC_FC_STRUCTPAD3:
1835     case RPC_FC_STRUCTPAD4:
1836     case RPC_FC_STRUCTPAD5:
1837     case RPC_FC_STRUCTPAD6:
1838     case RPC_FC_STRUCTPAD7:
1839       pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
1840       break;
1841     case RPC_FC_EMBEDDED_COMPLEX:
1842       pMemory += pFormat[1];
1843       pFormat += 2;
1844       desc = pFormat + *(const SHORT*)pFormat;
1845       size = EmbeddedComplexSize(pStubMsg, desc);
1846       TRACE("embedded complex (size=%ld) => %p\n", size, pMemory);
1847       m = NdrUnmarshaller[*desc & NDR_TABLE_MASK];
1848       memset(pMemory, 0, size); /* just in case */
1849       if (m) m(pStubMsg, &pMemory, desc, FALSE);
1850       else FIXME("no unmarshaller for embedded type %02x\n", *desc);
1851       pMemory += size;
1852       pFormat += 2;
1853       continue;
1854     case RPC_FC_PAD:
1855       break;
1856     default:
1857       FIXME("unhandled format %d\n", *pFormat);
1858     }
1859     pFormat++;
1860   }
1861
1862   return pMemory;
1863 }
1864
1865 static unsigned char * ComplexBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
1866                                          unsigned char *pMemory,
1867                                          PFORMAT_STRING pFormat,
1868                                          PFORMAT_STRING pPointer)
1869 {
1870   PFORMAT_STRING desc;
1871   NDR_BUFFERSIZE m;
1872   unsigned long size;
1873
1874   while (*pFormat != RPC_FC_END) {
1875     switch (*pFormat) {
1876     case RPC_FC_BYTE:
1877     case RPC_FC_CHAR:
1878     case RPC_FC_SMALL:
1879     case RPC_FC_USMALL:
1880       pStubMsg->BufferLength += 1;
1881       pMemory += 1;
1882       break;
1883     case RPC_FC_WCHAR:
1884     case RPC_FC_SHORT:
1885     case RPC_FC_USHORT:
1886       pStubMsg->BufferLength += 2;
1887       pMemory += 2;
1888       break;
1889     case RPC_FC_LONG:
1890     case RPC_FC_ULONG:
1891     case RPC_FC_ENUM32:
1892       pStubMsg->BufferLength += 4;
1893       pMemory += 4;
1894       break;
1895     case RPC_FC_HYPER:
1896       pStubMsg->BufferLength += 8;
1897       pMemory += 8;
1898       break;
1899     case RPC_FC_POINTER:
1900       NdrPointerBufferSize(pStubMsg, *(unsigned char**)pMemory, pPointer);
1901       pPointer += 4;
1902       pMemory += 4;
1903       break;
1904     case RPC_FC_ALIGNM4:
1905       ALIGN_POINTER(pMemory, 4);
1906       break;
1907     case RPC_FC_ALIGNM8:
1908       ALIGN_POINTER(pMemory, 8);
1909       break;
1910     case RPC_FC_STRUCTPAD1:
1911     case RPC_FC_STRUCTPAD2:
1912     case RPC_FC_STRUCTPAD3:
1913     case RPC_FC_STRUCTPAD4:
1914     case RPC_FC_STRUCTPAD5:
1915     case RPC_FC_STRUCTPAD6:
1916     case RPC_FC_STRUCTPAD7:
1917       pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
1918       break;
1919     case RPC_FC_EMBEDDED_COMPLEX:
1920       pMemory += pFormat[1];
1921       pFormat += 2;
1922       desc = pFormat + *(const SHORT*)pFormat;
1923       size = EmbeddedComplexSize(pStubMsg, desc);
1924       m = NdrBufferSizer[*desc & NDR_TABLE_MASK];
1925       if (m) m(pStubMsg, pMemory, desc);
1926       else FIXME("no buffersizer for embedded type %02x\n", *desc);
1927       pMemory += size;
1928       pFormat += 2;
1929       continue;
1930     case RPC_FC_PAD:
1931       break;
1932     default:
1933       FIXME("unhandled format 0x%02x\n", *pFormat);
1934     }
1935     pFormat++;
1936   }
1937
1938   return pMemory;
1939 }
1940
1941 static unsigned char * ComplexFree(PMIDL_STUB_MESSAGE pStubMsg,
1942                                    unsigned char *pMemory,
1943                                    PFORMAT_STRING pFormat,
1944                                    PFORMAT_STRING pPointer)
1945 {
1946   PFORMAT_STRING desc;
1947   NDR_FREE m;
1948   unsigned long size;
1949
1950   while (*pFormat != RPC_FC_END) {
1951     switch (*pFormat) {
1952     case RPC_FC_BYTE:
1953     case RPC_FC_CHAR:
1954     case RPC_FC_SMALL:
1955     case RPC_FC_USMALL:
1956       pMemory += 1;
1957       break;
1958     case RPC_FC_WCHAR:
1959     case RPC_FC_SHORT:
1960     case RPC_FC_USHORT:
1961       pMemory += 2;
1962       break;
1963     case RPC_FC_LONG:
1964     case RPC_FC_ULONG:
1965     case RPC_FC_ENUM32:
1966       pMemory += 4;
1967       break;
1968     case RPC_FC_HYPER:
1969       pMemory += 8;
1970       break;
1971     case RPC_FC_POINTER:
1972       NdrPointerFree(pStubMsg, *(unsigned char**)pMemory, pPointer);
1973       pPointer += 4;
1974       pMemory += 4;
1975       break;
1976     case RPC_FC_ALIGNM4:
1977       ALIGN_POINTER(pMemory, 4);
1978       break;
1979     case RPC_FC_ALIGNM8:
1980       ALIGN_POINTER(pMemory, 8);
1981       break;
1982     case RPC_FC_STRUCTPAD1:
1983     case RPC_FC_STRUCTPAD2:
1984     case RPC_FC_STRUCTPAD3:
1985     case RPC_FC_STRUCTPAD4:
1986     case RPC_FC_STRUCTPAD5:
1987     case RPC_FC_STRUCTPAD6:
1988     case RPC_FC_STRUCTPAD7:
1989       pMemory += *pFormat - RPC_FC_STRUCTPAD1 + 1;
1990       break;
1991     case RPC_FC_EMBEDDED_COMPLEX:
1992       pMemory += pFormat[1];
1993       pFormat += 2;
1994       desc = pFormat + *(const SHORT*)pFormat;
1995       size = EmbeddedComplexSize(pStubMsg, desc);
1996       m = NdrFreer[*desc & NDR_TABLE_MASK];
1997       if (m) m(pStubMsg, pMemory, desc);
1998       else FIXME("no freer for embedded type %02x\n", *desc);
1999       pMemory += size;
2000       pFormat += 2;
2001       continue;
2002     case RPC_FC_PAD:
2003       break;
2004     default:
2005       FIXME("unhandled format 0x%02x\n", *pFormat);
2006     }
2007     pFormat++;
2008   }
2009
2010   return pMemory;
2011 }
2012
2013 static unsigned long ComplexStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2014                                        PFORMAT_STRING pFormat)
2015 {
2016   PFORMAT_STRING desc;
2017   unsigned long size = 0;
2018
2019   while (*pFormat != RPC_FC_END) {
2020     switch (*pFormat) {
2021     case RPC_FC_BYTE:
2022     case RPC_FC_CHAR:
2023     case RPC_FC_SMALL:
2024     case RPC_FC_USMALL:
2025       size += 1;
2026       pStubMsg->Buffer += 1;
2027       break;
2028     case RPC_FC_WCHAR:
2029     case RPC_FC_SHORT:
2030     case RPC_FC_USHORT:
2031       size += 2;
2032       pStubMsg->Buffer += 2;
2033       break;
2034     case RPC_FC_LONG:
2035     case RPC_FC_ULONG:
2036     case RPC_FC_ENUM32:
2037       size += 4;
2038       pStubMsg->Buffer += 4;
2039       break;
2040     case RPC_FC_HYPER:
2041       size += 8;
2042       pStubMsg->Buffer += 8;
2043       break;
2044     case RPC_FC_POINTER:
2045       size += 4;
2046       pStubMsg->Buffer += 4;
2047       break;
2048     case RPC_FC_ALIGNM4:
2049       ALIGN_LENGTH(size, 4);
2050       ALIGN_POINTER(pStubMsg->Buffer, 4);
2051       break;
2052     case RPC_FC_ALIGNM8:
2053       ALIGN_LENGTH(size, 8);
2054       ALIGN_POINTER(pStubMsg->Buffer, 8);
2055       break;
2056     case RPC_FC_STRUCTPAD1:
2057     case RPC_FC_STRUCTPAD2:
2058     case RPC_FC_STRUCTPAD3:
2059     case RPC_FC_STRUCTPAD4:
2060     case RPC_FC_STRUCTPAD5:
2061     case RPC_FC_STRUCTPAD6:
2062     case RPC_FC_STRUCTPAD7:
2063       size += *pFormat - RPC_FC_STRUCTPAD1 + 1;
2064       break;
2065     case RPC_FC_EMBEDDED_COMPLEX:
2066       size += pFormat[1];
2067       pFormat += 2;
2068       desc = pFormat + *(const SHORT*)pFormat;
2069       size += EmbeddedComplexMemorySize(pStubMsg, desc);
2070       pFormat += 2;
2071       continue;
2072     case RPC_FC_PAD:
2073       break;
2074     default:
2075       FIXME("unhandled format 0x%02x\n", *pFormat);
2076     }
2077     pFormat++;
2078   }
2079
2080   return size;
2081 }
2082
2083 /***********************************************************************
2084  *           NdrComplexStructMarshall [RPCRT4.@]
2085  */
2086 unsigned char * WINAPI NdrComplexStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2087                                                 unsigned char *pMemory,
2088                                                 PFORMAT_STRING pFormat)
2089 {
2090   PFORMAT_STRING conf_array = NULL;
2091   PFORMAT_STRING pointer_desc = NULL;
2092   unsigned char *OldMemory = pStubMsg->Memory;
2093
2094   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2095
2096   ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
2097
2098   pFormat += 4;
2099   if (*(const WORD*)pFormat) conf_array = pFormat + *(const WORD*)pFormat;
2100   pFormat += 2;
2101   if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
2102   pFormat += 2;
2103
2104   pStubMsg->Memory = pMemory;
2105
2106   ComplexMarshall(pStubMsg, pMemory, pFormat, pointer_desc);
2107
2108   if (conf_array)
2109     NdrConformantArrayMarshall(pStubMsg, pMemory, conf_array);
2110
2111   pStubMsg->Memory = OldMemory;
2112
2113   STD_OVERFLOW_CHECK(pStubMsg);
2114
2115   return NULL;
2116 }
2117
2118 /***********************************************************************
2119  *           NdrComplexStructUnmarshall [RPCRT4.@]
2120  */
2121 unsigned char * WINAPI NdrComplexStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2122                                                   unsigned char **ppMemory,
2123                                                   PFORMAT_STRING pFormat,
2124                                                   unsigned char fMustAlloc)
2125 {
2126   unsigned size = *(const WORD*)(pFormat+2);
2127   PFORMAT_STRING conf_array = NULL;
2128   PFORMAT_STRING pointer_desc = NULL;
2129   unsigned char *pMemory;
2130
2131   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
2132
2133   ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
2134
2135   if (fMustAlloc || !*ppMemory)
2136   {
2137     *ppMemory = NdrAllocate(pStubMsg, size);
2138     memset(*ppMemory, 0, size);
2139   }
2140
2141   pFormat += 4;
2142   if (*(const WORD*)pFormat) conf_array = pFormat + *(const WORD*)pFormat;
2143   pFormat += 2;
2144   if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
2145   pFormat += 2;
2146
2147   pMemory = ComplexUnmarshall(pStubMsg, *ppMemory, pFormat, pointer_desc);
2148
2149   if (conf_array)
2150     NdrConformantArrayUnmarshall(pStubMsg, &pMemory, conf_array, fMustAlloc);
2151
2152   return NULL;
2153 }
2154
2155 /***********************************************************************
2156  *           NdrComplexStructBufferSize [RPCRT4.@]
2157  */
2158 void WINAPI NdrComplexStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2159                                        unsigned char *pMemory,
2160                                        PFORMAT_STRING pFormat)
2161 {
2162   PFORMAT_STRING conf_array = NULL;
2163   PFORMAT_STRING pointer_desc = NULL;
2164   unsigned char *OldMemory = pStubMsg->Memory;
2165
2166   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2167
2168   ALIGN_LENGTH(pStubMsg->BufferLength, pFormat[1] + 1);
2169
2170   pFormat += 4;
2171   if (*(const WORD*)pFormat) conf_array = pFormat + *(const WORD*)pFormat;
2172   pFormat += 2;
2173   if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
2174   pFormat += 2;
2175
2176   pStubMsg->Memory = pMemory;
2177
2178   pMemory = ComplexBufferSize(pStubMsg, pMemory, pFormat, pointer_desc);
2179
2180   if (conf_array)
2181     NdrConformantArrayBufferSize(pStubMsg, pMemory, conf_array);
2182
2183   pStubMsg->Memory = OldMemory;
2184 }
2185
2186 /***********************************************************************
2187  *           NdrComplexStructMemorySize [RPCRT4.@]
2188  */
2189 ULONG WINAPI NdrComplexStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2190                                         PFORMAT_STRING pFormat)
2191 {
2192   unsigned size = *(const WORD*)(pFormat+2);
2193   PFORMAT_STRING conf_array = NULL;
2194   PFORMAT_STRING pointer_desc = NULL;
2195
2196   TRACE("(%p,%p)\n", pStubMsg, pFormat);
2197
2198   ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
2199
2200   pFormat += 4;
2201   if (*(const WORD*)pFormat) conf_array = pFormat + *(const WORD*)pFormat;
2202   pFormat += 2;
2203   if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
2204   pFormat += 2;
2205
2206   ComplexStructMemorySize(pStubMsg, pFormat);
2207
2208   if (conf_array)
2209     NdrConformantArrayMemorySize(pStubMsg, conf_array);
2210
2211   return size;
2212 }
2213
2214 /***********************************************************************
2215  *           NdrComplexStructFree [RPCRT4.@]
2216  */
2217 void WINAPI NdrComplexStructFree(PMIDL_STUB_MESSAGE pStubMsg,
2218                                  unsigned char *pMemory,
2219                                  PFORMAT_STRING pFormat)
2220 {
2221   PFORMAT_STRING conf_array = NULL;
2222   PFORMAT_STRING pointer_desc = NULL;
2223   unsigned char *OldMemory = pStubMsg->Memory;
2224
2225   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2226
2227   pFormat += 4;
2228   if (*(const WORD*)pFormat) conf_array = pFormat + *(const WORD*)pFormat;
2229   pFormat += 2;
2230   if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
2231   pFormat += 2;
2232
2233   pStubMsg->Memory = pMemory;
2234
2235   pMemory = ComplexFree(pStubMsg, pMemory, pFormat, pointer_desc);
2236
2237   if (conf_array)
2238     NdrConformantArrayFree(pStubMsg, pMemory, conf_array);
2239
2240   pStubMsg->Memory = OldMemory;
2241 }
2242
2243 /***********************************************************************
2244  *           NdrConformantArrayMarshall [RPCRT4.@]
2245  */
2246 unsigned char * WINAPI NdrConformantArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2247                                                   unsigned char *pMemory,
2248                                                   PFORMAT_STRING pFormat)
2249 {
2250   DWORD size = 0, esize = *(const WORD*)(pFormat+2);
2251   unsigned char alignment = pFormat[1] + 1;
2252
2253   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2254   if (pFormat[0] != RPC_FC_CARRAY) FIXME("format=%d\n", pFormat[0]);
2255
2256   pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
2257
2258   WriteConformance(pStubMsg);
2259
2260   ALIGN_POINTER(pStubMsg->Buffer, alignment);
2261
2262   size = safe_multiply(esize, pStubMsg->MaxCount);
2263   memcpy(pStubMsg->Buffer, pMemory, size);
2264   pStubMsg->BufferMark = pStubMsg->Buffer;
2265   pStubMsg->Buffer += size;
2266
2267   EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
2268
2269   STD_OVERFLOW_CHECK(pStubMsg);
2270
2271   return NULL;
2272 }
2273
2274 /***********************************************************************
2275  *           NdrConformantArrayUnmarshall [RPCRT4.@]
2276  */
2277 unsigned char * WINAPI NdrConformantArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2278                                                     unsigned char **ppMemory,
2279                                                     PFORMAT_STRING pFormat,
2280                                                     unsigned char fMustAlloc)
2281 {
2282   DWORD size, esize = *(const WORD*)(pFormat+2);
2283   unsigned char alignment = pFormat[1] + 1;
2284
2285   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
2286   if (pFormat[0] != RPC_FC_CARRAY) FIXME("format=%d\n", pFormat[0]);
2287
2288   pFormat = ReadConformance(pStubMsg, pFormat+4);
2289
2290   size = safe_multiply(esize, pStubMsg->MaxCount);
2291
2292   if (fMustAlloc || !*ppMemory)
2293     *ppMemory = NdrAllocate(pStubMsg, size);
2294
2295   ALIGN_POINTER(pStubMsg->Buffer, alignment);
2296
2297   memcpy(*ppMemory, pStubMsg->Buffer, size);
2298
2299   pStubMsg->BufferMark = pStubMsg->Buffer;
2300   pStubMsg->Buffer += size;
2301
2302   EmbeddedPointerUnmarshall(pStubMsg, ppMemory, pFormat, fMustAlloc);
2303
2304   return NULL;
2305 }
2306
2307 /***********************************************************************
2308  *           NdrConformantArrayBufferSize [RPCRT4.@]
2309  */
2310 void WINAPI NdrConformantArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2311                                          unsigned char *pMemory,
2312                                          PFORMAT_STRING pFormat)
2313 {
2314   DWORD size, esize = *(const WORD*)(pFormat+2);
2315   unsigned char alignment = pFormat[1] + 1;
2316
2317   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2318   if (pFormat[0] != RPC_FC_CARRAY) FIXME("format=%d\n", pFormat[0]);
2319
2320   pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
2321
2322   SizeConformance(pStubMsg);
2323
2324   ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
2325
2326   size = safe_multiply(esize, pStubMsg->MaxCount);
2327   /* conformance value plus array */
2328   pStubMsg->BufferLength += size;
2329
2330   EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
2331 }
2332
2333 /***********************************************************************
2334  *           NdrConformantArrayMemorySize [RPCRT4.@]
2335  */
2336 ULONG WINAPI NdrConformantArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2337                                           PFORMAT_STRING pFormat)
2338 {
2339   DWORD size = 0, esize = *(const WORD*)(pFormat+2);
2340   unsigned char alignment = pFormat[1] + 1;
2341
2342   TRACE("(%p,%p)\n", pStubMsg, pFormat);
2343   if (pFormat[0] != RPC_FC_CARRAY) FIXME("format=%d\n", pFormat[0]);
2344
2345   pFormat = ReadConformance(pStubMsg, pFormat+4);
2346   size = safe_multiply(esize, pStubMsg->MaxCount);
2347   pStubMsg->MemorySize += size;
2348
2349   ALIGN_POINTER(pStubMsg->Buffer, alignment);
2350   pStubMsg->BufferMark = pStubMsg->Buffer;
2351   pStubMsg->Buffer += size;
2352
2353   EmbeddedPointerMemorySize(pStubMsg, pFormat);
2354
2355   return pStubMsg->MemorySize;
2356 }
2357
2358 /***********************************************************************
2359  *           NdrConformantArrayFree [RPCRT4.@]
2360  */
2361 void WINAPI NdrConformantArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
2362                                    unsigned char *pMemory,
2363                                    PFORMAT_STRING pFormat)
2364 {
2365   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2366   if (pFormat[0] != RPC_FC_CARRAY) FIXME("format=%d\n", pFormat[0]);
2367
2368   pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
2369
2370   EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
2371 }
2372
2373
2374 /***********************************************************************
2375  *           NdrConformantVaryingArrayMarshall  [RPCRT4.@]
2376  */
2377 unsigned char* WINAPI NdrConformantVaryingArrayMarshall( PMIDL_STUB_MESSAGE pStubMsg,
2378                                                          unsigned char* pMemory,
2379                                                          PFORMAT_STRING pFormat )
2380 {
2381     ULONG bufsize;
2382     unsigned char alignment = pFormat[1] + 1;
2383     DWORD esize = *(const WORD*)(pFormat+2);
2384
2385     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
2386
2387     if (pFormat[0] != RPC_FC_CVARRAY)
2388     {
2389         ERR("invalid format type %x\n", pFormat[0]);
2390         RpcRaiseException(RPC_S_INTERNAL_ERROR);
2391         return NULL;
2392     }
2393
2394     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
2395     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
2396
2397     WriteConformance(pStubMsg);
2398     WriteVariance(pStubMsg);
2399
2400     ALIGN_POINTER(pStubMsg->Buffer, alignment);
2401
2402     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
2403
2404     memcpy(pStubMsg->Buffer, pMemory + pStubMsg->Offset, bufsize);
2405     pStubMsg->BufferMark = pStubMsg->Buffer;
2406     pStubMsg->Buffer += bufsize;
2407
2408     EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
2409
2410     STD_OVERFLOW_CHECK(pStubMsg);
2411
2412     return NULL;
2413 }
2414
2415
2416 /***********************************************************************
2417  *           NdrConformantVaryingArrayUnmarshall  [RPCRT4.@]
2418  */
2419 unsigned char* WINAPI NdrConformantVaryingArrayUnmarshall( PMIDL_STUB_MESSAGE pStubMsg,
2420                                                            unsigned char** ppMemory,
2421                                                            PFORMAT_STRING pFormat,
2422                                                            unsigned char fMustAlloc )
2423 {
2424     ULONG bufsize, memsize;
2425     unsigned char alignment = pFormat[1] + 1;
2426     DWORD esize = *(const WORD*)(pFormat+2);
2427
2428     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
2429
2430     if (pFormat[0] != RPC_FC_CVARRAY)
2431     {
2432         ERR("invalid format type %x\n", pFormat[0]);
2433         RpcRaiseException(RPC_S_INTERNAL_ERROR);
2434         return NULL;
2435     }
2436
2437     pFormat = ReadConformance(pStubMsg, pFormat+4);
2438     pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
2439
2440     ALIGN_POINTER(pStubMsg->Buffer, alignment);
2441
2442     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
2443     memsize = safe_multiply(esize, pStubMsg->MaxCount);
2444
2445     if (!*ppMemory || fMustAlloc)
2446         *ppMemory = NdrAllocate(pStubMsg, memsize);
2447     memcpy(*ppMemory + pStubMsg->Offset, pStubMsg->Buffer, bufsize);
2448     pStubMsg->Buffer += bufsize;
2449
2450     EmbeddedPointerUnmarshall(pStubMsg, ppMemory, pFormat, fMustAlloc);
2451
2452     return NULL;
2453 }
2454
2455
2456 /***********************************************************************
2457  *           NdrConformantVaryingArrayFree  [RPCRT4.@]
2458  */
2459 void WINAPI NdrConformantVaryingArrayFree( PMIDL_STUB_MESSAGE pStubMsg,
2460                                            unsigned char* pMemory,
2461                                            PFORMAT_STRING pFormat )
2462 {
2463     TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2464
2465     if (pFormat[0] != RPC_FC_CVARRAY)
2466     {
2467         ERR("invalid format type %x\n", pFormat[0]);
2468         RpcRaiseException(RPC_S_INTERNAL_ERROR);
2469         return;
2470     }
2471
2472     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
2473     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
2474
2475     EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
2476 }
2477
2478
2479 /***********************************************************************
2480  *           NdrConformantVaryingArrayBufferSize  [RPCRT4.@]
2481  */
2482 void WINAPI NdrConformantVaryingArrayBufferSize( PMIDL_STUB_MESSAGE pStubMsg,
2483                                                  unsigned char* pMemory, PFORMAT_STRING pFormat )
2484 {
2485     unsigned char alignment = pFormat[1] + 1;
2486     DWORD esize = *(const WORD*)(pFormat+2);
2487
2488     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
2489
2490     if (pFormat[0] != RPC_FC_CVARRAY)
2491     {
2492         ERR("invalid format type %x\n", pFormat[0]);
2493         RpcRaiseException(RPC_S_INTERNAL_ERROR);
2494         return;
2495     }
2496
2497     /* compute size */
2498     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
2499     /* compute length */
2500     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
2501
2502     SizeConformance(pStubMsg);
2503     SizeVariance(pStubMsg);
2504
2505     ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
2506
2507     pStubMsg->BufferLength += safe_multiply(esize, pStubMsg->ActualCount);
2508
2509     EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
2510 }
2511
2512
2513 /***********************************************************************
2514  *           NdrConformantVaryingArrayMemorySize  [RPCRT4.@]
2515  */
2516 ULONG WINAPI NdrConformantVaryingArrayMemorySize( PMIDL_STUB_MESSAGE pStubMsg,
2517                                                   PFORMAT_STRING pFormat )
2518 {
2519     FIXME( "stub\n" );
2520     return 0;
2521 }
2522
2523
2524 /***********************************************************************
2525  *           NdrComplexArrayMarshall [RPCRT4.@]
2526  */
2527 unsigned char * WINAPI NdrComplexArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2528                                                unsigned char *pMemory,
2529                                                PFORMAT_STRING pFormat)
2530 {
2531   ULONG i, count, def;
2532   BOOL variance_present;
2533   unsigned char alignment;
2534
2535   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2536
2537   if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
2538   {
2539       ERR("invalid format type %x\n", pFormat[0]);
2540       RpcRaiseException(RPC_S_INTERNAL_ERROR);
2541       return NULL;
2542   }
2543
2544   alignment = pFormat[1] + 1;
2545
2546   def = *(const WORD*)&pFormat[2];
2547   pFormat += 4;
2548
2549   pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
2550   TRACE("conformance = %ld\n", pStubMsg->MaxCount);
2551
2552   variance_present = IsConformanceOrVariancePresent(pFormat);
2553   pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
2554   TRACE("variance = %d\n", pStubMsg->ActualCount);
2555
2556   WriteConformance(pStubMsg);
2557   if (variance_present)
2558     WriteVariance(pStubMsg);
2559
2560   ALIGN_POINTER(pStubMsg->Buffer, alignment);
2561
2562   count = pStubMsg->ActualCount;
2563   for (i = 0; i < count; i++)
2564     pMemory = ComplexMarshall(pStubMsg, pMemory, pFormat, NULL);
2565
2566   STD_OVERFLOW_CHECK(pStubMsg);
2567
2568   return NULL;
2569 }
2570
2571 /***********************************************************************
2572  *           NdrComplexArrayUnmarshall [RPCRT4.@]
2573  */
2574 unsigned char * WINAPI NdrComplexArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2575                                                  unsigned char **ppMemory,
2576                                                  PFORMAT_STRING pFormat,
2577                                                  unsigned char fMustAlloc)
2578 {
2579   ULONG i, count, esize, memsize;
2580   unsigned char alignment;
2581   unsigned char *pMemory;
2582   unsigned char *Buffer;
2583
2584   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
2585
2586   if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
2587   {
2588       ERR("invalid format type %x\n", pFormat[0]);
2589       RpcRaiseException(RPC_S_INTERNAL_ERROR);
2590       return NULL;
2591   }
2592
2593   alignment = pFormat[1] + 1;
2594
2595   pFormat += 4;
2596
2597   pFormat = ReadConformance(pStubMsg, pFormat);
2598   pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
2599
2600   Buffer = pStubMsg->Buffer;
2601   pStubMsg->MemorySize = 0;
2602   esize = ComplexStructMemorySize(pStubMsg, pFormat);
2603   pStubMsg->Buffer = Buffer;
2604
2605   /* do multiply here instead of inside if block to verify MaxCount */
2606   memsize = safe_multiply(esize, pStubMsg->MaxCount);
2607   if (fMustAlloc || !*ppMemory)
2608   {
2609     *ppMemory = NdrAllocate(pStubMsg, memsize);
2610     memset(*ppMemory, 0, memsize);
2611   }
2612
2613   ALIGN_POINTER(pStubMsg->Buffer, alignment);
2614
2615   pMemory = *ppMemory;
2616   count = pStubMsg->ActualCount;
2617   for (i = 0; i < count; i++)
2618     pMemory = ComplexUnmarshall(pStubMsg, pMemory, pFormat, NULL);
2619
2620   return NULL;
2621 }
2622
2623 /***********************************************************************
2624  *           NdrComplexArrayBufferSize [RPCRT4.@]
2625  */
2626 void WINAPI NdrComplexArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2627                                       unsigned char *pMemory,
2628                                       PFORMAT_STRING pFormat)
2629 {
2630   ULONG i, count, def;
2631   unsigned char alignment;
2632   BOOL variance_present;
2633
2634   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2635
2636   if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
2637   {
2638       ERR("invalid format type %x\n", pFormat[0]);
2639       RpcRaiseException(RPC_S_INTERNAL_ERROR);
2640       return;
2641   }
2642
2643   alignment = pFormat[1] + 1;
2644
2645   def = *(const WORD*)&pFormat[2];
2646   pFormat += 4;
2647
2648   pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
2649   TRACE("conformance = %ld\n", pStubMsg->MaxCount);
2650   SizeConformance(pStubMsg);
2651
2652   variance_present = IsConformanceOrVariancePresent(pFormat);
2653   pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
2654   TRACE("variance = %d\n", pStubMsg->ActualCount);
2655
2656   if (variance_present)
2657     SizeVariance(pStubMsg);
2658
2659   ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
2660
2661   count = pStubMsg->ActualCount;
2662   for (i = 0; i < count; i++)
2663     pMemory = ComplexBufferSize(pStubMsg, pMemory, pFormat, NULL);
2664 }
2665
2666 /***********************************************************************
2667  *           NdrComplexArrayMemorySize [RPCRT4.@]
2668  */
2669 ULONG WINAPI NdrComplexArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2670                                        PFORMAT_STRING pFormat)
2671 {
2672   ULONG i, count, esize, SavedMemorySize, MemorySize;
2673   unsigned char alignment;
2674   unsigned char *Buffer;
2675
2676   TRACE("(%p,%p)\n", pStubMsg, pFormat);
2677
2678   if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
2679   {
2680       ERR("invalid format type %x\n", pFormat[0]);
2681       RpcRaiseException(RPC_S_INTERNAL_ERROR);
2682       return 0;
2683   }
2684
2685   alignment = pFormat[1] + 1;
2686
2687   pFormat += 4;
2688
2689   pFormat = ReadConformance(pStubMsg, pFormat);
2690   pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
2691
2692   ALIGN_POINTER(pStubMsg->Buffer, alignment);
2693
2694   SavedMemorySize = pStubMsg->MemorySize;
2695
2696   Buffer = pStubMsg->Buffer;
2697   pStubMsg->MemorySize = 0;
2698   esize = ComplexStructMemorySize(pStubMsg, pFormat);
2699   pStubMsg->Buffer = Buffer;
2700
2701   MemorySize = safe_multiply(pStubMsg->MaxCount, esize);
2702
2703   count = pStubMsg->ActualCount;
2704   for (i = 0; i < count; i++)
2705     ComplexStructMemorySize(pStubMsg, pFormat);
2706
2707   pStubMsg->MemorySize = SavedMemorySize;
2708
2709   pStubMsg->MemorySize += MemorySize;
2710   return MemorySize;
2711 }
2712
2713 /***********************************************************************
2714  *           NdrComplexArrayFree [RPCRT4.@]
2715  */
2716 void WINAPI NdrComplexArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
2717                                 unsigned char *pMemory,
2718                                 PFORMAT_STRING pFormat)
2719 {
2720   ULONG i, count, def;
2721
2722   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2723
2724   if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
2725   {
2726       ERR("invalid format type %x\n", pFormat[0]);
2727       RpcRaiseException(RPC_S_INTERNAL_ERROR);
2728       return;
2729   }
2730
2731   def = *(const WORD*)&pFormat[2];
2732   pFormat += 4;
2733
2734   pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
2735   TRACE("conformance = %ld\n", pStubMsg->MaxCount);
2736
2737   pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
2738   TRACE("variance = %d\n", pStubMsg->ActualCount);
2739
2740   count = pStubMsg->ActualCount;
2741   for (i = 0; i < count; i++)
2742     pMemory = ComplexFree(pStubMsg, pMemory, pFormat, NULL);
2743 }
2744
2745 static ULONG UserMarshalFlags(PMIDL_STUB_MESSAGE pStubMsg)
2746 {
2747   return MAKELONG(pStubMsg->dwDestContext,
2748                   pStubMsg->RpcMsg->DataRepresentation);
2749 }
2750
2751 #define USER_MARSHAL_PTR_PREFIX \
2752         ( (DWORD)'U'         | ( (DWORD)'s' << 8 ) | \
2753         ( (DWORD)'e' << 16 ) | ( (DWORD)'r' << 24 ) )
2754
2755 /***********************************************************************
2756  *           NdrUserMarshalMarshall [RPCRT4.@]
2757  */
2758 unsigned char * WINAPI NdrUserMarshalMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2759                                               unsigned char *pMemory,
2760                                               PFORMAT_STRING pFormat)
2761 {
2762   unsigned flags = pFormat[1];
2763   unsigned index = *(const WORD*)&pFormat[2];
2764   ULONG uflag = UserMarshalFlags(pStubMsg);
2765   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2766   TRACE("index=%d\n", index);
2767
2768   if (flags & USER_MARSHAL_POINTER)
2769   {
2770     ALIGN_POINTER(pStubMsg->Buffer, 4);
2771     NDR_LOCAL_UINT32_WRITE(pStubMsg->Buffer, USER_MARSHAL_PTR_PREFIX);
2772     pStubMsg->Buffer += 4;
2773     ALIGN_POINTER(pStubMsg->Buffer, 8);
2774   }
2775   else
2776     ALIGN_POINTER(pStubMsg->Buffer, (flags & 0xf) + 1);
2777
2778   pStubMsg->Buffer =
2779     pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnMarshall(
2780       &uflag, pStubMsg->Buffer, pMemory);
2781
2782   STD_OVERFLOW_CHECK(pStubMsg);
2783
2784   return NULL;
2785 }
2786
2787 /***********************************************************************
2788  *           NdrUserMarshalUnmarshall [RPCRT4.@]
2789  */
2790 unsigned char * WINAPI NdrUserMarshalUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2791                                                  unsigned char **ppMemory,
2792                                                  PFORMAT_STRING pFormat,
2793                                                  unsigned char fMustAlloc)
2794 {
2795   unsigned flags = pFormat[1];
2796   unsigned index = *(const WORD*)&pFormat[2];
2797   DWORD memsize = *(const WORD*)&pFormat[4];
2798   ULONG uflag = UserMarshalFlags(pStubMsg);
2799   TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
2800   TRACE("index=%d\n", index);
2801
2802   if (flags & USER_MARSHAL_POINTER)
2803   {
2804     ALIGN_POINTER(pStubMsg->Buffer, 4);
2805     /* skip pointer prefix */
2806     pStubMsg->Buffer += 4;
2807     ALIGN_POINTER(pStubMsg->Buffer, 8);
2808   }
2809   else
2810     ALIGN_POINTER(pStubMsg->Buffer, (flags & 0xf) + 1);
2811
2812   if (fMustAlloc || !*ppMemory)
2813     *ppMemory = NdrAllocate(pStubMsg, memsize);
2814
2815   pStubMsg->Buffer =
2816     pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnUnmarshall(
2817       &uflag, pStubMsg->Buffer, *ppMemory);
2818
2819   return NULL;
2820 }
2821
2822 /***********************************************************************
2823  *           NdrUserMarshalBufferSize [RPCRT4.@]
2824  */
2825 void WINAPI NdrUserMarshalBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2826                                       unsigned char *pMemory,
2827                                       PFORMAT_STRING pFormat)
2828 {
2829   unsigned flags = pFormat[1];
2830   unsigned index = *(const WORD*)&pFormat[2];
2831   DWORD bufsize = *(const WORD*)&pFormat[6];
2832   ULONG uflag = UserMarshalFlags(pStubMsg);
2833   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2834   TRACE("index=%d\n", index);
2835
2836   if (flags & USER_MARSHAL_POINTER)
2837   {
2838     ALIGN_LENGTH(pStubMsg->BufferLength, 4);
2839     /* skip pointer prefix */
2840     pStubMsg->BufferLength += 4;
2841     ALIGN_LENGTH(pStubMsg->BufferLength, 8);
2842   }
2843   else
2844     ALIGN_LENGTH(pStubMsg->BufferLength, (flags & 0xf) + 1);
2845
2846   if (bufsize) {
2847     TRACE("size=%d\n", bufsize);
2848     pStubMsg->BufferLength += bufsize;
2849     return;
2850   }
2851
2852   pStubMsg->BufferLength =
2853     pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnBufferSize(
2854       &uflag, pStubMsg->BufferLength, pMemory);
2855 }
2856
2857 /***********************************************************************
2858  *           NdrUserMarshalMemorySize [RPCRT4.@]
2859  */
2860 ULONG WINAPI NdrUserMarshalMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2861                                       PFORMAT_STRING pFormat)
2862 {
2863   unsigned flags = pFormat[1];
2864   unsigned index = *(const WORD*)&pFormat[2];
2865   DWORD memsize = *(const WORD*)&pFormat[4];
2866   DWORD bufsize = *(const WORD*)&pFormat[6];
2867
2868   TRACE("(%p,%p)\n", pStubMsg, pFormat);
2869   TRACE("index=%d\n", index);
2870
2871   pStubMsg->MemorySize += memsize;
2872
2873   if (flags & USER_MARSHAL_POINTER)
2874   {
2875     ALIGN_POINTER(pStubMsg->Buffer, 4);
2876     /* skip pointer prefix */
2877     pStubMsg->Buffer += 4;
2878     ALIGN_POINTER(pStubMsg->Buffer, 8);
2879   }
2880   else
2881     ALIGN_POINTER(pStubMsg->Buffer, (flags & 0xf) + 1);
2882
2883   pStubMsg->Buffer += bufsize;
2884
2885   return pStubMsg->MemorySize;
2886 }
2887
2888 /***********************************************************************
2889  *           NdrUserMarshalFree [RPCRT4.@]
2890  */
2891 void WINAPI NdrUserMarshalFree(PMIDL_STUB_MESSAGE pStubMsg,
2892                                 unsigned char *pMemory,
2893                                 PFORMAT_STRING pFormat)
2894 {
2895 /*  unsigned flags = pFormat[1]; */
2896   unsigned index = *(const WORD*)&pFormat[2];
2897   ULONG uflag = UserMarshalFlags(pStubMsg);
2898   TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2899   TRACE("index=%d\n", index);
2900
2901   pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnFree(
2902     &uflag, pMemory);
2903 }
2904
2905 /***********************************************************************
2906  *           NdrClearOutParameters [RPCRT4.@]
2907  */
2908 void WINAPI NdrClearOutParameters(PMIDL_STUB_MESSAGE pStubMsg,
2909                                   PFORMAT_STRING pFormat,
2910                                   void *ArgAddr)
2911 {
2912   FIXME("(%p,%p,%p): stub\n", pStubMsg, pFormat, ArgAddr);
2913 }
2914
2915 /***********************************************************************
2916  *           NdrConvert [RPCRT4.@]
2917  */
2918 void WINAPI NdrConvert( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat )
2919 {
2920   FIXME("(pStubMsg == ^%p, pFormat == ^%p): stub.\n", pStubMsg, pFormat);
2921   /* FIXME: since this stub doesn't do any converting, the proper behavior
2922      is to raise an exception */
2923 }
2924
2925 /***********************************************************************
2926  *           NdrConvert2 [RPCRT4.@]
2927  */
2928 void WINAPI NdrConvert2( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, LONG NumberParams )
2929 {
2930   FIXME("(pStubMsg == ^%p, pFormat == ^%p, NumberParams == %d): stub.\n",
2931     pStubMsg, pFormat, NumberParams);
2932   /* FIXME: since this stub doesn't do any converting, the proper behavior
2933      is to raise an exception */
2934 }
2935
2936 typedef struct _NDR_CSTRUCT_FORMAT
2937 {
2938     unsigned char type;
2939     unsigned char alignment;
2940     unsigned short memory_size;
2941     short offset_to_array_description;
2942 } NDR_CSTRUCT_FORMAT, NDR_CVSTRUCT_FORMAT;
2943
2944 /***********************************************************************
2945  *           NdrConformantStructMarshall [RPCRT4.@]
2946  */
2947 unsigned char *  WINAPI NdrConformantStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2948                                 unsigned char *pMemory,
2949                                 PFORMAT_STRING pFormat)
2950 {
2951     const NDR_CSTRUCT_FORMAT *pCStructFormat = (const NDR_CSTRUCT_FORMAT *)pFormat;
2952     PFORMAT_STRING pCArrayFormat;
2953     ULONG esize, bufsize;
2954
2955     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
2956
2957     pFormat += sizeof(NDR_CSTRUCT_FORMAT);
2958     if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT))
2959     {
2960         ERR("invalid format type %x\n", pCStructFormat->type);
2961         RpcRaiseException(RPC_S_INTERNAL_ERROR);
2962         return NULL;
2963     }
2964
2965     pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description +
2966         pCStructFormat->offset_to_array_description;
2967     if (*pCArrayFormat != RPC_FC_CARRAY)
2968     {
2969         ERR("invalid array format type %x\n", pCStructFormat->type);
2970         RpcRaiseException(RPC_S_INTERNAL_ERROR);
2971         return NULL;
2972     }
2973     esize = *(const WORD*)(pCArrayFormat+2);
2974
2975     ComputeConformance(pStubMsg, pMemory + pCStructFormat->memory_size,
2976                        pCArrayFormat + 4, 0);
2977
2978     WriteConformance(pStubMsg);
2979
2980     ALIGN_POINTER(pStubMsg->Buffer, pCStructFormat->alignment + 1);
2981
2982     TRACE("memory_size = %d\n", pCStructFormat->memory_size);
2983
2984     bufsize = safe_multiply(esize, pStubMsg->MaxCount);
2985     /* copy constant sized part of struct */
2986     pStubMsg->BufferMark = pStubMsg->Buffer;
2987     memcpy(pStubMsg->Buffer, pMemory, pCStructFormat->memory_size + bufsize);
2988     pStubMsg->Buffer += pCStructFormat->memory_size + bufsize;
2989
2990     if (pCStructFormat->type == RPC_FC_CPSTRUCT)
2991         EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
2992
2993     STD_OVERFLOW_CHECK(pStubMsg);
2994
2995     return NULL;
2996 }
2997
2998 /***********************************************************************
2999  *           NdrConformantStructUnmarshall [RPCRT4.@]
3000  */
3001 unsigned char *  WINAPI NdrConformantStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
3002                                 unsigned char **ppMemory,
3003                                 PFORMAT_STRING pFormat,
3004                                 unsigned char fMustAlloc)
3005 {
3006     const NDR_CSTRUCT_FORMAT *pCStructFormat = (const NDR_CSTRUCT_FORMAT *)pFormat;
3007     PFORMAT_STRING pCArrayFormat;
3008     ULONG esize, bufsize;
3009
3010     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
3011
3012     pFormat += sizeof(NDR_CSTRUCT_FORMAT);
3013     if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT))
3014     {
3015         ERR("invalid format type %x\n", pCStructFormat->type);
3016         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3017         return NULL;
3018     }
3019     pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description +
3020         pCStructFormat->offset_to_array_description;
3021     if (*pCArrayFormat != RPC_FC_CARRAY)
3022     {
3023         ERR("invalid array format type %x\n", pCStructFormat->type);
3024         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3025         return NULL;
3026     }
3027     esize = *(const WORD*)(pCArrayFormat+2);
3028
3029     pCArrayFormat = ReadConformance(pStubMsg, pCArrayFormat + 4);
3030
3031     ALIGN_POINTER(pStubMsg->Buffer, pCStructFormat->alignment + 1);
3032
3033     TRACE("memory_size = %d\n", pCStructFormat->memory_size);
3034
3035     bufsize = safe_multiply(esize, pStubMsg->MaxCount);
3036     /* work out how much memory to allocate if we need to do so */
3037     if (!*ppMemory || fMustAlloc)
3038     {
3039         SIZE_T size = pCStructFormat->memory_size + bufsize;
3040         *ppMemory = NdrAllocate(pStubMsg, size);
3041     }
3042
3043     /* now copy the data */
3044     pStubMsg->BufferMark = pStubMsg->Buffer;
3045     memcpy(*ppMemory, pStubMsg->Buffer, pCStructFormat->memory_size + bufsize);
3046     pStubMsg->Buffer += pCStructFormat->memory_size + bufsize;
3047
3048     if (pCStructFormat->type == RPC_FC_CPSTRUCT)
3049         EmbeddedPointerUnmarshall(pStubMsg, ppMemory, pFormat, fMustAlloc);
3050
3051     return NULL;
3052 }
3053
3054 /***********************************************************************
3055  *           NdrConformantStructBufferSize [RPCRT4.@]
3056  */
3057 void WINAPI NdrConformantStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
3058                                 unsigned char *pMemory,
3059                                 PFORMAT_STRING pFormat)
3060 {
3061     const NDR_CSTRUCT_FORMAT * pCStructFormat = (const NDR_CSTRUCT_FORMAT *)pFormat;
3062     PFORMAT_STRING pCArrayFormat;
3063     ULONG esize;
3064
3065     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
3066
3067     pFormat += sizeof(NDR_CSTRUCT_FORMAT);
3068     if ((pCStructFormat->type != RPC_FC_CPSTRUCT) && (pCStructFormat->type != RPC_FC_CSTRUCT))
3069     {
3070         ERR("invalid format type %x\n", pCStructFormat->type);
3071         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3072         return;
3073     }
3074     pCArrayFormat = (const unsigned char *)&pCStructFormat->offset_to_array_description +
3075         pCStructFormat->offset_to_array_description;
3076     if (*pCArrayFormat != RPC_FC_CARRAY)
3077     {
3078         ERR("invalid array format type %x\n", pCStructFormat->type);
3079         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3080         return;
3081     }
3082     esize = *(const WORD*)(pCArrayFormat+2);
3083
3084     pCArrayFormat = ComputeConformance(pStubMsg, pMemory + pCStructFormat->memory_size, pCArrayFormat+4, 0);
3085     SizeConformance(pStubMsg);
3086
3087     ALIGN_LENGTH(pStubMsg->BufferLength, pCStructFormat->alignment + 1);
3088
3089     TRACE("memory_size = %d\n", pCStructFormat->memory_size);
3090
3091     pStubMsg->BufferLength += pCStructFormat->memory_size +
3092         safe_multiply(pStubMsg->MaxCount, esize);
3093
3094     if (pCStructFormat->type == RPC_FC_CPSTRUCT)
3095         EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
3096 }
3097
3098 /***********************************************************************
3099  *           NdrConformantStructMemorySize [RPCRT4.@]
3100  */
3101 ULONG WINAPI NdrConformantStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
3102                                 PFORMAT_STRING pFormat)
3103 {
3104     FIXME("stub\n");
3105     return 0;
3106 }
3107
3108 /***********************************************************************
3109  *           NdrConformantStructFree [RPCRT4.@]
3110  */
3111 void WINAPI NdrConformantStructFree(PMIDL_STUB_MESSAGE pStubMsg,
3112                                 unsigned char *pMemory,
3113                                 PFORMAT_STRING pFormat)
3114 {
3115     FIXME("stub\n");
3116 }
3117
3118 /***********************************************************************
3119  *           NdrConformantVaryingStructMarshall [RPCRT4.@]
3120  */
3121 unsigned char *  WINAPI NdrConformantVaryingStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
3122                                 unsigned char *pMemory,
3123                                 PFORMAT_STRING pFormat)
3124 {
3125     const NDR_CVSTRUCT_FORMAT *pCVStructFormat = (const NDR_CVSTRUCT_FORMAT *)pFormat;
3126     PFORMAT_STRING pCVArrayFormat;
3127     ULONG esize, bufsize;
3128
3129     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
3130
3131     pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
3132     if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
3133     {
3134         ERR("invalid format type %x\n", pCVStructFormat->type);
3135         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3136         return NULL;
3137     }
3138
3139     pCVArrayFormat = (const unsigned char *)&pCVStructFormat->offset_to_array_description +
3140         pCVStructFormat->offset_to_array_description;
3141     switch (*pCVArrayFormat)
3142     {
3143     case RPC_FC_CVARRAY:
3144         esize = *(const WORD*)(pCVArrayFormat+2);
3145
3146         pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
3147                                             pCVArrayFormat + 4, 0);
3148         pCVArrayFormat = ComputeVariance(pStubMsg, pMemory + pCVStructFormat->memory_size,
3149                                          pCVArrayFormat, 0);
3150         break;
3151     case RPC_FC_C_CSTRING:
3152         TRACE("string=%s\n", debugstr_a((char*)pMemory + pCVStructFormat->memory_size));
3153         pStubMsg->ActualCount = strlen((char*)pMemory + pCVStructFormat->memory_size)+1;
3154         esize = sizeof(char);
3155         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
3156             pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
3157                                                 pCVArrayFormat + 2, 0);
3158         else
3159             pStubMsg->MaxCount = pStubMsg->ActualCount;
3160         break;
3161     case RPC_FC_C_WSTRING:
3162         TRACE("string=%s\n", debugstr_w((LPWSTR)pMemory + pCVStructFormat->memory_size));
3163         pStubMsg->ActualCount = strlenW((LPWSTR)pMemory + pCVStructFormat->memory_size)+1;
3164         esize = sizeof(WCHAR);
3165         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
3166             pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
3167                                                 pCVArrayFormat + 2, 0);
3168         else
3169             pStubMsg->MaxCount = pStubMsg->ActualCount;
3170         break;
3171     default:
3172         ERR("invalid array format type %x\n", *pCVArrayFormat);
3173         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3174         return NULL;
3175     }
3176
3177     WriteConformance(pStubMsg);
3178
3179     ALIGN_POINTER(pStubMsg->Buffer, pCVStructFormat->alignment + 1);
3180
3181     TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
3182
3183     /* write constant sized part */
3184     pStubMsg->BufferMark = pStubMsg->Buffer;
3185     memcpy(pStubMsg->Buffer, pMemory, pCVStructFormat->memory_size);
3186     pStubMsg->Buffer += pCVStructFormat->memory_size;
3187
3188     WriteVariance(pStubMsg);
3189
3190     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
3191
3192     /* write array part */
3193     memcpy(pStubMsg->Buffer, pMemory + pCVStructFormat->memory_size, bufsize);
3194     pStubMsg->Buffer += bufsize;
3195
3196     EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
3197
3198     STD_OVERFLOW_CHECK(pStubMsg);
3199
3200     return NULL;
3201 }
3202
3203 /***********************************************************************
3204  *           NdrConformantVaryingStructUnmarshall [RPCRT4.@]
3205  */
3206 unsigned char *  WINAPI NdrConformantVaryingStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
3207                                 unsigned char **ppMemory,
3208                                 PFORMAT_STRING pFormat,
3209                                 unsigned char fMustAlloc)
3210 {
3211     const NDR_CVSTRUCT_FORMAT *pCVStructFormat = (const NDR_CVSTRUCT_FORMAT *)pFormat;
3212     PFORMAT_STRING pCVArrayFormat;
3213     ULONG esize, bufsize;
3214     unsigned char cvarray_type;
3215
3216     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
3217
3218     pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
3219     if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
3220     {
3221         ERR("invalid format type %x\n", pCVStructFormat->type);
3222         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3223         return NULL;
3224     }
3225
3226     pCVArrayFormat = (const unsigned char *)&pCVStructFormat->offset_to_array_description +
3227         pCVStructFormat->offset_to_array_description;
3228     cvarray_type = *pCVArrayFormat;
3229     switch (cvarray_type)
3230     {
3231     case RPC_FC_CVARRAY:
3232         esize = *(const WORD*)(pCVArrayFormat+2);
3233         pCVArrayFormat = ReadConformance(pStubMsg, pCVArrayFormat + 4);
3234         break;
3235     case RPC_FC_C_CSTRING:
3236         esize = sizeof(char);
3237         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
3238             pCVArrayFormat = ReadConformance(pStubMsg, pCVArrayFormat + 2);
3239         else
3240             pCVArrayFormat = ReadConformance(pStubMsg, NULL);
3241         break;
3242     case RPC_FC_C_WSTRING:
3243         esize = sizeof(WCHAR);
3244         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
3245             pCVArrayFormat = ReadConformance(pStubMsg, pCVArrayFormat + 2);
3246         else
3247             pCVArrayFormat = ReadConformance(pStubMsg, NULL);
3248         break;
3249     default:
3250         ERR("invalid array format type %x\n", *pCVArrayFormat);
3251         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3252         return NULL;
3253     }
3254
3255     ALIGN_POINTER(pStubMsg->Buffer, pCVStructFormat->alignment + 1);
3256
3257     TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
3258
3259     /* work out how much memory to allocate if we need to do so */
3260     if (!*ppMemory || fMustAlloc)
3261     {
3262         SIZE_T size = pCVStructFormat->memory_size + safe_multiply(esize, pStubMsg->MaxCount);
3263         *ppMemory = NdrAllocate(pStubMsg, size);
3264     }
3265
3266     /* copy the constant data */
3267     pStubMsg->BufferMark = pStubMsg->Buffer;
3268     memcpy(*ppMemory, pStubMsg->Buffer, pCVStructFormat->memory_size);
3269     pStubMsg->Buffer += pCVStructFormat->memory_size;
3270
3271     pCVArrayFormat = ReadVariance(pStubMsg, pCVArrayFormat, pStubMsg->MaxCount);
3272
3273     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
3274
3275     if ((cvarray_type == RPC_FC_C_CSTRING) ||
3276         (cvarray_type == RPC_FC_C_WSTRING))
3277     {
3278         ULONG i;
3279         /* strings must always have null terminating bytes */
3280         if (bufsize < esize)
3281         {
3282             ERR("invalid string length of %d\n", pStubMsg->ActualCount);
3283             RpcRaiseException(RPC_S_INVALID_BOUND);
3284             return NULL;
3285         }
3286         for (i = bufsize - esize; i < bufsize; i++)
3287             if (pStubMsg->Buffer[i] != 0)
3288             {
3289                 ERR("string not null-terminated at byte position %d, data is 0x%x\n",
3290                     i, pStubMsg->Buffer[i]);
3291                 RpcRaiseException(RPC_S_INVALID_BOUND);
3292                 return NULL;
3293             }
3294     }
3295
3296     /* copy the array data */
3297     memcpy(*ppMemory + pCVStructFormat->memory_size, pStubMsg->Buffer,
3298            bufsize);
3299     pStubMsg->Buffer += bufsize;
3300
3301     if (cvarray_type == RPC_FC_C_CSTRING)
3302         TRACE("string=%s\n", debugstr_a((char *)(*ppMemory + pCVStructFormat->memory_size)));
3303     else if (cvarray_type == RPC_FC_C_WSTRING)
3304         TRACE("string=%s\n", debugstr_w((WCHAR *)(*ppMemory + pCVStructFormat->memory_size)));
3305
3306     EmbeddedPointerUnmarshall(pStubMsg, ppMemory, pFormat, fMustAlloc);
3307
3308     return NULL;
3309 }
3310
3311 /***********************************************************************
3312  *           NdrConformantVaryingStructBufferSize [RPCRT4.@]
3313  */
3314 void WINAPI NdrConformantVaryingStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
3315                                 unsigned char *pMemory,
3316                                 PFORMAT_STRING pFormat)
3317 {
3318     const NDR_CVSTRUCT_FORMAT *pCVStructFormat = (const NDR_CVSTRUCT_FORMAT *)pFormat;
3319     PFORMAT_STRING pCVArrayFormat;
3320     ULONG esize;
3321
3322     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
3323
3324     pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
3325     if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
3326     {
3327         ERR("invalid format type %x\n", pCVStructFormat->type);
3328         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3329         return;
3330     }
3331
3332     pCVArrayFormat = (const unsigned char *)&pCVStructFormat->offset_to_array_description +
3333         pCVStructFormat->offset_to_array_description;
3334     switch (*pCVArrayFormat)
3335     {
3336     case RPC_FC_CVARRAY:
3337         esize = *(const WORD*)(pCVArrayFormat+2);
3338
3339         pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
3340                                             pCVArrayFormat + 4, 0);
3341         pCVArrayFormat = ComputeVariance(pStubMsg, pMemory + pCVStructFormat->memory_size,
3342                                          pCVArrayFormat, 0);
3343         break;
3344     case RPC_FC_C_CSTRING:
3345         TRACE("string=%s\n", debugstr_a((char*)pMemory + pCVStructFormat->memory_size));
3346         pStubMsg->ActualCount = strlen((char*)pMemory + pCVStructFormat->memory_size)+1;
3347         esize = sizeof(char);
3348         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
3349             pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
3350                                                 pCVArrayFormat + 2, 0);
3351         else
3352             pStubMsg->MaxCount = pStubMsg->ActualCount;
3353         break;
3354     case RPC_FC_C_WSTRING:
3355         TRACE("string=%s\n", debugstr_w((LPWSTR)pMemory + pCVStructFormat->memory_size));
3356         pStubMsg->ActualCount = strlenW((LPWSTR)pMemory + pCVStructFormat->memory_size)+1;
3357         esize = sizeof(WCHAR);
3358         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
3359             pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
3360                                                 pCVArrayFormat + 2, 0);
3361         else
3362             pStubMsg->MaxCount = pStubMsg->ActualCount;
3363         break;
3364     default:
3365         ERR("invalid array format type %x\n", *pCVArrayFormat);
3366         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3367         return;
3368     }
3369
3370     SizeConformance(pStubMsg);
3371
3372     ALIGN_LENGTH(pStubMsg->BufferLength, pCVStructFormat->alignment + 1);
3373
3374     TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
3375
3376     pStubMsg->BufferLength += pCVStructFormat->memory_size;
3377     SizeVariance(pStubMsg);
3378     pStubMsg->BufferLength += safe_multiply(pStubMsg->MaxCount, esize);
3379
3380     EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
3381 }
3382
3383 /***********************************************************************
3384  *           NdrConformantVaryingStructMemorySize [RPCRT4.@]
3385  */
3386 ULONG WINAPI NdrConformantVaryingStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
3387                                 PFORMAT_STRING pFormat)
3388 {
3389     const NDR_CVSTRUCT_FORMAT *pCVStructFormat = (const NDR_CVSTRUCT_FORMAT *)pFormat;
3390     PFORMAT_STRING pCVArrayFormat;
3391     ULONG esize;
3392     unsigned char cvarray_type;
3393
3394     TRACE("(%p, %p)\n", pStubMsg, pFormat);
3395
3396     pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
3397     if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
3398     {
3399         ERR("invalid format type %x\n", pCVStructFormat->type);
3400         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3401         return 0;
3402     }
3403
3404     pCVArrayFormat = (const unsigned char *)&pCVStructFormat->offset_to_array_description +
3405         pCVStructFormat->offset_to_array_description;
3406     cvarray_type = *pCVArrayFormat;
3407     switch (cvarray_type)
3408     {
3409     case RPC_FC_CVARRAY:
3410         esize = *(const WORD*)(pCVArrayFormat+2);
3411         pCVArrayFormat = ReadConformance(pStubMsg, pCVArrayFormat + 4);
3412         break;
3413     case RPC_FC_C_CSTRING:
3414         esize = sizeof(char);
3415         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
3416             pCVArrayFormat = ReadConformance(pStubMsg, pCVArrayFormat + 2);
3417         else
3418             pCVArrayFormat = ReadConformance(pStubMsg, NULL);
3419         break;
3420     case RPC_FC_C_WSTRING:
3421         esize = sizeof(WCHAR);
3422         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
3423             pCVArrayFormat = ReadConformance(pStubMsg, pCVArrayFormat + 2);
3424         else
3425             pCVArrayFormat = ReadConformance(pStubMsg, NULL);
3426         break;
3427     default:
3428         ERR("invalid array format type %x\n", *pCVArrayFormat);
3429         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3430         return 0;
3431     }
3432
3433     ALIGN_POINTER(pStubMsg->Buffer, pCVStructFormat->alignment + 1);
3434
3435     TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
3436
3437     pStubMsg->Buffer += pCVStructFormat->memory_size;
3438     pCVArrayFormat = ReadVariance(pStubMsg, pCVArrayFormat, pStubMsg->MaxCount);
3439     pStubMsg->Buffer += pCVStructFormat->memory_size + safe_multiply(esize, pStubMsg->ActualCount);
3440
3441     pStubMsg->MemorySize += pCVStructFormat->memory_size + safe_multiply(esize, pStubMsg->MaxCount);
3442
3443     EmbeddedPointerMemorySize(pStubMsg, pFormat);
3444
3445     return pCVStructFormat->memory_size + pStubMsg->MaxCount * esize;
3446 }
3447
3448 /***********************************************************************
3449  *           NdrConformantVaryingStructFree [RPCRT4.@]
3450  */
3451 void WINAPI NdrConformantVaryingStructFree(PMIDL_STUB_MESSAGE pStubMsg,
3452                                 unsigned char *pMemory,
3453                                 PFORMAT_STRING pFormat)
3454 {
3455     const NDR_CVSTRUCT_FORMAT *pCVStructFormat = (const NDR_CVSTRUCT_FORMAT *)pFormat;
3456     PFORMAT_STRING pCVArrayFormat;
3457     ULONG esize;
3458
3459     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
3460
3461     pFormat += sizeof(NDR_CVSTRUCT_FORMAT);
3462     if (pCVStructFormat->type != RPC_FC_CVSTRUCT)
3463     {
3464         ERR("invalid format type %x\n", pCVStructFormat->type);
3465         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3466         return;
3467     }
3468
3469     pCVArrayFormat = (const unsigned char *)&pCVStructFormat->offset_to_array_description +
3470         pCVStructFormat->offset_to_array_description;
3471     switch (*pCVArrayFormat)
3472     {
3473     case RPC_FC_CVARRAY:
3474         esize = *(const WORD*)(pCVArrayFormat+2);
3475
3476         pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
3477                                             pCVArrayFormat + 4, 0);
3478         pCVArrayFormat = ComputeVariance(pStubMsg, pMemory + pCVStructFormat->memory_size,
3479                                          pCVArrayFormat, 0);
3480         break;
3481     case RPC_FC_C_CSTRING:
3482         TRACE("string=%s\n", debugstr_a((char*)pMemory + pCVStructFormat->memory_size));
3483         pStubMsg->ActualCount = strlen((char*)pMemory + pCVStructFormat->memory_size)+1;
3484         esize = sizeof(char);
3485         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
3486             pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
3487                                                 pCVArrayFormat + 2, 0);
3488         else
3489             pStubMsg->MaxCount = pStubMsg->ActualCount;
3490         break;
3491     case RPC_FC_C_WSTRING:
3492         TRACE("string=%s\n", debugstr_w((LPWSTR)pMemory + pCVStructFormat->memory_size));
3493         pStubMsg->ActualCount = strlenW((LPWSTR)pMemory + pCVStructFormat->memory_size)+1;
3494         esize = sizeof(WCHAR);
3495         if (pCVArrayFormat[1] == RPC_FC_STRING_SIZED)
3496             pCVArrayFormat = ComputeConformance(pStubMsg, pMemory + pCVStructFormat->memory_size,
3497                                                 pCVArrayFormat + 2, 0);
3498         else
3499             pStubMsg->MaxCount = pStubMsg->ActualCount;
3500         break;
3501     default:
3502         ERR("invalid array format type %x\n", *pCVArrayFormat);
3503         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3504         return;
3505     }
3506
3507     TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
3508
3509     EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
3510 }
3511
3512 typedef struct
3513 {
3514     unsigned char type;
3515     unsigned char alignment;
3516     unsigned short total_size;
3517 } NDR_SMFARRAY_FORMAT;
3518
3519 typedef struct
3520 {
3521     unsigned char type;
3522     unsigned char alignment;
3523     unsigned long total_size;
3524 } NDR_LGFARRAY_FORMAT;
3525
3526 /***********************************************************************
3527  *           NdrFixedArrayMarshall [RPCRT4.@]
3528  */
3529 unsigned char *  WINAPI NdrFixedArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
3530                                 unsigned char *pMemory,
3531                                 PFORMAT_STRING pFormat)
3532 {
3533     const NDR_SMFARRAY_FORMAT *pSmFArrayFormat = (const NDR_SMFARRAY_FORMAT *)pFormat;
3534     unsigned long total_size;
3535
3536     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
3537
3538     if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
3539         (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
3540     {
3541         ERR("invalid format type %x\n", pSmFArrayFormat->type);
3542         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3543         return NULL;
3544     }
3545
3546     ALIGN_POINTER(pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
3547
3548     if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
3549     {
3550         total_size = pSmFArrayFormat->total_size;
3551         pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
3552     }
3553     else
3554     {
3555         const NDR_LGFARRAY_FORMAT *pLgFArrayFormat = (const NDR_LGFARRAY_FORMAT *)pFormat;
3556         total_size = pLgFArrayFormat->total_size;
3557         pFormat = (const unsigned char *)(pLgFArrayFormat + 1);
3558     }
3559
3560     memcpy(pStubMsg->Buffer, pMemory, total_size);
3561     pStubMsg->BufferMark = pStubMsg->Buffer;
3562     pStubMsg->Buffer += total_size;
3563
3564     pFormat = EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
3565
3566     return NULL;
3567 }
3568
3569 /***********************************************************************
3570  *           NdrFixedArrayUnmarshall [RPCRT4.@]
3571  */
3572 unsigned char *  WINAPI NdrFixedArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
3573                                 unsigned char **ppMemory,
3574                                 PFORMAT_STRING pFormat,
3575                                 unsigned char fMustAlloc)
3576 {
3577     const NDR_SMFARRAY_FORMAT *pSmFArrayFormat = (const NDR_SMFARRAY_FORMAT *)pFormat;
3578     unsigned long total_size;
3579
3580     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
3581
3582     if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
3583         (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
3584     {
3585         ERR("invalid format type %x\n", pSmFArrayFormat->type);
3586         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3587         return NULL;
3588     }
3589
3590     ALIGN_POINTER(pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
3591
3592     if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
3593     {
3594         total_size = pSmFArrayFormat->total_size;
3595         pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
3596     }
3597     else
3598     {
3599         const NDR_LGFARRAY_FORMAT *pLgFArrayFormat = (const NDR_LGFARRAY_FORMAT *)pFormat;
3600         total_size = pLgFArrayFormat->total_size;
3601         pFormat = (const unsigned char *)(pLgFArrayFormat + 1);
3602     }
3603
3604     if (fMustAlloc || !*ppMemory)
3605         *ppMemory = NdrAllocate(pStubMsg, total_size);
3606     memcpy(*ppMemory, pStubMsg->Buffer, total_size);
3607     pStubMsg->BufferMark = pStubMsg->Buffer;
3608     pStubMsg->Buffer += total_size;
3609
3610     pFormat = EmbeddedPointerUnmarshall(pStubMsg, ppMemory, pFormat, fMustAlloc);
3611
3612     return NULL;
3613 }
3614
3615 /***********************************************************************
3616  *           NdrFixedArrayBufferSize [RPCRT4.@]
3617  */
3618 void WINAPI NdrFixedArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
3619                                 unsigned char *pMemory,
3620                                 PFORMAT_STRING pFormat)
3621 {
3622     const NDR_SMFARRAY_FORMAT *pSmFArrayFormat = (const NDR_SMFARRAY_FORMAT *)pFormat;
3623     unsigned long total_size;
3624
3625     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
3626
3627     if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
3628         (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
3629     {
3630         ERR("invalid format type %x\n", pSmFArrayFormat->type);
3631         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3632         return;
3633     }
3634
3635     ALIGN_LENGTH(pStubMsg->BufferLength, pSmFArrayFormat->alignment + 1);
3636
3637     if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
3638     {
3639         total_size = pSmFArrayFormat->total_size;
3640         pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
3641     }
3642     else
3643     {
3644         const NDR_LGFARRAY_FORMAT *pLgFArrayFormat = (const NDR_LGFARRAY_FORMAT *)pFormat;
3645         total_size = pLgFArrayFormat->total_size;
3646         pFormat = (const unsigned char *)(pLgFArrayFormat + 1);
3647     }
3648     pStubMsg->BufferLength += total_size;
3649
3650     EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
3651 }
3652
3653 /***********************************************************************
3654  *           NdrFixedArrayMemorySize [RPCRT4.@]
3655  */
3656 ULONG WINAPI NdrFixedArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
3657                                 PFORMAT_STRING pFormat)
3658 {
3659     const NDR_SMFARRAY_FORMAT *pSmFArrayFormat = (const NDR_SMFARRAY_FORMAT *)pFormat;
3660     ULONG total_size;
3661
3662     TRACE("(%p, %p)\n", pStubMsg, pFormat);
3663
3664     if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
3665         (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
3666     {
3667         ERR("invalid format type %x\n", pSmFArrayFormat->type);
3668         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3669         return 0;
3670     }
3671
3672     ALIGN_POINTER(pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
3673
3674     if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
3675     {
3676         total_size = pSmFArrayFormat->total_size;
3677         pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
3678     }
3679     else
3680     {
3681         const NDR_LGFARRAY_FORMAT *pLgFArrayFormat = (const NDR_LGFARRAY_FORMAT *)pFormat;
3682         total_size = pLgFArrayFormat->total_size;
3683         pFormat = (const unsigned char *)(pLgFArrayFormat + 1);
3684     }
3685     pStubMsg->BufferMark = pStubMsg->Buffer;
3686     pStubMsg->Buffer += total_size;
3687     pStubMsg->MemorySize += total_size;
3688
3689     EmbeddedPointerMemorySize(pStubMsg, pFormat);
3690
3691     return total_size;
3692 }
3693
3694 /***********************************************************************
3695  *           NdrFixedArrayFree [RPCRT4.@]
3696  */
3697 void WINAPI NdrFixedArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
3698                                 unsigned char *pMemory,
3699                                 PFORMAT_STRING pFormat)
3700 {
3701     const NDR_SMFARRAY_FORMAT *pSmFArrayFormat = (const NDR_SMFARRAY_FORMAT *)pFormat;
3702
3703     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
3704
3705     if ((pSmFArrayFormat->type != RPC_FC_SMFARRAY) &&
3706         (pSmFArrayFormat->type != RPC_FC_LGFARRAY))
3707     {
3708         ERR("invalid format type %x\n", pSmFArrayFormat->type);
3709         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3710         return;
3711     }
3712
3713     if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
3714         pFormat = (const unsigned char *)(pSmFArrayFormat + 1);
3715     else
3716     {
3717         const NDR_LGFARRAY_FORMAT *pLgFArrayFormat = (const NDR_LGFARRAY_FORMAT *)pFormat;
3718         pFormat = (const unsigned char *)(pLgFArrayFormat + 1);
3719     }
3720
3721     EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
3722 }
3723
3724 /***********************************************************************
3725  *           NdrVaryingArrayMarshall [RPCRT4.@]
3726  */
3727 unsigned char *  WINAPI NdrVaryingArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
3728                                 unsigned char *pMemory,
3729                                 PFORMAT_STRING pFormat)
3730 {
3731     unsigned char alignment;
3732     DWORD elements, esize;
3733     ULONG bufsize;
3734
3735     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
3736
3737     if ((pFormat[0] != RPC_FC_SMVARRAY) &&
3738         (pFormat[0] != RPC_FC_LGVARRAY))
3739     {
3740         ERR("invalid format type %x\n", pFormat[0]);
3741         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3742         return NULL;
3743     }
3744
3745     alignment = pFormat[1] + 1;
3746
3747     if (pFormat[0] == RPC_FC_SMVARRAY)
3748     {
3749         pFormat += 2;
3750         pFormat += sizeof(WORD);
3751         elements = *(const WORD*)pFormat;
3752         pFormat += sizeof(WORD);
3753     }
3754     else
3755     {
3756         pFormat += 2;
3757         pFormat += sizeof(DWORD);
3758         elements = *(const DWORD*)pFormat;
3759         pFormat += sizeof(DWORD);
3760     }
3761
3762     esize = *(const WORD*)pFormat;
3763     pFormat += sizeof(WORD);
3764
3765     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
3766     if ((pStubMsg->ActualCount > elements) ||
3767         (pStubMsg->ActualCount + pStubMsg->Offset > elements))
3768     {
3769         RpcRaiseException(RPC_S_INVALID_BOUND);
3770         return NULL;
3771     }
3772
3773     WriteVariance(pStubMsg);
3774
3775     ALIGN_POINTER(pStubMsg->Buffer, alignment);
3776
3777     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
3778     memcpy(pStubMsg->Buffer, pMemory + pStubMsg->Offset, bufsize);
3779     pStubMsg->BufferMark = pStubMsg->Buffer;
3780     pStubMsg->Buffer += bufsize;
3781
3782     EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
3783
3784     STD_OVERFLOW_CHECK(pStubMsg);
3785
3786     return NULL;
3787 }
3788
3789 /***********************************************************************
3790  *           NdrVaryingArrayUnmarshall [RPCRT4.@]
3791  */
3792 unsigned char *  WINAPI NdrVaryingArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
3793                                 unsigned char **ppMemory,
3794                                 PFORMAT_STRING pFormat,
3795                                 unsigned char fMustAlloc)
3796 {
3797     unsigned char alignment;
3798     DWORD size, elements, esize;
3799     ULONG bufsize;
3800
3801     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
3802
3803     if ((pFormat[0] != RPC_FC_SMVARRAY) &&
3804         (pFormat[0] != RPC_FC_LGVARRAY))
3805     {
3806         ERR("invalid format type %x\n", pFormat[0]);
3807         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3808         return NULL;
3809     }
3810
3811     alignment = pFormat[1] + 1;
3812
3813     if (pFormat[0] == RPC_FC_SMVARRAY)
3814     {
3815         pFormat += 2;
3816         size = *(const WORD*)pFormat;
3817         pFormat += sizeof(WORD);
3818         elements = *(const WORD*)pFormat;
3819         pFormat += sizeof(WORD);
3820     }
3821     else
3822     {
3823         pFormat += 2;
3824         size = *(const DWORD*)pFormat;
3825         pFormat += sizeof(DWORD);
3826         elements = *(const DWORD*)pFormat;
3827         pFormat += sizeof(DWORD);
3828     }
3829
3830     esize = *(const WORD*)pFormat;
3831     pFormat += sizeof(WORD);
3832
3833     pFormat = ReadVariance(pStubMsg, pFormat, elements);
3834
3835     ALIGN_POINTER(pStubMsg->Buffer, alignment);
3836
3837     bufsize = safe_multiply(esize, pStubMsg->ActualCount);
3838
3839     if (!*ppMemory || fMustAlloc)
3840         *ppMemory = NdrAllocate(pStubMsg, size);
3841     memcpy(*ppMemory + pStubMsg->Offset, pStubMsg->Buffer, bufsize);
3842     pStubMsg->Buffer += bufsize;
3843
3844     EmbeddedPointerUnmarshall(pStubMsg, ppMemory, pFormat, fMustAlloc);
3845
3846     return NULL;
3847 }
3848
3849 /***********************************************************************
3850  *           NdrVaryingArrayBufferSize [RPCRT4.@]
3851  */
3852 void WINAPI NdrVaryingArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
3853                                 unsigned char *pMemory,
3854                                 PFORMAT_STRING pFormat)
3855 {
3856     unsigned char alignment;
3857     DWORD elements, esize;
3858
3859     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
3860
3861     if ((pFormat[0] != RPC_FC_SMVARRAY) &&
3862         (pFormat[0] != RPC_FC_LGVARRAY))
3863     {
3864         ERR("invalid format type %x\n", pFormat[0]);
3865         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3866         return;
3867     }
3868
3869     alignment = pFormat[1] + 1;
3870
3871     if (pFormat[0] == RPC_FC_SMVARRAY)
3872     {
3873         pFormat += 2;
3874         pFormat += sizeof(WORD);
3875         elements = *(const WORD*)pFormat;
3876         pFormat += sizeof(WORD);
3877     }
3878     else
3879     {
3880         pFormat += 2;
3881         pFormat += sizeof(DWORD);
3882         elements = *(const DWORD*)pFormat;
3883         pFormat += sizeof(DWORD);
3884     }
3885
3886     esize = *(const WORD*)pFormat;
3887     pFormat += sizeof(WORD);
3888
3889     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
3890     if ((pStubMsg->ActualCount > elements) ||
3891         (pStubMsg->ActualCount + pStubMsg->Offset > elements))
3892     {
3893         RpcRaiseException(RPC_S_INVALID_BOUND);
3894         return;
3895     }
3896
3897     SizeVariance(pStubMsg);
3898
3899     ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
3900
3901     pStubMsg->BufferLength += safe_multiply(esize, pStubMsg->ActualCount);
3902
3903     EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
3904 }
3905
3906 /***********************************************************************
3907  *           NdrVaryingArrayMemorySize [RPCRT4.@]
3908  */
3909 ULONG WINAPI NdrVaryingArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
3910                                 PFORMAT_STRING pFormat)
3911 {
3912     unsigned char alignment;
3913     DWORD size, elements, esize;
3914
3915     TRACE("(%p, %p)\n", pStubMsg, pFormat);
3916
3917     if ((pFormat[0] != RPC_FC_SMVARRAY) &&
3918         (pFormat[0] != RPC_FC_LGVARRAY))
3919     {
3920         ERR("invalid format type %x\n", pFormat[0]);
3921         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3922         return 0;
3923     }
3924
3925     alignment = pFormat[1] + 1;
3926
3927     if (pFormat[0] == RPC_FC_SMVARRAY)
3928     {
3929         pFormat += 2;
3930         size = *(const WORD*)pFormat;
3931         pFormat += sizeof(WORD);
3932         elements = *(const WORD*)pFormat;
3933         pFormat += sizeof(WORD);
3934     }
3935     else
3936     {
3937         pFormat += 2;
3938         size = *(const DWORD*)pFormat;
3939         pFormat += sizeof(DWORD);
3940         elements = *(const DWORD*)pFormat;
3941         pFormat += sizeof(DWORD);
3942     }
3943
3944     esize = *(const WORD*)pFormat;
3945     pFormat += sizeof(WORD);
3946
3947     pFormat = ReadVariance(pStubMsg, pFormat, elements);
3948
3949     ALIGN_POINTER(pStubMsg->Buffer, alignment);
3950
3951     pStubMsg->Buffer += safe_multiply(esize, pStubMsg->ActualCount);
3952     pStubMsg->MemorySize += size;
3953
3954     EmbeddedPointerMemorySize(pStubMsg, pFormat);
3955
3956     return pStubMsg->MemorySize;
3957 }
3958
3959 /***********************************************************************
3960  *           NdrVaryingArrayFree [RPCRT4.@]
3961  */
3962 void WINAPI NdrVaryingArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
3963                                 unsigned char *pMemory,
3964                                 PFORMAT_STRING pFormat)
3965 {
3966     unsigned char alignment;
3967     DWORD elements;
3968
3969     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
3970
3971     if ((pFormat[0] != RPC_FC_SMVARRAY) &&
3972         (pFormat[0] != RPC_FC_LGVARRAY))
3973     {
3974         ERR("invalid format type %x\n", pFormat[0]);
3975         RpcRaiseException(RPC_S_INTERNAL_ERROR);
3976         return;
3977     }
3978
3979     alignment = pFormat[1] + 1;
3980
3981     if (pFormat[0] == RPC_FC_SMVARRAY)
3982     {
3983         pFormat += 2;
3984         pFormat += sizeof(WORD);
3985         elements = *(const WORD*)pFormat;
3986         pFormat += sizeof(WORD);
3987     }
3988     else
3989     {
3990         pFormat += 2;
3991         pFormat += sizeof(DWORD);
3992         elements = *(const DWORD*)pFormat;
3993         pFormat += sizeof(DWORD);
3994     }
3995
3996     pFormat += sizeof(WORD);
3997
3998     pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
3999     if ((pStubMsg->ActualCount > elements) ||
4000         (pStubMsg->ActualCount + pStubMsg->Offset > elements))
4001     {
4002         RpcRaiseException(RPC_S_INVALID_BOUND);
4003         return;
4004     }
4005
4006     EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
4007 }
4008
4009 /***********************************************************************
4010  *           NdrEncapsulatedUnionMarshall [RPCRT4.@]
4011  */
4012 unsigned char *  WINAPI NdrEncapsulatedUnionMarshall(PMIDL_STUB_MESSAGE pStubMsg,
4013                                 unsigned char *pMemory,
4014                                 PFORMAT_STRING pFormat)
4015 {
4016     FIXME("stub\n");
4017     return NULL;
4018 }
4019
4020 /***********************************************************************
4021  *           NdrEncapsulatedUnionUnmarshall [RPCRT4.@]
4022  */
4023 unsigned char *  WINAPI NdrEncapsulatedUnionUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
4024                                 unsigned char **ppMemory,
4025                                 PFORMAT_STRING pFormat,
4026                                 unsigned char fMustAlloc)
4027 {
4028     FIXME("stub\n");
4029     return NULL;
4030 }
4031
4032 /***********************************************************************
4033  *           NdrEncapsulatedUnionBufferSize [RPCRT4.@]
4034  */
4035 void WINAPI NdrEncapsulatedUnionBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
4036                                 unsigned char *pMemory,
4037                                 PFORMAT_STRING pFormat)
4038 {
4039     FIXME("stub\n");
4040 }
4041
4042 /***********************************************************************
4043  *           NdrEncapsulatedUnionMemorySize [RPCRT4.@]
4044  */
4045 ULONG WINAPI NdrEncapsulatedUnionMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
4046                                 PFORMAT_STRING pFormat)
4047 {
4048     FIXME("stub\n");
4049     return 0;
4050 }
4051
4052 /***********************************************************************
4053  *           NdrEncapsulatedUnionFree [RPCRT4.@]
4054  */
4055 void WINAPI NdrEncapsulatedUnionFree(PMIDL_STUB_MESSAGE pStubMsg,
4056                                 unsigned char *pMemory,
4057                                 PFORMAT_STRING pFormat)
4058 {
4059     FIXME("stub\n");
4060 }
4061
4062 static PFORMAT_STRING get_arm_offset_from_union_arm_selector(PMIDL_STUB_MESSAGE pStubMsg,
4063                                                              unsigned long discriminant,
4064                                                              PFORMAT_STRING pFormat)
4065 {
4066     unsigned short num_arms, arm, type;
4067
4068     num_arms = *(const SHORT*)pFormat & 0x0fff;
4069     pFormat += 2;
4070     for(arm = 0; arm < num_arms; arm++)
4071     {
4072         if(discriminant == *(const ULONG*)pFormat)
4073         {
4074             pFormat += 4;
4075             break;
4076         }
4077         pFormat += 6;
4078     }
4079
4080     type = *(const unsigned short*)pFormat;
4081     TRACE("type %04x\n", type);
4082     if(arm == num_arms) /* default arm extras */
4083     {
4084         if(type == 0xffff)
4085         {
4086             ERR("no arm for 0x%lx and no default case\n", discriminant);
4087             RpcRaiseException(RPC_S_INVALID_TAG);
4088             return NULL;
4089         }
4090         if(type == 0)
4091         {
4092             TRACE("falling back to empty default case for 0x%lx\n", discriminant);
4093             return NULL;
4094         }
4095     }
4096     return pFormat;
4097 }
4098
4099 static PFORMAT_STRING get_non_encapsulated_union_arm(PMIDL_STUB_MESSAGE pStubMsg,
4100                                                      ULONG value,
4101                                                      PFORMAT_STRING pFormat)
4102 {
4103     pFormat += *(const SHORT*)pFormat;
4104     pFormat += 2;
4105
4106     return get_arm_offset_from_union_arm_selector(pStubMsg, value, pFormat);
4107 }
4108
4109 /***********************************************************************
4110  *           NdrNonEncapsulatedUnionMarshall [RPCRT4.@]
4111  */
4112 unsigned char *  WINAPI NdrNonEncapsulatedUnionMarshall(PMIDL_STUB_MESSAGE pStubMsg,
4113                                 unsigned char *pMemory,
4114                                 PFORMAT_STRING pFormat)
4115 {
4116     unsigned short type;
4117     unsigned char switch_type;
4118
4119     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4120     pFormat++;
4121
4122     switch_type = *pFormat;
4123     pFormat++;
4124
4125     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, 0);
4126     TRACE("got switch value 0x%lx\n", pStubMsg->MaxCount);
4127     /* Marshall discriminant */
4128     NdrBaseTypeMarshall(pStubMsg, (unsigned char *)&pStubMsg->MaxCount, &switch_type);
4129
4130     pFormat = get_non_encapsulated_union_arm(pStubMsg, pStubMsg->MaxCount, pFormat);
4131     if(!pFormat)
4132         return NULL;
4133
4134     type = *(const unsigned short*)pFormat;
4135     if((type & 0xff00) == 0x8000)
4136     {
4137         unsigned char basetype = LOBYTE(type);
4138         return NdrBaseTypeMarshall(pStubMsg, pMemory, &basetype);
4139     }
4140     else
4141     {
4142         PFORMAT_STRING desc = pFormat + *(const SHORT*)pFormat;
4143         NDR_MARSHALL m = NdrMarshaller[*desc & NDR_TABLE_MASK];
4144         if (m)
4145         {
4146             unsigned char *saved_buffer = NULL;
4147             switch(*desc)
4148             {
4149             case RPC_FC_RP:
4150             case RPC_FC_UP:
4151             case RPC_FC_OP:
4152             case RPC_FC_FP:
4153                 saved_buffer = pStubMsg->Buffer;
4154                 pStubMsg->Buffer += 4; /* for pointer ID */
4155                 PointerMarshall(pStubMsg, saved_buffer, *(unsigned char **)pMemory, desc);
4156                 break;
4157             default:
4158                 m(pStubMsg, pMemory, desc);
4159             }
4160         }
4161         else FIXME("no marshaller for embedded type %02x\n", *desc);
4162     }
4163     return NULL;
4164 }
4165
4166 static long unmarshall_discriminant(PMIDL_STUB_MESSAGE pStubMsg,
4167                                     PFORMAT_STRING *ppFormat)
4168 {
4169     long discriminant = 0;
4170
4171     switch(**ppFormat)
4172     {
4173     case RPC_FC_BYTE:
4174     case RPC_FC_CHAR:
4175     case RPC_FC_SMALL:
4176     case RPC_FC_USMALL:
4177         discriminant = *(UCHAR *)pStubMsg->Buffer;
4178         pStubMsg->Buffer += sizeof(UCHAR);
4179         break;
4180     case RPC_FC_WCHAR:
4181     case RPC_FC_SHORT:
4182     case RPC_FC_USHORT:
4183         ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
4184         discriminant = *(USHORT *)pStubMsg->Buffer;
4185         pStubMsg->Buffer += sizeof(USHORT);
4186         break;
4187     case RPC_FC_LONG:
4188     case RPC_FC_ULONG:
4189         ALIGN_POINTER(pStubMsg->Buffer, sizeof(ULONG));
4190         discriminant = *(ULONG *)pStubMsg->Buffer;
4191         pStubMsg->Buffer += sizeof(ULONG);
4192         break;
4193     default:
4194         FIXME("Unhandled base type: 0x%02x\n", **ppFormat);
4195     }
4196     (*ppFormat)++;
4197
4198     if (pStubMsg->fHasNewCorrDesc)
4199         *ppFormat += 6;
4200     else
4201         *ppFormat += 4;
4202     return discriminant;
4203 }
4204
4205 /**********************************************************************
4206  *           NdrNonEncapsulatedUnionUnmarshall [RPCRT4.@]
4207  */
4208 unsigned char *  WINAPI NdrNonEncapsulatedUnionUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
4209                                 unsigned char **ppMemory,
4210                                 PFORMAT_STRING pFormat,
4211                                 unsigned char fMustAlloc)
4212 {
4213     long discriminant;
4214     unsigned short type, size;
4215
4216     TRACE("(%p, %p, %p, %d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
4217     pFormat++;
4218
4219     /* Unmarshall discriminant */
4220     discriminant = unmarshall_discriminant(pStubMsg, &pFormat);
4221     TRACE("unmarshalled discriminant %lx\n", discriminant);
4222
4223     pFormat += *(const SHORT*)pFormat;
4224
4225     size = *(const unsigned short*)pFormat;
4226     pFormat += 2;
4227
4228     pFormat = get_arm_offset_from_union_arm_selector(pStubMsg, discriminant, pFormat);
4229     if(!pFormat)
4230         return NULL;
4231
4232     if(!*ppMemory || fMustAlloc)
4233         *ppMemory = NdrAllocate(pStubMsg, size);
4234
4235     type = *(const unsigned short*)pFormat;
4236     if((type & 0xff00) == 0x8000)
4237     {
4238         unsigned char basetype = LOBYTE(type);
4239         return NdrBaseTypeUnmarshall(pStubMsg, ppMemory, &basetype, fMustAlloc);
4240     }
4241     else
4242     {
4243         PFORMAT_STRING desc = pFormat + *(const SHORT*)pFormat;
4244         NDR_UNMARSHALL m = NdrUnmarshaller[*desc & NDR_TABLE_MASK];
4245         if (m)
4246         {
4247             unsigned char *saved_buffer = NULL;
4248             switch(*desc)
4249             {
4250             case RPC_FC_RP:
4251             case RPC_FC_UP:
4252             case RPC_FC_OP:
4253             case RPC_FC_FP:
4254                 ALIGN_POINTER(pStubMsg->Buffer, 4);
4255                 saved_buffer = pStubMsg->Buffer;
4256                 pStubMsg->Buffer += 4; /* for pointer ID */
4257                 PointerUnmarshall(pStubMsg, saved_buffer, *(unsigned char ***)ppMemory, desc, TRUE);
4258                 break;
4259             default:
4260                 m(pStubMsg, ppMemory, desc, fMustAlloc);
4261             }
4262         }
4263         else FIXME("no marshaller for embedded type %02x\n", *desc);
4264     }
4265     return NULL;
4266 }
4267
4268 /***********************************************************************
4269  *           NdrNonEncapsulatedUnionBufferSize [RPCRT4.@]
4270  */
4271 void WINAPI NdrNonEncapsulatedUnionBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
4272                                 unsigned char *pMemory,
4273                                 PFORMAT_STRING pFormat)
4274 {
4275     unsigned short type;
4276     unsigned char switch_type;
4277
4278     TRACE("(%p, %p, %p)\n", pStubMsg, pMemory, pFormat);
4279     pFormat++;
4280
4281     switch_type = *pFormat;
4282     pFormat++;
4283
4284     pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, 0);
4285     TRACE("got switch value 0x%lx\n", pStubMsg->MaxCount);
4286     /* Add discriminant size */
4287     NdrBaseTypeBufferSize(pStubMsg, (unsigned char *)&pStubMsg->MaxCount, &switch_type);
4288
4289     pFormat = get_non_encapsulated_union_arm(pStubMsg, pStubMsg->MaxCount, pFormat);
4290     if(!pFormat)
4291         return;
4292
4293     type = *(const unsigned short*)pFormat;
4294     if((type & 0xff00) == 0x8000)
4295     {
4296         unsigned char basetype = LOBYTE(type);
4297         NdrBaseTypeBufferSize(pStubMsg, pMemory, &basetype);
4298     }
4299     else
4300     {
4301         PFORMAT_STRING desc = pFormat + *(const SHORT*)pFormat;
4302         NDR_BUFFERSIZE m = NdrBufferSizer[*desc & NDR_TABLE_MASK];
4303         if (m)
4304         {
4305             switch(*desc)
4306             {
4307             case RPC_FC_RP:
4308             case RPC_FC_UP:
4309             case RPC_FC_OP:
4310             case RPC_FC_FP:
4311                 ALIGN_LENGTH(pStubMsg->BufferLength, 4);
4312                 pStubMsg->BufferLength += 4; /* for pointer ID */
4313                 PointerBufferSize(pStubMsg, *(unsigned char **)pMemory, desc);
4314                 break;
4315             default:
4316                 m(pStubMsg, pMemory, desc);
4317             }
4318         }
4319         else FIXME("no buffersizer for embedded type %02x\n", *desc);
4320     }
4321     return;
4322 }
4323
4324 /***********************************************************************
4325  *           NdrNonEncapsulatedUnionMemorySize [RPCRT4.@]
4326  */
4327 ULONG WINAPI NdrNonEncapsulatedUnionMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
4328                                 PFORMAT_STRING pFormat)
4329 {
4330     ULONG discriminant;
4331     unsigned short type, size;
4332
4333     pFormat++;
4334     /* Unmarshall discriminant */
4335     discriminant = unmarshall_discriminant(pStubMsg, &pFormat);
4336     TRACE("unmarshalled discriminant 0x%x\n", discriminant);
4337
4338     pFormat += *(const SHORT*)pFormat;
4339
4340     size = *(const unsigned short*)pFormat;
4341     pFormat += 2;
4342
4343     pFormat = get_arm_offset_from_union_arm_selector(pStubMsg, discriminant, pFormat);
4344     if(!pFormat)
4345         return 0;
4346
4347     pStubMsg->Memory += size;
4348
4349     type = *(const unsigned short*)pFormat;
4350     if((type & 0xff00) == 0x8000)
4351     {
4352         return NdrBaseTypeMemorySize(pStubMsg, pFormat);
4353     }
4354     else
4355     {
4356         PFORMAT_STRING desc = pFormat + *(const SHORT*)pFormat;
4357         NDR_MEMORYSIZE m = NdrMemorySizer[*desc & NDR_TABLE_MASK];
4358         unsigned char *saved_buffer;
4359         if (m)
4360         {
4361             switch(*desc)
4362             {
4363             case RPC_FC_RP:
4364             case RPC_FC_UP:
4365             case RPC_FC_OP:
4366             case RPC_FC_FP:
4367                 ALIGN_POINTER(pStubMsg->Buffer, 4);
4368                 saved_buffer = pStubMsg->Buffer;
4369                 pStubMsg->Buffer += 4;
4370                 ALIGN_LENGTH(pStubMsg->MemorySize, 4);
4371                 pStubMsg->MemorySize += 4;
4372                 PointerMemorySize(pStubMsg, saved_buffer, pFormat);
4373                 break;
4374             default:
4375                 return m(pStubMsg, desc);
4376             }
4377         }
4378         else FIXME("no marshaller for embedded type %02x\n", *desc);
4379     }
4380
4381     TRACE("size %d\n", size);
4382     return size;
4383 }
4384
4385 /***********************************************************************
4386  *           NdrNonEncapsulatedUnionFree [RPCRT4.@]
4387  */
4388 void WINAPI NdrNonEncapsulatedUnionFree(PMIDL_STUB_MESSAGE pStubMsg,
4389                                 unsigned char *pMemory,
4390                                 PFORMAT_STRING pFormat)
4391 {
4392     FIXME("stub\n");
4393 }
4394
4395 /***********************************************************************
4396  *           NdrByteCountPointerMarshall [RPCRT4.@]
4397  */
4398 unsigned char *  WINAPI NdrByteCountPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
4399                                 unsigned char *pMemory,
4400                                 PFORMAT_STRING pFormat)
4401 {
4402     FIXME("stub\n");
4403     return NULL;
4404 }
4405
4406 /***********************************************************************
4407  *           NdrByteCountPointerUnmarshall [RPCRT4.@]
4408  */
4409 unsigned char *  WINAPI NdrByteCountPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
4410                                 unsigned char **ppMemory,
4411                                 PFORMAT_STRING pFormat,
4412                                 unsigned char fMustAlloc)
4413 {
4414     FIXME("stub\n");
4415     return NULL;
4416 }
4417
4418 /***********************************************************************
4419  *           NdrByteCountPointerBufferSize [RPCRT4.@]
4420  */
4421 void WINAPI NdrByteCountPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
4422                                 unsigned char *pMemory,
4423                                 PFORMAT_STRING pFormat)
4424 {
4425     FIXME("stub\n");
4426 }
4427
4428 /***********************************************************************
4429  *           NdrByteCountPointerMemorySize [RPCRT4.@]
4430  */
4431 ULONG WINAPI NdrByteCountPointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
4432                                 PFORMAT_STRING pFormat)
4433 {
4434     FIXME("stub\n");
4435     return 0;
4436 }
4437
4438 /***********************************************************************
4439  *           NdrByteCountPointerFree [RPCRT4.@]
4440  */
4441 void WINAPI NdrByteCountPointerFree(PMIDL_STUB_MESSAGE pStubMsg,
4442                                 unsigned char *pMemory,
4443                                 PFORMAT_STRING pFormat)
4444 {
4445     FIXME("stub\n");
4446 }
4447
4448 /***********************************************************************
4449  *           NdrXmitOrRepAsMarshall [RPCRT4.@]
4450  */
4451 unsigned char *  WINAPI NdrXmitOrRepAsMarshall(PMIDL_STUB_MESSAGE pStubMsg,
4452                                 unsigned char *pMemory,
4453                                 PFORMAT_STRING pFormat)
4454 {
4455     FIXME("stub\n");
4456     return NULL;
4457 }
4458
4459 /***********************************************************************
4460  *           NdrXmitOrRepAsUnmarshall [RPCRT4.@]
4461  */
4462 unsigned char *  WINAPI NdrXmitOrRepAsUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
4463                                 unsigned char **ppMemory,
4464                                 PFORMAT_STRING pFormat,
4465                                 unsigned char fMustAlloc)
4466 {
4467     FIXME("stub\n");
4468     return NULL;
4469 }
4470
4471 /***********************************************************************
4472  *           NdrXmitOrRepAsBufferSize [RPCRT4.@]
4473  */
4474 void WINAPI NdrXmitOrRepAsBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
4475                                 unsigned char *pMemory,
4476                                 PFORMAT_STRING pFormat)
4477 {
4478     FIXME("stub\n");
4479 }
4480
4481 /***********************************************************************
4482  *           NdrXmitOrRepAsMemorySize [RPCRT4.@]
4483  */
4484 ULONG WINAPI NdrXmitOrRepAsMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
4485                                 PFORMAT_STRING pFormat)
4486 {
4487     FIXME("stub\n");
4488     return 0;
4489 }
4490
4491 /***********************************************************************
4492  *           NdrXmitOrRepAsFree [RPCRT4.@]
4493  */
4494 void WINAPI NdrXmitOrRepAsFree(PMIDL_STUB_MESSAGE pStubMsg,
4495                                 unsigned char *pMemory,
4496                                 PFORMAT_STRING pFormat)
4497 {
4498     FIXME("stub\n");
4499 }
4500
4501 /***********************************************************************
4502  *           NdrBaseTypeMarshall [internal]
4503  */
4504 static unsigned char *WINAPI NdrBaseTypeMarshall(
4505     PMIDL_STUB_MESSAGE pStubMsg,
4506     unsigned char *pMemory,
4507     PFORMAT_STRING pFormat)
4508 {
4509     TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
4510
4511     switch(*pFormat)
4512     {
4513     case RPC_FC_BYTE:
4514     case RPC_FC_CHAR:
4515     case RPC_FC_SMALL:
4516     case RPC_FC_USMALL:
4517         *(UCHAR *)pStubMsg->Buffer = *(UCHAR *)pMemory;
4518         pStubMsg->Buffer += sizeof(UCHAR);
4519         TRACE("value: 0x%02x\n", *(UCHAR *)pMemory);
4520         break;
4521     case RPC_FC_WCHAR:
4522     case RPC_FC_SHORT:
4523     case RPC_FC_USHORT:
4524         ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
4525         *(USHORT *)pStubMsg->Buffer = *(USHORT *)pMemory;
4526         pStubMsg->Buffer += sizeof(USHORT);
4527         TRACE("value: 0x%04x\n", *(USHORT *)pMemory);
4528         break;
4529     case RPC_FC_LONG:
4530     case RPC_FC_ULONG:
4531     case RPC_FC_ERROR_STATUS_T:
4532     case RPC_FC_ENUM32:
4533         ALIGN_POINTER(pStubMsg->Buffer, sizeof(ULONG));
4534         *(ULONG *)pStubMsg->Buffer = *(ULONG *)pMemory;
4535         pStubMsg->Buffer += sizeof(ULONG);
4536         TRACE("value: 0x%08x\n", *(ULONG *)pMemory);
4537         break;
4538     case RPC_FC_FLOAT:
4539         ALIGN_POINTER(pStubMsg->Buffer, sizeof(float));
4540         *(float *)pStubMsg->Buffer = *(float *)pMemory;
4541         pStubMsg->Buffer += sizeof(float);
4542         break;
4543     case RPC_FC_DOUBLE:
4544         ALIGN_POINTER(pStubMsg->Buffer, sizeof(double));
4545         *(double *)pStubMsg->Buffer = *(double *)pMemory;
4546         pStubMsg->Buffer += sizeof(double);
4547         break;
4548     case RPC_FC_HYPER:
4549         ALIGN_POINTER(pStubMsg->Buffer, sizeof(ULONGLONG));
4550         *(ULONGLONG *)pStubMsg->Buffer = *(ULONGLONG *)pMemory;
4551         pStubMsg->Buffer += sizeof(ULONGLONG);
4552         TRACE("value: %s\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory));
4553         break;
4554     case RPC_FC_ENUM16:
4555         /* only 16-bits on the wire, so do a sanity check */
4556         if (*(UINT *)pMemory > USHRT_MAX)
4557             RpcRaiseException(RPC_X_ENUM_VALUE_OUT_OF_RANGE);
4558         ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
4559         *(USHORT *)pStubMsg->Buffer = *(UINT *)pMemory;
4560         pStubMsg->Buffer += sizeof(USHORT);
4561         TRACE("value: 0x%04x\n", *(UINT *)pMemory);
4562         break;
4563     default:
4564         FIXME("Unhandled base type: 0x%02x\n", *pFormat);
4565     }
4566
4567     STD_OVERFLOW_CHECK(pStubMsg);
4568
4569     /* FIXME: what is the correct return value? */
4570     return NULL;
4571 }
4572
4573 /***********************************************************************
4574  *           NdrBaseTypeUnmarshall [internal]
4575  */
4576 static unsigned char *WINAPI NdrBaseTypeUnmarshall(
4577     PMIDL_STUB_MESSAGE pStubMsg,
4578     unsigned char **ppMemory,
4579     PFORMAT_STRING pFormat,
4580     unsigned char fMustAlloc)
4581 {
4582     TRACE("pStubMsg: %p, ppMemory: %p, type: 0x%02x, fMustAlloc: %s\n", pStubMsg, ppMemory, *pFormat, fMustAlloc ? "true" : "false");
4583
4584 #define BASE_TYPE_UNMARSHALL(type) \
4585         ALIGN_POINTER(pStubMsg->Buffer, sizeof(type)); \
4586         if (fMustAlloc || !*ppMemory) \
4587             *ppMemory = NdrAllocate(pStubMsg, sizeof(type)); \
4588         TRACE("*ppMemory: %p\n", *ppMemory); \
4589         **(type **)ppMemory = *(type *)pStubMsg->Buffer; \
4590         pStubMsg->Buffer += sizeof(type);
4591
4592     switch(*pFormat)
4593     {
4594     case RPC_FC_BYTE:
4595     case RPC_FC_CHAR:
4596     case RPC_FC_SMALL:
4597     case RPC_FC_USMALL:
4598         BASE_TYPE_UNMARSHALL(UCHAR);
4599         TRACE("value: 0x%02x\n", **(UCHAR **)ppMemory);
4600         break;
4601     case RPC_FC_WCHAR:
4602     case RPC_FC_SHORT:
4603     case RPC_FC_USHORT:
4604         BASE_TYPE_UNMARSHALL(USHORT);
4605         TRACE("value: 0x%04x\n", **(USHORT **)ppMemory);
4606         break;
4607     case RPC_FC_LONG:
4608     case RPC_FC_ULONG:
4609     case RPC_FC_ERROR_STATUS_T:
4610     case RPC_FC_ENUM32:
4611         BASE_TYPE_UNMARSHALL(ULONG);
4612         TRACE("value: 0x%08x\n", **(ULONG **)ppMemory);
4613         break;
4614    case RPC_FC_FLOAT:
4615         BASE_TYPE_UNMARSHALL(float);
4616         TRACE("value: %f\n", **(float **)ppMemory);
4617         break;
4618     case RPC_FC_DOUBLE:
4619         BASE_TYPE_UNMARSHALL(double);
4620         TRACE("value: %f\n", **(double **)ppMemory);
4621         break;
4622     case RPC_FC_HYPER:
4623         BASE_TYPE_UNMARSHALL(ULONGLONG);
4624         TRACE("value: %s\n", wine_dbgstr_longlong(**(ULONGLONG **)ppMemory));
4625         break;
4626     case RPC_FC_ENUM16:
4627         ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
4628         if (fMustAlloc || !*ppMemory)
4629             *ppMemory = NdrAllocate(pStubMsg, sizeof(UINT));
4630         TRACE("*ppMemory: %p\n", *ppMemory);
4631         /* 16-bits on the wire, but int in memory */
4632         **(UINT **)ppMemory = *(USHORT *)pStubMsg->Buffer;
4633         pStubMsg->Buffer += sizeof(USHORT);
4634         TRACE("value: 0x%08x\n", **(UINT **)ppMemory);
4635         break;
4636     default:
4637         FIXME("Unhandled base type: 0x%02x\n", *pFormat);
4638     }
4639 #undef BASE_TYPE_UNMARSHALL
4640
4641     /* FIXME: what is the correct return value? */
4642
4643     return NULL;
4644 }
4645
4646 /***********************************************************************
4647  *           NdrBaseTypeBufferSize [internal]
4648  */
4649 static void WINAPI NdrBaseTypeBufferSize(
4650     PMIDL_STUB_MESSAGE pStubMsg,
4651     unsigned char *pMemory,
4652     PFORMAT_STRING pFormat)
4653 {
4654     TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
4655
4656     switch(*pFormat)
4657     {
4658     case RPC_FC_BYTE:
4659     case RPC_FC_CHAR:
4660     case RPC_FC_SMALL:
4661     case RPC_FC_USMALL:
4662         pStubMsg->BufferLength += sizeof(UCHAR);
4663         break;
4664     case RPC_FC_WCHAR:
4665     case RPC_FC_SHORT:
4666     case RPC_FC_USHORT:
4667     case RPC_FC_ENUM16:
4668         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(USHORT));
4669         pStubMsg->BufferLength += sizeof(USHORT);
4670         break;
4671     case RPC_FC_LONG:
4672     case RPC_FC_ULONG:
4673     case RPC_FC_ENUM32:
4674         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(ULONG));
4675         pStubMsg->BufferLength += sizeof(ULONG);
4676         break;
4677     case RPC_FC_FLOAT:
4678         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(float));
4679         pStubMsg->BufferLength += sizeof(float);
4680         break;
4681     case RPC_FC_DOUBLE:
4682         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(double));
4683         pStubMsg->BufferLength += sizeof(double);
4684         break;
4685     case RPC_FC_HYPER:
4686         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(ULONGLONG));
4687         pStubMsg->BufferLength += sizeof(ULONGLONG);
4688         break;
4689     case RPC_FC_ERROR_STATUS_T:
4690         ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(error_status_t));
4691         pStubMsg->BufferLength += sizeof(error_status_t);
4692         break;
4693     default:
4694         FIXME("Unhandled base type: 0x%02x\n", *pFormat);
4695     }
4696 }
4697
4698 /***********************************************************************
4699  *           NdrBaseTypeMemorySize [internal]
4700  */
4701 static ULONG WINAPI NdrBaseTypeMemorySize(
4702     PMIDL_STUB_MESSAGE pStubMsg,
4703     PFORMAT_STRING pFormat)
4704 {
4705     switch(*pFormat)
4706     {
4707     case RPC_FC_BYTE:
4708     case RPC_FC_CHAR:
4709     case RPC_FC_SMALL:
4710     case RPC_FC_USMALL:
4711         pStubMsg->Buffer += sizeof(UCHAR);
4712         pStubMsg->MemorySize += sizeof(UCHAR);
4713         return sizeof(UCHAR);
4714     case RPC_FC_WCHAR:
4715     case RPC_FC_SHORT:
4716     case RPC_FC_USHORT:
4717         pStubMsg->Buffer += sizeof(USHORT);
4718         pStubMsg->MemorySize += sizeof(USHORT);
4719         return sizeof(USHORT);
4720     case RPC_FC_LONG:
4721     case RPC_FC_ULONG:
4722         pStubMsg->Buffer += sizeof(ULONG);
4723         pStubMsg->MemorySize += sizeof(ULONG);
4724         return sizeof(ULONG);
4725     case RPC_FC_FLOAT:
4726         pStubMsg->Buffer += sizeof(float);
4727         pStubMsg->MemorySize += sizeof(float);
4728         return sizeof(float);
4729     case RPC_FC_DOUBLE:
4730         pStubMsg->Buffer += sizeof(double);
4731         pStubMsg->MemorySize += sizeof(double);
4732         return sizeof(double);
4733     case RPC_FC_HYPER:
4734         pStubMsg->Buffer += sizeof(ULONGLONG);
4735         pStubMsg->MemorySize += sizeof(ULONGLONG);
4736         return sizeof(ULONGLONG);
4737     case RPC_FC_ERROR_STATUS_T:
4738         pStubMsg->Buffer += sizeof(error_status_t);
4739         pStubMsg->MemorySize += sizeof(error_status_t);
4740         return sizeof(error_status_t);
4741     case RPC_FC_ENUM16:
4742     case RPC_FC_ENUM32:
4743         pStubMsg->Buffer += sizeof(INT);
4744         pStubMsg->MemorySize += sizeof(INT);
4745         return sizeof(INT);
4746     default:
4747         FIXME("Unhandled base type: 0x%02x\n", *pFormat);
4748        return 0;
4749     }
4750 }
4751
4752 /***********************************************************************
4753  *           NdrBaseTypeFree [internal]
4754  */
4755 static void WINAPI NdrBaseTypeFree(PMIDL_STUB_MESSAGE pStubMsg,
4756                                 unsigned char *pMemory,
4757                                 PFORMAT_STRING pFormat)
4758 {
4759    TRACE("pStubMsg %p pMemory %p type 0x%02x\n", pStubMsg, pMemory, *pFormat);
4760
4761    /* nothing to do */
4762 }
4763
4764 /***********************************************************************
4765  *           NdrClientContextMarshall [RPCRT4.@]
4766  */
4767 void WINAPI NdrClientContextMarshall(PMIDL_STUB_MESSAGE pStubMsg,
4768                                      NDR_CCONTEXT ContextHandle,
4769                                      int fCheck)
4770 {
4771     TRACE("(%p, %p, %d)\n", pStubMsg, ContextHandle, fCheck);
4772
4773     ALIGN_POINTER(pStubMsg->Buffer, 4);
4774
4775     /* FIXME: what does fCheck do? */
4776     NDRCContextMarshall(ContextHandle,
4777                         pStubMsg->Buffer);
4778
4779     pStubMsg->Buffer += cbNDRContext;
4780 }
4781
4782 /***********************************************************************
4783  *           NdrClientContextUnmarshall [RPCRT4.@]
4784  */
4785 void WINAPI NdrClientContextUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
4786                                        NDR_CCONTEXT * pContextHandle,
4787                                        RPC_BINDING_HANDLE BindHandle)
4788 {
4789     TRACE("(%p, %p, %p)\n", pStubMsg, pContextHandle, BindHandle);
4790
4791     ALIGN_POINTER(pStubMsg->Buffer, 4);
4792
4793     NDRCContextUnmarshall(pContextHandle,
4794                           BindHandle,
4795                           pStubMsg->Buffer,
4796                           pStubMsg->RpcMsg->DataRepresentation);
4797
4798     pStubMsg->Buffer += cbNDRContext;
4799 }
4800
4801 void WINAPI NdrServerContextMarshall(PMIDL_STUB_MESSAGE pStubMsg,
4802                                      NDR_SCONTEXT ContextHandle,
4803                                      NDR_RUNDOWN RundownRoutine )
4804 {
4805     FIXME("(%p, %p, %p): stub\n", pStubMsg, ContextHandle, RundownRoutine);
4806 }
4807
4808 NDR_SCONTEXT WINAPI NdrServerContextUnmarshall(PMIDL_STUB_MESSAGE pStubMsg)
4809 {
4810     FIXME("(%p): stub\n", pStubMsg);
4811     return NULL;
4812 }
4813
4814 void WINAPI NdrContextHandleSize(PMIDL_STUB_MESSAGE pStubMsg,
4815                                  unsigned char* pMemory,
4816                                  PFORMAT_STRING pFormat)
4817 {
4818     FIXME("(%p, %p, %p): stub\n", pStubMsg, pMemory, pFormat);
4819 }
4820
4821 NDR_SCONTEXT WINAPI NdrContextHandleInitialize(PMIDL_STUB_MESSAGE pStubMsg,
4822                                                PFORMAT_STRING pFormat)
4823 {
4824     FIXME("(%p, %p): stub\n", pStubMsg, pFormat);
4825     return NULL;
4826 }
4827
4828 void WINAPI NdrServerContextNewMarshall(PMIDL_STUB_MESSAGE pStubMsg,
4829                                         NDR_SCONTEXT ContextHandle,
4830                                         NDR_RUNDOWN RundownRoutine,
4831                                         PFORMAT_STRING pFormat)
4832 {
4833     FIXME("(%p, %p, %p, %p): stub\n", pStubMsg, ContextHandle, RundownRoutine, pFormat);
4834 }
4835
4836 NDR_SCONTEXT WINAPI NdrServerContextNewUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
4837                                                   PFORMAT_STRING pFormat)
4838 {
4839     FIXME("(%p, %p): stub\n", pStubMsg, pFormat);
4840     return NULL;
4841 }
4842
4843 #define NDR_CONTEXT_HANDLE_MAGIC 0x4352444e
4844
4845 typedef struct ndr_context_handle
4846 {
4847     DWORD      attributes;
4848     GUID       uuid;
4849 } ndr_context_handle;
4850
4851 struct context_handle_entry
4852 {
4853     struct list entry;
4854     DWORD magic;
4855     RPC_BINDING_HANDLE handle;
4856     ndr_context_handle wire_data;
4857 };
4858
4859 static struct list context_handle_list = LIST_INIT(context_handle_list);
4860
4861 static CRITICAL_SECTION ndr_context_cs;
4862 static CRITICAL_SECTION_DEBUG ndr_context_debug =
4863 {
4864     0, 0, &ndr_context_cs,
4865     { &ndr_context_debug.ProcessLocksList, &ndr_context_debug.ProcessLocksList },
4866       0, 0, { (DWORD_PTR)(__FILE__ ": ndr_context") }
4867 };
4868 static CRITICAL_SECTION ndr_context_cs = { &ndr_context_debug, -1, 0, 0, 0, 0 };
4869
4870 static struct context_handle_entry *get_context_entry(NDR_CCONTEXT CContext)
4871 {
4872     struct context_handle_entry *che = (struct context_handle_entry*) CContext;
4873
4874     if (che->magic != NDR_CONTEXT_HANDLE_MAGIC)
4875         return NULL;
4876     return che;
4877 }
4878
4879 static struct context_handle_entry *context_entry_from_guid(LPGUID uuid)
4880 {
4881     struct context_handle_entry *che;
4882     LIST_FOR_EACH_ENTRY(che, &context_handle_list, struct context_handle_entry, entry)
4883         if (IsEqualGUID(&che->wire_data.uuid, uuid))
4884             return che;
4885     return NULL;
4886 }
4887
4888 RPC_BINDING_HANDLE WINAPI NDRCContextBinding(NDR_CCONTEXT CContext)
4889 {
4890     struct context_handle_entry *che;
4891     RPC_BINDING_HANDLE handle = NULL;
4892
4893     TRACE("%p\n", CContext);
4894
4895     EnterCriticalSection(&ndr_context_cs);
4896     che = get_context_entry(CContext);
4897     if (che)
4898         handle = che->handle;
4899     LeaveCriticalSection(&ndr_context_cs);
4900
4901     if (!handle)
4902         RpcRaiseException(ERROR_INVALID_HANDLE);
4903     return handle;
4904 }
4905
4906 void WINAPI NDRCContextMarshall(NDR_CCONTEXT CContext, void *pBuff)
4907 {
4908     struct context_handle_entry *che;
4909
4910     TRACE("%p %p\n", CContext, pBuff);
4911
4912     if (CContext)
4913     {
4914         EnterCriticalSection(&ndr_context_cs);
4915         che = get_context_entry(CContext);
4916         memcpy(pBuff, &che->wire_data, sizeof (ndr_context_handle));
4917         LeaveCriticalSection(&ndr_context_cs);
4918     }
4919     else
4920     {
4921         ndr_context_handle *wire_data = (ndr_context_handle *)pBuff;
4922         wire_data->attributes = 0;
4923         wire_data->uuid = GUID_NULL;
4924     }
4925 }
4926
4927 static UINT ndr_update_context_handle(NDR_CCONTEXT *CContext,
4928                                       RPC_BINDING_HANDLE hBinding,
4929                                       ndr_context_handle *chi)
4930 {
4931     struct context_handle_entry *che = NULL;
4932
4933     /* a null UUID means we should free the context handle */
4934     if (IsEqualGUID(&chi->uuid, &GUID_NULL))
4935     {
4936         if (*CContext)
4937         {
4938             che = get_context_entry(*CContext);
4939             if (!che)
4940                 return ERROR_INVALID_HANDLE;
4941             list_remove(&che->entry);
4942             RpcBindingFree(&che->handle);
4943             HeapFree(GetProcessHeap(), 0, che);
4944             che = NULL;
4945         }
4946     }
4947     /* if there's no existing entry matching the GUID, allocate one */
4948     else if (!(che = context_entry_from_guid(&chi->uuid)))
4949     {
4950         che = HeapAlloc(GetProcessHeap(), 0, sizeof *che);
4951         if (!che)
4952             return ERROR_NOT_ENOUGH_MEMORY;
4953         che->magic = NDR_CONTEXT_HANDLE_MAGIC;
4954         RpcBindingCopy(hBinding, &che->handle);
4955         list_add_tail(&context_handle_list, &che->entry);
4956         memcpy(&che->wire_data, chi, sizeof *chi);
4957     }
4958
4959     *CContext = che;
4960
4961     return ERROR_SUCCESS;
4962 }
4963
4964 /***********************************************************************
4965  *           NDRCContextUnmarshall [RPCRT4.@]
4966  */
4967 void WINAPI NDRCContextUnmarshall(NDR_CCONTEXT *CContext,
4968                                   RPC_BINDING_HANDLE hBinding,
4969                                   void *pBuff, ULONG DataRepresentation)
4970 {
4971     UINT r;
4972
4973     TRACE("*%p=(%p) %p %p %08x\n",
4974           CContext, *CContext, hBinding, pBuff, DataRepresentation);
4975
4976     EnterCriticalSection(&ndr_context_cs);
4977     r = ndr_update_context_handle(CContext, hBinding, pBuff);
4978     LeaveCriticalSection(&ndr_context_cs);
4979     if (r)
4980         RpcRaiseException(r);
4981 }
4982
4983 /***********************************************************************
4984  *           NDRSContextMarshall [RPCRT4.@]
4985  */
4986 void WINAPI NDRSContextMarshall(NDR_SCONTEXT CContext,
4987                                void *pBuff,
4988                                NDR_RUNDOWN userRunDownIn)
4989 {
4990     FIXME("(%p %p %p): stub\n", CContext, pBuff, userRunDownIn);
4991 }
4992
4993 /***********************************************************************
4994  *           NDRSContextMarshallEx [RPCRT4.@]
4995  */
4996 void WINAPI NDRSContextMarshallEx(RPC_BINDING_HANDLE hBinding,
4997                                   NDR_SCONTEXT CContext,
4998                                   void *pBuff,
4999                                   NDR_RUNDOWN userRunDownIn)
5000 {
5001     FIXME("(%p %p %p %p): stub\n", hBinding, CContext, pBuff, userRunDownIn);
5002 }
5003
5004 /***********************************************************************
5005  *           NDRSContextMarshall2 [RPCRT4.@]
5006  */
5007 void WINAPI NDRSContextMarshall2(RPC_BINDING_HANDLE hBinding,
5008                                  NDR_SCONTEXT CContext,
5009                                  void *pBuff,
5010                                  NDR_RUNDOWN userRunDownIn,
5011                                  void *CtxGuard, ULONG Flags)
5012 {
5013     FIXME("(%p %p %p %p %p %u): stub\n",
5014           hBinding, CContext, pBuff, userRunDownIn, CtxGuard, Flags);
5015 }
5016
5017 /***********************************************************************
5018  *           NDRSContextUnmarshall [RPCRT4.@]
5019  */
5020 NDR_SCONTEXT WINAPI NDRSContextUnmarshall(void *pBuff,
5021                                           ULONG DataRepresentation)
5022 {
5023     FIXME("(%p %08x): stub\n", pBuff, DataRepresentation);
5024     return NULL;
5025 }
5026
5027 /***********************************************************************
5028  *           NDRSContextUnmarshallEx [RPCRT4.@]
5029  */
5030 NDR_SCONTEXT WINAPI NDRSContextUnmarshallEx(RPC_BINDING_HANDLE hBinding,
5031                                             void *pBuff,
5032                                             ULONG DataRepresentation)
5033 {
5034     FIXME("(%p %p %08x): stub\n", hBinding, pBuff, DataRepresentation);
5035     return NULL;
5036 }
5037
5038 /***********************************************************************
5039  *           NDRSContextUnmarshall2 [RPCRT4.@]
5040  */
5041 NDR_SCONTEXT WINAPI NDRSContextUnmarshall2(RPC_BINDING_HANDLE hBinding,
5042                                            void *pBuff,
5043                                            ULONG DataRepresentation,
5044                                            void *CtxGuard, ULONG Flags)
5045 {
5046     FIXME("(%p %p %08x %p %u): stub\n",
5047           hBinding, pBuff, DataRepresentation, CtxGuard, Flags);
5048     return NULL;
5049 }