4 * Copyright 1999 Ulrich Czekalla for Corel Corporation
5 * Copyright 2002 Huw D M Davies for CodeWeavers
6 * Copyright 2005 Jacek Caban for CodeWeavers
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #define COM_NO_WINDOWS_H
28 #define NONAMELESSUNION
29 #define NONAMELESSSTRUCT
37 #include "wine/debug.h"
38 #include "wine/unicode.h"
43 #include "urlmon_main.h"
45 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
47 /* native urlmon.dll uses this key, too */
48 static const WCHAR BSCBHolder[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
50 /*static BOOL registered_wndclass = FALSE;*/
53 const IBindingVtbl *lpVtbl;
61 HINTERNET hinternet, hconnect, hrequest;
63 IUMCacheStream *pstrCache;
64 IBindStatusCallback *pbscb;
65 DWORD total_read, expected_size;
68 static HRESULT WINAPI Binding_QueryInterface(IBinding* iface, REFIID riid, void **ppvObject)
70 Binding *This = (Binding*)iface;
72 TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppvObject);
74 if((This == NULL) || (ppvObject == NULL))
77 if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IBinding, riid)) {
79 IBinding_AddRef(iface);
87 static ULONG WINAPI Binding_AddRef(IBinding* iface)
89 Binding *This = (Binding*)iface;
90 ULONG ref = InterlockedIncrement(&This->ref);
92 TRACE("(%p) ref=%ld\n", This, ref);
97 static ULONG WINAPI Binding_Release(IBinding* iface)
99 Binding *This = (Binding*)iface;
100 ULONG ref = InterlockedDecrement(&This->ref);
102 TRACE("(%p) ref=%ld\n",This, ref);
105 HeapFree(GetProcessHeap(), 0, This->URLName);
106 if (This->hCacheFile)
107 CloseHandle(This->hCacheFile);
110 UMCloseCacheFileStream(This->pstrCache);
111 IStream_Release((IStream *)This->pstrCache);
114 IBindStatusCallback_Release(This->pbscb);
116 HeapFree(GetProcessHeap(), 0, This);
118 URLMON_UnlockModule();
124 static HRESULT WINAPI Binding_Abort(IBinding* iface)
126 Binding *This = (Binding*)iface;
128 FIXME("(%p): stub\n", This);
133 static HRESULT WINAPI Binding_GetBindResult(IBinding* iface, CLSID* pclsidProtocol, DWORD* pdwResult, LPOLESTR* pszResult, DWORD* pdwReserved)
135 Binding *This = (Binding*)iface;
137 FIXME("(%p)->(%p, %p, %p, %p): stub\n", This, pclsidProtocol, pdwResult, pszResult, pdwReserved);
142 static HRESULT WINAPI Binding_GetPriority(IBinding* iface, LONG* pnPriority)
144 Binding *This = (Binding*)iface;
146 FIXME("(%p)->(%p): stub\n", This, pnPriority);
151 static HRESULT WINAPI Binding_Resume(IBinding* iface)
153 Binding *This = (Binding*)iface;
155 FIXME("(%p): stub\n", This);
160 static HRESULT WINAPI Binding_SetPriority(IBinding* iface, LONG nPriority)
162 Binding *This = (Binding*)iface;
164 FIXME("(%p)->(%ld): stub\n", This, nPriority);
169 static HRESULT WINAPI Binding_Suspend(IBinding* iface)
171 Binding *This = (Binding*)iface;
173 FIXME("(%p): stub\n", This);
178 static void Binding_CloseCacheDownload(Binding *This)
180 CloseHandle(This->hCacheFile);
181 This->hCacheFile = 0;
182 UMCloseCacheFileStream(This->pstrCache);
183 IStream_Release((IStream *)This->pstrCache);
187 static HRESULT Binding_MoreCacheData(Binding *This, char *buf, DWORD dwBytes)
191 if (WriteFile(This->hCacheFile, buf, dwBytes, &written, NULL) && written == dwBytes)
195 This->total_read += written;
196 hr = IBindStatusCallback_OnProgress(This->pbscb,
197 This->total_read + written,
199 (This->total_read == written) ?
200 BINDSTATUS_BEGINDOWNLOADDATA :
201 BINDSTATUS_DOWNLOADINGDATA,
212 fmt.tymed = TYMED_ISTREAM;
214 stg.tymed = TYMED_ISTREAM;
215 stg.u.pstm = (IStream *)This->pstrCache;
216 stg.pUnkForRelease = NULL;
218 hr = IBindStatusCallback_OnDataAvailable(This->pbscb,
219 (This->total_read == written) ?
220 BSCF_FIRSTDATANOTIFICATION :
221 BSCF_INTERMEDIATEDATANOTIFICATION,
222 This->total_read + written,
226 if (written < dwBytes)
227 return STG_E_MEDIUMFULL;
231 return HRESULT_FROM_WIN32(GetLastError());
234 static void Binding_FinishedDownload(Binding *This, HRESULT hr)
242 fmt.tymed = TYMED_ISTREAM;
244 stg.tymed = TYMED_ISTREAM;
245 stg.u.pstm = (IStream *)This->pstrCache;
246 stg.pUnkForRelease = NULL;
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);
253 WCHAR *pwchError = 0;
255 FormatMessageW (FORMAT_MESSAGE_FROM_SYSTEM |
256 FORMAT_MESSAGE_ALLOCATE_BUFFER,
258 0, (LPWSTR) &pwchError,
262 static WCHAR achFormat[] = { '%', '0', '8', 'x', 0 };
264 pwchError =(WCHAR *) LocalAlloc(LMEM_FIXED, sizeof(WCHAR) * 9);
265 wsprintfW(pwchError, achFormat, hr);
267 IBindStatusCallback_OnStopBinding(This->pbscb, hr, pwchError);
268 LocalFree(pwchError);
272 IBindStatusCallback_OnStopBinding(This->pbscb, hr, NULL);
274 IBindStatusCallback_Release(This->pbscb);
278 static const IBindingVtbl BindingVtbl =
280 Binding_QueryInterface,
288 Binding_GetBindResult
291 /* filemoniker data structure */
294 const IMonikerVtbl* lpvtbl; /* VTable relative to the IMoniker interface.*/
296 LONG ref; /* reference counter for this object */
298 LPOLESTR URLName; /* URL string identified by this URLmoniker */
301 /*******************************************************************************
302 * URLMoniker_QueryInterface
303 *******************************************************************************/
304 static HRESULT WINAPI URLMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
306 URLMonikerImpl *This = (URLMonikerImpl *)iface;
308 TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppvObject);
310 /* Perform a sanity check on the parameters.*/
311 if ( (This==0) || (ppvObject==0) )
314 /* Initialize the return parameter */
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)
325 /* Check that we obtained an interface.*/
327 return E_NOINTERFACE;
329 /* Query Interface always increases the reference count by one when it is successful */
330 IMoniker_AddRef(iface);
335 /******************************************************************************
337 ******************************************************************************/
338 static ULONG WINAPI URLMonikerImpl_AddRef(IMoniker* iface)
340 URLMonikerImpl *This = (URLMonikerImpl *)iface;
341 ULONG refCount = InterlockedIncrement(&This->ref);
343 TRACE("(%p)->(ref before=%lu)\n",This, refCount - 1);
348 /******************************************************************************
350 ******************************************************************************/
351 static ULONG WINAPI URLMonikerImpl_Release(IMoniker* iface)
353 URLMonikerImpl *This = (URLMonikerImpl *)iface;
354 ULONG refCount = InterlockedDecrement(&This->ref);
356 TRACE("(%p)->(ref before=%lu)\n",This, refCount + 1);
358 /* destroy the object if there's no more reference on it */
360 HeapFree(GetProcessHeap(),0,This->URLName);
361 HeapFree(GetProcessHeap(),0,This);
363 URLMON_UnlockModule();
370 /******************************************************************************
371 * URLMoniker_GetClassID
372 ******************************************************************************/
373 static HRESULT WINAPI URLMonikerImpl_GetClassID(IMoniker* iface,
374 CLSID *pClassID)/* Pointer to CLSID of object */
376 URLMonikerImpl *This = (URLMonikerImpl *)iface;
378 TRACE("(%p,%p)\n",This,pClassID);
382 /* Windows always returns CLSID_StdURLMoniker */
383 *pClassID = CLSID_StdURLMoniker;
387 /******************************************************************************
389 ******************************************************************************/
390 static HRESULT WINAPI URLMonikerImpl_IsDirty(IMoniker* iface)
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. */
397 TRACE("(%p)\n",This);
402 /******************************************************************************
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)
411 URLMonikerImpl *This = (URLMonikerImpl *)iface;
416 TRACE("(%p,%p)\n",This,pStm);
421 res = IStream_Read(pStm, &len, sizeof(ULONG), &got);
423 if(got == sizeof(ULONG)) {
424 HeapFree(GetProcessHeap(), 0, This->URLName);
425 This->URLName=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(len+1));
429 res = IStream_Read(pStm, This->URLName, len, NULL);
430 This->URLName[len] = 0;
439 /******************************************************************************
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 */
446 URLMonikerImpl *This = (URLMonikerImpl *)iface;
450 TRACE("(%p,%p,%d)\n",This,pStm,fClearDirty);
455 len = strlenW(This->URLName);
456 res=IStream_Write(pStm,&len,sizeof(ULONG),NULL);
458 res=IStream_Write(pStm,&This->URLName,len*sizeof(WCHAR),NULL);
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 */
469 URLMonikerImpl *This = (URLMonikerImpl *)iface;
471 TRACE("(%p,%p)\n",This,pcbSize);
476 pcbSize->u.LowPart = sizeof(ULONG) + (strlenW(This->URLName) * sizeof(WCHAR));
477 pcbSize->u.HighPart = 0;
481 /******************************************************************************
482 * URLMoniker_BindToObject
483 ******************************************************************************/
484 static HRESULT WINAPI URLMonikerImpl_BindToObject(IMoniker* iface,
490 URLMonikerImpl *This = (URLMonikerImpl *)iface;
494 FIXME("(%p)->(%p,%p,%s,%p): stub\n",This,pbc,pmkToLeft,debugstr_guid(riid),
500 /******************************************************************************
501 * URLMoniker_BindToStorage
502 ******************************************************************************/
503 static HRESULT URLMonikerImpl_BindToStorage_hack(LPCWSTR URLName,
512 WCHAR szFileName[MAX_PATH + 1];
516 WARN("(%s %p %p %s %p)\n", debugstr_w(URLName), pbc, pmkToLeft, debugstr_guid(riid),
520 FIXME("pmkToLeft != NULL\n");
523 if(!IsEqualIID(&IID_IStream, riid)) {
524 FIXME("unsupported iid\n");
528 bind = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(Binding));
529 bind->lpVtbl = &BindingVtbl;
533 len = lstrlenW(URLName)+1;
534 bind->URLName = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
535 memcpy(bind->URLName, URLName, len*sizeof(WCHAR));
537 hres = UMCreateStreamOnCacheFile(bind->URLName, 0, szFileName, &bind->hCacheFile, &bind->pstrCache);
539 if(SUCCEEDED(hres)) {
540 TRACE("Created stream...\n");
542 *ppvObject = (void *) bind->pstrCache;
543 IStream_AddRef((IStream *) bind->pstrCache);
545 hres = IBindCtx_GetObjectParam(pbc, (LPOLESTR)BSCBHolder, (IUnknown**)&bind->pbscb);
546 if(SUCCEEDED(hres)) {
547 TRACE("Got IBindStatusCallback...\n");
549 memset(&bi, 0, sizeof(bi));
550 bi.cbSize = sizeof(bi);
552 hres = IBindStatusCallback_GetBindInfo(bind->pbscb, &bindf, &bi);
553 if(SUCCEEDED(hres)) {
554 WCHAR *urlcopy, *tmpwc;
556 WCHAR *host, *path, *user, *pass;
557 DWORD lensz = sizeof(bind->expected_size);
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);
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.
571 urlcopy = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * (lstrlenW(bind->URLName) + 1));
572 lstrcpyW(urlcopy, bind->URLName);
573 for (tmpwc = urlcopy; *tmpwc && *tmpwc != '#' && *tmpwc != '?'; ++tmpwc)
577 bind->expected_size = 0;
578 bind->total_read = 0;
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)
592 user = HeapAlloc(GetProcessHeap(), 0, ((url.dwUserNameLength + 1) * sizeof(WCHAR)));
593 memcpy(user, url.lpszUserName, url.dwUserNameLength * sizeof(WCHAR));
594 user[url.dwUserNameLength] = 0;
600 if (url.dwPasswordLength)
602 pass = HeapAlloc(GetProcessHeap(), 0, ((url.dwPasswordLength + 1) * sizeof(WCHAR)));
603 memcpy(pass, url.lpszPassword, url.dwPasswordLength * sizeof(WCHAR));
604 pass[url.dwPasswordLength] = 0;
613 bind->hinternet = InternetOpenA("User Agent", 0, NULL, NULL, 0);
614 if (!bind->hinternet)
616 hres = HRESULT_FROM_WIN32(GetLastError());
620 switch ((DWORD) url.nScheme)
622 case INTERNET_SCHEME_FTP:
624 url.nPort = INTERNET_DEFAULT_FTP_PORT;
625 dwService = INTERNET_SERVICE_FTP;
628 case INTERNET_SCHEME_GOPHER:
630 url.nPort = INTERNET_DEFAULT_GOPHER_PORT;
631 dwService = INTERNET_SERVICE_GOPHER;
634 case INTERNET_SCHEME_HTTP:
636 url.nPort = INTERNET_DEFAULT_HTTP_PORT;
637 dwService = INTERNET_SERVICE_HTTP;
640 case INTERNET_SCHEME_HTTPS:
642 url.nPort = INTERNET_DEFAULT_HTTPS_PORT;
643 dwService = INTERNET_SERVICE_HTTP;
647 bind->hconnect = InternetConnectW(bind->hinternet, host, url.nPort, user, pass,
648 dwService, 0, (DWORD)bind);
651 hres = HRESULT_FROM_WIN32(GetLastError());
652 CloseHandle(bind->hinternet);
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);
665 case INTERNET_SERVICE_GOPHER:
666 bind->hrequest = GopherOpenFileW(bind->hconnect,
669 INTERNET_FLAG_RELOAD,
674 hres = HRESULT_FROM_WIN32(GetLastError());
677 case INTERNET_SERVICE_FTP:
678 bind->hrequest = FtpOpenFileW(bind->hconnect,
681 FTP_TRANSFER_TYPE_BINARY |
682 INTERNET_FLAG_TRANSFER_BINARY |
683 INTERNET_FLAG_RELOAD,
688 hres = HRESULT_FROM_WIN32(GetLastError());
691 case INTERNET_SERVICE_HTTP:
692 bind->hrequest = HttpOpenRequestW(bind->hconnect, NULL, path, NULL, NULL, NULL, 0, (DWORD)bind);
695 hres = HRESULT_FROM_WIN32(GetLastError());
697 else if (!HttpSendRequestW(bind->hrequest, NULL, 0, NULL, 0))
699 hres = HRESULT_FROM_WIN32(GetLastError());
700 InternetCloseHandle(bind->hrequest);
704 HttpQueryInfoW(bind->hrequest,
705 HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER,
706 &bind->expected_size,
715 TRACE("res = %ld gle = %08lx url len = %ld\n", hres, GetLastError(), bind->expected_size);
717 IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_CACHEFILENAMEAVAILABLE, szFileName);
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);
729 InternetCloseHandle(bind->hrequest);
733 InternetCloseHandle(bind->hconnect);
734 InternetCloseHandle(bind->hinternet);
737 Binding_CloseCacheDownload(bind);
738 Binding_FinishedDownload(bind, hres);
741 HeapFree(GetProcessHeap(), 0, user);
743 HeapFree(GetProcessHeap(), 0, pass);
744 HeapFree(GetProcessHeap(), 0, path);
745 HeapFree(GetProcessHeap(), 0, host);
746 HeapFree(GetProcessHeap(), 0, urlcopy);
751 IBinding_Release((IBinding*)bind);
756 static HRESULT WINAPI URLMonikerImpl_BindToStorage(IMoniker* iface,
762 URLMonikerImpl *This = (URLMonikerImpl*)iface;
766 URL_COMPONENTSW url = {sizeof(URL_COMPONENTSW), schema,
767 sizeof(schema)/sizeof(WCHAR), 0, NULL, 0, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0};
769 bret = InternetCrackUrlW(This->URLName, 0, ICU_ESCAPE, &url);
771 ERR("InternetCrackUrl failed: %ld\n", GetLastError());
775 if(url.nScheme == INTERNET_SCHEME_HTTP
776 || url.nScheme== INTERNET_SCHEME_HTTPS
777 || url.nScheme== INTERNET_SCHEME_FTP
778 || url.nScheme == INTERNET_SCHEME_GOPHER)
779 return URLMonikerImpl_BindToStorage_hack(This->URLName, pbc, pmkToLeft, riid, ppvObject);
781 TRACE("(%p)->(%p %p %s %p)\n", This, pbc, pmkToLeft, debugstr_guid(riid), ppvObject);
783 return start_binding(This->URLName, pbc, riid, ppvObject);
786 /******************************************************************************
788 ******************************************************************************/
789 static HRESULT WINAPI URLMonikerImpl_Reduce(IMoniker* iface,
791 DWORD dwReduceHowFar,
792 IMoniker** ppmkToLeft,
793 IMoniker** ppmkReduced)
795 URLMonikerImpl *This = (URLMonikerImpl *)iface;
797 TRACE("(%p,%p,%ld,%p,%p)\n",This,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
802 URLMonikerImpl_AddRef(iface);
803 *ppmkReduced = iface;
804 return MK_S_REDUCED_TO_SELF;
807 /******************************************************************************
808 * URLMoniker_ComposeWith
809 ******************************************************************************/
810 static HRESULT WINAPI URLMonikerImpl_ComposeWith(IMoniker* iface,
812 BOOL fOnlyIfNotGeneric,
813 IMoniker** ppmkComposite)
815 URLMonikerImpl *This = (URLMonikerImpl *)iface;
816 FIXME("(%p)->(%p,%d,%p): stub\n",This,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
821 /******************************************************************************
823 ******************************************************************************/
824 static HRESULT WINAPI URLMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
826 URLMonikerImpl *This = (URLMonikerImpl *)iface;
827 TRACE("(%p,%d,%p)\n",This,fForward,ppenumMoniker);
832 /* Does not support sub-monikers */
833 *ppenumMoniker = NULL;
837 /******************************************************************************
839 ******************************************************************************/
840 static HRESULT WINAPI URLMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
842 URLMonikerImpl *This = (URLMonikerImpl *)iface;
848 TRACE("(%p,%p)\n",This,pmkOtherMoniker);
850 if(pmkOtherMoniker==NULL)
853 IMoniker_GetClassID(pmkOtherMoniker,&clsid);
855 if(!IsEqualCLSID(&clsid,&CLSID_StdURLMoniker))
858 res = CreateBindCtx(0,&bind);
863 if(SUCCEEDED(IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&urlPath))) {
864 int result = lstrcmpiW(urlPath, This->URLName);
865 CoTaskMemFree(urlPath);
869 IUnknown_Release(bind);
874 /******************************************************************************
876 ******************************************************************************/
877 static HRESULT WINAPI URLMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
879 URLMonikerImpl *This = (URLMonikerImpl *)iface;
881 int h = 0,i,skip,len;
885 TRACE("(%p,%p)\n",This,pdwHash);
894 for(i = len ; i > 0; i--) {
895 h = (h * 37) + val[off++];
899 /* only sample some characters */
901 for(i = len; i > 0; i -= skip, off += skip) {
902 h = (h * 39) + val[off];
909 /******************************************************************************
910 * URLMoniker_IsRunning
911 ******************************************************************************/
912 static HRESULT WINAPI URLMonikerImpl_IsRunning(IMoniker* iface,
915 IMoniker* pmkNewlyRunning)
917 URLMonikerImpl *This = (URLMonikerImpl *)iface;
918 FIXME("(%p)->(%p,%p,%p): stub\n",This,pbc,pmkToLeft,pmkNewlyRunning);
923 /******************************************************************************
924 * URLMoniker_GetTimeOfLastChange
925 ******************************************************************************/
926 static HRESULT WINAPI URLMonikerImpl_GetTimeOfLastChange(IMoniker* iface,
931 URLMonikerImpl *This = (URLMonikerImpl *)iface;
932 FIXME("(%p)->(%p,%p,%p): stub\n",This,pbc,pmkToLeft,pFileTime);
937 /******************************************************************************
939 ******************************************************************************/
940 static HRESULT WINAPI URLMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
942 URLMonikerImpl *This = (URLMonikerImpl *)iface;
943 TRACE("(%p,%p)\n",This,ppmk);
945 return MK_E_NOINVERSE;
948 /******************************************************************************
949 * URLMoniker_CommonPrefixWith
950 ******************************************************************************/
951 static HRESULT WINAPI URLMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
953 URLMonikerImpl *This = (URLMonikerImpl *)iface;
954 FIXME("(%p)->(%p,%p): stub\n",This,pmkOther,ppmkPrefix);
959 /******************************************************************************
960 * URLMoniker_RelativePathTo
961 ******************************************************************************/
962 static HRESULT WINAPI URLMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
964 URLMonikerImpl *This = (URLMonikerImpl *)iface;
965 FIXME("(%p)->(%p,%p): stub\n",This,pmOther,ppmkRelPath);
970 /******************************************************************************
971 * URLMoniker_GetDisplayName
972 ******************************************************************************/
973 static HRESULT WINAPI URLMonikerImpl_GetDisplayName(IMoniker* iface,
976 LPOLESTR *ppszDisplayName)
978 URLMonikerImpl *This = (URLMonikerImpl *)iface;
982 TRACE("(%p,%p,%p,%p)\n",This,pbc,pmkToLeft,ppszDisplayName);
987 /* FIXME: If this is a partial URL, try and get a URL moniker from SZ_URLCONTEXT in the bind context,
988 then look at pmkToLeft to try and complete the URL
990 len = lstrlenW(This->URLName)+1;
991 *ppszDisplayName = CoTaskMemAlloc(len*sizeof(WCHAR));
992 if(!*ppszDisplayName)
993 return E_OUTOFMEMORY;
994 lstrcpyW(*ppszDisplayName, This->URLName);
998 /******************************************************************************
999 * URLMoniker_ParseDisplayName
1000 ******************************************************************************/
1001 static HRESULT WINAPI URLMonikerImpl_ParseDisplayName(IMoniker* iface,
1003 IMoniker* pmkToLeft,
1004 LPOLESTR pszDisplayName,
1008 URLMonikerImpl *This = (URLMonikerImpl *)iface;
1009 FIXME("(%p)->(%p,%p,%p,%p,%p): stub\n",This,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
1014 /******************************************************************************
1015 * URLMoniker_IsSystemMoniker
1016 ******************************************************************************/
1017 static HRESULT WINAPI URLMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
1019 URLMonikerImpl *This = (URLMonikerImpl *)iface;
1020 TRACE("(%p,%p)\n",This,pwdMksys);
1023 return E_INVALIDARG;
1025 *pwdMksys = MKSYS_URLMONIKER;
1029 /********************************************************************************/
1030 /* Virtual function table for the URLMonikerImpl class which include IPersist,*/
1031 /* IPersistStream and IMoniker functions. */
1032 static const IMonikerVtbl VT_URLMonikerImpl =
1034 URLMonikerImpl_QueryInterface,
1035 URLMonikerImpl_AddRef,
1036 URLMonikerImpl_Release,
1037 URLMonikerImpl_GetClassID,
1038 URLMonikerImpl_IsDirty,
1039 URLMonikerImpl_Load,
1040 URLMonikerImpl_Save,
1041 URLMonikerImpl_GetSizeMax,
1042 URLMonikerImpl_BindToObject,
1043 URLMonikerImpl_BindToStorage,
1044 URLMonikerImpl_Reduce,
1045 URLMonikerImpl_ComposeWith,
1046 URLMonikerImpl_Enum,
1047 URLMonikerImpl_IsEqual,
1048 URLMonikerImpl_Hash,
1049 URLMonikerImpl_IsRunning,
1050 URLMonikerImpl_GetTimeOfLastChange,
1051 URLMonikerImpl_Inverse,
1052 URLMonikerImpl_CommonPrefixWith,
1053 URLMonikerImpl_RelativePathTo,
1054 URLMonikerImpl_GetDisplayName,
1055 URLMonikerImpl_ParseDisplayName,
1056 URLMonikerImpl_IsSystemMoniker
1059 /******************************************************************************
1060 * URLMoniker_Construct (local function)
1061 *******************************************************************************/
1062 static HRESULT URLMonikerImpl_Construct(URLMonikerImpl* This, LPCOLESTR lpszLeftURLName, LPCOLESTR lpszURLName)
1065 DWORD sizeStr = INTERNET_MAX_URL_LENGTH;
1067 TRACE("(%p,%s,%s)\n",This,debugstr_w(lpszLeftURLName),debugstr_w(lpszURLName));
1069 This->lpvtbl = &VT_URLMonikerImpl;
1072 sizeStr = lstrlenW(lpszURLName)+1;
1074 sizeStr += strlenW(lpszLeftURLName)+32;
1076 This->URLName = HeapAlloc(GetProcessHeap(), 0, sizeStr*sizeof(WCHAR));
1078 if(lpszLeftURLName) {
1079 hres = CoInternetCombineUrl(lpszLeftURLName, lpszURLName, 0, This->URLName, sizeStr,
1082 HeapFree(GetProcessHeap(), 0, This->URLName);
1087 * We probably should use CoInternetParseUrl or something similar here.
1090 static const WCHAR wszFile[] = {'f','i','l','e',':','/','/',};
1092 /* file protocol is a special case */
1093 if(sizeStr > sizeof(wszFile)/sizeof(WCHAR)
1094 && !memcmp(lpszURLName, wszFile, sizeof(wszFile)))
1095 UrlCanonicalizeW(lpszURLName, This->URLName, &sizeStr, URL_FILE_USE_PATHURL);
1097 strcpyW(This->URLName,lpszURLName);
1100 URLMON_LockModule();
1105 /***********************************************************************
1106 * CreateAsyncBindCtx (URLMON.@)
1108 HRESULT WINAPI CreateAsyncBindCtx(DWORD reserved, IBindStatusCallback *callback,
1109 IEnumFORMATETC *format, IBindCtx **pbind)
1111 TRACE("(%08lx %p %p %p)\n", reserved, callback, format, pbind);
1114 return E_INVALIDARG;
1116 return CreateAsyncBindCtxEx(NULL, 0, callback, format, pbind, 0);
1118 /***********************************************************************
1119 * CreateAsyncBindCtxEx (URLMON.@)
1121 * Create an asynchronous bind context.
1123 HRESULT WINAPI CreateAsyncBindCtxEx(IBindCtx *ibind, DWORD options,
1124 IBindStatusCallback *callback, IEnumFORMATETC *format, IBindCtx** pbind,
1131 TRACE("(%p %08lx %p %p %p %ld)\n", ibind, options, callback, format, pbind, reserved);
1134 return E_INVALIDARG;
1137 FIXME("not supported options %08lx", options);
1139 FIXME("format is not supported\n");
1142 WARN("reserved=%ld\n", reserved);
1144 hres = CreateBindCtx(0, &bctx);
1148 bindopts.cbStruct = sizeof(BIND_OPTS);
1149 bindopts.grfFlags = BIND_MAYBOTHERUSER;
1150 bindopts.grfMode = STGM_READWRITE | STGM_SHARE_EXCLUSIVE;
1151 bindopts.dwTickCountDeadline = 0;
1152 IBindCtx_SetBindOptions(bctx, &bindopts);
1155 RegisterBindStatusCallback(bctx, callback, NULL, 0);
1163 /***********************************************************************
1164 * CreateURLMoniker (URLMON.@)
1166 * Create a url moniker.
1169 * pmkContext [I] Context
1170 * szURL [I] Url to create the moniker for
1171 * ppmk [O] Destination for created moniker.
1174 * Success: S_OK. ppmk contains the created IMoniker object.
1175 * Failure: MK_E_SYNTAX if szURL is not a valid url, or
1176 * E_OUTOFMEMORY if memory allocation fails.
1178 HRESULT WINAPI CreateURLMoniker(IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk)
1180 URLMonikerImpl *obj;
1182 IID iid = IID_IMoniker;
1183 LPOLESTR lefturl = NULL;
1185 TRACE("(%p, %s, %p)\n", pmkContext, debugstr_w(szURL), ppmk);
1187 if(!(obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*obj))))
1188 return E_OUTOFMEMORY;
1193 IMoniker_IsSystemMoniker(pmkContext, &dwMksys);
1194 if(dwMksys == MKSYS_URLMONIKER && SUCCEEDED(CreateBindCtx(0, &bind))) {
1195 IMoniker_GetDisplayName(pmkContext, bind, NULL, &lefturl);
1196 TRACE("lefturl = %s\n", debugstr_w(lefturl));
1197 IBindCtx_Release(bind);
1201 hres = URLMonikerImpl_Construct(obj, lefturl, szURL);
1202 CoTaskMemFree(lefturl);
1204 hres = URLMonikerImpl_QueryInterface((IMoniker*)obj, &iid, (void**)ppmk);
1206 HeapFree(GetProcessHeap(), 0, obj);
1210 /***********************************************************************
1211 * CoInternetQueryInfo (URLMON.@)
1213 * Retrieves information relevant to a specified URL
1217 * S_FALSE buffer too small
1218 * INET_E_QUERYOPTIONUNKNOWN invalid option
1221 HRESULT WINAPI CoInternetQueryInfo(LPCWSTR pwzUrl, QUERYOPTION QueryOption,
1222 DWORD dwQueryFlags, LPVOID pvBuffer, DWORD cbBuffer, DWORD * pcbBuffer,
1225 FIXME("(%s, %x, %lx, %p, %lx, %p, %lx): stub\n", debugstr_w(pwzUrl),
1226 QueryOption, dwQueryFlags, pvBuffer, cbBuffer, pcbBuffer, dwReserved);
1230 /***********************************************************************
1231 * IsAsyncMoniker (URLMON.@)
1233 HRESULT WINAPI IsAsyncMoniker(IMoniker *pmk)
1237 TRACE("(%p)\n", pmk);
1239 return E_INVALIDARG;
1240 if(SUCCEEDED(IMoniker_QueryInterface(pmk, &IID_IAsyncMoniker, (void**)&am))) {
1241 IUnknown_Release(am);
1247 /***********************************************************************
1248 * BindAsyncMoniker (URLMON.@)
1250 * Bind a bind status callback to an asynchronous URL Moniker.
1253 * pmk [I] Moniker object to bind status callback to
1254 * grfOpt [I] Options, seems not used
1255 * pbsc [I] Status callback to bind
1256 * iidResult [I] Interface to return
1257 * ppvResult [O] Resulting asynchronous moniker object
1261 * Failure: E_INVALIDARG, if any argument is invalid, or
1262 * E_OUTOFMEMORY if memory allocation fails.
1264 HRESULT WINAPI BindAsyncMoniker(IMoniker *pmk, DWORD grfOpt, IBindStatusCallback *pbsc, REFIID iidResult, LPVOID *ppvResult)
1267 HRESULT hr = E_INVALIDARG;
1269 if (pmk && ppvResult)
1273 hr = CreateAsyncBindCtx(0, pbsc, NULL, &pbc);
1276 hr = IMoniker_BindToObject(pmk, pbc, NULL, iidResult, ppvResult);
1277 IBindCtx_Release(pbc);
1283 /***********************************************************************
1284 * RegisterBindStatusCallback (URLMON.@)
1286 * Register a bind status callback.
1289 * pbc [I] Binding context
1290 * pbsc [I] Callback to register
1291 * ppbscPrevious [O] Destination for previous callback
1292 * dwReserved [I] Reserved, must be 0.
1296 * Failure: E_INVALIDARG, if any argument is invalid, or
1297 * E_OUTOFMEMORY if memory allocation fails.
1299 HRESULT WINAPI RegisterBindStatusCallback(
1301 IBindStatusCallback *pbsc,
1302 IBindStatusCallback **ppbscPrevious,
1305 IBindStatusCallback *prev;
1307 TRACE("(%p,%p,%p,%lu)\n", pbc, pbsc, ppbscPrevious, dwReserved);
1309 if (pbc == NULL || pbsc == NULL)
1310 return E_INVALIDARG;
1312 if (SUCCEEDED(IBindCtx_GetObjectParam(pbc, (LPOLESTR)BSCBHolder, (IUnknown **)&prev)))
1314 IBindCtx_RevokeObjectParam(pbc, (LPOLESTR)BSCBHolder);
1316 *ppbscPrevious = prev;
1318 IBindStatusCallback_Release(prev);
1321 return IBindCtx_RegisterObjectParam(pbc, (LPOLESTR)BSCBHolder, (IUnknown *)pbsc);
1324 /***********************************************************************
1325 * RevokeBindStatusCallback (URLMON.@)
1327 * Unregister a bind status callback.
1329 * pbc [I] Binding context
1330 * pbsc [I] Callback to unregister
1334 * Failure: E_INVALIDARG, if any argument is invalid, or
1335 * E_FAIL if pbsc wasn't registered with pbc.
1337 HRESULT WINAPI RevokeBindStatusCallback(
1339 IBindStatusCallback *pbsc)
1341 IBindStatusCallback *callback;
1342 HRESULT hr = E_FAIL;
1344 TRACE("(%p,%p)\n", pbc, pbsc);
1346 if (pbc == NULL || pbsc == NULL)
1347 return E_INVALIDARG;
1349 if (SUCCEEDED(IBindCtx_GetObjectParam(pbc, (LPOLESTR)BSCBHolder, (IUnknown **)&callback)))
1351 if (callback == pbsc)
1353 IBindCtx_RevokeObjectParam(pbc, (LPOLESTR)BSCBHolder);
1356 IBindStatusCallback_Release(pbsc);
1362 /***********************************************************************
1363 * URLDownloadToFileA (URLMON.@)
1365 * Downloads URL szURL to rile szFileName and call lpfnCB callback to
1369 * pCaller [I] controlling IUnknown interface.
1370 * szURL [I] URL of the file to download
1371 * szFileName [I] file name to store the content of the URL
1372 * dwReserved [I] reserved - set to 0
1373 * lpfnCB [I] callback for progress report
1377 * E_OUTOFMEMORY when going out of memory
1379 HRESULT WINAPI URLDownloadToFileA(LPUNKNOWN pCaller,
1383 LPBINDSTATUSCALLBACK lpfnCB)
1385 UNICODE_STRING szURL_w, szFileName_w;
1387 if ((szURL == NULL) || (szFileName == NULL)) {
1388 FIXME("(%p,%s,%s,%08lx,%p) cannot accept NULL strings !\n", pCaller, debugstr_a(szURL), debugstr_a(szFileName), dwReserved, lpfnCB);
1389 return E_INVALIDARG; /* The error code is not specified in this case... */
1392 if (RtlCreateUnicodeStringFromAsciiz(&szURL_w, szURL)) {
1393 if (RtlCreateUnicodeStringFromAsciiz(&szFileName_w, szFileName)) {
1394 HRESULT ret = URLDownloadToFileW(pCaller, szURL_w.Buffer, szFileName_w.Buffer, dwReserved, lpfnCB);
1396 RtlFreeUnicodeString(&szURL_w);
1397 RtlFreeUnicodeString(&szFileName_w);
1401 RtlFreeUnicodeString(&szURL_w);
1405 FIXME("(%p,%s,%s,%08lx,%p) could not allocate W strings !\n", pCaller, szURL, szFileName, dwReserved, lpfnCB);
1406 return E_OUTOFMEMORY;
1409 /***********************************************************************
1410 * URLDownloadToFileW (URLMON.@)
1412 * Downloads URL szURL to rile szFileName and call lpfnCB callback to
1416 * pCaller [I] controlling IUnknown interface.
1417 * szURL [I] URL of the file to download
1418 * szFileName [I] file name to store the content of the URL
1419 * dwReserved [I] reserved - set to 0
1420 * lpfnCB [I] callback for progress report
1424 * E_OUTOFMEMORY when going out of memory
1426 HRESULT WINAPI URLDownloadToFileW(LPUNKNOWN pCaller,
1430 LPBINDSTATUSCALLBACK lpfnCB)
1432 HINTERNET hinternet, hcon, hreq;
1434 CHAR buffer[0x1000];
1435 DWORD sz, total, written;
1436 DWORD total_size = 0xFFFFFFFF, arg_size = sizeof(total_size);
1437 URL_COMPONENTSW url;
1438 WCHAR host[0x80], path[0x100];
1440 static const WCHAR wszAppName[]={'u','r','l','m','o','n','.','d','l','l',0};
1442 /* Note: all error codes would need to be checked agains real Windows behaviour... */
1443 TRACE("(%p,%s,%s,%08lx,%p) stub!\n", pCaller, debugstr_w(szURL), debugstr_w(szFileName), dwReserved, lpfnCB);
1445 if ((szURL == NULL) || (szFileName == NULL)) {
1446 FIXME(" cannot accept NULL strings !\n");
1447 return E_INVALIDARG;
1450 /* Would be better to use the application name here rather than 'urlmon' :-/ */
1451 hinternet = InternetOpenW(wszAppName, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
1452 if (hinternet == NULL) {
1453 return E_OUTOFMEMORY;
1456 memset(&url, 0, sizeof(url));
1457 url.dwStructSize = sizeof(url);
1458 url.lpszHostName = host;
1459 url.dwHostNameLength = sizeof(host);
1460 url.lpszUrlPath = path;
1461 url.dwUrlPathLength = sizeof(path);
1463 if (!InternetCrackUrlW(szURL, 0, 0, &url)) {
1464 InternetCloseHandle(hinternet);
1465 return E_OUTOFMEMORY;
1469 if (IBindStatusCallback_OnProgress(lpfnCB, 0, 0, BINDSTATUS_CONNECTING, url.lpszHostName) == E_ABORT) {
1470 InternetCloseHandle(hinternet);
1475 hcon = InternetConnectW(hinternet, url.lpszHostName, url.nPort,
1476 url.lpszUserName, url.lpszPassword,
1477 INTERNET_SERVICE_HTTP, 0, 0);
1479 InternetCloseHandle(hinternet);
1480 return E_OUTOFMEMORY;
1483 hreq = HttpOpenRequestW(hcon, NULL, url.lpszUrlPath, NULL, NULL, NULL, 0, 0);
1485 InternetCloseHandle(hinternet);
1486 InternetCloseHandle(hcon);
1487 return E_OUTOFMEMORY;
1490 if (!HttpSendRequestW(hreq, NULL, 0, NULL, 0)) {
1491 InternetCloseHandle(hinternet);
1492 InternetCloseHandle(hcon);
1493 InternetCloseHandle(hreq);
1494 return E_OUTOFMEMORY;
1497 if (HttpQueryInfoW(hreq, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER,
1498 &total_size, &arg_size, NULL)) {
1499 TRACE(" total size : %ld\n", total_size);
1502 hfile = CreateFileW(szFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
1503 FILE_ATTRIBUTE_NORMAL, NULL );
1504 if (hfile == INVALID_HANDLE_VALUE) {
1505 return E_ACCESSDENIED;
1509 if (IBindStatusCallback_OnProgress(lpfnCB, 0, total_size != 0xFFFFFFFF ? total_size : 0,
1510 BINDSTATUS_BEGINDOWNLOADDATA, szURL) == E_ABORT) {
1511 InternetCloseHandle(hreq);
1512 InternetCloseHandle(hcon);
1513 InternetCloseHandle(hinternet);
1521 r = InternetReadFile(hreq, buffer, sizeof(buffer), &sz);
1523 InternetCloseHandle(hreq);
1524 InternetCloseHandle(hcon);
1525 InternetCloseHandle(hinternet);
1528 return E_OUTOFMEMORY;
1536 if (IBindStatusCallback_OnProgress(lpfnCB, total, total_size != 0xFFFFFFFF ? total_size : 0,
1537 BINDSTATUS_DOWNLOADINGDATA, szURL) == E_ABORT) {
1538 InternetCloseHandle(hreq);
1539 InternetCloseHandle(hcon);
1540 InternetCloseHandle(hinternet);
1546 if (!WriteFile(hfile, buffer, sz, &written, NULL)) {
1547 InternetCloseHandle(hreq);
1548 InternetCloseHandle(hcon);
1549 InternetCloseHandle(hinternet);
1552 return E_OUTOFMEMORY;
1557 if (IBindStatusCallback_OnProgress(lpfnCB, total, total_size != 0xFFFFFFFF ? total_size : 0,
1558 BINDSTATUS_ENDDOWNLOADDATA, szURL) == E_ABORT) {
1559 InternetCloseHandle(hreq);
1560 InternetCloseHandle(hcon);
1561 InternetCloseHandle(hinternet);
1567 InternetCloseHandle(hreq);
1568 InternetCloseHandle(hcon);
1569 InternetCloseHandle(hinternet);
1576 /***********************************************************************
1577 * URLDownloadToCacheFileA (URLMON.@)
1579 HRESULT WINAPI URLDownloadToCacheFileA(LPUNKNOWN lpUnkCaller, LPCSTR szURL, LPSTR szFileName,
1580 DWORD dwBufLength, DWORD dwReserved, LPBINDSTATUSCALLBACK pBSC)
1582 LPWSTR url = NULL, file_name = NULL;
1586 TRACE("(%p %s %p %ld %ld %p)\n", lpUnkCaller, debugstr_a(szURL), szFileName,
1587 dwBufLength, dwReserved, pBSC);
1590 len = MultiByteToWideChar(CP_ACP, 0, szURL, -1, NULL, 0);
1591 url = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
1592 MultiByteToWideChar(CP_ACP, 0, szURL, -1, url, -1);
1596 file_name = HeapAlloc(GetProcessHeap(), 0, dwBufLength*sizeof(WCHAR));
1598 hres = URLDownloadToCacheFileW(lpUnkCaller, url, file_name, dwBufLength*sizeof(WCHAR),
1601 if(SUCCEEDED(hres) && file_name)
1602 WideCharToMultiByte(CP_ACP, 0, file_name, -1, szFileName, dwBufLength, NULL, NULL);
1604 HeapFree(GetProcessHeap(), 0, url);
1605 HeapFree(GetProcessHeap(), 0, file_name);
1610 /***********************************************************************
1611 * URLDownloadToCacheFileW (URLMON.@)
1613 HRESULT WINAPI URLDownloadToCacheFileW(LPUNKNOWN lpUnkCaller, LPCWSTR szURL, LPWSTR szFileName,
1614 DWORD dwBufLength, DWORD dwReserved, LPBINDSTATUSCALLBACK pBSC)
1616 FIXME("(%p %s %p %ld %ld %p)\n", lpUnkCaller, debugstr_w(szURL), szFileName,
1617 dwBufLength, dwReserved, pBSC);
1621 /***********************************************************************
1622 * HlinkSimpleNavigateToString (URLMON.@)
1624 HRESULT WINAPI HlinkSimpleNavigateToString( LPCWSTR szTarget,
1625 LPCWSTR szLocation, LPCWSTR szTargetFrameName, IUnknown *pUnk,
1626 IBindCtx *pbc, IBindStatusCallback *pbsc, DWORD grfHLNF, DWORD dwReserved)
1628 FIXME("%s\n", debugstr_w( szTarget ) );
1632 /***********************************************************************
1633 * HlinkNavigateString (URLMON.@)
1635 HRESULT WINAPI HlinkNavigateString( IUnknown *pUnk, LPCWSTR szTarget )
1637 TRACE("%p %s\n", pUnk, debugstr_w( szTarget ) );
1638 return HlinkSimpleNavigateToString(
1639 szTarget, NULL, NULL, pUnk, NULL, NULL, 0, 0 );
1642 /***********************************************************************
1643 * GetSoftwareUpdateInfo (URLMON.@)
1645 HRESULT WINAPI GetSoftwareUpdateInfo( LPCWSTR szDistUnit, LPSOFTDISTINFO psdi )
1647 FIXME("%s %p\n", debugstr_w(szDistUnit), psdi );