git.oblomov.eu Git - wine/blob - dlls/oleaut32/usrmarshal.c

   1 /*
   2  * Misc marshalling routines
   3  *
   4  * Copyright 2002 Ove Kaaven
   5  * Copyright 2003 Mike Hearn
   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
  22 #include <stdarg.h>
  23 #include <string.h>
  24
  25 #define COBJMACROS
  26 #define NONAMELESSUNION
  27 #define NONAMELESSSTRUCT
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "wingdi.h"
  32 #include "winuser.h"
  33 #include "winerror.h"
  34
  35 #include "ole2.h"
  36 #include "oleauto.h"
  37 #include "typelib.h"
  38 #include "ocidl.h"
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  42
  43 #define ALIGNED_LENGTH(_Len, _Align) (((_Len)+(_Align))&~(_Align))
  44 #define ALIGNED_POINTER(_Ptr, _Align) ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
  45 #define ALIGN_LENGTH(_Len, _Align) _Len = ALIGNED_LENGTH(_Len, _Align)
  46 #define ALIGN_POINTER(_Ptr, _Align) _Ptr = ALIGNED_POINTER(_Ptr, _Align)
  47
  48 static void dump_user_flags(const ULONG *pFlags)
  49 {
  50     if (HIWORD(*pFlags) == NDR_LOCAL_DATA_REPRESENTATION)
  51         TRACE("MAKELONG(NDR_LOCAL_REPRESENTATION, ");
  52     else
  53         TRACE("MAKELONG(0x%04x, ", HIWORD(*pFlags));
  54     switch (LOWORD(*pFlags))
  55     {
  56         case MSHCTX_LOCAL: TRACE("MSHCTX_LOCAL)"); break;
  57         case MSHCTX_NOSHAREDMEM: TRACE("MSHCTX_NOSHAREDMEM)"); break;
  58         case MSHCTX_DIFFERENTMACHINE: TRACE("MSHCTX_DIFFERENTMACHINE)"); break;
  59         case MSHCTX_INPROC: TRACE("MSHCTX_INPROC)"); break;
  60         default: TRACE("%d)", LOWORD(*pFlags));
  61     }
  62 }
  63
  64 /* CLEANLOCALSTORAGE */
  65
  66 #define CLS_FUNCDESC  'f'
  67 #define CLS_LIBATTR   'l'
  68 #define CLS_TYPEATTR  't'
  69 #define CLS_VARDESC   'v'
  70
  71 ULONG WINAPI CLEANLOCALSTORAGE_UserSize(ULONG *pFlags, ULONG Start, CLEANLOCALSTORAGE *pstg)
  72 {
  73     ALIGN_LENGTH(Start, 3);
  74     return Start + sizeof(DWORD);
  75 }
  76
  77 unsigned char * WINAPI CLEANLOCALSTORAGE_UserMarshal(ULONG *pFlags, unsigned char *Buffer, CLEANLOCALSTORAGE *pstg)
  78 {
  79     ALIGN_POINTER(Buffer, 3);
  80     *(DWORD*)Buffer = pstg->flags;
  81     switch(pstg->flags)
  82     {
  83     case CLS_LIBATTR:
  84         ITypeLib_ReleaseTLibAttr((ITypeLib*)pstg->pInterface, *(TLIBATTR**)pstg->pStorage);
  85         break;
  86     case CLS_TYPEATTR:
  87         ITypeInfo_ReleaseTypeAttr((ITypeInfo*)pstg->pInterface, *(TYPEATTR**)pstg->pStorage);
  88         break;
  89     case CLS_FUNCDESC:
  90         ITypeInfo_ReleaseFuncDesc((ITypeInfo*)pstg->pInterface, *(FUNCDESC**)pstg->pStorage);
  91         break;
  92     case CLS_VARDESC:
  93         ITypeInfo_ReleaseVarDesc((ITypeInfo*)pstg->pInterface, *(VARDESC**)pstg->pStorage);
  94         break;
  95
  96     default:
  97         ERR("Unknown type %x\n", pstg->flags);
  98     }
  99
 100     *(VOID**)pstg->pStorage = NULL;
 101     IUnknown_Release(pstg->pInterface);
 102     pstg->pInterface = NULL;
 103
 104     return Buffer + sizeof(DWORD);
 105 }
 106
 107 unsigned char * WINAPI CLEANLOCALSTORAGE_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, CLEANLOCALSTORAGE *pstr)
 108 {
 109     ALIGN_POINTER(Buffer, 3);
 110     pstr->flags = *(DWORD*)Buffer;
 111     return Buffer + sizeof(DWORD);
 112 }
 113
 114 void WINAPI CLEANLOCALSTORAGE_UserFree(ULONG *pFlags, CLEANLOCALSTORAGE *pstr)
 115 {
 116     /* Nothing to do */
 117 }
 118
 119 /* BSTR */
 120
 121 typedef struct
 122 {
 123     DWORD len;          /* No. of chars not including trailing '\0' */
 124     DWORD byte_len;     /* len * 2 or 0xffffffff if len == 0 */
 125     DWORD len2;         /* == len */
 126 } bstr_wire_t;
 127
 128 ULONG WINAPI BSTR_UserSize(ULONG *pFlags, ULONG Start, BSTR *pstr)
 129 {
 130     TRACE("(%x,%d,%p) => %p\n", *pFlags, Start, pstr, *pstr);
 131     if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
 132     ALIGN_LENGTH(Start, 3);
 133     Start += sizeof(bstr_wire_t) + ((SysStringByteLen(*pstr) + 1) & ~1);
 134     TRACE("returning %d\n", Start);
 135     return Start;
 136 }
 137
 138 unsigned char * WINAPI BSTR_UserMarshal(ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
 139 {
 140     bstr_wire_t *header;
 141     DWORD len = SysStringByteLen(*pstr);
 142
 143     TRACE("(%x,%p,%p) => %p\n", *pFlags, Buffer, pstr, *pstr);
 144     if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
 145
 146     ALIGN_POINTER(Buffer, 3);
 147     header = (bstr_wire_t*)Buffer;
 148     header->len = header->len2 = (len + 1) / 2;
 149     if (*pstr)
 150     {
 151         header->byte_len = len;
 152         memcpy(header + 1, *pstr, header->len * 2);
 153     }
 154     else
 155         header->byte_len = 0xffffffff; /* special case for a null bstr */
 156
 157     return Buffer + sizeof(*header) + sizeof(OLECHAR) * header->len;
 158 }
 159
 160 unsigned char * WINAPI BSTR_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
 161 {
 162     bstr_wire_t *header;
 163     TRACE("(%x,%p,%p) => %p\n", *pFlags, Buffer, pstr, *pstr);
 164
 165     ALIGN_POINTER(Buffer, 3);
 166     header = (bstr_wire_t*)Buffer;
 167     if(header->len != header->len2)
 168         FIXME("len %08x != len2 %08x\n", header->len, header->len2);
 169
 170     SysFreeString(*pstr);
 171     *pstr = NULL;
 172
 173     if(header->byte_len != 0xffffffff)
 174         *pstr = SysAllocStringByteLen((char*)(header + 1), header->byte_len);
 175
 176     if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
 177     return Buffer + sizeof(*header) + sizeof(OLECHAR) * header->len;
 178 }
 179
 180 void WINAPI BSTR_UserFree(ULONG *pFlags, BSTR *pstr)
 181 {
 182     TRACE("(%x,%p) => %p\n", *pFlags, pstr, *pstr);
 183     SysFreeString(*pstr);
 184     *pstr = NULL;
 185 }
 186
 187 /* VARIANT */
 188
 189 typedef struct
 190 {
 191     DWORD clSize;
 192     DWORD rpcReserverd;
 193     USHORT vt;
 194     USHORT wReserved1;
 195     USHORT wReserved2;
 196     USHORT wReserved3;
 197     DWORD switch_is;
 198 } variant_wire_t;
 199
 200 static unsigned int get_type_size(ULONG *pFlags, VARTYPE vt)
 201 {
 202     if (vt & VT_ARRAY) return 4;
 203
 204     switch (vt & ~VT_BYREF) {
 205     case VT_EMPTY:
 206     case VT_NULL:
 207         return 0;
 208     case VT_I1:
 209     case VT_UI1:
 210         return sizeof(CHAR);
 211     case VT_I2:
 212     case VT_UI2:
 213         return sizeof(SHORT);
 214     case VT_I4:
 215     case VT_UI4:
 216         return sizeof(LONG);
 217     case VT_INT:
 218     case VT_UINT:
 219         return sizeof(INT);
 220     case VT_R4:
 221         return sizeof(FLOAT);
 222     case VT_R8:
 223         return sizeof(DOUBLE);
 224     case VT_BOOL:
 225         return sizeof(VARIANT_BOOL);
 226     case VT_ERROR:
 227         return sizeof(SCODE);
 228     case VT_DATE:
 229         return sizeof(DATE);
 230     case VT_CY:
 231         return sizeof(CY);
 232     case VT_DECIMAL:
 233         return sizeof(DECIMAL);
 234     case VT_BSTR:
 235         return sizeof(ULONG);
 236     case VT_VARIANT:
 237         return sizeof(VARIANT);
 238     case VT_UNKNOWN:
 239     case VT_DISPATCH:
 240     case VT_RECORD:
 241         return 0;
 242     default:
 243         FIXME("unhandled VT %d\n", vt);
 244         return 0;
 245     }
 246 }
 247
 248 static unsigned int get_type_alignment(ULONG *pFlags, VARTYPE vt)
 249 {
 250     unsigned int size = get_type_size(pFlags, vt);
 251     if(vt & VT_BYREF) return 3;
 252     if(size == 0) return 0;
 253     if(size <= 4) return size - 1;
 254     return 7;
 255 }
 256
 257 static unsigned interface_variant_size(const ULONG *pFlags, REFIID riid, IUnknown *punk)
 258 {
 259     ULONG size = 0;
 260     HRESULT hr;
 261
 262     if (punk)
 263     {
 264         hr = CoGetMarshalSizeMax(&size, riid, punk, LOWORD(*pFlags), NULL, MSHLFLAGS_NORMAL);
 265         if (FAILED(hr))
 266         {
 267             ERR("interface variant buffer size calculation failed, HRESULT=0x%x\n", hr);
 268             return 0;
 269         }
 270     }
 271     size += sizeof(ULONG); /* we have to store the buffersize in the stream */
 272     TRACE("wire-size extra of interface variant is %d\n", size);
 273     return size;
 274 }
 275
 276 static ULONG wire_extra_user_size(ULONG *pFlags, ULONG Start, VARIANT *pvar)
 277 {
 278   if (V_ISARRAY(pvar))
 279   {
 280     if (V_ISBYREF(pvar))
 281       return LPSAFEARRAY_UserSize(pFlags, Start, V_ARRAYREF(pvar));
 282     else
 283       return LPSAFEARRAY_UserSize(pFlags, Start, &V_ARRAY(pvar));
 284   }
 285
 286   switch (V_VT(pvar)) {
 287   case VT_BSTR:
 288     return BSTR_UserSize(pFlags, Start, &V_BSTR(pvar));
 289   case VT_BSTR | VT_BYREF:
 290     return BSTR_UserSize(pFlags, Start, V_BSTRREF(pvar));
 291   case VT_VARIANT | VT_BYREF:
 292     return VARIANT_UserSize(pFlags, Start, V_VARIANTREF(pvar));
 293   case VT_UNKNOWN:
 294     return Start + interface_variant_size(pFlags, &IID_IUnknown, V_UNKNOWN(pvar));
 295   case VT_UNKNOWN | VT_BYREF:
 296     return Start + interface_variant_size(pFlags, &IID_IUnknown, *V_UNKNOWNREF(pvar));
 297   case VT_DISPATCH:
 298     return Start + interface_variant_size(pFlags, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
 299   case VT_DISPATCH | VT_BYREF:
 300     return Start + interface_variant_size(pFlags, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
 301   case VT_RECORD:
 302     FIXME("wire-size record\n");
 303     return Start;
 304   case VT_SAFEARRAY:
 305   case VT_SAFEARRAY | VT_BYREF:
 306     FIXME("wire-size safearray: shouldn't be marshaling this\n");
 307     return Start;
 308   default:
 309     return Start;
 310   }
 311 }
 312
 313 /* helper: called for VT_DISPATCH variants to marshal the IDispatch* into the buffer. returns Buffer on failure, new position otherwise */
 314 static unsigned char* interface_variant_marshal(const ULONG *pFlags, unsigned char *Buffer,
 315                                                 REFIID riid, IUnknown *punk)
 316 {
 317   IStream *working;
 318   HGLOBAL working_mem;
 319   void *working_memlocked;
 320   unsigned char *oldpos;
 321   ULONG size;
 322   HRESULT hr;
 323
 324   TRACE("pFlags=%d, Buffer=%p, pUnk=%p\n", *pFlags, Buffer, punk);
 325
 326   if(!punk)
 327   {
 328       memset(Buffer, 0, sizeof(ULONG));
 329       return Buffer + sizeof(ULONG);
 330   }
 331
 332   oldpos = Buffer;
 333
 334   /* CoMarshalInterface needs a stream, whereas at this level we are operating in terms of buffers.
 335    * We create a stream on an HGLOBAL, so we can simply do a memcpy to move it to the buffer.
 336    * in rpcrt4/ndr_ole.c, a simple IStream implementation is wrapped around the buffer object,
 337    * but that would be overkill here, hence this implementation. We save the size because the unmarshal
 338    * code has no way to know how long the marshalled buffer is. */
 339
 340   size = interface_variant_size(pFlags, riid, punk);
 341
 342   working_mem = GlobalAlloc(0, size);
 343   if (!working_mem) return oldpos;
 344
 345   hr = CreateStreamOnHGlobal(working_mem, TRUE, &working);
 346   if (hr != S_OK) {
 347     GlobalFree(working_mem);
 348     return oldpos;
 349   }
 350
 351   hr = CoMarshalInterface(working, riid, punk, LOWORD(*pFlags), NULL, MSHLFLAGS_NORMAL);
 352   if (hr != S_OK) {
 353     IStream_Release(working); /* this also releases the hglobal */
 354     return oldpos;
 355   }
 356
 357   working_memlocked = GlobalLock(working_mem);
 358   memcpy(Buffer, &size, sizeof(ULONG)); /* copy the buffersize */
 359   memcpy(Buffer + sizeof(ULONG), working_memlocked, size - sizeof(ULONG));
 360   GlobalUnlock(working_mem);
 361
 362   IStream_Release(working);
 363
 364   /* size includes the ULONG for the size written above */
 365   TRACE("done, size=%d\n", size);
 366   return Buffer + size;
 367 }
 368
 369 /* helper: called for VT_DISPATCH / VT_UNKNOWN variants to unmarshal the buffer. returns Buffer on failure, new position otherwise */
 370 static unsigned char *interface_variant_unmarshal(const ULONG *pFlags, unsigned char *Buffer,
 371                                                   REFIID riid, IUnknown **ppunk)
 372 {
 373   IStream *working;
 374   HGLOBAL working_mem;
 375   void *working_memlocked;
 376   unsigned char *oldpos;
 377   ULONG size;
 378   HRESULT hr;
 379
 380   TRACE("pFlags=%d, Buffer=%p, ppUnk=%p\n", *pFlags, Buffer, ppunk);
 381
 382   oldpos = Buffer;
 383
 384   /* get the buffersize */
 385   memcpy(&size, Buffer, sizeof(ULONG));
 386   TRACE("buffersize=%d\n", size);
 387
 388   if(!size)
 389   {
 390       *ppunk = NULL;
 391       return Buffer + sizeof(ULONG);
 392   }
 393
 394   working_mem = GlobalAlloc(0, size);
 395   if (!working_mem) return oldpos;
 396
 397   hr = CreateStreamOnHGlobal(working_mem, TRUE, &working);
 398   if (hr != S_OK) {
 399     GlobalFree(working_mem);
 400     return oldpos;
 401   }
 402
 403   working_memlocked = GlobalLock(working_mem);
 404
 405   /* now we copy the contents of the marshalling buffer to working_memlocked, unlock it, and demarshal the stream */
 406   memcpy(working_memlocked, Buffer + sizeof(ULONG), size);
 407   GlobalUnlock(working_mem);
 408
 409   hr = CoUnmarshalInterface(working, riid, (void**)ppunk);
 410   if (hr != S_OK) {
 411     IStream_Release(working);
 412     return oldpos;
 413   }
 414
 415   IStream_Release(working); /* this also frees the underlying hglobal */
 416
 417   /* size includes the ULONG for the size written above */
 418   TRACE("done, processed=%d bytes\n", size);
 419   return Buffer + size;
 420 }
 421
 422
 423 ULONG WINAPI VARIANT_UserSize(ULONG *pFlags, ULONG Start, VARIANT *pvar)
 424 {
 425     int align;
 426     TRACE("(%x,%d,%p)\n", *pFlags, Start, pvar);
 427     TRACE("vt=%04x\n", V_VT(pvar));
 428
 429     ALIGN_LENGTH(Start, 7);
 430     Start += sizeof(variant_wire_t);
 431     if(V_VT(pvar) & VT_BYREF)
 432         Start += 4;
 433
 434     align = get_type_alignment(pFlags, V_VT(pvar));
 435     ALIGN_LENGTH(Start, align);
 436     if(V_VT(pvar) == (VT_VARIANT | VT_BYREF))
 437         Start += 4;
 438     else
 439         Start += get_type_size(pFlags, V_VT(pvar));
 440     Start = wire_extra_user_size(pFlags, Start, pvar);
 441
 442     TRACE("returning %d\n", Start);
 443     return Start;
 444 }
 445
 446 unsigned char * WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer, VARIANT *pvar)
 447 {
 448     variant_wire_t *header;
 449     ULONG type_size;
 450     int align;
 451     unsigned char *Pos;
 452
 453     TRACE("(%x,%p,%p)\n", *pFlags, Buffer, pvar);
 454     TRACE("vt=%04x\n", V_VT(pvar));
 455
 456     ALIGN_POINTER(Buffer, 7);
 457
 458     header = (variant_wire_t *)Buffer;
 459
 460     header->clSize = 0; /* fixed up at the end */
 461     header->rpcReserverd = 0;
 462     header->vt = pvar->n1.n2.vt;
 463     header->wReserved1 = pvar->n1.n2.wReserved1;
 464     header->wReserved2 = pvar->n1.n2.wReserved2;
 465     header->wReserved3 = pvar->n1.n2.wReserved3;
 466     header->switch_is = pvar->n1.n2.vt;
 467     if(header->switch_is & VT_ARRAY)
 468         header->switch_is &= ~VT_TYPEMASK;
 469
 470     Pos = (unsigned char*)(header + 1);
 471     type_size = get_type_size(pFlags, V_VT(pvar));
 472     align = get_type_alignment(pFlags, V_VT(pvar));
 473     ALIGN_POINTER(Pos, align);
 474
 475     if(header->vt & VT_BYREF)
 476     {
 477         *(DWORD *)Pos = max(type_size, 4);
 478         Pos += 4;
 479         if((header->vt & VT_TYPEMASK) != VT_VARIANT)
 480         {
 481             memcpy(Pos, pvar->n1.n2.n3.byref, type_size);
 482             Pos += type_size;
 483         }
 484         else
 485         {
 486             *(DWORD*)Pos = 'U' | 's' << 8 | 'e' << 16 | 'r' << 24;
 487             Pos += 4;
 488         }
 489     }
 490     else
 491     {
 492         if((header->vt & VT_TYPEMASK) == VT_DECIMAL)
 493             memcpy(Pos, pvar, type_size);
 494         else
 495             memcpy(Pos, &pvar->n1.n2.n3, type_size);
 496         Pos += type_size;
 497     }
 498
 499     if(header->vt & VT_ARRAY)
 500     {
 501         if(header->vt & VT_BYREF)
 502             Pos = LPSAFEARRAY_UserMarshal(pFlags, Pos, V_ARRAYREF(pvar));
 503         else
 504             Pos = LPSAFEARRAY_UserMarshal(pFlags, Pos, &V_ARRAY(pvar));
 505     }
 506     else
 507     {
 508         switch (header->vt)
 509         {
 510         case VT_BSTR:
 511             Pos = BSTR_UserMarshal(pFlags, Pos, &V_BSTR(pvar));
 512             break;
 513         case VT_BSTR | VT_BYREF:
 514             Pos = BSTR_UserMarshal(pFlags, Pos, V_BSTRREF(pvar));
 515             break;
 516         case VT_VARIANT | VT_BYREF:
 517             Pos = VARIANT_UserMarshal(pFlags, Pos, V_VARIANTREF(pvar));
 518             break;
 519         case VT_UNKNOWN:
 520             /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
 521             Pos = interface_variant_marshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWN(pvar));
 522             break;
 523         case VT_UNKNOWN | VT_BYREF:
 524             /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
 525             Pos = interface_variant_marshal(pFlags, Pos, &IID_IUnknown, *V_UNKNOWNREF(pvar));
 526             break;
 527         case VT_DISPATCH:
 528             /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
 529             Pos = interface_variant_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
 530             break;
 531         case VT_DISPATCH | VT_BYREF:
 532             /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
 533             Pos = interface_variant_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
 534             break;
 535         case VT_RECORD:
 536             FIXME("handle BRECORD by val\n");
 537             break;
 538         case VT_RECORD | VT_BYREF:
 539             FIXME("handle BRECORD by ref\n");
 540             break;
 541         }
 542     }
 543     header->clSize = ((Pos - Buffer) + 7) >> 3;
 544     TRACE("marshalled size=%d\n", header->clSize);
 545     return Pos;
 546 }
 547
 548 unsigned char * WINAPI VARIANT_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, VARIANT *pvar)
 549 {
 550     variant_wire_t *header;
 551     ULONG type_size;
 552     int align;
 553     unsigned char *Pos;
 554
 555     TRACE("(%x,%p,%p)\n", *pFlags, Buffer, pvar);
 556
 557     ALIGN_POINTER(Buffer, 7);
 558
 559     header = (variant_wire_t *)Buffer;
 560
 561     Pos = (unsigned char*)(header + 1);
 562     type_size = get_type_size(pFlags, header->vt);
 563     align = get_type_alignment(pFlags, header->vt);
 564     ALIGN_POINTER(Pos, align);
 565
 566     if(header->vt & VT_BYREF)
 567     {
 568         ULONG mem_size;
 569         Pos += 4;
 570
 571         switch (header->vt & ~VT_BYREF)
 572         {
 573         /* these types have a different memory size compared to wire size */
 574         case VT_UNKNOWN:
 575         case VT_DISPATCH:
 576         case VT_BSTR:
 577             mem_size = sizeof(void *);
 578             break;
 579         default:
 580             mem_size = type_size;
 581             break;
 582         }
 583
 584         if (V_VT(pvar) != header->vt)
 585         {
 586             VariantClear(pvar);
 587             V_BYREF(pvar) = CoTaskMemAlloc(mem_size);
 588         }
 589         else if (!V_BYREF(pvar))
 590             V_BYREF(pvar) = CoTaskMemAlloc(mem_size);
 591         memcpy(V_BYREF(pvar), Pos, type_size);
 592         if((header->vt & VT_TYPEMASK) != VT_VARIANT)
 593             Pos += type_size;
 594         else
 595             Pos += 4;
 596     }
 597     else
 598     {
 599         VariantClear(pvar);
 600         if((header->vt & VT_TYPEMASK) == VT_DECIMAL)
 601             memcpy(pvar, Pos, type_size);
 602         else
 603             memcpy(&pvar->n1.n2.n3, Pos, type_size);
 604         Pos += type_size;
 605     }
 606
 607     pvar->n1.n2.vt = header->vt;
 608     pvar->n1.n2.wReserved1 = header->wReserved1;
 609     pvar->n1.n2.wReserved2 = header->wReserved2;
 610     pvar->n1.n2.wReserved3 = header->wReserved3;
 611
 612     if(header->vt & VT_ARRAY)
 613     {
 614         if(header->vt & VT_BYREF)
 615             Pos = LPSAFEARRAY_UserUnmarshal(pFlags, Pos, V_ARRAYREF(pvar));
 616         else
 617             Pos = LPSAFEARRAY_UserUnmarshal(pFlags, Pos, &V_ARRAY(pvar));
 618     }
 619     else
 620     {
 621         switch (header->vt)
 622         {
 623         case VT_BSTR:
 624             V_BSTR(pvar) = NULL;
 625             Pos = BSTR_UserUnmarshal(pFlags, Pos, &V_BSTR(pvar));
 626             break;
 627         case VT_BSTR | VT_BYREF:
 628             *V_BSTRREF(pvar) = NULL;
 629             Pos = BSTR_UserUnmarshal(pFlags, Pos, V_BSTRREF(pvar));
 630             break;
 631         case VT_VARIANT | VT_BYREF:
 632             Pos = VARIANT_UserUnmarshal(pFlags, Pos, V_VARIANTREF(pvar));
 633             break;
 634         case VT_UNKNOWN:
 635             /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
 636             Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IUnknown, &V_UNKNOWN(pvar));
 637             break;
 638         case VT_UNKNOWN | VT_BYREF:
 639             /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
 640             Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWNREF(pvar));
 641             break;
 642         case VT_DISPATCH:
 643             /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
 644             Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)&V_DISPATCH(pvar));
 645             break;
 646         case VT_DISPATCH | VT_BYREF:
 647             /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
 648             Pos = interface_variant_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)V_DISPATCHREF(pvar));
 649             break;
 650         case VT_RECORD:
 651             FIXME("handle BRECORD by val\n");
 652             break;
 653         case VT_RECORD | VT_BYREF:
 654             FIXME("handle BRECORD by ref\n");
 655             break;
 656         }
 657     }
 658     return Pos;
 659 }
 660
 661 void WINAPI VARIANT_UserFree(ULONG *pFlags, VARIANT *pvar)
 662 {
 663   VARTYPE vt = V_VT(pvar);
 664   PVOID ref = NULL;
 665
 666   TRACE("(%x,%p)\n", *pFlags, pvar);
 667   TRACE("vt=%04x\n", V_VT(pvar));
 668
 669   if (vt & VT_BYREF) ref = pvar->n1.n2.n3.byref;
 670
 671   VariantClear(pvar);
 672   if (!ref) return;
 673
 674   if(vt & VT_ARRAY)
 675   {
 676     if (vt & VT_BYREF)
 677       LPSAFEARRAY_UserFree(pFlags, V_ARRAYREF(pvar));
 678     else
 679       LPSAFEARRAY_UserFree(pFlags, &V_ARRAY(pvar));
 680   }
 681   else
 682   {
 683     switch (vt)
 684     {
 685     case VT_BSTR | VT_BYREF:
 686       BSTR_UserFree(pFlags, V_BSTRREF(pvar));
 687       break;
 688     case VT_VARIANT | VT_BYREF:
 689       VARIANT_UserFree(pFlags, V_VARIANTREF(pvar));
 690       break;
 691     case VT_RECORD | VT_BYREF:
 692       FIXME("handle BRECORD by ref\n");
 693       break;
 694     case VT_UNKNOWN | VT_BYREF:
 695     case VT_DISPATCH | VT_BYREF:
 696       IUnknown_Release(*V_UNKNOWNREF(pvar));
 697       break;
 698     }
 699   }
 700
 701   CoTaskMemFree(ref);
 702 }
 703
 704 /* LPSAFEARRAY */
 705
 706 /* Get the number of cells in a SafeArray */
 707 static ULONG SAFEARRAY_GetCellCount(const SAFEARRAY *psa)
 708 {
 709     const SAFEARRAYBOUND* psab = psa->rgsabound;
 710     USHORT cCount = psa->cDims;
 711     ULONG ulNumCells = 1;
 712
 713     while (cCount--)
 714     {
 715         /* This is a valid bordercase. See testcases. -Marcus */
 716         if (!psab->cElements)
 717             return 0;
 718         ulNumCells *= psab->cElements;
 719         psab++;
 720     }
 721     return ulNumCells;
 722 }
 723
 724 static inline SF_TYPE SAFEARRAY_GetUnionType(SAFEARRAY *psa)
 725 {
 726     VARTYPE vt;
 727     HRESULT hr;
 728
 729     hr = SafeArrayGetVartype(psa, &vt);
 730     if (FAILED(hr))
 731     {
 732         if(psa->fFeatures & FADF_VARIANT) return SF_VARIANT;
 733
 734         switch(psa->cbElements)
 735         {
 736         case 1: vt = VT_I1; break;
 737         case 2: vt = VT_I2; break;
 738         case 4: vt = VT_I4; break;
 739         case 8: vt = VT_I8; break;
 740         default:
 741             RpcRaiseException(hr);
 742         }
 743     }
 744
 745     if (psa->fFeatures & FADF_HAVEIID)
 746         return SF_HAVEIID;
 747
 748     switch (vt)
 749     {
 750     case VT_I1:
 751     case VT_UI1:      return SF_I1;
 752     case VT_BOOL:
 753     case VT_I2:
 754     case VT_UI2:      return SF_I2;
 755     case VT_INT:
 756     case VT_UINT:
 757     case VT_I4:
 758     case VT_UI4:
 759     case VT_R4:       return SF_I4;
 760     case VT_DATE:
 761     case VT_CY:
 762     case VT_R8:
 763     case VT_I8:
 764     case VT_UI8:      return SF_I8;
 765     case VT_INT_PTR:
 766     case VT_UINT_PTR: return (sizeof(UINT_PTR) == 4 ? SF_I4 : SF_I8);
 767     case VT_BSTR:     return SF_BSTR;
 768     case VT_DISPATCH: return SF_DISPATCH;
 769     case VT_VARIANT:  return SF_VARIANT;
 770     case VT_UNKNOWN:  return SF_UNKNOWN;
 771     /* Note: Return a non-zero size to indicate vt is valid. The actual size
 772      * of a UDT is taken from the result of IRecordInfo_GetSize().
 773      */
 774     case VT_RECORD:   return SF_RECORD;
 775     default:          return SF_ERROR;
 776     }
 777 }
 778
 779 static DWORD elem_wire_size(LPSAFEARRAY lpsa, SF_TYPE sftype)
 780 {
 781     if (sftype == SF_BSTR)
 782         return sizeof(DWORD);
 783     else if (sftype == SF_VARIANT)
 784         return sizeof(variant_wire_t) - sizeof(DWORD);
 785     else
 786         return lpsa->cbElements;
 787 }
 788
 789 static DWORD elem_mem_size(wireSAFEARRAY wiresa, SF_TYPE sftype)
 790 {
 791     if (sftype == SF_BSTR)
 792         return sizeof(BSTR);
 793     else if (sftype == SF_VARIANT)
 794         return sizeof(VARIANT);
 795     else
 796         return wiresa->cbElements;
 797 }
 798
 799 ULONG WINAPI LPSAFEARRAY_UserSize(ULONG *pFlags, ULONG StartingSize, LPSAFEARRAY *ppsa)
 800 {
 801     ULONG size = StartingSize;
 802
 803     TRACE("("); dump_user_flags(pFlags); TRACE(", %d, %p\n", StartingSize, *ppsa);
 804
 805     ALIGN_LENGTH(size, 3);
 806     size += sizeof(ULONG);
 807     if (*ppsa)
 808     {
 809         SAFEARRAY *psa = *ppsa;
 810         ULONG ulCellCount = SAFEARRAY_GetCellCount(psa);
 811         SF_TYPE sftype;
 812         HRESULT hr;
 813
 814         size += sizeof(ULONG);
 815         size += 2 * sizeof(USHORT) + 2 * sizeof(ULONG);
 816
 817         sftype = SAFEARRAY_GetUnionType(psa);
 818         size += sizeof(ULONG);
 819
 820         size += sizeof(ULONG);
 821         size += sizeof(ULONG);
 822         if (sftype == SF_HAVEIID)
 823             size += sizeof(IID);
 824
 825         size += sizeof(psa->rgsabound[0]) * psa->cDims;
 826
 827         size += sizeof(ULONG);
 828
 829         switch (sftype)
 830         {
 831             case SF_BSTR:
 832             {
 833                 BSTR* lpBstr;
 834
 835                 for (lpBstr = psa->pvData; ulCellCount; ulCellCount--, lpBstr++)
 836                     size = BSTR_UserSize(pFlags, size, lpBstr);
 837
 838                 break;
 839             }
 840             case SF_DISPATCH:
 841             case SF_UNKNOWN:
 842             case SF_HAVEIID:
 843                 FIXME("size interfaces\n");
 844                 break;
 845             case SF_VARIANT:
 846             {
 847                 VARIANT* lpVariant;
 848
 849                 for (lpVariant = psa->pvData; ulCellCount; ulCellCount--, lpVariant++)
 850                     size = VARIANT_UserSize(pFlags, size, lpVariant);
 851
 852                 break;
 853             }
 854             case SF_RECORD:
 855             {
 856                 IRecordInfo* pRecInfo = NULL;
 857
 858                 hr = SafeArrayGetRecordInfo(psa, &pRecInfo);
 859                 if (FAILED(hr))
 860                     RpcRaiseException(hr);
 861
 862                 if (pRecInfo)
 863                 {
 864                     FIXME("size record info %p\n", pRecInfo);
 865
 866                     IRecordInfo_Release(pRecInfo);
 867                 }
 868                 break;
 869             }
 870             case SF_I8:
 871                 ALIGN_LENGTH(size, 7);
 872                 /* fallthrough */
 873             case SF_I1:
 874             case SF_I2:
 875             case SF_I4:
 876                 size += ulCellCount * psa->cbElements;
 877                 break;
 878             default:
 879                 break;
 880         }
 881
 882     }
 883
 884     return size;
 885 }
 886
 887 unsigned char * WINAPI LPSAFEARRAY_UserMarshal(ULONG *pFlags, unsigned char *Buffer, LPSAFEARRAY *ppsa)
 888 {
 889     HRESULT hr;
 890
 891     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &%p\n", Buffer, *ppsa);
 892
 893     ALIGN_POINTER(Buffer, 3);
 894     *(ULONG *)Buffer = *ppsa ? 0x1 : 0x0;
 895     Buffer += sizeof(ULONG);
 896     if (*ppsa)
 897     {
 898         VARTYPE vt;
 899         SAFEARRAY *psa = *ppsa;
 900         ULONG ulCellCount = SAFEARRAY_GetCellCount(psa);
 901         SAFEARRAYBOUND *bound;
 902         SF_TYPE sftype;
 903         GUID guid;
 904         INT i;
 905
 906         sftype = SAFEARRAY_GetUnionType(psa);
 907
 908         *(ULONG *)Buffer = psa->cDims;
 909         Buffer += sizeof(ULONG);
 910         *(USHORT *)Buffer = psa->cDims;
 911         Buffer += sizeof(USHORT);
 912         *(USHORT *)Buffer = psa->fFeatures;
 913         Buffer += sizeof(USHORT);
 914         *(ULONG *)Buffer = elem_wire_size(psa, sftype);
 915         Buffer += sizeof(ULONG);
 916
 917         hr = SafeArrayGetVartype(psa, &vt);
 918         if (FAILED(hr)) vt = 0;
 919
 920         *(ULONG *)Buffer = (USHORT)psa->cLocks | (vt << 16);
 921         Buffer += sizeof(ULONG);
 922
 923         *(ULONG *)Buffer = sftype;
 924         Buffer += sizeof(ULONG);
 925
 926         *(ULONG *)Buffer = ulCellCount;
 927         Buffer += sizeof(ULONG);
 928         *(ULONG *)Buffer = psa->pvData ? 0x2 : 0x0;
 929         Buffer += sizeof(ULONG);
 930         if (sftype == SF_HAVEIID)
 931         {
 932             SafeArrayGetIID(psa, &guid);
 933             memcpy(Buffer, &guid, sizeof(guid));
 934             Buffer += sizeof(guid);
 935         }
 936
 937         /* bounds are marshaled in opposite order comparing to storage layout */
 938         bound = (SAFEARRAYBOUND*)Buffer;
 939         for (i = 0; i < psa->cDims; i++)
 940         {
 941             memcpy(bound++, &psa->rgsabound[psa->cDims-i-1], sizeof(psa->rgsabound[0]));
 942         }
 943         Buffer += sizeof(psa->rgsabound[0]) * psa->cDims;
 944
 945         *(ULONG *)Buffer = ulCellCount;
 946         Buffer += sizeof(ULONG);
 947
 948         if (psa->pvData)
 949         {
 950             switch (sftype)
 951             {
 952                 case SF_BSTR:
 953                 {
 954                     BSTR* lpBstr;
 955
 956                     for (lpBstr = psa->pvData; ulCellCount; ulCellCount--, lpBstr++)
 957                         Buffer = BSTR_UserMarshal(pFlags, Buffer, lpBstr);
 958
 959                     break;
 960                 }
 961                 case SF_DISPATCH:
 962                 case SF_UNKNOWN:
 963                 case SF_HAVEIID:
 964                     FIXME("marshal interfaces\n");
 965                     break;
 966                 case SF_VARIANT:
 967                 {
 968                     VARIANT* lpVariant;
 969
 970                     for (lpVariant = psa->pvData; ulCellCount; ulCellCount--, lpVariant++)
 971                         Buffer = VARIANT_UserMarshal(pFlags, Buffer, lpVariant);
 972
 973                     break;
 974                 }
 975                 case SF_RECORD:
 976                 {
 977                     IRecordInfo* pRecInfo = NULL;
 978
 979                     hr = SafeArrayGetRecordInfo(psa, &pRecInfo);
 980                     if (FAILED(hr))
 981                         RpcRaiseException(hr);
 982
 983                     if (pRecInfo)
 984                     {
 985                         FIXME("write record info %p\n", pRecInfo);
 986
 987                         IRecordInfo_Release(pRecInfo);
 988                     }
 989                     break;
 990                 }
 991
 992                 case SF_I8:
 993                     ALIGN_POINTER(Buffer, 7);
 994                     /* fallthrough */
 995                 case SF_I1:
 996                 case SF_I2:
 997                 case SF_I4:
 998                     /* Just copy the data over */
 999                     memcpy(Buffer, psa->pvData, ulCellCount * psa->cbElements);
1000                     Buffer += ulCellCount * psa->cbElements;
1001                     break;
1002                 default:
1003                     break;
1004             }
1005         }
1006
1007     }
1008     return Buffer;
1009 }
1010
1011 #define FADF_AUTOSETFLAGS (FADF_HAVEIID | FADF_RECORD | FADF_HAVEVARTYPE | \
1012                            FADF_BSTR | FADF_UNKNOWN | FADF_DISPATCH | \
1013                            FADF_VARIANT | FADF_CREATEVECTOR)
1014
1015 unsigned char * WINAPI LPSAFEARRAY_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, LPSAFEARRAY *ppsa)
1016 {
1017     ULONG ptr;
1018     wireSAFEARRAY wiresa;
1019     ULONG cDims;
1020     HRESULT hr;
1021     SF_TYPE sftype;
1022     ULONG cell_count;
1023     GUID guid;
1024     VARTYPE vt;
1025     SAFEARRAYBOUND *wiresab;
1026
1027     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", Buffer, ppsa);
1028
1029     ALIGN_POINTER(Buffer, 3);
1030     ptr = *(ULONG *)Buffer;
1031     Buffer += sizeof(ULONG);
1032
1033     if (!ptr)
1034     {
1035         *ppsa = NULL;
1036
1037         TRACE("NULL safe array unmarshaled\n");
1038
1039         return Buffer;
1040     }
1041
1042     cDims = *(ULONG *)Buffer;
1043     Buffer += sizeof(ULONG);
1044
1045     wiresa = (wireSAFEARRAY)Buffer;
1046     Buffer += 2 * sizeof(USHORT) + 2 * sizeof(ULONG);
1047
1048     if (cDims != wiresa->cDims)
1049         RpcRaiseException(RPC_S_INVALID_BOUND);
1050
1051     /* FIXME: there should be a limit on how large cDims can be */
1052
1053     vt = HIWORD(wiresa->cLocks);
1054
1055     sftype = *(ULONG *)Buffer;
1056     Buffer += sizeof(ULONG);
1057
1058     cell_count = *(ULONG *)Buffer;
1059     Buffer += sizeof(ULONG);
1060     ptr = *(ULONG *)Buffer;
1061     Buffer += sizeof(ULONG);
1062     if (sftype == SF_HAVEIID)
1063     {
1064         memcpy(&guid, Buffer, sizeof(guid));
1065         Buffer += sizeof(guid);
1066     }
1067
1068     wiresab = (SAFEARRAYBOUND *)Buffer;
1069     Buffer += sizeof(wiresab[0]) * wiresa->cDims;
1070
1071     if(vt)
1072         *ppsa = SafeArrayCreateEx(vt, wiresa->cDims, wiresab, NULL);
1073     else
1074     {
1075         SafeArrayAllocDescriptor(wiresa->cDims, ppsa);
1076         if(*ppsa)
1077             memcpy((*ppsa)->rgsabound, wiresab, sizeof(SAFEARRAYBOUND) * wiresa->cDims);
1078     }
1079     if (!*ppsa)
1080         RpcRaiseException(E_OUTOFMEMORY);
1081
1082     /* be careful about which flags we set since they could be a security
1083      * risk */
1084     (*ppsa)->fFeatures &= FADF_AUTOSETFLAGS;
1085     (*ppsa)->fFeatures |= (wiresa->fFeatures & ~(FADF_AUTOSETFLAGS));
1086     /* FIXME: there should be a limit on how large wiresa->cbElements can be */
1087     (*ppsa)->cbElements = elem_mem_size(wiresa, sftype);
1088     (*ppsa)->cLocks = 0;
1089
1090     /* SafeArrayCreateEx allocates the data for us, but
1091      * SafeArrayAllocDescriptor doesn't */
1092     if(!vt)
1093     {
1094         hr = SafeArrayAllocData(*ppsa);
1095         if (FAILED(hr))
1096             RpcRaiseException(hr);
1097     }
1098
1099     if ((*(ULONG *)Buffer != cell_count) || (SAFEARRAY_GetCellCount(*ppsa) != cell_count))
1100         RpcRaiseException(RPC_S_INVALID_BOUND);
1101     Buffer += sizeof(ULONG);
1102
1103     if (ptr)
1104     {
1105         switch (sftype)
1106         {
1107             case SF_BSTR:
1108             {
1109                 BSTR* lpBstr;
1110
1111                 for (lpBstr = (*ppsa)->pvData; cell_count; cell_count--, lpBstr++)
1112                     Buffer = BSTR_UserUnmarshal(pFlags, Buffer, lpBstr);
1113
1114                 break;
1115             }
1116             case SF_DISPATCH:
1117             case SF_UNKNOWN:
1118             case SF_HAVEIID:
1119                 FIXME("marshal interfaces\n");
1120                 break;
1121             case SF_VARIANT:
1122             {
1123                 VARIANT* lpVariant;
1124
1125                 for (lpVariant = (*ppsa)->pvData; cell_count; cell_count--, lpVariant++)
1126                     Buffer = VARIANT_UserUnmarshal(pFlags, Buffer, lpVariant);
1127
1128                 break;
1129             }
1130             case SF_RECORD:
1131             {
1132                 FIXME("set record info\n");
1133
1134                 break;
1135             }
1136
1137             case SF_I8:
1138                 ALIGN_POINTER(Buffer, 7);
1139                 /* fallthrough */
1140             case SF_I1:
1141             case SF_I2:
1142             case SF_I4:
1143                 /* Just copy the data over */
1144                 memcpy((*ppsa)->pvData, Buffer, cell_count * (*ppsa)->cbElements);
1145                 Buffer += cell_count * (*ppsa)->cbElements;
1146                 break;
1147             default:
1148                 break;
1149         }
1150     }
1151
1152     TRACE("safe array unmarshaled: %p\n", *ppsa);
1153
1154     return Buffer;
1155 }
1156
1157 void WINAPI LPSAFEARRAY_UserFree(ULONG *pFlags, LPSAFEARRAY *ppsa)
1158 {
1159     TRACE("("); dump_user_flags(pFlags); TRACE(", &%p\n", *ppsa);
1160
1161     SafeArrayDestroy(*ppsa);
1162 }
1163
1164
1165 ULONG WINAPI HFONT_UserSize(ULONG *pFlags, ULONG Start, HFONT *phfont)
1166 {
1167     FIXME(":stub\n");
1168     return 0;
1169 }
1170
1171 unsigned char * WINAPI HFONT_UserMarshal(ULONG *pFlags, unsigned char *Buffer, HFONT *phfont)
1172 {
1173     FIXME(":stub\n");
1174     return NULL;
1175 }
1176
1177 unsigned char * WINAPI HFONT_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, HFONT *phfont)
1178 {
1179     FIXME(":stub\n");
1180     return NULL;
1181 }
1182
1183 void WINAPI HFONT_UserFree(ULONG *pFlags, HFONT *phfont)
1184 {
1185     FIXME(":stub\n");
1186     return;
1187 }
1188
1189
1190 /* IDispatch */
1191 /* exactly how Invoke is marshalled is not very clear to me yet,
1192  * but the way I've done it seems to work for me */
1193
1194 HRESULT CALLBACK IDispatch_Invoke_Proxy(
1195     IDispatch* This,
1196     DISPID dispIdMember,
1197     REFIID riid,
1198     LCID lcid,
1199     WORD wFlags,
1200     DISPPARAMS* pDispParams,
1201     VARIANT* pVarResult,
1202     EXCEPINFO* pExcepInfo,
1203     UINT* puArgErr)
1204 {
1205   HRESULT hr;
1206   VARIANT VarResult;
1207   UINT* rgVarRefIdx = NULL;
1208   VARIANTARG* rgVarRef = NULL;
1209   UINT u, cVarRef;
1210   UINT uArgErr;
1211   EXCEPINFO ExcepInfo;
1212
1213   TRACE("(%p)->(%d,%s,%x,%x,%p,%p,%p,%p)\n", This,
1214         dispIdMember, debugstr_guid(riid),
1215         lcid, wFlags, pDispParams, pVarResult,
1216         pExcepInfo, puArgErr);
1217
1218   /* [out] args can't be null, use dummy vars if needed */
1219   if (!pVarResult) pVarResult = &VarResult;
1220   if (!puArgErr) puArgErr = &uArgErr;
1221   if (!pExcepInfo) pExcepInfo = &ExcepInfo;
1222
1223   /* count by-ref args */
1224   for (cVarRef=0,u=0; u<pDispParams->cArgs; u++) {
1225     VARIANTARG* arg = &pDispParams->rgvarg[u];
1226     if (V_ISBYREF(arg)) {
1227       cVarRef++;
1228     }
1229   }
1230   if (cVarRef) {
1231     rgVarRefIdx = CoTaskMemAlloc(sizeof(UINT)*cVarRef);
1232     rgVarRef = CoTaskMemAlloc(sizeof(VARIANTARG)*cVarRef);
1233     /* make list of by-ref args */
1234     for (cVarRef=0,u=0; u<pDispParams->cArgs; u++) {
1235       VARIANTARG* arg = &pDispParams->rgvarg[u];
1236       if (V_ISBYREF(arg)) {
1237         rgVarRefIdx[cVarRef] = u;
1238         VariantInit(&rgVarRef[cVarRef]);
1239         VariantCopy(&rgVarRef[cVarRef], arg);
1240         VariantClear(arg);
1241         cVarRef++;
1242       }
1243     }
1244   } else {
1245     /* [out] args still can't be null,
1246      * but we can point these anywhere in this case,
1247      * since they won't be written to when cVarRef is 0 */
1248     rgVarRefIdx = puArgErr;
1249     rgVarRef = pVarResult;
1250   }
1251   TRACE("passed by ref: %d args\n", cVarRef);
1252   hr = IDispatch_RemoteInvoke_Proxy(This,
1253                                     dispIdMember,
1254                                     riid,
1255                                     lcid,
1256                                     wFlags,
1257                                     pDispParams,
1258                                     pVarResult,
1259                                     pExcepInfo,
1260                                     puArgErr,
1261                                     cVarRef,
1262                                     rgVarRefIdx,
1263                                     rgVarRef);
1264   if (cVarRef) {
1265     for (u=0; u<cVarRef; u++) {
1266       unsigned i = rgVarRefIdx[u];
1267       VariantCopy(&pDispParams->rgvarg[i],
1268                   &rgVarRef[u]);
1269       VariantClear(&rgVarRef[u]);
1270     }
1271     CoTaskMemFree(rgVarRef);
1272     CoTaskMemFree(rgVarRefIdx);
1273   }
1274
1275   if(pExcepInfo == &ExcepInfo)
1276   {
1277     SysFreeString(pExcepInfo->bstrSource);
1278     SysFreeString(pExcepInfo->bstrDescription);
1279     SysFreeString(pExcepInfo->bstrHelpFile);
1280   }
1281   return hr;
1282 }
1283
1284 HRESULT __RPC_STUB IDispatch_Invoke_Stub(
1285     IDispatch* This,
1286     DISPID dispIdMember,
1287     REFIID riid,
1288     LCID lcid,
1289     DWORD dwFlags,
1290     DISPPARAMS* pDispParams,
1291     VARIANT* pVarResult,
1292     EXCEPINFO* pExcepInfo,
1293     UINT* pArgErr,
1294     UINT cVarRef,
1295     UINT* rgVarRefIdx,
1296     VARIANTARG* rgVarRef)
1297 {
1298   HRESULT hr = S_OK;
1299   VARIANTARG *rgvarg, *arg;
1300   UINT u;
1301
1302   /* initialize out parameters, so that they can be marshalled
1303    * in case the real Invoke doesn't initialize them */
1304   VariantInit(pVarResult);
1305   memset(pExcepInfo, 0, sizeof(*pExcepInfo));
1306   *pArgErr = 0;
1307
1308   /* let the real Invoke operate on a copy of the in parameters,
1309    * so we don't risk losing pointers to allocated memory */
1310   rgvarg = pDispParams->rgvarg;
1311   arg = CoTaskMemAlloc(sizeof(VARIANTARG)*pDispParams->cArgs);
1312   if (!arg) return E_OUTOFMEMORY;
1313
1314   /* init all args so we can call VariantClear on all the args if the copy
1315    * below fails */
1316   for (u = 0; u < pDispParams->cArgs; u++)
1317     VariantInit(&arg[u]);
1318
1319   for (u = 0; u < pDispParams->cArgs; u++) {
1320     hr = VariantCopy(&arg[u], &rgvarg[u]);
1321     if (FAILED(hr))
1322         break;
1323   }
1324
1325   if (SUCCEEDED(hr)) {
1326     /* copy ref args to arg array */
1327     for (u=0; u<cVarRef; u++) {
1328       unsigned i = rgVarRefIdx[u];
1329       VariantCopy(&arg[i], &rgVarRef[u]);
1330     }
1331
1332     pDispParams->rgvarg = arg;
1333
1334     hr = IDispatch_Invoke(This,
1335                           dispIdMember,
1336                           riid,
1337                           lcid,
1338                           dwFlags,
1339                           pDispParams,
1340                           pVarResult,
1341                           pExcepInfo,
1342                           pArgErr);
1343
1344     /* copy ref args from arg array */
1345     for (u=0; u<cVarRef; u++) {
1346       unsigned i = rgVarRefIdx[u];
1347       VariantCopy(&rgVarRef[u], &arg[i]);
1348     }
1349   }
1350
1351   /* clear the duplicate argument list */
1352   for (u=0; u<pDispParams->cArgs; u++)
1353     VariantClear(&arg[u]);
1354
1355   pDispParams->rgvarg = rgvarg;
1356   CoTaskMemFree(arg);
1357
1358   return hr;
1359 }
1360
1361 /* IEnumVARIANT */
1362
1363 HRESULT CALLBACK IEnumVARIANT_Next_Proxy(
1364     IEnumVARIANT* This,
1365     ULONG celt,
1366     VARIANT* rgVar,
1367     ULONG* pCeltFetched)
1368 {
1369   ULONG fetched;
1370   if (!pCeltFetched)
1371     pCeltFetched = &fetched;
1372   return IEnumVARIANT_RemoteNext_Proxy(This,
1373                                        celt,
1374                                        rgVar,
1375                                        pCeltFetched);
1376 }
1377
1378 HRESULT __RPC_STUB IEnumVARIANT_Next_Stub(
1379     IEnumVARIANT* This,
1380     ULONG celt,
1381     VARIANT* rgVar,
1382     ULONG* pCeltFetched)
1383 {
1384   HRESULT hr;
1385   *pCeltFetched = 0;
1386   hr = IEnumVARIANT_Next(This,
1387                          celt,
1388                          rgVar,
1389                          pCeltFetched);
1390   if (hr == S_OK) *pCeltFetched = celt;
1391   return hr;
1392 }
1393
1394 /* TypeInfo related freers */
1395
1396 static void free_embedded_typedesc(TYPEDESC *tdesc);
1397 static void free_embedded_arraydesc(ARRAYDESC *adesc)
1398 {
1399     switch(adesc->tdescElem.vt)
1400     {
1401     case VT_PTR:
1402     case VT_SAFEARRAY:
1403         free_embedded_typedesc(adesc->tdescElem.u.lptdesc);
1404         CoTaskMemFree(adesc->tdescElem.u.lptdesc);
1405         break;
1406     case VT_CARRAY:
1407         free_embedded_arraydesc(adesc->tdescElem.u.lpadesc);
1408         CoTaskMemFree(adesc->tdescElem.u.lpadesc);
1409         break;
1410     }
1411 }
1412
1413 static void free_embedded_typedesc(TYPEDESC *tdesc)
1414 {
1415     switch(tdesc->vt)
1416     {
1417     case VT_PTR:
1418     case VT_SAFEARRAY:
1419         free_embedded_typedesc(tdesc->u.lptdesc);
1420         CoTaskMemFree(tdesc->u.lptdesc);
1421         break;
1422     case VT_CARRAY:
1423         free_embedded_arraydesc(tdesc->u.lpadesc);
1424         CoTaskMemFree(tdesc->u.lpadesc);
1425         break;
1426     }
1427 }
1428
1429 static void free_embedded_elemdesc(ELEMDESC *edesc)
1430 {
1431     free_embedded_typedesc(&edesc->tdesc);
1432     if(edesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
1433         CoTaskMemFree(edesc->u.paramdesc.pparamdescex);
1434 }
1435
1436 /* ITypeComp */
1437
1438 HRESULT CALLBACK ITypeComp_Bind_Proxy(
1439     ITypeComp* This,
1440     LPOLESTR szName,
1441     ULONG lHashVal,
1442     WORD wFlags,
1443     ITypeInfo** ppTInfo,
1444     DESCKIND* pDescKind,
1445     BINDPTR* pBindPtr)
1446 {
1447   FIXME("not implemented\n");
1448   return E_FAIL;
1449 }
1450
1451 HRESULT __RPC_STUB ITypeComp_Bind_Stub(
1452     ITypeComp* This,
1453     LPOLESTR szName,
1454     ULONG lHashVal,
1455     WORD wFlags,
1456     ITypeInfo** ppTInfo,
1457     DESCKIND* pDescKind,
1458     LPFUNCDESC* ppFuncDesc,
1459     LPVARDESC* ppVarDesc,
1460     ITypeComp** ppTypeComp,
1461     CLEANLOCALSTORAGE* pDummy)
1462 {
1463   FIXME("not implemented\n");
1464   return E_FAIL;
1465 }
1466
1467 HRESULT CALLBACK ITypeComp_BindType_Proxy(
1468     ITypeComp* This,
1469     LPOLESTR szName,
1470     ULONG lHashVal,
1471     ITypeInfo** ppTInfo,
1472     ITypeComp** ppTComp)
1473 {
1474   FIXME("not implemented\n");
1475   return E_FAIL;
1476 }
1477
1478 HRESULT __RPC_STUB ITypeComp_BindType_Stub(
1479     ITypeComp* This,
1480     LPOLESTR szName,
1481     ULONG lHashVal,
1482     ITypeInfo** ppTInfo)
1483 {
1484   FIXME("not implemented\n");
1485   return E_FAIL;
1486 }
1487
1488 /* ITypeInfo */
1489
1490 HRESULT CALLBACK ITypeInfo_GetTypeAttr_Proxy(
1491     ITypeInfo* This,
1492     TYPEATTR** ppTypeAttr)
1493
1494 {
1495     CLEANLOCALSTORAGE stg;
1496     TRACE("(%p, %p)\n", This, ppTypeAttr);
1497
1498     stg.flags = 0;
1499     stg.pStorage = NULL;
1500     stg.pInterface = NULL;
1501
1502     return ITypeInfo_RemoteGetTypeAttr_Proxy(This, ppTypeAttr, &stg);
1503 }
1504
1505 HRESULT __RPC_STUB ITypeInfo_GetTypeAttr_Stub(
1506     ITypeInfo* This,
1507     LPTYPEATTR* ppTypeAttr,
1508     CLEANLOCALSTORAGE* pDummy)
1509 {
1510     HRESULT hr;
1511     TRACE("(%p, %p)\n", This, ppTypeAttr);
1512
1513     hr = ITypeInfo_GetTypeAttr(This, ppTypeAttr);
1514     if(hr != S_OK)
1515         return hr;
1516
1517     pDummy->flags = CLS_TYPEATTR;
1518     ITypeInfo_AddRef(This);
1519     pDummy->pInterface = (IUnknown*)This;
1520     pDummy->pStorage = ppTypeAttr;
1521     return hr;
1522 }
1523
1524 HRESULT CALLBACK ITypeInfo_GetFuncDesc_Proxy(
1525     ITypeInfo* This,
1526     UINT index,
1527     FUNCDESC** ppFuncDesc)
1528 {
1529     CLEANLOCALSTORAGE stg;
1530     TRACE("(%p, %d, %p)\n", This, index, ppFuncDesc);
1531
1532     stg.flags = 0;
1533     stg.pStorage = NULL;
1534     stg.pInterface = NULL;
1535
1536     return ITypeInfo_RemoteGetFuncDesc_Proxy(This, index, ppFuncDesc, &stg);
1537 }
1538
1539 HRESULT __RPC_STUB ITypeInfo_GetFuncDesc_Stub(
1540     ITypeInfo* This,
1541     UINT index,
1542     LPFUNCDESC* ppFuncDesc,
1543     CLEANLOCALSTORAGE* pDummy)
1544 {
1545     HRESULT hr;
1546     TRACE("(%p, %d, %p)\n", This, index, ppFuncDesc);
1547
1548     hr = ITypeInfo_GetFuncDesc(This, index, ppFuncDesc);
1549     if(hr != S_OK)
1550         return hr;
1551
1552     pDummy->flags = CLS_FUNCDESC;
1553     ITypeInfo_AddRef(This);
1554     pDummy->pInterface = (IUnknown*)This;
1555     pDummy->pStorage = ppFuncDesc;
1556     return hr;
1557 }
1558
1559 HRESULT CALLBACK ITypeInfo_GetVarDesc_Proxy(
1560     ITypeInfo* This,
1561     UINT index,
1562     VARDESC** ppVarDesc)
1563 {
1564     CLEANLOCALSTORAGE stg;
1565     TRACE("(%p, %d, %p)\n", This, index, ppVarDesc);
1566
1567     stg.flags = 0;
1568     stg.pStorage = NULL;
1569     stg.pInterface = NULL;
1570
1571     return ITypeInfo_RemoteGetVarDesc_Proxy(This, index, ppVarDesc, &stg);
1572 }
1573
1574 HRESULT __RPC_STUB ITypeInfo_GetVarDesc_Stub(
1575     ITypeInfo* This,
1576     UINT index,
1577     LPVARDESC* ppVarDesc,
1578     CLEANLOCALSTORAGE* pDummy)
1579 {
1580     HRESULT hr;
1581     TRACE("(%p, %d, %p)\n", This, index, ppVarDesc);
1582
1583     hr = ITypeInfo_GetVarDesc(This, index, ppVarDesc);
1584     if(hr != S_OK)
1585         return hr;
1586
1587     pDummy->flags = CLS_VARDESC;
1588     ITypeInfo_AddRef(This);
1589     pDummy->pInterface = (IUnknown*)This;
1590     pDummy->pStorage = ppVarDesc;
1591     return hr;
1592 }
1593
1594 HRESULT CALLBACK ITypeInfo_GetNames_Proxy(
1595     ITypeInfo* This,
1596     MEMBERID memid,
1597     BSTR* rgBstrNames,
1598     UINT cMaxNames,
1599     UINT* pcNames)
1600 {
1601     TRACE("(%p, %08x, %p, %d, %p)\n", This, memid, rgBstrNames, cMaxNames, pcNames);
1602
1603     return ITypeInfo_RemoteGetNames_Proxy(This, memid, rgBstrNames, cMaxNames, pcNames);
1604 }
1605
1606 HRESULT __RPC_STUB ITypeInfo_GetNames_Stub(
1607     ITypeInfo* This,
1608     MEMBERID memid,
1609     BSTR* rgBstrNames,
1610     UINT cMaxNames,
1611     UINT* pcNames)
1612 {
1613     TRACE("(%p, %08x, %p, %d, %p)\n", This, memid, rgBstrNames, cMaxNames, pcNames);
1614
1615     return ITypeInfo_GetNames(This, memid, rgBstrNames, cMaxNames, pcNames);
1616 }
1617
1618 HRESULT CALLBACK ITypeInfo_GetIDsOfNames_Proxy(
1619     ITypeInfo* This,
1620     LPOLESTR* rgszNames,
1621     UINT cNames,
1622     MEMBERID* pMemId)
1623 {
1624   FIXME("not implemented\n");
1625   return E_FAIL;
1626 }
1627
1628 HRESULT __RPC_STUB ITypeInfo_GetIDsOfNames_Stub(
1629     ITypeInfo* This)
1630 {
1631   FIXME("not implemented\n");
1632   return E_FAIL;
1633 }
1634
1635 HRESULT CALLBACK ITypeInfo_Invoke_Proxy(
1636     ITypeInfo* This,
1637     PVOID pvInstance,
1638     MEMBERID memid,
1639     WORD wFlags,
1640     DISPPARAMS* pDispParams,
1641     VARIANT* pVarResult,
1642     EXCEPINFO* pExcepInfo,
1643     UINT* puArgErr)
1644 {
1645   FIXME("not implemented\n");
1646   return E_FAIL;
1647 }
1648
1649 HRESULT __RPC_STUB ITypeInfo_Invoke_Stub(
1650     ITypeInfo* This)
1651 {
1652   FIXME("not implemented\n");
1653   return E_FAIL;
1654 }
1655
1656 HRESULT CALLBACK ITypeInfo_GetDocumentation_Proxy(ITypeInfo *This, MEMBERID memid,
1657                                                   BSTR *name, BSTR *doc_string,
1658                                                   DWORD *help_context, BSTR *help_file)
1659 {
1660     DWORD dummy_help_context, flags = 0;
1661     BSTR dummy_name, dummy_doc_string, dummy_help_file;
1662     HRESULT hr;
1663     TRACE("(%p, %08x, %p, %p, %p, %p)\n", This, memid, name, doc_string, help_context, help_file);
1664
1665     if(!name) name = &dummy_name;
1666     else flags = 1;
1667
1668     if(!doc_string) doc_string = &dummy_doc_string;
1669     else flags |= 2;
1670
1671     if(!help_context) help_context = &dummy_help_context;
1672     else flags |= 4;
1673
1674     if(!help_file) help_file = &dummy_help_file;
1675     else flags |= 8;
1676
1677     hr = ITypeInfo_RemoteGetDocumentation_Proxy(This, memid, flags, name, doc_string, help_context, help_file);
1678
1679     /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
1680
1681     return hr;
1682 }
1683
1684 HRESULT __RPC_STUB ITypeInfo_GetDocumentation_Stub(ITypeInfo *This, MEMBERID memid,
1685                                                    DWORD flags, BSTR *name, BSTR *doc_string,
1686                                                    DWORD *help_context, BSTR *help_file)
1687 {
1688     TRACE("(%p, %08x, %08x, %p, %p, %p, %p)\n", This, memid, flags, name, doc_string, help_context, help_file);
1689
1690     *name = *doc_string = *help_file = NULL;
1691     *help_context = 0;
1692
1693     if(!(flags & 1)) name = NULL;
1694     if(!(flags & 2)) doc_string = NULL;
1695     if(!(flags & 4)) help_context = NULL;
1696     if(!(flags & 8)) help_file = NULL;
1697
1698     return ITypeInfo_GetDocumentation(This, memid, name, doc_string, help_context, help_file);
1699 }
1700
1701 HRESULT CALLBACK ITypeInfo_GetDllEntry_Proxy(ITypeInfo *This, MEMBERID memid,
1702                                              INVOKEKIND invkind, BSTR *dll_name,
1703                                              BSTR* name, WORD *ordinal)
1704 {
1705     DWORD flags = 0;
1706     BSTR dummy_dll_name, dummy_name;
1707     WORD dummy_ordinal;
1708     HRESULT hr;
1709     TRACE("(%p, %08x, %x, %p, %p, %p)\n", This, memid, invkind, dll_name, name, ordinal);
1710
1711     if(!dll_name) dll_name = &dummy_dll_name;
1712     else flags = 1;
1713
1714     if(!name) name = &dummy_name;
1715     else flags |= 2;
1716
1717     if(!ordinal) ordinal = &dummy_ordinal;
1718     else flags |= 4;
1719
1720     hr = ITypeInfo_RemoteGetDllEntry_Proxy(This, memid, invkind, flags, dll_name, name, ordinal);
1721
1722     /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
1723
1724     return hr;
1725 }
1726
1727 HRESULT __RPC_STUB ITypeInfo_GetDllEntry_Stub(ITypeInfo *This, MEMBERID memid,
1728                                               INVOKEKIND invkind, DWORD flags,
1729                                               BSTR *dll_name, BSTR *name,
1730                                               WORD *ordinal)
1731 {
1732     TRACE("(%p, %08x, %x, %p, %p, %p)\n", This, memid, invkind, dll_name, name, ordinal);
1733
1734     *dll_name = *name = NULL;
1735     *ordinal = 0;
1736
1737     if(!(flags & 1)) dll_name = NULL;
1738     if(!(flags & 2)) name = NULL;
1739     if(!(flags & 4)) ordinal = NULL;
1740
1741     return ITypeInfo_GetDllEntry(This, memid, invkind, dll_name, name, ordinal);
1742 }
1743
1744 HRESULT CALLBACK ITypeInfo_AddressOfMember_Proxy(
1745     ITypeInfo* This,
1746     MEMBERID memid,
1747     INVOKEKIND invKind,
1748     PVOID* ppv)
1749 {
1750   FIXME("not implemented\n");
1751   return E_FAIL;
1752 }
1753
1754 HRESULT __RPC_STUB ITypeInfo_AddressOfMember_Stub(
1755     ITypeInfo* This)
1756 {
1757   FIXME("not implemented\n");
1758   return E_FAIL;
1759 }
1760
1761 HRESULT CALLBACK ITypeInfo_CreateInstance_Proxy(
1762     ITypeInfo* This,
1763     IUnknown* pUnkOuter,
1764     REFIID riid,
1765     PVOID* ppvObj)
1766 {
1767   FIXME("not implemented\n");
1768   return E_FAIL;
1769 }
1770
1771 HRESULT __RPC_STUB ITypeInfo_CreateInstance_Stub(
1772     ITypeInfo* This,
1773     REFIID riid,
1774     IUnknown** ppvObj)
1775 {
1776   FIXME("not implemented\n");
1777   return E_FAIL;
1778 }
1779
1780 HRESULT CALLBACK ITypeInfo_GetContainingTypeLib_Proxy(
1781     ITypeInfo* This,
1782     ITypeLib** ppTLib,
1783     UINT* pIndex)
1784 {
1785     ITypeLib *pTL;
1786     UINT index;
1787     HRESULT hr;
1788
1789     TRACE("(%p, %p, %p)\n", This, ppTLib, pIndex );
1790
1791     hr = ITypeInfo_RemoteGetContainingTypeLib_Proxy(This, &pTL, &index);
1792     if(SUCCEEDED(hr))
1793     {
1794         if(pIndex)
1795             *pIndex = index;
1796
1797         if(ppTLib)
1798             *ppTLib = pTL;
1799         else
1800             ITypeLib_Release(pTL);
1801     }
1802     return hr;
1803 }
1804
1805 HRESULT __RPC_STUB ITypeInfo_GetContainingTypeLib_Stub(
1806     ITypeInfo* This,
1807     ITypeLib** ppTLib,
1808     UINT* pIndex)
1809 {
1810     TRACE("(%p, %p, %p)\n", This, ppTLib, pIndex );
1811     return ITypeInfo_GetContainingTypeLib(This, ppTLib, pIndex);
1812 }
1813
1814 void CALLBACK ITypeInfo_ReleaseTypeAttr_Proxy(
1815     ITypeInfo* This,
1816     TYPEATTR* pTypeAttr)
1817 {
1818     TRACE("(%p, %p)\n", This, pTypeAttr);
1819     free_embedded_typedesc(&pTypeAttr->tdescAlias);
1820     CoTaskMemFree(pTypeAttr);
1821 }
1822
1823 HRESULT __RPC_STUB ITypeInfo_ReleaseTypeAttr_Stub(
1824     ITypeInfo* This)
1825 {
1826     TRACE("nothing to do\n");
1827     return S_OK;
1828 }
1829
1830 void CALLBACK ITypeInfo_ReleaseFuncDesc_Proxy(
1831     ITypeInfo* This,
1832     FUNCDESC* pFuncDesc)
1833 {
1834     SHORT param;
1835     TRACE("(%p, %p)\n", This, pFuncDesc);
1836
1837     for(param = 0; param < pFuncDesc->cParams; param++)
1838         free_embedded_elemdesc(pFuncDesc->lprgelemdescParam + param);
1839     if(param)
1840         CoTaskMemFree(pFuncDesc->lprgelemdescParam);
1841
1842     free_embedded_elemdesc(&pFuncDesc->elemdescFunc);
1843
1844     if(pFuncDesc->cScodes != 0 && pFuncDesc->cScodes != -1)
1845         CoTaskMemFree(pFuncDesc->lprgscode);
1846
1847     CoTaskMemFree(pFuncDesc);
1848 }
1849
1850 HRESULT __RPC_STUB ITypeInfo_ReleaseFuncDesc_Stub(
1851     ITypeInfo* This)
1852 {
1853     TRACE("nothing to do\n");
1854     return S_OK;
1855 }
1856
1857 void CALLBACK ITypeInfo_ReleaseVarDesc_Proxy(
1858     ITypeInfo* This,
1859     VARDESC* pVarDesc)
1860 {
1861     TRACE("(%p, %p)\n", This, pVarDesc);
1862
1863     CoTaskMemFree(pVarDesc->lpstrSchema);
1864
1865     if(pVarDesc->varkind == VAR_CONST)
1866         CoTaskMemFree(pVarDesc->u.lpvarValue);
1867
1868     free_embedded_elemdesc(&pVarDesc->elemdescVar);
1869     CoTaskMemFree(pVarDesc);
1870 }
1871
1872 HRESULT __RPC_STUB ITypeInfo_ReleaseVarDesc_Stub(
1873     ITypeInfo* This)
1874 {
1875     TRACE("nothing to do\n");
1876     return S_OK;
1877 }
1878
1879
1880 /* ITypeInfo2 */
1881
1882 HRESULT CALLBACK ITypeInfo2_GetDocumentation2_Proxy(ITypeInfo2 *This, MEMBERID memid,
1883                                                     LCID lcid, BSTR *help_string,
1884                                                     DWORD *help_context, BSTR *help_dll)
1885 {
1886     DWORD dummy_help_context, flags = 0;
1887     BSTR dummy_help_string, dummy_help_dll;
1888     HRESULT hr;
1889     TRACE("(%p, %08x, %08x, %p, %p, %p)\n", This, memid, lcid, help_string, help_context, help_dll);
1890
1891     if(!help_string) help_string = &dummy_help_string;
1892     else flags = 1;
1893
1894     if(!help_context) help_context = &dummy_help_context;
1895     else flags |= 2;
1896
1897     if(!help_dll) help_dll = &dummy_help_dll;
1898     else flags |= 4;
1899
1900     hr = ITypeInfo2_RemoteGetDocumentation2_Proxy(This, memid, lcid, flags, help_string, help_context, help_dll);
1901
1902     /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
1903
1904     return hr;
1905 }
1906
1907 HRESULT __RPC_STUB ITypeInfo2_GetDocumentation2_Stub(ITypeInfo2 *This, MEMBERID memid,
1908                                                      LCID lcid, DWORD flags,
1909                                                      BSTR *help_string, DWORD *help_context,
1910                                                      BSTR *help_dll)
1911 {
1912     TRACE("(%p, %08x, %08x, %08x, %p, %p, %p)\n", This, memid, lcid, flags, help_string, help_context, help_dll);
1913
1914     *help_string = *help_dll = NULL;
1915     *help_context = 0;
1916
1917     if(!(flags & 1)) help_string = NULL;
1918     if(!(flags & 2)) help_context = NULL;
1919     if(!(flags & 4)) help_dll = NULL;
1920
1921     return ITypeInfo2_GetDocumentation2(This, memid, lcid, help_string, help_context, help_dll);
1922 }
1923
1924 /* ITypeLib */
1925
1926 UINT CALLBACK ITypeLib_GetTypeInfoCount_Proxy(
1927     ITypeLib* This)
1928 {
1929     UINT count = 0;
1930     TRACE("(%p)\n", This);
1931
1932     ITypeLib_RemoteGetTypeInfoCount_Proxy(This, &count);
1933
1934     return count;
1935 }
1936
1937 HRESULT __RPC_STUB ITypeLib_GetTypeInfoCount_Stub(
1938     ITypeLib* This,
1939     UINT* pcTInfo)
1940 {
1941     TRACE("(%p, %p)\n", This, pcTInfo);
1942     *pcTInfo = ITypeLib_GetTypeInfoCount(This);
1943     return S_OK;
1944 }
1945
1946 HRESULT CALLBACK ITypeLib_GetLibAttr_Proxy(
1947     ITypeLib* This,
1948     TLIBATTR** ppTLibAttr)
1949 {
1950     CLEANLOCALSTORAGE stg;
1951     TRACE("(%p, %p)\n", This, ppTLibAttr);
1952
1953     stg.flags = 0;
1954     stg.pStorage = NULL;
1955     stg.pInterface = NULL;
1956
1957     return ITypeLib_RemoteGetLibAttr_Proxy(This, ppTLibAttr, &stg);
1958 }
1959
1960 HRESULT __RPC_STUB ITypeLib_GetLibAttr_Stub(
1961     ITypeLib* This,
1962     LPTLIBATTR* ppTLibAttr,
1963     CLEANLOCALSTORAGE* pDummy)
1964 {
1965     HRESULT hr;
1966     TRACE("(%p, %p)\n", This, ppTLibAttr);
1967
1968     hr = ITypeLib_GetLibAttr(This, ppTLibAttr);
1969     if(hr != S_OK)
1970         return hr;
1971
1972     pDummy->flags = CLS_LIBATTR;
1973     ITypeLib_AddRef(This);
1974     pDummy->pInterface = (IUnknown*)This;
1975     pDummy->pStorage = ppTLibAttr;
1976     return hr;
1977 }
1978
1979 HRESULT CALLBACK ITypeLib_GetDocumentation_Proxy(ITypeLib *This, INT index, BSTR *name,
1980                                                  BSTR *doc_string, DWORD *help_context,
1981                                                  BSTR *help_file)
1982 {
1983     DWORD dummy_help_context, flags = 0;
1984     BSTR dummy_name, dummy_doc_string, dummy_help_file;
1985     HRESULT hr;
1986     TRACE("(%p, %d, %p, %p, %p, %p)\n", This, index, name, doc_string, help_context, help_file);
1987
1988     if(!name) name = &dummy_name;
1989     else flags = 1;
1990
1991     if(!doc_string) doc_string = &dummy_doc_string;
1992     else flags |= 2;
1993
1994     if(!help_context) help_context = &dummy_help_context;
1995     else flags |= 4;
1996
1997     if(!help_file) help_file = &dummy_help_file;
1998     else flags |= 8;
1999
2000     hr = ITypeLib_RemoteGetDocumentation_Proxy(This, index, flags, name, doc_string, help_context, help_file);
2001
2002     /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
2003
2004     return hr;
2005 }
2006
2007 HRESULT __RPC_STUB ITypeLib_GetDocumentation_Stub(ITypeLib *This, INT index, DWORD flags,
2008                                                   BSTR *name, BSTR *doc_string,
2009                                                   DWORD *help_context, BSTR *help_file)
2010 {
2011     TRACE("(%p, %d, %08x, %p, %p, %p, %p)\n", This, index, flags, name, doc_string, help_context, help_file);
2012
2013     *name = *doc_string = *help_file = NULL;
2014     *help_context = 0;
2015
2016     if(!(flags & 1)) name = NULL;
2017     if(!(flags & 2)) doc_string = NULL;
2018     if(!(flags & 4)) help_context = NULL;
2019     if(!(flags & 8)) help_file = NULL;
2020
2021     return ITypeLib_GetDocumentation(This, index, name, doc_string, help_context, help_file);
2022 }
2023
2024 HRESULT CALLBACK ITypeLib_IsName_Proxy(
2025     ITypeLib* This,
2026     LPOLESTR szNameBuf,
2027     ULONG lHashVal,
2028     BOOL* pfName)
2029 {
2030   FIXME("not implemented\n");
2031   return E_FAIL;
2032 }
2033
2034 HRESULT __RPC_STUB ITypeLib_IsName_Stub(
2035     ITypeLib* This,
2036     LPOLESTR szNameBuf,
2037     ULONG lHashVal,
2038     BOOL* pfName,
2039     BSTR* pBstrLibName)
2040 {
2041   FIXME("not implemented\n");
2042   return E_FAIL;
2043 }
2044
2045 HRESULT CALLBACK ITypeLib_FindName_Proxy(
2046     ITypeLib* This,
2047     LPOLESTR szNameBuf,
2048     ULONG lHashVal,
2049     ITypeInfo** ppTInfo,
2050     MEMBERID* rgMemId,
2051     USHORT* pcFound)
2052 {
2053   FIXME("not implemented\n");
2054   return E_FAIL;
2055 }
2056
2057 HRESULT __RPC_STUB ITypeLib_FindName_Stub(
2058     ITypeLib* This,
2059     LPOLESTR szNameBuf,
2060     ULONG lHashVal,
2061     ITypeInfo** ppTInfo,
2062     MEMBERID* rgMemId,
2063     USHORT* pcFound,
2064     BSTR* pBstrLibName)
2065 {
2066   FIXME("not implemented\n");
2067   return E_FAIL;
2068 }
2069
2070 void CALLBACK ITypeLib_ReleaseTLibAttr_Proxy(
2071     ITypeLib* This,
2072     TLIBATTR* pTLibAttr)
2073 {
2074     TRACE("(%p, %p)\n", This, pTLibAttr);
2075     CoTaskMemFree(pTLibAttr);
2076 }
2077
2078 HRESULT __RPC_STUB ITypeLib_ReleaseTLibAttr_Stub(
2079     ITypeLib* This)
2080 {
2081     TRACE("nothing to do\n");
2082     return S_OK;
2083 }
2084
2085
2086 /* ITypeLib2 */
2087
2088 HRESULT CALLBACK ITypeLib2_GetLibStatistics_Proxy(
2089     ITypeLib2* This,
2090     ULONG* pcUniqueNames,
2091     ULONG* pcchUniqueNames)
2092 {
2093   FIXME("not implemented\n");
2094   return E_FAIL;
2095 }
2096
2097 HRESULT __RPC_STUB ITypeLib2_GetLibStatistics_Stub(
2098     ITypeLib2* This,
2099     ULONG* pcUniqueNames,
2100     ULONG* pcchUniqueNames)
2101 {
2102   FIXME("not implemented\n");
2103   return E_FAIL;
2104 }
2105
2106 HRESULT CALLBACK ITypeLib2_GetDocumentation2_Proxy(ITypeLib2 *This, INT index,
2107                                                    LCID lcid, BSTR *help_string,
2108                                                    DWORD *help_context, BSTR *help_dll)
2109 {
2110     DWORD dummy_help_context, flags = 0;
2111     BSTR dummy_help_string, dummy_help_dll;
2112     HRESULT hr;
2113     TRACE("(%p, %d, %08x, %p, %p, %p)\n", This, index, lcid, help_string, help_context, help_dll);
2114
2115     if(!help_string) help_string = &dummy_help_string;
2116     else flags = 1;
2117
2118     if(!help_context) help_context = &dummy_help_context;
2119     else flags |= 2;
2120
2121     if(!help_dll) help_dll = &dummy_help_dll;
2122     else flags |= 4;
2123
2124     hr = ITypeLib2_RemoteGetDocumentation2_Proxy(This, index, lcid, flags, help_string, help_context, help_dll);
2125
2126     /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
2127
2128     return hr;
2129 }
2130
2131 HRESULT __RPC_STUB ITypeLib2_GetDocumentation2_Stub(ITypeLib2 *This, INT index, LCID lcid,
2132                                                     DWORD flags, BSTR *help_string,
2133                                                     DWORD *help_context, BSTR *help_dll)
2134 {
2135     TRACE("(%p, %d, %08x, %08x, %p, %p, %p)\n", This, index, lcid, flags, help_string, help_context, help_dll);
2136
2137     *help_string = *help_dll = NULL;
2138     *help_context = 0;
2139
2140     if(!(flags & 1)) help_string = NULL;
2141     if(!(flags & 2)) help_context = NULL;
2142     if(!(flags & 4)) help_dll = NULL;
2143
2144     return ITypeLib2_GetDocumentation2(This, index, lcid, help_string, help_context, help_dll);
2145 }
2146
2147 HRESULT CALLBACK IPropertyBag_Read_Proxy(
2148     IPropertyBag* This,
2149     LPCOLESTR pszPropName,
2150     VARIANT *pVar,
2151     IErrorLog *pErrorLog)
2152 {
2153   IUnknown *pUnk = NULL;
2154   TRACE("(%p, %s, %p, %p)\n", This, debugstr_w(pszPropName), pVar, pErrorLog);
2155
2156   if(!pVar)
2157     return E_POINTER;
2158
2159   if(V_VT(pVar) & (VT_BYREF | VT_ARRAY | VT_VECTOR))
2160   {
2161     FIXME("Variant type %x is byref, array or vector. Not implemented.\n", V_VT(pVar));
2162     return E_NOTIMPL;
2163   }
2164
2165   switch(V_VT(pVar))
2166   {
2167     case VT_DISPATCH:
2168       pUnk = (IUnknown*)V_DISPATCH(pVar);
2169       break;
2170     case VT_UNKNOWN:
2171       pUnk = V_UNKNOWN(pVar);
2172       break;
2173     case VT_SAFEARRAY:
2174       FIXME("Safearray support not yet implemented.\n");
2175       return E_NOTIMPL;
2176     default:
2177       FIXME("Unknown V_VT %d - support not yet implemented.\n", V_VT(pVar));
2178       return E_NOTIMPL;
2179   }
2180
2181   return IPropertyBag_RemoteRead_Proxy(This, pszPropName, pVar, pErrorLog,
2182                                        V_VT(pVar), pUnk);
2183 }
2184
2185 HRESULT __RPC_STUB IPropertyBag_Read_Stub(
2186     IPropertyBag* This,
2187     LPCOLESTR pszPropName,
2188     VARIANT *pVar,
2189     IErrorLog *pErrorLog,
2190     DWORD varType,
2191     IUnknown *pUnkObj)
2192 {
2193   static const WCHAR emptyWstr[1] = {0};
2194   IDispatch *disp;
2195   HRESULT hr;
2196   TRACE("(%p, %s, %p, %p, %x, %p)\n", This, debugstr_w(pszPropName), pVar,
2197                                      pErrorLog, varType, pUnkObj);
2198
2199   if(varType & (VT_BYREF | VT_ARRAY | VT_VECTOR))
2200   {
2201     FIXME("Variant type %x is byref, array or vector. Not implemented.\n", V_VT(pVar));
2202     return E_NOTIMPL;
2203   }
2204
2205   V_VT(pVar) = varType;
2206   switch(varType)
2207   {
2208     case VT_DISPATCH:
2209       hr = IUnknown_QueryInterface(pUnkObj, &IID_IDispatch, (LPVOID*)&disp);
2210       if(FAILED(hr))
2211         return hr;
2212       IUnknown_Release(pUnkObj);
2213       V_DISPATCH(pVar) = disp;
2214       break;
2215     case VT_UNKNOWN:
2216       V_UNKNOWN(pVar) = pUnkObj;
2217       break;
2218     case VT_BSTR:
2219       V_BSTR(pVar) = SysAllocString(emptyWstr);
2220       break;
2221     case VT_SAFEARRAY:
2222       FIXME("Safearray support not yet implemented.\n");
2223       return E_NOTIMPL;
2224     default:
2225       break;
2226   }
2227   hr = IPropertyBag_Read(This, pszPropName, pVar, pErrorLog);
2228   if(FAILED(hr))
2229     VariantClear(pVar);
2230
2231   return hr;
2232 }
2233
2234 /* call_as/local stubs for ocidl.idl */
2235
2236 HRESULT CALLBACK IClassFactory2_CreateInstanceLic_Proxy(
2237     IClassFactory2* This,
2238     IUnknown *pUnkOuter,
2239     IUnknown *pUnkReserved,
2240     REFIID riid,
2241     BSTR bstrKey,
2242     PVOID *ppvObj)
2243 {
2244     FIXME("not implemented\n");
2245     return E_NOTIMPL;
2246 }
2247
2248 HRESULT __RPC_STUB IClassFactory2_CreateInstanceLic_Stub(
2249     IClassFactory2* This,
2250     REFIID riid,
2251     BSTR bstrKey,
2252     IUnknown **ppvObj)
2253 {
2254     FIXME("not implemented\n");
2255     return E_NOTIMPL;
2256 }
2257
2258 HRESULT CALLBACK IEnumConnections_Next_Proxy(
2259     IEnumConnections* This,
2260     ULONG cConnections,
2261     LPCONNECTDATA rgcd,
2262     ULONG *pcFetched)
2263 {
2264     FIXME("not implemented\n");
2265     return E_NOTIMPL;
2266 }
2267
2268 HRESULT __RPC_STUB IEnumConnections_Next_Stub(
2269     IEnumConnections* This,
2270     ULONG cConnections,
2271     LPCONNECTDATA rgcd,
2272     ULONG *pcFetched)
2273 {
2274     FIXME("not implemented\n");
2275     return E_NOTIMPL;
2276 }
2277
2278 HRESULT CALLBACK IEnumConnectionPoints_Next_Proxy(
2279     IEnumConnectionPoints* This,
2280     ULONG cConnections,
2281     LPCONNECTIONPOINT *ppCP,
2282     ULONG *pcFetched)
2283 {
2284     FIXME("not implemented\n");
2285     return E_NOTIMPL;
2286 }
2287
2288 HRESULT __RPC_STUB IEnumConnectionPoints_Next_Stub(
2289     IEnumConnectionPoints* This,
2290     ULONG cConnections,
2291     LPCONNECTIONPOINT *ppCP,
2292     ULONG *pcFetched)
2293 {
2294     FIXME("not implemented\n");
2295     return E_NOTIMPL;
2296 }
2297
2298 HRESULT CALLBACK IPersistMemory_Load_Proxy(
2299     IPersistMemory* This,
2300     LPVOID pMem,
2301     ULONG cbSize)
2302 {
2303     FIXME("not implemented\n");
2304     return E_NOTIMPL;
2305 }
2306
2307 HRESULT __RPC_STUB IPersistMemory_Load_Stub(
2308     IPersistMemory* This,
2309     BYTE *pMem,
2310     ULONG cbSize)
2311 {
2312     FIXME("not implemented\n");
2313     return E_NOTIMPL;
2314 }
2315
2316 HRESULT CALLBACK IPersistMemory_Save_Proxy(
2317     IPersistMemory* This,
2318     LPVOID pMem,
2319     BOOL fClearDirty,
2320     ULONG cbSize)
2321 {
2322     FIXME("not implemented\n");
2323     return E_NOTIMPL;
2324 }
2325
2326 HRESULT __RPC_STUB IPersistMemory_Save_Stub(
2327     IPersistMemory* This,
2328     BYTE *pMem,
2329     BOOL fClearDirty,
2330     ULONG cbSize)
2331 {
2332     FIXME("not implemented\n");
2333     return E_NOTIMPL;
2334 }
2335
2336 void CALLBACK IAdviseSinkEx_OnViewStatusChange_Proxy(
2337     IAdviseSinkEx* This,
2338     DWORD dwViewStatus)
2339 {
2340     FIXME("not implemented\n");
2341 }
2342
2343 HRESULT __RPC_STUB IAdviseSinkEx_OnViewStatusChange_Stub(
2344     IAdviseSinkEx* This,
2345     DWORD dwViewStatus)
2346 {
2347     FIXME("not implemented\n");
2348     return E_NOTIMPL;
2349 }
2350
2351 HRESULT CALLBACK IEnumOleUndoUnits_Next_Proxy(
2352     IEnumOleUndoUnits* This,
2353     ULONG cElt,
2354     IOleUndoUnit **rgElt,
2355     ULONG *pcEltFetched)
2356 {
2357     FIXME("not implemented\n");
2358     return E_NOTIMPL;
2359 }
2360
2361 HRESULT __RPC_STUB IEnumOleUndoUnits_Next_Stub(
2362     IEnumOleUndoUnits* This,
2363     ULONG cElt,
2364     IOleUndoUnit **rgElt,
2365     ULONG *pcEltFetched)
2366 {
2367     FIXME("not implemented\n");
2368     return E_NOTIMPL;
2369 }
2370
2371 HRESULT CALLBACK IQuickActivate_QuickActivate_Proxy(
2372     IQuickActivate* This,
2373     QACONTAINER *pQaContainer,
2374     QACONTROL *pQaControl)
2375 {
2376     FIXME("not implemented\n");
2377     return E_NOTIMPL;
2378 }
2379
2380 HRESULT __RPC_STUB IQuickActivate_QuickActivate_Stub(
2381     IQuickActivate* This,
2382     QACONTAINER *pQaContainer,
2383     QACONTROL *pQaControl)
2384 {
2385     FIXME("not implemented\n");
2386     return E_NOTIMPL;
2387 }