1 /* 2 * Marshalling library 3 * 4 * Copyright 2002 Marcus Meissner 5 * Copyright 2004 Mike Hearn, for CodeWeavers 6 * Copyright 2004 Rob Shearman, for CodeWeavers 7 * 8 * This library is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU Lesser General Public 10 * License as published by the Free Software Foundation; either 11 * version 2.1 of the License, or (at your option) any later version. 12 * 13 * This library is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * Lesser General Public License for more details. 17 * 18 * You should have received a copy of the GNU Lesser General Public 19 * License along with this library; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 21 */ 22 23 #include <stdarg.h> 24 #include <string.h> 25 #include <assert.h> 26 27 #define COBJMACROS 28 29 #include "windef.h" 30 #include "winbase.h" 31 #include "winuser.h" 32 #include "objbase.h" 33 #include "ole2.h" 34 #include "winerror.h" 35 #include "wine/unicode.h" 36 37 #include "compobj_private.h" 38 39 #include "wine/debug.h" 40 41 WINE_DEFAULT_DEBUG_CHANNEL(ole); 42 43 extern const CLSID CLSID_DfMarshal; 44 45 /* number of refs given out for normal marshaling */ 46 #define NORMALEXTREFS 5 47 48 49 /* private flag indicating that the object was marshaled as table-weak */ 50 #define SORFP_TABLEWEAK SORF_OXRES1 51 /* private flag indicating that the caller does not want to notify the stub 52 * when the proxy disconnects or is destroyed */ 53 #define SORFP_NOLIFETIMEMGMT SORF_OXRES2 54 55 /* imported object / proxy manager */ 56 struct proxy_manager 57 { 58 IMultiQI IMultiQI_iface; 59 IMarshal IMarshal_iface; 60 IClientSecurity IClientSecurity_iface; 61 struct apartment *parent; /* owning apartment (RO) */ 62 struct list entry; /* entry in apartment (CS parent->cs) */ 63 OXID oxid; /* object exported ID (RO) */ 64 OXID_INFO oxid_info; /* string binding, ipid of rem unknown and other information (RO) */ 65 OID oid; /* object ID (RO) */ 66 struct list interfaces; /* imported interfaces (CS cs) */ 67 LONG refs; /* proxy reference count (LOCK) */ 68 CRITICAL_SECTION cs; /* thread safety for this object and children */ 69 ULONG sorflags; /* STDOBJREF flags (RO) */ 70 IRemUnknown *remunk; /* proxy to IRemUnknown used for lifecycle management (CS cs) */ 71 HANDLE remoting_mutex; /* mutex used for synchronizing access to IRemUnknown */ 72 MSHCTX dest_context; /* context used for activating optimisations (LOCK) */ 73 void *dest_context_data; /* reserved context value (LOCK) */ 74 }; 75 76 static inline struct proxy_manager *impl_from_IMultiQI( IMultiQI *iface ) 77 { 78 return CONTAINING_RECORD(iface, struct proxy_manager, IMultiQI_iface); 79 } 80 81 static inline struct proxy_manager *impl_from_IMarshal( IMarshal *iface ) 82 { 83 return CONTAINING_RECORD(iface, struct proxy_manager, IMarshal_iface); 84 } 85 86 static inline struct proxy_manager *impl_from_IClientSecurity( IClientSecurity *iface ) 87 { 88 return CONTAINING_RECORD(iface, struct proxy_manager, IClientSecurity_iface); 89 } 90 91 static HRESULT unmarshal_object(const STDOBJREF *stdobjref, APARTMENT *apt, 92 MSHCTX dest_context, void *dest_context_data, 93 REFIID riid, const OXID_INFO *oxid_info, 94 void **object); 95 96 /* Marshalling just passes a unique identifier to the remote client, 97 * that makes it possible to find the passed interface again. 98 * 99 * So basically we need a set of values that make it unique. 100 * 101 * Note that the IUnknown_QI(ob,xiid,&ppv) always returns the SAME ppv value! 102 * 103 * A triple is used: OXID (apt id), OID (stub manager id), 104 * IPID (interface ptr/stub id). 105 * 106 * OXIDs identify an apartment and are network scoped 107 * OIDs identify a stub manager and are apartment scoped 108 * IPIDs identify an interface stub and are apartment scoped 109 */ 110 111 static inline HRESULT get_facbuf_for_iid(REFIID riid, IPSFactoryBuffer **facbuf) 112 { 113 HRESULT hr; 114 CLSID clsid; 115 116 hr = CoGetPSClsid(riid, &clsid); 117 if (hr != S_OK) 118 return hr; 119 return CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER | WINE_CLSCTX_DONT_HOST, 120 NULL, &IID_IPSFactoryBuffer, (LPVOID*)facbuf); 121 } 122 123 /* marshals an object into a STDOBJREF structure */ 124 HRESULT marshal_object(APARTMENT *apt, STDOBJREF *stdobjref, REFIID riid, IUnknown *object, 125 DWORD dest_context, void *dest_context_data, MSHLFLAGS mshlflags) 126 { 127 struct stub_manager *manager; 128 struct ifstub *ifstub; 129 BOOL tablemarshal; 130 HRESULT hr; 131 132 hr = apartment_getoxid(apt, &stdobjref->oxid); 133 if (hr != S_OK) 134 return hr; 135 136 hr = apartment_createwindowifneeded(apt); 137 if (hr != S_OK) 138 return hr; 139 140 if (!(manager = get_stub_manager_from_object(apt, object, TRUE))) 141 return E_OUTOFMEMORY; 142 143 stdobjref->flags = SORF_NULL; 144 if (mshlflags & MSHLFLAGS_TABLEWEAK) 145 stdobjref->flags |= SORFP_TABLEWEAK; 146 if (mshlflags & MSHLFLAGS_NOPING) 147 stdobjref->flags |= SORF_NOPING; 148 stdobjref->oid = manager->oid; 149 150 tablemarshal = ((mshlflags & MSHLFLAGS_TABLESTRONG) || (mshlflags & MSHLFLAGS_TABLEWEAK)); 151 152 /* make sure ifstub that we are creating is unique */ 153 ifstub = stub_manager_find_ifstub(manager, riid, mshlflags); 154 if (!ifstub) { 155 IRpcStubBuffer *stub = NULL; 156 157 /* IUnknown doesn't require a stub buffer, because it never goes out on 158 * the wire */ 159 if (!IsEqualIID(riid, &IID_IUnknown)) 160 { 161 IPSFactoryBuffer *psfb; 162 163 hr = get_facbuf_for_iid(riid, &psfb); 164 if (hr == S_OK) { 165 hr = IPSFactoryBuffer_CreateStub(psfb, riid, manager->object, &stub); 166 IPSFactoryBuffer_Release(psfb); 167 if (hr != S_OK) 168 ERR("Failed to create an IRpcStubBuffer from IPSFactory for %s with error 0x%08x\n", 169 debugstr_guid(riid), hr); 170 }else { 171 ERR("couldn't get IPSFactory buffer for interface %s\n", debugstr_guid(riid)); 172 hr = E_NOINTERFACE; 173 } 174 175 } 176 177 if (hr == S_OK) { 178 ifstub = stub_manager_new_ifstub(manager, stub, riid, dest_context, dest_context_data, mshlflags); 179 if (!ifstub) 180 hr = E_OUTOFMEMORY; 181 } 182 if (stub) IRpcStubBuffer_Release(stub); 183 184 if (hr != S_OK) { 185 stub_manager_int_release(manager); 186 /* destroy the stub manager if it has no ifstubs by releasing 187 * zero external references */ 188 stub_manager_ext_release(manager, 0, FALSE, TRUE); 189 return hr; 190 } 191 } 192 193 if (!tablemarshal) 194 { 195 stdobjref->cPublicRefs = NORMALEXTREFS; 196 stub_manager_ext_addref(manager, stdobjref->cPublicRefs, FALSE); 197 } 198 else 199 { 200 stdobjref->cPublicRefs = 0; 201 if (mshlflags & MSHLFLAGS_TABLESTRONG) 202 stub_manager_ext_addref(manager, 1, FALSE); 203 else 204 stub_manager_ext_addref(manager, 0, TRUE); 205 } 206 207 /* FIXME: check return value */ 208 RPC_RegisterInterface(riid); 209 210 stdobjref->ipid = ifstub->ipid; 211 212 stub_manager_int_release(manager); 213 return S_OK; 214 } 215 216 217 218 /* Client-side identity of the server object */ 219 220 static HRESULT proxy_manager_get_remunknown(struct proxy_manager * This, IRemUnknown **remunk); 221 static void proxy_manager_destroy(struct proxy_manager * This); 222 static HRESULT proxy_manager_find_ifproxy(struct proxy_manager * This, REFIID riid, struct ifproxy ** ifproxy_found); 223 static HRESULT proxy_manager_query_local_interface(struct proxy_manager * This, REFIID riid, void ** ppv); 224 225 static HRESULT WINAPI ClientIdentity_QueryInterface(IMultiQI * iface, REFIID riid, void ** ppv) 226 { 227 HRESULT hr; 228 MULTI_QI mqi; 229 230 TRACE("%s\n", debugstr_guid(riid)); 231 232 mqi.pIID = riid; 233 hr = IMultiQI_QueryMultipleInterfaces(iface, 1, &mqi); 234 *ppv = mqi.pItf; 235 236 return hr; 237 } 238 239 static ULONG WINAPI ClientIdentity_AddRef(IMultiQI *iface) 240 { 241 struct proxy_manager *This = impl_from_IMultiQI(iface); 242 TRACE("%p - before %d\n", iface, This->refs); 243 return InterlockedIncrement(&This->refs); 244 } 245 246 static ULONG WINAPI ClientIdentity_Release(IMultiQI *iface) 247 { 248 struct proxy_manager *This = impl_from_IMultiQI(iface); 249 ULONG refs = InterlockedDecrement(&This->refs); 250 TRACE("%p - after %d\n", iface, refs); 251 if (!refs) 252 proxy_manager_destroy(This); 253 return refs; 254 } 255 256 static HRESULT WINAPI ClientIdentity_QueryMultipleInterfaces(IMultiQI *iface, ULONG cMQIs, MULTI_QI *pMQIs) 257 { 258 struct proxy_manager *This = impl_from_IMultiQI(iface); 259 REMQIRESULT *qiresults = NULL; 260 ULONG nonlocal_mqis = 0; 261 ULONG i; 262 ULONG successful_mqis = 0; 263 IID *iids = HeapAlloc(GetProcessHeap(), 0, cMQIs * sizeof(*iids)); 264 /* mapping of RemQueryInterface index to QueryMultipleInterfaces index */ 265 ULONG *mapping = HeapAlloc(GetProcessHeap(), 0, cMQIs * sizeof(*mapping)); 266 267 TRACE("cMQIs: %d\n", cMQIs); 268 269 /* try to get a local interface - this includes already active proxy 270 * interfaces and also interfaces exposed by the proxy manager */ 271 for (i = 0; i < cMQIs; i++) 272 { 273 TRACE("iid[%d] = %s\n", i, debugstr_guid(pMQIs[i].pIID)); 274 pMQIs[i].hr = proxy_manager_query_local_interface(This, pMQIs[i].pIID, (void **)&pMQIs[i].pItf); 275 if (pMQIs[i].hr == S_OK) 276 successful_mqis++; 277 else 278 { 279 iids[nonlocal_mqis] = *pMQIs[i].pIID; 280 mapping[nonlocal_mqis] = i; 281 nonlocal_mqis++; 282 } 283 } 284 285 TRACE("%d interfaces not found locally\n", nonlocal_mqis); 286 287 /* if we have more than one interface not found locally then we must try 288 * to query the remote object for it */ 289 if (nonlocal_mqis != 0) 290 { 291 IRemUnknown *remunk; 292 HRESULT hr; 293 IPID *ipid; 294 295 /* get the ipid of the first entry */ 296 /* FIXME: should we implement ClientIdentity on the ifproxies instead 297 * of the proxy_manager so we use the correct ipid here? */ 298 ipid = &LIST_ENTRY(list_head(&This->interfaces), struct ifproxy, entry)->stdobjref.ipid; 299 300 /* get IRemUnknown proxy so we can communicate with the remote object */ 301 hr = proxy_manager_get_remunknown(This, &remunk); 302 303 if (SUCCEEDED(hr)) 304 { 305 hr = IRemUnknown_RemQueryInterface(remunk, ipid, NORMALEXTREFS, 306 nonlocal_mqis, iids, &qiresults); 307 IRemUnknown_Release(remunk); 308 if (FAILED(hr)) 309 ERR("IRemUnknown_RemQueryInterface failed with error 0x%08x\n", hr); 310 } 311 312 /* IRemUnknown_RemQueryInterface can return S_FALSE if only some of 313 * the interfaces were returned */ 314 if (SUCCEEDED(hr)) 315 { 316 APARTMENT *apt = apartment_get_current_or_mta(); 317 318 /* try to unmarshal each object returned to us */ 319 for (i = 0; i < nonlocal_mqis; i++) 320 { 321 ULONG index = mapping[i]; 322 HRESULT hrobj = qiresults[i].hResult; 323 if (hrobj == S_OK) 324 hrobj = unmarshal_object(&qiresults[i].std, apt, 325 This->dest_context, 326 This->dest_context_data, 327 pMQIs[index].pIID, &This->oxid_info, 328 (void **)&pMQIs[index].pItf); 329 330 if (hrobj == S_OK) 331 successful_mqis++; 332 else 333 ERR("Failed to get pointer to interface %s\n", debugstr_guid(pMQIs[index].pIID)); 334 pMQIs[index].hr = hrobj; 335 } 336 337 apartment_release(apt); 338 } 339 340 /* free the memory allocated by the proxy */ 341 CoTaskMemFree(qiresults); 342 } 343 344 TRACE("%d/%d successfully queried\n", successful_mqis, cMQIs); 345 346 HeapFree(GetProcessHeap(), 0, iids); 347 HeapFree(GetProcessHeap(), 0, mapping); 348 349 if (successful_mqis == cMQIs) 350 return S_OK; /* we got all requested interfaces */ 351 else if (successful_mqis == 0) 352 return E_NOINTERFACE; /* we didn't get any interfaces */ 353 else 354 return S_FALSE; /* we got some interfaces */ 355 } 356 357 static const IMultiQIVtbl ClientIdentity_Vtbl = 358 { 359 ClientIdentity_QueryInterface, 360 ClientIdentity_AddRef, 361 ClientIdentity_Release, 362 ClientIdentity_QueryMultipleInterfaces 363 }; 364 365 /* FIXME: remove these */ 366 static HRESULT WINAPI StdMarshalImpl_GetUnmarshalClass(LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext, void* pvDestContext, DWORD mshlflags, CLSID* pCid); 367 static HRESULT WINAPI StdMarshalImpl_GetMarshalSizeMax(LPMARSHAL iface, REFIID riid, void* pv, DWORD dwDestContext, void* pvDestContext, DWORD mshlflags, DWORD* pSize); 368 static HRESULT WINAPI StdMarshalImpl_UnmarshalInterface(LPMARSHAL iface, IStream *pStm, REFIID riid, void **ppv); 369 static HRESULT WINAPI StdMarshalImpl_ReleaseMarshalData(LPMARSHAL iface, IStream *pStm); 370 static HRESULT WINAPI StdMarshalImpl_DisconnectObject(LPMARSHAL iface, DWORD dwReserved); 371 372 static HRESULT WINAPI Proxy_QueryInterface(IMarshal *iface, REFIID riid, void **ppvObject) 373 { 374 struct proxy_manager *This = impl_from_IMarshal( iface ); 375 return IMultiQI_QueryInterface(&This->IMultiQI_iface, riid, ppvObject); 376 } 377 378 static ULONG WINAPI Proxy_AddRef(IMarshal *iface) 379 { 380 struct proxy_manager *This = impl_from_IMarshal( iface ); 381 return IMultiQI_AddRef(&This->IMultiQI_iface); 382 } 383 384 static ULONG WINAPI Proxy_Release(IMarshal *iface) 385 { 386 struct proxy_manager *This = impl_from_IMarshal( iface ); 387 return IMultiQI_Release(&This->IMultiQI_iface); 388 } 389 390 static HRESULT WINAPI Proxy_MarshalInterface( 391 LPMARSHAL iface, IStream *pStm, REFIID riid, void* pv, DWORD dwDestContext, 392 void* pvDestContext, DWORD mshlflags) 393 { 394 struct proxy_manager *This = impl_from_IMarshal( iface ); 395 HRESULT hr; 396 struct ifproxy *ifproxy; 397 398 TRACE("(...,%s,...)\n", debugstr_guid(riid)); 399 400 hr = proxy_manager_find_ifproxy(This, riid, &ifproxy); 401 if (SUCCEEDED(hr)) 402 { 403 STDOBJREF stdobjref = ifproxy->stdobjref; 404 405 stdobjref.cPublicRefs = 0; 406 407 if ((mshlflags != MSHLFLAGS_TABLEWEAK) && 408 (mshlflags != MSHLFLAGS_TABLESTRONG)) 409 { 410 ULONG cPublicRefs = ifproxy->refs; 411 ULONG cPublicRefsOld; 412 /* optimization - share out proxy's public references if possible 413 * instead of making new proxy do a roundtrip through the server */ 414 do 415 { 416 ULONG cPublicRefsNew; 417 cPublicRefsOld = cPublicRefs; 418 stdobjref.cPublicRefs = cPublicRefs / 2; 419 cPublicRefsNew = cPublicRefs - stdobjref.cPublicRefs; 420 cPublicRefs = InterlockedCompareExchange( 421 (LONG *)&ifproxy->refs, cPublicRefsNew, cPublicRefsOld); 422 } while (cPublicRefs != cPublicRefsOld); 423 } 424 425 /* normal and table-strong marshaling need at least one reference */ 426 if (!stdobjref.cPublicRefs && (mshlflags != MSHLFLAGS_TABLEWEAK)) 427 { 428 IRemUnknown *remunk; 429 hr = proxy_manager_get_remunknown(This, &remunk); 430 if (hr == S_OK) 431 { 432 HRESULT hrref = S_OK; 433 REMINTERFACEREF rif; 434 rif.ipid = ifproxy->stdobjref.ipid; 435 rif.cPublicRefs = (mshlflags == MSHLFLAGS_TABLESTRONG) ? 1 : NORMALEXTREFS; 436 rif.cPrivateRefs = 0; 437 hr = IRemUnknown_RemAddRef(remunk, 1, &rif, &hrref); 438 IRemUnknown_Release(remunk); 439 if (hr == S_OK && hrref == S_OK) 440 { 441 /* table-strong marshaling doesn't give the refs to the 442 * client that unmarshals the STDOBJREF */ 443 if (mshlflags != MSHLFLAGS_TABLESTRONG) 444 stdobjref.cPublicRefs = rif.cPublicRefs; 445 } 446 else 447 ERR("IRemUnknown_RemAddRef returned with 0x%08x, hrref = 0x%08x\n", hr, hrref); 448 } 449 } 450 451 if (SUCCEEDED(hr)) 452 { 453 TRACE("writing stdobjref: flags = %04x cPublicRefs = %d oxid = %s oid = %s ipid = %s\n", 454 stdobjref.flags, stdobjref.cPublicRefs, 455 wine_dbgstr_longlong(stdobjref.oxid), 456 wine_dbgstr_longlong(stdobjref.oid), 457 debugstr_guid(&stdobjref.ipid)); 458 hr = IStream_Write(pStm, &stdobjref, sizeof(stdobjref), NULL); 459 } 460 } 461 else 462 { 463 /* we don't have the interface already unmarshaled so we have to 464 * request the object from the server */ 465 IRemUnknown *remunk; 466 IPID *ipid; 467 REMQIRESULT *qiresults = NULL; 468 IID iid = *riid; 469 470 /* get the ipid of the first entry */ 471 /* FIXME: should we implement ClientIdentity on the ifproxies instead 472 * of the proxy_manager so we use the correct ipid here? */ 473 ipid = &LIST_ENTRY(list_head(&This->interfaces), struct ifproxy, entry)->stdobjref.ipid; 474 475 /* get IRemUnknown proxy so we can communicate with the remote object */ 476 hr = proxy_manager_get_remunknown(This, &remunk); 477 478 if (hr == S_OK) 479 { 480 hr = IRemUnknown_RemQueryInterface(remunk, ipid, NORMALEXTREFS, 481 1, &iid, &qiresults); 482 if (SUCCEEDED(hr)) 483 { 484 hr = IStream_Write(pStm, &qiresults->std, sizeof(qiresults->std), NULL); 485 if (FAILED(hr)) 486 { 487 REMINTERFACEREF rif; 488 rif.ipid = qiresults->std.ipid; 489 rif.cPublicRefs = qiresults->std.cPublicRefs; 490 rif.cPrivateRefs = 0; 491 IRemUnknown_RemRelease(remunk, 1, &rif); 492 } 493 CoTaskMemFree(qiresults); 494 } 495 else 496 ERR("IRemUnknown_RemQueryInterface failed with error 0x%08x\n", hr); 497 IRemUnknown_Release(remunk); 498 } 499 } 500 501 return hr; 502 } 503 504 static const IMarshalVtbl ProxyMarshal_Vtbl = 505 { 506 Proxy_QueryInterface, 507 Proxy_AddRef, 508 Proxy_Release, 509 StdMarshalImpl_GetUnmarshalClass, 510 StdMarshalImpl_GetMarshalSizeMax, 511 Proxy_MarshalInterface, 512 StdMarshalImpl_UnmarshalInterface, 513 StdMarshalImpl_ReleaseMarshalData, 514 StdMarshalImpl_DisconnectObject 515 }; 516 517 static HRESULT WINAPI ProxyCliSec_QueryInterface(IClientSecurity *iface, REFIID riid, void **ppvObject) 518 { 519 struct proxy_manager *This = impl_from_IClientSecurity( iface ); 520 return IMultiQI_QueryInterface(&This->IMultiQI_iface, riid, ppvObject); 521 } 522 523 static ULONG WINAPI ProxyCliSec_AddRef(IClientSecurity *iface) 524 { 525 struct proxy_manager *This = impl_from_IClientSecurity( iface ); 526 return IMultiQI_AddRef(&This->IMultiQI_iface); 527 } 528 529 static ULONG WINAPI ProxyCliSec_Release(IClientSecurity *iface) 530 { 531 struct proxy_manager *This = impl_from_IClientSecurity( iface ); 532 return IMultiQI_Release(&This->IMultiQI_iface); 533 } 534 535 static HRESULT WINAPI ProxyCliSec_QueryBlanket(IClientSecurity *iface, 536 IUnknown *pProxy, 537 DWORD *pAuthnSvc, 538 DWORD *pAuthzSvc, 539 OLECHAR **ppServerPrincName, 540 DWORD *pAuthnLevel, 541 DWORD *pImpLevel, 542 void **pAuthInfo, 543 DWORD *pCapabilities) 544 { 545 FIXME("(%p, %p, %p, %p, %p, %p, %p, %p): stub\n", pProxy, pAuthnSvc, 546 pAuthzSvc, ppServerPrincName, pAuthnLevel, pImpLevel, pAuthInfo, 547 pCapabilities); 548 549 if (pAuthnSvc) 550 *pAuthnSvc = 0; 551 if (pAuthzSvc) 552 *pAuthzSvc = 0; 553 if (ppServerPrincName) 554 *ppServerPrincName = NULL; 555 if (pAuthnLevel) 556 *pAuthnLevel = RPC_C_AUTHN_LEVEL_DEFAULT; 557 if (pImpLevel) 558 *pImpLevel = RPC_C_IMP_LEVEL_DEFAULT; 559 if (pAuthInfo) 560 *pAuthInfo = NULL; 561 if (pCapabilities) 562 *pCapabilities = EOAC_NONE; 563 564 return E_NOTIMPL; 565 } 566 567 static HRESULT WINAPI ProxyCliSec_SetBlanket(IClientSecurity *iface, 568 IUnknown *pProxy, DWORD AuthnSvc, 569 DWORD AuthzSvc, 570 OLECHAR *pServerPrincName, 571 DWORD AuthnLevel, DWORD ImpLevel, 572 void *pAuthInfo, 573 DWORD Capabilities) 574 { 575 FIXME("(%p, %d, %d, %s, %d, %d, %p, 0x%x): stub\n", pProxy, AuthnSvc, AuthzSvc, 576 pServerPrincName == COLE_DEFAULT_PRINCIPAL ? "<default principal>" : debugstr_w(pServerPrincName), 577 AuthnLevel, ImpLevel, pAuthInfo, Capabilities); 578 return E_NOTIMPL; 579 } 580 581 static HRESULT WINAPI ProxyCliSec_CopyProxy(IClientSecurity *iface, 582 IUnknown *pProxy, IUnknown **ppCopy) 583 { 584 FIXME("(%p, %p): stub\n", pProxy, ppCopy); 585 *ppCopy = NULL; 586 return E_NOTIMPL; 587 } 588 589 static const IClientSecurityVtbl ProxyCliSec_Vtbl = 590 { 591 ProxyCliSec_QueryInterface, 592 ProxyCliSec_AddRef, 593 ProxyCliSec_Release, 594 ProxyCliSec_QueryBlanket, 595 ProxyCliSec_SetBlanket, 596 ProxyCliSec_CopyProxy 597 }; 598 599 static HRESULT ifproxy_get_public_ref(struct ifproxy * This) 600 { 601 HRESULT hr = S_OK; 602 603 if (WAIT_OBJECT_0 != WaitForSingleObject(This->parent->remoting_mutex, INFINITE)) 604 { 605 ERR("Wait failed for ifproxy %p\n", This); 606 return E_UNEXPECTED; 607 } 608 609 if (This->refs == 0) 610 { 611 IRemUnknown *remunk = NULL; 612 613 TRACE("getting public ref for ifproxy %p\n", This); 614 615 hr = proxy_manager_get_remunknown(This->parent, &remunk); 616 if (hr == S_OK) 617 { 618 HRESULT hrref = S_OK; 619 REMINTERFACEREF rif; 620 rif.ipid = This->stdobjref.ipid; 621 rif.cPublicRefs = NORMALEXTREFS; 622 rif.cPrivateRefs = 0; 623 hr = IRemUnknown_RemAddRef(remunk, 1, &rif, &hrref); 624 IRemUnknown_Release(remunk); 625 if (hr == S_OK && hrref == S_OK) 626 InterlockedExchangeAdd((LONG *)&This->refs, NORMALEXTREFS); 627 else 628 ERR("IRemUnknown_RemAddRef returned with 0x%08x, hrref = 0x%08x\n", hr, hrref); 629 } 630 } 631 ReleaseMutex(This->parent->remoting_mutex); 632 633 return hr; 634 } 635 636 static HRESULT ifproxy_release_public_refs(struct ifproxy * This) 637 { 638 HRESULT hr = S_OK; 639 LONG public_refs; 640 641 if (WAIT_OBJECT_0 != WaitForSingleObject(This->parent->remoting_mutex, INFINITE)) 642 { 643 ERR("Wait failed for ifproxy %p\n", This); 644 return E_UNEXPECTED; 645 } 646 647 public_refs = This->refs; 648 if (public_refs > 0) 649 { 650 IRemUnknown *remunk = NULL; 651 652 TRACE("releasing %d refs\n", public_refs); 653 654 hr = proxy_manager_get_remunknown(This->parent, &remunk); 655 if (hr == S_OK) 656 { 657 REMINTERFACEREF rif; 658 rif.ipid = This->stdobjref.ipid; 659 rif.cPublicRefs = public_refs; 660 rif.cPrivateRefs = 0; 661 hr = IRemUnknown_RemRelease(remunk, 1, &rif); 662 IRemUnknown_Release(remunk); 663 if (hr == S_OK) 664 InterlockedExchangeAdd((LONG *)&This->refs, -public_refs); 665 else if (hr == RPC_E_DISCONNECTED) 666 WARN("couldn't release references because object was " 667 "disconnected: oxid = %s, oid = %s\n", 668 wine_dbgstr_longlong(This->parent->oxid), 669 wine_dbgstr_longlong(This->parent->oid)); 670 else 671 ERR("IRemUnknown_RemRelease failed with error 0x%08x\n", hr); 672 } 673 } 674 ReleaseMutex(This->parent->remoting_mutex); 675 676 return hr; 677 } 678 679 /* should be called inside This->parent->cs critical section */ 680 static void ifproxy_disconnect(struct ifproxy * This) 681 { 682 ifproxy_release_public_refs(This); 683 if (This->proxy) IRpcProxyBuffer_Disconnect(This->proxy); 684 685 IRpcChannelBuffer_Release(This->chan); 686 This->chan = NULL; 687 } 688 689 /* should be called in This->parent->cs critical section if it is an entry in parent's list */ 690 static void ifproxy_destroy(struct ifproxy * This) 691 { 692 TRACE("%p\n", This); 693 694 /* release public references to this object so that the stub can know 695 * when to destroy itself */ 696 ifproxy_release_public_refs(This); 697 698 list_remove(&This->entry); 699 700 if (This->chan) 701 { 702 IRpcChannelBuffer_Release(This->chan); 703 This->chan = NULL; 704 } 705 706 if (This->proxy) IRpcProxyBuffer_Release(This->proxy); 707 708 HeapFree(GetProcessHeap(), 0, This); 709 } 710 711 static HRESULT proxy_manager_construct( 712 APARTMENT * apt, ULONG sorflags, OXID oxid, OID oid, 713 const OXID_INFO *oxid_info, struct proxy_manager ** proxy_manager) 714 { 715 struct proxy_manager * This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This)); 716 if (!This) return E_OUTOFMEMORY; 717 718 This->remoting_mutex = CreateMutexW(NULL, FALSE, NULL); 719 if (!This->remoting_mutex) 720 { 721 HeapFree(GetProcessHeap(), 0, This); 722 return HRESULT_FROM_WIN32(GetLastError()); 723 } 724 725 if (oxid_info) 726 { 727 This->oxid_info.dwPid = oxid_info->dwPid; 728 This->oxid_info.dwTid = oxid_info->dwTid; 729 This->oxid_info.ipidRemUnknown = oxid_info->ipidRemUnknown; 730 This->oxid_info.dwAuthnHint = oxid_info->dwAuthnHint; 731 This->oxid_info.psa = NULL /* FIXME: copy from oxid_info */; 732 } 733 else 734 { 735 HRESULT hr = RPC_ResolveOxid(oxid, &This->oxid_info); 736 if (FAILED(hr)) 737 { 738 CloseHandle(This->remoting_mutex); 739 HeapFree(GetProcessHeap(), 0, This); 740 return hr; 741 } 742 } 743 744 This->IMultiQI_iface.lpVtbl = &ClientIdentity_Vtbl; 745 This->IMarshal_iface.lpVtbl = &ProxyMarshal_Vtbl; 746 This->IClientSecurity_iface.lpVtbl = &ProxyCliSec_Vtbl; 747 748 list_init(&This->entry); 749 list_init(&This->interfaces); 750 751 InitializeCriticalSection(&This->cs); 752 DEBUG_SET_CRITSEC_NAME(&This->cs, "proxy_manager"); 753 754 /* the apartment the object was unmarshaled into */ 755 This->parent = apt; 756 757 /* the source apartment and id of the object */ 758 This->oxid = oxid; 759 This->oid = oid; 760 761 This->refs = 1; 762 763 /* the DCOM draft specification states that the SORF_NOPING flag is 764 * proxy manager specific, not ifproxy specific, so this implies that we 765 * should store the STDOBJREF flags here in the proxy manager. */ 766 This->sorflags = sorflags; 767 768 /* we create the IRemUnknown proxy on demand */ 769 This->remunk = NULL; 770 771 /* initialise these values to the weakest values and they will be 772 * overwritten in proxy_manager_set_context */ 773 This->dest_context = MSHCTX_INPROC; 774 This->dest_context_data = NULL; 775 776 EnterCriticalSection(&apt->cs); 777 /* FIXME: we are dependent on the ordering in here to make sure a proxy's 778 * IRemUnknown proxy doesn't get destroyed before the regular proxy does 779 * because we need the IRemUnknown proxy during the destruction of the 780 * regular proxy. Ideally, we should maintain a separate list for the 781 * IRemUnknown proxies that need late destruction */ 782 list_add_tail(&apt->proxies, &This->entry); 783 LeaveCriticalSection(&apt->cs); 784 785 TRACE("%p created for OXID %s, OID %s\n", This, 786 wine_dbgstr_longlong(oxid), wine_dbgstr_longlong(oid)); 787 788 *proxy_manager = This; 789 return S_OK; 790 } 791 792 static inline void proxy_manager_set_context(struct proxy_manager *This, MSHCTX dest_context, void *dest_context_data) 793 { 794 MSHCTX old_dest_context; 795 MSHCTX new_dest_context; 796 797 do 798 { 799 old_dest_context = This->dest_context; 800 new_dest_context = old_dest_context; 801 /* "stronger" values overwrite "weaker" values. stronger values are 802 * ones that disable more optimisations */ 803 switch (old_dest_context) 804 { 805 case MSHCTX_INPROC: 806 new_dest_context = dest_context; 807 break; 808 case MSHCTX_CROSSCTX: 809 switch (dest_context) 810 { 811 case MSHCTX_INPROC: 812 break; 813 default: 814 new_dest_context = dest_context; 815 } 816 break; 817 case MSHCTX_LOCAL: 818 switch (dest_context) 819 { 820 case MSHCTX_INPROC: 821 case MSHCTX_CROSSCTX: 822 break; 823 default: 824 new_dest_context = dest_context; 825 } 826 break; 827 case MSHCTX_NOSHAREDMEM: 828 switch (dest_context) 829 { 830 case MSHCTX_DIFFERENTMACHINE: 831 new_dest_context = dest_context; 832 break; 833 default: 834 break; 835 } 836 break; 837 default: 838 break; 839 } 840 841 if (old_dest_context == new_dest_context) break; 842 843 new_dest_context = InterlockedCompareExchange((PLONG)&This->dest_context, new_dest_context, old_dest_context); 844 } while (new_dest_context != old_dest_context); 845 846 if (dest_context_data) 847 InterlockedExchangePointer(&This->dest_context_data, dest_context_data); 848 } 849 850 static HRESULT proxy_manager_query_local_interface(struct proxy_manager * This, REFIID riid, void ** ppv) 851 { 852 HRESULT hr; 853 struct ifproxy * ifproxy; 854 855 TRACE("%s\n", debugstr_guid(riid)); 856 857 if (IsEqualIID(riid, &IID_IUnknown) || 858 IsEqualIID(riid, &IID_IMultiQI)) 859 { 860 *ppv = &This->IMultiQI_iface; 861 IMultiQI_AddRef(&This->IMultiQI_iface); 862 return S_OK; 863 } 864 if (IsEqualIID(riid, &IID_IMarshal)) 865 { 866 *ppv = &This->IMarshal_iface; 867 IMarshal_AddRef(&This->IMarshal_iface); 868 return S_OK; 869 } 870 if (IsEqualIID(riid, &IID_IClientSecurity)) 871 { 872 *ppv = &This->IClientSecurity_iface; 873 IClientSecurity_AddRef(&This->IClientSecurity_iface); 874 return S_OK; 875 } 876 877 hr = proxy_manager_find_ifproxy(This, riid, &ifproxy); 878 if (hr == S_OK) 879 { 880 *ppv = ifproxy->iface; 881 IUnknown_AddRef((IUnknown *)*ppv); 882 return S_OK; 883 } 884 885 *ppv = NULL; 886 return E_NOINTERFACE; 887 } 888 889 static HRESULT proxy_manager_create_ifproxy( 890 struct proxy_manager * This, const STDOBJREF *stdobjref, REFIID riid, 891 IRpcChannelBuffer * channel, struct ifproxy ** iif_out) 892 { 893 HRESULT hr; 894 IPSFactoryBuffer * psfb; 895 struct ifproxy * ifproxy = HeapAlloc(GetProcessHeap(), 0, sizeof(*ifproxy)); 896 if (!ifproxy) return E_OUTOFMEMORY; 897 898 list_init(&ifproxy->entry); 899 900 ifproxy->parent = This; 901 ifproxy->stdobjref = *stdobjref; 902 ifproxy->iid = *riid; 903 ifproxy->refs = 0; 904 ifproxy->proxy = NULL; 905 906 assert(channel); 907 ifproxy->chan = channel; /* FIXME: we should take the binding strings and construct the channel in this function */ 908 909 /* the IUnknown interface is special because it does not have a 910 * proxy associated with the ifproxy as we handle IUnknown ourselves */ 911 if (IsEqualIID(riid, &IID_IUnknown)) 912 { 913 ifproxy->iface = &This->IMultiQI_iface; 914 IMultiQI_AddRef(&This->IMultiQI_iface); 915 hr = S_OK; 916 } 917 else 918 { 919 hr = get_facbuf_for_iid(riid, &psfb); 920 if (hr == S_OK) 921 { 922 /* important note: the outer unknown is set to the proxy manager. 923 * This ensures the COM identity rules are not violated, by having a 924 * one-to-one mapping of objects on the proxy side to objects on the 925 * stub side, no matter which interface you view the object through */ 926 hr = IPSFactoryBuffer_CreateProxy(psfb, (IUnknown*)&This->IMultiQI_iface, riid, 927 &ifproxy->proxy, &ifproxy->iface); 928 IPSFactoryBuffer_Release(psfb); 929 if (hr != S_OK) 930 ERR("Could not create proxy for interface %s, error 0x%08x\n", 931 debugstr_guid(riid), hr); 932 } 933 else 934 ERR("Could not get IPSFactoryBuffer for interface %s, error 0x%08x\n", 935 debugstr_guid(riid), hr); 936 937 if (hr == S_OK) 938 hr = IRpcProxyBuffer_Connect(ifproxy->proxy, ifproxy->chan); 939 } 940 941 if (hr == S_OK) 942 { 943 EnterCriticalSection(&This->cs); 944 list_add_tail(&This->interfaces, &ifproxy->entry); 945 LeaveCriticalSection(&This->cs); 946 947 *iif_out = ifproxy; 948 TRACE("ifproxy %p created for IPID %s, interface %s with %u public refs\n", 949 ifproxy, debugstr_guid(&stdobjref->ipid), debugstr_guid(riid), stdobjref->cPublicRefs); 950 } 951 else 952 ifproxy_destroy(ifproxy); 953 954 return hr; 955 } 956 957 static HRESULT proxy_manager_find_ifproxy(struct proxy_manager * This, REFIID riid, struct ifproxy ** ifproxy_found) 958 { 959 HRESULT hr = E_NOINTERFACE; /* assume not found */ 960 struct list * cursor; 961 962 EnterCriticalSection(&This->cs); 963 LIST_FOR_EACH(cursor, &This->interfaces) 964 { 965 struct ifproxy * ifproxy = LIST_ENTRY(cursor, struct ifproxy, entry); 966 if (IsEqualIID(riid, &ifproxy->iid)) 967 { 968 *ifproxy_found = ifproxy; 969 hr = S_OK; 970 break; 971 } 972 } 973 LeaveCriticalSection(&This->cs); 974 975 return hr; 976 } 977 978 static void proxy_manager_disconnect(struct proxy_manager * This) 979 { 980 struct list * cursor; 981 982 TRACE("oxid = %s, oid = %s\n", wine_dbgstr_longlong(This->oxid), 983 wine_dbgstr_longlong(This->oid)); 984 985 EnterCriticalSection(&This->cs); 986 987 /* SORFP_NOLIFTIMEMGMT proxies (for IRemUnknown) shouldn't be 988 * disconnected - it won't do anything anyway, except cause 989 * problems for other objects that depend on this proxy always 990 * working */ 991 if (!(This->sorflags & SORFP_NOLIFETIMEMGMT)) 992 { 993 LIST_FOR_EACH(cursor, &This->interfaces) 994 { 995 struct ifproxy * ifproxy = LIST_ENTRY(cursor, struct ifproxy, entry); 996 ifproxy_disconnect(ifproxy); 997 } 998 } 999 1000 /* apartment is being destroyed so don't keep a pointer around to it */ 1001 This->parent = NULL; 1002 1003 LeaveCriticalSection(&This->cs); 1004 } 1005 1006 static HRESULT proxy_manager_get_remunknown(struct proxy_manager * This, IRemUnknown **remunk) 1007 { 1008 HRESULT hr = S_OK; 1009 struct apartment *apt; 1010 BOOL called_in_original_apt; 1011 1012 /* we don't want to try and unmarshal or use IRemUnknown if we don't want 1013 * lifetime management */ 1014 if (This->sorflags & SORFP_NOLIFETIMEMGMT) 1015 return S_FALSE; 1016 1017 if (!(apt = apartment_get_current_or_mta())) 1018 return CO_E_NOTINITIALIZED; 1019 1020 called_in_original_apt = This->parent && (This->parent->oxid == apt->oxid); 1021 1022 EnterCriticalSection(&This->cs); 1023 /* only return the cached object if called from the original apartment. 1024 * in future, we might want to make the IRemUnknown proxy callable from any 1025 * apartment to avoid these checks */ 1026 if (This->remunk && called_in_original_apt) 1027 { 1028 /* already created - return existing object */ 1029 *remunk = This->remunk; 1030 IRemUnknown_AddRef(*remunk); 1031 } 1032 else if (!This->parent) 1033 { 1034 /* disconnected - we can't create IRemUnknown */ 1035 *remunk = NULL; 1036 hr = S_FALSE; 1037 } 1038 else 1039 { 1040 STDOBJREF stdobjref; 1041 /* Don't want IRemUnknown lifetime management as this is IRemUnknown! 1042 * We also don't care about whether or not the stub is still alive */ 1043 stdobjref.flags = SORFP_NOLIFETIMEMGMT | SORF_NOPING; 1044 stdobjref.cPublicRefs = 1; 1045 /* oxid of destination object */ 1046 stdobjref.oxid = This->oxid; 1047 /* FIXME: what should be used for the oid? The DCOM draft doesn't say */ 1048 stdobjref.oid = (OID)-1; 1049 stdobjref.ipid = This->oxid_info.ipidRemUnknown; 1050 1051 /* do the unmarshal */ 1052 hr = unmarshal_object(&stdobjref, apt, This->dest_context, 1053 This->dest_context_data, &IID_IRemUnknown, 1054 &This->oxid_info, (void**)remunk); 1055 if (hr == S_OK && called_in_original_apt) 1056 { 1057 This->remunk = *remunk; 1058 IRemUnknown_AddRef(This->remunk); 1059 } 1060 } 1061 LeaveCriticalSection(&This->cs); 1062 apartment_release(apt); 1063 1064 TRACE("got IRemUnknown* pointer %p, hr = 0x%08x\n", *remunk, hr); 1065 1066 return hr; 1067 } 1068 1069 /* destroys a proxy manager, freeing the memory it used. 1070 * Note: this function should not be called from a list iteration in the 1071 * apartment, due to the fact that it removes itself from the apartment and 1072 * it could add a proxy to IRemUnknown into the apartment. */ 1073 static void proxy_manager_destroy(struct proxy_manager * This) 1074 { 1075 struct list * cursor; 1076 1077 TRACE("oxid = %s, oid = %s\n", wine_dbgstr_longlong(This->oxid), 1078 wine_dbgstr_longlong(This->oid)); 1079 1080 if (This->parent) 1081 { 1082 EnterCriticalSection(&This->parent->cs); 1083 1084 /* remove ourself from the list of proxy objects in the apartment */ 1085 LIST_FOR_EACH(cursor, &This->parent->proxies) 1086 { 1087 if (cursor == &This->entry) 1088 { 1089 list_remove(&This->entry); 1090 break; 1091 } 1092 } 1093 1094 LeaveCriticalSection(&This->parent->cs); 1095 } 1096 1097 /* destroy all of the interface proxies */ 1098 while ((cursor = list_head(&This->interfaces))) 1099 { 1100 struct ifproxy * ifproxy = LIST_ENTRY(cursor, struct ifproxy, entry); 1101 ifproxy_destroy(ifproxy); 1102 } 1103 1104 if (This->remunk) IRemUnknown_Release(This->remunk); 1105 CoTaskMemFree(This->oxid_info.psa); 1106 1107 DEBUG_CLEAR_CRITSEC_NAME(&This->cs); 1108 DeleteCriticalSection(&This->cs); 1109 1110 CloseHandle(This->remoting_mutex); 1111 1112 HeapFree(GetProcessHeap(), 0, This); 1113 } 1114 1115 /* finds the proxy manager corresponding to a given OXID and OID that has 1116 * been unmarshaled in the specified apartment. The caller must release the 1117 * reference to the proxy_manager when the object is no longer used. */ 1118 static BOOL find_proxy_manager(APARTMENT * apt, OXID oxid, OID oid, struct proxy_manager ** proxy_found) 1119 { 1120 BOOL found = FALSE; 1121 struct list * cursor; 1122 1123 EnterCriticalSection(&apt->cs); 1124 LIST_FOR_EACH(cursor, &apt->proxies) 1125 { 1126 struct proxy_manager * proxy = LIST_ENTRY(cursor, struct proxy_manager, entry); 1127 if ((oxid == proxy->oxid) && (oid == proxy->oid)) 1128 { 1129 /* be careful of a race with ClientIdentity_Release, which would 1130 * cause us to return a proxy which is in the process of being 1131 * destroyed */ 1132 if (IMultiQI_AddRef(&proxy->IMultiQI_iface) != 0) 1133 { 1134 *proxy_found = proxy; 1135 found = TRUE; 1136 break; 1137 } 1138 } 1139 } 1140 LeaveCriticalSection(&apt->cs); 1141 return found; 1142 } 1143 1144 HRESULT apartment_disconnectproxies(struct apartment *apt) 1145 { 1146 struct list * cursor; 1147 1148 LIST_FOR_EACH(cursor, &apt->proxies) 1149 { 1150 struct proxy_manager * proxy = LIST_ENTRY(cursor, struct proxy_manager, entry); 1151 proxy_manager_disconnect(proxy); 1152 } 1153 1154 return S_OK; 1155 } 1156 1157 /********************** StdMarshal implementation ****************************/ 1158 typedef struct _StdMarshalImpl 1159 { 1160 IMarshal IMarshal_iface; 1161 LONG ref; 1162 DWORD dest_context; 1163 void *dest_context_data; 1164 } StdMarshalImpl; 1165 1166 static inline StdMarshalImpl *impl_from_StdMarshal(IMarshal *iface) 1167 { 1168 return CONTAINING_RECORD(iface, StdMarshalImpl, IMarshal_iface); 1169 } 1170 1171 static HRESULT WINAPI 1172 StdMarshalImpl_QueryInterface(IMarshal *iface, REFIID riid, void **ppv) 1173 { 1174 *ppv = NULL; 1175 if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IMarshal, riid)) 1176 { 1177 *ppv = iface; 1178 IMarshal_AddRef(iface); 1179 return S_OK; 1180 } 1181 FIXME("No interface for %s.\n", debugstr_guid(riid)); 1182 return E_NOINTERFACE; 1183 } 1184 1185 static ULONG WINAPI 1186 StdMarshalImpl_AddRef(IMarshal *iface) 1187 { 1188 StdMarshalImpl *This = impl_from_StdMarshal(iface); 1189 return InterlockedIncrement(&This->ref); 1190 } 1191 1192 static ULONG WINAPI 1193 StdMarshalImpl_Release(IMarshal *iface) 1194 { 1195 StdMarshalImpl *This = impl_from_StdMarshal(iface); 1196 ULONG ref = InterlockedDecrement(&This->ref); 1197 1198 if (!ref) HeapFree(GetProcessHeap(),0,This); 1199 return ref; 1200 } 1201 1202 static HRESULT WINAPI 1203 StdMarshalImpl_GetUnmarshalClass( 1204 IMarshal *iface, REFIID riid, void* pv, DWORD dwDestContext, 1205 void* pvDestContext, DWORD mshlflags, CLSID* pCid) 1206 { 1207 *pCid = CLSID_DfMarshal; 1208 return S_OK; 1209 } 1210 1211 static HRESULT WINAPI 1212 StdMarshalImpl_GetMarshalSizeMax( 1213 IMarshal *iface, REFIID riid, void* pv, DWORD dwDestContext, 1214 void* pvDestContext, DWORD mshlflags, DWORD* pSize) 1215 { 1216 *pSize = sizeof(STDOBJREF); 1217 return S_OK; 1218 } 1219 1220 static HRESULT WINAPI 1221 StdMarshalImpl_MarshalInterface( 1222 IMarshal *iface, IStream *pStm,REFIID riid, void* pv, DWORD dest_context, 1223 void* dest_context_data, DWORD mshlflags) 1224 { 1225 STDOBJREF stdobjref; 1226 ULONG res; 1227 HRESULT hres; 1228 APARTMENT *apt; 1229 1230 TRACE("(...,%s,...)\n", debugstr_guid(riid)); 1231 1232 if (!(apt = apartment_get_current_or_mta())) 1233 { 1234 ERR("Apartment not initialized\n"); 1235 return CO_E_NOTINITIALIZED; 1236 } 1237 1238 /* make sure this apartment can be reached from other threads / processes */ 1239 RPC_StartRemoting(apt); 1240 1241 hres = marshal_object(apt, &stdobjref, riid, pv, dest_context, dest_context_data, mshlflags); 1242 apartment_release(apt); 1243 if (hres != S_OK) 1244 { 1245 ERR("Failed to create ifstub, hres=0x%x\n", hres); 1246 return hres; 1247 } 1248 1249 return IStream_Write(pStm, &stdobjref, sizeof(stdobjref), &res); 1250 } 1251 1252 /* helper for StdMarshalImpl_UnmarshalInterface - does the unmarshaling with 1253 * no questions asked about the rules surrounding same-apartment unmarshals 1254 * and table marshaling */ 1255 static HRESULT unmarshal_object(const STDOBJREF *stdobjref, APARTMENT *apt, 1256 MSHCTX dest_context, void *dest_context_data, 1257 REFIID riid, const OXID_INFO *oxid_info, 1258 void **object) 1259 { 1260 struct proxy_manager *proxy_manager = NULL; 1261 HRESULT hr = S_OK; 1262 1263 assert(apt); 1264 1265 TRACE("stdobjref: flags = %04x cPublicRefs = %d oxid = %s oid = %s ipid = %s\n", 1266 stdobjref->flags, stdobjref->cPublicRefs, 1267 wine_dbgstr_longlong(stdobjref->oxid), 1268 wine_dbgstr_longlong(stdobjref->oid), 1269 debugstr_guid(&stdobjref->ipid)); 1270 1271 /* create a new proxy manager if one doesn't already exist for the 1272 * object */ 1273 if (!find_proxy_manager(apt, stdobjref->oxid, stdobjref->oid, &proxy_manager)) 1274 { 1275 hr = proxy_manager_construct(apt, stdobjref->flags, 1276 stdobjref->oxid, stdobjref->oid, oxid_info, 1277 &proxy_manager); 1278 } 1279 else 1280 TRACE("proxy manager already created, using\n"); 1281 1282 if (hr == S_OK) 1283 { 1284 struct ifproxy * ifproxy; 1285 1286 proxy_manager_set_context(proxy_manager, dest_context, dest_context_data); 1287 1288 hr = proxy_manager_find_ifproxy(proxy_manager, riid, &ifproxy); 1289 if (hr == E_NOINTERFACE) 1290 { 1291 IRpcChannelBuffer *chanbuf; 1292 hr = RPC_CreateClientChannel(&stdobjref->oxid, &stdobjref->ipid, 1293 &proxy_manager->oxid_info, 1294 proxy_manager->dest_context, 1295 proxy_manager->dest_context_data, 1296 &chanbuf, apt); 1297 if (hr == S_OK) 1298 hr = proxy_manager_create_ifproxy(proxy_manager, stdobjref, 1299 riid, chanbuf, &ifproxy); 1300 } 1301 else 1302 IUnknown_AddRef((IUnknown *)ifproxy->iface); 1303 1304 if (hr == S_OK) 1305 { 1306 InterlockedExchangeAdd((LONG *)&ifproxy->refs, stdobjref->cPublicRefs); 1307 /* get at least one external reference to the object to keep it alive */ 1308 hr = ifproxy_get_public_ref(ifproxy); 1309 if (FAILED(hr)) 1310 ifproxy_destroy(ifproxy); 1311 } 1312 1313 if (hr == S_OK) 1314 *object = ifproxy->iface; 1315 } 1316 1317 /* release our reference to the proxy manager - the client/apartment 1318 * will hold on to the remaining reference for us */ 1319 if (proxy_manager) IMultiQI_Release(&proxy_manager->IMultiQI_iface); 1320 1321 return hr; 1322 } 1323 1324 static HRESULT WINAPI 1325 StdMarshalImpl_UnmarshalInterface(IMarshal *iface, IStream *pStm, REFIID riid, void **ppv) 1326 { 1327 StdMarshalImpl *This = impl_from_StdMarshal(iface); 1328 struct stub_manager *stubmgr = NULL; 1329 STDOBJREF stdobjref; 1330 ULONG res; 1331 HRESULT hres; 1332 APARTMENT *apt; 1333 APARTMENT *stub_apt; 1334 OXID oxid; 1335 1336 TRACE("(...,%s,....)\n", debugstr_guid(riid)); 1337 1338 /* we need an apartment to unmarshal into */ 1339 if (!(apt = apartment_get_current_or_mta())) 1340 { 1341 ERR("Apartment not initialized\n"); 1342 return CO_E_NOTINITIALIZED; 1343 } 1344 1345 /* read STDOBJREF from wire */ 1346 hres = IStream_Read(pStm, &stdobjref, sizeof(stdobjref), &res); 1347 if (hres != S_OK) 1348 { 1349 apartment_release(apt); 1350 return STG_E_READFAULT; 1351 } 1352 1353 hres = apartment_getoxid(apt, &oxid); 1354 if (hres != S_OK) 1355 { 1356 apartment_release(apt); 1357 return hres; 1358 } 1359 1360 /* check if we're marshalling back to ourselves */ 1361 if ((oxid == stdobjref.oxid) && (stubmgr = get_stub_manager(apt, stdobjref.oid))) 1362 { 1363 TRACE("Unmarshalling object marshalled in same apartment for iid %s, " 1364 "returning original object %p\n", debugstr_guid(riid), stubmgr->object); 1365 1366 hres = IUnknown_QueryInterface(stubmgr->object, riid, ppv); 1367 1368 /* unref the ifstub. FIXME: only do this on success? */ 1369 if (!stub_manager_is_table_marshaled(stubmgr, &stdobjref.ipid)) 1370 stub_manager_ext_release(stubmgr, stdobjref.cPublicRefs, stdobjref.flags & SORFP_TABLEWEAK, FALSE); 1371 1372 stub_manager_int_release(stubmgr); 1373 apartment_release(apt); 1374 return hres; 1375 } 1376 1377 /* notify stub manager about unmarshal if process-local object. 1378 * note: if the oxid is not found then we and native will quite happily 1379 * ignore table marshaling and normal marshaling rules regarding number of 1380 * unmarshals, etc, but if you abuse these rules then your proxy could end 1381 * up returning RPC_E_DISCONNECTED. */ 1382 if ((stub_apt = apartment_findfromoxid(stdobjref.oxid, TRUE))) 1383 { 1384 if ((stubmgr = get_stub_manager(stub_apt, stdobjref.oid))) 1385 { 1386 if (!stub_manager_notify_unmarshal(stubmgr, &stdobjref.ipid)) 1387 hres = CO_E_OBJNOTCONNECTED; 1388 } 1389 else 1390 { 1391 WARN("Couldn't find object for OXID %s, OID %s, assuming disconnected\n", 1392 wine_dbgstr_longlong(stdobjref.oxid), 1393 wine_dbgstr_longlong(stdobjref.oid)); 1394 hres = CO_E_OBJNOTCONNECTED; 1395 } 1396 } 1397 else 1398 TRACE("Treating unmarshal from OXID %s as inter-process\n", 1399 wine_dbgstr_longlong(stdobjref.oxid)); 1400 1401 if (hres == S_OK) 1402 hres = unmarshal_object(&stdobjref, apt, This->dest_context, 1403 This->dest_context_data, riid, 1404 stubmgr ? &stubmgr->oxid_info : NULL, ppv); 1405 1406 if (stubmgr) stub_manager_int_release(stubmgr); 1407 if (stub_apt) apartment_release(stub_apt); 1408 1409 if (hres != S_OK) WARN("Failed with error 0x%08x\n", hres); 1410 else TRACE("Successfully created proxy %p\n", *ppv); 1411 1412 apartment_release(apt); 1413 return hres; 1414 } 1415 1416 static HRESULT WINAPI 1417 StdMarshalImpl_ReleaseMarshalData(IMarshal *iface, IStream *pStm) 1418 { 1419 STDOBJREF stdobjref; 1420 ULONG res; 1421 HRESULT hres; 1422 struct stub_manager *stubmgr; 1423 APARTMENT *apt; 1424 1425 TRACE("iface=%p, pStm=%p\n", iface, pStm); 1426 1427 hres = IStream_Read(pStm, &stdobjref, sizeof(stdobjref), &res); 1428 if (hres != S_OK) return STG_E_READFAULT; 1429 1430 TRACE("oxid = %s, oid = %s, ipid = %s\n", 1431 wine_dbgstr_longlong(stdobjref.oxid), 1432 wine_dbgstr_longlong(stdobjref.oid), 1433 wine_dbgstr_guid(&stdobjref.ipid)); 1434 1435 if (!(apt = apartment_findfromoxid(stdobjref.oxid, TRUE))) 1436 { 1437 WARN("Could not map OXID %s to apartment object\n", 1438 wine_dbgstr_longlong(stdobjref.oxid)); 1439 return RPC_E_INVALID_OBJREF; 1440 } 1441 1442 if (!(stubmgr = get_stub_manager(apt, stdobjref.oid))) 1443 { 1444 apartment_release(apt); 1445 ERR("could not map object ID to stub manager, oxid=%s, oid=%s\n", 1446 wine_dbgstr_longlong(stdobjref.oxid), wine_dbgstr_longlong(stdobjref.oid)); 1447 return RPC_E_INVALID_OBJREF; 1448 } 1449 1450 stub_manager_release_marshal_data(stubmgr, stdobjref.cPublicRefs, &stdobjref.ipid, stdobjref.flags & SORFP_TABLEWEAK); 1451 1452 stub_manager_int_release(stubmgr); 1453 apartment_release(apt); 1454 1455 return S_OK; 1456 } 1457 1458 static HRESULT WINAPI 1459 StdMarshalImpl_DisconnectObject(IMarshal *iface, DWORD dwReserved) 1460 { 1461 FIXME("(), stub!\n"); 1462 return S_OK; 1463 } 1464 1465 static const IMarshalVtbl StdMarshalVtbl = 1466 { 1467 StdMarshalImpl_QueryInterface, 1468 StdMarshalImpl_AddRef, 1469 StdMarshalImpl_Release, 1470 StdMarshalImpl_GetUnmarshalClass, 1471 StdMarshalImpl_GetMarshalSizeMax, 1472 StdMarshalImpl_MarshalInterface, 1473 StdMarshalImpl_UnmarshalInterface, 1474 StdMarshalImpl_ReleaseMarshalData, 1475 StdMarshalImpl_DisconnectObject 1476 }; 1477 1478 static HRESULT StdMarshalImpl_Construct(REFIID riid, DWORD dest_context, void *dest_context_data, void** ppvObject) 1479 { 1480 HRESULT hr; 1481 1482 StdMarshalImpl *pStdMarshal = HeapAlloc(GetProcessHeap(), 0, sizeof(StdMarshalImpl)); 1483 if (!pStdMarshal) 1484 return E_OUTOFMEMORY; 1485 1486 pStdMarshal->IMarshal_iface.lpVtbl = &StdMarshalVtbl; 1487 pStdMarshal->ref = 0; 1488 pStdMarshal->dest_context = dest_context; 1489 pStdMarshal->dest_context_data = dest_context_data; 1490 1491 hr = IMarshal_QueryInterface(&pStdMarshal->IMarshal_iface, riid, ppvObject); 1492 if (FAILED(hr)) 1493 HeapFree(GetProcessHeap(), 0, pStdMarshal); 1494 1495 return hr; 1496 } 1497 1498 /*********************************************************************** 1499 * CoGetStandardMarshal [OLE32.@] 1500 * 1501 * Gets or creates a standard marshal object. 1502 * 1503 * PARAMS 1504 * riid [I] Interface identifier of the pUnk object. 1505 * pUnk [I] Optional. Object to get the marshal object for. 1506 * dwDestContext [I] Destination. Used to enable or disable optimizations. 1507 * pvDestContext [I] Reserved. Must be NULL. 1508 * mshlflags [I] Flags affecting the marshaling process. 1509 * ppMarshal [O] Address where marshal object will be stored. 1510 * 1511 * RETURNS 1512 * Success: S_OK. 1513 * Failure: HRESULT code. 1514 * 1515 * NOTES 1516 * 1517 * The function retrieves the IMarshal object associated with an object if 1518 * that object is currently an active stub, otherwise a new marshal object is 1519 * created. 1520 */ 1521 HRESULT WINAPI CoGetStandardMarshal(REFIID riid, IUnknown *pUnk, 1522 DWORD dwDestContext, LPVOID pvDestContext, 1523 DWORD mshlflags, LPMARSHAL *ppMarshal) 1524 { 1525 if (pUnk == NULL) 1526 { 1527 FIXME("(%s,NULL,%x,%p,%x,%p), unimplemented yet.\n", 1528 debugstr_guid(riid),dwDestContext,pvDestContext,mshlflags,ppMarshal); 1529 return E_NOTIMPL; 1530 } 1531 TRACE("(%s,%p,%x,%p,%x,%p)\n", 1532 debugstr_guid(riid),pUnk,dwDestContext,pvDestContext,mshlflags,ppMarshal); 1533 1534 return StdMarshalImpl_Construct(&IID_IMarshal, dwDestContext, pvDestContext, (void**)ppMarshal); 1535 } 1536 1537 /*********************************************************************** 1538 * get_marshaler [internal] 1539 * 1540 * Retrieves an IMarshal interface for an object. 1541 */ 1542 static HRESULT get_marshaler(REFIID riid, IUnknown *pUnk, DWORD dwDestContext, 1543 void *pvDestContext, DWORD mshlFlags, 1544 LPMARSHAL *pMarshal) 1545 { 1546 HRESULT hr; 1547 1548 if (!pUnk) 1549 return E_POINTER; 1550 hr = IUnknown_QueryInterface(pUnk, &IID_IMarshal, (LPVOID*)pMarshal); 1551 if (hr != S_OK) 1552 hr = CoGetStandardMarshal(riid, pUnk, dwDestContext, pvDestContext, 1553 mshlFlags, pMarshal); 1554 return hr; 1555 } 1556 1557 /*********************************************************************** 1558 * get_unmarshaler_from_stream [internal] 1559 * 1560 * Creates an IMarshal* object according to the data marshaled to the stream. 1561 * The function leaves the stream pointer at the start of the data written 1562 * to the stream by the IMarshal* object. 1563 */ 1564 static HRESULT get_unmarshaler_from_stream(IStream *stream, IMarshal **marshal, IID *iid) 1565 { 1566 HRESULT hr; 1567 ULONG res; 1568 OBJREF objref; 1569 1570 /* read common OBJREF header */ 1571 hr = IStream_Read(stream, &objref, FIELD_OFFSET(OBJREF, u_objref), &res); 1572 if (hr != S_OK || (res != FIELD_OFFSET(OBJREF, u_objref))) 1573 { 1574 ERR("Failed to read common OBJREF header, 0x%08x\n", hr); 1575 return STG_E_READFAULT; 1576 } 1577 1578 /* sanity check on header */ 1579 if (objref.signature != OBJREF_SIGNATURE) 1580 { 1581 ERR("Bad OBJREF signature 0x%08x\n", objref.signature); 1582 return RPC_E_INVALID_OBJREF; 1583 } 1584 1585 if (iid) *iid = objref.iid; 1586 1587 /* FIXME: handler marshaling */ 1588 if (objref.flags & OBJREF_STANDARD) 1589 { 1590 TRACE("Using standard unmarshaling\n"); 1591 hr = StdMarshalImpl_Construct(&IID_IMarshal, 0, NULL, (LPVOID*)marshal); 1592 } 1593 else if (objref.flags & OBJREF_CUSTOM) 1594 { 1595 ULONG custom_header_size = FIELD_OFFSET(OBJREF, u_objref.u_custom.pData) - 1596 FIELD_OFFSET(OBJREF, u_objref.u_custom); 1597 TRACE("Using custom unmarshaling\n"); 1598 /* read constant sized OR_CUSTOM data from stream */ 1599 hr = IStream_Read(stream, &objref.u_objref.u_custom, 1600 custom_header_size, &res); 1601 if (hr != S_OK || (res != custom_header_size)) 1602 { 1603 ERR("Failed to read OR_CUSTOM header, 0x%08x\n", hr); 1604 return STG_E_READFAULT; 1605 } 1606 /* now create the marshaler specified in the stream */ 1607 hr = CoCreateInstance(&objref.u_objref.u_custom.clsid, NULL, 1608 CLSCTX_INPROC_SERVER, &IID_IMarshal, 1609 (LPVOID*)marshal); 1610 } 1611 else 1612 { 1613 FIXME("Invalid or unimplemented marshaling type specified: %x\n", 1614 objref.flags); 1615 return RPC_E_INVALID_OBJREF; 1616 } 1617 1618 if (hr != S_OK) 1619 ERR("Failed to create marshal, 0x%08x\n", hr); 1620 1621 return hr; 1622 } 1623 1624 /*********************************************************************** 1625 * CoGetMarshalSizeMax [OLE32.@] 1626 * 1627 * Gets the maximum amount of data that will be needed by a marshal. 1628 * 1629 * PARAMS 1630 * pulSize [O] Address where maximum marshal size will be stored. 1631 * riid [I] Identifier of the interface to marshal. 1632 * pUnk [I] Pointer to the object to marshal. 1633 * dwDestContext [I] Destination. Used to enable or disable optimizations. 1634 * pvDestContext [I] Reserved. Must be NULL. 1635 * mshlFlags [I] Flags that affect the marshaling. See CoMarshalInterface(). 1636 * 1637 * RETURNS 1638 * Success: S_OK. 1639 * Failure: HRESULT code. 1640 * 1641 * SEE ALSO 1642 * CoMarshalInterface(). 1643 */ 1644 HRESULT WINAPI CoGetMarshalSizeMax(ULONG *pulSize, REFIID riid, IUnknown *pUnk, 1645 DWORD dwDestContext, void *pvDestContext, 1646 DWORD mshlFlags) 1647 { 1648 HRESULT hr; 1649 LPMARSHAL pMarshal; 1650 CLSID marshaler_clsid; 1651 1652 hr = get_marshaler(riid, pUnk, dwDestContext, pvDestContext, mshlFlags, &pMarshal); 1653 if (hr != S_OK) 1654 return hr; 1655 1656 hr = IMarshal_GetUnmarshalClass(pMarshal, riid, pUnk, dwDestContext, 1657 pvDestContext, mshlFlags, &marshaler_clsid); 1658 if (hr != S_OK) 1659 { 1660 ERR("IMarshal::GetUnmarshalClass failed, 0x%08x\n", hr); 1661 IMarshal_Release(pMarshal); 1662 return hr; 1663 } 1664 1665 hr = IMarshal_GetMarshalSizeMax(pMarshal, riid, pUnk, dwDestContext, 1666 pvDestContext, mshlFlags, pulSize); 1667 if (IsEqualCLSID(&marshaler_clsid, &CLSID_DfMarshal)) 1668 /* add on the size of the common header */ 1669 *pulSize += FIELD_OFFSET(OBJREF, u_objref); 1670 else 1671 /* custom marshaling: add on the size of the whole OBJREF structure 1672 * like native does */ 1673 *pulSize += sizeof(OBJREF); 1674 1675 IMarshal_Release(pMarshal); 1676 return hr; 1677 } 1678 1679 1680 static void dump_MSHLFLAGS(MSHLFLAGS flags) 1681 { 1682 if (flags & MSHLFLAGS_TABLESTRONG) 1683 TRACE(" MSHLFLAGS_TABLESTRONG"); 1684 if (flags & MSHLFLAGS_TABLEWEAK) 1685 TRACE(" MSHLFLAGS_TABLEWEAK"); 1686 if (!(flags & (MSHLFLAGS_TABLESTRONG|MSHLFLAGS_TABLEWEAK))) 1687 TRACE(" MSHLFLAGS_NORMAL"); 1688 if (flags & MSHLFLAGS_NOPING) 1689 TRACE(" MSHLFLAGS_NOPING"); 1690 } 1691 1692 /*********************************************************************** 1693 * CoMarshalInterface [OLE32.@] 1694 * 1695 * Marshals an interface into a stream so that the object can then be 1696 * unmarshaled from another COM apartment and used remotely. 1697 * 1698 * PARAMS 1699 * pStream [I] Stream the object will be marshaled into. 1700 * riid [I] Identifier of the interface to marshal. 1701 * pUnk [I] Pointer to the object to marshal. 1702 * dwDestContext [I] Destination. Used to enable or disable optimizations. 1703 * pvDestContext [I] Reserved. Must be NULL. 1704 * mshlFlags [I] Flags that affect the marshaling. See notes. 1705 * 1706 * RETURNS 1707 * Success: S_OK. 1708 * Failure: HRESULT code. 1709 * 1710 * NOTES 1711 * 1712 * The mshlFlags parameter can take one or more of the following flags: 1713 *| MSHLFLAGS_NORMAL - Unmarshal once, releases stub on last proxy release. 1714 *| MSHLFLAGS_TABLESTRONG - Unmarshal many, release when CoReleaseMarshalData() called. 1715 *| MSHLFLAGS_TABLEWEAK - Unmarshal many, releases stub on last proxy release. 1716 *| MSHLFLAGS_NOPING - No automatic garbage collection (and so reduces network traffic). 1717 * 1718 * If a marshaled object is not unmarshaled, then CoReleaseMarshalData() must 1719 * be called in order to release the resources used in the marshaling. 1720 * 1721 * SEE ALSO 1722 * CoUnmarshalInterface(), CoReleaseMarshalData(). 1723 */ 1724 HRESULT WINAPI CoMarshalInterface(IStream *pStream, REFIID riid, IUnknown *pUnk, 1725 DWORD dwDestContext, void *pvDestContext, 1726 DWORD mshlFlags) 1727 { 1728 HRESULT hr; 1729 CLSID marshaler_clsid; 1730 OBJREF objref; 1731 LPMARSHAL pMarshal; 1732 1733 TRACE("(%p, %s, %p, %x, %p, ", pStream, debugstr_guid(riid), pUnk, 1734 dwDestContext, pvDestContext); 1735 dump_MSHLFLAGS(mshlFlags); 1736 TRACE(")\n"); 1737 1738 if (!pUnk || !pStream) 1739 return E_INVALIDARG; 1740 1741 objref.signature = OBJREF_SIGNATURE; 1742 objref.iid = *riid; 1743 1744 /* get the marshaler for the specified interface */ 1745 hr = get_marshaler(riid, pUnk, dwDestContext, pvDestContext, mshlFlags, &pMarshal); 1746 if (hr != S_OK) 1747 { 1748 ERR("Failed to get marshaller, 0x%08x\n", hr); 1749 return hr; 1750 } 1751 1752 hr = IMarshal_GetUnmarshalClass(pMarshal, riid, pUnk, dwDestContext, 1753 pvDestContext, mshlFlags, &marshaler_clsid); 1754 if (hr != S_OK) 1755 { 1756 ERR("IMarshal::GetUnmarshalClass failed, 0x%08x\n", hr); 1757 goto cleanup; 1758 } 1759 1760 /* FIXME: implement handler marshaling too */ 1761 if (IsEqualCLSID(&marshaler_clsid, &CLSID_DfMarshal)) 1762 { 1763 TRACE("Using standard marshaling\n"); 1764 objref.flags = OBJREF_STANDARD; 1765 1766 /* write the common OBJREF header to the stream */ 1767 hr = IStream_Write(pStream, &objref, FIELD_OFFSET(OBJREF, u_objref), NULL); 1768 if (hr != S_OK) 1769 { 1770 ERR("Failed to write OBJREF header to stream, 0x%08x\n", hr); 1771 goto cleanup; 1772 } 1773 } 1774 else 1775 { 1776 TRACE("Using custom marshaling\n"); 1777 objref.flags = OBJREF_CUSTOM; 1778 objref.u_objref.u_custom.clsid = marshaler_clsid; 1779 objref.u_objref.u_custom.cbExtension = 0; 1780 objref.u_objref.u_custom.size = 0; 1781 hr = IMarshal_GetMarshalSizeMax(pMarshal, riid, pUnk, dwDestContext, 1782 pvDestContext, mshlFlags, 1783 &objref.u_objref.u_custom.size); 1784 if (hr != S_OK) 1785 { 1786 ERR("Failed to get max size of marshal data, error 0x%08x\n", hr); 1787 goto cleanup; 1788 } 1789 /* write constant sized common header and OR_CUSTOM data into stream */ 1790 hr = IStream_Write(pStream, &objref, 1791 FIELD_OFFSET(OBJREF, u_objref.u_custom.pData), NULL); 1792 if (hr != S_OK) 1793 { 1794 ERR("Failed to write OR_CUSTOM header to stream with 0x%08x\n", hr); 1795 goto cleanup; 1796 } 1797 } 1798 1799 TRACE("Calling IMarshal::MarshalInterface\n"); 1800 /* call helper object to do the actual marshaling */ 1801 hr = IMarshal_MarshalInterface(pMarshal, pStream, riid, pUnk, dwDestContext, 1802 pvDestContext, mshlFlags); 1803 1804 if (hr != S_OK) 1805 { 1806 ERR("Failed to marshal the interface %s, %x\n", debugstr_guid(riid), hr); 1807 goto cleanup; 1808 } 1809 1810 cleanup: 1811 IMarshal_Release(pMarshal); 1812 1813 TRACE("completed with hr 0x%08x\n", hr); 1814 1815 return hr; 1816 } 1817 1818 /*********************************************************************** 1819 * CoUnmarshalInterface [OLE32.@] 1820 * 1821 * Unmarshals an object from a stream by creating a proxy to the remote 1822 * object, if necessary. 1823 * 1824 * PARAMS 1825 * 1826 * pStream [I] Stream containing the marshaled object. 1827 * riid [I] Interface identifier of the object to create a proxy to. 1828 * ppv [O] Address where proxy will be stored. 1829 * 1830 * RETURNS 1831 * 1832 * Success: S_OK. 1833 * Failure: HRESULT code. 1834 * 1835 * SEE ALSO 1836 * CoMarshalInterface(). 1837 */ 1838 HRESULT WINAPI CoUnmarshalInterface(IStream *pStream, REFIID riid, LPVOID *ppv) 1839 { 1840 HRESULT hr; 1841 LPMARSHAL pMarshal; 1842 IID iid; 1843 IUnknown *object; 1844 1845 TRACE("(%p, %s, %p)\n", pStream, debugstr_guid(riid), ppv); 1846 1847 if (!pStream || !ppv) 1848 return E_INVALIDARG; 1849 1850 hr = get_unmarshaler_from_stream(pStream, &pMarshal, &iid); 1851 if (hr != S_OK) 1852 return hr; 1853 1854 /* call the helper object to do the actual unmarshaling */ 1855 hr = IMarshal_UnmarshalInterface(pMarshal, pStream, &iid, (LPVOID*)&object); 1856 if (hr != S_OK) 1857 ERR("IMarshal::UnmarshalInterface failed, 0x%08x\n", hr); 1858 1859 if (hr == S_OK) 1860 { 1861 /* IID_NULL means use the interface ID of the marshaled object */ 1862 if (!IsEqualIID(riid, &IID_NULL) && !IsEqualIID(riid, &iid)) 1863 { 1864 TRACE("requested interface != marshalled interface, additional QI needed\n"); 1865 hr = IUnknown_QueryInterface(object, riid, ppv); 1866 if (hr != S_OK) 1867 ERR("Couldn't query for interface %s, hr = 0x%08x\n", 1868 debugstr_guid(riid), hr); 1869 IUnknown_Release(object); 1870 } 1871 else 1872 { 1873 *ppv = object; 1874 } 1875 } 1876 1877 IMarshal_Release(pMarshal); 1878 1879 TRACE("completed with hr 0x%x\n", hr); 1880 1881 return hr; 1882 } 1883 1884 /*********************************************************************** 1885 * CoReleaseMarshalData [OLE32.@] 1886 * 1887 * Releases resources associated with an object that has been marshaled into 1888 * a stream. 1889 * 1890 * PARAMS 1891 * 1892 * pStream [I] The stream that the object has been marshaled into. 1893 * 1894 * RETURNS 1895 * Success: S_OK. 1896 * Failure: HRESULT error code. 1897 * 1898 * NOTES 1899 * 1900 * Call this function to release resources associated with a normal or 1901 * table-weak marshal that will not be unmarshaled, and all table-strong 1902 * marshals when they are no longer needed. 1903 * 1904 * SEE ALSO 1905 * CoMarshalInterface(), CoUnmarshalInterface(). 1906 */ 1907 HRESULT WINAPI CoReleaseMarshalData(IStream *pStream) 1908 { 1909 HRESULT hr; 1910 LPMARSHAL pMarshal; 1911 1912 TRACE("(%p)\n", pStream); 1913 1914 hr = get_unmarshaler_from_stream(pStream, &pMarshal, NULL); 1915 if (hr != S_OK) 1916 return hr; 1917 1918 /* call the helper object to do the releasing of marshal data */ 1919 hr = IMarshal_ReleaseMarshalData(pMarshal, pStream); 1920 if (hr != S_OK) 1921 ERR("IMarshal::ReleaseMarshalData failed with error 0x%08x\n", hr); 1922 1923 IMarshal_Release(pMarshal); 1924 return hr; 1925 } 1926 1927 1928 /*********************************************************************** 1929 * CoMarshalInterThreadInterfaceInStream [OLE32.@] 1930 * 1931 * Marshal an interface across threads in the same process. 1932 * 1933 * PARAMS 1934 * riid [I] Identifier of the interface to be marshalled. 1935 * pUnk [I] Pointer to IUnknown-derived interface that will be marshalled. 1936 * ppStm [O] Pointer to IStream object that is created and then used to store the marshalled interface. 1937 * 1938 * RETURNS 1939 * Success: S_OK 1940 * Failure: E_OUTOFMEMORY and other COM error codes 1941 * 1942 * SEE ALSO 1943 * CoMarshalInterface(), CoUnmarshalInterface() and CoGetInterfaceAndReleaseStream() 1944 */ 1945 HRESULT WINAPI CoMarshalInterThreadInterfaceInStream( 1946 REFIID riid, LPUNKNOWN pUnk, LPSTREAM * ppStm) 1947 { 1948 ULARGE_INTEGER xpos; 1949 LARGE_INTEGER seekto; 1950 HRESULT hres; 1951 1952 TRACE("(%s, %p, %p)\n",debugstr_guid(riid), pUnk, ppStm); 1953 1954 hres = CreateStreamOnHGlobal(NULL, TRUE, ppStm); 1955 if (FAILED(hres)) return hres; 1956 hres = CoMarshalInterface(*ppStm, riid, pUnk, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL); 1957 1958 if (SUCCEEDED(hres)) 1959 { 1960 memset(&seekto, 0, sizeof(seekto)); 1961 IStream_Seek(*ppStm, seekto, STREAM_SEEK_SET, &xpos); 1962 } 1963 else 1964 { 1965 IStream_Release(*ppStm); 1966 *ppStm = NULL; 1967 } 1968 1969 return hres; 1970 } 1971 1972 /*********************************************************************** 1973 * CoGetInterfaceAndReleaseStream [OLE32.@] 1974 * 1975 * Unmarshalls an interface from a stream and then releases the stream. 1976 * 1977 * PARAMS 1978 * pStm [I] Stream that contains the marshalled interface. 1979 * riid [I] Interface identifier of the object to unmarshall. 1980 * ppv [O] Address of pointer where the requested interface object will be stored. 1981 * 1982 * RETURNS 1983 * Success: S_OK 1984 * Failure: A COM error code 1985 * 1986 * SEE ALSO 1987 * CoMarshalInterThreadInterfaceInStream() and CoUnmarshalInterface() 1988 */ 1989 HRESULT WINAPI CoGetInterfaceAndReleaseStream(LPSTREAM pStm, REFIID riid, 1990 LPVOID *ppv) 1991 { 1992 HRESULT hres; 1993 1994 TRACE("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv); 1995 1996 if(!pStm) return E_INVALIDARG; 1997 hres = CoUnmarshalInterface(pStm, riid, ppv); 1998 IStream_Release(pStm); 1999 return hres; 2000 } 2001 2002 static HRESULT WINAPI StdMarshalCF_QueryInterface(LPCLASSFACTORY iface, 2003 REFIID riid, LPVOID *ppv) 2004 { 2005 *ppv = NULL; 2006 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory)) 2007 { 2008 *ppv = iface; 2009 return S_OK; 2010 } 2011 return E_NOINTERFACE; 2012 } 2013 2014 static ULONG WINAPI StdMarshalCF_AddRef(LPCLASSFACTORY iface) 2015 { 2016 return 2; /* non-heap based object */ 2017 } 2018 2019 static ULONG WINAPI StdMarshalCF_Release(LPCLASSFACTORY iface) 2020 { 2021 return 1; /* non-heap based object */ 2022 } 2023 2024 static HRESULT WINAPI StdMarshalCF_CreateInstance(LPCLASSFACTORY iface, 2025 LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv) 2026 { 2027 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IMarshal)) 2028 return StdMarshalImpl_Construct(riid, 0, NULL, ppv); 2029 2030 FIXME("(%s), not supported.\n",debugstr_guid(riid)); 2031 return E_NOINTERFACE; 2032 } 2033 2034 static HRESULT WINAPI StdMarshalCF_LockServer(LPCLASSFACTORY iface, BOOL fLock) 2035 { 2036 FIXME("(%d), stub!\n",fLock); 2037 return S_OK; 2038 } 2039 2040 static const IClassFactoryVtbl StdMarshalCFVtbl = 2041 { 2042 StdMarshalCF_QueryInterface, 2043 StdMarshalCF_AddRef, 2044 StdMarshalCF_Release, 2045 StdMarshalCF_CreateInstance, 2046 StdMarshalCF_LockServer 2047 }; 2048 static const IClassFactoryVtbl *StdMarshalCF = &StdMarshalCFVtbl; 2049 2050 HRESULT MARSHAL_GetStandardMarshalCF(LPVOID *ppv) 2051 { 2052 *ppv = &StdMarshalCF; 2053 return S_OK; 2054 } 2055 2056 /*********************************************************************** 2057 * CoMarshalHresult [OLE32.@] 2058 * 2059 * Marshals an HRESULT value into a stream. 2060 * 2061 * PARAMS 2062 * pStm [I] Stream that hresult will be marshalled into. 2063 * hresult [I] HRESULT to be marshalled. 2064 * 2065 * RETURNS 2066 * Success: S_OK 2067 * Failure: A COM error code 2068 * 2069 * SEE ALSO 2070 * CoUnmarshalHresult(). 2071 */ 2072 HRESULT WINAPI CoMarshalHresult(LPSTREAM pStm, HRESULT hresult) 2073 { 2074 return IStream_Write(pStm, &hresult, sizeof(hresult), NULL); 2075 } 2076 2077 /*********************************************************************** 2078 * CoUnmarshalHresult [OLE32.@] 2079 * 2080 * Unmarshals an HRESULT value from a stream. 2081 * 2082 * PARAMS 2083 * pStm [I] Stream that hresult will be unmarshalled from. 2084 * phresult [I] Pointer to HRESULT where the value will be unmarshalled to. 2085 * 2086 * RETURNS 2087 * Success: S_OK 2088 * Failure: A COM error code 2089 * 2090 * SEE ALSO 2091 * CoMarshalHresult(). 2092 */ 2093 HRESULT WINAPI CoUnmarshalHresult(LPSTREAM pStm, HRESULT * phresult) 2094 { 2095 return IStream_Read(pStm, phresult, sizeof(*phresult), NULL); 2096 } 2097