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