dlls/urlmon/bindctx.c

   1 /*
   2  * Copyright 2007 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdio.h>
  20
  21 #include "urlmon_main.h"
  22 #include "wine/debug.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  25
  26 static WCHAR BSCBHolder[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
  27
  28 extern IID IID_IBindStatusCallbackHolder;
  29
  30 typedef struct {
  31     const IBindStatusCallbackExVtbl  *lpBindStatusCallbackExVtbl;
  32     const IServiceProviderVtbl       *lpServiceProviderVtbl;
  33     const IHttpNegotiate2Vtbl        *lpHttpNegotiate2Vtbl;
  34     const IAuthenticateVtbl          *lpAuthenticateVtbl;
  35
  36     LONG ref;
  37
  38     IBindStatusCallback *callback;
  39     IServiceProvider *serv_prov;
  40 } BindStatusCallback;
  41
  42 #define STATUSCLB(x)     ((IBindStatusCallback*)  &(x)->lpBindStatusCallbackExVtbl)
  43 #define STATUSCLBEX(x)   ((IBindStatusCallbackEx*)&(x)->lpBindStatusCallbackExVtbl)
  44 #define SERVPROV(x)      ((IServiceProvider*)     &(x)->lpServiceProviderVtbl)
  45 #define HTTPNEG2(x)      ((IHttpNegotiate2*)      &(x)->lpHttpNegotiate2Vtbl)
  46 #define AUTHENTICATE(x)  ((IAuthenticate*)        &(x)->lpAuthenticateVtbl)
  47
  48 static void *get_callback_iface(BindStatusCallback *This, REFIID riid)
  49 {
  50     void *ret;
  51     HRESULT hres;
  52
  53     hres = IBindStatusCallback_QueryInterface(This->callback, riid, (void**)&ret);
  54     if(FAILED(hres) && This->serv_prov)
  55         hres = IServiceProvider_QueryService(This->serv_prov, riid, riid, &ret);
  56
  57     return SUCCEEDED(hres) ? ret : NULL;
  58 }
  59
  60 #define STATUSCLB_THIS(iface) DEFINE_THIS(BindStatusCallback, BindStatusCallbackEx, iface)
  61
  62 static HRESULT WINAPI BindStatusCallback_QueryInterface(IBindStatusCallbackEx *iface,
  63         REFIID riid, void **ppv)
  64 {
  65     BindStatusCallback *This = STATUSCLB_THIS(iface);
  66
  67     *ppv = NULL;
  68
  69     if(IsEqualGUID(&IID_IUnknown, riid)) {
  70         TRACE("(%p)->(IID_IUnknown, %p)\n", This, ppv);
  71         *ppv = STATUSCLB(This);
  72     }else if(IsEqualGUID(&IID_IBindStatusCallback, riid)) {
  73         TRACE("(%p)->(IID_IBindStatusCallback, %p)\n", This, ppv);
  74         *ppv = STATUSCLB(This);
  75     }else if(IsEqualGUID(&IID_IBindStatusCallbackEx, riid)) {
  76         TRACE("(%p)->(IID_IBindStatusCallback, %p)\n", This, ppv);
  77         *ppv = STATUSCLBEX(This);
  78     }else if(IsEqualGUID(&IID_IBindStatusCallbackHolder, riid)) {
  79         TRACE("(%p)->(IID_IBindStatusCallbackHolder, %p)\n", This, ppv);
  80         *ppv = This;
  81     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
  82         TRACE("(%p)->(IID_IServiceProvider, %p)\n", This, ppv);
  83         *ppv = SERVPROV(This);
  84     }else if(IsEqualGUID(&IID_IHttpNegotiate, riid)) {
  85         TRACE("(%p)->(IID_IHttpNegotiate, %p)\n", This, ppv);
  86         *ppv = HTTPNEG2(This);
  87     }else if(IsEqualGUID(&IID_IHttpNegotiate2, riid)) {
  88         TRACE("(%p)->(IID_IHttpNegotiate2, %p)\n", This, ppv);
  89         *ppv = HTTPNEG2(This);
  90     }else if(IsEqualGUID(&IID_IAuthenticate, riid)) {
  91         TRACE("(%p)->(IID_IAuthenticate, %p)\n", This, ppv);
  92         *ppv = AUTHENTICATE(This);
  93     }
  94
  95     if(*ppv) {
  96         IBindStatusCallback_AddRef((IUnknown*)*ppv);
  97         return S_OK;
  98     }
  99
 100     TRACE("Unsupported riid = %s\n", debugstr_guid(riid));
 101     return E_NOINTERFACE;
 102 }
 103
 104 static ULONG WINAPI BindStatusCallback_AddRef(IBindStatusCallbackEx *iface)
 105 {
 106     BindStatusCallback *This = STATUSCLB_THIS(iface);
 107     LONG ref = InterlockedIncrement(&This->ref);
 108
 109     TRACE("(%p) ref = %d\n", This, ref);
 110
 111     return ref;
 112 }
 113
 114 static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallbackEx *iface)
 115 {
 116     BindStatusCallback *This = STATUSCLB_THIS(iface);
 117     LONG ref = InterlockedDecrement(&This->ref);
 118
 119     TRACE("(%p) ref = %d\n", This, ref);
 120
 121     if(!ref) {
 122         if(This->serv_prov)
 123             IServiceProvider_Release(This->serv_prov);
 124         IBindStatusCallback_Release(This->callback);
 125         heap_free(This);
 126     }
 127
 128     return ref;
 129 }
 130
 131 static HRESULT WINAPI BindStatusCallback_OnStartBinding(IBindStatusCallbackEx *iface,
 132         DWORD dwReserved, IBinding *pbind)
 133 {
 134     BindStatusCallback *This = STATUSCLB_THIS(iface);
 135
 136     TRACE("(%p)->(%d %p)\n", This, dwReserved, pbind);
 137
 138     return IBindStatusCallback_OnStartBinding(This->callback, 0xff, pbind);
 139 }
 140
 141 static HRESULT WINAPI BindStatusCallback_GetPriority(IBindStatusCallbackEx *iface, LONG *pnPriority)
 142 {
 143     BindStatusCallback *This = STATUSCLB_THIS(iface);
 144
 145     TRACE("(%p)->(%p)\n", This, pnPriority);
 146
 147     return IBindStatusCallback_GetPriority(This->callback, pnPriority);
 148 }
 149
 150 static HRESULT WINAPI BindStatusCallback_OnLowResource(IBindStatusCallbackEx *iface, DWORD reserved)
 151 {
 152     BindStatusCallback *This = STATUSCLB_THIS(iface);
 153
 154     TRACE("(%p)->(%d)\n", This, reserved);
 155
 156     return IBindStatusCallback_OnLowResource(This->callback, reserved);
 157 }
 158
 159 static HRESULT WINAPI BindStatusCallback_OnProgress(IBindStatusCallbackEx *iface, ULONG ulProgress,
 160         ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
 161 {
 162     BindStatusCallback *This = STATUSCLB_THIS(iface);
 163
 164     TRACE("%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
 165             debugstr_w(szStatusText));
 166
 167     return IBindStatusCallback_OnProgress(This->callback, ulProgress,
 168             ulProgressMax, ulStatusCode, szStatusText);
 169 }
 170
 171 static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallbackEx *iface,
 172         HRESULT hresult, LPCWSTR szError)
 173 {
 174     BindStatusCallback *This = STATUSCLB_THIS(iface);
 175
 176     TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError));
 177
 178     return IBindStatusCallback_OnStopBinding(This->callback, hresult, szError);
 179 }
 180
 181 static HRESULT WINAPI BindStatusCallback_GetBindInfo(IBindStatusCallbackEx *iface,
 182         DWORD *grfBINDF, BINDINFO *pbindinfo)
 183 {
 184     BindStatusCallback *This = STATUSCLB_THIS(iface);
 185     IBindStatusCallbackEx *bscex;
 186     HRESULT hres;
 187
 188     TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
 189
 190     hres = IBindStatusCallback_QueryInterface(This->callback, &IID_IBindStatusCallbackEx, (void**)&bscex);
 191     if(SUCCEEDED(hres)) {
 192         DWORD bindf2 = 0, reserv = 0;
 193
 194         hres = IBindStatusCallbackEx_GetBindInfoEx(bscex, grfBINDF, pbindinfo, &bindf2, &reserv);
 195         IBindStatusCallbackEx_Release(bscex);
 196     }else {
 197         hres = IBindStatusCallback_GetBindInfo(This->callback, grfBINDF, pbindinfo);
 198     }
 199
 200     return hres;
 201 }
 202
 203 static HRESULT WINAPI BindStatusCallback_OnDataAvailable(IBindStatusCallbackEx *iface,
 204         DWORD grfBSCF, DWORD dwSize, FORMATETC *pformatetc, STGMEDIUM *pstgmed)
 205 {
 206     BindStatusCallback *This = STATUSCLB_THIS(iface);
 207
 208     TRACE("(%p)->(%08x %d %p %p)\n", This, grfBSCF, dwSize, pformatetc, pstgmed);
 209
 210     return IBindStatusCallback_OnDataAvailable(This->callback, grfBSCF, dwSize, pformatetc, pstgmed);
 211 }
 212
 213 static HRESULT WINAPI BindStatusCallback_OnObjectAvailable(IBindStatusCallbackEx *iface,
 214         REFIID riid, IUnknown *punk)
 215 {
 216     BindStatusCallback *This = STATUSCLB_THIS(iface);
 217
 218     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), punk);
 219
 220     return IBindStatusCallback_OnObjectAvailable(This->callback, riid, punk);
 221 }
 222
 223 static HRESULT WINAPI BindStatusCallback_GetBindInfoEx(IBindStatusCallbackEx *iface, DWORD *grfBINDF,
 224         BINDINFO *pbindinfo, DWORD *grfBINDF2, DWORD *pdwReserved)
 225 {
 226     BindStatusCallback *This = STATUSCLB_THIS(iface);
 227     IBindStatusCallbackEx *bscex;
 228     HRESULT hres;
 229
 230     TRACE("(%p)->(%p %p %p %p)\n", This, grfBINDF, pbindinfo, grfBINDF2, pdwReserved);
 231
 232     hres = IBindStatusCallback_QueryInterface(This->callback, &IID_IBindStatusCallbackEx, (void**)&bscex);
 233     if(SUCCEEDED(hres)) {
 234         hres = IBindStatusCallbackEx_GetBindInfoEx(bscex, grfBINDF, pbindinfo, grfBINDF2, pdwReserved);
 235         IBindStatusCallbackEx_Release(bscex);
 236     }else {
 237         hres = IBindStatusCallback_GetBindInfo(This->callback, grfBINDF, pbindinfo);
 238     }
 239
 240     return hres;
 241 }
 242
 243 #undef STATUSCLB_THIS
 244
 245 static const IBindStatusCallbackExVtbl BindStatusCallbackExVtbl = {
 246     BindStatusCallback_QueryInterface,
 247     BindStatusCallback_AddRef,
 248     BindStatusCallback_Release,
 249     BindStatusCallback_OnStartBinding,
 250     BindStatusCallback_GetPriority,
 251     BindStatusCallback_OnLowResource,
 252     BindStatusCallback_OnProgress,
 253     BindStatusCallback_OnStopBinding,
 254     BindStatusCallback_GetBindInfo,
 255     BindStatusCallback_OnDataAvailable,
 256     BindStatusCallback_OnObjectAvailable,
 257     BindStatusCallback_GetBindInfoEx
 258 };
 259
 260 #define SERVPROV_THIS(iface) DEFINE_THIS(BindStatusCallback, ServiceProvider, iface)
 261
 262 static HRESULT WINAPI BSCServiceProvider_QueryInterface(IServiceProvider *iface,
 263         REFIID riid, void **ppv)
 264 {
 265     BindStatusCallback *This = SERVPROV_THIS(iface);
 266     return IBindStatusCallback_QueryInterface(STATUSCLB(This), riid, ppv);
 267 }
 268
 269 static ULONG WINAPI BSCServiceProvider_AddRef(IServiceProvider *iface)
 270 {
 271     BindStatusCallback *This = SERVPROV_THIS(iface);
 272     return IBindStatusCallback_AddRef(STATUSCLB(This));
 273 }
 274
 275 static ULONG WINAPI BSCServiceProvider_Release(IServiceProvider *iface)
 276 {
 277     BindStatusCallback *This = SERVPROV_THIS(iface);
 278     return IBindStatusCallback_Release(STATUSCLB(This));
 279 }
 280
 281 static HRESULT WINAPI BSCServiceProvider_QueryService(IServiceProvider *iface,
 282         REFGUID guidService, REFIID riid, void **ppv)
 283 {
 284     BindStatusCallback *This = SERVPROV_THIS(iface);
 285     HRESULT hres;
 286
 287     if(IsEqualGUID(&IID_IHttpNegotiate, guidService)) {
 288         TRACE("(%p)->(IID_IHttpNegotiate %s %p)\n", This, debugstr_guid(riid), ppv);
 289         return IBindStatusCallback_QueryInterface(STATUSCLB(This), riid, ppv);
 290     }
 291
 292     if(IsEqualGUID(&IID_IHttpNegotiate2, guidService)) {
 293         TRACE("(%p)->(IID_IHttpNegotiate2 %s %p)\n", This, debugstr_guid(riid), ppv);
 294         return IBindStatusCallback_QueryInterface(STATUSCLB(This), riid, ppv);
 295     }
 296
 297     if(IsEqualGUID(&IID_IAuthenticate, guidService)) {
 298         TRACE("(%p)->(IID_IAuthenticate %s %p)\n", This, debugstr_guid(riid), ppv);
 299         return IBindStatusCallback_QueryInterface(STATUSCLB(This), riid, ppv);
 300     }
 301
 302     TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
 303
 304     hres = IBindStatusCallback_QueryInterface(This->callback, riid, ppv);
 305     if(SUCCEEDED(hres))
 306         return S_OK;
 307
 308     if(This->serv_prov) {
 309         hres = IServiceProvider_QueryService(This->serv_prov, guidService, riid, ppv);
 310         if(SUCCEEDED(hres))
 311             return S_OK;
 312     }
 313
 314     return E_NOINTERFACE;
 315 }
 316
 317 #undef SERVPROV_THIS
 318
 319 static const IServiceProviderVtbl BSCServiceProviderVtbl = {
 320     BSCServiceProvider_QueryInterface,
 321     BSCServiceProvider_AddRef,
 322     BSCServiceProvider_Release,
 323     BSCServiceProvider_QueryService
 324 };
 325
 326 #define HTTPNEG2_THIS(iface) DEFINE_THIS(BindStatusCallback, HttpNegotiate2, iface)
 327
 328 static HRESULT WINAPI BSCHttpNegotiate_QueryInterface(IHttpNegotiate2 *iface,
 329         REFIID riid, void **ppv)
 330 {
 331     BindStatusCallback *This = HTTPNEG2_THIS(iface);
 332     return IBindStatusCallback_QueryInterface(STATUSCLB(This), riid, ppv);
 333 }
 334
 335 static ULONG WINAPI BSCHttpNegotiate_AddRef(IHttpNegotiate2 *iface)
 336 {
 337     BindStatusCallback *This = HTTPNEG2_THIS(iface);
 338     return IBindStatusCallback_AddRef(STATUSCLB(This));
 339 }
 340
 341 static ULONG WINAPI BSCHttpNegotiate_Release(IHttpNegotiate2 *iface)
 342 {
 343     BindStatusCallback *This = HTTPNEG2_THIS(iface);
 344     return IBindStatusCallback_Release(STATUSCLB(This));
 345 }
 346
 347 static HRESULT WINAPI BSCHttpNegotiate_BeginningTransaction(IHttpNegotiate2 *iface,
 348         LPCWSTR szURL, LPCWSTR szHeaders, DWORD dwReserved, LPWSTR *pszAdditionalHeaders)
 349 {
 350     BindStatusCallback *This = HTTPNEG2_THIS(iface);
 351     IHttpNegotiate *http_negotiate;
 352     HRESULT hres = S_OK;
 353
 354     TRACE("(%p)->(%s %s %d %p)\n", This, debugstr_w(szURL), debugstr_w(szHeaders), dwReserved,
 355           pszAdditionalHeaders);
 356
 357     *pszAdditionalHeaders = NULL;
 358
 359     http_negotiate = get_callback_iface(This, &IID_IHttpNegotiate);
 360     if(http_negotiate) {
 361         hres = IHttpNegotiate_BeginningTransaction(http_negotiate, szURL, szHeaders,
 362                 dwReserved, pszAdditionalHeaders);
 363         IHttpNegotiate_Release(http_negotiate);
 364     }
 365
 366     return hres;
 367 }
 368
 369 static HRESULT WINAPI BSCHttpNegotiate_OnResponse(IHttpNegotiate2 *iface, DWORD dwResponseCode,
 370         LPCWSTR szResponseHeaders, LPCWSTR szRequestHeaders,
 371         LPWSTR *pszAdditionalRequestHeaders)
 372 {
 373     BindStatusCallback *This = HTTPNEG2_THIS(iface);
 374     LPWSTR additional_headers = NULL;
 375     IHttpNegotiate *http_negotiate;
 376     HRESULT hres = S_OK;
 377
 378     TRACE("(%p)->(%d %s %s %p)\n", This, dwResponseCode, debugstr_w(szResponseHeaders),
 379           debugstr_w(szRequestHeaders), pszAdditionalRequestHeaders);
 380
 381     http_negotiate = get_callback_iface(This, &IID_IHttpNegotiate);
 382     if(http_negotiate) {
 383         hres = IHttpNegotiate_OnResponse(http_negotiate, dwResponseCode, szResponseHeaders,
 384                 szRequestHeaders, &additional_headers);
 385         IHttpNegotiate_Release(http_negotiate);
 386     }
 387
 388     if(pszAdditionalRequestHeaders)
 389         *pszAdditionalRequestHeaders = additional_headers;
 390     else if(additional_headers)
 391         CoTaskMemFree(additional_headers);
 392
 393     return hres;
 394 }
 395
 396 static HRESULT WINAPI BSCHttpNegotiate_GetRootSecurityId(IHttpNegotiate2 *iface,
 397         BYTE *pbSecurityId, DWORD *pcbSecurityId, DWORD_PTR dwReserved)
 398 {
 399     BindStatusCallback *This = HTTPNEG2_THIS(iface);
 400     IHttpNegotiate2 *http_negotiate2;
 401     HRESULT hres = E_FAIL;
 402
 403     TRACE("(%p)->(%p %p %ld)\n", This, pbSecurityId, pcbSecurityId, dwReserved);
 404
 405     http_negotiate2 = get_callback_iface(This, &IID_IHttpNegotiate2);
 406     if(http_negotiate2) {
 407         hres = IHttpNegotiate2_GetRootSecurityId(http_negotiate2, pbSecurityId,
 408                 pcbSecurityId, dwReserved);
 409         IHttpNegotiate2_Release(http_negotiate2);
 410     }
 411
 412     return hres;
 413 }
 414
 415 #undef HTTPNEG2_THIS
 416
 417 static const IHttpNegotiate2Vtbl BSCHttpNegotiateVtbl = {
 418     BSCHttpNegotiate_QueryInterface,
 419     BSCHttpNegotiate_AddRef,
 420     BSCHttpNegotiate_Release,
 421     BSCHttpNegotiate_BeginningTransaction,
 422     BSCHttpNegotiate_OnResponse,
 423     BSCHttpNegotiate_GetRootSecurityId
 424 };
 425
 426 #define AUTHENTICATE_THIS(iface)  DEFINE_THIS(BindStatusCallback, Authenticate, iface)
 427
 428 static HRESULT WINAPI BSCAuthenticate_QueryInterface(IAuthenticate *iface, REFIID riid, void **ppv)
 429 {
 430     BindStatusCallback *This = AUTHENTICATE_THIS(iface);
 431     return IBindStatusCallback_QueryInterface(AUTHENTICATE(This), riid, ppv);
 432 }
 433
 434 static ULONG WINAPI BSCAuthenticate_AddRef(IAuthenticate *iface)
 435 {
 436     BindStatusCallback *This = AUTHENTICATE_THIS(iface);
 437     return IBindStatusCallback_AddRef(STATUSCLB(This));
 438 }
 439
 440 static ULONG WINAPI BSCAuthenticate_Release(IAuthenticate *iface)
 441 {
 442     BindStatusCallback *This = AUTHENTICATE_THIS(iface);
 443     return IBindStatusCallback_Release(STATUSCLB(This));
 444 }
 445
 446 static HRESULT WINAPI BSCAuthenticate_Authenticate(IAuthenticate *iface,
 447         HWND *phwnd, LPWSTR *pszUsername, LPWSTR *pszPassword)
 448 {
 449     BindStatusCallback *This = AUTHENTICATE_THIS(iface);
 450     FIXME("(%p)->(%p %p %p)\n", This, phwnd, pszUsername, pszPassword);
 451     return E_NOTIMPL;
 452 }
 453
 454 #undef AUTHENTICATE_THIS
 455
 456 static const IAuthenticateVtbl BSCAuthenticateVtbl = {
 457     BSCAuthenticate_QueryInterface,
 458     BSCAuthenticate_AddRef,
 459     BSCAuthenticate_Release,
 460     BSCAuthenticate_Authenticate
 461 };
 462
 463 static void set_callback(BindStatusCallback *This, IBindStatusCallback *bsc)
 464 {
 465     IServiceProvider *serv_prov;
 466     HRESULT hres;
 467
 468     if(This->callback)
 469         IBindStatusCallback_Release(This->callback);
 470     if(This->serv_prov)
 471         IServiceProvider_Release(This->serv_prov);
 472
 473     IBindStatusCallback_AddRef(bsc);
 474     This->callback = bsc;
 475
 476     hres = IBindStatusCallback_QueryInterface(bsc, &IID_IServiceProvider, (void**)&serv_prov);
 477     This->serv_prov = hres == S_OK ? serv_prov : NULL;
 478 }
 479
 480 HRESULT wrap_callback(IBindStatusCallback *bsc, IBindStatusCallback **ret_iface)
 481 {
 482     BindStatusCallback *ret;
 483
 484     ret = heap_alloc_zero(sizeof(BindStatusCallback));
 485     if(!ret)
 486         return E_OUTOFMEMORY;
 487
 488     ret->lpBindStatusCallbackExVtbl = &BindStatusCallbackExVtbl;
 489     ret->lpServiceProviderVtbl    = &BSCServiceProviderVtbl;
 490     ret->lpHttpNegotiate2Vtbl     = &BSCHttpNegotiateVtbl;
 491     ret->lpAuthenticateVtbl       = &BSCAuthenticateVtbl;
 492
 493     ret->ref = 1;
 494     set_callback(ret, bsc);
 495
 496     *ret_iface = STATUSCLB(ret);
 497     return S_OK;
 498 }
 499
 500 /***********************************************************************
 501  *           RegisterBindStatusCallback (urlmon.@)
 502  *
 503  * Register a bind status callback.
 504  *
 505  * PARAMS
 506  *  pbc           [I] Binding context
 507  *  pbsc          [I] Callback to register
 508  *  ppbscPrevious [O] Destination for previous callback
 509  *  dwReserved    [I] Reserved, must be 0.
 510  *
 511  * RETURNS
 512  *    Success: S_OK.
 513  *    Failure: E_INVALIDARG, if any argument is invalid, or
 514  *             E_OUTOFMEMORY if memory allocation fails.
 515  */
 516 HRESULT WINAPI RegisterBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc,
 517         IBindStatusCallback **ppbscPrevious, DWORD dwReserved)
 518 {
 519     BindStatusCallback *holder;
 520     IBindStatusCallback *bsc, *prev = NULL;
 521     IUnknown *unk;
 522     HRESULT hres;
 523
 524     TRACE("(%p %p %p %x)\n", pbc, pbsc, ppbscPrevious, dwReserved);
 525
 526     if (!pbc || !pbsc)
 527         return E_INVALIDARG;
 528
 529     hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, &unk);
 530     if(SUCCEEDED(hres)) {
 531         hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&bsc);
 532         IUnknown_Release(unk);
 533         if(SUCCEEDED(hres)) {
 534             hres = IBindStatusCallback_QueryInterface(bsc, &IID_IBindStatusCallbackHolder, (void**)&holder);
 535             if(SUCCEEDED(hres)) {
 536                 if(ppbscPrevious) {
 537                     IBindStatusCallback_AddRef(holder->callback);
 538                     *ppbscPrevious = holder->callback;
 539                 }
 540
 541                 set_callback(holder, pbsc);
 542
 543                 IBindStatusCallback_Release(bsc);
 544                 IBindStatusCallback_Release(STATUSCLB(holder));
 545                 return S_OK;
 546             }else {
 547                 prev = bsc;
 548             }
 549         }
 550
 551         IBindCtx_RevokeObjectParam(pbc, BSCBHolder);
 552     }
 553
 554     hres = wrap_callback(pbsc, &bsc);
 555     if(SUCCEEDED(hres)) {
 556         hres = IBindCtx_RegisterObjectParam(pbc, BSCBHolder, (IUnknown*)bsc);
 557         IBindStatusCallback_Release(bsc);
 558     }
 559     if(FAILED(hres)) {
 560         if(prev)
 561             IBindStatusCallback_Release(prev);
 562         return hres;
 563     }
 564
 565     if(ppbscPrevious)
 566         *ppbscPrevious = prev;
 567     return S_OK;
 568 }
 569
 570 /***********************************************************************
 571  *           RevokeBindStatusCallback (URLMON.@)
 572  *
 573  * Unregister a bind status callback.
 574  *
 575  *  pbc           [I] Binding context
 576  *  pbsc          [I] Callback to unregister
 577  *
 578  * RETURNS
 579  *    Success: S_OK.
 580  *    Failure: E_INVALIDARG, if any argument is invalid
 581  */
 582 HRESULT WINAPI RevokeBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc)
 583 {
 584     BindStatusCallback *holder;
 585     IBindStatusCallback *callback;
 586     IUnknown *unk;
 587     BOOL dorevoke = FALSE;
 588     HRESULT hres;
 589
 590     TRACE("(%p %p)\n", pbc, pbsc);
 591
 592     if (!pbc || !pbsc)
 593         return E_INVALIDARG;
 594
 595     hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, &unk);
 596     if(FAILED(hres))
 597         return S_OK;
 598
 599     hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&callback);
 600     IUnknown_Release(unk);
 601     if(FAILED(hres))
 602         return S_OK;
 603
 604     hres = IBindStatusCallback_QueryInterface(callback, &IID_IBindStatusCallbackHolder, (void**)&holder);
 605     if(SUCCEEDED(hres)) {
 606         if(pbsc == holder->callback)
 607             dorevoke = TRUE;
 608         IBindStatusCallback_Release(STATUSCLB(holder));
 609     }else if(pbsc == callback) {
 610         dorevoke = TRUE;
 611     }
 612     IBindStatusCallback_Release(callback);
 613
 614     if(dorevoke)
 615         IBindCtx_RevokeObjectParam(pbc, BSCBHolder);
 616
 617     return S_OK;
 618 }
 619
 620 typedef struct {
 621     const IBindCtxVtbl *lpBindCtxVtbl;
 622
 623     LONG ref;
 624
 625     IBindCtx *bindctx;
 626 } AsyncBindCtx;
 627
 628 #define BINDCTX(x)  ((IBindCtx*)  &(x)->lpBindCtxVtbl)
 629
 630 #define BINDCTX_THIS(iface) DEFINE_THIS(AsyncBindCtx, BindCtx, iface)
 631
 632 static HRESULT WINAPI AsyncBindCtx_QueryInterface(IBindCtx *iface, REFIID riid, void **ppv)
 633 {
 634     AsyncBindCtx *This = BINDCTX_THIS(iface);
 635
 636     *ppv = NULL;
 637
 638     if(IsEqualGUID(riid, &IID_IUnknown)) {
 639         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 640         *ppv = BINDCTX(This);
 641     }else if(IsEqualGUID(riid, &IID_IBindCtx)) {
 642         TRACE("(%p)->(IID_IBindCtx %p)\n", This, ppv);
 643         *ppv = BINDCTX(This);
 644     }else if(IsEqualGUID(riid, &IID_IAsyncBindCtx)) {
 645         TRACE("(%p)->(IID_IAsyncBindCtx %p)\n", This, ppv);
 646         *ppv = BINDCTX(This);
 647     }
 648
 649     if(*ppv) {
 650         IUnknown_AddRef((IUnknown*)*ppv);
 651         return S_OK;
 652     }
 653
 654     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 655     return E_NOINTERFACE;
 656 }
 657
 658 static ULONG WINAPI AsyncBindCtx_AddRef(IBindCtx *iface)
 659 {
 660     AsyncBindCtx *This = BINDCTX_THIS(iface);
 661     LONG ref = InterlockedIncrement(&This->ref);
 662
 663     TRACE("(%p) ref=%d\n", This, ref);
 664
 665     return ref;
 666 }
 667
 668 static ULONG WINAPI AsyncBindCtx_Release(IBindCtx *iface)
 669 {
 670     AsyncBindCtx *This = BINDCTX_THIS(iface);
 671     LONG ref = InterlockedDecrement(&This->ref);
 672
 673     TRACE("(%p) ref=%d\n", This, ref);
 674
 675     if(!ref) {
 676         IBindCtx_Release(This->bindctx);
 677         heap_free(This);
 678     }
 679
 680     return ref;
 681 }
 682
 683 static HRESULT WINAPI AsyncBindCtx_RegisterObjectBound(IBindCtx *iface, IUnknown *punk)
 684 {
 685     AsyncBindCtx *This = BINDCTX_THIS(iface);
 686
 687     TRACE("(%p)->(%p)\n", This, punk);
 688
 689     return IBindCtx_RegisterObjectBound(This->bindctx, punk);
 690 }
 691
 692 static HRESULT WINAPI AsyncBindCtx_RevokeObjectBound(IBindCtx *iface, IUnknown *punk)
 693 {
 694     AsyncBindCtx *This = BINDCTX_THIS(iface);
 695
 696     TRACE("(%p %p)\n", This, punk);
 697
 698     return IBindCtx_RevokeObjectBound(This->bindctx, punk);
 699 }
 700
 701 static HRESULT WINAPI AsyncBindCtx_ReleaseBoundObjects(IBindCtx *iface)
 702 {
 703     AsyncBindCtx *This = BINDCTX_THIS(iface);
 704
 705     TRACE("(%p)\n", This);
 706
 707     return IBindCtx_ReleaseBoundObjects(This->bindctx);
 708 }
 709
 710 static HRESULT WINAPI AsyncBindCtx_SetBindOptions(IBindCtx *iface, BIND_OPTS *pbindopts)
 711 {
 712     AsyncBindCtx *This = BINDCTX_THIS(iface);
 713
 714     TRACE("(%p)->(%p)\n", This, pbindopts);
 715
 716     return IBindCtx_SetBindOptions(This->bindctx, pbindopts);
 717 }
 718
 719 static HRESULT WINAPI AsyncBindCtx_GetBindOptions(IBindCtx *iface, BIND_OPTS *pbindopts)
 720 {
 721     AsyncBindCtx *This = BINDCTX_THIS(iface);
 722
 723     TRACE("(%p)->(%p)\n", This, pbindopts);
 724
 725     return IBindCtx_GetBindOptions(This->bindctx, pbindopts);
 726 }
 727
 728 static HRESULT WINAPI AsyncBindCtx_GetRunningObjectTable(IBindCtx *iface, IRunningObjectTable **pprot)
 729 {
 730     AsyncBindCtx *This = BINDCTX_THIS(iface);
 731
 732     TRACE("(%p)->(%p)\n", This, pprot);
 733
 734     return IBindCtx_GetRunningObjectTable(This->bindctx, pprot);
 735 }
 736
 737 static HRESULT WINAPI AsyncBindCtx_RegisterObjectParam(IBindCtx *iface, LPOLESTR pszkey, IUnknown *punk)
 738 {
 739     AsyncBindCtx *This = BINDCTX_THIS(iface);
 740
 741     TRACE("(%p)->(%s %p)\n", This, debugstr_w(pszkey), punk);
 742
 743     return IBindCtx_RegisterObjectParam(This->bindctx, pszkey, punk);
 744 }
 745
 746 static HRESULT WINAPI AsyncBindCtx_GetObjectParam(IBindCtx* iface, LPOLESTR pszkey, IUnknown **punk)
 747 {
 748     AsyncBindCtx *This = BINDCTX_THIS(iface);
 749
 750     TRACE("(%p)->(%s %p)\n", This, debugstr_w(pszkey), punk);
 751
 752     return IBindCtx_GetObjectParam(This->bindctx, pszkey, punk);
 753 }
 754
 755 static HRESULT WINAPI AsyncBindCtx_RevokeObjectParam(IBindCtx *iface, LPOLESTR pszkey)
 756 {
 757     AsyncBindCtx *This = BINDCTX_THIS(iface);
 758
 759     TRACE("(%p)->(%s)\n", This, debugstr_w(pszkey));
 760
 761     return IBindCtx_RevokeObjectParam(This->bindctx, pszkey);
 762 }
 763
 764 static HRESULT WINAPI AsyncBindCtx_EnumObjectParam(IBindCtx *iface, IEnumString **pszkey)
 765 {
 766     AsyncBindCtx *This = BINDCTX_THIS(iface);
 767
 768     TRACE("(%p)->(%p)\n", This, pszkey);
 769
 770     return IBindCtx_EnumObjectParam(This->bindctx, pszkey);
 771 }
 772
 773 #undef BINDCTX_THIS
 774
 775 static const IBindCtxVtbl AsyncBindCtxVtbl =
 776 {
 777     AsyncBindCtx_QueryInterface,
 778     AsyncBindCtx_AddRef,
 779     AsyncBindCtx_Release,
 780     AsyncBindCtx_RegisterObjectBound,
 781     AsyncBindCtx_RevokeObjectBound,
 782     AsyncBindCtx_ReleaseBoundObjects,
 783     AsyncBindCtx_SetBindOptions,
 784     AsyncBindCtx_GetBindOptions,
 785     AsyncBindCtx_GetRunningObjectTable,
 786     AsyncBindCtx_RegisterObjectParam,
 787     AsyncBindCtx_GetObjectParam,
 788     AsyncBindCtx_EnumObjectParam,
 789     AsyncBindCtx_RevokeObjectParam
 790 };
 791
 792 static HRESULT init_bindctx(IBindCtx *bindctx, DWORD options,
 793        IBindStatusCallback *callback, IEnumFORMATETC *format)
 794 {
 795     BIND_OPTS bindopts;
 796     HRESULT hres;
 797
 798     if(options)
 799         FIXME("not supported options %08x\n", options);
 800     if(format)
 801         FIXME("format is not supported\n");
 802
 803     bindopts.cbStruct = sizeof(BIND_OPTS);
 804     bindopts.grfFlags = BIND_MAYBOTHERUSER;
 805     bindopts.grfMode = STGM_READWRITE | STGM_SHARE_EXCLUSIVE;
 806     bindopts.dwTickCountDeadline = 0;
 807
 808     hres = IBindCtx_SetBindOptions(bindctx, &bindopts);
 809     if(FAILED(hres))
 810        return hres;
 811
 812     if(callback) {
 813         hres = RegisterBindStatusCallback(bindctx, callback, NULL, 0);
 814         if(FAILED(hres))
 815             return hres;
 816     }
 817
 818     return S_OK;
 819 }
 820
 821 /***********************************************************************
 822  *           CreateAsyncBindCtx (urlmon.@)
 823  */
 824 HRESULT WINAPI CreateAsyncBindCtx(DWORD reserved, IBindStatusCallback *callback,
 825         IEnumFORMATETC *format, IBindCtx **pbind)
 826 {
 827     IBindCtx *bindctx;
 828     HRESULT hres;
 829
 830     TRACE("(%08x %p %p %p)\n", reserved, callback, format, pbind);
 831
 832     if(!pbind || !callback)
 833         return E_INVALIDARG;
 834
 835     hres = CreateBindCtx(0, &bindctx);
 836     if(FAILED(hres))
 837         return hres;
 838
 839     hres = init_bindctx(bindctx, 0, callback, format);
 840     if(FAILED(hres)) {
 841         IBindCtx_Release(bindctx);
 842         return hres;
 843     }
 844
 845     *pbind = bindctx;
 846     return S_OK;
 847 }
 848
 849 /***********************************************************************
 850  *           CreateAsyncBindCtxEx (urlmon.@)
 851  *
 852  * Create an asynchronous bind context.
 853  */
 854 HRESULT WINAPI CreateAsyncBindCtxEx(IBindCtx *ibind, DWORD options,
 855         IBindStatusCallback *callback, IEnumFORMATETC *format, IBindCtx** pbind,
 856         DWORD reserved)
 857 {
 858     AsyncBindCtx *ret;
 859     IBindCtx *bindctx;
 860     HRESULT hres;
 861
 862     TRACE("(%p %08x %p %p %p %d)\n", ibind, options, callback, format, pbind, reserved);
 863
 864     if(!pbind)
 865         return E_INVALIDARG;
 866
 867     if(reserved)
 868         WARN("reserved=%d\n", reserved);
 869
 870     if(ibind) {
 871         IBindCtx_AddRef(ibind);
 872         bindctx = ibind;
 873     }else {
 874         hres = CreateBindCtx(0, &bindctx);
 875         if(FAILED(hres))
 876             return hres;
 877     }
 878
 879     ret = heap_alloc(sizeof(AsyncBindCtx));
 880
 881     ret->lpBindCtxVtbl = &AsyncBindCtxVtbl;
 882     ret->ref = 1;
 883     ret->bindctx = bindctx;
 884
 885     hres = init_bindctx(BINDCTX(ret), options, callback, format);
 886     if(FAILED(hres)) {
 887         IBindCtx_Release(BINDCTX(ret));
 888         return hres;
 889     }
 890
 891     *pbind = BINDCTX(ret);
 892     return S_OK;
 893 }