mshtml/htmltextcont: Initialize value (Coverity).
[wine] / dlls / rpcrt4 / ndr_stubless.c
1 /*
2  * NDR -Oi,-Oif,-Oicf Interpreter
3  *
4  * Copyright 2001 Ove Kåven, TransGaming Technologies
5  * Copyright 2003-5 Robert Shearman (for CodeWeavers)
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  *
21  * TODO:
22  *  - Pipes
23  *  - Some types of binding handles
24  */
25
26 #include "config.h"
27 #include "wine/port.h"
28
29 #include <stdarg.h>
30 #include <stdio.h>
31 #include <string.h>
32
33 #include "windef.h"
34 #include "winbase.h"
35 #include "winerror.h"
36
37 #include "objbase.h"
38 #include "rpc.h"
39 #include "rpcproxy.h"
40 #include "ndrtypes.h"
41
42 #include "wine/debug.h"
43 #include "wine/rpcfc.h"
44
45 #include "ndr_misc.h"
46 #include "cpsf.h"
47
48 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
49
50 #define NDR_TABLE_MASK 127
51
52 static inline void call_buffer_sizer(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
53 {
54     NDR_BUFFERSIZE m = NdrBufferSizer[pFormat[0] & NDR_TABLE_MASK];
55     if (m) m(pStubMsg, pMemory, pFormat);
56     else
57     {
58         FIXME("format type 0x%x not implemented\n", pFormat[0]);
59         RpcRaiseException(RPC_X_BAD_STUB_DATA);
60     }
61 }
62
63 static inline unsigned char *call_marshaller(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
64 {
65     NDR_MARSHALL m = NdrMarshaller[pFormat[0] & NDR_TABLE_MASK];
66     if (m) return m(pStubMsg, pMemory, pFormat);
67     else
68     {
69         FIXME("format type 0x%x not implemented\n", pFormat[0]);
70         RpcRaiseException(RPC_X_BAD_STUB_DATA);
71         return NULL;
72     }
73 }
74
75 static inline unsigned char *call_unmarshaller(PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
76 {
77     NDR_UNMARSHALL m = NdrUnmarshaller[pFormat[0] & NDR_TABLE_MASK];
78     if (m) return m(pStubMsg, ppMemory, pFormat, fMustAlloc);
79     else
80     {
81         FIXME("format type 0x%x not implemented\n", pFormat[0]);
82         RpcRaiseException(RPC_X_BAD_STUB_DATA);
83         return NULL;
84     }
85 }
86
87 static inline void call_freer(PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
88 {
89     NDR_FREE m = NdrFreer[pFormat[0] & NDR_TABLE_MASK];
90     if (m) m(pStubMsg, pMemory, pFormat);
91 }
92
93 static inline unsigned long call_memory_sizer(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
94 {
95     NDR_MEMORYSIZE m = NdrMemorySizer[pFormat[0] & NDR_TABLE_MASK];
96     if (m)
97     {
98         unsigned char *saved_buffer = pStubMsg->Buffer;
99         unsigned long ret;
100         int saved_ignore_embedded_pointers = pStubMsg->IgnoreEmbeddedPointers;
101         pStubMsg->MemorySize = 0;
102         pStubMsg->IgnoreEmbeddedPointers = 1;
103         ret = m(pStubMsg, pFormat);
104         pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded_pointers;
105         pStubMsg->Buffer = saved_buffer;
106         return ret;
107     }
108     else
109     {
110         FIXME("format type 0x%x not implemented\n", pFormat[0]);
111         RpcRaiseException(RPC_X_BAD_STUB_DATA);
112         return 0;
113     }
114 }
115
116 /* there can't be any alignment with the structures in this file */
117 #include "pshpack1.h"
118
119 #define STUBLESS_UNMARSHAL  1
120 #define STUBLESS_CALLSERVER 2
121 #define STUBLESS_CALCSIZE   3
122 #define STUBLESS_GETBUFFER  4
123 #define STUBLESS_MARSHAL    5
124 #define STUBLESS_FREE       6
125
126 /* From http://msdn.microsoft.com/library/default.asp?url=/library/en-us/rpc/rpc/parameter_descriptors.asp */
127 typedef struct _NDR_PROC_HEADER
128 {
129     /* type of handle to use:
130      * RPC_FC_BIND_EXPLICIT = 0 - Explicit handle.
131      *   Handle is passed as a parameter to the function.
132      *   Indicates that explicit handle information follows the header,
133      *   which actually describes the handle.
134      * RPC_FC_BIND_GENERIC = 31 - Implicit handle with custom binding routines
135      *   (MIDL_STUB_DESC::IMPLICIT_HANDLE_INFO::pGenericBindingInfo)
136      * RPC_FC_BIND_PRIMITIVE = 32 - Implicit handle using handle_t created by
137      *   calling application
138      * RPC_FC_AUTO_HANDLE = 33 - Automatic handle
139      * RPC_FC_CALLBACK_HANDLE = 34 - undocmented
140      */
141     unsigned char handle_type;
142
143     /* procedure flags:
144      * Oi_FULL_PTR_USED = 0x01 - A full pointer can have the value NULL and can
145      *   change during the call from NULL to non-NULL and supports aliasing
146      *   and cycles. Indicates that the NdrFullPointerXlatInit function
147      *   should be called.
148      * Oi_RPCSS_ALLOC_USED = 0x02 - Use RpcSS allocate/free routines instead of
149      *   normal allocate/free routines
150      * Oi_OBJECT_PROC = 0x04 - Indicates a procedure that is part of an OLE
151      *   interface, rather than a DCE RPC interface.
152      * Oi_HAS_RPCFLAGS = 0x08 - Indicates that the rpc_flags element is 
153      *   present in the header.
154      * Oi_HAS_COMM_OR_FAULT = 0x20 - If Oi_OBJECT_PROC not present only then
155      *   indicates that the procedure has the comm_status or fault_status
156      *   MIDL attribute.
157      * Oi_OBJ_USE_V2_INTERPRETER = 0x20 - If Oi_OBJECT_PROC present only
158      *   then indicates that the format string is in -Oif or -Oicf format
159      * Oi_USE_NEW_INIT_ROUTINES = 0x40 - Use NdrXInitializeNew instead of
160      *   NdrXInitialize?
161      */
162     unsigned char Oi_flags;
163
164     /* the zero-based index of the procedure */
165     unsigned short proc_num;
166
167     /* total size of all parameters on the stack, including any "this"
168      * pointer and/or return value */
169     unsigned short stack_size;
170 } NDR_PROC_HEADER;
171
172 /* same as above struct except additional element rpc_flags */
173 typedef struct _NDR_PROC_HEADER_RPC
174 {
175     unsigned char handle_type;
176     unsigned char Oi_flags;
177
178     /*
179      * RPCF_Idempotent = 0x0001 - [idempotent] MIDL attribute
180      * RPCF_Broadcast = 0x0002 - [broadcast] MIDL attribute
181      * RPCF_Maybe = 0x0004 - [maybe] MIDL attribute
182      * Reserved = 0x0008 - 0x0080
183      * RPCF_Message = 0x0100 - [message] MIDL attribute
184      * Reserved = 0x0200 - 0x1000
185      * RPCF_InputSynchronous = 0x2000 - unknown
186      * RPCF_Asynchronous = 0x4000 - [async] MIDL attribute
187      * Reserved = 0x8000
188      */
189     unsigned long rpc_flags;
190     unsigned short proc_num;
191     unsigned short stack_size;
192
193 } NDR_PROC_HEADER_RPC;
194
195 typedef struct _NDR_PROC_PARTIAL_OIF_HEADER
196 {
197     /* the pre-computed client buffer size so that interpreter can skip all
198      * or some (if the flag RPC_FC_PROC_OI2F_CLTMUSTSIZE is specified) of the
199      * sizing pass */
200     unsigned short constant_client_buffer_size;
201
202     /* the pre-computed server buffer size so that interpreter can skip all
203      * or some (if the flag RPC_FC_PROC_OI2F_SRVMUSTSIZE is specified) of the
204      * sizing pass */
205     unsigned short constant_server_buffer_size;
206
207     INTERPRETER_OPT_FLAGS Oi2Flags;
208
209     /* number of params */
210     unsigned char number_of_params;
211 } NDR_PROC_PARTIAL_OIF_HEADER;
212
213 typedef struct _NDR_PARAM_OI_BASETYPE
214 {
215     /* parameter direction. One of:
216      * FC_IN_PARAM_BASETYPE = 0x4e - an in param
217      * FC_RETURN_PARAM_BASETYPE = 0x53 - a return param
218      */
219     unsigned char param_direction;
220
221     /* One of: FC_BYTE,FC_CHAR,FC_SMALL,FC_USMALL,FC_WCHAR,FC_SHORT,FC_USHORT,
222      * FC_LONG,FC_ULONG,FC_FLOAT,FC_HYPER,FC_DOUBLE,FC_ENUM16,FC_ENUM32,
223      * FC_ERROR_STATUS_T,FC_INT3264,FC_UINT3264 */
224     unsigned char type_format_char;
225 } NDR_PARAM_OI_BASETYPE;
226
227 typedef struct _NDR_PARAM_OI_OTHER
228 {
229     /* One of:
230      * FC_IN_PARAM = 0x4d - An in param
231      * FC_IN_OUT_PARAM = 0x50 - An in/out param
232      * FC_OUT_PARAM = 0x51 - An out param
233      * FC_RETURN_PARAM = 0x52 - A return value
234      * FC_IN_PARAM_NO_FREE_INST = 0x4f - A param for which no freeing is done
235      */
236     unsigned char param_direction;
237
238     /* Size of param on stack in NUMBERS OF INTS */
239     unsigned char stack_size;
240
241     /* offset in the type format string table */
242     unsigned short type_offset;
243 } NDR_PARAM_OI_OTHER;
244
245 typedef struct _NDR_PARAM_OIF_BASETYPE
246 {
247     PARAM_ATTRIBUTES param_attributes;
248
249     /* the offset on the calling stack where the parameter is located */
250     unsigned short stack_offset;
251
252     /* see NDR_PARAM_OI_BASETYPE::type_format_char */
253     unsigned char type_format_char;
254
255     /* always FC_PAD */
256     unsigned char unused;
257 } NDR_PARAM_OIF_BASETYPE;
258
259 typedef struct _NDR_PARAM_OIF_OTHER
260 {
261     PARAM_ATTRIBUTES param_attributes;
262
263     /* see NDR_PARAM_OIF_BASETYPE::stack_offset */
264     unsigned short stack_offset;
265
266     /* offset into the provided type format string where the type for this
267      * parameter starts */
268     unsigned short type_offset;
269 } NDR_PARAM_OIF_OTHER;
270
271 /* explicit handle description for FC_BIND_PRIMITIVE type */
272 typedef struct _NDR_EHD_PRIMITIVE
273 {
274     /* FC_BIND_PRIMITIVE */
275     unsigned char handle_type;
276
277     /* is the handle passed in via a pointer? */
278     unsigned char flag;
279
280     /* offset from the beginning of the stack to the handle in bytes */
281     unsigned short offset;
282 } NDR_EHD_PRIMITIVE;
283
284 /* explicit handle description for FC_BIND_GENERIC type */
285 typedef struct _NDR_EHD_GENERIC
286 {
287     /* FC_BIND_GENERIC */
288     unsigned char handle_type;
289
290     /* upper 4bits is a flag indicating whether the handle is passed in
291      * via a pointer. lower 4bits is the size of the user defined generic
292      * handle type. the size must be less than or equal to the machine
293      * register size */
294     unsigned char flag_and_size;
295
296     /* offset from the beginning of the stack to the handle in bytes */
297     unsigned short offset;
298
299     /* the index into the aGenericBindingRoutinesPairs field of MIDL_STUB_DESC
300      * giving the bind and unbind routines for the handle */
301     unsigned char binding_routine_pair_index;
302
303     /* FC_PAD */
304     unsigned char unused;
305 } NDR_EHD_GENERIC;
306
307 /* explicit handle description for FC_BIND_CONTEXT type */
308 typedef struct _NDR_EHD_CONTEXT
309 {
310     /* FC_BIND_CONTEXT */
311     unsigned char handle_type;
312
313     /* Any of the following flags:
314      * NDR_CONTEXT_HANDLE_CANNOT_BE_NULL = 0x01
315      * NDR_CONTEXT_HANDLE_SERIALIZE = 0x02
316      * NDR_CONTEXT_HANDLE_NO_SERIALIZE = 0x04
317      * NDR_STRICT_CONTEXT_HANDLE = 0x08
318      * HANDLE_PARAM_IS_OUT = 0x20
319      * HANDLE_PARAM_IS_RETURN = 0x21
320      * HANDLE_PARAM_IS_IN = 0x40
321      * HANDLE_PARAM_IS_VIA_PTR = 0x80
322      */
323     unsigned char flags;
324
325     /* offset from the beginning of the stack to the handle in bytes */
326     unsigned short offset;
327
328     /* zero-based index on rundown routine in apfnNdrRundownRoutines field
329      * of MIDL_STUB_DESC */
330     unsigned char context_rundown_routine_index;
331
332     /* varies depending on NDR version used.
333      * V1: zero-based index into parameters 
334      * V2: zero-based index into handles that are parameters */
335     unsigned char param_num;
336 } NDR_EHD_CONTEXT;
337
338 #include "poppack.h"
339
340 void WINAPI NdrRpcSmSetClientToOsf(PMIDL_STUB_MESSAGE pMessage)
341 {
342 #if 0 /* these functions are not defined yet */
343     pMessage->pfnAllocate = NdrRpcSmClientAllocate;
344     pMessage->pfnFree = NdrRpcSmClientFree;
345 #endif
346 }
347
348 static void WINAPI dump_RPC_FC_PROC_PF(PARAM_ATTRIBUTES param_attributes)
349 {
350     if (param_attributes.MustSize) TRACE(" MustSize");
351     if (param_attributes.MustFree) TRACE(" MustFree");
352     if (param_attributes.IsPipe) TRACE(" IsPipe");
353     if (param_attributes.IsIn) TRACE(" IsIn");
354     if (param_attributes.IsOut) TRACE(" IsOut");
355     if (param_attributes.IsReturn) TRACE(" IsReturn");
356     if (param_attributes.IsBasetype) TRACE(" IsBasetype");
357     if (param_attributes.IsByValue) TRACE(" IsByValue");
358     if (param_attributes.IsSimpleRef) TRACE(" IsSimpleRef");
359     if (param_attributes.IsDontCallFreeInst) TRACE(" IsDontCallFreeInst");
360     if (param_attributes.SaveForAsyncFinish) TRACE(" SaveForAsyncFinish");
361     if (param_attributes.ServerAllocSize) TRACE(" ServerAllocSize = %d", param_attributes.ServerAllocSize * 8);
362 }
363
364 static void WINAPI dump_INTERPRETER_OPT_FLAGS(INTERPRETER_OPT_FLAGS Oi2Flags)
365 {
366     if (Oi2Flags.ServerMustSize) TRACE(" ServerMustSize");
367     if (Oi2Flags.ClientMustSize) TRACE(" ClientMustSize");
368     if (Oi2Flags.HasReturn) TRACE(" HasReturn");
369     if (Oi2Flags.HasPipes) TRACE(" HasPipes");
370     if (Oi2Flags.Unused) TRACE(" Unused");
371     if (Oi2Flags.HasAsyncUuid) TRACE(" HasAsyncUuid");
372     if (Oi2Flags.HasExtensions) TRACE(" HasExtensions");
373     if (Oi2Flags.HasAsyncHandle) TRACE(" HasAsyncHandle");
374     TRACE("\n");
375 }
376
377 #define ARG_FROM_OFFSET(stubMsg, offset) ((stubMsg).StackTop + (offset))
378
379 static PFORMAT_STRING client_get_handle(
380     PMIDL_STUB_MESSAGE pStubMsg, const NDR_PROC_HEADER *pProcHeader,
381     PFORMAT_STRING pFormat, handle_t *phBinding)
382 {
383     /* binding */
384     switch (pProcHeader->handle_type)
385     {
386     /* explicit binding: parse additional section */
387     case RPC_FC_BIND_EXPLICIT:
388         switch (*pFormat) /* handle_type */
389         {
390         case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */
391             {
392                 const NDR_EHD_PRIMITIVE *pDesc = (const NDR_EHD_PRIMITIVE *)pFormat;
393
394                 TRACE("Explicit primitive handle @ %d\n", pDesc->offset);
395
396                 if (pDesc->flag) /* pointer to binding */
397                     *phBinding = **(handle_t **)ARG_FROM_OFFSET(*pStubMsg, pDesc->offset);
398                 else
399                     *phBinding = *(handle_t *)ARG_FROM_OFFSET(*pStubMsg, pDesc->offset);
400                 return pFormat + sizeof(NDR_EHD_PRIMITIVE);
401             }
402         case RPC_FC_BIND_GENERIC: /* explicit generic */
403             {
404                 const NDR_EHD_GENERIC *pDesc = (const NDR_EHD_GENERIC *)pFormat;
405                 void *pObject = NULL;
406                 void *pArg;
407                 const GENERIC_BINDING_ROUTINE_PAIR *pGenPair;
408
409                 TRACE("Explicit generic binding handle #%d\n", pDesc->binding_routine_pair_index);
410
411                 if (pDesc->flag_and_size & HANDLE_PARAM_IS_VIA_PTR)
412                     pArg = *(void **)ARG_FROM_OFFSET(*pStubMsg, pDesc->offset);
413                 else
414                     pArg = (void *)ARG_FROM_OFFSET(*pStubMsg, pDesc->offset);
415                 memcpy(&pObject, pArg, pDesc->flag_and_size & 0xf);
416                 pGenPair = &pStubMsg->StubDesc->aGenericBindingRoutinePairs[pDesc->binding_routine_pair_index];
417                 *phBinding = pGenPair->pfnBind(pObject);
418                 return pFormat + sizeof(NDR_EHD_GENERIC);
419             }
420         case RPC_FC_BIND_CONTEXT: /* explicit context */
421             {
422                 const NDR_EHD_CONTEXT *pDesc = (const NDR_EHD_CONTEXT *)pFormat;
423                 NDR_CCONTEXT context_handle;
424                 TRACE("Explicit bind context\n");
425                 if (pDesc->flags & HANDLE_PARAM_IS_VIA_PTR)
426                 {
427                     TRACE("\tHANDLE_PARAM_IS_VIA_PTR\n");
428                     context_handle = **(NDR_CCONTEXT **)ARG_FROM_OFFSET(*pStubMsg, pDesc->offset);
429                 }
430                 else
431                     context_handle = *(NDR_CCONTEXT *)ARG_FROM_OFFSET(*pStubMsg, pDesc->offset);
432                 if ((pDesc->flags & NDR_CONTEXT_HANDLE_CANNOT_BE_NULL) &&
433                     !context_handle)
434                 {
435                     ERR("null context handle isn't allowed\n");
436                     RpcRaiseException(RPC_X_SS_IN_NULL_CONTEXT);
437                     return NULL;
438                 }
439                 *phBinding = NDRCContextBinding(context_handle);
440                 /* FIXME: should we store this structure in stubMsg.pContext? */
441                 return pFormat + sizeof(NDR_EHD_CONTEXT);
442             }
443         default:
444             ERR("bad explicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
445             RpcRaiseException(RPC_X_BAD_STUB_DATA);
446         }
447         break;
448     case RPC_FC_BIND_GENERIC: /* implicit generic */
449         FIXME("RPC_FC_BIND_GENERIC\n");
450         RpcRaiseException(RPC_X_BAD_STUB_DATA); /* FIXME: remove when implemented */
451         break;
452     case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */
453         TRACE("Implicit primitive handle\n");
454         *phBinding = *pStubMsg->StubDesc->IMPLICIT_HANDLE_INFO.pPrimitiveHandle;
455         break;
456     case RPC_FC_CALLBACK_HANDLE: /* implicit callback */
457         FIXME("RPC_FC_CALLBACK_HANDLE\n");
458         break;
459     case RPC_FC_AUTO_HANDLE: /* implicit auto handle */
460         /* strictly speaking, it isn't necessary to set hBinding here
461          * since it isn't actually used (hence the automatic in its name),
462          * but then why does MIDL generate a valid entry in the
463          * MIDL_STUB_DESC for it? */
464         TRACE("Implicit auto handle\n");
465         *phBinding = *pStubMsg->StubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle;
466         break;
467     default:
468         ERR("bad implicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
469         RpcRaiseException(RPC_X_BAD_STUB_DATA);
470     }
471     return pFormat;
472 }
473
474 static void client_free_handle(
475     PMIDL_STUB_MESSAGE pStubMsg, const NDR_PROC_HEADER *pProcHeader,
476     PFORMAT_STRING pFormat, handle_t hBinding)
477 {
478     /* binding */
479     switch (pProcHeader->handle_type)
480     {
481     /* explicit binding: parse additional section */
482     case RPC_FC_BIND_EXPLICIT:
483         switch (*pFormat) /* handle_type */
484         {
485         case RPC_FC_BIND_GENERIC: /* explicit generic */
486             {
487                 const NDR_EHD_GENERIC *pDesc = (const NDR_EHD_GENERIC *)pFormat;
488                 void *pObject = NULL;
489                 void *pArg;
490                 const GENERIC_BINDING_ROUTINE_PAIR *pGenPair;
491
492                 TRACE("Explicit generic binding handle #%d\n", pDesc->binding_routine_pair_index);
493
494                 if (pDesc->flag_and_size & HANDLE_PARAM_IS_VIA_PTR)
495                     pArg = *(void **)ARG_FROM_OFFSET(*pStubMsg, pDesc->offset);
496                 else
497                     pArg = (void *)ARG_FROM_OFFSET(*pStubMsg, pDesc->offset);
498                 memcpy(&pObject, pArg, pDesc->flag_and_size & 0xf);
499                 pGenPair = &pStubMsg->StubDesc->aGenericBindingRoutinePairs[pDesc->binding_routine_pair_index];
500                 pGenPair->pfnUnbind(pObject, hBinding);
501                 break;
502             }
503         case RPC_FC_BIND_CONTEXT: /* explicit context */
504         case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */
505             break;
506         default:
507             ERR("bad explicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
508             RpcRaiseException(RPC_X_BAD_STUB_DATA);
509         }
510         break;
511     case RPC_FC_BIND_GENERIC: /* implicit generic */
512         FIXME("RPC_FC_BIND_GENERIC\n");
513         RpcRaiseException(RPC_X_BAD_STUB_DATA); /* FIXME: remove when implemented */
514         break;
515     case RPC_FC_CALLBACK_HANDLE: /* implicit callback */
516     case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */
517     case RPC_FC_AUTO_HANDLE: /* implicit auto handle */
518         break;
519     default:
520         ERR("bad implicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
521         RpcRaiseException(RPC_X_BAD_STUB_DATA);
522     }
523 }
524
525 static void client_do_args(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat,
526     int phase, unsigned short number_of_params, unsigned char *pRetVal)
527 {
528     /* current format string offset */
529     int current_offset = 0;
530     /* current stack offset */
531     unsigned short current_stack_offset = 0;
532     /* counter */
533     unsigned short i;
534
535     for (i = 0; i < number_of_params; i++)
536     {
537         const NDR_PARAM_OIF_BASETYPE *pParam =
538             (const NDR_PARAM_OIF_BASETYPE *)&pFormat[current_offset];
539         unsigned char * pArg;
540
541         current_stack_offset = pParam->stack_offset;
542         pArg = ARG_FROM_OFFSET(*pStubMsg, current_stack_offset);
543
544         TRACE("param[%d]: new format\n", i);
545         TRACE("\tparam_attributes:"); dump_RPC_FC_PROC_PF(pParam->param_attributes); TRACE("\n");
546         TRACE("\tstack_offset: 0x%x\n", current_stack_offset);
547         TRACE("\tmemory addr (before): %p\n", pArg);
548
549         if (pParam->param_attributes.IsBasetype)
550         {
551             const unsigned char * pTypeFormat =
552                 &pParam->type_format_char;
553
554             if (pParam->param_attributes.IsSimpleRef)
555                 pArg = *(unsigned char **)pArg;
556
557             TRACE("\tbase type: 0x%02x\n", *pTypeFormat);
558
559             switch (phase)
560             {
561             case PROXY_CALCSIZE:
562                 if (pParam->param_attributes.IsIn)
563                     call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
564                 break;
565             case PROXY_MARSHAL:
566                 if (pParam->param_attributes.IsIn)
567                     call_marshaller(pStubMsg, pArg, pTypeFormat);
568                 break;
569             case PROXY_UNMARSHAL:
570                 if (pParam->param_attributes.IsOut)
571                 {
572                     if (pParam->param_attributes.IsReturn)
573                         call_unmarshaller(pStubMsg, &pRetVal, pTypeFormat, 0);
574                     else
575                         call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
576                     TRACE("pRetVal = %p\n", pRetVal);
577                 }
578                 break;
579             default:
580                 RpcRaiseException(RPC_S_INTERNAL_ERROR);
581             }
582
583             current_offset += sizeof(NDR_PARAM_OIF_BASETYPE);
584         }
585         else
586         {
587             const NDR_PARAM_OIF_OTHER *pParamOther =
588                 (const NDR_PARAM_OIF_OTHER *)&pFormat[current_offset];
589
590             const unsigned char * pTypeFormat =
591                 &(pStubMsg->StubDesc->pFormatTypes[pParamOther->type_offset]);
592
593             /* if a simple ref pointer then we have to do the
594              * check for the pointer being non-NULL. */
595             if (pParam->param_attributes.IsSimpleRef)
596             {
597                 if (!*(unsigned char **)pArg)
598                     RpcRaiseException(RPC_X_NULL_REF_POINTER);
599             }
600
601             TRACE("\tcomplex type: 0x%02x\n", *pTypeFormat);
602
603             switch (phase)
604             {
605             case PROXY_CALCSIZE:
606                 if (pParam->param_attributes.IsIn)
607                 {
608                     if (pParam->param_attributes.IsByValue)
609                         call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
610                     else
611                         call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
612                 }
613                 break;
614             case PROXY_MARSHAL:
615                 if (pParam->param_attributes.IsIn)
616                 {
617                     if (pParam->param_attributes.IsByValue)
618                         call_marshaller(pStubMsg, pArg, pTypeFormat);
619                     else
620                         call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
621                 }
622                 break;
623             case PROXY_UNMARSHAL:
624                 if (pParam->param_attributes.IsOut)
625                 {
626                     if (pParam->param_attributes.IsReturn)
627                         call_unmarshaller(pStubMsg, &pRetVal, pTypeFormat, 0);
628                     else if (pParam->param_attributes.IsByValue)
629                         call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
630                     else
631                         call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
632                 }
633                 break;
634             default:
635                 RpcRaiseException(RPC_S_INTERNAL_ERROR);
636             }
637
638             current_offset += sizeof(NDR_PARAM_OIF_OTHER);
639         }
640         TRACE("\tmemory addr (after): %p\n", pArg);
641     }
642 }
643
644 static void client_do_args_old_format(PMIDL_STUB_MESSAGE pStubMsg,
645     PFORMAT_STRING pFormat, int phase, unsigned short stack_size,
646     unsigned char *pRetVal, BOOL object_proc)
647 {
648     /* current format string offset */
649     int current_offset = 0;
650     /* current stack offset */
651     unsigned short current_stack_offset = 0;
652     /* counter */
653     unsigned short i;
654
655     /* NOTE: V1 style format does't terminate on the number_of_params
656      * condition as it doesn't have this attribute. Instead it
657      * terminates when the stack size given in the header is exceeded.
658      */
659     for (i = 0; TRUE; i++)
660     {
661         const NDR_PARAM_OI_BASETYPE *pParam =
662             (const NDR_PARAM_OI_BASETYPE *)&pFormat[current_offset];
663         /* note: current_stack_offset starts after the This pointer
664          * if present, so adjust this */
665         unsigned short current_stack_offset_adjusted = current_stack_offset +
666             (object_proc ? sizeof(void *) : 0);
667         unsigned char * pArg = ARG_FROM_OFFSET(*pStubMsg, current_stack_offset_adjusted);
668
669         /* no more parameters; exit loop */
670         if (current_stack_offset_adjusted >= stack_size)
671             break;
672
673         TRACE("param[%d]: old format\n", i);
674         TRACE("\tparam_direction: 0x%x\n", pParam->param_direction);
675         TRACE("\tstack_offset: 0x%x\n", current_stack_offset_adjusted);
676         TRACE("\tmemory addr (before): %p\n", pArg);
677
678         if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE ||
679             pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
680         {
681             const unsigned char * pTypeFormat =
682                 &pParam->type_format_char;
683
684             TRACE("\tbase type 0x%02x\n", *pTypeFormat);
685
686             switch (phase)
687             {
688             case PROXY_CALCSIZE:
689                 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
690                     call_buffer_sizer(pStubMsg, pArg, pTypeFormat);
691                 break;
692             case PROXY_MARSHAL:
693                 if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
694                     call_marshaller(pStubMsg, pArg, pTypeFormat);
695                 break;
696             case PROXY_UNMARSHAL:
697                 if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
698                 {
699                     if (pParam->param_direction & RPC_FC_RETURN_PARAM)
700                         call_unmarshaller(pStubMsg, (unsigned char **)pRetVal, pTypeFormat, 0);
701                     else
702                         call_unmarshaller(pStubMsg, &pArg, pTypeFormat, 0);
703                 }
704                 break;
705             default:
706                 RpcRaiseException(RPC_S_INTERNAL_ERROR);
707             }
708
709             current_stack_offset += call_memory_sizer(pStubMsg, pTypeFormat);
710             current_offset += sizeof(NDR_PARAM_OI_BASETYPE);
711         }
712         else
713         {
714             const NDR_PARAM_OI_OTHER *pParamOther = 
715                 (const NDR_PARAM_OI_OTHER *)&pFormat[current_offset];
716
717             const unsigned char *pTypeFormat =
718                 &pStubMsg->StubDesc->pFormatTypes[pParamOther->type_offset];
719
720             TRACE("\tcomplex type 0x%02x\n", *pTypeFormat);
721
722             switch (phase)
723             {
724             case PROXY_CALCSIZE:
725                 if (pParam->param_direction == RPC_FC_IN_PARAM ||
726                     pParam->param_direction & RPC_FC_IN_OUT_PARAM)
727                     call_buffer_sizer(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
728                 break;
729             case PROXY_MARSHAL:
730                 if (pParam->param_direction == RPC_FC_IN_PARAM ||
731                     pParam->param_direction & RPC_FC_IN_OUT_PARAM)
732                     call_marshaller(pStubMsg, *(unsigned char **)pArg, pTypeFormat);
733                 break;
734             case PROXY_UNMARSHAL:
735                 if (pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
736                     pParam->param_direction == RPC_FC_OUT_PARAM)
737                     call_unmarshaller(pStubMsg, (unsigned char **)pArg, pTypeFormat, 0);
738                 else if (pParam->param_direction == RPC_FC_RETURN_PARAM)
739                     call_unmarshaller(pStubMsg, (unsigned char **)pRetVal, pTypeFormat, 0);
740                 break;
741             default:
742                 RpcRaiseException(RPC_S_INTERNAL_ERROR);
743             }
744
745             current_stack_offset += pParamOther->stack_size * sizeof(INT);
746             current_offset += sizeof(NDR_PARAM_OI_OTHER);
747         }
748         TRACE("\tmemory addr (after): %p\n", pArg);
749     }
750 }
751
752 /* the return type should be CLIENT_CALL_RETURN, but this is incompatible
753  * with the way gcc returns structures. "void *" should be the largest type
754  * that MIDL should allow you to return anyway */
755 LONG_PTR WINAPIV NdrClientCall2(PMIDL_STUB_DESC pStubDesc, PFORMAT_STRING pFormat, ...)
756 {
757     /* pointer to start of stack where arguments start */
758     RPC_MESSAGE rpcMsg;
759     MIDL_STUB_MESSAGE stubMsg;
760     handle_t hBinding = NULL;
761     /* procedure number */
762     unsigned short procedure_number;
763     /* size of stack */
764     unsigned short stack_size;
765     /* number of parameters. optional for client to give it to us */
766     unsigned char number_of_params = ~0;
767     /* cache of Oif_flags from v2 procedure header */
768     INTERPRETER_OPT_FLAGS Oif_flags = { 0 };
769     /* cache of extension flags from NDR_PROC_HEADER_EXTS */
770     INTERPRETER_OPT_FLAGS2 ext_flags = { 0 };
771     /* the type of pass we are currently doing */
772     int phase;
773     /* header for procedure string */
774     const NDR_PROC_HEADER * pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
775     /* -Oif or -Oicf generated format */
776     BOOL bV2Format = FALSE;
777     /* the value to return to the client from the remote procedure */
778     LONG_PTR RetVal = 0;
779     /* the pointer to the object when in OLE mode */
780     void * This = NULL;
781     PFORMAT_STRING pHandleFormat;
782
783     TRACE("pStubDesc %p, pFormat %p, ...\n", pStubDesc, pFormat);
784
785     /* Later NDR language versions probably won't be backwards compatible */
786     if (pStubDesc->Version > 0x50002)
787     {
788         FIXME("Incompatible stub description version: 0x%x\n", pStubDesc->Version);
789         RpcRaiseException(RPC_X_WRONG_STUB_VERSION);
790     }
791
792     if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
793     {
794         const NDR_PROC_HEADER_RPC *pProcHeader = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
795         stack_size = pProcHeader->stack_size;
796         procedure_number = pProcHeader->proc_num;
797         pFormat += sizeof(NDR_PROC_HEADER_RPC);
798     }
799     else
800     {
801         stack_size = pProcHeader->stack_size;
802         procedure_number = pProcHeader->proc_num;
803         pFormat += sizeof(NDR_PROC_HEADER);
804     }
805     TRACE("stack size: 0x%x\n", stack_size);
806     TRACE("proc num: %d\n", procedure_number);
807
808     /* create the full pointer translation tables, if requested */
809     if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
810         stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
811
812     if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
813     {
814         /* object is always the first argument */
815         This = **(void *const **)(&pFormat+1);
816         NdrProxyInitialize(This, &rpcMsg, &stubMsg, pStubDesc, procedure_number);
817     }
818     else
819         NdrClientInitializeNew(&rpcMsg, &stubMsg, pStubDesc, procedure_number);
820
821     TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
822     TRACE("MIDL stub version = 0x%x\n", pStubDesc->MIDLVersion);
823
824     /* needed for conformance of top-level objects */
825 #ifdef __i386__
826     stubMsg.StackTop = *(unsigned char **)(&pFormat+1);
827 #else
828 # warning Stack not retrieved for your CPU architecture
829 #endif
830
831     pHandleFormat = pFormat;
832
833     /* we only need a handle if this isn't an object method */
834     if (!(pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT))
835     {
836         pFormat = client_get_handle(&stubMsg, pProcHeader, pHandleFormat, &hBinding);
837         if (!pFormat) return 0;
838     }
839
840     bV2Format = (pStubDesc->Version >= 0x20000);
841
842     if (bV2Format)
843     {
844         const NDR_PROC_PARTIAL_OIF_HEADER *pOIFHeader =
845             (const NDR_PROC_PARTIAL_OIF_HEADER *)pFormat;
846
847         Oif_flags = pOIFHeader->Oi2Flags;
848         number_of_params = pOIFHeader->number_of_params;
849
850         pFormat += sizeof(NDR_PROC_PARTIAL_OIF_HEADER);
851     }
852
853     TRACE("Oif_flags = "); dump_INTERPRETER_OPT_FLAGS(Oif_flags);
854
855     if (Oif_flags.HasExtensions)
856     {
857         const NDR_PROC_HEADER_EXTS *pExtensions =
858             (const NDR_PROC_HEADER_EXTS *)pFormat;
859         ext_flags = pExtensions->Flags2;
860         pFormat += pExtensions->Size;
861     }
862
863     stubMsg.BufferLength = 0;
864
865     /* store the RPC flags away */
866     if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
867         rpcMsg.RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
868
869     /* use alternate memory allocation routines */
870     if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
871         NdrRpcSmSetClientToOsf(&stubMsg);
872
873     if (Oif_flags.HasPipes)
874     {
875         FIXME("pipes not supported yet\n");
876         RpcRaiseException(RPC_X_WRONG_STUB_VERSION); /* FIXME: remove when implemented */
877         /* init pipes package */
878         /* NdrPipesInitialize(...) */
879     }
880     if (ext_flags.HasNewCorrDesc)
881     {
882         /* initialize extra correlation package */
883         FIXME("new correlation description not implemented\n");
884         stubMsg.fHasNewCorrDesc = TRUE;
885     }
886
887     /* order of phases:
888      * 1. PROXY_CALCSIZE - calculate the buffer size
889      * 2. PROXY_GETBUFFER - allocate the buffer
890      * 3. PROXY_MARHSAL - marshal [in] params into the buffer
891      * 4. PROXY_SENDRECEIVE - send/receive buffer
892      * 5. PROXY_UNMARHSAL - unmarshal [out] params from buffer
893      */
894     for (phase = PROXY_CALCSIZE; phase <= PROXY_UNMARSHAL; phase++)
895     {
896         TRACE("phase = %d\n", phase);
897         switch (phase)
898         {
899         case PROXY_GETBUFFER:
900             /* allocate the buffer */
901             if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
902                 NdrProxyGetBuffer(This, &stubMsg);
903             else if (Oif_flags.HasPipes)
904                 /* NdrGetPipeBuffer(...) */
905                 FIXME("pipes not supported yet\n");
906             else
907             {
908                 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
909 #if 0
910                     NdrNsGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
911 #else
912                     FIXME("using auto handle - call NdrNsGetBuffer when it gets implemented\n");
913 #endif
914                 else
915                     NdrGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
916             }
917             break;
918         case PROXY_SENDRECEIVE:
919             /* send the [in] params and receive the [out] and [retval]
920              * params */
921             if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
922                 NdrProxySendReceive(This, &stubMsg);
923             else if (Oif_flags.HasPipes)
924                 /* NdrPipesSendReceive(...) */
925                 FIXME("pipes not supported yet\n");
926             else
927             {
928                 if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
929 #if 0
930                     NdrNsSendReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
931 #else
932                     FIXME("using auto handle - call NdrNsSendReceive when it gets implemented\n");
933 #endif
934                 else
935                     NdrSendReceive(&stubMsg, stubMsg.Buffer);
936             }
937
938             /* convert strings, floating point values and endianess into our
939              * preferred format */
940             if ((rpcMsg.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
941                 NdrConvert(&stubMsg, pFormat);
942
943             break;
944         case PROXY_CALCSIZE:
945         case PROXY_MARSHAL:
946         case PROXY_UNMARSHAL:
947             if (bV2Format)
948                 client_do_args(&stubMsg, pFormat, phase, number_of_params,
949                     (unsigned char *)&RetVal);
950             else
951                 client_do_args_old_format(&stubMsg, pFormat, phase, stack_size,
952                     (unsigned char *)&RetVal,
953                     (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT));
954             break;
955         default:
956             ERR("shouldn't reach here. phase %d\n", phase);
957             break;
958         }
959     }
960
961     if (ext_flags.HasNewCorrDesc)
962     {
963         /* free extra correlation package */
964         /* NdrCorrelationFree(&stubMsg); */
965     }
966
967     if (Oif_flags.HasPipes)
968     {
969         /* NdrPipesDone(...) */
970     }
971
972     /* free the full pointer translation tables */
973     if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
974         NdrFullPointerXlatFree(stubMsg.FullPtrXlatTables);
975
976     /* free marshalling buffer */
977     if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
978         NdrProxyFreeBuffer(This, &stubMsg);
979     else
980     {
981         NdrFreeBuffer(&stubMsg);
982         client_free_handle(&stubMsg, pProcHeader, pHandleFormat, hBinding);
983     }
984
985     TRACE("RetVal = 0x%lx\n", RetVal);
986
987     return RetVal;
988 }
989
990 /* calls a function with the specificed arguments, restoring the stack
991  * properly afterwards as we don't know the calling convention of the
992  * function */
993 #if defined __i386__ && defined _MSC_VER
994 __declspec(naked) LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned int stack_size)
995 {
996     __asm
997     {
998         push ebp
999         push edi            ; Save registers
1000         push esi
1001         mov ebp, esp
1002         mov eax, [ebp+16]   ; Get stack size
1003         sub esp, eax        ; Make room in stack for arguments
1004         mov edi, esp
1005         mov ecx, eax
1006         mov esi, [ebp+12]
1007         shr ecx, 2
1008         cld
1009         rep movsd           ; Copy dword blocks
1010         call [ebp+8]        ; Call function
1011         lea esp, [ebp-8]    ; Restore stack
1012         pop esi             ; Restore registers
1013         pop edi
1014         pop ebp
1015         ret
1016     }
1017 }
1018 #elif defined __i386__ && defined __GNUC__
1019 LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned int stack_size);
1020 __ASM_GLOBAL_FUNC(call_server_func,
1021     "pushl %ebp\n\t"
1022     "movl %esp, %ebp\n\t"
1023     "pushl %edi\n\t"            /* Save registers */
1024     "pushl %esi\n\t"
1025     "movl 16(%ebp), %eax\n\t"   /* Get stack size */
1026     "subl %eax, %esp\n\t"       /* Make room in stack for arguments */
1027     "andl $~15, %esp\n\t"       /* Make sure stack has 16-byte alignment for Mac OS X */
1028     "movl %esp, %edi\n\t"
1029     "movl %eax, %ecx\n\t"
1030     "movl 12(%ebp), %esi\n\t"
1031     "shrl $2, %ecx\n\t"         /* divide by 4 */
1032     "cld\n\t"
1033     "rep; movsl\n\t"            /* Copy dword blocks */
1034     "call *8(%ebp)\n\t"         /* Call function */
1035     "leal -8(%ebp), %esp\n\t"   /* Restore stack */
1036     "popl %esi\n\t"             /* Restore registers */
1037     "popl %edi\n\t"
1038     "popl %ebp\n\t"
1039     "ret\n" )
1040 #else
1041 #warning call_server_func not implemented for your architecture
1042 LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned short stack_size)
1043 {
1044     FIXME("Not implemented for your architecture\n");
1045     return 0;
1046 }
1047 #endif
1048
1049 static DWORD calc_arg_size(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat)
1050 {
1051     DWORD size;
1052     switch(*pFormat)
1053     {
1054     case RPC_FC_STRUCT:
1055         size = *(const WORD*)(pFormat + 2);
1056         break;
1057     case RPC_FC_CARRAY:
1058         size = *(const WORD*)(pFormat + 2);
1059         ComputeConformance(pStubMsg, NULL, pFormat + 4, 0);
1060         size *= pStubMsg->MaxCount;
1061         break;
1062     case RPC_FC_SMFARRAY:
1063         size = *(const WORD*)(pFormat + 2);
1064         break;
1065     case RPC_FC_LGFARRAY:
1066         size = *(const DWORD*)(pFormat + 2);
1067         break;
1068     default:
1069         FIXME("Unhandled type %02x\n", *pFormat);
1070         /* fallthrough */
1071     case RPC_FC_RP:
1072         size = sizeof(void *);
1073         break;
1074     }
1075     return size;
1076 }
1077
1078 /* FIXME: need to free some stuff in here too */
1079 LONG WINAPI NdrStubCall2(
1080     struct IRpcStubBuffer * pThis,
1081     struct IRpcChannelBuffer * pChannel,
1082     PRPC_MESSAGE pRpcMsg,
1083     DWORD * pdwStubPhase)
1084 {
1085     const MIDL_SERVER_INFO *pServerInfo;
1086     const MIDL_STUB_DESC *pStubDesc;
1087     PFORMAT_STRING pFormat;
1088     MIDL_STUB_MESSAGE stubMsg;
1089     /* pointer to start of stack to pass into stub implementation */
1090     unsigned char * args;
1091     /* size of stack */
1092     unsigned short stack_size;
1093     /* current stack offset */
1094     unsigned short current_stack_offset;
1095     /* number of parameters. optional for client to give it to us */
1096     unsigned char number_of_params = ~0;
1097     /* counter */
1098     unsigned short i;
1099     /* cache of Oif_flags from v2 procedure header */
1100     INTERPRETER_OPT_FLAGS Oif_flags = { 0 };
1101     /* cache of extension flags from NDR_PROC_HEADER_EXTS */
1102     INTERPRETER_OPT_FLAGS2 ext_flags = { 0 };
1103     /* the type of pass we are currently doing */
1104     int phase;
1105     /* header for procedure string */
1106     const NDR_PROC_HEADER *pProcHeader;
1107     /* offset in format string for start of params */
1108     int parameter_start_offset;
1109     /* current format string offset */
1110     int current_offset;
1111     /* -Oif or -Oicf generated format */
1112     BOOL bV2Format = FALSE;
1113     /* location to put retval into */
1114     LONG_PTR *retval_ptr = NULL;
1115
1116     TRACE("pThis %p, pChannel %p, pRpcMsg %p, pdwStubPhase %p\n", pThis, pChannel, pRpcMsg, pdwStubPhase);
1117
1118     if (pThis)
1119         pServerInfo = CStdStubBuffer_GetServerInfo(pThis);
1120     else
1121         pServerInfo = ((RPC_SERVER_INTERFACE *)pRpcMsg->RpcInterfaceInformation)->InterpreterInfo;
1122
1123     pStubDesc = pServerInfo->pStubDesc;
1124     pFormat = pServerInfo->ProcString + pServerInfo->FmtStringOffset[pRpcMsg->ProcNum];
1125     pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
1126
1127     /* Later NDR language versions probably won't be backwards compatible */
1128     if (pStubDesc->Version > 0x50002)
1129     {
1130         FIXME("Incompatible stub description version: 0x%x\n", pStubDesc->Version);
1131         RpcRaiseException(RPC_X_WRONG_STUB_VERSION);
1132     }
1133
1134     /* create the full pointer translation tables, if requested */
1135     if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
1136         stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_SERVER);
1137
1138     if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1139     {
1140         const NDR_PROC_HEADER_RPC *pProcHeader = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
1141         stack_size = pProcHeader->stack_size;
1142         current_offset = sizeof(NDR_PROC_HEADER_RPC);
1143
1144     }
1145     else
1146     {
1147         stack_size = pProcHeader->stack_size;
1148         current_offset = sizeof(NDR_PROC_HEADER);
1149     }
1150
1151     TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
1152
1153     /* binding */
1154     switch (pProcHeader->handle_type)
1155     {
1156     /* explicit binding: parse additional section */
1157     case RPC_FC_BIND_EXPLICIT:
1158         switch (pFormat[current_offset]) /* handle_type */
1159         {
1160         case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */
1161             current_offset += sizeof(NDR_EHD_PRIMITIVE);
1162             break;
1163         case RPC_FC_BIND_GENERIC: /* explicit generic */
1164             current_offset += sizeof(NDR_EHD_GENERIC);
1165             break;
1166         case RPC_FC_BIND_CONTEXT: /* explicit context */
1167             current_offset += sizeof(NDR_EHD_CONTEXT);
1168             break;
1169         default:
1170             ERR("bad explicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
1171             RpcRaiseException(RPC_X_BAD_STUB_DATA);
1172         }
1173         break;
1174     case RPC_FC_BIND_GENERIC: /* implicit generic */
1175     case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */
1176     case RPC_FC_CALLBACK_HANDLE: /* implicit callback */
1177     case RPC_FC_AUTO_HANDLE: /* implicit auto handle */
1178         break;
1179     default:
1180         ERR("bad implicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
1181         RpcRaiseException(RPC_X_BAD_STUB_DATA);
1182     }
1183
1184     bV2Format = (pStubDesc->Version >= 0x20000);
1185
1186     if (bV2Format)
1187     {
1188         const NDR_PROC_PARTIAL_OIF_HEADER *pOIFHeader =
1189             (const NDR_PROC_PARTIAL_OIF_HEADER *)&pFormat[current_offset];
1190
1191         Oif_flags = pOIFHeader->Oi2Flags;
1192         number_of_params = pOIFHeader->number_of_params;
1193
1194         current_offset += sizeof(NDR_PROC_PARTIAL_OIF_HEADER);
1195     }
1196
1197     TRACE("Oif_flags = "); dump_INTERPRETER_OPT_FLAGS(Oif_flags);
1198
1199     if (Oif_flags.HasExtensions)
1200     {
1201         const NDR_PROC_HEADER_EXTS *pExtensions =
1202             (const NDR_PROC_HEADER_EXTS *)&pFormat[current_offset];
1203         ext_flags = pExtensions->Flags2;
1204         current_offset += pExtensions->Size;
1205     }
1206
1207     if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1208         NdrStubInitialize(pRpcMsg, &stubMsg, pStubDesc, pChannel);
1209     else
1210         NdrServerInitializeNew(pRpcMsg, &stubMsg, pStubDesc);
1211
1212     /* store the RPC flags away */
1213     if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
1214         pRpcMsg->RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
1215
1216     /* use alternate memory allocation routines */
1217     if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
1218 #if 0
1219           NdrRpcSsEnableAllocate(&stubMsg);
1220 #else
1221           FIXME("Set RPCSS memory allocation routines\n");
1222 #endif
1223
1224     if (Oif_flags.HasPipes)
1225     {
1226         FIXME("pipes not supported yet\n");
1227         RpcRaiseException(RPC_X_WRONG_STUB_VERSION); /* FIXME: remove when implemented */
1228         /* init pipes package */
1229         /* NdrPipesInitialize(...) */
1230     }
1231     if (ext_flags.HasNewCorrDesc)
1232     {
1233         /* initialize extra correlation package */
1234         FIXME("new correlation description not implemented\n");
1235         stubMsg.fHasNewCorrDesc = TRUE;
1236     }
1237
1238     /* convert strings, floating point values and endianess into our
1239      * preferred format */
1240     if ((pRpcMsg->DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
1241         NdrConvert(&stubMsg, pFormat);
1242
1243     parameter_start_offset = current_offset;
1244
1245     TRACE("allocating memory for stack of size %x\n", stack_size);
1246
1247     args = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, stack_size);
1248     stubMsg.StackTop = args; /* used by conformance of top-level objects */
1249
1250     /* add the implicit This pointer as the first arg to the function if we
1251      * are calling an object method */
1252     if (pThis)
1253         *(void **)args = ((CStdStubBuffer *)pThis)->pvServerObject;
1254
1255     /* order of phases:
1256      * 1. STUBLESS_UNMARHSAL - unmarshal [in] params from buffer
1257      * 2. STUBLESS_CALLSERVER - send/receive buffer
1258      * 3. STUBLESS_CALCSIZE - get [out] buffer size
1259      * 4. STUBLESS_GETBUFFER - allocate [out] buffer
1260      * 5. STUBLESS_MARHSAL - marshal [out] params to buffer
1261      */
1262     for (phase = STUBLESS_UNMARSHAL; phase <= STUBLESS_FREE; phase++)
1263     {
1264         TRACE("phase = %d\n", phase);
1265         switch (phase)
1266         {
1267         case STUBLESS_CALLSERVER:
1268             /* call the server function */
1269             if (pServerInfo->ThunkTable && pServerInfo->ThunkTable[pRpcMsg->ProcNum])
1270                 pServerInfo->ThunkTable[pRpcMsg->ProcNum](&stubMsg);
1271             else
1272             {
1273                 SERVER_ROUTINE func;
1274                 LONG_PTR retval;
1275
1276                 if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1277                 {
1278                     SERVER_ROUTINE *vtbl = *(SERVER_ROUTINE **)((CStdStubBuffer *)pThis)->pvServerObject;
1279                     func = vtbl[pRpcMsg->ProcNum];
1280                 }
1281                 else
1282                     func = pServerInfo->DispatchTable[pRpcMsg->ProcNum];
1283
1284                 /* FIXME: what happens with return values that don't fit into a single register on x86? */
1285                 retval = call_server_func(func, args, stack_size);
1286
1287                 if (retval_ptr)
1288                 {
1289                     TRACE("stub implementation returned 0x%lx\n", retval);
1290                     *retval_ptr = retval;
1291                 }
1292                 else
1293                     TRACE("void stub implementation\n");
1294             }
1295
1296             stubMsg.Buffer = NULL;
1297             stubMsg.BufferLength = 0;
1298
1299             break;
1300         case STUBLESS_GETBUFFER:
1301             if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
1302                 NdrStubGetBuffer(pThis, pChannel, &stubMsg);
1303             else
1304             {
1305                 RPC_STATUS Status;
1306
1307                 pRpcMsg->BufferLength = stubMsg.BufferLength;
1308                 /* allocate buffer for [out] and [ret] params */
1309                 Status = I_RpcGetBuffer(pRpcMsg); 
1310                 if (Status)
1311                     RpcRaiseException(Status);
1312                 stubMsg.BufferStart = pRpcMsg->Buffer;
1313                 stubMsg.BufferEnd = stubMsg.BufferStart + stubMsg.BufferLength;
1314                 stubMsg.Buffer = stubMsg.BufferStart;
1315             }
1316             break;
1317         case STUBLESS_MARSHAL:
1318         case STUBLESS_UNMARSHAL:
1319         case STUBLESS_CALCSIZE:
1320         case STUBLESS_FREE:
1321             current_offset = parameter_start_offset;
1322             current_stack_offset = 0;
1323
1324             /* NOTE: V1 style format does't terminate on the number_of_params
1325              * condition as it doesn't have this attribute. Instead it
1326              * terminates when the stack size given in the header is exceeded.
1327              */
1328             for (i = 0; i < number_of_params; i++)
1329             {
1330                 if (bV2Format) /* new parameter format */
1331                 {
1332                     const NDR_PARAM_OIF_BASETYPE *pParam =
1333                         (const NDR_PARAM_OIF_BASETYPE *)&pFormat[current_offset];
1334                     unsigned char *pArg;
1335
1336                     current_stack_offset = pParam->stack_offset;
1337                     pArg = (unsigned char *)(args+current_stack_offset);
1338
1339                     TRACE("param[%d]: new format\n", i);
1340                     TRACE("\tparam_attributes:"); dump_RPC_FC_PROC_PF(pParam->param_attributes); TRACE("\n");
1341                     TRACE("\tstack_offset: 0x%x\n", current_stack_offset);
1342                     TRACE("\tmemory addr (before): %p -> %p\n", pArg, *(unsigned char **)pArg);
1343
1344                     if (pParam->param_attributes.IsBasetype)
1345                     {
1346                         const unsigned char *pTypeFormat =
1347                             &pParam->type_format_char;
1348
1349                         TRACE("\tbase type: 0x%02x\n", *pTypeFormat);
1350
1351                         switch (phase)
1352                         {
1353                         case STUBLESS_MARSHAL:
1354                             if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1355                             {
1356                                 if (pParam->param_attributes.IsSimpleRef)
1357                                     call_marshaller(&stubMsg, *(unsigned char **)pArg, pTypeFormat);
1358                                 else
1359                                     call_marshaller(&stubMsg, pArg, pTypeFormat);
1360                             }
1361                             break;
1362                         case STUBLESS_FREE:
1363                             if (pParam->param_attributes.ServerAllocSize)
1364                                 HeapFree(GetProcessHeap(), 0, *(void **)pArg);
1365                             break;
1366                         case STUBLESS_UNMARSHAL:
1367                             if (pParam->param_attributes.ServerAllocSize)
1368                                 *(void **)pArg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1369                                     pParam->param_attributes.ServerAllocSize * 8);
1370
1371                             if (pParam->param_attributes.IsIn)
1372                             {
1373                                 if (pParam->param_attributes.IsSimpleRef)
1374                                     call_unmarshaller(&stubMsg, (unsigned char **)pArg, pTypeFormat, 0);
1375                                 else
1376                                     call_unmarshaller(&stubMsg, &pArg, pTypeFormat, 0);
1377                             }
1378
1379                             /* make a note of the address of the return value parameter for later */
1380                             if (pParam->param_attributes.IsReturn)
1381                                 retval_ptr = (LONG_PTR *)pArg;
1382
1383                             break;
1384                         case STUBLESS_CALCSIZE:
1385                             if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1386                             {
1387                                 if (pParam->param_attributes.IsSimpleRef)
1388                                     call_buffer_sizer(&stubMsg, *(unsigned char **)pArg, pTypeFormat);
1389                                 else
1390                                     call_buffer_sizer(&stubMsg, pArg, pTypeFormat);
1391                             }
1392                             break;
1393                         default:
1394                             RpcRaiseException(RPC_S_INTERNAL_ERROR);
1395                         }
1396
1397                         current_offset += sizeof(NDR_PARAM_OIF_BASETYPE);
1398                     }
1399                     else
1400                     {
1401                         const NDR_PARAM_OIF_OTHER *pParamOther =
1402                             (const NDR_PARAM_OIF_OTHER *)&pFormat[current_offset];
1403
1404                         const unsigned char * pTypeFormat =
1405                             &(pStubDesc->pFormatTypes[pParamOther->type_offset]);
1406
1407                         TRACE("\tcomplex type 0x%02x\n", *pTypeFormat);
1408
1409                         switch (phase)
1410                         {
1411                         case STUBLESS_MARSHAL:
1412                             if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1413                             {
1414                                 if (pParam->param_attributes.IsByValue)
1415                                     call_marshaller(&stubMsg, pArg, pTypeFormat);
1416                                 else
1417                                     call_marshaller(&stubMsg, *(unsigned char **)pArg, pTypeFormat);
1418                             }
1419                             break;
1420                         case STUBLESS_FREE:
1421                             if (pParam->param_attributes.MustFree)
1422                             {
1423                                 if (pParam->param_attributes.IsByValue)
1424                                     call_freer(&stubMsg, pArg, pTypeFormat);
1425                                 else
1426                                     call_freer(&stubMsg, *(unsigned char **)pArg, pTypeFormat);
1427                             }
1428
1429                             if (pParam->param_attributes.IsOut &&
1430                                 !pParam->param_attributes.IsIn &&
1431                                 !pParam->param_attributes.IsByValue &&
1432                                 !pParam->param_attributes.ServerAllocSize)
1433                             {
1434                                 stubMsg.pfnFree(*(void **)pArg);
1435                             }
1436
1437                             if (pParam->param_attributes.ServerAllocSize)
1438                                 HeapFree(GetProcessHeap(), 0, *(void **)pArg);
1439                             /* FIXME: call call_freer here for IN types with MustFree set */
1440                             break;
1441                         case STUBLESS_UNMARSHAL:
1442                             if (pParam->param_attributes.ServerAllocSize)
1443                                 *(void **)pArg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1444                                     pParam->param_attributes.ServerAllocSize * 8);
1445
1446                             if (pParam->param_attributes.IsIn)
1447                             {
1448                                 if (pParam->param_attributes.IsByValue)
1449                                     call_unmarshaller(&stubMsg, &pArg, pTypeFormat, 0);
1450                                 else
1451                                     call_unmarshaller(&stubMsg, (unsigned char **)pArg, pTypeFormat, 0);
1452                             }
1453                             else if (pParam->param_attributes.IsOut &&
1454                                      !pParam->param_attributes.ServerAllocSize &&
1455                                      !pParam->param_attributes.IsByValue)
1456                             {
1457                                 DWORD size = calc_arg_size(&stubMsg, pTypeFormat);
1458
1459                                 if(size)
1460                                 {
1461                                     *(void **)pArg = NdrAllocate(&stubMsg, size);
1462                                     memset(*(void **)pArg, 0, size);
1463                                 }
1464                             }
1465                             break;
1466                         case STUBLESS_CALCSIZE:
1467                             if (pParam->param_attributes.IsOut || pParam->param_attributes.IsReturn)
1468                             {
1469                                 if (pParam->param_attributes.IsByValue)
1470                                     call_buffer_sizer(&stubMsg, pArg, pTypeFormat);
1471                                 else
1472                                     call_buffer_sizer(&stubMsg, *(unsigned char **)pArg, pTypeFormat);
1473                             }
1474                             break;
1475                         default:
1476                             RpcRaiseException(RPC_S_INTERNAL_ERROR);
1477                         }
1478
1479                         current_offset += sizeof(NDR_PARAM_OIF_OTHER);
1480                     }
1481                     TRACE("\tmemory addr (after): %p -> %p\n", pArg, *(unsigned char **)pArg);
1482                 }
1483                 else /* old parameter format */
1484                 {
1485                     const NDR_PARAM_OI_BASETYPE *pParam =
1486                         (const NDR_PARAM_OI_BASETYPE *)&pFormat[current_offset];
1487                     /* note: current_stack_offset starts after the This pointer
1488                      * if present, so adjust this */
1489                     unsigned short current_stack_offset_adjusted = current_stack_offset +
1490                         ((pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT) ? sizeof(void *) : 0);
1491                     unsigned char *pArg = (unsigned char *)(args+current_stack_offset_adjusted);
1492
1493                     /* no more parameters; exit loop */
1494                     if (current_stack_offset_adjusted >= stack_size)
1495                         break;
1496
1497                     TRACE("param[%d]: old format\n", i);
1498                     TRACE("\tparam_direction: 0x%x\n", pParam->param_direction);
1499                     TRACE("\tstack_offset: 0x%x\n", current_stack_offset_adjusted);
1500
1501                     if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE ||
1502                         pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1503                     {
1504                         const unsigned char *pTypeFormat =
1505                             &pParam->type_format_char;
1506
1507                         TRACE("\tbase type 0x%02x\n", *pTypeFormat);
1508
1509                         switch (phase)
1510                         {
1511                         case STUBLESS_MARSHAL:
1512                             if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1513                                 call_marshaller(&stubMsg, pArg, pTypeFormat);
1514                             break;
1515                         case STUBLESS_FREE:
1516                             if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
1517                                 call_freer(&stubMsg, pArg, pTypeFormat);
1518                             break;
1519                         case STUBLESS_UNMARSHAL:
1520                             if (pParam->param_direction == RPC_FC_IN_PARAM_BASETYPE)
1521                                 call_unmarshaller(&stubMsg, &pArg, pTypeFormat, 0);
1522                             else if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1523                                 retval_ptr = (LONG_PTR *)pArg;
1524                             break;
1525                         case STUBLESS_CALCSIZE:
1526                             if (pParam->param_direction == RPC_FC_RETURN_PARAM_BASETYPE)
1527                                 call_buffer_sizer(&stubMsg, pArg, pTypeFormat);
1528                             break;
1529                         default:
1530                             RpcRaiseException(RPC_S_INTERNAL_ERROR);
1531                         }
1532
1533                         current_stack_offset += call_memory_sizer(&stubMsg, pTypeFormat);
1534                         current_offset += sizeof(NDR_PARAM_OI_BASETYPE);
1535                     }
1536                     else
1537                     {
1538                         const NDR_PARAM_OI_OTHER *pParamOther = 
1539                             (const NDR_PARAM_OI_OTHER *)&pFormat[current_offset];
1540
1541                         const unsigned char * pTypeFormat =
1542                             &pStubDesc->pFormatTypes[pParamOther->type_offset];
1543
1544                         TRACE("\tcomplex type 0x%02x\n", *pTypeFormat);
1545
1546                         switch (phase)
1547                         {
1548                         case STUBLESS_MARSHAL:
1549                             if (pParam->param_direction == RPC_FC_OUT_PARAM ||
1550                                 pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1551                                 pParam->param_direction == RPC_FC_RETURN_PARAM)
1552                                 call_marshaller(&stubMsg, *(unsigned char **)pArg, pTypeFormat);
1553                             break;
1554                         case STUBLESS_FREE:
1555                             if (pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1556                                 pParam->param_direction == RPC_FC_IN_PARAM)
1557                                 call_freer(&stubMsg, *(unsigned char **)pArg, pTypeFormat);
1558                             else if (pParam->param_direction == RPC_FC_OUT_PARAM)
1559                                 stubMsg.pfnFree(*(void **)pArg);
1560                             break;
1561                         case STUBLESS_UNMARSHAL:
1562                             if (pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1563                                 pParam->param_direction == RPC_FC_IN_PARAM)
1564                                 call_unmarshaller(&stubMsg, (unsigned char **)pArg, pTypeFormat, 0);
1565                             else if (pParam->param_direction == RPC_FC_RETURN_PARAM)
1566                                 retval_ptr = (LONG_PTR *)pArg;
1567                             else if (pParam->param_direction == RPC_FC_OUT_PARAM)
1568                             {
1569                                 DWORD size = calc_arg_size(&stubMsg, pTypeFormat);
1570
1571                                 if(size)
1572                                 {
1573                                     *(void **)pArg = NdrAllocate(&stubMsg, size);
1574                                     memset(*(void **)pArg, 0, size);
1575                                 }
1576                             }
1577                             break;
1578                         case STUBLESS_CALCSIZE:
1579                             if (pParam->param_direction == RPC_FC_OUT_PARAM ||
1580                                 pParam->param_direction == RPC_FC_IN_OUT_PARAM ||
1581                                 pParam->param_direction == RPC_FC_RETURN_PARAM)
1582                                 call_buffer_sizer(&stubMsg, *(unsigned char **)pArg, pTypeFormat);
1583                             break;
1584                         default:
1585                             RpcRaiseException(RPC_S_INTERNAL_ERROR);
1586                         }
1587
1588                         current_stack_offset += pParamOther->stack_size * sizeof(INT);
1589                         current_offset += sizeof(NDR_PARAM_OI_OTHER);
1590                     }
1591                 }
1592             }
1593
1594             break;
1595         default:
1596             ERR("shouldn't reach here. phase %d\n", phase);
1597             break;
1598         }
1599     }
1600
1601     pRpcMsg->BufferLength = (unsigned int)(stubMsg.Buffer - (unsigned char *)pRpcMsg->Buffer);
1602
1603     if (ext_flags.HasNewCorrDesc)
1604     {
1605         /* free extra correlation package */
1606         /* NdrCorrelationFree(&stubMsg); */
1607     }
1608
1609     if (Oif_flags.HasPipes)
1610     {
1611         /* NdrPipesDone(...) */
1612     }
1613
1614     /* free the full pointer translation tables */
1615     if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
1616         NdrFullPointerXlatFree(stubMsg.FullPtrXlatTables);
1617
1618     /* free server function stack */
1619     HeapFree(GetProcessHeap(), 0, args);
1620
1621     return S_OK;
1622 }
1623
1624 void WINAPI NdrServerCall2(PRPC_MESSAGE pRpcMsg)
1625 {
1626     DWORD dwPhase;
1627     NdrStubCall2(NULL, NULL, pRpcMsg, &dwPhase);
1628 }