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