dlls/urlmon/umon.c

   1 /*
   2  * UrlMon
   3  *
   4  * Copyright 1999 Ulrich Czekalla for Corel Corporation
   5  * Copyright 2002 Huw D M Davies for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #define COM_NO_WINDOWS_H
  23 #include <stdio.h>
  24
  25 #define NONAMELESSUNION
  26 #define NONAMELESSSTRUCT
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winternl.h"
  30 #include "winuser.h"
  31 #include "objbase.h"
  32 #include "wine/debug.h"
  33 #include "wine/unicode.h"
  34 #include "ole2.h"
  35 #include "urlmon.h"
  36 #include "wininet.h"
  37 #include "urlmon_main.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  40
  41 /* native urlmon.dll uses this key, too */
  42 static WCHAR BSCBHolder[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
  43
  44 /*static BOOL registered_wndclass = FALSE;*/
  45
  46 /* filemoniker data structure */
  47 typedef struct URLMonikerImpl{
  48
  49     ICOM_VTABLE(IMoniker)*  lpvtbl1;  /* VTable relative to the IMoniker interface.*/
  50     ICOM_VTABLE(IBinding)*  lpvtbl2;  /* VTable to IBinding interface */
  51
  52     ULONG ref; /* reference counter for this object */
  53
  54     LPOLESTR URLName; /* URL string identified by this URLmoniker */
  55
  56     HWND hwndCallback;
  57     IBindCtx *pBC;
  58     HINTERNET hinternet, hconnect, hrequest;
  59 } URLMonikerImpl;
  60
  61 /********************************************************************************/
  62 /* URLMoniker prototype functions :                                            */
  63
  64 /* IUnknown prototype functions */
  65 static HRESULT WINAPI URLMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject);
  66 static ULONG   WINAPI URLMonikerImpl_AddRef(IMoniker* iface);
  67 static ULONG   WINAPI URLMonikerImpl_Release(IMoniker* iface);
  68
  69 /* IPersist prototype functions */
  70 static HRESULT WINAPI URLMonikerImpl_GetClassID(IMoniker* iface, CLSID *pClassID);
  71
  72 /* IPersistStream prototype functions */
  73 static HRESULT WINAPI URLMonikerImpl_IsDirty(IMoniker* iface);
  74 static HRESULT WINAPI URLMonikerImpl_Load(IMoniker* iface, IStream* pStm);
  75 static HRESULT WINAPI URLMonikerImpl_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty);
  76 static HRESULT WINAPI URLMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize);
  77
  78 /* IMoniker prototype functions */
  79 static HRESULT WINAPI URLMonikerImpl_BindToObject(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
  80 static HRESULT WINAPI URLMonikerImpl_BindToStorage(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, REFIID riid, VOID** ppvResult);
  81 static HRESULT WINAPI URLMonikerImpl_Reduce(IMoniker* iface,IBindCtx* pbc, DWORD dwReduceHowFar,IMoniker** ppmkToLeft, IMoniker** ppmkReduced);
  82 static HRESULT WINAPI URLMonikerImpl_ComposeWith(IMoniker* iface,IMoniker* pmkRight,BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite);
  83 static HRESULT WINAPI URLMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker);
  84 static HRESULT WINAPI URLMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker);
  85 static HRESULT WINAPI URLMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash);
  86 static HRESULT WINAPI URLMonikerImpl_IsRunning(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning);
  87 static HRESULT WINAPI URLMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft, FILETIME* pFileTime);
  88 static HRESULT WINAPI URLMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk);
  89 static HRESULT WINAPI URLMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther, IMoniker** ppmkPrefix);
  90 static HRESULT WINAPI URLMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath);
  91 static HRESULT WINAPI URLMonikerImpl_GetDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName);
  92 static HRESULT WINAPI URLMonikerImpl_ParseDisplayName(IMoniker* iface,IBindCtx* pbc, IMoniker* pmkToLeft, LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut);
  93 static HRESULT WINAPI URLMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys);
  94
  95 /* IBinding interface to moniker */
  96 static HRESULT WINAPI URLMonikerImpl_IBinding_QueryInterface(IBinding* iface,REFIID riid,void** ppvObject);
  97 static ULONG WINAPI URLMonikerImpl_IBinding_AddRef(IBinding* iface);
  98 static ULONG WINAPI URLMonikerImpl_IBinding_Release(IBinding* iface);
  99 static HRESULT WINAPI URLMonikerImpl_IBinding_Abort(IBinding* iface);
 100 static HRESULT WINAPI URLMonikerImpl_IBinding_Suspend(IBinding* iface);
 101 static HRESULT WINAPI URLMonikerImpl_IBinding_Resume(IBinding* iface);
 102 static HRESULT WINAPI URLMonikerImpl_IBinding_SetPriority(IBinding* iface, LONG nPriority);
 103 static HRESULT WINAPI URLMonikerImpl_IBinding_GetPriority(IBinding* iface, LONG* pnPriority);
 104 static HRESULT WINAPI URLMonikerImpl_IBinding_GetBindResult(IBinding* iface, CLSID* pclsidProtocol, DWORD* pdwResult, LPOLESTR* pszResult, DWORD* pdwReserved);
 105
 106 /* Local function used by urlmoniker implementation */
 107 static HRESULT URLMonikerImpl_Construct(URLMonikerImpl* iface, LPCOLESTR lpszURL);
 108 static HRESULT URLMonikerImpl_Destroy(URLMonikerImpl* iface);
 109
 110 /********************************************************************************/
 111 /* Virtual function table for the URLMonikerImpl class which  include IPersist,*/
 112 /* IPersistStream and IMoniker functions.                                       */
 113 static ICOM_VTABLE(IMoniker) VT_URLMonikerImpl =
 114 {
 115     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 116     URLMonikerImpl_QueryInterface,
 117     URLMonikerImpl_AddRef,
 118     URLMonikerImpl_Release,
 119     URLMonikerImpl_GetClassID,
 120     URLMonikerImpl_IsDirty,
 121     URLMonikerImpl_Load,
 122     URLMonikerImpl_Save,
 123     URLMonikerImpl_GetSizeMax,
 124     URLMonikerImpl_BindToObject,
 125     URLMonikerImpl_BindToStorage,
 126     URLMonikerImpl_Reduce,
 127     URLMonikerImpl_ComposeWith,
 128     URLMonikerImpl_Enum,
 129     URLMonikerImpl_IsEqual,
 130     URLMonikerImpl_Hash,
 131     URLMonikerImpl_IsRunning,
 132     URLMonikerImpl_GetTimeOfLastChange,
 133     URLMonikerImpl_Inverse,
 134     URLMonikerImpl_CommonPrefixWith,
 135     URLMonikerImpl_RelativePathTo,
 136     URLMonikerImpl_GetDisplayName,
 137     URLMonikerImpl_ParseDisplayName,
 138     URLMonikerImpl_IsSystemMoniker
 139 };
 140
 141 static ICOM_VTABLE(IBinding) VTBinding_URLMonikerImpl =
 142 {
 143     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 144     URLMonikerImpl_IBinding_QueryInterface,
 145     URLMonikerImpl_IBinding_AddRef,
 146     URLMonikerImpl_IBinding_Release,
 147     URLMonikerImpl_IBinding_Abort,
 148     URLMonikerImpl_IBinding_Suspend,
 149     URLMonikerImpl_IBinding_Resume,
 150     URLMonikerImpl_IBinding_SetPriority,
 151     URLMonikerImpl_IBinding_GetPriority,
 152     URLMonikerImpl_IBinding_GetBindResult
 153 };
 154
 155
 156 /*******************************************************************************
 157  *        URLMoniker_QueryInterface
 158  *******************************************************************************/
 159 static HRESULT WINAPI URLMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
 160 {
 161     ICOM_THIS(URLMonikerImpl,iface);
 162
 163     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppvObject);
 164
 165     /* Perform a sanity check on the parameters.*/
 166     if ( (This==0) || (ppvObject==0) )
 167         return E_INVALIDARG;
 168
 169     /* Initialize the return parameter */
 170     *ppvObject = 0;
 171
 172     /* Compare the riid with the interface IDs implemented by this object.*/
 173     if (IsEqualIID(&IID_IUnknown, riid)      ||
 174         IsEqualIID(&IID_IPersist, riid)      ||
 175         IsEqualIID(&IID_IPersistStream,riid) ||
 176         IsEqualIID(&IID_IMoniker, riid)
 177        )
 178         *ppvObject = iface;
 179
 180     /* Check that we obtained an interface.*/
 181     if ((*ppvObject)==0)
 182         return E_NOINTERFACE;
 183
 184     /* Query Interface always increases the reference count by one when it is successful */
 185     URLMonikerImpl_AddRef(iface);
 186
 187     return S_OK;
 188 }
 189
 190 /******************************************************************************
 191  *        URLMoniker_AddRef
 192  ******************************************************************************/
 193 static ULONG WINAPI URLMonikerImpl_AddRef(IMoniker* iface)
 194 {
 195     ICOM_THIS(URLMonikerImpl,iface);
 196
 197     TRACE("(%p)\n",This);
 198
 199     return ++(This->ref);
 200 }
 201
 202 /******************************************************************************
 203  *        URLMoniker_Release
 204  ******************************************************************************/
 205 static ULONG WINAPI URLMonikerImpl_Release(IMoniker* iface)
 206 {
 207     ICOM_THIS(URLMonikerImpl,iface);
 208
 209     TRACE("(%p)\n",This);
 210
 211     This->ref--;
 212
 213     /* destroy the object if there's no more reference on it */
 214     if (This->ref==0){
 215
 216         URLMonikerImpl_Destroy(This);
 217
 218         return 0;
 219     }
 220     return This->ref;
 221 }
 222
 223 /******************************************************************************
 224  *        URLMoniker_GetClassID
 225  ******************************************************************************/
 226 static HRESULT WINAPI URLMonikerImpl_GetClassID(IMoniker* iface,
 227                                                 CLSID *pClassID)/* Pointer to CLSID of object */
 228 {
 229     ICOM_THIS(URLMonikerImpl,iface);
 230
 231     FIXME("(%p)->(%p): stub\n",This,pClassID);
 232
 233     if (pClassID==NULL)
 234         return E_POINTER;
 235
 236     return E_NOTIMPL;
 237 }
 238
 239 /******************************************************************************
 240  *        URLMoniker_IsDirty
 241  ******************************************************************************/
 242 static HRESULT WINAPI URLMonikerImpl_IsDirty(IMoniker* iface)
 243 {
 244     ICOM_THIS(URLMonikerImpl,iface);
 245     /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
 246        method in the OLE-provided moniker interfaces always return S_FALSE because
 247        their internal state never changes. */
 248
 249     TRACE("(%p)\n",This);
 250
 251     return S_FALSE;
 252 }
 253
 254 /******************************************************************************
 255  *        URLMoniker_Load
 256  ******************************************************************************/
 257 static HRESULT WINAPI URLMonikerImpl_Load(IMoniker* iface,IStream* pStm)
 258 {
 259     ICOM_THIS(URLMonikerImpl,iface);
 260
 261     FIXME("(%p)->(%p): stub\n",This,pStm);
 262
 263     return E_NOTIMPL;
 264 }
 265
 266 /******************************************************************************
 267  *        URLMoniker_Save
 268  ******************************************************************************/
 269 static HRESULT WINAPI URLMonikerImpl_Save(IMoniker* iface,
 270                                           IStream* pStm,/* pointer to the stream where the object is to be saved */
 271                                           BOOL fClearDirty)/* Specifies whether to clear the dirty flag */
 272 {
 273     ICOM_THIS(URLMonikerImpl,iface);
 274
 275     FIXME("(%p)->(%p,%d): stub\n",This,pStm,fClearDirty);
 276
 277     return E_NOTIMPL;
 278
 279 }
 280
 281 /******************************************************************************
 282  *        URLMoniker_GetSizeMax
 283  ******************************************************************************/
 284 static HRESULT WINAPI URLMonikerImpl_GetSizeMax(IMoniker* iface,
 285                                                 ULARGE_INTEGER* pcbSize)/* Pointer to size of stream needed to save object */
 286 {
 287     ICOM_THIS(URLMonikerImpl,iface);
 288
 289     FIXME("(%p)->(%p): stub\n",This,pcbSize);
 290
 291     return E_NOTIMPL;
 292 }
 293
 294 /******************************************************************************
 295  *         URLMoniker_Construct (local function)
 296  *******************************************************************************/
 297 static HRESULT URLMonikerImpl_Construct(URLMonikerImpl* This, LPCOLESTR lpszURLName)
 298 {
 299     int sizeStr = strlenW(lpszURLName);
 300
 301     TRACE("(%p,%s)\n",This,debugstr_w(lpszURLName));
 302     memset(This, 0, sizeof(*This));
 303
 304     /* Initialize the virtual fgunction table. */
 305     This->lpvtbl1      = &VT_URLMonikerImpl;
 306     This->lpvtbl2      = &VTBinding_URLMonikerImpl;
 307     This->ref          = 0;
 308
 309     This->URLName=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(sizeStr+1));
 310
 311     if (This->URLName==NULL)
 312         return E_OUTOFMEMORY;
 313
 314     strcpyW(This->URLName,lpszURLName);
 315
 316     return S_OK;
 317 }
 318
 319
 320
 321 /******************************************************************************
 322  *        URLMoniker_Destroy (local function)
 323  *******************************************************************************/
 324 static HRESULT URLMonikerImpl_Destroy(URLMonikerImpl* This)
 325 {
 326     TRACE("(%p)\n",This);
 327
 328     if (This->URLName!=NULL)
 329             HeapFree(GetProcessHeap(),0,This->URLName);
 330
 331     HeapFree(GetProcessHeap(),0,This);
 332
 333     return S_OK;
 334 }
 335
 336 /******************************************************************************
 337  *                  URLMoniker_BindToObject
 338  ******************************************************************************/
 339 static HRESULT WINAPI URLMonikerImpl_BindToObject(IMoniker* iface,
 340                                                   IBindCtx* pbc,
 341                                                   IMoniker* pmkToLeft,
 342                                                   REFIID riid,
 343                                                   VOID** ppvResult)
 344 {
 345     ICOM_THIS(URLMonikerImpl,iface);
 346
 347     *ppvResult=0;
 348
 349     FIXME("(%p)->(%p,%p,%s,%p): stub\n",This,pbc,pmkToLeft,debugstr_guid(riid),
 350           ppvResult);
 351
 352     return E_NOTIMPL;
 353 }
 354
 355 typedef struct {
 356     enum {OnProgress, OnDataAvailable} callback;
 357 } URLMON_CallbackData;
 358
 359
 360 #if 0
 361 static LRESULT CALLBACK URLMON_WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
 362 {
 363     return DefWindowProcA(hwnd, msg, wparam, lparam);
 364 }
 365
 366 static void PostOnProgress(URLMonikerImpl *This, UINT progress, UINT maxprogress, DWORD status, LPCWSTR *str)
 367 {
 368 }
 369
 370 static void CALLBACK URLMON_InternetCallback(HINTERNET hinet, /*DWORD_PTR*/ DWORD context, DWORD status,
 371                                              void *status_info, DWORD status_info_len)
 372 {
 373     URLMonikerImpl *This = (URLMonikerImpl *)context;
 374     TRACE("handle %p this %p status %08lx\n", hinet, This, status);
 375
 376     if(This->filesize == -1) {
 377         switch(status) {
 378         case INTERNET_STATUS_RESOLVING_NAME:
 379             PostOnProgess(This, 0, 0, BINDSTATUS_FINDINGRESOURCE, status_info);
 380             break;
 381         case INTERNET_STATUS_CONNECTING_TO_SERVER:
 382             PostOnProgress(This, 0, 0, BINDSTATUS_CONNECTING, NULL);
 383             break;
 384         case INTERNET_STATUS_SENDING_REQUEST:
 385             PostOnProgress(This, 0, 0, BINDSTATUS_SENDINGREQUEST, NULL);
 386             break;
 387         case INTERNET_REQUEST_COMPLETE:
 388           {
 389               DWORD len, lensz = sizeof(len);
 390
 391             HttpQueryInfoW(hrequest, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, &len, &lensz, NULL);
 392             TRACE("res = %ld gle = %08lx url len = %ld\n", hres, GetLastError(), len);
 393             This->filesize = len;
 394             break;
 395           }
 396         }
 397     }
 398
 399     return;
 400 }
 401 #endif
 402 /******************************************************************************
 403  *        URLMoniker_BindToStorage
 404  ******************************************************************************/
 405 static HRESULT WINAPI URLMonikerImpl_BindToStorage(IMoniker* iface,
 406                                                    IBindCtx* pbc,
 407                                                    IMoniker* pmkToLeft,
 408                                                    REFIID riid,
 409                                                    VOID** ppvObject)
 410 {
 411     ICOM_THIS(URLMonikerImpl,iface);
 412     HRESULT hres;
 413     IBindStatusCallback *pbscb;
 414     BINDINFO bi;
 415     DWORD bindf;
 416
 417     FIXME("(%p)->(%p,%p,%s,%p): stub\n",This,pbc,pmkToLeft,debugstr_guid(riid),ppvObject);
 418     if(pmkToLeft) {
 419         FIXME("pmkToLeft != NULL\n");
 420         return E_NOTIMPL;
 421     }
 422     if(!IsEqualIID(&IID_IStream, riid)) {
 423         FIXME("unsupported iid\n");
 424         return E_NOTIMPL;
 425     }
 426
 427     /* FIXME This is a bad hack (tm).  We should clearly download to a temporary file.
 428        We also need to implement IStream ourselves so that IStream_Read can return
 429        E_PENDING */
 430
 431     hres = CreateStreamOnHGlobal(0, TRUE, (IStream**)ppvObject);
 432
 433
 434     if(SUCCEEDED(hres)) {
 435         TRACE("Created dummy stream...\n");
 436
 437         hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, (IUnknown**)&pbscb);
 438         if(SUCCEEDED(hres)) {
 439             TRACE("Got IBindStatusCallback...\n");
 440
 441             memset(&bi, 0, sizeof(bi));
 442             bi.cbSize = sizeof(bi);
 443             bindf = 0;
 444             hres = IBindStatusCallback_GetBindInfo(pbscb, &bindf, &bi);
 445             if(SUCCEEDED(hres)) {
 446                 URL_COMPONENTSW url;
 447                 WCHAR *host, *path;
 448                 DWORD len, lensz = sizeof(len), total_read = 0;
 449                 LARGE_INTEGER last_read_pos;
 450                 FORMATETC fmt;
 451                 STGMEDIUM stg;
 452
 453                 TRACE("got bindinfo. bindf = %08lx extrainfo = %s bindinfof = %08lx bindverb = %08lx iid %s\n",
 454                       bindf, debugstr_w(bi.szExtraInfo), bi.grfBindInfoF, bi.dwBindVerb, debugstr_guid(&bi.iid));
 455                 hres = IBindStatusCallback_OnStartBinding(pbscb, 0, (IBinding*)&This->lpvtbl2);
 456                 TRACE("OnStartBinding rets %08lx\n", hres);
 457
 458 #if 0
 459                 if(!registered_wndclass) {
 460                     WNDCLASSA urlmon_wndclass = {0, URLMON_WndProc,0, 0, URLMON_hInstance, 0, 0, 0, NULL, "URLMON_Callback_Window_Class"};
 461                     RegisterClassA(&urlmon_wndclass);
 462                     registered_wndclass = TRUE;
 463                 }
 464
 465                 This->hwndCallback = CreateWindowA("URLMON_Callback_Window_Class", NULL, 0, 0, 0, 0, 0, 0, 0,
 466                                                    URLMON_hInstance, NULL);
 467
 468 #endif
 469                 memset(&url, 0, sizeof(url));
 470                 url.dwStructSize = sizeof(url);
 471                 url.dwSchemeLength = url.dwHostNameLength = url.dwUrlPathLength = 1;
 472                 InternetCrackUrlW(This->URLName, 0, 0, &url);
 473                 host = HeapAlloc(GetProcessHeap(), 0, (url.dwHostNameLength + 1) * sizeof(WCHAR));
 474                 memcpy(host, url.lpszHostName, url.dwHostNameLength * sizeof(WCHAR));
 475                 host[url.dwHostNameLength] = '\0';
 476                 path = HeapAlloc(GetProcessHeap(), 0, (url.dwUrlPathLength + 1) * sizeof(WCHAR));
 477                 memcpy(path, url.lpszUrlPath, url.dwUrlPathLength * sizeof(WCHAR));
 478                 path[url.dwUrlPathLength] = '\0';
 479
 480                 This->hinternet = InternetOpenA("User Agent", 0, NULL, NULL, 0 /*INTERNET_FLAG_ASYNC*/);
 481 /*              InternetSetStatusCallback(This->hinternet, URLMON_InternetCallback);*/
 482
 483                 This->hconnect = InternetConnectW(This->hinternet, host, INTERNET_DEFAULT_HTTP_PORT, NULL, NULL,
 484                                             INTERNET_SERVICE_HTTP, 0, (DWORD)This);
 485                 This->hrequest = HttpOpenRequestW(This->hconnect, NULL, path, NULL, NULL, NULL, 0, (DWORD)This);
 486
 487                 hres = IBindStatusCallback_OnProgress(pbscb, 0, 0, 0x22, NULL);
 488                 hres = IBindStatusCallback_OnProgress(pbscb, 0, 0, BINDSTATUS_FINDINGRESOURCE, NULL);
 489                 hres = IBindStatusCallback_OnProgress(pbscb, 0, 0, BINDSTATUS_CONNECTING, NULL);
 490                 hres = IBindStatusCallback_OnProgress(pbscb, 0, 0, BINDSTATUS_SENDINGREQUEST, NULL);
 491                 hres = E_OUTOFMEMORY; /* FIXME */
 492                 if(HttpSendRequestW(This->hrequest, NULL, 0, NULL, 0)) {
 493
 494                     len = 0;
 495                     HttpQueryInfoW(This->hrequest, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, &len, &lensz, NULL);
 496
 497                     TRACE("res = %ld gle = %08lx url len = %ld\n", hres, GetLastError(), len);
 498
 499                     last_read_pos.s.LowPart = last_read_pos.s.HighPart = 0;
 500                     fmt.cfFormat = 0;
 501                     fmt.ptd = NULL;
 502                     fmt.dwAspect = 0;
 503                     fmt.lindex = -1;
 504                     fmt.tymed = TYMED_ISTREAM;
 505                     stg.tymed = TYMED_ISTREAM;
 506                     stg.u.pstm = *(IStream**)ppvObject;
 507                     stg.pUnkForRelease = NULL;
 508
 509                     while(1) {
 510                         char buf[4096];
 511                         DWORD bufread;
 512                         DWORD written;
 513                         if(InternetReadFile(This->hrequest, buf, sizeof(buf), &bufread)) {
 514                             TRACE("read %ld bytes %s...\n", bufread, debugstr_an(buf, 10));
 515                             if(bufread == 0) break;
 516                             IStream_Write(*(IStream**)ppvObject, buf, bufread, &written);
 517                             total_read += bufread;
 518                             IStream_Seek(*(IStream**)ppvObject, last_read_pos, STREAM_SEEK_SET, NULL);
 519                             hres = IBindStatusCallback_OnProgress(pbscb, total_read, len, (total_read == bufread) ?
 520                                                                   BINDSTATUS_BEGINDOWNLOADDATA :
 521                                                                   BINDSTATUS_DOWNLOADINGDATA, NULL);
 522                             hres = IBindStatusCallback_OnDataAvailable(pbscb,
 523                                                                        (total_read == bufread) ? BSCF_FIRSTDATANOTIFICATION :
 524                                                                        BSCF_INTERMEDIATEDATANOTIFICATION,
 525                                                                        total_read, &fmt, &stg);
 526                             last_read_pos.s.LowPart += bufread; /* FIXME */
 527                         } else
 528                             break;
 529                     }
 530                     hres = IBindStatusCallback_OnProgress(pbscb, total_read, len, BINDSTATUS_ENDDOWNLOADDATA, NULL);
 531                     hres = IBindStatusCallback_OnDataAvailable(pbscb, BSCF_LASTDATANOTIFICATION, total_read, &fmt, &stg);
 532                     TRACE("OnDataAvail rets %08lx\n", hres);
 533                     hres = IBindStatusCallback_OnStopBinding(pbscb, S_OK, NULL);
 534                     TRACE("OnStop rets %08lx\n", hres);
 535                     hres = S_OK;
 536                 }
 537                 InternetCloseHandle(This->hrequest);
 538                 InternetCloseHandle(This->hconnect);
 539                 InternetCloseHandle(This->hinternet);
 540             }
 541         }
 542     }
 543     return hres;
 544 }
 545
 546 /******************************************************************************
 547  *        URLMoniker_Reduce
 548  ******************************************************************************/
 549 static HRESULT WINAPI URLMonikerImpl_Reduce(IMoniker* iface,
 550                                             IBindCtx* pbc,
 551                                             DWORD dwReduceHowFar,
 552                                             IMoniker** ppmkToLeft,
 553                                             IMoniker** ppmkReduced)
 554 {
 555     ICOM_THIS(URLMonikerImpl,iface);
 556     FIXME("(%p)->(%p,%ld,%p,%p): stub\n",This,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
 557
 558     return E_NOTIMPL;
 559 }
 560
 561 /******************************************************************************
 562  *        URLMoniker_ComposeWith
 563  ******************************************************************************/
 564 static HRESULT WINAPI URLMonikerImpl_ComposeWith(IMoniker* iface,
 565                                                  IMoniker* pmkRight,
 566                                                  BOOL fOnlyIfNotGeneric,
 567                                                  IMoniker** ppmkComposite)
 568 {
 569     ICOM_THIS(URLMonikerImpl,iface);
 570     FIXME("(%p)->(%p,%d,%p): stub\n",This,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
 571
 572     return E_NOTIMPL;
 573 }
 574
 575 /******************************************************************************
 576  *        URLMoniker_Enum
 577  ******************************************************************************/
 578 static HRESULT WINAPI URLMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
 579 {
 580     ICOM_THIS(URLMonikerImpl,iface);
 581     FIXME("(%p)->(%d,%p): stub\n",This,fForward,ppenumMoniker);
 582
 583     return E_NOTIMPL;
 584 }
 585
 586 /******************************************************************************
 587  *        URLMoniker_IsEqual
 588  ******************************************************************************/
 589 static HRESULT WINAPI URLMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
 590 {
 591     ICOM_THIS(URLMonikerImpl,iface);
 592     FIXME("(%p)->(%p): stub\n",This,pmkOtherMoniker);
 593
 594     return E_NOTIMPL;
 595 }
 596
 597
 598 /******************************************************************************
 599  *        URLMoniker_Hash
 600  ******************************************************************************/
 601 static HRESULT WINAPI URLMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
 602 {
 603     ICOM_THIS(URLMonikerImpl,iface);
 604     FIXME("(%p)->(%p): stub\n",This,pdwHash);
 605
 606     return E_NOTIMPL;
 607 }
 608
 609 /******************************************************************************
 610  *        URLMoniker_IsRunning
 611  ******************************************************************************/
 612 static HRESULT WINAPI URLMonikerImpl_IsRunning(IMoniker* iface,
 613                                                IBindCtx* pbc,
 614                                                IMoniker* pmkToLeft,
 615                                                IMoniker* pmkNewlyRunning)
 616 {
 617     ICOM_THIS(URLMonikerImpl,iface);
 618     FIXME("(%p)->(%p,%p,%p): stub\n",This,pbc,pmkToLeft,pmkNewlyRunning);
 619
 620     return E_NOTIMPL;
 621 }
 622
 623 /******************************************************************************
 624  *        URLMoniker_GetTimeOfLastChange
 625  ******************************************************************************/
 626 static HRESULT WINAPI URLMonikerImpl_GetTimeOfLastChange(IMoniker* iface,
 627                                                          IBindCtx* pbc,
 628                                                          IMoniker* pmkToLeft,
 629                                                          FILETIME* pFileTime)
 630 {
 631     ICOM_THIS(URLMonikerImpl,iface);
 632     FIXME("(%p)->(%p,%p,%p): stub\n",This,pbc,pmkToLeft,pFileTime);
 633
 634     return E_NOTIMPL;
 635 }
 636
 637 /******************************************************************************
 638  *        URLMoniker_Inverse
 639  ******************************************************************************/
 640 static HRESULT WINAPI URLMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
 641 {
 642     ICOM_THIS(URLMonikerImpl,iface);
 643     FIXME("(%p)->(%p): stub\n",This,ppmk);
 644
 645     return E_NOTIMPL;
 646 }
 647
 648 /******************************************************************************
 649  *        URLMoniker_CommonPrefixWith
 650  ******************************************************************************/
 651 static HRESULT WINAPI URLMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
 652 {
 653     ICOM_THIS(URLMonikerImpl,iface);
 654     FIXME("(%p)->(%p,%p): stub\n",This,pmkOther,ppmkPrefix);
 655
 656     return E_NOTIMPL;
 657 }
 658
 659 /******************************************************************************
 660  *        URLMoniker_RelativePathTo
 661  ******************************************************************************/
 662 static HRESULT WINAPI URLMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
 663 {
 664     ICOM_THIS(URLMonikerImpl,iface);
 665     FIXME("(%p)->(%p,%p): stub\n",This,pmOther,ppmkRelPath);
 666
 667     return E_NOTIMPL;
 668 }
 669
 670 /******************************************************************************
 671  *        URLMoniker_GetDisplayName
 672  ******************************************************************************/
 673 static HRESULT WINAPI URLMonikerImpl_GetDisplayName(IMoniker* iface,
 674                                                     IBindCtx* pbc,
 675                                                     IMoniker* pmkToLeft,
 676                                                     LPOLESTR *ppszDisplayName)
 677 {
 678     ICOM_THIS(URLMonikerImpl,iface);
 679     FIXME("(%p)->(%p,%p,%p): stub\n",This,pbc,pmkToLeft,ppszDisplayName);
 680
 681     return E_NOTIMPL;
 682 }
 683
 684 /******************************************************************************
 685  *        URLMoniker_ParseDisplayName
 686  ******************************************************************************/
 687 static HRESULT WINAPI URLMonikerImpl_ParseDisplayName(IMoniker* iface,
 688                                                       IBindCtx* pbc,
 689                                                       IMoniker* pmkToLeft,
 690                                                       LPOLESTR pszDisplayName,
 691                                                       ULONG* pchEaten,
 692                                                       IMoniker** ppmkOut)
 693 {
 694     ICOM_THIS(URLMonikerImpl,iface);
 695     FIXME("(%p)->(%p,%p,%p,%p,%p): stub\n",This,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
 696
 697     return E_NOTIMPL;
 698 }
 699
 700 /******************************************************************************
 701  *        URLMoniker_IsSystemMoniker
 702  ******************************************************************************/
 703 static HRESULT WINAPI URLMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
 704 {
 705     ICOM_THIS(URLMonikerImpl,iface);
 706     FIXME("(%p)->(%p)\n",This,pwdMksys);
 707
 708     return E_NOTIMPL;
 709 }
 710
 711 static HRESULT WINAPI URLMonikerImpl_IBinding_QueryInterface(IBinding* iface,REFIID riid,void** ppvObject)
 712 {
 713     ICOM_THIS_MULTI(URLMonikerImpl, lpvtbl2, iface);
 714
 715     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppvObject);
 716
 717     /* Perform a sanity check on the parameters.*/
 718     if ( (This==0) || (ppvObject==0) )
 719         return E_INVALIDARG;
 720
 721     /* Initialize the return parameter */
 722     *ppvObject = 0;
 723
 724     /* Compare the riid with the interface IDs implemented by this object.*/
 725     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IBinding, riid))
 726         *ppvObject = iface;
 727
 728     /* Check that we obtained an interface.*/
 729     if ((*ppvObject)==0)
 730         return E_NOINTERFACE;
 731
 732     /* Query Interface always increases the reference count by one when it is successful */
 733     URLMonikerImpl_IBinding_AddRef(iface);
 734
 735     return S_OK;
 736
 737 }
 738
 739 static ULONG WINAPI URLMonikerImpl_IBinding_AddRef(IBinding* iface)
 740 {
 741     ICOM_THIS_MULTI(URLMonikerImpl, lpvtbl2, iface);
 742     TRACE("(%p)\n",This);
 743
 744     return URLMonikerImpl_AddRef((IMoniker*)This);
 745 }
 746
 747 static ULONG WINAPI URLMonikerImpl_IBinding_Release(IBinding* iface)
 748 {
 749     ICOM_THIS_MULTI(URLMonikerImpl, lpvtbl2, iface);
 750     TRACE("(%p)\n",This);
 751
 752     return URLMonikerImpl_Release((IMoniker*)This);
 753 }
 754
 755 static HRESULT WINAPI URLMonikerImpl_IBinding_Abort(IBinding* iface)
 756 {
 757     ICOM_THIS_MULTI(URLMonikerImpl, lpvtbl2, iface);
 758     FIXME("(%p): stub\n", This);
 759
 760     return E_NOTIMPL;
 761 }
 762
 763 static HRESULT WINAPI URLMonikerImpl_IBinding_GetBindResult(IBinding* iface, CLSID* pclsidProtocol, DWORD* pdwResult, LPOLESTR* pszResult, DWORD* pdwReserved)
 764 {
 765     ICOM_THIS_MULTI(URLMonikerImpl, lpvtbl2, iface);
 766     FIXME("(%p)->(%s, %p, %p, %p): stub\n", This, debugstr_guid(pclsidProtocol), pdwResult, pszResult, pdwReserved);
 767
 768     return E_NOTIMPL;
 769 }
 770
 771 static HRESULT WINAPI URLMonikerImpl_IBinding_GetPriority(IBinding* iface, LONG* pnPriority)
 772 {
 773     ICOM_THIS_MULTI(URLMonikerImpl, lpvtbl2, iface);
 774     FIXME("(%p)->(%p): stub\n", This, pnPriority);
 775
 776     return E_NOTIMPL;
 777 }
 778
 779 static HRESULT WINAPI URLMonikerImpl_IBinding_Resume(IBinding* iface)
 780 {
 781     ICOM_THIS_MULTI(URLMonikerImpl, lpvtbl2, iface);
 782     FIXME("(%p): stub\n", This);
 783
 784     return E_NOTIMPL;
 785 }
 786
 787 static HRESULT WINAPI URLMonikerImpl_IBinding_SetPriority(IBinding* iface, LONG nPriority)
 788 {
 789     ICOM_THIS_MULTI(URLMonikerImpl, lpvtbl2, iface);
 790     FIXME("(%p)->(%ld): stub\n", This, nPriority);
 791
 792     return E_NOTIMPL;
 793 }
 794
 795 static HRESULT WINAPI URLMonikerImpl_IBinding_Suspend(IBinding* iface)
 796 {
 797     ICOM_THIS_MULTI(URLMonikerImpl, lpvtbl2, iface);
 798     FIXME("(%p): stub\n", This);
 799
 800     return E_NOTIMPL;
 801 }
 802
 803 /***********************************************************************
 804  *           CreateAsyncBindCtxEx (URLMON.@)
 805  *
 806  * Create an asynchronous bind context.
 807  *
 808  * FIXME
 809  *   Not implemented.
 810  */
 811 HRESULT WINAPI CreateAsyncBindCtxEx(IBindCtx *ibind, DWORD options,
 812     IBindStatusCallback *callback, IEnumFORMATETC *format, IBindCtx** pbind,
 813     DWORD reserved)
 814 {
 815      FIXME("stub, returns failure\n");
 816      return E_INVALIDARG;
 817 }
 818
 819
 820 /***********************************************************************
 821  *           CreateURLMoniker (URLMON.@)
 822  *
 823  * Create a url moniker.
 824  *
 825  * PARAMS
 826  *    pmkContext [I] Context
 827  *    szURL      [I] Url to create the moniker for
 828  *    ppmk       [O] Destination for created moniker.
 829  *
 830  * RETURNS
 831  *    Success: S_OK. ppmk contains the created IMoniker object.
 832  *    Failure: MK_E_SYNTAX if szURL is not a valid url, or
 833  *             E_OUTOFMEMORY if memory allocation fails.
 834  */
 835 HRESULT WINAPI CreateURLMoniker(IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk)
 836 {
 837     URLMonikerImpl *obj;
 838     HRESULT hres;
 839     IID iid = IID_IMoniker;
 840
 841     TRACE("(%p, %s, %p)\n", pmkContext, debugstr_w(szURL), ppmk);
 842
 843     if (NULL != pmkContext)
 844         FIXME("Non-null pmkContext not implemented\n");
 845
 846     if(!(obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*obj))))
 847         return E_OUTOFMEMORY;
 848
 849     hres = URLMonikerImpl_Construct(obj, szURL);
 850     if(SUCCEEDED(hres))
 851         hres = URLMonikerImpl_QueryInterface((IMoniker*)obj, &iid, (void**)ppmk);
 852     else
 853         HeapFree(GetProcessHeap(), 0, obj);
 854     return hres;
 855 }
 856
 857
 858 /***********************************************************************
 859  *           CoInternetGetSession (URLMON.@)
 860  *
 861  * Create a new internet session and return an IInternetSession interface
 862  * representing it.
 863  *
 864  * PARAMS
 865  *    dwSessionMode      [I] Mode for the internet session
 866  *    ppIInternetSession [O] Destination for creates IInternetSession object
 867  *    dwReserved         [I] Reserved, must be 0.
 868  *
 869  * RETURNS
 870  *    Success: S_OK. ppIInternetSession contains the IInternetSession interface.
 871  *    Failure: E_INVALIDARG, if any argument is invalid, or
 872  *             E_OUTOFMEMORY if memory allocation fails.
 873  */
 874 HRESULT WINAPI CoInternetGetSession(DWORD dwSessionMode, /*IInternetSession*/void **ppIInternetSession, DWORD dwReserved)
 875 {
 876     FIXME("(%ld, %p, %ld): stub\n", dwSessionMode, ppIInternetSession, dwReserved);
 877
 878     if(dwSessionMode) {
 879       ERR("dwSessionMode: %ld, must be zero\n", dwSessionMode);
 880     }
 881
 882     if(dwReserved) {
 883       ERR("dwReserved: %ld, must be zero\n", dwReserved);
 884     }
 885
 886     *ppIInternetSession=NULL;
 887     return E_OUTOFMEMORY;
 888 }
 889
 890 /***********************************************************************
 891  *           CoInternetQueryInfo (URLMON.@)
 892  *
 893  * Retrieves information relevant to a specified URL
 894  *
 895  * RETURNS
 896  *    S_OK                      success
 897  *    S_FALSE                   buffer too small
 898  *    INET_E_QUERYOPTIONUNKNOWN invalid option
 899  *
 900  */
 901 HRESULT WINAPI CoInternetQueryInfo(LPCWSTR pwzUrl, QUERYOPTION QueryOption,
 902   DWORD dwQueryFlags, LPVOID pvBuffer, DWORD cbBuffer, DWORD * pcbBuffer,
 903   DWORD dwReserved)
 904 {
 905   FIXME("(%s, %x, %lx, %p, %lx, %p, %lx): stub\n", debugstr_w(pwzUrl),
 906     QueryOption, dwQueryFlags, pvBuffer, cbBuffer, pcbBuffer, dwReserved);
 907   return S_OK;
 908 }
 909
 910 /***********************************************************************
 911  *           FindMimeFromData (URLMON.@)
 912  *
 913  * Determines the Multipurpose Internet Mail Extensions (MIME) type from the data provided.
 914  *
 915  */
 916 HRESULT WINAPI FindMimeFromData(LPBC pBC, LPCWSTR pwzUrl, LPVOID pBuffer,
 917    DWORD cbSize, LPCWSTR pwzMimeProposed, DWORD dwMimeFlags,
 918    LPWSTR* ppwzMimeOut, DWORD dwReserved)
 919 {
 920   FIXME("stub\n");
 921   return E_OUTOFMEMORY;
 922 }
 923
 924 /***********************************************************************
 925  *           RegisterBindStatusCallback (URLMON.@)
 926  *
 927  * Register a bind status callback.
 928  *
 929  * PARAMS
 930  *  pbc           [I] Binding context
 931  *  pbsc          [I] Callback to register
 932  *  ppbscPrevious [O] Destination for previous callback
 933  *  dwReserved    [I] Reserved, must be 0.
 934  *
 935  * RETURNS
 936  *    Success: S_OK.
 937  *    Failure: E_INVALIDARG, if any argument is invalid, or
 938  *             E_OUTOFMEMORY if memory allocation fails.
 939  */
 940 HRESULT WINAPI RegisterBindStatusCallback(
 941     IBindCtx *pbc,
 942     IBindStatusCallback *pbsc,
 943     IBindStatusCallback **ppbscPrevious,
 944     DWORD dwReserved)
 945 {
 946     IBindStatusCallback *prev;
 947
 948         TRACE("(%p,%p,%p,%lu)\n", pbc, pbsc, ppbscPrevious, dwReserved);
 949
 950     if (pbc == NULL || pbsc == NULL)
 951         return E_INVALIDARG;
 952
 953     if (SUCCEEDED(IBindCtx_GetObjectParam(pbc, BSCBHolder, (IUnknown **)&prev)))
 954     {
 955         IBindCtx_RevokeObjectParam(pbc, BSCBHolder);
 956         if (ppbscPrevious)
 957             *ppbscPrevious = prev;
 958         else
 959             IBindStatusCallback_Release(prev);
 960     }
 961
 962         return IBindCtx_RegisterObjectParam(pbc, BSCBHolder, (IUnknown *)pbsc);
 963 }
 964
 965 /***********************************************************************
 966  *           RevokeBindStatusCallback (URLMON.@)
 967  *
 968  * Unregister a bind status callback.
 969  *
 970  *  pbc           [I] Binding context
 971  *  pbsc          [I] Callback to unregister
 972  *
 973  * RETURNS
 974  *    Success: S_OK.
 975  *    Failure: E_INVALIDARG, if any argument is invalid, or
 976  *             E_FAIL if pbsc wasn't registered with pbc.
 977  */
 978 HRESULT WINAPI RevokeBindStatusCallback(
 979     IBindCtx *pbc,
 980     IBindStatusCallback *pbsc)
 981 {
 982     IBindStatusCallback *callback;
 983     HRESULT hr = E_FAIL;
 984
 985         TRACE("(%p,%p)\n", pbc, pbsc);
 986
 987     if (pbc == NULL || pbsc == NULL)
 988         return E_INVALIDARG;
 989
 990     if (SUCCEEDED(IBindCtx_GetObjectParam(pbc, BSCBHolder, (IUnknown **)&callback)))
 991     {
 992         if (callback == pbsc)
 993         {
 994             IBindCtx_RevokeObjectParam(pbc, BSCBHolder);
 995             hr = S_OK;
 996         }
 997         IBindStatusCallback_Release(pbsc);
 998     }
 999
1000     return hr;
1001 }
1002
1003 /***********************************************************************
1004  *           ReleaseBindInfo (URLMON.@)
1005  *
1006  * Release the resources used by the specified BINDINFO structure.
1007  *
1008  * PARAMS
1009  *  pbindinfo [I] BINDINFO to release.
1010  *
1011  * RETURNS
1012  *  Nothing.
1013  */
1014 void WINAPI ReleaseBindInfo(BINDINFO* pbindinfo)
1015 {
1016     FIXME("(%p)stub!\n", pbindinfo);
1017 }
1018
1019 /***********************************************************************
1020  *           URLDownloadToFileA (URLMON.@)
1021  *
1022  * Downloads URL szURL to rile szFileName and call lpfnCB callback to
1023  * report progress.
1024  *
1025  * PARAMS
1026  *  pCaller    [I] controlling IUnknown interface.
1027  *  szURL      [I] URL of the file to download
1028  *  szFileName [I] file name to store the content of the URL
1029  *  dwReserved [I] reserved - set to 0
1030  *  lpfnCB     [I] callback for progress report
1031  *
1032  * RETURNS
1033  *  S_OK on success
1034  *  E_OUTOFMEMORY when going out of memory
1035  */
1036 HRESULT WINAPI URLDownloadToFileA(LPUNKNOWN pCaller,
1037                                   LPCSTR szURL,
1038                                   LPCSTR szFileName,
1039                                   DWORD dwReserved,
1040                                   LPBINDSTATUSCALLBACK lpfnCB)
1041 {
1042     UNICODE_STRING szURL_w, szFileName_w;
1043
1044     if ((szURL == NULL) || (szFileName == NULL)) {
1045         FIXME("(%p,%s,%s,%08lx,%p) cannot accept NULL strings !\n", pCaller, debugstr_a(szURL), debugstr_a(szFileName), dwReserved, lpfnCB);
1046         return E_INVALIDARG; /* The error code is not specified in this case... */
1047     }
1048
1049     if (RtlCreateUnicodeStringFromAsciiz(&szURL_w, szURL)) {
1050         if (RtlCreateUnicodeStringFromAsciiz(&szFileName_w, szFileName)) {
1051             HRESULT ret = URLDownloadToFileW(pCaller, szURL_w.Buffer, szFileName_w.Buffer, dwReserved, lpfnCB);
1052
1053             RtlFreeUnicodeString(&szURL_w);
1054             RtlFreeUnicodeString(&szFileName_w);
1055
1056             return ret;
1057         } else {
1058             RtlFreeUnicodeString(&szURL_w);
1059         }
1060     }
1061
1062     FIXME("(%p,%s,%s,%08lx,%p) could not allocate W strings !\n", pCaller, szURL, szFileName, dwReserved, lpfnCB);
1063     return E_OUTOFMEMORY;
1064 }
1065
1066 /***********************************************************************
1067  *           URLDownloadToFileW (URLMON.@)
1068  *
1069  * Downloads URL szURL to rile szFileName and call lpfnCB callback to
1070  * report progress.
1071  *
1072  * PARAMS
1073  *  pCaller    [I] controlling IUnknown interface.
1074  *  szURL      [I] URL of the file to download
1075  *  szFileName [I] file name to store the content of the URL
1076  *  dwReserved [I] reserved - set to 0
1077  *  lpfnCB     [I] callback for progress report
1078  *
1079  * RETURNS
1080  *  S_OK on success
1081  *  E_OUTOFMEMORY when going out of memory
1082  */
1083 HRESULT WINAPI URLDownloadToFileW(LPUNKNOWN pCaller,
1084                                   LPCWSTR szURL,
1085                                   LPCWSTR szFileName,
1086                                   DWORD dwReserved,
1087                                   LPBINDSTATUSCALLBACK lpfnCB)
1088 {
1089     HINTERNET hinternet, hcon, hreq;
1090     BOOL r;
1091     CHAR buffer[0x1000];
1092     DWORD sz, total, written;
1093     DWORD total_size = 0xFFFFFFFF, arg_size = sizeof(total_size);
1094     URL_COMPONENTSW url;
1095     WCHAR host[0x80], path[0x100];
1096     HANDLE hfile;
1097     WCHAR wszAppName[]={'u','r','l','m','o','n','.','d','l','l',0};
1098
1099     /* Note: all error codes would need to be checked agains real Windows behaviour... */
1100     TRACE("(%p,%s,%s,%08lx,%p) stub!\n", pCaller, debugstr_w(szURL), debugstr_w(szFileName), dwReserved, lpfnCB);
1101
1102     if ((szURL == NULL) || (szFileName == NULL)) {
1103         FIXME(" cannot accept NULL strings !\n");
1104         return E_INVALIDARG;
1105     }
1106
1107     /* Would be better to use the application name here rather than 'urlmon' :-/ */
1108     hinternet = InternetOpenW(wszAppName, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
1109     if (hinternet == NULL) {
1110         return E_OUTOFMEMORY;
1111     }
1112
1113     memset(&url, 0, sizeof(url));
1114     url.dwStructSize = sizeof(url);
1115     url.lpszHostName = host;
1116     url.dwHostNameLength = sizeof(host);
1117     url.lpszUrlPath = path;
1118     url.dwUrlPathLength = sizeof(path);
1119
1120     if (!InternetCrackUrlW(szURL, 0, 0, &url)) {
1121         InternetCloseHandle(hinternet);
1122         return E_OUTOFMEMORY;
1123     }
1124
1125     if (lpfnCB) {
1126         if (IBindStatusCallback_OnProgress(lpfnCB, 0, 0, BINDSTATUS_CONNECTING, url.lpszHostName) == E_ABORT) {
1127             InternetCloseHandle(hinternet);
1128             return S_OK;
1129         }
1130     }
1131
1132     hcon = InternetConnectW(hinternet, url.lpszHostName, url.nPort,
1133                             url.lpszUserName, url.lpszPassword,
1134                             INTERNET_SERVICE_HTTP, 0, 0);
1135     if (!hcon) {
1136         InternetCloseHandle(hinternet);
1137         return E_OUTOFMEMORY;
1138     }
1139
1140     hreq = HttpOpenRequestW(hcon, NULL, url.lpszUrlPath, NULL, NULL, NULL, 0, 0);
1141     if (!hreq) {
1142         InternetCloseHandle(hinternet);
1143         InternetCloseHandle(hcon);
1144         return E_OUTOFMEMORY;
1145     }
1146
1147     if (!HttpSendRequestW(hreq, NULL, 0, NULL, 0)) {
1148         InternetCloseHandle(hinternet);
1149         InternetCloseHandle(hcon);
1150         InternetCloseHandle(hreq);
1151         return E_OUTOFMEMORY;
1152     }
1153
1154     if (HttpQueryInfoW(hreq, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER,
1155                        &total_size, &arg_size, NULL)) {
1156         TRACE(" total size : %ld\n", total_size);
1157     }
1158
1159     hfile = CreateFileW(szFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
1160                         FILE_ATTRIBUTE_NORMAL, NULL );
1161     if (hfile == INVALID_HANDLE_VALUE) {
1162         return E_ACCESSDENIED;
1163     }
1164
1165     if (lpfnCB) {
1166         if (IBindStatusCallback_OnProgress(lpfnCB, 0, total_size != 0xFFFFFFFF ? total_size : 0,
1167                                            BINDSTATUS_BEGINDOWNLOADDATA, szURL) == E_ABORT) {
1168             InternetCloseHandle(hreq);
1169             InternetCloseHandle(hcon);
1170             InternetCloseHandle(hinternet);
1171             CloseHandle(hfile);
1172             return S_OK;
1173         }
1174     }
1175
1176     total = 0;
1177     while (1) {
1178         r = InternetReadFile(hreq, buffer, sizeof(buffer), &sz);
1179         if (!r) {
1180             InternetCloseHandle(hreq);
1181             InternetCloseHandle(hcon);
1182             InternetCloseHandle(hinternet);
1183
1184             CloseHandle(hfile);
1185             return E_OUTOFMEMORY;
1186         }
1187         if (!sz)
1188             break;
1189
1190         total += sz;
1191
1192         if (lpfnCB) {
1193             if (IBindStatusCallback_OnProgress(lpfnCB, total, total_size != 0xFFFFFFFF ? total_size : 0,
1194                                                BINDSTATUS_DOWNLOADINGDATA, szURL) == E_ABORT) {
1195                 InternetCloseHandle(hreq);
1196                 InternetCloseHandle(hcon);
1197                 InternetCloseHandle(hinternet);
1198                 CloseHandle(hfile);
1199                 return S_OK;
1200             }
1201         }
1202
1203         if (!WriteFile(hfile, buffer, sz, &written, NULL)) {
1204             InternetCloseHandle(hreq);
1205             InternetCloseHandle(hcon);
1206             InternetCloseHandle(hinternet);
1207
1208             CloseHandle(hfile);
1209             return E_OUTOFMEMORY;
1210         }
1211     }
1212
1213     if (lpfnCB) {
1214         if (IBindStatusCallback_OnProgress(lpfnCB, total, total_size != 0xFFFFFFFF ? total_size : 0,
1215                                            BINDSTATUS_ENDDOWNLOADDATA, szURL) == E_ABORT) {
1216             InternetCloseHandle(hreq);
1217             InternetCloseHandle(hcon);
1218             InternetCloseHandle(hinternet);
1219             CloseHandle(hfile);
1220             return S_OK;
1221         }
1222     }
1223
1224     InternetCloseHandle(hreq);
1225     InternetCloseHandle(hcon);
1226     InternetCloseHandle(hinternet);
1227
1228     CloseHandle(hfile);
1229
1230     return S_OK;
1231 }