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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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(unsigned long *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 unsigned long __RPC_USER CLIPFORMAT_UserSize(unsigned long *pFlags, unsigned long StartingSize, CLIPFORMAT *pCF)
  83 {
  84     unsigned long size = StartingSize;
  85
  86     TRACE("("); dump_user_flags(pFlags); TRACE(", %ld, %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(unsigned long *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(unsigned long *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(unsigned long *pFlags, CLIPFORMAT *pCF)
 238 {
 239     /* there is no inverse of the RegisterClipboardFormat function,
 240      * so nothing to do */
 241 }
 242
 243 static unsigned long __RPC_USER handle_UserSize(unsigned long *pFlags, unsigned long 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(unsigned long *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(unsigned long *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(unsigned long *pFlags, HANDLE *phMenu)
 278 {
 279     /* nothing to do */
 280 }
 281
 282 #define IMPL_WIREM_HANDLE(type) \
 283     unsigned long __RPC_USER type##_UserSize(unsigned long *pFlags, unsigned long StartingSize, type *handle) \
 284     { \
 285         TRACE("("); dump_user_flags(pFlags); TRACE(", %ld, %p\n", StartingSize, handle); \
 286         return handle_UserSize(pFlags, StartingSize, (HANDLE *)handle); \
 287     } \
 288     \
 289     unsigned char * __RPC_USER type##_UserMarshal(unsigned long *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(unsigned long *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(unsigned long *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 unsigned long __RPC_USER HGLOBAL_UserSize(unsigned long *pFlags, unsigned long StartingSize, HGLOBAL *phGlobal)
 312 {
 313     unsigned long size = StartingSize;
 314
 315     TRACE("("); dump_user_flags(pFlags); TRACE(", %ld, %p\n", StartingSize, phGlobal);
 316
 317     ALIGN_LENGTH(size, 3);
 318
 319     size += sizeof(ULONG);
 320
 321     if (LOWORD(*pFlags == MSHCTX_INPROC))
 322         size += sizeof(HGLOBAL);
 323     else
 324     {
 325         size += sizeof(ULONG);
 326         if (*phGlobal)
 327         {
 328             SIZE_T ret;
 329             size += 3 * sizeof(ULONG);
 330             ret = GlobalSize(*phGlobal);
 331             size += (unsigned long)ret;
 332         }
 333     }
 334
 335     return size;
 336 }
 337
 338 unsigned char * __RPC_USER HGLOBAL_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, HGLOBAL *phGlobal)
 339 {
 340     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &%p\n", pBuffer, *phGlobal);
 341
 342     ALIGN_POINTER(pBuffer, 3);
 343
 344     if (LOWORD(*pFlags == MSHCTX_INPROC))
 345     {
 346         if (sizeof(*phGlobal) == 8)
 347             *(ULONG *)pBuffer = WDT_INPROC64_CALL;
 348         else
 349             *(ULONG *)pBuffer = WDT_INPROC_CALL;
 350         pBuffer += sizeof(ULONG);
 351         *(HGLOBAL *)pBuffer = *phGlobal;
 352         pBuffer += sizeof(HGLOBAL);
 353     }
 354     else
 355     {
 356         *(ULONG *)pBuffer = WDT_REMOTE_CALL;
 357         pBuffer += sizeof(ULONG);
 358         *(ULONG *)pBuffer = (ULONG)*phGlobal;
 359         pBuffer += sizeof(ULONG);
 360         if (*phGlobal)
 361         {
 362             const unsigned char *memory;
 363             SIZE_T size = GlobalSize(*phGlobal);
 364             *(ULONG *)pBuffer = (ULONG)size;
 365             pBuffer += sizeof(ULONG);
 366             *(ULONG *)pBuffer = (ULONG)*phGlobal;
 367             pBuffer += sizeof(ULONG);
 368             *(ULONG *)pBuffer = (ULONG)size;
 369             pBuffer += sizeof(ULONG);
 370
 371             memory = GlobalLock(*phGlobal);
 372             memcpy(pBuffer, memory, size);
 373             pBuffer += size;
 374             GlobalUnlock(*phGlobal);
 375         }
 376     }
 377
 378     return pBuffer;
 379 }
 380
 381 unsigned char * __RPC_USER HGLOBAL_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, HGLOBAL *phGlobal)
 382 {
 383     ULONG fContext;
 384
 385     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &%p\n", pBuffer, *phGlobal);
 386
 387     ALIGN_POINTER(pBuffer, 3);
 388
 389     fContext = *(ULONG *)pBuffer;
 390     pBuffer += sizeof(ULONG);
 391
 392     if (((fContext == WDT_INPROC_CALL) && (sizeof(*phGlobal) < 8)) ||
 393         ((fContext == WDT_INPROC64_CALL) && (sizeof(*phGlobal) == 8)))
 394     {
 395         *phGlobal = *(HGLOBAL *)pBuffer;
 396         pBuffer += sizeof(*phGlobal);
 397     }
 398     else if (fContext == WDT_REMOTE_CALL)
 399     {
 400         ULONG handle;
 401
 402         handle = *(ULONG *)pBuffer;
 403         pBuffer += sizeof(ULONG);
 404
 405         if (handle)
 406         {
 407             ULONG size;
 408             void *memory;
 409
 410             size = *(ULONG *)pBuffer;
 411             pBuffer += sizeof(ULONG);
 412             /* redundancy is bad - it means you have to check consistency like
 413              * this: */
 414             if (*(ULONG *)pBuffer != handle)
 415             {
 416                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
 417                 return pBuffer;
 418             }
 419             pBuffer += sizeof(ULONG);
 420             /* redundancy is bad - it means you have to check consistency like
 421              * this: */
 422             if (*(ULONG *)pBuffer != size)
 423             {
 424                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
 425                 return pBuffer;
 426             }
 427             pBuffer += sizeof(ULONG);
 428
 429             /* FIXME: check size is not too big */
 430
 431             *phGlobal = GlobalAlloc(GMEM_MOVEABLE, size);
 432             memory = GlobalLock(*phGlobal);
 433             memcpy(memory, pBuffer, size);
 434             pBuffer += size;
 435             GlobalUnlock(*phGlobal);
 436         }
 437         else
 438             *phGlobal = NULL;
 439     }
 440     else
 441         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 442
 443     return pBuffer;
 444 }
 445
 446 void __RPC_USER HGLOBAL_UserFree(unsigned long *pFlags, HGLOBAL *phGlobal)
 447 {
 448     TRACE("("); dump_user_flags(pFlags); TRACE(", &%p\n", *phGlobal);
 449
 450     if (LOWORD(*pFlags != MSHCTX_INPROC) && *phGlobal)
 451         GlobalFree(*phGlobal);
 452 }
 453
 454 unsigned long __RPC_USER HBITMAP_UserSize(unsigned long *pFlags, unsigned long StartingSize, HBITMAP *phBmp)
 455 {
 456     FIXME(":stub\n");
 457     return StartingSize;
 458 }
 459
 460 unsigned char * __RPC_USER HBITMAP_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, HBITMAP *phBmp)
 461 {
 462     FIXME(":stub\n");
 463     return pBuffer;
 464 }
 465
 466 unsigned char * __RPC_USER HBITMAP_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, HBITMAP *phBmp)
 467 {
 468     FIXME(":stub\n");
 469     return pBuffer;
 470 }
 471
 472 void __RPC_USER HBITMAP_UserFree(unsigned long *pFlags, HBITMAP *phBmp)
 473 {
 474     FIXME(":stub\n");
 475 }
 476
 477 unsigned long __RPC_USER HDC_UserSize(unsigned long *pFlags, unsigned long StartingSize, HDC *phdc)
 478 {
 479     FIXME(":stub\n");
 480     return StartingSize;
 481 }
 482
 483 unsigned char * __RPC_USER HDC_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, HDC *phdc)
 484 {
 485     FIXME(":stub\n");
 486     return pBuffer;
 487 }
 488
 489 unsigned char * __RPC_USER HDC_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, HDC *phdc)
 490 {
 491     FIXME(":stub\n");
 492     return pBuffer;
 493 }
 494
 495 void __RPC_USER HDC_UserFree(unsigned long *pFlags, HDC *phdc)
 496 {
 497     FIXME(":stub\n");
 498 }
 499
 500 unsigned long __RPC_USER HPALETTE_UserSize(unsigned long *pFlags, unsigned long StartingSize, HPALETTE *phPal)
 501 {
 502     FIXME(":stub\n");
 503     return StartingSize;
 504 }
 505
 506 unsigned char * __RPC_USER HPALETTE_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, HPALETTE *phPal)
 507 {
 508     FIXME(":stub\n");
 509     return pBuffer;
 510 }
 511
 512 unsigned char * __RPC_USER HPALETTE_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, HPALETTE *phPal)
 513 {
 514     FIXME(":stub\n");
 515     return pBuffer;
 516 }
 517
 518 void __RPC_USER HPALETTE_UserFree(unsigned long *pFlags, HPALETTE *phPal)
 519 {
 520     FIXME(":stub\n");
 521 }
 522
 523
 524 unsigned long __RPC_USER HENHMETAFILE_UserSize(unsigned long *pFlags, unsigned long StartingSize, HENHMETAFILE *phEmf)
 525 {
 526     unsigned long size = StartingSize;
 527
 528     TRACE("("); dump_user_flags(pFlags); TRACE(", %ld, %p\n", StartingSize, *phEmf);
 529
 530     size += sizeof(ULONG);
 531     if (LOWORD(*pFlags) == MSHCTX_INPROC)
 532         size += sizeof(ULONG_PTR);
 533     else
 534     {
 535         size += sizeof(ULONG);
 536
 537         if (*phEmf)
 538         {
 539             UINT emfsize;
 540
 541             size += 2 * sizeof(ULONG);
 542             emfsize = GetEnhMetaFileBits(*phEmf, 0, NULL);
 543             size += emfsize;
 544         }
 545     }
 546
 547     return size;
 548 }
 549
 550 unsigned char * __RPC_USER HENHMETAFILE_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
 551 {
 552     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &%p\n", pBuffer, *phEmf);
 553
 554     if (LOWORD(*pFlags) == MSHCTX_INPROC)
 555     {
 556         if (sizeof(*phEmf) == 8)
 557             *(ULONG *)pBuffer = WDT_INPROC64_CALL;
 558         else
 559             *(ULONG *)pBuffer = WDT_INPROC_CALL;
 560         pBuffer += sizeof(ULONG);
 561         *(HENHMETAFILE *)pBuffer = *phEmf;
 562         pBuffer += sizeof(HENHMETAFILE);
 563     }
 564     else
 565     {
 566         *(ULONG *)pBuffer = WDT_REMOTE_CALL;
 567         pBuffer += sizeof(ULONG);
 568         *(ULONG *)pBuffer = (ULONG)(ULONG_PTR)*phEmf;
 569         pBuffer += sizeof(ULONG);
 570
 571         if (*phEmf)
 572         {
 573             UINT emfsize = GetEnhMetaFileBits(*phEmf, 0, NULL);
 574
 575             *(ULONG *)pBuffer = emfsize;
 576             pBuffer += sizeof(ULONG);
 577             *(ULONG *)pBuffer = emfsize;
 578             pBuffer += sizeof(ULONG);
 579             GetEnhMetaFileBits(*phEmf, emfsize, pBuffer);
 580             pBuffer += emfsize;
 581         }
 582     }
 583
 584     return pBuffer;
 585 }
 586
 587 unsigned char * __RPC_USER HENHMETAFILE_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
 588 {
 589     ULONG fContext;
 590
 591     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", pBuffer, phEmf);
 592
 593     fContext = *(ULONG *)pBuffer;
 594     pBuffer += sizeof(ULONG);
 595
 596     if (((fContext == WDT_INPROC_CALL) && (sizeof(*phEmf) < 8)) ||
 597         ((fContext == WDT_INPROC64_CALL) && (sizeof(*phEmf) == 8)))
 598     {
 599         *phEmf = *(HENHMETAFILE *)pBuffer;
 600         pBuffer += sizeof(*phEmf);
 601     }
 602     else if (fContext == WDT_REMOTE_CALL)
 603     {
 604         ULONG handle;
 605
 606         handle = *(ULONG *)pBuffer;
 607         pBuffer += sizeof(ULONG);
 608
 609         if (handle)
 610         {
 611             ULONG size;
 612             size = *(ULONG *)pBuffer;
 613             pBuffer += sizeof(ULONG);
 614             if (size != *(ULONG *)pBuffer)
 615             {
 616                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
 617                 return pBuffer;
 618             }
 619             pBuffer += sizeof(ULONG);
 620             *phEmf = SetEnhMetaFileBits(size, pBuffer);
 621             pBuffer += size;
 622         }
 623         else
 624             *phEmf = NULL;
 625     }
 626     else
 627         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 628
 629     return pBuffer;
 630 }
 631
 632 void __RPC_USER HENHMETAFILE_UserFree(unsigned long *pFlags, HENHMETAFILE *phEmf)
 633 {
 634     TRACE("("); dump_user_flags(pFlags); TRACE(", &%p\n", *phEmf);
 635
 636     if (LOWORD(*pFlags) != MSHCTX_INPROC)
 637         DeleteEnhMetaFile(*phEmf);
 638 }
 639
 640 unsigned long __RPC_USER STGMEDIUM_UserSize(unsigned long *pFlags, unsigned long StartingSize, STGMEDIUM *pStgMedium)
 641 {
 642     unsigned long size = StartingSize;
 643
 644     TRACE("("); dump_user_flags(pFlags); TRACE(", %ld, %p\n", StartingSize, pStgMedium);
 645
 646     ALIGN_LENGTH(size, 3);
 647
 648     size += 2 * sizeof(DWORD);
 649     if (pStgMedium->tymed != TYMED_NULL)
 650         size += sizeof(DWORD);
 651
 652     switch (pStgMedium->tymed)
 653     {
 654     case TYMED_NULL:
 655         TRACE("TYMED_NULL\n");
 656         break;
 657     case TYMED_HGLOBAL:
 658         TRACE("TYMED_HGLOBAL\n");
 659         size = HGLOBAL_UserSize(pFlags, size, &pStgMedium->u.hGlobal);
 660         break;
 661     case TYMED_FILE:
 662         FIXME("TYMED_FILE\n");
 663         break;
 664     case TYMED_ISTREAM:
 665         FIXME("TYMED_ISTREAM\n");
 666         break;
 667     case TYMED_ISTORAGE:
 668         FIXME("TYMED_ISTORAGE\n");
 669         break;
 670     case TYMED_GDI:
 671         FIXME("TYMED_GDI\n");
 672         break;
 673     case TYMED_MFPICT:
 674         FIXME("TYMED_MFPICT\n");
 675         break;
 676     case TYMED_ENHMF:
 677         TRACE("TYMED_ENHMF\n");
 678         size = HENHMETAFILE_UserSize(pFlags, size, &pStgMedium->u.hEnhMetaFile);
 679         break;
 680     default:
 681         RaiseException(DV_E_TYMED, 0, 0, NULL);
 682     }
 683
 684     if (pStgMedium->pUnkForRelease)
 685         FIXME("buffer size pUnkForRelease\n");
 686
 687     return size;
 688 }
 689
 690 unsigned char * __RPC_USER STGMEDIUM_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
 691 {
 692     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", pBuffer, pStgMedium);
 693
 694     ALIGN_POINTER(pBuffer, 3);
 695
 696     *(DWORD *)pBuffer = pStgMedium->tymed;
 697     pBuffer += sizeof(DWORD);
 698     if (pStgMedium->tymed != TYMED_NULL)
 699     {
 700         *(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->u.pstg;
 701         pBuffer += sizeof(DWORD);
 702     }
 703     *(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->pUnkForRelease;
 704     pBuffer += sizeof(DWORD);
 705
 706     switch (pStgMedium->tymed)
 707     {
 708     case TYMED_NULL:
 709         TRACE("TYMED_NULL\n");
 710         break;
 711     case TYMED_HGLOBAL:
 712         TRACE("TYMED_HGLOBAL\n");
 713         pBuffer = HGLOBAL_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hGlobal);
 714         break;
 715     case TYMED_FILE:
 716         FIXME("TYMED_FILE\n");
 717         break;
 718     case TYMED_ISTREAM:
 719         FIXME("TYMED_ISTREAM\n");
 720         break;
 721     case TYMED_ISTORAGE:
 722         FIXME("TYMED_ISTORAGE\n");
 723         break;
 724     case TYMED_GDI:
 725         FIXME("TYMED_GDI\n");
 726         break;
 727     case TYMED_MFPICT:
 728         FIXME("TYMED_MFPICT\n");
 729         break;
 730     case TYMED_ENHMF:
 731         TRACE("TYMED_ENHMF\n");
 732         pBuffer = HENHMETAFILE_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hEnhMetaFile);
 733         break;
 734     default:
 735         RaiseException(DV_E_TYMED, 0, 0, NULL);
 736     }
 737
 738     if (pStgMedium->pUnkForRelease)
 739         FIXME("marshal pUnkForRelease\n");
 740
 741     return pBuffer;
 742 }
 743
 744 unsigned char * __RPC_USER STGMEDIUM_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
 745 {
 746     DWORD content;
 747     DWORD releaseunk;
 748
 749     ALIGN_POINTER(pBuffer, 3);
 750
 751     TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", pBuffer, pStgMedium);
 752
 753     pStgMedium->tymed = *(DWORD *)pBuffer;
 754     pBuffer += sizeof(DWORD);
 755     if (pStgMedium->tymed != TYMED_NULL)
 756     {
 757         content = *(DWORD *)pBuffer;
 758         pBuffer += sizeof(DWORD);
 759     }
 760     releaseunk = *(DWORD *)pBuffer;
 761     pBuffer += sizeof(DWORD);
 762
 763     switch (pStgMedium->tymed)
 764     {
 765     case TYMED_NULL:
 766         TRACE("TYMED_NULL\n");
 767         break;
 768     case TYMED_HGLOBAL:
 769         TRACE("TYMED_HGLOBAL\n");
 770         pBuffer = HGLOBAL_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hGlobal);
 771         break;
 772     case TYMED_FILE:
 773         FIXME("TYMED_FILE\n");
 774         break;
 775     case TYMED_ISTREAM:
 776         FIXME("TYMED_ISTREAM\n");
 777         break;
 778     case TYMED_ISTORAGE:
 779         FIXME("TYMED_ISTORAGE\n");
 780         break;
 781     case TYMED_GDI:
 782         FIXME("TYMED_GDI\n");
 783         break;
 784     case TYMED_MFPICT:
 785         FIXME("TYMED_MFPICT\n");
 786         break;
 787     case TYMED_ENHMF:
 788         TRACE("TYMED_ENHMF\n");
 789         pBuffer = HENHMETAFILE_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hEnhMetaFile);
 790         break;
 791     default:
 792         RaiseException(DV_E_TYMED, 0, 0, NULL);
 793     }
 794
 795     pStgMedium->pUnkForRelease = NULL;
 796     if (releaseunk)
 797         FIXME("unmarshal pUnkForRelease\n");
 798
 799     return pBuffer;
 800 }
 801
 802 void __RPC_USER STGMEDIUM_UserFree(unsigned long *pFlags, STGMEDIUM *pStgMedium)
 803 {
 804     TRACE("("); dump_user_flags(pFlags); TRACE(", %p\n", pStgMedium);
 805
 806     ReleaseStgMedium(pStgMedium);
 807 }
 808
 809 unsigned long __RPC_USER ASYNC_STGMEDIUM_UserSize(unsigned long *pFlags, unsigned long StartingSize, ASYNC_STGMEDIUM *pStgMedium)
 810 {
 811     FIXME(":stub\n");
 812     return StartingSize;
 813 }
 814
 815 unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserMarshal(  unsigned long *pFlags, unsigned char *pBuffer, ASYNC_STGMEDIUM *pStgMedium)
 816 {
 817     FIXME(":stub\n");
 818     return pBuffer;
 819 }
 820
 821 unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, ASYNC_STGMEDIUM *pStgMedium)
 822 {
 823     FIXME(":stub\n");
 824     return pBuffer;
 825 }
 826
 827 void __RPC_USER ASYNC_STGMEDIUM_UserFree(unsigned long *pFlags, ASYNC_STGMEDIUM *pStgMedium)
 828 {
 829     FIXME(":stub\n");
 830 }
 831
 832 unsigned long __RPC_USER FLAG_STGMEDIUM_UserSize(unsigned long *pFlags, unsigned long StartingSize, FLAG_STGMEDIUM *pStgMedium)
 833 {
 834     FIXME(":stub\n");
 835     return StartingSize;
 836 }
 837
 838 unsigned char * __RPC_USER FLAG_STGMEDIUM_UserMarshal(  unsigned long *pFlags, unsigned char *pBuffer, FLAG_STGMEDIUM *pStgMedium)
 839 {
 840     FIXME(":stub\n");
 841     return pBuffer;
 842 }
 843
 844 unsigned char * __RPC_USER FLAG_STGMEDIUM_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, FLAG_STGMEDIUM *pStgMedium)
 845 {
 846     FIXME(":stub\n");
 847     return pBuffer;
 848 }
 849
 850 void __RPC_USER FLAG_STGMEDIUM_UserFree(unsigned long *pFlags, FLAG_STGMEDIUM *pStgMedium)
 851 {
 852     FIXME(":stub\n");
 853 }
 854
 855 unsigned long __RPC_USER SNB_UserSize(unsigned long *pFlags, unsigned long StartingSize, SNB *pSnb)
 856 {
 857     FIXME(":stub\n");
 858     return StartingSize;
 859 }
 860
 861 unsigned char * __RPC_USER SNB_UserMarshal(  unsigned long *pFlags, unsigned char *pBuffer, SNB *pSnb)
 862 {
 863     FIXME(":stub\n");
 864     return pBuffer;
 865 }
 866
 867 unsigned char * __RPC_USER SNB_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, SNB *pSnb)
 868 {
 869     FIXME(":stub\n");
 870     return pBuffer;
 871 }
 872
 873 void __RPC_USER SNB_UserFree(unsigned long *pFlags, SNB *pSnb)
 874 {
 875     FIXME(":stub\n");
 876 }