projects / reactos.git / blob
? search:


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