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