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 <stdarg.h>
  22 #include <string.h>
  23
  24 #define COBJMACROS
  25 #define NONAMELESSUNION
  26 #define NONAMELESSSTRUCT
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "wingdi.h"
  31 #include "winuser.h"
  32 #include "winerror.h"
  33
  34 #include "ole2.h"
  35 #include "oleauto.h"
  36 #include "rpcproxy.h"
  37 #include "wine/debug.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  40
  41 #define ALIGNED_LENGTH(_Len, _Align) (((_Len)+(_Align))&~(_Align))
  42 #define ALIGNED_POINTER(_Ptr, _Align) ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
  43 #define ALIGN_LENGTH(_Len, _Align) _Len = ALIGNED_LENGTH(_Len, _Align)
  44 #define ALIGN_POINTER(_Ptr, _Align) _Ptr = ALIGNED_POINTER(_Ptr, _Align)
  45
  46 static void dump_user_flags(ULONG *pFlags)
  47 {
  48     if (HIWORD(*pFlags) == NDR_LOCAL_DATA_REPRESENTATION)
  49         TRACE("MAKELONG(NDR_LOCAL_REPRESENTATION, ");
  50     else
  51         TRACE("MAKELONG(0x%04x, ", HIWORD(*pFlags));
  52     switch (LOWORD(*pFlags))
  53     {
  54     case MSHCTX_LOCAL: TRACE("MSHCTX_LOCAL)"); break;
  55     case MSHCTX_NOSHAREDMEM: TRACE("MSHCTX_NOSHAREDMEM)"); break;
  56     case MSHCTX_DIFFERENTMACHINE: TRACE("MSHCTX_DIFFERENTMACHINE)"); break;
  57     case MSHCTX_INPROC: TRACE("MSHCTX_INPROC)"); break;
  58     default: TRACE("%d)", LOWORD(*pFlags));
  59     }
  60 }
  61
  62 /******************************************************************************
  63  *           CLIPFORMAT_UserSize [OLE32.@]
  64  *
  65  * Calculates the buffer size required to marshal a clip format.
  66  *
  67  * PARAMS
  68  *  pFlags       [I] Flags. See notes.
  69  *  StartingSize [I] Starting size of the buffer. This value is added on to
  70  *                   the buffer size required for the clip format.
  71  *  pCF          [I] Clip format to size.
  72  *
  73  * RETURNS
  74  *  The buffer size required to marshal a clip format plus the starting size.
  75  *
  76  * NOTES
  77  *  Even though the function is documented to take a pointer to an unsigned
  78  *  long in pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
  79  *  the first parameter is an unsigned long.
  80  *  This function is only intended to be called by the RPC runtime.
  81  */
  82 ULONG __RPC_USER CLIPFORMAT_UserSize(ULONG *pFlags, ULONG StartingSize, CLIPFORMAT *pCF)
  83 {
  84     ULONG size = StartingSize;
  85
  86     TRACE("("); dump_user_flags(pFlags); TRACE(", %d, %p\n", StartingSize, pCF);
  87
  88     size += sizeof(userCLIPFORMAT);
  89
  90     /* only need to marshal the name if it is not a pre-defined type and
  91      * we are going remote */
  92     if ((*pCF >= 0xc000) && (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE))
  93     {
  94         WCHAR format[255];
  95         INT ret;
  96         size += 3 * sizeof(INT);
  97         /* urg! this function is badly designed because it won't tell us how
  98          * much space is needed without doing a dummy run of storing the
  99          * name into a buffer */
 100         ret = GetClipboardFormatNameW(*pCF, format, sizeof(format)/sizeof(format[0])-1);
 101         if (!ret)
 102             RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL);
 103         size += (ret + 1) * sizeof(WCHAR);
 104     }
 105     return size;
 106 }
 107
 108 /******************************************************************************
 109  *           CLIPFORMAT_UserMarshal [OLE32.@]
 110  *
 111  * Marshals a clip format into a buffer.
 112  *
 113  * PARAMS
 114  *  pFlags  [I] Flags. See notes.
 115  *  pBuffer [I] Buffer to marshal the clip format into.
 116  *  pCF     [I] Clip format to marshal.
 117  *
 118  * RETURNS
 119  *  The end of the marshaled data in the buffer.
 120  *
 121  * NOTES
 122  *  Even though the function is documented to take a pointer to an unsigned
 123  *  long in pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 124  *  the first parameter is an unsigned long.
 125  *  This function is only intended to be called by the RPC runtime.
 126  */
 127 unsigned char * __RPC_USER CLIPFORMAT_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, CLIPFORMAT *pCF)
 128 {
 129     wireCLIPFORMAT wirecf = (wireCLIPFORMAT)pBuffer;
 130
 131     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &0x%04x\n", pBuffer, *pCF);
 132
 133     wirecf->u.dwValue = *pCF;
 134     pBuffer += sizeof(*wirecf);
 135
 136     /* only need to marshal the name if it is not a pre-defined type and
 137      * we are going remote */
 138     if ((*pCF >= 0xc000) && (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE))
 139     {
 140         WCHAR format[255];
 141         INT len;
 142         wirecf->fContext = WDT_REMOTE_CALL;
 143         len = GetClipboardFormatNameW(*pCF, format, sizeof(format)/sizeof(format[0])-1);
 144         if (!len)
 145             RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL);
 146         len += 1;
 147         *(INT *)pBuffer = len;
 148         pBuffer += sizeof(INT);
 149         *(INT *)pBuffer = 0;
 150         pBuffer += sizeof(INT);
 151         *(INT *)pBuffer = len;
 152         pBuffer += sizeof(INT);
 153         TRACE("marshaling format name %s\n", debugstr_wn(format, len-1));
 154         lstrcpynW((LPWSTR)pBuffer, format, len);
 155         pBuffer += len * sizeof(WCHAR);
 156         *(WCHAR *)pBuffer = '\0';
 157         pBuffer += sizeof(WCHAR);
 158     }
 159     else
 160         wirecf->fContext = WDT_INPROC_CALL;
 161
 162     return pBuffer;
 163 }
 164
 165 /******************************************************************************
 166  *           CLIPFORMAT_UserUnmarshal [OLE32.@]
 167  *
 168  * Unmarshals a clip format from a buffer.
 169  *
 170  * PARAMS
 171  *  pFlags  [I] Flags. See notes.
 172  *  pBuffer [I] Buffer to marshal the clip format from.
 173  *  pCF     [O] Address that receive the unmarshaled clip format.
 174  *
 175  * RETURNS
 176  *  The end of the marshaled data in the buffer.
 177  *
 178  * NOTES
 179  *  Even though the function is documented to take a pointer to an unsigned
 180  *  long in pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 181  *  the first parameter is an unsigned long.
 182  *  This function is only intended to be called by the RPC runtime.
 183  */
 184 unsigned char * __RPC_USER CLIPFORMAT_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, CLIPFORMAT *pCF)
 185 {
 186     wireCLIPFORMAT wirecf = (wireCLIPFORMAT)pBuffer;
 187
 188     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", pBuffer, pCF);
 189
 190     pBuffer += sizeof(*wirecf);
 191     if (wirecf->fContext == WDT_INPROC_CALL)
 192         *pCF = (CLIPFORMAT)wirecf->u.dwValue;
 193     else if (wirecf->fContext == WDT_REMOTE_CALL)
 194     {
 195         CLIPFORMAT cf;
 196         INT len = *(INT *)pBuffer;
 197         pBuffer += sizeof(INT);
 198         if (*(INT *)pBuffer != 0)
 199             RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
 200         pBuffer += sizeof(INT);
 201         if (*(INT *)pBuffer != len)
 202             RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
 203         pBuffer += sizeof(INT);
 204         if (((WCHAR *)pBuffer)[len] != '\0')
 205             RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
 206         TRACE("unmarshaling clip format %s\n", debugstr_w((LPCWSTR)pBuffer));
 207         cf = RegisterClipboardFormatW((LPCWSTR)pBuffer);
 208         pBuffer += (len + 1) * sizeof(WCHAR);
 209         if (!cf)
 210             RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL);
 211         *pCF = cf;
 212     }
 213     else
 214         /* code not really appropriate, but nearest I can find */
 215         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 216     return pBuffer;
 217 }
 218
 219 /******************************************************************************
 220  *           CLIPFORMAT_UserFree [OLE32.@]
 221  *
 222  * Frees an unmarshaled clip format.
 223  *
 224  * PARAMS
 225  *  pFlags  [I] Flags. See notes.
 226  *  pCF     [I] Clip format to free.
 227  *
 228  * RETURNS
 229  *  The end of the marshaled data in the buffer.
 230  *
 231  * NOTES
 232  *  Even though the function is documented to take a pointer to an unsigned
 233  *  long in pFlags, it actually takes a pointer to a USER_MARSHAL_CB
 234  *  structure, of which the first parameter is an unsigned long.
 235  *  This function is only intended to be called by the RPC runtime.
 236  */
 237 void __RPC_USER CLIPFORMAT_UserFree(ULONG *pFlags, CLIPFORMAT *pCF)
 238 {
 239     /* there is no inverse of the RegisterClipboardFormat function,
 240      * so nothing to do */
 241 }
 242
 243 static ULONG __RPC_USER handle_UserSize(ULONG *pFlags, ULONG StartingSize, HANDLE *handle)
 244 {
 245     if (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE)
 246     {
 247         ERR("can't remote a local handle\n");
 248         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 249         return StartingSize;
 250     }
 251     return StartingSize + sizeof(RemotableHandle);
 252 }
 253
 254 static unsigned char * __RPC_USER handle_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HANDLE *handle)
 255 {
 256     RemotableHandle *remhandle = (RemotableHandle *)pBuffer;
 257     if (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE)
 258     {
 259         ERR("can't remote a local handle\n");
 260         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 261         return pBuffer;
 262     }
 263     remhandle->fContext = WDT_INPROC_CALL;
 264     remhandle->u.hInproc = (LONG_PTR)*handle;
 265     return pBuffer + sizeof(RemotableHandle);
 266 }
 267
 268 static unsigned char * __RPC_USER handle_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HANDLE *handle)
 269 {
 270     RemotableHandle *remhandle = (RemotableHandle *)pBuffer;
 271     if (remhandle->fContext != WDT_INPROC_CALL)
 272         RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
 273     *handle = (HANDLE)remhandle->u.hInproc;
 274     return pBuffer + sizeof(RemotableHandle);
 275 }
 276
 277 static void __RPC_USER handle_UserFree(ULONG *pFlags, HANDLE *phMenu)
 278 {
 279     /* nothing to do */
 280 }
 281
 282 #define IMPL_WIREM_HANDLE(type) \
 283     ULONG __RPC_USER type##_UserSize(ULONG *pFlags, ULONG StartingSize, type *handle) \
 284     { \
 285         TRACE("("); dump_user_flags(pFlags); TRACE(", %d, %p\n", StartingSize, handle); \
 286         return handle_UserSize(pFlags, StartingSize, (HANDLE *)handle); \
 287     } \
 288     \
 289     unsigned char * __RPC_USER type##_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, type *handle) \
 290     { \
 291         TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &%p\n", pBuffer, *handle); \
 292         return handle_UserMarshal(pFlags, pBuffer, (HANDLE *)handle); \
 293     } \
 294     \
 295     unsigned char * __RPC_USER type##_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, type *handle) \
 296     { \
 297         TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", pBuffer, handle); \
 298         return handle_UserUnmarshal(pFlags, pBuffer, (HANDLE *)handle); \
 299     } \
 300     \
 301     void __RPC_USER type##_UserFree(ULONG *pFlags, type *handle) \
 302     { \
 303         TRACE("("); dump_user_flags(pFlags); TRACE(", &%p\n", *handle); \
 304         return handle_UserFree(pFlags, (HANDLE *)handle); \
 305     }
 306
 307 IMPL_WIREM_HANDLE(HACCEL)
 308 IMPL_WIREM_HANDLE(HMENU)
 309 IMPL_WIREM_HANDLE(HWND)
 310
 311 /******************************************************************************
 312  *           HGLOBAL_UserSize [OLE32.@]
 313  */
 314 ULONG __RPC_USER HGLOBAL_UserSize(ULONG *pFlags, ULONG StartingSize, HGLOBAL *phGlobal)
 315 {
 316     ULONG size = StartingSize;
 317
 318     TRACE("("); dump_user_flags(pFlags); TRACE(", %d, %p\n", StartingSize, phGlobal);
 319
 320     ALIGN_LENGTH(size, 3);
 321
 322     size += sizeof(ULONG);
 323
 324     if (LOWORD(*pFlags == MSHCTX_INPROC))
 325         size += sizeof(HGLOBAL);
 326     else
 327     {
 328         size += sizeof(ULONG);
 329         if (*phGlobal)
 330         {
 331             SIZE_T ret;
 332             size += 3 * sizeof(ULONG);
 333             ret = GlobalSize(*phGlobal);
 334             size += (ULONG)ret;
 335         }
 336     }
 337
 338     return size;
 339 }
 340
 341 unsigned char * __RPC_USER HGLOBAL_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HGLOBAL *phGlobal)
 342 {
 343     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &%p\n", pBuffer, *phGlobal);
 344
 345     ALIGN_POINTER(pBuffer, 3);
 346
 347     if (LOWORD(*pFlags == MSHCTX_INPROC))
 348     {
 349         if (sizeof(*phGlobal) == 8)
 350             *(ULONG *)pBuffer = WDT_INPROC64_CALL;
 351         else
 352             *(ULONG *)pBuffer = WDT_INPROC_CALL;
 353         pBuffer += sizeof(ULONG);
 354         *(HGLOBAL *)pBuffer = *phGlobal;
 355         pBuffer += sizeof(HGLOBAL);
 356     }
 357     else
 358     {
 359         *(ULONG *)pBuffer = WDT_REMOTE_CALL;
 360         pBuffer += sizeof(ULONG);
 361         *(ULONG *)pBuffer = (ULONG)*phGlobal;
 362         pBuffer += sizeof(ULONG);
 363         if (*phGlobal)
 364         {
 365             const unsigned char *memory;
 366             SIZE_T size = GlobalSize(*phGlobal);
 367             *(ULONG *)pBuffer = (ULONG)size;
 368             pBuffer += sizeof(ULONG);
 369             *(ULONG *)pBuffer = (ULONG)*phGlobal;
 370             pBuffer += sizeof(ULONG);
 371             *(ULONG *)pBuffer = (ULONG)size;
 372             pBuffer += sizeof(ULONG);
 373
 374             memory = GlobalLock(*phGlobal);
 375             memcpy(pBuffer, memory, size);
 376             pBuffer += size;
 377             GlobalUnlock(*phGlobal);
 378         }
 379     }
 380
 381     return pBuffer;
 382 }
 383
 384 unsigned char * __RPC_USER HGLOBAL_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HGLOBAL *phGlobal)
 385 {
 386     ULONG fContext;
 387
 388     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &%p\n", pBuffer, *phGlobal);
 389
 390     ALIGN_POINTER(pBuffer, 3);
 391
 392     fContext = *(ULONG *)pBuffer;
 393     pBuffer += sizeof(ULONG);
 394
 395     if (((fContext == WDT_INPROC_CALL) && (sizeof(*phGlobal) < 8)) ||
 396         ((fContext == WDT_INPROC64_CALL) && (sizeof(*phGlobal) == 8)))
 397     {
 398         *phGlobal = *(HGLOBAL *)pBuffer;
 399         pBuffer += sizeof(*phGlobal);
 400     }
 401     else if (fContext == WDT_REMOTE_CALL)
 402     {
 403         ULONG handle;
 404
 405         handle = *(ULONG *)pBuffer;
 406         pBuffer += sizeof(ULONG);
 407
 408         if (handle)
 409         {
 410             ULONG size;
 411             void *memory;
 412
 413             size = *(ULONG *)pBuffer;
 414             pBuffer += sizeof(ULONG);
 415             /* redundancy is bad - it means you have to check consistency like
 416              * this: */
 417             if (*(ULONG *)pBuffer != handle)
 418             {
 419                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
 420                 return pBuffer;
 421             }
 422             pBuffer += sizeof(ULONG);
 423             /* redundancy is bad - it means you have to check consistency like
 424              * this: */
 425             if (*(ULONG *)pBuffer != size)
 426             {
 427                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
 428                 return pBuffer;
 429             }
 430             pBuffer += sizeof(ULONG);
 431
 432             /* FIXME: check size is not too big */
 433
 434             *phGlobal = GlobalAlloc(GMEM_MOVEABLE, size);
 435             memory = GlobalLock(*phGlobal);
 436             memcpy(memory, pBuffer, size);
 437             pBuffer += size;
 438             GlobalUnlock(*phGlobal);
 439         }
 440         else
 441             *phGlobal = NULL;
 442     }
 443     else
 444         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 445
 446     return pBuffer;
 447 }
 448
 449 /******************************************************************************
 450  *           HGLOBAL_UserFree [OLE32.@]
 451  */
 452 void __RPC_USER HGLOBAL_UserFree(ULONG *pFlags, HGLOBAL *phGlobal)
 453 {
 454     TRACE("("); dump_user_flags(pFlags); TRACE(", &%p\n", *phGlobal);
 455
 456     if (LOWORD(*pFlags != MSHCTX_INPROC) && *phGlobal)
 457         GlobalFree(*phGlobal);
 458 }
 459
 460 ULONG __RPC_USER HBITMAP_UserSize(ULONG *pFlags, ULONG StartingSize, HBITMAP *phBmp)
 461 {
 462     FIXME(":stub\n");
 463     return StartingSize;
 464 }
 465
 466 unsigned char * __RPC_USER HBITMAP_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HBITMAP *phBmp)
 467 {
 468     FIXME(":stub\n");
 469     return pBuffer;
 470 }
 471
 472 unsigned char * __RPC_USER HBITMAP_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HBITMAP *phBmp)
 473 {
 474     FIXME(":stub\n");
 475     return pBuffer;
 476 }
 477
 478 void __RPC_USER HBITMAP_UserFree(ULONG *pFlags, HBITMAP *phBmp)
 479 {
 480     FIXME(":stub\n");
 481 }
 482
 483 ULONG __RPC_USER HDC_UserSize(ULONG *pFlags, ULONG StartingSize, HDC *phdc)
 484 {
 485     FIXME(":stub\n");
 486     return StartingSize;
 487 }
 488
 489 unsigned char * __RPC_USER HDC_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HDC *phdc)
 490 {
 491     FIXME(":stub\n");
 492     return pBuffer;
 493 }
 494
 495 unsigned char * __RPC_USER HDC_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HDC *phdc)
 496 {
 497     FIXME(":stub\n");
 498     return pBuffer;
 499 }
 500
 501 void __RPC_USER HDC_UserFree(ULONG *pFlags, HDC *phdc)
 502 {
 503     FIXME(":stub\n");
 504 }
 505
 506 ULONG __RPC_USER HPALETTE_UserSize(ULONG *pFlags, ULONG StartingSize, HPALETTE *phPal)
 507 {
 508     FIXME(":stub\n");
 509     return StartingSize;
 510 }
 511
 512 unsigned char * __RPC_USER HPALETTE_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HPALETTE *phPal)
 513 {
 514     FIXME(":stub\n");
 515     return pBuffer;
 516 }
 517
 518 unsigned char * __RPC_USER HPALETTE_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HPALETTE *phPal)
 519 {
 520     FIXME(":stub\n");
 521     return pBuffer;
 522 }
 523
 524 void __RPC_USER HPALETTE_UserFree(ULONG *pFlags, HPALETTE *phPal)
 525 {
 526     FIXME(":stub\n");
 527 }
 528
 529
 530 ULONG __RPC_USER HENHMETAFILE_UserSize(ULONG *pFlags, ULONG StartingSize, HENHMETAFILE *phEmf)
 531 {
 532     ULONG size = StartingSize;
 533
 534     TRACE("("); dump_user_flags(pFlags); TRACE(", %d, %p\n", StartingSize, *phEmf);
 535
 536     size += sizeof(ULONG);
 537     if (LOWORD(*pFlags) == MSHCTX_INPROC)
 538         size += sizeof(ULONG_PTR);
 539     else
 540     {
 541         size += sizeof(ULONG);
 542
 543         if (*phEmf)
 544         {
 545             UINT emfsize;
 546
 547             size += 2 * sizeof(ULONG);
 548             emfsize = GetEnhMetaFileBits(*phEmf, 0, NULL);
 549             size += emfsize;
 550         }
 551     }
 552
 553     return size;
 554 }
 555
 556 unsigned char * __RPC_USER HENHMETAFILE_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
 557 {
 558     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &%p\n", pBuffer, *phEmf);
 559
 560     if (LOWORD(*pFlags) == MSHCTX_INPROC)
 561     {
 562         if (sizeof(*phEmf) == 8)
 563             *(ULONG *)pBuffer = WDT_INPROC64_CALL;
 564         else
 565             *(ULONG *)pBuffer = WDT_INPROC_CALL;
 566         pBuffer += sizeof(ULONG);
 567         *(HENHMETAFILE *)pBuffer = *phEmf;
 568         pBuffer += sizeof(HENHMETAFILE);
 569     }
 570     else
 571     {
 572         *(ULONG *)pBuffer = WDT_REMOTE_CALL;
 573         pBuffer += sizeof(ULONG);
 574         *(ULONG *)pBuffer = (ULONG)(ULONG_PTR)*phEmf;
 575         pBuffer += sizeof(ULONG);
 576
 577         if (*phEmf)
 578         {
 579             UINT emfsize = GetEnhMetaFileBits(*phEmf, 0, NULL);
 580
 581             *(ULONG *)pBuffer = emfsize;
 582             pBuffer += sizeof(ULONG);
 583             *(ULONG *)pBuffer = emfsize;
 584             pBuffer += sizeof(ULONG);
 585             GetEnhMetaFileBits(*phEmf, emfsize, pBuffer);
 586             pBuffer += emfsize;
 587         }
 588     }
 589
 590     return pBuffer;
 591 }
 592
 593 unsigned char * __RPC_USER HENHMETAFILE_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
 594 {
 595     ULONG fContext;
 596
 597     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", pBuffer, phEmf);
 598
 599     fContext = *(ULONG *)pBuffer;
 600     pBuffer += sizeof(ULONG);
 601
 602     if (((fContext == WDT_INPROC_CALL) && (sizeof(*phEmf) < 8)) ||
 603         ((fContext == WDT_INPROC64_CALL) && (sizeof(*phEmf) == 8)))
 604     {
 605         *phEmf = *(HENHMETAFILE *)pBuffer;
 606         pBuffer += sizeof(*phEmf);
 607     }
 608     else if (fContext == WDT_REMOTE_CALL)
 609     {
 610         ULONG handle;
 611
 612         handle = *(ULONG *)pBuffer;
 613         pBuffer += sizeof(ULONG);
 614
 615         if (handle)
 616         {
 617             ULONG size;
 618             size = *(ULONG *)pBuffer;
 619             pBuffer += sizeof(ULONG);
 620             if (size != *(ULONG *)pBuffer)
 621             {
 622                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
 623                 return pBuffer;
 624             }
 625             pBuffer += sizeof(ULONG);
 626             *phEmf = SetEnhMetaFileBits(size, pBuffer);
 627             pBuffer += size;
 628         }
 629         else
 630             *phEmf = NULL;
 631     }
 632     else
 633         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 634
 635     return pBuffer;
 636 }
 637
 638 void __RPC_USER HENHMETAFILE_UserFree(ULONG *pFlags, HENHMETAFILE *phEmf)
 639 {
 640     TRACE("("); dump_user_flags(pFlags); TRACE(", &%p\n", *phEmf);
 641
 642     if (LOWORD(*pFlags) != MSHCTX_INPROC)
 643         DeleteEnhMetaFile(*phEmf);
 644 }
 645
 646 ULONG __RPC_USER STGMEDIUM_UserSize(ULONG *pFlags, ULONG StartingSize, STGMEDIUM *pStgMedium)
 647 {
 648     ULONG size = StartingSize;
 649
 650     TRACE("("); dump_user_flags(pFlags); TRACE(", %d, %p\n", StartingSize, pStgMedium);
 651
 652     ALIGN_LENGTH(size, 3);
 653
 654     size += 2 * sizeof(DWORD);
 655     if (pStgMedium->tymed != TYMED_NULL)
 656         size += sizeof(DWORD);
 657
 658     switch (pStgMedium->tymed)
 659     {
 660     case TYMED_NULL:
 661         TRACE("TYMED_NULL\n");
 662         break;
 663     case TYMED_HGLOBAL:
 664         TRACE("TYMED_HGLOBAL\n");
 665         size = HGLOBAL_UserSize(pFlags, size, &pStgMedium->u.hGlobal);
 666         break;
 667     case TYMED_FILE:
 668         FIXME("TYMED_FILE\n");
 669         break;
 670     case TYMED_ISTREAM:
 671         FIXME("TYMED_ISTREAM\n");
 672         break;
 673     case TYMED_ISTORAGE:
 674         FIXME("TYMED_ISTORAGE\n");
 675         break;
 676     case TYMED_GDI:
 677         FIXME("TYMED_GDI\n");
 678         break;
 679     case TYMED_MFPICT:
 680         FIXME("TYMED_MFPICT\n");
 681         break;
 682     case TYMED_ENHMF:
 683         TRACE("TYMED_ENHMF\n");
 684         size = HENHMETAFILE_UserSize(pFlags, size, &pStgMedium->u.hEnhMetaFile);
 685         break;
 686     default:
 687         RaiseException(DV_E_TYMED, 0, 0, NULL);
 688     }
 689
 690     if (pStgMedium->pUnkForRelease)
 691         FIXME("buffer size pUnkForRelease\n");
 692
 693     return size;
 694 }
 695
 696 unsigned char * __RPC_USER STGMEDIUM_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
 697 {
 698     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", pBuffer, pStgMedium);
 699
 700     ALIGN_POINTER(pBuffer, 3);
 701
 702     *(DWORD *)pBuffer = pStgMedium->tymed;
 703     pBuffer += sizeof(DWORD);
 704     if (pStgMedium->tymed != TYMED_NULL)
 705     {
 706         *(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->u.pstg;
 707         pBuffer += sizeof(DWORD);
 708     }
 709     *(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->pUnkForRelease;
 710     pBuffer += sizeof(DWORD);
 711
 712     switch (pStgMedium->tymed)
 713     {
 714     case TYMED_NULL:
 715         TRACE("TYMED_NULL\n");
 716         break;
 717     case TYMED_HGLOBAL:
 718         TRACE("TYMED_HGLOBAL\n");
 719         pBuffer = HGLOBAL_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hGlobal);
 720         break;
 721     case TYMED_FILE:
 722         FIXME("TYMED_FILE\n");
 723         break;
 724     case TYMED_ISTREAM:
 725         FIXME("TYMED_ISTREAM\n");
 726         break;
 727     case TYMED_ISTORAGE:
 728         FIXME("TYMED_ISTORAGE\n");
 729         break;
 730     case TYMED_GDI:
 731         FIXME("TYMED_GDI\n");
 732         break;
 733     case TYMED_MFPICT:
 734         FIXME("TYMED_MFPICT\n");
 735         break;
 736     case TYMED_ENHMF:
 737         TRACE("TYMED_ENHMF\n");
 738         pBuffer = HENHMETAFILE_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hEnhMetaFile);
 739         break;
 740     default:
 741         RaiseException(DV_E_TYMED, 0, 0, NULL);
 742     }
 743
 744     if (pStgMedium->pUnkForRelease)
 745         FIXME("marshal pUnkForRelease\n");
 746
 747     return pBuffer;
 748 }
 749
 750 unsigned char * __RPC_USER STGMEDIUM_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
 751 {
 752     DWORD content;
 753     DWORD releaseunk;
 754
 755     ALIGN_POINTER(pBuffer, 3);
 756
 757     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", pBuffer, pStgMedium);
 758
 759     pStgMedium->tymed = *(DWORD *)pBuffer;
 760     pBuffer += sizeof(DWORD);
 761     if (pStgMedium->tymed != TYMED_NULL)
 762     {
 763         content = *(DWORD *)pBuffer;
 764         pBuffer += sizeof(DWORD);
 765     }
 766     releaseunk = *(DWORD *)pBuffer;
 767     pBuffer += sizeof(DWORD);
 768
 769     switch (pStgMedium->tymed)
 770     {
 771     case TYMED_NULL:
 772         TRACE("TYMED_NULL\n");
 773         break;
 774     case TYMED_HGLOBAL:
 775         TRACE("TYMED_HGLOBAL\n");
 776         pBuffer = HGLOBAL_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hGlobal);
 777         break;
 778     case TYMED_FILE:
 779         FIXME("TYMED_FILE\n");
 780         break;
 781     case TYMED_ISTREAM:
 782         FIXME("TYMED_ISTREAM\n");
 783         break;
 784     case TYMED_ISTORAGE:
 785         FIXME("TYMED_ISTORAGE\n");
 786         break;
 787     case TYMED_GDI:
 788         FIXME("TYMED_GDI\n");
 789         break;
 790     case TYMED_MFPICT:
 791         FIXME("TYMED_MFPICT\n");
 792         break;
 793     case TYMED_ENHMF:
 794         TRACE("TYMED_ENHMF\n");
 795         pBuffer = HENHMETAFILE_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hEnhMetaFile);
 796         break;
 797     default:
 798         RaiseException(DV_E_TYMED, 0, 0, NULL);
 799     }
 800
 801     pStgMedium->pUnkForRelease = NULL;
 802     if (releaseunk)
 803         FIXME("unmarshal pUnkForRelease\n");
 804
 805     return pBuffer;
 806 }
 807
 808 void __RPC_USER STGMEDIUM_UserFree(ULONG *pFlags, STGMEDIUM *pStgMedium)
 809 {
 810     TRACE("("); dump_user_flags(pFlags); TRACE(", %p\n", pStgMedium);
 811
 812     ReleaseStgMedium(pStgMedium);
 813 }
 814
 815 ULONG __RPC_USER ASYNC_STGMEDIUM_UserSize(ULONG *pFlags, ULONG StartingSize, ASYNC_STGMEDIUM *pStgMedium)
 816 {
 817     FIXME(":stub\n");
 818     return StartingSize;
 819 }
 820
 821 unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserMarshal(  ULONG *pFlags, unsigned char *pBuffer, ASYNC_STGMEDIUM *pStgMedium)
 822 {
 823     FIXME(":stub\n");
 824     return pBuffer;
 825 }
 826
 827 unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, ASYNC_STGMEDIUM *pStgMedium)
 828 {
 829     FIXME(":stub\n");
 830     return pBuffer;
 831 }
 832
 833 void __RPC_USER ASYNC_STGMEDIUM_UserFree(ULONG *pFlags, ASYNC_STGMEDIUM *pStgMedium)
 834 {
 835     FIXME(":stub\n");
 836 }
 837
 838 ULONG __RPC_USER FLAG_STGMEDIUM_UserSize(ULONG *pFlags, ULONG StartingSize, FLAG_STGMEDIUM *pStgMedium)
 839 {
 840     FIXME(":stub\n");
 841     return StartingSize;
 842 }
 843
 844 unsigned char * __RPC_USER FLAG_STGMEDIUM_UserMarshal(  ULONG *pFlags, unsigned char *pBuffer, FLAG_STGMEDIUM *pStgMedium)
 845 {
 846     FIXME(":stub\n");
 847     return pBuffer;
 848 }
 849
 850 unsigned char * __RPC_USER FLAG_STGMEDIUM_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, FLAG_STGMEDIUM *pStgMedium)
 851 {
 852     FIXME(":stub\n");
 853     return pBuffer;
 854 }
 855
 856 void __RPC_USER FLAG_STGMEDIUM_UserFree(ULONG *pFlags, FLAG_STGMEDIUM *pStgMedium)
 857 {
 858     FIXME(":stub\n");
 859 }
 860
 861 ULONG __RPC_USER SNB_UserSize(ULONG *pFlags, ULONG StartingSize, SNB *pSnb)
 862 {
 863     FIXME(":stub\n");
 864     return StartingSize;
 865 }
 866
 867 unsigned char * __RPC_USER SNB_UserMarshal(  ULONG *pFlags, unsigned char *pBuffer, SNB *pSnb)
 868 {
 869     FIXME(":stub\n");
 870     return pBuffer;
 871 }
 872
 873 unsigned char * __RPC_USER SNB_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, SNB *pSnb)
 874 {
 875     FIXME(":stub\n");
 876     return pBuffer;
 877 }
 878
 879 void __RPC_USER SNB_UserFree(ULONG *pFlags, SNB *pSnb)
 880 {
 881     FIXME(":stub\n");
 882 }