projects / reactos.git / blob
? search:


8cb5f2b5e45a92b45ba4a7823ad773bc58e23b58
[reactos.git] / reactos / dll / win32 / rpcrt4 / ndr_stubless.c
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 if ((pDesc->flags & NDR_CONTEXT_HANDLE_CANNOT_BE_NULL) &&
195 !context_handle)
196 {
197 ERR("null context handle isn't allowed\n");
198 RpcRaiseException(RPC_X_SS_IN_NULL_CONTEXT);
199 return NULL;
200 }
201 *phBinding = NDRCContextBinding(context_handle);
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 pArg = *(unsigned char **)pArg;
319
320 TRACE("\tbase type: 0x%02x\n", *pTypeFormat);
321
322 switch (phase)
323 {
324 case PROXY_CALCSIZE:
325 if (pParam->param_attributes.IsIn)
326 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
327 break;
328 case PROXY_MARSHAL:
329 if (pParam->param_attributes.IsIn)
330 call_marshaller(pStubMsg, pArg, pTypeFormat);
331 break;
332 case PROXY_UNMARSHAL:
333 if (pParam->param_attributes.IsOut)
334 {
335 if (pParam->param_attributes.IsReturn)
336 call_unmarshaller(pStubMsg, &pRetVal, pTypeFormat, 0);
337 else
338 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
339 TRACE("pRetVal = %p\n", pRetVal);
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)
390 call_unmarshaller(pStubMsg, &pRetVal, pTypeFormat, 0);
391 else if (pParam->param_attributes.IsByValue)
392 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
393 else
394 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
395 }
396 break;
397 default:
398 RpcRaiseException(RPC_S_INTERNAL_ERROR);
399 }
400
401 current_offset += sizeof(NDR_PARAM_OIF_OTHER);
402 }
403 TRACE("\tmemory addr (after): %p\n", pArg);
404 }
405 }
406
407 static unsigned int type_stack_size(unsigned char fc)
408 {
409 switch (fc)
410 {
411 case RPC_FC_BYTE:
412 case RPC_FC_CHAR:
413 case RPC_FC_SMALL:
414 case RPC_FC_USMALL:
415 return sizeof(char);
416 case RPC_FC_WCHAR:
417 case RPC_FC_SHORT:
418 case RPC_FC_USHORT:
419 return sizeof(short);
420 case RPC_FC_LONG:
421 case RPC_FC_ULONG:
422 case RPC_FC_ENUM16:
423 case RPC_FC_ENUM32:
424 return sizeof(int);
425 case RPC_FC_FLOAT:
426 return sizeof(float);
427 case RPC_FC_DOUBLE:
428 return sizeof(double);
429 case RPC_FC_HYPER:
430 return sizeof(ULONGLONG);
431 case RPC_FC_ERROR_STATUS_T:
432 return sizeof(error_status_t);
433 case RPC_FC_IGNORE:
434 return sizeof(void *);
435 default:
436 ERR("invalid base type 0x%x\n", fc);
437 RpcRaiseException(RPC_S_INTERNAL_ERROR);
438 }
439 }
440
441 void client_do_args_old_format(PMIDL_STUB_MESSAGE pStubMsg,
442 PFORMAT_STRING pFormat, int phase, unsigned char *args,
443 unsigned short stack_size,
444 unsigned char *pRetVal, BOOL object_proc, BOOL ignore_retval)
445 {
446 /* current format string offset */
447 int current_offset = 0;
448 /* current stack offset */
449 unsigned short current_stack_offset = 0;
450 /* counter */
451 unsigned short i;
452
453 /* NOTE: V1 style format doesn't terminate on the number_of_params
454 * condition as it doesn't have this attribute. Instead it
455 * terminates when the stack size given in the header is exceeded.
456 */
457 for (i = 0; TRUE; i++)
458 {
459 const NDR_PARAM_OI_BASETYPE *pParam =
460 (const NDR_PARAM_OI_BASETYPE *)&pFormat[current_offset];
461 /* note: current_stack_offset starts after the This pointer
462 * if present, so adjust this */
463 unsigned short current_stack_offset_adjusted = current_stack_offset +
464 (object_proc ? sizeof(void *) : 0);
465 unsigned char * pArg = ARG_FROM_OFFSET(args, current_stack_offset_adjusted);
466
467 /* no more parameters; exit loop */
468 if (current_stack_offset_adjusted >= stack_size)
469 break;
470
471 TRACE("param[%d]: old format\n", i);
472 TRACE("\tparam_direction: 0x%x\n", pParam->param_direction);
473 TRACE("\tstack_offset: 0x%x\n", current_stack_offset_adjusted);
474 TRACE("\tmemory addr (before): %p\n", pArg);
475
476 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE ||
477 pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
478 {
479 const unsigned char * pTypeFormat =
480 &pParam->type_format_char;
481
482 TRACE("\tbase type 0x%02x\n", *pTypeFormat);
483
484 switch (phase)
485 {
486 case PROXY_CALCSIZE:
487 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
488 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
489 break;
490 case PROXY_MARSHAL:
491 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
492 call_marshaller(pStubMsg, pArg, pTypeFormat);
493 break;
494 case PROXY_UNMARSHAL:
495 if (!ignore_retval &&
496 pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
497 {
498 if (pParam->param_direction & RPC_FC_RETURN_PARAM)
499 call_unmarshaller(pStubMsg, &pRetVal, pTypeFormat, 0);
500 else
501 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
502 }
503 break;
504 default:
505 RpcRaiseException(RPC_S_INTERNAL_ERROR);
506 }
507
508 current_stack_offset += type_stack_size(*pTypeFormat);
509 current_offset += sizeof(NDR_PARAM_OI_BASETYPE);
510 }
511 else
512 {
513 const NDR_PARAM_OI_OTHER *pParamOther =
514 (const NDR_PARAM_OI_OTHER *)&pFormat[current_offset];
515
516 const unsigned char *pTypeFormat =
517 &pStubMsg->StubDesc->pFormatTypes[pParamOther->type_offset];
518
519 TRACE("\tcomplex type 0x%02x\n", *pTypeFormat);
520
521 switch (phase)
522 {
523 case PROXY_CALCSIZE:
524 if (pParam->param_direction == RPC_FC_IN_PARAM ||
525 pParam->param_direction & RPC_FC_IN_OUT_PARAM)
526 call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
527 break;
528 case PROXY_MARSHAL:
529 if (pParam->param_direction == RPC_FC_IN_PARAM ||
530 pParam->param_direction & RPC_FC_IN_OUT_PARAM)
531 call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
532 break;
533 case PROXY_UNMARSHAL:
534 if (pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
535 pParam->param_direction == RPC_FC_OUT_PARAM)
536 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
537 else if (pParam->param_direction == RPC_FC_RETURN_PARAM)
538 call_unmarshaller(pStubMsg, (unsigned char **)pRetVal, pTypeFormat, 0);
539 break;
540 default:
541 RpcRaiseException(RPC_S_INTERNAL_ERROR);
542 }
543
544 current_stack_offset += pParamOther->stack_size * sizeof(INT);
545 current_offset += sizeof(NDR_PARAM_OI_OTHER);
546 }
547 TRACE("\tmemory addr (after): %p\n", pArg);
548 }
549 }
550
551 /* the return type should be CLIENT_CALL_RETURN, but this is incompatible
552 * with the way gcc returns structures. "void *" should be the largest type
553 * that MIDL should allow you to return anyway */
554 LONG_PTR WINAPIV NdrClientCall2(PMIDL_STUB_DESC pStubDesc, PFORMAT_STRING pFormat, ...)
555 {
556 /* pointer to start of stack where arguments start */
557 RPC_MESSAGE rpcMsg;
558 MIDL_STUB_MESSAGE stubMsg;
559 handle_t hBinding = NULL;
560 /* procedure number */
561 unsigned short procedure_number;
562 /* size of stack */
563 unsigned short stack_size;
564 /* number of parameters. optional for client to give it to us */
565 unsigned char number_of_params = ~0;
566 /* cache of Oif_flags from v2 procedure header */
567 INTERPRETER_OPT_FLAGS Oif_flags = { 0 };
568 /* cache of extension flags from NDR_PROC_HEADER_EXTS */
569 INTERPRETER_OPT_FLAGS2 ext_flags = { 0 };
570 /* the type of pass we are currently doing */
571 int phase;
572 /* header for procedure string */
573 const NDR_PROC_HEADER * pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
574 /* -Oif or -Oicf generated format */
575 BOOL bV2Format = FALSE;
576 /* the value to return to the client from the remote procedure */
577 LONG_PTR RetVal = 0;
578 /* the pointer to the object when in OLE mode */
579 void * This = NULL;
580 PFORMAT_STRING pHandleFormat;
581 /* correlation cache */
582 unsigned long NdrCorrCache[256];
583
584 TRACE("pStubDesc %p, pFormat %p, ...\n", pStubDesc, pFormat);
585
586 TRACE("NDR Version: 0x%x\n", pStubDesc->Version);
587
588 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
589 {
590 const NDR_PROC_HEADER_RPC *pProcHeader = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
591 stack_size = pProcHeader->stack_size;
592 procedure_number = pProcHeader->proc_num;
593 pFormat += sizeof(NDR_PROC_HEADER_RPC);
594 }
595 else
596 {
597 stack_size = pProcHeader->stack_size;
598 procedure_number = pProcHeader->proc_num;
599 pFormat += sizeof(NDR_PROC_HEADER);
600 }
601 TRACE("stack size: 0x%x\n", stack_size);
602 TRACE("proc num: %d\n", procedure_number);
603
604 /* create the full pointer translation tables, if requested */
605 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
606 stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
607
608 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
609 {
610 /* object is always the first argument */
611 This = **(void *const **)(&pFormat+1);
612 NdrProxyInitialize(This, &rpcMsg, &stubMsg, pStubDesc, procedure_number);
613 }
614 else
615 NdrClientInitializeNew(&rpcMsg, &stubMsg, pStubDesc, procedure_number);
616
617 TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
618 TRACE("MIDL stub version = 0x%x\n", pStubDesc->MIDLVersion);
619
620 /* needed for conformance of top-level objects */
621 #ifdef __i386__
622 stubMsg.StackTop = *(unsigned char **)(&pFormat+1);
623 #else
624 # warning Stack not retrieved for your CPU architecture
625 #endif
626
627 pHandleFormat = pFormat;
628
629 /* we only need a handle if this isn't an object method */
630 if (!(pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT))
631 {
632 pFormat = client_get_handle(&stubMsg, pProcHeader, pHandleFormat, &hBinding);
633 if (!pFormat) return 0;
634 }
635
636 bV2Format = (pStubDesc->Version >= 0x20000);
637
638 if (bV2Format)
639 {
640 const NDR_PROC_PARTIAL_OIF_HEADER *pOIFHeader =
641 (const NDR_PROC_PARTIAL_OIF_HEADER *)pFormat;
642
643 Oif_flags = pOIFHeader->Oi2Flags;
644 number_of_params = pOIFHeader->number_of_params;
645
646 pFormat += sizeof(NDR_PROC_PARTIAL_OIF_HEADER);
647 }
648
649 TRACE("Oif_flags = "); dump_INTERPRETER_OPT_FLAGS(Oif_flags);
650
651 if (Oif_flags.HasExtensions)
652 {
653 const NDR_PROC_HEADER_EXTS *pExtensions =
654 (const NDR_PROC_HEADER_EXTS *)pFormat;
655 ext_flags = pExtensions->Flags2;
656 pFormat += pExtensions->Size;
657 }
658
659 stubMsg.BufferLength = 0;
660
661 /* store the RPC flags away */
662 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
663 rpcMsg.RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
664
665 /* use alternate memory allocation routines */
666 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
667 NdrRpcSmSetClientToOsf(&stubMsg);
668
669 if (Oif_flags.HasPipes)
670 {
671 FIXME("pipes not supported yet\n");
672 RpcRaiseException(RPC_X_WRONG_STUB_VERSION); /* FIXME: remove when implemented */
673 /* init pipes package */
674 /* NdrPipesInitialize(...) */
675 }
676 if (ext_flags.HasNewCorrDesc)
677 {
678 /* initialize extra correlation package */
679 NdrCorrelationInitialize(&stubMsg, NdrCorrCache, sizeof(NdrCorrCache), 0);
680 }
681
682 /* order of phases:
683 * 1. PROXY_CALCSIZE - calculate the buffer size
684 * 2. PROXY_GETBUFFER - allocate the buffer
685 * 3. PROXY_MARHSAL - marshal [in] params into the buffer
686 * 4. PROXY_SENDRECEIVE - send/receive buffer
687 * 5. PROXY_UNMARHSAL - unmarshal [out] params from buffer
688 */
689 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
690 {
691 __TRY
692 {
693 for (phase = PROXY_CALCSIZE; phase <= PROXY_UNMARSHAL; phase++)
694 {
695 TRACE("phase = %d\n", phase);
696 switch (phase)
697 {
698 case PROXY_GETBUFFER:
699 /* allocate the buffer */
700 NdrProxyGetBuffer(This, &stubMsg);
701 break;
702 case PROXY_SENDRECEIVE:
703 /* send the [in] params and receive the [out] and [retval]
704 * params */
705 NdrProxySendReceive(This, &stubMsg);
706
707 /* convert strings, floating point values and endianess into our
708 * preferred format */
709 if ((rpcMsg.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
710 NdrConvert(&stubMsg, pFormat);
711
712 break;
713 case PROXY_CALCSIZE:
714 case PROXY_MARSHAL:
715 case PROXY_UNMARSHAL:
716 if (bV2Format)
717 client_do_args(&stubMsg, pFormat, phase, stubMsg.StackTop,
718 number_of_params, (unsigned char *)&RetVal);
719 else
720 client_do_args_old_format(&stubMsg, pFormat, phase,
721 stubMsg.StackTop, stack_size, (unsigned char *)&RetVal,
722 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT), FALSE);
723 break;
724 default:
725 ERR("shouldn't reach here. phase %d\n", phase);
726 break;
727 }
728 }
729 }
730 __EXCEPT_ALL
731 {
732 RetVal = NdrProxyErrorHandler(GetExceptionCode());
733 }
734 __ENDTRY
735 }
736 else
737 {
738 /* order of phases:
739 * 1. PROXY_CALCSIZE - calculate the buffer size
740 * 2. PROXY_GETBUFFER - allocate the buffer
741 * 3. PROXY_MARHSAL - marshal [in] params into the buffer
742 * 4. PROXY_SENDRECEIVE - send/receive buffer
743 * 5. PROXY_UNMARHSAL - unmarshal [out] params from buffer
744 */
745 for (phase = PROXY_CALCSIZE; phase <= PROXY_UNMARSHAL; phase++)
746 {
747 TRACE("phase = %d\n", phase);
748 switch (phase)
749 {
750 case PROXY_GETBUFFER:
751 /* allocate the buffer */
752 if (Oif_flags.HasPipes)
753 /* NdrGetPipeBuffer(...) */
754 FIXME("pipes not supported yet\n");
755 else
756 {
757 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
758 #if 0
759 NdrNsGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
760 #else
761 FIXME("using auto handle - call NdrNsGetBuffer when it gets implemented\n");
762 #endif
763 else
764 NdrGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
765 }
766 break;
767 case PROXY_SENDRECEIVE:
768 /* send the [in] params and receive the [out] and [retval]
769 * params */
770 if (Oif_flags.HasPipes)
771 /* NdrPipesSendReceive(...) */
772 FIXME("pipes not supported yet\n");
773 else
774 {
775 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
776 #if 0
777 NdrNsSendReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
778 #else
779 FIXME("using auto handle - call NdrNsSendReceive when it gets implemented\n");
780 #endif
781 else
782 NdrSendReceive(&stubMsg, stubMsg.Buffer);
783 }
784
785 /* convert strings, floating point values and endianess into our
786 * preferred format */
787 if ((rpcMsg.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
788 NdrConvert(&stubMsg, pFormat);
789
790 break;
791 case PROXY_CALCSIZE:
792 case PROXY_MARSHAL:
793 case PROXY_UNMARSHAL:
794 if (bV2Format)
795 client_do_args(&stubMsg, pFormat, phase, stubMsg.StackTop,
796 number_of_params, (unsigned char *)&RetVal);
797 else
798 client_do_args_old_format(&stubMsg, pFormat, phase,
799 stubMsg.StackTop, stack_size, (unsigned char *)&RetVal,
800 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT), FALSE);
801 break;
802 default:
803 ERR("shouldn't reach here. phase %d\n", phase);
804 break;
805 }
806 }
807 }
808
809 if (ext_flags.HasNewCorrDesc)
810 {
811 /* free extra correlation package */
812 NdrCorrelationFree(&stubMsg);
813 }
814
815 if (Oif_flags.HasPipes)
816 {
817 /* NdrPipesDone(...) */
818 }
819
820 /* free the full pointer translation tables */
821 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
822 NdrFullPointerXlatFree(stubMsg.FullPtrXlatTables);
823
824 /* free marshalling buffer */
825 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
826 NdrProxyFreeBuffer(This, &stubMsg);
827 else
828 {
829 NdrFreeBuffer(&stubMsg);
830 client_free_handle(&stubMsg, pProcHeader, pHandleFormat, hBinding);
831 }
832
833 TRACE("RetVal = 0x%lx\n", RetVal);
834
835 return RetVal;
836 }
837
838 /* Calls a function with the specified arguments, restoring the stack
839 * properly afterwards as we don't know the calling convention of the
840 * function */
841 #if defined __i386__ && defined _MSC_VER
842 __declspec(naked) LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned int stack_size)
843 {
844 __asm
845 {
846 push ebp
847 push edi ; Save registers
848 push esi
849 mov ebp, esp
850 mov eax, [ebp+16] ; Get stack size
851 sub esp, eax ; Make room in stack for arguments
852 mov edi, esp
853 mov ecx, eax
854 mov esi, [ebp+12]
855 shr ecx, 2
856 cld
857 rep movsd ; Copy dword blocks
858 call [ebp+8] ; Call function
859 lea esp, [ebp-8] ; Restore stack
860 pop esi ; Restore registers
861 pop edi
862 pop ebp
863 ret
864 }
865 }
866 #elif defined __i386__ && defined __GNUC__
867 LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned int stack_size);
868 __ASM_GLOBAL_FUNC(call_server_func,
869 "pushl %ebp\n\t"
870 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
871 __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
872 "movl %esp,%ebp\n\t"
873 __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
874 "pushl %edi\n\t" /* Save registers */
875 __ASM_CFI(".cfi_rel_offset %edi,-4\n\t")
876 "pushl %esi\n\t"
877 __ASM_CFI(".cfi_rel_offset %esi,-8\n\t")
878 "movl 16(%ebp), %eax\n\t" /* Get stack size */
879 "subl %eax, %esp\n\t" /* Make room in stack for arguments */
880 "andl $~15, %esp\n\t" /* Make sure stack has 16-byte alignment for Mac OS X */
881 "movl %esp, %edi\n\t"
882 "movl %eax, %ecx\n\t"
883 "movl 12(%ebp), %esi\n\t"
884 "shrl $2, %ecx\n\t" /* divide by 4 */
885 "cld\n\t"
886 "rep; movsl\n\t" /* Copy dword blocks */
887 "call *8(%ebp)\n\t" /* Call function */
888 "leal -8(%ebp), %esp\n\t" /* Restore stack */
889 "popl %esi\n\t" /* Restore registers */
890 __ASM_CFI(".cfi_same_value %esi\n\t")
891 "popl %edi\n\t"
892 __ASM_CFI(".cfi_same_value %edi\n\t")
893 "popl %ebp\n\t"
894 __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
895 __ASM_CFI(".cfi_same_value %ebp\n\t")
896 "ret" )
897 #else
898 #warning call_server_func not implemented for your architecture
899 LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned short stack_size)
900 {
901 FIXME("Not implemented for your architecture\n");
902 return 0;
903 }
904 #endif
905
906 static DWORD calc_arg_size(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat)
907 {
908 DWORD size;
909 switch(*pFormat)
910 {
911 case RPC_FC_STRUCT:
912 size = *(const WORD*)(pFormat + 2);
913 break;
914 case RPC_FC_CARRAY:
915 size = *(const WORD*)(pFormat + 2);
916 ComputeConformance(pStubMsg, NULL, pFormat + 4, 0);
917 size *= pStubMsg->MaxCount;
918 break;
919 case RPC_FC_SMFARRAY:
920 size = *(const WORD*)(pFormat + 2);
921 break;
922 case RPC_FC_LGFARRAY:
923 size = *(const DWORD*)(pFormat + 2);
924 break;
925 case RPC_FC_BOGUS_ARRAY:
926 pFormat = ComputeConformance(pStubMsg, NULL, pFormat + 4, *(const WORD*)&pFormat[2]);
927 TRACE("conformance = %ld\n", pStubMsg->MaxCount);
928 pFormat = ComputeVariance(pStubMsg, NULL, pFormat, pStubMsg->MaxCount);
929 size = ComplexStructSize(pStubMsg, pFormat);
930 size *= pStubMsg->MaxCount;
931 break;
932 default:
933 FIXME("Unhandled type %02x\n", *pFormat);
934 /* fallthrough */
935 case RPC_FC_RP:
936 size = sizeof(void *);
937 break;
938 }
939 return size;
940 }
941
942 static LONG_PTR *stub_do_args(MIDL_STUB_MESSAGE *pStubMsg,
943 PFORMAT_STRING pFormat, int phase,
944 unsigned char *args,
945 unsigned short number_of_params)
946 {
947 /* counter */
948 unsigned short i;
949 /* current format string offset */
950 int current_offset = 0;
951 /* current stack offset */
952 unsigned short current_stack_offset = 0;
953 /* location to put retval into */
954 LONG_PTR *retval_ptr = NULL;
955
956 for (i = 0; i < number_of_params; i++)
957 {
958 const NDR_PARAM_OIF_BASETYPE *pParam =
959 (const NDR_PARAM_OIF_BASETYPE *)&pFormat[current_offset];
960 unsigned char *pArg;
961
962 current_stack_offset = pParam->stack_offset;
963 pArg = args + current_stack_offset;
964
965 TRACE("param[%d]: new format\n", i);
966 TRACE("\tparam_attributes:"); dump_RPC_FC_PROC_PF(pParam->param_attributes); TRACE("\n");
967 TRACE("\tstack_offset: 0x%x\n", current_stack_offset);
968 TRACE("\tmemory addr (before): %p -> %p\n", pArg, *(unsigned char **)pArg);
969
970 if (pParam->param_attributes.IsBasetype)
971 {
972 const unsigned char *pTypeFormat =
973 &pParam->type_format_char;
974
975 TRACE("\tbase type: 0x%02x\n", *pTypeFormat);
976
977 /* make a note of the address of the return value parameter for later */
978 if (pParam->param_attributes.IsReturn)
979 retval_ptr = (LONG_PTR *)pArg;
980
981 switch (phase)
982 {
983 case STUBLESS_MARSHAL:
984 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
985 {
986 if (pParam->param_attributes.IsSimpleRef)
987 call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
988 else
989 call_marshaller(pStubMsg, pArg, pTypeFormat);
990 }
991 break;
992 case STUBLESS_FREE:
993 if (pParam->param_attributes.ServerAllocSize)
994 HeapFree(GetProcessHeap(), 0, *(void **)pArg);
995 break;
996 case STUBLESS_INITOUT:
997 break;
998 case STUBLESS_UNMARSHAL:
999 if (pParam->param_attributes.ServerAllocSize)
1000 *(void **)pArg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1001 pParam->param_attributes.ServerAllocSize * 8);
1002
1003 if (pParam->param_attributes.IsIn)
1004 {
1005 if (pParam->param_attributes.IsSimpleRef)
1006 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
1007 else
1008 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
1009 }
1010 break;
1011 case STUBLESS_CALCSIZE:
1012 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1013 {
1014 if (pParam->param_attributes.IsSimpleRef)
1015 call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1016 else
1017 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
1018 }
1019 break;
1020 default:
1021 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1022 }
1023
1024 current_offset += sizeof(NDR_PARAM_OIF_BASETYPE);
1025 }
1026 else
1027 {
1028 const NDR_PARAM_OIF_OTHER *pParamOther =
1029 (const NDR_PARAM_OIF_OTHER *)&pFormat[current_offset];
1030
1031 const unsigned char * pTypeFormat =
1032 &(pStubMsg->StubDesc->pFormatTypes[pParamOther->type_offset]);
1033
1034 TRACE("\tcomplex type 0x%02x\n", *pTypeFormat);
1035
1036 switch (phase)
1037 {
1038 case STUBLESS_MARSHAL:
1039 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1040 {
1041 if (pParam->param_attributes.IsByValue)
1042 call_marshaller(pStubMsg, pArg, pTypeFormat);
1043 else
1044 call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1045 }
1046 break;
1047 case STUBLESS_FREE:
1048 if (pParam->param_attributes.MustFree)
1049 {
1050 if (pParam->param_attributes.IsByValue)
1051 call_freer(pStubMsg, pArg, pTypeFormat);
1052 else
1053 call_freer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1054 }
1055
1056 if (pParam->param_attributes.IsOut &&
1057 !pParam->param_attributes.IsIn &&
1058 !pParam->param_attributes.IsByValue &&
1059 !pParam->param_attributes.ServerAllocSize)
1060 {
1061 pStubMsg->pfnFree(*(void **)pArg);
1062 }
1063
1064 if (pParam->param_attributes.ServerAllocSize)
1065 HeapFree(GetProcessHeap(), 0, *(void **)pArg);
1066 break;
1067 case STUBLESS_INITOUT:
1068 if (!pParam->param_attributes.IsIn &&
1069 pParam->param_attributes.IsOut &&
1070 !pParam->param_attributes.ServerAllocSize &&
1071 !pParam->param_attributes.IsByValue)
1072 {
1073 DWORD size = calc_arg_size(pStubMsg, pTypeFormat);
1074
1075 if(size)
1076 {
1077 *(void **)pArg = NdrAllocate(pStubMsg, size);
1078 memset(*(void **)pArg, 0, size);
1079 }
1080 }
1081 break;
1082 case STUBLESS_UNMARSHAL:
1083 if (pParam->param_attributes.ServerAllocSize)
1084 *(void **)pArg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1085 pParam->param_attributes.ServerAllocSize * 8);
1086
1087 if (pParam->param_attributes.IsIn)
1088 {
1089 if (pParam->param_attributes.IsByValue)
1090 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
1091 else
1092 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
1093 }
1094 break;
1095 case STUBLESS_CALCSIZE:
1096 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1097 {
1098 if (pParam->param_attributes.IsByValue)
1099 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
1100 else
1101 call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1102 }
1103 break;
1104 default:
1105 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1106 }
1107
1108 current_offset += sizeof(NDR_PARAM_OIF_OTHER);
1109 }
1110 TRACE("\tmemory addr (after): %p -> %p\n", pArg, *(unsigned char **)pArg);
1111 }
1112
1113 return retval_ptr;
1114 }
1115
1116 static LONG_PTR *stub_do_old_args(MIDL_STUB_MESSAGE *pStubMsg,
1117 PFORMAT_STRING pFormat, int phase,
1118 unsigned char *args,
1119 unsigned short stack_size, BOOL object)
1120 {
1121 /* counter */
1122 unsigned short i;
1123 /* current format string offset */
1124 int current_offset = 0;
1125 /* current stack offset */
1126 unsigned short current_stack_offset = 0;
1127 /* location to put retval into */
1128 LONG_PTR *retval_ptr = NULL;
1129
1130 for (i = 0; TRUE; i++)
1131 {
1132 const NDR_PARAM_OI_BASETYPE *pParam =
1133 (const NDR_PARAM_OI_BASETYPE *)&pFormat[current_offset];
1134 /* note: current_stack_offset starts after the This pointer
1135 * if present, so adjust this */
1136 unsigned short current_stack_offset_adjusted = current_stack_offset +
1137 (object ? sizeof(void *) : 0);
1138 unsigned char *pArg = args + current_stack_offset_adjusted;
1139
1140 /* no more parameters; exit loop */
1141 if (current_stack_offset_adjusted >= stack_size)
1142 break;
1143
1144 TRACE("param[%d]: old format\n", i);
1145 TRACE("\tparam_direction: 0x%x\n", pParam->param_direction);
1146 TRACE("\tstack_offset: 0x%x\n", current_stack_offset_adjusted);
1147
1148 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE ||
1149 pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1150 {
1151 const unsigned char *pTypeFormat =
1152 &pParam->type_format_char;
1153
1154 TRACE("\tbase type 0x%02x\n", *pTypeFormat);
1155
1156 if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1157 retval_ptr = (LONG_PTR *)pArg;
1158
1159 switch (phase)
1160 {
1161 case STUBLESS_MARSHAL:
1162 if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1163 call_marshaller(pStubMsg, pArg, pTypeFormat);
1164 break;
1165 case STUBLESS_FREE:
1166 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
1167 call_freer(pStubMsg, pArg, pTypeFormat);
1168 break;
1169 case STUBLESS_UNMARSHAL:
1170 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
1171 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
1172 break;
1173 case STUBLESS_CALCSIZE:
1174 if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1175 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
1176 break;
1177 default:
1178 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1179 }
1180
1181 current_stack_offset += type_stack_size(*pTypeFormat);
1182 current_offset += sizeof(NDR_PARAM_OI_BASETYPE);
1183 }
1184 else
1185 {
1186 const NDR_PARAM_OI_OTHER *pParamOther =
1187 (const NDR_PARAM_OI_OTHER *)&pFormat[current_offset];
1188
1189 const unsigned char * pTypeFormat =
1190 &pStubMsg->StubDesc->pFormatTypes[pParamOther->type_offset];
1191
1192 TRACE("\tcomplex type 0x%02x\n", *pTypeFormat);
1193
1194 if (pParam->param_direction == RPC_FC_RETURN_PARAM)
1195 retval_ptr = (LONG_PTR *)pArg;
1196
1197 switch (phase)
1198 {
1199 case STUBLESS_MARSHAL:
1200 if (pParam->param_direction == RPC_FC_OUT_PARAM ||
1201 pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1202 pParam->param_direction == RPC_FC_RETURN_PARAM)
1203 call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1204 break;
1205 case STUBLESS_FREE:
1206 if (pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1207 pParam->param_direction == RPC_FC_IN_PARAM)
1208 call_freer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1209 else if (pParam->param_direction == RPC_FC_OUT_PARAM)
1210 pStubMsg->pfnFree(*(void **)pArg);
1211 break;
1212 case STUBLESS_INITOUT:
1213 if (pParam->param_direction == RPC_FC_OUT_PARAM)
1214 {
1215 DWORD size = calc_arg_size(pStubMsg, pTypeFormat);
1216
1217 if(size)
1218 {
1219 *(void **)pArg = NdrAllocate(pStubMsg, size);
1220 memset(*(void **)pArg, 0, size);
1221 }
1222 }
1223 break;
1224 case STUBLESS_UNMARSHAL:
1225 if (pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1226 pParam->param_direction == RPC_FC_IN_PARAM)
1227 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
1228 break;
1229 case STUBLESS_CALCSIZE:
1230 if (pParam->param_direction == RPC_FC_OUT_PARAM ||
1231 pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1232 pParam->param_direction == RPC_FC_RETURN_PARAM)
1233 call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1234 break;
1235 default:
1236 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1237 }
1238
1239 current_stack_offset += pParamOther->stack_size * sizeof(INT);
1240 current_offset += sizeof(NDR_PARAM_OI_OTHER);
1241 }
1242 }
1243
1244 return retval_ptr;
1245 }
1246
1247 /***********************************************************************
1248 * NdrStubCall2 [RPCRT4.@]
1249 *
1250 * Unmarshals [in] parameters, calls either a method in an object or a server
1251 * function, marshals any [out] parameters and frees any allocated data.
1252 *
1253 * NOTES
1254 * Used by stubless MIDL-generated code.
1255 */
1256 LONG WINAPI NdrStubCall2(
1257 struct IRpcStubBuffer * pThis,
1258 struct IRpcChannelBuffer * pChannel,
1259 PRPC_MESSAGE pRpcMsg,
1260 DWORD * pdwStubPhase)
1261 {
1262 const MIDL_SERVER_INFO *pServerInfo;
1263 const MIDL_STUB_DESC *pStubDesc;
1264 PFORMAT_STRING pFormat;
1265 MIDL_STUB_MESSAGE stubMsg;
1266 /* pointer to start of stack to pass into stub implementation */
1267 unsigned char * args;
1268 /* size of stack */
1269 unsigned short stack_size;
1270 /* number of parameters. optional for client to give it to us */
1271 unsigned char number_of_params = ~0;
1272 /* cache of Oif_flags from v2 procedure header */
1273 INTERPRETER_OPT_FLAGS Oif_flags = { 0 };
1274 /* cache of extension flags from NDR_PROC_HEADER_EXTS */
1275 INTERPRETER_OPT_FLAGS2 ext_flags = { 0 };
1276 /* the type of pass we are currently doing */
1277 int phase;
1278 /* header for procedure string */
1279 const NDR_PROC_HEADER *pProcHeader;
1280 /* offset in format string for start of params */
1281 int parameter_start_offset;
1282 /* current format string offset */
1283 int current_offset;
1284 /* -Oif or -Oicf generated format */
1285 BOOL bV2Format = FALSE;
1286 /* location to put retval into */
1287 LONG_PTR *retval_ptr = NULL;
1288
1289 TRACE("pThis %p, pChannel %p, pRpcMsg %p, pdwStubPhase %p\n", pThis, pChannel, pRpcMsg, pdwStubPhase);
1290
1291 if (pThis)
1292 pServerInfo = CStdStubBuffer_GetServerInfo(pThis);
1293 else
1294 pServerInfo = ((RPC_SERVER_INTERFACE *)pRpcMsg->RpcInterfaceInformation)->InterpreterInfo;
1295
1296 pStubDesc = pServerInfo->pStubDesc;
1297 pFormat = pServerInfo->ProcString + pServerInfo->FmtStringOffset[pRpcMsg->ProcNum];
1298 pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
1299
1300 TRACE("NDR Version: 0x%x\n", pStubDesc->Version);
1301
1302 /* create the full pointer translation tables, if requested */
1303 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
1304 stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_SERVER);
1305
1306 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1307 {
1308 const NDR_PROC_HEADER_RPC *pProcHeader = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
1309 stack_size = pProcHeader->stack_size;
1310 current_offset = sizeof(NDR_PROC_HEADER_RPC);
1311
1312 }
1313 else
1314 {
1315 stack_size = pProcHeader->stack_size;
1316 current_offset = sizeof(NDR_PROC_HEADER);
1317 }
1318
1319 TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
1320
1321 /* binding */
1322 switch (pProcHeader->handle_type)
1323 {
1324 /* explicit binding: parse additional section */
1325 case RPC_FC_BIND_EXPLICIT:
1326 switch (pFormat[current_offset]) /* handle_type */
1327 {
1328 case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */
1329 current_offset += sizeof(NDR_EHD_PRIMITIVE);
1330 break;
1331 case RPC_FC_BIND_GENERIC: /* explicit generic */
1332 current_offset += sizeof(NDR_EHD_GENERIC);
1333 break;
1334 case RPC_FC_BIND_CONTEXT: /* explicit context */
1335 current_offset += sizeof(NDR_EHD_CONTEXT);
1336 break;
1337 default:
1338 ERR("bad explicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
1339 RpcRaiseException(RPC_X_BAD_STUB_DATA);
1340 }
1341 break;
1342 case RPC_FC_BIND_GENERIC: /* implicit generic */
1343 case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */
1344 case RPC_FC_CALLBACK_HANDLE: /* implicit callback */
1345 case RPC_FC_AUTO_HANDLE: /* implicit auto handle */
1346 break;
1347 default:
1348 ERR("bad implicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
1349 RpcRaiseException(RPC_X_BAD_STUB_DATA);
1350 }
1351
1352 bV2Format = (pStubDesc->Version >= 0x20000);
1353
1354 if (bV2Format)
1355 {
1356 const NDR_PROC_PARTIAL_OIF_HEADER *pOIFHeader =
1357 (const NDR_PROC_PARTIAL_OIF_HEADER *)&pFormat[current_offset];
1358
1359 Oif_flags = pOIFHeader->Oi2Flags;
1360 number_of_params = pOIFHeader->number_of_params;
1361
1362 current_offset += sizeof(NDR_PROC_PARTIAL_OIF_HEADER);
1363 }
1364
1365 TRACE("Oif_flags = "); dump_INTERPRETER_OPT_FLAGS(Oif_flags);
1366
1367 if (Oif_flags.HasExtensions)
1368 {
1369 const NDR_PROC_HEADER_EXTS *pExtensions =
1370 (const NDR_PROC_HEADER_EXTS *)&pFormat[current_offset];
1371 ext_flags = pExtensions->Flags2;
1372 current_offset += pExtensions->Size;
1373 }
1374
1375 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1376 NdrStubInitialize(pRpcMsg, &stubMsg, pStubDesc, pChannel);
1377 else
1378 NdrServerInitializeNew(pRpcMsg, &stubMsg, pStubDesc);
1379
1380 /* store the RPC flags away */
1381 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1382 pRpcMsg->RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
1383
1384 /* use alternate memory allocation routines */
1385 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
1386 #if 0
1387 NdrRpcSsEnableAllocate(&stubMsg);
1388 #else
1389 FIXME("Set RPCSS memory allocation routines\n");
1390 #endif
1391
1392 if (Oif_flags.HasPipes)
1393 {
1394 FIXME("pipes not supported yet\n");
1395 RpcRaiseException(RPC_X_WRONG_STUB_VERSION); /* FIXME: remove when implemented */
1396 /* init pipes package */
1397 /* NdrPipesInitialize(...) */
1398 }
1399 if (ext_flags.HasNewCorrDesc)
1400 {
1401 /* initialize extra correlation package */
1402 FIXME("new correlation description not implemented\n");
1403 stubMsg.fHasNewCorrDesc = TRUE;
1404 }
1405
1406 /* convert strings, floating point values and endianess into our
1407 * preferred format */
1408 if ((pRpcMsg->DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
1409 NdrConvert(&stubMsg, pFormat);
1410
1411 parameter_start_offset = current_offset;
1412
1413 TRACE("allocating memory for stack of size %x\n", stack_size);
1414
1415 args = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, stack_size);
1416 stubMsg.StackTop = args; /* used by conformance of top-level objects */
1417
1418 /* add the implicit This pointer as the first arg to the function if we
1419 * are calling an object method */
1420 if (pThis)
1421 *(void **)args = ((CStdStubBuffer *)pThis)->pvServerObject;
1422
1423 /* order of phases:
1424 * 1. STUBLESS_UNMARHSAL - unmarshal [in] params from buffer
1425 * 2. STUBLESS_CALLSERVER - send/receive buffer
1426 * 3. STUBLESS_CALCSIZE - get [out] buffer size
1427 * 4. STUBLESS_GETBUFFER - allocate [out] buffer
1428 * 5. STUBLESS_MARHSAL - marshal [out] params to buffer
1429 */
1430 for (phase = STUBLESS_UNMARSHAL; phase <= STUBLESS_FREE; phase++)
1431 {
1432 TRACE("phase = %d\n", phase);
1433 switch (phase)
1434 {
1435 case STUBLESS_CALLSERVER:
1436 /* call the server function */
1437 if (pServerInfo->ThunkTable && pServerInfo->ThunkTable[pRpcMsg->ProcNum])
1438 pServerInfo->ThunkTable[pRpcMsg->ProcNum](&stubMsg);
1439 else
1440 {
1441 SERVER_ROUTINE func;
1442 LONG_PTR retval;
1443
1444 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1445 {
1446 SERVER_ROUTINE *vtbl = *(SERVER_ROUTINE **)((CStdStubBuffer *)pThis)->pvServerObject;
1447 func = vtbl[pRpcMsg->ProcNum];
1448 }
1449 else
1450 func = pServerInfo->DispatchTable[pRpcMsg->ProcNum];
1451
1452 /* FIXME: what happens with return values that don't fit into a single register on x86? */
1453 retval = call_server_func(func, args, stack_size);
1454
1455 if (retval_ptr)
1456 {
1457 TRACE("stub implementation returned 0x%lx\n", retval);
1458 *retval_ptr = retval;
1459 }
1460 else
1461 TRACE("void stub implementation\n");
1462 }
1463
1464 stubMsg.Buffer = NULL;
1465 stubMsg.BufferLength = 0;
1466
1467 break;
1468 case STUBLESS_GETBUFFER:
1469 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1470 NdrStubGetBuffer(pThis, pChannel, &stubMsg);
1471 else
1472 {
1473 RPC_STATUS Status;
1474
1475 pRpcMsg->BufferLength = stubMsg.BufferLength;
1476 /* allocate buffer for [out] and [ret] params */
1477 Status = I_RpcGetBuffer(pRpcMsg);
1478 if (Status)
1479 RpcRaiseException(Status);
1480 stubMsg.Buffer = pRpcMsg->Buffer;
1481 }
1482 break;
1483 case STUBLESS_UNMARSHAL:
1484 case STUBLESS_INITOUT:
1485 case STUBLESS_CALCSIZE:
1486 case STUBLESS_MARSHAL:
1487 case STUBLESS_FREE:
1488 if (bV2Format)
1489 retval_ptr = stub_do_args(&stubMsg, &pFormat[parameter_start_offset],
1490 phase, args, number_of_params);
1491 else
1492 retval_ptr = stub_do_old_args(&stubMsg, &pFormat[parameter_start_offset],
1493 phase, args, stack_size,
1494 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT));
1495
1496 break;
1497 default:
1498 ERR("shouldn't reach here. phase %d\n", phase);
1499 break;
1500 }
1501 }
1502
1503 pRpcMsg->BufferLength = (unsigned int)(stubMsg.Buffer - (unsigned char *)pRpcMsg->Buffer);
1504
1505 if (ext_flags.HasNewCorrDesc)
1506 {
1507 /* free extra correlation package */
1508 /* NdrCorrelationFree(&stubMsg); */
1509 }
1510
1511 if (Oif_flags.HasPipes)
1512 {
1513 /* NdrPipesDone(...) */
1514 }
1515
1516 /* free the full pointer translation tables */
1517 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
1518 NdrFullPointerXlatFree(stubMsg.FullPtrXlatTables);
1519
1520 /* free server function stack */
1521 HeapFree(GetProcessHeap(), 0, args);
1522
1523 return S_OK;
1524 }
1525
1526 /***********************************************************************
1527 * NdrServerCall2 [RPCRT4.@]
1528 */
1529 void WINAPI NdrServerCall2(PRPC_MESSAGE pRpcMsg)
1530 {
1531 DWORD dwPhase;
1532 NdrStubCall2(NULL, NULL, pRpcMsg, &dwPhase);
1533 }
1534
1535 struct async_call_data
1536 {
1537 MIDL_STUB_MESSAGE *pStubMsg;
1538 const NDR_PROC_HEADER *pProcHeader;
1539 PFORMAT_STRING pHandleFormat;
1540 PFORMAT_STRING pParamFormat;
1541 RPC_BINDING_HANDLE hBinding;
1542 /* size of stack */
1543 unsigned short stack_size;
1544 /* number of parameters. optional for client to give it to us */
1545 unsigned char number_of_params;
1546 /* correlation cache */
1547 unsigned long NdrCorrCache[256];
1548 };
1549
1550 LONG_PTR WINAPIV NdrAsyncClientCall(PMIDL_STUB_DESC pStubDesc,
1551 PFORMAT_STRING pFormat, ...)
1552 {
1553 /* pointer to start of stack where arguments start */
1554 PRPC_MESSAGE pRpcMsg;
1555 PMIDL_STUB_MESSAGE pStubMsg;
1556 RPC_ASYNC_STATE *pAsync;
1557 struct async_call_data *async_call_data;
1558 /* procedure number */
1559 unsigned short procedure_number;
1560 /* cache of Oif_flags from v2 procedure header */
1561 INTERPRETER_OPT_FLAGS Oif_flags = { 0 };
1562 /* cache of extension flags from NDR_PROC_HEADER_EXTS */
1563 INTERPRETER_OPT_FLAGS2 ext_flags = { 0 };
1564 /* the type of pass we are currently doing */
1565 int phase;
1566 /* header for procedure string */
1567 const NDR_PROC_HEADER * pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
1568 /* -Oif or -Oicf generated format */
1569 BOOL bV2Format = FALSE;
1570
1571 TRACE("pStubDesc %p, pFormat %p, ...\n", pStubDesc, pFormat);
1572
1573 /* Later NDR language versions probably won't be backwards compatible */
1574 if (pStubDesc->Version > 0x50002)
1575 {
1576 FIXME("Incompatible stub description version: 0x%x\n", pStubDesc->Version);
1577 RpcRaiseException(RPC_X_WRONG_STUB_VERSION);
1578 }
1579
1580 async_call_data = I_RpcAllocate(sizeof(*async_call_data) + sizeof(MIDL_STUB_MESSAGE) + sizeof(RPC_MESSAGE));
1581 if (!async_call_data) RpcRaiseException(ERROR_OUTOFMEMORY);
1582 async_call_data->number_of_params = ~0;
1583 async_call_data->pProcHeader = pProcHeader;
1584
1585 async_call_data->pStubMsg = pStubMsg = (PMIDL_STUB_MESSAGE)(async_call_data + 1);
1586 pRpcMsg = (PRPC_MESSAGE)(pStubMsg + 1);
1587
1588 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1589 {
1590 const NDR_PROC_HEADER_RPC *pProcHeader = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
1591 async_call_data->stack_size = pProcHeader->stack_size;
1592 procedure_number = pProcHeader->proc_num;
1593 pFormat += sizeof(NDR_PROC_HEADER_RPC);
1594 }
1595 else
1596 {
1597 async_call_data->stack_size = pProcHeader->stack_size;
1598 procedure_number = pProcHeader->proc_num;
1599 pFormat += sizeof(NDR_PROC_HEADER);
1600 }
1601 TRACE("stack size: 0x%x\n", async_call_data->stack_size);
1602 TRACE("proc num: %d\n", procedure_number);
1603
1604 /* create the full pointer translation tables, if requested */
1605 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
1606 pStubMsg->FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
1607
1608 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1609 {
1610 ERR("objects not supported\n");
1611 I_RpcFree(async_call_data);
1612 RpcRaiseException(RPC_X_BAD_STUB_DATA);
1613 }
1614
1615 NdrClientInitializeNew(pRpcMsg, pStubMsg, pStubDesc, procedure_number);
1616
1617 TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
1618 TRACE("MIDL stub version = 0x%x\n", pStubDesc->MIDLVersion);
1619
1620 /* needed for conformance of top-level objects */
1621 #ifdef __i386__
1622 pStubMsg->StackTop = I_RpcAllocate(async_call_data->stack_size);
1623 /* FIXME: this may read one more DWORD than is necessary, but it shouldn't hurt */
1624 memcpy(pStubMsg->StackTop, *(unsigned char **)(&pFormat+1), async_call_data->stack_size);
1625 #else
1626 # warning Stack not retrieved for your CPU architecture
1627 #endif
1628
1629 pAsync = *(RPC_ASYNC_STATE **)pStubMsg->StackTop;
1630 pAsync->StubInfo = async_call_data;
1631 async_call_data->pHandleFormat = pFormat;
1632
1633 pFormat = client_get_handle(pStubMsg, pProcHeader, async_call_data->pHandleFormat, &async_call_data->hBinding);
1634 if (!pFormat) return 0;
1635
1636 bV2Format = (pStubDesc->Version >= 0x20000);
1637
1638 if (bV2Format)
1639 {
1640 const NDR_PROC_PARTIAL_OIF_HEADER *pOIFHeader =
1641 (const NDR_PROC_PARTIAL_OIF_HEADER *)pFormat;
1642
1643 Oif_flags = pOIFHeader->Oi2Flags;
1644 async_call_data->number_of_params = pOIFHeader->number_of_params;
1645
1646 pFormat += sizeof(NDR_PROC_PARTIAL_OIF_HEADER);
1647 }
1648
1649 TRACE("Oif_flags = "); dump_INTERPRETER_OPT_FLAGS(Oif_flags);
1650
1651 if (Oif_flags.HasExtensions)
1652 {
1653 const NDR_PROC_HEADER_EXTS *pExtensions =
1654 (const NDR_PROC_HEADER_EXTS *)pFormat;
1655 ext_flags = pExtensions->Flags2;
1656 pFormat += pExtensions->Size;
1657 }
1658
1659 async_call_data->pParamFormat = pFormat;
1660
1661 pStubMsg->BufferLength = 0;
1662
1663 /* store the RPC flags away */
1664 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1665 pRpcMsg->RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
1666
1667 /* use alternate memory allocation routines */
1668 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
1669 NdrRpcSmSetClientToOsf(pStubMsg);
1670
1671 if (Oif_flags.HasPipes)
1672 {
1673 FIXME("pipes not supported yet\n");
1674 RpcRaiseException(RPC_X_WRONG_STUB_VERSION); /* FIXME: remove when implemented */
1675 /* init pipes package */
1676 /* NdrPipesInitialize(...) */
1677 }
1678 if (ext_flags.HasNewCorrDesc)
1679 {
1680 /* initialize extra correlation package */
1681 NdrCorrelationInitialize(pStubMsg, async_call_data->NdrCorrCache, sizeof(async_call_data->NdrCorrCache), 0);
1682 }
1683
1684 /* order of phases:
1685 * 1. PROXY_CALCSIZE - calculate the buffer size
1686 * 2. PROXY_GETBUFFER - allocate the buffer
1687 * 3. PROXY_MARHSAL - marshal [in] params into the buffer
1688 * 4. PROXY_SENDRECEIVE - send buffer
1689 * Then in NdrpCompleteAsyncClientCall:
1690 * 1. PROXY_SENDRECEIVE - receive buffer
1691 * 2. PROXY_UNMARHSAL - unmarshal [out] params from buffer
1692 */
1693 for (phase = PROXY_CALCSIZE; phase <= PROXY_SENDRECEIVE; phase++)
1694 {
1695 RPC_STATUS status;
1696 TRACE("phase = %d\n", phase);
1697 switch (phase)
1698 {
1699 case PROXY_GETBUFFER:
1700 /* allocate the buffer */
1701 if (Oif_flags.HasPipes)
1702 /* NdrGetPipeBuffer(...) */
1703 FIXME("pipes not supported yet\n");
1704 else
1705 {
1706 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
1707 #if 0
1708 NdrNsGetBuffer(pStubMsg, pStubMsg->BufferLength, async_call_data->hBinding);
1709 #else
1710 FIXME("using auto handle - call NdrNsGetBuffer when it gets implemented\n");
1711 #endif
1712 else
1713 NdrGetBuffer(pStubMsg, pStubMsg->BufferLength, async_call_data->hBinding);
1714 }
1715 pRpcMsg->RpcFlags |= RPC_BUFFER_ASYNC;
1716 status = I_RpcAsyncSetHandle(pRpcMsg, pAsync);
1717 if (status != RPC_S_OK)
1718 RpcRaiseException(status);
1719 break;
1720 case PROXY_SENDRECEIVE:
1721 pRpcMsg->RpcFlags |= RPC_BUFFER_ASYNC;
1722 /* send the [in] params only */
1723 if (Oif_flags.HasPipes)
1724 /* NdrPipesSend(...) */
1725 FIXME("pipes not supported yet\n");
1726 else
1727 {
1728 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
1729 #if 0
1730 NdrNsSend(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
1731 #else
1732 FIXME("using auto handle - call NdrNsSend when it gets implemented\n");
1733 #endif
1734 else
1735 {
1736 pStubMsg->RpcMsg->BufferLength = pStubMsg->Buffer - (unsigned char *)pStubMsg->RpcMsg->Buffer;
1737 status = I_RpcSend(pStubMsg->RpcMsg);
1738 if (status != RPC_S_OK)
1739 RpcRaiseException(status);
1740 }
1741 }
1742
1743 break;
1744 case PROXY_CALCSIZE:
1745 case PROXY_MARSHAL:
1746 if (bV2Format)
1747 client_do_args(pStubMsg, pFormat, phase, pStubMsg->StackTop,
1748 async_call_data->number_of_params, NULL);
1749 else
1750 client_do_args_old_format(pStubMsg, pFormat, phase,
1751 pStubMsg->StackTop, async_call_data->stack_size, NULL,
1752 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT), FALSE);
1753 break;
1754 default:
1755 ERR("shouldn't reach here. phase %d\n", phase);
1756 break;
1757 }
1758 }
1759
1760 TRACE("returning 0\n");
1761 return 0;
1762 }
1763
1764 RPC_STATUS NdrpCompleteAsyncClientCall(RPC_ASYNC_STATE *pAsync, void *Reply)
1765 {
1766 /* pointer to start of stack where arguments start */
1767 PMIDL_STUB_MESSAGE pStubMsg;
1768 struct async_call_data *async_call_data;
1769 /* the type of pass we are currently doing */
1770 int phase;
1771 /* header for procedure string */
1772 const NDR_PROC_HEADER * pProcHeader;
1773 /* -Oif or -Oicf generated format */
1774 BOOL bV2Format;
1775 RPC_STATUS status = RPC_S_OK;
1776
1777 if (!pAsync->StubInfo)
1778 return RPC_S_INVALID_ASYNC_HANDLE;
1779
1780 async_call_data = pAsync->StubInfo;
1781 pStubMsg = async_call_data->pStubMsg;
1782 pProcHeader = async_call_data->pProcHeader;
1783
1784 bV2Format = (pStubMsg->StubDesc->Version >= 0x20000);
1785
1786 /* order of phases:
1787 * 1. PROXY_CALCSIZE - calculate the buffer size
1788 * 2. PROXY_GETBUFFER - allocate the buffer
1789 * 3. PROXY_MARHSAL - marshal [in] params into the buffer
1790 * 4. PROXY_SENDRECEIVE - send buffer
1791 * Then in NdrpCompleteAsyncClientCall:
1792 * 1. PROXY_SENDRECEIVE - receive buffer
1793 * 2. PROXY_UNMARHSAL - unmarshal [out] params from buffer
1794 */
1795 for (phase = PROXY_SENDRECEIVE; phase <= PROXY_UNMARSHAL; phase++)
1796 {
1797 switch (phase)
1798 {
1799 case PROXY_SENDRECEIVE:
1800 pStubMsg->RpcMsg->RpcFlags |= RPC_BUFFER_ASYNC;
1801 /* receive the [out] params */
1802 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
1803 #if 0
1804 NdrNsReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
1805 #else
1806 FIXME("using auto handle - call NdrNsReceive when it gets implemented\n");
1807 #endif
1808 else
1809 {
1810 status = I_RpcReceive(pStubMsg->RpcMsg);
1811 if (status != RPC_S_OK)
1812 goto cleanup;
1813 pStubMsg->BufferLength = pStubMsg->RpcMsg->BufferLength;
1814 pStubMsg->BufferStart = pStubMsg->RpcMsg->Buffer;
1815 pStubMsg->BufferEnd = pStubMsg->BufferStart + pStubMsg->BufferLength;
1816 pStubMsg->Buffer = pStubMsg->BufferStart;
1817 }
1818
1819 /* convert strings, floating point values and endianess into our
1820 * preferred format */
1821 #if 0
1822 if ((pStubMsg->RpcMsg.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
1823 NdrConvert(pStubMsg, pFormat);
1824 #endif
1825
1826 break;
1827 case PROXY_UNMARSHAL:
1828 if (bV2Format)
1829 client_do_args(pStubMsg, async_call_data->pParamFormat, phase, pStubMsg->StackTop,
1830 async_call_data->number_of_params, Reply);
1831 else
1832 client_do_args_old_format(pStubMsg, async_call_data->pParamFormat, phase,
1833 pStubMsg->StackTop, async_call_data->stack_size, Reply, FALSE, FALSE);
1834 break;
1835 default:
1836 ERR("shouldn't reach here. phase %d\n", phase);
1837 break;
1838 }
1839 }
1840
1841 cleanup:
1842 if (pStubMsg->fHasNewCorrDesc)
1843 {
1844 /* free extra correlation package */
1845 NdrCorrelationFree(pStubMsg);
1846 }
1847
1848 /* free the full pointer translation tables */
1849 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
1850 NdrFullPointerXlatFree(pStubMsg->FullPtrXlatTables);
1851
1852 /* free marshalling buffer */
1853 NdrFreeBuffer(pStubMsg);
1854 client_free_handle(pStubMsg, pProcHeader, async_call_data->pHandleFormat, async_call_data->hBinding);
1855
1856 I_RpcFree(pStubMsg->StackTop);
1857 I_RpcFree(async_call_data);
1858
1859 TRACE("-- 0x%x\n", status);
1860 return status;
1861 }
1862
1863 RPCRTAPI LONG RPC_ENTRY NdrAsyncStubCall(struct IRpcStubBuffer* pThis,
1864 struct IRpcChannelBuffer* pChannel, PRPC_MESSAGE pRpcMsg,
1865 DWORD * pdwStubPhase)
1866 {
1867 FIXME("unimplemented, expect crash!\n");
1868 return 0;
1869 }
A free Windows-compatible Operating System