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