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