?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fusion: Implement CreateAssemblyCache.
[wine.git] / dlls / rpcrt4 / ndr_stubless.c
blob347db48cfac22bd780c9be72b5662e56fc33663f
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 WINAPI 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 WINAPI 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(stubMsg, offset) ((stubMsg).StackTop + (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, pDesc->offset);
160 else
161 *phBinding = *(handle_t *)ARG_FROM_OFFSET(*pStubMsg, 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, pDesc->offset);
175 else
176 pArg = (void *)ARG_FROM_OFFSET(*pStubMsg, 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, pDesc->offset);
191 }
192 else
193 context_handle = *(NDR_CCONTEXT *)ARG_FROM_OFFSET(*pStubMsg, 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, pDesc->offset);
258 else
259 pArg = (void *)ARG_FROM_OFFSET(*pStubMsg, 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 short number_of_params, unsigned char *pRetVal)
289 {
290 /* current format string offset */
291 int current_offset = 0;
292 /* current stack offset */
293 unsigned short current_stack_offset = 0;
294 /* counter */
295 unsigned short i;
296
297 for (i = 0; i < number_of_params; i++)
298 {
299 const NDR_PARAM_OIF_BASETYPE *pParam =
300 (const NDR_PARAM_OIF_BASETYPE *)&pFormat[current_offset];
301 unsigned char * pArg;
302
303 current_stack_offset = pParam->stack_offset;
304 pArg = ARG_FROM_OFFSET(*pStubMsg, current_stack_offset);
305
306 TRACE("param[%d]: new format\n", i);
307 TRACE("\tparam_attributes:"); dump_RPC_FC_PROC_PF(pParam->param_attributes); TRACE("\n");
308 TRACE("\tstack_offset: 0x%x\n", current_stack_offset);
309 TRACE("\tmemory addr (before): %p\n", pArg);
310
311 if (pParam->param_attributes.IsBasetype)
312 {
313 const unsigned char * pTypeFormat =
314 &pParam->type_format_char;
315
316 if (pParam->param_attributes.IsSimpleRef)
317 pArg = *(unsigned char **)pArg;
318
319 TRACE("\tbase type: 0x%02x\n", *pTypeFormat);
320
321 switch (phase)
322 {
323 case PROXY_CALCSIZE:
324 if (pParam->param_attributes.IsIn)
325 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
326 break;
327 case PROXY_MARSHAL:
328 if (pParam->param_attributes.IsIn)
329 call_marshaller(pStubMsg, pArg, pTypeFormat);
330 break;
331 case PROXY_UNMARSHAL:
332 if (pParam->param_attributes.IsOut)
333 {
334 if (pParam->param_attributes.IsReturn)
335 call_unmarshaller(pStubMsg, &pRetVal, pTypeFormat, 0);
336 else
337 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
338 TRACE("pRetVal = %p\n", pRetVal);
339 }
340 break;
341 default:
342 RpcRaiseException(RPC_S_INTERNAL_ERROR);
343 }
344
345 current_offset += sizeof(NDR_PARAM_OIF_BASETYPE);
346 }
347 else
348 {
349 const NDR_PARAM_OIF_OTHER *pParamOther =
350 (const NDR_PARAM_OIF_OTHER *)&pFormat[current_offset];
351
352 const unsigned char * pTypeFormat =
353 &(pStubMsg->StubDesc->pFormatTypes[pParamOther->type_offset]);
354
355 /* if a simple ref pointer then we have to do the
356 * check for the pointer being non-NULL. */
357 if (pParam->param_attributes.IsSimpleRef)
358 {
359 if (!*(unsigned char **)pArg)
360 RpcRaiseException(RPC_X_NULL_REF_POINTER);
361 }
362
363 TRACE("\tcomplex type: 0x%02x\n", *pTypeFormat);
364
365 switch (phase)
366 {
367 case PROXY_CALCSIZE:
368 if (pParam->param_attributes.IsIn)
369 {
370 if (pParam->param_attributes.IsByValue)
371 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
372 else
373 call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
374 }
375 break;
376 case PROXY_MARSHAL:
377 if (pParam->param_attributes.IsIn)
378 {
379 if (pParam->param_attributes.IsByValue)
380 call_marshaller(pStubMsg, pArg, pTypeFormat);
381 else
382 call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
383 }
384 break;
385 case PROXY_UNMARSHAL:
386 if (pParam->param_attributes.IsOut)
387 {
388 if (pParam->param_attributes.IsReturn)
389 call_unmarshaller(pStubMsg, &pRetVal, pTypeFormat, 0);
390 else if (pParam->param_attributes.IsByValue)
391 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
392 else
393 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
394 }
395 break;
396 default:
397 RpcRaiseException(RPC_S_INTERNAL_ERROR);
398 }
399
400 current_offset += sizeof(NDR_PARAM_OIF_OTHER);
401 }
402 TRACE("\tmemory addr (after): %p\n", pArg);
403 }
404 }
405
406 static unsigned int type_stack_size(unsigned char fc)
407 {
408 switch (fc)
409 {
410 case RPC_FC_BYTE:
411 case RPC_FC_CHAR:
412 case RPC_FC_SMALL:
413 case RPC_FC_USMALL:
414 return sizeof(char);
415 case RPC_FC_WCHAR:
416 case RPC_FC_SHORT:
417 case RPC_FC_USHORT:
418 return sizeof(short);
419 case RPC_FC_LONG:
420 case RPC_FC_ULONG:
421 case RPC_FC_ENUM16:
422 case RPC_FC_ENUM32:
423 return sizeof(int);
424 case RPC_FC_FLOAT:
425 return sizeof(float);
426 case RPC_FC_DOUBLE:
427 return sizeof(double);
428 case RPC_FC_HYPER:
429 return sizeof(ULONGLONG);
430 case RPC_FC_ERROR_STATUS_T:
431 return sizeof(error_status_t);
432 case RPC_FC_IGNORE:
433 return sizeof(void *);
434 default:
435 ERR("invalid base type 0x%x\n", fc);
436 RpcRaiseException(RPC_S_INTERNAL_ERROR);
437 }
438 }
439
440 static void client_do_args_old_format(PMIDL_STUB_MESSAGE pStubMsg,
441 PFORMAT_STRING pFormat, int phase, unsigned short stack_size,
442 unsigned char *pRetVal, BOOL object_proc)
443 {
444 /* current format string offset */
445 int current_offset = 0;
446 /* current stack offset */
447 unsigned short current_stack_offset = 0;
448 /* counter */
449 unsigned short i;
450
451 /* NOTE: V1 style format does't terminate on the number_of_params
452 * condition as it doesn't have this attribute. Instead it
453 * terminates when the stack size given in the header is exceeded.
454 */
455 for (i = 0; TRUE; i++)
456 {
457 const NDR_PARAM_OI_BASETYPE *pParam =
458 (const NDR_PARAM_OI_BASETYPE *)&pFormat[current_offset];
459 /* note: current_stack_offset starts after the This pointer
460 * if present, so adjust this */
461 unsigned short current_stack_offset_adjusted = current_stack_offset +
462 (object_proc ? sizeof(void *) : 0);
463 unsigned char * pArg = ARG_FROM_OFFSET(*pStubMsg, current_stack_offset_adjusted);
464
465 /* no more parameters; exit loop */
466 if (current_stack_offset_adjusted >= stack_size)
467 break;
468
469 TRACE("param[%d]: old format\n", i);
470 TRACE("\tparam_direction: 0x%x\n", pParam->param_direction);
471 TRACE("\tstack_offset: 0x%x\n", current_stack_offset_adjusted);
472 TRACE("\tmemory addr (before): %p\n", pArg);
473
474 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE ||
475 pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
476 {
477 const unsigned char * pTypeFormat =
478 &pParam->type_format_char;
479
480 TRACE("\tbase type 0x%02x\n", *pTypeFormat);
481
482 switch (phase)
483 {
484 case PROXY_CALCSIZE:
485 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
486 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
487 break;
488 case PROXY_MARSHAL:
489 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
490 call_marshaller(pStubMsg, pArg, pTypeFormat);
491 break;
492 case PROXY_UNMARSHAL:
493 if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
494 {
495 if (pParam->param_direction & RPC_FC_RETURN_PARAM)
496 call_unmarshaller(pStubMsg, &pRetVal, pTypeFormat, 0);
497 else
498 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
499 }
500 break;
501 default:
502 RpcRaiseException(RPC_S_INTERNAL_ERROR);
503 }
504
505 current_stack_offset += type_stack_size(*pTypeFormat);
506 current_offset += sizeof(NDR_PARAM_OI_BASETYPE);
507 }
508 else
509 {
510 const NDR_PARAM_OI_OTHER *pParamOther =
511 (const NDR_PARAM_OI_OTHER *)&pFormat[current_offset];
512
513 const unsigned char *pTypeFormat =
514 &pStubMsg->StubDesc->pFormatTypes[pParamOther->type_offset];
515
516 TRACE("\tcomplex type 0x%02x\n", *pTypeFormat);
517
518 switch (phase)
519 {
520 case PROXY_CALCSIZE:
521 if (pParam->param_direction == RPC_FC_IN_PARAM ||
522 pParam->param_direction & RPC_FC_IN_OUT_PARAM)
523 call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
524 break;
525 case PROXY_MARSHAL:
526 if (pParam->param_direction == RPC_FC_IN_PARAM ||
527 pParam->param_direction & RPC_FC_IN_OUT_PARAM)
528 call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
529 break;
530 case PROXY_UNMARSHAL:
531 if (pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
532 pParam->param_direction == RPC_FC_OUT_PARAM)
533 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
534 else if (pParam->param_direction == RPC_FC_RETURN_PARAM)
535 call_unmarshaller(pStubMsg, (unsigned char **)pRetVal, pTypeFormat, 0);
536 break;
537 default:
538 RpcRaiseException(RPC_S_INTERNAL_ERROR);
539 }
540
541 current_stack_offset += pParamOther->stack_size * sizeof(INT);
542 current_offset += sizeof(NDR_PARAM_OI_OTHER);
543 }
544 TRACE("\tmemory addr (after): %p\n", pArg);
545 }
546 }
547
548 /* the return type should be CLIENT_CALL_RETURN, but this is incompatible
549 * with the way gcc returns structures. "void *" should be the largest type
550 * that MIDL should allow you to return anyway */
551 LONG_PTR WINAPIV NdrClientCall2(PMIDL_STUB_DESC pStubDesc, PFORMAT_STRING pFormat, ...)
552 {
553 /* pointer to start of stack where arguments start */
554 RPC_MESSAGE rpcMsg;
555 MIDL_STUB_MESSAGE stubMsg;
556 handle_t hBinding = NULL;
557 /* procedure number */
558 unsigned short procedure_number;
559 /* size of stack */
560 unsigned short stack_size;
561 /* number of parameters. optional for client to give it to us */
562 unsigned char number_of_params = ~0;
563 /* cache of Oif_flags from v2 procedure header */
564 INTERPRETER_OPT_FLAGS Oif_flags = { 0 };
565 /* cache of extension flags from NDR_PROC_HEADER_EXTS */
566 INTERPRETER_OPT_FLAGS2 ext_flags = { 0 };
567 /* the type of pass we are currently doing */
568 int phase;
569 /* header for procedure string */
570 const NDR_PROC_HEADER * pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
571 /* -Oif or -Oicf generated format */
572 BOOL bV2Format = FALSE;
573 /* the value to return to the client from the remote procedure */
574 LONG_PTR RetVal = 0;
575 /* the pointer to the object when in OLE mode */
576 void * This = NULL;
577 PFORMAT_STRING pHandleFormat;
578 /* correlation cache */
579 unsigned long NdrCorrCache[256];
580
581 TRACE("pStubDesc %p, pFormat %p, ...\n", pStubDesc, pFormat);
582
583 /* Later NDR language versions probably won't be backwards compatible */
584 if (pStubDesc->Version > 0x50002)
585 {
586 FIXME("Incompatible stub description version: 0x%x\n", pStubDesc->Version);
587 RpcRaiseException(RPC_X_WRONG_STUB_VERSION);
588 }
589
590 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
591 {
592 const NDR_PROC_HEADER_RPC *pProcHeader = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
593 stack_size = pProcHeader->stack_size;
594 procedure_number = pProcHeader->proc_num;
595 pFormat += sizeof(NDR_PROC_HEADER_RPC);
596 }
597 else
598 {
599 stack_size = pProcHeader->stack_size;
600 procedure_number = pProcHeader->proc_num;
601 pFormat += sizeof(NDR_PROC_HEADER);
602 }
603 TRACE("stack size: 0x%x\n", stack_size);
604 TRACE("proc num: %d\n", procedure_number);
605
606 /* create the full pointer translation tables, if requested */
607 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
608 stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
609
610 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
611 {
612 /* object is always the first argument */
613 This = **(void *const **)(&pFormat+1);
614 NdrProxyInitialize(This, &rpcMsg, &stubMsg, pStubDesc, procedure_number);
615 }
616 else
617 NdrClientInitializeNew(&rpcMsg, &stubMsg, pStubDesc, procedure_number);
618
619 TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
620 TRACE("MIDL stub version = 0x%x\n", pStubDesc->MIDLVersion);
621
622 /* needed for conformance of top-level objects */
623 #ifdef __i386__
624 stubMsg.StackTop = *(unsigned char **)(&pFormat+1);
625 #else
626 # warning Stack not retrieved for your CPU architecture
627 #endif
628
629 pHandleFormat = pFormat;
630
631 /* we only need a handle if this isn't an object method */
632 if (!(pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT))
633 {
634 pFormat = client_get_handle(&stubMsg, pProcHeader, pHandleFormat, &hBinding);
635 if (!pFormat) return 0;
636 }
637
638 bV2Format = (pStubDesc->Version >= 0x20000);
639
640 if (bV2Format)
641 {
642 const NDR_PROC_PARTIAL_OIF_HEADER *pOIFHeader =
643 (const NDR_PROC_PARTIAL_OIF_HEADER *)pFormat;
644
645 Oif_flags = pOIFHeader->Oi2Flags;
646 number_of_params = pOIFHeader->number_of_params;
647
648 pFormat += sizeof(NDR_PROC_PARTIAL_OIF_HEADER);
649 }
650
651 TRACE("Oif_flags = "); dump_INTERPRETER_OPT_FLAGS(Oif_flags);
652
653 if (Oif_flags.HasExtensions)
654 {
655 const NDR_PROC_HEADER_EXTS *pExtensions =
656 (const NDR_PROC_HEADER_EXTS *)pFormat;
657 ext_flags = pExtensions->Flags2;
658 pFormat += pExtensions->Size;
659 }
660
661 stubMsg.BufferLength = 0;
662
663 /* store the RPC flags away */
664 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
665 rpcMsg.RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
666
667 /* use alternate memory allocation routines */
668 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
669 NdrRpcSmSetClientToOsf(&stubMsg);
670
671 if (Oif_flags.HasPipes)
672 {
673 FIXME("pipes not supported yet\n");
674 RpcRaiseException(RPC_X_WRONG_STUB_VERSION); /* FIXME: remove when implemented */
675 /* init pipes package */
676 /* NdrPipesInitialize(...) */
677 }
678 if (ext_flags.HasNewCorrDesc)
679 {
680 /* initialize extra correlation package */
681 NdrCorrelationInitialize(&stubMsg, NdrCorrCache, sizeof(NdrCorrCache), 0);
682 }
683
684 /* order of phases:
685 * 1. PROXY_CALCSIZE - calculate the buffer size
686 * 2. PROXY_GETBUFFER - allocate the buffer
687 * 3. PROXY_MARHSAL - marshal [in] params into the buffer
688 * 4. PROXY_SENDRECEIVE - send/receive buffer
689 * 5. PROXY_UNMARHSAL - unmarshal [out] params from buffer
690 */
691 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
692 {
693 __TRY
694 {
695 for (phase = PROXY_CALCSIZE; phase <= PROXY_UNMARSHAL; phase++)
696 {
697 TRACE("phase = %d\n", phase);
698 switch (phase)
699 {
700 case PROXY_GETBUFFER:
701 /* allocate the buffer */
702 NdrProxyGetBuffer(This, &stubMsg);
703 break;
704 case PROXY_SENDRECEIVE:
705 /* send the [in] params and receive the [out] and [retval]
706 * params */
707 NdrProxySendReceive(This, &stubMsg);
708
709 /* convert strings, floating point values and endianess into our
710 * preferred format */
711 if ((rpcMsg.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
712 NdrConvert(&stubMsg, pFormat);
713
714 break;
715 case PROXY_CALCSIZE:
716 case PROXY_MARSHAL:
717 case PROXY_UNMARSHAL:
718 if (bV2Format)
719 client_do_args(&stubMsg, pFormat, phase, number_of_params,
720 (unsigned char *)&RetVal);
721 else
722 client_do_args_old_format(&stubMsg, pFormat, phase, stack_size,
723 (unsigned char *)&RetVal,
724 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT));
725 break;
726 default:
727 ERR("shouldn't reach here. phase %d\n", phase);
728 break;
729 }
730 }
731 }
732 __EXCEPT_ALL
733 {
734 RetVal = NdrProxyErrorHandler(GetExceptionCode());
735 }
736 __ENDTRY
737 }
738 else
739 {
740 /* order of phases:
741 * 1. PROXY_CALCSIZE - calculate the buffer size
742 * 2. PROXY_GETBUFFER - allocate the buffer
743 * 3. PROXY_MARHSAL - marshal [in] params into the buffer
744 * 4. PROXY_SENDRECEIVE - send/receive buffer
745 * 5. PROXY_UNMARHSAL - unmarshal [out] params from buffer
746 */
747 for (phase = PROXY_CALCSIZE; phase <= PROXY_UNMARSHAL; phase++)
748 {
749 TRACE("phase = %d\n", phase);
750 switch (phase)
751 {
752 case PROXY_GETBUFFER:
753 /* allocate the buffer */
754 if (Oif_flags.HasPipes)
755 /* NdrGetPipeBuffer(...) */
756 FIXME("pipes not supported yet\n");
757 else
758 {
759 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
760 #if 0
761 NdrNsGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
762 #else
763 FIXME("using auto handle - call NdrNsGetBuffer when it gets implemented\n");
764 #endif
765 else
766 NdrGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
767 }
768 break;
769 case PROXY_SENDRECEIVE:
770 /* send the [in] params and receive the [out] and [retval]
771 * params */
772 if (Oif_flags.HasPipes)
773 /* NdrPipesSendReceive(...) */
774 FIXME("pipes not supported yet\n");
775 else
776 {
777 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
778 #if 0
779 NdrNsSendReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
780 #else
781 FIXME("using auto handle - call NdrNsSendReceive when it gets implemented\n");
782 #endif
783 else
784 NdrSendReceive(&stubMsg, stubMsg.Buffer);
785 }
786
787 /* convert strings, floating point values and endianess into our
788 * preferred format */
789 if ((rpcMsg.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
790 NdrConvert(&stubMsg, pFormat);
791
792 break;
793 case PROXY_CALCSIZE:
794 case PROXY_MARSHAL:
795 case PROXY_UNMARSHAL:
796 if (bV2Format)
797 client_do_args(&stubMsg, pFormat, phase, number_of_params,
798 (unsigned char *)&RetVal);
799 else
800 client_do_args_old_format(&stubMsg, pFormat, phase, stack_size,
801 (unsigned char *)&RetVal,
802 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT));
803 break;
804 default:
805 ERR("shouldn't reach here. phase %d\n", phase);
806 break;
807 }
808 }
809 }
810
811 if (ext_flags.HasNewCorrDesc)
812 {
813 /* free extra correlation package */
814 NdrCorrelationFree(&stubMsg);
815 }
816
817 if (Oif_flags.HasPipes)
818 {
819 /* NdrPipesDone(...) */
820 }
821
822 /* free the full pointer translation tables */
823 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
824 NdrFullPointerXlatFree(stubMsg.FullPtrXlatTables);
825
826 /* free marshalling buffer */
827 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
828 NdrProxyFreeBuffer(This, &stubMsg);
829 else
830 {
831 NdrFreeBuffer(&stubMsg);
832 client_free_handle(&stubMsg, pProcHeader, pHandleFormat, hBinding);
833 }
834
835 TRACE("RetVal = 0x%lx\n", RetVal);
836
837 return RetVal;
838 }
839
840 /* calls a function with the specificed arguments, restoring the stack
841 * properly afterwards as we don't know the calling convention of the
842 * function */
843 #if defined __i386__ && defined _MSC_VER
844 __declspec(naked) LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned int stack_size)
845 {
846 __asm
847 {
848 push ebp
849 push edi ; Save registers
850 push esi
851 mov ebp, esp
852 mov eax, [ebp+16] ; Get stack size
853 sub esp, eax ; Make room in stack for arguments
854 mov edi, esp
855 mov ecx, eax
856 mov esi, [ebp+12]
857 shr ecx, 2
858 cld
859 rep movsd ; Copy dword blocks
860 call [ebp+8] ; Call function
861 lea esp, [ebp-8] ; Restore stack
862 pop esi ; Restore registers
863 pop edi
864 pop ebp
865 ret
866 }
867 }
868 #elif defined __i386__ && defined __GNUC__
869 LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned int stack_size);
870 __ASM_GLOBAL_FUNC(call_server_func,
871 "pushl %ebp\n\t"
872 "movl %esp, %ebp\n\t"
873 "pushl %edi\n\t" /* Save registers */
874 "pushl %esi\n\t"
875 "movl 16(%ebp), %eax\n\t" /* Get stack size */
876 "subl %eax, %esp\n\t" /* Make room in stack for arguments */
877 "andl $~15, %esp\n\t" /* Make sure stack has 16-byte alignment for Mac OS X */
878 "movl %esp, %edi\n\t"
879 "movl %eax, %ecx\n\t"
880 "movl 12(%ebp), %esi\n\t"
881 "shrl $2, %ecx\n\t" /* divide by 4 */
882 "cld\n\t"
883 "rep; movsl\n\t" /* Copy dword blocks */
884 "call *8(%ebp)\n\t" /* Call function */
885 "leal -8(%ebp), %esp\n\t" /* Restore stack */
886 "popl %esi\n\t" /* Restore registers */
887 "popl %edi\n\t"
888 "popl %ebp\n\t"
889 "ret\n" )
890 #else
891 #warning call_server_func not implemented for your architecture
892 LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned short stack_size)
893 {
894 FIXME("Not implemented for your architecture\n");
895 return 0;
896 }
897 #endif
898
899 static DWORD calc_arg_size(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat)
900 {
901 DWORD size;
902 switch(*pFormat)
903 {
904 case RPC_FC_STRUCT:
905 size = *(const WORD*)(pFormat + 2);
906 break;
907 case RPC_FC_CARRAY:
908 size = *(const WORD*)(pFormat + 2);
909 ComputeConformance(pStubMsg, NULL, pFormat + 4, 0);
910 size *= pStubMsg->MaxCount;
911 break;
912 case RPC_FC_SMFARRAY:
913 size = *(const WORD*)(pFormat + 2);
914 break;
915 case RPC_FC_LGFARRAY:
916 size = *(const DWORD*)(pFormat + 2);
917 break;
918 case RPC_FC_BOGUS_ARRAY:
919 pFormat = ComputeConformance(pStubMsg, NULL, pFormat + 4, *(const WORD*)&pFormat[2]);
920 TRACE("conformance = %ld\n", pStubMsg->MaxCount);
921 pFormat = ComputeVariance(pStubMsg, NULL, pFormat, pStubMsg->MaxCount);
922 size = ComplexStructSize(pStubMsg, pFormat);
923 size *= pStubMsg->MaxCount;
924 break;
925 default:
926 FIXME("Unhandled type %02x\n", *pFormat);
927 /* fallthrough */
928 case RPC_FC_RP:
929 size = sizeof(void *);
930 break;
931 }
932 return size;
933 }
934
935 static LONG_PTR *stub_do_args(MIDL_STUB_MESSAGE *pStubMsg,
936 PFORMAT_STRING pFormat, int phase,
937 unsigned char *args,
938 unsigned short number_of_params)
939 {
940 /* counter */
941 unsigned short i;
942 /* current format string offset */
943 int current_offset = 0;
944 /* current stack offset */
945 unsigned short current_stack_offset = 0;
946 /* location to put retval into */
947 LONG_PTR *retval_ptr = NULL;
948
949 for (i = 0; i < number_of_params; i++)
950 {
951 const NDR_PARAM_OIF_BASETYPE *pParam =
952 (const NDR_PARAM_OIF_BASETYPE *)&pFormat[current_offset];
953 unsigned char *pArg;
954
955 current_stack_offset = pParam->stack_offset;
956 pArg = args + current_stack_offset;
957
958 TRACE("param[%d]: new format\n", i);
959 TRACE("\tparam_attributes:"); dump_RPC_FC_PROC_PF(pParam->param_attributes); TRACE("\n");
960 TRACE("\tstack_offset: 0x%x\n", current_stack_offset);
961 TRACE("\tmemory addr (before): %p -> %p\n", pArg, *(unsigned char **)pArg);
962
963 if (pParam->param_attributes.IsBasetype)
964 {
965 const unsigned char *pTypeFormat =
966 &pParam->type_format_char;
967
968 TRACE("\tbase type: 0x%02x\n", *pTypeFormat);
969
970 /* make a note of the address of the return value parameter for later */
971 if (pParam->param_attributes.IsReturn)
972 retval_ptr = (LONG_PTR *)pArg;
973
974 switch (phase)
975 {
976 case STUBLESS_MARSHAL:
977 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
978 {
979 if (pParam->param_attributes.IsSimpleRef)
980 call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
981 else
982 call_marshaller(pStubMsg, pArg, pTypeFormat);
983 }
984 break;
985 case STUBLESS_FREE:
986 if (pParam->param_attributes.ServerAllocSize)
987 HeapFree(GetProcessHeap(), 0, *(void **)pArg);
988 break;
989 case STUBLESS_INITOUT:
990 break;
991 case STUBLESS_UNMARSHAL:
992 if (pParam->param_attributes.ServerAllocSize)
993 *(void **)pArg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
994 pParam->param_attributes.ServerAllocSize * 8);
995
996 if (pParam->param_attributes.IsIn)
997 {
998 if (pParam->param_attributes.IsSimpleRef)
999 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
1000 else
1001 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
1002 }
1003 break;
1004 case STUBLESS_CALCSIZE:
1005 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1006 {
1007 if (pParam->param_attributes.IsSimpleRef)
1008 call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1009 else
1010 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
1011 }
1012 break;
1013 default:
1014 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1015 }
1016
1017 current_offset += sizeof(NDR_PARAM_OIF_BASETYPE);
1018 }
1019 else
1020 {
1021 const NDR_PARAM_OIF_OTHER *pParamOther =
1022 (const NDR_PARAM_OIF_OTHER *)&pFormat[current_offset];
1023
1024 const unsigned char * pTypeFormat =
1025 &(pStubMsg->StubDesc->pFormatTypes[pParamOther->type_offset]);
1026
1027 TRACE("\tcomplex type 0x%02x\n", *pTypeFormat);
1028
1029 switch (phase)
1030 {
1031 case STUBLESS_MARSHAL:
1032 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1033 {
1034 if (pParam->param_attributes.IsByValue)
1035 call_marshaller(pStubMsg, pArg, pTypeFormat);
1036 else
1037 call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1038 }
1039 break;
1040 case STUBLESS_FREE:
1041 if (pParam->param_attributes.MustFree)
1042 {
1043 if (pParam->param_attributes.IsByValue)
1044 call_freer(pStubMsg, pArg, pTypeFormat);
1045 else
1046 call_freer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1047 }
1048
1049 if (pParam->param_attributes.IsOut &&
1050 !pParam->param_attributes.IsIn &&
1051 !pParam->param_attributes.IsByValue &&
1052 !pParam->param_attributes.ServerAllocSize)
1053 {
1054 pStubMsg->pfnFree(*(void **)pArg);
1055 }
1056
1057 if (pParam->param_attributes.ServerAllocSize)
1058 HeapFree(GetProcessHeap(), 0, *(void **)pArg);
1059 break;
1060 case STUBLESS_INITOUT:
1061 if (!pParam->param_attributes.IsIn &&
1062 pParam->param_attributes.IsOut &&
1063 !pParam->param_attributes.ServerAllocSize &&
1064 !pParam->param_attributes.IsByValue)
1065 {
1066 DWORD size = calc_arg_size(pStubMsg, pTypeFormat);
1067
1068 if(size)
1069 {
1070 *(void **)pArg = NdrAllocate(pStubMsg, size);
1071 memset(*(void **)pArg, 0, size);
1072 }
1073 }
1074 break;
1075 case STUBLESS_UNMARSHAL:
1076 if (pParam->param_attributes.ServerAllocSize)
1077 *(void **)pArg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1078 pParam->param_attributes.ServerAllocSize * 8);
1079
1080 if (pParam->param_attributes.IsIn)
1081 {
1082 if (pParam->param_attributes.IsByValue)
1083 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
1084 else
1085 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
1086 }
1087 break;
1088 case STUBLESS_CALCSIZE:
1089 if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1090 {
1091 if (pParam->param_attributes.IsByValue)
1092 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
1093 else
1094 call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1095 }
1096 break;
1097 default:
1098 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1099 }
1100
1101 current_offset += sizeof(NDR_PARAM_OIF_OTHER);
1102 }
1103 TRACE("\tmemory addr (after): %p -> %p\n", pArg, *(unsigned char **)pArg);
1104 }
1105
1106 return retval_ptr;
1107 }
1108
1109 static LONG_PTR *stub_do_old_args(MIDL_STUB_MESSAGE *pStubMsg,
1110 PFORMAT_STRING pFormat, int phase,
1111 unsigned char *args,
1112 unsigned short stack_size, BOOL object)
1113 {
1114 /* counter */
1115 unsigned short i;
1116 /* current format string offset */
1117 int current_offset = 0;
1118 /* current stack offset */
1119 unsigned short current_stack_offset = 0;
1120 /* location to put retval into */
1121 LONG_PTR *retval_ptr = NULL;
1122
1123 for (i = 0; TRUE; i++)
1124 {
1125 const NDR_PARAM_OI_BASETYPE *pParam =
1126 (const NDR_PARAM_OI_BASETYPE *)&pFormat[current_offset];
1127 /* note: current_stack_offset starts after the This pointer
1128 * if present, so adjust this */
1129 unsigned short current_stack_offset_adjusted = current_stack_offset +
1130 (object ? sizeof(void *) : 0);
1131 unsigned char *pArg = args + current_stack_offset_adjusted;
1132
1133 /* no more parameters; exit loop */
1134 if (current_stack_offset_adjusted >= stack_size)
1135 break;
1136
1137 TRACE("param[%d]: old format\n", i);
1138 TRACE("\tparam_direction: 0x%x\n", pParam->param_direction);
1139 TRACE("\tstack_offset: 0x%x\n", current_stack_offset_adjusted);
1140
1141 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE ||
1142 pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1143 {
1144 const unsigned char *pTypeFormat =
1145 &pParam->type_format_char;
1146
1147 TRACE("\tbase type 0x%02x\n", *pTypeFormat);
1148
1149 if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1150 retval_ptr = (LONG_PTR *)pArg;
1151
1152 switch (phase)
1153 {
1154 case STUBLESS_MARSHAL:
1155 if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1156 call_marshaller(pStubMsg, pArg, pTypeFormat);
1157 break;
1158 case STUBLESS_FREE:
1159 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
1160 call_freer(pStubMsg, pArg, pTypeFormat);
1161 break;
1162 case STUBLESS_UNMARSHAL:
1163 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
1164 call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
1165 break;
1166 case STUBLESS_CALCSIZE:
1167 if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1168 call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
1169 break;
1170 default:
1171 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1172 }
1173
1174 current_stack_offset += type_stack_size(*pTypeFormat);
1175 current_offset += sizeof(NDR_PARAM_OI_BASETYPE);
1176 }
1177 else
1178 {
1179 const NDR_PARAM_OI_OTHER *pParamOther =
1180 (const NDR_PARAM_OI_OTHER *)&pFormat[current_offset];
1181
1182 const unsigned char * pTypeFormat =
1183 &pStubMsg->StubDesc->pFormatTypes[pParamOther->type_offset];
1184
1185 TRACE("\tcomplex type 0x%02x\n", *pTypeFormat);
1186
1187 if (pParam->param_direction == RPC_FC_RETURN_PARAM)
1188 retval_ptr = (LONG_PTR *)pArg;
1189
1190 switch (phase)
1191 {
1192 case STUBLESS_MARSHAL:
1193 if (pParam->param_direction == RPC_FC_OUT_PARAM ||
1194 pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1195 pParam->param_direction == RPC_FC_RETURN_PARAM)
1196 call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1197 break;
1198 case STUBLESS_FREE:
1199 if (pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1200 pParam->param_direction == RPC_FC_IN_PARAM)
1201 call_freer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1202 else if (pParam->param_direction == RPC_FC_OUT_PARAM)
1203 pStubMsg->pfnFree(*(void **)pArg);
1204 break;
1205 case STUBLESS_INITOUT:
1206 if (pParam->param_direction == RPC_FC_OUT_PARAM)
1207 {
1208 DWORD size = calc_arg_size(pStubMsg, pTypeFormat);
1209
1210 if(size)
1211 {
1212 *(void **)pArg = NdrAllocate(pStubMsg, size);
1213 memset(*(void **)pArg, 0, size);
1214 }
1215 }
1216 break;
1217 case STUBLESS_UNMARSHAL:
1218 if (pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1219 pParam->param_direction == RPC_FC_IN_PARAM)
1220 call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
1221 break;
1222 case STUBLESS_CALCSIZE:
1223 if (pParam->param_direction == RPC_FC_OUT_PARAM ||
1224 pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1225 pParam->param_direction == RPC_FC_RETURN_PARAM)
1226 call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
1227 break;
1228 default:
1229 RpcRaiseException(RPC_S_INTERNAL_ERROR);
1230 }
1231
1232 current_stack_offset += pParamOther->stack_size * sizeof(INT);
1233 current_offset += sizeof(NDR_PARAM_OI_OTHER);
1234 }
1235 }
1236
1237 return retval_ptr;
1238 }
1239
1240 /***********************************************************************
1241 * NdrStubCall2 [RPCRT4.@]
1242 *
1243 * Unmarshals [in] parameters, calls either a method in an object or a server
1244 * function, marshals any [out] parameters and frees any allocated data.
1245 *
1246 * NOTES
1247 * Used by stubless MIDL-generated code.
1248 */
1249 LONG WINAPI NdrStubCall2(
1250 struct IRpcStubBuffer * pThis,
1251 struct IRpcChannelBuffer * pChannel,
1252 PRPC_MESSAGE pRpcMsg,
1253 DWORD * pdwStubPhase)
1254 {
1255 const MIDL_SERVER_INFO *pServerInfo;
1256 const MIDL_STUB_DESC *pStubDesc;
1257 PFORMAT_STRING pFormat;
1258 MIDL_STUB_MESSAGE stubMsg;
1259 /* pointer to start of stack to pass into stub implementation */
1260 unsigned char * args;
1261 /* size of stack */
1262 unsigned short stack_size;
1263 /* number of parameters. optional for client to give it to us */
1264 unsigned char number_of_params = ~0;
1265 /* cache of Oif_flags from v2 procedure header */
1266 INTERPRETER_OPT_FLAGS Oif_flags = { 0 };
1267 /* cache of extension flags from NDR_PROC_HEADER_EXTS */
1268 INTERPRETER_OPT_FLAGS2 ext_flags = { 0 };
1269 /* the type of pass we are currently doing */
1270 int phase;
1271 /* header for procedure string */
1272 const NDR_PROC_HEADER *pProcHeader;
1273 /* offset in format string for start of params */
1274 int parameter_start_offset;
1275 /* current format string offset */
1276 int current_offset;
1277 /* -Oif or -Oicf generated format */
1278 BOOL bV2Format = FALSE;
1279 /* location to put retval into */
1280 LONG_PTR *retval_ptr = NULL;
1281
1282 TRACE("pThis %p, pChannel %p, pRpcMsg %p, pdwStubPhase %p\n", pThis, pChannel, pRpcMsg, pdwStubPhase);
1283
1284 if (pThis)
1285 pServerInfo = CStdStubBuffer_GetServerInfo(pThis);
1286 else
1287 pServerInfo = ((RPC_SERVER_INTERFACE *)pRpcMsg->RpcInterfaceInformation)->InterpreterInfo;
1288
1289 pStubDesc = pServerInfo->pStubDesc;
1290 pFormat = pServerInfo->ProcString + pServerInfo->FmtStringOffset[pRpcMsg->ProcNum];
1291 pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
1292
1293 /* Later NDR language versions probably won't be backwards compatible */
1294 if (pStubDesc->Version > 0x50002)
1295 {
1296 FIXME("Incompatible stub description version: 0x%x\n", pStubDesc->Version);
1297 RpcRaiseException(RPC_X_WRONG_STUB_VERSION);
1298 }
1299
1300 /* create the full pointer translation tables, if requested */
1301 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
1302 stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_SERVER);
1303
1304 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1305 {
1306 const NDR_PROC_HEADER_RPC *pProcHeader = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
1307 stack_size = pProcHeader->stack_size;
1308 current_offset = sizeof(NDR_PROC_HEADER_RPC);
1309
1310 }
1311 else
1312 {
1313 stack_size = pProcHeader->stack_size;
1314 current_offset = sizeof(NDR_PROC_HEADER);
1315 }
1316
1317 TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
1318
1319 /* binding */
1320 switch (pProcHeader->handle_type)
1321 {
1322 /* explicit binding: parse additional section */
1323 case RPC_FC_BIND_EXPLICIT:
1324 switch (pFormat[current_offset]) /* handle_type */
1325 {
1326 case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */
1327 current_offset += sizeof(NDR_EHD_PRIMITIVE);
1328 break;
1329 case RPC_FC_BIND_GENERIC: /* explicit generic */
1330 current_offset += sizeof(NDR_EHD_GENERIC);
1331 break;
1332 case RPC_FC_BIND_CONTEXT: /* explicit context */
1333 current_offset += sizeof(NDR_EHD_CONTEXT);
1334 break;
1335 default:
1336 ERR("bad explicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
1337 RpcRaiseException(RPC_X_BAD_STUB_DATA);
1338 }
1339 break;
1340 case RPC_FC_BIND_GENERIC: /* implicit generic */
1341 case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */
1342 case RPC_FC_CALLBACK_HANDLE: /* implicit callback */
1343 case RPC_FC_AUTO_HANDLE: /* implicit auto handle */
1344 break;
1345 default:
1346 ERR("bad implicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
1347 RpcRaiseException(RPC_X_BAD_STUB_DATA);
1348 }
1349
1350 bV2Format = (pStubDesc->Version >= 0x20000);
1351
1352 if (bV2Format)
1353 {
1354 const NDR_PROC_PARTIAL_OIF_HEADER *pOIFHeader =
1355 (const NDR_PROC_PARTIAL_OIF_HEADER *)&pFormat[current_offset];
1356
1357 Oif_flags = pOIFHeader->Oi2Flags;
1358 number_of_params = pOIFHeader->number_of_params;
1359
1360 current_offset += sizeof(NDR_PROC_PARTIAL_OIF_HEADER);
1361 }
1362
1363 TRACE("Oif_flags = "); dump_INTERPRETER_OPT_FLAGS(Oif_flags);
1364
1365 if (Oif_flags.HasExtensions)
1366 {
1367 const NDR_PROC_HEADER_EXTS *pExtensions =
1368 (const NDR_PROC_HEADER_EXTS *)&pFormat[current_offset];
1369 ext_flags = pExtensions->Flags2;
1370 current_offset += pExtensions->Size;
1371 }
1372
1373 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1374 NdrStubInitialize(pRpcMsg, &stubMsg, pStubDesc, pChannel);
1375 else
1376 NdrServerInitializeNew(pRpcMsg, &stubMsg, pStubDesc);
1377
1378 /* store the RPC flags away */
1379 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1380 pRpcMsg->RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
1381
1382 /* use alternate memory allocation routines */
1383 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
1384 #if 0
1385 NdrRpcSsEnableAllocate(&stubMsg);
1386 #else
1387 FIXME("Set RPCSS memory allocation routines\n");
1388 #endif
1389
1390 if (Oif_flags.HasPipes)
1391 {
1392 FIXME("pipes not supported yet\n");
1393 RpcRaiseException(RPC_X_WRONG_STUB_VERSION); /* FIXME: remove when implemented */
1394 /* init pipes package */
1395 /* NdrPipesInitialize(...) */
1396 }
1397 if (ext_flags.HasNewCorrDesc)
1398 {
1399 /* initialize extra correlation package */
1400 FIXME("new correlation description not implemented\n");
1401 stubMsg.fHasNewCorrDesc = TRUE;
1402 }
1403
1404 /* convert strings, floating point values and endianess into our
1405 * preferred format */
1406 if ((pRpcMsg->DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
1407 NdrConvert(&stubMsg, pFormat);
1408
1409 parameter_start_offset = current_offset;
1410
1411 TRACE("allocating memory for stack of size %x\n", stack_size);
1412
1413 args = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, stack_size);
1414 stubMsg.StackTop = args; /* used by conformance of top-level objects */
1415
1416 /* add the implicit This pointer as the first arg to the function if we
1417 * are calling an object method */
1418 if (pThis)
1419 *(void **)args = ((CStdStubBuffer *)pThis)->pvServerObject;
1420
1421 /* order of phases:
1422 * 1. STUBLESS_UNMARHSAL - unmarshal [in] params from buffer
1423 * 2. STUBLESS_CALLSERVER - send/receive buffer
1424 * 3. STUBLESS_CALCSIZE - get [out] buffer size
1425 * 4. STUBLESS_GETBUFFER - allocate [out] buffer
1426 * 5. STUBLESS_MARHSAL - marshal [out] params to buffer
1427 */
1428 for (phase = STUBLESS_UNMARSHAL; phase <= STUBLESS_FREE; phase++)
1429 {
1430 TRACE("phase = %d\n", phase);
1431 switch (phase)
1432 {
1433 case STUBLESS_CALLSERVER:
1434 /* call the server function */
1435 if (pServerInfo->ThunkTable && pServerInfo->ThunkTable[pRpcMsg->ProcNum])
1436 pServerInfo->ThunkTable[pRpcMsg->ProcNum](&stubMsg);
1437 else
1438 {
1439 SERVER_ROUTINE func;
1440 LONG_PTR retval;
1441
1442 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1443 {
1444 SERVER_ROUTINE *vtbl = *(SERVER_ROUTINE **)((CStdStubBuffer *)pThis)->pvServerObject;
1445 func = vtbl[pRpcMsg->ProcNum];
1446 }
1447 else
1448 func = pServerInfo->DispatchTable[pRpcMsg->ProcNum];
1449
1450 /* FIXME: what happens with return values that don't fit into a single register on x86? */
1451 retval = call_server_func(func, args, stack_size);
1452
1453 if (retval_ptr)
1454 {
1455 TRACE("stub implementation returned 0x%lx\n", retval);
1456 *retval_ptr = retval;
1457 }
1458 else
1459 TRACE("void stub implementation\n");
1460 }
1461
1462 stubMsg.Buffer = NULL;
1463 stubMsg.BufferLength = 0;
1464
1465 break;
1466 case STUBLESS_GETBUFFER:
1467 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1468 NdrStubGetBuffer(pThis, pChannel, &stubMsg);
1469 else
1470 {
1471 RPC_STATUS Status;
1472
1473 pRpcMsg->BufferLength = stubMsg.BufferLength;
1474 /* allocate buffer for [out] and [ret] params */
1475 Status = I_RpcGetBuffer(pRpcMsg);
1476 if (Status)
1477 RpcRaiseException(Status);
1478 stubMsg.Buffer = pRpcMsg->Buffer;
1479 }
1480 break;
1481 case STUBLESS_UNMARSHAL:
1482 case STUBLESS_INITOUT:
1483 case STUBLESS_CALCSIZE:
1484 case STUBLESS_MARSHAL:
1485 case STUBLESS_FREE:
1486 if (bV2Format)
1487 retval_ptr = stub_do_args(&stubMsg, &pFormat[parameter_start_offset],
1488 phase, args, number_of_params);
1489 else
1490 retval_ptr = stub_do_old_args(&stubMsg, &pFormat[parameter_start_offset],
1491 phase, args, stack_size,
1492 (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT));
1493
1494 break;
1495 default:
1496 ERR("shouldn't reach here. phase %d\n", phase);
1497 break;
1498 }
1499 }
1500
1501 pRpcMsg->BufferLength = (unsigned int)(stubMsg.Buffer - (unsigned char *)pRpcMsg->Buffer);
1502
1503 if (ext_flags.HasNewCorrDesc)
1504 {
1505 /* free extra correlation package */
1506 /* NdrCorrelationFree(&stubMsg); */
1507 }
1508
1509 if (Oif_flags.HasPipes)
1510 {
1511 /* NdrPipesDone(...) */
1512 }
1513
1514 /* free the full pointer translation tables */
1515 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
1516 NdrFullPointerXlatFree(stubMsg.FullPtrXlatTables);
1517
1518 /* free server function stack */
1519 HeapFree(GetProcessHeap(), 0, args);
1520
1521 return S_OK;
1522 }
1523
1524 /***********************************************************************
1525 * NdrServerCall2 [RPCRT4.@]
1526 */
1527 void WINAPI NdrServerCall2(PRPC_MESSAGE pRpcMsg)
1528 {
1529 DWORD dwPhase;
1530 NdrStubCall2(NULL, NULL, pRpcMsg, &dwPhase);
1531 }
Windows API implementation