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