[OLE32_WINETEST] Sync with Wine Staging 3.3. CORE-14434
[reactos.git] / modules / rostests / winetests / ole32 / usrmarshal.c
1 /*
2 * User Marshaling Tests
3 *
4 * Copyright 2004-2006 Robert Shearman for CodeWeavers
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 #define COBJMACROS
22 #define CONST_VTABLE
23 #include <stdarg.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "objbase.h"
28 #include "objidl.h"
29
30 #include "wine/test.h"
31
32 ULONG __RPC_USER HMETAFILE_UserSize(ULONG *, ULONG, HMETAFILE *);
33 unsigned char * __RPC_USER HMETAFILE_UserMarshal(ULONG *, unsigned char *, HMETAFILE *);
34 unsigned char * __RPC_USER HMETAFILE_UserUnmarshal(ULONG *, unsigned char *, HMETAFILE *);
35 void __RPC_USER HMETAFILE_UserFree(ULONG *, HMETAFILE *);
36
37 ULONG __RPC_USER HENHMETAFILE_UserSize(ULONG *, ULONG, HENHMETAFILE *);
38 unsigned char * __RPC_USER HENHMETAFILE_UserMarshal (ULONG *, unsigned char *, HENHMETAFILE *);
39 unsigned char * __RPC_USER HENHMETAFILE_UserUnmarshal(ULONG *, unsigned char *, HENHMETAFILE *);
40 void __RPC_USER HENHMETAFILE_UserFree(ULONG *, HENHMETAFILE *);
41
42 ULONG __RPC_USER HMETAFILEPICT_UserSize(ULONG *, ULONG, HMETAFILEPICT *);
43 unsigned char * __RPC_USER HMETAFILEPICT_UserMarshal (ULONG *, unsigned char *, HMETAFILEPICT *);
44 unsigned char * __RPC_USER HMETAFILEPICT_UserUnmarshal(ULONG *, unsigned char *, HMETAFILEPICT *);
45 void __RPC_USER HMETAFILEPICT_UserFree(ULONG *, HMETAFILEPICT *);
46
47 ULONG __RPC_USER HBRUSH_UserSize(ULONG *, ULONG, HBRUSH *);
48 unsigned char * __RPC_USER HBRUSH_UserMarshal(ULONG *, unsigned char *, HBRUSH *);
49 unsigned char * __RPC_USER HBRUSH_UserUnmarshal(ULONG *, unsigned char *, HBRUSH *);
50 void __RPC_USER HBRUSH_UserFree(ULONG *, HBRUSH *);
51
52 static BOOL g_expect_user_alloc;
53 static void * WINAPI user_allocate(SIZE_T size)
54 {
55 ok(g_expect_user_alloc, "unexpected user_allocate call\n");
56 return CoTaskMemAlloc(size);
57 }
58
59 static BOOL g_expect_user_free;
60 static void WINAPI user_free(void *p)
61 {
62 ok(g_expect_user_free, "unexpected user_free call\n");
63 CoTaskMemFree(p);
64 }
65
66 static void init_user_marshal_cb(USER_MARSHAL_CB *umcb,
67 PMIDL_STUB_MESSAGE stub_msg,
68 PRPC_MESSAGE rpc_msg, unsigned char *buffer,
69 unsigned int size, MSHCTX context)
70 {
71 memset(rpc_msg, 0, sizeof(*rpc_msg));
72 rpc_msg->Buffer = buffer;
73 rpc_msg->BufferLength = size;
74
75 memset(stub_msg, 0, sizeof(*stub_msg));
76 stub_msg->RpcMsg = rpc_msg;
77 stub_msg->Buffer = buffer;
78 stub_msg->pfnAllocate = user_allocate;
79 stub_msg->pfnFree = user_free;
80
81 memset(umcb, 0, sizeof(*umcb));
82 umcb->Flags = MAKELONG(context, NDR_LOCAL_DATA_REPRESENTATION);
83 umcb->pStubMsg = stub_msg;
84 umcb->Signature = USER_MARSHAL_CB_SIGNATURE;
85 umcb->CBType = buffer ? USER_MARSHAL_CB_UNMARSHALL : USER_MARSHAL_CB_BUFFER_SIZE;
86 }
87
88 #define RELEASEMARSHALDATA WM_USER
89
90 struct host_object_data
91 {
92 IStream *stream;
93 IID iid;
94 IUnknown *object;
95 MSHLFLAGS marshal_flags;
96 HANDLE marshal_event;
97 IMessageFilter *filter;
98 };
99
100 static DWORD CALLBACK host_object_proc(LPVOID p)
101 {
102 struct host_object_data *data = p;
103 HRESULT hr;
104 MSG msg;
105
106 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
107
108 if (data->filter)
109 {
110 IMessageFilter * prev_filter = NULL;
111 hr = CoRegisterMessageFilter(data->filter, &prev_filter);
112 if (prev_filter) IMessageFilter_Release(prev_filter);
113 ok(hr == S_OK, "got %08x\n", hr);
114 }
115
116 hr = CoMarshalInterface(data->stream, &data->iid, data->object, MSHCTX_INPROC, NULL, data->marshal_flags);
117 ok(hr == S_OK, "got %08x\n", hr);
118
119 /* force the message queue to be created before signaling parent thread */
120 PeekMessageA(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
121
122 SetEvent(data->marshal_event);
123
124 while (GetMessageA(&msg, NULL, 0, 0))
125 {
126 if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
127 {
128 CoReleaseMarshalData(data->stream);
129 SetEvent((HANDLE)msg.lParam);
130 }
131 else
132 DispatchMessageA(&msg);
133 }
134
135 HeapFree(GetProcessHeap(), 0, data);
136
137 CoUninitialize();
138
139 return hr;
140 }
141
142 static DWORD start_host_object2(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, IMessageFilter *filter, HANDLE *thread)
143 {
144 DWORD tid = 0;
145 HANDLE marshal_event = CreateEventA(NULL, FALSE, FALSE, NULL);
146 struct host_object_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data));
147
148 data->stream = stream;
149 data->iid = *riid;
150 data->object = object;
151 data->marshal_flags = marshal_flags;
152 data->marshal_event = marshal_event;
153 data->filter = filter;
154
155 *thread = CreateThread(NULL, 0, host_object_proc, data, 0, &tid);
156
157 /* wait for marshaling to complete before returning */
158 ok( !WaitForSingleObject(marshal_event, 10000), "wait timed out\n" );
159 CloseHandle(marshal_event);
160
161 return tid;
162 }
163
164 static void end_host_object(DWORD tid, HANDLE thread)
165 {
166 BOOL ret = PostThreadMessageA(tid, WM_QUIT, 0, 0);
167 ok(ret, "PostThreadMessage failed with error %d\n", GetLastError());
168 /* be careful of races - don't return until hosting thread has terminated */
169 ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
170 CloseHandle(thread);
171 }
172
173 static const char cf_marshaled[] =
174 {
175 0x9, 0x0, 0x0, 0x0,
176 0x0, 0x0, 0x0, 0x0,
177 0x9, 0x0, 0x0, 0x0,
178 'M', 0x0, 'y', 0x0,
179 'F', 0x0, 'o', 0x0,
180 'r', 0x0, 'm', 0x0,
181 'a', 0x0, 't', 0x0,
182 0x0, 0x0
183 };
184
185 static void test_marshal_CLIPFORMAT(void)
186 {
187 USER_MARSHAL_CB umcb;
188 MIDL_STUB_MESSAGE stub_msg;
189 RPC_MESSAGE rpc_msg;
190 unsigned char *buffer, *buffer_end;
191 ULONG i, size;
192 CLIPFORMAT cf = RegisterClipboardFormatA("MyFormat");
193 CLIPFORMAT cf2;
194
195 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
196 size = CLIPFORMAT_UserSize(&umcb.Flags, 1, &cf);
197 ok(size == 12 + sizeof(cf_marshaled) ||
198 broken(size == 16 + sizeof(cf_marshaled)), /* win64 adds 4 extra (unused) bytes */
199 "CLIPFORMAT: Wrong size %d\n", size);
200
201 buffer = HeapAlloc(GetProcessHeap(), 0, size);
202 memset( buffer, 0xcc, size );
203 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
204 buffer_end = CLIPFORMAT_UserMarshal(&umcb.Flags, buffer + 1, &cf);
205 ok(buffer_end == buffer + 12 + sizeof(cf_marshaled), "got %p buffer %p\n", buffer_end, buffer);
206 ok(*(LONG *)(buffer + 4) == WDT_REMOTE_CALL, "CLIPFORMAT: Context should be WDT_REMOTE_CALL instead of 0x%08x\n", *(LONG *)(buffer + 0));
207 ok(*(DWORD *)(buffer + 8) == cf, "CLIPFORMAT: Marshaled value should be 0x%04x instead of 0x%04x\n", cf, *(DWORD *)(buffer + 4));
208 ok(!memcmp(buffer + 12, cf_marshaled, min( sizeof(cf_marshaled), size-12 )), "Marshaled data differs\n");
209 if (size > sizeof(cf_marshaled) + 12) /* make sure the extra bytes are not used */
210 for (i = sizeof(cf_marshaled) + 12; i < size; i++)
211 ok( buffer[i] == 0xcc, "buffer offset %u has been set to %x\n", i, buffer[i] );
212
213 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
214 buffer_end = CLIPFORMAT_UserUnmarshal(&umcb.Flags, buffer + 1, &cf2);
215 ok(buffer_end == buffer + 12 + sizeof(cf_marshaled), "got %p buffer %p\n", buffer_end, buffer);
216 ok(cf == cf2, "CLIPFORMAT: Didn't unmarshal properly\n");
217 HeapFree(GetProcessHeap(), 0, buffer);
218
219 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
220 CLIPFORMAT_UserFree(&umcb.Flags, &cf2);
221 }
222
223 static void test_marshal_HWND(void)
224 {
225 USER_MARSHAL_CB umcb;
226 MIDL_STUB_MESSAGE stub_msg;
227 RPC_MESSAGE rpc_msg;
228 unsigned char *buffer, *buffer_end;
229 ULONG size;
230 HWND hwnd = GetDesktopWindow();
231 HWND hwnd2;
232 wireHWND wirehwnd;
233
234 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
235 size = HWND_UserSize(&umcb.Flags, 1, &hwnd);
236 ok(size == 4 + sizeof(*wirehwnd), "Wrong size %d\n", size);
237
238 buffer = HeapAlloc(GetProcessHeap(), 0, size);
239 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
240 buffer_end = HWND_UserMarshal(&umcb.Flags, buffer + 1, &hwnd);
241 ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
242 wirehwnd = (wireHWND)(buffer + 4);
243 ok(wirehwnd->fContext == WDT_INPROC_CALL, "Context should be WDT_INPROC_CALL instead of 0x%08x\n", wirehwnd->fContext);
244 ok(wirehwnd->u.hInproc == (LONG_PTR)hwnd, "Marshaled value should be %p instead of %x\n", hwnd, wirehwnd->u.hRemote);
245
246 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
247 buffer_end = HWND_UserUnmarshal(&umcb.Flags, buffer + 1, &hwnd2);
248 ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
249 ok(hwnd == hwnd2, "Didn't unmarshal properly\n");
250 HeapFree(GetProcessHeap(), 0, buffer);
251
252 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
253 HWND_UserFree(&umcb.Flags, &hwnd2);
254 }
255
256 static void test_marshal_HGLOBAL(void)
257 {
258 USER_MARSHAL_CB umcb;
259 MIDL_STUB_MESSAGE stub_msg;
260 RPC_MESSAGE rpc_msg;
261 unsigned char *buffer;
262 ULONG size, block_size;
263 HGLOBAL hglobal;
264 HGLOBAL hglobal2;
265 unsigned char *wirehglobal;
266 int i;
267
268 hglobal = NULL;
269 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
270 size = HGLOBAL_UserSize(&umcb.Flags, 0, &hglobal);
271 /* native is poorly programmed and allocates 4/8 bytes more than it needs to
272 * here - Wine doesn't have to emulate that */
273 ok((size == 8) || broken(size == 12) || broken(size == 16), "Size should be 8, instead of %d\n", size);
274 buffer = HeapAlloc(GetProcessHeap(), 0, size);
275 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
276 HGLOBAL_UserMarshal(&umcb.Flags, buffer, &hglobal);
277 wirehglobal = buffer;
278 ok(*(ULONG *)wirehglobal == WDT_REMOTE_CALL, "Context should be WDT_REMOTE_CALL instead of 0x%08x\n", *(ULONG *)wirehglobal);
279 wirehglobal += sizeof(ULONG);
280 ok(*(ULONG *)wirehglobal == 0, "buffer+4 should be HGLOBAL\n");
281 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
282 hglobal2 = NULL;
283 HGLOBAL_UserUnmarshal(&umcb.Flags, buffer, &hglobal2);
284 ok(hglobal2 == hglobal, "Didn't unmarshal properly\n");
285 HeapFree(GetProcessHeap(), 0, buffer);
286 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
287 HGLOBAL_UserFree(&umcb.Flags, &hglobal2);
288
289
290 for(block_size = 0; block_size <= 17; block_size++)
291 {
292 ULONG actual_size, expected_size;
293
294 hglobal = GlobalAlloc(0, block_size);
295 buffer = GlobalLock(hglobal);
296 for (i = 0; i < block_size; i++)
297 buffer[i] = i;
298 GlobalUnlock(hglobal);
299 actual_size = GlobalSize(hglobal);
300 expected_size = actual_size + 5 * sizeof(DWORD);
301 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
302 size = HGLOBAL_UserSize(&umcb.Flags, 0, &hglobal);
303 /* native is poorly programmed and allocates 4/8 bytes more than it needs to
304 * here - Wine doesn't have to emulate that */
305 ok(size == expected_size ||
306 broken(size == expected_size + 4) ||
307 broken(size == expected_size + 8),
308 "%d: got size %d\n", block_size, size);
309 buffer = HeapAlloc(GetProcessHeap(), 0, size);
310 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
311 HGLOBAL_UserMarshal(&umcb.Flags, buffer, &hglobal);
312 wirehglobal = buffer;
313 ok(*(ULONG *)wirehglobal == WDT_REMOTE_CALL, "Context should be WDT_REMOTE_CALL instead of 0x%08x\n", *(ULONG *)wirehglobal);
314 wirehglobal += sizeof(ULONG);
315 ok(*(ULONG *)wirehglobal == (ULONG)(ULONG_PTR)hglobal, "buffer+0x4 should be HGLOBAL\n");
316 wirehglobal += sizeof(ULONG);
317 ok(*(ULONG *)wirehglobal == actual_size, "%d: buffer+0x8 %08x\n", block_size, *(ULONG *)wirehglobal);
318 wirehglobal += sizeof(ULONG);
319 ok(*(ULONG *)wirehglobal == (ULONG)(ULONG_PTR)hglobal, "buffer+0xc should be HGLOBAL\n");
320 wirehglobal += sizeof(ULONG);
321 ok(*(ULONG *)wirehglobal == actual_size, "%d: buffer+0x10 %08x\n", block_size, *(ULONG *)wirehglobal);
322 wirehglobal += sizeof(ULONG);
323 for (i = 0; i < block_size; i++)
324 ok(wirehglobal[i] == i, "buffer+0x%x should be %d\n", 0x10 + i, i);
325
326 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
327 hglobal2 = NULL;
328 HGLOBAL_UserUnmarshal(&umcb.Flags, buffer, &hglobal2);
329 ok(hglobal2 != NULL, "Didn't unmarshal properly\n");
330 HeapFree(GetProcessHeap(), 0, buffer);
331 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
332 HGLOBAL_UserFree(&umcb.Flags, &hglobal2);
333 GlobalFree(hglobal);
334 }
335 }
336
337 static HENHMETAFILE create_emf(void)
338 {
339 const RECT rect = {0, 0, 100, 100};
340 HDC hdc = CreateEnhMetaFileA(NULL, NULL, &rect, "HENHMETAFILE Marshaling Test\0Test\0\0");
341 ExtTextOutA(hdc, 0, 0, ETO_OPAQUE, &rect, "Test String", strlen("Test String"), NULL);
342 return CloseEnhMetaFile(hdc);
343 }
344
345 static void test_marshal_HENHMETAFILE(void)
346 {
347 USER_MARSHAL_CB umcb;
348 MIDL_STUB_MESSAGE stub_msg;
349 RPC_MESSAGE rpc_msg;
350 unsigned char *buffer, *buffer_end;
351 ULONG size;
352 HENHMETAFILE hemf;
353 HENHMETAFILE hemf2 = NULL;
354 unsigned char *wirehemf;
355
356 hemf = create_emf();
357
358 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
359 size = HENHMETAFILE_UserSize(&umcb.Flags, 1, &hemf);
360 ok(size > 24, "size should be at least 24 bytes, not %d\n", size);
361 buffer = HeapAlloc(GetProcessHeap(), 0, size);
362 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
363 buffer_end = HENHMETAFILE_UserMarshal(&umcb.Flags, buffer + 1, &hemf);
364 ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
365 wirehemf = buffer + 4;
366 ok(*(DWORD *)wirehemf == WDT_REMOTE_CALL, "wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(DWORD *)wirehemf);
367 wirehemf += sizeof(DWORD);
368 ok(*(DWORD *)wirehemf == (DWORD)(DWORD_PTR)hemf, "wirestgm + 0x4 should be hemf instead of 0x%08x\n", *(DWORD *)wirehemf);
369 wirehemf += sizeof(DWORD);
370 ok(*(DWORD *)wirehemf == (size - 0x14), "wirestgm + 0x8 should be size - 0x14 instead of 0x%08x\n", *(DWORD *)wirehemf);
371 wirehemf += sizeof(DWORD);
372 ok(*(DWORD *)wirehemf == (size - 0x14), "wirestgm + 0xc should be size - 0x14 instead of 0x%08x\n", *(DWORD *)wirehemf);
373 wirehemf += sizeof(DWORD);
374 ok(*(DWORD *)wirehemf == EMR_HEADER, "wirestgm + 0x10 should be EMR_HEADER instead of %d\n", *(DWORD *)wirehemf);
375 /* ... rest of data not tested - refer to tests for GetEnhMetaFileBits
376 * at this point */
377
378 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
379 buffer_end = HENHMETAFILE_UserUnmarshal(&umcb.Flags, buffer + 1, &hemf2);
380 ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
381 ok(hemf2 != NULL, "HENHMETAFILE didn't unmarshal\n");
382 HeapFree(GetProcessHeap(), 0, buffer);
383 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
384 HENHMETAFILE_UserFree(&umcb.Flags, &hemf2);
385 DeleteEnhMetaFile(hemf);
386
387 /* test NULL emf */
388 hemf = NULL;
389
390 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
391 size = HENHMETAFILE_UserSize(&umcb.Flags, 1, &hemf);
392 ok(size == 12, "size should be 12 bytes, not %d\n", size);
393 buffer = HeapAlloc(GetProcessHeap(), 0, size);
394 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
395 buffer_end = HENHMETAFILE_UserMarshal(&umcb.Flags, buffer + 1, &hemf);
396 ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
397 wirehemf = buffer + 4;
398 ok(*(DWORD *)wirehemf == WDT_REMOTE_CALL, "wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(DWORD *)wirehemf);
399 wirehemf += sizeof(DWORD);
400 ok(*(DWORD *)wirehemf == (DWORD)(DWORD_PTR)hemf, "wirestgm + 0x4 should be hemf instead of 0x%08x\n", *(DWORD *)wirehemf);
401
402 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
403 buffer_end = HENHMETAFILE_UserUnmarshal(&umcb.Flags, buffer + 1, &hemf2);
404 ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
405 ok(hemf2 == NULL, "NULL HENHMETAFILE didn't unmarshal\n");
406 HeapFree(GetProcessHeap(), 0, buffer);
407 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
408 HENHMETAFILE_UserFree(&umcb.Flags, &hemf2);
409 }
410
411 static HMETAFILE create_mf(void)
412 {
413 RECT rect = {0, 0, 100, 100};
414 HDC hdc = CreateMetaFileA(NULL);
415 ExtTextOutA(hdc, 0, 0, ETO_OPAQUE, &rect, "Test String", strlen("Test String"), NULL);
416 return CloseMetaFile(hdc);
417 }
418
419 static void test_marshal_HMETAFILE(void)
420 {
421 USER_MARSHAL_CB umcb;
422 MIDL_STUB_MESSAGE stub_msg;
423 RPC_MESSAGE rpc_msg;
424 unsigned char *buffer;
425 ULONG size;
426 HMETAFILE hmf;
427 HMETAFILE hmf2 = NULL;
428 unsigned char *wirehmf;
429
430 hmf = create_mf();
431
432 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
433 size = HMETAFILE_UserSize(&umcb.Flags, 0, &hmf);
434 ok(size > 20, "size should be at least 20 bytes, not %d\n", size);
435 buffer = HeapAlloc(GetProcessHeap(), 0, size);
436 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
437 HMETAFILE_UserMarshal(&umcb.Flags, buffer, &hmf);
438 wirehmf = buffer;
439 ok(*(DWORD *)wirehmf == WDT_REMOTE_CALL, "wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(DWORD *)wirehmf);
440 wirehmf += sizeof(DWORD);
441 ok(*(DWORD *)wirehmf == (DWORD)(DWORD_PTR)hmf, "wirestgm + 0x4 should be hmf instead of 0x%08x\n", *(DWORD *)wirehmf);
442 wirehmf += sizeof(DWORD);
443 ok(*(DWORD *)wirehmf == (size - 0x10), "wirestgm + 0x8 should be size - 0x10 instead of 0x%08x\n", *(DWORD *)wirehmf);
444 wirehmf += sizeof(DWORD);
445 ok(*(DWORD *)wirehmf == (size - 0x10), "wirestgm + 0xc should be size - 0x10 instead of 0x%08x\n", *(DWORD *)wirehmf);
446 wirehmf += sizeof(DWORD);
447 ok(*(WORD *)wirehmf == 1, "wirestgm + 0x10 should be 1 instead of 0x%08x\n", *(DWORD *)wirehmf);
448 wirehmf += sizeof(DWORD);
449 /* ... rest of data not tested - refer to tests for GetMetaFileBits
450 * at this point */
451
452 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
453 HMETAFILE_UserUnmarshal(&umcb.Flags, buffer, &hmf2);
454 ok(hmf2 != NULL, "HMETAFILE didn't unmarshal\n");
455 HeapFree(GetProcessHeap(), 0, buffer);
456 HMETAFILE_UserFree(&umcb.Flags, &hmf2);
457 DeleteMetaFile(hmf);
458
459 /* test NULL emf */
460 hmf = NULL;
461
462 size = HMETAFILE_UserSize(&umcb.Flags, 0, &hmf);
463 ok(size == 8, "size should be 8 bytes, not %d\n", size);
464 buffer = HeapAlloc(GetProcessHeap(), 0, size);
465 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
466 HMETAFILE_UserMarshal(&umcb.Flags, buffer, &hmf);
467 wirehmf = buffer;
468 ok(*(DWORD *)wirehmf == WDT_REMOTE_CALL, "wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(DWORD *)wirehmf);
469 wirehmf += sizeof(DWORD);
470 ok(*(DWORD *)wirehmf == (DWORD)(DWORD_PTR)hmf, "wirestgm + 0x4 should be hmf instead of 0x%08x\n", *(DWORD *)wirehmf);
471 wirehmf += sizeof(DWORD);
472
473 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
474 HMETAFILE_UserUnmarshal(&umcb.Flags, buffer, &hmf2);
475 ok(hmf2 == NULL, "NULL HMETAFILE didn't unmarshal\n");
476 HeapFree(GetProcessHeap(), 0, buffer);
477 HMETAFILE_UserFree(&umcb.Flags, &hmf2);
478 }
479
480 #define USER_MARSHAL_PTR_PREFIX \
481 ( (DWORD)'U' | ( (DWORD)'s' << 8 ) | \
482 ( (DWORD)'e' << 16 ) | ( (DWORD)'r' << 24 ) )
483
484 static void test_marshal_HMETAFILEPICT(void)
485 {
486 USER_MARSHAL_CB umcb;
487 MIDL_STUB_MESSAGE stub_msg;
488 RPC_MESSAGE rpc_msg;
489 unsigned char *buffer, *buffer_end;
490 ULONG size;
491 HMETAFILEPICT hmfp;
492 HMETAFILEPICT hmfp2 = NULL;
493 METAFILEPICT *pmfp;
494 unsigned char *wirehmfp;
495
496 hmfp = GlobalAlloc(GMEM_MOVEABLE, sizeof(*pmfp));
497 pmfp = GlobalLock(hmfp);
498 pmfp->mm = MM_ISOTROPIC;
499 pmfp->xExt = 1;
500 pmfp->yExt = 2;
501 pmfp->hMF = create_mf();
502 GlobalUnlock(hmfp);
503
504 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
505 size = HMETAFILEPICT_UserSize(&umcb.Flags, 1, &hmfp);
506 ok(size > 24, "size should be at least 24 bytes, not %d\n", size);
507 buffer = HeapAlloc(GetProcessHeap(), 0, size);
508 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
509 buffer_end = HMETAFILEPICT_UserMarshal(&umcb.Flags, buffer + 1, &hmfp);
510 wirehmfp = buffer + 4;
511 ok(*(DWORD *)wirehmfp == WDT_REMOTE_CALL, "wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(DWORD *)wirehmfp);
512 wirehmfp += sizeof(DWORD);
513 ok(*(DWORD *)wirehmfp == (DWORD)(DWORD_PTR)hmfp, "wirestgm + 0x4 should be hmf instead of 0x%08x\n", *(DWORD *)wirehmfp);
514 wirehmfp += sizeof(DWORD);
515 ok(*(DWORD *)wirehmfp == MM_ISOTROPIC, "wirestgm + 0x8 should be MM_ISOTROPIC instead of 0x%08x\n", *(DWORD *)wirehmfp);
516 wirehmfp += sizeof(DWORD);
517 ok(*(DWORD *)wirehmfp == 1, "wirestgm + 0xc should be 1 instead of 0x%08x\n", *(DWORD *)wirehmfp);
518 wirehmfp += sizeof(DWORD);
519 ok(*(DWORD *)wirehmfp == 2, "wirestgm + 0x10 should be 2 instead of 0x%08x\n", *(DWORD *)wirehmfp);
520 wirehmfp += sizeof(DWORD);
521 ok(*(DWORD *)wirehmfp == USER_MARSHAL_PTR_PREFIX, "wirestgm + 0x14 should be \"User\" instead of 0x%08x\n", *(DWORD *)wirehmfp);
522 wirehmfp += sizeof(DWORD);
523 ok(*(DWORD *)wirehmfp == WDT_REMOTE_CALL, "wirestgm + 0x18 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(DWORD *)wirehmfp);
524 wirehmfp += sizeof(DWORD);
525 pmfp = GlobalLock(hmfp);
526 ok(*(DWORD *)wirehmfp == (DWORD)(DWORD_PTR)pmfp->hMF, "wirestgm + 0x1c should be pmfp->hMF instead of 0x%08x\n", *(DWORD *)wirehmfp);
527 GlobalUnlock(hmfp);
528 wirehmfp += sizeof(DWORD);
529 /* Note use (buffer_end - buffer) instead of size here, because size is an
530 * overestimate with native */
531 ok(*(DWORD *)wirehmfp == (buffer_end - buffer - 0x2c), "wirestgm + 0x20 should be size - 0x34 instead of 0x%08x\n", *(DWORD *)wirehmfp);
532 wirehmfp += sizeof(DWORD);
533 ok(*(DWORD *)wirehmfp == (buffer_end - buffer - 0x2c), "wirestgm + 0x24 should be size - 0x34 instead of 0x%08x\n", *(DWORD *)wirehmfp);
534 wirehmfp += sizeof(DWORD);
535 ok(*(WORD *)wirehmfp == 1, "wirehmfp + 0x28 should be 1 instead of 0x%08x\n", *(DWORD *)wirehmfp);
536 /* ... rest of data not tested - refer to tests for GetMetaFileBits
537 * at this point */
538
539 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
540 HMETAFILEPICT_UserUnmarshal(&umcb.Flags, buffer + 1, &hmfp2);
541 ok(hmfp2 != NULL, "HMETAFILEPICT didn't unmarshal\n");
542 HeapFree(GetProcessHeap(), 0, buffer);
543 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
544 HMETAFILEPICT_UserFree(&umcb.Flags, &hmfp2);
545 pmfp = GlobalLock(hmfp);
546 DeleteMetaFile(pmfp->hMF);
547 GlobalUnlock(hmfp);
548 GlobalFree(hmfp);
549
550 /* test NULL emf */
551 hmfp = NULL;
552
553 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
554 size = HMETAFILEPICT_UserSize(&umcb.Flags, 1, &hmfp);
555 ok(size == 12, "size should be 12 bytes, not %d\n", size);
556 buffer = HeapAlloc(GetProcessHeap(), 0, size);
557 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
558 buffer_end = HMETAFILEPICT_UserMarshal(&umcb.Flags, buffer + 1, &hmfp);
559 ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
560 wirehmfp = buffer + 4;
561 ok(*(DWORD *)wirehmfp == WDT_REMOTE_CALL, "wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(DWORD *)wirehmfp);
562 wirehmfp += sizeof(DWORD);
563 ok(*(DWORD *)wirehmfp == (DWORD)(DWORD_PTR)hmfp, "wirestgm + 0x4 should be hmf instead of 0x%08x\n", *(DWORD *)wirehmfp);
564 wirehmfp += sizeof(DWORD);
565
566 hmfp2 = NULL;
567 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
568 buffer_end = HMETAFILEPICT_UserUnmarshal(&umcb.Flags, buffer + 1, &hmfp2);
569 ok(buffer_end == buffer + size, "got %p buffer %p\n", buffer_end, buffer);
570 ok(hmfp2 == NULL, "NULL HMETAFILE didn't unmarshal\n");
571 HeapFree(GetProcessHeap(), 0, buffer);
572 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
573 HMETAFILEPICT_UserFree(&umcb.Flags, &hmfp2);
574 }
575
576 typedef struct
577 {
578 IUnknown IUnknown_iface;
579 LONG refs;
580 } TestUnknown;
581
582 static inline TestUnknown *impl_from_IUnknown(IUnknown *iface)
583 {
584 return CONTAINING_RECORD(iface, TestUnknown, IUnknown_iface);
585 }
586
587 static HRESULT WINAPI Test_IUnknown_QueryInterface(
588 LPUNKNOWN iface,
589 REFIID riid,
590 LPVOID *ppvObj)
591 {
592 if (ppvObj == NULL) return E_POINTER;
593
594 if (IsEqualGUID(riid, &IID_IUnknown))
595 {
596 *ppvObj = iface;
597 IUnknown_AddRef(iface);
598 return S_OK;
599 }
600
601 *ppvObj = NULL;
602 return E_NOINTERFACE;
603 }
604
605 static ULONG WINAPI Test_IUnknown_AddRef(LPUNKNOWN iface)
606 {
607 TestUnknown *This = impl_from_IUnknown(iface);
608 return InterlockedIncrement(&This->refs);
609 }
610
611 static ULONG WINAPI Test_IUnknown_Release(LPUNKNOWN iface)
612 {
613 TestUnknown *This = impl_from_IUnknown(iface);
614 return InterlockedDecrement(&This->refs);
615 }
616
617 static const IUnknownVtbl TestUnknown_Vtbl =
618 {
619 Test_IUnknown_QueryInterface,
620 Test_IUnknown_AddRef,
621 Test_IUnknown_Release,
622 };
623
624 struct test_stream
625 {
626 IStream IStream_iface;
627 LONG refs;
628 };
629
630 static inline struct test_stream *impl_from_IStream(IStream *iface)
631 {
632 return CONTAINING_RECORD(iface, struct test_stream, IStream_iface);
633 }
634
635 static HRESULT WINAPI Test_IStream_QueryInterface(IStream *iface,
636 REFIID riid, LPVOID *ppvObj)
637 {
638 if (ppvObj == NULL) return E_POINTER;
639
640 if (IsEqualIID(riid, &IID_IUnknown) ||
641 IsEqualIID(riid, &IID_IStream))
642 {
643 *ppvObj = iface;
644 IStream_AddRef(iface);
645 return S_OK;
646 }
647
648 *ppvObj = NULL;
649 return E_NOINTERFACE;
650 }
651
652 static ULONG WINAPI Test_IStream_AddRef(IStream *iface)
653 {
654 struct test_stream *This = impl_from_IStream(iface);
655 return InterlockedIncrement(&This->refs);
656 }
657
658 static ULONG WINAPI Test_IStream_Release(IStream *iface)
659 {
660 struct test_stream *This = impl_from_IStream(iface);
661 return InterlockedDecrement(&This->refs);
662 }
663
664 static const IStreamVtbl TestStream_Vtbl =
665 {
666 Test_IStream_QueryInterface,
667 Test_IStream_AddRef,
668 Test_IStream_Release
669 /* the rest can be NULLs */
670 };
671
672 static TestUnknown Test_Unknown = { {&TestUnknown_Vtbl}, 1 };
673 static TestUnknown Test_Unknown2 = { {&TestUnknown_Vtbl}, 1 };
674 static struct test_stream Test_Stream = { {&TestStream_Vtbl}, 1 };
675 static struct test_stream Test_Stream2 = { {&TestStream_Vtbl}, 1 };
676
677 ULONG __RPC_USER WdtpInterfacePointer_UserSize(ULONG *, ULONG, ULONG, IUnknown *, REFIID);
678 unsigned char * __RPC_USER WdtpInterfacePointer_UserMarshal(ULONG *, ULONG, unsigned char *, IUnknown *, REFIID);
679 unsigned char * __RPC_USER WdtpInterfacePointer_UserUnmarshal(ULONG *, unsigned char *, IUnknown **, REFIID);
680
681 static void marshal_WdtpInterfacePointer(DWORD umcb_ctx, DWORD ctx, BOOL client, BOOL in, BOOL out)
682 {
683 USER_MARSHAL_CB umcb;
684 MIDL_STUB_MESSAGE stub_msg;
685 RPC_MESSAGE rpc_msg;
686 unsigned char *buffer, *buffer_end;
687 ULONG size;
688 IUnknown *unk;
689 IUnknown *unk2;
690 unsigned char *wireip;
691 HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE, 0);
692 IStream *stm;
693 void *marshal_data;
694 LARGE_INTEGER zero;
695 ULARGE_INTEGER pos;
696 DWORD marshal_size;
697
698 /* shows that the WdtpInterfacePointer functions don't marshal anything for
699 * NULL pointers, so code using these functions must handle that case
700 * itself */
701
702 unk = NULL;
703 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, umcb_ctx);
704 size = WdtpInterfacePointer_UserSize(&umcb.Flags, ctx, 0, unk, &IID_IUnknown);
705 ok(size == 0, "size should be 0 bytes, not %d\n", size);
706 buffer = HeapAlloc(GetProcessHeap(), 0, size);
707 buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, ctx, buffer, unk, &IID_IUnknown);
708 ok(buffer_end == buffer, "buffer_end %p buffer %p\n", buffer_end, buffer);
709 HeapFree(GetProcessHeap(), 0, buffer);
710
711 /* Now for a non-NULL pointer. The marshalled data are two size DWORDS and then
712 the result of CoMarshalInterface called with the LOWORD of the ctx */
713
714 unk = &Test_Unknown.IUnknown_iface;
715 Test_Unknown.refs = 1;
716
717 CreateStreamOnHGlobal(h, TRUE, &stm);
718 CoMarshalInterface(stm, &IID_IUnknown, unk, LOWORD(ctx), NULL, MSHLFLAGS_NORMAL);
719 zero.QuadPart = 0;
720 IStream_Seek(stm, zero, STREAM_SEEK_CUR, &pos);
721 marshal_size = pos.u.LowPart;
722 marshal_data = GlobalLock(h);
723 todo_wine
724 ok(Test_Unknown.refs == 2, "got %d\n", Test_Unknown.refs);
725
726 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, umcb_ctx);
727 size = WdtpInterfacePointer_UserSize(&umcb.Flags, ctx, 0, unk, &IID_IUnknown);
728 ok(size >= marshal_size + 2 * sizeof(DWORD), "marshal size %x got %x\n", marshal_size, size);
729 buffer = HeapAlloc(GetProcessHeap(), 0, size);
730 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, umcb_ctx);
731 buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, ctx, buffer, unk, &IID_IUnknown);
732 todo_wine
733 ok(Test_Unknown.refs == 2, "got %d\n", Test_Unknown.refs);
734 wireip = buffer;
735
736 ok(buffer_end == buffer + marshal_size + 2 * sizeof(DWORD), "buffer_end %p buffer %p\n", buffer_end, buffer);
737
738 ok(*(DWORD *)wireip == marshal_size, "wireip + 0x0 should be %x instead of %x\n", marshal_size, *(DWORD *)wireip);
739 wireip += sizeof(DWORD);
740 ok(*(DWORD *)wireip == marshal_size, "wireip + 0x4 should be %x instead of %x\n", marshal_size, *(DWORD *)wireip);
741 wireip += sizeof(DWORD);
742
743 ok(!memcmp(marshal_data, wireip, marshal_size), "buffer mismatch\n");
744 GlobalUnlock(h);
745 zero.QuadPart = 0;
746 IStream_Seek(stm, zero, STREAM_SEEK_SET, NULL);
747 CoReleaseMarshalData(stm);
748 IStream_Release(stm);
749
750 Test_Unknown2.refs = 1;
751 unk2 = &Test_Unknown2.IUnknown_iface;
752 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, umcb_ctx);
753 umcb.pStubMsg->IsClient = client;
754 umcb.pStubMsg->fIsIn = in;
755 umcb.pStubMsg->fIsOut = out;
756
757 WdtpInterfacePointer_UserUnmarshal(&umcb.Flags, buffer, &unk2, &IID_IUnknown);
758 ok(unk2 != NULL, "IUnknown object didn't unmarshal properly\n");
759 ok(Test_Unknown.refs == 2, "got %d\n", Test_Unknown.refs);
760 ok(Test_Unknown2.refs == 0, "got %d\n", Test_Unknown2.refs);
761 HeapFree(GetProcessHeap(), 0, buffer);
762 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_INPROC);
763 IUnknown_Release(unk2);
764 }
765
766 static void test_marshal_WdtpInterfacePointer(void)
767 {
768 /*
769 * There are two places where we can pass the marshalling ctx: as
770 * part of the umcb and as a separate flag. The loword of that
771 * separate flag field is what matters.
772 */
773
774 /* All three are marshalled as inproc */
775 marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_INPROC, 0,0,0);
776 marshal_WdtpInterfacePointer(MSHCTX_DIFFERENTMACHINE, MSHCTX_INPROC,0,0,0);
777 marshal_WdtpInterfacePointer(MSHCTX_INPROC, MAKELONG(MSHCTX_INPROC, 0xffff),0,0,0);
778
779 /* All three are marshalled as remote */
780 marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,0,0,0);
781 marshal_WdtpInterfacePointer(MSHCTX_DIFFERENTMACHINE, MSHCTX_DIFFERENTMACHINE,0,0,0);
782 marshal_WdtpInterfacePointer(MSHCTX_INPROC, MAKELONG(MSHCTX_DIFFERENTMACHINE, 0xffff),0,0,0);
783
784 /* Test different combinations of client, in and out */
785 marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,0,0,1);
786 marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,0,1,0);
787 marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,0,1,1);
788 marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,1,0,0);
789 marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,1,0,1);
790 marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,1,1,0);
791 marshal_WdtpInterfacePointer(MSHCTX_INPROC, MSHCTX_DIFFERENTMACHINE,1,1,1);
792 }
793
794 static void marshal_STGMEDIUM(BOOL client, BOOL in, BOOL out)
795 {
796 USER_MARSHAL_CB umcb;
797 MIDL_STUB_MESSAGE stub_msg;
798 RPC_MESSAGE rpc_msg;
799 unsigned char *buffer, *buffer_end, *expect_buffer, *expect_buffer_end;
800 ULONG size, expect_size;
801 STGMEDIUM med, med2;
802 IUnknown *unk = &Test_Unknown.IUnknown_iface;
803 IStream *stm = &Test_Stream.IStream_iface;
804
805 /* TYMED_NULL with pUnkForRelease */
806
807 Test_Unknown.refs = 1;
808
809 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
810 expect_size = WdtpInterfacePointer_UserSize(&umcb.Flags, umcb.Flags, 2 * sizeof(DWORD), unk, &IID_IUnknown);
811 expect_buffer = HeapAlloc(GetProcessHeap(), 0, expect_size);
812 *(DWORD*)expect_buffer = TYMED_NULL;
813 *((DWORD*)expect_buffer + 1) = 0xdeadbeef;
814 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, expect_buffer, expect_size, MSHCTX_DIFFERENTMACHINE);
815 expect_buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, umcb.Flags, expect_buffer + 2 * sizeof(DWORD), unk, &IID_IUnknown);
816
817 med.tymed = TYMED_NULL;
818 U(med).pstg = NULL;
819 med.pUnkForRelease = unk;
820
821 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
822 size = STGMEDIUM_UserSize(&umcb.Flags, 0, &med);
823 ok(size == expect_size, "size %d should be %d bytes\n", size, expect_size);
824
825 buffer = HeapAlloc(GetProcessHeap(), 0, size);
826 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
827 buffer_end = STGMEDIUM_UserMarshal(&umcb.Flags, buffer, &med);
828 ok(buffer_end - buffer == expect_buffer_end - expect_buffer, "buffer size mismatch\n");
829 ok(*(DWORD*)buffer == TYMED_NULL, "got %08x\n", *(DWORD*)buffer);
830 ok(*((DWORD*)buffer+1) != 0, "got %08x\n", *((DWORD*)buffer+1));
831 ok(!memcmp(buffer+8, expect_buffer + 8, expect_buffer_end - expect_buffer - 8), "buffer mismatch\n");
832
833 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
834 umcb.pStubMsg->IsClient = client;
835 umcb.pStubMsg->fIsIn = in;
836 umcb.pStubMsg->fIsOut = out;
837
838 Test_Unknown2.refs = 1;
839 med2.tymed = TYMED_NULL;
840 U(med2).pstm = NULL;
841 med2.pUnkForRelease = &Test_Unknown2.IUnknown_iface;
842
843 STGMEDIUM_UserUnmarshal(&umcb.Flags, buffer, &med2);
844
845 ok(med2.tymed == TYMED_NULL, "got tymed %x\n", med2.tymed);
846 ok(med2.pUnkForRelease != NULL, "Incorrectly unmarshalled\n");
847 ok(Test_Unknown2.refs == 0, "got %d\n", Test_Unknown2.refs);
848
849 HeapFree(GetProcessHeap(), 0, buffer);
850 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
851 STGMEDIUM_UserFree(&umcb.Flags, &med2);
852
853 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, expect_buffer, expect_size, MSHCTX_DIFFERENTMACHINE);
854 med2.tymed = TYMED_NULL;
855 U(med2).pstm = NULL;
856 med2.pUnkForRelease = NULL;
857 STGMEDIUM_UserUnmarshal(&umcb.Flags, expect_buffer, &med2);
858 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
859 STGMEDIUM_UserFree(&umcb.Flags, &med2);
860
861 ok(Test_Unknown.refs == 1, "got %d\n", Test_Unknown.refs);
862
863 HeapFree(GetProcessHeap(), 0, expect_buffer);
864
865 /* TYMED_ISTREAM with pUnkForRelease */
866
867 Test_Unknown.refs = 1;
868 Test_Stream.refs = 1;
869
870 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
871 expect_size = WdtpInterfacePointer_UserSize(&umcb.Flags, umcb.Flags, 3 * sizeof(DWORD), (IUnknown*)stm, &IID_IStream);
872 expect_size = WdtpInterfacePointer_UserSize(&umcb.Flags, umcb.Flags, expect_size, unk, &IID_IUnknown);
873
874 expect_buffer = HeapAlloc(GetProcessHeap(), 0, expect_size);
875 /* There may be a hole between the two interfaces so init the buffer to something */
876 memset(expect_buffer, 0xcc, expect_size);
877 *(DWORD*)expect_buffer = TYMED_ISTREAM;
878 *((DWORD*)expect_buffer + 1) = 0xdeadbeef;
879 *((DWORD*)expect_buffer + 2) = 0xcafe;
880 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, expect_buffer, expect_size, MSHCTX_DIFFERENTMACHINE);
881 expect_buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, umcb.Flags, expect_buffer + 3 * sizeof(DWORD), (IUnknown*)stm, &IID_IStream);
882 expect_buffer_end = WdtpInterfacePointer_UserMarshal(&umcb.Flags, umcb.Flags, expect_buffer_end, unk, &IID_IUnknown);
883
884 med.tymed = TYMED_ISTREAM;
885 U(med).pstm = stm;
886 med.pUnkForRelease = unk;
887
888 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
889 size = STGMEDIUM_UserSize(&umcb.Flags, 0, &med);
890 ok(size == expect_size, "size %d should be %d bytes\n", size, expect_size);
891
892 buffer = HeapAlloc(GetProcessHeap(), 0, size);
893 memset(buffer, 0xcc, size);
894 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
895 buffer_end = STGMEDIUM_UserMarshal(&umcb.Flags, buffer, &med);
896 ok(buffer_end - buffer == expect_buffer_end - expect_buffer, "buffer size mismatch\n");
897 ok(*(DWORD*)buffer == TYMED_ISTREAM, "got %08x\n", *(DWORD*)buffer);
898 ok(*((DWORD*)buffer+1) != 0, "got %08x\n", *((DWORD*)buffer+1));
899 ok(*((DWORD*)buffer+2) != 0, "got %08x\n", *((DWORD*)buffer+2));
900 ok(!memcmp(buffer + 12, expect_buffer + 12, (buffer_end - buffer) - 12), "buffer mismatch\n");
901
902 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
903 umcb.pStubMsg->IsClient = client;
904 umcb.pStubMsg->fIsIn = in;
905 umcb.pStubMsg->fIsOut = out;
906
907 Test_Stream2.refs = 1;
908 Test_Unknown2.refs = 1;
909 med2.tymed = TYMED_ISTREAM;
910 U(med2).pstm = &Test_Stream2.IStream_iface;
911 med2.pUnkForRelease = &Test_Unknown2.IUnknown_iface;
912
913 STGMEDIUM_UserUnmarshal(&umcb.Flags, buffer, &med2);
914
915 ok(med2.tymed == TYMED_ISTREAM, "got tymed %x\n", med2.tymed);
916 ok(U(med2).pstm != NULL, "Incorrectly unmarshalled\n");
917 ok(med2.pUnkForRelease != NULL, "Incorrectly unmarshalled\n");
918 ok(Test_Stream2.refs == 0, "got %d\n", Test_Stream2.refs);
919 ok(Test_Unknown2.refs == 0, "got %d\n", Test_Unknown2.refs);
920
921 HeapFree(GetProcessHeap(), 0, buffer);
922 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
923 STGMEDIUM_UserFree(&umcb.Flags, &med2);
924
925 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, expect_buffer, expect_size, MSHCTX_DIFFERENTMACHINE);
926 med2.tymed = TYMED_NULL;
927 U(med2).pstm = NULL;
928 med2.pUnkForRelease = NULL;
929 STGMEDIUM_UserUnmarshal(&umcb.Flags, expect_buffer, &med2);
930 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
931 STGMEDIUM_UserFree(&umcb.Flags, &med2);
932
933 ok(Test_Unknown.refs == 1, "got %d\n", Test_Unknown.refs);
934 ok(Test_Stream.refs == 1, "got %d\n", Test_Stream.refs);
935
936 HeapFree(GetProcessHeap(), 0, expect_buffer);
937
938 /* TYMED_ISTREAM = NULL with pUnkForRelease = NULL */
939
940 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
941 expect_size = 3 * sizeof(DWORD);
942
943 med.tymed = TYMED_ISTREAM;
944 U(med).pstm = NULL;
945 med.pUnkForRelease = NULL;
946
947 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
948 size = STGMEDIUM_UserSize(&umcb.Flags, 0, &med);
949 ok(size == expect_size, "size %d should be %d bytes\n", size, expect_size);
950
951 buffer = HeapAlloc(GetProcessHeap(), 0, size);
952 memset(buffer, 0xcc, size);
953 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
954 buffer_end = STGMEDIUM_UserMarshal(&umcb.Flags, buffer, &med);
955 ok(buffer_end - buffer == expect_size, "buffer size mismatch\n");
956 ok(*(DWORD*)buffer == TYMED_ISTREAM, "got %08x\n", *(DWORD*)buffer);
957 ok(*((DWORD*)buffer+1) == 0, "got %08x\n", *((DWORD*)buffer+1));
958 ok(*((DWORD*)buffer+2) == 0, "got %08x\n", *((DWORD*)buffer+2));
959
960 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE);
961 umcb.pStubMsg->IsClient = client;
962 umcb.pStubMsg->fIsIn = in;
963 umcb.pStubMsg->fIsOut = out;
964
965 Test_Stream2.refs = 1;
966 Test_Unknown2.refs = 1;
967 med2.tymed = TYMED_ISTREAM;
968 U(med2).pstm = &Test_Stream2.IStream_iface;
969 med2.pUnkForRelease = &Test_Unknown2.IUnknown_iface;
970
971 STGMEDIUM_UserUnmarshal(&umcb.Flags, buffer, &med2);
972
973 ok(med2.tymed == TYMED_ISTREAM, "got tymed %x\n", med2.tymed);
974 ok(U(med2).pstm == NULL, "Incorrectly unmarshalled\n");
975 ok(med2.pUnkForRelease == &Test_Unknown2.IUnknown_iface, "Incorrectly unmarshalled\n");
976 ok(Test_Stream2.refs == 0, "got %d\n", Test_Stream2.refs);
977 ok(Test_Unknown2.refs == 1, "got %d\n", Test_Unknown2.refs);
978
979 HeapFree(GetProcessHeap(), 0, buffer);
980 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE);
981 STGMEDIUM_UserFree(&umcb.Flags, &med2);
982 }
983
984 static void test_marshal_STGMEDIUM(void)
985 {
986 marshal_STGMEDIUM(0, 0, 0);
987 marshal_STGMEDIUM(0, 0, 1);
988 marshal_STGMEDIUM(0, 1, 0);
989 marshal_STGMEDIUM(0, 1, 1);
990 /* For Windows versions post 2003, client side, non-[in,out] STGMEDIUMs get zero-initialised.
991 However since inline stubs don't set fIsIn or fIsOut this behaviour would break
992 ref counting in GetDataHere_Proxy for example, as we'd end up not releasing the original
993 interface. For simplicity we don't test or implement this. */
994 marshal_STGMEDIUM(1, 1, 1);
995 }
996
997 static void test_marshal_SNB(void)
998 {
999 static const WCHAR str1W[] = {'s','t','r','i','n','g','1',0};
1000 static const WCHAR str2W[] = {'s','t','r','2',0};
1001 unsigned char *buffer, *src, *mbuf;
1002 MIDL_STUB_MESSAGE stub_msg;
1003 WCHAR **ptrW, *dataW;
1004 USER_MARSHAL_CB umcb;
1005 RPC_MESSAGE rpc_msg;
1006 RemSNB *wiresnb;
1007 SNB snb, snb2;
1008 ULONG size;
1009
1010 /* 4 bytes alignment */
1011 snb = NULL;
1012 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
1013 size = SNB_UserSize(&umcb.Flags, 3, &snb);
1014 ok(size == 16, "Size should be 16, instead of %d\n", size);
1015
1016 /* NULL block */
1017 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
1018 size = SNB_UserSize(&umcb.Flags, 0, &snb);
1019 ok(size == 12, "Size should be 12, instead of %d\n", size);
1020
1021 buffer = HeapAlloc(GetProcessHeap(), 0, size);
1022 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
1023 mbuf = SNB_UserMarshal(&umcb.Flags, buffer, &snb);
1024 ok(mbuf == buffer + size, "got %p, %p\n", mbuf, buffer + size);
1025
1026 wiresnb = (RemSNB*)buffer;
1027 ok(wiresnb->ulCntStr == 0, "got %u\n", wiresnb->ulCntStr);
1028 ok(wiresnb->ulCntChar == 0, "got %u\n", wiresnb->ulCntChar);
1029 ok(*(ULONG*)wiresnb->rgString == 0, "got %u\n", *(ULONG*)wiresnb->rgString);
1030
1031 snb2 = NULL;
1032 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
1033 SNB_UserUnmarshal(&umcb.Flags, buffer, &snb2);
1034 ok(snb2 == NULL, "got %p\n", snb2);
1035
1036 HeapFree(GetProcessHeap(), 0, buffer);
1037 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
1038 SNB_UserFree(&umcb.Flags, &snb2);
1039
1040 /* block with actual data */
1041
1042 /* allocate source block, n+1 pointers first, then data */
1043 src = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR*)*3 + sizeof(str1W) + sizeof(str2W));
1044 ptrW = (WCHAR**)src;
1045 dataW = *ptrW = (WCHAR*)(src + 3*sizeof(WCHAR*));
1046 ptrW++;
1047 *ptrW = (WCHAR*)(src + 3*sizeof(WCHAR*) + sizeof(str1W));
1048 ptrW++;
1049 *ptrW = NULL;
1050 lstrcpyW(dataW, str1W);
1051 dataW += lstrlenW(str1W) + 1;
1052 lstrcpyW(dataW, str2W);
1053
1054 snb = (SNB)src;
1055 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
1056 size = SNB_UserSize(&umcb.Flags, 0, &snb);
1057 ok(size == 38, "Size should be 38, instead of %d\n", size);
1058
1059 buffer = HeapAlloc(GetProcessHeap(), 0, size);
1060 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
1061 SNB_UserMarshal(&umcb.Flags, buffer, &snb);
1062
1063 wiresnb = (RemSNB*)buffer;
1064 ok(wiresnb->ulCntStr == 13, "got %u\n", wiresnb->ulCntStr);
1065 ok(wiresnb->ulCntChar == 2, "got %u\n", wiresnb->ulCntChar);
1066 /* payload length is stored one more time, as ULONG */
1067 ok(*(ULONG*)wiresnb->rgString == wiresnb->ulCntStr, "got %u\n", *(ULONG*)wiresnb->rgString);
1068 dataW = &wiresnb->rgString[2];
1069 ok(!lstrcmpW(dataW, str1W), "marshalled string 0: %s\n", wine_dbgstr_w(dataW));
1070 dataW += sizeof(str1W)/sizeof(WCHAR);
1071 ok(!lstrcmpW(dataW, str2W), "marshalled string 1: %s\n", wine_dbgstr_w(dataW));
1072
1073 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
1074
1075 g_expect_user_alloc = TRUE;
1076 snb2 = NULL;
1077 SNB_UserUnmarshal(&umcb.Flags, buffer, &snb2);
1078 g_expect_user_alloc = FALSE;
1079
1080 ptrW = snb2;
1081 ok(!lstrcmpW(*ptrW, str1W), "unmarshalled string 0: %s\n", wine_dbgstr_w(*ptrW));
1082 ptrW++;
1083 ok(!lstrcmpW(*ptrW, str2W), "unmarshalled string 1: %s\n", wine_dbgstr_w(*ptrW));
1084 ptrW++;
1085 ok(*ptrW == NULL, "expected terminating NULL ptr, got %p, start %p\n", *ptrW, snb2);
1086
1087 HeapFree(GetProcessHeap(), 0, buffer);
1088 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
1089
1090 g_expect_user_free = TRUE;
1091 SNB_UserFree(&umcb.Flags, &snb2);
1092 g_expect_user_free = FALSE;
1093
1094 HeapFree(GetProcessHeap(), 0, src);
1095 }
1096
1097 static void test_marshal_HDC(void)
1098 {
1099 MIDL_STUB_MESSAGE stub_msg;
1100 HDC hdc = GetDC(0), hdc2;
1101 USER_MARSHAL_CB umcb;
1102 RPC_MESSAGE rpc_msg;
1103 unsigned char *buffer, *buffer_end;
1104 wireHDC wirehdc;
1105 ULONG size;
1106
1107 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
1108 size = HDC_UserSize(&umcb.Flags, 1, &hdc);
1109 ok(size == 4 + sizeof(*wirehdc), "Wrong size %d\n", size);
1110
1111 buffer = HeapAlloc(GetProcessHeap(), 0, size);
1112 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
1113 buffer_end = HDC_UserMarshal(&umcb.Flags, buffer + 1, &hdc);
1114 ok(buffer_end == buffer + 4 + sizeof(*wirehdc), "got %p buffer %p\n", buffer_end, buffer);
1115 wirehdc = (wireHDC)(buffer + 4);
1116 ok(wirehdc->fContext == WDT_INPROC_CALL, "Context should be WDT_INPROC_CALL instead of 0x%08x\n", wirehdc->fContext);
1117 ok(wirehdc->u.hInproc == (LONG_PTR)hdc, "Marshaled value should be %p instead of %x\n", hdc, wirehdc->u.hRemote);
1118
1119 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
1120 buffer_end = HDC_UserUnmarshal(&umcb.Flags, buffer + 1, &hdc2);
1121 ok(buffer_end == buffer + 4 + sizeof(*wirehdc), "got %p buffer %p\n", buffer_end, buffer);
1122 ok(hdc == hdc2, "Didn't unmarshal properly\n");
1123 HeapFree(GetProcessHeap(), 0, buffer);
1124
1125 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
1126 HDC_UserFree(&umcb.Flags, &hdc2);
1127 ReleaseDC(0, hdc);
1128 }
1129
1130 static void test_marshal_HICON(void)
1131 {
1132 static const BYTE bmp_bits[1024];
1133 MIDL_STUB_MESSAGE stub_msg;
1134 HICON hIcon, hIcon2;
1135 USER_MARSHAL_CB umcb;
1136 RPC_MESSAGE rpc_msg;
1137 unsigned char *buffer, *buffer_end;
1138 wireHICON wirehicon;
1139 ULONG size;
1140
1141 hIcon = CreateIcon(0, 16, 16, 1, 1, bmp_bits, bmp_bits);
1142 ok(hIcon != 0, "CreateIcon failed\n");
1143
1144 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
1145 size = HICON_UserSize(&umcb.Flags, 1, &hIcon);
1146 ok(size == 4 + sizeof(*wirehicon), "Wrong size %d\n", size);
1147
1148 buffer = HeapAlloc(GetProcessHeap(), 0, size);
1149 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
1150 buffer_end = HICON_UserMarshal(&umcb.Flags, buffer + 1, &hIcon);
1151 ok(buffer_end == buffer + 4 + sizeof(*wirehicon), "got %p buffer %p\n", buffer_end, buffer);
1152 wirehicon = (wireHICON)(buffer + 4);
1153 ok(wirehicon->fContext == WDT_INPROC_CALL, "Context should be WDT_INPROC_CALL instead of 0x%08x\n", wirehicon->fContext);
1154 ok(wirehicon->u.hInproc == (LONG_PTR)hIcon, "Marshaled value should be %p instead of %x\n", hIcon, wirehicon->u.hRemote);
1155
1156 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
1157 buffer_end = HICON_UserUnmarshal(&umcb.Flags, buffer + 1, &hIcon2);
1158 ok(buffer_end == buffer + 4 + sizeof(*wirehicon), "got %p buffer %p\n", buffer_end, buffer);
1159 ok(hIcon == hIcon2, "Didn't unmarshal properly\n");
1160 HeapFree(GetProcessHeap(), 0, buffer);
1161
1162 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
1163 HICON_UserFree(&umcb.Flags, &hIcon2);
1164 DestroyIcon(hIcon);
1165 }
1166
1167 static void test_marshal_HBRUSH(void)
1168 {
1169 MIDL_STUB_MESSAGE stub_msg;
1170 HBRUSH hBrush, hBrush2;
1171 USER_MARSHAL_CB umcb;
1172 RPC_MESSAGE rpc_msg;
1173 unsigned char *buffer, *buffer_end;
1174 LOGBRUSH logbrush;
1175 wireHBRUSH wirehbrush;
1176 ULONG size;
1177
1178 logbrush.lbStyle = BS_SOLID;
1179 logbrush.lbColor = RGB(0, 0, 0);
1180 logbrush.lbHatch = 0;
1181
1182 hBrush = CreateBrushIndirect(&logbrush);
1183 ok(hBrush != 0, "CreateBrushIndirect failed\n");
1184
1185 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
1186 size = HBRUSH_UserSize(&umcb.Flags, 1, &hBrush);
1187 ok(size == 4 + sizeof(*wirehbrush), "Wrong size %d\n", size);
1188
1189 buffer = HeapAlloc(GetProcessHeap(), 0, size);
1190 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
1191 buffer_end = HBRUSH_UserMarshal(&umcb.Flags, buffer + 1, &hBrush);
1192 ok(buffer_end == buffer + 4 + sizeof(*wirehbrush), "got %p buffer %p\n", buffer_end, buffer);
1193 wirehbrush = (wireHBRUSH)(buffer + 4);
1194 ok(wirehbrush->fContext == WDT_INPROC_CALL, "Context should be WDT_INPROC_CALL instead of 0x%08x\n", wirehbrush->fContext);
1195 ok(wirehbrush->u.hInproc == (LONG_PTR)hBrush, "Marshaled value should be %p instead of %x\n", hBrush, wirehbrush->u.hRemote);
1196
1197 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
1198 buffer_end = HBRUSH_UserUnmarshal(&umcb.Flags, buffer + 1, &hBrush2);
1199 ok(buffer_end == buffer + 4 + sizeof(*wirehbrush), "got %p buffer %p\n", buffer_end, buffer);
1200 ok(hBrush == hBrush2, "Didn't unmarshal properly\n");
1201 HeapFree(GetProcessHeap(), 0, buffer);
1202
1203 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
1204 HBRUSH_UserFree(&umcb.Flags, &hBrush2);
1205 DeleteObject(hBrush);
1206 }
1207
1208 static void test_marshal_HBITMAP(void)
1209 {
1210 static const ULONG header_size = FIELD_OFFSET(userBITMAP, cbSize);
1211 static BYTE bmp_bits[1024];
1212 MIDL_STUB_MESSAGE stub_msg;
1213 HBITMAP hBitmap, hBitmap2;
1214 USER_MARSHAL_CB umcb;
1215 RPC_MESSAGE rpc_msg;
1216 unsigned char *buffer, *buffer_end;
1217 unsigned char bitmap[1024];
1218 ULONG size, bitmap_size;
1219
1220 hBitmap = CreateBitmap(16, 16, 1, 1, bmp_bits);
1221 ok(hBitmap != 0, "CreateBitmap failed\n");
1222 size = GetObjectA(hBitmap, sizeof(bitmap), bitmap);
1223 ok(size != 0, "GetObject failed\n");
1224 bitmap_size = GetBitmapBits(hBitmap, 0, NULL);
1225 ok(bitmap_size != 0, "GetBitmapBits failed\n");
1226
1227 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_INPROC);
1228 size = HBITMAP_UserSize(&umcb.Flags, 1, &hBitmap);
1229 ok(size == 0xc, "Wrong size %d\n", size);
1230 buffer = HeapAlloc(GetProcessHeap(), 0, size + 4);
1231 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_INPROC);
1232 buffer_end = HBITMAP_UserMarshal(&umcb.Flags, buffer + 1, &hBitmap);
1233 ok(buffer_end == buffer + 0xc, "HBITMAP_UserMarshal() returned wrong size %d\n", (LONG)(buffer_end - buffer));
1234 ok(*(ULONG *)(buffer + 0x4) == WDT_INPROC_CALL, "Context should be WDT_INPROC_CALL instead of 0x%08x\n", *(ULONG *)(buffer + 0x4));
1235 ok(*(ULONG *)(buffer + 0x8) == (ULONG)(ULONG_PTR)hBitmap, "wirestgm + 0x4 should be bitmap handle instead of 0x%08x\n", *(ULONG *)(buffer + 0x8));
1236
1237 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_INPROC);
1238 HBITMAP_UserUnmarshal(&umcb.Flags, buffer + 1, &hBitmap2);
1239 ok(hBitmap2 != NULL, "Didn't unmarshal properly\n");
1240 HeapFree(GetProcessHeap(), 0, buffer);
1241
1242 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_INPROC);
1243 HBITMAP_UserFree(&umcb.Flags, &hBitmap2);
1244
1245 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
1246 size = HBITMAP_UserSize(&umcb.Flags, 1, &hBitmap);
1247 ok(size == 0x10 + header_size + bitmap_size ||
1248 broken(size == 0x14 + header_size + bitmap_size), /* Windows adds 4 extra (unused) bytes */
1249 "Wrong size %d\n", size);
1250
1251 buffer = HeapAlloc(GetProcessHeap(), 0, size + 4);
1252 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
1253 buffer_end = HBITMAP_UserMarshal(&umcb.Flags, buffer + 1, &hBitmap);
1254 ok(buffer_end == buffer + 0x10 + header_size + bitmap_size, "HBITMAP_UserMarshal() returned wrong size %d\n", (LONG)(buffer_end - buffer));
1255 ok(*(ULONG *)(buffer + 0x4) == WDT_REMOTE_CALL, "Context should be WDT_REMOTE_CALL instead of 0x%08x\n", *(ULONG *)buffer);
1256 ok(*(ULONG *)(buffer + 0x8) == (ULONG)(ULONG_PTR)hBitmap, "wirestgm + 0x4 should be bitmap handle instead of 0x%08x\n", *(ULONG *)(buffer + 0x4));
1257 ok(*(ULONG *)(buffer + 0xc) == (ULONG)(ULONG_PTR)bitmap_size, "wirestgm + 0x8 should be bitmap size instead of 0x%08x\n", *(ULONG *)(buffer + 0x4));
1258 ok(!memcmp(buffer + 0x10, bitmap, header_size), "buffer mismatch\n");
1259 ok(!memcmp(buffer + 0x10 + header_size, bmp_bits, bitmap_size), "buffer mismatch\n");
1260
1261 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_LOCAL);
1262 HBITMAP_UserUnmarshal(&umcb.Flags, buffer + 1, &hBitmap2);
1263 ok(hBitmap2 != NULL, "Didn't unmarshal properly\n");
1264 HeapFree(GetProcessHeap(), 0, buffer);
1265
1266 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_LOCAL);
1267 HBITMAP_UserFree(&umcb.Flags, &hBitmap2);
1268 DeleteObject(hBitmap);
1269 }
1270
1271 struct obj
1272 {
1273 IDataObject IDataObject_iface;
1274 };
1275
1276 static HRESULT WINAPI obj_QueryInterface(IDataObject *iface, REFIID iid, void **obj)
1277 {
1278 *obj = NULL;
1279
1280 if (IsEqualGUID(iid, &IID_IUnknown) ||
1281 IsEqualGUID(iid, &IID_IDataObject))
1282 *obj = iface;
1283
1284 if (*obj)
1285 {
1286 IDataObject_AddRef(iface);
1287 return S_OK;
1288 }
1289
1290 return E_NOINTERFACE;
1291 }
1292
1293 static ULONG WINAPI obj_AddRef(IDataObject *iface)
1294 {
1295 return 2;
1296 }
1297
1298 static ULONG WINAPI obj_Release(IDataObject *iface)
1299 {
1300 return 1;
1301 }
1302
1303 static HRESULT WINAPI obj_DO_GetDataHere(IDataObject *iface, FORMATETC *fmt,
1304 STGMEDIUM *med)
1305 {
1306 ok( med->pUnkForRelease == NULL, "got %p\n", med->pUnkForRelease );
1307
1308 if (fmt->cfFormat == 2)
1309 {
1310 IStream_Release(U(med)->pstm);
1311 U(med)->pstm = &Test_Stream2.IStream_iface;
1312 }
1313
1314 return S_OK;
1315 }
1316
1317 static const IDataObjectVtbl obj_data_object_vtbl =
1318 {
1319 obj_QueryInterface,
1320 obj_AddRef,
1321 obj_Release,
1322 NULL, /* GetData */
1323 obj_DO_GetDataHere,
1324 NULL, /* QueryGetData */
1325 NULL, /* GetCanonicalFormatEtc */
1326 NULL, /* SetData */
1327 NULL, /* EnumFormatEtc */
1328 NULL, /* DAdvise */
1329 NULL, /* DUnadvise */
1330 NULL /* EnumDAdvise */
1331 };
1332
1333 static struct obj obj =
1334 {
1335 {&obj_data_object_vtbl}
1336 };
1337
1338 static void test_GetDataHere_Proxy(void)
1339 {
1340 HRESULT hr;
1341 IStream *stm;
1342 HANDLE thread;
1343 DWORD tid;
1344 static const LARGE_INTEGER zero;
1345 IDataObject *data;
1346 FORMATETC fmt;
1347 STGMEDIUM med;
1348
1349 hr = CreateStreamOnHGlobal( NULL, TRUE, &stm );
1350 ok( hr == S_OK, "got %08x\n", hr );
1351 tid = start_host_object2( stm, &IID_IDataObject, (IUnknown *)&obj.IDataObject_iface, MSHLFLAGS_NORMAL, NULL, &thread );
1352
1353 IStream_Seek( stm, zero, STREAM_SEEK_SET, NULL );
1354 hr = CoUnmarshalInterface( stm, &IID_IDataObject, (void **)&data );
1355 ok( hr == S_OK, "got %08x\n", hr );
1356 IStream_Release( stm );
1357
1358 Test_Stream.refs = 1;
1359 Test_Stream2.refs = 1;
1360 Test_Unknown.refs = 1;
1361
1362 fmt.cfFormat = 1;
1363 fmt.ptd = NULL;
1364 fmt.dwAspect = DVASPECT_CONTENT;
1365 fmt.lindex = -1;
1366 U(med).pstm = NULL;
1367 med.pUnkForRelease = &Test_Unknown.IUnknown_iface;
1368
1369 fmt.tymed = med.tymed = TYMED_NULL;
1370 hr = IDataObject_GetDataHere( data, &fmt, &med );
1371 ok( hr == DV_E_TYMED, "got %08x\n", hr );
1372
1373 for (fmt.tymed = TYMED_HGLOBAL; fmt.tymed <= TYMED_ENHMF; fmt.tymed <<= 1)
1374 {
1375 med.tymed = fmt.tymed;
1376 hr = IDataObject_GetDataHere( data, &fmt, &med );
1377 ok( hr == (fmt.tymed <= TYMED_ISTORAGE ? S_OK : DV_E_TYMED), "got %08x for tymed %d\n", hr, fmt.tymed );
1378 ok( Test_Unknown.refs == 1, "got %d\n", Test_Unknown.refs );
1379 }
1380
1381 fmt.tymed = TYMED_ISTREAM;
1382 med.tymed = TYMED_ISTORAGE;
1383 hr = IDataObject_GetDataHere( data, &fmt, &med );
1384 ok( hr == DV_E_TYMED, "got %08x\n", hr );
1385
1386 fmt.tymed = med.tymed = TYMED_ISTREAM;
1387 U(med).pstm = &Test_Stream.IStream_iface;
1388 med.pUnkForRelease = &Test_Unknown.IUnknown_iface;
1389
1390 hr = IDataObject_GetDataHere( data, &fmt, &med );
1391 ok( hr == S_OK, "got %08x\n", hr );
1392
1393 ok( U(med).pstm == &Test_Stream.IStream_iface, "stm changed\n" );
1394 ok( med.pUnkForRelease == &Test_Unknown.IUnknown_iface, "punk changed\n" );
1395
1396 ok( Test_Stream.refs == 1, "got %d\n", Test_Stream.refs );
1397 ok( Test_Unknown.refs == 1, "got %d\n", Test_Unknown.refs );
1398
1399 fmt.cfFormat = 2;
1400 fmt.tymed = med.tymed = TYMED_ISTREAM;
1401 U(med).pstm = &Test_Stream.IStream_iface;
1402 med.pUnkForRelease = &Test_Unknown.IUnknown_iface;
1403
1404 hr = IDataObject_GetDataHere( data, &fmt, &med );
1405 ok( hr == S_OK, "got %08x\n", hr );
1406
1407 ok( U(med).pstm == &Test_Stream.IStream_iface, "stm changed\n" );
1408 ok( med.pUnkForRelease == &Test_Unknown.IUnknown_iface, "punk changed\n" );
1409
1410 ok( Test_Stream.refs == 1, "got %d\n", Test_Stream.refs );
1411 ok( Test_Unknown.refs == 1, "got %d\n", Test_Unknown.refs );
1412 ok( Test_Stream2.refs == 0, "got %d\n", Test_Stream2.refs );
1413
1414 IDataObject_Release( data );
1415 end_host_object( tid, thread );
1416 }
1417
1418 START_TEST(usrmarshal)
1419 {
1420 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1421
1422 test_marshal_CLIPFORMAT();
1423 test_marshal_HWND();
1424 test_marshal_HGLOBAL();
1425 test_marshal_HENHMETAFILE();
1426 test_marshal_HMETAFILE();
1427 test_marshal_HMETAFILEPICT();
1428 test_marshal_WdtpInterfacePointer();
1429 test_marshal_STGMEDIUM();
1430 test_marshal_SNB();
1431 test_marshal_HDC();
1432 test_marshal_HICON();
1433 test_marshal_HBRUSH();
1434 test_marshal_HBITMAP();
1435
1436 test_GetDataHere_Proxy();
1437
1438 CoUninitialize();
1439 }