dlls/urlmon/download.c

   1 /*
   2  * Copyright 2008 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     IBindStatusCallback IBindStatusCallback_iface;
  26     IServiceProvider    IServiceProvider_iface;
  27
  28     LONG ref;
  29
  30     IBindStatusCallback *callback;
  31     IBinding *binding;
  32     LPWSTR file_name;
  33     LPWSTR cache_file;
  34     DWORD bindf;
  35
  36     stop_cache_binding_proc_t onstop_proc;
  37     void *ctx;
  38 } DownloadBSC;
  39
  40 static inline DownloadBSC *impl_from_IBindStatusCallback(IBindStatusCallback *iface)
  41 {
  42     return CONTAINING_RECORD(iface, DownloadBSC, IBindStatusCallback_iface);
  43 }
  44
  45 static inline DownloadBSC *impl_from_IServiceProvider(IServiceProvider *iface)
  46 {
  47     return CONTAINING_RECORD(iface, DownloadBSC, IServiceProvider_iface);
  48 }
  49
  50 static HRESULT WINAPI DownloadBSC_QueryInterface(IBindStatusCallback *iface,
  51         REFIID riid, void **ppv)
  52 {
  53     DownloadBSC *This = impl_from_IBindStatusCallback(iface);
  54
  55     *ppv = NULL;
  56
  57     if(IsEqualGUID(&IID_IUnknown, riid)) {
  58         TRACE("(%p)->(IID_IUnknown, %p)\n", This, ppv);
  59         *ppv = &This->IBindStatusCallback_iface;
  60     }else if(IsEqualGUID(&IID_IBindStatusCallback, riid)) {
  61         TRACE("(%p)->(IID_IBindStatusCallback, %p)\n", This, ppv);
  62         *ppv = &This->IBindStatusCallback_iface;
  63     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
  64         TRACE("(%p)->(IID_IServiceProvider, %p)\n", This, ppv);
  65         *ppv = &This->IServiceProvider_iface;
  66     }
  67
  68     if(*ppv) {
  69         IUnknown_AddRef((IUnknown*)*ppv);
  70         return S_OK;
  71     }
  72
  73     TRACE("Unsupported riid = %s\n", debugstr_guid(riid));
  74     return E_NOINTERFACE;
  75 }
  76
  77 static ULONG WINAPI DownloadBSC_AddRef(IBindStatusCallback *iface)
  78 {
  79     DownloadBSC *This = impl_from_IBindStatusCallback(iface);
  80     LONG ref = InterlockedIncrement(&This->ref);
  81
  82     TRACE("(%p) ref = %d\n", This, ref);
  83
  84     return ref;
  85 }
  86
  87 static ULONG WINAPI DownloadBSC_Release(IBindStatusCallback *iface)
  88 {
  89     DownloadBSC *This = impl_from_IBindStatusCallback(iface);
  90     LONG ref = InterlockedDecrement(&This->ref);
  91
  92     TRACE("(%p) ref = %d\n", This, ref);
  93
  94     if(!ref) {
  95         if(This->callback)
  96             IBindStatusCallback_Release(This->callback);
  97         if(This->binding)
  98             IBinding_Release(This->binding);
  99         heap_free(This->file_name);
 100         heap_free(This->cache_file);
 101         heap_free(This);
 102     }
 103
 104     return ref;
 105 }
 106
 107 static HRESULT WINAPI DownloadBSC_OnStartBinding(IBindStatusCallback *iface,
 108         DWORD dwReserved, IBinding *pbind)
 109 {
 110     DownloadBSC *This = impl_from_IBindStatusCallback(iface);
 111     HRESULT hres = S_OK;
 112
 113     TRACE("(%p)->(%d %p)\n", This, dwReserved, pbind);
 114
 115     if(This->callback) {
 116         hres = IBindStatusCallback_OnStartBinding(This->callback, dwReserved, pbind);
 117
 118         IBinding_AddRef(pbind);
 119         This->binding = pbind;
 120     }
 121
 122     /* Windows seems to ignore E_NOTIMPL if it's returned from the client. */
 123     return hres == E_NOTIMPL ? S_OK : hres;
 124 }
 125
 126 static HRESULT WINAPI DownloadBSC_GetPriority(IBindStatusCallback *iface, LONG *pnPriority)
 127 {
 128     DownloadBSC *This = impl_from_IBindStatusCallback(iface);
 129     FIXME("(%p)->(%p)\n", This, pnPriority);
 130     return E_NOTIMPL;
 131 }
 132
 133 static HRESULT WINAPI DownloadBSC_OnLowResource(IBindStatusCallback *iface, DWORD reserved)
 134 {
 135     DownloadBSC *This = impl_from_IBindStatusCallback(iface);
 136     FIXME("(%p)->(%d)\n", This, reserved);
 137     return E_NOTIMPL;
 138 }
 139
 140 static HRESULT on_progress(DownloadBSC *This, ULONG progress, ULONG progress_max, ULONG status_code, LPCWSTR status_text)
 141 {
 142     HRESULT hres;
 143
 144     if(!This->callback)
 145         return S_OK;
 146
 147     hres = IBindStatusCallback_OnProgress(This->callback, progress, progress_max, status_code, status_text);
 148     if(hres == E_ABORT) {
 149         if(This->binding)
 150             IBinding_Abort(This->binding);
 151         else
 152             FIXME("No binding, not sure what to do!\n");
 153     }
 154
 155     return hres;
 156 }
 157
 158 static HRESULT WINAPI DownloadBSC_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
 159         ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
 160 {
 161     DownloadBSC *This = impl_from_IBindStatusCallback(iface);
 162     HRESULT hres = S_OK;
 163
 164     TRACE("%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
 165             debugstr_w(szStatusText));
 166
 167     switch(ulStatusCode) {
 168     case BINDSTATUS_CONNECTING:
 169     case BINDSTATUS_BEGINDOWNLOADDATA:
 170     case BINDSTATUS_DOWNLOADINGDATA:
 171     case BINDSTATUS_ENDDOWNLOADDATA:
 172     case BINDSTATUS_SENDINGREQUEST:
 173     case BINDSTATUS_MIMETYPEAVAILABLE:
 174         hres = on_progress(This, ulProgress, ulProgressMax, ulStatusCode, szStatusText);
 175         break;
 176
 177     case BINDSTATUS_CACHEFILENAMEAVAILABLE:
 178         hres = on_progress(This, ulProgress, ulProgressMax, ulStatusCode, szStatusText);
 179         This->cache_file = heap_strdupW(szStatusText);
 180         break;
 181
 182     case BINDSTATUS_FINDINGRESOURCE: /* FIXME */
 183         break;
 184
 185     default:
 186         FIXME("Unsupported status %u\n", ulStatusCode);
 187     }
 188
 189     return hres;
 190 }
 191
 192 static HRESULT WINAPI DownloadBSC_OnStopBinding(IBindStatusCallback *iface,
 193         HRESULT hresult, LPCWSTR szError)
 194 {
 195     DownloadBSC *This = impl_from_IBindStatusCallback(iface);
 196     HRESULT hres = S_OK;
 197
 198     TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError));
 199
 200     if(This->file_name) {
 201         if(This->cache_file) {
 202             BOOL b;
 203
 204             b = CopyFileW(This->cache_file, This->file_name, FALSE);
 205             if(!b)
 206                 FIXME("CopyFile failed: %u\n", GetLastError());
 207         }else {
 208             FIXME("No cache file\n");
 209         }
 210     }
 211
 212     if(This->onstop_proc)
 213         hres = This->onstop_proc(This->ctx, This->cache_file, hresult, szError);
 214     else if(This->callback)
 215         IBindStatusCallback_OnStopBinding(This->callback, hresult, szError);
 216
 217     if(This->binding) {
 218         IBinding_Release(This->binding);
 219         This->binding = NULL;
 220     }
 221
 222     return hres;
 223 }
 224
 225 static HRESULT WINAPI DownloadBSC_GetBindInfo(IBindStatusCallback *iface,
 226         DWORD *grfBINDF, BINDINFO *pbindinfo)
 227 {
 228     DownloadBSC *This = impl_from_IBindStatusCallback(iface);
 229     DWORD bindf = 0;
 230
 231     TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
 232
 233     if(This->callback) {
 234         BINDINFO bindinfo;
 235         HRESULT hres;
 236
 237         memset(&bindinfo, 0, sizeof(bindinfo));
 238         bindinfo.cbSize = sizeof(bindinfo);
 239
 240         hres = IBindStatusCallback_GetBindInfo(This->callback, &bindf, &bindinfo);
 241         if(SUCCEEDED(hres))
 242             ReleaseBindInfo(&bindinfo);
 243     }
 244
 245     *grfBINDF = BINDF_PULLDATA | BINDF_NEEDFILE | (bindf & BINDF_ENFORCERESTRICTED) | This->bindf;
 246     return S_OK;
 247 }
 248
 249 static HRESULT WINAPI DownloadBSC_OnDataAvailable(IBindStatusCallback *iface,
 250         DWORD grfBSCF, DWORD dwSize, FORMATETC *pformatetc, STGMEDIUM *pstgmed)
 251 {
 252     DownloadBSC *This = impl_from_IBindStatusCallback(iface);
 253
 254     TRACE("(%p)->(%08x %d %p %p)\n", This, grfBSCF, dwSize, pformatetc, pstgmed);
 255
 256     return S_OK;
 257 }
 258
 259 static HRESULT WINAPI DownloadBSC_OnObjectAvailable(IBindStatusCallback *iface,
 260         REFIID riid, IUnknown *punk)
 261 {
 262     DownloadBSC *This = impl_from_IBindStatusCallback(iface);
 263     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), punk);
 264     return E_NOTIMPL;
 265 }
 266
 267 static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = {
 268     DownloadBSC_QueryInterface,
 269     DownloadBSC_AddRef,
 270     DownloadBSC_Release,
 271     DownloadBSC_OnStartBinding,
 272     DownloadBSC_GetPriority,
 273     DownloadBSC_OnLowResource,
 274     DownloadBSC_OnProgress,
 275     DownloadBSC_OnStopBinding,
 276     DownloadBSC_GetBindInfo,
 277     DownloadBSC_OnDataAvailable,
 278     DownloadBSC_OnObjectAvailable
 279 };
 280
 281 static HRESULT WINAPI DwlServiceProvider_QueryInterface(IServiceProvider *iface,
 282         REFIID riid, void **ppv)
 283 {
 284     DownloadBSC *This = impl_from_IServiceProvider(iface);
 285     return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
 286 }
 287
 288 static ULONG WINAPI DwlServiceProvider_AddRef(IServiceProvider *iface)
 289 {
 290     DownloadBSC *This = impl_from_IServiceProvider(iface);
 291     return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
 292 }
 293
 294 static ULONG WINAPI DwlServiceProvider_Release(IServiceProvider *iface)
 295 {
 296     DownloadBSC *This = impl_from_IServiceProvider(iface);
 297     return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
 298 }
 299
 300 static HRESULT WINAPI DwlServiceProvider_QueryService(IServiceProvider *iface,
 301         REFGUID guidService, REFIID riid, void **ppv)
 302 {
 303     DownloadBSC *This = impl_from_IServiceProvider(iface);
 304     IServiceProvider *serv_prov;
 305     HRESULT hres;
 306
 307     TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
 308
 309     if(!This->callback)
 310         return E_NOINTERFACE;
 311
 312     hres = IBindStatusCallback_QueryInterface(This->callback, riid, ppv);
 313     if(SUCCEEDED(hres))
 314         return S_OK;
 315
 316     hres = IBindStatusCallback_QueryInterface(This->callback, &IID_IServiceProvider, (void**)&serv_prov);
 317     if(SUCCEEDED(hres)) {
 318         hres = IServiceProvider_QueryService(serv_prov, guidService, riid, ppv);
 319         IServiceProvider_Release(serv_prov);
 320         return hres;
 321     }
 322
 323     return E_NOINTERFACE;
 324 }
 325
 326 static const IServiceProviderVtbl ServiceProviderVtbl = {
 327     DwlServiceProvider_QueryInterface,
 328     DwlServiceProvider_AddRef,
 329     DwlServiceProvider_Release,
 330     DwlServiceProvider_QueryService
 331 };
 332
 333 static HRESULT DownloadBSC_Create(IBindStatusCallback *callback, LPCWSTR file_name, DownloadBSC **ret_callback)
 334 {
 335     DownloadBSC *ret;
 336
 337     ret = heap_alloc_zero(sizeof(*ret));
 338     if(!ret)
 339         return E_OUTOFMEMORY;
 340
 341     ret->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl;
 342     ret->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
 343     ret->ref = 1;
 344
 345     if(file_name) {
 346         ret->file_name = heap_strdupW(file_name);
 347         if(!ret->file_name) {
 348             heap_free(ret);
 349             return E_OUTOFMEMORY;
 350         }
 351     }
 352
 353     if(callback)
 354         IBindStatusCallback_AddRef(callback);
 355     ret->callback = callback;
 356
 357     *ret_callback = ret;
 358     return S_OK;
 359 }
 360
 361 HRESULT create_default_callback(IBindStatusCallback **ret)
 362 {
 363     DownloadBSC *callback;
 364     HRESULT hres;
 365
 366     hres = DownloadBSC_Create(NULL, NULL, &callback);
 367     if(FAILED(hres))
 368         return hres;
 369
 370     hres = wrap_callback(&callback->IBindStatusCallback_iface, ret);
 371     IBindStatusCallback_Release(&callback->IBindStatusCallback_iface);
 372     return hres;
 373 }
 374
 375 HRESULT download_to_cache(IUri *uri, stop_cache_binding_proc_t proc, void *ctx, IBindStatusCallback *callback)
 376 {
 377     DownloadBSC *dwl_bsc;
 378     IBindCtx *bindctx;
 379     IMoniker *mon;
 380     IUnknown *unk;
 381     HRESULT hres;
 382
 383     hres = DownloadBSC_Create(callback, NULL, &dwl_bsc);
 384     if(FAILED(hres))
 385         return hres;
 386
 387     dwl_bsc->onstop_proc = proc;
 388     dwl_bsc->ctx = ctx;
 389     dwl_bsc->bindf = BINDF_ASYNCHRONOUS;
 390
 391     hres = CreateAsyncBindCtx(0, &dwl_bsc->IBindStatusCallback_iface, NULL, &bindctx);
 392     IBindStatusCallback_Release(&dwl_bsc->IBindStatusCallback_iface);
 393     if(FAILED(hres))
 394         return hres;
 395
 396     hres = CreateURLMonikerEx2(NULL, uri, &mon, 0);
 397     if(FAILED(hres)) {
 398         IBindCtx_Release(bindctx);
 399         return hres;
 400     }
 401
 402     hres = IMoniker_BindToStorage(mon, bindctx, NULL, &IID_IUnknown, (void**)&unk);
 403     IMoniker_Release(mon);
 404     IBindCtx_Release(bindctx);
 405     if(SUCCEEDED(hres) && unk)
 406         IUnknown_Release(unk);
 407     return hres;
 408
 409 }
 410
 411 /***********************************************************************
 412  *           URLDownloadToFileW (URLMON.@)
 413  *
 414  * Downloads URL szURL to file szFileName and call lpfnCB callback to
 415  * report progress.
 416  *
 417  * PARAMS
 418  *  pCaller    [I] controlling IUnknown interface.
 419  *  szURL      [I] URL of the file to download
 420  *  szFileName [I] file name to store the content of the URL
 421  *  dwReserved [I] reserved - set to 0
 422  *  lpfnCB     [I] callback for progress report
 423  *
 424  * RETURNS
 425  *  S_OK on success
 426  */
 427 HRESULT WINAPI URLDownloadToFileW(LPUNKNOWN pCaller, LPCWSTR szURL, LPCWSTR szFileName,
 428         DWORD dwReserved, LPBINDSTATUSCALLBACK lpfnCB)
 429 {
 430     DownloadBSC *callback;
 431     IUnknown *unk;
 432     IMoniker *mon;
 433     IBindCtx *bindctx;
 434     HRESULT hres;
 435
 436     TRACE("(%p %s %s %d %p)\n", pCaller, debugstr_w(szURL), debugstr_w(szFileName), dwReserved, lpfnCB);
 437
 438     if(pCaller)
 439         FIXME("pCaller not supported\n");
 440
 441     hres = DownloadBSC_Create(lpfnCB, szFileName, &callback);
 442     if(FAILED(hres))
 443         return hres;
 444
 445     hres = CreateAsyncBindCtx(0, &callback->IBindStatusCallback_iface, NULL, &bindctx);
 446     IBindStatusCallback_Release(&callback->IBindStatusCallback_iface);
 447     if(FAILED(hres))
 448         return hres;
 449
 450     hres = CreateURLMoniker(NULL, szURL, &mon);
 451     if(FAILED(hres)) {
 452         IBindCtx_Release(bindctx);
 453         return hres;
 454     }
 455
 456     hres = IMoniker_BindToStorage(mon, bindctx, NULL, &IID_IUnknown, (void**)&unk);
 457     IMoniker_Release(mon);
 458     IBindCtx_Release(bindctx);
 459
 460     if(unk)
 461         IUnknown_Release(unk);
 462
 463     return hres == MK_S_ASYNCHRONOUS ? S_OK : hres;
 464 }
 465
 466 /***********************************************************************
 467  *           URLDownloadToFileA (URLMON.@)
 468  *
 469  * Downloads URL szURL to rile szFileName and call lpfnCB callback to
 470  * report progress.
 471  *
 472  * PARAMS
 473  *  pCaller    [I] controlling IUnknown interface.
 474  *  szURL      [I] URL of the file to download
 475  *  szFileName [I] file name to store the content of the URL
 476  *  dwReserved [I] reserved - set to 0
 477  *  lpfnCB     [I] callback for progress report
 478  *
 479  * RETURNS
 480  *  S_OK on success
 481  */
 482 HRESULT WINAPI URLDownloadToFileA(LPUNKNOWN pCaller, LPCSTR szURL, LPCSTR szFileName, DWORD dwReserved,
 483         LPBINDSTATUSCALLBACK lpfnCB)
 484 {
 485     LPWSTR urlW, file_nameW;
 486     HRESULT hres;
 487
 488     TRACE("(%p %s %s %d %p)\n", pCaller, debugstr_a(szURL), debugstr_a(szFileName), dwReserved, lpfnCB);
 489
 490     urlW = heap_strdupAtoW(szURL);
 491     file_nameW = heap_strdupAtoW(szFileName);
 492
 493     hres = URLDownloadToFileW(pCaller, urlW, file_nameW, dwReserved, lpfnCB);
 494
 495     heap_free(urlW);
 496     heap_free(file_nameW);
 497
 498     return hres;
 499 }