include: Use ULONG in rpcdcep.h for Win64 compatibility.
[wine] / 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 #include <stdio.h>
24
25 #include "urlmon_main.h"
26
27 #include "winreg.h"
28 #include "winternl.h"
29 #include "wininet.h"
30 #include "shlwapi.h"
31
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
35
36 /* native urlmon.dll uses this key, too */
37 static WCHAR BSCBHolder[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
38
39 /*static BOOL registered_wndclass = FALSE;*/
40
41 typedef struct {
42     const IBindingVtbl *lpVtbl;
43
44     LONG ref;
45
46     LPWSTR URLName;
47
48     HWND hwndCallback;
49     IBindCtx *pBC;
50     HINTERNET hinternet, hconnect, hrequest;
51     HANDLE hCacheFile;
52     IUMCacheStream *pstrCache;
53     IBindStatusCallback *pbscb;
54     DWORD total_read, expected_size;
55 } Binding;
56
57 static HRESULT WINAPI Binding_QueryInterface(IBinding* iface, REFIID riid, void **ppvObject)
58 {
59     Binding *This = (Binding*)iface;
60
61     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppvObject);
62
63     if((This == NULL) || (ppvObject == NULL))
64         return E_INVALIDARG;
65
66     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IBinding, riid)) {
67         *ppvObject = iface;
68         IBinding_AddRef(iface);
69         return S_OK;
70     }
71
72     *ppvObject = NULL;
73     return E_NOINTERFACE;
74 }
75
76 static ULONG WINAPI Binding_AddRef(IBinding* iface)
77 {
78     Binding *This = (Binding*)iface;
79     ULONG ref = InterlockedIncrement(&This->ref);
80
81     TRACE("(%p) ref=%d\n", This, ref);
82
83     return ref;
84 }
85
86 static ULONG WINAPI Binding_Release(IBinding* iface)
87 {
88     Binding *This = (Binding*)iface;
89     ULONG ref = InterlockedDecrement(&This->ref);
90
91     TRACE("(%p) ref=%d\n",This, ref);
92
93     if(!ref) {
94         heap_free(This->URLName);
95         if (This->hCacheFile)
96             CloseHandle(This->hCacheFile);
97         if (This->pstrCache)
98         {
99             UMCloseCacheFileStream(This->pstrCache);
100             IStream_Release((IStream *)This->pstrCache);
101         }
102         if (This->pbscb)
103             IBindStatusCallback_Release(This->pbscb);
104
105         heap_free(This);
106
107         URLMON_UnlockModule();
108     }
109
110     return ref;
111 }
112
113 static HRESULT WINAPI Binding_Abort(IBinding* iface)
114 {
115     Binding *This = (Binding*)iface;
116
117     FIXME("(%p): stub\n", This);
118
119     return E_NOTIMPL;
120 }
121
122 static HRESULT WINAPI Binding_GetBindResult(IBinding* iface, CLSID* pclsidProtocol, DWORD* pdwResult, LPOLESTR* pszResult, DWORD* pdwReserved)
123 {
124     Binding *This = (Binding*)iface;
125
126     FIXME("(%p)->(%p, %p, %p, %p): stub\n", This, pclsidProtocol, pdwResult, pszResult, pdwReserved);
127
128     return E_NOTIMPL;
129 }
130
131 static HRESULT WINAPI Binding_GetPriority(IBinding* iface, LONG* pnPriority)
132 {
133     Binding *This = (Binding*)iface;
134
135     FIXME("(%p)->(%p): stub\n", This, pnPriority);
136
137     return E_NOTIMPL;
138 }
139
140 static HRESULT WINAPI Binding_Resume(IBinding* iface)
141 {
142     Binding *This = (Binding*)iface;
143
144     FIXME("(%p): stub\n", This);
145
146     return E_NOTIMPL;
147 }
148
149 static HRESULT WINAPI Binding_SetPriority(IBinding* iface, LONG nPriority)
150 {
151     Binding *This = (Binding*)iface;
152
153     FIXME("(%p)->(%d): stub\n", This, nPriority);
154
155     return E_NOTIMPL;
156 }
157
158 static HRESULT WINAPI Binding_Suspend(IBinding* iface)
159 {
160     Binding *This = (Binding*)iface;
161
162     FIXME("(%p): stub\n", This);
163
164     return E_NOTIMPL;
165 }
166
167 static void Binding_CloseCacheDownload(Binding *This)
168 {
169     CloseHandle(This->hCacheFile);
170     This->hCacheFile = 0;
171     UMCloseCacheFileStream(This->pstrCache);
172     IStream_Release((IStream *)This->pstrCache);
173     This->pstrCache = 0;
174 }
175
176 static HRESULT Binding_MoreCacheData(Binding *This, const char *buf, DWORD dwBytes)
177 {
178     DWORD written;
179
180     if (WriteFile(This->hCacheFile, buf, dwBytes, &written, NULL) && written == dwBytes)
181     {
182         HRESULT hr;
183
184         This->total_read += written;
185         hr = IBindStatusCallback_OnProgress(This->pbscb,
186                                             This->total_read + written,
187                                             This->expected_size,
188                                             (This->total_read == written) ?
189                                                 BINDSTATUS_BEGINDOWNLOADDATA :
190                                                 BINDSTATUS_DOWNLOADINGDATA,
191                                             This->URLName);
192         if (hr == S_OK)
193         {
194             STGMEDIUM stg;
195             FORMATETC fmt;
196
197             fmt.cfFormat = 0;
198             fmt.ptd = NULL;
199             fmt.dwAspect = 0;
200             fmt.lindex = -1;
201             fmt.tymed = TYMED_ISTREAM;
202
203             stg.tymed = TYMED_ISTREAM;
204             stg.u.pstm = (IStream *)This->pstrCache;
205             stg.pUnkForRelease = NULL;
206
207             hr = IBindStatusCallback_OnDataAvailable(This->pbscb,
208                                                      (This->total_read == written) ?
209                                                          BSCF_FIRSTDATANOTIFICATION :
210                                                          BSCF_INTERMEDIATEDATANOTIFICATION,
211                                                      This->total_read + written,
212                                                      &fmt,
213                                                      &stg);
214         }
215         if (written < dwBytes)
216             return STG_E_MEDIUMFULL;
217         else
218             return hr;
219     }
220     return HRESULT_FROM_WIN32(GetLastError());
221 }
222
223 static void Binding_FinishedDownload(Binding *This, HRESULT hr)
224 {
225     STGMEDIUM stg;
226     FORMATETC fmt;
227
228     fmt.ptd = NULL;
229     fmt.dwAspect = 0;
230     fmt.lindex = -1;
231     fmt.tymed = TYMED_ISTREAM;
232
233     stg.tymed = TYMED_ISTREAM;
234     stg.u.pstm = (IStream *)This->pstrCache;
235     stg.pUnkForRelease = NULL;
236
237     IBindStatusCallback_OnProgress(This->pbscb, This->total_read, This->expected_size,
238                                    BINDSTATUS_ENDDOWNLOADDATA, This->URLName);
239     IBindStatusCallback_OnDataAvailable(This->pbscb, BSCF_LASTDATANOTIFICATION, This->total_read, &fmt, &stg);
240     if (hr != S_OK)
241     {
242         WCHAR *pwchError = 0;
243
244         FormatMessageW (FORMAT_MESSAGE_FROM_SYSTEM |
245                          FORMAT_MESSAGE_ALLOCATE_BUFFER,
246                         NULL, (DWORD) hr,
247                         0, (LPWSTR) &pwchError,
248                         0, NULL);
249         if (!pwchError)
250         {
251             static const WCHAR achFormat[] = { '%', '0', '8', 'x', 0 };
252
253             pwchError =(WCHAR *) LocalAlloc(LMEM_FIXED, sizeof(WCHAR) * 9);
254             wsprintfW(pwchError, achFormat, hr);
255         }
256         IBindStatusCallback_OnStopBinding(This->pbscb, hr, pwchError);
257         LocalFree(pwchError);
258     }
259     else
260     {
261         IBindStatusCallback_OnStopBinding(This->pbscb, hr, NULL);
262     }
263     IBindStatusCallback_Release(This->pbscb);
264     This->pbscb = 0;
265 }
266
267 static const IBindingVtbl BindingVtbl =
268 {
269     Binding_QueryInterface,
270     Binding_AddRef,
271     Binding_Release,
272     Binding_Abort,
273     Binding_Suspend,
274     Binding_Resume,
275     Binding_SetPriority,
276     Binding_GetPriority,
277     Binding_GetBindResult
278 };
279
280 /* filemoniker data structure */
281 typedef struct {
282
283     const IMonikerVtbl* lpvtbl;  /* VTable relative to the IMoniker interface.*/
284
285     LONG ref; /* reference counter for this object */
286
287     LPOLESTR URLName; /* URL string identified by this URLmoniker */
288 } URLMonikerImpl;
289
290 /*******************************************************************************
291  *        URLMoniker_QueryInterface
292  *******************************************************************************/
293 static HRESULT WINAPI URLMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
294 {
295     URLMonikerImpl *This = (URLMonikerImpl *)iface;
296
297     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppvObject);
298
299     /* Perform a sanity check on the parameters.*/
300     if ( (This==0) || (ppvObject==0) )
301         return E_INVALIDARG;
302
303     /* Initialize the return parameter */
304     *ppvObject = 0;
305
306     /* Compare the riid with the interface IDs implemented by this object.*/
307     if (IsEqualIID(&IID_IUnknown, riid)      ||
308         IsEqualIID(&IID_IPersist, riid)      ||
309         IsEqualIID(&IID_IPersistStream,riid) ||
310         IsEqualIID(&IID_IMoniker, riid)
311        )
312         *ppvObject = iface;
313
314     /* Check that we obtained an interface.*/
315     if ((*ppvObject)==0)
316         return E_NOINTERFACE;
317
318     /* Query Interface always increases the reference count by one when it is successful */
319     IMoniker_AddRef(iface);
320
321     return S_OK;
322 }
323
324 /******************************************************************************
325  *        URLMoniker_AddRef
326  ******************************************************************************/
327 static ULONG WINAPI URLMonikerImpl_AddRef(IMoniker* iface)
328 {
329     URLMonikerImpl *This = (URLMonikerImpl *)iface;
330     ULONG refCount = InterlockedIncrement(&This->ref);
331
332     TRACE("(%p) ref=%u\n",This, refCount);
333
334     return refCount;
335 }
336
337 /******************************************************************************
338  *        URLMoniker_Release
339  ******************************************************************************/
340 static ULONG WINAPI URLMonikerImpl_Release(IMoniker* iface)
341 {
342     URLMonikerImpl *This = (URLMonikerImpl *)iface;
343     ULONG refCount = InterlockedDecrement(&This->ref);
344
345     TRACE("(%p) ref=%u\n",This, refCount);
346
347     /* destroy the object if there's no more reference on it */
348     if (!refCount) {
349         heap_free(This->URLName);
350         heap_free(This);
351
352         URLMON_UnlockModule();
353     }
354
355     return refCount;
356 }
357
358
359 /******************************************************************************
360  *        URLMoniker_GetClassID
361  ******************************************************************************/
362 static HRESULT WINAPI URLMonikerImpl_GetClassID(IMoniker* iface,
363                                                 CLSID *pClassID)/* Pointer to CLSID of object */
364 {
365     URLMonikerImpl *This = (URLMonikerImpl *)iface;
366
367     TRACE("(%p,%p)\n",This,pClassID);
368
369     if (pClassID==NULL)
370         return E_POINTER;
371     /* Windows always returns CLSID_StdURLMoniker */
372     *pClassID = CLSID_StdURLMoniker;
373     return S_OK;
374 }
375
376 /******************************************************************************
377  *        URLMoniker_IsDirty
378  ******************************************************************************/
379 static HRESULT WINAPI URLMonikerImpl_IsDirty(IMoniker* iface)
380 {
381     URLMonikerImpl *This = (URLMonikerImpl *)iface;
382     /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
383        method in the OLE-provided moniker interfaces always return S_FALSE because
384        their internal state never changes. */
385
386     TRACE("(%p)\n",This);
387
388     return S_FALSE;
389 }
390
391 /******************************************************************************
392  *        URLMoniker_Load
393  *
394  * NOTE
395  *  Writes a ULONG containing length of unicode string, followed
396  *  by that many unicode characters
397  ******************************************************************************/
398 static HRESULT WINAPI URLMonikerImpl_Load(IMoniker* iface,IStream* pStm)
399 {
400     URLMonikerImpl *This = (URLMonikerImpl *)iface;
401     
402     HRESULT res;
403     ULONG size;
404     ULONG got;
405     TRACE("(%p,%p)\n",This,pStm);
406
407     if(!pStm)
408         return E_INVALIDARG;
409
410     res = IStream_Read(pStm, &size, sizeof(ULONG), &got);
411     if(SUCCEEDED(res)) {
412         if(got == sizeof(ULONG)) {
413             heap_free(This->URLName);
414             This->URLName = heap_alloc(size);
415             if(!This->URLName)
416                 res = E_OUTOFMEMORY;
417             else {
418                 res = IStream_Read(pStm, This->URLName, size, NULL);
419                 This->URLName[size/sizeof(WCHAR) - 1] = 0;
420             }
421         }
422         else
423             res = E_FAIL;
424     }
425     return res;
426 }
427
428 /******************************************************************************
429  *        URLMoniker_Save
430  ******************************************************************************/
431 static HRESULT WINAPI URLMonikerImpl_Save(IMoniker* iface,
432                                           IStream* pStm,/* pointer to the stream where the object is to be saved */
433                                           BOOL fClearDirty)/* Specifies whether to clear the dirty flag */
434 {
435     URLMonikerImpl *This = (URLMonikerImpl *)iface;
436
437     HRESULT res;
438     ULONG size;
439     TRACE("(%p,%p,%d)\n",This,pStm,fClearDirty);
440
441     if(!pStm)
442         return E_INVALIDARG;
443
444     size = (strlenW(This->URLName) + 1)*sizeof(WCHAR);
445     res=IStream_Write(pStm,&size,sizeof(ULONG),NULL);
446     if(SUCCEEDED(res))
447         res=IStream_Write(pStm,This->URLName,size,NULL);
448     return res;
449
450 }
451
452 /******************************************************************************
453  *        URLMoniker_GetSizeMax
454  ******************************************************************************/
455 static HRESULT WINAPI URLMonikerImpl_GetSizeMax(IMoniker* iface,
456                                                 ULARGE_INTEGER* pcbSize)/* Pointer to size of stream needed to save object */
457 {
458     URLMonikerImpl *This = (URLMonikerImpl *)iface;
459
460     TRACE("(%p,%p)\n",This,pcbSize);
461
462     if(!pcbSize)
463         return E_INVALIDARG;
464
465     pcbSize->QuadPart = sizeof(ULONG) + ((strlenW(This->URLName)+1) * sizeof(WCHAR));
466     return S_OK;
467 }
468
469 /******************************************************************************
470  *                  URLMoniker_BindToObject
471  ******************************************************************************/
472 static HRESULT WINAPI URLMonikerImpl_BindToObject(IMoniker* iface,
473                                                   IBindCtx* pbc,
474                                                   IMoniker* pmkToLeft,
475                                                   REFIID riid,
476                                                   VOID** ppv)
477 {
478     URLMonikerImpl *This = (URLMonikerImpl *)iface;
479     IRunningObjectTable *obj_tbl;
480     HRESULT hres;
481
482     TRACE("(%p)->(%p,%p,%s,%p): stub\n", This, pbc, pmkToLeft, debugstr_guid(riid), ppv);
483
484     hres = IBindCtx_GetRunningObjectTable(pbc, &obj_tbl);
485     if(SUCCEEDED(hres)) {
486         FIXME("use running object table\n");
487         IRunningObjectTable_Release(obj_tbl);
488     }
489
490     return bind_to_object(iface, This->URLName, pbc, riid, ppv);
491 }
492
493 /******************************************************************************
494  *        URLMoniker_BindToStorage
495  ******************************************************************************/
496 static HRESULT URLMonikerImpl_BindToStorage_hack(LPCWSTR URLName, IBindCtx* pbc, VOID** ppvObject)
497 {
498     HRESULT hres;
499     BINDINFO bi;
500     DWORD bindf;
501     WCHAR szFileName[MAX_PATH + 1];
502     Binding *bind;
503     int len;
504
505     WARN("(%s %p %p)\n", debugstr_w(URLName), pbc, ppvObject);
506
507     bind = heap_alloc_zero(sizeof(Binding));
508     bind->lpVtbl = &BindingVtbl;
509     bind->ref = 1;
510     URLMON_LockModule();
511
512     len = lstrlenW(URLName)+1;
513     bind->URLName = heap_alloc(len*sizeof(WCHAR));
514     memcpy(bind->URLName, URLName, len*sizeof(WCHAR));
515
516     hres = UMCreateStreamOnCacheFile(bind->URLName, 0, szFileName, &bind->hCacheFile, &bind->pstrCache);
517
518     if(SUCCEEDED(hres)) {
519         TRACE("Created stream...\n");
520
521         *ppvObject = (void *) bind->pstrCache;
522         IStream_AddRef((IStream *) bind->pstrCache);
523
524         hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, (IUnknown**)&bind->pbscb);
525         if(SUCCEEDED(hres)) {
526             TRACE("Got IBindStatusCallback...\n");
527
528             memset(&bi, 0, sizeof(bi));
529             bi.cbSize = sizeof(bi);
530             bindf = 0;
531             hres = IBindStatusCallback_GetBindInfo(bind->pbscb, &bindf, &bi);
532             if(SUCCEEDED(hres)) {
533                 URL_COMPONENTSW url;
534                 WCHAR *host, *path, *user, *pass;
535                 DWORD lensz = sizeof(bind->expected_size);
536                 DWORD dwService = 0;
537                 BOOL bSuccess;
538
539                 TRACE("got bindinfo. bindf = %08x extrainfo = %s bindinfof = %08x bindverb = %08x iid %s\n",
540                       bindf, debugstr_w(bi.szExtraInfo), bi.grfBindInfoF, bi.dwBindVerb, debugstr_guid(&bi.iid));
541                 hres = IBindStatusCallback_OnStartBinding(bind->pbscb, 0, (IBinding*)bind);
542                 TRACE("OnStartBinding rets %08x\n", hres);
543
544                 bind->expected_size = 0;
545                 bind->total_read = 0;
546
547                 memset(&url, 0, sizeof(url));
548                 url.dwStructSize = sizeof(url);
549                 url.dwSchemeLength = url.dwHostNameLength = url.dwUrlPathLength = url.dwUserNameLength = url.dwPasswordLength = 1;
550                 InternetCrackUrlW(URLName, 0, ICU_ESCAPE, &url);
551                 host = heap_alloc((url.dwHostNameLength + 1) * sizeof(WCHAR));
552                 memcpy(host, url.lpszHostName, url.dwHostNameLength * sizeof(WCHAR));
553                 host[url.dwHostNameLength] = '\0';
554                 path = heap_alloc((url.dwUrlPathLength + 1) * sizeof(WCHAR));
555                 memcpy(path, url.lpszUrlPath, url.dwUrlPathLength * sizeof(WCHAR));
556                 path[url.dwUrlPathLength] = '\0';
557                 if (url.dwUserNameLength)
558                 {
559                     user = heap_alloc(((url.dwUserNameLength + 1) * sizeof(WCHAR)));
560                     memcpy(user, url.lpszUserName, url.dwUserNameLength * sizeof(WCHAR));
561                     user[url.dwUserNameLength] = 0;
562                 }
563                 else
564                 {
565                     user = 0;
566                 }
567                 if (url.dwPasswordLength)
568                 {
569                     pass = heap_alloc(((url.dwPasswordLength + 1) * sizeof(WCHAR)));
570                     memcpy(pass, url.lpszPassword, url.dwPasswordLength * sizeof(WCHAR));
571                     pass[url.dwPasswordLength] = 0;
572                 }
573                 else
574                 {
575                     pass = 0;
576                 }
577
578
579                 do {
580                     bind->hinternet = InternetOpenA("User Agent", 0, NULL, NULL, 0);
581                     if (!bind->hinternet)
582                     {
583                             hres = HRESULT_FROM_WIN32(GetLastError());
584                             break;
585                     }
586
587                     switch ((DWORD) url.nScheme)
588                     {
589                     case INTERNET_SCHEME_FTP:
590                         if (!url.nPort)
591                             url.nPort = INTERNET_DEFAULT_FTP_PORT;
592                         dwService = INTERNET_SERVICE_FTP;
593                         break;
594     
595                     case INTERNET_SCHEME_GOPHER:
596                         if (!url.nPort)
597                             url.nPort = INTERNET_DEFAULT_GOPHER_PORT;
598                         dwService = INTERNET_SERVICE_GOPHER;
599                         break;
600
601                     case INTERNET_SCHEME_HTTPS:
602                         if (!url.nPort)
603                             url.nPort = INTERNET_DEFAULT_HTTPS_PORT;
604                         dwService = INTERNET_SERVICE_HTTP;
605                         break;
606                     }
607
608                     bind->hconnect = InternetConnectW(bind->hinternet, host, url.nPort, user, pass,
609                                                       dwService, 0, (DWORD_PTR)bind);
610                     if (!bind->hconnect)
611                     {
612                             hres = HRESULT_FROM_WIN32(GetLastError());
613                             CloseHandle(bind->hinternet);
614                             break;
615                     }
616
617                     hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, 0x22, NULL);
618                     hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_FINDINGRESOURCE, NULL);
619                     hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_CONNECTING, NULL);
620                     hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_SENDINGREQUEST, NULL);
621
622                     bSuccess = FALSE;
623
624                     switch (dwService)
625                     {
626                     case INTERNET_SERVICE_GOPHER:
627                         bind->hrequest = GopherOpenFileW(bind->hconnect,
628                                                          path,
629                                                          0,
630                                                          INTERNET_FLAG_RELOAD,
631                                                          0);
632                         if (bind->hrequest)
633                                 bSuccess = TRUE;
634                         else
635                                 hres = HRESULT_FROM_WIN32(GetLastError());
636                         break;
637
638                     case INTERNET_SERVICE_FTP:
639                         bind->hrequest = FtpOpenFileW(bind->hconnect,
640                                                       path,
641                                                       GENERIC_READ,
642                                                       FTP_TRANSFER_TYPE_BINARY |
643                                                        INTERNET_FLAG_TRANSFER_BINARY |
644                                                        INTERNET_FLAG_RELOAD,
645                                                       0);
646                         if (bind->hrequest)
647                                 bSuccess = TRUE;
648                         else
649                                 hres = HRESULT_FROM_WIN32(GetLastError());
650                         break;
651
652                     case INTERNET_SERVICE_HTTP:
653                         bind->hrequest = HttpOpenRequestW(bind->hconnect, NULL, path, NULL, NULL, NULL, 0, (DWORD_PTR)bind);
654                         if (!bind->hrequest)
655                         {
656                                 hres = HRESULT_FROM_WIN32(GetLastError());
657                         }
658                         else if (!HttpSendRequestW(bind->hrequest, NULL, 0, NULL, 0))
659                         {
660                                 hres = HRESULT_FROM_WIN32(GetLastError());
661                                 InternetCloseHandle(bind->hrequest);
662                         }
663                         else
664                         {
665                                 HttpQueryInfoW(bind->hrequest,
666                                                HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER,
667                                                &bind->expected_size,
668                                                &lensz,
669                                                NULL);
670                                 bSuccess = TRUE;
671                         }
672                         break;
673                     }
674                     if(bSuccess)
675                     {
676                         TRACE("res = %d gle = %u url len = %d\n", hres, GetLastError(), bind->expected_size);
677
678                         IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_CACHEFILENAMEAVAILABLE, szFileName);
679
680                         while(1) {
681                             char buf[4096];
682                             DWORD bufread;
683                             if(InternetReadFile(bind->hrequest, buf, sizeof(buf), &bufread)) {
684                                 TRACE("read %d bytes %s...\n", bufread, debugstr_an(buf, 10));
685                                 if(bufread == 0) break;
686                                 hres = Binding_MoreCacheData(bind, buf, bufread);
687                             } else
688                                 break;
689                         }
690                         InternetCloseHandle(bind->hrequest);
691                             hres = S_OK;
692                     }
693             
694                     InternetCloseHandle(bind->hconnect);
695                     InternetCloseHandle(bind->hinternet);
696                 } while(0);
697
698                 Binding_FinishedDownload(bind, hres);
699                 Binding_CloseCacheDownload(bind);
700
701                 heap_free(user);
702                 heap_free(pass);
703                 heap_free(path);
704                 heap_free(host);
705             }
706         }
707     }
708
709     IBinding_Release((IBinding*)bind);
710
711     return hres;
712 }
713
714 static HRESULT WINAPI URLMonikerImpl_BindToStorage(IMoniker* iface,
715                                                    IBindCtx* pbc,
716                                                    IMoniker* pmkToLeft,
717                                                    REFIID riid,
718                                                    VOID** ppvObject)
719 {
720     URLMonikerImpl *This = (URLMonikerImpl*)iface;
721     WCHAR schema[64];
722     BOOL bret;
723
724     URL_COMPONENTSW url = {sizeof(URL_COMPONENTSW), schema,
725         sizeof(schema)/sizeof(WCHAR), 0, NULL, 0, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0};
726
727     if(pmkToLeft)
728         FIXME("Unsupported pmkToLeft\n");
729
730     bret = InternetCrackUrlW(This->URLName, 0, ICU_ESCAPE, &url);
731     if(!bret) {
732         ERR("InternetCrackUrl failed: %u\n", GetLastError());
733         return E_FAIL;
734     }
735
736     if(IsEqualGUID(&IID_IStream, riid) &&
737        (  url.nScheme == INTERNET_SCHEME_HTTPS
738        || url.nScheme == INTERNET_SCHEME_FTP
739        || url.nScheme == INTERNET_SCHEME_GOPHER))
740         return URLMonikerImpl_BindToStorage_hack(This->URLName, pbc, ppvObject);
741
742     TRACE("(%p)->(%p %p %s %p)\n", This, pbc, pmkToLeft, debugstr_guid(riid), ppvObject);
743
744     return bind_to_storage(This->URLName, pbc, riid, ppvObject);
745 }
746
747 /******************************************************************************
748  *        URLMoniker_Reduce
749  ******************************************************************************/
750 static HRESULT WINAPI URLMonikerImpl_Reduce(IMoniker* iface,
751                                             IBindCtx* pbc,
752                                             DWORD dwReduceHowFar,
753                                             IMoniker** ppmkToLeft,
754                                             IMoniker** ppmkReduced)
755 {
756     URLMonikerImpl *This = (URLMonikerImpl *)iface;
757     
758     TRACE("(%p,%p,%d,%p,%p)\n",This,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
759
760     if(!ppmkReduced)
761         return E_INVALIDARG;
762
763     URLMonikerImpl_AddRef(iface);
764     *ppmkReduced = iface;
765     return MK_S_REDUCED_TO_SELF;
766 }
767
768 /******************************************************************************
769  *        URLMoniker_ComposeWith
770  ******************************************************************************/
771 static HRESULT WINAPI URLMonikerImpl_ComposeWith(IMoniker* iface,
772                                                  IMoniker* pmkRight,
773                                                  BOOL fOnlyIfNotGeneric,
774                                                  IMoniker** ppmkComposite)
775 {
776     URLMonikerImpl *This = (URLMonikerImpl *)iface;
777     FIXME("(%p)->(%p,%d,%p): stub\n",This,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
778
779     return E_NOTIMPL;
780 }
781
782 /******************************************************************************
783  *        URLMoniker_Enum
784  ******************************************************************************/
785 static HRESULT WINAPI URLMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
786 {
787     URLMonikerImpl *This = (URLMonikerImpl *)iface;
788     TRACE("(%p,%d,%p)\n",This,fForward,ppenumMoniker);
789
790     if(!ppenumMoniker)
791         return E_INVALIDARG;
792
793     /* Does not support sub-monikers */
794     *ppenumMoniker = NULL;
795     return S_OK;
796 }
797
798 /******************************************************************************
799  *        URLMoniker_IsEqual
800  ******************************************************************************/
801 static HRESULT WINAPI URLMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
802 {
803     URLMonikerImpl *This = (URLMonikerImpl *)iface;
804     CLSID clsid;
805     LPOLESTR urlPath;
806     IBindCtx* bind;
807     HRESULT res;
808
809     TRACE("(%p,%p)\n",This,pmkOtherMoniker);
810
811     if(pmkOtherMoniker==NULL)
812         return E_INVALIDARG;
813
814     IMoniker_GetClassID(pmkOtherMoniker,&clsid);
815
816     if(!IsEqualCLSID(&clsid,&CLSID_StdURLMoniker))
817         return S_FALSE;
818
819     res = CreateBindCtx(0,&bind);
820     if(FAILED(res))
821         return res;
822
823     res = S_FALSE;
824     if(SUCCEEDED(IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&urlPath))) {
825         int result = lstrcmpiW(urlPath, This->URLName);
826         CoTaskMemFree(urlPath);
827         if(result == 0)
828             res = S_OK;
829     }
830     IUnknown_Release(bind);
831     return res;
832 }
833
834
835 /******************************************************************************
836  *        URLMoniker_Hash
837  ******************************************************************************/
838 static HRESULT WINAPI URLMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
839 {
840     URLMonikerImpl *This = (URLMonikerImpl *)iface;
841     
842     int  h = 0,i,skip,len;
843     int  off = 0;
844     LPOLESTR val;
845
846     TRACE("(%p,%p)\n",This,pdwHash);
847
848     if(!pdwHash)
849         return E_INVALIDARG;
850
851     val = This->URLName;
852     len = lstrlenW(val);
853
854     if(len < 16) {
855         for(i = len ; i > 0; i--) {
856             h = (h * 37) + val[off++];
857         }
858     }
859     else {
860         /* only sample some characters */
861         skip = len / 8;
862         for(i = len; i > 0; i -= skip, off += skip) {
863             h = (h * 39) + val[off];
864         }
865     }
866     *pdwHash = h;
867     return S_OK;
868 }
869
870 /******************************************************************************
871  *        URLMoniker_IsRunning
872  ******************************************************************************/
873 static HRESULT WINAPI URLMonikerImpl_IsRunning(IMoniker* iface,
874                                                IBindCtx* pbc,
875                                                IMoniker* pmkToLeft,
876                                                IMoniker* pmkNewlyRunning)
877 {
878     URLMonikerImpl *This = (URLMonikerImpl *)iface;
879     FIXME("(%p)->(%p,%p,%p): stub\n",This,pbc,pmkToLeft,pmkNewlyRunning);
880
881     return E_NOTIMPL;
882 }
883
884 /******************************************************************************
885  *        URLMoniker_GetTimeOfLastChange
886  ******************************************************************************/
887 static HRESULT WINAPI URLMonikerImpl_GetTimeOfLastChange(IMoniker* iface,
888                                                          IBindCtx* pbc,
889                                                          IMoniker* pmkToLeft,
890                                                          FILETIME* pFileTime)
891 {
892     URLMonikerImpl *This = (URLMonikerImpl *)iface;
893     FIXME("(%p)->(%p,%p,%p): stub\n",This,pbc,pmkToLeft,pFileTime);
894
895     return E_NOTIMPL;
896 }
897
898 /******************************************************************************
899  *        URLMoniker_Inverse
900  ******************************************************************************/
901 static HRESULT WINAPI URLMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
902 {
903     URLMonikerImpl *This = (URLMonikerImpl *)iface;
904     TRACE("(%p,%p)\n",This,ppmk);
905
906     return MK_E_NOINVERSE;
907 }
908
909 /******************************************************************************
910  *        URLMoniker_CommonPrefixWith
911  ******************************************************************************/
912 static HRESULT WINAPI URLMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
913 {
914     URLMonikerImpl *This = (URLMonikerImpl *)iface;
915     FIXME("(%p)->(%p,%p): stub\n",This,pmkOther,ppmkPrefix);
916
917     return E_NOTIMPL;
918 }
919
920 /******************************************************************************
921  *        URLMoniker_RelativePathTo
922  ******************************************************************************/
923 static HRESULT WINAPI URLMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
924 {
925     URLMonikerImpl *This = (URLMonikerImpl *)iface;
926     FIXME("(%p)->(%p,%p): stub\n",This,pmOther,ppmkRelPath);
927
928     return E_NOTIMPL;
929 }
930
931 /******************************************************************************
932  *        URLMoniker_GetDisplayName
933  ******************************************************************************/
934 static HRESULT WINAPI URLMonikerImpl_GetDisplayName(IMoniker* iface,
935                                                     IBindCtx* pbc,
936                                                     IMoniker* pmkToLeft,
937                                                     LPOLESTR *ppszDisplayName)
938 {
939     URLMonikerImpl *This = (URLMonikerImpl *)iface;
940     
941     int len;
942     
943     TRACE("(%p,%p,%p,%p)\n",This,pbc,pmkToLeft,ppszDisplayName);
944     
945     if(!ppszDisplayName)
946         return E_INVALIDARG;
947     
948     /* FIXME: If this is a partial URL, try and get a URL moniker from SZ_URLCONTEXT in the bind context,
949         then look at pmkToLeft to try and complete the URL
950     */
951     len = lstrlenW(This->URLName)+1;
952     *ppszDisplayName = CoTaskMemAlloc(len*sizeof(WCHAR));
953     if(!*ppszDisplayName)
954         return E_OUTOFMEMORY;
955     lstrcpyW(*ppszDisplayName, This->URLName);
956     return S_OK;
957 }
958
959 /******************************************************************************
960  *        URLMoniker_ParseDisplayName
961  ******************************************************************************/
962 static HRESULT WINAPI URLMonikerImpl_ParseDisplayName(IMoniker* iface,
963                                                       IBindCtx* pbc,
964                                                       IMoniker* pmkToLeft,
965                                                       LPOLESTR pszDisplayName,
966                                                       ULONG* pchEaten,
967                                                       IMoniker** ppmkOut)
968 {
969     URLMonikerImpl *This = (URLMonikerImpl *)iface;
970     FIXME("(%p)->(%p,%p,%p,%p,%p): stub\n",This,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
971
972     return E_NOTIMPL;
973 }
974
975 /******************************************************************************
976  *        URLMoniker_IsSystemMoniker
977  ******************************************************************************/
978 static HRESULT WINAPI URLMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
979 {
980     URLMonikerImpl *This = (URLMonikerImpl *)iface;
981     TRACE("(%p,%p)\n",This,pwdMksys);
982
983     if(!pwdMksys)
984         return E_INVALIDARG;
985
986     *pwdMksys = MKSYS_URLMONIKER;
987     return S_OK;
988 }
989
990 /********************************************************************************/
991 /* Virtual function table for the URLMonikerImpl class which  include IPersist,*/
992 /* IPersistStream and IMoniker functions.                                       */
993 static const IMonikerVtbl VT_URLMonikerImpl =
994 {
995     URLMonikerImpl_QueryInterface,
996     URLMonikerImpl_AddRef,
997     URLMonikerImpl_Release,
998     URLMonikerImpl_GetClassID,
999     URLMonikerImpl_IsDirty,
1000     URLMonikerImpl_Load,
1001     URLMonikerImpl_Save,
1002     URLMonikerImpl_GetSizeMax,
1003     URLMonikerImpl_BindToObject,
1004     URLMonikerImpl_BindToStorage,
1005     URLMonikerImpl_Reduce,
1006     URLMonikerImpl_ComposeWith,
1007     URLMonikerImpl_Enum,
1008     URLMonikerImpl_IsEqual,
1009     URLMonikerImpl_Hash,
1010     URLMonikerImpl_IsRunning,
1011     URLMonikerImpl_GetTimeOfLastChange,
1012     URLMonikerImpl_Inverse,
1013     URLMonikerImpl_CommonPrefixWith,
1014     URLMonikerImpl_RelativePathTo,
1015     URLMonikerImpl_GetDisplayName,
1016     URLMonikerImpl_ParseDisplayName,
1017     URLMonikerImpl_IsSystemMoniker
1018 };
1019
1020 /******************************************************************************
1021  *         URLMoniker_Construct (local function)
1022  *******************************************************************************/
1023 static HRESULT URLMonikerImpl_Construct(URLMonikerImpl* This, LPCOLESTR lpszLeftURLName, LPCOLESTR lpszURLName)
1024 {
1025     HRESULT hres;
1026     DWORD sizeStr = 0;
1027
1028     TRACE("(%p,%s,%s)\n",This,debugstr_w(lpszLeftURLName),debugstr_w(lpszURLName));
1029
1030     This->lpvtbl = &VT_URLMonikerImpl;
1031     This->ref = 0;
1032
1033     This->URLName = heap_alloc(INTERNET_MAX_URL_LENGTH*sizeof(WCHAR));
1034
1035     if(lpszLeftURLName)
1036         hres = CoInternetCombineUrl(lpszLeftURLName, lpszURLName, URL_FILE_USE_PATHURL,
1037                 This->URLName, INTERNET_MAX_URL_LENGTH, &sizeStr, 0);
1038     else
1039         hres = CoInternetParseUrl(lpszURLName, PARSE_CANONICALIZE, URL_FILE_USE_PATHURL,
1040                 This->URLName, INTERNET_MAX_URL_LENGTH, &sizeStr, 0);
1041
1042     if(FAILED(hres)) {
1043         heap_free(This->URLName);
1044         return hres;
1045     }
1046
1047     URLMON_LockModule();
1048
1049     if(sizeStr != INTERNET_MAX_URL_LENGTH)
1050         This->URLName = heap_realloc(This->URLName, (sizeStr+1)*sizeof(WCHAR));
1051
1052     TRACE("URLName = %s\n", debugstr_w(This->URLName));
1053
1054     return S_OK;
1055 }
1056
1057 /***********************************************************************
1058  *           CreateURLMonikerEx (URLMON.@)
1059  *
1060  * Create a url moniker.
1061  *
1062  * PARAMS
1063  *    pmkContext [I] Context
1064  *    szURL      [I] Url to create the moniker for
1065  *    ppmk       [O] Destination for created moniker.
1066  *    dwFlags    [I] Flags.
1067  *
1068  * RETURNS
1069  *    Success: S_OK. ppmk contains the created IMoniker object.
1070  *    Failure: MK_E_SYNTAX if szURL is not a valid url, or
1071  *             E_OUTOFMEMORY if memory allocation fails.
1072  */
1073 HRESULT WINAPI CreateURLMonikerEx(IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk, DWORD dwFlags)
1074 {
1075     URLMonikerImpl *obj;
1076     HRESULT hres;
1077     LPOLESTR lefturl = NULL;
1078
1079     TRACE("(%p, %s, %p, %08x)\n", pmkContext, debugstr_w(szURL), ppmk, dwFlags);
1080
1081     if (dwFlags & URL_MK_UNIFORM) FIXME("ignoring flag URL_MK_UNIFORM\n");
1082
1083     if(!(obj = heap_alloc(sizeof(*obj))))
1084         return E_OUTOFMEMORY;
1085
1086     if(pmkContext) {
1087         IBindCtx* bind;
1088         DWORD dwMksys = 0;
1089         IMoniker_IsSystemMoniker(pmkContext, &dwMksys);
1090         if(dwMksys == MKSYS_URLMONIKER && SUCCEEDED(CreateBindCtx(0, &bind))) {
1091             IMoniker_GetDisplayName(pmkContext, bind, NULL, &lefturl);
1092             TRACE("lefturl = %s\n", debugstr_w(lefturl));
1093             IBindCtx_Release(bind);
1094         }
1095     }
1096         
1097     hres = URLMonikerImpl_Construct(obj, lefturl, szURL);
1098     CoTaskMemFree(lefturl);
1099     if(SUCCEEDED(hres))
1100         hres = URLMonikerImpl_QueryInterface((IMoniker*)obj, &IID_IMoniker, (void**)ppmk);
1101     else
1102         heap_free(obj);
1103     return hres;
1104 }
1105
1106 /**********************************************************************
1107  *           CreateURLMoniker (URLMON.@)
1108  *
1109  * Create a url moniker.
1110  *
1111  * PARAMS
1112  *    pmkContext [I] Context
1113  *    szURL      [I] Url to create the moniker for
1114  *    ppmk       [O] Destination for created moniker.
1115  *
1116  * RETURNS
1117  *    Success: S_OK. ppmk contains the created IMoniker object.
1118  *    Failure: MK_E_SYNTAX if szURL is not a valid url, or
1119  *             E_OUTOFMEMORY if memory allocation fails.
1120  */
1121 HRESULT WINAPI CreateURLMoniker(IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk)
1122 {
1123     return CreateURLMonikerEx(pmkContext, szURL, ppmk, URL_MK_LEGACY);
1124 }
1125
1126 /***********************************************************************
1127  *           IsAsyncMoniker (URLMON.@)
1128  */
1129 HRESULT WINAPI IsAsyncMoniker(IMoniker *pmk)
1130 {
1131     IUnknown *am;
1132     
1133     TRACE("(%p)\n", pmk);
1134     if(!pmk)
1135         return E_INVALIDARG;
1136     if(SUCCEEDED(IMoniker_QueryInterface(pmk, &IID_IAsyncMoniker, (void**)&am))) {
1137         IUnknown_Release(am);
1138         return S_OK;
1139     }
1140     return S_FALSE;
1141 }
1142
1143 /***********************************************************************
1144  *           BindAsyncMoniker (URLMON.@)
1145  *
1146  * Bind a bind status callback to an asynchronous URL Moniker.
1147  *
1148  * PARAMS
1149  *  pmk           [I] Moniker object to bind status callback to
1150  *  grfOpt        [I] Options, seems not used
1151  *  pbsc          [I] Status callback to bind
1152  *  iidResult     [I] Interface to return
1153  *  ppvResult     [O] Resulting asynchronous moniker object
1154  *
1155  * RETURNS
1156  *    Success: S_OK.
1157  *    Failure: E_INVALIDARG, if any argument is invalid, or
1158  *             E_OUTOFMEMORY if memory allocation fails.
1159  */
1160 HRESULT WINAPI BindAsyncMoniker(IMoniker *pmk, DWORD grfOpt, IBindStatusCallback *pbsc, REFIID iidResult, LPVOID *ppvResult)
1161 {
1162     LPBC pbc = NULL;
1163     HRESULT hr = E_INVALIDARG;
1164
1165     TRACE("(%p %08x %p %s %p)\n", pmk, grfOpt, pbsc, debugstr_guid(iidResult), ppvResult);
1166
1167     if (pmk && ppvResult)
1168     {
1169         *ppvResult = NULL;
1170
1171         hr = CreateAsyncBindCtx(0, pbsc, NULL, &pbc);
1172         if (hr == NOERROR)
1173         {
1174             hr = IMoniker_BindToObject(pmk, pbc, NULL, iidResult, ppvResult);
1175             IBindCtx_Release(pbc);
1176         }
1177     }
1178     return hr;
1179 }
1180
1181 /***********************************************************************
1182  *           MkParseDisplayNameEx (URLMON.@)
1183  */
1184 HRESULT WINAPI MkParseDisplayNameEx(IBindCtx *pbc, LPCWSTR szDisplayName, ULONG *pchEaten, LPMONIKER *ppmk)
1185 {
1186     TRACE("(%p %s %p %p)\n", pbc, debugstr_w(szDisplayName), pchEaten, ppmk);
1187
1188     if(is_registered_protocol(szDisplayName)) {
1189         HRESULT hres;
1190
1191         hres = CreateURLMoniker(NULL, szDisplayName, ppmk);
1192         if(SUCCEEDED(hres)) {
1193             *pchEaten = strlenW(szDisplayName);
1194             return hres;
1195         }
1196     }
1197
1198     return MkParseDisplayName(pbc, szDisplayName, pchEaten, ppmk);
1199 }
1200
1201
1202 /***********************************************************************
1203  *           URLDownloadToCacheFileA (URLMON.@)
1204  */
1205 HRESULT WINAPI URLDownloadToCacheFileA(LPUNKNOWN lpUnkCaller, LPCSTR szURL, LPSTR szFileName,
1206         DWORD dwBufLength, DWORD dwReserved, LPBINDSTATUSCALLBACK pBSC)
1207 {
1208     LPWSTR url = NULL, file_name = NULL;
1209     int len;
1210     HRESULT hres;
1211
1212     TRACE("(%p %s %p %d %d %p)\n", lpUnkCaller, debugstr_a(szURL), szFileName,
1213             dwBufLength, dwReserved, pBSC);
1214
1215     if(szURL) {
1216         len = MultiByteToWideChar(CP_ACP, 0, szURL, -1, NULL, 0);
1217         url = heap_alloc(len*sizeof(WCHAR));
1218         MultiByteToWideChar(CP_ACP, 0, szURL, -1, url, -1);
1219     }
1220
1221     if(szFileName)
1222         file_name = heap_alloc(dwBufLength*sizeof(WCHAR));
1223
1224     hres = URLDownloadToCacheFileW(lpUnkCaller, url, file_name, dwBufLength*sizeof(WCHAR),
1225             dwReserved, pBSC);
1226
1227     if(SUCCEEDED(hres) && file_name)
1228         WideCharToMultiByte(CP_ACP, 0, file_name, -1, szFileName, dwBufLength, NULL, NULL);
1229
1230     heap_free(url);
1231     heap_free(file_name);
1232
1233     return hres;
1234 }
1235
1236 /***********************************************************************
1237  *           URLDownloadToCacheFileW (URLMON.@)
1238  */
1239 HRESULT WINAPI URLDownloadToCacheFileW(LPUNKNOWN lpUnkCaller, LPCWSTR szURL, LPWSTR szFileName,
1240                 DWORD dwBufLength, DWORD dwReserved, LPBINDSTATUSCALLBACK pBSC)
1241 {
1242     WCHAR cache_path[MAX_PATH + 1];
1243     FILETIME expire, modified;
1244     HRESULT hr;
1245     LPWSTR ext;
1246
1247     static WCHAR header[] = {
1248         'H','T','T','P','/','1','.','0',' ','2','0','0',' ',
1249         'O','K','\\','r','\\','n','\\','r','\\','n',0
1250     };
1251
1252     TRACE("(%p, %s, %p, %d, %d, %p)\n", lpUnkCaller, debugstr_w(szURL),
1253           szFileName, dwBufLength, dwReserved, pBSC);
1254
1255     if (!szURL || !szFileName)
1256         return E_INVALIDARG;
1257
1258     ext = PathFindExtensionW(szURL);
1259
1260     if (!CreateUrlCacheEntryW(szURL, 0, ext, cache_path, 0))
1261         return E_FAIL;
1262
1263     hr = URLDownloadToFileW(lpUnkCaller, szURL, cache_path, 0, pBSC);
1264     if (FAILED(hr))
1265         return hr;
1266
1267     expire.dwHighDateTime = 0;
1268     expire.dwLowDateTime = 0;
1269     modified.dwHighDateTime = 0;
1270     modified.dwLowDateTime = 0;
1271
1272     if (!CommitUrlCacheEntryW(szURL, cache_path, expire, modified, NORMAL_CACHE_ENTRY,
1273                               header, sizeof(header), NULL, NULL))
1274         return E_FAIL;
1275
1276     if (strlenW(cache_path) > dwBufLength)
1277         return E_OUTOFMEMORY;
1278
1279     lstrcpyW(szFileName, cache_path);
1280
1281     return S_OK;
1282 }
1283
1284 /***********************************************************************
1285  *           HlinkSimpleNavigateToString (URLMON.@)
1286  */
1287 HRESULT WINAPI HlinkSimpleNavigateToString( LPCWSTR szTarget,
1288     LPCWSTR szLocation, LPCWSTR szTargetFrameName, IUnknown *pUnk,
1289     IBindCtx *pbc, IBindStatusCallback *pbsc, DWORD grfHLNF, DWORD dwReserved)
1290 {
1291     FIXME("%s\n", debugstr_w( szTarget ) );
1292     return E_NOTIMPL;
1293 }
1294
1295 /***********************************************************************
1296  *           HlinkNavigateString (URLMON.@)
1297  */
1298 HRESULT WINAPI HlinkNavigateString( IUnknown *pUnk, LPCWSTR szTarget )
1299 {
1300     TRACE("%p %s\n", pUnk, debugstr_w( szTarget ) );
1301     return HlinkSimpleNavigateToString( 
1302                szTarget, NULL, NULL, pUnk, NULL, NULL, 0, 0 );
1303 }
1304
1305 /***********************************************************************
1306  *           GetSoftwareUpdateInfo (URLMON.@)
1307  */
1308 HRESULT WINAPI GetSoftwareUpdateInfo( LPCWSTR szDistUnit, LPSOFTDISTINFO psdi )
1309 {
1310     FIXME("%s %p\n", debugstr_w(szDistUnit), psdi );
1311     return E_FAIL;
1312 }