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 ULONG 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 ULONG 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 }
2916
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.