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