projects / reactos.git / blob
? search:


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