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