dlls/ole32/usrmarshal.c

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