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