?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
crypt32: Add more tests for CertVerifyRevocation.
[wine/testsucceed.git] / dlls / rpcrt4 / ndr_stubless.c
blobbf6a7bea37af973e0be442a838c9b8d1530cbfe4
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 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_HAS_COMM_OR_FAULT))
691 {
692 __TRY
693 {
694 for (phase = PROXY_CALCSIZE; phase <= PROXY_UNMARSHAL; phase++)
695 {
696 TRACE("phase = %d\n", phase);
697 switch (phase)
698 {
699 case PROXY_GETBUFFER:
700 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
701 {
702 /* allocate the buffer */
703 NdrProxyGetBuffer(This, &stubMsg);
704 }
705 else
706 {
707 /* allocate the buffer */
708 if (Oif_flags.HasPipes)
709 /* NdrGetPipeBuffer(...) */
710 FIXME("pipes not supported yet\n");
711 else
712 {
713 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
714 #if 0
715 NdrNsGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
716 #else
717 FIXME("using auto handle - call NdrNsGetBuffer when it gets implemented\n");
718 #endif
719 else
720 NdrGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
721 }
722 }
723 break;
724 case PROXY_SENDRECEIVE:
725 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
726 {
727 /* send the [in] params and receive the [out] and [retval]
728 * params */
729 NdrProxySendReceive(This, &stubMsg);
730 }
731 else
732 {
733 /* send the [in] params and receive the [out] and [retval]
734 * params */
735 if (Oif_flags.HasPipes)
736 /* NdrPipesSendReceive(...) */
737 FIXME("pipes not supported yet\n");
738 else
739 {
740 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
741 #if 0
742 NdrNsSendReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
743 #else
744 FIXME("using auto handle - call NdrNsSendReceive when it gets implemented\n");
745 #endif
746 else
747 NdrSendReceive(&stubMsg, stubMsg.Buffer);
748 }
749 }
750
751 /* convert strings, floating point values and endianess into our
752 * preferred format */
753 if ((rpcMsg.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
754 NdrConvert(&stubMsg, pFormat);
755
756 break;
757 case PROXY_CALCSIZE:
758 case PROXY_MARSHAL:
759 case PROXY_UNMARSHAL:
760 if (bV2Format)
761 client_do_args(&stubMsg, pFormat, phase, stubMsg.StackTop,
762 number_of_params, (unsigned char *)&RetVal);
763 else
764 client_do_args_old_format(&stubMsg, pFormat, phase,
765 stubMsg.StackTop, stack_size, (unsigned char *)&RetVal,
766 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT), FALSE);
767 break;
768 default:
769 ERR("shouldn't reach here. phase %d\n", phase);
770 break;
771 }
772 }
773 }
774 __EXCEPT_ALL
775 {
776 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
777 RetVal = NdrProxyErrorHandler(GetExceptionCode());
778 else
779 {
780 const COMM_FAULT_OFFSETS *comm_fault_offsets = &pStubDesc->CommFaultOffsets[procedure_number];
781 ULONG *comm_status;
782 ULONG *fault_status;
783
784 TRACE("comm_fault_offsets = {0x%hx, 0x%hx}\n", comm_fault_offsets->CommOffset, comm_fault_offsets->FaultOffset);
785
786 if (comm_fault_offsets->CommOffset == -1)
787 comm_status = (ULONG *)&RetVal;
788 else if (comm_fault_offsets->CommOffset >= 0)
789 comm_status = *(ULONG **)ARG_FROM_OFFSET(stubMsg.StackTop, comm_fault_offsets->CommOffset);
790 else
791 comm_status = NULL;
792
793 if (comm_fault_offsets->FaultOffset == -1)
794 fault_status = (ULONG *)&RetVal;
795 else if (comm_fault_offsets->FaultOffset >= 0)
796 fault_status = *(ULONG **)ARG_FROM_OFFSET(stubMsg.StackTop, comm_fault_offsets->CommOffset);
797 else
798 fault_status = NULL;
799
800 NdrMapCommAndFaultStatus(&stubMsg, comm_status, fault_status,
801 GetExceptionCode());
802 }
803 }
804 __ENDTRY
805 }
806 else
807 {
808 /* order of phases:
809 * 1. PROXY_CALCSIZE - calculate the buffer size
810 * 2. PROXY_GETBUFFER - allocate the buffer
811 * 3. PROXY_MARHSAL - marshal [in] params into the buffer
812 * 4. PROXY_SENDRECEIVE - send/receive buffer
813 * 5. PROXY_UNMARHSAL - unmarshal [out] params from buffer
814 */
815 for (phase = PROXY_CALCSIZE; phase <= PROXY_UNMARSHAL; phase++)
816 {
817 TRACE("phase = %d\n", phase);
818 switch (phase)
819 {
820 case PROXY_GETBUFFER:
821 /* allocate the buffer */
822 if (Oif_flags.HasPipes)
823 /* NdrGetPipeBuffer(...) */
824 FIXME("pipes not supported yet\n");
825 else
826 {
827 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
828 #if 0
829 NdrNsGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
830 #else
831 FIXME("using auto handle - call NdrNsGetBuffer when it gets implemented\n");
832 #endif
833 else
834 NdrGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
835 }
836 break;
837 case PROXY_SENDRECEIVE:
838 /* send the [in] params and receive the [out] and [retval]
839 * params */
840 if (Oif_flags.HasPipes)
841 /* NdrPipesSendReceive(...) */
842 FIXME("pipes not supported yet\n");
843 else
844 {
845 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
846 #if 0
847 NdrNsSendReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
848 #else
849 FIXME("using auto handle - call NdrNsSendReceive when it gets implemented\n");
850 #endif
851 else
852 NdrSendReceive(&stubMsg, stubMsg.Buffer);
853 }
854
855 /* convert strings, floating point values and endianess into our
856 * preferred format */
857 if ((rpcMsg.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
858 NdrConvert(&stubMsg, pFormat);
859
860 break;
861 case PROXY_CALCSIZE:
862 case PROXY_MARSHAL:
863 case PROXY_UNMARSHAL:
864 if (bV2Format)
865 client_do_args(&stubMsg, pFormat, phase, stubMsg.StackTop,
866 number_of_params, (unsigned char *)&RetVal);
867 else
868 client_do_args_old_format(&stubMsg, pFormat, phase,
869 stubMsg.StackTop, stack_size, (unsigned char *)&RetVal,
870 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT), FALSE);
871 break;
872 default:
873 ERR("shouldn't reach here. phase %d\n", phase);
874 break;
875 }
876 }
877 }
878
879 if (ext_flags.HasNewCorrDesc)
880 {
881 /* free extra correlation package */
882 NdrCorrelationFree(&stubMsg);
883 }
884
885 if (Oif_flags.HasPipes)
886 {
887 /* NdrPipesDone(...) */
888 }
889
890 /* free the full pointer translation tables */
891 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
892 NdrFullPointerXlatFree(stubMsg.FullPtrXlatTables);
893
894 /* free marshalling buffer */
895 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
896 NdrProxyFreeBuffer(This, &stubMsg);
897 else
898 {
899 NdrFreeBuffer(&stubMsg);
900 client_free_handle(&stubMsg, pProcHeader, pHandleFormat, hBinding);
901 }
902
903 TRACE("RetVal = 0x%lx\n", RetVal);
904
905 return RetVal;
906 }
907
908 /* Calls a function with the specified arguments, restoring the stack
909 * properly afterwards as we don't know the calling convention of the
910 * function */
911 #if defined __i386__ && defined _MSC_VER
912 __declspec(naked) LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned int stack_size)
913 {
914 __asm
915 {
916 push ebp
917 push edi ; Save registers
918 push esi
919 mov ebp, esp
920 mov eax, [ebp+16] ; Get stack size
921 sub esp, eax ; Make room in stack for arguments
922 mov edi, esp
923 mov ecx, eax
924 mov esi, [ebp+12]
925 shr ecx, 2
926 cld
927 rep movsd ; Copy dword blocks
928 call [ebp+8] ; Call function
929 lea esp, [ebp-8] ; Restore stack
930 pop esi ; Restore registers
931 pop edi
932 pop ebp
933 ret
934 }
935 }
936 #elif defined __i386__ && defined __GNUC__
937 LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned int stack_size);
938 __ASM_GLOBAL_FUNC(call_server_func,
939 "pushl %ebp\n\t"
940 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
941 __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
942 "movl %esp,%ebp\n\t"
943 __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
944 "pushl %edi\n\t" /* Save registers */
945 __ASM_CFI(".cfi_rel_offset %edi,-4\n\t")
946 "pushl %esi\n\t"
947 __ASM_CFI(".cfi_rel_offset %esi,-8\n\t")
948 "movl 16(%ebp), %eax\n\t" /* Get stack size */
949 "subl %eax, %esp\n\t" /* Make room in stack for arguments */
950 "andl $~15, %esp\n\t" /* Make sure stack has 16-byte alignment for Mac OS X */
951 "movl %esp, %edi\n\t"
952 "movl %eax, %ecx\n\t"
953 "movl 12(%ebp), %esi\n\t"
954 "shrl $2, %ecx\n\t" /* divide by 4 */
955 "cld\n\t"
956 "rep; movsl\n\t" /* Copy dword blocks */
957 "call *8(%ebp)\n\t" /* Call function */
958 "leal -8(%ebp), %esp\n\t" /* Restore stack */
959 "popl %esi\n\t" /* Restore registers */
960 __ASM_CFI(".cfi_same_value %esi\n\t")
961 "popl %edi\n\t"
962 __ASM_CFI(".cfi_same_value %edi\n\t")
963 "popl %ebp\n\t"
964 __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
965 __ASM_CFI(".cfi_same_value %ebp\n\t")
966 "ret" )
967 #else
968 #warning call_server_func not implemented for your architecture
969 LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned short stack_size)
970 {
971 FIXME("Not implemented for your architecture\n");
972 return 0;
973 }
974 #endif
975
976 static DWORD calc_arg_size(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat)
977 {
978 DWORD size;
979 switch(*pFormat)
980 {
981 case RPC_FC_STRUCT:
982 size = *(const WORD*)(pFormat + 2);
983 break;
984 case RPC_FC_CARRAY:
985 size = *(const WORD*)(pFormat + 2);
986 ComputeConformance(pStubMsg, NULL, pFormat + 4, 0);
987 size *= pStubMsg->MaxCount;
988 break;
989 case RPC_FC_SMFARRAY:
990 size = *(const WORD*)(pFormat + 2);
991 break;
992 case RPC_FC_LGFARRAY:
993 size = *(const DWORD*)(pFormat + 2);
994 break;
995 case RPC_FC_BOGUS_ARRAY:
996 pFormat = ComputeConformance(pStubMsg, NULL, pFormat + 4, *(const WORD*)&pFormat[2]);
997 TRACE("conformance = %ld\n", pStubMsg->MaxCount);
998 pFormat = ComputeVariance(pStubMsg, NULL, pFormat, pStubMsg->MaxCount);
999 size = ComplexStructSize(pStubMsg, pFormat);
1000 size *= pStubMsg->MaxCount;
1001 break;
1002 default:
1003 FIXME("Unhandled type %02x\n", *pFormat);
1004 /* fallthrough */
1005 case RPC_FC_RP:
1006 size = sizeof(void *);
1007 break;
1008 }
1009 return size;
1010 }
1011
1012 static LONG_PTR *stub_do_args(MIDL_STUB_MESSAGE *pStubMsg,
1013 PFORMAT_STRING pFormat, int phase,
1014 unsigned char *args,
1015 unsigned short number_of_params)
1016 {
1017 /* counter */
1018 unsigned short i;
1019 /* current format string offset */
1020 int current_offset = 0;
1021 /* current stack offset */
1022 unsigned short current_stack_offset = 0;
1023 /* location to put retval into */
1024 LONG_PTR *retval_ptr = NULL;
1025
1026 for (i = 0; i < number_of_params; i++)
1027 {
1028 const NDR_PARAM_OIF_BASETYPE *pParam =
1029 (const NDR_PARAM_OIF_BASETYPE *)&pFormat[current_offset];
1030 unsigned char *pArg;
1031
1032 current_stack_offset = pParam->stack_offset;
1033 pArg = args + current_stack_offset;
1034
1035 TRACE("param[%d]: new format\n", i);
1036 TRACE("\tparam_attributes:"); dump_RPC_FC_PROC_PF(pParam->param_attributes); TRACE("\n");
1037 TRACE("\tstack_offset: 0x%x\n", current_stack_offset);
1038 TRACE("\tmemory addr (before): %p -> %p\n", pArg, *(unsigned char **)pArg);
1039
1040 if (pParam->param_attributes.IsBasetype)
1041 {
1042 const unsigned char *pTypeFormat =
1043 &pParam->type_format_char;
1044
1045 TRACE("\tbase type: 0x%02x\n", *pTypeFormat);
1046
1047 /* make a note of the address of the return value parameter for later */
1048 if (pParam->param_attributes.IsReturn)
1049 retval_ptr = (LONG_PTR *)pArg;
1050
1051 switch (phase)
1052 {
1053 case STUBLESS_MARSHAL:
1054 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1055 {
1056 if (pParam->param_attributes.IsSimpleRef)
1057 call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1058 else
1059 call_marshaller(pStubMsg, pArg, pTypeFormat);
1060 }
1061 break;
1062 case STUBLESS_FREE:
1063 if (pParam->param_attributes.ServerAllocSize)
1064 HeapFree(GetProcessHeap(), 0, *(void **)pArg);
1065 break;
1066 case STUBLESS_INITOUT:
1067 break;
1068 case STUBLESS_UNMARSHAL:
1069 if (pParam->param_attributes.ServerAllocSize)
1070 *(void **)pArg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1071 pParam->param_attributes.ServerAllocSize * 8);
1072
1073 if (pParam->param_attributes.IsIn)
1074 {
1075 if (pParam->param_attributes.IsSimpleRef)
1076 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
1077 else
1078 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
1079 }
1080 break;
1081 case STUBLESS_CALCSIZE:
1082 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1083 {
1084 if (pParam->param_attributes.IsSimpleRef)
1085 call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1086 else
1087 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
1088 }
1089 break;
1090 default:
1091 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1092 }
1093
1094 current_offset += sizeof(NDR_PARAM_OIF_BASETYPE);
1095 }
1096 else
1097 {
1098 const NDR_PARAM_OIF_OTHER *pParamOther =
1099 (const NDR_PARAM_OIF_OTHER *)&pFormat[current_offset];
1100
1101 const unsigned char * pTypeFormat =
1102 &(pStubMsg->StubDesc->pFormatTypes[pParamOther->type_offset]);
1103
1104 TRACE("\tcomplex type 0x%02x\n", *pTypeFormat);
1105
1106 switch (phase)
1107 {
1108 case STUBLESS_MARSHAL:
1109 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1110 {
1111 if (pParam->param_attributes.IsByValue)
1112 call_marshaller(pStubMsg, pArg, pTypeFormat);
1113 else
1114 call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1115 }
1116 break;
1117 case STUBLESS_FREE:
1118 if (pParam->param_attributes.MustFree)
1119 {
1120 if (pParam->param_attributes.IsByValue)
1121 call_freer(pStubMsg, pArg, pTypeFormat);
1122 else
1123 call_freer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1124 }
1125
1126 if (pParam->param_attributes.IsOut &&
1127 !pParam->param_attributes.IsIn &&
1128 !pParam->param_attributes.IsByValue &&
1129 !pParam->param_attributes.ServerAllocSize)
1130 {
1131 pStubMsg->pfnFree(*(void **)pArg);
1132 }
1133
1134 if (pParam->param_attributes.ServerAllocSize)
1135 HeapFree(GetProcessHeap(), 0, *(void **)pArg);
1136 break;
1137 case STUBLESS_INITOUT:
1138 if (!pParam->param_attributes.IsIn &&
1139 pParam->param_attributes.IsOut &&
1140 !pParam->param_attributes.ServerAllocSize &&
1141 !pParam->param_attributes.IsByValue)
1142 {
1143 DWORD size = calc_arg_size(pStubMsg, pTypeFormat);
1144
1145 if(size)
1146 {
1147 *(void **)pArg = NdrAllocate(pStubMsg, size);
1148 memset(*(void **)pArg, 0, size);
1149 }
1150 }
1151 break;
1152 case STUBLESS_UNMARSHAL:
1153 if (pParam->param_attributes.ServerAllocSize)
1154 *(void **)pArg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1155 pParam->param_attributes.ServerAllocSize * 8);
1156
1157 if (pParam->param_attributes.IsIn)
1158 {
1159 if (pParam->param_attributes.IsByValue)
1160 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
1161 else
1162 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
1163 }
1164 break;
1165 case STUBLESS_CALCSIZE:
1166 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1167 {
1168 if (pParam->param_attributes.IsByValue)
1169 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
1170 else
1171 call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1172 }
1173 break;
1174 default:
1175 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1176 }
1177
1178 current_offset += sizeof(NDR_PARAM_OIF_OTHER);
1179 }
1180 TRACE("\tmemory addr (after): %p -> %p\n", pArg, *(unsigned char **)pArg);
1181 }
1182
1183 return retval_ptr;
1184 }
1185
1186 static LONG_PTR *stub_do_old_args(MIDL_STUB_MESSAGE *pStubMsg,
1187 PFORMAT_STRING pFormat, int phase,
1188 unsigned char *args,
1189 unsigned short stack_size, BOOL object)
1190 {
1191 /* counter */
1192 unsigned short i;
1193 /* current format string offset */
1194 int current_offset = 0;
1195 /* current stack offset */
1196 unsigned short current_stack_offset = 0;
1197 /* location to put retval into */
1198 LONG_PTR *retval_ptr = NULL;
1199
1200 for (i = 0; TRUE; i++)
1201 {
1202 const NDR_PARAM_OI_BASETYPE *pParam =
1203 (const NDR_PARAM_OI_BASETYPE *)&pFormat[current_offset];
1204 /* note: current_stack_offset starts after the This pointer
1205 * if present, so adjust this */
1206 unsigned short current_stack_offset_adjusted = current_stack_offset +
1207 (object ? sizeof(void *) : 0);
1208 unsigned char *pArg = args + current_stack_offset_adjusted;
1209
1210 /* no more parameters; exit loop */
1211 if (current_stack_offset_adjusted >= stack_size)
1212 break;
1213
1214 TRACE("param[%d]: old format\n", i);
1215 TRACE("\tparam_direction: 0x%x\n", pParam->param_direction);
1216 TRACE("\tstack_offset: 0x%x\n", current_stack_offset_adjusted);
1217
1218 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE ||
1219 pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1220 {
1221 const unsigned char *pTypeFormat =
1222 &pParam->type_format_char;
1223
1224 TRACE("\tbase type 0x%02x\n", *pTypeFormat);
1225
1226 if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1227 retval_ptr = (LONG_PTR *)pArg;
1228
1229 switch (phase)
1230 {
1231 case STUBLESS_MARSHAL:
1232 if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1233 call_marshaller(pStubMsg, pArg, pTypeFormat);
1234 break;
1235 case STUBLESS_FREE:
1236 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
1237 call_freer(pStubMsg, pArg, pTypeFormat);
1238 break;
1239 case STUBLESS_UNMARSHAL:
1240 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
1241 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
1242 break;
1243 case STUBLESS_CALCSIZE:
1244 if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1245 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
1246 break;
1247 default:
1248 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1249 }
1250
1251 current_stack_offset += type_stack_size(*pTypeFormat);
1252 current_offset += sizeof(NDR_PARAM_OI_BASETYPE);
1253 }
1254 else
1255 {
1256 const NDR_PARAM_OI_OTHER *pParamOther =
1257 (const NDR_PARAM_OI_OTHER *)&pFormat[current_offset];
1258
1259 const unsigned char * pTypeFormat =
1260 &pStubMsg->StubDesc->pFormatTypes[pParamOther->type_offset];
1261
1262 TRACE("\tcomplex type 0x%02x\n", *pTypeFormat);
1263
1264 if (pParam->param_direction == RPC_FC_RETURN_PARAM)
1265 retval_ptr = (LONG_PTR *)pArg;
1266
1267 switch (phase)
1268 {
1269 case STUBLESS_MARSHAL:
1270 if (pParam->param_direction == RPC_FC_OUT_PARAM ||
1271 pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1272 pParam->param_direction == RPC_FC_RETURN_PARAM)
1273 call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1274 break;
1275 case STUBLESS_FREE:
1276 if (pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1277 pParam->param_direction == RPC_FC_IN_PARAM)
1278 call_freer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1279 else if (pParam->param_direction == RPC_FC_OUT_PARAM)
1280 pStubMsg->pfnFree(*(void **)pArg);
1281 break;
1282 case STUBLESS_INITOUT:
1283 if (pParam->param_direction == RPC_FC_OUT_PARAM)
1284 {
1285 DWORD size = calc_arg_size(pStubMsg, pTypeFormat);
1286
1287 if(size)
1288 {
1289 *(void **)pArg = NdrAllocate(pStubMsg, size);
1290 memset(*(void **)pArg, 0, size);
1291 }
1292 }
1293 break;
1294 case STUBLESS_UNMARSHAL:
1295 if (pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1296 pParam->param_direction == RPC_FC_IN_PARAM)
1297 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
1298 break;
1299 case STUBLESS_CALCSIZE:
1300 if (pParam->param_direction == RPC_FC_OUT_PARAM ||
1301 pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1302 pParam->param_direction == RPC_FC_RETURN_PARAM)
1303 call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1304 break;
1305 default:
1306 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1307 }
1308
1309 current_stack_offset += pParamOther->stack_size * sizeof(INT);
1310 current_offset += sizeof(NDR_PARAM_OI_OTHER);
1311 }
1312 }
1313
1314 return retval_ptr;
1315 }
1316
1317 /***********************************************************************
1318 * NdrStubCall2 [RPCRT4.@]
1319 *
1320 * Unmarshals [in] parameters, calls either a method in an object or a server
1321 * function, marshals any [out] parameters and frees any allocated data.
1322 *
1323 * NOTES
1324 * Used by stubless MIDL-generated code.
1325 */
1326 LONG WINAPI NdrStubCall2(
1327 struct IRpcStubBuffer * pThis,
1328 struct IRpcChannelBuffer * pChannel,
1329 PRPC_MESSAGE pRpcMsg,
1330 DWORD * pdwStubPhase)
1331 {
1332 const MIDL_SERVER_INFO *pServerInfo;
1333 const MIDL_STUB_DESC *pStubDesc;
1334 PFORMAT_STRING pFormat;
1335 MIDL_STUB_MESSAGE stubMsg;
1336 /* pointer to start of stack to pass into stub implementation */
1337 unsigned char * args;
1338 /* size of stack */
1339 unsigned short stack_size;
1340 /* number of parameters. optional for client to give it to us */
1341 unsigned char number_of_params = ~0;
1342 /* cache of Oif_flags from v2 procedure header */
1343 INTERPRETER_OPT_FLAGS Oif_flags = { 0 };
1344 /* cache of extension flags from NDR_PROC_HEADER_EXTS */
1345 INTERPRETER_OPT_FLAGS2 ext_flags = { 0 };
1346 /* the type of pass we are currently doing */
1347 int phase;
1348 /* header for procedure string */
1349 const NDR_PROC_HEADER *pProcHeader;
1350 /* offset in format string for start of params */
1351 int parameter_start_offset;
1352 /* current format string offset */
1353 int current_offset;
1354 /* -Oif or -Oicf generated format */
1355 BOOL bV2Format = FALSE;
1356 /* location to put retval into */
1357 LONG_PTR *retval_ptr = NULL;
1358
1359 TRACE("pThis %p, pChannel %p, pRpcMsg %p, pdwStubPhase %p\n", pThis, pChannel, pRpcMsg, pdwStubPhase);
1360
1361 if (pThis)
1362 pServerInfo = CStdStubBuffer_GetServerInfo(pThis);
1363 else
1364 pServerInfo = ((RPC_SERVER_INTERFACE *)pRpcMsg->RpcInterfaceInformation)->InterpreterInfo;
1365
1366 pStubDesc = pServerInfo->pStubDesc;
1367 pFormat = pServerInfo->ProcString + pServerInfo->FmtStringOffset[pRpcMsg->ProcNum];
1368 pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
1369
1370 TRACE("NDR Version: 0x%x\n", pStubDesc->Version);
1371
1372 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1373 {
1374 const NDR_PROC_HEADER_RPC *pProcHeader = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
1375 stack_size = pProcHeader->stack_size;
1376 current_offset = sizeof(NDR_PROC_HEADER_RPC);
1377
1378 }
1379 else
1380 {
1381 stack_size = pProcHeader->stack_size;
1382 current_offset = sizeof(NDR_PROC_HEADER);
1383 }
1384
1385 TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
1386
1387 /* binding */
1388 switch (pProcHeader->handle_type)
1389 {
1390 /* explicit binding: parse additional section */
1391 case RPC_FC_BIND_EXPLICIT:
1392 switch (pFormat[current_offset]) /* handle_type */
1393 {
1394 case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */
1395 current_offset += sizeof(NDR_EHD_PRIMITIVE);
1396 break;
1397 case RPC_FC_BIND_GENERIC: /* explicit generic */
1398 current_offset += sizeof(NDR_EHD_GENERIC);
1399 break;
1400 case RPC_FC_BIND_CONTEXT: /* explicit context */
1401 current_offset += sizeof(NDR_EHD_CONTEXT);
1402 break;
1403 default:
1404 ERR("bad explicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
1405 RpcRaiseException(RPC_X_BAD_STUB_DATA);
1406 }
1407 break;
1408 case RPC_FC_BIND_GENERIC: /* implicit generic */
1409 case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */
1410 case RPC_FC_CALLBACK_HANDLE: /* implicit callback */
1411 case RPC_FC_AUTO_HANDLE: /* implicit auto handle */
1412 break;
1413 default:
1414 ERR("bad implicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
1415 RpcRaiseException(RPC_X_BAD_STUB_DATA);
1416 }
1417
1418 bV2Format = (pStubDesc->Version >= 0x20000);
1419
1420 if (bV2Format)
1421 {
1422 const NDR_PROC_PARTIAL_OIF_HEADER *pOIFHeader =
1423 (const NDR_PROC_PARTIAL_OIF_HEADER *)&pFormat[current_offset];
1424
1425 Oif_flags = pOIFHeader->Oi2Flags;
1426 number_of_params = pOIFHeader->number_of_params;
1427
1428 current_offset += sizeof(NDR_PROC_PARTIAL_OIF_HEADER);
1429 }
1430
1431 TRACE("Oif_flags = "); dump_INTERPRETER_OPT_FLAGS(Oif_flags);
1432
1433 if (Oif_flags.HasExtensions)
1434 {
1435 const NDR_PROC_HEADER_EXTS *pExtensions =
1436 (const NDR_PROC_HEADER_EXTS *)&pFormat[current_offset];
1437 ext_flags = pExtensions->Flags2;
1438 current_offset += pExtensions->Size;
1439 }
1440
1441 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1442 NdrStubInitialize(pRpcMsg, &stubMsg, pStubDesc, pChannel);
1443 else
1444 NdrServerInitializeNew(pRpcMsg, &stubMsg, pStubDesc);
1445
1446 /* create the full pointer translation tables, if requested */
1447 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
1448 stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_SERVER);
1449
1450 /* store the RPC flags away */
1451 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1452 pRpcMsg->RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
1453
1454 /* use alternate memory allocation routines */
1455 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
1456 #if 0
1457 NdrRpcSsEnableAllocate(&stubMsg);
1458 #else
1459 FIXME("Set RPCSS memory allocation routines\n");
1460 #endif
1461
1462 if (Oif_flags.HasPipes)
1463 {
1464 FIXME("pipes not supported yet\n");
1465 RpcRaiseException(RPC_X_WRONG_STUB_VERSION); /* FIXME: remove when implemented */
1466 /* init pipes package */
1467 /* NdrPipesInitialize(...) */
1468 }
1469 if (ext_flags.HasNewCorrDesc)
1470 {
1471 /* initialize extra correlation package */
1472 FIXME("new correlation description not implemented\n");
1473 stubMsg.fHasNewCorrDesc = TRUE;
1474 }
1475
1476 /* convert strings, floating point values and endianess into our
1477 * preferred format */
1478 if ((pRpcMsg->DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
1479 NdrConvert(&stubMsg, pFormat);
1480
1481 parameter_start_offset = current_offset;
1482
1483 TRACE("allocating memory for stack of size %x\n", stack_size);
1484
1485 args = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, stack_size);
1486 stubMsg.StackTop = args; /* used by conformance of top-level objects */
1487
1488 /* add the implicit This pointer as the first arg to the function if we
1489 * are calling an object method */
1490 if (pThis)
1491 *(void **)args = ((CStdStubBuffer *)pThis)->pvServerObject;
1492
1493 /* order of phases:
1494 * 1. STUBLESS_UNMARHSAL - unmarshal [in] params from buffer
1495 * 2. STUBLESS_CALLSERVER - send/receive buffer
1496 * 3. STUBLESS_CALCSIZE - get [out] buffer size
1497 * 4. STUBLESS_GETBUFFER - allocate [out] buffer
1498 * 5. STUBLESS_MARHSAL - marshal [out] params to buffer
1499 */
1500 for (phase = STUBLESS_UNMARSHAL; phase <= STUBLESS_FREE; phase++)
1501 {
1502 TRACE("phase = %d\n", phase);
1503 switch (phase)
1504 {
1505 case STUBLESS_CALLSERVER:
1506 /* call the server function */
1507 if (pServerInfo->ThunkTable && pServerInfo->ThunkTable[pRpcMsg->ProcNum])
1508 pServerInfo->ThunkTable[pRpcMsg->ProcNum](&stubMsg);
1509 else
1510 {
1511 SERVER_ROUTINE func;
1512 LONG_PTR retval;
1513
1514 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1515 {
1516 SERVER_ROUTINE *vtbl = *(SERVER_ROUTINE **)((CStdStubBuffer *)pThis)->pvServerObject;
1517 func = vtbl[pRpcMsg->ProcNum];
1518 }
1519 else
1520 func = pServerInfo->DispatchTable[pRpcMsg->ProcNum];
1521
1522 /* FIXME: what happens with return values that don't fit into a single register on x86? */
1523 retval = call_server_func(func, args, stack_size);
1524
1525 if (retval_ptr)
1526 {
1527 TRACE("stub implementation returned 0x%lx\n", retval);
1528 *retval_ptr = retval;
1529 }
1530 else
1531 TRACE("void stub implementation\n");
1532 }
1533
1534 stubMsg.Buffer = NULL;
1535 stubMsg.BufferLength = 0;
1536
1537 break;
1538 case STUBLESS_GETBUFFER:
1539 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1540 NdrStubGetBuffer(pThis, pChannel, &stubMsg);
1541 else
1542 {
1543 RPC_STATUS Status;
1544
1545 pRpcMsg->BufferLength = stubMsg.BufferLength;
1546 /* allocate buffer for [out] and [ret] params */
1547 Status = I_RpcGetBuffer(pRpcMsg);
1548 if (Status)
1549 RpcRaiseException(Status);
1550 stubMsg.Buffer = pRpcMsg->Buffer;
1551 }
1552 break;
1553 case STUBLESS_UNMARSHAL:
1554 case STUBLESS_INITOUT:
1555 case STUBLESS_CALCSIZE:
1556 case STUBLESS_MARSHAL:
1557 case STUBLESS_FREE:
1558 if (bV2Format)
1559 retval_ptr = stub_do_args(&stubMsg, &pFormat[parameter_start_offset],
1560 phase, args, number_of_params);
1561 else
1562 retval_ptr = stub_do_old_args(&stubMsg, &pFormat[parameter_start_offset],
1563 phase, args, stack_size,
1564 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT));
1565
1566 break;
1567 default:
1568 ERR("shouldn't reach here. phase %d\n", phase);
1569 break;
1570 }
1571 }
1572
1573 pRpcMsg->BufferLength = (unsigned int)(stubMsg.Buffer - (unsigned char *)pRpcMsg->Buffer);
1574
1575 if (ext_flags.HasNewCorrDesc)
1576 {
1577 /* free extra correlation package */
1578 /* NdrCorrelationFree(&stubMsg); */
1579 }
1580
1581 if (Oif_flags.HasPipes)
1582 {
1583 /* NdrPipesDone(...) */
1584 }
1585
1586 /* free the full pointer translation tables */
1587 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
1588 NdrFullPointerXlatFree(stubMsg.FullPtrXlatTables);
1589
1590 /* free server function stack */
1591 HeapFree(GetProcessHeap(), 0, args);
1592
1593 return S_OK;
1594 }
1595
1596 /***********************************************************************
1597 * NdrServerCall2 [RPCRT4.@]
1598 */
1599 void WINAPI NdrServerCall2(PRPC_MESSAGE pRpcMsg)
1600 {
1601 DWORD dwPhase;
1602 NdrStubCall2(NULL, NULL, pRpcMsg, &dwPhase);
1603 }
1604
1605 struct async_call_data
1606 {
1607 MIDL_STUB_MESSAGE *pStubMsg;
1608 const NDR_PROC_HEADER *pProcHeader;
1609 PFORMAT_STRING pHandleFormat;
1610 PFORMAT_STRING pParamFormat;
1611 RPC_BINDING_HANDLE hBinding;
1612 /* size of stack */
1613 unsigned short stack_size;
1614 /* number of parameters. optional for client to give it to us */
1615 unsigned char number_of_params;
1616 /* correlation cache */
1617 unsigned long NdrCorrCache[256];
1618 };
1619
1620 LONG_PTR WINAPIV NdrAsyncClientCall(PMIDL_STUB_DESC pStubDesc,
1621 PFORMAT_STRING pFormat, ...)
1622 {
1623 /* pointer to start of stack where arguments start */
1624 PRPC_MESSAGE pRpcMsg;
1625 PMIDL_STUB_MESSAGE pStubMsg;
1626 RPC_ASYNC_STATE *pAsync;
1627 struct async_call_data *async_call_data;
1628 /* procedure number */
1629 unsigned short procedure_number;
1630 /* cache of Oif_flags from v2 procedure header */
1631 INTERPRETER_OPT_FLAGS Oif_flags = { 0 };
1632 /* cache of extension flags from NDR_PROC_HEADER_EXTS */
1633 INTERPRETER_OPT_FLAGS2 ext_flags = { 0 };
1634 /* the type of pass we are currently doing */
1635 int phase;
1636 /* header for procedure string */
1637 const NDR_PROC_HEADER * pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
1638 /* -Oif or -Oicf generated format */
1639 BOOL bV2Format = FALSE;
1640
1641 TRACE("pStubDesc %p, pFormat %p, ...\n", pStubDesc, pFormat);
1642
1643 /* Later NDR language versions probably won't be backwards compatible */
1644 if (pStubDesc->Version > 0x50002)
1645 {
1646 FIXME("Incompatible stub description version: 0x%x\n", pStubDesc->Version);
1647 RpcRaiseException(RPC_X_WRONG_STUB_VERSION);
1648 }
1649
1650 async_call_data = I_RpcAllocate(sizeof(*async_call_data) + sizeof(MIDL_STUB_MESSAGE) + sizeof(RPC_MESSAGE));
1651 if (!async_call_data) RpcRaiseException(ERROR_OUTOFMEMORY);
1652 async_call_data->number_of_params = ~0;
1653 async_call_data->pProcHeader = pProcHeader;
1654
1655 async_call_data->pStubMsg = pStubMsg = (PMIDL_STUB_MESSAGE)(async_call_data + 1);
1656 pRpcMsg = (PRPC_MESSAGE)(pStubMsg + 1);
1657
1658 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1659 {
1660 const NDR_PROC_HEADER_RPC *pProcHeader = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
1661 async_call_data->stack_size = pProcHeader->stack_size;
1662 procedure_number = pProcHeader->proc_num;
1663 pFormat += sizeof(NDR_PROC_HEADER_RPC);
1664 }
1665 else
1666 {
1667 async_call_data->stack_size = pProcHeader->stack_size;
1668 procedure_number = pProcHeader->proc_num;
1669 pFormat += sizeof(NDR_PROC_HEADER);
1670 }
1671 TRACE("stack size: 0x%x\n", async_call_data->stack_size);
1672 TRACE("proc num: %d\n", procedure_number);
1673
1674 /* create the full pointer translation tables, if requested */
1675 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
1676 pStubMsg->FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
1677
1678 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1679 {
1680 ERR("objects not supported\n");
1681 I_RpcFree(async_call_data);
1682 RpcRaiseException(RPC_X_BAD_STUB_DATA);
1683 }
1684
1685 NdrClientInitializeNew(pRpcMsg, pStubMsg, pStubDesc, procedure_number);
1686
1687 TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
1688 TRACE("MIDL stub version = 0x%x\n", pStubDesc->MIDLVersion);
1689
1690 /* needed for conformance of top-level objects */
1691 #ifdef __i386__
1692 pStubMsg->StackTop = I_RpcAllocate(async_call_data->stack_size);
1693 /* FIXME: this may read one more DWORD than is necessary, but it shouldn't hurt */
1694 memcpy(pStubMsg->StackTop, *(unsigned char **)(&pFormat+1), async_call_data->stack_size);
1695 #else
1696 # warning Stack not retrieved for your CPU architecture
1697 #endif
1698
1699 pAsync = *(RPC_ASYNC_STATE **)pStubMsg->StackTop;
1700 pAsync->StubInfo = async_call_data;
1701 async_call_data->pHandleFormat = pFormat;
1702
1703 pFormat = client_get_handle(pStubMsg, pProcHeader, async_call_data->pHandleFormat, &async_call_data->hBinding);
1704 if (!pFormat) return 0;
1705
1706 bV2Format = (pStubDesc->Version >= 0x20000);
1707
1708 if (bV2Format)
1709 {
1710 const NDR_PROC_PARTIAL_OIF_HEADER *pOIFHeader =
1711 (const NDR_PROC_PARTIAL_OIF_HEADER *)pFormat;
1712
1713 Oif_flags = pOIFHeader->Oi2Flags;
1714 async_call_data->number_of_params = pOIFHeader->number_of_params;
1715
1716 pFormat += sizeof(NDR_PROC_PARTIAL_OIF_HEADER);
1717 }
1718
1719 TRACE("Oif_flags = "); dump_INTERPRETER_OPT_FLAGS(Oif_flags);
1720
1721 if (Oif_flags.HasExtensions)
1722 {
1723 const NDR_PROC_HEADER_EXTS *pExtensions =
1724 (const NDR_PROC_HEADER_EXTS *)pFormat;
1725 ext_flags = pExtensions->Flags2;
1726 pFormat += pExtensions->Size;
1727 }
1728
1729 async_call_data->pParamFormat = pFormat;
1730
1731 pStubMsg->BufferLength = 0;
1732
1733 /* store the RPC flags away */
1734 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1735 pRpcMsg->RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
1736
1737 /* use alternate memory allocation routines */
1738 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
1739 NdrRpcSmSetClientToOsf(pStubMsg);
1740
1741 if (Oif_flags.HasPipes)
1742 {
1743 FIXME("pipes not supported yet\n");
1744 RpcRaiseException(RPC_X_WRONG_STUB_VERSION); /* FIXME: remove when implemented */
1745 /* init pipes package */
1746 /* NdrPipesInitialize(...) */
1747 }
1748 if (ext_flags.HasNewCorrDesc)
1749 {
1750 /* initialize extra correlation package */
1751 NdrCorrelationInitialize(pStubMsg, async_call_data->NdrCorrCache, sizeof(async_call_data->NdrCorrCache), 0);
1752 }
1753
1754 /* order of phases:
1755 * 1. PROXY_CALCSIZE - calculate the buffer size
1756 * 2. PROXY_GETBUFFER - allocate the buffer
1757 * 3. PROXY_MARHSAL - marshal [in] params into the buffer
1758 * 4. PROXY_SENDRECEIVE - send buffer
1759 * Then in NdrpCompleteAsyncClientCall:
1760 * 1. PROXY_SENDRECEIVE - receive buffer
1761 * 2. PROXY_UNMARHSAL - unmarshal [out] params from buffer
1762 */
1763 for (phase = PROXY_CALCSIZE; phase <= PROXY_SENDRECEIVE; phase++)
1764 {
1765 RPC_STATUS status;
1766 TRACE("phase = %d\n", phase);
1767 switch (phase)
1768 {
1769 case PROXY_GETBUFFER:
1770 /* allocate the buffer */
1771 if (Oif_flags.HasPipes)
1772 /* NdrGetPipeBuffer(...) */
1773 FIXME("pipes not supported yet\n");
1774 else
1775 {
1776 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
1777 #if 0
1778 NdrNsGetBuffer(pStubMsg, pStubMsg->BufferLength, async_call_data->hBinding);
1779 #else
1780 FIXME("using auto handle - call NdrNsGetBuffer when it gets implemented\n");
1781 #endif
1782 else
1783 NdrGetBuffer(pStubMsg, pStubMsg->BufferLength, async_call_data->hBinding);
1784 }
1785 pRpcMsg->RpcFlags |= RPC_BUFFER_ASYNC;
1786 status = I_RpcAsyncSetHandle(pRpcMsg, pAsync);
1787 if (status != RPC_S_OK)
1788 RpcRaiseException(status);
1789 break;
1790 case PROXY_SENDRECEIVE:
1791 pRpcMsg->RpcFlags |= RPC_BUFFER_ASYNC;
1792 /* send the [in] params only */
1793 if (Oif_flags.HasPipes)
1794 /* NdrPipesSend(...) */
1795 FIXME("pipes not supported yet\n");
1796 else
1797 {
1798 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
1799 #if 0
1800 NdrNsSend(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
1801 #else
1802 FIXME("using auto handle - call NdrNsSend when it gets implemented\n");
1803 #endif
1804 else
1805 {
1806 pStubMsg->RpcMsg->BufferLength = pStubMsg->Buffer - (unsigned char *)pStubMsg->RpcMsg->Buffer;
1807 status = I_RpcSend(pStubMsg->RpcMsg);
1808 if (status != RPC_S_OK)
1809 RpcRaiseException(status);
1810 }
1811 }
1812
1813 break;
1814 case PROXY_CALCSIZE:
1815 case PROXY_MARSHAL:
1816 if (bV2Format)
1817 client_do_args(pStubMsg, pFormat, phase, pStubMsg->StackTop,
1818 async_call_data->number_of_params, NULL);
1819 else
1820 client_do_args_old_format(pStubMsg, pFormat, phase,
1821 pStubMsg->StackTop, async_call_data->stack_size, NULL,
1822 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT), FALSE);
1823 break;
1824 default:
1825 ERR("shouldn't reach here. phase %d\n", phase);
1826 break;
1827 }
1828 }
1829
1830 TRACE("returning 0\n");
1831 return 0;
1832 }
1833
1834 RPC_STATUS NdrpCompleteAsyncClientCall(RPC_ASYNC_STATE *pAsync, void *Reply)
1835 {
1836 /* pointer to start of stack where arguments start */
1837 PMIDL_STUB_MESSAGE pStubMsg;
1838 struct async_call_data *async_call_data;
1839 /* the type of pass we are currently doing */
1840 int phase;
1841 /* header for procedure string */
1842 const NDR_PROC_HEADER * pProcHeader;
1843 /* -Oif or -Oicf generated format */
1844 BOOL bV2Format;
1845 RPC_STATUS status = RPC_S_OK;
1846
1847 if (!pAsync->StubInfo)
1848 return RPC_S_INVALID_ASYNC_HANDLE;
1849
1850 async_call_data = pAsync->StubInfo;
1851 pStubMsg = async_call_data->pStubMsg;
1852 pProcHeader = async_call_data->pProcHeader;
1853
1854 bV2Format = (pStubMsg->StubDesc->Version >= 0x20000);
1855
1856 /* order of phases:
1857 * 1. PROXY_CALCSIZE - calculate the buffer size
1858 * 2. PROXY_GETBUFFER - allocate the buffer
1859 * 3. PROXY_MARHSAL - marshal [in] params into the buffer
1860 * 4. PROXY_SENDRECEIVE - send buffer
1861 * Then in NdrpCompleteAsyncClientCall:
1862 * 1. PROXY_SENDRECEIVE - receive buffer
1863 * 2. PROXY_UNMARHSAL - unmarshal [out] params from buffer
1864 */
1865 for (phase = PROXY_SENDRECEIVE; phase <= PROXY_UNMARSHAL; phase++)
1866 {
1867 switch (phase)
1868 {
1869 case PROXY_SENDRECEIVE:
1870 pStubMsg->RpcMsg->RpcFlags |= RPC_BUFFER_ASYNC;
1871 /* receive the [out] params */
1872 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
1873 #if 0
1874 NdrNsReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
1875 #else
1876 FIXME("using auto handle - call NdrNsReceive when it gets implemented\n");
1877 #endif
1878 else
1879 {
1880 status = I_RpcReceive(pStubMsg->RpcMsg);
1881 if (status != RPC_S_OK)
1882 goto cleanup;
1883 pStubMsg->BufferLength = pStubMsg->RpcMsg->BufferLength;
1884 pStubMsg->BufferStart = pStubMsg->RpcMsg->Buffer;
1885 pStubMsg->BufferEnd = pStubMsg->BufferStart + pStubMsg->BufferLength;
1886 pStubMsg->Buffer = pStubMsg->BufferStart;
1887 }
1888
1889 /* convert strings, floating point values and endianess into our
1890 * preferred format */
1891 #if 0
1892 if ((pStubMsg->RpcMsg.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
1893 NdrConvert(pStubMsg, pFormat);
1894 #endif
1895
1896 break;
1897 case PROXY_UNMARSHAL:
1898 if (bV2Format)
1899 client_do_args(pStubMsg, async_call_data->pParamFormat, phase, pStubMsg->StackTop,
1900 async_call_data->number_of_params, Reply);
1901 else
1902 client_do_args_old_format(pStubMsg, async_call_data->pParamFormat, phase,
1903 pStubMsg->StackTop, async_call_data->stack_size, Reply, FALSE, FALSE);
1904 break;
1905 default:
1906 ERR("shouldn't reach here. phase %d\n", phase);
1907 break;
1908 }
1909 }
1910
1911 cleanup:
1912 if (pStubMsg->fHasNewCorrDesc)
1913 {
1914 /* free extra correlation package */
1915 NdrCorrelationFree(pStubMsg);
1916 }
1917
1918 /* free the full pointer translation tables */
1919 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
1920 NdrFullPointerXlatFree(pStubMsg->FullPtrXlatTables);
1921
1922 /* free marshalling buffer */
1923 NdrFreeBuffer(pStubMsg);
1924 client_free_handle(pStubMsg, pProcHeader, async_call_data->pHandleFormat, async_call_data->hBinding);
1925
1926 I_RpcFree(pStubMsg->StackTop);
1927 I_RpcFree(async_call_data);
1928
1929 TRACE("-- 0x%x\n", status);
1930 return status;
1931 }
1932
1933 RPCRTAPI LONG RPC_ENTRY NdrAsyncStubCall(struct IRpcStubBuffer* pThis,
1934 struct IRpcChannelBuffer* pChannel, PRPC_MESSAGE pRpcMsg,
1935 DWORD * pdwStubPhase)
1936 {
1937 FIXME("unimplemented, expect crash!\n");
1938 return 0;
1939 }
Quick hack tree for wine patches julliard doesn't want to commit