?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rpcrt4: Implement calling server functions on x86_64.
[wine/multimedia.git] / dlls / rpcrt4 / ndr_stubless.c
blob7fd7e6a33d2eed806422f75a72c8bae3bca970c1
1 /*
2 * NDR -Oi,-Oif,-Oicf Interpreter
3 *
4 * Copyright 2001 Ove Kåven, TransGaming Technologies
5 * Copyright 2003-5 Robert Shearman (for 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 * - Pipes
23 * - Some types of binding handles
24 */
25
26 #include "config.h"
27 #include "wine/port.h"
28
29 #include <stdarg.h>
30 #include <stdio.h>
31 #include <string.h>
32
33 #include "windef.h"
34 #include "winbase.h"
35 #include "winerror.h"
36
37 #include "objbase.h"
38 #include "rpc.h"
39 #include "rpcproxy.h"
40
41 #include "wine/exception.h"
42 #include "wine/debug.h"
43 #include "wine/rpcfc.h"
44
45 #include "cpsf.h"
46 #include "ndr_misc.h"
47 #include "ndr_stubless.h"
48
49 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
50
51 #define NDR_TABLE_MASK 127
52
53 static inline void call_buffer_sizer(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
54 {
55 NDR_BUFFERSIZE m = NdrBufferSizer[pFormat[0] & NDR_TABLE_MASK];
56 if (m) m(pStubMsg, pMemory, pFormat);
57 else
58 {
59 FIXME("format type 0x%x not implemented\n", pFormat[0]);
60 RpcRaiseException(RPC_X_BAD_STUB_DATA);
61 }
62 }
63
64 static inline unsigned char *call_marshaller(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
65 {
66 NDR_MARSHALL m = NdrMarshaller[pFormat[0] & NDR_TABLE_MASK];
67 if (m) return m(pStubMsg, pMemory, pFormat);
68 else
69 {
70 FIXME("format type 0x%x not implemented\n", pFormat[0]);
71 RpcRaiseException(RPC_X_BAD_STUB_DATA);
72 return NULL;
73 }
74 }
75
76 static inline unsigned char *call_unmarshaller(PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
77 {
78 NDR_UNMARSHALL m = NdrUnmarshaller[pFormat[0] & NDR_TABLE_MASK];
79 if (m) return m(pStubMsg, ppMemory, pFormat, fMustAlloc);
80 else
81 {
82 FIXME("format type 0x%x not implemented\n", pFormat[0]);
83 RpcRaiseException(RPC_X_BAD_STUB_DATA);
84 return NULL;
85 }
86 }
87
88 static inline void call_freer(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
89 {
90 NDR_FREE m = NdrFreer[pFormat[0] & NDR_TABLE_MASK];
91 if (m) m(pStubMsg, pMemory, pFormat);
92 }
93
94 #define STUBLESS_UNMARSHAL 1
95 #define STUBLESS_INITOUT 2
96 #define STUBLESS_CALLSERVER 3
97 #define STUBLESS_CALCSIZE 4
98 #define STUBLESS_GETBUFFER 5
99 #define STUBLESS_MARSHAL 6
100 #define STUBLESS_FREE 7
101
102 void WINAPI NdrRpcSmSetClientToOsf(PMIDL_STUB_MESSAGE pMessage)
103 {
104 #if 0 /* these functions are not defined yet */
105 pMessage->pfnAllocate = NdrRpcSmClientAllocate;
106 pMessage->pfnFree = NdrRpcSmClientFree;
107 #endif
108 }
109
110 static void dump_RPC_FC_PROC_PF(PARAM_ATTRIBUTES param_attributes)
111 {
112 if (param_attributes.MustSize) TRACE(" MustSize");
113 if (param_attributes.MustFree) TRACE(" MustFree");
114 if (param_attributes.IsPipe) TRACE(" IsPipe");
115 if (param_attributes.IsIn) TRACE(" IsIn");
116 if (param_attributes.IsOut) TRACE(" IsOut");
117 if (param_attributes.IsReturn) TRACE(" IsReturn");
118 if (param_attributes.IsBasetype) TRACE(" IsBasetype");
119 if (param_attributes.IsByValue) TRACE(" IsByValue");
120 if (param_attributes.IsSimpleRef) TRACE(" IsSimpleRef");
121 if (param_attributes.IsDontCallFreeInst) TRACE(" IsDontCallFreeInst");
122 if (param_attributes.SaveForAsyncFinish) TRACE(" SaveForAsyncFinish");
123 if (param_attributes.ServerAllocSize) TRACE(" ServerAllocSize = %d", param_attributes.ServerAllocSize * 8);
124 }
125
126 static void dump_INTERPRETER_OPT_FLAGS(INTERPRETER_OPT_FLAGS Oi2Flags)
127 {
128 if (Oi2Flags.ServerMustSize) TRACE(" ServerMustSize");
129 if (Oi2Flags.ClientMustSize) TRACE(" ClientMustSize");
130 if (Oi2Flags.HasReturn) TRACE(" HasReturn");
131 if (Oi2Flags.HasPipes) TRACE(" HasPipes");
132 if (Oi2Flags.Unused) TRACE(" Unused");
133 if (Oi2Flags.HasAsyncUuid) TRACE(" HasAsyncUuid");
134 if (Oi2Flags.HasExtensions) TRACE(" HasExtensions");
135 if (Oi2Flags.HasAsyncHandle) TRACE(" HasAsyncHandle");
136 TRACE("\n");
137 }
138
139 #define ARG_FROM_OFFSET(args, offset) ((args) + (offset))
140
141 static PFORMAT_STRING client_get_handle(
142 PMIDL_STUB_MESSAGE pStubMsg, const NDR_PROC_HEADER *pProcHeader,
143 PFORMAT_STRING pFormat, handle_t *phBinding)
144 {
145 /* binding */
146 switch (pProcHeader->handle_type)
147 {
148 /* explicit binding: parse additional section */
149 case RPC_FC_BIND_EXPLICIT:
150 switch (*pFormat) /* handle_type */
151 {
152 case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */
153 {
154 const NDR_EHD_PRIMITIVE *pDesc = (const NDR_EHD_PRIMITIVE *)pFormat;
155
156 TRACE("Explicit primitive handle @ %d\n", pDesc->offset);
157
158 if (pDesc->flag) /* pointer to binding */
159 *phBinding = **(handle_t **)ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset);
160 else
161 *phBinding = *(handle_t *)ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset);
162 return pFormat + sizeof(NDR_EHD_PRIMITIVE);
163 }
164 case RPC_FC_BIND_GENERIC: /* explicit generic */
165 {
166 const NDR_EHD_GENERIC *pDesc = (const NDR_EHD_GENERIC *)pFormat;
167 void *pObject = NULL;
168 void *pArg;
169 const GENERIC_BINDING_ROUTINE_PAIR *pGenPair;
170
171 TRACE("Explicit generic binding handle #%d\n", pDesc->binding_routine_pair_index);
172
173 if (pDesc->flag_and_size & HANDLE_PARAM_IS_VIA_PTR)
174 pArg = *(void **)ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset);
175 else
176 pArg = ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset);
177 memcpy(&pObject, pArg, pDesc->flag_and_size & 0xf);
178 pGenPair = &pStubMsg->StubDesc->aGenericBindingRoutinePairs[pDesc->binding_routine_pair_index];
179 *phBinding = pGenPair->pfnBind(pObject);
180 return pFormat + sizeof(NDR_EHD_GENERIC);
181 }
182 case RPC_FC_BIND_CONTEXT: /* explicit context */
183 {
184 const NDR_EHD_CONTEXT *pDesc = (const NDR_EHD_CONTEXT *)pFormat;
185 NDR_CCONTEXT context_handle;
186 TRACE("Explicit bind context\n");
187 if (pDesc->flags & HANDLE_PARAM_IS_VIA_PTR)
188 {
189 TRACE("\tHANDLE_PARAM_IS_VIA_PTR\n");
190 context_handle = **(NDR_CCONTEXT **)ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset);
191 }
192 else
193 context_handle = *(NDR_CCONTEXT *)ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset);
194
195 if (context_handle) *phBinding = NDRCContextBinding(context_handle);
196 else if (pDesc->flags & NDR_CONTEXT_HANDLE_CANNOT_BE_NULL)
197 {
198 ERR("null context handle isn't allowed\n");
199 RpcRaiseException(RPC_X_SS_IN_NULL_CONTEXT);
200 return NULL;
201 }
202 /* FIXME: should we store this structure in stubMsg.pContext? */
203 return pFormat + sizeof(NDR_EHD_CONTEXT);
204 }
205 default:
206 ERR("bad explicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
207 RpcRaiseException(RPC_X_BAD_STUB_DATA);
208 }
209 break;
210 case RPC_FC_BIND_GENERIC: /* implicit generic */
211 FIXME("RPC_FC_BIND_GENERIC\n");
212 RpcRaiseException(RPC_X_BAD_STUB_DATA); /* FIXME: remove when implemented */
213 break;
214 case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */
215 TRACE("Implicit primitive handle\n");
216 *phBinding = *pStubMsg->StubDesc->IMPLICIT_HANDLE_INFO.pPrimitiveHandle;
217 break;
218 case RPC_FC_CALLBACK_HANDLE: /* implicit callback */
219 FIXME("RPC_FC_CALLBACK_HANDLE\n");
220 break;
221 case RPC_FC_AUTO_HANDLE: /* implicit auto handle */
222 /* strictly speaking, it isn't necessary to set hBinding here
223 * since it isn't actually used (hence the automatic in its name),
224 * but then why does MIDL generate a valid entry in the
225 * MIDL_STUB_DESC for it? */
226 TRACE("Implicit auto handle\n");
227 *phBinding = *pStubMsg->StubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle;
228 break;
229 default:
230 ERR("bad implicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
231 RpcRaiseException(RPC_X_BAD_STUB_DATA);
232 }
233 return pFormat;
234 }
235
236 static void client_free_handle(
237 PMIDL_STUB_MESSAGE pStubMsg, const NDR_PROC_HEADER *pProcHeader,
238 PFORMAT_STRING pFormat, handle_t hBinding)
239 {
240 /* binding */
241 switch (pProcHeader->handle_type)
242 {
243 /* explicit binding: parse additional section */
244 case RPC_FC_BIND_EXPLICIT:
245 switch (*pFormat) /* handle_type */
246 {
247 case RPC_FC_BIND_GENERIC: /* explicit generic */
248 {
249 const NDR_EHD_GENERIC *pDesc = (const NDR_EHD_GENERIC *)pFormat;
250 void *pObject = NULL;
251 void *pArg;
252 const GENERIC_BINDING_ROUTINE_PAIR *pGenPair;
253
254 TRACE("Explicit generic binding handle #%d\n", pDesc->binding_routine_pair_index);
255
256 if (pDesc->flag_and_size & HANDLE_PARAM_IS_VIA_PTR)
257 pArg = *(void **)ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset);
258 else
259 pArg = ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset);
260 memcpy(&pObject, pArg, pDesc->flag_and_size & 0xf);
261 pGenPair = &pStubMsg->StubDesc->aGenericBindingRoutinePairs[pDesc->binding_routine_pair_index];
262 pGenPair->pfnUnbind(pObject, hBinding);
263 break;
264 }
265 case RPC_FC_BIND_CONTEXT: /* explicit context */
266 case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */
267 break;
268 default:
269 ERR("bad explicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
270 RpcRaiseException(RPC_X_BAD_STUB_DATA);
271 }
272 break;
273 case RPC_FC_BIND_GENERIC: /* implicit generic */
274 FIXME("RPC_FC_BIND_GENERIC\n");
275 RpcRaiseException(RPC_X_BAD_STUB_DATA); /* FIXME: remove when implemented */
276 break;
277 case RPC_FC_CALLBACK_HANDLE: /* implicit callback */
278 case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */
279 case RPC_FC_AUTO_HANDLE: /* implicit auto handle */
280 break;
281 default:
282 ERR("bad implicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
283 RpcRaiseException(RPC_X_BAD_STUB_DATA);
284 }
285 }
286
287 static void client_do_args(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat,
288 int phase, unsigned char *args, unsigned short number_of_params,
289 unsigned char *pRetVal)
290 {
291 /* current format string offset */
292 int current_offset = 0;
293 /* current stack offset */
294 unsigned short current_stack_offset = 0;
295 /* counter */
296 unsigned short i;
297
298 for (i = 0; i < number_of_params; i++)
299 {
300 const NDR_PARAM_OIF_BASETYPE *pParam =
301 (const NDR_PARAM_OIF_BASETYPE *)&pFormat[current_offset];
302 unsigned char * pArg;
303
304 current_stack_offset = pParam->stack_offset;
305 pArg = ARG_FROM_OFFSET(args, current_stack_offset);
306
307 TRACE("param[%d]: new format\n", i);
308 TRACE("\tparam_attributes:"); dump_RPC_FC_PROC_PF(pParam->param_attributes); TRACE("\n");
309 TRACE("\tstack_offset: 0x%x\n", current_stack_offset);
310 TRACE("\tmemory addr (before): %p\n", pArg);
311
312 if (pParam->param_attributes.IsBasetype)
313 {
314 const unsigned char * pTypeFormat =
315 &pParam->type_format_char;
316
317 if (pParam->param_attributes.IsSimpleRef)
318 {
319 pArg = *(unsigned char **)pArg;
320 if (!pArg) RpcRaiseException(RPC_X_NULL_REF_POINTER);
321 }
322
323 TRACE("\tbase type: 0x%02x\n", *pTypeFormat);
324
325 switch (phase)
326 {
327 case PROXY_CALCSIZE:
328 if (pParam->param_attributes.IsIn)
329 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
330 break;
331 case PROXY_MARSHAL:
332 if (pParam->param_attributes.IsIn)
333 call_marshaller(pStubMsg, pArg, pTypeFormat);
334 break;
335 case PROXY_UNMARSHAL:
336 if (pParam->param_attributes.IsOut)
337 {
338 if (pParam->param_attributes.IsReturn) pArg = pRetVal;
339 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
340 }
341 break;
342 default:
343 RpcRaiseException(RPC_S_INTERNAL_ERROR);
344 }
345
346 current_offset += sizeof(NDR_PARAM_OIF_BASETYPE);
347 }
348 else
349 {
350 const NDR_PARAM_OIF_OTHER *pParamOther =
351 (const NDR_PARAM_OIF_OTHER *)&pFormat[current_offset];
352
353 const unsigned char * pTypeFormat =
354 &(pStubMsg->StubDesc->pFormatTypes[pParamOther->type_offset]);
355
356 /* if a simple ref pointer then we have to do the
357 * check for the pointer being non-NULL. */
358 if (pParam->param_attributes.IsSimpleRef)
359 {
360 if (!*(unsigned char **)pArg)
361 RpcRaiseException(RPC_X_NULL_REF_POINTER);
362 }
363
364 TRACE("\tcomplex type: 0x%02x\n", *pTypeFormat);
365
366 switch (phase)
367 {
368 case PROXY_CALCSIZE:
369 if (pParam->param_attributes.IsIn)
370 {
371 if (pParam->param_attributes.IsByValue)
372 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
373 else
374 call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
375 }
376 break;
377 case PROXY_MARSHAL:
378 if (pParam->param_attributes.IsIn)
379 {
380 if (pParam->param_attributes.IsByValue)
381 call_marshaller(pStubMsg, pArg, pTypeFormat);
382 else
383 call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
384 }
385 break;
386 case PROXY_UNMARSHAL:
387 if (pParam->param_attributes.IsOut)
388 {
389 if (pParam->param_attributes.IsReturn) pArg = pRetVal;
390 if (pParam->param_attributes.IsByValue)
391 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
392 else
393 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
394 }
395 break;
396 default:
397 RpcRaiseException(RPC_S_INTERNAL_ERROR);
398 }
399
400 current_offset += sizeof(NDR_PARAM_OIF_OTHER);
401 }
402 TRACE("\tmemory addr (after): %p\n", pArg);
403 }
404 }
405
406 static unsigned int type_stack_size(unsigned char fc)
407 {
408 switch (fc)
409 {
410 case RPC_FC_BYTE:
411 case RPC_FC_CHAR:
412 case RPC_FC_SMALL:
413 case RPC_FC_USMALL:
414 case RPC_FC_WCHAR:
415 case RPC_FC_SHORT:
416 case RPC_FC_USHORT:
417 case RPC_FC_LONG:
418 case RPC_FC_ULONG:
419 case RPC_FC_INT3264:
420 case RPC_FC_UINT3264:
421 case RPC_FC_ENUM16:
422 case RPC_FC_ENUM32:
423 case RPC_FC_FLOAT:
424 case RPC_FC_ERROR_STATUS_T:
425 case RPC_FC_IGNORE:
426 return sizeof(void *);
427 case RPC_FC_DOUBLE:
428 return sizeof(double);
429 case RPC_FC_HYPER:
430 return sizeof(ULONGLONG);
431 default:
432 ERR("invalid base type 0x%x\n", fc);
433 RpcRaiseException(RPC_S_INTERNAL_ERROR);
434 }
435 }
436
437 static BOOL is_by_value( PFORMAT_STRING format )
438 {
439 switch (*format)
440 {
441 case RPC_FC_USER_MARSHAL:
442 case RPC_FC_STRUCT:
443 case RPC_FC_PSTRUCT:
444 case RPC_FC_CSTRUCT:
445 case RPC_FC_CPSTRUCT:
446 case RPC_FC_CVSTRUCT:
447 case RPC_FC_BOGUS_STRUCT:
448 return TRUE;
449 default:
450 return FALSE;
451 }
452 }
453
454 void client_do_args_old_format(PMIDL_STUB_MESSAGE pStubMsg,
455 PFORMAT_STRING pFormat, int phase, unsigned char *args,
456 unsigned short stack_size,
457 unsigned char *pRetVal, BOOL object_proc, BOOL ignore_retval)
458 {
459 /* current format string offset */
460 int current_offset = 0;
461 /* current stack offset */
462 unsigned short current_stack_offset = object_proc ? sizeof(void *) : 0;
463 /* counter */
464 unsigned short i;
465
466 /* NOTE: V1 style format doesn't terminate on the number_of_params
467 * condition as it doesn't have this attribute. Instead it
468 * terminates when the stack size given in the header is exceeded.
469 */
470 for (i = 0; TRUE; i++)
471 {
472 const NDR_PARAM_OI_BASETYPE *pParam =
473 (const NDR_PARAM_OI_BASETYPE *)&pFormat[current_offset];
474 unsigned char * pArg = ARG_FROM_OFFSET(args, current_stack_offset);
475
476 /* no more parameters; exit loop */
477 if (current_stack_offset >= stack_size)
478 break;
479
480 TRACE("param[%d]: old format\n", i);
481 TRACE("\tparam_direction: 0x%x\n", pParam->param_direction);
482 TRACE("\tstack_offset: 0x%x\n", current_stack_offset);
483 TRACE("\tmemory addr (before): %p\n", pArg);
484
485 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE ||
486 pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
487 {
488 const unsigned char * pTypeFormat =
489 &pParam->type_format_char;
490
491 TRACE("\tbase type 0x%02x\n", *pTypeFormat);
492
493 switch (phase)
494 {
495 case PROXY_CALCSIZE:
496 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
497 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
498 break;
499 case PROXY_MARSHAL:
500 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
501 call_marshaller(pStubMsg, pArg, pTypeFormat);
502 break;
503 case PROXY_UNMARSHAL:
504 if (!ignore_retval &&
505 pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
506 {
507 if (pParam->param_direction & RPC_FC_RETURN_PARAM)
508 call_unmarshaller(pStubMsg, &pRetVal, pTypeFormat, 0);
509 else
510 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
511 }
512 break;
513 default:
514 RpcRaiseException(RPC_S_INTERNAL_ERROR);
515 }
516
517 current_stack_offset += type_stack_size(*pTypeFormat);
518 current_offset += sizeof(NDR_PARAM_OI_BASETYPE);
519 }
520 else
521 {
522 const NDR_PARAM_OI_OTHER *pParamOther = (const NDR_PARAM_OI_OTHER *)&pFormat[current_offset];
523 const unsigned char *pTypeFormat = &pStubMsg->StubDesc->pFormatTypes[pParamOther->type_offset];
524 const BOOL by_value = is_by_value( pTypeFormat );
525
526 TRACE("\tcomplex type 0x%02x\n", *pTypeFormat);
527
528 switch (phase)
529 {
530 case PROXY_CALCSIZE:
531 if (pParam->param_direction == RPC_FC_IN_PARAM ||
532 pParam->param_direction == RPC_FC_IN_OUT_PARAM)
533 {
534 if (!by_value) pArg = *(unsigned char **)pArg;
535 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
536 }
537 break;
538 case PROXY_MARSHAL:
539 if (pParam->param_direction == RPC_FC_IN_PARAM ||
540 pParam->param_direction == RPC_FC_IN_OUT_PARAM)
541 {
542 if (!by_value) pArg = *(unsigned char **)pArg;
543 call_marshaller(pStubMsg, pArg, pTypeFormat);
544 }
545 break;
546 case PROXY_UNMARSHAL:
547 if (pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
548 pParam->param_direction == RPC_FC_OUT_PARAM)
549 {
550 if (by_value)
551 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
552 else
553 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
554 }
555 else if (pParam->param_direction == RPC_FC_RETURN_PARAM)
556 call_unmarshaller(pStubMsg, (unsigned char **)pRetVal, pTypeFormat, 0);
557 break;
558 default:
559 RpcRaiseException(RPC_S_INTERNAL_ERROR);
560 }
561
562 current_stack_offset += pParamOther->stack_size * sizeof(void *);
563 current_offset += sizeof(NDR_PARAM_OI_OTHER);
564 }
565 }
566 }
567
568 LONG_PTR CDECL ndr_client_call( PMIDL_STUB_DESC pStubDesc, PFORMAT_STRING pFormat, void **stack_top )
569 {
570 /* pointer to start of stack where arguments start */
571 RPC_MESSAGE rpcMsg;
572 MIDL_STUB_MESSAGE stubMsg;
573 handle_t hBinding = NULL;
574 /* procedure number */
575 unsigned short procedure_number;
576 /* size of stack */
577 unsigned short stack_size;
578 /* number of parameters. optional for client to give it to us */
579 unsigned char number_of_params = ~0;
580 /* cache of Oif_flags from v2 procedure header */
581 INTERPRETER_OPT_FLAGS Oif_flags = { 0 };
582 /* cache of extension flags from NDR_PROC_HEADER_EXTS */
583 INTERPRETER_OPT_FLAGS2 ext_flags = { 0 };
584 /* the type of pass we are currently doing */
585 int phase;
586 /* header for procedure string */
587 const NDR_PROC_HEADER * pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
588 /* -Oif or -Oicf generated format */
589 BOOL bV2Format = FALSE;
590 /* the value to return to the client from the remote procedure */
591 LONG_PTR RetVal = 0;
592 /* the pointer to the object when in OLE mode */
593 void * This = NULL;
594 PFORMAT_STRING pHandleFormat;
595 /* correlation cache */
596 ULONG_PTR NdrCorrCache[256];
597
598 TRACE("pStubDesc %p, pFormat %p, ...\n", pStubDesc, pFormat);
599
600 TRACE("NDR Version: 0x%x\n", pStubDesc->Version);
601
602 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
603 {
604 const NDR_PROC_HEADER_RPC *pProcHeader = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
605 stack_size = pProcHeader->stack_size;
606 procedure_number = pProcHeader->proc_num;
607 pFormat += sizeof(NDR_PROC_HEADER_RPC);
608 }
609 else
610 {
611 stack_size = pProcHeader->stack_size;
612 procedure_number = pProcHeader->proc_num;
613 pFormat += sizeof(NDR_PROC_HEADER);
614 }
615 TRACE("stack size: 0x%x\n", stack_size);
616 TRACE("proc num: %d\n", procedure_number);
617
618 /* create the full pointer translation tables, if requested */
619 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
620 stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
621
622 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
623 {
624 /* object is always the first argument */
625 This = stack_top[0];
626 NdrProxyInitialize(This, &rpcMsg, &stubMsg, pStubDesc, procedure_number);
627 }
628 else
629 NdrClientInitializeNew(&rpcMsg, &stubMsg, pStubDesc, procedure_number);
630
631 TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
632 TRACE("MIDL stub version = 0x%x\n", pStubDesc->MIDLVersion);
633
634 stubMsg.StackTop = (unsigned char *)stack_top;
635 pHandleFormat = pFormat;
636
637 /* we only need a handle if this isn't an object method */
638 if (!(pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT))
639 {
640 pFormat = client_get_handle(&stubMsg, pProcHeader, pHandleFormat, &hBinding);
641 if (!pFormat) goto done;
642 }
643
644 bV2Format = (pStubDesc->Version >= 0x20000);
645
646 if (bV2Format)
647 {
648 const NDR_PROC_PARTIAL_OIF_HEADER *pOIFHeader =
649 (const NDR_PROC_PARTIAL_OIF_HEADER *)pFormat;
650
651 Oif_flags = pOIFHeader->Oi2Flags;
652 number_of_params = pOIFHeader->number_of_params;
653
654 pFormat += sizeof(NDR_PROC_PARTIAL_OIF_HEADER);
655 }
656
657 TRACE("Oif_flags = "); dump_INTERPRETER_OPT_FLAGS(Oif_flags);
658
659 if (Oif_flags.HasExtensions)
660 {
661 const NDR_PROC_HEADER_EXTS *pExtensions =
662 (const NDR_PROC_HEADER_EXTS *)pFormat;
663 ext_flags = pExtensions->Flags2;
664 pFormat += pExtensions->Size;
665 }
666
667 stubMsg.BufferLength = 0;
668
669 /* store the RPC flags away */
670 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
671 rpcMsg.RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
672
673 /* use alternate memory allocation routines */
674 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
675 NdrRpcSmSetClientToOsf(&stubMsg);
676
677 if (Oif_flags.HasPipes)
678 {
679 FIXME("pipes not supported yet\n");
680 RpcRaiseException(RPC_X_WRONG_STUB_VERSION); /* FIXME: remove when implemented */
681 /* init pipes package */
682 /* NdrPipesInitialize(...) */
683 }
684 if (ext_flags.HasNewCorrDesc)
685 {
686 /* initialize extra correlation package */
687 NdrCorrelationInitialize(&stubMsg, NdrCorrCache, sizeof(NdrCorrCache), 0);
688 }
689
690 /* order of phases:
691 * 1. PROXY_CALCSIZE - calculate the buffer size
692 * 2. PROXY_GETBUFFER - allocate the buffer
693 * 3. PROXY_MARHSAL - marshal [in] params into the buffer
694 * 4. PROXY_SENDRECEIVE - send/receive buffer
695 * 5. PROXY_UNMARHSAL - unmarshal [out] params from buffer
696 */
697 if ((pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT) ||
698 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_HAS_COMM_OR_FAULT))
699 {
700 __TRY
701 {
702 for (phase = PROXY_CALCSIZE; phase <= PROXY_UNMARSHAL; phase++)
703 {
704 TRACE("phase = %d\n", phase);
705 switch (phase)
706 {
707 case PROXY_GETBUFFER:
708 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
709 {
710 /* allocate the buffer */
711 NdrProxyGetBuffer(This, &stubMsg);
712 }
713 else
714 {
715 /* allocate the buffer */
716 if (Oif_flags.HasPipes)
717 /* NdrGetPipeBuffer(...) */
718 FIXME("pipes not supported yet\n");
719 else
720 {
721 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
722 #if 0
723 NdrNsGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
724 #else
725 FIXME("using auto handle - call NdrNsGetBuffer when it gets implemented\n");
726 #endif
727 else
728 NdrGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
729 }
730 }
731 break;
732 case PROXY_SENDRECEIVE:
733 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
734 {
735 /* send the [in] params and receive the [out] and [retval]
736 * params */
737 NdrProxySendReceive(This, &stubMsg);
738 }
739 else
740 {
741 /* send the [in] params and receive the [out] and [retval]
742 * params */
743 if (Oif_flags.HasPipes)
744 /* NdrPipesSendReceive(...) */
745 FIXME("pipes not supported yet\n");
746 else
747 {
748 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
749 #if 0
750 NdrNsSendReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
751 #else
752 FIXME("using auto handle - call NdrNsSendReceive when it gets implemented\n");
753 #endif
754 else
755 NdrSendReceive(&stubMsg, stubMsg.Buffer);
756 }
757 }
758
759 /* convert strings, floating point values and endianess into our
760 * preferred format */
761 if ((rpcMsg.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
762 NdrConvert(&stubMsg, pFormat);
763
764 break;
765 case PROXY_CALCSIZE:
766 case PROXY_MARSHAL:
767 case PROXY_UNMARSHAL:
768 if (bV2Format)
769 client_do_args(&stubMsg, pFormat, phase, stubMsg.StackTop,
770 number_of_params, (unsigned char *)&RetVal);
771 else
772 client_do_args_old_format(&stubMsg, pFormat, phase,
773 stubMsg.StackTop, stack_size, (unsigned char *)&RetVal,
774 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT), FALSE);
775 break;
776 default:
777 ERR("shouldn't reach here. phase %d\n", phase);
778 break;
779 }
780 }
781 }
782 __EXCEPT_ALL
783 {
784 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
785 RetVal = NdrProxyErrorHandler(GetExceptionCode());
786 else
787 {
788 const COMM_FAULT_OFFSETS *comm_fault_offsets = &pStubDesc->CommFaultOffsets[procedure_number];
789 ULONG *comm_status;
790 ULONG *fault_status;
791
792 TRACE("comm_fault_offsets = {0x%hx, 0x%hx}\n", comm_fault_offsets->CommOffset, comm_fault_offsets->FaultOffset);
793
794 if (comm_fault_offsets->CommOffset == -1)
795 comm_status = (ULONG *)&RetVal;
796 else if (comm_fault_offsets->CommOffset >= 0)
797 comm_status = *(ULONG **)ARG_FROM_OFFSET(stubMsg.StackTop, comm_fault_offsets->CommOffset);
798 else
799 comm_status = NULL;
800
801 if (comm_fault_offsets->FaultOffset == -1)
802 fault_status = (ULONG *)&RetVal;
803 else if (comm_fault_offsets->FaultOffset >= 0)
804 fault_status = *(ULONG **)ARG_FROM_OFFSET(stubMsg.StackTop, comm_fault_offsets->CommOffset);
805 else
806 fault_status = NULL;
807
808 NdrMapCommAndFaultStatus(&stubMsg, comm_status, fault_status,
809 GetExceptionCode());
810 }
811 }
812 __ENDTRY
813 }
814 else
815 {
816 /* order of phases:
817 * 1. PROXY_CALCSIZE - calculate the buffer size
818 * 2. PROXY_GETBUFFER - allocate the buffer
819 * 3. PROXY_MARHSAL - marshal [in] params into the buffer
820 * 4. PROXY_SENDRECEIVE - send/receive buffer
821 * 5. PROXY_UNMARHSAL - unmarshal [out] params from buffer
822 */
823 for (phase = PROXY_CALCSIZE; phase <= PROXY_UNMARSHAL; phase++)
824 {
825 TRACE("phase = %d\n", phase);
826 switch (phase)
827 {
828 case PROXY_GETBUFFER:
829 /* allocate the buffer */
830 if (Oif_flags.HasPipes)
831 /* NdrGetPipeBuffer(...) */
832 FIXME("pipes not supported yet\n");
833 else
834 {
835 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
836 #if 0
837 NdrNsGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
838 #else
839 FIXME("using auto handle - call NdrNsGetBuffer when it gets implemented\n");
840 #endif
841 else
842 NdrGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
843 }
844 break;
845 case PROXY_SENDRECEIVE:
846 /* send the [in] params and receive the [out] and [retval]
847 * params */
848 if (Oif_flags.HasPipes)
849 /* NdrPipesSendReceive(...) */
850 FIXME("pipes not supported yet\n");
851 else
852 {
853 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
854 #if 0
855 NdrNsSendReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
856 #else
857 FIXME("using auto handle - call NdrNsSendReceive when it gets implemented\n");
858 #endif
859 else
860 NdrSendReceive(&stubMsg, stubMsg.Buffer);
861 }
862
863 /* convert strings, floating point values and endianess into our
864 * preferred format */
865 if ((rpcMsg.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
866 NdrConvert(&stubMsg, pFormat);
867
868 break;
869 case PROXY_CALCSIZE:
870 case PROXY_MARSHAL:
871 case PROXY_UNMARSHAL:
872 if (bV2Format)
873 client_do_args(&stubMsg, pFormat, phase, stubMsg.StackTop,
874 number_of_params, (unsigned char *)&RetVal);
875 else
876 client_do_args_old_format(&stubMsg, pFormat, phase,
877 stubMsg.StackTop, stack_size, (unsigned char *)&RetVal,
878 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT), FALSE);
879 break;
880 default:
881 ERR("shouldn't reach here. phase %d\n", phase);
882 break;
883 }
884 }
885 }
886
887 if (ext_flags.HasNewCorrDesc)
888 {
889 /* free extra correlation package */
890 NdrCorrelationFree(&stubMsg);
891 }
892
893 if (Oif_flags.HasPipes)
894 {
895 /* NdrPipesDone(...) */
896 }
897
898 /* free the full pointer translation tables */
899 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
900 NdrFullPointerXlatFree(stubMsg.FullPtrXlatTables);
901
902 /* free marshalling buffer */
903 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
904 NdrProxyFreeBuffer(This, &stubMsg);
905 else
906 {
907 NdrFreeBuffer(&stubMsg);
908 client_free_handle(&stubMsg, pProcHeader, pHandleFormat, hBinding);
909 }
910
911 done:
912 TRACE("RetVal = 0x%lx\n", RetVal);
913 return RetVal;
914 }
915
916 #ifdef __x86_64__
917
918 __ASM_GLOBAL_FUNC( NdrClientCall2,
919 "movq %r8,0x18(%rsp)\n\t"
920 "movq %r9,0x20(%rsp)\n\t"
921 "leaq 0x18(%rsp),%r8\n\t"
922 "subq $0x28,%rsp\n\t"
923 __ASM_CFI(".cfi_adjust_cfa_offset 0x28\n\t")
924 "call " __ASM_NAME("ndr_client_call") "\n\t"
925 "addq $0x28,%rsp\n\t"
926 __ASM_CFI(".cfi_adjust_cfa_offset -0x28\n\t")
927 "ret" );
928
929 #else /* __x86_64__ */
930
931 /***********************************************************************
932 * NdrClientCall2 [RPCRT4.@]
933 */
934 CLIENT_CALL_RETURN WINAPIV NdrClientCall2( PMIDL_STUB_DESC desc, PFORMAT_STRING format, ... )
935 {
936 __ms_va_list args;
937 LONG_PTR ret;
938
939 __ms_va_start( args, format );
940 ret = ndr_client_call( desc, format, va_arg( args, void ** ));
941 __ms_va_end( args );
942 return *(CLIENT_CALL_RETURN *)&ret;
943 }
944
945 #endif /* __x86_64__ */
946
947 /* Calls a function with the specified arguments, restoring the stack
948 * properly afterwards as we don't know the calling convention of the
949 * function */
950 #if defined __i386__ && defined _MSC_VER
951 __declspec(naked) LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned int stack_size)
952 {
953 __asm
954 {
955 push ebp
956 push edi ; Save registers
957 push esi
958 mov ebp, esp
959 mov eax, [ebp+16] ; Get stack size
960 sub esp, eax ; Make room in stack for arguments
961 mov edi, esp
962 mov ecx, eax
963 mov esi, [ebp+12]
964 shr ecx, 2
965 cld
966 rep movsd ; Copy dword blocks
967 call [ebp+8] ; Call function
968 lea esp, [ebp-8] ; Restore stack
969 pop esi ; Restore registers
970 pop edi
971 pop ebp
972 ret
973 }
974 }
975 #elif defined __i386__ && defined __GNUC__
976 LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned int stack_size);
977 __ASM_GLOBAL_FUNC(call_server_func,
978 "pushl %ebp\n\t"
979 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
980 __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
981 "movl %esp,%ebp\n\t"
982 __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
983 "pushl %edi\n\t" /* Save registers */
984 __ASM_CFI(".cfi_rel_offset %edi,-4\n\t")
985 "pushl %esi\n\t"
986 __ASM_CFI(".cfi_rel_offset %esi,-8\n\t")
987 "movl 16(%ebp), %eax\n\t" /* Get stack size */
988 "subl %eax, %esp\n\t" /* Make room in stack for arguments */
989 "andl $~15, %esp\n\t" /* Make sure stack has 16-byte alignment for Mac OS X */
990 "movl %esp, %edi\n\t"
991 "movl %eax, %ecx\n\t"
992 "movl 12(%ebp), %esi\n\t"
993 "shrl $2, %ecx\n\t" /* divide by 4 */
994 "cld\n\t"
995 "rep; movsl\n\t" /* Copy dword blocks */
996 "call *8(%ebp)\n\t" /* Call function */
997 "leal -8(%ebp), %esp\n\t" /* Restore stack */
998 "popl %esi\n\t" /* Restore registers */
999 __ASM_CFI(".cfi_same_value %esi\n\t")
1000 "popl %edi\n\t"
1001 __ASM_CFI(".cfi_same_value %edi\n\t")
1002 "popl %ebp\n\t"
1003 __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
1004 __ASM_CFI(".cfi_same_value %ebp\n\t")
1005 "ret" )
1006 #elif defined __x86_64__
1007 LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned int stack_size);
1008 __ASM_GLOBAL_FUNC( call_server_func,
1009 "pushq %rbp\n\t"
1010 __ASM_CFI(".cfi_adjust_cfa_offset 8\n\t")
1011 __ASM_CFI(".cfi_rel_offset %rbp,0\n\t")
1012 "movq %rsp,%rbp\n\t"
1013 __ASM_CFI(".cfi_def_cfa_register %rbp\n\t")
1014 "pushq %rsi\n\t"
1015 __ASM_CFI(".cfi_rel_offset %rsi,-8\n\t")
1016 "pushq %rdi\n\t"
1017 __ASM_CFI(".cfi_rel_offset %rdi,-16\n\t")
1018 "movq %rcx,%rax\n\t" /* function to call */
1019 "movq $32,%rcx\n\t" /* allocate max(32,stack_size) bytes of stack space */
1020 "cmpq %rcx,%r8\n\t"
1021 "cmovgq %r8,%rcx\n\t"
1022 "subq %rcx,%rsp\n\t"
1023 "andq $~15,%rsp\n\t"
1024 "movq %r8,%rcx\n\t"
1025 "shrq $3,%rcx\n\t"
1026 "movq %rsp,%rdi\n\t"
1027 "movq %rdx,%rsi\n\t"
1028 "rep; movsq\n\t" /* copy arguments */
1029 "movq 0(%rsp),%rcx\n\t"
1030 "movq 8(%rsp),%rdx\n\t"
1031 "movq 16(%rsp),%r8\n\t"
1032 "movq 24(%rsp),%r9\n\t"
1033 "movq %rcx,%xmm0\n\t"
1034 "movq %rdx,%xmm1\n\t"
1035 "movq %r8,%xmm2\n\t"
1036 "movq %r9,%xmm3\n\t"
1037 "callq *%rax\n\t"
1038 "leaq -16(%rbp),%rsp\n\t" /* restore stack */
1039 "popq %rdi\n\t"
1040 __ASM_CFI(".cfi_same_value %rdi\n\t")
1041 "popq %rsi\n\t"
1042 __ASM_CFI(".cfi_same_value %rsi\n\t")
1043 __ASM_CFI(".cfi_def_cfa_register %rsp\n\t")
1044 "popq %rbp\n\t"
1045 __ASM_CFI(".cfi_adjust_cfa_offset -8\n\t")
1046 __ASM_CFI(".cfi_same_value %rbp\n\t")
1047 "ret")
1048 #else
1049 #warning call_server_func not implemented for your architecture
1050 LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned short stack_size)
1051 {
1052 FIXME("Not implemented for your architecture\n");
1053 return 0;
1054 }
1055 #endif
1056
1057 static DWORD calc_arg_size(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat)
1058 {
1059 DWORD size;
1060 switch(*pFormat)
1061 {
1062 case RPC_FC_STRUCT:
1063 size = *(const WORD*)(pFormat + 2);
1064 break;
1065 case RPC_FC_BOGUS_STRUCT:
1066 size = *(const WORD*)(pFormat + 2);
1067 if(*(const WORD*)(pFormat + 4))
1068 FIXME("Unhandled conformant description\n");
1069 break;
1070 case RPC_FC_CARRAY:
1071 case RPC_FC_CVARRAY:
1072 size = *(const WORD*)(pFormat + 2);
1073 ComputeConformance(pStubMsg, NULL, pFormat + 4, 0);
1074 size *= pStubMsg->MaxCount;
1075 break;
1076 case RPC_FC_SMFARRAY:
1077 case RPC_FC_SMVARRAY:
1078 size = *(const WORD*)(pFormat + 2);
1079 break;
1080 case RPC_FC_LGFARRAY:
1081 case RPC_FC_LGVARRAY:
1082 size = *(const DWORD*)(pFormat + 2);
1083 break;
1084 case RPC_FC_BOGUS_ARRAY:
1085 pFormat = ComputeConformance(pStubMsg, NULL, pFormat + 4, *(const WORD*)&pFormat[2]);
1086 TRACE("conformance = %ld\n", pStubMsg->MaxCount);
1087 pFormat = ComputeVariance(pStubMsg, NULL, pFormat, pStubMsg->MaxCount);
1088 size = ComplexStructSize(pStubMsg, pFormat);
1089 size *= pStubMsg->MaxCount;
1090 break;
1091 case RPC_FC_C_CSTRING:
1092 case RPC_FC_C_WSTRING:
1093 if (*pFormat == RPC_FC_C_CSTRING)
1094 size = sizeof(CHAR);
1095 else
1096 size = sizeof(WCHAR);
1097 if (pFormat[1] == RPC_FC_STRING_SIZED)
1098 ComputeConformance(pStubMsg, NULL, pFormat + 2, 0);
1099 else
1100 pStubMsg->MaxCount = 0;
1101 size *= pStubMsg->MaxCount;
1102 break;
1103 default:
1104 FIXME("Unhandled type %02x\n", *pFormat);
1105 /* fallthrough */
1106 case RPC_FC_RP:
1107 size = sizeof(void *);
1108 break;
1109 }
1110 return size;
1111 }
1112
1113 static LONG_PTR *stub_do_args(MIDL_STUB_MESSAGE *pStubMsg,
1114 PFORMAT_STRING pFormat, int phase,
1115 unsigned char *args,
1116 unsigned short number_of_params)
1117 {
1118 /* counter */
1119 unsigned short i;
1120 /* current format string offset */
1121 int current_offset = 0;
1122 /* current stack offset */
1123 unsigned short current_stack_offset = 0;
1124 /* location to put retval into */
1125 LONG_PTR *retval_ptr = NULL;
1126
1127 for (i = 0; i < number_of_params; i++)
1128 {
1129 const NDR_PARAM_OIF_BASETYPE *pParam =
1130 (const NDR_PARAM_OIF_BASETYPE *)&pFormat[current_offset];
1131 unsigned char *pArg;
1132
1133 current_stack_offset = pParam->stack_offset;
1134 pArg = args + current_stack_offset;
1135
1136 TRACE("param[%d]: new format\n", i);
1137 TRACE("\tparam_attributes:"); dump_RPC_FC_PROC_PF(pParam->param_attributes); TRACE("\n");
1138 TRACE("\tstack_offset: 0x%x\n", current_stack_offset);
1139 TRACE("\tmemory addr (before): %p -> %p\n", pArg, *(unsigned char **)pArg);
1140
1141 if (pParam->param_attributes.IsBasetype)
1142 {
1143 const unsigned char *pTypeFormat =
1144 &pParam->type_format_char;
1145
1146 TRACE("\tbase type: 0x%02x\n", *pTypeFormat);
1147
1148 switch (phase)
1149 {
1150 case STUBLESS_MARSHAL:
1151 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1152 {
1153 if (pParam->param_attributes.IsSimpleRef)
1154 call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1155 else
1156 call_marshaller(pStubMsg, pArg, pTypeFormat);
1157 }
1158 break;
1159 case STUBLESS_FREE:
1160 if (pParam->param_attributes.ServerAllocSize)
1161 HeapFree(GetProcessHeap(), 0, *(void **)pArg);
1162 break;
1163 case STUBLESS_INITOUT:
1164 break;
1165 case STUBLESS_UNMARSHAL:
1166 if (pParam->param_attributes.ServerAllocSize)
1167 *(void **)pArg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1168 pParam->param_attributes.ServerAllocSize * 8);
1169
1170 if (pParam->param_attributes.IsIn)
1171 {
1172 if (pParam->param_attributes.IsSimpleRef)
1173 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
1174 else
1175 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
1176 }
1177 break;
1178 case STUBLESS_CALCSIZE:
1179 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1180 {
1181 if (pParam->param_attributes.IsSimpleRef)
1182 call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1183 else
1184 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
1185 }
1186 break;
1187 default:
1188 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1189 }
1190
1191 current_offset += sizeof(NDR_PARAM_OIF_BASETYPE);
1192 }
1193 else
1194 {
1195 const NDR_PARAM_OIF_OTHER *pParamOther =
1196 (const NDR_PARAM_OIF_OTHER *)&pFormat[current_offset];
1197
1198 const unsigned char * pTypeFormat =
1199 &(pStubMsg->StubDesc->pFormatTypes[pParamOther->type_offset]);
1200
1201 TRACE("\tcomplex type 0x%02x\n", *pTypeFormat);
1202
1203 switch (phase)
1204 {
1205 case STUBLESS_MARSHAL:
1206 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1207 {
1208 if (pParam->param_attributes.IsByValue)
1209 call_marshaller(pStubMsg, pArg, pTypeFormat);
1210 else
1211 call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1212 }
1213 break;
1214 case STUBLESS_FREE:
1215 if (pParam->param_attributes.MustFree)
1216 {
1217 if (pParam->param_attributes.IsByValue)
1218 call_freer(pStubMsg, pArg, pTypeFormat);
1219 else
1220 call_freer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1221 }
1222
1223 if (pParam->param_attributes.IsOut &&
1224 !pParam->param_attributes.IsIn &&
1225 !pParam->param_attributes.IsByValue &&
1226 !pParam->param_attributes.ServerAllocSize)
1227 {
1228 if (*pTypeFormat != RPC_FC_BIND_CONTEXT)
1229 pStubMsg->pfnFree(*(void **)pArg);
1230 }
1231
1232 if (pParam->param_attributes.ServerAllocSize)
1233 HeapFree(GetProcessHeap(), 0, *(void **)pArg);
1234 break;
1235 case STUBLESS_INITOUT:
1236 if (!pParam->param_attributes.IsIn &&
1237 pParam->param_attributes.IsOut &&
1238 !pParam->param_attributes.ServerAllocSize &&
1239 !pParam->param_attributes.IsByValue)
1240 {
1241 if (*pTypeFormat == RPC_FC_BIND_CONTEXT)
1242 {
1243 NDR_SCONTEXT ctxt = NdrContextHandleInitialize(
1244 pStubMsg, pTypeFormat);
1245 *(void **)pArg = NDRSContextValue(ctxt);
1246 }
1247 else
1248 {
1249 DWORD size = calc_arg_size(pStubMsg, pTypeFormat);
1250
1251 if(size)
1252 {
1253 *(void **)pArg = NdrAllocate(pStubMsg, size);
1254 memset(*(void **)pArg, 0, size);
1255 }
1256 }
1257 }
1258 break;
1259 case STUBLESS_UNMARSHAL:
1260 if (pParam->param_attributes.ServerAllocSize)
1261 *(void **)pArg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1262 pParam->param_attributes.ServerAllocSize * 8);
1263
1264 if (pParam->param_attributes.IsIn)
1265 {
1266 if (pParam->param_attributes.IsByValue)
1267 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
1268 else
1269 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
1270 }
1271 break;
1272 case STUBLESS_CALCSIZE:
1273 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1274 {
1275 if (pParam->param_attributes.IsByValue)
1276 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
1277 else
1278 call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1279 }
1280 break;
1281 default:
1282 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1283 }
1284
1285 current_offset += sizeof(NDR_PARAM_OIF_OTHER);
1286 }
1287 TRACE("\tmemory addr (after): %p -> %p\n", pArg, *(unsigned char **)pArg);
1288
1289 /* make a note of the address of the return value parameter for later */
1290 if (pParam->param_attributes.IsReturn) retval_ptr = (LONG_PTR *)pArg;
1291 }
1292
1293 return retval_ptr;
1294 }
1295
1296 static LONG_PTR *stub_do_old_args(MIDL_STUB_MESSAGE *pStubMsg,
1297 PFORMAT_STRING pFormat, int phase,
1298 unsigned char *args,
1299 unsigned short stack_size, BOOL object)
1300 {
1301 /* counter */
1302 unsigned short i;
1303 /* current format string offset */
1304 int current_offset = 0;
1305 /* current stack offset */
1306 unsigned short current_stack_offset = object ? sizeof(void *) : 0;
1307 /* location to put retval into */
1308 LONG_PTR *retval_ptr = NULL;
1309
1310 for (i = 0; TRUE; i++)
1311 {
1312 const NDR_PARAM_OI_BASETYPE *pParam =
1313 (const NDR_PARAM_OI_BASETYPE *)&pFormat[current_offset];
1314 unsigned char *pArg = args + current_stack_offset;
1315
1316 /* no more parameters; exit loop */
1317 if (current_stack_offset >= stack_size)
1318 break;
1319
1320 TRACE("param[%d]: old format\n", i);
1321 TRACE("\tparam_direction: 0x%x\n", pParam->param_direction);
1322 TRACE("\tstack_offset: 0x%x\n", current_stack_offset);
1323
1324 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE ||
1325 pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1326 {
1327 const unsigned char *pTypeFormat =
1328 &pParam->type_format_char;
1329
1330 TRACE("\tbase type 0x%02x\n", *pTypeFormat);
1331
1332 if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1333 retval_ptr = (LONG_PTR *)pArg;
1334
1335 switch (phase)
1336 {
1337 case STUBLESS_MARSHAL:
1338 if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1339 call_marshaller(pStubMsg, pArg, pTypeFormat);
1340 break;
1341 case STUBLESS_FREE:
1342 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
1343 call_freer(pStubMsg, pArg, pTypeFormat);
1344 break;
1345 case STUBLESS_INITOUT:
1346 break;
1347 case STUBLESS_UNMARSHAL:
1348 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
1349 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
1350 break;
1351 case STUBLESS_CALCSIZE:
1352 if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1353 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
1354 break;
1355 default:
1356 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1357 }
1358
1359 current_stack_offset += type_stack_size(*pTypeFormat);
1360 current_offset += sizeof(NDR_PARAM_OI_BASETYPE);
1361 }
1362 else
1363 {
1364 const NDR_PARAM_OI_OTHER *pParamOther =
1365 (const NDR_PARAM_OI_OTHER *)&pFormat[current_offset];
1366
1367 const unsigned char * pTypeFormat =
1368 &pStubMsg->StubDesc->pFormatTypes[pParamOther->type_offset];
1369 const BOOL by_value = is_by_value( pTypeFormat );
1370
1371 TRACE("\tcomplex type 0x%02x\n", *pTypeFormat);
1372
1373 if (pParam->param_direction == RPC_FC_RETURN_PARAM)
1374 retval_ptr = (LONG_PTR *)pArg;
1375
1376 switch (phase)
1377 {
1378 case STUBLESS_MARSHAL:
1379 if (pParam->param_direction == RPC_FC_OUT_PARAM ||
1380 pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1381 pParam->param_direction == RPC_FC_RETURN_PARAM)
1382 {
1383 if (!by_value) pArg = *(unsigned char **)pArg;
1384 call_marshaller(pStubMsg, pArg, pTypeFormat);
1385 }
1386 break;
1387 case STUBLESS_FREE:
1388 if (pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1389 pParam->param_direction == RPC_FC_IN_PARAM)
1390 {
1391 if (!by_value) pArg = *(unsigned char **)pArg;
1392 call_freer(pStubMsg, pArg, pTypeFormat);
1393 }
1394 else if (pParam->param_direction == RPC_FC_OUT_PARAM && !by_value)
1395 pStubMsg->pfnFree(*(void **)pArg);
1396 break;
1397 case STUBLESS_INITOUT:
1398 if (pParam->param_direction == RPC_FC_OUT_PARAM && !by_value)
1399 {
1400 DWORD size = calc_arg_size(pStubMsg, pTypeFormat);
1401
1402 if(size)
1403 {
1404 *(void **)pArg = NdrAllocate(pStubMsg, size);
1405 memset(*(void **)pArg, 0, size);
1406 }
1407 }
1408 break;
1409 case STUBLESS_UNMARSHAL:
1410 if (pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1411 pParam->param_direction == RPC_FC_IN_PARAM)
1412 {
1413 if (by_value)
1414 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
1415 else
1416 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
1417 }
1418 break;
1419 case STUBLESS_CALCSIZE:
1420 if (pParam->param_direction == RPC_FC_OUT_PARAM ||
1421 pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1422 pParam->param_direction == RPC_FC_RETURN_PARAM)
1423 {
1424 if (!by_value) pArg = *(unsigned char **)pArg;
1425 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
1426 }
1427 break;
1428 default:
1429 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1430 }
1431
1432 current_stack_offset += pParamOther->stack_size * sizeof(void *);
1433 current_offset += sizeof(NDR_PARAM_OI_OTHER);
1434 }
1435 }
1436
1437 return retval_ptr;
1438 }
1439
1440 /***********************************************************************
1441 * NdrStubCall2 [RPCRT4.@]
1442 *
1443 * Unmarshals [in] parameters, calls either a method in an object or a server
1444 * function, marshals any [out] parameters and frees any allocated data.
1445 *
1446 * NOTES
1447 * Used by stubless MIDL-generated code.
1448 */
1449 LONG WINAPI NdrStubCall2(
1450 struct IRpcStubBuffer * pThis,
1451 struct IRpcChannelBuffer * pChannel,
1452 PRPC_MESSAGE pRpcMsg,
1453 DWORD * pdwStubPhase)
1454 {
1455 const MIDL_SERVER_INFO *pServerInfo;
1456 const MIDL_STUB_DESC *pStubDesc;
1457 PFORMAT_STRING pFormat;
1458 MIDL_STUB_MESSAGE stubMsg;
1459 /* pointer to start of stack to pass into stub implementation */
1460 unsigned char * args;
1461 /* size of stack */
1462 unsigned short stack_size;
1463 /* number of parameters. optional for client to give it to us */
1464 unsigned char number_of_params = ~0;
1465 /* cache of Oif_flags from v2 procedure header */
1466 INTERPRETER_OPT_FLAGS Oif_flags = { 0 };
1467 /* cache of extension flags from NDR_PROC_HEADER_EXTS */
1468 INTERPRETER_OPT_FLAGS2 ext_flags = { 0 };
1469 /* the type of pass we are currently doing */
1470 int phase;
1471 /* header for procedure string */
1472 const NDR_PROC_HEADER *pProcHeader;
1473 /* offset in format string for start of params */
1474 int parameter_start_offset;
1475 /* current format string offset */
1476 int current_offset;
1477 /* -Oif or -Oicf generated format */
1478 BOOL bV2Format = FALSE;
1479 /* location to put retval into */
1480 LONG_PTR *retval_ptr = NULL;
1481
1482 TRACE("pThis %p, pChannel %p, pRpcMsg %p, pdwStubPhase %p\n", pThis, pChannel, pRpcMsg, pdwStubPhase);
1483
1484 if (pThis)
1485 pServerInfo = CStdStubBuffer_GetServerInfo(pThis);
1486 else
1487 pServerInfo = ((RPC_SERVER_INTERFACE *)pRpcMsg->RpcInterfaceInformation)->InterpreterInfo;
1488
1489 pStubDesc = pServerInfo->pStubDesc;
1490 pFormat = pServerInfo->ProcString + pServerInfo->FmtStringOffset[pRpcMsg->ProcNum];
1491 pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
1492
1493 TRACE("NDR Version: 0x%x\n", pStubDesc->Version);
1494
1495 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1496 {
1497 const NDR_PROC_HEADER_RPC *pProcHeader = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
1498 stack_size = pProcHeader->stack_size;
1499 current_offset = sizeof(NDR_PROC_HEADER_RPC);
1500
1501 }
1502 else
1503 {
1504 stack_size = pProcHeader->stack_size;
1505 current_offset = sizeof(NDR_PROC_HEADER);
1506 }
1507
1508 TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
1509
1510 /* binding */
1511 switch (pProcHeader->handle_type)
1512 {
1513 /* explicit binding: parse additional section */
1514 case RPC_FC_BIND_EXPLICIT:
1515 switch (pFormat[current_offset]) /* handle_type */
1516 {
1517 case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */
1518 current_offset += sizeof(NDR_EHD_PRIMITIVE);
1519 break;
1520 case RPC_FC_BIND_GENERIC: /* explicit generic */
1521 current_offset += sizeof(NDR_EHD_GENERIC);
1522 break;
1523 case RPC_FC_BIND_CONTEXT: /* explicit context */
1524 current_offset += sizeof(NDR_EHD_CONTEXT);
1525 break;
1526 default:
1527 ERR("bad explicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
1528 RpcRaiseException(RPC_X_BAD_STUB_DATA);
1529 }
1530 break;
1531 case RPC_FC_BIND_GENERIC: /* implicit generic */
1532 case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */
1533 case RPC_FC_CALLBACK_HANDLE: /* implicit callback */
1534 case RPC_FC_AUTO_HANDLE: /* implicit auto handle */
1535 break;
1536 default:
1537 ERR("bad implicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
1538 RpcRaiseException(RPC_X_BAD_STUB_DATA);
1539 }
1540
1541 bV2Format = (pStubDesc->Version >= 0x20000);
1542
1543 if (bV2Format)
1544 {
1545 const NDR_PROC_PARTIAL_OIF_HEADER *pOIFHeader =
1546 (const NDR_PROC_PARTIAL_OIF_HEADER *)&pFormat[current_offset];
1547
1548 Oif_flags = pOIFHeader->Oi2Flags;
1549 number_of_params = pOIFHeader->number_of_params;
1550
1551 current_offset += sizeof(NDR_PROC_PARTIAL_OIF_HEADER);
1552 }
1553
1554 TRACE("Oif_flags = "); dump_INTERPRETER_OPT_FLAGS(Oif_flags);
1555
1556 if (Oif_flags.HasExtensions)
1557 {
1558 const NDR_PROC_HEADER_EXTS *pExtensions =
1559 (const NDR_PROC_HEADER_EXTS *)&pFormat[current_offset];
1560 ext_flags = pExtensions->Flags2;
1561 current_offset += pExtensions->Size;
1562 }
1563
1564 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1565 NdrStubInitialize(pRpcMsg, &stubMsg, pStubDesc, pChannel);
1566 else
1567 NdrServerInitializeNew(pRpcMsg, &stubMsg, pStubDesc);
1568
1569 /* create the full pointer translation tables, if requested */
1570 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
1571 stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_SERVER);
1572
1573 /* store the RPC flags away */
1574 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1575 pRpcMsg->RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
1576
1577 /* use alternate memory allocation routines */
1578 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
1579 #if 0
1580 NdrRpcSsEnableAllocate(&stubMsg);
1581 #else
1582 FIXME("Set RPCSS memory allocation routines\n");
1583 #endif
1584
1585 if (Oif_flags.HasPipes)
1586 {
1587 FIXME("pipes not supported yet\n");
1588 RpcRaiseException(RPC_X_WRONG_STUB_VERSION); /* FIXME: remove when implemented */
1589 /* init pipes package */
1590 /* NdrPipesInitialize(...) */
1591 }
1592 if (ext_flags.HasNewCorrDesc)
1593 {
1594 /* initialize extra correlation package */
1595 FIXME("new correlation description not implemented\n");
1596 stubMsg.fHasNewCorrDesc = TRUE;
1597 }
1598
1599 /* convert strings, floating point values and endianess into our
1600 * preferred format */
1601 if ((pRpcMsg->DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
1602 NdrConvert(&stubMsg, pFormat);
1603
1604 parameter_start_offset = current_offset;
1605
1606 TRACE("allocating memory for stack of size %x\n", stack_size);
1607
1608 args = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, stack_size);
1609 stubMsg.StackTop = args; /* used by conformance of top-level objects */
1610
1611 /* add the implicit This pointer as the first arg to the function if we
1612 * are calling an object method */
1613 if (pThis)
1614 *(void **)args = ((CStdStubBuffer *)pThis)->pvServerObject;
1615
1616 for (phase = STUBLESS_UNMARSHAL; phase <= STUBLESS_FREE; phase++)
1617 {
1618 TRACE("phase = %d\n", phase);
1619 switch (phase)
1620 {
1621 case STUBLESS_CALLSERVER:
1622 /* call the server function */
1623 if (pServerInfo->ThunkTable && pServerInfo->ThunkTable[pRpcMsg->ProcNum])
1624 pServerInfo->ThunkTable[pRpcMsg->ProcNum](&stubMsg);
1625 else
1626 {
1627 SERVER_ROUTINE func;
1628 LONG_PTR retval;
1629
1630 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1631 {
1632 SERVER_ROUTINE *vtbl = *(SERVER_ROUTINE **)((CStdStubBuffer *)pThis)->pvServerObject;
1633 func = vtbl[pRpcMsg->ProcNum];
1634 }
1635 else
1636 func = pServerInfo->DispatchTable[pRpcMsg->ProcNum];
1637
1638 /* FIXME: what happens with return values that don't fit into a single register on x86? */
1639 retval = call_server_func(func, args, stack_size);
1640
1641 if (retval_ptr)
1642 {
1643 TRACE("stub implementation returned 0x%lx\n", retval);
1644 *retval_ptr = retval;
1645 }
1646 else
1647 TRACE("void stub implementation\n");
1648 }
1649
1650 stubMsg.Buffer = NULL;
1651 stubMsg.BufferLength = 0;
1652
1653 break;
1654 case STUBLESS_GETBUFFER:
1655 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1656 NdrStubGetBuffer(pThis, pChannel, &stubMsg);
1657 else
1658 {
1659 RPC_STATUS Status;
1660
1661 pRpcMsg->BufferLength = stubMsg.BufferLength;
1662 /* allocate buffer for [out] and [ret] params */
1663 Status = I_RpcGetBuffer(pRpcMsg);
1664 if (Status)
1665 RpcRaiseException(Status);
1666 stubMsg.Buffer = pRpcMsg->Buffer;
1667 }
1668 break;
1669 case STUBLESS_UNMARSHAL:
1670 case STUBLESS_INITOUT:
1671 case STUBLESS_CALCSIZE:
1672 case STUBLESS_MARSHAL:
1673 case STUBLESS_FREE:
1674 if (bV2Format)
1675 retval_ptr = stub_do_args(&stubMsg, &pFormat[parameter_start_offset],
1676 phase, args, number_of_params);
1677 else
1678 retval_ptr = stub_do_old_args(&stubMsg, &pFormat[parameter_start_offset],
1679 phase, args, stack_size,
1680 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT));
1681
1682 break;
1683 default:
1684 ERR("shouldn't reach here. phase %d\n", phase);
1685 break;
1686 }
1687 }
1688
1689 pRpcMsg->BufferLength = (unsigned int)(stubMsg.Buffer - (unsigned char *)pRpcMsg->Buffer);
1690
1691 if (ext_flags.HasNewCorrDesc)
1692 {
1693 /* free extra correlation package */
1694 /* NdrCorrelationFree(&stubMsg); */
1695 }
1696
1697 if (Oif_flags.HasPipes)
1698 {
1699 /* NdrPipesDone(...) */
1700 }
1701
1702 /* free the full pointer translation tables */
1703 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
1704 NdrFullPointerXlatFree(stubMsg.FullPtrXlatTables);
1705
1706 /* free server function stack */
1707 HeapFree(GetProcessHeap(), 0, args);
1708
1709 return S_OK;
1710 }
1711
1712 /***********************************************************************
1713 * NdrServerCall2 [RPCRT4.@]
1714 */
1715 void WINAPI NdrServerCall2(PRPC_MESSAGE pRpcMsg)
1716 {
1717 DWORD dwPhase;
1718 NdrStubCall2(NULL, NULL, pRpcMsg, &dwPhase);
1719 }
1720
1721 /***********************************************************************
1722 * NdrStubCall [RPCRT4.@]
1723 */
1724 LONG WINAPI NdrStubCall( struct IRpcStubBuffer *This, struct IRpcChannelBuffer *channel,
1725 PRPC_MESSAGE msg, DWORD *phase )
1726 {
1727 return NdrStubCall2( This, channel, msg, phase );
1728 }
1729
1730 /***********************************************************************
1731 * NdrServerCall [RPCRT4.@]
1732 */
1733 void WINAPI NdrServerCall( PRPC_MESSAGE msg )
1734 {
1735 DWORD phase;
1736 NdrStubCall( NULL, NULL, msg, &phase );
1737 }
1738
1739 struct async_call_data
1740 {
1741 MIDL_STUB_MESSAGE *pStubMsg;
1742 const NDR_PROC_HEADER *pProcHeader;
1743 PFORMAT_STRING pHandleFormat;
1744 PFORMAT_STRING pParamFormat;
1745 RPC_BINDING_HANDLE hBinding;
1746 /* size of stack */
1747 unsigned short stack_size;
1748 /* number of parameters. optional for client to give it to us */
1749 unsigned char number_of_params;
1750 /* correlation cache */
1751 ULONG_PTR NdrCorrCache[256];
1752 };
1753
1754 CLIENT_CALL_RETURN WINAPIV NdrAsyncClientCall(PMIDL_STUB_DESC pStubDesc,
1755 PFORMAT_STRING pFormat, ...)
1756 {
1757 /* pointer to start of stack where arguments start */
1758 PRPC_MESSAGE pRpcMsg;
1759 PMIDL_STUB_MESSAGE pStubMsg;
1760 RPC_ASYNC_STATE *pAsync;
1761 struct async_call_data *async_call_data;
1762 /* procedure number */
1763 unsigned short procedure_number;
1764 /* cache of Oif_flags from v2 procedure header */
1765 INTERPRETER_OPT_FLAGS Oif_flags = { 0 };
1766 /* cache of extension flags from NDR_PROC_HEADER_EXTS */
1767 INTERPRETER_OPT_FLAGS2 ext_flags = { 0 };
1768 /* the type of pass we are currently doing */
1769 int phase;
1770 /* header for procedure string */
1771 const NDR_PROC_HEADER * pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
1772 /* -Oif or -Oicf generated format */
1773 BOOL bV2Format = FALSE;
1774 LONG_PTR RetVal;
1775 __ms_va_list args;
1776
1777 TRACE("pStubDesc %p, pFormat %p, ...\n", pStubDesc, pFormat);
1778
1779 /* Later NDR language versions probably won't be backwards compatible */
1780 if (pStubDesc->Version > 0x50002)
1781 {
1782 FIXME("Incompatible stub description version: 0x%x\n", pStubDesc->Version);
1783 RpcRaiseException(RPC_X_WRONG_STUB_VERSION);
1784 }
1785
1786 async_call_data = I_RpcAllocate(sizeof(*async_call_data) + sizeof(MIDL_STUB_MESSAGE) + sizeof(RPC_MESSAGE));
1787 if (!async_call_data) RpcRaiseException(ERROR_OUTOFMEMORY);
1788 async_call_data->number_of_params = ~0;
1789 async_call_data->pProcHeader = pProcHeader;
1790
1791 async_call_data->pStubMsg = pStubMsg = (PMIDL_STUB_MESSAGE)(async_call_data + 1);
1792 pRpcMsg = (PRPC_MESSAGE)(pStubMsg + 1);
1793
1794 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1795 {
1796 const NDR_PROC_HEADER_RPC *pProcHeader = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
1797 async_call_data->stack_size = pProcHeader->stack_size;
1798 procedure_number = pProcHeader->proc_num;
1799 pFormat += sizeof(NDR_PROC_HEADER_RPC);
1800 }
1801 else
1802 {
1803 async_call_data->stack_size = pProcHeader->stack_size;
1804 procedure_number = pProcHeader->proc_num;
1805 pFormat += sizeof(NDR_PROC_HEADER);
1806 }
1807 TRACE("stack size: 0x%x\n", async_call_data->stack_size);
1808 TRACE("proc num: %d\n", procedure_number);
1809
1810 /* create the full pointer translation tables, if requested */
1811 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
1812 pStubMsg->FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
1813
1814 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1815 {
1816 ERR("objects not supported\n");
1817 I_RpcFree(async_call_data);
1818 RpcRaiseException(RPC_X_BAD_STUB_DATA);
1819 }
1820
1821 NdrClientInitializeNew(pRpcMsg, pStubMsg, pStubDesc, procedure_number);
1822
1823 TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
1824 TRACE("MIDL stub version = 0x%x\n", pStubDesc->MIDLVersion);
1825
1826 /* needed for conformance of top-level objects */
1827 pStubMsg->StackTop = I_RpcAllocate(async_call_data->stack_size);
1828 __ms_va_start( args, pFormat );
1829 memcpy(pStubMsg->StackTop, va_arg( args, unsigned char * ), async_call_data->stack_size);
1830 __ms_va_end( args );
1831
1832 pAsync = *(RPC_ASYNC_STATE **)pStubMsg->StackTop;
1833 pAsync->StubInfo = async_call_data;
1834 async_call_data->pHandleFormat = pFormat;
1835
1836 pFormat = client_get_handle(pStubMsg, pProcHeader, async_call_data->pHandleFormat, &async_call_data->hBinding);
1837 if (!pFormat) goto done;
1838
1839 bV2Format = (pStubDesc->Version >= 0x20000);
1840
1841 if (bV2Format)
1842 {
1843 const NDR_PROC_PARTIAL_OIF_HEADER *pOIFHeader =
1844 (const NDR_PROC_PARTIAL_OIF_HEADER *)pFormat;
1845
1846 Oif_flags = pOIFHeader->Oi2Flags;
1847 async_call_data->number_of_params = pOIFHeader->number_of_params;
1848
1849 pFormat += sizeof(NDR_PROC_PARTIAL_OIF_HEADER);
1850 }
1851
1852 TRACE("Oif_flags = "); dump_INTERPRETER_OPT_FLAGS(Oif_flags);
1853
1854 if (Oif_flags.HasExtensions)
1855 {
1856 const NDR_PROC_HEADER_EXTS *pExtensions =
1857 (const NDR_PROC_HEADER_EXTS *)pFormat;
1858 ext_flags = pExtensions->Flags2;
1859 pFormat += pExtensions->Size;
1860 }
1861
1862 async_call_data->pParamFormat = pFormat;
1863
1864 pStubMsg->BufferLength = 0;
1865
1866 /* store the RPC flags away */
1867 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1868 pRpcMsg->RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
1869
1870 /* use alternate memory allocation routines */
1871 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
1872 NdrRpcSmSetClientToOsf(pStubMsg);
1873
1874 if (Oif_flags.HasPipes)
1875 {
1876 FIXME("pipes not supported yet\n");
1877 RpcRaiseException(RPC_X_WRONG_STUB_VERSION); /* FIXME: remove when implemented */
1878 /* init pipes package */
1879 /* NdrPipesInitialize(...) */
1880 }
1881 if (ext_flags.HasNewCorrDesc)
1882 {
1883 /* initialize extra correlation package */
1884 NdrCorrelationInitialize(pStubMsg, async_call_data->NdrCorrCache, sizeof(async_call_data->NdrCorrCache), 0);
1885 }
1886
1887 /* order of phases:
1888 * 1. PROXY_CALCSIZE - calculate the buffer size
1889 * 2. PROXY_GETBUFFER - allocate the buffer
1890 * 3. PROXY_MARHSAL - marshal [in] params into the buffer
1891 * 4. PROXY_SENDRECEIVE - send buffer
1892 * Then in NdrpCompleteAsyncClientCall:
1893 * 1. PROXY_SENDRECEIVE - receive buffer
1894 * 2. PROXY_UNMARHSAL - unmarshal [out] params from buffer
1895 */
1896 for (phase = PROXY_CALCSIZE; phase <= PROXY_SENDRECEIVE; phase++)
1897 {
1898 RPC_STATUS status;
1899 TRACE("phase = %d\n", phase);
1900 switch (phase)
1901 {
1902 case PROXY_GETBUFFER:
1903 /* allocate the buffer */
1904 if (Oif_flags.HasPipes)
1905 /* NdrGetPipeBuffer(...) */
1906 FIXME("pipes not supported yet\n");
1907 else
1908 {
1909 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
1910 #if 0
1911 NdrNsGetBuffer(pStubMsg, pStubMsg->BufferLength, async_call_data->hBinding);
1912 #else
1913 FIXME("using auto handle - call NdrNsGetBuffer when it gets implemented\n");
1914 #endif
1915 else
1916 NdrGetBuffer(pStubMsg, pStubMsg->BufferLength, async_call_data->hBinding);
1917 }
1918 pRpcMsg->RpcFlags |= RPC_BUFFER_ASYNC;
1919 status = I_RpcAsyncSetHandle(pRpcMsg, pAsync);
1920 if (status != RPC_S_OK)
1921 RpcRaiseException(status);
1922 break;
1923 case PROXY_SENDRECEIVE:
1924 pRpcMsg->RpcFlags |= RPC_BUFFER_ASYNC;
1925 /* send the [in] params only */
1926 if (Oif_flags.HasPipes)
1927 /* NdrPipesSend(...) */
1928 FIXME("pipes not supported yet\n");
1929 else
1930 {
1931 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
1932 #if 0
1933 NdrNsSend(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
1934 #else
1935 FIXME("using auto handle - call NdrNsSend when it gets implemented\n");
1936 #endif
1937 else
1938 {
1939 pStubMsg->RpcMsg->BufferLength = pStubMsg->Buffer - (unsigned char *)pStubMsg->RpcMsg->Buffer;
1940 status = I_RpcSend(pStubMsg->RpcMsg);
1941 if (status != RPC_S_OK)
1942 RpcRaiseException(status);
1943 }
1944 }
1945
1946 break;
1947 case PROXY_CALCSIZE:
1948 case PROXY_MARSHAL:
1949 if (bV2Format)
1950 client_do_args(pStubMsg, pFormat, phase, pStubMsg->StackTop,
1951 async_call_data->number_of_params, NULL);
1952 else
1953 client_do_args_old_format(pStubMsg, pFormat, phase,
1954 pStubMsg->StackTop, async_call_data->stack_size, NULL,
1955 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT), FALSE);
1956 break;
1957 default:
1958 ERR("shouldn't reach here. phase %d\n", phase);
1959 break;
1960 }
1961 }
1962
1963 done:
1964 TRACE("returning 0\n");
1965 RetVal = 0;
1966 return *(CLIENT_CALL_RETURN *)&RetVal;
1967 }
1968
1969 RPC_STATUS NdrpCompleteAsyncClientCall(RPC_ASYNC_STATE *pAsync, void *Reply)
1970 {
1971 /* pointer to start of stack where arguments start */
1972 PMIDL_STUB_MESSAGE pStubMsg;
1973 struct async_call_data *async_call_data;
1974 /* the type of pass we are currently doing */
1975 int phase;
1976 /* header for procedure string */
1977 const NDR_PROC_HEADER * pProcHeader;
1978 /* -Oif or -Oicf generated format */
1979 BOOL bV2Format;
1980 RPC_STATUS status = RPC_S_OK;
1981
1982 if (!pAsync->StubInfo)
1983 return RPC_S_INVALID_ASYNC_HANDLE;
1984
1985 async_call_data = pAsync->StubInfo;
1986 pStubMsg = async_call_data->pStubMsg;
1987 pProcHeader = async_call_data->pProcHeader;
1988
1989 bV2Format = (pStubMsg->StubDesc->Version >= 0x20000);
1990
1991 /* order of phases:
1992 * 1. PROXY_CALCSIZE - calculate the buffer size
1993 * 2. PROXY_GETBUFFER - allocate the buffer
1994 * 3. PROXY_MARHSAL - marshal [in] params into the buffer
1995 * 4. PROXY_SENDRECEIVE - send buffer
1996 * Then in NdrpCompleteAsyncClientCall:
1997 * 1. PROXY_SENDRECEIVE - receive buffer
1998 * 2. PROXY_UNMARHSAL - unmarshal [out] params from buffer
1999 */
2000 for (phase = PROXY_SENDRECEIVE; phase <= PROXY_UNMARSHAL; phase++)
2001 {
2002 switch (phase)
2003 {
2004 case PROXY_SENDRECEIVE:
2005 pStubMsg->RpcMsg->RpcFlags |= RPC_BUFFER_ASYNC;
2006 /* receive the [out] params */
2007 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
2008 #if 0
2009 NdrNsReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
2010 #else
2011 FIXME("using auto handle - call NdrNsReceive when it gets implemented\n");
2012 #endif
2013 else
2014 {
2015 status = I_RpcReceive(pStubMsg->RpcMsg);
2016 if (status != RPC_S_OK)
2017 goto cleanup;
2018 pStubMsg->BufferLength = pStubMsg->RpcMsg->BufferLength;
2019 pStubMsg->BufferStart = pStubMsg->RpcMsg->Buffer;
2020 pStubMsg->BufferEnd = pStubMsg->BufferStart + pStubMsg->BufferLength;
2021 pStubMsg->Buffer = pStubMsg->BufferStart;
2022 }
2023
2024 /* convert strings, floating point values and endianess into our
2025 * preferred format */
2026 #if 0
2027 if ((pStubMsg->RpcMsg.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
2028 NdrConvert(pStubMsg, pFormat);
2029 #endif
2030
2031 break;
2032 case PROXY_UNMARSHAL:
2033 if (bV2Format)
2034 client_do_args(pStubMsg, async_call_data->pParamFormat, phase, pStubMsg->StackTop,
2035 async_call_data->number_of_params, Reply);
2036 else
2037 client_do_args_old_format(pStubMsg, async_call_data->pParamFormat, phase,
2038 pStubMsg->StackTop, async_call_data->stack_size, Reply, FALSE, FALSE);
2039 break;
2040 default:
2041 ERR("shouldn't reach here. phase %d\n", phase);
2042 break;
2043 }
2044 }
2045
2046 cleanup:
2047 if (pStubMsg->fHasNewCorrDesc)
2048 {
2049 /* free extra correlation package */
2050 NdrCorrelationFree(pStubMsg);
2051 }
2052
2053 /* free the full pointer translation tables */
2054 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
2055 NdrFullPointerXlatFree(pStubMsg->FullPtrXlatTables);
2056
2057 /* free marshalling buffer */
2058 NdrFreeBuffer(pStubMsg);
2059 client_free_handle(pStubMsg, pProcHeader, async_call_data->pHandleFormat, async_call_data->hBinding);
2060
2061 I_RpcFree(pStubMsg->StackTop);
2062 I_RpcFree(async_call_data);
2063
2064 TRACE("-- 0x%x\n", status);
2065 return status;
2066 }
2067
2068 RPCRTAPI LONG RPC_ENTRY NdrAsyncStubCall(struct IRpcStubBuffer* pThis,
2069 struct IRpcChannelBuffer* pChannel, PRPC_MESSAGE pRpcMsg,
2070 DWORD * pdwStubPhase)
2071 {
2072 FIXME("unimplemented, expect crash!\n");
2073 return 0;
2074 }
Maarten's multimedia branch