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

   1 /*
   2  * Miscellaneous Marshaling Routines
   3  *
   4  * Copyright 2005 Robert Shearman
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdarg.h>
  23 #include <string.h>
  24
  25 #define COBJMACROS
  26 #define NONAMELESSUNION
  27 #define NONAMELESSSTRUCT
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "wingdi.h"
  32 #include "winuser.h"
  33 #include "winerror.h"
  34
  35 #include "ole2.h"
  36 #include "oleauto.h"
  37 #include "rpcproxy.h"
  38
  39 #include "wine/unicode.h"
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  43
  44 #define ALIGNED_LENGTH(_Len, _Align) (((_Len)+(_Align))&~(_Align))
  45 #define ALIGNED_POINTER(_Ptr, _Align) ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
  46 #define ALIGN_LENGTH(_Len, _Align) _Len = ALIGNED_LENGTH(_Len, _Align)
  47 #define ALIGN_POINTER(_Ptr, _Align) _Ptr = ALIGNED_POINTER(_Ptr, _Align)
  48
  49 #define USER_MARSHAL_PTR_PREFIX \
  50   ( (DWORD)'U'         | ( (DWORD)'s' << 8 ) | \
  51   ( (DWORD)'e' << 16 ) | ( (DWORD)'r' << 24 ) )
  52
  53 static const char* debugstr_user_flags(ULONG *pFlags)
  54 {
  55     char buf[12];
  56     const char* loword;
  57     switch (LOWORD(*pFlags))
  58     {
  59     case MSHCTX_LOCAL:
  60         loword="MSHCTX_LOCAL";
  61         break;
  62     case MSHCTX_NOSHAREDMEM:
  63         loword="MSHCTX_NOSHAREDMEM";
  64         break;
  65     case MSHCTX_DIFFERENTMACHINE:
  66         loword="MSHCTX_DIFFERENTMACHINE";
  67         break;
  68     case MSHCTX_INPROC:
  69         loword="MSHCTX_INPROC";
  70         break;
  71     default:
  72         sprintf(buf, "%d", LOWORD(*pFlags));
  73         loword=buf;
  74     }
  75
  76     if (HIWORD(*pFlags) == NDR_LOCAL_DATA_REPRESENTATION)
  77         return wine_dbg_sprintf("MAKELONG(NDR_LOCAL_REPRESENTATION, %s)", loword);
  78     else
  79         return wine_dbg_sprintf("MAKELONG(0x%04x, %s)", HIWORD(*pFlags), loword);
  80 }
  81
  82 /******************************************************************************
  83  *           CLIPFORMAT_UserSize [OLE32.@]
  84  *
  85  * Calculates the buffer size required to marshal a clip format.
  86  *
  87  * PARAMS
  88  *  pFlags       [I] Flags. See notes.
  89  *  StartingSize [I] Starting size of the buffer. This value is added on to
  90  *                   the buffer size required for the clip format.
  91  *  pCF          [I] Clip format to size.
  92  *
  93  * RETURNS
  94  *  The buffer size required to marshal a clip format plus the starting size.
  95  *
  96  * NOTES
  97  *  Even though the function is documented to take a pointer to an unsigned
  98  *  long in pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
  99  *  the first parameter is an unsigned long.
 100  *  This function is only intended to be called by the RPC runtime.
 101  */
 102 ULONG __RPC_USER CLIPFORMAT_UserSize(ULONG *pFlags, ULONG StartingSize, CLIPFORMAT *pCF)
 103 {
 104     ULONG size = StartingSize;
 105
 106     TRACE("(%s, %d, %p\n", debugstr_user_flags(pFlags), StartingSize, pCF);
 107
 108     size += sizeof(userCLIPFORMAT);
 109
 110     /* only need to marshal the name if it is not a pre-defined type and
 111      * we are going remote */
 112     if ((*pCF >= 0xc000) && (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE))
 113     {
 114         WCHAR format[255];
 115         INT ret;
 116         size += 3 * sizeof(INT);
 117         /* urg! this function is badly designed because it won't tell us how
 118          * much space is needed without doing a dummy run of storing the
 119          * name into a buffer */
 120         ret = GetClipboardFormatNameW(*pCF, format, sizeof(format)/sizeof(format[0])-1);
 121         if (!ret)
 122             RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL);
 123         size += (ret + 1) * sizeof(WCHAR);
 124     }
 125     return size;
 126 }
 127
 128 /******************************************************************************
 129  *           CLIPFORMAT_UserMarshal [OLE32.@]
 130  *
 131  * Marshals a clip format into a buffer.
 132  *
 133  * PARAMS
 134  *  pFlags  [I] Flags. See notes.
 135  *  pBuffer [I] Buffer to marshal the clip format into.
 136  *  pCF     [I] Clip format to marshal.
 137  *
 138  * RETURNS
 139  *  The end of the marshaled data in the buffer.
 140  *
 141  * NOTES
 142  *  Even though the function is documented to take a pointer to an unsigned
 143  *  long in pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 144  *  the first parameter is an unsigned long.
 145  *  This function is only intended to be called by the RPC runtime.
 146  */
 147 unsigned char * __RPC_USER CLIPFORMAT_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, CLIPFORMAT *pCF)
 148 {
 149     wireCLIPFORMAT wirecf = (wireCLIPFORMAT)pBuffer;
 150
 151     TRACE("(%s, %p, &0x%04x\n", debugstr_user_flags(pFlags), pBuffer, *pCF);
 152
 153     wirecf->u.dwValue = *pCF;
 154     pBuffer += sizeof(*wirecf);
 155
 156     /* only need to marshal the name if it is not a pre-defined type and
 157      * we are going remote */
 158     if ((*pCF >= 0xc000) && (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE))
 159     {
 160         WCHAR format[255];
 161         INT len;
 162         wirecf->fContext = WDT_REMOTE_CALL;
 163         len = GetClipboardFormatNameW(*pCF, format, sizeof(format)/sizeof(format[0])-1);
 164         if (!len)
 165             RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL);
 166         len += 1;
 167         *(INT *)pBuffer = len;
 168         pBuffer += sizeof(INT);
 169         *(INT *)pBuffer = 0;
 170         pBuffer += sizeof(INT);
 171         *(INT *)pBuffer = len;
 172         pBuffer += sizeof(INT);
 173         TRACE("marshaling format name %s\n", debugstr_wn(format, len-1));
 174         lstrcpynW((LPWSTR)pBuffer, format, len);
 175         pBuffer += len * sizeof(WCHAR);
 176         *(WCHAR *)pBuffer = '\0';
 177         pBuffer += sizeof(WCHAR);
 178     }
 179     else
 180         wirecf->fContext = WDT_INPROC_CALL;
 181
 182     return pBuffer;
 183 }
 184
 185 /******************************************************************************
 186  *           CLIPFORMAT_UserUnmarshal [OLE32.@]
 187  *
 188  * Unmarshals a clip format from a buffer.
 189  *
 190  * PARAMS
 191  *  pFlags  [I] Flags. See notes.
 192  *  pBuffer [I] Buffer to marshal the clip format from.
 193  *  pCF     [O] Address that receive the unmarshaled clip format.
 194  *
 195  * RETURNS
 196  *  The end of the marshaled data in the buffer.
 197  *
 198  * NOTES
 199  *  Even though the function is documented to take a pointer to an unsigned
 200  *  long in pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 201  *  the first parameter is an unsigned long.
 202  *  This function is only intended to be called by the RPC runtime.
 203  */
 204 unsigned char * __RPC_USER CLIPFORMAT_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, CLIPFORMAT *pCF)
 205 {
 206     wireCLIPFORMAT wirecf = (wireCLIPFORMAT)pBuffer;
 207
 208     TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, pCF);
 209
 210     pBuffer += sizeof(*wirecf);
 211     if (wirecf->fContext == WDT_INPROC_CALL)
 212         *pCF = (CLIPFORMAT)wirecf->u.dwValue;
 213     else if (wirecf->fContext == WDT_REMOTE_CALL)
 214     {
 215         CLIPFORMAT cf;
 216         INT len = *(INT *)pBuffer;
 217         pBuffer += sizeof(INT);
 218         if (*(INT *)pBuffer != 0)
 219             RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
 220         pBuffer += sizeof(INT);
 221         if (*(INT *)pBuffer != len)
 222             RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
 223         pBuffer += sizeof(INT);
 224         if (((WCHAR *)pBuffer)[len] != '\0')
 225             RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
 226         TRACE("unmarshaling clip format %s\n", debugstr_w((LPCWSTR)pBuffer));
 227         cf = RegisterClipboardFormatW((LPCWSTR)pBuffer);
 228         pBuffer += (len + 1) * sizeof(WCHAR);
 229         if (!cf)
 230             RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL);
 231         *pCF = cf;
 232     }
 233     else
 234         /* code not really appropriate, but nearest I can find */
 235         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 236     return pBuffer;
 237 }
 238
 239 /******************************************************************************
 240  *           CLIPFORMAT_UserFree [OLE32.@]
 241  *
 242  * Frees an unmarshaled clip format.
 243  *
 244  * PARAMS
 245  *  pFlags  [I] Flags. See notes.
 246  *  pCF     [I] Clip format to free.
 247  *
 248  * RETURNS
 249  *  The end of the marshaled data in the buffer.
 250  *
 251  * NOTES
 252  *  Even though the function is documented to take a pointer to an unsigned
 253  *  long in pFlags, it actually takes a pointer to a USER_MARSHAL_CB
 254  *  structure, of which the first parameter is an unsigned long.
 255  *  This function is only intended to be called by the RPC runtime.
 256  */
 257 void __RPC_USER CLIPFORMAT_UserFree(ULONG *pFlags, CLIPFORMAT *pCF)
 258 {
 259     /* there is no inverse of the RegisterClipboardFormat function,
 260      * so nothing to do */
 261 }
 262
 263 static ULONG handle_UserSize(ULONG *pFlags, ULONG StartingSize, HANDLE *handle)
 264 {
 265     if (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE)
 266     {
 267         ERR("can't remote a local handle\n");
 268         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 269         return StartingSize;
 270     }
 271     return StartingSize + sizeof(RemotableHandle);
 272 }
 273
 274 static unsigned char * handle_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HANDLE *handle)
 275 {
 276     RemotableHandle *remhandle = (RemotableHandle *)pBuffer;
 277     if (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE)
 278     {
 279         ERR("can't remote a local handle\n");
 280         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 281         return pBuffer;
 282     }
 283     remhandle->fContext = WDT_INPROC_CALL;
 284     remhandle->u.hInproc = (LONG_PTR)*handle;
 285     return pBuffer + sizeof(RemotableHandle);
 286 }
 287
 288 static unsigned char * handle_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HANDLE *handle)
 289 {
 290     RemotableHandle *remhandle = (RemotableHandle *)pBuffer;
 291     if (remhandle->fContext != WDT_INPROC_CALL)
 292         RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
 293     *handle = (HANDLE)remhandle->u.hInproc;
 294     return pBuffer + sizeof(RemotableHandle);
 295 }
 296
 297 static void handle_UserFree(ULONG *pFlags, HANDLE *phMenu)
 298 {
 299     /* nothing to do */
 300 }
 301
 302 #define IMPL_WIREM_HANDLE(type) \
 303     ULONG __RPC_USER type##_UserSize(ULONG *pFlags, ULONG StartingSize, type *handle) \
 304     { \
 305         TRACE("(%s, %d, %p\n", debugstr_user_flags(pFlags), StartingSize, handle); \
 306         return handle_UserSize(pFlags, StartingSize, (HANDLE *)handle); \
 307     } \
 308     \
 309     unsigned char * __RPC_USER type##_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, type *handle) \
 310     { \
 311         TRACE("(%s, %p, &%p\n", debugstr_user_flags(pFlags), pBuffer, *handle); \
 312         return handle_UserMarshal(pFlags, pBuffer, (HANDLE *)handle); \
 313     } \
 314     \
 315     unsigned char * __RPC_USER type##_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, type *handle) \
 316     { \
 317         TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, handle); \
 318         return handle_UserUnmarshal(pFlags, pBuffer, (HANDLE *)handle); \
 319     } \
 320     \
 321     void __RPC_USER type##_UserFree(ULONG *pFlags, type *handle) \
 322     { \
 323         TRACE("(%s, &%p\n", debugstr_user_flags(pFlags), *handle); \
 324         handle_UserFree(pFlags, (HANDLE *)handle); \
 325     }
 326
 327 IMPL_WIREM_HANDLE(HACCEL)
 328 IMPL_WIREM_HANDLE(HMENU)
 329 IMPL_WIREM_HANDLE(HWND)
 330
 331 /******************************************************************************
 332  *           HGLOBAL_UserSize [OLE32.@]
 333  *
 334  * Calculates the buffer size required to marshal an HGLOBAL.
 335  *
 336  * PARAMS
 337  *  pFlags       [I] Flags. See notes.
 338  *  StartingSize [I] Starting size of the buffer. This value is added on to
 339  *                   the buffer size required for the clip format.
 340  *  phGlobal     [I] HGLOBAL to size.
 341  *
 342  * RETURNS
 343  *  The buffer size required to marshal an HGLOBAL plus the starting size.
 344  *
 345  * NOTES
 346  *  Even though the function is documented to take a pointer to a ULONG in
 347  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 348  *  the first parameter is a ULONG.
 349  *  This function is only intended to be called by the RPC runtime.
 350  */
 351 ULONG __RPC_USER HGLOBAL_UserSize(ULONG *pFlags, ULONG StartingSize, HGLOBAL *phGlobal)
 352 {
 353     ULONG size = StartingSize;
 354
 355     TRACE("(%s, %d, %p\n", debugstr_user_flags(pFlags), StartingSize, phGlobal);
 356
 357     ALIGN_LENGTH(size, 3);
 358
 359     size += sizeof(ULONG);
 360
 361     if (LOWORD(*pFlags == MSHCTX_INPROC))
 362         size += sizeof(HGLOBAL);
 363     else
 364     {
 365         size += sizeof(ULONG);
 366         if (*phGlobal)
 367         {
 368             SIZE_T ret;
 369             size += 3 * sizeof(ULONG);
 370             ret = GlobalSize(*phGlobal);
 371             size += (ULONG)ret;
 372         }
 373     }
 374
 375     return size;
 376 }
 377
 378 /******************************************************************************
 379  *           HGLOBAL_UserMarshal [OLE32.@]
 380  *
 381  * Marshals an HGLOBAL into a buffer.
 382  *
 383  * PARAMS
 384  *  pFlags   [I] Flags. See notes.
 385  *  pBuffer  [I] Buffer to marshal the clip format into.
 386  *  phGlobal [I] HGLOBAL to marshal.
 387  *
 388  * RETURNS
 389  *  The end of the marshaled data in the buffer.
 390  *
 391  * NOTES
 392  *  Even though the function is documented to take a pointer to a ULONG in
 393  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 394  *  the first parameter is a ULONG.
 395  *  This function is only intended to be called by the RPC runtime.
 396  */
 397 unsigned char * __RPC_USER HGLOBAL_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HGLOBAL *phGlobal)
 398 {
 399     TRACE("(%s, %p, &%p\n", debugstr_user_flags(pFlags), pBuffer, *phGlobal);
 400
 401     ALIGN_POINTER(pBuffer, 3);
 402
 403     if (LOWORD(*pFlags == MSHCTX_INPROC))
 404     {
 405         if (sizeof(*phGlobal) == 8)
 406             *(ULONG *)pBuffer = WDT_INPROC64_CALL;
 407         else
 408             *(ULONG *)pBuffer = WDT_INPROC_CALL;
 409         pBuffer += sizeof(ULONG);
 410         *(HGLOBAL *)pBuffer = *phGlobal;
 411         pBuffer += sizeof(HGLOBAL);
 412     }
 413     else
 414     {
 415         *(ULONG *)pBuffer = WDT_REMOTE_CALL;
 416         pBuffer += sizeof(ULONG);
 417         *(ULONG *)pBuffer = (ULONG)*phGlobal;
 418         pBuffer += sizeof(ULONG);
 419         if (*phGlobal)
 420         {
 421             const unsigned char *memory;
 422             SIZE_T size = GlobalSize(*phGlobal);
 423             *(ULONG *)pBuffer = (ULONG)size;
 424             pBuffer += sizeof(ULONG);
 425             *(ULONG *)pBuffer = (ULONG)*phGlobal;
 426             pBuffer += sizeof(ULONG);
 427             *(ULONG *)pBuffer = (ULONG)size;
 428             pBuffer += sizeof(ULONG);
 429
 430             memory = GlobalLock(*phGlobal);
 431             memcpy(pBuffer, memory, size);
 432             pBuffer += size;
 433             GlobalUnlock(*phGlobal);
 434         }
 435     }
 436
 437     return pBuffer;
 438 }
 439
 440 /******************************************************************************
 441  *           HGLOBAL_UserUnmarshal [OLE32.@]
 442  *
 443  * Unmarshals an HGLOBAL from a buffer.
 444  *
 445  * PARAMS
 446  *  pFlags   [I] Flags. See notes.
 447  *  pBuffer  [I] Buffer to marshal the clip format from.
 448  *  phGlobal [O] Address that receive the unmarshaled HGLOBAL.
 449  *
 450  * RETURNS
 451  *  The end of the marshaled data in the buffer.
 452  *
 453  * NOTES
 454  *  Even though the function is documented to take a pointer to an ULONG in
 455  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 456  *  the first parameter is an ULONG.
 457  *  This function is only intended to be called by the RPC runtime.
 458  */
 459 unsigned char * __RPC_USER HGLOBAL_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HGLOBAL *phGlobal)
 460 {
 461     ULONG fContext;
 462
 463     TRACE("(%s, %p, &%p\n", debugstr_user_flags(pFlags), pBuffer, *phGlobal);
 464
 465     ALIGN_POINTER(pBuffer, 3);
 466
 467     fContext = *(ULONG *)pBuffer;
 468     pBuffer += sizeof(ULONG);
 469
 470     if (((fContext == WDT_INPROC_CALL) && (sizeof(*phGlobal) < 8)) ||
 471         ((fContext == WDT_INPROC64_CALL) && (sizeof(*phGlobal) == 8)))
 472     {
 473         *phGlobal = *(HGLOBAL *)pBuffer;
 474         pBuffer += sizeof(*phGlobal);
 475     }
 476     else if (fContext == WDT_REMOTE_CALL)
 477     {
 478         ULONG handle;
 479
 480         handle = *(ULONG *)pBuffer;
 481         pBuffer += sizeof(ULONG);
 482
 483         if (handle)
 484         {
 485             ULONG size;
 486             void *memory;
 487
 488             size = *(ULONG *)pBuffer;
 489             pBuffer += sizeof(ULONG);
 490             /* redundancy is bad - it means you have to check consistency like
 491              * this: */
 492             if (*(ULONG *)pBuffer != handle)
 493             {
 494                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
 495                 return pBuffer;
 496             }
 497             pBuffer += sizeof(ULONG);
 498             /* redundancy is bad - it means you have to check consistency like
 499              * this: */
 500             if (*(ULONG *)pBuffer != size)
 501             {
 502                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
 503                 return pBuffer;
 504             }
 505             pBuffer += sizeof(ULONG);
 506
 507             /* FIXME: check size is not too big */
 508
 509             *phGlobal = GlobalAlloc(GMEM_MOVEABLE, size);
 510             memory = GlobalLock(*phGlobal);
 511             memcpy(memory, pBuffer, size);
 512             pBuffer += size;
 513             GlobalUnlock(*phGlobal);
 514         }
 515         else
 516             *phGlobal = NULL;
 517     }
 518     else
 519         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 520
 521     return pBuffer;
 522 }
 523
 524 /******************************************************************************
 525  *           HGLOBAL_UserFree [OLE32.@]
 526  *
 527  * Frees an unmarshaled HGLOBAL.
 528  *
 529  * PARAMS
 530  *  pFlags   [I] Flags. See notes.
 531  *  phGlobal [I] HGLOBAL to free.
 532  *
 533  * RETURNS
 534  *  The end of the marshaled data in the buffer.
 535  *
 536  * NOTES
 537  *  Even though the function is documented to take a pointer to a ULONG in
 538  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
 539  *  which the first parameter is a ULONG.
 540  *  This function is only intended to be called by the RPC runtime.
 541  */
 542 void __RPC_USER HGLOBAL_UserFree(ULONG *pFlags, HGLOBAL *phGlobal)
 543 {
 544     TRACE("(%s, &%p\n", debugstr_user_flags(pFlags), *phGlobal);
 545
 546     if (LOWORD(*pFlags != MSHCTX_INPROC) && *phGlobal)
 547         GlobalFree(*phGlobal);
 548 }
 549
 550 /******************************************************************************
 551  *           HBITMAP_UserSize [OLE32.@]
 552  *
 553  * Calculates the buffer size required to marshal a bitmap.
 554  *
 555  * PARAMS
 556  *  pFlags       [I] Flags. See notes.
 557  *  StartingSize [I] Starting size of the buffer. This value is added on to
 558  *                   the buffer size required for the clip format.
 559  *  phBmp        [I] Bitmap to size.
 560  *
 561  * RETURNS
 562  *  The buffer size required to marshal an bitmap plus the starting size.
 563  *
 564  * NOTES
 565  *  Even though the function is documented to take a pointer to a ULONG in
 566  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 567  *  the first parameter is a ULONG.
 568  *  This function is only intended to be called by the RPC runtime.
 569  */
 570 ULONG __RPC_USER HBITMAP_UserSize(ULONG *pFlags, ULONG StartingSize, HBITMAP *phBmp)
 571 {
 572     FIXME(":stub\n");
 573     return StartingSize;
 574 }
 575
 576 /******************************************************************************
 577 *           HBITMAP_UserMarshal [OLE32.@]
 578 *
 579 * Marshals a bitmap into a buffer.
 580 *
 581 * PARAMS
 582 *  pFlags  [I] Flags. See notes.
 583 *  pBuffer [I] Buffer to marshal the clip format into.
 584 *  phBmp   [I] Bitmap to marshal.
 585 *
 586 * RETURNS
 587 *  The end of the marshaled data in the buffer.
 588 *
 589 * NOTES
 590 *  Even though the function is documented to take a pointer to a ULONG in
 591 *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 592 *  the first parameter is a ULONG.
 593 *  This function is only intended to be called by the RPC runtime.
 594 */
 595 unsigned char * __RPC_USER HBITMAP_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HBITMAP *phBmp)
 596 {
 597     FIXME(":stub\n");
 598     return pBuffer;
 599 }
 600
 601 /******************************************************************************
 602  *           HBITMAP_UserUnmarshal [OLE32.@]
 603  *
 604  * Unmarshals a bitmap from a buffer.
 605  *
 606  * PARAMS
 607  *  pFlags   [I] Flags. See notes.
 608  *  pBuffer  [I] Buffer to marshal the clip format from.
 609  *  phBmp    [O] Address that receive the unmarshaled bitmap.
 610  *
 611  * RETURNS
 612  *  The end of the marshaled data in the buffer.
 613  *
 614  * NOTES
 615  *  Even though the function is documented to take a pointer to an ULONG in
 616  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 617  *  the first parameter is an ULONG.
 618  *  This function is only intended to be called by the RPC runtime.
 619  */
 620 unsigned char * __RPC_USER HBITMAP_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HBITMAP *phBmp)
 621 {
 622     FIXME(":stub\n");
 623     return pBuffer;
 624 }
 625
 626 /******************************************************************************
 627  *           HBITMAP_UserFree [OLE32.@]
 628  *
 629  * Frees an unmarshaled bitmap.
 630  *
 631  * PARAMS
 632  *  pFlags   [I] Flags. See notes.
 633  *  phBmp    [I] Bitmap to free.
 634  *
 635  * RETURNS
 636  *  The end of the marshaled data in the buffer.
 637  *
 638  * NOTES
 639  *  Even though the function is documented to take a pointer to a ULONG in
 640  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
 641  *  which the first parameter is a ULONG.
 642  *  This function is only intended to be called by the RPC runtime.
 643  */
 644 void __RPC_USER HBITMAP_UserFree(ULONG *pFlags, HBITMAP *phBmp)
 645 {
 646     FIXME(":stub\n");
 647 }
 648
 649 /******************************************************************************
 650  *           HDC_UserSize [OLE32.@]
 651  *
 652  * Calculates the buffer size required to marshal an HDC.
 653  *
 654  * PARAMS
 655  *  pFlags       [I] Flags. See notes.
 656  *  StartingSize [I] Starting size of the buffer. This value is added on to
 657  *                   the buffer size required for the clip format.
 658  *  phGlobal     [I] HDC to size.
 659  *
 660  * RETURNS
 661  *  The buffer size required to marshal an HDC plus the starting size.
 662  *
 663  * NOTES
 664  *  Even though the function is documented to take a pointer to a ULONG in
 665  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 666  *  the first parameter is a ULONG.
 667  *  This function is only intended to be called by the RPC runtime.
 668  */
 669 ULONG __RPC_USER HDC_UserSize(ULONG *pFlags, ULONG StartingSize, HDC *phdc)
 670 {
 671     FIXME(":stub\n");
 672     return StartingSize;
 673 }
 674
 675 /******************************************************************************
 676  *           HDC_UserMarshal [OLE32.@]
 677  *
 678  * Marshals an HDC into a buffer.
 679  *
 680  * PARAMS
 681  *  pFlags  [I] Flags. See notes.
 682  *  pBuffer [I] Buffer to marshal the clip format into.
 683  *  phdc    [I] HDC to marshal.
 684  *
 685  * RETURNS
 686  *  The end of the marshaled data in the buffer.
 687  *
 688  * NOTES
 689  *  Even though the function is documented to take a pointer to a ULONG in
 690  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 691  *  the first parameter is a ULONG.
 692  *  This function is only intended to be called by the RPC runtime.
 693  */
 694 unsigned char * __RPC_USER HDC_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HDC *phdc)
 695 {
 696     FIXME(":stub\n");
 697     return pBuffer;
 698 }
 699
 700 /******************************************************************************
 701  *           HDC_UserUnmarshal [OLE32.@]
 702  *
 703  * Unmarshals an HDC from a buffer.
 704  *
 705  * PARAMS
 706  *  pFlags   [I] Flags. See notes.
 707  *  pBuffer  [I] Buffer to marshal the clip format from.
 708  *  phdc     [O] Address that receive the unmarshaled HDC.
 709  *
 710  * RETURNS
 711  *  The end of the marshaled data in the buffer.
 712  *
 713  * NOTES
 714  *  Even though the function is documented to take a pointer to an ULONG in
 715  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 716  *  the first parameter is an ULONG.
 717  *  This function is only intended to be called by the RPC runtime.
 718  */
 719 unsigned char * __RPC_USER HDC_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HDC *phdc)
 720 {
 721     FIXME(":stub\n");
 722     return pBuffer;
 723 }
 724
 725 /******************************************************************************
 726  *           HDC_UserFree [OLE32.@]
 727  *
 728  * Frees an unmarshaled HDC.
 729  *
 730  * PARAMS
 731  *  pFlags   [I] Flags. See notes.
 732  *  phdc     [I] HDC to free.
 733  *
 734  * RETURNS
 735  *  The end of the marshaled data in the buffer.
 736  *
 737  * NOTES
 738  *  Even though the function is documented to take a pointer to a ULONG in
 739  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
 740  *  which the first parameter is a ULONG.
 741  *  This function is only intended to be called by the RPC runtime.
 742  */
 743 void __RPC_USER HDC_UserFree(ULONG *pFlags, HDC *phdc)
 744 {
 745     FIXME(":stub\n");
 746 }
 747
 748 /******************************************************************************
 749  *           HPALETTE_UserSize [OLE32.@]
 750  *
 751  * Calculates the buffer size required to marshal a palette.
 752  *
 753  * PARAMS
 754  *  pFlags       [I] Flags. See notes.
 755  *  StartingSize [I] Starting size of the buffer. This value is added on to
 756  *                   the buffer size required for the clip format.
 757  *  phPal        [I] Palette to size.
 758  *
 759  * RETURNS
 760  *  The buffer size required to marshal a palette plus the starting size.
 761  *
 762  * NOTES
 763  *  Even though the function is documented to take a pointer to a ULONG in
 764  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 765  *  the first parameter is a ULONG.
 766  *  This function is only intended to be called by the RPC runtime.
 767  */
 768 ULONG __RPC_USER HPALETTE_UserSize(ULONG *pFlags, ULONG StartingSize, HPALETTE *phPal)
 769 {
 770     FIXME(":stub\n");
 771     return StartingSize;
 772 }
 773
 774 /******************************************************************************
 775  *           HPALETTE_UserMarshal [OLE32.@]
 776  *
 777  * Marshals a palette into a buffer.
 778  *
 779  * PARAMS
 780  *  pFlags  [I] Flags. See notes.
 781  *  pBuffer [I] Buffer to marshal the clip format into.
 782  *  phPal   [I] Palette to marshal.
 783  *
 784  * RETURNS
 785  *  The end of the marshaled data in the buffer.
 786  *
 787  * NOTES
 788  *  Even though the function is documented to take a pointer to a ULONG in
 789  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 790  *  the first parameter is a ULONG.
 791  *  This function is only intended to be called by the RPC runtime.
 792  */
 793 unsigned char * __RPC_USER HPALETTE_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HPALETTE *phPal)
 794 {
 795     FIXME(":stub\n");
 796     return pBuffer;
 797 }
 798
 799 /******************************************************************************
 800  *           HPALETTE_UserUnmarshal [OLE32.@]
 801  *
 802  * Unmarshals a palette from a buffer.
 803  *
 804  * PARAMS
 805  *  pFlags   [I] Flags. See notes.
 806  *  pBuffer  [I] Buffer to marshal the clip format from.
 807  *  phPal    [O] Address that receive the unmarshaled palette.
 808  *
 809  * RETURNS
 810  *  The end of the marshaled data in the buffer.
 811  *
 812  * NOTES
 813  *  Even though the function is documented to take a pointer to an ULONG in
 814  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 815  *  the first parameter is an ULONG.
 816  *  This function is only intended to be called by the RPC runtime.
 817  */
 818 unsigned char * __RPC_USER HPALETTE_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HPALETTE *phPal)
 819 {
 820     FIXME(":stub\n");
 821     return pBuffer;
 822 }
 823
 824 /******************************************************************************
 825  *           HPALETTE_UserFree [OLE32.@]
 826  *
 827  * Frees an unmarshaled palette.
 828  *
 829  * PARAMS
 830  *  pFlags   [I] Flags. See notes.
 831  *  phPal    [I] Palette to free.
 832  *
 833  * RETURNS
 834  *  The end of the marshaled data in the buffer.
 835  *
 836  * NOTES
 837  *  Even though the function is documented to take a pointer to a ULONG in
 838  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
 839  *  which the first parameter is a ULONG.
 840  *  This function is only intended to be called by the RPC runtime.
 841  */
 842 void __RPC_USER HPALETTE_UserFree(ULONG *pFlags, HPALETTE *phPal)
 843 {
 844     FIXME(":stub\n");
 845 }
 846
 847
 848 /******************************************************************************
 849  *           HMETAFILE_UserSize [OLE32.@]
 850  *
 851  * Calculates the buffer size required to marshal a metafile.
 852  *
 853  * PARAMS
 854  *  pFlags       [I] Flags. See notes.
 855  *  StartingSize [I] Starting size of the buffer. This value is added on to
 856  *                   the buffer size required for the clip format.
 857  *  phmf         [I] Metafile to size.
 858  *
 859  * RETURNS
 860  *  The buffer size required to marshal a metafile plus the starting size.
 861  *
 862  * NOTES
 863  *  Even though the function is documented to take a pointer to a ULONG in
 864  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 865  *  the first parameter is a ULONG.
 866  *  This function is only intended to be called by the RPC runtime.
 867  */
 868 ULONG __RPC_USER HMETAFILE_UserSize(ULONG *pFlags, ULONG StartingSize, HMETAFILE *phmf)
 869 {
 870     ULONG size = StartingSize;
 871
 872     TRACE("(%s, %d, &%p\n", debugstr_user_flags(pFlags), StartingSize, *phmf);
 873
 874     ALIGN_LENGTH(size, 3);
 875
 876     size += sizeof(ULONG);
 877     if (LOWORD(*pFlags) == MSHCTX_INPROC)
 878         size += sizeof(ULONG_PTR);
 879     else
 880     {
 881         size += sizeof(ULONG);
 882
 883         if (*phmf)
 884         {
 885             UINT mfsize;
 886
 887             size += 2 * sizeof(ULONG);
 888             mfsize = GetMetaFileBitsEx(*phmf, 0, NULL);
 889             size += mfsize;
 890         }
 891     }
 892
 893     return size;
 894 }
 895
 896 /******************************************************************************
 897  *           HMETAFILE_UserMarshal [OLE32.@]
 898  *
 899  * Marshals a metafile into a buffer.
 900  *
 901  * PARAMS
 902  *  pFlags  [I] Flags. See notes.
 903  *  pBuffer [I] Buffer to marshal the clip format into.
 904  *  phEmf   [I] Metafile to marshal.
 905  *
 906  * RETURNS
 907  *  The end of the marshaled data in the buffer.
 908  *
 909  * NOTES
 910  *  Even though the function is documented to take a pointer to a ULONG in
 911  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 912  *  the first parameter is a ULONG.
 913  *  This function is only intended to be called by the RPC runtime.
 914  */
 915 unsigned char * __RPC_USER HMETAFILE_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILE *phmf)
 916 {
 917     TRACE("(%s, %p, &%p\n", debugstr_user_flags(pFlags), pBuffer, *phmf);
 918
 919     ALIGN_POINTER(pBuffer, 3);
 920
 921     if (LOWORD(*pFlags) == MSHCTX_INPROC)
 922     {
 923         if (sizeof(*phmf) == 8)
 924             *(ULONG *)pBuffer = WDT_INPROC64_CALL;
 925         else
 926             *(ULONG *)pBuffer = WDT_INPROC_CALL;
 927         pBuffer += sizeof(ULONG);
 928         *(HMETAFILE *)pBuffer = *phmf;
 929         pBuffer += sizeof(HMETAFILE);
 930     }
 931     else
 932     {
 933         *(ULONG *)pBuffer = WDT_REMOTE_CALL;
 934         pBuffer += sizeof(ULONG);
 935         *(ULONG *)pBuffer = (ULONG)(ULONG_PTR)*phmf;
 936         pBuffer += sizeof(ULONG);
 937
 938         if (*phmf)
 939         {
 940             UINT mfsize = GetMetaFileBitsEx(*phmf, 0, NULL);
 941
 942             *(ULONG *)pBuffer = mfsize;
 943             pBuffer += sizeof(ULONG);
 944             *(ULONG *)pBuffer = mfsize;
 945             pBuffer += sizeof(ULONG);
 946             GetMetaFileBitsEx(*phmf, mfsize, pBuffer);
 947             pBuffer += mfsize;
 948         }
 949     }
 950
 951     return pBuffer;
 952 }
 953
 954 /******************************************************************************
 955  *           HMETAFILE_UserUnmarshal [OLE32.@]
 956  *
 957  * Unmarshals a metafile from a buffer.
 958  *
 959  * PARAMS
 960  *  pFlags   [I] Flags. See notes.
 961  *  pBuffer  [I] Buffer to marshal the clip format from.
 962  *  phmf     [O] Address that receive the unmarshaled metafile.
 963  *
 964  * RETURNS
 965  *  The end of the marshaled data in the buffer.
 966  *
 967  * NOTES
 968  *  Even though the function is documented to take a pointer to an ULONG in
 969  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 970  *  the first parameter is an ULONG.
 971  *  This function is only intended to be called by the RPC runtime.
 972  */
 973 unsigned char * __RPC_USER HMETAFILE_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILE *phmf)
 974 {
 975     ULONG fContext;
 976
 977     TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, phmf);
 978
 979     ALIGN_POINTER(pBuffer, 3);
 980
 981     fContext = *(ULONG *)pBuffer;
 982     pBuffer += sizeof(ULONG);
 983
 984     if (((fContext == WDT_INPROC_CALL) && (sizeof(*phmf) < 8)) ||
 985         ((fContext == WDT_INPROC64_CALL) && (sizeof(*phmf) == 8)))
 986     {
 987         *phmf = *(HMETAFILE *)pBuffer;
 988         pBuffer += sizeof(*phmf);
 989     }
 990     else if (fContext == WDT_REMOTE_CALL)
 991     {
 992         ULONG handle;
 993
 994         handle = *(ULONG *)pBuffer;
 995         pBuffer += sizeof(ULONG);
 996
 997         if (handle)
 998         {
 999             ULONG size;
1000             size = *(ULONG *)pBuffer;
1001             pBuffer += sizeof(ULONG);
1002             if (size != *(ULONG *)pBuffer)
1003             {
1004                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
1005                 return pBuffer;
1006             }
1007             pBuffer += sizeof(ULONG);
1008             *phmf = SetMetaFileBitsEx(size, pBuffer);
1009             pBuffer += size;
1010         }
1011         else
1012             *phmf = NULL;
1013     }
1014     else
1015         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
1016
1017     return pBuffer;
1018 }
1019
1020 /******************************************************************************
1021  *           HMETAFILE_UserFree [OLE32.@]
1022  *
1023  * Frees an unmarshaled metafile.
1024  *
1025  * PARAMS
1026  *  pFlags   [I] Flags. See notes.
1027  *  phmf     [I] Metafile to free.
1028  *
1029  * RETURNS
1030  *  The end of the marshaled data in the buffer.
1031  *
1032  * NOTES
1033  *  Even though the function is documented to take a pointer to a ULONG in
1034  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
1035  *  which the first parameter is a ULONG.
1036  *  This function is only intended to be called by the RPC runtime.
1037  */
1038 void __RPC_USER HMETAFILE_UserFree(ULONG *pFlags, HMETAFILE *phmf)
1039 {
1040     TRACE("(%s, &%p\n", debugstr_user_flags(pFlags), *phmf);
1041
1042     if (LOWORD(*pFlags) != MSHCTX_INPROC)
1043         DeleteMetaFile(*phmf);
1044 }
1045
1046 /******************************************************************************
1047 *           HENHMETAFILE_UserSize [OLE32.@]
1048 *
1049 * Calculates the buffer size required to marshal an enhanced metafile.
1050 *
1051 * PARAMS
1052 *  pFlags       [I] Flags. See notes.
1053 *  StartingSize [I] Starting size of the buffer. This value is added on to
1054 *                   the buffer size required for the clip format.
1055 *  phEmf        [I] Enhanced metafile to size.
1056 *
1057 * RETURNS
1058 *  The buffer size required to marshal an enhanced metafile plus the starting size.
1059 *
1060 * NOTES
1061 *  Even though the function is documented to take a pointer to a ULONG in
1062 *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1063 *  the first parameter is a ULONG.
1064 *  This function is only intended to be called by the RPC runtime.
1065 */
1066 ULONG __RPC_USER HENHMETAFILE_UserSize(ULONG *pFlags, ULONG StartingSize, HENHMETAFILE *phEmf)
1067 {
1068     ULONG size = StartingSize;
1069
1070     TRACE("(%s, %d, %p\n", debugstr_user_flags(pFlags), StartingSize, *phEmf);
1071
1072     size += sizeof(ULONG);
1073     if (LOWORD(*pFlags) == MSHCTX_INPROC)
1074         size += sizeof(ULONG_PTR);
1075     else
1076     {
1077         size += sizeof(ULONG);
1078
1079         if (*phEmf)
1080         {
1081             UINT emfsize;
1082
1083             size += 2 * sizeof(ULONG);
1084             emfsize = GetEnhMetaFileBits(*phEmf, 0, NULL);
1085             size += emfsize;
1086         }
1087     }
1088
1089     return size;
1090 }
1091
1092 /******************************************************************************
1093  *           HENHMETAFILE_UserMarshal [OLE32.@]
1094  *
1095  * Marshals an enhance metafile into a buffer.
1096  *
1097  * PARAMS
1098  *  pFlags  [I] Flags. See notes.
1099  *  pBuffer [I] Buffer to marshal the clip format into.
1100  *  phEmf   [I] Enhanced metafile to marshal.
1101  *
1102  * RETURNS
1103  *  The end of the marshaled data in the buffer.
1104  *
1105  * NOTES
1106  *  Even though the function is documented to take a pointer to a ULONG in
1107  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1108  *  the first parameter is a ULONG.
1109  *  This function is only intended to be called by the RPC runtime.
1110  */
1111 unsigned char * __RPC_USER HENHMETAFILE_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
1112 {
1113     TRACE("(%s, %p, &%p\n", debugstr_user_flags(pFlags), pBuffer, *phEmf);
1114
1115     if (LOWORD(*pFlags) == MSHCTX_INPROC)
1116     {
1117         if (sizeof(*phEmf) == 8)
1118             *(ULONG *)pBuffer = WDT_INPROC64_CALL;
1119         else
1120             *(ULONG *)pBuffer = WDT_INPROC_CALL;
1121         pBuffer += sizeof(ULONG);
1122         *(HENHMETAFILE *)pBuffer = *phEmf;
1123         pBuffer += sizeof(HENHMETAFILE);
1124     }
1125     else
1126     {
1127         *(ULONG *)pBuffer = WDT_REMOTE_CALL;
1128         pBuffer += sizeof(ULONG);
1129         *(ULONG *)pBuffer = (ULONG)(ULONG_PTR)*phEmf;
1130         pBuffer += sizeof(ULONG);
1131
1132         if (*phEmf)
1133         {
1134             UINT emfsize = GetEnhMetaFileBits(*phEmf, 0, NULL);
1135
1136             *(ULONG *)pBuffer = emfsize;
1137             pBuffer += sizeof(ULONG);
1138             *(ULONG *)pBuffer = emfsize;
1139             pBuffer += sizeof(ULONG);
1140             GetEnhMetaFileBits(*phEmf, emfsize, pBuffer);
1141             pBuffer += emfsize;
1142         }
1143     }
1144
1145     return pBuffer;
1146 }
1147
1148 /******************************************************************************
1149  *           HENHMETAFILE_UserUnmarshal [OLE32.@]
1150  *
1151  * Unmarshals an enhanced metafile from a buffer.
1152  *
1153  * PARAMS
1154  *  pFlags   [I] Flags. See notes.
1155  *  pBuffer  [I] Buffer to marshal the clip format from.
1156  *  phEmf    [O] Address that receive the unmarshaled enhanced metafile.
1157  *
1158  * RETURNS
1159  *  The end of the marshaled data in the buffer.
1160  *
1161  * NOTES
1162  *  Even though the function is documented to take a pointer to an ULONG in
1163  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1164  *  the first parameter is an ULONG.
1165  *  This function is only intended to be called by the RPC runtime.
1166  */
1167 unsigned char * __RPC_USER HENHMETAFILE_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
1168 {
1169     ULONG fContext;
1170
1171     TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, phEmf);
1172
1173     fContext = *(ULONG *)pBuffer;
1174     pBuffer += sizeof(ULONG);
1175
1176     if (((fContext == WDT_INPROC_CALL) && (sizeof(*phEmf) < 8)) ||
1177         ((fContext == WDT_INPROC64_CALL) && (sizeof(*phEmf) == 8)))
1178     {
1179         *phEmf = *(HENHMETAFILE *)pBuffer;
1180         pBuffer += sizeof(*phEmf);
1181     }
1182     else if (fContext == WDT_REMOTE_CALL)
1183     {
1184         ULONG handle;
1185
1186         handle = *(ULONG *)pBuffer;
1187         pBuffer += sizeof(ULONG);
1188
1189         if (handle)
1190         {
1191             ULONG size;
1192             size = *(ULONG *)pBuffer;
1193             pBuffer += sizeof(ULONG);
1194             if (size != *(ULONG *)pBuffer)
1195             {
1196                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
1197                 return pBuffer;
1198             }
1199             pBuffer += sizeof(ULONG);
1200             *phEmf = SetEnhMetaFileBits(size, pBuffer);
1201             pBuffer += size;
1202         }
1203         else
1204             *phEmf = NULL;
1205     }
1206     else
1207         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
1208
1209     return pBuffer;
1210 }
1211
1212 /******************************************************************************
1213  *           HENHMETAFILE_UserFree [OLE32.@]
1214  *
1215  * Frees an unmarshaled enhanced metafile.
1216  *
1217  * PARAMS
1218  *  pFlags   [I] Flags. See notes.
1219  *  phEmf    [I] Enhanced metafile to free.
1220  *
1221  * RETURNS
1222  *  The end of the marshaled data in the buffer.
1223  *
1224  * NOTES
1225  *  Even though the function is documented to take a pointer to a ULONG in
1226  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
1227  *  which the first parameter is a ULONG.
1228  *  This function is only intended to be called by the RPC runtime.
1229  */
1230 void __RPC_USER HENHMETAFILE_UserFree(ULONG *pFlags, HENHMETAFILE *phEmf)
1231 {
1232     TRACE("(%s, &%p\n", debugstr_user_flags(pFlags), *phEmf);
1233
1234     if (LOWORD(*pFlags) != MSHCTX_INPROC)
1235         DeleteEnhMetaFile(*phEmf);
1236 }
1237
1238 /******************************************************************************
1239  *           HMETAFILEPICT_UserSize [OLE32.@]
1240  *
1241  * Calculates the buffer size required to marshal an metafile pict.
1242  *
1243  * PARAMS
1244  *  pFlags       [I] Flags. See notes.
1245  *  StartingSize [I] Starting size of the buffer. This value is added on to
1246  *                   the buffer size required for the clip format.
1247  *  phMfp        [I] Metafile pict to size.
1248  *
1249  * RETURNS
1250  *  The buffer size required to marshal a metafile pict plus the starting size.
1251  *
1252  * NOTES
1253  *  Even though the function is documented to take a pointer to a ULONG in
1254  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1255  *  the first parameter is a ULONG.
1256  *  This function is only intended to be called by the RPC runtime.
1257  */
1258 ULONG __RPC_USER HMETAFILEPICT_UserSize(ULONG *pFlags, ULONG StartingSize, HMETAFILEPICT *phMfp)
1259 {
1260     ULONG size = StartingSize;
1261
1262     TRACE("(%s, %d, &%p)\n", debugstr_user_flags(pFlags), StartingSize, *phMfp);
1263
1264     size += sizeof(ULONG);
1265     size += sizeof(HMETAFILEPICT);
1266
1267     if ((LOWORD(*pFlags) != MSHCTX_INPROC) && *phMfp)
1268     {
1269         METAFILEPICT *mfpict = GlobalLock(*phMfp);
1270
1271         /* FIXME: raise an exception if mfpict is NULL? */
1272         size += FIELD_OFFSET(remoteMETAFILEPICT, hMF);
1273         size += sizeof(ULONG);
1274
1275         size = HMETAFILE_UserSize(pFlags, size, &mfpict->hMF);
1276
1277         GlobalUnlock(*phMfp);
1278     }
1279
1280     return size;
1281 }
1282
1283 /******************************************************************************
1284  *           HMETAFILEPICT_UserMarshal [OLE32.@]
1285  *
1286  * Marshals a metafile pict into a buffer.
1287  *
1288  * PARAMS
1289  *  pFlags  [I] Flags. See notes.
1290  *  pBuffer [I] Buffer to marshal the clip format into.
1291  *  phMfp   [I] Metafile pict to marshal.
1292  *
1293  * RETURNS
1294  *  The end of the marshaled data in the buffer.
1295  *
1296  * NOTES
1297  *  Even though the function is documented to take a pointer to a ULONG in
1298  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1299  *  the first parameter is a ULONG.
1300  *  This function is only intended to be called by the RPC runtime.
1301  */
1302 unsigned char * __RPC_USER HMETAFILEPICT_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILEPICT *phMfp)
1303 {
1304     TRACE("(%s, %p, &%p)\n", debugstr_user_flags(pFlags), pBuffer, *phMfp);
1305
1306     if (LOWORD(*pFlags) == MSHCTX_INPROC)
1307         *(ULONG *)pBuffer = WDT_INPROC_CALL;
1308     else
1309         *(ULONG *)pBuffer = WDT_REMOTE_CALL;
1310     pBuffer += sizeof(ULONG);
1311
1312     *(HMETAFILEPICT *)pBuffer = *phMfp;
1313     pBuffer += sizeof(HMETAFILEPICT);
1314
1315     if ((LOWORD(*pFlags) != MSHCTX_INPROC) && *phMfp)
1316     {
1317         METAFILEPICT *mfpict = GlobalLock(*phMfp);
1318         remoteMETAFILEPICT * remmfpict = (remoteMETAFILEPICT *)pBuffer;
1319
1320         /* FIXME: raise an exception if mfpict is NULL? */
1321         remmfpict->mm = mfpict->mm;
1322         remmfpict->xExt = mfpict->xExt;
1323         remmfpict->yExt = mfpict->yExt;
1324         pBuffer += FIELD_OFFSET(remoteMETAFILEPICT, hMF);
1325         *(ULONG *)pBuffer = USER_MARSHAL_PTR_PREFIX;
1326         pBuffer += sizeof(ULONG);
1327
1328         pBuffer = HMETAFILE_UserMarshal(pFlags, pBuffer, &mfpict->hMF);
1329
1330         GlobalUnlock(*phMfp);
1331     }
1332
1333     return pBuffer;
1334 }
1335
1336 /******************************************************************************
1337  *           HMETAFILEPICT_UserUnmarshal [OLE32.@]
1338  *
1339  * Unmarshals an metafile pict from a buffer.
1340  *
1341  * PARAMS
1342  *  pFlags   [I] Flags. See notes.
1343  *  pBuffer  [I] Buffer to marshal the clip format from.
1344  *  phMfp    [O] Address that receive the unmarshaled metafile pict.
1345  *
1346  * RETURNS
1347  *  The end of the marshaled data in the buffer.
1348  *
1349  * NOTES
1350  *  Even though the function is documented to take a pointer to an ULONG in
1351  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1352  *  the first parameter is an ULONG.
1353  *  This function is only intended to be called by the RPC runtime.
1354  */
1355 unsigned char * __RPC_USER HMETAFILEPICT_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILEPICT *phMfp)
1356 {
1357     ULONG fContext;
1358
1359     TRACE("(%s, %p, %p)\n", debugstr_user_flags(pFlags), pBuffer, phMfp);
1360
1361     fContext = *(ULONG *)pBuffer;
1362     pBuffer += sizeof(ULONG);
1363
1364     if ((fContext == WDT_INPROC_CALL) || !*(HMETAFILEPICT *)pBuffer)
1365     {
1366         *phMfp = *(HMETAFILEPICT *)pBuffer;
1367         pBuffer += sizeof(HMETAFILEPICT);
1368     }
1369     else
1370     {
1371         METAFILEPICT *mfpict;
1372         const remoteMETAFILEPICT *remmfpict;
1373         ULONG user_marshal_prefix;
1374
1375         pBuffer += sizeof(HMETAFILEPICT);
1376         remmfpict = (const remoteMETAFILEPICT *)pBuffer;
1377
1378         *phMfp = GlobalAlloc(GMEM_MOVEABLE, sizeof(METAFILEPICT));
1379         if (!*phMfp)
1380             RpcRaiseException(E_OUTOFMEMORY);
1381
1382         mfpict = GlobalLock(*phMfp);
1383         mfpict->mm = remmfpict->mm;
1384         mfpict->xExt = remmfpict->xExt;
1385         mfpict->yExt = remmfpict->yExt;
1386         pBuffer += FIELD_OFFSET(remoteMETAFILEPICT, hMF);
1387         user_marshal_prefix = *(ULONG *)pBuffer;
1388         pBuffer += sizeof(ULONG);
1389
1390         if (user_marshal_prefix != USER_MARSHAL_PTR_PREFIX)
1391             RpcRaiseException(RPC_X_INVALID_TAG);
1392
1393         pBuffer = HMETAFILE_UserUnmarshal(pFlags, pBuffer, &mfpict->hMF);
1394
1395         GlobalUnlock(*phMfp);
1396     }
1397
1398     return pBuffer;
1399 }
1400
1401 /******************************************************************************
1402  *           HMETAFILEPICT_UserFree [OLE32.@]
1403  *
1404  * Frees an unmarshaled metafile pict.
1405  *
1406  * PARAMS
1407  *  pFlags   [I] Flags. See notes.
1408  *  phMfp    [I] Metafile pict to free.
1409  *
1410  * RETURNS
1411  *  The end of the marshaled data in the buffer.
1412  *
1413  * NOTES
1414  *  Even though the function is documented to take a pointer to a ULONG in
1415  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
1416  *  which the first parameter is a ULONG.
1417  *  This function is only intended to be called by the RPC runtime.
1418  */
1419 void __RPC_USER HMETAFILEPICT_UserFree(ULONG *pFlags, HMETAFILEPICT *phMfp)
1420 {
1421     TRACE("(%s, &%p)\n", debugstr_user_flags(pFlags), *phMfp);
1422
1423     if ((LOWORD(*pFlags) != MSHCTX_INPROC) && *phMfp)
1424     {
1425         METAFILEPICT *mfpict;
1426
1427         mfpict = GlobalLock(*phMfp);
1428         /* FIXME: raise an exception if mfpict is NULL? */
1429         HMETAFILE_UserFree(pFlags, &mfpict->hMF);
1430         GlobalUnlock(*phMfp);
1431
1432         GlobalFree(*phMfp);
1433     }
1434 }
1435
1436 /******************************************************************************
1437  *           WdtpInterfacePointer_UserSize [OLE32.@]
1438  *
1439  * Calculates the buffer size required to marshal an interface pointer.
1440  *
1441  * PARAMS
1442  *  pFlags       [I] Flags. See notes.
1443  *  RealFlags    [I] The MSHCTX to use when marshaling the interface.
1444  *  punk         [I] Interface pointer to size.
1445  *  StartingSize [I] Starting size of the buffer. This value is added on to
1446  *                   the buffer size required for the clip format.
1447  *  riid         [I] ID of interface to size.
1448  *
1449  * RETURNS
1450  *  The buffer size required to marshal an interface pointer plus the starting size.
1451  *
1452  * NOTES
1453  *  Even though the function is documented to take a pointer to a ULONG in
1454  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1455  *  the first parameter is a ULONG.
1456  */
1457 ULONG __RPC_USER WdtpInterfacePointer_UserSize(ULONG *pFlags, ULONG RealFlags, IUnknown *punk, ULONG StartingSize, REFIID riid)
1458 {
1459     FIXME("(%s, 0%x, %p, %d, %s): stub\n", debugstr_user_flags(pFlags), RealFlags, punk, StartingSize, debugstr_guid(riid));
1460     return 0;
1461 }
1462
1463 /******************************************************************************
1464  *           WdtpInterfacePointer_UserMarshal [OLE32.@]
1465  *
1466  * Marshals an interface pointer into a buffer.
1467  *
1468  * PARAMS
1469  *  pFlags    [I] Flags. See notes.
1470  *  RealFlags [I] The MSHCTX to use when marshaling the interface.
1471  *  pBuffer   [I] Buffer to marshal the clip format into.
1472  *  punk      [I] Interface pointer to marshal.
1473  *  riid      [I] ID of interface to marshal.
1474  *
1475  * RETURNS
1476  *  The end of the marshaled data in the buffer.
1477  *
1478  * NOTES
1479  *  Even though the function is documented to take a pointer to a ULONG in
1480  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1481  *  the first parameter is a ULONG.
1482  */
1483 unsigned char * WINAPI WdtpInterfacePointer_UserMarshal(ULONG *pFlags, ULONG RealFlags, unsigned char *pBuffer, IUnknown *punk, REFIID riid)
1484 {
1485     FIXME("(%s, 0x%x, %p, &%p, %s): stub\n", debugstr_user_flags(pFlags), RealFlags, pBuffer, punk, debugstr_guid(riid));
1486     return NULL;
1487 }
1488
1489 /******************************************************************************
1490  *           WdtpInterfacePointer_UserUnmarshal [OLE32.@]
1491  *
1492  * Unmarshals an interface pointer from a buffer.
1493  *
1494  * PARAMS
1495  *  pFlags   [I] Flags. See notes.
1496  *  pBuffer  [I] Buffer to marshal the clip format from.
1497  *  ppunk    [I/O] Address that receives the unmarshaled interface pointer.
1498  *  riid     [I] ID of interface to unmarshal.
1499  *
1500  * RETURNS
1501  *  The end of the marshaled data in the buffer.
1502  *
1503  * NOTES
1504  *  Even though the function is documented to take a pointer to an ULONG in
1505  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1506  *  the first parameter is an ULONG.
1507  */
1508 unsigned char * WINAPI WdtpInterfacePointer_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, IUnknown **ppunk, REFIID riid)
1509 {
1510     FIXME("(%s, %p, %p, %s): stub\n", debugstr_user_flags(pFlags), pBuffer, ppunk, debugstr_guid(riid));
1511     return NULL;
1512 }
1513
1514 /******************************************************************************
1515  *           WdtpInterfacePointer_UserFree [OLE32.@]
1516  *
1517  * Frees an unmarshaled interface pointer.
1518  *
1519  * PARAMS
1520  *  punk    [I] Interface pointer to free.
1521  *
1522  * RETURNS
1523  *  Nothing.
1524  */
1525 void WINAPI WdtpInterfacePointer_UserFree(IUnknown *punk)
1526 {
1527     FIXME("(%p): stub\n", punk);
1528 }
1529
1530 /******************************************************************************
1531 *           STGMEDIUM_UserSize [OLE32.@]
1532 *
1533 * Calculates the buffer size required to marshal an STGMEDIUM.
1534 *
1535 * PARAMS
1536 *  pFlags       [I] Flags. See notes.
1537 *  StartingSize [I] Starting size of the buffer. This value is added on to
1538 *                   the buffer size required for the clip format.
1539 *  pStgMedium   [I] STGMEDIUM to size.
1540 *
1541 * RETURNS
1542 *  The buffer size required to marshal an STGMEDIUM plus the starting size.
1543 *
1544 * NOTES
1545 *  Even though the function is documented to take a pointer to a ULONG in
1546 *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1547 *  the first parameter is a ULONG.
1548 *  This function is only intended to be called by the RPC runtime.
1549 */
1550 ULONG __RPC_USER STGMEDIUM_UserSize(ULONG *pFlags, ULONG StartingSize, STGMEDIUM *pStgMedium)
1551 {
1552     ULONG size = StartingSize;
1553
1554     TRACE("(%s, %d, %p\n", debugstr_user_flags(pFlags), StartingSize, pStgMedium);
1555
1556     ALIGN_LENGTH(size, 3);
1557
1558     size += 2 * sizeof(DWORD);
1559     if (pStgMedium->tymed != TYMED_NULL)
1560         size += sizeof(DWORD);
1561
1562     switch (pStgMedium->tymed)
1563     {
1564     case TYMED_NULL:
1565         TRACE("TYMED_NULL\n");
1566         break;
1567     case TYMED_HGLOBAL:
1568         TRACE("TYMED_HGLOBAL\n");
1569         if (pStgMedium->u.hGlobal)
1570             size = HGLOBAL_UserSize(pFlags, size, &pStgMedium->u.hGlobal);
1571         break;
1572     case TYMED_FILE:
1573         TRACE("TYMED_FILE\n");
1574         if (pStgMedium->u.lpszFileName)
1575         {
1576             TRACE("file name is %s\n", debugstr_w(pStgMedium->u.lpszFileName));
1577             size += 3 * sizeof(DWORD) +
1578                 (strlenW(pStgMedium->u.lpszFileName) + 1) * sizeof(WCHAR);
1579         }
1580         break;
1581     case TYMED_ISTREAM:
1582         TRACE("TYMED_ISTREAM\n");
1583         if (pStgMedium->u.pstm)
1584         {
1585             FIXME("not implemented for IStream %p\n", pStgMedium->u.pstm);
1586         }
1587         break;
1588     case TYMED_ISTORAGE:
1589         TRACE("TYMED_ISTORAGE\n");
1590         if (pStgMedium->u.pstg)
1591         {
1592             FIXME("not implemented for IStorage %p\n", pStgMedium->u.pstg);
1593         }
1594         break;
1595     case TYMED_GDI:
1596         TRACE("TYMED_GDI\n");
1597         if (pStgMedium->u.hBitmap)
1598         {
1599             FIXME("not implemented for GDI object %p\n", pStgMedium->u.hBitmap);
1600         }
1601         break;
1602     case TYMED_MFPICT:
1603         TRACE("TYMED_MFPICT\n");
1604         if (pStgMedium->u.hMetaFilePict)
1605             size = HMETAFILEPICT_UserSize(pFlags, size, &pStgMedium->u.hMetaFilePict);
1606         break;
1607     case TYMED_ENHMF:
1608         TRACE("TYMED_ENHMF\n");
1609         if (pStgMedium->u.hEnhMetaFile)
1610             size = HENHMETAFILE_UserSize(pFlags, size, &pStgMedium->u.hEnhMetaFile);
1611         break;
1612     default:
1613         RaiseException(DV_E_TYMED, 0, 0, NULL);
1614     }
1615
1616     if (pStgMedium->pUnkForRelease)
1617         FIXME("buffer size pUnkForRelease\n");
1618
1619     return size;
1620 }
1621
1622 /******************************************************************************
1623  *           STGMEDIUM_UserMarshal [OLE32.@]
1624  *
1625  * Marshals a STGMEDIUM into a buffer.
1626  *
1627  * PARAMS
1628  *  pFlags  [I] Flags. See notes.
1629  *  pBuffer [I] Buffer to marshal the clip format into.
1630  *  pCF     [I] STGMEDIUM to marshal.
1631  *
1632  * RETURNS
1633  *  The end of the marshaled data in the buffer.
1634  *
1635  * NOTES
1636  *  Even though the function is documented to take a pointer to a ULONG in
1637  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1638  *  the first parameter is a ULONG.
1639  *  This function is only intended to be called by the RPC runtime.
1640  */
1641 unsigned char * __RPC_USER STGMEDIUM_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
1642 {
1643     TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, pStgMedium);
1644
1645     ALIGN_POINTER(pBuffer, 3);
1646
1647     *(DWORD *)pBuffer = pStgMedium->tymed;
1648     pBuffer += sizeof(DWORD);
1649     if (pStgMedium->tymed != TYMED_NULL)
1650     {
1651         *(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->u.pstg;
1652         pBuffer += sizeof(DWORD);
1653     }
1654     *(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->pUnkForRelease;
1655     pBuffer += sizeof(DWORD);
1656
1657     switch (pStgMedium->tymed)
1658     {
1659     case TYMED_NULL:
1660         TRACE("TYMED_NULL\n");
1661         break;
1662     case TYMED_HGLOBAL:
1663         TRACE("TYMED_HGLOBAL\n");
1664         if (pStgMedium->u.hGlobal)
1665             pBuffer = HGLOBAL_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hGlobal);
1666         break;
1667     case TYMED_FILE:
1668         TRACE("TYMED_FILE\n");
1669         if (pStgMedium->u.lpszFileName)
1670         {
1671             DWORD len;
1672             len = strlenW(pStgMedium->u.lpszFileName);
1673             /* conformance */
1674             *(DWORD *)pBuffer = len + 1;
1675             pBuffer += sizeof(DWORD);
1676             /* offset */
1677             *(DWORD *)pBuffer = 0;
1678             pBuffer += sizeof(DWORD);
1679             /* variance */
1680             *(DWORD *)pBuffer = len + 1;
1681             pBuffer += sizeof(DWORD);
1682
1683             TRACE("file name is %s\n", debugstr_w(pStgMedium->u.lpszFileName));
1684             memcpy(pBuffer, pStgMedium->u.lpszFileName, (len + 1) * sizeof(WCHAR));
1685         }
1686         break;
1687     case TYMED_ISTREAM:
1688         TRACE("TYMED_ISTREAM\n");
1689         if (pStgMedium->u.pstm)
1690         {
1691             FIXME("not implemented for IStream %p\n", pStgMedium->u.pstm);
1692         }
1693         break;
1694     case TYMED_ISTORAGE:
1695         TRACE("TYMED_ISTORAGE\n");
1696         if (pStgMedium->u.pstg)
1697         {
1698             FIXME("not implemented for IStorage %p\n", pStgMedium->u.pstg);
1699         }
1700         break;
1701     case TYMED_GDI:
1702         TRACE("TYMED_GDI\n");
1703         if (pStgMedium->u.hBitmap)
1704         {
1705             FIXME("not implemented for GDI object %p\n", pStgMedium->u.hBitmap);
1706         }
1707         break;
1708     case TYMED_MFPICT:
1709         TRACE("TYMED_MFPICT\n");
1710         if (pStgMedium->u.hMetaFilePict)
1711             pBuffer = HMETAFILEPICT_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hMetaFilePict);
1712         break;
1713     case TYMED_ENHMF:
1714         TRACE("TYMED_ENHMF\n");
1715         if (pStgMedium->u.hEnhMetaFile)
1716             pBuffer = HENHMETAFILE_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hEnhMetaFile);
1717         break;
1718     default:
1719         RaiseException(DV_E_TYMED, 0, 0, NULL);
1720     }
1721
1722     if (pStgMedium->pUnkForRelease)
1723         FIXME("marshal pUnkForRelease\n");
1724
1725     return pBuffer;
1726 }
1727
1728 /******************************************************************************
1729  *           STGMEDIUM_UserUnmarshal [OLE32.@]
1730  *
1731  * Unmarshals a STGMEDIUM from a buffer.
1732  *
1733  * PARAMS
1734  *  pFlags     [I] Flags. See notes.
1735  *  pBuffer    [I] Buffer to marshal the clip format from.
1736  *  pStgMedium [O] Address that receive the unmarshaled STGMEDIUM.
1737  *
1738  * RETURNS
1739  *  The end of the marshaled data in the buffer.
1740  *
1741  * NOTES
1742  *  Even though the function is documented to take a pointer to an ULONG in
1743  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1744  *  the first parameter is an ULONG.
1745  *  This function is only intended to be called by the RPC runtime.
1746  */
1747 unsigned char * __RPC_USER STGMEDIUM_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
1748 {
1749     DWORD content = 0;
1750     DWORD releaseunk;
1751
1752     ALIGN_POINTER(pBuffer, 3);
1753
1754     TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, pStgMedium);
1755
1756     pStgMedium->tymed = *(DWORD *)pBuffer;
1757     pBuffer += sizeof(DWORD);
1758     if (pStgMedium->tymed != TYMED_NULL)
1759     {
1760         content = *(DWORD *)pBuffer;
1761         pBuffer += sizeof(DWORD);
1762     }
1763     releaseunk = *(DWORD *)pBuffer;
1764     pBuffer += sizeof(DWORD);
1765
1766     switch (pStgMedium->tymed)
1767     {
1768     case TYMED_NULL:
1769         TRACE("TYMED_NULL\n");
1770         break;
1771     case TYMED_HGLOBAL:
1772         TRACE("TYMED_HGLOBAL\n");
1773         if (content)
1774             pBuffer = HGLOBAL_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hGlobal);
1775         break;
1776     case TYMED_FILE:
1777         TRACE("TYMED_FILE\n");
1778         if (content)
1779         {
1780             DWORD conformance;
1781             DWORD variance;
1782             conformance = *(DWORD *)pBuffer;
1783             pBuffer += sizeof(DWORD);
1784             if (*(DWORD *)pBuffer != 0)
1785             {
1786                 ERR("invalid offset %d\n", *(DWORD *)pBuffer);
1787                 RpcRaiseException(RPC_S_INVALID_BOUND);
1788                 return NULL;
1789             }
1790             pBuffer += sizeof(DWORD);
1791             variance = *(DWORD *)pBuffer;
1792             pBuffer += sizeof(DWORD);
1793             if (conformance != variance)
1794             {
1795                 ERR("conformance (%d) and variance (%d) should be equal\n",
1796                     conformance, variance);
1797                 RpcRaiseException(RPC_S_INVALID_BOUND);
1798                 return NULL;
1799             }
1800             if (conformance > 0x7fffffff)
1801             {
1802                 ERR("conformance 0x%x too large\n", conformance);
1803                 RpcRaiseException(RPC_S_INVALID_BOUND);
1804                 return NULL;
1805             }
1806             pStgMedium->u.lpszFileName = CoTaskMemAlloc(conformance * sizeof(WCHAR));
1807             if (!pStgMedium->u.lpszFileName) RpcRaiseException(ERROR_OUTOFMEMORY);
1808             TRACE("unmarshalled file name is %s\n", debugstr_wn((const WCHAR *)pBuffer, variance));
1809             memcpy(pStgMedium->u.lpszFileName, pBuffer, variance * sizeof(WCHAR));
1810             pBuffer += variance * sizeof(WCHAR);
1811         }
1812         else
1813             pStgMedium->u.lpszFileName = NULL;
1814         break;
1815     case TYMED_ISTREAM:
1816         TRACE("TYMED_ISTREAM\n");
1817         if (content)
1818         {
1819             FIXME("not implemented for IStream\n");
1820         }
1821         else
1822             pStgMedium->u.pstm = NULL;
1823         break;
1824     case TYMED_ISTORAGE:
1825         TRACE("TYMED_ISTORAGE\n");
1826         if (content)
1827         {
1828             FIXME("not implemented for IStorage\n");
1829         }
1830         else
1831             pStgMedium->u.pstg = NULL;
1832         break;
1833     case TYMED_GDI:
1834         TRACE("TYMED_GDI\n");
1835         if (content)
1836         {
1837             FIXME("not implemented for GDI object\n");
1838         }
1839         else
1840             pStgMedium->u.hBitmap = NULL;
1841         break;
1842     case TYMED_MFPICT:
1843         TRACE("TYMED_MFPICT\n");
1844         if (content)
1845             pBuffer = HMETAFILEPICT_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hMetaFilePict);
1846         else
1847             pStgMedium->u.hMetaFilePict = NULL;
1848         break;
1849     case TYMED_ENHMF:
1850         TRACE("TYMED_ENHMF\n");
1851         if (content)
1852             pBuffer = HENHMETAFILE_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hEnhMetaFile);
1853         else
1854             pStgMedium->u.hEnhMetaFile = NULL;
1855         break;
1856     default:
1857         RaiseException(DV_E_TYMED, 0, 0, NULL);
1858     }
1859
1860     pStgMedium->pUnkForRelease = NULL;
1861     if (releaseunk)
1862         FIXME("unmarshal pUnkForRelease\n");
1863
1864     return pBuffer;
1865 }
1866
1867 /******************************************************************************
1868  *           STGMEDIUM_UserFree [OLE32.@]
1869  *
1870  * Frees an unmarshaled STGMEDIUM.
1871  *
1872  * PARAMS
1873  *  pFlags     [I] Flags. See notes.
1874  *  pStgmedium [I] STGMEDIUM to free.
1875  *
1876  * RETURNS
1877  *  The end of the marshaled data in the buffer.
1878  *
1879  * NOTES
1880  *  Even though the function is documented to take a pointer to a ULONG in
1881  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
1882  *  which the first parameter is a ULONG.
1883  *  This function is only intended to be called by the RPC runtime.
1884  */
1885 void __RPC_USER STGMEDIUM_UserFree(ULONG *pFlags, STGMEDIUM *pStgMedium)
1886 {
1887     TRACE("(%s, %p\n", debugstr_user_flags(pFlags), pStgMedium);
1888
1889     ReleaseStgMedium(pStgMedium);
1890 }
1891
1892 ULONG __RPC_USER ASYNC_STGMEDIUM_UserSize(ULONG *pFlags, ULONG StartingSize, ASYNC_STGMEDIUM *pStgMedium)
1893 {
1894     TRACE("\n");
1895     return STGMEDIUM_UserSize(pFlags, StartingSize, pStgMedium);
1896 }
1897
1898 unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserMarshal(  ULONG *pFlags, unsigned char *pBuffer, ASYNC_STGMEDIUM *pStgMedium)
1899 {
1900     TRACE("\n");
1901     return STGMEDIUM_UserMarshal(pFlags, pBuffer, pStgMedium);
1902 }
1903
1904 unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, ASYNC_STGMEDIUM *pStgMedium)
1905 {
1906     TRACE("\n");
1907     return STGMEDIUM_UserUnmarshal(pFlags, pBuffer, pStgMedium);
1908 }
1909
1910 void __RPC_USER ASYNC_STGMEDIUM_UserFree(ULONG *pFlags, ASYNC_STGMEDIUM *pStgMedium)
1911 {
1912     TRACE("\n");
1913     STGMEDIUM_UserFree(pFlags, pStgMedium);
1914 }
1915
1916 ULONG __RPC_USER FLAG_STGMEDIUM_UserSize(ULONG *pFlags, ULONG StartingSize, FLAG_STGMEDIUM *pStgMedium)
1917 {
1918     FIXME(":stub\n");
1919     return StartingSize;
1920 }
1921
1922 unsigned char * __RPC_USER FLAG_STGMEDIUM_UserMarshal(  ULONG *pFlags, unsigned char *pBuffer, FLAG_STGMEDIUM *pStgMedium)
1923 {
1924     FIXME(":stub\n");
1925     return pBuffer;
1926 }
1927
1928 unsigned char * __RPC_USER FLAG_STGMEDIUM_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, FLAG_STGMEDIUM *pStgMedium)
1929 {
1930     FIXME(":stub\n");
1931     return pBuffer;
1932 }
1933
1934 void __RPC_USER FLAG_STGMEDIUM_UserFree(ULONG *pFlags, FLAG_STGMEDIUM *pStgMedium)
1935 {
1936     FIXME(":stub\n");
1937 }
1938
1939 ULONG __RPC_USER SNB_UserSize(ULONG *pFlags, ULONG StartingSize, SNB *pSnb)
1940 {
1941     FIXME(":stub\n");
1942     return StartingSize;
1943 }
1944
1945 unsigned char * __RPC_USER SNB_UserMarshal(  ULONG *pFlags, unsigned char *pBuffer, SNB *pSnb)
1946 {
1947     FIXME(":stub\n");
1948     return pBuffer;
1949 }
1950
1951 unsigned char * __RPC_USER SNB_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, SNB *pSnb)
1952 {
1953     FIXME(":stub\n");
1954     return pBuffer;
1955 }
1956
1957 void __RPC_USER SNB_UserFree(ULONG *pFlags, SNB *pSnb)
1958 {
1959     FIXME(":stub\n");
1960 }
1961
1962 /* call_as/local stubs for unknwn.idl */
1963
1964 HRESULT CALLBACK IClassFactory_CreateInstance_Proxy(
1965     IClassFactory* This,
1966     IUnknown *pUnkOuter,
1967     REFIID riid,
1968     void **ppvObject)
1969 {
1970     TRACE("(%p, %s, %p)\n", pUnkOuter, debugstr_guid(riid), ppvObject);
1971     *ppvObject = NULL;
1972     if (pUnkOuter)
1973     {
1974         ERR("aggregation is not allowed on remote objects\n");
1975         return CLASS_E_NOAGGREGATION;
1976     }
1977     return IClassFactory_RemoteCreateInstance_Proxy(This, riid,
1978                                                     (IUnknown **) ppvObject);
1979 }
1980
1981 HRESULT __RPC_STUB IClassFactory_CreateInstance_Stub(
1982     IClassFactory* This,
1983     REFIID riid,
1984     IUnknown **ppvObject)
1985 {
1986     TRACE("(%s, %p)\n", debugstr_guid(riid), ppvObject);
1987     return IClassFactory_CreateInstance(This, NULL, riid, (void **) ppvObject);
1988 }
1989
1990 HRESULT CALLBACK IClassFactory_LockServer_Proxy(
1991     IClassFactory* This,
1992     BOOL fLock)
1993 {
1994     FIXME(":stub\n");
1995     return E_NOTIMPL;
1996 }
1997
1998 HRESULT __RPC_STUB IClassFactory_LockServer_Stub(
1999     IClassFactory* This,
2000     BOOL fLock)
2001 {
2002     FIXME(":stub\n");
2003     return E_NOTIMPL;
2004 }
2005
2006 /* call_as/local stubs for objidl.idl */
2007
2008 HRESULT CALLBACK IEnumUnknown_Next_Proxy(
2009     IEnumUnknown* This,
2010     ULONG celt,
2011     IUnknown **rgelt,
2012     ULONG *pceltFetched)
2013 {
2014     ULONG fetched;
2015     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2016     if (!pceltFetched) pceltFetched = &fetched;
2017     return IEnumUnknown_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
2018 }
2019
2020 HRESULT __RPC_STUB IEnumUnknown_Next_Stub(
2021     IEnumUnknown* This,
2022     ULONG celt,
2023     IUnknown **rgelt,
2024     ULONG *pceltFetched)
2025 {
2026     HRESULT hr;
2027     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2028     *pceltFetched = 0;
2029     hr = IEnumUnknown_Next(This, celt, rgelt, pceltFetched);
2030     if (hr == S_OK) *pceltFetched = celt;
2031     return hr;
2032 }
2033
2034 HRESULT CALLBACK IBindCtx_SetBindOptions_Proxy(
2035     IBindCtx* This,
2036     BIND_OPTS *pbindopts)
2037 {
2038     FIXME(":stub\n");
2039     return E_NOTIMPL;
2040 }
2041
2042 HRESULT __RPC_STUB IBindCtx_SetBindOptions_Stub(
2043     IBindCtx* This,
2044     BIND_OPTS2 *pbindopts)
2045 {
2046     FIXME(":stub\n");
2047     return E_NOTIMPL;
2048 }
2049
2050 HRESULT CALLBACK IBindCtx_GetBindOptions_Proxy(
2051     IBindCtx* This,
2052     BIND_OPTS *pbindopts)
2053 {
2054     FIXME(":stub\n");
2055     return E_NOTIMPL;
2056 }
2057
2058 HRESULT __RPC_STUB IBindCtx_GetBindOptions_Stub(
2059     IBindCtx* This,
2060     BIND_OPTS2 *pbindopts)
2061 {
2062     FIXME(":stub\n");
2063     return E_NOTIMPL;
2064 }
2065
2066 HRESULT CALLBACK IEnumMoniker_Next_Proxy(
2067     IEnumMoniker* This,
2068     ULONG celt,
2069     IMoniker **rgelt,
2070     ULONG *pceltFetched)
2071 {
2072     ULONG fetched;
2073     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2074     if (!pceltFetched) pceltFetched = &fetched;
2075     return IEnumMoniker_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
2076 }
2077
2078 HRESULT __RPC_STUB IEnumMoniker_Next_Stub(
2079     IEnumMoniker* This,
2080     ULONG celt,
2081     IMoniker **rgelt,
2082     ULONG *pceltFetched)
2083 {
2084     HRESULT hr;
2085     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2086     *pceltFetched = 0;
2087     hr = IEnumMoniker_Next(This, celt, rgelt, pceltFetched);
2088     if (hr == S_OK) *pceltFetched = celt;
2089     return hr;
2090 }
2091
2092 BOOL CALLBACK IRunnableObject_IsRunning_Proxy(
2093     IRunnableObject* This)
2094 {
2095     BOOL rv;
2096     FIXME(":stub\n");
2097     memset(&rv, 0, sizeof rv);
2098     return rv;
2099 }
2100
2101 HRESULT __RPC_STUB IRunnableObject_IsRunning_Stub(
2102     IRunnableObject* This)
2103 {
2104     FIXME(":stub\n");
2105     return E_NOTIMPL;
2106 }
2107
2108 HRESULT CALLBACK IMoniker_BindToObject_Proxy(
2109     IMoniker* This,
2110     IBindCtx *pbc,
2111     IMoniker *pmkToLeft,
2112     REFIID riidResult,
2113     void **ppvResult)
2114 {
2115     FIXME(":stub\n");
2116     return E_NOTIMPL;
2117 }
2118
2119 HRESULT __RPC_STUB IMoniker_BindToObject_Stub(
2120     IMoniker* This,
2121     IBindCtx *pbc,
2122     IMoniker *pmkToLeft,
2123     REFIID riidResult,
2124     IUnknown **ppvResult)
2125 {
2126     FIXME(":stub\n");
2127     return E_NOTIMPL;
2128 }
2129
2130 HRESULT CALLBACK IMoniker_BindToStorage_Proxy(
2131     IMoniker* This,
2132     IBindCtx *pbc,
2133     IMoniker *pmkToLeft,
2134     REFIID riid,
2135     void **ppvObj)
2136 {
2137     FIXME(":stub\n");
2138     return E_NOTIMPL;
2139 }
2140
2141 HRESULT __RPC_STUB IMoniker_BindToStorage_Stub(
2142     IMoniker* This,
2143     IBindCtx *pbc,
2144     IMoniker *pmkToLeft,
2145     REFIID riid,
2146     IUnknown **ppvObj)
2147 {
2148     FIXME(":stub\n");
2149     return E_NOTIMPL;
2150 }
2151
2152 HRESULT CALLBACK IEnumString_Next_Proxy(
2153     IEnumString* This,
2154     ULONG celt,
2155     LPOLESTR *rgelt,
2156     ULONG *pceltFetched)
2157 {
2158     ULONG fetched;
2159     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2160     if (!pceltFetched) pceltFetched = &fetched;
2161     return IEnumString_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
2162 }
2163
2164 HRESULT __RPC_STUB IEnumString_Next_Stub(
2165     IEnumString* This,
2166     ULONG celt,
2167     LPOLESTR *rgelt,
2168     ULONG *pceltFetched)
2169 {
2170     HRESULT hr;
2171     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2172     *pceltFetched = 0;
2173     hr = IEnumString_Next(This, celt, rgelt, pceltFetched);
2174     if (hr == S_OK) *pceltFetched = celt;
2175     return hr;
2176 }
2177
2178 HRESULT CALLBACK ISequentialStream_Read_Proxy(
2179     ISequentialStream* This,
2180     void *pv,
2181     ULONG cb,
2182     ULONG *pcbRead)
2183 {
2184     FIXME(":stub\n");
2185     return E_NOTIMPL;
2186 }
2187
2188 HRESULT __RPC_STUB ISequentialStream_Read_Stub(
2189     ISequentialStream* This,
2190     byte *pv,
2191     ULONG cb,
2192     ULONG *pcbRead)
2193 {
2194     FIXME(":stub\n");
2195     return E_NOTIMPL;
2196 }
2197
2198 HRESULT CALLBACK ISequentialStream_Write_Proxy(
2199     ISequentialStream* This,
2200     const void *pv,
2201     ULONG cb,
2202     ULONG *pcbWritten)
2203 {
2204     FIXME(":stub\n");
2205     return E_NOTIMPL;
2206 }
2207
2208 HRESULT __RPC_STUB ISequentialStream_Write_Stub(
2209     ISequentialStream* This,
2210     const byte *pv,
2211     ULONG cb,
2212     ULONG *pcbWritten)
2213 {
2214     FIXME(":stub\n");
2215     return E_NOTIMPL;
2216 }
2217
2218 HRESULT CALLBACK IStream_Seek_Proxy(
2219     IStream* This,
2220     LARGE_INTEGER dlibMove,
2221     DWORD dwOrigin,
2222     ULARGE_INTEGER *plibNewPosition)
2223 {
2224     FIXME(":stub\n");
2225     return E_NOTIMPL;
2226 }
2227
2228 HRESULT __RPC_STUB IStream_Seek_Stub(
2229     IStream* This,
2230     LARGE_INTEGER dlibMove,
2231     DWORD dwOrigin,
2232     ULARGE_INTEGER *plibNewPosition)
2233 {
2234     FIXME(":stub\n");
2235     return E_NOTIMPL;
2236 }
2237
2238 HRESULT CALLBACK IStream_CopyTo_Proxy(
2239     IStream* This,
2240     IStream *pstm,
2241     ULARGE_INTEGER cb,
2242     ULARGE_INTEGER *pcbRead,
2243     ULARGE_INTEGER *pcbWritten)
2244 {
2245     FIXME(":stub\n");
2246     return E_NOTIMPL;
2247 }
2248
2249 HRESULT __RPC_STUB IStream_CopyTo_Stub(
2250     IStream* This,
2251     IStream *pstm,
2252     ULARGE_INTEGER cb,
2253     ULARGE_INTEGER *pcbRead,
2254     ULARGE_INTEGER *pcbWritten)
2255 {
2256     FIXME(":stub\n");
2257     return E_NOTIMPL;
2258 }
2259
2260 HRESULT CALLBACK IEnumSTATSTG_Next_Proxy(
2261     IEnumSTATSTG* This,
2262     ULONG celt,
2263     STATSTG *rgelt,
2264     ULONG *pceltFetched)
2265 {
2266     ULONG fetched;
2267     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2268     if (!pceltFetched) pceltFetched = &fetched;
2269     return IEnumSTATSTG_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
2270 }
2271
2272 HRESULT __RPC_STUB IEnumSTATSTG_Next_Stub(
2273     IEnumSTATSTG* This,
2274     ULONG celt,
2275     STATSTG *rgelt,
2276     ULONG *pceltFetched)
2277 {
2278     HRESULT hr;
2279     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2280     *pceltFetched = 0;
2281     hr = IEnumSTATSTG_Next(This, celt, rgelt, pceltFetched);
2282     if (hr == S_OK) *pceltFetched = celt;
2283     return hr;
2284 }
2285
2286 HRESULT CALLBACK IStorage_OpenStream_Proxy(
2287     IStorage* This,
2288     LPCOLESTR pwcsName,
2289     void *reserved1,
2290     DWORD grfMode,
2291     DWORD reserved2,
2292     IStream **ppstm)
2293 {
2294     FIXME(":stub\n");
2295     return E_NOTIMPL;
2296 }
2297
2298 HRESULT __RPC_STUB IStorage_OpenStream_Stub(
2299     IStorage* This,
2300     LPCOLESTR pwcsName,
2301     unsigned long cbReserved1,
2302     byte *reserved1,
2303     DWORD grfMode,
2304     DWORD reserved2,
2305     IStream **ppstm)
2306 {
2307     FIXME(":stub\n");
2308     return E_NOTIMPL;
2309 }
2310
2311 HRESULT CALLBACK IStorage_EnumElements_Proxy(
2312     IStorage* This,
2313     DWORD reserved1,
2314     void *reserved2,
2315     DWORD reserved3,
2316     IEnumSTATSTG **ppenum)
2317 {
2318     FIXME(":stub\n");
2319     return E_NOTIMPL;
2320 }
2321
2322 HRESULT __RPC_STUB IStorage_EnumElements_Stub(
2323     IStorage* This,
2324     DWORD reserved1,
2325     unsigned long cbReserved2,
2326     byte *reserved2,
2327     DWORD reserved3,
2328     IEnumSTATSTG **ppenum)
2329 {
2330     FIXME(":stub\n");
2331     return E_NOTIMPL;
2332 }
2333
2334 HRESULT CALLBACK ILockBytes_ReadAt_Proxy(
2335     ILockBytes* This,
2336     ULARGE_INTEGER ulOffset,
2337     void *pv,
2338     ULONG cb,
2339     ULONG *pcbRead)
2340 {
2341     FIXME(":stub\n");
2342     return E_NOTIMPL;
2343 }
2344
2345 HRESULT __RPC_STUB ILockBytes_ReadAt_Stub(
2346     ILockBytes* This,
2347     ULARGE_INTEGER ulOffset,
2348     byte *pv,
2349     ULONG cb,
2350     ULONG *pcbRead)
2351 {
2352     FIXME(":stub\n");
2353     return E_NOTIMPL;
2354 }
2355
2356 HRESULT CALLBACK ILockBytes_WriteAt_Proxy(
2357     ILockBytes* This,
2358     ULARGE_INTEGER ulOffset,
2359     const void *pv,
2360     ULONG cb,
2361     ULONG *pcbWritten)
2362 {
2363     FIXME(":stub\n");
2364     return E_NOTIMPL;
2365 }
2366
2367 HRESULT __RPC_STUB ILockBytes_WriteAt_Stub(
2368     ILockBytes* This,
2369     ULARGE_INTEGER ulOffset,
2370     const byte *pv,
2371     ULONG cb,
2372     ULONG *pcbWritten)
2373 {
2374     FIXME(":stub\n");
2375     return E_NOTIMPL;
2376 }
2377
2378 HRESULT CALLBACK IFillLockBytes_FillAppend_Proxy(
2379     IFillLockBytes* This,
2380     const void *pv,
2381     ULONG cb,
2382     ULONG *pcbWritten)
2383 {
2384     FIXME(":stub\n");
2385     return E_NOTIMPL;
2386 }
2387
2388 HRESULT __RPC_STUB IFillLockBytes_FillAppend_Stub(
2389     IFillLockBytes* This,
2390     const byte *pv,
2391     ULONG cb,
2392     ULONG *pcbWritten)
2393 {
2394     FIXME(":stub\n");
2395     return E_NOTIMPL;
2396 }
2397
2398 HRESULT CALLBACK IFillLockBytes_FillAt_Proxy(
2399     IFillLockBytes* This,
2400     ULARGE_INTEGER ulOffset,
2401     const void *pv,
2402     ULONG cb,
2403     ULONG *pcbWritten)
2404 {
2405     FIXME(":stub\n");
2406     return E_NOTIMPL;
2407 }
2408
2409 HRESULT __RPC_STUB IFillLockBytes_FillAt_Stub(
2410     IFillLockBytes* This,
2411     ULARGE_INTEGER ulOffset,
2412     const byte *pv,
2413     ULONG cb,
2414     ULONG *pcbWritten)
2415 {
2416     FIXME(":stub\n");
2417     return E_NOTIMPL;
2418 }
2419
2420 HRESULT CALLBACK IEnumFORMATETC_Next_Proxy(
2421     IEnumFORMATETC* This,
2422     ULONG celt,
2423     FORMATETC *rgelt,
2424     ULONG *pceltFetched)
2425 {
2426     ULONG fetched;
2427     if (!pceltFetched) pceltFetched = &fetched;
2428     return IEnumFORMATETC_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
2429 }
2430
2431 HRESULT __RPC_STUB IEnumFORMATETC_Next_Stub(
2432     IEnumFORMATETC* This,
2433     ULONG celt,
2434     FORMATETC *rgelt,
2435     ULONG *pceltFetched)
2436 {
2437     HRESULT hr;
2438     *pceltFetched = 0;
2439     hr = IEnumFORMATETC_Next(This, celt, rgelt, pceltFetched);
2440     if (hr == S_OK) *pceltFetched = celt;
2441     return hr;
2442 }
2443
2444 HRESULT CALLBACK IEnumSTATDATA_Next_Proxy(
2445     IEnumSTATDATA* This,
2446     ULONG celt,
2447     STATDATA *rgelt,
2448     ULONG *pceltFetched)
2449 {
2450     ULONG fetched;
2451     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2452     if (!pceltFetched) pceltFetched = &fetched;
2453     return IEnumSTATDATA_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
2454 }
2455
2456 HRESULT __RPC_STUB IEnumSTATDATA_Next_Stub(
2457     IEnumSTATDATA* This,
2458     ULONG celt,
2459     STATDATA *rgelt,
2460     ULONG *pceltFetched)
2461 {
2462     HRESULT hr;
2463     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2464     *pceltFetched = 0;
2465     hr = IEnumSTATDATA_Next(This, celt, rgelt, pceltFetched);
2466     if (hr == S_OK) *pceltFetched = celt;
2467     return hr;
2468 }
2469
2470 void CALLBACK IAdviseSink_OnDataChange_Proxy(
2471     IAdviseSink* This,
2472     FORMATETC *pFormatetc,
2473     STGMEDIUM *pStgmed)
2474 {
2475     FIXME(":stub\n");
2476 }
2477
2478 HRESULT __RPC_STUB IAdviseSink_OnDataChange_Stub(
2479     IAdviseSink* This,
2480     FORMATETC *pFormatetc,
2481     ASYNC_STGMEDIUM *pStgmed)
2482 {
2483     FIXME(":stub\n");
2484     return E_NOTIMPL;
2485 }
2486
2487 void CALLBACK IAdviseSink_OnViewChange_Proxy(
2488     IAdviseSink* This,
2489     DWORD dwAspect,
2490     LONG lindex)
2491 {
2492     FIXME(":stub\n");
2493 }
2494
2495 HRESULT __RPC_STUB IAdviseSink_OnViewChange_Stub(
2496     IAdviseSink* This,
2497     DWORD dwAspect,
2498     LONG lindex)
2499 {
2500     FIXME(":stub\n");
2501     return E_NOTIMPL;
2502 }
2503
2504 void CALLBACK IAdviseSink_OnRename_Proxy(
2505     IAdviseSink* This,
2506     IMoniker *pmk)
2507 {
2508     FIXME(":stub\n");
2509 }
2510
2511 HRESULT __RPC_STUB IAdviseSink_OnRename_Stub(
2512     IAdviseSink* This,
2513     IMoniker *pmk)
2514 {
2515     FIXME(":stub\n");
2516     return E_NOTIMPL;
2517 }
2518
2519 void CALLBACK IAdviseSink_OnSave_Proxy(
2520     IAdviseSink* This)
2521 {
2522     FIXME(":stub\n");
2523 }
2524
2525 HRESULT __RPC_STUB IAdviseSink_OnSave_Stub(
2526     IAdviseSink* This)
2527 {
2528     FIXME(":stub\n");
2529     return E_NOTIMPL;
2530 }
2531
2532 void CALLBACK IAdviseSink_OnClose_Proxy(
2533     IAdviseSink* This)
2534 {
2535     FIXME(":stub\n");
2536 }
2537
2538 HRESULT __RPC_STUB IAdviseSink_OnClose_Stub(
2539     IAdviseSink* This)
2540 {
2541     FIXME(":stub\n");
2542     return E_NOTIMPL;
2543 }
2544
2545 void CALLBACK IAdviseSink2_OnLinkSrcChange_Proxy(
2546     IAdviseSink2* This,
2547     IMoniker *pmk)
2548 {
2549     FIXME(":stub\n");
2550 }
2551
2552 HRESULT __RPC_STUB IAdviseSink2_OnLinkSrcChange_Stub(
2553     IAdviseSink2* This,
2554     IMoniker *pmk)
2555 {
2556     FIXME(":stub\n");
2557     return E_NOTIMPL;
2558 }
2559
2560 HRESULT CALLBACK IDataObject_GetData_Proxy(
2561     IDataObject* This,
2562     FORMATETC *pformatetcIn,
2563     STGMEDIUM *pmedium)
2564 {
2565     FIXME(":stub\n");
2566     return E_NOTIMPL;
2567 }
2568
2569 HRESULT __RPC_STUB IDataObject_GetData_Stub(
2570     IDataObject* This,
2571     FORMATETC *pformatetcIn,
2572     STGMEDIUM *pRemoteMedium)
2573 {
2574     FIXME(":stub\n");
2575     return E_NOTIMPL;
2576 }
2577
2578 HRESULT CALLBACK IDataObject_GetDataHere_Proxy(
2579     IDataObject* This,
2580     FORMATETC *pformatetc,
2581     STGMEDIUM *pmedium)
2582 {
2583     FIXME(":stub\n");
2584     return E_NOTIMPL;
2585 }
2586
2587 HRESULT __RPC_STUB IDataObject_GetDataHere_Stub(
2588     IDataObject* This,
2589     FORMATETC *pformatetc,
2590     STGMEDIUM *pRemoteMedium)
2591 {
2592     FIXME(":stub\n");
2593     return E_NOTIMPL;
2594 }
2595
2596 HRESULT CALLBACK IDataObject_SetData_Proxy(
2597     IDataObject* This,
2598     FORMATETC *pformatetc,
2599     STGMEDIUM *pmedium,
2600     BOOL fRelease)
2601 {
2602     FIXME(":stub\n");
2603     return E_NOTIMPL;
2604 }
2605
2606 HRESULT __RPC_STUB IDataObject_SetData_Stub(
2607     IDataObject* This,
2608     FORMATETC *pformatetc,
2609     FLAG_STGMEDIUM *pmedium,
2610     BOOL fRelease)
2611 {
2612     FIXME(":stub\n");
2613     return E_NOTIMPL;
2614 }
2615
2616 /* call_as/local stubs for oleidl.idl */
2617
2618 HRESULT CALLBACK IOleInPlaceActiveObject_TranslateAccelerator_Proxy(
2619     IOleInPlaceActiveObject* This,
2620     LPMSG lpmsg)
2621 {
2622     FIXME(":stub\n");
2623     return E_NOTIMPL;
2624 }
2625
2626 HRESULT __RPC_STUB IOleInPlaceActiveObject_TranslateAccelerator_Stub(
2627     IOleInPlaceActiveObject* This)
2628 {
2629     FIXME(":stub\n");
2630     return E_NOTIMPL;
2631 }
2632
2633 HRESULT CALLBACK IOleInPlaceActiveObject_ResizeBorder_Proxy(
2634     IOleInPlaceActiveObject* This,
2635     LPCRECT prcBorder,
2636     IOleInPlaceUIWindow *pUIWindow,
2637     BOOL fFrameWindow)
2638 {
2639     FIXME(":stub\n");
2640     return E_NOTIMPL;
2641 }
2642
2643 HRESULT __RPC_STUB IOleInPlaceActiveObject_ResizeBorder_Stub(
2644     IOleInPlaceActiveObject* This,
2645     LPCRECT prcBorder,
2646     REFIID riid,
2647     IOleInPlaceUIWindow *pUIWindow,
2648     BOOL fFrameWindow)
2649 {
2650     FIXME(":stub\n");
2651     return E_NOTIMPL;
2652 }
2653
2654 HRESULT CALLBACK IOleCache2_UpdateCache_Proxy(
2655     IOleCache2* This,
2656     LPDATAOBJECT pDataObject,
2657     DWORD grfUpdf,
2658     LPVOID pReserved)
2659 {
2660     FIXME(":stub\n");
2661     return E_NOTIMPL;
2662 }
2663
2664 HRESULT __RPC_STUB IOleCache2_UpdateCache_Stub(
2665     IOleCache2* This,
2666     LPDATAOBJECT pDataObject,
2667     DWORD grfUpdf,
2668     LONG_PTR pReserved)
2669 {
2670     FIXME(":stub\n");
2671     return E_NOTIMPL;
2672 }
2673
2674 HRESULT CALLBACK IEnumOLEVERB_Next_Proxy(
2675     IEnumOLEVERB* This,
2676     ULONG celt,
2677     LPOLEVERB rgelt,
2678     ULONG *pceltFetched)
2679 {
2680     ULONG fetched;
2681     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2682     if (!pceltFetched) pceltFetched = &fetched;
2683     return IEnumOLEVERB_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
2684 }
2685
2686 HRESULT __RPC_STUB IEnumOLEVERB_Next_Stub(
2687     IEnumOLEVERB* This,
2688     ULONG celt,
2689     LPOLEVERB rgelt,
2690     ULONG *pceltFetched)
2691 {
2692     HRESULT hr;
2693     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2694     *pceltFetched = 0;
2695     hr = IEnumOLEVERB_Next(This, celt, rgelt, pceltFetched);
2696     if (hr == S_OK) *pceltFetched = celt;
2697     return hr;
2698 }
2699
2700 HRESULT CALLBACK IViewObject_Draw_Proxy(
2701     IViewObject* This,
2702     DWORD dwDrawAspect,
2703     LONG lindex,
2704     void *pvAspect,
2705     DVTARGETDEVICE *ptd,
2706     HDC hdcTargetDev,
2707     HDC hdcDraw,
2708     LPCRECTL lprcBounds,
2709     LPCRECTL lprcWBounds,
2710     BOOL (STDMETHODCALLTYPE *pfnContinue)(ULONG_PTR dwContinue),
2711     ULONG_PTR dwContinue)
2712 {
2713     FIXME(":stub\n");
2714     return E_NOTIMPL;
2715 }
2716
2717 HRESULT __RPC_STUB IViewObject_Draw_Stub(
2718     IViewObject* This,
2719     DWORD dwDrawAspect,
2720     LONG lindex,
2721     ULONG_PTR pvAspect,
2722     DVTARGETDEVICE *ptd,
2723     ULONG_PTR hdcTargetDev,
2724     ULONG_PTR hdcDraw,
2725     LPCRECTL lprcBounds,
2726     LPCRECTL lprcWBounds,
2727     IContinue *pContinue)
2728 {
2729     FIXME(":stub\n");
2730     return E_NOTIMPL;
2731 }
2732
2733 HRESULT CALLBACK IViewObject_GetColorSet_Proxy(
2734     IViewObject* This,
2735     DWORD dwDrawAspect,
2736     LONG lindex,
2737     void *pvAspect,
2738     DVTARGETDEVICE *ptd,
2739     HDC hicTargetDev,
2740     LOGPALETTE **ppColorSet)
2741 {
2742     FIXME(":stub\n");
2743     return E_NOTIMPL;
2744 }
2745
2746 HRESULT __RPC_STUB IViewObject_GetColorSet_Stub(
2747     IViewObject* This,
2748     DWORD dwDrawAspect,
2749     LONG lindex,
2750     ULONG_PTR pvAspect,
2751     DVTARGETDEVICE *ptd,
2752     ULONG_PTR hicTargetDev,
2753     LOGPALETTE **ppColorSet)
2754 {
2755     FIXME(":stub\n");
2756     return E_NOTIMPL;
2757 }
2758
2759 HRESULT CALLBACK IViewObject_Freeze_Proxy(
2760     IViewObject* This,
2761     DWORD dwDrawAspect,
2762     LONG lindex,
2763     void *pvAspect,
2764     DWORD *pdwFreeze)
2765 {
2766     FIXME(":stub\n");
2767     return E_NOTIMPL;
2768 }
2769
2770 HRESULT __RPC_STUB IViewObject_Freeze_Stub(
2771     IViewObject* This,
2772     DWORD dwDrawAspect,
2773     LONG lindex,
2774     ULONG_PTR pvAspect,
2775     DWORD *pdwFreeze)
2776 {
2777     FIXME(":stub\n");
2778     return E_NOTIMPL;
2779 }
2780
2781 HRESULT CALLBACK IViewObject_GetAdvise_Proxy(
2782     IViewObject* This,
2783     DWORD *pAspects,
2784     DWORD *pAdvf,
2785     IAdviseSink **ppAdvSink)
2786 {
2787     FIXME(":stub\n");
2788     return E_NOTIMPL;
2789 }
2790
2791 HRESULT __RPC_STUB IViewObject_GetAdvise_Stub(
2792     IViewObject* This,
2793     DWORD *pAspects,
2794     DWORD *pAdvf,
2795     IAdviseSink **ppAdvSink)
2796 {
2797     FIXME(":stub\n");
2798     return E_NOTIMPL;
2799 }