72cce6f457ef30a50b097115883208b129620fc4
[reactos.git] / reactos / lib / rpcrt4 / ndr_marshall.c
1 /*
2 * NDR data marshalling
3 *
4 * Copyright 2002 Greg Turner
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * TODO:
21 * - figure out whether we *really* got this right
22 * - check for errors and throw exceptions
23 */
24
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <assert.h>
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "winerror.h"
33 #include "winreg.h"
34
35 #include "ndr_misc.h"
36 #include "rpcndr.h"
37
38 #include "wine/unicode.h"
39 #include "wine/rpcfc.h"
40
41 #include "wine/debug.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(ole);
44
45 #define BUFFER_PARANOIA 20
46
47 #if defined(__i386__)
48 # define LITTLE_ENDIAN_UINT32_WRITE(pchar, uint32) \
49 (*((UINT32 *)(pchar)) = (uint32))
50
51 # define LITTLE_ENDIAN_UINT32_READ(pchar) \
52 (*((UINT32 *)(pchar)))
53 #else
54 /* these would work for i386 too, but less efficient */
55 # define LITTLE_ENDIAN_UINT32_WRITE(pchar, uint32) \
56 (*(pchar) = LOBYTE(LOWORD(uint32)), \
57 *((pchar)+1) = HIBYTE(LOWORD(uint32)), \
58 *((pchar)+2) = LOBYTE(HIWORD(uint32)), \
59 *((pchar)+3) = HIBYTE(HIWORD(uint32)), \
60 (uint32)) /* allow as r-value */
61
62 # define LITTLE_ENDIAN_UINT32_READ(pchar) \
63 (MAKELONG( \
64 MAKEWORD(*(pchar), *((pchar)+1)), \
65 MAKEWORD(*((pchar)+2), *((pchar)+3))))
66 #endif
67
68 #define BIG_ENDIAN_UINT32_WRITE(pchar, uint32) \
69 (*((pchar)+3) = LOBYTE(LOWORD(uint32)), \
70 *((pchar)+2) = HIBYTE(LOWORD(uint32)), \
71 *((pchar)+1) = LOBYTE(HIWORD(uint32)), \
72 *(pchar) = HIBYTE(HIWORD(uint32)), \
73 (uint32)) /* allow as r-value */
74
75 #define BIG_ENDIAN_UINT32_READ(pchar) \
76 (MAKELONG( \
77 MAKEWORD(*((pchar)+3), *((pchar)+2)), \
78 MAKEWORD(*((pchar)+1), *(pchar))))
79
80 #ifdef NDR_LOCAL_IS_BIG_ENDIAN
81 # define NDR_LOCAL_UINT32_WRITE(pchar, uint32) \
82 BIG_ENDIAN_UINT32_WRITE(pchar, uint32)
83 # define NDR_LOCAL_UINT32_READ(pchar) \
84 BIG_ENDIAN_UINT32_READ(pchar)
85 #else
86 # define NDR_LOCAL_UINT32_WRITE(pchar, uint32) \
87 LITTLE_ENDIAN_UINT32_WRITE(pchar, uint32)
88 # define NDR_LOCAL_UINT32_READ(pchar) \
89 LITTLE_ENDIAN_UINT32_READ(pchar)
90 #endif
91
92 /* _Align must be the desired alignment minus 1,
93 * e.g. ALIGN_LENGTH(len, 3) to align on a dword boundary. */
94 #define ALIGNED_LENGTH(_Len, _Align) (((_Len)+(_Align))&~(_Align))
95 #define ALIGNED_POINTER(_Ptr, _Align) ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
96 #define ALIGN_LENGTH(_Len, _Align) _Len = ALIGNED_LENGTH(_Len, _Align)
97 #define ALIGN_POINTER(_Ptr, _Align) _Ptr = ALIGNED_POINTER(_Ptr, _Align)
98
99 #define STD_OVERFLOW_CHECK(_Msg) do { \
100 TRACE("buffer=%d/%ld\n", _Msg->Buffer - _Msg->BufferStart, _Msg->BufferLength); \
101 if (_Msg->Buffer > _Msg->BufferEnd) ERR("buffer overflow %d bytes\n", _Msg->Buffer - _Msg->BufferEnd); \
102 } while (0)
103
104 #define NDR_TABLE_SIZE 128
105 #define NDR_TABLE_MASK 127
106
107 NDR_MARSHALL NdrMarshaller[NDR_TABLE_SIZE] = {
108 0, 0, 0, 0, 0, 0, 0, 0,
109 0, 0, 0, 0, 0, 0, 0, 0,
110 /* 0x10 */
111 0,
112 /* 0x11 */
113 NdrPointerMarshall, NdrPointerMarshall,
114 NdrPointerMarshall, NdrPointerMarshall,
115 /* 0x15 */
116 NdrSimpleStructMarshall, NdrSimpleStructMarshall,
117 NdrConformantStructMarshall, NdrConformantStructMarshall,
118 NdrConformantVaryingStructMarshall,
119 NdrComplexStructMarshall,
120 /* 0x1b */
121 NdrConformantArrayMarshall,
122 NdrConformantVaryingArrayMarshall,
123 NdrFixedArrayMarshall, NdrFixedArrayMarshall,
124 NdrVaryingArrayMarshall, NdrVaryingArrayMarshall,
125 NdrComplexArrayMarshall,
126 /* 0x22 */
127 NdrConformantStringMarshall, 0, 0,
128 NdrConformantStringMarshall, 0, 0, 0, 0,
129 /* 0x2a */
130 NdrEncapsulatedUnionMarshall,
131 NdrNonEncapsulatedUnionMarshall,
132 0,
133 NdrXmitOrRepAsMarshall, NdrXmitOrRepAsMarshall,
134 /* 0x2f */
135 NdrInterfacePointerMarshall,
136 /* 0xb0 */
137 0, 0, 0, 0,
138 NdrUserMarshalMarshall
139 };
140 NDR_UNMARSHALL NdrUnmarshaller[NDR_TABLE_SIZE] = {
141 0, 0, 0, 0, 0, 0, 0, 0,
142 0, 0, 0, 0, 0, 0, 0, 0,
143 /* 0x10 */
144 0,
145 /* 0x11 */
146 NdrPointerUnmarshall, NdrPointerUnmarshall,
147 NdrPointerUnmarshall, NdrPointerUnmarshall,
148 /* 0x15 */
149 NdrSimpleStructUnmarshall, NdrSimpleStructUnmarshall,
150 NdrConformantStructUnmarshall, NdrConformantStructUnmarshall,
151 NdrConformantVaryingStructUnmarshall,
152 NdrComplexStructUnmarshall,
153 /* 0x1b */
154 NdrConformantArrayUnmarshall,
155 NdrConformantVaryingArrayUnmarshall,
156 NdrFixedArrayUnmarshall, NdrFixedArrayUnmarshall,
157 NdrVaryingArrayUnmarshall, NdrVaryingArrayUnmarshall,
158 NdrComplexArrayUnmarshall,
159 /* 0x22 */
160 NdrConformantStringUnmarshall, 0, 0,
161 NdrConformantStringUnmarshall, 0, 0, 0, 0,
162 /* 0x2a */
163 NdrEncapsulatedUnionUnmarshall,
164 NdrNonEncapsulatedUnionUnmarshall,
165 0,
166 NdrXmitOrRepAsUnmarshall, NdrXmitOrRepAsUnmarshall,
167 /* 0x2f */
168 NdrInterfacePointerUnmarshall,
169 /* 0xb0 */
170 0, 0, 0, 0,
171 NdrUserMarshalUnmarshall
172 };
173 NDR_BUFFERSIZE NdrBufferSizer[NDR_TABLE_SIZE] = {
174 0, 0, 0, 0, 0, 0, 0, 0,
175 0, 0, 0, 0, 0, 0, 0, 0,
176 /* 0x10 */
177 0,
178 /* 0x11 */
179 NdrPointerBufferSize, NdrPointerBufferSize,
180 NdrPointerBufferSize, NdrPointerBufferSize,
181 /* 0x15 */
182 NdrSimpleStructBufferSize, NdrSimpleStructBufferSize,
183 NdrConformantStructBufferSize, NdrConformantStructBufferSize,
184 NdrConformantVaryingStructBufferSize,
185 NdrComplexStructBufferSize,
186 /* 0x1b */
187 NdrConformantArrayBufferSize,
188 NdrConformantVaryingArrayBufferSize,
189 NdrFixedArrayBufferSize, NdrFixedArrayBufferSize,
190 NdrVaryingArrayBufferSize, NdrVaryingArrayBufferSize,
191 NdrComplexArrayBufferSize,
192 /* 0x22 */
193 NdrConformantStringBufferSize, 0, 0,
194 NdrConformantStringBufferSize, 0, 0, 0, 0,
195 /* 0x2a */
196 NdrEncapsulatedUnionBufferSize,
197 NdrNonEncapsulatedUnionBufferSize,
198 0,
199 NdrXmitOrRepAsBufferSize, NdrXmitOrRepAsBufferSize,
200 /* 0x2f */
201 NdrInterfacePointerBufferSize,
202 /* 0xb0 */
203 0, 0, 0, 0,
204 NdrUserMarshalBufferSize
205 };
206 NDR_MEMORYSIZE NdrMemorySizer[NDR_TABLE_SIZE] = {
207 0, 0, 0, 0, 0, 0, 0, 0,
208 0, 0, 0, 0, 0, 0, 0, 0,
209 /* 0x10 */
210 0,
211 /* 0x11 */
212 NdrPointerMemorySize, NdrPointerMemorySize,
213 NdrPointerMemorySize, NdrPointerMemorySize,
214 /* 0x15 */
215 NdrSimpleStructMemorySize, NdrSimpleStructMemorySize,
216 0, 0, 0,
217 NdrComplexStructMemorySize,
218 /* 0x1b */
219 NdrConformantArrayMemorySize, 0, 0, 0, 0, 0,
220 NdrComplexArrayMemorySize,
221 /* 0x22 */
222 NdrConformantStringMemorySize, 0, 0,
223 NdrConformantStringMemorySize, 0, 0, 0, 0,
224 /* 0x2a */
225 0, 0, 0, 0, 0,
226 /* 0x2f */
227 NdrInterfacePointerMemorySize,
228 /* 0xb0 */
229 0, 0, 0, 0,
230 NdrUserMarshalMemorySize
231 };
232 NDR_FREE NdrFreer[NDR_TABLE_SIZE] = {
233 0, 0, 0, 0, 0, 0, 0, 0,
234 0, 0, 0, 0, 0, 0, 0, 0,
235 /* 0x10 */
236 0,
237 /* 0x11 */
238 NdrPointerFree, NdrPointerFree,
239 NdrPointerFree, NdrPointerFree,
240 /* 0x15 */
241 NdrSimpleStructFree, NdrSimpleStructFree,
242 NdrConformantStructFree, NdrConformantStructFree,
243 NdrConformantVaryingStructFree,
244 NdrComplexStructFree,
245 /* 0x1b */
246 NdrConformantArrayFree,
247 NdrConformantVaryingArrayFree,
248 NdrFixedArrayFree, NdrFixedArrayFree,
249 NdrVaryingArrayFree, NdrVaryingArrayFree,
250 NdrComplexArrayFree,
251 /* 0x22 */
252 0, 0, 0,
253 0, 0, 0, 0, 0,
254 /* 0x2a */
255 NdrEncapsulatedUnionFree,
256 NdrNonEncapsulatedUnionFree,
257 0,
258 NdrXmitOrRepAsFree, NdrXmitOrRepAsFree,
259 /* 0x2f */
260 NdrInterfacePointerFree,
261 /* 0xb0 */
262 0, 0, 0, 0,
263 NdrUserMarshalFree
264 };
265
266 void * WINAPI NdrAllocate(MIDL_STUB_MESSAGE *pStubMsg, size_t len)
267 {
268 /* hmm, this is probably supposed to do more? */
269 return pStubMsg->pfnAllocate(len);
270 }
271
272 static void WINAPI NdrFree(MIDL_STUB_MESSAGE *pStubMsg, unsigned char *Pointer)
273 {
274 pStubMsg->pfnFree(Pointer);
275 }
276
277 PFORMAT_STRING ReadConformance(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat)
278 {
279 pStubMsg->MaxCount = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer);
280 pStubMsg->Buffer += 4;
281 TRACE("unmarshalled conformance is %ld\n", pStubMsg->MaxCount);
282 return pFormat+4;
283 }
284
285 PFORMAT_STRING ComputeConformance(MIDL_STUB_MESSAGE *pStubMsg, unsigned char *pMemory,
286 PFORMAT_STRING pFormat, ULONG_PTR def)
287 {
288 BYTE dtype = pFormat[0] & 0xf;
289 DWORD ofs = (DWORD)pFormat[2] | ((DWORD)pFormat[3] << 8);
290 LPVOID ptr = NULL;
291 DWORD data = 0;
292
293 if (pFormat[0] == 0xff) {
294 /* null descriptor */
295 pStubMsg->MaxCount = def;
296 goto finish_conf;
297 }
298
299 switch (pFormat[0] & 0xf0) {
300 case RPC_FC_NORMAL_CONFORMANCE:
301 TRACE("normal conformance, ofs=%ld\n", ofs);
302 ptr = pMemory + ofs;
303 break;
304 case RPC_FC_POINTER_CONFORMANCE:
305 TRACE("pointer conformance, ofs=%ld\n", ofs);
306 ptr = pStubMsg->Memory + ofs;
307 break;
308 case RPC_FC_TOP_LEVEL_CONFORMANCE:
309 TRACE("toplevel conformance, ofs=%ld\n", ofs);
310 if (pStubMsg->StackTop) {
311 ptr = pStubMsg->StackTop + ofs;
312 }
313 else {
314 /* -Os mode, MaxCount is already set */
315 goto finish_conf;
316 }
317 break;
318 case RPC_FC_CONSTANT_CONFORMANCE:
319 data = ofs | ((DWORD)pFormat[1] << 16);
320 TRACE("constant conformance, val=%ld\n", data);
321 pStubMsg->MaxCount = data;
322 goto finish_conf;
323 case RPC_FC_TOP_LEVEL_MULTID_CONFORMANCE:
324 FIXME("toplevel multidimensional conformance, ofs=%ld\n", ofs);
325 if (pStubMsg->StackTop) {
326 ptr = pStubMsg->StackTop + ofs;
327 }
328 else {
329 /* ? */
330 goto done_conf_grab;
331 }
332 break;
333 default:
334 FIXME("unknown conformance type %x\n", pFormat[0] & 0xf0);
335 }
336
337 switch (pFormat[1]) {
338 case RPC_FC_DEREFERENCE:
339 ptr = *(LPVOID*)ptr;
340 break;
341 case RPC_FC_CALLBACK:
342 /* ofs is index into StubDesc->apfnExprEval */
343 FIXME("handle callback\n");
344 goto finish_conf;
345 default:
346 break;
347 }
348
349 switch (dtype) {
350 case RPC_FC_LONG:
351 case RPC_FC_ULONG:
352 data = *(DWORD*)ptr;
353 break;
354 case RPC_FC_SHORT:
355 data = *(SHORT*)ptr;
356 break;
357 case RPC_FC_USHORT:
358 data = *(USHORT*)ptr;
359 break;
360 case RPC_FC_SMALL:
361 data = *(CHAR*)ptr;
362 break;
363 case RPC_FC_USMALL:
364 data = *(UCHAR*)ptr;
365 break;
366 default:
367 FIXME("unknown conformance data type %x\n", dtype);
368 goto done_conf_grab;
369 }
370 TRACE("dereferenced data type %x at %p, got %ld\n", dtype, ptr, data);
371
372 done_conf_grab:
373 switch (pFormat[1]) {
374 case 0: /* no op */
375 pStubMsg->MaxCount = data;
376 break;
377 case RPC_FC_DEREFERENCE:
378 /* already handled */
379 break;
380 default:
381 FIXME("unknown conformance op %d\n", pFormat[1]);
382 goto finish_conf;
383 }
384
385 finish_conf:
386 TRACE("resulting conformance is %ld\n", pStubMsg->MaxCount);
387 return pFormat+4;
388 }
389
390
391 /*
392 * NdrConformantString:
393 *
394 * What MS calls a ConformantString is, in DCE terminology,
395 * a Varying-Conformant String.
396 * [
397 * maxlen: DWORD (max # of CHARTYPE characters, inclusive of '\0')
398 * offset: DWORD (actual string data begins at (offset) CHARTYPE's
399 * into unmarshalled string)
400 * length: DWORD (# of CHARTYPE characters, inclusive of '\0')
401 * [
402 * data: CHARTYPE[maxlen]
403 * ]
404 * ], where CHARTYPE is the appropriate character type (specified externally)
405 *
406 */
407
408 /***********************************************************************
409 * NdrConformantStringMarshall [RPCRT4.@]
410 */
411 unsigned char *WINAPI NdrConformantStringMarshall(MIDL_STUB_MESSAGE *pStubMsg,
412 unsigned char *pszMessage, PFORMAT_STRING pFormat)
413 {
414 unsigned long len, esize;
415 unsigned char *c;
416
417 TRACE("(pStubMsg == ^%p, pszMessage == ^%p, pFormat == ^%p)\n", pStubMsg, pszMessage, pFormat);
418
419 assert(pFormat);
420 if (pszMessage == NULL) {
421 TRACE("string=%s\n", debugstr_a(pszMessage));
422 len = 0;
423 esize = 0;
424 }
425 else if (*pFormat == RPC_FC_C_CSTRING) {
426 TRACE("string=%s\n", debugstr_a(pszMessage));
427 len = strlen(pszMessage)+1;
428 esize = 1;
429 }
430 else if (*pFormat == RPC_FC_C_WSTRING) {
431 TRACE("string=%s\n", debugstr_w((LPWSTR)pszMessage));
432 len = strlenW((LPWSTR)pszMessage)+1;
433 esize = 2;
434 }
435 else {
436 ERR("Unhandled string type: %#x\n", *pFormat);
437 /* FIXME: raise an exception. */
438 return NULL;
439 }
440
441 if (pFormat[1] != RPC_FC_PAD) {
442 FIXME("sized string format=%d\n", pFormat[1]);
443 }
444
445 assert( (pStubMsg->BufferLength >= (len*esize + 13)) && (pStubMsg->Buffer != NULL) );
446
447 c = pStubMsg->Buffer;
448 memset(c, 0, 12);
449 NDR_LOCAL_UINT32_WRITE(c, len); /* max length: strlen + 1 (for '\0') */
450 c += 8; /* offset: 0 */
451 NDR_LOCAL_UINT32_WRITE(c, len); /* actual length: (same) */
452 c += 4;
453 if (len != 0) {
454 memcpy(c, pszMessage, len*esize); /* the string itself */
455 c += len*esize;
456 }
457 pStubMsg->Buffer = c;
458
459 STD_OVERFLOW_CHECK(pStubMsg);
460
461 /* success */
462 return NULL; /* is this always right? */
463 }
464
465 /***********************************************************************
466 * NdrConformantStringBufferSize [RPCRT4.@]
467 */
468 void WINAPI NdrConformantStringBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
469 unsigned char* pMemory, PFORMAT_STRING pFormat)
470 {
471 TRACE("(pStubMsg == ^%p, pMemory == ^%p, pFormat == ^%p)\n", pStubMsg, pMemory, pFormat);
472
473 assert(pFormat);
474 if (pMemory == NULL) {
475 /* we need 12 octets for the [maxlen, offset, len] DWORDS */
476 TRACE("string=NULL\n");
477 pStubMsg->BufferLength += 12 + BUFFER_PARANOIA;
478 }
479 else if (*pFormat == RPC_FC_C_CSTRING) {
480 /* we need 12 octets for the [maxlen, offset, len] DWORDS, + 1 octet for '\0' */
481 TRACE("string=%s\n", debugstr_a(pMemory));
482 pStubMsg->BufferLength += strlen(pMemory) + 13 + BUFFER_PARANOIA;
483 }
484 else if (*pFormat == RPC_FC_C_WSTRING) {
485 /* we need 12 octets for the [maxlen, offset, len] DWORDS, + 2 octets for L'\0' */
486 TRACE("string=%s\n", debugstr_w((LPWSTR)pMemory));
487 pStubMsg->BufferLength += strlenW((LPWSTR)pMemory)*2 + 14 + BUFFER_PARANOIA;
488 }
489 else {
490 ERR("Unhandled string type: %#x\n", *pFormat);
491 /* FIXME: raise an exception */
492 }
493
494 if (pFormat[1] != RPC_FC_PAD) {
495 FIXME("sized string format=%d\n", pFormat[1]);
496 }
497 }
498
499 /************************************************************************
500 * NdrConformantStringMemorySize [RPCRT4.@]
501 */
502 unsigned long WINAPI NdrConformantStringMemorySize( PMIDL_STUB_MESSAGE pStubMsg,
503 PFORMAT_STRING pFormat )
504 {
505 unsigned long rslt = 0;
506
507 TRACE("(pStubMsg == ^%p, pFormat == ^%p)\n", pStubMsg, pFormat);
508
509 assert(pStubMsg && pFormat);
510
511 if (*pFormat == RPC_FC_C_CSTRING) {
512 rslt = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer); /* maxlen */
513 }
514 else if (*pFormat == RPC_FC_C_WSTRING) {
515 rslt = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer)*2; /* maxlen */
516 }
517 else {
518 ERR("Unhandled string type: %#x\n", *pFormat);
519 /* FIXME: raise an exception */
520 }
521
522 if (pFormat[1] != RPC_FC_PAD) {
523 FIXME("sized string format=%d\n", pFormat[1]);
524 }
525
526 TRACE(" --> %lu\n", rslt);
527 return rslt;
528 }
529
530 /************************************************************************
531 * NdrConformantStringUnmarshall [RPCRT4.@]
532 */
533 unsigned char *WINAPI NdrConformantStringUnmarshall( PMIDL_STUB_MESSAGE pStubMsg,
534 unsigned char** ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc )
535 {
536 unsigned long len, esize, ofs;
537 unsigned char *pMem;
538
539 TRACE("(pStubMsg == ^%p, *pMemory == ^%p, pFormat == ^%p, fMustAlloc == %u)\n",
540 pStubMsg, *ppMemory, pFormat, fMustAlloc);
541
542 assert(pFormat && ppMemory && pStubMsg);
543
544 pStubMsg->Buffer += 4;
545 ofs = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer);
546 pStubMsg->Buffer += 4;
547 len = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer);
548 pStubMsg->Buffer += 4;
549
550 if (*pFormat == RPC_FC_C_CSTRING) esize = 1;
551 else if (*pFormat == RPC_FC_C_WSTRING) esize = 2;
552 else {
553 ERR("Unhandled string type: %#x\n", *pFormat);
554 /* FIXME: raise an exception */
555 esize = 0;
556 }
557
558 if (pFormat[1] != RPC_FC_PAD) {
559 FIXME("sized string format=%d\n", pFormat[1]);
560 }
561
562 if (fMustAlloc) {
563 *ppMemory = NdrAllocate(pStubMsg, len*esize + BUFFER_PARANOIA);
564 } else {
565 if (pStubMsg->ReuseBuffer && !*ppMemory)
566 /* for servers, we may just point straight into the RPC buffer, I think
567 * (I guess that's what MS does since MIDL code doesn't try to free) */
568 *ppMemory = pStubMsg->Buffer - ofs*esize;
569 /* for clients, memory should be provided by caller */
570 }
571
572 if (len == 0) {
573 *ppMemory = NULL;
574 return NULL;
575 }
576
577 pMem = *ppMemory + ofs*esize;
578
579 if (pMem != pStubMsg->Buffer)
580 memcpy(pMem, pStubMsg->Buffer, len*esize);
581
582 pStubMsg->Buffer += len*esize;
583
584 if (*pFormat == RPC_FC_C_CSTRING) {
585 TRACE("string=%s\n", debugstr_a(pMem));
586 }
587 else if (*pFormat == RPC_FC_C_WSTRING) {
588 TRACE("string=%s\n", debugstr_w((LPWSTR)pMem));
589 }
590
591 return NULL; /* FIXME: is this always right? */
592 }
593
594 static inline void dump_pointer_attr(unsigned char attr)
595 {
596 if (attr & RPC_FC_P_ALLOCALLNODES)
597 TRACE(" RPC_FC_P_ALLOCALLNODES");
598 if (attr & RPC_FC_P_DONTFREE)
599 TRACE(" RPC_FC_P_DONTFREE");
600 if (attr & RPC_FC_P_ONSTACK)
601 TRACE(" RPC_FC_P_ONSTACK");
602 if (attr & RPC_FC_P_SIMPLEPOINTER)
603 TRACE(" RPC_FC_P_SIMPLEPOINTER");
604 if (attr & RPC_FC_P_DEREF)
605 TRACE(" RPC_FC_P_DEREF");
606 TRACE("\n");
607 }
608
609 /***********************************************************************
610 * PointerMarshall
611 */
612 void WINAPI PointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
613 unsigned char *Buffer,
614 unsigned char *Pointer,
615 PFORMAT_STRING pFormat)
616 {
617 unsigned type = pFormat[0], attr = pFormat[1];
618 PFORMAT_STRING desc;
619 NDR_MARSHALL m;
620
621 TRACE("(%p,%p,%p,%p)\n", pStubMsg, Buffer, Pointer, pFormat);
622 TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
623 pFormat += 2;
624 if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
625 else desc = pFormat + *(const SHORT*)pFormat;
626 if (attr & RPC_FC_P_DEREF) {
627 Pointer = *(unsigned char**)Pointer;
628 TRACE("deref => %p\n", Pointer);
629 }
630
631 switch (type) {
632 case RPC_FC_RP: /* ref pointer (always non-null) */
633 #if 0 /* this causes problems for InstallShield so is disabled - we need more tests */
634 if (!Pointer)
635 RpcRaiseException(RPC_X_NULL_REF_POINTER);
636 #endif
637 break;
638 case RPC_FC_UP: /* unique pointer */
639 case RPC_FC_OP: /* object pointer - same as unique here */
640 TRACE("writing %p to buffer\n", Pointer);
641 NDR_LOCAL_UINT32_WRITE(pStubMsg->Buffer, (unsigned long)Pointer);
642 pStubMsg->Buffer += 4;
643 break;
644 case RPC_FC_FP:
645 default:
646 FIXME("unhandled ptr type=%02x\n", type);
647 RpcRaiseException(RPC_X_BAD_STUB_DATA);
648 }
649
650 TRACE("calling marshaller for type 0x%x\n", (int)*desc);
651
652 if (Pointer) {
653 m = NdrMarshaller[*desc & NDR_TABLE_MASK];
654 if (m) m(pStubMsg, Pointer, desc);
655 else FIXME("no marshaller for data type=%02x\n", *desc);
656 }
657
658 STD_OVERFLOW_CHECK(pStubMsg);
659 }
660
661 /***********************************************************************
662 * PointerUnmarshall
663 */
664 void WINAPI PointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
665 unsigned char *Buffer,
666 unsigned char **pPointer,
667 PFORMAT_STRING pFormat,
668 unsigned char fMustAlloc)
669 {
670 unsigned type = pFormat[0], attr = pFormat[1];
671 PFORMAT_STRING desc;
672 NDR_UNMARSHALL m;
673 DWORD pointer_id = 0;
674
675 TRACE("(%p,%p,%p,%p,%d)\n", pStubMsg, Buffer, pPointer, pFormat, fMustAlloc);
676 TRACE("type=0x%x, attr=", type); dump_pointer_attr(attr);
677 pFormat += 2;
678 if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
679 else desc = pFormat + *(const SHORT*)pFormat;
680 if (attr & RPC_FC_P_DEREF) {
681 pPointer = *(unsigned char***)pPointer;
682 TRACE("deref => %p\n", pPointer);
683 }
684
685 switch (type) {
686 case RPC_FC_RP: /* ref pointer (always non-null) */
687 pointer_id = ~0UL;
688 break;
689 case RPC_FC_UP: /* unique pointer */
690 pointer_id = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer);
691 pStubMsg->Buffer += 4;
692 break;
693 case RPC_FC_OP: /* object pointer - we must free data before overwriting it */
694 case RPC_FC_FP:
695 default:
696 FIXME("unhandled ptr type=%02x\n", type);
697 RpcRaiseException(RPC_X_BAD_STUB_DATA);
698 }
699
700 *pPointer = NULL;
701
702 if (pointer_id) {
703 m = NdrUnmarshaller[*desc & NDR_TABLE_MASK];
704 if (m) m(pStubMsg, pPointer, desc, fMustAlloc);
705 else FIXME("no unmarshaller for data type=%02x\n", *desc);
706 }
707
708 TRACE("pointer=%p\n", *pPointer);
709 }
710
711 /***********************************************************************
712 * PointerBufferSize
713 */
714 void WINAPI PointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
715 unsigned char *Pointer,
716 PFORMAT_STRING pFormat)
717 {
718 unsigned type = pFormat[0], attr = pFormat[1];
719 PFORMAT_STRING desc;
720 NDR_BUFFERSIZE m;
721
722 TRACE("(%p,%p,%p)\n", pStubMsg, Pointer, pFormat);
723 TRACE("type=%d, attr=%d\n", type, attr);
724 pFormat += 2;
725 if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
726 else desc = pFormat + *(const SHORT*)pFormat;
727 if (attr & RPC_FC_P_DEREF) {
728 Pointer = *(unsigned char**)Pointer;
729 TRACE("deref => %p\n", Pointer);
730 }
731
732 switch (type) {
733 case RPC_FC_RP: /* ref pointer (always non-null) */
734 break;
735 case RPC_FC_OP:
736 case RPC_FC_UP:
737 pStubMsg->BufferLength += 4;
738 /* NULL pointer has no further representation */
739 if (!Pointer)
740 return;
741 break;
742 case RPC_FC_FP:
743 default:
744 FIXME("unhandled ptr type=%02x\n", type);
745 RpcRaiseException(RPC_X_BAD_STUB_DATA);
746 }
747
748 m = NdrBufferSizer[*desc & NDR_TABLE_MASK];
749 if (m) m(pStubMsg, Pointer, desc);
750 else FIXME("no buffersizer for data type=%02x\n", *desc);
751 }
752
753 /***********************************************************************
754 * PointerMemorySize [RPCRT4.@]
755 */
756 unsigned long WINAPI PointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
757 unsigned char *Buffer,
758 PFORMAT_STRING pFormat)
759 {
760 unsigned type = pFormat[0], attr = pFormat[1];
761 PFORMAT_STRING desc;
762 NDR_MEMORYSIZE m;
763
764 FIXME("(%p,%p,%p): stub\n", pStubMsg, Buffer, pFormat);
765 TRACE("type=%d, attr=", type); dump_pointer_attr(attr);
766 pFormat += 2;
767 if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
768 else desc = pFormat + *(const SHORT*)pFormat;
769 if (attr & RPC_FC_P_DEREF) {
770 TRACE("deref\n");
771 }
772
773 switch (type) {
774 case RPC_FC_RP: /* ref pointer (always non-null) */
775 break;
776 default:
777 FIXME("unhandled ptr type=%02x\n", type);
778 RpcRaiseException(RPC_X_BAD_STUB_DATA);
779 }
780
781 m = NdrMemorySizer[*desc & NDR_TABLE_MASK];
782 if (m) m(pStubMsg, desc);
783 else FIXME("no memorysizer for data type=%02x\n", *desc);
784
785 return 0;
786 }
787
788 /***********************************************************************
789 * PointerFree [RPCRT4.@]
790 */
791 void WINAPI PointerFree(PMIDL_STUB_MESSAGE pStubMsg,
792 unsigned char *Pointer,
793 PFORMAT_STRING pFormat)
794 {
795 unsigned type = pFormat[0], attr = pFormat[1];
796 PFORMAT_STRING desc;
797 NDR_FREE m;
798
799 TRACE("(%p,%p,%p)\n", pStubMsg, Pointer, pFormat);
800 TRACE("type=%d, attr=", type); dump_pointer_attr(attr);
801 if (attr & RPC_FC_P_DONTFREE) return;
802 pFormat += 2;
803 if (attr & RPC_FC_P_SIMPLEPOINTER) desc = pFormat;
804 else desc = pFormat + *(const SHORT*)pFormat;
805 if (attr & RPC_FC_P_DEREF) {
806 Pointer = *(unsigned char**)Pointer;
807 TRACE("deref => %p\n", Pointer);
808 }
809
810 if (!Pointer) return;
811
812 m = NdrFreer[*desc & NDR_TABLE_MASK];
813 if (m) m(pStubMsg, Pointer, desc);
814
815 /* hmm... is this sensible?
816 * perhaps we should check if the memory comes from NdrAllocate,
817 * and deallocate only if so - checking if the pointer is between
818 * BufferStart and BufferEnd is probably no good since the buffer
819 * may be reallocated when the server wants to marshal the reply */
820 switch (*desc) {
821 case RPC_FC_BOGUS_STRUCT:
822 case RPC_FC_BOGUS_ARRAY:
823 case RPC_FC_USER_MARSHAL:
824 break;
825 default:
826 FIXME("unhandled data type=%02x\n", *desc);
827 case RPC_FC_CARRAY:
828 case RPC_FC_C_CSTRING:
829 case RPC_FC_C_WSTRING:
830 if (pStubMsg->ReuseBuffer) goto notfree;
831 break;
832 case RPC_FC_IP:
833 goto notfree;
834 }
835
836 if (attr & RPC_FC_P_ONSTACK) {
837 TRACE("not freeing stack ptr %p\n", Pointer);
838 return;
839 }
840 TRACE("freeing %p\n", Pointer);
841 NdrFree(pStubMsg, Pointer);
842 return;
843 notfree:
844 TRACE("not freeing %p\n", Pointer);
845 }
846
847 /***********************************************************************
848 * EmbeddedPointerMarshall
849 */
850 unsigned char * WINAPI EmbeddedPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
851 unsigned char *pMemory,
852 PFORMAT_STRING pFormat)
853 {
854 unsigned char *Mark = pStubMsg->BufferMark;
855 unsigned long Offset = pStubMsg->Offset;
856 unsigned ofs, rep, count, stride, xofs;
857
858 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
859
860 if (*pFormat != RPC_FC_PP) return NULL;
861 pFormat += 2;
862
863 while (pFormat[0] != RPC_FC_END) {
864 switch (pFormat[0]) {
865 default:
866 FIXME("unknown repeat type %d\n", pFormat[0]);
867 case RPC_FC_NO_REPEAT:
868 rep = 1;
869 stride = 0;
870 ofs = 0;
871 count = 1;
872 xofs = 0;
873 pFormat += 2;
874 break;
875 case RPC_FC_FIXED_REPEAT:
876 rep = *(const WORD*)&pFormat[2];
877 stride = *(const WORD*)&pFormat[4];
878 ofs = *(const WORD*)&pFormat[6];
879 count = *(const WORD*)&pFormat[8];
880 xofs = 0;
881 pFormat += 10;
882 break;
883 case RPC_FC_VARIABLE_REPEAT:
884 rep = pStubMsg->MaxCount;
885 stride = *(const WORD*)&pFormat[2];
886 ofs = *(const WORD*)&pFormat[4];
887 count = *(const WORD*)&pFormat[6];
888 xofs = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? Offset * stride : 0;
889 pFormat += 8;
890 break;
891 }
892 /* ofs doesn't seem to matter in this context */
893 while (rep) {
894 PFORMAT_STRING info = pFormat;
895 unsigned char *membase = pMemory + xofs;
896 unsigned u;
897 for (u=0; u<count; u++,info+=8) {
898 unsigned char *memptr = membase + *(const SHORT*)&info[0];
899 unsigned char *bufptr = Mark + *(const SHORT*)&info[2];
900 PointerMarshall(pStubMsg, bufptr, *(unsigned char**)memptr, info+4);
901 }
902 rep--;
903 }
904 pFormat += 8 * count;
905 }
906
907 STD_OVERFLOW_CHECK(pStubMsg);
908
909 return NULL;
910 }
911
912 /***********************************************************************
913 * EmbeddedPointerUnmarshall
914 */
915 unsigned char * WINAPI EmbeddedPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
916 unsigned char **ppMemory,
917 PFORMAT_STRING pFormat,
918 unsigned char fMustAlloc)
919 {
920 unsigned char *Mark = pStubMsg->BufferMark;
921 unsigned long Offset = pStubMsg->Offset;
922 unsigned ofs, rep, count, stride, xofs;
923
924 TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
925
926 if (*pFormat != RPC_FC_PP) return NULL;
927 pFormat += 2;
928
929 while (pFormat[0] != RPC_FC_END) {
930 switch (pFormat[0]) {
931 default:
932 FIXME("unknown repeat type %d\n", pFormat[0]);
933 case RPC_FC_NO_REPEAT:
934 rep = 1;
935 stride = 0;
936 ofs = 0;
937 count = 1;
938 xofs = 0;
939 pFormat += 2;
940 break;
941 case RPC_FC_FIXED_REPEAT:
942 rep = *(const WORD*)&pFormat[2];
943 stride = *(const WORD*)&pFormat[4];
944 ofs = *(const WORD*)&pFormat[6];
945 count = *(const WORD*)&pFormat[8];
946 xofs = 0;
947 pFormat += 10;
948 break;
949 case RPC_FC_VARIABLE_REPEAT:
950 rep = pStubMsg->MaxCount;
951 stride = *(const WORD*)&pFormat[2];
952 ofs = *(const WORD*)&pFormat[4];
953 count = *(const WORD*)&pFormat[6];
954 xofs = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? Offset * stride : 0;
955 pFormat += 8;
956 break;
957 }
958 /* ofs doesn't seem to matter in this context */
959 while (rep) {
960 PFORMAT_STRING info = pFormat;
961 unsigned char *membase = *ppMemory + xofs;
962 unsigned u;
963 for (u=0; u<count; u++,info+=8) {
964 unsigned char *memptr = membase + *(const SHORT*)&info[0];
965 unsigned char *bufptr = Mark + *(const SHORT*)&info[2];
966 PointerUnmarshall(pStubMsg, bufptr, (unsigned char**)memptr, info+4, fMustAlloc);
967 }
968 rep--;
969 }
970 pFormat += 8 * count;
971 }
972
973 return NULL;
974 }
975
976 /***********************************************************************
977 * EmbeddedPointerBufferSize
978 */
979 void WINAPI EmbeddedPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
980 unsigned char *pMemory,
981 PFORMAT_STRING pFormat)
982 {
983 unsigned long Offset = pStubMsg->Offset;
984 unsigned ofs, rep, count, stride, xofs;
985
986 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
987 if (*pFormat != RPC_FC_PP) return;
988 pFormat += 2;
989
990 while (pFormat[0] != RPC_FC_END) {
991 switch (pFormat[0]) {
992 default:
993 FIXME("unknown repeat type %d\n", pFormat[0]);
994 case RPC_FC_NO_REPEAT:
995 rep = 1;
996 stride = 0;
997 ofs = 0;
998 count = 1;
999 xofs = 0;
1000 pFormat += 2;
1001 break;
1002 case RPC_FC_FIXED_REPEAT:
1003 rep = *(const WORD*)&pFormat[2];
1004 stride = *(const WORD*)&pFormat[4];
1005 ofs = *(const WORD*)&pFormat[6];
1006 count = *(const WORD*)&pFormat[8];
1007 xofs = 0;
1008 pFormat += 10;
1009 break;
1010 case RPC_FC_VARIABLE_REPEAT:
1011 rep = pStubMsg->MaxCount;
1012 stride = *(const WORD*)&pFormat[2];
1013 ofs = *(const WORD*)&pFormat[4];
1014 count = *(const WORD*)&pFormat[6];
1015 xofs = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? Offset * stride : 0;
1016 pFormat += 8;
1017 break;
1018 }
1019 /* ofs doesn't seem to matter in this context */
1020 while (rep) {
1021 PFORMAT_STRING info = pFormat;
1022 unsigned char *membase = pMemory + xofs;
1023 unsigned u;
1024 for (u=0; u<count; u++,info+=8) {
1025 unsigned char *memptr = membase + *(const SHORT*)&info[0];
1026 PointerBufferSize(pStubMsg, *(unsigned char**)memptr, info+4);
1027 }
1028 rep--;
1029 }
1030 pFormat += 8 * count;
1031 }
1032 }
1033
1034 /***********************************************************************
1035 * EmbeddedPointerMemorySize
1036 */
1037 unsigned long WINAPI EmbeddedPointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
1038 PFORMAT_STRING pFormat)
1039 {
1040 unsigned long Offset = pStubMsg->Offset;
1041 unsigned char *Mark = pStubMsg->BufferMark;
1042 unsigned ofs, rep, count, stride, xofs;
1043
1044 FIXME("(%p,%p): stub\n", pStubMsg, pFormat);
1045 if (*pFormat != RPC_FC_PP) return 0;
1046 pFormat += 2;
1047
1048 while (pFormat[0] != RPC_FC_END) {
1049 switch (pFormat[0]) {
1050 default:
1051 FIXME("unknown repeat type %d\n", pFormat[0]);
1052 case RPC_FC_NO_REPEAT:
1053 rep = 1;
1054 stride = 0;
1055 ofs = 0;
1056 count = 1;
1057 xofs = 0;
1058 pFormat += 2;
1059 break;
1060 case RPC_FC_FIXED_REPEAT:
1061 rep = *(const WORD*)&pFormat[2];
1062 stride = *(const WORD*)&pFormat[4];
1063 ofs = *(const WORD*)&pFormat[6];
1064 count = *(const WORD*)&pFormat[8];
1065 xofs = 0;
1066 pFormat += 10;
1067 break;
1068 case RPC_FC_VARIABLE_REPEAT:
1069 rep = pStubMsg->MaxCount;
1070 stride = *(const WORD*)&pFormat[2];
1071 ofs = *(const WORD*)&pFormat[4];
1072 count = *(const WORD*)&pFormat[6];
1073 xofs = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? Offset * stride : 0;
1074 pFormat += 8;
1075 break;
1076 }
1077 /* ofs doesn't seem to matter in this context */
1078 while (rep) {
1079 PFORMAT_STRING info = pFormat;
1080 unsigned u;
1081 for (u=0; u<count; u++,info+=8) {
1082 unsigned char *bufptr = Mark + *(const SHORT*)&info[2];
1083 PointerMemorySize(pStubMsg, bufptr, info+4);
1084 }
1085 rep--;
1086 }
1087 pFormat += 8 * count;
1088 }
1089
1090 return 0;
1091 }
1092
1093 /***********************************************************************
1094 * EmbeddedPointerFree
1095 */
1096 void WINAPI EmbeddedPointerFree(PMIDL_STUB_MESSAGE pStubMsg,
1097 unsigned char *pMemory,
1098 PFORMAT_STRING pFormat)
1099 {
1100 unsigned long Offset = pStubMsg->Offset;
1101 unsigned ofs, rep, count, stride, xofs;
1102
1103 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1104 if (*pFormat != RPC_FC_PP) return;
1105 pFormat += 2;
1106
1107 while (pFormat[0] != RPC_FC_END) {
1108 switch (pFormat[0]) {
1109 default:
1110 FIXME("unknown repeat type %d\n", pFormat[0]);
1111 case RPC_FC_NO_REPEAT:
1112 rep = 1;
1113 stride = 0;
1114 ofs = 0;
1115 count = 1;
1116 xofs = 0;
1117 pFormat += 2;
1118 break;
1119 case RPC_FC_FIXED_REPEAT:
1120 rep = *(const WORD*)&pFormat[2];
1121 stride = *(const WORD*)&pFormat[4];
1122 ofs = *(const WORD*)&pFormat[6];
1123 count = *(const WORD*)&pFormat[8];
1124 xofs = 0;
1125 pFormat += 10;
1126 break;
1127 case RPC_FC_VARIABLE_REPEAT:
1128 rep = pStubMsg->MaxCount;
1129 stride = *(const WORD*)&pFormat[2];
1130 ofs = *(const WORD*)&pFormat[4];
1131 count = *(const WORD*)&pFormat[6];
1132 xofs = (pFormat[1] == RPC_FC_VARIABLE_OFFSET) ? Offset * stride : 0;
1133 pFormat += 8;
1134 break;
1135 }
1136 /* ofs doesn't seem to matter in this context */
1137 while (rep) {
1138 PFORMAT_STRING info = pFormat;
1139 unsigned char *membase = pMemory + xofs;
1140 unsigned u;
1141 for (u=0; u<count; u++,info+=8) {
1142 unsigned char *memptr = membase + *(const SHORT*)&info[0];
1143 PointerFree(pStubMsg, *(unsigned char**)memptr, info+4);
1144 }
1145 rep--;
1146 }
1147 pFormat += 8 * count;
1148 }
1149 }
1150
1151 /***********************************************************************
1152 * NdrPointerMarshall [RPCRT4.@]
1153 */
1154 unsigned char * WINAPI NdrPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
1155 unsigned char *pMemory,
1156 PFORMAT_STRING pFormat)
1157 {
1158 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1159
1160 pStubMsg->BufferMark = pStubMsg->Buffer;
1161 PointerMarshall(pStubMsg, pStubMsg->Buffer, pMemory, pFormat);
1162
1163 STD_OVERFLOW_CHECK(pStubMsg);
1164
1165 return NULL;
1166 }
1167
1168 /***********************************************************************
1169 * NdrPointerUnmarshall [RPCRT4.@]
1170 */
1171 unsigned char * WINAPI NdrPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
1172 unsigned char **ppMemory,
1173 PFORMAT_STRING pFormat,
1174 unsigned char fMustAlloc)
1175 {
1176 TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
1177
1178 pStubMsg->BufferMark = pStubMsg->Buffer;
1179 PointerUnmarshall(pStubMsg, pStubMsg->Buffer, ppMemory, pFormat, fMustAlloc);
1180
1181 return NULL;
1182 }
1183
1184 /***********************************************************************
1185 * NdrPointerBufferSize [RPCRT4.@]
1186 */
1187 void WINAPI NdrPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
1188 unsigned char *pMemory,
1189 PFORMAT_STRING pFormat)
1190 {
1191 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1192 PointerBufferSize(pStubMsg, pMemory, pFormat);
1193 }
1194
1195 /***********************************************************************
1196 * NdrPointerMemorySize [RPCRT4.@]
1197 */
1198 unsigned long WINAPI NdrPointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
1199 PFORMAT_STRING pFormat)
1200 {
1201 /* unsigned size = *(LPWORD)(pFormat+2); */
1202 FIXME("(%p,%p): stub\n", pStubMsg, pFormat);
1203 PointerMemorySize(pStubMsg, pStubMsg->Buffer, pFormat);
1204 return 0;
1205 }
1206
1207 /***********************************************************************
1208 * NdrPointerFree [RPCRT4.@]
1209 */
1210 void WINAPI NdrPointerFree(PMIDL_STUB_MESSAGE pStubMsg,
1211 unsigned char *pMemory,
1212 PFORMAT_STRING pFormat)
1213 {
1214 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1215 PointerFree(pStubMsg, pMemory, pFormat);
1216 }
1217
1218 /***********************************************************************
1219 * NdrSimpleStructMarshall [RPCRT4.@]
1220 */
1221 unsigned char * WINAPI NdrSimpleStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
1222 unsigned char *pMemory,
1223 PFORMAT_STRING pFormat)
1224 {
1225 unsigned size = *(const WORD*)(pFormat+2);
1226 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1227
1228 memcpy(pStubMsg->Buffer, pMemory, size);
1229 pStubMsg->BufferMark = pStubMsg->Buffer;
1230 pStubMsg->Buffer += size;
1231
1232 if (pFormat[0] != RPC_FC_STRUCT)
1233 EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat+4);
1234
1235 /*
1236 * This test does not work when NdrSimpleStructMarshall is called
1237 * by an rpc-server to marshall data to return to the client because
1238 * BufferStart and BufferEnd are bogus. MIDL does not update them
1239 * when a new buffer is allocated in order to return data to the caller.
1240 */
1241 #if 0
1242 STD_OVERFLOW_CHECK(pStubMsg);
1243 #endif
1244
1245 return NULL;
1246 }
1247
1248 /***********************************************************************
1249 * NdrSimpleStructUnmarshall [RPCRT4.@]
1250 */
1251 unsigned char * WINAPI NdrSimpleStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
1252 unsigned char **ppMemory,
1253 PFORMAT_STRING pFormat,
1254 unsigned char fMustAlloc)
1255 {
1256 unsigned size = *(const WORD*)(pFormat+2);
1257 TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
1258
1259 if (fMustAlloc) {
1260 *ppMemory = NdrAllocate(pStubMsg, size);
1261 memcpy(*ppMemory, pStubMsg->Buffer, size);
1262 } else {
1263 if (pStubMsg->ReuseBuffer && !*ppMemory)
1264 /* for servers, we may just point straight into the RPC buffer, I think
1265 * (I guess that's what MS does since MIDL code doesn't try to free) */
1266 *ppMemory = pStubMsg->Buffer;
1267 else
1268 /* for clients, memory should be provided by caller */
1269 memcpy(*ppMemory, pStubMsg->Buffer, size);
1270 }
1271
1272 pStubMsg->BufferMark = pStubMsg->Buffer;
1273 pStubMsg->Buffer += size;
1274
1275 if (pFormat[0] != RPC_FC_STRUCT)
1276 EmbeddedPointerUnmarshall(pStubMsg, ppMemory, pFormat+4, fMustAlloc);
1277
1278 return NULL;
1279 }
1280
1281
1282 /***********************************************************************
1283 * NdrSimpleTypeUnmarshall [RPCRT4.@]
1284 */
1285 void WINAPI NdrSimpleTypeMarshall(PMIDL_STUB_MESSAGE pStubMsg,
1286 unsigned char *pMemory,
1287 unsigned char FormatChar)
1288 {
1289 FIXME("stub\n");
1290 }
1291
1292
1293 /***********************************************************************
1294 * NdrSimpleTypeUnmarshall [RPCRT4.@]
1295 */
1296 void WINAPI NdrSimpleTypeUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
1297 unsigned char *pMemory,
1298 unsigned char FormatChar)
1299 {
1300 FIXME("stub\n");
1301 }
1302
1303
1304 /***********************************************************************
1305 * NdrSimpleStructBufferSize [RPCRT4.@]
1306 */
1307 void WINAPI NdrSimpleStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
1308 unsigned char *pMemory,
1309 PFORMAT_STRING pFormat)
1310 {
1311 unsigned size = *(const WORD*)(pFormat+2);
1312 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1313 pStubMsg->BufferLength += size;
1314 if (pFormat[0] != RPC_FC_STRUCT)
1315 EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat+4);
1316 }
1317
1318 /***********************************************************************
1319 * NdrSimpleStructMemorySize [RPCRT4.@]
1320 */
1321 unsigned long WINAPI NdrSimpleStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
1322 PFORMAT_STRING pFormat)
1323 {
1324 /* unsigned size = *(LPWORD)(pFormat+2); */
1325 FIXME("(%p,%p): stub\n", pStubMsg, pFormat);
1326 if (pFormat[0] != RPC_FC_STRUCT)
1327 EmbeddedPointerMemorySize(pStubMsg, pFormat+4);
1328 return 0;
1329 }
1330
1331 /***********************************************************************
1332 * NdrSimpleStructFree [RPCRT4.@]
1333 */
1334 void WINAPI NdrSimpleStructFree(PMIDL_STUB_MESSAGE pStubMsg,
1335 unsigned char *pMemory,
1336 PFORMAT_STRING pFormat)
1337 {
1338 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1339 if (pFormat[0] != RPC_FC_STRUCT)
1340 EmbeddedPointerFree(pStubMsg, pMemory, pFormat+4);
1341 }
1342
1343
1344 unsigned long WINAPI EmbeddedComplexSize(PMIDL_STUB_MESSAGE pStubMsg,
1345 PFORMAT_STRING pFormat)
1346 {
1347 switch (*pFormat) {
1348 case RPC_FC_STRUCT:
1349 case RPC_FC_PSTRUCT:
1350 case RPC_FC_CSTRUCT:
1351 case RPC_FC_BOGUS_STRUCT:
1352 return *(const WORD*)&pFormat[2];
1353 case RPC_FC_USER_MARSHAL:
1354 return *(const WORD*)&pFormat[4];
1355 default:
1356 FIXME("unhandled embedded type %02x\n", *pFormat);
1357 }
1358 return 0;
1359 }
1360
1361
1362 unsigned char * WINAPI ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg,
1363 unsigned char *pMemory,
1364 PFORMAT_STRING pFormat,
1365 PFORMAT_STRING pPointer)
1366 {
1367 PFORMAT_STRING desc;
1368 NDR_MARSHALL m;
1369 unsigned long size;
1370
1371 while (*pFormat != RPC_FC_END) {
1372 switch (*pFormat) {
1373 case RPC_FC_SHORT:
1374 case RPC_FC_USHORT:
1375 TRACE("short=%d <= %p\n", *(WORD*)pMemory, pMemory);
1376 memcpy(pStubMsg->Buffer, pMemory, 2);
1377 pStubMsg->Buffer += 2;
1378 pMemory += 2;
1379 break;
1380 case RPC_FC_LONG:
1381 case RPC_FC_ULONG:
1382 TRACE("long=%ld <= %p\n", *(DWORD*)pMemory, pMemory);
1383 memcpy(pStubMsg->Buffer, pMemory, 4);
1384 pStubMsg->Buffer += 4;
1385 pMemory += 4;
1386 break;
1387 case RPC_FC_POINTER:
1388 TRACE("pointer=%p <= %p\n", *(unsigned char**)pMemory, pMemory);
1389 NdrPointerMarshall(pStubMsg, *(unsigned char**)pMemory, pPointer);
1390 pPointer += 4;
1391 pMemory += 4;
1392 break;
1393 case RPC_FC_ALIGNM4:
1394 ALIGN_POINTER(pMemory, 3);
1395 break;
1396 case RPC_FC_ALIGNM8:
1397 ALIGN_POINTER(pMemory, 7);
1398 break;
1399 case RPC_FC_EMBEDDED_COMPLEX:
1400 pMemory += pFormat[1];
1401 pFormat += 2;
1402 desc = pFormat + *(const SHORT*)pFormat;
1403 size = EmbeddedComplexSize(pStubMsg, desc);
1404 TRACE("embedded complex (size=%ld) <= %p\n", size, pMemory);
1405 m = NdrMarshaller[*desc & NDR_TABLE_MASK];
1406 if (m) m(pStubMsg, pMemory, desc);
1407 else FIXME("no marshaller for embedded type %02x\n", *desc);
1408 pMemory += size;
1409 pFormat += 2;
1410 continue;
1411 case RPC_FC_PAD:
1412 break;
1413 default:
1414 FIXME("unhandled format %02x\n", *pFormat);
1415 }
1416 pFormat++;
1417 }
1418
1419 return pMemory;
1420 }
1421
1422 unsigned char * WINAPI ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
1423 unsigned char *pMemory,
1424 PFORMAT_STRING pFormat,
1425 PFORMAT_STRING pPointer,
1426 unsigned char fMustAlloc)
1427 {
1428 PFORMAT_STRING desc;
1429 NDR_UNMARSHALL m;
1430 unsigned long size;
1431
1432 while (*pFormat != RPC_FC_END) {
1433 switch (*pFormat) {
1434 case RPC_FC_SHORT:
1435 case RPC_FC_USHORT:
1436 memcpy(pMemory, pStubMsg->Buffer, 2);
1437 TRACE("short=%d => %p\n", *(WORD*)pMemory, pMemory);
1438 pStubMsg->Buffer += 2;
1439 pMemory += 2;
1440 break;
1441 case RPC_FC_LONG:
1442 case RPC_FC_ULONG:
1443 memcpy(pMemory, pStubMsg->Buffer, 4);
1444 TRACE("long=%ld => %p\n", *(DWORD*)pMemory, pMemory);
1445 pStubMsg->Buffer += 4;
1446 pMemory += 4;
1447 break;
1448 case RPC_FC_POINTER:
1449 *(unsigned char**)pMemory = NULL;
1450 TRACE("pointer => %p\n", pMemory);
1451 NdrPointerUnmarshall(pStubMsg, (unsigned char**)pMemory, pPointer, fMustAlloc);
1452 pPointer += 4;
1453 pMemory += 4;
1454 break;
1455 case RPC_FC_ALIGNM4:
1456 ALIGN_POINTER(pMemory, 3);
1457 break;
1458 case RPC_FC_ALIGNM8:
1459 ALIGN_POINTER(pMemory, 7);
1460 break;
1461 case RPC_FC_EMBEDDED_COMPLEX:
1462 pMemory += pFormat[1];
1463 pFormat += 2;
1464 desc = pFormat + *(const SHORT*)pFormat;
1465 size = EmbeddedComplexSize(pStubMsg, desc);
1466 TRACE("embedded complex (size=%ld) => %p\n", size, pMemory);
1467 m = NdrUnmarshaller[*desc & NDR_TABLE_MASK];
1468 memset(pMemory, 0, size); /* just in case */
1469 if (m) m(pStubMsg, &pMemory, desc, fMustAlloc);
1470 else FIXME("no unmarshaller for embedded type %02x\n", *desc);
1471 pMemory += size;
1472 pFormat += 2;
1473 continue;
1474 case RPC_FC_PAD:
1475 break;
1476 default:
1477 FIXME("unhandled format %d\n", *pFormat);
1478 }
1479 pFormat++;
1480 }
1481
1482 return pMemory;
1483 }
1484
1485 unsigned char * WINAPI ComplexBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
1486 unsigned char *pMemory,
1487 PFORMAT_STRING pFormat,
1488 PFORMAT_STRING pPointer)
1489 {
1490 PFORMAT_STRING desc;
1491 NDR_BUFFERSIZE m;
1492 unsigned long size;
1493
1494 while (*pFormat != RPC_FC_END) {
1495 switch (*pFormat) {
1496 case RPC_FC_SHORT:
1497 case RPC_FC_USHORT:
1498 pStubMsg->BufferLength += 2;
1499 pMemory += 2;
1500 break;
1501 case RPC_FC_LONG:
1502 case RPC_FC_ULONG:
1503 pStubMsg->BufferLength += 4;
1504 pMemory += 4;
1505 break;
1506 case RPC_FC_POINTER:
1507 NdrPointerBufferSize(pStubMsg, *(unsigned char**)pMemory, pPointer);
1508 pPointer += 4;
1509 pMemory += 4;
1510 break;
1511 case RPC_FC_ALIGNM4:
1512 ALIGN_POINTER(pMemory, 3);
1513 break;
1514 case RPC_FC_ALIGNM8:
1515 ALIGN_POINTER(pMemory, 7);
1516 break;
1517 case RPC_FC_EMBEDDED_COMPLEX:
1518 pMemory += pFormat[1];
1519 pFormat += 2;
1520 desc = pFormat + *(const SHORT*)pFormat;
1521 size = EmbeddedComplexSize(pStubMsg, desc);
1522 m = NdrBufferSizer[*desc & NDR_TABLE_MASK];
1523 if (m) m(pStubMsg, pMemory, desc);
1524 else FIXME("no buffersizer for embedded type %02x\n", *desc);
1525 pMemory += size;
1526 pFormat += 2;
1527 continue;
1528 case RPC_FC_PAD:
1529 break;
1530 default:
1531 FIXME("unhandled format %d\n", *pFormat);
1532 }
1533 pFormat++;
1534 }
1535
1536 return pMemory;
1537 }
1538
1539 unsigned char * WINAPI ComplexFree(PMIDL_STUB_MESSAGE pStubMsg,
1540 unsigned char *pMemory,
1541 PFORMAT_STRING pFormat,
1542 PFORMAT_STRING pPointer)
1543 {
1544 PFORMAT_STRING desc;
1545 NDR_FREE m;
1546 unsigned long size;
1547
1548 while (*pFormat != RPC_FC_END) {
1549 switch (*pFormat) {
1550 case RPC_FC_SHORT:
1551 case RPC_FC_USHORT:
1552 pMemory += 2;
1553 break;
1554 case RPC_FC_LONG:
1555 case RPC_FC_ULONG:
1556 pMemory += 4;
1557 break;
1558 case RPC_FC_POINTER:
1559 NdrPointerFree(pStubMsg, *(unsigned char**)pMemory, pPointer);
1560 pPointer += 4;
1561 pMemory += 4;
1562 break;
1563 case RPC_FC_ALIGNM4:
1564 ALIGN_POINTER(pMemory, 3);
1565 break;
1566 case RPC_FC_ALIGNM8:
1567 ALIGN_POINTER(pMemory, 7);
1568 break;
1569 case RPC_FC_EMBEDDED_COMPLEX:
1570 pMemory += pFormat[1];
1571 pFormat += 2;
1572 desc = pFormat + *(const SHORT*)pFormat;
1573 size = EmbeddedComplexSize(pStubMsg, desc);
1574 m = NdrFreer[*desc & NDR_TABLE_MASK];
1575 if (m) m(pStubMsg, pMemory, desc);
1576 else FIXME("no freer for embedded type %02x\n", *desc);
1577 pMemory += size;
1578 pFormat += 2;
1579 continue;
1580 case RPC_FC_PAD:
1581 break;
1582 default:
1583 FIXME("unhandled format %d\n", *pFormat);
1584 }
1585 pFormat++;
1586 }
1587
1588 return pMemory;
1589 }
1590
1591 unsigned long WINAPI ComplexStructSize(PMIDL_STUB_MESSAGE pStubMsg,
1592 PFORMAT_STRING pFormat)
1593 {
1594 PFORMAT_STRING desc;
1595 unsigned long size = 0;
1596
1597 while (*pFormat != RPC_FC_END) {
1598 switch (*pFormat) {
1599 case RPC_FC_SHORT:
1600 case RPC_FC_USHORT:
1601 size += 2;
1602 break;
1603 case RPC_FC_LONG:
1604 case RPC_FC_ULONG:
1605 size += 4;
1606 break;
1607 case RPC_FC_POINTER:
1608 size += 4;
1609 break;
1610 case RPC_FC_ALIGNM4:
1611 ALIGN_LENGTH(size, 3);
1612 break;
1613 case RPC_FC_ALIGNM8:
1614 ALIGN_LENGTH(size, 7);
1615 break;
1616 case RPC_FC_EMBEDDED_COMPLEX:
1617 size += pFormat[1];
1618 pFormat += 2;
1619 desc = pFormat + *(const SHORT*)pFormat;
1620 size += EmbeddedComplexSize(pStubMsg, desc);
1621 pFormat += 2;
1622 continue;
1623 case RPC_FC_PAD:
1624 break;
1625 default:
1626 FIXME("unhandled format %d\n", *pFormat);
1627 }
1628 pFormat++;
1629 }
1630
1631 return size;
1632 }
1633
1634 /***********************************************************************
1635 * NdrComplexStructMarshall [RPCRT4.@]
1636 */
1637 unsigned char * WINAPI NdrComplexStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
1638 unsigned char *pMemory,
1639 PFORMAT_STRING pFormat)
1640 {
1641 PFORMAT_STRING conf_array = NULL;
1642 PFORMAT_STRING pointer_desc = NULL;
1643 unsigned char *OldMemory = pStubMsg->Memory;
1644
1645 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1646
1647 pFormat += 4;
1648 if (*(const WORD*)pFormat) conf_array = pFormat + *(const WORD*)pFormat;
1649 pFormat += 2;
1650 if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
1651 pFormat += 2;
1652
1653 pStubMsg->Memory = pMemory;
1654
1655 ComplexMarshall(pStubMsg, pMemory, pFormat, pointer_desc);
1656
1657 if (conf_array)
1658 NdrConformantArrayMarshall(pStubMsg, pMemory, conf_array);
1659
1660 pStubMsg->Memory = OldMemory;
1661
1662 STD_OVERFLOW_CHECK(pStubMsg);
1663
1664 return NULL;
1665 }
1666
1667 /***********************************************************************
1668 * NdrComplexStructUnmarshall [RPCRT4.@]
1669 */
1670 unsigned char * WINAPI NdrComplexStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
1671 unsigned char **ppMemory,
1672 PFORMAT_STRING pFormat,
1673 unsigned char fMustAlloc)
1674 {
1675 unsigned size = *(const WORD*)(pFormat+2);
1676 PFORMAT_STRING conf_array = NULL;
1677 PFORMAT_STRING pointer_desc = NULL;
1678 unsigned char *pMemory;
1679
1680 TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
1681
1682 if (fMustAlloc || !*ppMemory)
1683 *ppMemory = NdrAllocate(pStubMsg, size);
1684
1685 pFormat += 4;
1686 if (*(const WORD*)pFormat) conf_array = pFormat + *(const WORD*)pFormat;
1687 pFormat += 2;
1688 if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
1689 pFormat += 2;
1690
1691 pMemory = ComplexUnmarshall(pStubMsg, *ppMemory, pFormat, pointer_desc, fMustAlloc);
1692
1693 if (conf_array)
1694 NdrConformantArrayUnmarshall(pStubMsg, &pMemory, conf_array, fMustAlloc);
1695
1696 return NULL;
1697 }
1698
1699 /***********************************************************************
1700 * NdrComplexStructBufferSize [RPCRT4.@]
1701 */
1702 void WINAPI NdrComplexStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
1703 unsigned char *pMemory,
1704 PFORMAT_STRING pFormat)
1705 {
1706 PFORMAT_STRING conf_array = NULL;
1707 PFORMAT_STRING pointer_desc = NULL;
1708 unsigned char *OldMemory = pStubMsg->Memory;
1709
1710 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1711
1712 pFormat += 4;
1713 if (*(const WORD*)pFormat) conf_array = pFormat + *(const WORD*)pFormat;
1714 pFormat += 2;
1715 if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
1716 pFormat += 2;
1717
1718 pStubMsg->Memory = pMemory;
1719
1720 pMemory = ComplexBufferSize(pStubMsg, pMemory, pFormat, pointer_desc);
1721
1722 if (conf_array)
1723 NdrConformantArrayBufferSize(pStubMsg, pMemory, conf_array);
1724
1725 pStubMsg->Memory = OldMemory;
1726 }
1727
1728 /***********************************************************************
1729 * NdrComplexStructMemorySize [RPCRT4.@]
1730 */
1731 unsigned long WINAPI NdrComplexStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
1732 PFORMAT_STRING pFormat)
1733 {
1734 /* unsigned size = *(LPWORD)(pFormat+2); */
1735 PFORMAT_STRING conf_array = NULL;
1736 PFORMAT_STRING pointer_desc = NULL;
1737
1738 FIXME("(%p,%p): stub\n", pStubMsg, pFormat);
1739
1740 pFormat += 4;
1741 if (*(const WORD*)pFormat) conf_array = pFormat + *(const WORD*)pFormat;
1742 pFormat += 2;
1743 if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
1744 pFormat += 2;
1745
1746 return 0;
1747 }
1748
1749 /***********************************************************************
1750 * NdrComplexStructFree [RPCRT4.@]
1751 */
1752 void WINAPI NdrComplexStructFree(PMIDL_STUB_MESSAGE pStubMsg,
1753 unsigned char *pMemory,
1754 PFORMAT_STRING pFormat)
1755 {
1756 PFORMAT_STRING conf_array = NULL;
1757 PFORMAT_STRING pointer_desc = NULL;
1758 unsigned char *OldMemory = pStubMsg->Memory;
1759
1760 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1761
1762 pFormat += 4;
1763 if (*(const WORD*)pFormat) conf_array = pFormat + *(const WORD*)pFormat;
1764 pFormat += 2;
1765 if (*(const WORD*)pFormat) pointer_desc = pFormat + *(const WORD*)pFormat;
1766 pFormat += 2;
1767
1768 pStubMsg->Memory = pMemory;
1769
1770 pMemory = ComplexFree(pStubMsg, pMemory, pFormat, pointer_desc);
1771
1772 if (conf_array)
1773 NdrConformantArrayFree(pStubMsg, pMemory, conf_array);
1774
1775 pStubMsg->Memory = OldMemory;
1776 }
1777
1778 /***********************************************************************
1779 * NdrConformantArrayMarshall [RPCRT4.@]
1780 */
1781 unsigned char * WINAPI NdrConformantArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
1782 unsigned char *pMemory,
1783 PFORMAT_STRING pFormat)
1784 {
1785 DWORD size = 0, esize = *(const WORD*)(pFormat+2);
1786 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1787 if (pFormat[0] != RPC_FC_CARRAY) FIXME("format=%d\n", pFormat[0]);
1788
1789 pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
1790 size = pStubMsg->MaxCount;
1791
1792 NDR_LOCAL_UINT32_WRITE(pStubMsg->Buffer, size);
1793 pStubMsg->Buffer += 4;
1794
1795 memcpy(pStubMsg->Buffer, pMemory, size*esize);
1796 pStubMsg->BufferMark = pStubMsg->Buffer;
1797 pStubMsg->Buffer += size*esize;
1798
1799 EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
1800
1801 STD_OVERFLOW_CHECK(pStubMsg);
1802
1803 return NULL;
1804 }
1805
1806 /***********************************************************************
1807 * NdrConformantArrayUnmarshall [RPCRT4.@]
1808 */
1809 unsigned char * WINAPI NdrConformantArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
1810 unsigned char **ppMemory,
1811 PFORMAT_STRING pFormat,
1812 unsigned char fMustAlloc)
1813 {
1814 DWORD size = 0, esize = *(const WORD*)(pFormat+2);
1815 TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
1816 if (pFormat[0] != RPC_FC_CARRAY) FIXME("format=%d\n", pFormat[0]);
1817
1818 pFormat = ReadConformance(pStubMsg, pFormat+4);
1819 size = pStubMsg->MaxCount;
1820
1821 if (fMustAlloc) {
1822 *ppMemory = NdrAllocate(pStubMsg, size*esize);
1823 memcpy(*ppMemory, pStubMsg->Buffer, size*esize);
1824 } else {
1825 if (pStubMsg->ReuseBuffer && !*ppMemory)
1826 /* for servers, we may just point straight into the RPC buffer, I think
1827 * (I guess that's what MS does since MIDL code doesn't try to free) */
1828 *ppMemory = pStubMsg->Buffer;
1829 else
1830 /* for clients, memory should be provided by caller */
1831 memcpy(*ppMemory, pStubMsg->Buffer, size*esize);
1832 }
1833
1834 pStubMsg->BufferMark = pStubMsg->Buffer;
1835 pStubMsg->Buffer += size*esize;
1836
1837 EmbeddedPointerUnmarshall(pStubMsg, ppMemory, pFormat, fMustAlloc);
1838
1839 return NULL;
1840 }
1841
1842 /***********************************************************************
1843 * NdrConformantArrayBufferSize [RPCRT4.@]
1844 */
1845 void WINAPI NdrConformantArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
1846 unsigned char *pMemory,
1847 PFORMAT_STRING pFormat)
1848 {
1849 DWORD size = 0, esize = *(const WORD*)(pFormat+2);
1850 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1851 if (pFormat[0] != RPC_FC_CARRAY) FIXME("format=%d\n", pFormat[0]);
1852
1853 pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
1854 size = pStubMsg->MaxCount;
1855
1856 pStubMsg->BufferLength += size*esize;
1857
1858 EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
1859 }
1860
1861 /***********************************************************************
1862 * NdrConformantArrayMemorySize [RPCRT4.@]
1863 */
1864 unsigned long WINAPI NdrConformantArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
1865 PFORMAT_STRING pFormat)
1866 {
1867 DWORD size = 0;
1868 FIXME("(%p,%p): stub\n", pStubMsg, pFormat);
1869 if (pFormat[0] != RPC_FC_CARRAY) FIXME("format=%d\n", pFormat[0]);
1870
1871 pFormat = ReadConformance(pStubMsg, pFormat+4);
1872 size = pStubMsg->MaxCount;
1873
1874 EmbeddedPointerMemorySize(pStubMsg, pFormat);
1875
1876 return 0;
1877 }
1878
1879 /***********************************************************************
1880 * NdrConformantArrayFree [RPCRT4.@]
1881 */
1882 void WINAPI NdrConformantArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
1883 unsigned char *pMemory,
1884 PFORMAT_STRING pFormat)
1885 {
1886 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1887 if (pFormat[0] != RPC_FC_CARRAY) FIXME("format=%d\n", pFormat[0]);
1888
1889 EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
1890 }
1891
1892
1893 /***********************************************************************
1894 * NdrConformantVaryingArrayMarshall [RPCRT4.@]
1895 */
1896 unsigned char* WINAPI NdrConformantVaryingArrayMarshall( PMIDL_STUB_MESSAGE pStubMsg,
1897 unsigned char* pMemory,
1898 PFORMAT_STRING pFormat )
1899 {
1900 FIXME( "stub\n" );
1901 return NULL;
1902 }
1903
1904
1905 /***********************************************************************
1906 * NdrConformantVaryingArrayUnmarshall [RPCRT4.@]
1907 */
1908 unsigned char* WINAPI NdrConformantVaryingArrayUnmarshall( PMIDL_STUB_MESSAGE pStubMsg,
1909 unsigned char** ppMemory,
1910 PFORMAT_STRING pFormat,
1911 unsigned char fMustAlloc )
1912 {
1913 FIXME( "stub\n" );
1914 return NULL;
1915 }
1916
1917
1918 /***********************************************************************
1919 * NdrConformantVaryingArrayFree [RPCRT4.@]
1920 */
1921 void WINAPI NdrConformantVaryingArrayFree( PMIDL_STUB_MESSAGE pStubMsg,
1922 unsigned char* pMemory,
1923 PFORMAT_STRING pFormat )
1924 {
1925 FIXME( "stub\n" );
1926 }
1927
1928
1929 /***********************************************************************
1930 * NdrConformantVaryingArrayBufferSize [RPCRT4.@]
1931 */
1932 void WINAPI NdrConformantVaryingArrayBufferSize( PMIDL_STUB_MESSAGE pStubMsg,
1933 unsigned char* pMemory, PFORMAT_STRING pFormat )
1934 {
1935 FIXME( "stub\n" );
1936 }
1937
1938
1939 /***********************************************************************
1940 * NdrConformantVaryingArrayMemorySize [RPCRT4.@]
1941 */
1942 unsigned long WINAPI NdrConformantVaryingArrayMemorySize( PMIDL_STUB_MESSAGE pStubMsg,
1943 PFORMAT_STRING pFormat )
1944 {
1945 FIXME( "stub\n" );
1946 return 0;
1947 }
1948
1949
1950 /***********************************************************************
1951 * NdrComplexArrayMarshall [RPCRT4.@]
1952 */
1953 unsigned char * WINAPI NdrComplexArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
1954 unsigned char *pMemory,
1955 PFORMAT_STRING pFormat)
1956 {
1957 DWORD size = 0, count, def;
1958 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
1959
1960 def = *(const WORD*)&pFormat[2];
1961 pFormat += 4;
1962
1963 pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
1964 size = pStubMsg->MaxCount;
1965 TRACE("conformance=%ld\n", size);
1966
1967 if (*(const DWORD*)pFormat != 0xffffffff)
1968 FIXME("compute variance\n");
1969 pFormat += 4;
1970
1971 NDR_LOCAL_UINT32_WRITE(pStubMsg->Buffer, size);
1972 pStubMsg->Buffer += 4;
1973
1974 for (count=0; count<size; count++)
1975 pMemory = ComplexMarshall(pStubMsg, pMemory, pFormat, NULL);
1976
1977 STD_OVERFLOW_CHECK(pStubMsg);
1978
1979 return NULL;
1980 }
1981
1982 /***********************************************************************
1983 * NdrComplexArrayUnmarshall [RPCRT4.@]
1984 */
1985 unsigned char * WINAPI NdrComplexArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
1986 unsigned char **ppMemory,
1987 PFORMAT_STRING pFormat,
1988 unsigned char fMustAlloc)
1989 {
1990 DWORD size = 0, count, esize;
1991 unsigned char *pMemory;
1992 TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
1993
1994 pFormat += 4;
1995
1996 pFormat = ReadConformance(pStubMsg, pFormat);
1997 size = pStubMsg->MaxCount;
1998 TRACE("conformance=%ld\n", size);
1999
2000 pFormat += 4;
2001
2002 esize = ComplexStructSize(pStubMsg, pFormat);
2003
2004 if (fMustAlloc || !*ppMemory)
2005 *ppMemory = NdrAllocate(pStubMsg, size*esize);
2006
2007 pMemory = *ppMemory;
2008 for (count=0; count<size; count++)
2009 pMemory = ComplexUnmarshall(pStubMsg, pMemory, pFormat, NULL, fMustAlloc);
2010
2011 return NULL;
2012 }
2013
2014 /***********************************************************************
2015 * NdrComplexArrayBufferSize [RPCRT4.@]
2016 */
2017 void WINAPI NdrComplexArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2018 unsigned char *pMemory,
2019 PFORMAT_STRING pFormat)
2020 {
2021 DWORD size = 0, count, def;
2022 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2023
2024 def = *(const WORD*)&pFormat[2];
2025 pFormat += 4;
2026
2027 pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
2028 size = pStubMsg->MaxCount;
2029 TRACE("conformance=%ld\n", size);
2030
2031 if (*(const DWORD*)pFormat != 0xffffffff)
2032 FIXME("compute variance\n");
2033 pFormat += 4;
2034
2035 for (count=0; count<size; count++)
2036 pMemory = ComplexBufferSize(pStubMsg, pMemory, pFormat, NULL);
2037 }
2038
2039 /***********************************************************************
2040 * NdrComplexArrayMemorySize [RPCRT4.@]
2041 */
2042 unsigned long WINAPI NdrComplexArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2043 PFORMAT_STRING pFormat)
2044 {
2045 DWORD size = 0;
2046 FIXME("(%p,%p): stub\n", pStubMsg, pFormat);
2047
2048 pFormat += 4;
2049
2050 pFormat = ReadConformance(pStubMsg, pFormat);
2051 size = pStubMsg->MaxCount;
2052 TRACE("conformance=%ld\n", size);
2053
2054 pFormat += 4;
2055
2056 return 0;
2057 }
2058
2059 /***********************************************************************
2060 * NdrComplexArrayFree [RPCRT4.@]
2061 */
2062 void WINAPI NdrComplexArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
2063 unsigned char *pMemory,
2064 PFORMAT_STRING pFormat)
2065 {
2066 DWORD size = 0, count, def;
2067 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2068
2069 def = *(const WORD*)&pFormat[2];
2070 pFormat += 4;
2071
2072 pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
2073 size = pStubMsg->MaxCount;
2074 TRACE("conformance=%ld\n", size);
2075
2076 if (*(const DWORD*)pFormat != 0xffffffff)
2077 FIXME("compute variance\n");
2078 pFormat += 4;
2079
2080 for (count=0; count<size; count++)
2081 pMemory = ComplexFree(pStubMsg, pMemory, pFormat, NULL);
2082 }
2083
2084 unsigned long UserMarshalFlags(PMIDL_STUB_MESSAGE pStubMsg)
2085 {
2086 return MAKELONG(pStubMsg->dwDestContext,
2087 pStubMsg->RpcMsg->DataRepresentation);
2088 }
2089
2090 /***********************************************************************
2091 * NdrUserMarshalMarshall [RPCRT4.@]
2092 */
2093 unsigned char * WINAPI NdrUserMarshalMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2094 unsigned char *pMemory,
2095 PFORMAT_STRING pFormat)
2096 {
2097 /* unsigned flags = pFormat[1]; */
2098 unsigned index = *(const WORD*)&pFormat[2];
2099 unsigned long uflag = UserMarshalFlags(pStubMsg);
2100 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2101 TRACE("index=%d\n", index);
2102
2103 pStubMsg->Buffer =
2104 pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnMarshall(
2105 &uflag, pStubMsg->Buffer, pMemory);
2106
2107 STD_OVERFLOW_CHECK(pStubMsg);
2108
2109 return NULL;
2110 }
2111
2112 /***********************************************************************
2113 * NdrUserMarshalUnmarshall [RPCRT4.@]
2114 */
2115 unsigned char * WINAPI NdrUserMarshalUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2116 unsigned char **ppMemory,
2117 PFORMAT_STRING pFormat,
2118 unsigned char fMustAlloc)
2119 {
2120 /* unsigned flags = pFormat[1];*/
2121 unsigned index = *(const WORD*)&pFormat[2];
2122 DWORD memsize = *(const WORD*)&pFormat[4];
2123 unsigned long uflag = UserMarshalFlags(pStubMsg);
2124 TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
2125 TRACE("index=%d\n", index);
2126
2127 if (fMustAlloc || !*ppMemory)
2128 *ppMemory = NdrAllocate(pStubMsg, memsize);
2129
2130 pStubMsg->Buffer =
2131 pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnUnmarshall(
2132 &uflag, pStubMsg->Buffer, *ppMemory);
2133
2134 return NULL;
2135 }
2136
2137 /***********************************************************************
2138 * NdrUserMarshalBufferSize [RPCRT4.@]
2139 */
2140 void WINAPI NdrUserMarshalBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2141 unsigned char *pMemory,
2142 PFORMAT_STRING pFormat)
2143 {
2144 /* unsigned flags = pFormat[1];*/
2145 unsigned index = *(const WORD*)&pFormat[2];
2146 DWORD bufsize = *(const WORD*)&pFormat[6];
2147 unsigned long uflag = UserMarshalFlags(pStubMsg);
2148 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2149 TRACE("index=%d\n", index);
2150
2151 if (bufsize) {
2152 TRACE("size=%ld\n", bufsize);
2153 pStubMsg->BufferLength += bufsize;
2154 return;
2155 }
2156
2157 pStubMsg->BufferLength =
2158 pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnBufferSize(
2159 &uflag, pStubMsg->BufferLength, pMemory);
2160 }
2161
2162 /***********************************************************************
2163 * NdrUserMarshalMemorySize [RPCRT4.@]
2164 */
2165 unsigned long WINAPI NdrUserMarshalMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2166 PFORMAT_STRING pFormat)
2167 {
2168 unsigned index = *(const WORD*)&pFormat[2];
2169 /* DWORD memsize = *(const WORD*)&pFormat[4]; */
2170 FIXME("(%p,%p): stub\n", pStubMsg, pFormat);
2171 TRACE("index=%d\n", index);
2172
2173 return 0;
2174 }
2175
2176 /***********************************************************************
2177 * NdrUserMarshalFree [RPCRT4.@]
2178 */
2179 void WINAPI NdrUserMarshalFree(PMIDL_STUB_MESSAGE pStubMsg,
2180 unsigned char *pMemory,
2181 PFORMAT_STRING pFormat)
2182 {
2183 /* unsigned flags = pFormat[1]; */
2184 unsigned index = *(const WORD*)&pFormat[2];
2185 unsigned long uflag = UserMarshalFlags(pStubMsg);
2186 TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
2187 TRACE("index=%d\n", index);
2188
2189 pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnFree(
2190 &uflag, pMemory);
2191 }
2192
2193 /***********************************************************************
2194 * NdrClearOutParameters [RPCRT4.@]
2195 */
2196 void WINAPI NdrClearOutParameters(PMIDL_STUB_MESSAGE pStubMsg,
2197 PFORMAT_STRING pFormat,
2198 void *ArgAddr)
2199 {
2200 FIXME("(%p,%p,%p): stub\n", pStubMsg, pFormat, ArgAddr);
2201 }
2202
2203 /***********************************************************************
2204 * NdrConvert [RPCRT4.@]
2205 */
2206 void WINAPI NdrConvert( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat )
2207 {
2208 FIXME("(pStubMsg == ^%p, pFormat == ^%p): stub.\n", pStubMsg, pFormat);
2209 /* FIXME: since this stub doesn't do any converting, the proper behavior
2210 is to raise an exception */
2211 }
2212
2213 /***********************************************************************
2214 * NdrConvert2 [RPCRT4.@]
2215 */
2216 void WINAPI NdrConvert2( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, long NumberParams )
2217 {
2218 FIXME("(pStubMsg == ^%p, pFormat == ^%p, NumberParams == %ld): stub.\n",
2219 pStubMsg, pFormat, NumberParams);
2220 /* FIXME: since this stub doesn't do any converting, the proper behavior
2221 is to raise an exception */
2222 }
2223
2224 /***********************************************************************
2225 * NdrConformantStructMarshall [RPCRT4.@]
2226 */
2227 unsigned char * WINAPI NdrConformantStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2228 unsigned char *pMemory,
2229 PFORMAT_STRING pFormat)
2230 {
2231 FIXME("stub\n");
2232 return NULL;
2233 }
2234
2235 /***********************************************************************
2236 * NdrConformantStructUnmarshall [RPCRT4.@]
2237 */
2238 unsigned char * WINAPI NdrConformantStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2239 unsigned char **ppMemory,
2240 PFORMAT_STRING pFormat,
2241 unsigned char fMustAlloc)
2242 {
2243 FIXME("stub\n");
2244 return NULL;
2245 }
2246
2247 /***********************************************************************
2248 * NdrConformantStructBufferSize [RPCRT4.@]
2249 */
2250 void WINAPI NdrConformantStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2251 unsigned char *pMemory,
2252 PFORMAT_STRING pFormat)
2253 {
2254 FIXME("stub\n");
2255 }
2256
2257 /***********************************************************************
2258 * NdrConformantStructMemorySize [RPCRT4.@]
2259 */
2260 unsigned long WINAPI NdrConformantStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2261 PFORMAT_STRING pFormat)
2262 {
2263 FIXME("stub\n");
2264 return 0;
2265 }
2266
2267 /***********************************************************************
2268 * NdrConformantStructFree [RPCRT4.@]
2269 */
2270 void WINAPI NdrConformantStructFree(PMIDL_STUB_MESSAGE pStubMsg,
2271 unsigned char *pMemory,
2272 PFORMAT_STRING pFormat)
2273 {
2274 FIXME("stub\n");
2275 }
2276
2277 /***********************************************************************
2278 * NdrConformantVaryingStructMarshall [RPCRT4.@]
2279 */
2280 unsigned char * WINAPI NdrConformantVaryingStructMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2281 unsigned char *pMemory,
2282 PFORMAT_STRING pFormat)
2283 {
2284 FIXME("stub\n");
2285 return NULL;
2286 }
2287
2288 /***********************************************************************
2289 * NdrConformantVaryingStructUnmarshall [RPCRT4.@]
2290 */
2291 unsigned char * WINAPI NdrConformantVaryingStructUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2292 unsigned char **ppMemory,
2293 PFORMAT_STRING pFormat,
2294 unsigned char fMustAlloc)
2295 {
2296 FIXME("stub\n");
2297 return NULL;
2298 }
2299
2300 /***********************************************************************
2301 * NdrConformantVaryingStructBufferSize [RPCRT4.@]
2302 */
2303 void WINAPI NdrConformantVaryingStructBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2304 unsigned char *pMemory,
2305 PFORMAT_STRING pFormat)
2306 {
2307 FIXME("stub\n");
2308 }
2309
2310 /***********************************************************************
2311 * NdrConformantVaryingStructMemorySize [RPCRT4.@]
2312 */
2313 unsigned long WINAPI NdrConformantVaryingStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2314 PFORMAT_STRING pFormat)
2315 {
2316 FIXME("stub\n");
2317 return 0;
2318 }
2319
2320 /***********************************************************************
2321 * NdrConformantVaryingStructFree [RPCRT4.@]
2322 */
2323 void WINAPI NdrConformantVaryingStructFree(PMIDL_STUB_MESSAGE pStubMsg,
2324 unsigned char *pMemory,
2325 PFORMAT_STRING pFormat)
2326 {
2327 FIXME("stub\n");
2328 }
2329
2330 /***********************************************************************
2331 * NdrFixedArrayMarshall [RPCRT4.@]
2332 */
2333 unsigned char * WINAPI NdrFixedArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2334 unsigned char *pMemory,
2335 PFORMAT_STRING pFormat)
2336 {
2337 FIXME("stub\n");
2338 return NULL;
2339 }
2340
2341 /***********************************************************************
2342 * NdrFixedArrayUnmarshall [RPCRT4.@]
2343 */
2344 unsigned char * WINAPI NdrFixedArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2345 unsigned char **ppMemory,
2346 PFORMAT_STRING pFormat,
2347 unsigned char fMustAlloc)
2348 {
2349 FIXME("stub\n");
2350 return NULL;
2351 }
2352
2353 /***********************************************************************
2354 * NdrFixedArrayBufferSize [RPCRT4.@]
2355 */
2356 void WINAPI NdrFixedArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2357 unsigned char *pMemory,
2358 PFORMAT_STRING pFormat)
2359 {
2360 FIXME("stub\n");
2361 }
2362
2363 /***********************************************************************
2364 * NdrFixedArrayMemorySize [RPCRT4.@]
2365 */
2366 unsigned long WINAPI NdrFixedArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2367 PFORMAT_STRING pFormat)
2368 {
2369 FIXME("stub\n");
2370 return 0;
2371 }
2372
2373 /***********************************************************************
2374 * NdrFixedArrayFree [RPCRT4.@]
2375 */
2376 void WINAPI NdrFixedArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
2377 unsigned char *pMemory,
2378 PFORMAT_STRING pFormat)
2379 {
2380 FIXME("stub\n");
2381 }
2382
2383 /***********************************************************************
2384 * NdrVaryingArrayMarshall [RPCRT4.@]
2385 */
2386 unsigned char * WINAPI NdrVaryingArrayMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2387 unsigned char *pMemory,
2388 PFORMAT_STRING pFormat)
2389 {
2390 FIXME("stub\n");
2391 return NULL;
2392 }
2393
2394 /***********************************************************************
2395 * NdrVaryingArrayUnmarshall [RPCRT4.@]
2396 */
2397 unsigned char * WINAPI NdrVaryingArrayUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2398 unsigned char **ppMemory,
2399 PFORMAT_STRING pFormat,
2400 unsigned char fMustAlloc)
2401 {
2402 FIXME("stub\n");
2403 return NULL;
2404 }
2405
2406 /***********************************************************************
2407 * NdrVaryingArrayBufferSize [RPCRT4.@]
2408 */
2409 void WINAPI NdrVaryingArrayBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2410 unsigned char *pMemory,
2411 PFORMAT_STRING pFormat)
2412 {
2413 FIXME("stub\n");
2414 }
2415
2416 /***********************************************************************
2417 * NdrVaryingArrayMemorySize [RPCRT4.@]
2418 */
2419 unsigned long WINAPI NdrVaryingArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2420 PFORMAT_STRING pFormat)
2421 {
2422 FIXME("stub\n");
2423 return 0;
2424 }
2425
2426 /***********************************************************************
2427 * NdrVaryingArrayFree [RPCRT4.@]
2428 */
2429 void WINAPI NdrVaryingArrayFree(PMIDL_STUB_MESSAGE pStubMsg,
2430 unsigned char *pMemory,
2431 PFORMAT_STRING pFormat)
2432 {
2433 FIXME("stub\n");
2434 }
2435
2436 /***********************************************************************
2437 * NdrEncapsulatedUnionMarshall [RPCRT4.@]
2438 */
2439 unsigned char * WINAPI NdrEncapsulatedUnionMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2440 unsigned char *pMemory,
2441 PFORMAT_STRING pFormat)
2442 {
2443 FIXME("stub\n");
2444 return NULL;
2445 }
2446
2447 /***********************************************************************
2448 * NdrEncapsulatedUnionUnmarshall [RPCRT4.@]
2449 */
2450 unsigned char * WINAPI NdrEncapsulatedUnionUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2451 unsigned char **ppMemory,
2452 PFORMAT_STRING pFormat,
2453 unsigned char fMustAlloc)
2454 {
2455 FIXME("stub\n");
2456 return NULL;
2457 }
2458
2459 /***********************************************************************
2460 * NdrEncapsulatedUnionBufferSize [RPCRT4.@]
2461 */
2462 void WINAPI NdrEncapsulatedUnionBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2463 unsigned char *pMemory,
2464 PFORMAT_STRING pFormat)
2465 {
2466 FIXME("stub\n");
2467 }
2468
2469 /***********************************************************************
2470 * NdrEncapsulatedUnionMemorySize [RPCRT4.@]
2471 */
2472 unsigned long WINAPI NdrEncapsulatedUnionMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2473 PFORMAT_STRING pFormat)
2474 {
2475 FIXME("stub\n");
2476 return 0;
2477 }
2478
2479 /***********************************************************************
2480 * NdrEncapsulatedUnionFree [RPCRT4.@]
2481 */
2482 void WINAPI NdrEncapsulatedUnionFree(PMIDL_STUB_MESSAGE pStubMsg,
2483 unsigned char *pMemory,
2484 PFORMAT_STRING pFormat)
2485 {
2486 FIXME("stub\n");
2487 }
2488
2489 /***********************************************************************
2490 * NdrNonEncapsulatedUnionMarshall [RPCRT4.@]
2491 */
2492 unsigned char * WINAPI NdrNonEncapsulatedUnionMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2493 unsigned char *pMemory,
2494 PFORMAT_STRING pFormat)
2495 {
2496 FIXME("stub\n");
2497 return NULL;
2498 }
2499
2500 /***********************************************************************
2501 * NdrNonEncapsulatedUnionUnmarshall [RPCRT4.@]
2502 */
2503 unsigned char * WINAPI NdrNonEncapsulatedUnionUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2504 unsigned char **ppMemory,
2505 PFORMAT_STRING pFormat,
2506 unsigned char fMustAlloc)
2507 {
2508 FIXME("stub\n");
2509 return NULL;
2510 }
2511
2512 /***********************************************************************
2513 * NdrNonEncapsulatedUnionBufferSize [RPCRT4.@]
2514 */
2515 void WINAPI NdrNonEncapsulatedUnionBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2516 unsigned char *pMemory,
2517 PFORMAT_STRING pFormat)
2518 {
2519 FIXME("stub\n");
2520 }
2521
2522 /***********************************************************************
2523 * NdrNonEncapsulatedUnionMemorySize [RPCRT4.@]
2524 */
2525 unsigned long WINAPI NdrNonEncapsulatedUnionMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2526 PFORMAT_STRING pFormat)
2527 {
2528 FIXME("stub\n");
2529 return 0;
2530 }
2531
2532 /***********************************************************************
2533 * NdrNonEncapsulatedUnionFree [RPCRT4.@]
2534 */
2535 void WINAPI NdrNonEncapsulatedUnionFree(PMIDL_STUB_MESSAGE pStubMsg,
2536 unsigned char *pMemory,
2537 PFORMAT_STRING pFormat)
2538 {
2539 FIXME("stub\n");
2540 }
2541
2542 /***********************************************************************
2543 * NdrByteCountPointerMarshall [RPCRT4.@]
2544 */
2545 unsigned char * WINAPI NdrByteCountPointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2546 unsigned char *pMemory,
2547 PFORMAT_STRING pFormat)
2548 {
2549 FIXME("stub\n");
2550 return NULL;
2551 }
2552
2553 /***********************************************************************
2554 * NdrByteCountPointerUnmarshall [RPCRT4.@]
2555 */
2556 unsigned char * WINAPI NdrByteCountPointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2557 unsigned char **ppMemory,
2558 PFORMAT_STRING pFormat,
2559 unsigned char fMustAlloc)
2560 {
2561 FIXME("stub\n");
2562 return NULL;
2563 }
2564
2565 /***********************************************************************
2566 * NdrByteCountPointerBufferSize [RPCRT4.@]
2567 */
2568 void WINAPI NdrByteCountPointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2569 unsigned char *pMemory,
2570 PFORMAT_STRING pFormat)
2571 {
2572 FIXME("stub\n");
2573 }
2574
2575 /***********************************************************************
2576 * NdrByteCountPointerMemorySize [RPCRT4.@]
2577 */
2578 unsigned long WINAPI NdrByteCountPointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2579 PFORMAT_STRING pFormat)
2580 {
2581 FIXME("stub\n");
2582 return 0;
2583 }
2584
2585 /***********************************************************************
2586 * NdrByteCountPointerFree [RPCRT4.@]
2587 */
2588 void WINAPI NdrByteCountPointerFree(PMIDL_STUB_MESSAGE pStubMsg,
2589 unsigned char *pMemory,
2590 PFORMAT_STRING pFormat)
2591 {
2592 FIXME("stub\n");
2593 }
2594
2595 /***********************************************************************
2596 * NdrXmitOrRepAsMarshall [RPCRT4.@]
2597 */
2598 unsigned char * WINAPI NdrXmitOrRepAsMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2599 unsigned char *pMemory,
2600 PFORMAT_STRING pFormat)
2601 {
2602 FIXME("stub\n");
2603 return NULL;
2604 }
2605
2606 /***********************************************************************
2607 * NdrXmitOrRepAsUnmarshall [RPCRT4.@]
2608 */
2609 unsigned char * WINAPI NdrXmitOrRepAsUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2610 unsigned char **ppMemory,
2611 PFORMAT_STRING pFormat,
2612 unsigned char fMustAlloc)
2613 {
2614 FIXME("stub\n");
2615 return NULL;
2616 }
2617
2618 /***********************************************************************
2619 * NdrXmitOrRepAsBufferSize [RPCRT4.@]
2620 */
2621 void WINAPI NdrXmitOrRepAsBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
2622 unsigned char *pMemory,
2623 PFORMAT_STRING pFormat)
2624 {
2625 FIXME("stub\n");
2626 }
2627
2628 /***********************************************************************
2629 * NdrXmitOrRepAsMemorySize [RPCRT4.@]
2630 */
2631 unsigned long WINAPI NdrXmitOrRepAsMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
2632 PFORMAT_STRING pFormat)
2633 {
2634 FIXME("stub\n");
2635 return 0;
2636 }
2637
2638 /***********************************************************************
2639 * NdrXmitOrRepAsFree [RPCRT4.@]
2640 */
2641 void WINAPI NdrXmitOrRepAsFree(PMIDL_STUB_MESSAGE pStubMsg,
2642 unsigned char *pMemory,
2643 PFORMAT_STRING pFormat)
2644 {
2645 FIXME("stub\n");
2646 }
2647
2648 /***********************************************************************
2649 * NdrClientContextMarshall
2650 */
2651 void WINAPI NdrClientContextMarshall(PMIDL_STUB_MESSAGE pStubMsg,
2652 NDR_CCONTEXT ContextHandle,
2653 int fCheck)
2654 {
2655 FIXME("(%p, %p, %d): stub\n", pStubMsg, ContextHandle, fCheck);
2656 }
2657
2658 /***********************************************************************
2659 * NdrClientContextUnmarshall
2660 */
2661 void WINAPI NdrClientContextUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
2662 NDR_CCONTEXT * pContextHandle,
2663 RPC_BINDING_HANDLE BindHandle)
2664 {
2665 FIXME("(%p, %p, %p): stub\n", pStubMsg, pContextHandle, BindHandle);
2666 }