dlls/msxml3/bsc.c

   1 /*
   2  * Copyright 2008 Piotr Caban
   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 #define COBJMACROS
  20 #define NONAMELESSUNION
  21
  22 #include <stdarg.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "ole2.h"
  28 #include "msxml6.h"
  29 #include "wininet.h"
  30 #include "urlmon.h"
  31 #include "winreg.h"
  32 #include "shlwapi.h"
  33
  34 #include "wine/debug.h"
  35
  36 #include "msxml_dispex.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  39
  40 struct bsc_t {
  41     IBindStatusCallback IBindStatusCallback_iface;
  42
  43     LONG ref;
  44
  45     void *obj;
  46     HRESULT (*onDataAvailable)(void*,char*,DWORD);
  47
  48     IBinding *binding;
  49     IStream *memstream;
  50     HRESULT hres;
  51 };
  52
  53 static inline bsc_t *impl_from_IBindStatusCallback( IBindStatusCallback *iface )
  54 {
  55     return CONTAINING_RECORD(iface, bsc_t, IBindStatusCallback_iface);
  56 }
  57
  58 static HRESULT WINAPI bsc_QueryInterface(
  59     IBindStatusCallback *iface,
  60     REFIID riid,
  61     LPVOID *ppobj )
  62 {
  63     if (IsEqualGUID(riid, &IID_IUnknown) ||
  64         IsEqualGUID(riid, &IID_IBindStatusCallback))
  65     {
  66         IBindStatusCallback_AddRef( iface );
  67         *ppobj = iface;
  68         return S_OK;
  69     }
  70
  71     TRACE("interface %s not implemented\n", debugstr_guid(riid));
  72     *ppobj = NULL;
  73     return E_NOINTERFACE;
  74 }
  75
  76 static ULONG WINAPI bsc_AddRef(
  77     IBindStatusCallback *iface )
  78 {
  79     bsc_t *bsc = impl_from_IBindStatusCallback(iface);
  80     LONG ref = InterlockedIncrement(&bsc->ref);
  81
  82     TRACE("%p, refcount %ld.\n", iface, ref);
  83
  84     return ref;
  85 }
  86
  87 static ULONG WINAPI bsc_Release(
  88     IBindStatusCallback *iface )
  89 {
  90     bsc_t *bsc = impl_from_IBindStatusCallback(iface);
  91     LONG ref = InterlockedDecrement(&bsc->ref);
  92
  93     TRACE("%p, refcount %ld.\n", iface, ref);
  94
  95     if (!ref)
  96     {
  97         if (bsc->binding)
  98             IBinding_Release(bsc->binding);
  99         if (bsc->memstream)
 100             IStream_Release(bsc->memstream);
 101         heap_free(bsc);
 102     }
 103
 104     return ref;
 105 }
 106
 107 static HRESULT WINAPI bsc_OnStartBinding(
 108         IBindStatusCallback* iface,
 109         DWORD dwReserved,
 110         IBinding* pib)
 111 {
 112     bsc_t *This = impl_from_IBindStatusCallback(iface);
 113     HRESULT hr;
 114
 115     TRACE("%p, %lx, %p.\n", iface, dwReserved, pib);
 116
 117     This->binding = pib;
 118     IBinding_AddRef(pib);
 119
 120     hr = CreateStreamOnHGlobal(NULL, TRUE, &This->memstream);
 121     if(FAILED(hr))
 122         return hr;
 123
 124     return S_OK;
 125 }
 126
 127 static HRESULT WINAPI bsc_GetPriority(
 128         IBindStatusCallback* iface,
 129         LONG* pnPriority)
 130 {
 131     return S_OK;
 132 }
 133
 134 static HRESULT WINAPI bsc_OnLowResource(
 135         IBindStatusCallback* iface,
 136         DWORD reserved)
 137 {
 138     return S_OK;
 139 }
 140
 141 static HRESULT WINAPI bsc_OnProgress(
 142         IBindStatusCallback* iface,
 143         ULONG ulProgress,
 144         ULONG ulProgressMax,
 145         ULONG ulStatusCode,
 146         LPCWSTR szStatusText)
 147 {
 148     return S_OK;
 149 }
 150
 151 static HRESULT WINAPI bsc_OnStopBinding(
 152         IBindStatusCallback* iface,
 153         HRESULT hresult,
 154         LPCWSTR szError)
 155 {
 156     bsc_t *This = impl_from_IBindStatusCallback(iface);
 157     HRESULT hr = S_OK;
 158
 159     TRACE("%p, %#lx, %s.\n", iface, hresult, debugstr_w(szError));
 160
 161     if(This->binding) {
 162         IBinding_Release(This->binding);
 163         This->binding = NULL;
 164     }
 165
 166     if(This->obj && SUCCEEDED(hresult)) {
 167         HGLOBAL hglobal;
 168         hr = GetHGlobalFromStream(This->memstream, &hglobal);
 169         if(SUCCEEDED(hr))
 170         {
 171             DWORD len = GlobalSize(hglobal);
 172             char *ptr = GlobalLock(hglobal);
 173
 174             This->hres = This->onDataAvailable(This->obj, ptr, len);
 175
 176             GlobalUnlock(hglobal);
 177         }
 178     }
 179
 180     return hr;
 181 }
 182
 183 static HRESULT WINAPI bsc_GetBindInfo(
 184         IBindStatusCallback* iface,
 185         DWORD* grfBINDF,
 186         BINDINFO* pbindinfo)
 187 {
 188     *grfBINDF = BINDF_GETNEWESTVERSION|BINDF_PULLDATA|BINDF_RESYNCHRONIZE|BINDF_PRAGMA_NO_CACHE;
 189
 190     return S_OK;
 191 }
 192
 193 static HRESULT WINAPI bsc_OnDataAvailable(
 194         IBindStatusCallback* iface,
 195         DWORD grfBSCF,
 196         DWORD dwSize,
 197         FORMATETC* pformatetc,
 198         STGMEDIUM* pstgmed)
 199 {
 200     bsc_t *bsc = impl_from_IBindStatusCallback(iface);
 201     BYTE buf[4096];
 202     DWORD read, written;
 203     HRESULT hr;
 204
 205     TRACE("%p, %lx, %lu, %p, %p.\n", iface, grfBSCF, dwSize, pformatetc, pstgmed);
 206
 207     do
 208     {
 209         hr = IStream_Read(pstgmed->u.pstm, buf, sizeof(buf), &read);
 210         if(FAILED(hr))
 211             break;
 212
 213         hr = IStream_Write(bsc->memstream, buf, read, &written);
 214     } while(SUCCEEDED(hr) && written != 0 && read != 0);
 215
 216     return S_OK;
 217 }
 218
 219 static HRESULT WINAPI bsc_OnObjectAvailable(
 220         IBindStatusCallback* iface,
 221         REFIID riid,
 222         IUnknown* punk)
 223 {
 224     return S_OK;
 225 }
 226
 227 static const struct IBindStatusCallbackVtbl bsc_vtbl =
 228 {
 229     bsc_QueryInterface,
 230     bsc_AddRef,
 231     bsc_Release,
 232     bsc_OnStartBinding,
 233     bsc_GetPriority,
 234     bsc_OnLowResource,
 235     bsc_OnProgress,
 236     bsc_OnStopBinding,
 237     bsc_GetBindInfo,
 238     bsc_OnDataAvailable,
 239     bsc_OnObjectAvailable
 240 };
 241
 242 HRESULT create_uri(IUri *base, const WCHAR *url, IUri **uri)
 243 {
 244     WCHAR fileUrl[INTERNET_MAX_URL_LENGTH];
 245     HRESULT hr;
 246
 247     TRACE("%s\n", debugstr_w(url));
 248
 249     if (!PathIsURLW(url))
 250     {
 251         WCHAR fullpath[MAX_PATH];
 252         DWORD needed = ARRAY_SIZE(fileUrl);
 253
 254         lstrcpynW(fileUrl, url, ARRAY_SIZE(fileUrl));
 255         UrlUnescapeW(fileUrl, NULL, NULL, URL_UNESCAPE_INPLACE);
 256
 257         if (!PathSearchAndQualifyW(fileUrl, fullpath, ARRAY_SIZE(fullpath)))
 258         {
 259             WARN("can't find path\n");
 260             return E_FAIL;
 261         }
 262
 263         if (FAILED(UrlApplySchemeW(fullpath, fileUrl, &needed, URL_APPLY_GUESSSCHEME | URL_APPLY_GUESSFILE |
 264                 URL_APPLY_DEFAULT)))
 265         {
 266             ERR("Failed to apply url scheme.\n");
 267             return E_FAIL;
 268         }
 269         url = fileUrl;
 270     }
 271
 272     hr = CreateUri(url, Uri_CREATE_ALLOW_RELATIVE | Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME, 0, uri);
 273     if (hr == S_OK && base)
 274     {
 275         IUri *rebased_uri;
 276
 277         hr = CoInternetCombineIUri(base, *uri, 0, &rebased_uri, 0);
 278         IUri_Release(*uri);
 279         *uri = rebased_uri;
 280     }
 281
 282     return hr;
 283 }
 284
 285 HRESULT create_moniker_from_url(LPCWSTR url, IMoniker **mon)
 286 {
 287     HRESULT hr;
 288     IUri *uri;
 289
 290     TRACE("%s\n", debugstr_w(url));
 291
 292     if (FAILED(hr = create_uri(NULL, url, &uri)))
 293         return hr;
 294
 295     hr = CreateURLMonikerEx2(NULL, uri, mon, 0);
 296     IUri_Release(uri);
 297     return hr;
 298 }
 299
 300 HRESULT bind_url(IMoniker *mon, HRESULT (*onDataAvailable)(void*,char*,DWORD),
 301         void *obj, bsc_t **ret)
 302 {
 303     bsc_t *bsc;
 304     IBindCtx *pbc;
 305     HRESULT hr;
 306
 307     TRACE("%p\n", mon);
 308
 309     hr = CreateBindCtx(0, &pbc);
 310     if(FAILED(hr))
 311         return hr;
 312
 313     bsc = heap_alloc(sizeof(bsc_t));
 314
 315     bsc->IBindStatusCallback_iface.lpVtbl = &bsc_vtbl;
 316     bsc->ref = 1;
 317     bsc->obj = obj;
 318     bsc->onDataAvailable = onDataAvailable;
 319     bsc->binding = NULL;
 320     bsc->memstream = NULL;
 321     bsc->hres = S_OK;
 322
 323     hr = RegisterBindStatusCallback(pbc, &bsc->IBindStatusCallback_iface, NULL, 0);
 324     if(SUCCEEDED(hr))
 325     {
 326         IStream *stream;
 327         hr = IMoniker_BindToStorage(mon, pbc, NULL, &IID_IStream, (LPVOID*)&stream);
 328         if(stream)
 329             IStream_Release(stream);
 330         IBindCtx_Release(pbc);
 331     }
 332
 333     if(FAILED(hr))
 334     {
 335         IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
 336         bsc = NULL;
 337     }
 338
 339     *ret = bsc;
 340     return hr;
 341 }
 342
 343 HRESULT detach_bsc(bsc_t *bsc)
 344 {
 345     HRESULT hres;
 346
 347     if(bsc->binding)
 348         IBinding_Abort(bsc->binding);
 349
 350     bsc->obj = NULL;
 351     hres = bsc->hres;
 352     IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
 353
 354     return hres;
 355 }