git.oblomov.eu Git - wine/blob - 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  * Copyright 2005 Jacek Caban for CodeWeavers
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #define COM_NO_WINDOWS_H
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26
  27 #define COBJMACROS
  28 #define NONAMELESSUNION
  29 #define NONAMELESSSTRUCT
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "winreg.h"
  34 #include "winternl.h"
  35 #include "winuser.h"
  36 #include "objbase.h"
  37 #include "wine/debug.h"
  38 #include "wine/unicode.h"
  39 #include "ole2.h"
  40 #include "urlmon.h"
  41 #include "wininet.h"
  42 #include "shlwapi.h"
  43 #include "urlmon_main.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  46
  47 /* native urlmon.dll uses this key, too */
  48 static const WCHAR BSCBHolder[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
  49
  50 /*static BOOL registered_wndclass = FALSE;*/
  51
  52 typedef struct {
  53     const IBindingVtbl *lpVtbl;
  54
  55     LONG ref;
  56
  57     LPWSTR URLName;
  58
  59     HWND hwndCallback;
  60     IBindCtx *pBC;
  61     HINTERNET hinternet, hconnect, hrequest;
  62     HANDLE hCacheFile;
  63     IUMCacheStream *pstrCache;
  64     IBindStatusCallback *pbscb;
  65     DWORD total_read, expected_size;
  66 } Binding;
  67
  68 static HRESULT WINAPI Binding_QueryInterface(IBinding* iface, REFIID riid, void **ppvObject)
  69 {
  70     Binding *This = (Binding*)iface;
  71
  72     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppvObject);
  73
  74     if((This == NULL) || (ppvObject == NULL))
  75         return E_INVALIDARG;
  76
  77     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IBinding, riid)) {
  78         *ppvObject = iface;
  79         IBinding_AddRef(iface);
  80         return S_OK;
  81     }
  82
  83     *ppvObject = NULL;
  84     return E_NOINTERFACE;
  85 }
  86
  87 static ULONG WINAPI Binding_AddRef(IBinding* iface)
  88 {
  89     Binding *This = (Binding*)iface;
  90     ULONG ref = InterlockedIncrement(&This->ref);
  91
  92     TRACE("(%p) ref=%ld\n", This, ref);
  93
  94     return ref;
  95 }
  96
  97 static ULONG WINAPI Binding_Release(IBinding* iface)
  98 {
  99     Binding *This = (Binding*)iface;
 100     ULONG ref = InterlockedDecrement(&This->ref);
 101
 102     TRACE("(%p) ref=%ld\n",This, ref);
 103
 104     if(!ref) {
 105         HeapFree(GetProcessHeap(), 0, This->URLName);
 106         if (This->hCacheFile)
 107             CloseHandle(This->hCacheFile);
 108         if (This->pstrCache)
 109         {
 110             UMCloseCacheFileStream(This->pstrCache);
 111             IStream_Release((IStream *)This->pstrCache);
 112         }
 113         if (This->pbscb)
 114             IBindStatusCallback_Release(This->pbscb);
 115
 116         HeapFree(GetProcessHeap(), 0, This);
 117
 118         URLMON_UnlockModule();
 119     }
 120
 121     return ref;
 122 }
 123
 124 static HRESULT WINAPI Binding_Abort(IBinding* iface)
 125 {
 126     Binding *This = (Binding*)iface;
 127
 128     FIXME("(%p): stub\n", This);
 129
 130     return E_NOTIMPL;
 131 }
 132
 133 static HRESULT WINAPI Binding_GetBindResult(IBinding* iface, CLSID* pclsidProtocol, DWORD* pdwResult, LPOLESTR* pszResult, DWORD* pdwReserved)
 134 {
 135     Binding *This = (Binding*)iface;
 136
 137     FIXME("(%p)->(%p, %p, %p, %p): stub\n", This, pclsidProtocol, pdwResult, pszResult, pdwReserved);
 138
 139     return E_NOTIMPL;
 140 }
 141
 142 static HRESULT WINAPI Binding_GetPriority(IBinding* iface, LONG* pnPriority)
 143 {
 144     Binding *This = (Binding*)iface;
 145
 146     FIXME("(%p)->(%p): stub\n", This, pnPriority);
 147
 148     return E_NOTIMPL;
 149 }
 150
 151 static HRESULT WINAPI Binding_Resume(IBinding* iface)
 152 {
 153     Binding *This = (Binding*)iface;
 154
 155     FIXME("(%p): stub\n", This);
 156
 157     return E_NOTIMPL;
 158 }
 159
 160 static HRESULT WINAPI Binding_SetPriority(IBinding* iface, LONG nPriority)
 161 {
 162     Binding *This = (Binding*)iface;
 163
 164     FIXME("(%p)->(%ld): stub\n", This, nPriority);
 165
 166     return E_NOTIMPL;
 167 }
 168
 169 static HRESULT WINAPI Binding_Suspend(IBinding* iface)
 170 {
 171     Binding *This = (Binding*)iface;
 172
 173     FIXME("(%p): stub\n", This);
 174
 175     return E_NOTIMPL;
 176 }
 177
 178 static void Binding_CloseCacheDownload(Binding *This)
 179 {
 180     CloseHandle(This->hCacheFile);
 181     This->hCacheFile = 0;
 182     UMCloseCacheFileStream(This->pstrCache);
 183     IStream_Release((IStream *)This->pstrCache);
 184     This->pstrCache = 0;
 185 }
 186
 187 static HRESULT Binding_MoreCacheData(Binding *This, char *buf, DWORD dwBytes)
 188 {
 189     DWORD written;
 190
 191     if (WriteFile(This->hCacheFile, buf, dwBytes, &written, NULL) && written == dwBytes)
 192     {
 193         HRESULT hr;
 194
 195         This->total_read += written;
 196         hr = IBindStatusCallback_OnProgress(This->pbscb,
 197                                             This->total_read + written,
 198                                             This->expected_size,
 199                                             (This->total_read == written) ?
 200                                                 BINDSTATUS_BEGINDOWNLOADDATA :
 201                                                 BINDSTATUS_DOWNLOADINGDATA,
 202                                             This->URLName);
 203         if (!hr)
 204         {
 205             STGMEDIUM stg;
 206             FORMATETC fmt;
 207
 208             fmt.cfFormat = 0;
 209             fmt.ptd = NULL;
 210             fmt.dwAspect = 0;
 211             fmt.lindex = -1;
 212             fmt.tymed = TYMED_ISTREAM;
 213
 214             stg.tymed = TYMED_ISTREAM;
 215             stg.u.pstm = (IStream *)This->pstrCache;
 216             stg.pUnkForRelease = NULL;
 217
 218             hr = IBindStatusCallback_OnDataAvailable(This->pbscb,
 219                                                      (This->total_read == written) ?
 220                                                          BSCF_FIRSTDATANOTIFICATION :
 221                                                          BSCF_INTERMEDIATEDATANOTIFICATION,
 222                                                      This->total_read + written,
 223                                                      &fmt,
 224                                                      &stg);
 225         }
 226         if (written < dwBytes)
 227             return STG_E_MEDIUMFULL;
 228         else
 229             return hr;
 230     }
 231     return HRESULT_FROM_WIN32(GetLastError());
 232 }
 233
 234 static void Binding_FinishedDownload(Binding *This, HRESULT hr)
 235 {
 236     STGMEDIUM stg;
 237     FORMATETC fmt;
 238
 239     fmt.ptd = NULL;
 240     fmt.dwAspect = 0;
 241     fmt.lindex = -1;
 242     fmt.tymed = TYMED_ISTREAM;
 243
 244     stg.tymed = TYMED_ISTREAM;
 245     stg.u.pstm = (IStream *)This->pstrCache;
 246     stg.pUnkForRelease = NULL;
 247
 248     IBindStatusCallback_OnProgress(This->pbscb, This->total_read, This->expected_size,
 249                                    BINDSTATUS_ENDDOWNLOADDATA, This->URLName);
 250     IBindStatusCallback_OnDataAvailable(This->pbscb, BSCF_LASTDATANOTIFICATION, This->total_read, &fmt, &stg);
 251     if (hr)
 252     {
 253         WCHAR *pwchError = 0;
 254
 255         FormatMessageW (FORMAT_MESSAGE_FROM_SYSTEM |
 256                          FORMAT_MESSAGE_ALLOCATE_BUFFER,
 257                         NULL, (DWORD) hr,
 258                         0, (LPWSTR) &pwchError,
 259                         0, NULL);
 260         if (!pwchError)
 261         {
 262             static const WCHAR achFormat[] = { '%', '0', '8', 'x', 0 };
 263
 264             pwchError =(WCHAR *) LocalAlloc(LMEM_FIXED, sizeof(WCHAR) * 9);
 265             wsprintfW(pwchError, achFormat, hr);
 266         }
 267         IBindStatusCallback_OnStopBinding(This->pbscb, hr, pwchError);
 268         LocalFree(pwchError);
 269     }
 270     else
 271     {
 272         IBindStatusCallback_OnStopBinding(This->pbscb, hr, NULL);
 273     }
 274     IBindStatusCallback_Release(This->pbscb);
 275     This->pbscb = 0;
 276 }
 277
 278 static const IBindingVtbl BindingVtbl =
 279 {
 280     Binding_QueryInterface,
 281     Binding_AddRef,
 282     Binding_Release,
 283     Binding_Abort,
 284     Binding_Suspend,
 285     Binding_Resume,
 286     Binding_SetPriority,
 287     Binding_GetPriority,
 288     Binding_GetBindResult
 289 };
 290
 291 /* filemoniker data structure */
 292 typedef struct {
 293
 294     const IMonikerVtbl* lpvtbl;  /* VTable relative to the IMoniker interface.*/
 295
 296     LONG ref; /* reference counter for this object */
 297
 298     LPOLESTR URLName; /* URL string identified by this URLmoniker */
 299 } URLMonikerImpl;
 300
 301 /*******************************************************************************
 302  *        URLMoniker_QueryInterface
 303  *******************************************************************************/
 304 static HRESULT WINAPI URLMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
 305 {
 306     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 307
 308     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppvObject);
 309
 310     /* Perform a sanity check on the parameters.*/
 311     if ( (This==0) || (ppvObject==0) )
 312         return E_INVALIDARG;
 313
 314     /* Initialize the return parameter */
 315     *ppvObject = 0;
 316
 317     /* Compare the riid with the interface IDs implemented by this object.*/
 318     if (IsEqualIID(&IID_IUnknown, riid)      ||
 319         IsEqualIID(&IID_IPersist, riid)      ||
 320         IsEqualIID(&IID_IPersistStream,riid) ||
 321         IsEqualIID(&IID_IMoniker, riid)
 322        )
 323         *ppvObject = iface;
 324
 325     /* Check that we obtained an interface.*/
 326     if ((*ppvObject)==0)
 327         return E_NOINTERFACE;
 328
 329     /* Query Interface always increases the reference count by one when it is successful */
 330     IMoniker_AddRef(iface);
 331
 332     return S_OK;
 333 }
 334
 335 /******************************************************************************
 336  *        URLMoniker_AddRef
 337  ******************************************************************************/
 338 static ULONG WINAPI URLMonikerImpl_AddRef(IMoniker* iface)
 339 {
 340     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 341     ULONG refCount = InterlockedIncrement(&This->ref);
 342
 343     TRACE("(%p)->(ref before=%lu)\n",This, refCount - 1);
 344
 345     return refCount;
 346 }
 347
 348 /******************************************************************************
 349  *        URLMoniker_Release
 350  ******************************************************************************/
 351 static ULONG WINAPI URLMonikerImpl_Release(IMoniker* iface)
 352 {
 353     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 354     ULONG refCount = InterlockedDecrement(&This->ref);
 355
 356     TRACE("(%p)->(ref before=%lu)\n",This, refCount + 1);
 357
 358     /* destroy the object if there's no more reference on it */
 359     if (!refCount) {
 360         HeapFree(GetProcessHeap(),0,This->URLName);
 361         HeapFree(GetProcessHeap(),0,This);
 362
 363         URLMON_UnlockModule();
 364     }
 365
 366     return refCount;
 367 }
 368
 369
 370 /******************************************************************************
 371  *        URLMoniker_GetClassID
 372  ******************************************************************************/
 373 static HRESULT WINAPI URLMonikerImpl_GetClassID(IMoniker* iface,
 374                                                 CLSID *pClassID)/* Pointer to CLSID of object */
 375 {
 376     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 377
 378     TRACE("(%p,%p)\n",This,pClassID);
 379
 380     if (pClassID==NULL)
 381         return E_POINTER;
 382     /* Windows always returns CLSID_StdURLMoniker */
 383     *pClassID = CLSID_StdURLMoniker;
 384     return S_OK;
 385 }
 386
 387 /******************************************************************************
 388  *        URLMoniker_IsDirty
 389  ******************************************************************************/
 390 static HRESULT WINAPI URLMonikerImpl_IsDirty(IMoniker* iface)
 391 {
 392     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 393     /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
 394        method in the OLE-provided moniker interfaces always return S_FALSE because
 395        their internal state never changes. */
 396
 397     TRACE("(%p)\n",This);
 398
 399     return S_FALSE;
 400 }
 401
 402 /******************************************************************************
 403  *        URLMoniker_Load
 404  *
 405  * NOTE
 406  *  Writes a ULONG containing length of unicode string, followed
 407  *  by that many unicode characters
 408  ******************************************************************************/
 409 static HRESULT WINAPI URLMonikerImpl_Load(IMoniker* iface,IStream* pStm)
 410 {
 411     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 412
 413     HRESULT res;
 414     ULONG len;
 415     ULONG got;
 416     TRACE("(%p,%p)\n",This,pStm);
 417
 418     if(!pStm)
 419         return E_INVALIDARG;
 420
 421     res = IStream_Read(pStm, &len, sizeof(ULONG), &got);
 422     if(SUCCEEDED(res)) {
 423         if(got == sizeof(ULONG)) {
 424             HeapFree(GetProcessHeap(), 0, This->URLName);
 425             This->URLName=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(len+1));
 426             if(!This->URLName)
 427                 res = E_OUTOFMEMORY;
 428             else {
 429                 res = IStream_Read(pStm, This->URLName, len, NULL);
 430                 This->URLName[len] = 0;
 431             }
 432         }
 433         else
 434             res = E_FAIL;
 435     }
 436     return res;
 437 }
 438
 439 /******************************************************************************
 440  *        URLMoniker_Save
 441  ******************************************************************************/
 442 static HRESULT WINAPI URLMonikerImpl_Save(IMoniker* iface,
 443                                           IStream* pStm,/* pointer to the stream where the object is to be saved */
 444                                           BOOL fClearDirty)/* Specifies whether to clear the dirty flag */
 445 {
 446     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 447
 448     HRESULT res;
 449     ULONG len;
 450     TRACE("(%p,%p,%d)\n",This,pStm,fClearDirty);
 451
 452     if(!pStm)
 453         return E_INVALIDARG;
 454
 455     len = strlenW(This->URLName);
 456     res=IStream_Write(pStm,&len,sizeof(ULONG),NULL);
 457     if(SUCCEEDED(res))
 458         res=IStream_Write(pStm,&This->URLName,len*sizeof(WCHAR),NULL);
 459     return res;
 460
 461 }
 462
 463 /******************************************************************************
 464  *        URLMoniker_GetSizeMax
 465  ******************************************************************************/
 466 static HRESULT WINAPI URLMonikerImpl_GetSizeMax(IMoniker* iface,
 467                                                 ULARGE_INTEGER* pcbSize)/* Pointer to size of stream needed to save object */
 468 {
 469     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 470
 471     TRACE("(%p,%p)\n",This,pcbSize);
 472
 473     if(!pcbSize)
 474         return E_INVALIDARG;
 475
 476     pcbSize->u.LowPart = sizeof(ULONG) + (strlenW(This->URLName) * sizeof(WCHAR));
 477     pcbSize->u.HighPart = 0;
 478     return S_OK;
 479 }
 480
 481 /******************************************************************************
 482  *                  URLMoniker_BindToObject
 483  ******************************************************************************/
 484 static HRESULT WINAPI URLMonikerImpl_BindToObject(IMoniker* iface,
 485                                                   IBindCtx* pbc,
 486                                                   IMoniker* pmkToLeft,
 487                                                   REFIID riid,
 488                                                   VOID** ppvResult)
 489 {
 490     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 491
 492     *ppvResult=0;
 493
 494     FIXME("(%p)->(%p,%p,%s,%p): stub\n",This,pbc,pmkToLeft,debugstr_guid(riid),
 495           ppvResult);
 496
 497     return E_NOTIMPL;
 498 }
 499
 500 /******************************************************************************
 501  *        URLMoniker_BindToStorage
 502  ******************************************************************************/
 503 static HRESULT URLMonikerImpl_BindToStorage_hack(LPCWSTR URLName,
 504                                                    IBindCtx* pbc,
 505                                                    IMoniker* pmkToLeft,
 506                                                    REFIID riid,
 507                                                    VOID** ppvObject)
 508 {
 509     HRESULT hres;
 510     BINDINFO bi;
 511     DWORD bindf;
 512     WCHAR szFileName[MAX_PATH + 1];
 513     Binding *bind;
 514     int len;
 515
 516     WARN("(%s %p %p %s %p)\n", debugstr_w(URLName), pbc, pmkToLeft, debugstr_guid(riid),
 517             ppvObject);
 518
 519     if(pmkToLeft) {
 520         FIXME("pmkToLeft != NULL\n");
 521         return E_NOTIMPL;
 522     }
 523     if(!IsEqualIID(&IID_IStream, riid)) {
 524         FIXME("unsupported iid\n");
 525         return E_NOTIMPL;
 526     }
 527
 528     bind = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(Binding));
 529     bind->lpVtbl = &BindingVtbl;
 530     bind->ref = 1;
 531     URLMON_LockModule();
 532
 533     len = lstrlenW(URLName)+1;
 534     bind->URLName = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 535     memcpy(bind->URLName, URLName, len*sizeof(WCHAR));
 536
 537     hres = UMCreateStreamOnCacheFile(bind->URLName, 0, szFileName, &bind->hCacheFile, &bind->pstrCache);
 538
 539     if(SUCCEEDED(hres)) {
 540         TRACE("Created stream...\n");
 541
 542         *ppvObject = (void *) bind->pstrCache;
 543         IStream_AddRef((IStream *) bind->pstrCache);
 544
 545         hres = IBindCtx_GetObjectParam(pbc, (LPOLESTR)BSCBHolder, (IUnknown**)&bind->pbscb);
 546         if(SUCCEEDED(hres)) {
 547             TRACE("Got IBindStatusCallback...\n");
 548
 549             memset(&bi, 0, sizeof(bi));
 550             bi.cbSize = sizeof(bi);
 551             bindf = 0;
 552             hres = IBindStatusCallback_GetBindInfo(bind->pbscb, &bindf, &bi);
 553             if(SUCCEEDED(hres)) {
 554                 WCHAR *urlcopy, *tmpwc;
 555                 URL_COMPONENTSW url;
 556                 WCHAR *host, *path, *user, *pass;
 557                 DWORD lensz = sizeof(bind->expected_size);
 558                 DWORD dwService = 0;
 559                 BOOL bSuccess;
 560
 561                 TRACE("got bindinfo. bindf = %08lx extrainfo = %s bindinfof = %08lx bindverb = %08lx iid %s\n",
 562                       bindf, debugstr_w(bi.szExtraInfo), bi.grfBindInfoF, bi.dwBindVerb, debugstr_guid(&bi.iid));
 563                 hres = IBindStatusCallback_OnStartBinding(bind->pbscb, 0, (IBinding*)bind);
 564                 TRACE("OnStartBinding rets %08lx\n", hres);
 565
 566                 /* This class will accept URLs with the backslash in them. But InternetCrackURL will not - it
 567                  * requires forward slashes (this is the behaviour of Microsoft's INETAPI). So we need to make
 568                  * a copy of the URL here and change the backslash to a forward slash everywhere it appears -
 569                  * but only before any '#' or '?', after which backslash should be left alone.
 570                  */
 571                 urlcopy = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * (lstrlenW(bind->URLName) + 1));
 572                 lstrcpyW(urlcopy, bind->URLName);
 573                 for (tmpwc = urlcopy; *tmpwc && *tmpwc != '#' && *tmpwc != '?'; ++tmpwc)
 574                     if (*tmpwc == '\\')
 575                             *tmpwc = '/';
 576
 577                 bind->expected_size = 0;
 578                 bind->total_read = 0;
 579
 580                 memset(&url, 0, sizeof(url));
 581                 url.dwStructSize = sizeof(url);
 582                 url.dwSchemeLength = url.dwHostNameLength = url.dwUrlPathLength = url.dwUserNameLength = url.dwPasswordLength = 1;
 583                 InternetCrackUrlW(urlcopy, 0, ICU_ESCAPE, &url);
 584                 host = HeapAlloc(GetProcessHeap(), 0, (url.dwHostNameLength + 1) * sizeof(WCHAR));
 585                 memcpy(host, url.lpszHostName, url.dwHostNameLength * sizeof(WCHAR));
 586                 host[url.dwHostNameLength] = '\0';
 587                 path = HeapAlloc(GetProcessHeap(), 0, (url.dwUrlPathLength + 1) * sizeof(WCHAR));
 588                 memcpy(path, url.lpszUrlPath, url.dwUrlPathLength * sizeof(WCHAR));
 589                 path[url.dwUrlPathLength] = '\0';
 590                 if (url.dwUserNameLength)
 591                 {
 592                     user = HeapAlloc(GetProcessHeap(), 0, ((url.dwUserNameLength + 1) * sizeof(WCHAR)));
 593                     memcpy(user, url.lpszUserName, url.dwUserNameLength * sizeof(WCHAR));
 594                     user[url.dwUserNameLength] = 0;
 595                 }
 596                 else
 597                 {
 598                     user = 0;
 599                 }
 600                 if (url.dwPasswordLength)
 601                 {
 602                     pass = HeapAlloc(GetProcessHeap(), 0, ((url.dwPasswordLength + 1) * sizeof(WCHAR)));
 603                     memcpy(pass, url.lpszPassword, url.dwPasswordLength * sizeof(WCHAR));
 604                     pass[url.dwPasswordLength] = 0;
 605                 }
 606                 else
 607                 {
 608                     pass = 0;
 609                 }
 610
 611
 612                 do {
 613                     bind->hinternet = InternetOpenA("User Agent", 0, NULL, NULL, 0);
 614                     if (!bind->hinternet)
 615                     {
 616                             hres = HRESULT_FROM_WIN32(GetLastError());
 617                             break;
 618                     }
 619
 620                     switch ((DWORD) url.nScheme)
 621                     {
 622                     case INTERNET_SCHEME_FTP:
 623                         if (!url.nPort)
 624                             url.nPort = INTERNET_DEFAULT_FTP_PORT;
 625                         dwService = INTERNET_SERVICE_FTP;
 626                         break;
 627
 628                     case INTERNET_SCHEME_GOPHER:
 629                         if (!url.nPort)
 630                             url.nPort = INTERNET_DEFAULT_GOPHER_PORT;
 631                         dwService = INTERNET_SERVICE_GOPHER;
 632                         break;
 633
 634                     case INTERNET_SCHEME_HTTP:
 635                         if (!url.nPort)
 636                             url.nPort = INTERNET_DEFAULT_HTTP_PORT;
 637                         dwService = INTERNET_SERVICE_HTTP;
 638                         break;
 639
 640                     case INTERNET_SCHEME_HTTPS:
 641                         if (!url.nPort)
 642                             url.nPort = INTERNET_DEFAULT_HTTPS_PORT;
 643                         dwService = INTERNET_SERVICE_HTTP;
 644                         break;
 645                     }
 646
 647                     bind->hconnect = InternetConnectW(bind->hinternet, host, url.nPort, user, pass,
 648                                                       dwService, 0, (DWORD)bind);
 649                     if (!bind->hconnect)
 650                     {
 651                             hres = HRESULT_FROM_WIN32(GetLastError());
 652                             CloseHandle(bind->hinternet);
 653                             break;
 654                     }
 655
 656                     hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, 0x22, NULL);
 657                     hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_FINDINGRESOURCE, NULL);
 658                     hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_CONNECTING, NULL);
 659                     hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_SENDINGREQUEST, NULL);
 660
 661                     bSuccess = FALSE;
 662
 663                     switch (dwService)
 664                     {
 665                     case INTERNET_SERVICE_GOPHER:
 666                         bind->hrequest = GopherOpenFileW(bind->hconnect,
 667                                                          path,
 668                                                          0,
 669                                                          INTERNET_FLAG_RELOAD,
 670                                                          0);
 671                         if (bind->hrequest)
 672                                 bSuccess = TRUE;
 673                         else
 674                                 hres = HRESULT_FROM_WIN32(GetLastError());
 675                         break;
 676
 677                     case INTERNET_SERVICE_FTP:
 678                         bind->hrequest = FtpOpenFileW(bind->hconnect,
 679                                                       path,
 680                                                       GENERIC_READ,
 681                                                       FTP_TRANSFER_TYPE_BINARY |
 682                                                        INTERNET_FLAG_TRANSFER_BINARY |
 683                                                        INTERNET_FLAG_RELOAD,
 684                                                       0);
 685                         if (bind->hrequest)
 686                                 bSuccess = TRUE;
 687                         else
 688                                 hres = HRESULT_FROM_WIN32(GetLastError());
 689                         break;
 690
 691                     case INTERNET_SERVICE_HTTP:
 692                         bind->hrequest = HttpOpenRequestW(bind->hconnect, NULL, path, NULL, NULL, NULL, 0, (DWORD)bind);
 693                         if (!bind->hrequest)
 694                         {
 695                                 hres = HRESULT_FROM_WIN32(GetLastError());
 696                         }
 697                         else if (!HttpSendRequestW(bind->hrequest, NULL, 0, NULL, 0))
 698                         {
 699                                 hres = HRESULT_FROM_WIN32(GetLastError());
 700                                 InternetCloseHandle(bind->hrequest);
 701                         }
 702                         else
 703                         {
 704                                 HttpQueryInfoW(bind->hrequest,
 705                                                HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER,
 706                                                &bind->expected_size,
 707                                                &lensz,
 708                                                NULL);
 709                                 bSuccess = TRUE;
 710                         }
 711                         break;
 712                     }
 713                     if(bSuccess)
 714                     {
 715                         TRACE("res = %ld gle = %08lx url len = %ld\n", hres, GetLastError(), bind->expected_size);
 716
 717                         IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_CACHEFILENAMEAVAILABLE, szFileName);
 718
 719                         while(1) {
 720                             char buf[4096];
 721                             DWORD bufread;
 722                             if(InternetReadFile(bind->hrequest, buf, sizeof(buf), &bufread)) {
 723                                 TRACE("read %ld bytes %s...\n", bufread, debugstr_an(buf, 10));
 724                                 if(bufread == 0) break;
 725                                 hres = Binding_MoreCacheData(bind, buf, bufread);
 726                             } else
 727                                 break;
 728                         }
 729                         InternetCloseHandle(bind->hrequest);
 730                             hres = S_OK;
 731                     }
 732
 733                     InternetCloseHandle(bind->hconnect);
 734                     InternetCloseHandle(bind->hinternet);
 735                 } while(0);
 736
 737                 Binding_FinishedDownload(bind, hres);
 738                 Binding_CloseCacheDownload(bind);
 739
 740                 HeapFree(GetProcessHeap(), 0, user);
 741                 HeapFree(GetProcessHeap(), 0, pass);
 742                 HeapFree(GetProcessHeap(), 0, path);
 743                 HeapFree(GetProcessHeap(), 0, host);
 744                 HeapFree(GetProcessHeap(), 0, urlcopy);
 745             }
 746         }
 747     }
 748
 749     IBinding_Release((IBinding*)bind);
 750
 751     return hres;
 752 }
 753
 754 static HRESULT WINAPI URLMonikerImpl_BindToStorage(IMoniker* iface,
 755                                                    IBindCtx* pbc,
 756                                                    IMoniker* pmkToLeft,
 757                                                    REFIID riid,
 758                                                    VOID** ppvObject)
 759 {
 760     URLMonikerImpl *This = (URLMonikerImpl*)iface;
 761     WCHAR schema[64];
 762     BOOL bret;
 763
 764     URL_COMPONENTSW url = {sizeof(URL_COMPONENTSW), schema,
 765         sizeof(schema)/sizeof(WCHAR), 0, NULL, 0, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0};
 766
 767     bret = InternetCrackUrlW(This->URLName, 0, ICU_ESCAPE, &url);
 768     if(!bret) {
 769         ERR("InternetCrackUrl failed: %ld\n", GetLastError());
 770         return E_FAIL;
 771     }
 772
 773     if(url.nScheme == INTERNET_SCHEME_HTTP
 774        || url.nScheme== INTERNET_SCHEME_HTTPS
 775        || url.nScheme== INTERNET_SCHEME_FTP
 776        || url.nScheme == INTERNET_SCHEME_GOPHER)
 777         return URLMonikerImpl_BindToStorage_hack(This->URLName, pbc, pmkToLeft, riid, ppvObject);
 778
 779     TRACE("(%p)->(%p %p %s %p)\n", This, pbc, pmkToLeft, debugstr_guid(riid), ppvObject);
 780
 781     return start_binding(This->URLName, pbc, riid, ppvObject);
 782 }
 783
 784 /******************************************************************************
 785  *        URLMoniker_Reduce
 786  ******************************************************************************/
 787 static HRESULT WINAPI URLMonikerImpl_Reduce(IMoniker* iface,
 788                                             IBindCtx* pbc,
 789                                             DWORD dwReduceHowFar,
 790                                             IMoniker** ppmkToLeft,
 791                                             IMoniker** ppmkReduced)
 792 {
 793     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 794
 795     TRACE("(%p,%p,%ld,%p,%p)\n",This,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
 796
 797     if(!ppmkReduced)
 798         return E_INVALIDARG;
 799
 800     URLMonikerImpl_AddRef(iface);
 801     *ppmkReduced = iface;
 802     return MK_S_REDUCED_TO_SELF;
 803 }
 804
 805 /******************************************************************************
 806  *        URLMoniker_ComposeWith
 807  ******************************************************************************/
 808 static HRESULT WINAPI URLMonikerImpl_ComposeWith(IMoniker* iface,
 809                                                  IMoniker* pmkRight,
 810                                                  BOOL fOnlyIfNotGeneric,
 811                                                  IMoniker** ppmkComposite)
 812 {
 813     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 814     FIXME("(%p)->(%p,%d,%p): stub\n",This,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
 815
 816     return E_NOTIMPL;
 817 }
 818
 819 /******************************************************************************
 820  *        URLMoniker_Enum
 821  ******************************************************************************/
 822 static HRESULT WINAPI URLMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
 823 {
 824     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 825     TRACE("(%p,%d,%p)\n",This,fForward,ppenumMoniker);
 826
 827     if(!ppenumMoniker)
 828         return E_INVALIDARG;
 829
 830     /* Does not support sub-monikers */
 831     *ppenumMoniker = NULL;
 832     return S_OK;
 833 }
 834
 835 /******************************************************************************
 836  *        URLMoniker_IsEqual
 837  ******************************************************************************/
 838 static HRESULT WINAPI URLMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
 839 {
 840     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 841     CLSID clsid;
 842     LPOLESTR urlPath;
 843     IBindCtx* bind;
 844     HRESULT res;
 845
 846     TRACE("(%p,%p)\n",This,pmkOtherMoniker);
 847
 848     if(pmkOtherMoniker==NULL)
 849         return E_INVALIDARG;
 850
 851     IMoniker_GetClassID(pmkOtherMoniker,&clsid);
 852
 853     if(!IsEqualCLSID(&clsid,&CLSID_StdURLMoniker))
 854         return S_FALSE;
 855
 856     res = CreateBindCtx(0,&bind);
 857     if(FAILED(res))
 858         return res;
 859
 860     res = S_FALSE;
 861     if(SUCCEEDED(IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&urlPath))) {
 862         int result = lstrcmpiW(urlPath, This->URLName);
 863         CoTaskMemFree(urlPath);
 864         if(result == 0)
 865             res = S_OK;
 866     }
 867     IUnknown_Release(bind);
 868     return res;
 869 }
 870
 871
 872 /******************************************************************************
 873  *        URLMoniker_Hash
 874  ******************************************************************************/
 875 static HRESULT WINAPI URLMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
 876 {
 877     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 878
 879     int  h = 0,i,skip,len;
 880     int  off = 0;
 881     LPOLESTR val;
 882
 883     TRACE("(%p,%p)\n",This,pdwHash);
 884
 885     if(!pdwHash)
 886         return E_INVALIDARG;
 887
 888     val = This->URLName;
 889     len = lstrlenW(val);
 890
 891     if(len < 16) {
 892         for(i = len ; i > 0; i--) {
 893             h = (h * 37) + val[off++];
 894         }
 895     }
 896     else {
 897         /* only sample some characters */
 898         skip = len / 8;
 899         for(i = len; i > 0; i -= skip, off += skip) {
 900             h = (h * 39) + val[off];
 901         }
 902     }
 903     *pdwHash = h;
 904     return S_OK;
 905 }
 906
 907 /******************************************************************************
 908  *        URLMoniker_IsRunning
 909  ******************************************************************************/
 910 static HRESULT WINAPI URLMonikerImpl_IsRunning(IMoniker* iface,
 911                                                IBindCtx* pbc,
 912                                                IMoniker* pmkToLeft,
 913                                                IMoniker* pmkNewlyRunning)
 914 {
 915     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 916     FIXME("(%p)->(%p,%p,%p): stub\n",This,pbc,pmkToLeft,pmkNewlyRunning);
 917
 918     return E_NOTIMPL;
 919 }
 920
 921 /******************************************************************************
 922  *        URLMoniker_GetTimeOfLastChange
 923  ******************************************************************************/
 924 static HRESULT WINAPI URLMonikerImpl_GetTimeOfLastChange(IMoniker* iface,
 925                                                          IBindCtx* pbc,
 926                                                          IMoniker* pmkToLeft,
 927                                                          FILETIME* pFileTime)
 928 {
 929     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 930     FIXME("(%p)->(%p,%p,%p): stub\n",This,pbc,pmkToLeft,pFileTime);
 931
 932     return E_NOTIMPL;
 933 }
 934
 935 /******************************************************************************
 936  *        URLMoniker_Inverse
 937  ******************************************************************************/
 938 static HRESULT WINAPI URLMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
 939 {
 940     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 941     TRACE("(%p,%p)\n",This,ppmk);
 942
 943     return MK_E_NOINVERSE;
 944 }
 945
 946 /******************************************************************************
 947  *        URLMoniker_CommonPrefixWith
 948  ******************************************************************************/
 949 static HRESULT WINAPI URLMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
 950 {
 951     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 952     FIXME("(%p)->(%p,%p): stub\n",This,pmkOther,ppmkPrefix);
 953
 954     return E_NOTIMPL;
 955 }
 956
 957 /******************************************************************************
 958  *        URLMoniker_RelativePathTo
 959  ******************************************************************************/
 960 static HRESULT WINAPI URLMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
 961 {
 962     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 963     FIXME("(%p)->(%p,%p): stub\n",This,pmOther,ppmkRelPath);
 964
 965     return E_NOTIMPL;
 966 }
 967
 968 /******************************************************************************
 969  *        URLMoniker_GetDisplayName
 970  ******************************************************************************/
 971 static HRESULT WINAPI URLMonikerImpl_GetDisplayName(IMoniker* iface,
 972                                                     IBindCtx* pbc,
 973                                                     IMoniker* pmkToLeft,
 974                                                     LPOLESTR *ppszDisplayName)
 975 {
 976     URLMonikerImpl *This = (URLMonikerImpl *)iface;
 977
 978     int len;
 979
 980     TRACE("(%p,%p,%p,%p)\n",This,pbc,pmkToLeft,ppszDisplayName);
 981
 982     if(!ppszDisplayName)
 983         return E_INVALIDARG;
 984
 985     /* FIXME: If this is a partial URL, try and get a URL moniker from SZ_URLCONTEXT in the bind context,
 986         then look at pmkToLeft to try and complete the URL
 987     */
 988     len = lstrlenW(This->URLName)+1;
 989     *ppszDisplayName = CoTaskMemAlloc(len*sizeof(WCHAR));
 990     if(!*ppszDisplayName)
 991         return E_OUTOFMEMORY;
 992     lstrcpyW(*ppszDisplayName, This->URLName);
 993     return S_OK;
 994 }
 995
 996 /******************************************************************************
 997  *        URLMoniker_ParseDisplayName
 998  ******************************************************************************/
 999 static HRESULT WINAPI URLMonikerImpl_ParseDisplayName(IMoniker* iface,
1000                                                       IBindCtx* pbc,
1001                                                       IMoniker* pmkToLeft,
1002                                                       LPOLESTR pszDisplayName,
1003                                                       ULONG* pchEaten,
1004                                                       IMoniker** ppmkOut)
1005 {
1006     URLMonikerImpl *This = (URLMonikerImpl *)iface;
1007     FIXME("(%p)->(%p,%p,%p,%p,%p): stub\n",This,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
1008
1009     return E_NOTIMPL;
1010 }
1011
1012 /******************************************************************************
1013  *        URLMoniker_IsSystemMoniker
1014  ******************************************************************************/
1015 static HRESULT WINAPI URLMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
1016 {
1017     URLMonikerImpl *This = (URLMonikerImpl *)iface;
1018     TRACE("(%p,%p)\n",This,pwdMksys);
1019
1020     if(!pwdMksys)
1021         return E_INVALIDARG;
1022
1023     *pwdMksys = MKSYS_URLMONIKER;
1024     return S_OK;
1025 }
1026
1027 /********************************************************************************/
1028 /* Virtual function table for the URLMonikerImpl class which  include IPersist,*/
1029 /* IPersistStream and IMoniker functions.                                       */
1030 static const IMonikerVtbl VT_URLMonikerImpl =
1031 {
1032     URLMonikerImpl_QueryInterface,
1033     URLMonikerImpl_AddRef,
1034     URLMonikerImpl_Release,
1035     URLMonikerImpl_GetClassID,
1036     URLMonikerImpl_IsDirty,
1037     URLMonikerImpl_Load,
1038     URLMonikerImpl_Save,
1039     URLMonikerImpl_GetSizeMax,
1040     URLMonikerImpl_BindToObject,
1041     URLMonikerImpl_BindToStorage,
1042     URLMonikerImpl_Reduce,
1043     URLMonikerImpl_ComposeWith,
1044     URLMonikerImpl_Enum,
1045     URLMonikerImpl_IsEqual,
1046     URLMonikerImpl_Hash,
1047     URLMonikerImpl_IsRunning,
1048     URLMonikerImpl_GetTimeOfLastChange,
1049     URLMonikerImpl_Inverse,
1050     URLMonikerImpl_CommonPrefixWith,
1051     URLMonikerImpl_RelativePathTo,
1052     URLMonikerImpl_GetDisplayName,
1053     URLMonikerImpl_ParseDisplayName,
1054     URLMonikerImpl_IsSystemMoniker
1055 };
1056
1057 /******************************************************************************
1058  *         URLMoniker_Construct (local function)
1059  *******************************************************************************/
1060 static HRESULT URLMonikerImpl_Construct(URLMonikerImpl* This, LPCOLESTR lpszLeftURLName, LPCOLESTR lpszURLName)
1061 {
1062     HRESULT hres;
1063     DWORD sizeStr = INTERNET_MAX_URL_LENGTH;
1064
1065     TRACE("(%p,%s,%s)\n",This,debugstr_w(lpszLeftURLName),debugstr_w(lpszURLName));
1066
1067     This->lpvtbl = &VT_URLMonikerImpl;
1068     This->ref = 0;
1069
1070     sizeStr = lstrlenW(lpszURLName)+1;
1071     if(lpszLeftURLName)
1072         sizeStr += strlenW(lpszLeftURLName)+32;
1073
1074     This->URLName = HeapAlloc(GetProcessHeap(), 0, sizeStr*sizeof(WCHAR));
1075
1076     if(lpszLeftURLName) {
1077         hres = CoInternetCombineUrl(lpszLeftURLName, lpszURLName, URL_FILE_USE_PATHURL,
1078                                     This->URLName, sizeStr, &sizeStr, 0);
1079         if(FAILED(hres)) {
1080             HeapFree(GetProcessHeap(), 0, This->URLName);
1081             return hres;
1082         }
1083     }else {
1084         /* FIXME:
1085          * We probably should use CoInternetParseUrl or something similar here.
1086          */
1087
1088         static const WCHAR wszFile[] = {'f','i','l','e',':','/','/',};
1089
1090         /* file protocol is a special case */
1091         if(sizeStr > sizeof(wszFile)/sizeof(WCHAR)
1092                 && !memcmp(lpszURLName, wszFile, sizeof(wszFile)))
1093             UrlCanonicalizeW(lpszURLName, This->URLName, &sizeStr, URL_FILE_USE_PATHURL);
1094         else
1095             strcpyW(This->URLName,lpszURLName);
1096     }
1097
1098     URLMON_LockModule();
1099
1100     return S_OK;
1101 }
1102
1103 /***********************************************************************
1104  *           CreateAsyncBindCtx (URLMON.@)
1105  */
1106 HRESULT WINAPI CreateAsyncBindCtx(DWORD reserved, IBindStatusCallback *callback,
1107     IEnumFORMATETC *format, IBindCtx **pbind)
1108 {
1109     TRACE("(%08lx %p %p %p)\n", reserved, callback, format, pbind);
1110
1111     if(!callback)
1112         return E_INVALIDARG;
1113
1114     return CreateAsyncBindCtxEx(NULL, 0, callback, format, pbind, 0);
1115 }
1116 /***********************************************************************
1117  *           CreateAsyncBindCtxEx (URLMON.@)
1118  *
1119  * Create an asynchronous bind context.
1120  */
1121 HRESULT WINAPI CreateAsyncBindCtxEx(IBindCtx *ibind, DWORD options,
1122     IBindStatusCallback *callback, IEnumFORMATETC *format, IBindCtx** pbind,
1123     DWORD reserved)
1124 {
1125     HRESULT hres;
1126     BIND_OPTS bindopts;
1127     IBindCtx *bctx;
1128
1129     TRACE("(%p %08lx %p %p %p %ld)\n", ibind, options, callback, format, pbind, reserved);
1130
1131     if(!pbind)
1132         return E_INVALIDARG;
1133
1134     if(options)
1135         FIXME("not supported options %08lx", options);
1136     if(format)
1137         FIXME("format is not supported\n");
1138
1139     if(reserved)
1140         WARN("reserved=%ld\n", reserved);
1141
1142     hres = CreateBindCtx(0, &bctx);
1143     if(FAILED(hres))
1144         return hres;
1145
1146     bindopts.cbStruct = sizeof(BIND_OPTS);
1147     bindopts.grfFlags = BIND_MAYBOTHERUSER;
1148     bindopts.grfMode = STGM_READWRITE | STGM_SHARE_EXCLUSIVE;
1149     bindopts.dwTickCountDeadline = 0;
1150     IBindCtx_SetBindOptions(bctx, &bindopts);
1151
1152     if(callback)
1153         RegisterBindStatusCallback(bctx, callback, NULL, 0);
1154
1155     *pbind = bctx;
1156
1157     return S_OK;
1158 }
1159
1160
1161 /***********************************************************************
1162  *           CreateURLMoniker (URLMON.@)
1163  *
1164  * Create a url moniker.
1165  *
1166  * PARAMS
1167  *    pmkContext [I] Context
1168  *    szURL      [I] Url to create the moniker for
1169  *    ppmk       [O] Destination for created moniker.
1170  *
1171  * RETURNS
1172  *    Success: S_OK. ppmk contains the created IMoniker object.
1173  *    Failure: MK_E_SYNTAX if szURL is not a valid url, or
1174  *             E_OUTOFMEMORY if memory allocation fails.
1175  */
1176 HRESULT WINAPI CreateURLMoniker(IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk)
1177 {
1178     URLMonikerImpl *obj;
1179     HRESULT hres;
1180     IID iid = IID_IMoniker;
1181     LPOLESTR lefturl = NULL;
1182
1183     TRACE("(%p, %s, %p)\n", pmkContext, debugstr_w(szURL), ppmk);
1184
1185     if(!(obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*obj))))
1186         return E_OUTOFMEMORY;
1187
1188     if(pmkContext) {
1189         IBindCtx* bind;
1190         DWORD dwMksys = 0;
1191         IMoniker_IsSystemMoniker(pmkContext, &dwMksys);
1192         if(dwMksys == MKSYS_URLMONIKER && SUCCEEDED(CreateBindCtx(0, &bind))) {
1193             IMoniker_GetDisplayName(pmkContext, bind, NULL, &lefturl);
1194             TRACE("lefturl = %s\n", debugstr_w(lefturl));
1195             IBindCtx_Release(bind);
1196         }
1197     }
1198
1199     hres = URLMonikerImpl_Construct(obj, lefturl, szURL);
1200     CoTaskMemFree(lefturl);
1201     if(SUCCEEDED(hres))
1202         hres = URLMonikerImpl_QueryInterface((IMoniker*)obj, &iid, (void**)ppmk);
1203     else
1204         HeapFree(GetProcessHeap(), 0, obj);
1205     return hres;
1206 }
1207
1208 /***********************************************************************
1209  *           CoInternetQueryInfo (URLMON.@)
1210  *
1211  * Retrieves information relevant to a specified URL
1212  *
1213  * RETURNS
1214  *    S_OK                      success
1215  *    S_FALSE                   buffer too small
1216  *    INET_E_QUERYOPTIONUNKNOWN invalid option
1217  *
1218  */
1219 HRESULT WINAPI CoInternetQueryInfo(LPCWSTR pwzUrl, QUERYOPTION QueryOption,
1220   DWORD dwQueryFlags, LPVOID pvBuffer, DWORD cbBuffer, DWORD * pcbBuffer,
1221   DWORD dwReserved)
1222 {
1223   FIXME("(%s, %x, %lx, %p, %lx, %p, %lx): stub\n", debugstr_w(pwzUrl),
1224     QueryOption, dwQueryFlags, pvBuffer, cbBuffer, pcbBuffer, dwReserved);
1225   return S_OK;
1226 }
1227
1228 /***********************************************************************
1229  *           IsAsyncMoniker (URLMON.@)
1230  */
1231 HRESULT WINAPI IsAsyncMoniker(IMoniker *pmk)
1232 {
1233     IUnknown *am;
1234
1235     TRACE("(%p)\n", pmk);
1236     if(!pmk)
1237         return E_INVALIDARG;
1238     if(SUCCEEDED(IMoniker_QueryInterface(pmk, &IID_IAsyncMoniker, (void**)&am))) {
1239         IUnknown_Release(am);
1240         return S_OK;
1241     }
1242     return S_FALSE;
1243 }
1244
1245 /***********************************************************************
1246  *           BindAsyncMoniker (URLMON.@)
1247  *
1248  * Bind a bind status callback to an asynchronous URL Moniker.
1249  *
1250  * PARAMS
1251  *  pmk           [I] Moniker object to bind status callback to
1252  *  grfOpt        [I] Options, seems not used
1253  *  pbsc          [I] Status callback to bind
1254  *  iidResult     [I] Interface to return
1255  *  ppvResult     [O] Resulting asynchronous moniker object
1256  *
1257  * RETURNS
1258  *    Success: S_OK.
1259  *    Failure: E_INVALIDARG, if any argument is invalid, or
1260  *             E_OUTOFMEMORY if memory allocation fails.
1261  */
1262 HRESULT WINAPI BindAsyncMoniker(IMoniker *pmk, DWORD grfOpt, IBindStatusCallback *pbsc, REFIID iidResult, LPVOID *ppvResult)
1263 {
1264     LPBC pbc = NULL;
1265     HRESULT hr = E_INVALIDARG;
1266
1267     if (pmk && ppvResult)
1268     {
1269         *ppvResult = NULL;
1270
1271         hr = CreateAsyncBindCtx(0, pbsc, NULL, &pbc);
1272         if (hr == NOERROR)
1273         {
1274             hr = IMoniker_BindToObject(pmk, pbc, NULL, iidResult, ppvResult);
1275             IBindCtx_Release(pbc);
1276         }
1277     }
1278     return hr;
1279 }
1280
1281 /***********************************************************************
1282  *           RegisterBindStatusCallback (URLMON.@)
1283  *
1284  * Register a bind status callback.
1285  *
1286  * PARAMS
1287  *  pbc           [I] Binding context
1288  *  pbsc          [I] Callback to register
1289  *  ppbscPrevious [O] Destination for previous callback
1290  *  dwReserved    [I] Reserved, must be 0.
1291  *
1292  * RETURNS
1293  *    Success: S_OK.
1294  *    Failure: E_INVALIDARG, if any argument is invalid, or
1295  *             E_OUTOFMEMORY if memory allocation fails.
1296  */
1297 HRESULT WINAPI RegisterBindStatusCallback(
1298     IBindCtx *pbc,
1299     IBindStatusCallback *pbsc,
1300     IBindStatusCallback **ppbscPrevious,
1301     DWORD dwReserved)
1302 {
1303     IBindStatusCallback *prev;
1304
1305     TRACE("(%p,%p,%p,%lu)\n", pbc, pbsc, ppbscPrevious, dwReserved);
1306
1307     if (pbc == NULL || pbsc == NULL)
1308         return E_INVALIDARG;
1309
1310     if (SUCCEEDED(IBindCtx_GetObjectParam(pbc, (LPOLESTR)BSCBHolder, (IUnknown **)&prev)))
1311     {
1312         IBindCtx_RevokeObjectParam(pbc, (LPOLESTR)BSCBHolder);
1313         if (ppbscPrevious)
1314             *ppbscPrevious = prev;
1315         else
1316             IBindStatusCallback_Release(prev);
1317     }
1318
1319     return IBindCtx_RegisterObjectParam(pbc, (LPOLESTR)BSCBHolder, (IUnknown *)pbsc);
1320 }
1321
1322 /***********************************************************************
1323  *           RevokeBindStatusCallback (URLMON.@)
1324  *
1325  * Unregister a bind status callback.
1326  *
1327  *  pbc           [I] Binding context
1328  *  pbsc          [I] Callback to unregister
1329  *
1330  * RETURNS
1331  *    Success: S_OK.
1332  *    Failure: E_INVALIDARG, if any argument is invalid, or
1333  *             E_FAIL if pbsc wasn't registered with pbc.
1334  */
1335 HRESULT WINAPI RevokeBindStatusCallback(
1336     IBindCtx *pbc,
1337     IBindStatusCallback *pbsc)
1338 {
1339     IBindStatusCallback *callback;
1340     HRESULT hr = E_FAIL;
1341
1342         TRACE("(%p,%p)\n", pbc, pbsc);
1343
1344     if (pbc == NULL || pbsc == NULL)
1345         return E_INVALIDARG;
1346
1347     if (SUCCEEDED(IBindCtx_GetObjectParam(pbc, (LPOLESTR)BSCBHolder, (IUnknown **)&callback)))
1348     {
1349         if (callback == pbsc)
1350         {
1351             IBindCtx_RevokeObjectParam(pbc, (LPOLESTR)BSCBHolder);
1352             hr = S_OK;
1353         }
1354         IBindStatusCallback_Release(pbsc);
1355     }
1356
1357     return hr;
1358 }
1359
1360 /***********************************************************************
1361  *           URLDownloadToFileA (URLMON.@)
1362  *
1363  * Downloads URL szURL to rile szFileName and call lpfnCB callback to
1364  * report progress.
1365  *
1366  * PARAMS
1367  *  pCaller    [I] controlling IUnknown interface.
1368  *  szURL      [I] URL of the file to download
1369  *  szFileName [I] file name to store the content of the URL
1370  *  dwReserved [I] reserved - set to 0
1371  *  lpfnCB     [I] callback for progress report
1372  *
1373  * RETURNS
1374  *  S_OK on success
1375  *  E_OUTOFMEMORY when going out of memory
1376  */
1377 HRESULT WINAPI URLDownloadToFileA(LPUNKNOWN pCaller,
1378                                   LPCSTR szURL,
1379                                   LPCSTR szFileName,
1380                                   DWORD dwReserved,
1381                                   LPBINDSTATUSCALLBACK lpfnCB)
1382 {
1383     UNICODE_STRING szURL_w, szFileName_w;
1384
1385     if ((szURL == NULL) || (szFileName == NULL)) {
1386         FIXME("(%p,%s,%s,%08lx,%p) cannot accept NULL strings !\n", pCaller, debugstr_a(szURL), debugstr_a(szFileName), dwReserved, lpfnCB);
1387         return E_INVALIDARG; /* The error code is not specified in this case... */
1388     }
1389
1390     if (RtlCreateUnicodeStringFromAsciiz(&szURL_w, szURL)) {
1391         if (RtlCreateUnicodeStringFromAsciiz(&szFileName_w, szFileName)) {
1392             HRESULT ret = URLDownloadToFileW(pCaller, szURL_w.Buffer, szFileName_w.Buffer, dwReserved, lpfnCB);
1393
1394             RtlFreeUnicodeString(&szURL_w);
1395             RtlFreeUnicodeString(&szFileName_w);
1396
1397             return ret;
1398         } else {
1399             RtlFreeUnicodeString(&szURL_w);
1400         }
1401     }
1402
1403     FIXME("(%p,%s,%s,%08lx,%p) could not allocate W strings !\n", pCaller, szURL, szFileName, dwReserved, lpfnCB);
1404     return E_OUTOFMEMORY;
1405 }
1406
1407 /***********************************************************************
1408  *           URLDownloadToFileW (URLMON.@)
1409  *
1410  * Downloads URL szURL to rile szFileName and call lpfnCB callback to
1411  * report progress.
1412  *
1413  * PARAMS
1414  *  pCaller    [I] controlling IUnknown interface.
1415  *  szURL      [I] URL of the file to download
1416  *  szFileName [I] file name to store the content of the URL
1417  *  dwReserved [I] reserved - set to 0
1418  *  lpfnCB     [I] callback for progress report
1419  *
1420  * RETURNS
1421  *  S_OK on success
1422  *  E_OUTOFMEMORY when going out of memory
1423  */
1424 HRESULT WINAPI URLDownloadToFileW(LPUNKNOWN pCaller,
1425                                   LPCWSTR szURL,
1426                                   LPCWSTR szFileName,
1427                                   DWORD dwReserved,
1428                                   LPBINDSTATUSCALLBACK lpfnCB)
1429 {
1430     HINTERNET hinternet, hcon, hreq;
1431     BOOL r;
1432     CHAR buffer[0x1000];
1433     DWORD sz, total, written;
1434     DWORD total_size = 0xFFFFFFFF, arg_size = sizeof(total_size);
1435     URL_COMPONENTSW url;
1436     WCHAR host[0x80], path[0x100];
1437     HANDLE hfile;
1438     static const WCHAR wszAppName[]={'u','r','l','m','o','n','.','d','l','l',0};
1439
1440     /* Note: all error codes would need to be checked agains real Windows behaviour... */
1441     TRACE("(%p,%s,%s,%08lx,%p) stub!\n", pCaller, debugstr_w(szURL), debugstr_w(szFileName), dwReserved, lpfnCB);
1442
1443     if ((szURL == NULL) || (szFileName == NULL)) {
1444         FIXME(" cannot accept NULL strings !\n");
1445         return E_INVALIDARG;
1446     }
1447
1448     /* Would be better to use the application name here rather than 'urlmon' :-/ */
1449     hinternet = InternetOpenW(wszAppName, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
1450     if (hinternet == NULL) {
1451         return E_OUTOFMEMORY;
1452     }
1453
1454     memset(&url, 0, sizeof(url));
1455     url.dwStructSize = sizeof(url);
1456     url.lpszHostName = host;
1457     url.dwHostNameLength = sizeof(host);
1458     url.lpszUrlPath = path;
1459     url.dwUrlPathLength = sizeof(path);
1460
1461     if (!InternetCrackUrlW(szURL, 0, 0, &url)) {
1462         InternetCloseHandle(hinternet);
1463         return E_OUTOFMEMORY;
1464     }
1465
1466     if (lpfnCB) {
1467         if (IBindStatusCallback_OnProgress(lpfnCB, 0, 0, BINDSTATUS_CONNECTING, url.lpszHostName) == E_ABORT) {
1468             InternetCloseHandle(hinternet);
1469             return S_OK;
1470         }
1471     }
1472
1473     hcon = InternetConnectW(hinternet, url.lpszHostName, url.nPort,
1474                             url.lpszUserName, url.lpszPassword,
1475                             INTERNET_SERVICE_HTTP, 0, 0);
1476     if (!hcon) {
1477         InternetCloseHandle(hinternet);
1478         return E_OUTOFMEMORY;
1479     }
1480
1481     hreq = HttpOpenRequestW(hcon, NULL, url.lpszUrlPath, NULL, NULL, NULL, 0, 0);
1482     if (!hreq) {
1483         InternetCloseHandle(hinternet);
1484         InternetCloseHandle(hcon);
1485         return E_OUTOFMEMORY;
1486     }
1487
1488     if (!HttpSendRequestW(hreq, NULL, 0, NULL, 0)) {
1489         InternetCloseHandle(hinternet);
1490         InternetCloseHandle(hcon);
1491         InternetCloseHandle(hreq);
1492         return E_OUTOFMEMORY;
1493     }
1494
1495     if (HttpQueryInfoW(hreq, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER,
1496                        &total_size, &arg_size, NULL)) {
1497         TRACE(" total size : %ld\n", total_size);
1498     }
1499
1500     hfile = CreateFileW(szFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
1501                         FILE_ATTRIBUTE_NORMAL, NULL );
1502     if (hfile == INVALID_HANDLE_VALUE) {
1503         return E_ACCESSDENIED;
1504     }
1505
1506     if (lpfnCB) {
1507         if (IBindStatusCallback_OnProgress(lpfnCB, 0, total_size != 0xFFFFFFFF ? total_size : 0,
1508                                            BINDSTATUS_BEGINDOWNLOADDATA, szURL) == E_ABORT) {
1509             InternetCloseHandle(hreq);
1510             InternetCloseHandle(hcon);
1511             InternetCloseHandle(hinternet);
1512             CloseHandle(hfile);
1513             return S_OK;
1514         }
1515     }
1516
1517     total = 0;
1518     while (1) {
1519         r = InternetReadFile(hreq, buffer, sizeof(buffer), &sz);
1520         if (!r) {
1521             InternetCloseHandle(hreq);
1522             InternetCloseHandle(hcon);
1523             InternetCloseHandle(hinternet);
1524
1525             CloseHandle(hfile);
1526             return E_OUTOFMEMORY;
1527         }
1528         if (!sz)
1529             break;
1530
1531         total += sz;
1532
1533         if (lpfnCB) {
1534             if (IBindStatusCallback_OnProgress(lpfnCB, total, total_size != 0xFFFFFFFF ? total_size : 0,
1535                                                BINDSTATUS_DOWNLOADINGDATA, szURL) == E_ABORT) {
1536                 InternetCloseHandle(hreq);
1537                 InternetCloseHandle(hcon);
1538                 InternetCloseHandle(hinternet);
1539                 CloseHandle(hfile);
1540                 return S_OK;
1541             }
1542         }
1543
1544         if (!WriteFile(hfile, buffer, sz, &written, NULL)) {
1545             InternetCloseHandle(hreq);
1546             InternetCloseHandle(hcon);
1547             InternetCloseHandle(hinternet);
1548
1549             CloseHandle(hfile);
1550             return E_OUTOFMEMORY;
1551         }
1552     }
1553
1554     if (lpfnCB) {
1555         if (IBindStatusCallback_OnProgress(lpfnCB, total, total_size != 0xFFFFFFFF ? total_size : 0,
1556                                            BINDSTATUS_ENDDOWNLOADDATA, szURL) == E_ABORT) {
1557             InternetCloseHandle(hreq);
1558             InternetCloseHandle(hcon);
1559             InternetCloseHandle(hinternet);
1560             CloseHandle(hfile);
1561             return S_OK;
1562         }
1563     }
1564
1565     InternetCloseHandle(hreq);
1566     InternetCloseHandle(hcon);
1567     InternetCloseHandle(hinternet);
1568
1569     CloseHandle(hfile);
1570
1571     return S_OK;
1572 }
1573
1574 /***********************************************************************
1575  *           URLDownloadToCacheFileA (URLMON.@)
1576  */
1577 HRESULT WINAPI URLDownloadToCacheFileA(LPUNKNOWN lpUnkCaller, LPCSTR szURL, LPSTR szFileName,
1578         DWORD dwBufLength, DWORD dwReserved, LPBINDSTATUSCALLBACK pBSC)
1579 {
1580     LPWSTR url = NULL, file_name = NULL;
1581     int len;
1582     HRESULT hres;
1583
1584     TRACE("(%p %s %p %ld %ld %p)\n", lpUnkCaller, debugstr_a(szURL), szFileName,
1585             dwBufLength, dwReserved, pBSC);
1586
1587     if(szURL) {
1588         len = MultiByteToWideChar(CP_ACP, 0, szURL, -1, NULL, 0);
1589         url = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
1590         MultiByteToWideChar(CP_ACP, 0, szURL, -1, url, -1);
1591     }
1592
1593     if(szFileName)
1594         file_name = HeapAlloc(GetProcessHeap(), 0, dwBufLength*sizeof(WCHAR));
1595
1596     hres = URLDownloadToCacheFileW(lpUnkCaller, url, file_name, dwBufLength*sizeof(WCHAR),
1597             dwReserved, pBSC);
1598
1599     if(SUCCEEDED(hres) && file_name)
1600         WideCharToMultiByte(CP_ACP, 0, file_name, -1, szFileName, dwBufLength, NULL, NULL);
1601
1602     HeapFree(GetProcessHeap(), 0, url);
1603     HeapFree(GetProcessHeap(), 0, file_name);
1604
1605     return hres;
1606 }
1607
1608 /***********************************************************************
1609  *           URLDownloadToCacheFileW (URLMON.@)
1610  */
1611 HRESULT WINAPI URLDownloadToCacheFileW(LPUNKNOWN lpUnkCaller, LPCWSTR szURL, LPWSTR szFileName,
1612                 DWORD dwBufLength, DWORD dwReserved, LPBINDSTATUSCALLBACK pBSC)
1613 {
1614     WCHAR cache_path[MAX_PATH + 1];
1615     FILETIME expire, modified;
1616     HRESULT hr;
1617     LPWSTR ext;
1618
1619     static const WCHAR header[] = {
1620         'H','T','T','P','/','1','.','0',' ','2','0','0',' ',
1621         'O','K','\\','r','\\','n','\\','r','\\','n',0
1622     };
1623
1624     TRACE("(%p, %s, %p, %ld, %ld, %p)\n", lpUnkCaller, debugstr_w(szURL),
1625           szFileName, dwBufLength, dwReserved, pBSC);
1626
1627     if (!szURL || !szFileName)
1628         return E_INVALIDARG;
1629
1630     ext = PathFindExtensionW(szURL);
1631
1632     if (!CreateUrlCacheEntryW(szURL, 0, ext, cache_path, 0))
1633         return E_FAIL;
1634
1635     hr = URLDownloadToFileW(lpUnkCaller, szURL, cache_path, 0, pBSC);
1636     if (FAILED(hr))
1637         return hr;
1638
1639     expire.dwHighDateTime = 0;
1640     expire.dwLowDateTime = 0;
1641     modified.dwHighDateTime = 0;
1642     modified.dwLowDateTime = 0;
1643
1644     if (!CommitUrlCacheEntryW(szURL, cache_path, expire, modified, NORMAL_CACHE_ENTRY,
1645                               (LPWSTR)header, sizeof(header), NULL, NULL))
1646         return E_FAIL;
1647
1648     if (lstrlenW(cache_path) > dwBufLength)
1649         return E_OUTOFMEMORY;
1650
1651     lstrcpyW(szFileName, cache_path);
1652
1653     return S_OK;
1654 }
1655
1656 /***********************************************************************
1657  *           HlinkSimpleNavigateToString (URLMON.@)
1658  */
1659 HRESULT WINAPI HlinkSimpleNavigateToString( LPCWSTR szTarget,
1660     LPCWSTR szLocation, LPCWSTR szTargetFrameName, IUnknown *pUnk,
1661     IBindCtx *pbc, IBindStatusCallback *pbsc, DWORD grfHLNF, DWORD dwReserved)
1662 {
1663     FIXME("%s\n", debugstr_w( szTarget ) );
1664     return E_NOTIMPL;
1665 }
1666
1667 /***********************************************************************
1668  *           HlinkNavigateString (URLMON.@)
1669  */
1670 HRESULT WINAPI HlinkNavigateString( IUnknown *pUnk, LPCWSTR szTarget )
1671 {
1672     TRACE("%p %s\n", pUnk, debugstr_w( szTarget ) );
1673     return HlinkSimpleNavigateToString(
1674                szTarget, NULL, NULL, pUnk, NULL, NULL, 0, 0 );
1675 }
1676
1677 /***********************************************************************
1678  *           GetSoftwareUpdateInfo (URLMON.@)
1679  */
1680 HRESULT WINAPI GetSoftwareUpdateInfo( LPCWSTR szDistUnit, LPSOFTDISTINFO psdi )
1681 {
1682     FIXME("%s %p\n", debugstr_w(szDistUnit), psdi );
1683     return E_FAIL;
1684 }