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