dlls/urlmon/bindprot.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 "urlmon_main.h"
  20 #include "wine/debug.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  23
  24 typedef struct {
  25     const IInternetProtocolVtbl *lpInternetProtocolVtbl;
  26     const IInternetBindInfoVtbl *lpInternetBindInfoVtbl;
  27     const IInternetPriorityVtbl *lpInternetPriorityVtbl;
  28     const IServiceProviderVtbl  *lpServiceProviderVtbl;
  29     const IInternetProtocolSinkVtbl *lpInternetProtocolSinkVtbl;
  30
  31     LONG ref;
  32
  33     IInternetProtocol *protocol;
  34     IInternetBindInfo *bind_info;
  35     IInternetProtocolSink *protocol_sink;
  36     IServiceProvider *service_provider;
  37
  38     LONG priority;
  39 } BindProtocol;
  40
  41 #define PROTOCOL(x)  ((IInternetProtocol*) &(x)->lpInternetProtocolVtbl)
  42 #define BINDINFO(x)  ((IInternetBindInfo*) &(x)->lpInternetBindInfoVtbl)
  43 #define PRIORITY(x)  ((IInternetPriority*) &(x)->lpInternetPriorityVtbl)
  44 #define SERVPROV(x)  ((IServiceProvider*)  &(x)->lpServiceProviderVtbl)
  45 #define PROTSINK(x)  ((IInternetProtocolSink*) &(x)->lpInternetProtocolSinkVtbl)
  46
  47 #define PROTOCOL_THIS(iface) DEFINE_THIS(BindProtocol, InternetProtocol, iface)
  48
  49 static HRESULT WINAPI BindProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
  50 {
  51     BindProtocol *This = PROTOCOL_THIS(iface);
  52
  53     *ppv = NULL;
  54     if(IsEqualGUID(&IID_IUnknown, riid)) {
  55         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
  56         *ppv = PROTOCOL(This);
  57     }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
  58         TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv);
  59         *ppv = PROTOCOL(This);
  60     }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
  61         TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv);
  62         *ppv = PROTOCOL(This);
  63     }else if(IsEqualGUID(&IID_IInternetBindInfo, riid)) {
  64         TRACE("(%p)->(IID_IInternetBindInfo %p)\n", This, ppv);
  65         *ppv = BINDINFO(This);
  66     }else if(IsEqualGUID(&IID_IInternetPriority, riid)) {
  67         TRACE("(%p)->(IID_IInternetPriority %p)\n", This, ppv);
  68         *ppv = PRIORITY(This);
  69     }else if(IsEqualGUID(&IID_IAuthenticate, riid)) {
  70         FIXME("(%p)->(IID_IAuthenticate %p)\n", This, ppv);
  71     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
  72         TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
  73         *ppv = SERVPROV(This);
  74     }else if(IsEqualGUID(&IID_IInternetProtocolSink, riid)) {
  75         TRACE("(%p)->(IID_IInternetProtocolSink %p)\n", This, ppv);
  76         *ppv = PROTSINK(This);
  77     }
  78
  79     if(*ppv) {
  80         IInternetProtocol_AddRef(iface);
  81         return S_OK;
  82     }
  83
  84     WARN("not supported interface %s\n", debugstr_guid(riid));
  85     return E_NOINTERFACE;
  86 }
  87
  88 static ULONG WINAPI BindProtocol_AddRef(IInternetProtocol *iface)
  89 {
  90     BindProtocol *This = PROTOCOL_THIS(iface);
  91     LONG ref = InterlockedIncrement(&This->ref);
  92     TRACE("(%p) ref=%d\n", This, ref);
  93     return ref;
  94 }
  95
  96 static ULONG WINAPI BindProtocol_Release(IInternetProtocol *iface)
  97 {
  98     BindProtocol *This = PROTOCOL_THIS(iface);
  99     LONG ref = InterlockedDecrement(&This->ref);
 100
 101     TRACE("(%p) ref=%d\n", This, ref);
 102
 103     if(!ref) {
 104         if(This->protocol)
 105             IInternetProtocol_Release(This->protocol);
 106         if(This->bind_info)
 107             IInternetBindInfo_Release(This->bind_info);
 108         if(This->protocol_sink)
 109             IInternetProtocolSink_Release(This->protocol_sink);
 110
 111         heap_free(This);
 112
 113         URLMON_UnlockModule();
 114     }
 115
 116     return ref;
 117 }
 118
 119 static HRESULT WINAPI BindProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
 120         IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
 121         DWORD grfPI, DWORD dwReserved)
 122 {
 123     BindProtocol *This = PROTOCOL_THIS(iface);
 124     IInternetProtocol *protocol = NULL;
 125     IInternetPriority *priority;
 126     IServiceProvider *service_provider;
 127     CLSID clsid = IID_NULL;
 128     LPOLESTR clsid_str;
 129     HRESULT hres;
 130
 131     TRACE("(%p)->(%s %p %p %08x %d)\n", This, debugstr_w(szUrl), pOIProtSink,
 132             pOIBindInfo, grfPI, dwReserved);
 133
 134     if(!szUrl || !pOIProtSink || !pOIBindInfo)
 135         return E_INVALIDARG;
 136
 137     hres = IInternetProtocolSink_QueryInterface(pOIProtSink, &IID_IServiceProvider,
 138                                                 (void**)&service_provider);
 139     if(SUCCEEDED(hres)) {
 140         /* FIXME: What's protocol CLSID here? */
 141         IServiceProvider_QueryService(service_provider, &IID_IInternetProtocol,
 142                                       &IID_IInternetProtocol, (void**)&protocol);
 143         IServiceProvider_Release(service_provider);
 144     }
 145
 146     if(!protocol) {
 147         IClassFactory *cf;
 148         IUnknown *unk;
 149
 150         hres = get_protocol_handler(szUrl, &clsid, &cf);
 151         if(FAILED(hres))
 152             return hres;
 153
 154         hres = IClassFactory_CreateInstance(cf, (IUnknown*)BINDINFO(This),
 155                 &IID_IUnknown, (void**)&unk);
 156         IClassFactory_Release(cf);
 157         if(FAILED(hres))
 158             return hres;
 159
 160         hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocol, (void**)&protocol);
 161         IUnknown_Release(unk);
 162         if(FAILED(hres))
 163             return hres;
 164     }
 165
 166     StringFromCLSID(&clsid, &clsid_str);
 167     IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_PROTOCOLCLASSID, clsid_str);
 168     CoTaskMemFree(clsid_str);
 169
 170     This->protocol = protocol;
 171
 172     IInternetBindInfo_AddRef(pOIBindInfo);
 173     This->bind_info = pOIBindInfo;
 174
 175     IInternetProtocolSink_AddRef(pOIProtSink);
 176     This->protocol_sink = pOIProtSink;
 177
 178     IInternetProtocolSink_QueryInterface(pOIProtSink, &IID_IServiceProvider, (void**)&This->service_provider);
 179
 180     hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetPriority, (void**)&priority);
 181     if(SUCCEEDED(hres)) {
 182         IInternetPriority_SetPriority(priority, This->priority);
 183         IInternetPriority_Release(priority);
 184     }
 185
 186     return IInternetProtocol_Start(protocol, szUrl, PROTSINK(This), BINDINFO(This), 0, 0);
 187 }
 188
 189 static HRESULT WINAPI BindProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData)
 190 {
 191     BindProtocol *This = PROTOCOL_THIS(iface);
 192     FIXME("(%p)->(%p)\n", This, pProtocolData);
 193     return E_NOTIMPL;
 194 }
 195
 196 static HRESULT WINAPI BindProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
 197         DWORD dwOptions)
 198 {
 199     BindProtocol *This = PROTOCOL_THIS(iface);
 200     FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
 201     return E_NOTIMPL;
 202 }
 203
 204 static HRESULT WINAPI BindProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
 205 {
 206     BindProtocol *This = PROTOCOL_THIS(iface);
 207
 208     TRACE("(%p)->(%08x)\n", This, dwOptions);
 209
 210     IInternetProtocol_Terminate(This->protocol, 0);
 211     return S_OK;
 212 }
 213
 214 static HRESULT WINAPI BindProtocol_Suspend(IInternetProtocol *iface)
 215 {
 216     BindProtocol *This = PROTOCOL_THIS(iface);
 217     FIXME("(%p)\n", This);
 218     return E_NOTIMPL;
 219 }
 220
 221 static HRESULT WINAPI BindProtocol_Resume(IInternetProtocol *iface)
 222 {
 223     BindProtocol *This = PROTOCOL_THIS(iface);
 224     FIXME("(%p)\n", This);
 225     return E_NOTIMPL;
 226 }
 227
 228 static HRESULT WINAPI BindProtocol_Read(IInternetProtocol *iface, void *pv,
 229         ULONG cb, ULONG *pcbRead)
 230 {
 231     BindProtocol *This = PROTOCOL_THIS(iface);
 232     ULONG read = 0;
 233     HRESULT hres;
 234
 235     TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
 236
 237     hres = IInternetProtocol_Read(This->protocol, pv, cb, &read);
 238
 239     *pcbRead = read;
 240     return hres;
 241 }
 242
 243 static HRESULT WINAPI BindProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
 244         DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
 245 {
 246     BindProtocol *This = PROTOCOL_THIS(iface);
 247     FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 248     return E_NOTIMPL;
 249 }
 250
 251 static HRESULT WINAPI BindProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
 252 {
 253     BindProtocol *This = PROTOCOL_THIS(iface);
 254     FIXME("(%p)->(%08x)\n", This, dwOptions);
 255     return E_NOTIMPL;
 256 }
 257
 258 static HRESULT WINAPI BindProtocol_UnlockRequest(IInternetProtocol *iface)
 259 {
 260     BindProtocol *This = PROTOCOL_THIS(iface);
 261     FIXME("(%p)\n", This);
 262     return E_NOTIMPL;
 263 }
 264
 265 #undef PROTOCOL_THIS
 266
 267 static const IInternetProtocolVtbl BindProtocolVtbl = {
 268     BindProtocol_QueryInterface,
 269     BindProtocol_AddRef,
 270     BindProtocol_Release,
 271     BindProtocol_Start,
 272     BindProtocol_Continue,
 273     BindProtocol_Abort,
 274     BindProtocol_Terminate,
 275     BindProtocol_Suspend,
 276     BindProtocol_Resume,
 277     BindProtocol_Read,
 278     BindProtocol_Seek,
 279     BindProtocol_LockRequest,
 280     BindProtocol_UnlockRequest
 281 };
 282
 283 #define BINDINFO_THIS(iface) DEFINE_THIS(BindProtocol, InternetBindInfo, iface)
 284
 285 static HRESULT WINAPI BindInfo_QueryInterface(IInternetBindInfo *iface,
 286         REFIID riid, void **ppv)
 287 {
 288     BindProtocol *This = BINDINFO_THIS(iface);
 289     return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
 290 }
 291
 292 static ULONG WINAPI BindInfo_AddRef(IInternetBindInfo *iface)
 293 {
 294     BindProtocol *This = BINDINFO_THIS(iface);
 295     return IBinding_AddRef(PROTOCOL(This));
 296 }
 297
 298 static ULONG WINAPI BindInfo_Release(IInternetBindInfo *iface)
 299 {
 300     BindProtocol *This = BINDINFO_THIS(iface);
 301     return IBinding_Release(PROTOCOL(This));
 302 }
 303
 304 static HRESULT WINAPI BindInfo_GetBindInfo(IInternetBindInfo *iface,
 305         DWORD *grfBINDF, BINDINFO *pbindinfo)
 306 {
 307     BindProtocol *This = BINDINFO_THIS(iface);
 308     HRESULT hres;
 309
 310     TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
 311
 312     hres = IInternetBindInfo_GetBindInfo(This->bind_info, grfBINDF, pbindinfo);
 313     if(FAILED(hres)) {
 314         WARN("GetBindInfo failed: %08x\n", hres);
 315         return hres;
 316     }
 317
 318     *grfBINDF |= BINDF_FROMURLMON;
 319     return hres;
 320 }
 321
 322 static HRESULT WINAPI BindInfo_GetBindString(IInternetBindInfo *iface,
 323         ULONG ulStringType, LPOLESTR *ppwzStr, ULONG cEl, ULONG *pcElFetched)
 324 {
 325     BindProtocol *This = BINDINFO_THIS(iface);
 326
 327     TRACE("(%p)->(%d %p %d %p)\n", This, ulStringType, ppwzStr, cEl, pcElFetched);
 328
 329     return IInternetBindInfo_GetBindString(This->bind_info, ulStringType, ppwzStr, cEl, pcElFetched);
 330 }
 331
 332 #undef BINDFO_THIS
 333
 334 static const IInternetBindInfoVtbl InternetBindInfoVtbl = {
 335     BindInfo_QueryInterface,
 336     BindInfo_AddRef,
 337     BindInfo_Release,
 338     BindInfo_GetBindInfo,
 339     BindInfo_GetBindString
 340 };
 341
 342 #define PRIORITY_THIS(iface) DEFINE_THIS(BindProtocol, InternetPriority, iface)
 343
 344 static HRESULT WINAPI InternetPriority_QueryInterface(IInternetPriority *iface,
 345         REFIID riid, void **ppv)
 346 {
 347     BindProtocol *This = PRIORITY_THIS(iface);
 348     return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
 349 }
 350
 351 static ULONG WINAPI InternetPriority_AddRef(IInternetPriority *iface)
 352 {
 353     BindProtocol *This = PRIORITY_THIS(iface);
 354     return IInternetProtocol_AddRef(PROTOCOL(This));
 355 }
 356
 357 static ULONG WINAPI InternetPriority_Release(IInternetPriority *iface)
 358 {
 359     BindProtocol *This = PRIORITY_THIS(iface);
 360     return IInternetProtocol_Release(PROTOCOL(This));
 361 }
 362
 363 static HRESULT WINAPI InternetPriority_SetPriority(IInternetPriority *iface, LONG nPriority)
 364 {
 365     BindProtocol *This = PRIORITY_THIS(iface);
 366
 367     TRACE("(%p)->(%d)\n", This, nPriority);
 368
 369     This->priority = nPriority;
 370     return S_OK;
 371 }
 372
 373 static HRESULT WINAPI InternetPriority_GetPriority(IInternetPriority *iface, LONG *pnPriority)
 374 {
 375     BindProtocol *This = PRIORITY_THIS(iface);
 376
 377     TRACE("(%p)->(%p)\n", This, pnPriority);
 378
 379     *pnPriority = This->priority;
 380     return S_OK;
 381 }
 382
 383 #undef PRIORITY_THIS
 384
 385 static const IInternetPriorityVtbl InternetPriorityVtbl = {
 386     InternetPriority_QueryInterface,
 387     InternetPriority_AddRef,
 388     InternetPriority_Release,
 389     InternetPriority_SetPriority,
 390     InternetPriority_GetPriority
 391
 392 };
 393
 394 #define PROTSINK_THIS(iface) DEFINE_THIS(BindProtocol, InternetProtocolSink, iface)
 395
 396 static HRESULT WINAPI InternetProtocolSink_QueryInterface(IInternetProtocolSink *iface,
 397         REFIID riid, void **ppv)
 398 {
 399     BindProtocol *This = PROTSINK_THIS(iface);
 400     return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
 401 }
 402
 403 static ULONG WINAPI InternetProtocolSink_AddRef(IInternetProtocolSink *iface)
 404 {
 405     BindProtocol *This = PROTSINK_THIS(iface);
 406     return IInternetProtocol_AddRef(PROTOCOL(This));
 407 }
 408
 409 static ULONG WINAPI InternetProtocolSink_Release(IInternetProtocolSink *iface)
 410 {
 411     BindProtocol *This = PROTSINK_THIS(iface);
 412     return IInternetProtocol_Release(PROTOCOL(This));
 413 }
 414
 415 static HRESULT WINAPI InternetProtocolSink_Switch(IInternetProtocolSink *iface,
 416         PROTOCOLDATA *pProtocolData)
 417 {
 418     BindProtocol *This = PROTSINK_THIS(iface);
 419
 420     TRACE("(%p)->(%p)\n", This, pProtocolData);
 421
 422     return IInternetProtocolSink_Switch(This->protocol_sink, pProtocolData);
 423 }
 424
 425 static HRESULT WINAPI InternetProtocolSink_ReportProgress(IInternetProtocolSink *iface,
 426         ULONG ulStatusCode, LPCWSTR szStatusText)
 427 {
 428     BindProtocol *This = PROTSINK_THIS(iface);
 429
 430     TRACE("(%p)->(%u %s)\n", This, ulStatusCode, debugstr_w(szStatusText));
 431
 432     switch(ulStatusCode) {
 433     case BINDSTATUS_SENDINGREQUEST:
 434         return IInternetProtocolSink_ReportProgress(This->protocol_sink,
 435                 ulStatusCode, NULL);
 436     case BINDSTATUS_CACHEFILENAMEAVAILABLE:
 437         return IInternetProtocolSink_ReportProgress(This->protocol_sink,
 438                 ulStatusCode, szStatusText);
 439     case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
 440         return IInternetProtocolSink_ReportProgress(This->protocol_sink,
 441                 BINDSTATUS_MIMETYPEAVAILABLE, szStatusText);
 442     default:
 443         FIXME("unsupported ulStatusCode %u\n", ulStatusCode);
 444     }
 445
 446     return E_NOTIMPL;
 447 }
 448
 449 static HRESULT WINAPI InternetProtocolSink_ReportData(IInternetProtocolSink *iface,
 450         DWORD grfBSCF, ULONG ulProgress, ULONG ulProgressMax)
 451 {
 452     BindProtocol *This = PROTSINK_THIS(iface);
 453
 454     TRACE("(%p)->(%d %u %u)\n", This, grfBSCF, ulProgress, ulProgressMax);
 455
 456     return IInternetProtocolSink_ReportData(This->protocol_sink, grfBSCF, ulProgress, ulProgressMax);
 457 }
 458
 459 static HRESULT WINAPI InternetProtocolSink_ReportResult(IInternetProtocolSink *iface,
 460         HRESULT hrResult, DWORD dwError, LPCWSTR szResult)
 461 {
 462     BindProtocol *This = PROTSINK_THIS(iface);
 463
 464     TRACE("(%p)->(%08x %d %s)\n", This, hrResult, dwError, debugstr_w(szResult));
 465
 466     return IInternetProtocolSink_ReportResult(This->protocol_sink, hrResult, dwError, szResult);
 467 }
 468
 469 #undef PROTSINK_THIS
 470
 471 static const IInternetProtocolSinkVtbl InternetProtocolSinkVtbl = {
 472     InternetProtocolSink_QueryInterface,
 473     InternetProtocolSink_AddRef,
 474     InternetProtocolSink_Release,
 475     InternetProtocolSink_Switch,
 476     InternetProtocolSink_ReportProgress,
 477     InternetProtocolSink_ReportData,
 478     InternetProtocolSink_ReportResult
 479 };
 480
 481 #define SERVPROV_THIS(iface) DEFINE_THIS(BindProtocol, ServiceProvider, iface)
 482
 483 static HRESULT WINAPI BPServiceProvider_QueryInterface(IServiceProvider *iface,
 484         REFIID riid, void **ppv)
 485 {
 486     BindProtocol *This = SERVPROV_THIS(iface);
 487     return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
 488 }
 489
 490 static ULONG WINAPI BPServiceProvider_AddRef(IServiceProvider *iface)
 491 {
 492     BindProtocol *This = SERVPROV_THIS(iface);
 493     return IInternetProtocol_AddRef(PROTOCOL(This));
 494 }
 495
 496 static ULONG WINAPI BPServiceProvider_Release(IServiceProvider *iface)
 497 {
 498     BindProtocol *This = SERVPROV_THIS(iface);
 499     return IInternetProtocol_Release(PROTOCOL(This));
 500 }
 501
 502 static HRESULT WINAPI BPServiceProvider_QueryService(IServiceProvider *iface,
 503         REFGUID guidService, REFIID riid, void **ppv)
 504 {
 505     BindProtocol *This = SERVPROV_THIS(iface);
 506
 507     TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
 508
 509     if(!This->service_provider)
 510         return E_NOINTERFACE;
 511
 512     return IServiceProvider_QueryService(This->service_provider, guidService, riid, ppv);
 513 }
 514
 515 #undef SERVPROV_THIS
 516
 517 static const IServiceProviderVtbl ServiceProviderVtbl = {
 518     BPServiceProvider_QueryInterface,
 519     BPServiceProvider_AddRef,
 520     BPServiceProvider_Release,
 521     BPServiceProvider_QueryService
 522 };
 523
 524 HRESULT create_binding_protocol(LPCWSTR url, IInternetProtocol **protocol)
 525 {
 526     BindProtocol *ret = heap_alloc(sizeof(BindProtocol));
 527
 528     ret->lpInternetProtocolVtbl = &BindProtocolVtbl;
 529     ret->lpInternetBindInfoVtbl = &InternetBindInfoVtbl;
 530     ret->lpInternetPriorityVtbl = &InternetPriorityVtbl;
 531     ret->lpServiceProviderVtbl  = &ServiceProviderVtbl;
 532     ret->lpInternetProtocolSinkVtbl = &InternetProtocolSinkVtbl;
 533
 534     ret->ref = 1;
 535     ret->protocol = NULL;
 536     ret->bind_info = NULL;
 537     ret->protocol_sink = NULL;
 538     ret->service_provider = NULL;
 539     ret->priority = 0;
 540
 541     URLMON_LockModule();
 542
 543     *protocol = PROTOCOL(ret);
 544     return S_OK;
 545 }