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 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "winuser.h"
  30 #include "winerror.h"
  31
  32 #include "ole2.h"
  33 #include "oleauto.h"
  34 #include "rpcproxy.h"
  35
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  39
  40 #define ALIGNED_LENGTH(_Len, _Align) (((_Len)+(_Align))&~(_Align))
  41 #define ALIGNED_POINTER(_Ptr, _Align) ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
  42 #define ALIGN_LENGTH(_Len, _Align) _Len = ALIGNED_LENGTH(_Len, _Align)
  43 #define ALIGN_POINTER(_Ptr, _Align) _Ptr = ALIGNED_POINTER(_Ptr, _Align)
  44
  45 #define USER_MARSHAL_PTR_PREFIX \
  46   ( (DWORD)'U'         | ( (DWORD)'s' << 8 ) | \
  47   ( (DWORD)'e' << 16 ) | ( (DWORD)'r' << 24 ) )
  48
  49 ULONG __RPC_USER WdtpInterfacePointer_UserSize(ULONG *pFlags, ULONG RealFlags, ULONG StartingSize, IUnknown *punk, REFIID riid);
  50 unsigned char * WINAPI WdtpInterfacePointer_UserMarshal(ULONG *pFlags, ULONG RealFlags, unsigned char *pBuffer,
  51         IUnknown *punk, REFIID riid);
  52 unsigned char * WINAPI WdtpInterfacePointer_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, IUnknown **ppunk, REFIID riid);
  53
  54 static const char* debugstr_user_flags(ULONG *pFlags)
  55 {
  56     char buf[12];
  57     const char* loword;
  58     switch (LOWORD(*pFlags))
  59     {
  60     case MSHCTX_LOCAL:
  61         loword="MSHCTX_LOCAL";
  62         break;
  63     case MSHCTX_NOSHAREDMEM:
  64         loword="MSHCTX_NOSHAREDMEM";
  65         break;
  66     case MSHCTX_DIFFERENTMACHINE:
  67         loword="MSHCTX_DIFFERENTMACHINE";
  68         break;
  69     case MSHCTX_INPROC:
  70         loword="MSHCTX_INPROC";
  71         break;
  72     default:
  73         sprintf(buf, "%d", LOWORD(*pFlags));
  74         loword=buf;
  75     }
  76
  77     if (HIWORD(*pFlags) == NDR_LOCAL_DATA_REPRESENTATION)
  78         return wine_dbg_sprintf("MAKELONG(%s, NDR_LOCAL_DATA_REPRESENTATION)", loword);
  79     else
  80         return wine_dbg_sprintf("MAKELONG(%s, 0x%04x)", loword, HIWORD(*pFlags));
  81 }
  82
  83 /******************************************************************************
  84  *           HMETAFILE_UserSize [OLE32.@]
  85  *
  86  * Calculates the buffer size required to marshal a metafile.
  87  *
  88  * PARAMS
  89  *  pFlags       [I] Flags. See notes.
  90  *  StartingSize [I] Starting size of the buffer. This value is added on to
  91  *                   the buffer size required for the clip format.
  92  *  phmf         [I] Metafile to size.
  93  *
  94  * RETURNS
  95  *  The buffer size required to marshal a metafile plus the starting size.
  96  *
  97  * NOTES
  98  *  Even though the function is documented to take a pointer to a ULONG in
  99  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 100  *  the first parameter is a ULONG.
 101  *  This function is only intended to be called by the RPC runtime.
 102  */
 103 ULONG __RPC_USER HMETAFILE_UserSize(ULONG *pFlags, ULONG StartingSize, HMETAFILE *phmf)
 104 {
 105     ULONG size = StartingSize;
 106
 107     TRACE("%s, %lu, &%p.\n", debugstr_user_flags(pFlags), StartingSize, *phmf);
 108
 109     ALIGN_LENGTH(size, 3);
 110
 111     size += sizeof(ULONG);
 112     if (LOWORD(*pFlags) == MSHCTX_INPROC)
 113         size += sizeof(ULONG_PTR);
 114     else
 115     {
 116         size += sizeof(ULONG);
 117
 118         if (*phmf)
 119         {
 120             UINT mfsize;
 121
 122             size += 2 * sizeof(ULONG);
 123             mfsize = GetMetaFileBitsEx(*phmf, 0, NULL);
 124             size += mfsize;
 125         }
 126     }
 127
 128     return size;
 129 }
 130
 131 /******************************************************************************
 132  *           HMETAFILE_UserMarshal [OLE32.@]
 133  *
 134  * Marshals a metafile into a buffer.
 135  *
 136  * PARAMS
 137  *  pFlags  [I] Flags. See notes.
 138  *  pBuffer [I] Buffer to marshal the clip format into.
 139  *  phEmf   [I] Metafile to marshal.
 140  *
 141  * RETURNS
 142  *  The end of the marshaled data in the buffer.
 143  *
 144  * NOTES
 145  *  Even though the function is documented to take a pointer to a ULONG in
 146  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 147  *  the first parameter is a ULONG.
 148  *  This function is only intended to be called by the RPC runtime.
 149  */
 150 unsigned char * __RPC_USER HMETAFILE_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILE *phmf)
 151 {
 152     TRACE("(%s, %p, &%p\n", debugstr_user_flags(pFlags), pBuffer, *phmf);
 153
 154     ALIGN_POINTER(pBuffer, 3);
 155
 156     if (LOWORD(*pFlags) == MSHCTX_INPROC)
 157     {
 158         if (sizeof(*phmf) == 8)
 159             *(ULONG *)pBuffer = WDT_INPROC64_CALL;
 160         else
 161             *(ULONG *)pBuffer = WDT_INPROC_CALL;
 162         pBuffer += sizeof(ULONG);
 163         *(HMETAFILE *)pBuffer = *phmf;
 164         pBuffer += sizeof(HMETAFILE);
 165     }
 166     else
 167     {
 168         *(ULONG *)pBuffer = WDT_REMOTE_CALL;
 169         pBuffer += sizeof(ULONG);
 170         *(ULONG *)pBuffer = (ULONG)(ULONG_PTR)*phmf;
 171         pBuffer += sizeof(ULONG);
 172
 173         if (*phmf)
 174         {
 175             UINT mfsize = GetMetaFileBitsEx(*phmf, 0, NULL);
 176
 177             *(ULONG *)pBuffer = mfsize;
 178             pBuffer += sizeof(ULONG);
 179             *(ULONG *)pBuffer = mfsize;
 180             pBuffer += sizeof(ULONG);
 181             GetMetaFileBitsEx(*phmf, mfsize, pBuffer);
 182             pBuffer += mfsize;
 183         }
 184     }
 185
 186     return pBuffer;
 187 }
 188
 189 /******************************************************************************
 190  *           HMETAFILE_UserUnmarshal [OLE32.@]
 191  *
 192  * Unmarshals a metafile from a buffer.
 193  *
 194  * PARAMS
 195  *  pFlags   [I] Flags. See notes.
 196  *  pBuffer  [I] Buffer to marshal the clip format from.
 197  *  phmf     [O] Address that receive the unmarshaled metafile.
 198  *
 199  * RETURNS
 200  *  The end of the marshaled data in the buffer.
 201  *
 202  * NOTES
 203  *  Even though the function is documented to take a pointer to an ULONG in
 204  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 205  *  the first parameter is an ULONG.
 206  *  This function is only intended to be called by the RPC runtime.
 207  */
 208 unsigned char * __RPC_USER HMETAFILE_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILE *phmf)
 209 {
 210     ULONG fContext;
 211
 212     TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, phmf);
 213
 214     ALIGN_POINTER(pBuffer, 3);
 215
 216     fContext = *(ULONG *)pBuffer;
 217     pBuffer += sizeof(ULONG);
 218
 219     if (((fContext == WDT_INPROC_CALL) && (sizeof(*phmf) < 8)) ||
 220         ((fContext == WDT_INPROC64_CALL) && (sizeof(*phmf) == 8)))
 221     {
 222         *phmf = *(HMETAFILE *)pBuffer;
 223         pBuffer += sizeof(*phmf);
 224     }
 225     else if (fContext == WDT_REMOTE_CALL)
 226     {
 227         ULONG handle;
 228
 229         handle = *(ULONG *)pBuffer;
 230         pBuffer += sizeof(ULONG);
 231
 232         if (handle)
 233         {
 234             ULONG size;
 235             size = *(ULONG *)pBuffer;
 236             pBuffer += sizeof(ULONG);
 237             if (size != *(ULONG *)pBuffer)
 238             {
 239                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
 240                 return pBuffer;
 241             }
 242             pBuffer += sizeof(ULONG);
 243             *phmf = SetMetaFileBitsEx(size, pBuffer);
 244             pBuffer += size;
 245         }
 246         else
 247             *phmf = NULL;
 248     }
 249     else
 250         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 251
 252     return pBuffer;
 253 }
 254
 255 /******************************************************************************
 256  *           HMETAFILE_UserFree [OLE32.@]
 257  *
 258  * Frees an unmarshaled metafile.
 259  *
 260  * PARAMS
 261  *  pFlags   [I] Flags. See notes.
 262  *  phmf     [I] Metafile to free.
 263  *
 264  * RETURNS
 265  *  The end of the marshaled data in the buffer.
 266  *
 267  * NOTES
 268  *  Even though the function is documented to take a pointer to a ULONG in
 269  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
 270  *  which the first parameter is a ULONG.
 271  *  This function is only intended to be called by the RPC runtime.
 272  */
 273 void __RPC_USER HMETAFILE_UserFree(ULONG *pFlags, HMETAFILE *phmf)
 274 {
 275     TRACE("(%s, &%p\n", debugstr_user_flags(pFlags), *phmf);
 276
 277     if (LOWORD(*pFlags) != MSHCTX_INPROC)
 278         DeleteMetaFile(*phmf);
 279 }
 280
 281 /******************************************************************************
 282 *           HENHMETAFILE_UserSize [OLE32.@]
 283 *
 284 * Calculates the buffer size required to marshal an enhanced metafile.
 285 *
 286 * PARAMS
 287 *  pFlags       [I] Flags. See notes.
 288 *  StartingSize [I] Starting size of the buffer. This value is added on to
 289 *                   the buffer size required for the clip format.
 290 *  phEmf        [I] Enhanced metafile to size.
 291 *
 292 * RETURNS
 293 *  The buffer size required to marshal an enhanced metafile plus the starting size.
 294 *
 295 * NOTES
 296 *  Even though the function is documented to take a pointer to a ULONG in
 297 *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 298 *  the first parameter is a ULONG.
 299 *  This function is only intended to be called by the RPC runtime.
 300 */
 301 ULONG __RPC_USER HENHMETAFILE_UserSize(ULONG *pFlags, ULONG size, HENHMETAFILE *phEmf)
 302 {
 303     TRACE("%s, %lu, %p.\n", debugstr_user_flags(pFlags), size, *phEmf);
 304
 305     ALIGN_LENGTH(size, 3);
 306
 307     size += sizeof(ULONG);
 308     if (LOWORD(*pFlags) == MSHCTX_INPROC)
 309         size += sizeof(ULONG_PTR);
 310     else
 311     {
 312         size += sizeof(ULONG);
 313
 314         if (*phEmf)
 315         {
 316             UINT emfsize;
 317
 318             size += 2 * sizeof(ULONG);
 319             emfsize = GetEnhMetaFileBits(*phEmf, 0, NULL);
 320             size += emfsize;
 321         }
 322     }
 323
 324     return size;
 325 }
 326
 327 /******************************************************************************
 328  *           HENHMETAFILE_UserMarshal [OLE32.@]
 329  *
 330  * Marshals an enhance metafile into a buffer.
 331  *
 332  * PARAMS
 333  *  pFlags  [I] Flags. See notes.
 334  *  pBuffer [I] Buffer to marshal the clip format into.
 335  *  phEmf   [I] Enhanced metafile to marshal.
 336  *
 337  * RETURNS
 338  *  The end of the marshaled data in the buffer.
 339  *
 340  * NOTES
 341  *  Even though the function is documented to take a pointer to a ULONG in
 342  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 343  *  the first parameter is a ULONG.
 344  *  This function is only intended to be called by the RPC runtime.
 345  */
 346 unsigned char * __RPC_USER HENHMETAFILE_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
 347 {
 348     TRACE("(%s, %p, &%p\n", debugstr_user_flags(pFlags), pBuffer, *phEmf);
 349
 350     ALIGN_POINTER(pBuffer, 3);
 351
 352     if (LOWORD(*pFlags) == MSHCTX_INPROC)
 353     {
 354         if (sizeof(*phEmf) == 8)
 355             *(ULONG *)pBuffer = WDT_INPROC64_CALL;
 356         else
 357             *(ULONG *)pBuffer = WDT_INPROC_CALL;
 358         pBuffer += sizeof(ULONG);
 359         *(HENHMETAFILE *)pBuffer = *phEmf;
 360         pBuffer += sizeof(HENHMETAFILE);
 361     }
 362     else
 363     {
 364         *(ULONG *)pBuffer = WDT_REMOTE_CALL;
 365         pBuffer += sizeof(ULONG);
 366         *(ULONG *)pBuffer = (ULONG)(ULONG_PTR)*phEmf;
 367         pBuffer += sizeof(ULONG);
 368
 369         if (*phEmf)
 370         {
 371             UINT emfsize = GetEnhMetaFileBits(*phEmf, 0, NULL);
 372
 373             *(ULONG *)pBuffer = emfsize;
 374             pBuffer += sizeof(ULONG);
 375             *(ULONG *)pBuffer = emfsize;
 376             pBuffer += sizeof(ULONG);
 377             GetEnhMetaFileBits(*phEmf, emfsize, pBuffer);
 378             pBuffer += emfsize;
 379         }
 380     }
 381
 382     return pBuffer;
 383 }
 384
 385 /******************************************************************************
 386  *           HENHMETAFILE_UserUnmarshal [OLE32.@]
 387  *
 388  * Unmarshals an enhanced metafile from a buffer.
 389  *
 390  * PARAMS
 391  *  pFlags   [I] Flags. See notes.
 392  *  pBuffer  [I] Buffer to marshal the clip format from.
 393  *  phEmf    [O] Address that receive the unmarshaled enhanced metafile.
 394  *
 395  * RETURNS
 396  *  The end of the marshaled data in the buffer.
 397  *
 398  * NOTES
 399  *  Even though the function is documented to take a pointer to an ULONG in
 400  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 401  *  the first parameter is an ULONG.
 402  *  This function is only intended to be called by the RPC runtime.
 403  */
 404 unsigned char * __RPC_USER HENHMETAFILE_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
 405 {
 406     ULONG fContext;
 407
 408     TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, phEmf);
 409
 410     ALIGN_POINTER(pBuffer, 3);
 411
 412     fContext = *(ULONG *)pBuffer;
 413     pBuffer += sizeof(ULONG);
 414
 415     if (((fContext == WDT_INPROC_CALL) && (sizeof(*phEmf) < 8)) ||
 416         ((fContext == WDT_INPROC64_CALL) && (sizeof(*phEmf) == 8)))
 417     {
 418         *phEmf = *(HENHMETAFILE *)pBuffer;
 419         pBuffer += sizeof(*phEmf);
 420     }
 421     else if (fContext == WDT_REMOTE_CALL)
 422     {
 423         ULONG handle;
 424
 425         handle = *(ULONG *)pBuffer;
 426         pBuffer += sizeof(ULONG);
 427
 428         if (handle)
 429         {
 430             ULONG size;
 431             size = *(ULONG *)pBuffer;
 432             pBuffer += sizeof(ULONG);
 433             if (size != *(ULONG *)pBuffer)
 434             {
 435                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
 436                 return pBuffer;
 437             }
 438             pBuffer += sizeof(ULONG);
 439             *phEmf = SetEnhMetaFileBits(size, pBuffer);
 440             pBuffer += size;
 441         }
 442         else
 443             *phEmf = NULL;
 444     }
 445     else
 446         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
 447
 448     return pBuffer;
 449 }
 450
 451 /******************************************************************************
 452  *           HENHMETAFILE_UserFree [OLE32.@]
 453  *
 454  * Frees an unmarshaled enhanced metafile.
 455  *
 456  * PARAMS
 457  *  pFlags   [I] Flags. See notes.
 458  *  phEmf    [I] Enhanced metafile to free.
 459  *
 460  * RETURNS
 461  *  The end of the marshaled data in the buffer.
 462  *
 463  * NOTES
 464  *  Even though the function is documented to take a pointer to a ULONG in
 465  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
 466  *  which the first parameter is a ULONG.
 467  *  This function is only intended to be called by the RPC runtime.
 468  */
 469 void __RPC_USER HENHMETAFILE_UserFree(ULONG *pFlags, HENHMETAFILE *phEmf)
 470 {
 471     TRACE("(%s, &%p\n", debugstr_user_flags(pFlags), *phEmf);
 472
 473     if (LOWORD(*pFlags) != MSHCTX_INPROC)
 474         DeleteEnhMetaFile(*phEmf);
 475 }
 476
 477 /******************************************************************************
 478  *           HMETAFILEPICT_UserSize [OLE32.@]
 479  *
 480  * Calculates the buffer size required to marshal an metafile pict.
 481  *
 482  * PARAMS
 483  *  pFlags       [I] Flags. See notes.
 484  *  StartingSize [I] Starting size of the buffer. This value is added on to
 485  *                   the buffer size required for the clip format.
 486  *  phMfp        [I] Metafile pict to size.
 487  *
 488  * RETURNS
 489  *  The buffer size required to marshal a metafile pict plus the starting size.
 490  *
 491  * NOTES
 492  *  Even though the function is documented to take a pointer to a ULONG in
 493  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 494  *  the first parameter is a ULONG.
 495  *  This function is only intended to be called by the RPC runtime.
 496  */
 497 ULONG __RPC_USER HMETAFILEPICT_UserSize(ULONG *pFlags, ULONG size, HMETAFILEPICT *phMfp)
 498 {
 499     TRACE("%s, %lu, &%p.\n", debugstr_user_flags(pFlags), size, *phMfp);
 500
 501     ALIGN_LENGTH(size, 3);
 502
 503     size += sizeof(ULONG);
 504
 505     if(LOWORD(*pFlags) == MSHCTX_INPROC)
 506         size += sizeof(HMETAFILEPICT);
 507     else
 508     {
 509         size += sizeof(ULONG);
 510
 511         if (*phMfp)
 512         {
 513             METAFILEPICT *mfpict = GlobalLock(*phMfp);
 514
 515             /* FIXME: raise an exception if mfpict is NULL? */
 516             size += 3 * sizeof(ULONG);
 517             size += sizeof(ULONG);
 518
 519             size = HMETAFILE_UserSize(pFlags, size, &mfpict->hMF);
 520
 521             GlobalUnlock(*phMfp);
 522         }
 523     }
 524
 525     return size;
 526 }
 527
 528 /******************************************************************************
 529  *           HMETAFILEPICT_UserMarshal [OLE32.@]
 530  *
 531  * Marshals a metafile pict into a buffer.
 532  *
 533  * PARAMS
 534  *  pFlags  [I] Flags. See notes.
 535  *  pBuffer [I] Buffer to marshal the clip format into.
 536  *  phMfp   [I] Metafile pict to marshal.
 537  *
 538  * RETURNS
 539  *  The end of the marshaled data in the buffer.
 540  *
 541  * NOTES
 542  *  Even though the function is documented to take a pointer to a ULONG in
 543  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 544  *  the first parameter is a ULONG.
 545  *  This function is only intended to be called by the RPC runtime.
 546  */
 547 unsigned char * __RPC_USER HMETAFILEPICT_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILEPICT *phMfp)
 548 {
 549     TRACE("(%s, %p, &%p)\n", debugstr_user_flags(pFlags), pBuffer, *phMfp);
 550
 551     ALIGN_POINTER(pBuffer, 3);
 552
 553     if (LOWORD(*pFlags) == MSHCTX_INPROC)
 554     {
 555         if (sizeof(HMETAFILEPICT) == 8)
 556             *(ULONG *)pBuffer = WDT_INPROC64_CALL;
 557         else
 558             *(ULONG *)pBuffer = WDT_INPROC_CALL;
 559         pBuffer += sizeof(ULONG);
 560         *(HMETAFILEPICT *)pBuffer = *phMfp;
 561         pBuffer += sizeof(HMETAFILEPICT);
 562     }
 563     else
 564     {
 565         *(ULONG *)pBuffer = WDT_REMOTE_CALL;
 566         pBuffer += sizeof(ULONG);
 567         *(ULONG *)pBuffer = (ULONG)(ULONG_PTR)*phMfp;
 568         pBuffer += sizeof(ULONG);
 569
 570         if (*phMfp)
 571         {
 572             METAFILEPICT *mfpict = GlobalLock(*phMfp);
 573             remoteMETAFILEPICT * remmfpict = (remoteMETAFILEPICT *)pBuffer;
 574
 575             /* FIXME: raise an exception if mfpict is NULL? */
 576             remmfpict->mm = mfpict->mm;
 577             remmfpict->xExt = mfpict->xExt;
 578             remmfpict->yExt = mfpict->yExt;
 579             pBuffer += 3 * sizeof(ULONG);
 580             *(ULONG *)pBuffer = USER_MARSHAL_PTR_PREFIX;
 581             pBuffer += sizeof(ULONG);
 582
 583             pBuffer = HMETAFILE_UserMarshal(pFlags, pBuffer, &mfpict->hMF);
 584
 585             GlobalUnlock(*phMfp);
 586         }
 587     }
 588     return pBuffer;
 589 }
 590
 591 /******************************************************************************
 592  *           HMETAFILEPICT_UserUnmarshal [OLE32.@]
 593  *
 594  * Unmarshals an metafile pict from a buffer.
 595  *
 596  * PARAMS
 597  *  pFlags   [I] Flags. See notes.
 598  *  pBuffer  [I] Buffer to marshal the clip format from.
 599  *  phMfp    [O] Address that receive the unmarshaled metafile pict.
 600  *
 601  * RETURNS
 602  *  The end of the marshaled data in the buffer.
 603  *
 604  * NOTES
 605  *  Even though the function is documented to take a pointer to an ULONG in
 606  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 607  *  the first parameter is an ULONG.
 608  *  This function is only intended to be called by the RPC runtime.
 609  */
 610 unsigned char * __RPC_USER HMETAFILEPICT_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILEPICT *phMfp)
 611 {
 612     ULONG fContext;
 613
 614     TRACE("(%s, %p, %p)\n", debugstr_user_flags(pFlags), pBuffer, phMfp);
 615
 616     ALIGN_POINTER(pBuffer, 3);
 617
 618     fContext = *(ULONG *)pBuffer;
 619     pBuffer += sizeof(ULONG);
 620
 621     if ((fContext == WDT_INPROC_CALL) || fContext == WDT_INPROC64_CALL)
 622     {
 623         *phMfp = *(HMETAFILEPICT *)pBuffer;
 624         pBuffer += sizeof(HMETAFILEPICT);
 625     }
 626     else
 627     {
 628         ULONG handle = *(ULONG *)pBuffer;
 629         pBuffer += sizeof(ULONG);
 630         *phMfp = NULL;
 631
 632         if(handle)
 633         {
 634             METAFILEPICT *mfpict;
 635             const remoteMETAFILEPICT *remmfpict;
 636             ULONG user_marshal_prefix;
 637
 638             remmfpict = (const remoteMETAFILEPICT *)pBuffer;
 639
 640             *phMfp = GlobalAlloc(GMEM_MOVEABLE, sizeof(METAFILEPICT));
 641             if (!*phMfp)
 642                 RpcRaiseException(E_OUTOFMEMORY);
 643
 644             mfpict = GlobalLock(*phMfp);
 645             mfpict->mm = remmfpict->mm;
 646             mfpict->xExt = remmfpict->xExt;
 647             mfpict->yExt = remmfpict->yExt;
 648             pBuffer += 3 * sizeof(ULONG);
 649             user_marshal_prefix = *(ULONG *)pBuffer;
 650             pBuffer += sizeof(ULONG);
 651
 652             if (user_marshal_prefix != USER_MARSHAL_PTR_PREFIX)
 653                 RpcRaiseException(RPC_X_INVALID_TAG);
 654
 655             pBuffer = HMETAFILE_UserUnmarshal(pFlags, pBuffer, &mfpict->hMF);
 656
 657             GlobalUnlock(*phMfp);
 658         }
 659     }
 660     return pBuffer;
 661 }
 662
 663 /******************************************************************************
 664  *           HMETAFILEPICT_UserFree [OLE32.@]
 665  *
 666  * Frees an unmarshaled metafile pict.
 667  *
 668  * PARAMS
 669  *  pFlags   [I] Flags. See notes.
 670  *  phMfp    [I] Metafile pict to free.
 671  *
 672  * RETURNS
 673  *  The end of the marshaled data in the buffer.
 674  *
 675  * NOTES
 676  *  Even though the function is documented to take a pointer to a ULONG in
 677  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
 678  *  which the first parameter is a ULONG.
 679  *  This function is only intended to be called by the RPC runtime.
 680  */
 681 void __RPC_USER HMETAFILEPICT_UserFree(ULONG *pFlags, HMETAFILEPICT *phMfp)
 682 {
 683     TRACE("(%s, &%p)\n", debugstr_user_flags(pFlags), *phMfp);
 684
 685     if ((LOWORD(*pFlags) != MSHCTX_INPROC) && *phMfp)
 686     {
 687         METAFILEPICT *mfpict;
 688
 689         mfpict = GlobalLock(*phMfp);
 690         /* FIXME: raise an exception if mfpict is NULL? */
 691         HMETAFILE_UserFree(pFlags, &mfpict->hMF);
 692         GlobalUnlock(*phMfp);
 693
 694         GlobalFree(*phMfp);
 695     }
 696 }
 697
 698 /******************************************************************************
 699 *           STGMEDIUM_UserSize [OLE32.@]
 700 *
 701 * Calculates the buffer size required to marshal an STGMEDIUM.
 702 *
 703 * PARAMS
 704 *  pFlags       [I] Flags. See notes.
 705 *  StartingSize [I] Starting size of the buffer. This value is added on to
 706 *                   the buffer size required for the clip format.
 707 *  pStgMedium   [I] STGMEDIUM to size.
 708 *
 709 * RETURNS
 710 *  The buffer size required to marshal an STGMEDIUM plus the starting size.
 711 *
 712 * NOTES
 713 *  Even though the function is documented to take a pointer to a ULONG in
 714 *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 715 *  the first parameter is a ULONG.
 716 *  This function is only intended to be called by the RPC runtime.
 717 */
 718 ULONG __RPC_USER STGMEDIUM_UserSize(ULONG *pFlags, ULONG StartingSize, STGMEDIUM *pStgMedium)
 719 {
 720     ULONG size = StartingSize;
 721
 722     TRACE("%s, %lu, %p.\n", debugstr_user_flags(pFlags), StartingSize, pStgMedium);
 723
 724     ALIGN_LENGTH(size, 3);
 725
 726     size += 2 * sizeof(DWORD);
 727     if (pStgMedium->tymed != TYMED_NULL)
 728         size += sizeof(DWORD);
 729
 730     switch (pStgMedium->tymed)
 731     {
 732     case TYMED_NULL:
 733         TRACE("TYMED_NULL\n");
 734         break;
 735     case TYMED_HGLOBAL:
 736         TRACE("TYMED_HGLOBAL\n");
 737         if (pStgMedium->hGlobal)
 738             size = HGLOBAL_UserSize(pFlags, size, &pStgMedium->hGlobal);
 739         break;
 740     case TYMED_FILE:
 741         TRACE("TYMED_FILE\n");
 742         if (pStgMedium->lpszFileName)
 743         {
 744             TRACE("file name is %s\n", debugstr_w(pStgMedium->lpszFileName));
 745             size += 3 * sizeof(DWORD) +
 746                 (lstrlenW(pStgMedium->lpszFileName) + 1) * sizeof(WCHAR);
 747         }
 748         break;
 749     case TYMED_ISTREAM:
 750         TRACE("TYMED_ISTREAM\n");
 751         if (pStgMedium->pstm)
 752         {
 753             IUnknown *unk;
 754             IStream_QueryInterface(pStgMedium->pstm, &IID_IUnknown, (void**)&unk);
 755             size = WdtpInterfacePointer_UserSize(pFlags, LOWORD(*pFlags), size, unk, &IID_IStream);
 756             IUnknown_Release(unk);
 757         }
 758         break;
 759     case TYMED_ISTORAGE:
 760         TRACE("TYMED_ISTORAGE\n");
 761         if (pStgMedium->pstg)
 762         {
 763             IUnknown *unk;
 764             IStorage_QueryInterface(pStgMedium->pstg, &IID_IUnknown, (void**)&unk);
 765             size = WdtpInterfacePointer_UserSize(pFlags, LOWORD(*pFlags), size, unk, &IID_IStorage);
 766             IUnknown_Release(unk);
 767         }
 768         break;
 769     case TYMED_GDI:
 770         TRACE("TYMED_GDI\n");
 771         if (pStgMedium->hBitmap)
 772             size = HBITMAP_UserSize(pFlags, size, &pStgMedium->hBitmap);
 773         break;
 774     case TYMED_MFPICT:
 775         TRACE("TYMED_MFPICT\n");
 776         if (pStgMedium->hMetaFilePict)
 777             size = HMETAFILEPICT_UserSize(pFlags, size, &pStgMedium->hMetaFilePict);
 778         break;
 779     case TYMED_ENHMF:
 780         TRACE("TYMED_ENHMF\n");
 781         if (pStgMedium->hEnhMetaFile)
 782             size = HENHMETAFILE_UserSize(pFlags, size, &pStgMedium->hEnhMetaFile);
 783         break;
 784     default:
 785         RaiseException(DV_E_TYMED, 0, 0, NULL);
 786     }
 787
 788     if (pStgMedium->pUnkForRelease)
 789         size = WdtpInterfacePointer_UserSize(pFlags, LOWORD(*pFlags), size, pStgMedium->pUnkForRelease, &IID_IUnknown);
 790
 791     return size;
 792 }
 793
 794 /******************************************************************************
 795  *           STGMEDIUM_UserMarshal [OLE32.@]
 796  *
 797  * Marshals a STGMEDIUM into a buffer.
 798  *
 799  * PARAMS
 800  *  pFlags  [I] Flags. See notes.
 801  *  pBuffer [I] Buffer to marshal the clip format into.
 802  *  pCF     [I] STGMEDIUM to marshal.
 803  *
 804  * RETURNS
 805  *  The end of the marshaled data in the buffer.
 806  *
 807  * NOTES
 808  *  Even though the function is documented to take a pointer to a ULONG in
 809  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 810  *  the first parameter is a ULONG.
 811  *  This function is only intended to be called by the RPC runtime.
 812  */
 813 unsigned char * __RPC_USER STGMEDIUM_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
 814 {
 815     TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, pStgMedium);
 816
 817     ALIGN_POINTER(pBuffer, 3);
 818
 819     *(DWORD *)pBuffer = pStgMedium->tymed;
 820     pBuffer += sizeof(DWORD);
 821     if (pStgMedium->tymed != TYMED_NULL)
 822     {
 823         *(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->pstg;
 824         pBuffer += sizeof(DWORD);
 825     }
 826     *(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->pUnkForRelease;
 827     pBuffer += sizeof(DWORD);
 828
 829     switch (pStgMedium->tymed)
 830     {
 831     case TYMED_NULL:
 832         TRACE("TYMED_NULL\n");
 833         break;
 834     case TYMED_HGLOBAL:
 835         TRACE("TYMED_HGLOBAL\n");
 836         if (pStgMedium->hGlobal)
 837             pBuffer = HGLOBAL_UserMarshal(pFlags, pBuffer, &pStgMedium->hGlobal);
 838         break;
 839     case TYMED_FILE:
 840         TRACE("TYMED_FILE\n");
 841         if (pStgMedium->lpszFileName)
 842         {
 843             DWORD len;
 844             len = lstrlenW(pStgMedium->lpszFileName);
 845             /* conformance */
 846             *(DWORD *)pBuffer = len + 1;
 847             pBuffer += sizeof(DWORD);
 848             /* offset */
 849             *(DWORD *)pBuffer = 0;
 850             pBuffer += sizeof(DWORD);
 851             /* variance */
 852             *(DWORD *)pBuffer = len + 1;
 853             pBuffer += sizeof(DWORD);
 854
 855             TRACE("file name is %s\n", debugstr_w(pStgMedium->lpszFileName));
 856             memcpy(pBuffer, pStgMedium->lpszFileName, (len + 1) * sizeof(WCHAR));
 857         }
 858         break;
 859     case TYMED_ISTREAM:
 860         TRACE("TYMED_ISTREAM\n");
 861         if (pStgMedium->pstm)
 862         {
 863             IUnknown *unk;
 864             IStream_QueryInterface(pStgMedium->pstm, &IID_IUnknown, (void**)&unk);
 865             pBuffer = WdtpInterfacePointer_UserMarshal(pFlags, LOWORD(*pFlags), pBuffer, unk, &IID_IStream);
 866             IUnknown_Release(unk);
 867         }
 868         break;
 869     case TYMED_ISTORAGE:
 870         TRACE("TYMED_ISTORAGE\n");
 871         if (pStgMedium->pstg)
 872         {
 873             IUnknown *unk;
 874             IStorage_QueryInterface(pStgMedium->pstg, &IID_IUnknown, (void**)&unk);
 875             pBuffer = WdtpInterfacePointer_UserMarshal(pFlags, LOWORD(*pFlags), pBuffer, unk, &IID_IStorage);
 876             IUnknown_Release(unk);
 877         }
 878         break;
 879     case TYMED_GDI:
 880         TRACE("TYMED_GDI\n");
 881         if (pStgMedium->hBitmap)
 882             pBuffer = HBITMAP_UserMarshal(pFlags, pBuffer, &pStgMedium->hBitmap);
 883         break;
 884     case TYMED_MFPICT:
 885         TRACE("TYMED_MFPICT\n");
 886         if (pStgMedium->hMetaFilePict)
 887             pBuffer = HMETAFILEPICT_UserMarshal(pFlags, pBuffer, &pStgMedium->hMetaFilePict);
 888         break;
 889     case TYMED_ENHMF:
 890         TRACE("TYMED_ENHMF\n");
 891         if (pStgMedium->hEnhMetaFile)
 892             pBuffer = HENHMETAFILE_UserMarshal(pFlags, pBuffer, &pStgMedium->hEnhMetaFile);
 893         break;
 894     default:
 895         RaiseException(DV_E_TYMED, 0, 0, NULL);
 896     }
 897
 898     if (pStgMedium->pUnkForRelease)
 899         pBuffer = WdtpInterfacePointer_UserMarshal(pFlags, LOWORD(*pFlags), pBuffer, pStgMedium->pUnkForRelease, &IID_IUnknown);
 900
 901     return pBuffer;
 902 }
 903
 904 /******************************************************************************
 905  *           STGMEDIUM_UserUnmarshal [OLE32.@]
 906  *
 907  * Unmarshals a STGMEDIUM from a buffer.
 908  *
 909  * PARAMS
 910  *  pFlags     [I] Flags. See notes.
 911  *  pBuffer    [I] Buffer to marshal the clip format from.
 912  *  pStgMedium [O] Address that receive the unmarshaled STGMEDIUM.
 913  *
 914  * RETURNS
 915  *  The end of the marshaled data in the buffer.
 916  *
 917  * NOTES
 918  *  Even though the function is documented to take a pointer to an ULONG in
 919  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
 920  *  the first parameter is an ULONG.
 921  *  This function is only intended to be called by the RPC runtime.
 922  */
 923 unsigned char * __RPC_USER STGMEDIUM_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
 924 {
 925     DWORD content = 0;
 926     DWORD releaseunk;
 927
 928     ALIGN_POINTER(pBuffer, 3);
 929
 930     TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, pStgMedium);
 931
 932     pStgMedium->tymed = *(DWORD *)pBuffer;
 933     pBuffer += sizeof(DWORD);
 934     if (pStgMedium->tymed != TYMED_NULL)
 935     {
 936         content = *(DWORD *)pBuffer;
 937         pBuffer += sizeof(DWORD);
 938     }
 939     releaseunk = *(DWORD *)pBuffer;
 940     pBuffer += sizeof(DWORD);
 941
 942     switch (pStgMedium->tymed)
 943     {
 944     case TYMED_NULL:
 945         TRACE("TYMED_NULL\n");
 946         break;
 947     case TYMED_HGLOBAL:
 948         TRACE("TYMED_HGLOBAL\n");
 949         if (content)
 950             pBuffer = HGLOBAL_UserUnmarshal(pFlags, pBuffer, &pStgMedium->hGlobal);
 951         break;
 952     case TYMED_FILE:
 953         TRACE("TYMED_FILE\n");
 954         if (content)
 955         {
 956             DWORD conformance;
 957             DWORD variance;
 958             conformance = *(DWORD *)pBuffer;
 959             pBuffer += sizeof(DWORD);
 960             if (*(DWORD *)pBuffer != 0)
 961             {
 962                 ERR("invalid offset %ld\n", *(DWORD *)pBuffer);
 963                 RpcRaiseException(RPC_S_INVALID_BOUND);
 964                 return NULL;
 965             }
 966             pBuffer += sizeof(DWORD);
 967             variance = *(DWORD *)pBuffer;
 968             pBuffer += sizeof(DWORD);
 969             if (conformance != variance)
 970             {
 971                 ERR("conformance (%ld) and variance (%ld) should be equal\n", conformance, variance);
 972                 RpcRaiseException(RPC_S_INVALID_BOUND);
 973                 return NULL;
 974             }
 975             if (conformance > 0x7fffffff)
 976             {
 977                 ERR("conformance %#lx too large\n", conformance);
 978                 RpcRaiseException(RPC_S_INVALID_BOUND);
 979                 return NULL;
 980             }
 981             pStgMedium->lpszFileName = CoTaskMemAlloc(conformance * sizeof(WCHAR));
 982             if (!pStgMedium->lpszFileName) RpcRaiseException(ERROR_OUTOFMEMORY);
 983             TRACE("unmarshalled file name is %s\n", debugstr_wn((const WCHAR *)pBuffer, variance));
 984             memcpy(pStgMedium->lpszFileName, pBuffer, variance * sizeof(WCHAR));
 985             pBuffer += variance * sizeof(WCHAR);
 986         }
 987         else
 988             pStgMedium->lpszFileName = NULL;
 989         break;
 990     case TYMED_ISTREAM:
 991         TRACE("TYMED_ISTREAM\n");
 992         if (content)
 993         {
 994             pBuffer = WdtpInterfacePointer_UserUnmarshal(pFlags, pBuffer, (IUnknown**)&pStgMedium->pstm, &IID_IStream);
 995         }
 996         else
 997         {
 998             if (pStgMedium->pstm) IStream_Release( pStgMedium->pstm );
 999             pStgMedium->pstm = NULL;
1000         }
1001         break;
1002     case TYMED_ISTORAGE:
1003         TRACE("TYMED_ISTORAGE\n");
1004         if (content)
1005         {
1006             pBuffer = WdtpInterfacePointer_UserUnmarshal(pFlags, pBuffer, (IUnknown**)&pStgMedium->pstg, &IID_IStorage);
1007         }
1008         else
1009         {
1010             if (pStgMedium->pstg) IStorage_Release( pStgMedium->pstg );
1011             pStgMedium->pstg = NULL;
1012         }
1013         break;
1014     case TYMED_GDI:
1015         TRACE("TYMED_GDI\n");
1016         if (content)
1017             pBuffer = HBITMAP_UserUnmarshal(pFlags, pBuffer, &pStgMedium->hBitmap);
1018         else
1019             pStgMedium->hBitmap = NULL;
1020         break;
1021     case TYMED_MFPICT:
1022         TRACE("TYMED_MFPICT\n");
1023         if (content)
1024             pBuffer = HMETAFILEPICT_UserUnmarshal(pFlags, pBuffer, &pStgMedium->hMetaFilePict);
1025         else
1026             pStgMedium->hMetaFilePict = NULL;
1027         break;
1028     case TYMED_ENHMF:
1029         TRACE("TYMED_ENHMF\n");
1030         if (content)
1031             pBuffer = HENHMETAFILE_UserUnmarshal(pFlags, pBuffer, &pStgMedium->hEnhMetaFile);
1032         else
1033             pStgMedium->hEnhMetaFile = NULL;
1034         break;
1035     default:
1036         RaiseException(DV_E_TYMED, 0, 0, NULL);
1037     }
1038
1039     if (releaseunk)
1040         pBuffer = WdtpInterfacePointer_UserUnmarshal(pFlags, pBuffer, &pStgMedium->pUnkForRelease, &IID_IUnknown);
1041     /* Unlike the IStream / IStorage ifaces, the existing pUnkForRelease
1042        is left intact if a NULL ptr is unmarshalled - see the tests. */
1043
1044     return pBuffer;
1045 }
1046
1047 /******************************************************************************
1048  *           STGMEDIUM_UserFree [OLE32.@]
1049  *
1050  * Frees an unmarshaled STGMEDIUM.
1051  *
1052  * PARAMS
1053  *  pFlags     [I] Flags. See notes.
1054  *  pStgmedium [I] STGMEDIUM to free.
1055  *
1056  * RETURNS
1057  *  The end of the marshaled data in the buffer.
1058  *
1059  * NOTES
1060  *  Even though the function is documented to take a pointer to a ULONG in
1061  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
1062  *  which the first parameter is a ULONG.
1063  *  This function is only intended to be called by the RPC runtime.
1064  */
1065 void __RPC_USER STGMEDIUM_UserFree(ULONG *flags, STGMEDIUM *med)
1066 {
1067     TRACE("(%s, %p)\n", debugstr_user_flags(flags), med);
1068
1069     switch (med->tymed)
1070     {
1071     case TYMED_NULL:
1072     case TYMED_FILE:
1073     case TYMED_ISTREAM:
1074     case TYMED_ISTORAGE:
1075         ReleaseStgMedium(med);
1076         break;
1077     case TYMED_HGLOBAL:
1078     case TYMED_GDI:
1079     case TYMED_MFPICT:
1080     case TYMED_ENHMF:
1081         if (LOWORD(*flags) == MSHCTX_INPROC)
1082             med->tymed = TYMED_NULL;
1083         ReleaseStgMedium(med);
1084         break;
1085     default:
1086         RaiseException(DV_E_TYMED, 0, 0, NULL);
1087     }
1088 }
1089
1090 ULONG __RPC_USER ASYNC_STGMEDIUM_UserSize(ULONG *pFlags, ULONG StartingSize, ASYNC_STGMEDIUM *pStgMedium)
1091 {
1092     TRACE("\n");
1093     return STGMEDIUM_UserSize(pFlags, StartingSize, pStgMedium);
1094 }
1095
1096 unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserMarshal(  ULONG *pFlags, unsigned char *pBuffer, ASYNC_STGMEDIUM *pStgMedium)
1097 {
1098     TRACE("\n");
1099     return STGMEDIUM_UserMarshal(pFlags, pBuffer, pStgMedium);
1100 }
1101
1102 unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, ASYNC_STGMEDIUM *pStgMedium)
1103 {
1104     TRACE("\n");
1105     return STGMEDIUM_UserUnmarshal(pFlags, pBuffer, pStgMedium);
1106 }
1107
1108 void __RPC_USER ASYNC_STGMEDIUM_UserFree(ULONG *pFlags, ASYNC_STGMEDIUM *pStgMedium)
1109 {
1110     TRACE("\n");
1111     STGMEDIUM_UserFree(pFlags, pStgMedium);
1112 }
1113
1114 ULONG __RPC_USER FLAG_STGMEDIUM_UserSize(ULONG *pFlags, ULONG StartingSize, FLAG_STGMEDIUM *pStgMedium)
1115 {
1116     FIXME(":stub\n");
1117     return StartingSize;
1118 }
1119
1120 unsigned char * __RPC_USER FLAG_STGMEDIUM_UserMarshal(  ULONG *pFlags, unsigned char *pBuffer, FLAG_STGMEDIUM *pStgMedium)
1121 {
1122     FIXME(":stub\n");
1123     return pBuffer;
1124 }
1125
1126 unsigned char * __RPC_USER FLAG_STGMEDIUM_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, FLAG_STGMEDIUM *pStgMedium)
1127 {
1128     FIXME(":stub\n");
1129     return pBuffer;
1130 }
1131
1132 void __RPC_USER FLAG_STGMEDIUM_UserFree(ULONG *pFlags, FLAG_STGMEDIUM *pStgMedium)
1133 {
1134     FIXME(":stub\n");
1135 }
1136
1137 ULONG __RPC_USER SNB_UserSize(ULONG *pFlags, ULONG StartingSize, SNB *pSnb)
1138 {
1139     ULONG size = StartingSize;
1140
1141     TRACE("%s, %lu, %p.\n", debugstr_user_flags(pFlags), StartingSize, pSnb);
1142
1143     ALIGN_LENGTH(size, 3);
1144
1145     /* two counters from RemSNB header, plus one more ULONG */
1146     size += 3*sizeof(ULONG);
1147
1148     /* now actual data length */
1149     if (*pSnb)
1150     {
1151         WCHAR **ptrW = *pSnb;
1152
1153         while (*ptrW)
1154         {
1155             size += (lstrlenW(*ptrW) + 1)*sizeof(WCHAR);
1156             ptrW++;
1157         }
1158     }
1159
1160     return size;
1161 }
1162
1163 struct SNB_wire {
1164     ULONG charcnt;
1165     ULONG strcnt;
1166     ULONG datalen;
1167     WCHAR data[1];
1168 };
1169
1170 unsigned char * __RPC_USER SNB_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, SNB *pSnb)
1171 {
1172     struct SNB_wire *wire;
1173     ULONG size;
1174
1175     TRACE("(%s, %p, %p)\n", debugstr_user_flags(pFlags), pBuffer, pSnb);
1176
1177     ALIGN_POINTER(pBuffer, 3);
1178
1179     wire = (struct SNB_wire*)pBuffer;
1180     wire->charcnt = wire->strcnt = 0;
1181     size = 3*sizeof(ULONG);
1182
1183     if (*pSnb)
1184     {
1185         WCHAR **ptrW = *pSnb;
1186         WCHAR *dataW = wire->data;
1187
1188         while (*ptrW)
1189         {
1190             ULONG len = lstrlenW(*ptrW) + 1;
1191
1192             wire->strcnt++;
1193             wire->charcnt += len;
1194             memcpy(dataW, *ptrW, len*sizeof(WCHAR));
1195             dataW += len;
1196
1197             size += len*sizeof(WCHAR);
1198             ptrW++;
1199         }
1200     }
1201
1202     wire->datalen = wire->charcnt;
1203     return pBuffer + size;
1204 }
1205
1206 unsigned char * __RPC_USER SNB_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, SNB *pSnb)
1207 {
1208     USER_MARSHAL_CB *umcb = (USER_MARSHAL_CB*)pFlags;
1209     struct SNB_wire *wire;
1210
1211     TRACE("(%s, %p, %p)\n", debugstr_user_flags(pFlags), pBuffer, pSnb);
1212
1213     wire = (struct SNB_wire*)pBuffer;
1214
1215     if (*pSnb)
1216         umcb->pStubMsg->pfnFree(*pSnb);
1217
1218     if (wire->datalen == 0)
1219         *pSnb = NULL;
1220     else
1221     {
1222         WCHAR *src = wire->data, *dest;
1223         WCHAR **ptrW;
1224         ULONG i;
1225
1226         ptrW = *pSnb = umcb->pStubMsg->pfnAllocate((wire->strcnt+1)*sizeof(WCHAR*) + wire->datalen*sizeof(WCHAR));
1227         dest = (WCHAR*)(*pSnb + wire->strcnt + 1);
1228
1229         for (i = 0; i < wire->strcnt; i++)
1230         {
1231             ULONG len = lstrlenW(src);
1232             memcpy(dest, src, (len + 1)*sizeof(WCHAR));
1233             *ptrW = dest;
1234             src += len + 1;
1235             dest += len + 1;
1236             ptrW++;
1237         }
1238         *ptrW = NULL;
1239     }
1240
1241     return pBuffer + 3*sizeof(ULONG) + wire->datalen*sizeof(WCHAR);
1242 }
1243
1244 void __RPC_USER SNB_UserFree(ULONG *pFlags, SNB *pSnb)
1245 {
1246     USER_MARSHAL_CB *umcb = (USER_MARSHAL_CB*)pFlags;
1247     TRACE("(%p)\n", pSnb);
1248     if (*pSnb)
1249         umcb->pStubMsg->pfnFree(*pSnb);
1250 }
1251
1252 /* call_as/local stubs for unknwn.idl */
1253
1254 HRESULT CALLBACK IClassFactory_CreateInstance_Proxy(
1255     IClassFactory* This,
1256     IUnknown *pUnkOuter,
1257     REFIID riid,
1258     void **ppvObject)
1259 {
1260     TRACE("(%p, %s, %p)\n", pUnkOuter, debugstr_guid(riid), ppvObject);
1261     *ppvObject = NULL;
1262     if (pUnkOuter)
1263     {
1264         ERR("aggregation is not allowed on remote objects\n");
1265         return CLASS_E_NOAGGREGATION;
1266     }
1267     return IClassFactory_RemoteCreateInstance_Proxy(This, riid,
1268                                                     (IUnknown **) ppvObject);
1269 }
1270
1271 HRESULT __RPC_STUB IClassFactory_CreateInstance_Stub(
1272     IClassFactory* This,
1273     REFIID riid,
1274     IUnknown **ppvObject)
1275 {
1276     TRACE("(%s, %p)\n", debugstr_guid(riid), ppvObject);
1277     return IClassFactory_CreateInstance(This, NULL, riid, (void **) ppvObject);
1278 }
1279
1280 HRESULT CALLBACK IClassFactory_LockServer_Proxy(
1281     IClassFactory* This,
1282     BOOL fLock)
1283 {
1284     FIXME(":stub\n");
1285     return E_NOTIMPL;
1286 }
1287
1288 HRESULT __RPC_STUB IClassFactory_LockServer_Stub(
1289     IClassFactory* This,
1290     BOOL fLock)
1291 {
1292     FIXME(":stub\n");
1293     return E_NOTIMPL;
1294 }
1295
1296 /* call_as/local stubs for objidl.idl */
1297
1298 HRESULT CALLBACK IEnumUnknown_Next_Proxy(
1299     IEnumUnknown* This,
1300     ULONG celt,
1301     IUnknown **rgelt,
1302     ULONG *pceltFetched)
1303 {
1304     ULONG fetched;
1305     TRACE("%p, %lu, %p, %p.\n", This, celt, rgelt, pceltFetched);
1306     if (!pceltFetched) pceltFetched = &fetched;
1307     return IEnumUnknown_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
1308 }
1309
1310 HRESULT __RPC_STUB IEnumUnknown_Next_Stub(
1311     IEnumUnknown* This,
1312     ULONG celt,
1313     IUnknown **rgelt,
1314     ULONG *pceltFetched)
1315 {
1316     HRESULT hr;
1317     TRACE("%p, %lu, %p, %p.\n", This, celt, rgelt, pceltFetched);
1318     *pceltFetched = 0;
1319     hr = IEnumUnknown_Next(This, celt, rgelt, pceltFetched);
1320     if (hr == S_OK) *pceltFetched = celt;
1321     return hr;
1322 }
1323
1324 HRESULT CALLBACK IBindCtx_SetBindOptions_Proxy(
1325     IBindCtx* This,
1326     BIND_OPTS *pbindopts)
1327 {
1328     FIXME(":stub\n");
1329     return E_NOTIMPL;
1330 }
1331
1332 HRESULT __RPC_STUB IBindCtx_SetBindOptions_Stub(
1333     IBindCtx* This,
1334     BIND_OPTS2 *pbindopts)
1335 {
1336     FIXME(":stub\n");
1337     return E_NOTIMPL;
1338 }
1339
1340 HRESULT CALLBACK IBindCtx_GetBindOptions_Proxy(
1341     IBindCtx* This,
1342     BIND_OPTS *pbindopts)
1343 {
1344     FIXME(":stub\n");
1345     return E_NOTIMPL;
1346 }
1347
1348 HRESULT __RPC_STUB IBindCtx_GetBindOptions_Stub(
1349     IBindCtx* This,
1350     BIND_OPTS2 *pbindopts)
1351 {
1352     FIXME(":stub\n");
1353     return E_NOTIMPL;
1354 }
1355
1356 HRESULT CALLBACK IEnumMoniker_Next_Proxy(
1357     IEnumMoniker* This,
1358     ULONG celt,
1359     IMoniker **rgelt,
1360     ULONG *pceltFetched)
1361 {
1362     ULONG fetched;
1363     TRACE("%p, %lu, %p, %p.\n", This, celt, rgelt, pceltFetched);
1364     if (!pceltFetched) pceltFetched = &fetched;
1365     return IEnumMoniker_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
1366 }
1367
1368 HRESULT __RPC_STUB IEnumMoniker_Next_Stub(
1369     IEnumMoniker* This,
1370     ULONG celt,
1371     IMoniker **rgelt,
1372     ULONG *pceltFetched)
1373 {
1374     HRESULT hr;
1375     TRACE("%p, %lu, %p, %p.\n", This, celt, rgelt, pceltFetched);
1376     *pceltFetched = 0;
1377     hr = IEnumMoniker_Next(This, celt, rgelt, pceltFetched);
1378     if (hr == S_OK) *pceltFetched = celt;
1379     return hr;
1380 }
1381
1382 BOOL CALLBACK IRunnableObject_IsRunning_Proxy(
1383     IRunnableObject* This)
1384 {
1385     BOOL rv;
1386     FIXME(":stub\n");
1387     memset(&rv, 0, sizeof rv);
1388     return rv;
1389 }
1390
1391 HRESULT __RPC_STUB IRunnableObject_IsRunning_Stub(
1392     IRunnableObject* This)
1393 {
1394     FIXME(":stub\n");
1395     return E_NOTIMPL;
1396 }
1397
1398 HRESULT CALLBACK IMoniker_BindToObject_Proxy(
1399     IMoniker* This,
1400     IBindCtx *pbc,
1401     IMoniker *pmkToLeft,
1402     REFIID riidResult,
1403     void **ppvResult)
1404 {
1405     FIXME(":stub\n");
1406     return E_NOTIMPL;
1407 }
1408
1409 HRESULT __RPC_STUB IMoniker_BindToObject_Stub(
1410     IMoniker* This,
1411     IBindCtx *pbc,
1412     IMoniker *pmkToLeft,
1413     REFIID riidResult,
1414     IUnknown **ppvResult)
1415 {
1416     FIXME(":stub\n");
1417     return E_NOTIMPL;
1418 }
1419
1420 HRESULT CALLBACK IMoniker_BindToStorage_Proxy(
1421     IMoniker* This,
1422     IBindCtx *pbc,
1423     IMoniker *pmkToLeft,
1424     REFIID riid,
1425     void **ppvObj)
1426 {
1427     TRACE("(%p)->(%p %p %s %p)\n", This, pbc, pmkToLeft, debugstr_guid(riid), ppvObj);
1428     return IMoniker_RemoteBindToStorage_Proxy(This, pbc, pmkToLeft, riid, (IUnknown**)ppvObj);
1429 }
1430
1431 HRESULT __RPC_STUB IMoniker_BindToStorage_Stub(
1432     IMoniker* This,
1433     IBindCtx *pbc,
1434     IMoniker *pmkToLeft,
1435     REFIID riid,
1436     IUnknown **ppvObj)
1437 {
1438     TRACE("(%p)->(%p %p %s %p)\n", This, pbc, pmkToLeft, debugstr_guid(riid), ppvObj);
1439     return IMoniker_BindToStorage(This, pbc, pmkToLeft, riid, (void**)ppvObj);
1440 }
1441
1442 HRESULT CALLBACK IEnumString_Next_Proxy(
1443     IEnumString* This,
1444     ULONG celt,
1445     LPOLESTR *rgelt,
1446     ULONG *pceltFetched)
1447 {
1448     ULONG fetched;
1449     TRACE("%p, %lu, %p, %p.\n", This, celt, rgelt, pceltFetched);
1450     if (!pceltFetched) pceltFetched = &fetched;
1451     return IEnumString_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
1452 }
1453
1454 HRESULT __RPC_STUB IEnumString_Next_Stub(
1455     IEnumString* This,
1456     ULONG celt,
1457     LPOLESTR *rgelt,
1458     ULONG *pceltFetched)
1459 {
1460     HRESULT hr;
1461     TRACE("%p, %lu, %p, %p.\n", This, celt, rgelt, pceltFetched);
1462     *pceltFetched = 0;
1463     hr = IEnumString_Next(This, celt, rgelt, pceltFetched);
1464     if (hr == S_OK) *pceltFetched = celt;
1465     return hr;
1466 }
1467
1468 HRESULT CALLBACK ISequentialStream_Read_Proxy(
1469     ISequentialStream* This,
1470     void *pv,
1471     ULONG cb,
1472     ULONG *pcbRead)
1473 {
1474     ULONG read;
1475     HRESULT hr;
1476
1477     TRACE("%p, %p, %lu, %p.\n", This, pv, cb, pcbRead);
1478
1479     hr = ISequentialStream_RemoteRead_Proxy(This, pv, cb, &read);
1480     if(pcbRead) *pcbRead = read;
1481
1482     return hr;
1483 }
1484
1485 HRESULT __RPC_STUB ISequentialStream_Read_Stub(
1486     ISequentialStream* This,
1487     byte *pv,
1488     ULONG cb,
1489     ULONG *pcbRead)
1490 {
1491     TRACE("%p, %p, %lu, %p.\n", This, pv, cb, pcbRead);
1492     return ISequentialStream_Read(This, pv, cb, pcbRead);
1493 }
1494
1495 HRESULT CALLBACK ISequentialStream_Write_Proxy(
1496     ISequentialStream* This,
1497     const void *pv,
1498     ULONG cb,
1499     ULONG *pcbWritten)
1500 {
1501     ULONG written;
1502     HRESULT hr;
1503
1504     TRACE("%p, %p, %lu, %p.\n", This, pv, cb, pcbWritten);
1505
1506     hr = ISequentialStream_RemoteWrite_Proxy(This, pv, cb, &written);
1507     if(pcbWritten) *pcbWritten = written;
1508
1509     return hr;
1510 }
1511
1512 HRESULT __RPC_STUB ISequentialStream_Write_Stub(
1513     ISequentialStream* This,
1514     const byte *pv,
1515     ULONG cb,
1516     ULONG *pcbWritten)
1517 {
1518     TRACE("%p, %p, %lu, %p.\n", This, pv, cb, pcbWritten);
1519     return ISequentialStream_Write(This, pv, cb, pcbWritten);
1520 }
1521
1522 HRESULT CALLBACK IStream_Seek_Proxy(
1523     IStream* This,
1524     LARGE_INTEGER dlibMove,
1525     DWORD dwOrigin,
1526     ULARGE_INTEGER *plibNewPosition)
1527 {
1528     ULARGE_INTEGER newpos;
1529     HRESULT hr;
1530
1531     TRACE("%p, %s, %ld, %p.\n", This, wine_dbgstr_longlong(dlibMove.QuadPart), dwOrigin, plibNewPosition);
1532
1533     hr = IStream_RemoteSeek_Proxy(This, dlibMove, dwOrigin, &newpos);
1534     if(plibNewPosition) *plibNewPosition = newpos;
1535
1536     return hr;
1537 }
1538
1539 HRESULT __RPC_STUB IStream_Seek_Stub(
1540     IStream* This,
1541     LARGE_INTEGER dlibMove,
1542     DWORD dwOrigin,
1543     ULARGE_INTEGER *plibNewPosition)
1544 {
1545     TRACE("%p, %s, %ld, %p.\n", This, wine_dbgstr_longlong(dlibMove.QuadPart), dwOrigin, plibNewPosition);
1546     return IStream_Seek(This, dlibMove, dwOrigin, plibNewPosition);
1547 }
1548
1549 HRESULT CALLBACK IStream_CopyTo_Proxy(
1550     IStream* This,
1551     IStream *pstm,
1552     ULARGE_INTEGER cb,
1553     ULARGE_INTEGER *pcbRead,
1554     ULARGE_INTEGER *pcbWritten)
1555 {
1556     ULARGE_INTEGER read, written;
1557     HRESULT hr;
1558
1559     TRACE("(%p)->(%p, %s, %p, %p)\n", This, pstm, wine_dbgstr_longlong(cb.QuadPart), pcbRead, pcbWritten);
1560
1561     hr = IStream_RemoteCopyTo_Proxy(This, pstm, cb, &read, &written);
1562     if(pcbRead) *pcbRead = read;
1563     if(pcbWritten) *pcbWritten = written;
1564
1565     return hr;
1566 }
1567
1568 HRESULT __RPC_STUB IStream_CopyTo_Stub(
1569     IStream* This,
1570     IStream *pstm,
1571     ULARGE_INTEGER cb,
1572     ULARGE_INTEGER *pcbRead,
1573     ULARGE_INTEGER *pcbWritten)
1574 {
1575     TRACE("(%p)->(%p, %s, %p, %p)\n", This, pstm, wine_dbgstr_longlong(cb.QuadPart), pcbRead, pcbWritten);
1576
1577     return IStream_CopyTo(This, pstm, cb, pcbRead, pcbWritten);
1578 }
1579
1580 HRESULT CALLBACK IEnumSTATSTG_Next_Proxy(
1581     IEnumSTATSTG* This,
1582     ULONG celt,
1583     STATSTG *rgelt,
1584     ULONG *pceltFetched)
1585 {
1586     ULONG fetched;
1587     TRACE("%p, %lu, %p, %p.\n", This, celt, rgelt, pceltFetched);
1588     if (!pceltFetched) pceltFetched = &fetched;
1589     return IEnumSTATSTG_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
1590 }
1591
1592 HRESULT __RPC_STUB IEnumSTATSTG_Next_Stub(
1593     IEnumSTATSTG* This,
1594     ULONG celt,
1595     STATSTG *rgelt,
1596     ULONG *pceltFetched)
1597 {
1598     HRESULT hr;
1599     TRACE("%p, %lu, %p, %p.\n", This, celt, rgelt, pceltFetched);
1600     *pceltFetched = 0;
1601     hr = IEnumSTATSTG_Next(This, celt, rgelt, pceltFetched);
1602     if (hr == S_OK) *pceltFetched = celt;
1603     return hr;
1604 }
1605
1606 HRESULT CALLBACK IStorage_OpenStream_Proxy(
1607     IStorage* This,
1608     LPCOLESTR pwcsName,
1609     void *reserved1,
1610     DWORD grfMode,
1611     DWORD reserved2,
1612     IStream **ppstm)
1613 {
1614     TRACE("%p, %s, %p, %#lx, %ld, %p.\n", This, debugstr_w(pwcsName), reserved1, grfMode, reserved2, ppstm);
1615     if(reserved1) WARN("reserved1 %p\n", reserved1);
1616
1617     return IStorage_RemoteOpenStream_Proxy(This, pwcsName, 0, NULL, grfMode, reserved2, ppstm);
1618 }
1619
1620 HRESULT __RPC_STUB IStorage_OpenStream_Stub(
1621     IStorage* This,
1622     LPCOLESTR pwcsName,
1623     ULONG cbReserved1,
1624     byte *reserved1,
1625     DWORD grfMode,
1626     DWORD reserved2,
1627     IStream **ppstm)
1628 {
1629     TRACE("%p, %s, %ld, %p, %#lx, %ld, %p.\n", This, debugstr_w(pwcsName), cbReserved1, reserved1, grfMode, reserved2, ppstm);
1630     if(cbReserved1 || reserved1) WARN("cbReserved1 %ld reserved1 %p\n", cbReserved1, reserved1);
1631
1632     return IStorage_OpenStream(This, pwcsName, NULL, grfMode, reserved2, ppstm);
1633 }
1634
1635 HRESULT CALLBACK IStorage_EnumElements_Proxy(
1636     IStorage* This,
1637     DWORD reserved1,
1638     void *reserved2,
1639     DWORD reserved3,
1640     IEnumSTATSTG **ppenum)
1641 {
1642     TRACE("%p, %ld, %p, %ld, %p.\n", This, reserved1, reserved2, reserved3, ppenum);
1643     if(reserved2) WARN("reserved2 %p\n", reserved2);
1644
1645     return IStorage_RemoteEnumElements_Proxy(This, reserved1, 0, NULL, reserved3, ppenum);
1646 }
1647
1648 HRESULT __RPC_STUB IStorage_EnumElements_Stub(
1649     IStorage* This,
1650     DWORD reserved1,
1651     ULONG cbReserved2,
1652     byte *reserved2,
1653     DWORD reserved3,
1654     IEnumSTATSTG **ppenum)
1655 {
1656     TRACE("%p, %ld, %ld, %p, %ld, %p.\n", This, reserved1, cbReserved2, reserved2, reserved3, ppenum);
1657     if(cbReserved2 || reserved2) WARN("cbReserved2 %ld reserved2 %p\n", cbReserved2, reserved2);
1658
1659     return IStorage_EnumElements(This, reserved1, NULL, reserved3, ppenum);
1660 }
1661
1662 HRESULT CALLBACK ILockBytes_ReadAt_Proxy(
1663     ILockBytes* This,
1664     ULARGE_INTEGER ulOffset,
1665     void *pv,
1666     ULONG cb,
1667     ULONG *pcbRead)
1668 {
1669     ULONG read;
1670     HRESULT hr;
1671
1672     TRACE("%p, %s, %p, %lu, %p.\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbRead);
1673
1674     hr = ILockBytes_RemoteReadAt_Proxy(This, ulOffset, pv, cb, &read);
1675     if(pcbRead) *pcbRead = read;
1676
1677     return hr;
1678 }
1679
1680 HRESULT __RPC_STUB ILockBytes_ReadAt_Stub(
1681     ILockBytes* This,
1682     ULARGE_INTEGER ulOffset,
1683     byte *pv,
1684     ULONG cb,
1685     ULONG *pcbRead)
1686 {
1687     TRACE("%p, %s, %p, %lu, %p.\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbRead);
1688     return ILockBytes_ReadAt(This, ulOffset, pv, cb, pcbRead);
1689 }
1690
1691 HRESULT CALLBACK ILockBytes_WriteAt_Proxy(
1692     ILockBytes* This,
1693     ULARGE_INTEGER ulOffset,
1694     const void *pv,
1695     ULONG cb,
1696     ULONG *pcbWritten)
1697 {
1698     ULONG written;
1699     HRESULT hr;
1700
1701     TRACE("%p, %s, %p, %lu, %p.\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbWritten);
1702
1703     hr = ILockBytes_RemoteWriteAt_Proxy(This, ulOffset, pv, cb, &written);
1704     if(pcbWritten) *pcbWritten = written;
1705
1706     return hr;
1707 }
1708
1709 HRESULT __RPC_STUB ILockBytes_WriteAt_Stub(
1710     ILockBytes* This,
1711     ULARGE_INTEGER ulOffset,
1712     const byte *pv,
1713     ULONG cb,
1714     ULONG *pcbWritten)
1715 {
1716     TRACE("%p, %s, %p, %lu, %p.\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbWritten);
1717     return ILockBytes_WriteAt(This, ulOffset, pv, cb, pcbWritten);
1718 }
1719
1720 HRESULT CALLBACK IFillLockBytes_FillAppend_Proxy(
1721     IFillLockBytes* This,
1722     const void *pv,
1723     ULONG cb,
1724     ULONG *pcbWritten)
1725 {
1726     ULONG written;
1727     HRESULT hr;
1728
1729     TRACE("%p, %p, %lu, %p.\n", This, pv, cb, pcbWritten);
1730
1731     hr = IFillLockBytes_RemoteFillAppend_Proxy(This, pv, cb, &written);
1732     if(pcbWritten) *pcbWritten = written;
1733
1734     return hr;
1735 }
1736
1737 HRESULT __RPC_STUB IFillLockBytes_FillAppend_Stub(
1738     IFillLockBytes* This,
1739     const byte *pv,
1740     ULONG cb,
1741     ULONG *pcbWritten)
1742 {
1743     TRACE("%p, %p, %lu, %p.\n", This, pv, cb, pcbWritten);
1744     return IFillLockBytes_FillAppend(This, pv, cb, pcbWritten);
1745 }
1746
1747 HRESULT CALLBACK IFillLockBytes_FillAt_Proxy(
1748     IFillLockBytes* This,
1749     ULARGE_INTEGER ulOffset,
1750     const void *pv,
1751     ULONG cb,
1752     ULONG *pcbWritten)
1753 {
1754     ULONG written;
1755     HRESULT hr;
1756
1757     TRACE("%p, %s, %p, %lu, %p.\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbWritten);
1758
1759     hr = IFillLockBytes_RemoteFillAt_Proxy(This, ulOffset, pv, cb, &written);
1760     if(pcbWritten) *pcbWritten = written;
1761
1762     return hr;
1763 }
1764
1765 HRESULT __RPC_STUB IFillLockBytes_FillAt_Stub(
1766     IFillLockBytes* This,
1767     ULARGE_INTEGER ulOffset,
1768     const byte *pv,
1769     ULONG cb,
1770     ULONG *pcbWritten)
1771 {
1772     TRACE("%p, %s, %p, %ld, %p.\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbWritten);
1773     return IFillLockBytes_FillAt(This, ulOffset, pv, cb, pcbWritten);
1774 }
1775
1776 HRESULT CALLBACK IEnumFORMATETC_Next_Proxy(
1777     IEnumFORMATETC* This,
1778     ULONG celt,
1779     FORMATETC *rgelt,
1780     ULONG *pceltFetched)
1781 {
1782     ULONG fetched;
1783     if (!pceltFetched) pceltFetched = &fetched;
1784     return IEnumFORMATETC_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
1785 }
1786
1787 HRESULT __RPC_STUB IEnumFORMATETC_Next_Stub(
1788     IEnumFORMATETC* This,
1789     ULONG celt,
1790     FORMATETC *rgelt,
1791     ULONG *pceltFetched)
1792 {
1793     HRESULT hr;
1794     *pceltFetched = 0;
1795     hr = IEnumFORMATETC_Next(This, celt, rgelt, pceltFetched);
1796     if (hr == S_OK) *pceltFetched = celt;
1797     return hr;
1798 }
1799
1800 HRESULT CALLBACK IEnumSTATDATA_Next_Proxy(
1801     IEnumSTATDATA* This,
1802     ULONG celt,
1803     STATDATA *rgelt,
1804     ULONG *pceltFetched)
1805 {
1806     ULONG fetched;
1807     TRACE("%p, %ld, %p, %p.\n", This, celt, rgelt, pceltFetched);
1808     if (!pceltFetched) pceltFetched = &fetched;
1809     return IEnumSTATDATA_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
1810 }
1811
1812 HRESULT __RPC_STUB IEnumSTATDATA_Next_Stub(
1813     IEnumSTATDATA* This,
1814     ULONG celt,
1815     STATDATA *rgelt,
1816     ULONG *pceltFetched)
1817 {
1818     HRESULT hr;
1819     TRACE("%p, %lu, %p, %p.\n", This, celt, rgelt, pceltFetched);
1820     *pceltFetched = 0;
1821     hr = IEnumSTATDATA_Next(This, celt, rgelt, pceltFetched);
1822     if (hr == S_OK) *pceltFetched = celt;
1823     return hr;
1824 }
1825
1826 void CALLBACK IAdviseSink_OnDataChange_Proxy(
1827     IAdviseSink* This,
1828     FORMATETC *pFormatetc,
1829     STGMEDIUM *pStgmed)
1830 {
1831     TRACE("(%p)->(%p, %p)\n", This, pFormatetc, pStgmed);
1832     IAdviseSink_RemoteOnDataChange_Proxy(This, pFormatetc, pStgmed);
1833 }
1834
1835 HRESULT __RPC_STUB IAdviseSink_OnDataChange_Stub(
1836     IAdviseSink* This,
1837     FORMATETC *pFormatetc,
1838     ASYNC_STGMEDIUM *pStgmed)
1839 {
1840     TRACE("(%p)->(%p, %p)\n", This, pFormatetc, pStgmed);
1841     IAdviseSink_OnDataChange(This, pFormatetc, pStgmed);
1842     return S_OK;
1843 }
1844
1845 void CALLBACK IAdviseSink_OnViewChange_Proxy(
1846     IAdviseSink* This,
1847     DWORD dwAspect,
1848     LONG lindex)
1849 {
1850     TRACE("%p, %ld, %ld.\n", This, dwAspect, lindex);
1851     IAdviseSink_RemoteOnViewChange_Proxy(This, dwAspect, lindex);
1852 }
1853
1854 HRESULT __RPC_STUB IAdviseSink_OnViewChange_Stub(
1855     IAdviseSink* This,
1856     DWORD dwAspect,
1857     LONG lindex)
1858 {
1859     TRACE("%p, %ld, %ld.\n", This, dwAspect, lindex);
1860     IAdviseSink_OnViewChange(This, dwAspect, lindex);
1861     return S_OK;
1862 }
1863
1864 void CALLBACK IAdviseSink_OnRename_Proxy(
1865     IAdviseSink* This,
1866     IMoniker *pmk)
1867 {
1868     TRACE("(%p)->(%p)\n", This, pmk);
1869     IAdviseSink_RemoteOnRename_Proxy(This, pmk);
1870 }
1871
1872 HRESULT __RPC_STUB IAdviseSink_OnRename_Stub(
1873     IAdviseSink* This,
1874     IMoniker *pmk)
1875 {
1876     TRACE("(%p)->(%p)\n", This, pmk);
1877     IAdviseSink_OnRename(This, pmk);
1878     return S_OK;
1879 }
1880
1881 void CALLBACK IAdviseSink_OnSave_Proxy(
1882     IAdviseSink* This)
1883 {
1884     TRACE("(%p)\n", This);
1885     IAdviseSink_RemoteOnSave_Proxy(This);
1886 }
1887
1888 HRESULT __RPC_STUB IAdviseSink_OnSave_Stub(
1889     IAdviseSink* This)
1890 {
1891     TRACE("(%p)\n", This);
1892     IAdviseSink_OnSave(This);
1893     return S_OK;
1894 }
1895
1896 void CALLBACK IAdviseSink_OnClose_Proxy(
1897     IAdviseSink* This)
1898 {
1899     TRACE("(%p)\n", This);
1900     IAdviseSink_RemoteOnClose_Proxy(This);
1901 }
1902
1903 HRESULT __RPC_STUB IAdviseSink_OnClose_Stub(
1904     IAdviseSink* This)
1905 {
1906     TRACE("(%p)\n", This);
1907     IAdviseSink_OnClose(This);
1908     return S_OK;
1909 }
1910
1911 void CALLBACK IAdviseSink2_OnLinkSrcChange_Proxy(
1912     IAdviseSink2* This,
1913     IMoniker *pmk)
1914 {
1915     TRACE("(%p)->(%p)\n", This, pmk);
1916     IAdviseSink2_RemoteOnLinkSrcChange_Proxy(This, pmk);
1917 }
1918
1919 HRESULT __RPC_STUB IAdviseSink2_OnLinkSrcChange_Stub(
1920     IAdviseSink2* This,
1921     IMoniker *pmk)
1922 {
1923     TRACE("(%p)->(%p)\n", This, pmk);
1924     IAdviseSink2_OnLinkSrcChange(This, pmk);
1925     return S_OK;
1926 }
1927
1928 HRESULT CALLBACK IDataObject_GetData_Proxy(
1929     IDataObject* This,
1930     FORMATETC *pformatetcIn,
1931     STGMEDIUM *pmedium)
1932 {
1933     TRACE("(%p)->(%p, %p)\n", This, pformatetcIn, pmedium);
1934     return IDataObject_RemoteGetData_Proxy(This, pformatetcIn, pmedium);
1935 }
1936
1937 HRESULT __RPC_STUB IDataObject_GetData_Stub(
1938     IDataObject* This,
1939     FORMATETC *pformatetcIn,
1940     STGMEDIUM *pRemoteMedium)
1941 {
1942     TRACE("(%p)->(%p, %p)\n", This, pformatetcIn, pRemoteMedium);
1943     return IDataObject_GetData(This, pformatetcIn, pRemoteMedium);
1944 }
1945
1946 HRESULT CALLBACK IDataObject_GetDataHere_Proxy(IDataObject *iface, FORMATETC *fmt, STGMEDIUM *med)
1947 {
1948     IUnknown *release;
1949     IStorage *stg = NULL;
1950     HRESULT hr;
1951
1952     TRACE("(%p)->(%p, %p)\n", iface, fmt, med);
1953
1954     if ((med->tymed & (TYMED_HGLOBAL | TYMED_FILE | TYMED_ISTREAM | TYMED_ISTORAGE)) == 0)
1955         return DV_E_TYMED;
1956     if (med->tymed != fmt->tymed)
1957         return DV_E_TYMED;
1958
1959     release = med->pUnkForRelease;
1960     med->pUnkForRelease = NULL;
1961
1962     if (med->tymed == TYMED_ISTREAM || med->tymed == TYMED_ISTORAGE)
1963     {
1964         stg = med->pstg; /* This may actually be a stream, but that's ok */
1965         if (stg) IStorage_AddRef( stg );
1966     }
1967
1968     hr = IDataObject_RemoteGetDataHere_Proxy(iface, fmt, med);
1969
1970     med->pUnkForRelease = release;
1971     if (stg)
1972     {
1973         if (med->pstg)
1974             IStorage_Release( med->pstg );
1975         med->pstg = stg;
1976     }
1977
1978     return hr;
1979 }
1980
1981 HRESULT __RPC_STUB IDataObject_GetDataHere_Stub(
1982     IDataObject* This,
1983     FORMATETC *pformatetc,
1984     STGMEDIUM *pRemoteMedium)
1985 {
1986     TRACE("(%p)->(%p, %p)\n", This, pformatetc, pRemoteMedium);
1987     return IDataObject_GetDataHere(This, pformatetc, pRemoteMedium);
1988 }
1989
1990 HRESULT CALLBACK IDataObject_SetData_Proxy(
1991     IDataObject* This,
1992     FORMATETC *pformatetc,
1993     STGMEDIUM *pmedium,
1994     BOOL fRelease)
1995 {
1996     FIXME(":stub\n");
1997     return E_NOTIMPL;
1998 }
1999
2000 HRESULT __RPC_STUB IDataObject_SetData_Stub(
2001     IDataObject* This,
2002     FORMATETC *pformatetc,
2003     FLAG_STGMEDIUM *pmedium,
2004     BOOL fRelease)
2005 {
2006     FIXME(":stub\n");
2007     return E_NOTIMPL;
2008 }
2009
2010 /* call_as/local stubs for oleidl.idl */
2011
2012 HRESULT CALLBACK IOleInPlaceActiveObject_TranslateAccelerator_Proxy(
2013     IOleInPlaceActiveObject* This,
2014     LPMSG lpmsg)
2015 {
2016     TRACE("(%p %p)\n", This, lpmsg);
2017     return IOleInPlaceActiveObject_RemoteTranslateAccelerator_Proxy(This);
2018 }
2019
2020 HRESULT __RPC_STUB IOleInPlaceActiveObject_TranslateAccelerator_Stub(
2021     IOleInPlaceActiveObject* This)
2022 {
2023     TRACE("(%p)\n", This);
2024     return S_FALSE;
2025 }
2026
2027 HRESULT CALLBACK IOleInPlaceActiveObject_ResizeBorder_Proxy(
2028     IOleInPlaceActiveObject* This,
2029     LPCRECT prcBorder,
2030     IOleInPlaceUIWindow *pUIWindow,
2031     BOOL fFrameWindow)
2032 {
2033     FIXME(":stub\n");
2034     return E_NOTIMPL;
2035 }
2036
2037 HRESULT __RPC_STUB IOleInPlaceActiveObject_ResizeBorder_Stub(
2038     IOleInPlaceActiveObject* This,
2039     LPCRECT prcBorder,
2040     REFIID riid,
2041     IOleInPlaceUIWindow *pUIWindow,
2042     BOOL fFrameWindow)
2043 {
2044     FIXME(":stub\n");
2045     return E_NOTIMPL;
2046 }
2047
2048 HRESULT CALLBACK IOleCache2_UpdateCache_Proxy(
2049     IOleCache2* This,
2050     LPDATAOBJECT pDataObject,
2051     DWORD grfUpdf,
2052     LPVOID pReserved)
2053 {
2054     TRACE("%p, %p, %#lx, %p.\n", This, pDataObject, grfUpdf, pReserved);
2055     return IOleCache2_RemoteUpdateCache_Proxy(This, pDataObject, grfUpdf, (LONG_PTR)pReserved);
2056 }
2057
2058 HRESULT __RPC_STUB IOleCache2_UpdateCache_Stub(
2059     IOleCache2* This,
2060     LPDATAOBJECT pDataObject,
2061     DWORD grfUpdf,
2062     LONG_PTR pReserved)
2063 {
2064     TRACE("%p, %p, %#lx, %Id.\n", This, pDataObject, grfUpdf, pReserved);
2065     return IOleCache2_UpdateCache(This, pDataObject, grfUpdf, (void*)pReserved);
2066 }
2067
2068 HRESULT CALLBACK IEnumOLEVERB_Next_Proxy(
2069     IEnumOLEVERB* This,
2070     ULONG celt,
2071     LPOLEVERB rgelt,
2072     ULONG *pceltFetched)
2073 {
2074     ULONG fetched;
2075     TRACE("%p, %lu, %p, %p.\n", This, celt, rgelt, pceltFetched);
2076     if (!pceltFetched) pceltFetched = &fetched;
2077     return IEnumOLEVERB_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
2078 }
2079
2080 HRESULT __RPC_STUB IEnumOLEVERB_Next_Stub(
2081     IEnumOLEVERB* This,
2082     ULONG celt,
2083     LPOLEVERB rgelt,
2084     ULONG *pceltFetched)
2085 {
2086     HRESULT hr;
2087     TRACE("%p, %lu, %p, %p.\n", This, celt, rgelt, pceltFetched);
2088     *pceltFetched = 0;
2089     hr = IEnumOLEVERB_Next(This, celt, rgelt, pceltFetched);
2090     if (hr == S_OK) *pceltFetched = celt;
2091     return hr;
2092 }
2093
2094 HRESULT CALLBACK IViewObject_Draw_Proxy(
2095     IViewObject* This,
2096     DWORD dwDrawAspect,
2097     LONG lindex,
2098     void *pvAspect,
2099     DVTARGETDEVICE *ptd,
2100     HDC hdcTargetDev,
2101     HDC hdcDraw,
2102     LPCRECTL lprcBounds,
2103     LPCRECTL lprcWBounds,
2104     BOOL (STDMETHODCALLTYPE *pfnContinue)(ULONG_PTR dwContinue),
2105     ULONG_PTR dwContinue)
2106 {
2107     FIXME(":stub\n");
2108     return E_NOTIMPL;
2109 }
2110
2111 HRESULT __RPC_STUB IViewObject_Draw_Stub(
2112     IViewObject* This,
2113     DWORD dwDrawAspect,
2114     LONG lindex,
2115     ULONG_PTR pvAspect,
2116     DVTARGETDEVICE *ptd,
2117     ULONG_PTR hdcTargetDev,
2118     ULONG_PTR hdcDraw,
2119     LPCRECTL lprcBounds,
2120     LPCRECTL lprcWBounds,
2121     IContinue *pContinue)
2122 {
2123     FIXME(":stub\n");
2124     return E_NOTIMPL;
2125 }
2126
2127 HRESULT CALLBACK IViewObject_GetColorSet_Proxy(
2128     IViewObject* This,
2129     DWORD dwDrawAspect,
2130     LONG lindex,
2131     void *pvAspect,
2132     DVTARGETDEVICE *ptd,
2133     HDC hicTargetDev,
2134     LOGPALETTE **ppColorSet)
2135 {
2136     FIXME(":stub\n");
2137     return E_NOTIMPL;
2138 }
2139
2140 HRESULT __RPC_STUB IViewObject_GetColorSet_Stub(
2141     IViewObject* This,
2142     DWORD dwDrawAspect,
2143     LONG lindex,
2144     ULONG_PTR pvAspect,
2145     DVTARGETDEVICE *ptd,
2146     ULONG_PTR hicTargetDev,
2147     LOGPALETTE **ppColorSet)
2148 {
2149     FIXME(":stub\n");
2150     return E_NOTIMPL;
2151 }
2152
2153 HRESULT CALLBACK IViewObject_Freeze_Proxy(
2154     IViewObject* This,
2155     DWORD dwDrawAspect,
2156     LONG lindex,
2157     void *pvAspect,
2158     DWORD *pdwFreeze)
2159 {
2160     FIXME(":stub\n");
2161     return E_NOTIMPL;
2162 }
2163
2164 HRESULT __RPC_STUB IViewObject_Freeze_Stub(
2165     IViewObject* This,
2166     DWORD dwDrawAspect,
2167     LONG lindex,
2168     ULONG_PTR pvAspect,
2169     DWORD *pdwFreeze)
2170 {
2171     FIXME(":stub\n");
2172     return E_NOTIMPL;
2173 }
2174
2175 HRESULT CALLBACK IViewObject_GetAdvise_Proxy(
2176     IViewObject* This,
2177     DWORD *pAspects,
2178     DWORD *pAdvf,
2179     IAdviseSink **ppAdvSink)
2180 {
2181     FIXME(":stub\n");
2182     return E_NOTIMPL;
2183 }
2184
2185 HRESULT __RPC_STUB IViewObject_GetAdvise_Stub(
2186     IViewObject* This,
2187     DWORD *pAspects,
2188     DWORD *pAdvf,
2189     IAdviseSink **ppAdvSink)
2190 {
2191     FIXME(":stub\n");
2192     return E_NOTIMPL;
2193 }