1 /* 2 * Marshaling Tests 3 * 4 * Copyright 2004 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 #define WIN32_NO_STATUS 22 #define _INC_WINDOWS 23 #define COM_NO_WINDOWS_H 24 25 #define COBJMACROS 26 #define CONST_VTABLE 27 28 #include <stdarg.h> 29 30 #include <windef.h> 31 #include <winbase.h> 32 #include <ole2.h> 33 //#include "objbase.h" 34 //#include "propidl.h" /* for LPSAFEARRAY_User* routines */ 35 36 #include <wine/test.h> 37 38 #if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION) 39 # define V_U2(A) ((A)->n1.n2) 40 #else 41 # define V_U2(A) (*(A)) 42 #endif 43 44 static HRESULT (WINAPI *pSafeArrayGetIID)(SAFEARRAY*,GUID*); 45 static HRESULT (WINAPI *pSafeArrayGetVartype)(SAFEARRAY*,VARTYPE*); 46 static HRESULT (WINAPI *pVarBstrCmp)(BSTR,BSTR,LCID,ULONG); 47 48 static inline SF_TYPE get_union_type(SAFEARRAY *psa) 49 { 50 VARTYPE vt; 51 HRESULT hr; 52 53 hr = pSafeArrayGetVartype(psa, &vt); 54 if (FAILED(hr)) 55 { 56 if(psa->fFeatures & FADF_VARIANT) return SF_VARIANT; 57 58 switch(psa->cbElements) 59 { 60 case 1: vt = VT_I1; break; 61 case 2: vt = VT_I2; break; 62 case 4: vt = VT_I4; break; 63 case 8: vt = VT_I8; break; 64 default: return 0; 65 } 66 } 67 68 if (psa->fFeatures & FADF_HAVEIID) 69 return SF_HAVEIID; 70 71 switch (vt) 72 { 73 case VT_I1: 74 case VT_UI1: return SF_I1; 75 case VT_BOOL: 76 case VT_I2: 77 case VT_UI2: return SF_I2; 78 case VT_INT: 79 case VT_UINT: 80 case VT_I4: 81 case VT_UI4: 82 case VT_R4: return SF_I4; 83 case VT_DATE: 84 case VT_CY: 85 case VT_R8: 86 case VT_I8: 87 case VT_UI8: return SF_I8; 88 case VT_INT_PTR: 89 case VT_UINT_PTR: return (sizeof(UINT_PTR) == 4 ? SF_I4 : SF_I8); 90 case VT_BSTR: return SF_BSTR; 91 case VT_DISPATCH: return SF_DISPATCH; 92 case VT_VARIANT: return SF_VARIANT; 93 case VT_UNKNOWN: return SF_UNKNOWN; 94 /* Note: Return a non-zero size to indicate vt is valid. The actual size 95 * of a UDT is taken from the result of IRecordInfo_GetSize(). 96 */ 97 case VT_RECORD: return SF_RECORD; 98 default: return SF_ERROR; 99 } 100 } 101 102 static ULONG get_cell_count(const SAFEARRAY *psa) 103 { 104 const SAFEARRAYBOUND* psab = psa->rgsabound; 105 USHORT cCount = psa->cDims; 106 ULONG ulNumCells = 1; 107 108 while (cCount--) 109 { 110 if (!psab->cElements) 111 return 0; 112 ulNumCells *= psab->cElements; 113 psab++; 114 } 115 return ulNumCells; 116 } 117 118 static DWORD elem_wire_size(LPSAFEARRAY lpsa, SF_TYPE sftype) 119 { 120 if (sftype == SF_BSTR) 121 return sizeof(DWORD); 122 else 123 return lpsa->cbElements; 124 } 125 126 static void check_safearray(void *buffer, LPSAFEARRAY lpsa) 127 { 128 unsigned char *wiresa = buffer; 129 const SAFEARRAYBOUND *bounds; 130 VARTYPE vt; 131 SF_TYPE sftype; 132 ULONG cell_count; 133 int i; 134 135 if(!lpsa) 136 { 137 ok(*(DWORD *)wiresa == 0, "wiresa + 0x0 should be NULL instead of 0x%08x\n", *(DWORD *)wiresa); 138 return; 139 } 140 141 if (!pSafeArrayGetVartype || !pSafeArrayGetIID) 142 return; 143 144 if(FAILED(pSafeArrayGetVartype(lpsa, &vt))) 145 vt = 0; 146 147 sftype = get_union_type(lpsa); 148 cell_count = get_cell_count(lpsa); 149 150 ok(*(DWORD *)wiresa, "wiresa + 0x0 should be non-NULL instead of 0x%08x\n", *(DWORD *)wiresa); /* win2k: this is lpsa. winxp: this is 0x00000001 */ 151 wiresa += sizeof(DWORD); 152 ok(*(DWORD *)wiresa == lpsa->cDims, "wiresa + 0x4 should be lpsa->cDims instead of 0x%08x\n", *(DWORD *)wiresa); 153 wiresa += sizeof(DWORD); 154 ok(*(WORD *)wiresa == lpsa->cDims, "wiresa + 0x8 should be lpsa->cDims instead of 0x%04x\n", *(WORD *)wiresa); 155 wiresa += sizeof(WORD); 156 ok(*(WORD *)wiresa == lpsa->fFeatures, "wiresa + 0xa should be lpsa->fFeatures instead of 0x%08x\n", *(WORD *)wiresa); 157 wiresa += sizeof(WORD); 158 ok(*(DWORD *)wiresa == elem_wire_size(lpsa, sftype), "wiresa + 0xc should be 0x%08x instead of 0x%08x\n", elem_wire_size(lpsa, sftype), *(DWORD *)wiresa); 159 wiresa += sizeof(DWORD); 160 ok(*(WORD *)wiresa == lpsa->cLocks, "wiresa + 0x10 should be lpsa->cLocks instead of 0x%04x\n", *(WORD *)wiresa); 161 wiresa += sizeof(WORD); 162 ok(*(WORD *)wiresa == vt, "wiresa + 0x12 should be %04x instead of 0x%04x\n", vt, *(WORD *)wiresa); 163 wiresa += sizeof(WORD); 164 ok(*(DWORD *)wiresa == sftype, "wiresa + 0x14 should be %08x instead of 0x%08x\n", (DWORD)sftype, *(DWORD *)wiresa); 165 wiresa += sizeof(DWORD); 166 ok(*(DWORD *)wiresa == cell_count, "wiresa + 0x18 should be %u instead of %u\n", cell_count, *(DWORD *)wiresa); 167 wiresa += sizeof(DWORD); 168 ok(*(DWORD *)wiresa, "wiresa + 0x1c should be non-zero instead of 0x%08x\n", *(DWORD *)wiresa); 169 wiresa += sizeof(DWORD); 170 if(sftype == SF_HAVEIID) 171 { 172 GUID guid; 173 pSafeArrayGetIID(lpsa, &guid); 174 ok(IsEqualGUID(&guid, wiresa), "guid mismatch\n"); 175 wiresa += sizeof(GUID); 176 } 177 178 /* bounds are marshaled in natural dimensions order */ 179 bounds = (SAFEARRAYBOUND*)wiresa; 180 for(i=0; i<lpsa->cDims; i++) 181 { 182 ok(memcmp(bounds, &lpsa->rgsabound[lpsa->cDims-i-1], sizeof(SAFEARRAYBOUND)) == 0, 183 "bounds mismatch for dimension %d, got (%d,%d), expected (%d,%d)\n", i, 184 bounds->lLbound, bounds->cElements, lpsa->rgsabound[lpsa->cDims-i-1].lLbound, 185 lpsa->rgsabound[lpsa->cDims-i-1].cElements); 186 bounds++; 187 } 188 189 wiresa += sizeof(lpsa->rgsabound[0]) * lpsa->cDims; 190 191 ok(*(DWORD *)wiresa == cell_count, "wiresa + 0x28 should be %u instead of %u\n", cell_count, *(DWORD*)wiresa); 192 wiresa += sizeof(DWORD); 193 /* elements are now pointed to by wiresa */ 194 } 195 196 static void * WINAPI user_allocate(SIZE_T size) 197 { 198 ok(0, "unexpected user_allocate call\n"); 199 return CoTaskMemAlloc(size); 200 } 201 202 static void WINAPI user_free(void *p) 203 { 204 ok(0, "unexpected user_free call\n"); 205 CoTaskMemFree(p); 206 } 207 208 static void init_user_marshal_cb(USER_MARSHAL_CB *umcb, 209 PMIDL_STUB_MESSAGE stub_msg, 210 PRPC_MESSAGE rpc_msg, unsigned char *buffer, 211 unsigned int size, MSHCTX context) 212 { 213 memset(rpc_msg, 0, sizeof(*rpc_msg)); 214 rpc_msg->Buffer = buffer; 215 rpc_msg->BufferLength = size; 216 217 memset(stub_msg, 0, sizeof(*stub_msg)); 218 stub_msg->RpcMsg = rpc_msg; 219 stub_msg->Buffer = buffer; 220 stub_msg->pfnAllocate = user_allocate; 221 stub_msg->pfnFree = user_free; 222 223 memset(umcb, 0, sizeof(*umcb)); 224 umcb->Flags = MAKELONG(context, NDR_LOCAL_DATA_REPRESENTATION); 225 umcb->pStubMsg = stub_msg; 226 umcb->Signature = USER_MARSHAL_CB_SIGNATURE; 227 umcb->CBType = buffer ? USER_MARSHAL_CB_UNMARSHALL : USER_MARSHAL_CB_BUFFER_SIZE; 228 } 229 230 static void test_marshal_LPSAFEARRAY(void) 231 { 232 unsigned char *buffer, *next; 233 ULONG size, expected; 234 LPSAFEARRAY lpsa; 235 LPSAFEARRAY lpsa2 = NULL; 236 SAFEARRAYBOUND sab[2]; 237 RPC_MESSAGE rpc_msg; 238 MIDL_STUB_MESSAGE stub_msg; 239 USER_MARSHAL_CB umcb; 240 HRESULT hr; 241 VARTYPE vt, vt2; 242 OLECHAR *values[10]; 243 int expected_bstr_size; 244 int i; 245 LONG indices[1]; 246 247 sab[0].lLbound = 5; 248 sab[0].cElements = 10; 249 250 lpsa = SafeArrayCreate(VT_I2, 1, sab); 251 *(DWORD *)lpsa->pvData = 0xcafebabe; 252 253 lpsa->cLocks = 7; 254 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 255 size = LPSAFEARRAY_UserSize(&umcb.Flags, 1, &lpsa); 256 expected = (44 + 1 + sizeof(ULONG) - 1) & ~(sizeof(ULONG) - 1); 257 expected += sab[0].cElements * sizeof(USHORT); 258 ok(size == expected || size == expected + 12, /* win64 */ 259 "size should be %u bytes, not %u\n", expected, size); 260 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 261 size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa); 262 expected = 44 + sab[0].cElements * sizeof(USHORT); 263 ok(size == expected || size == expected + 12, /* win64 */ 264 "size should be %u bytes, not %u\n", expected, size); 265 buffer = HeapAlloc(GetProcessHeap(), 0, size); 266 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 267 next = LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa); 268 ok(next - buffer == expected, "Marshaled %u bytes, expected %u\n", (ULONG) (next - buffer), expected); 269 ok(lpsa->cLocks == 7, "got lock count %u\n", lpsa->cLocks); 270 271 check_safearray(buffer, lpsa); 272 273 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 274 LPSAFEARRAY_UserUnmarshal(&umcb.Flags, buffer, &lpsa2); 275 ok(lpsa2 != NULL, "LPSAFEARRAY didn't unmarshal\n"); 276 if (pSafeArrayGetVartype) 277 { 278 pSafeArrayGetVartype(lpsa, &vt); 279 pSafeArrayGetVartype(lpsa2, &vt2); 280 ok(vt == vt2, "vts differ %x %x\n", vt, vt2); 281 } 282 ok(lpsa2->cLocks == 0, "got lock count %u, expected 0\n", lpsa2->cLocks); 283 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 284 LPSAFEARRAY_UserFree(&umcb.Flags, &lpsa2); 285 ok(!lpsa2, "lpsa2 was not set to 0 by LPSAFEARRAY_UserFree\n"); 286 HeapFree(GetProcessHeap(), 0, buffer); 287 lpsa->cLocks = 0; 288 hr = SafeArrayDestroy(lpsa); 289 ok(hr == S_OK, "got 0x%08x\n", hr); 290 291 /* use two dimensions */ 292 sab[0].lLbound = 5; 293 sab[0].cElements = 10; 294 sab[1].lLbound = 1; 295 sab[1].cElements = 2; 296 297 lpsa = SafeArrayCreate(VT_I2, 2, sab); 298 *(DWORD *)lpsa->pvData = 0xcafebabe; 299 300 lpsa->cLocks = 7; 301 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 302 size = LPSAFEARRAY_UserSize(&umcb.Flags, 1, &lpsa); 303 expected = (44 + 1 + +sizeof(SAFEARRAYBOUND) + sizeof(ULONG) - 1) & ~(sizeof(ULONG) - 1); 304 expected += max(sab[0].cElements, sab[1].cElements) * lpsa->cDims * sizeof(USHORT); 305 ok(size == expected || size == expected + 12, /* win64 */ 306 "size should be %u bytes, not %u\n", expected, size); 307 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 308 size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa); 309 expected = 52 + max(sab[0].cElements, sab[1].cElements) * lpsa->cDims * sizeof(USHORT); 310 ok(size == expected || size == expected + 12, /* win64 */ 311 "size should be %u bytes, not %u\n", expected, size); 312 buffer = HeapAlloc(GetProcessHeap(), 0, size); 313 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 314 next = LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa); 315 ok(next - buffer == expected, "Marshaled %u bytes, expected %u\n", (ULONG) (next - buffer), expected); 316 ok(lpsa->cLocks == 7, "got lock count %u\n", lpsa->cLocks); 317 318 check_safearray(buffer, lpsa); 319 320 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 321 LPSAFEARRAY_UserUnmarshal(&umcb.Flags, buffer, &lpsa2); 322 ok(lpsa2 != NULL, "LPSAFEARRAY didn't unmarshal\n"); 323 if (pSafeArrayGetVartype) 324 { 325 pSafeArrayGetVartype(lpsa, &vt); 326 pSafeArrayGetVartype(lpsa2, &vt2); 327 ok(vt == vt2, "vts differ %x %x\n", vt, vt2); 328 } 329 ok(lpsa2->cLocks == 0, "got lock count %u, expected 0\n", lpsa2->cLocks); 330 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 331 LPSAFEARRAY_UserFree(&umcb.Flags, &lpsa2); 332 HeapFree(GetProcessHeap(), 0, buffer); 333 lpsa->cLocks = 0; 334 hr = SafeArrayDestroy(lpsa); 335 ok(hr == S_OK, "got 0x%08x\n", hr); 336 337 /* test NULL safe array */ 338 lpsa = NULL; 339 340 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 341 size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa); 342 expected = 4; 343 ok(size == expected, "size should be 4 bytes, not %d\n", size); 344 buffer = HeapAlloc(GetProcessHeap(), 0, size); 345 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 346 next = LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa); 347 ok(next - buffer == expected, "Marshaled %u bytes, expected %u\n", (ULONG) (next - buffer), expected); 348 check_safearray(buffer, lpsa); 349 350 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 351 LPSAFEARRAY_UserUnmarshal(&umcb.Flags, buffer, &lpsa2); 352 ok(lpsa2 == NULL, "NULL LPSAFEARRAY didn't unmarshal\n"); 353 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 354 LPSAFEARRAY_UserFree(&umcb.Flags, &lpsa2); 355 HeapFree(GetProcessHeap(), 0, buffer); 356 357 sab[0].lLbound = 5; 358 sab[0].cElements = 10; 359 360 lpsa = SafeArrayCreate(VT_R8, 1, sab); 361 *(double *)lpsa->pvData = 3.1415; 362 363 lpsa->cLocks = 7; 364 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 365 size = LPSAFEARRAY_UserSize(&umcb.Flags, 1, &lpsa); 366 expected = (44 + 1 + (sizeof(double) - 1)) & ~(sizeof(double) - 1); 367 expected += sab[0].cElements * sizeof(double); 368 ok(size == expected || size == expected + 16, /* win64 */ 369 "size should be %u bytes, not %u\n", expected, size); 370 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 371 expected = (44 + (sizeof(double) - 1)) & ~(sizeof(double) - 1); 372 expected += sab[0].cElements * sizeof(double); 373 size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa); 374 ok(size == expected || size == expected + 8, /* win64 */ 375 "size should be %u bytes, not %u\n", expected, size); 376 buffer = HeapAlloc(GetProcessHeap(), 0, size); 377 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 378 next = LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa); 379 ok(next - buffer == expected || broken(next - buffer + sizeof(DWORD) == expected), 380 "Marshaled %u bytes, expected %u\n", (ULONG) (next - buffer), expected); 381 382 check_safearray(buffer, lpsa); 383 384 HeapFree(GetProcessHeap(), 0, buffer); 385 lpsa->cLocks = 0; 386 hr = SafeArrayDestroy(lpsa); 387 ok(hr == S_OK, "got 0x%08x\n", hr); 388 389 /* VARTYPE-less arrays can be marshaled if cbElements is 1,2,4 or 8 as type SF_In */ 390 hr = SafeArrayAllocDescriptor(1, &lpsa); 391 ok(hr == S_OK, "saad failed %08x\n", hr); 392 lpsa->cbElements = 8; 393 lpsa->rgsabound[0].lLbound = 2; 394 lpsa->rgsabound[0].cElements = 48; 395 hr = SafeArrayAllocData(lpsa); 396 ok(hr == S_OK, "saad failed %08x\n", hr); 397 398 if (pSafeArrayGetVartype) 399 { 400 hr = pSafeArrayGetVartype(lpsa, &vt); 401 ok(hr == E_INVALIDARG, "ret %08x\n", hr); 402 } 403 404 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 405 size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa); 406 expected = (44 + lpsa->cbElements - 1) & ~(lpsa->cbElements - 1); 407 expected += lpsa->cbElements * lpsa->rgsabound[0].cElements; 408 ok(size == expected || size == expected + 8, /* win64 */ 409 "size should be %u bytes, not %u\n", expected, size); 410 buffer = HeapAlloc(GetProcessHeap(), 0, size); 411 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 412 next = LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa); 413 ok(next - buffer == expected || broken(next - buffer + sizeof(DWORD) == expected), 414 "Marshaled %u bytes, expected %u\n", (ULONG) (next - buffer), expected); 415 check_safearray(buffer, lpsa); 416 HeapFree(GetProcessHeap(), 0, buffer); 417 hr = SafeArrayDestroyData(lpsa); 418 ok(hr == S_OK, "got 0x%08x\n", hr); 419 hr = SafeArrayDestroyDescriptor(lpsa); 420 ok(hr == S_OK, "got 0x%08x\n", hr); 421 422 /* Test an array of VT_BSTR */ 423 sab[0].lLbound = 3; 424 sab[0].cElements = sizeof(values) / sizeof(values[0]); 425 426 lpsa = SafeArrayCreate(VT_BSTR, 1, sab); 427 expected_bstr_size = 0; 428 for (i = 0; i < sab[0].cElements; i++) 429 { 430 int j; 431 WCHAR buf[128]; 432 for (j = 0; j <= i; j++) 433 buf[j] = 'a' + j; 434 buf[j] = 0; 435 indices[0] = i + sab[0].lLbound; 436 values[i] = SysAllocString(buf); 437 hr = SafeArrayPutElement(lpsa, indices, values[i]); 438 ok(hr == S_OK, "Failed to put bstr element hr 0x%x\n", hr); 439 expected_bstr_size += (j * sizeof(WCHAR)) + (3 * sizeof(DWORD)); 440 if (i % 2 == 0) /* Account for DWORD padding. Works so long as cElements is even */ 441 expected_bstr_size += sizeof(WCHAR); 442 } 443 444 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 445 size = LPSAFEARRAY_UserSize(&umcb.Flags, 1, &lpsa); 446 expected = 44 + (sab[0].cElements * sizeof(DWORD)) + expected_bstr_size; 447 todo_wine 448 ok(size == expected + sizeof(DWORD) || size == (expected + sizeof(DWORD) + 12 /* win64 */), 449 "size should be %u bytes, not %u\n", expected + (ULONG) sizeof(DWORD), size); 450 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 451 size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa); 452 todo_wine 453 ok(size == expected || size == (expected + 12 /* win64 */), 454 "size should be %u bytes, not %u\n", expected, size); 455 buffer = HeapAlloc(GetProcessHeap(), 0, size); 456 memset(buffer, 0xcc, size); 457 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 458 next = LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa); 459 todo_wine 460 ok(next - buffer == expected, "Marshaled %u bytes, expected %u\n", (ULONG) (next - buffer), expected); 461 462 check_safearray(buffer, lpsa); 463 464 lpsa2 = NULL; 465 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 466 next = LPSAFEARRAY_UserUnmarshal(&umcb.Flags, buffer, &lpsa2); 467 todo_wine 468 ok(next - buffer == expected, "Marshaled %u bytes, expected %u\n", (ULONG) (next - buffer), expected); 469 ok(lpsa2 != NULL, "LPSAFEARRAY didn't unmarshal, result %p\n", next); 470 471 for (i = 0; i < sizeof(values) / sizeof(values[0]); i++) 472 { 473 BSTR gotvalue = NULL; 474 475 if (lpsa2) 476 { 477 indices[0] = i + sab[0].lLbound; 478 hr = SafeArrayGetElement(lpsa2, indices, &gotvalue); 479 ok(hr == S_OK, "Failed to get bstr element at hres 0x%x\n", hr); 480 if (hr == S_OK) 481 { 482 if (pVarBstrCmp) 483 ok(pVarBstrCmp(values[i], gotvalue, 0, 0) == VARCMP_EQ, "String %d does not match\n", i); 484 SysFreeString(gotvalue); 485 } 486 } 487 488 SysFreeString(values[i]); 489 } 490 491 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 492 LPSAFEARRAY_UserFree(&umcb.Flags, &lpsa2); 493 494 HeapFree(GetProcessHeap(), 0, buffer); 495 hr = SafeArrayDestroy(lpsa); 496 ok(hr == S_OK, "got 0x%08x\n", hr); 497 498 /* VARTYPE-less arrays with FADF_VARIANT */ 499 hr = SafeArrayAllocDescriptor(1, &lpsa); 500 ok(hr == S_OK, "saad failed %08x\n", hr); 501 lpsa->cbElements = sizeof(VARIANT); 502 lpsa->fFeatures = FADF_VARIANT; 503 lpsa->rgsabound[0].lLbound = 2; 504 lpsa->rgsabound[0].cElements = 48; 505 hr = SafeArrayAllocData(lpsa); 506 ok(hr == S_OK, "saad failed %08x\n", hr); 507 508 if (pSafeArrayGetVartype) 509 { 510 hr = pSafeArrayGetVartype(lpsa, &vt); 511 ok(hr == E_INVALIDARG, "ret %08x\n", hr); 512 } 513 514 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 515 size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa); 516 expected = 44 + 28 * lpsa->rgsabound[0].cElements; 517 todo_wine 518 ok(size == expected || size == expected + 8, /* win64 */ 519 "size should be %u bytes, not %u\n", expected, size); 520 buffer = HeapAlloc(GetProcessHeap(), 0, size); 521 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 522 next = LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa); 523 todo_wine 524 ok(next - buffer == expected || broken(next - buffer + sizeof(DWORD) == expected), 525 "Marshaled %u bytes, expected %u\n", (ULONG) (next - buffer), expected); 526 lpsa->cbElements = 16; /* VARIANT wire size */ 527 check_safearray(buffer, lpsa); 528 HeapFree(GetProcessHeap(), 0, buffer); 529 hr = SafeArrayDestroyData(lpsa); 530 ok(hr == S_OK, "got 0x%08x\n", hr); 531 hr = SafeArrayDestroyDescriptor(lpsa); 532 ok(hr == S_OK, "got 0x%08x\n", hr); 533 } 534 535 static void check_bstr(void *buffer, BSTR b) 536 { 537 DWORD *wireb = buffer; 538 DWORD len = SysStringByteLen(b); 539 540 ok(*wireb == (len + 1) / 2, "wv[0] %08x\n", *wireb); 541 wireb++; 542 if(b) 543 ok(*wireb == len, "wv[1] %08x\n", *wireb); 544 else 545 ok(*wireb == 0xffffffff, "wv[1] %08x\n", *wireb); 546 wireb++; 547 ok(*wireb == (len + 1) / 2, "wv[2] %08x\n", *wireb); 548 if(len) 549 { 550 wireb++; 551 ok(!memcmp(wireb, b, (len + 1) & ~1), "strings differ\n"); 552 } 553 return; 554 } 555 556 static void test_marshal_BSTR(void) 557 { 558 ULONG size; 559 RPC_MESSAGE rpc_msg; 560 MIDL_STUB_MESSAGE stub_msg; 561 USER_MARSHAL_CB umcb; 562 unsigned char *buffer, *next; 563 BSTR b, b2; 564 WCHAR str[] = {'m','a','r','s','h','a','l',' ','t','e','s','t','1',0}; 565 DWORD len; 566 567 b = SysAllocString(str); 568 len = SysStringLen(b); 569 ok(len == 13, "get %d\n", len); 570 571 /* BSTRs are DWORD aligned */ 572 573 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 574 size = BSTR_UserSize(&umcb.Flags, 1, &b); 575 ok(size == 42, "size %d\n", size); 576 577 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 578 size = BSTR_UserSize(&umcb.Flags, 0, &b); 579 ok(size == 38, "size %d\n", size); 580 581 buffer = HeapAlloc(GetProcessHeap(), 0, size); 582 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 583 next = BSTR_UserMarshal(&umcb.Flags, buffer, &b); 584 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); 585 check_bstr(buffer, b); 586 587 b2 = NULL; 588 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 589 next = BSTR_UserUnmarshal(&umcb.Flags, buffer, &b2); 590 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); 591 ok(b2 != NULL, "BSTR didn't unmarshal\n"); 592 ok(!memcmp(b, b2, (len + 1) * 2), "strings differ\n"); 593 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 594 BSTR_UserFree(&umcb.Flags, &b2); 595 596 HeapFree(GetProcessHeap(), 0, buffer); 597 SysFreeString(b); 598 599 b = NULL; 600 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 601 size = BSTR_UserSize(&umcb.Flags, 0, &b); 602 ok(size == 12, "size %d\n", size); 603 604 buffer = HeapAlloc(GetProcessHeap(), 0, size); 605 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 606 next = BSTR_UserMarshal(&umcb.Flags, buffer, &b); 607 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); 608 609 check_bstr(buffer, b); 610 b2 = NULL; 611 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 612 next = BSTR_UserUnmarshal(&umcb.Flags, buffer, &b2); 613 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); 614 ok(b2 == NULL, "NULL BSTR didn't unmarshal\n"); 615 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 616 BSTR_UserFree(&umcb.Flags, &b2); 617 HeapFree(GetProcessHeap(), 0, buffer); 618 619 b = SysAllocStringByteLen("abc", 3); 620 *(((char*)b) + 3) = 'd'; 621 len = SysStringLen(b); 622 ok(len == 1, "get %d\n", len); 623 len = SysStringByteLen(b); 624 ok(len == 3, "get %d\n", len); 625 626 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 627 size = BSTR_UserSize(&umcb.Flags, 0, &b); 628 ok(size == 16, "size %d\n", size); 629 630 buffer = HeapAlloc(GetProcessHeap(), 0, size); 631 memset(buffer, 0xcc, size); 632 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 633 next = BSTR_UserMarshal(&umcb.Flags, buffer, &b); 634 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); 635 check_bstr(buffer, b); 636 ok(buffer[15] == 'd', "buffer[15] %02x\n", buffer[15]); 637 638 b2 = NULL; 639 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 640 next = BSTR_UserUnmarshal(&umcb.Flags, buffer, &b2); 641 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); 642 ok(b2 != NULL, "BSTR didn't unmarshal\n"); 643 ok(!memcmp(b, b2, len), "strings differ\n"); 644 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 645 BSTR_UserFree(&umcb.Flags, &b2); 646 HeapFree(GetProcessHeap(), 0, buffer); 647 SysFreeString(b); 648 649 b = SysAllocStringByteLen("", 0); 650 len = SysStringLen(b); 651 ok(len == 0, "get %d\n", len); 652 len = SysStringByteLen(b); 653 ok(len == 0, "get %d\n", len); 654 655 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 656 size = BSTR_UserSize(&umcb.Flags, 0, &b); 657 ok(size == 12, "size %d\n", size); 658 659 buffer = HeapAlloc(GetProcessHeap(), 0, size); 660 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 661 next = BSTR_UserMarshal(&umcb.Flags, buffer, &b); 662 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); 663 check_bstr(buffer, b); 664 665 b2 = NULL; 666 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, buffer, size, MSHCTX_DIFFERENTMACHINE); 667 next = BSTR_UserUnmarshal(&umcb.Flags, buffer, &b2); 668 ok(next == buffer + size, "got %p expect %p\n", next, buffer + size); 669 ok(b2 != NULL, "NULL LPSAFEARRAY didn't unmarshal\n"); 670 len = SysStringByteLen(b2); 671 ok(len == 0, "byte len %d\n", len); 672 init_user_marshal_cb(&umcb, &stub_msg, &rpc_msg, NULL, 0, MSHCTX_DIFFERENTMACHINE); 673 BSTR_UserFree(&umcb.Flags, &b2); 674 HeapFree(GetProcessHeap(), 0, buffer); 675 SysFreeString(b); 676 } 677 678 typedef struct 679 { 680 IUnknown IUnknown_iface; 681 ULONG refs; 682 } HeapUnknown; 683 684 static inline HeapUnknown *impl_from_IUnknown(IUnknown *iface) 685 { 686 return CONTAINING_RECORD(iface, HeapUnknown, IUnknown_iface); 687 } 688 689 static HRESULT WINAPI HeapUnknown_QueryInterface(IUnknown *iface, REFIID riid, void **ppv) 690 { 691 if (IsEqualIID(riid, &IID_IUnknown)) 692 { 693 IUnknown_AddRef(iface); 694 *ppv = iface; 695 return S_OK; 696 } 697 *ppv = NULL; 698 return E_NOINTERFACE; 699 } 700 701 static ULONG WINAPI HeapUnknown_AddRef(IUnknown *iface) 702 { 703 HeapUnknown *This = impl_from_IUnknown(iface); 704 return InterlockedIncrement((LONG*)&This->refs); 705 } 706 707 static ULONG WINAPI HeapUnknown_Release(IUnknown *iface) 708 { 709 HeapUnknown *This = impl_from_IUnknown(iface); 710 ULONG refs = InterlockedDecrement((LONG*)&This->refs); 711 if (!refs) HeapFree(GetProcessHeap(), 0, This); 712 return refs; 713 } 714 715 static const IUnknownVtbl HeapUnknown_Vtbl = 716 { 717 HeapUnknown_QueryInterface, 718 HeapUnknown_AddRef, 719 HeapUnknown_Release 720 }; 721 722 typedef struct 723 { 724 DWORD clSize; 725 DWORD rpcReserved; 726 USHORT vt; 727 USHORT wReserved1; 728 USHORT wReserved2; 729 USHORT wReserved3; 730 DWORD switch_is; 731 } variant_wire_t; 732 733 static DWORD *check_variant_header(DWORD *wirev, VARIANT *v, ULONG size) 734 { 735 const variant_wire_t *header = (const variant_wire_t*)wirev; 736 DWORD switch_is; 737 738 ok(header->clSize == (size + 7) >> 3, "wv[0] %08x, expected %08x\n", header->clSize, (size + 7) >> 3); 739 ok(header->rpcReserved == 0, "wv[1] %08x\n", header->rpcReserved); 740 ok(header->vt == V_VT(v), "vt %04x expected %04x\n", header->vt, V_VT(v)); 741 ok(header->wReserved1 == V_U2(v).wReserved1, "res1 %04x expected %04x\n", header->wReserved1, V_U2(v).wReserved1); 742 ok(header->wReserved2 == V_U2(v).wReserved2, "res2 %04x expected %04x\n", header->wReserved2, V_U2(v).wReserved2); 743 ok(header->wReserved3 == V_U2(v).wReserved3, "res3 %04x expected %04x\n", header->wReserved3, V_U2(v).wReserved3); 744 745 switch_is = V_VT(v); 746 if(switch_is & VT_ARRAY) 747 switch_is &= ~VT_TYPEMASK; 748 ok(header->switch_is == switch_is, "switch_is %08x expected %08x\n", header->switch_is, switch_is); 749 750 return (DWORD*)((unsigned char*)wirev + sizeof(variant_wire_t)); 751 } 752 753 /* Win9x and WinME don't always align as needed. Variants have 754 * an alignment of 8. 755 */ 756 static void *alloc_aligned(SIZE_T size, void **buf) 757 { 758 *buf = HeapAlloc(GetProcessHeap(), 0, size + 7); 759 return (void *)(((UINT_PTR)*buf + 7) & ~7); 760 } 761 762 static void test_marshal_VARIANT(void) 763 { 764 VARIANT v, v2, v3; 765 MIDL_STUB_MESSAGE stubMsg = { 0 }; 766 RPC_MESSAGE rpcMsg = { 0 }; 767 USER_MARSHAL_CB umcb = { 0 }; 768 unsigned char *buffer, *next; 769 void *oldbuffer; 770 ULONG ul; 771 short s; 772 double d; 773 void *mem; 774 DWORD *wirev; 775 BSTR b, b2; 776 WCHAR str[] = {'m','a','r','s','h','a','l',' ','t','e','s','t',0}; 777 SAFEARRAYBOUND sab; 778 LPSAFEARRAY lpsa, lpsa2, lpsa_copy; 779 DECIMAL dec, dec2; 780 HeapUnknown *heap_unknown; 781 DWORD expected; 782 HRESULT hr; 783 LONG bound, bound2; 784 VARTYPE vt, vt2; 785 786 stubMsg.RpcMsg = &rpcMsg; 787 788 umcb.Flags = MAKELONG(MSHCTX_DIFFERENTMACHINE, NDR_LOCAL_DATA_REPRESENTATION); 789 umcb.pStubMsg = &stubMsg; 790 umcb.pReserve = NULL; 791 umcb.Signature = USER_MARSHAL_CB_SIGNATURE; 792 umcb.CBType = USER_MARSHAL_CB_UNMARSHALL; 793 794 /*** I1 ***/ 795 VariantInit(&v); 796 V_VT(&v) = VT_I1; 797 V_I1(&v) = 0x12; 798 799 /* check_variant_header tests wReserved[123], so initialize to unique values. 800 * (Could probably also do this by setting the variant to a known DECIMAL.) 801 */ 802 V_U2(&v).wReserved1 = 0x1234; 803 V_U2(&v).wReserved2 = 0x5678; 804 V_U2(&v).wReserved3 = 0x9abc; 805 806 /* Variants have an alignment of 8 */ 807 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 1, &v); 808 ok(stubMsg.BufferLength == 29, "size %d\n", stubMsg.BufferLength); 809 810 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 811 ok(stubMsg.BufferLength == 21, "size %d\n", stubMsg.BufferLength); 812 813 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 814 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 815 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 816 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 817 wirev = (DWORD*)buffer; 818 819 wirev = check_variant_header(wirev, &v, stubMsg.BufferLength); 820 ok(*(char*)wirev == V_I1(&v), "wv[5] %08x\n", *wirev); 821 VariantInit(&v2); 822 stubMsg.Buffer = buffer; 823 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 824 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 825 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 826 ok(V_I1(&v) == V_I1(&v2), "got i1 %x expect %x\n", V_I1(&v), V_I1(&v2)); 827 828 VARIANT_UserFree(&umcb.Flags, &v2); 829 HeapFree(GetProcessHeap(), 0, oldbuffer); 830 831 /*** I2 ***/ 832 VariantInit(&v); 833 V_VT(&v) = VT_I2; 834 V_I2(&v) = 0x1234; 835 836 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 837 ok(stubMsg.BufferLength == 22, "size %d\n", stubMsg.BufferLength); 838 839 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 840 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 841 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 842 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 843 wirev = (DWORD*)buffer; 844 845 wirev = check_variant_header(wirev, &v, stubMsg.BufferLength); 846 ok(*(short*)wirev == V_I2(&v), "wv[5] %08x\n", *wirev); 847 VariantInit(&v2); 848 stubMsg.Buffer = buffer; 849 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 850 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 851 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 852 ok(V_I2(&v) == V_I2(&v2), "got i2 %x expect %x\n", V_I2(&v), V_I2(&v2)); 853 854 VARIANT_UserFree(&umcb.Flags, &v2); 855 HeapFree(GetProcessHeap(), 0, oldbuffer); 856 857 /*** I2 BYREF ***/ 858 VariantInit(&v); 859 V_VT(&v) = VT_I2 | VT_BYREF; 860 s = 0x1234; 861 V_I2REF(&v) = &s; 862 863 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 864 ok(stubMsg.BufferLength == 26, "size %d\n", stubMsg.BufferLength); 865 866 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 867 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 868 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 869 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 870 wirev = (DWORD*)buffer; 871 872 wirev = check_variant_header(wirev, &v, stubMsg.BufferLength); 873 ok(*wirev == 0x4, "wv[5] %08x\n", *wirev); 874 wirev++; 875 ok(*(short*)wirev == s, "wv[6] %08x\n", *wirev); 876 VariantInit(&v2); 877 V_VT(&v2) = VT_I2 | VT_BYREF; 878 V_BYREF(&v2) = mem = CoTaskMemAlloc(sizeof(V_I2(&v2))); 879 stubMsg.Buffer = buffer; 880 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 881 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 882 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 883 ok(V_BYREF(&v2) == mem, "didn't reuse existing memory\n"); 884 ok(*V_I2REF(&v) == *V_I2REF(&v2), "got i2 ref %x expect ui4 ref %x\n", *V_I2REF(&v), *V_I2REF(&v2)); 885 886 VARIANT_UserFree(&umcb.Flags, &v2); 887 HeapFree(GetProcessHeap(), 0, oldbuffer); 888 889 /*** I4 ***/ 890 VariantInit(&v); 891 V_VT(&v) = VT_I4; 892 V_I4(&v) = 0x1234; 893 894 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 895 ok(stubMsg.BufferLength == 24, "size %d\n", stubMsg.BufferLength); 896 897 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 898 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 899 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 900 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 901 wirev = (DWORD*)buffer; 902 903 wirev = check_variant_header(wirev, &v, stubMsg.BufferLength); 904 ok(*wirev == V_I4(&v), "wv[5] %08x\n", *wirev); 905 906 VariantInit(&v2); 907 stubMsg.Buffer = buffer; 908 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 909 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 910 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 911 ok(V_I4(&v) == V_I4(&v2), "got i4 %x expect %x\n", V_I4(&v), V_I4(&v2)); 912 913 VARIANT_UserFree(&umcb.Flags, &v2); 914 HeapFree(GetProcessHeap(), 0, oldbuffer); 915 916 /*** UI4 ***/ 917 VariantInit(&v); 918 V_VT(&v) = VT_UI4; 919 V_UI4(&v) = 0x1234; 920 921 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 922 ok(stubMsg.BufferLength == 24, "size %d\n", stubMsg.BufferLength); 923 924 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 925 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 926 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 927 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 928 wirev = (DWORD*)buffer; 929 930 wirev = check_variant_header(wirev, &v, stubMsg.BufferLength); 931 ok(*wirev == 0x1234, "wv[5] %08x\n", *wirev); 932 VariantInit(&v2); 933 stubMsg.Buffer = buffer; 934 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 935 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 936 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 937 ok(V_UI4(&v) == V_UI4(&v2), "got ui4 %x expect %x\n", V_UI4(&v), V_UI4(&v2)); 938 939 VARIANT_UserFree(&umcb.Flags, &v2); 940 HeapFree(GetProcessHeap(), 0, oldbuffer); 941 942 /*** UI4 BYREF ***/ 943 VariantInit(&v); 944 V_VT(&v) = VT_UI4 | VT_BYREF; 945 ul = 0x1234; 946 V_UI4REF(&v) = &ul; 947 948 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 949 ok(stubMsg.BufferLength == 28, "size %d\n", stubMsg.BufferLength); 950 951 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 952 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 953 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 954 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 955 wirev = (DWORD*)buffer; 956 957 wirev = check_variant_header(wirev, &v, stubMsg.BufferLength); 958 ok(*wirev == 0x4, "wv[5] %08x\n", *wirev); 959 wirev++; 960 ok(*wirev == ul, "wv[6] %08x\n", *wirev); 961 962 VariantInit(&v2); 963 stubMsg.Buffer = buffer; 964 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 965 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 966 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 967 ok(*V_UI4REF(&v) == *V_UI4REF(&v2), "got ui4 ref %x expect ui4 ref %x\n", *V_UI4REF(&v), *V_UI4REF(&v2)); 968 969 VARIANT_UserFree(&umcb.Flags, &v2); 970 HeapFree(GetProcessHeap(), 0, oldbuffer); 971 972 /*** R4 ***/ 973 VariantInit(&v); 974 V_VT(&v) = VT_R4; 975 V_R8(&v) = 3.1415; 976 977 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 978 ok(stubMsg.BufferLength == 24, "size %d\n", stubMsg.BufferLength); 979 980 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 981 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 982 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 983 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 984 wirev = (DWORD*)buffer; 985 986 wirev = check_variant_header(wirev, &v, stubMsg.BufferLength); 987 ok(*(float*)wirev == V_R4(&v), "wv[5] %08x\n", *wirev); 988 VariantInit(&v2); 989 stubMsg.Buffer = buffer; 990 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 991 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 992 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 993 ok(V_R4(&v) == V_R4(&v2), "got r4 %f expect %f\n", V_R4(&v), V_R4(&v2)); 994 995 VARIANT_UserFree(&umcb.Flags, &v2); 996 HeapFree(GetProcessHeap(), 0, oldbuffer); 997 998 /*** R8 ***/ 999 VariantInit(&v); 1000 V_VT(&v) = VT_R8; 1001 V_R8(&v) = 3.1415; 1002 1003 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1004 ok(stubMsg.BufferLength == 32, "size %d\n", stubMsg.BufferLength); 1005 1006 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1007 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1008 memset(buffer, 0xcc, stubMsg.BufferLength); 1009 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1010 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1011 wirev = (DWORD*)buffer; 1012 1013 wirev = check_variant_header(wirev, &v, stubMsg.BufferLength); 1014 ok(*wirev == 0xcccccccc, "wv[5] %08x\n", *wirev); /* pad */ 1015 wirev++; 1016 ok(*(double*)wirev == V_R8(&v), "wv[6] %08x, wv[7] %08x\n", *wirev, *(wirev+1)); 1017 VariantInit(&v2); 1018 stubMsg.Buffer = buffer; 1019 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 1020 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1021 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 1022 ok(V_R8(&v) == V_R8(&v2), "got r8 %f expect %f\n", V_R8(&v), V_R8(&v2)); 1023 1024 VARIANT_UserFree(&umcb.Flags, &v2); 1025 HeapFree(GetProcessHeap(), 0, oldbuffer); 1026 1027 /*** R8 BYREF ***/ 1028 VariantInit(&v); 1029 V_VT(&v) = VT_R8 | VT_BYREF; 1030 d = 3.1415; 1031 V_R8REF(&v) = &d; 1032 1033 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1034 ok(stubMsg.BufferLength == 32, "size %d\n", stubMsg.BufferLength); 1035 1036 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1037 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1038 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1039 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1040 wirev = (DWORD*)buffer; 1041 1042 wirev = check_variant_header(wirev, &v, stubMsg.BufferLength); 1043 ok(*wirev == 8, "wv[5] %08x\n", *wirev); 1044 wirev++; 1045 ok(*(double*)wirev == d, "wv[6] %08x wv[7] %08x\n", *wirev, *(wirev+1)); 1046 VariantInit(&v2); 1047 stubMsg.Buffer = buffer; 1048 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 1049 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1050 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 1051 ok(*V_R8REF(&v) == *V_R8REF(&v2), "got r8 ref %f expect %f\n", *V_R8REF(&v), *V_R8REF(&v2)); 1052 1053 VARIANT_UserFree(&umcb.Flags, &v2); 1054 HeapFree(GetProcessHeap(), 0, oldbuffer); 1055 1056 /*** VARIANT_BOOL ***/ 1057 VariantInit(&v); 1058 V_VT(&v) = VT_BOOL; 1059 V_BOOL(&v) = 0x1234; 1060 1061 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1062 ok(stubMsg.BufferLength == 22, "size %d\n", stubMsg.BufferLength); 1063 1064 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1065 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1066 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1067 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1068 wirev = (DWORD*)buffer; 1069 1070 wirev = check_variant_header(wirev, &v, stubMsg.BufferLength); 1071 ok(*(short*)wirev == V_BOOL(&v), "wv[5] %04x\n", *(WORD*)wirev); 1072 VariantInit(&v2); 1073 stubMsg.Buffer = buffer; 1074 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 1075 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1076 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 1077 ok(V_BOOL(&v) == V_BOOL(&v2), "got bool %x expect %x\n", V_BOOL(&v), V_BOOL(&v2)); 1078 1079 VARIANT_UserFree(&umcb.Flags, &v2); 1080 HeapFree(GetProcessHeap(), 0, oldbuffer); 1081 1082 /*** DECIMAL ***/ 1083 VarDecFromI4(0x12345678, &dec); 1084 dec.wReserved = 0xfedc; /* Also initialize reserved field, as we check it later */ 1085 VariantInit(&v); 1086 V_DECIMAL(&v) = dec; 1087 V_VT(&v) = VT_DECIMAL; 1088 1089 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1090 ok(stubMsg.BufferLength == 40, "size %d\n", stubMsg.BufferLength); 1091 1092 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1093 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1094 memset(buffer, 0xcc, stubMsg.BufferLength); 1095 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1096 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1097 wirev = (DWORD*)buffer; 1098 1099 wirev = check_variant_header(wirev, &v, stubMsg.BufferLength); 1100 ok(*wirev == 0xcccccccc, "wirev[5] %08x\n", *wirev); /* pad */ 1101 wirev++; 1102 dec2 = dec; 1103 dec2.wReserved = VT_DECIMAL; 1104 ok(!memcmp(wirev, &dec2, sizeof(dec2)), "wirev[6] %08x wirev[7] %08x wirev[8] %08x wirev[9] %08x\n", 1105 *wirev, *(wirev + 1), *(wirev + 2), *(wirev + 3)); 1106 VariantInit(&v2); 1107 stubMsg.Buffer = buffer; 1108 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 1109 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1110 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 1111 ok(!memcmp(&V_DECIMAL(&v), & V_DECIMAL(&v2), sizeof(DECIMAL)), "decimals differ\n"); 1112 1113 VARIANT_UserFree(&umcb.Flags, &v2); 1114 HeapFree(GetProcessHeap(), 0, oldbuffer); 1115 1116 /*** DECIMAL BYREF ***/ 1117 VariantInit(&v); 1118 V_VT(&v) = VT_DECIMAL | VT_BYREF; 1119 V_DECIMALREF(&v) = &dec; 1120 1121 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1122 ok(stubMsg.BufferLength == 40, "size %d\n", stubMsg.BufferLength); 1123 1124 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1125 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1126 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1127 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1128 wirev = (DWORD*)buffer; 1129 1130 wirev = check_variant_header(wirev, &v, stubMsg.BufferLength); 1131 ok(*wirev == 16, "wv[5] %08x\n", *wirev); 1132 wirev++; 1133 ok(!memcmp(wirev, &dec, sizeof(dec)), "wirev[6] %08x wirev[7] %08x wirev[8] %08x wirev[9] %08x\n", *wirev, *(wirev + 1), *(wirev + 2), *(wirev + 3)); 1134 VariantInit(&v2); 1135 /* check_variant_header tests wReserved[123], so initialize to unique values. 1136 * (Could probably also do this by setting the variant to a known DECIMAL.) 1137 */ 1138 V_U2(&v2).wReserved1 = 0x0123; 1139 V_U2(&v2).wReserved2 = 0x4567; 1140 V_U2(&v2).wReserved3 = 0x89ab; 1141 1142 stubMsg.Buffer = buffer; 1143 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 1144 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1145 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 1146 ok(!memcmp(V_DECIMALREF(&v), V_DECIMALREF(&v2), sizeof(DECIMAL)), "decimals differ\n"); 1147 1148 VARIANT_UserFree(&umcb.Flags, &v2); 1149 HeapFree(GetProcessHeap(), 0, oldbuffer); 1150 1151 /*** EMPTY ***/ 1152 VariantInit(&v); 1153 V_VT(&v) = VT_EMPTY; 1154 1155 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1156 ok(stubMsg.BufferLength == 20, "size %d\n", stubMsg.BufferLength); 1157 1158 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1159 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1160 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1161 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1162 wirev = (DWORD*)buffer; 1163 1164 check_variant_header(wirev, &v, stubMsg.BufferLength); 1165 VariantInit(&v2); 1166 stubMsg.Buffer = buffer; 1167 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 1168 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1169 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 1170 1171 VARIANT_UserFree(&umcb.Flags, &v2); 1172 HeapFree(GetProcessHeap(), 0, oldbuffer); 1173 1174 /*** NULL ***/ 1175 VariantInit(&v); 1176 V_VT(&v) = VT_NULL; 1177 1178 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1179 ok(stubMsg.BufferLength == 20, "size %d\n", stubMsg.BufferLength); 1180 1181 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1182 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1183 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1184 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1185 wirev = (DWORD*)buffer; 1186 1187 check_variant_header(wirev, &v, stubMsg.BufferLength); 1188 VariantInit(&v2); 1189 stubMsg.Buffer = buffer; 1190 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 1191 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1192 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 1193 1194 VARIANT_UserFree(&umcb.Flags, &v2); 1195 HeapFree(GetProcessHeap(), 0, oldbuffer); 1196 1197 /*** BSTR ***/ 1198 b = SysAllocString(str); 1199 VariantInit(&v); 1200 V_VT(&v) = VT_BSTR; 1201 V_BSTR(&v) = b; 1202 1203 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1204 ok(stubMsg.BufferLength == 60, "size %d\n", stubMsg.BufferLength); 1205 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1206 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1207 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1208 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1209 wirev = (DWORD*)buffer; 1210 1211 wirev = check_variant_header(wirev, &v, stubMsg.BufferLength); 1212 ok(*wirev, "wv[5] %08x\n", *wirev); /* win2k: this is b. winxp: this is (char*)b + 1 */ 1213 wirev++; 1214 check_bstr(wirev, V_BSTR(&v)); 1215 VariantInit(&v2); 1216 stubMsg.Buffer = buffer; 1217 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 1218 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1219 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 1220 ok(SysStringByteLen(V_BSTR(&v)) == SysStringByteLen(V_BSTR(&v2)), "bstr string lens differ\n"); 1221 ok(!memcmp(V_BSTR(&v), V_BSTR(&v2), SysStringByteLen(V_BSTR(&v))), "bstrs differ\n"); 1222 1223 VARIANT_UserFree(&umcb.Flags, &v2); 1224 HeapFree(GetProcessHeap(), 0, oldbuffer); 1225 1226 /*** BSTR BYREF ***/ 1227 VariantInit(&v); 1228 V_VT(&v) = VT_BSTR | VT_BYREF; 1229 V_BSTRREF(&v) = &b; 1230 1231 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1232 ok(stubMsg.BufferLength == 64, "size %d\n", stubMsg.BufferLength); 1233 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1234 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1235 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1236 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1237 wirev = (DWORD*)buffer; 1238 1239 wirev = check_variant_header(wirev, &v, stubMsg.BufferLength); 1240 ok(*wirev == 0x4, "wv[5] %08x\n", *wirev); 1241 wirev++; 1242 ok(*wirev, "wv[6] %08x\n", *wirev); /* win2k: this is b. winxp: this is (char*)b + 1 */ 1243 wirev++; 1244 check_bstr(wirev, b); 1245 b2 = SysAllocString(str); 1246 b2[0] = 0; 1247 V_VT(&v2) = VT_BSTR | VT_BYREF; 1248 V_BSTRREF(&v2) = &b2; 1249 mem = b2; 1250 VariantInit(&v2); 1251 stubMsg.Buffer = buffer; 1252 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 1253 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1254 ok(mem == b2, "BSTR should be reused\n"); 1255 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 1256 ok(SysStringByteLen(*V_BSTRREF(&v)) == SysStringByteLen(*V_BSTRREF(&v2)), "bstr string lens differ\n"); 1257 ok(!memcmp(*V_BSTRREF(&v), *V_BSTRREF(&v2), SysStringByteLen(*V_BSTRREF(&v))), "bstrs differ\n"); 1258 1259 SysFreeString(b2); 1260 HeapFree(GetProcessHeap(), 0, oldbuffer); 1261 SysFreeString(b); 1262 1263 /*** ARRAY ***/ 1264 sab.lLbound = 5; 1265 sab.cElements = 10; 1266 1267 lpsa = SafeArrayCreate(VT_R8, 1, &sab); 1268 *(DWORD *)lpsa->pvData = 0xcafebabe; 1269 *((DWORD *)lpsa->pvData + 1) = 0xdeadbeef; 1270 1271 VariantInit(&v); 1272 V_VT(&v) = VT_UI4 | VT_ARRAY; 1273 V_ARRAY(&v) = lpsa; 1274 1275 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1276 expected = 152; 1277 ok(stubMsg.BufferLength == expected || stubMsg.BufferLength == expected + 8, /* win64 */ 1278 "size %u instead of %u\n", stubMsg.BufferLength, expected); 1279 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1280 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1281 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1282 ok(next == buffer + expected, "got %p expect %p\n", next, buffer + expected); 1283 wirev = (DWORD*)buffer; 1284 1285 wirev = check_variant_header(wirev, &v, expected); 1286 ok(*wirev, "wv[5] %08x\n", *wirev); /* win2k: this is lpsa. winxp: this is (char*)lpsa + 1 */ 1287 wirev++; 1288 check_safearray(wirev, lpsa); 1289 VariantInit(&v2); 1290 stubMsg.Buffer = buffer; 1291 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 1292 ok(next == buffer + expected, "got %p expect %p\n", next, buffer + expected); 1293 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 1294 ok(SafeArrayGetDim(V_ARRAY(&v)) == SafeArrayGetDim(V_ARRAY(&v2)), "array dims differ\n"); 1295 SafeArrayGetLBound(V_ARRAY(&v), 1, &bound); 1296 SafeArrayGetLBound(V_ARRAY(&v2), 1, &bound2); 1297 ok(bound == bound2, "array lbounds differ\n"); 1298 SafeArrayGetUBound(V_ARRAY(&v), 1, &bound); 1299 SafeArrayGetUBound(V_ARRAY(&v2), 1, &bound2); 1300 ok(bound == bound2, "array ubounds differ\n"); 1301 if (pSafeArrayGetVartype) 1302 { 1303 pSafeArrayGetVartype(V_ARRAY(&v), &vt); 1304 pSafeArrayGetVartype(V_ARRAY(&v2), &vt2); 1305 ok(vt == vt2, "array vts differ %x %x\n", vt, vt2); 1306 } 1307 VARIANT_UserFree(&umcb.Flags, &v2); 1308 HeapFree(GetProcessHeap(), 0, oldbuffer); 1309 1310 /*** ARRAY BYREF ***/ 1311 VariantInit(&v); 1312 V_VT(&v) = VT_UI4 | VT_ARRAY | VT_BYREF; 1313 V_ARRAYREF(&v) = &lpsa; 1314 1315 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1316 expected = 152; 1317 ok(stubMsg.BufferLength == expected || stubMsg.BufferLength == expected + 16, /* win64 */ 1318 "size %u instead of %u\n", stubMsg.BufferLength, expected); 1319 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1320 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1321 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1322 ok(next == buffer + expected, "got %p expect %p\n", next, buffer + expected); 1323 wirev = (DWORD*)buffer; 1324 1325 wirev = check_variant_header(wirev, &v, expected); 1326 ok(*wirev == 4, "wv[5] %08x\n", *wirev); 1327 wirev++; 1328 ok(*wirev, "wv[6] %08x\n", *wirev); /* win2k: this is lpsa. winxp: this is (char*)lpsa + 1 */ 1329 wirev++; 1330 check_safearray(wirev, lpsa); 1331 VariantInit(&v2); 1332 stubMsg.Buffer = buffer; 1333 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 1334 ok(next == buffer + expected, "got %p expect %p\n", next, buffer + expected); 1335 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 1336 ok(SafeArrayGetDim(*V_ARRAYREF(&v)) == SafeArrayGetDim(*V_ARRAYREF(&v2)), "array dims differ\n"); 1337 SafeArrayGetLBound(*V_ARRAYREF(&v), 1, &bound); 1338 SafeArrayGetLBound(*V_ARRAYREF(&v2), 1, &bound2); 1339 ok(bound == bound2, "array lbounds differ\n"); 1340 SafeArrayGetUBound(*V_ARRAYREF(&v), 1, &bound); 1341 SafeArrayGetUBound(*V_ARRAYREF(&v2), 1, &bound2); 1342 ok(bound == bound2, "array ubounds differ\n"); 1343 if (pSafeArrayGetVartype) 1344 { 1345 pSafeArrayGetVartype(*V_ARRAYREF(&v), &vt); 1346 pSafeArrayGetVartype(*V_ARRAYREF(&v2), &vt2); 1347 ok(vt == vt2, "array vts differ %x %x\n", vt, vt2); 1348 } 1349 VARIANT_UserFree(&umcb.Flags, &v2); 1350 HeapFree(GetProcessHeap(), 0, oldbuffer); 1351 1352 /*** ARRAY BYREF ***/ 1353 VariantInit(&v); 1354 V_VT(&v) = VT_UI4 | VT_ARRAY | VT_BYREF; 1355 V_ARRAYREF(&v) = &lpsa; 1356 lpsa->fFeatures |= FADF_STATIC; 1357 1358 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1359 expected = 152; 1360 ok(stubMsg.BufferLength == expected || stubMsg.BufferLength == expected + 16, /* win64 */ 1361 "size %u instead of %u\n", stubMsg.BufferLength, expected); 1362 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1363 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1364 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1365 ok(next == buffer + expected, "got %p expect %p\n", next, buffer + expected); 1366 wirev = (DWORD*)buffer; 1367 1368 wirev = check_variant_header(wirev, &v, expected); 1369 ok(*wirev == 4, "wv[5] %08x\n", *wirev); 1370 wirev++; 1371 ok(*wirev, "wv[6] %08x\n", *wirev); /* win2k: this is lpsa. winxp: this is (char*)lpsa + 1 */ 1372 wirev++; 1373 check_safearray(wirev, lpsa); 1374 lpsa_copy = lpsa2 = SafeArrayCreate(VT_I8, 1, &sab); 1375 /* set FADF_STATIC feature to make sure lpsa2->pvData pointer changes if new data buffer is allocated */ 1376 lpsa2->fFeatures |= FADF_STATIC; 1377 mem = lpsa2->pvData; 1378 V_VT(&v2) = VT_UI4 | VT_ARRAY | VT_BYREF; 1379 V_ARRAYREF(&v2) = &lpsa2; 1380 stubMsg.Buffer = buffer; 1381 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 1382 ok(next == buffer + expected, "got %p expect %p\n", next, buffer + expected); 1383 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 1384 ok(lpsa2 == lpsa_copy, "safearray should be reused\n"); 1385 ok(mem == lpsa2->pvData, "safearray data should be reused\n"); 1386 ok(SafeArrayGetDim(*V_ARRAYREF(&v)) == SafeArrayGetDim(*V_ARRAYREF(&v2)), "array dims differ\n"); 1387 SafeArrayGetLBound(*V_ARRAYREF(&v), 1, &bound); 1388 SafeArrayGetLBound(*V_ARRAYREF(&v2), 1, &bound2); 1389 ok(bound == bound2, "array lbounds differ\n"); 1390 SafeArrayGetUBound(*V_ARRAYREF(&v), 1, &bound); 1391 SafeArrayGetUBound(*V_ARRAYREF(&v2), 1, &bound2); 1392 ok(bound == bound2, "array ubounds differ\n"); 1393 if (pSafeArrayGetVartype) 1394 { 1395 pSafeArrayGetVartype(*V_ARRAYREF(&v), &vt); 1396 pSafeArrayGetVartype(*V_ARRAYREF(&v2), &vt2); 1397 ok(vt == vt2, "array vts differ %x %x\n", vt, vt2); 1398 } 1399 lpsa2->fFeatures &= ~FADF_STATIC; 1400 hr = SafeArrayDestroy(*V_ARRAYREF(&v2)); 1401 ok(hr == S_OK, "got 0x%08x\n", hr); 1402 HeapFree(GetProcessHeap(), 0, oldbuffer); 1403 lpsa->fFeatures &= ~FADF_STATIC; 1404 hr = SafeArrayDestroy(lpsa); 1405 ok(hr == S_OK, "got 0x%08x\n", hr); 1406 1407 /*** VARIANT BYREF ***/ 1408 VariantInit(&v); 1409 VariantInit(&v2); 1410 V_VT(&v2) = VT_R8; 1411 V_R8(&v2) = 3.1415; 1412 V_VT(&v) = VT_VARIANT | VT_BYREF; 1413 V_VARIANTREF(&v) = &v2; 1414 1415 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1416 ok(stubMsg.BufferLength == 64, "size %d\n", stubMsg.BufferLength); 1417 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1418 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1419 memset(buffer, 0xcc, stubMsg.BufferLength); 1420 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1421 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1422 wirev = (DWORD*)buffer; 1423 wirev = check_variant_header(wirev, &v, stubMsg.BufferLength); 1424 1425 ok(*wirev == sizeof(VARIANT), "wv[5] %08x\n", *wirev); 1426 wirev++; 1427 ok(*wirev == ('U' | 's' << 8 | 'e' << 16 | 'r' << 24), "wv[6] %08x\n", *wirev); /* 'User' */ 1428 wirev++; 1429 ok(*wirev == 0xcccccccc, "wv[7] %08x\n", *wirev); /* pad */ 1430 wirev++; 1431 wirev = check_variant_header(wirev, &v2, stubMsg.BufferLength - 32); 1432 ok(*wirev == 0xcccccccc, "wv[13] %08x\n", *wirev); /* pad for VT_R8 */ 1433 wirev++; 1434 ok(*(double*)wirev == V_R8(&v2), "wv[6] %08x wv[7] %08x\n", *wirev, *(wirev+1)); 1435 VariantInit(&v3); 1436 stubMsg.Buffer = buffer; 1437 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v3); 1438 ok(next == buffer + stubMsg.BufferLength, "got %p expect %p\n", next, buffer + stubMsg.BufferLength); 1439 ok(V_VT(&v) == V_VT(&v3), "got vt %d expect %d\n", V_VT(&v), V_VT(&v3)); 1440 ok(V_VT(V_VARIANTREF(&v)) == V_VT(V_VARIANTREF(&v3)), "vts differ %x %x\n", 1441 V_VT(V_VARIANTREF(&v)), V_VT(V_VARIANTREF(&v3))); 1442 ok(V_R8(V_VARIANTREF(&v)) == V_R8(V_VARIANTREF(&v3)), "r8s differ\n"); 1443 VARIANT_UserFree(&umcb.Flags, &v3); 1444 HeapFree(GetProcessHeap(), 0, oldbuffer); 1445 1446 /*** UNKNOWN ***/ 1447 heap_unknown = HeapAlloc(GetProcessHeap(), 0, sizeof(*heap_unknown)); 1448 heap_unknown->IUnknown_iface.lpVtbl = &HeapUnknown_Vtbl; 1449 heap_unknown->refs = 1; 1450 VariantInit(&v); 1451 VariantInit(&v2); 1452 V_VT(&v) = VT_UNKNOWN; 1453 V_UNKNOWN(&v) = &heap_unknown->IUnknown_iface; 1454 1455 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1456 ok(stubMsg.BufferLength > 40, "size %d\n", stubMsg.BufferLength); 1457 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1458 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1459 memset(buffer, 0xcc, stubMsg.BufferLength); 1460 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1461 todo_wine 1462 ok(heap_unknown->refs == 2, "got refcount %d\n", heap_unknown->refs); 1463 wirev = (DWORD*)buffer; 1464 wirev = check_variant_header(wirev, &v, next - buffer); 1465 1466 ok(*wirev == (DWORD_PTR)V_UNKNOWN(&v) /* Win9x */ || 1467 *wirev == (DWORD_PTR)V_UNKNOWN(&v) + 1 /* NT */, "wv[5] %08x\n", *wirev); 1468 wirev++; 1469 ok(*wirev == next - buffer - 0x20, "wv[6] %08x\n", *wirev); 1470 wirev++; 1471 ok(*wirev == next - buffer - 0x20, "wv[7] %08x\n", *wirev); 1472 wirev++; 1473 ok(*wirev == 0x574f454d, "wv[8] %08x\n", *wirev); 1474 VariantInit(&v3); 1475 V_VT(&v3) = VT_UNKNOWN; 1476 V_UNKNOWN(&v3) = &heap_unknown->IUnknown_iface; 1477 IUnknown_AddRef(V_UNKNOWN(&v3)); 1478 stubMsg.Buffer = buffer; 1479 todo_wine 1480 ok(heap_unknown->refs == 3, "got refcount %d\n", heap_unknown->refs); 1481 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v3); 1482 ok(V_VT(&v) == V_VT(&v3), "got vt %d expect %d\n", V_VT(&v), V_VT(&v3)); 1483 ok(V_UNKNOWN(&v) == V_UNKNOWN(&v3), "got %p expect %p\n", V_UNKNOWN(&v), V_UNKNOWN(&v3)); 1484 VARIANT_UserFree(&umcb.Flags, &v3); 1485 ok(heap_unknown->refs == 1, "%d refcounts of IUnknown leaked\n", heap_unknown->refs - 1); 1486 IUnknown_Release(&heap_unknown->IUnknown_iface); 1487 HeapFree(GetProcessHeap(), 0, oldbuffer); 1488 1489 /*** NULL UNKNOWN ***/ 1490 VariantInit(&v); 1491 V_VT(&v) = VT_UNKNOWN; 1492 V_UNKNOWN(&v) = NULL; 1493 1494 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1495 ok(stubMsg.BufferLength >= 24, "size %d\n", stubMsg.BufferLength); 1496 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1497 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1498 memset(buffer, 0xcc, stubMsg.BufferLength); 1499 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1500 wirev = (DWORD*)buffer; 1501 wirev = check_variant_header(wirev, &v, next - buffer); 1502 ok(*wirev == 0, "wv[5] %08x\n", *wirev); 1503 1504 VariantInit(&v2); 1505 stubMsg.Buffer = buffer; 1506 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v2); 1507 ok(V_VT(&v) == V_VT(&v2), "got vt %d expect %d\n", V_VT(&v), V_VT(&v2)); 1508 ok(V_UNKNOWN(&v2) == NULL, "got %p expect NULL\n", V_UNKNOWN(&v2)); 1509 VARIANT_UserFree(&umcb.Flags, &v2); 1510 HeapFree(GetProcessHeap(), 0, oldbuffer); 1511 1512 /*** UNKNOWN BYREF ***/ 1513 heap_unknown = HeapAlloc(GetProcessHeap(), 0, sizeof(*heap_unknown)); 1514 heap_unknown->IUnknown_iface.lpVtbl = &HeapUnknown_Vtbl; 1515 heap_unknown->refs = 1; 1516 VariantInit(&v); 1517 VariantInit(&v2); 1518 V_VT(&v) = VT_UNKNOWN | VT_BYREF; 1519 V_UNKNOWNREF(&v) = (IUnknown **)&heap_unknown; 1520 1521 rpcMsg.BufferLength = stubMsg.BufferLength = VARIANT_UserSize(&umcb.Flags, 0, &v); 1522 ok(stubMsg.BufferLength >= 44, "size %d\n", stubMsg.BufferLength); 1523 buffer = rpcMsg.Buffer = stubMsg.Buffer = stubMsg.BufferStart = alloc_aligned(stubMsg.BufferLength, &oldbuffer); 1524 stubMsg.BufferEnd = stubMsg.Buffer + stubMsg.BufferLength; 1525 memset(buffer, 0xcc, stubMsg.BufferLength); 1526 ok(heap_unknown->refs == 1, "got refcount %d\n", heap_unknown->refs); 1527 next = VARIANT_UserMarshal(&umcb.Flags, buffer, &v); 1528 todo_wine 1529 ok(heap_unknown->refs == 2, "got refcount %d\n", heap_unknown->refs); 1530 wirev = (DWORD*)buffer; 1531 wirev = check_variant_header(wirev, &v, next - buffer); 1532 1533 ok(*wirev == 4, "wv[5] %08x\n", *wirev); 1534 wirev++; 1535 ok(*wirev == (DWORD_PTR)heap_unknown /* Win9x, Win2000 */ || 1536 *wirev == (DWORD_PTR)heap_unknown + 1 /* XP */, "wv[6] %08x\n", *wirev); 1537 wirev++; 1538 ok(*wirev == next - buffer - 0x24, "wv[7] %08x\n", *wirev); 1539 wirev++; 1540 ok(*wirev == next - buffer - 0x24, "wv[8] %08x\n", *wirev); 1541 wirev++; 1542 ok(*wirev == 0x574f454d, "wv[9] %08x\n", *wirev); 1543 1544 VariantInit(&v3); 1545 V_VT(&v3) = VT_UNKNOWN; 1546 V_UNKNOWN(&v3) = &heap_unknown->IUnknown_iface; 1547 IUnknown_AddRef(V_UNKNOWN(&v3)); 1548 stubMsg.Buffer = buffer; 1549 next = VARIANT_UserUnmarshal(&umcb.Flags, buffer, &v3); 1550 ok(heap_unknown->refs == 2, "got refcount %d\n", heap_unknown->refs); 1551 ok(V_VT(&v) == V_VT(&v3), "got vt %d expect %d\n", V_VT(&v), V_VT(&v3)); 1552 ok(*V_UNKNOWNREF(&v) == *V_UNKNOWNREF(&v3), "got %p expect %p\n", *V_UNKNOWNREF(&v), *V_UNKNOWNREF(&v3)); 1553 VARIANT_UserFree(&umcb.Flags, &v3); 1554 ok(heap_unknown->refs == 1, "%d refcounts of IUnknown leaked\n", heap_unknown->refs - 1); 1555 IUnknown_Release(&heap_unknown->IUnknown_iface); 1556 HeapFree(GetProcessHeap(), 0, oldbuffer); 1557 } 1558 1559 1560 START_TEST(usrmarshal) 1561 { 1562 HANDLE hOleaut32 = GetModuleHandleA("oleaut32.dll"); 1563 #define GETPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func) 1564 GETPTR(SafeArrayGetIID); 1565 GETPTR(SafeArrayGetVartype); 1566 GETPTR(VarBstrCmp); 1567 #undef GETPTR 1568 1569 if (!pSafeArrayGetIID || !pSafeArrayGetVartype) 1570 win_skip("SafeArrayGetIID and/or SafeArrayGetVartype is not available, some tests will be skipped\n"); 1571 1572 CoInitialize(NULL); 1573 1574 test_marshal_LPSAFEARRAY(); 1575 test_marshal_BSTR(); 1576 test_marshal_VARIANT(); 1577 1578 CoUninitialize(); 1579 } 1580