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