| /* |
| * UrlMon |
| * |
| * Copyright 1999 Ulrich Czekalla for Corel Corporation |
| * Copyright 2002 Huw D M Davies for CodeWeavers |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #define COM_NO_WINDOWS_H |
| #include <stdarg.h> |
| #include <stdio.h> |
| |
| #define COBJMACROS |
| #define NONAMELESSUNION |
| #define NONAMELESSSTRUCT |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winreg.h" |
| #include "winternl.h" |
| #include "winuser.h" |
| #include "objbase.h" |
| #include "wine/debug.h" |
| #include "wine/unicode.h" |
| #include "ole2.h" |
| #include "urlmon.h" |
| #include "wininet.h" |
| #include "shlwapi.h" |
| #include "urlmon_main.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(urlmon); |
| |
| /* native urlmon.dll uses this key, too */ |
| static const WCHAR BSCBHolder[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 }; |
| |
| /*static BOOL registered_wndclass = FALSE;*/ |
| |
| typedef struct { |
| const IBindingVtbl *lpVtbl; |
| |
| ULONG ref; |
| |
| LPWSTR URLName; |
| |
| HWND hwndCallback; |
| IBindCtx *pBC; |
| HINTERNET hinternet, hconnect, hrequest; |
| HANDLE hCacheFile; |
| IUMCacheStream *pstrCache; |
| IBindStatusCallback *pbscb; |
| DWORD total_read, expected_size; |
| } Binding; |
| |
| static HRESULT WINAPI Binding_QueryInterface(IBinding* iface, REFIID riid, void **ppvObject) |
| { |
| Binding *This = (Binding*)iface; |
| |
| TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppvObject); |
| |
| if((This == NULL) || (ppvObject == NULL)) |
| return E_INVALIDARG; |
| |
| if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IBinding, riid)) { |
| *ppvObject = iface; |
| IBinding_AddRef(iface); |
| return S_OK; |
| } |
| |
| *ppvObject = NULL; |
| return E_NOINTERFACE; |
| } |
| |
| static ULONG WINAPI Binding_AddRef(IBinding* iface) |
| { |
| Binding *This = (Binding*)iface; |
| ULONG ref = InterlockedIncrement(&This->ref); |
| |
| TRACE("(%p) ref=%ld\n", This, ref); |
| |
| return ref; |
| } |
| |
| static ULONG WINAPI Binding_Release(IBinding* iface) |
| { |
| Binding *This = (Binding*)iface; |
| ULONG ref = InterlockedDecrement(&This->ref); |
| |
| TRACE("(%p) ref=%ld\n",This, ref); |
| |
| if(!ref) { |
| HeapFree(GetProcessHeap(), 0, This->URLName); |
| if (This->hCacheFile) |
| CloseHandle(This->hCacheFile); |
| if (This->pstrCache) |
| { |
| UMCloseCacheFileStream(This->pstrCache); |
| IStream_Release((IStream *)This->pstrCache); |
| } |
| if (This->pbscb) |
| IBindStatusCallback_Release(This->pbscb); |
| |
| HeapFree(GetProcessHeap(), 0, This); |
| |
| URLMON_UnlockModule(); |
| } |
| |
| return ref; |
| } |
| |
| static HRESULT WINAPI Binding_Abort(IBinding* iface) |
| { |
| Binding *This = (Binding*)iface; |
| |
| FIXME("(%p): stub\n", This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI Binding_GetBindResult(IBinding* iface, CLSID* pclsidProtocol, DWORD* pdwResult, LPOLESTR* pszResult, DWORD* pdwReserved) |
| { |
| Binding *This = (Binding*)iface; |
| |
| FIXME("(%p)->(%p, %p, %p, %p): stub\n", This, pclsidProtocol, pdwResult, pszResult, pdwReserved); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI Binding_GetPriority(IBinding* iface, LONG* pnPriority) |
| { |
| Binding *This = (Binding*)iface; |
| |
| FIXME("(%p)->(%p): stub\n", This, pnPriority); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI Binding_Resume(IBinding* iface) |
| { |
| Binding *This = (Binding*)iface; |
| |
| FIXME("(%p): stub\n", This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI Binding_SetPriority(IBinding* iface, LONG nPriority) |
| { |
| Binding *This = (Binding*)iface; |
| |
| FIXME("(%p)->(%ld): stub\n", This, nPriority); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI Binding_Suspend(IBinding* iface) |
| { |
| Binding *This = (Binding*)iface; |
| |
| FIXME("(%p): stub\n", This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static void Binding_CloseCacheDownload(Binding *This) |
| { |
| CloseHandle(This->hCacheFile); |
| This->hCacheFile = 0; |
| UMCloseCacheFileStream(This->pstrCache); |
| IStream_Release((IStream *)This->pstrCache); |
| This->pstrCache = 0; |
| } |
| |
| static HRESULT Binding_MoreCacheData(Binding *This, char *buf, DWORD dwBytes) |
| { |
| DWORD written; |
| |
| if (WriteFile(This->hCacheFile, buf, dwBytes, &written, NULL) && written == dwBytes) |
| { |
| HRESULT hr; |
| |
| This->total_read += written; |
| hr = IBindStatusCallback_OnProgress(This->pbscb, |
| This->total_read + written, |
| This->expected_size, |
| (This->total_read == written) ? |
| BINDSTATUS_BEGINDOWNLOADDATA : |
| BINDSTATUS_DOWNLOADINGDATA, |
| NULL); |
| if (!hr) |
| { |
| STGMEDIUM stg; |
| FORMATETC fmt; |
| |
| fmt.cfFormat = 0; |
| fmt.ptd = NULL; |
| fmt.dwAspect = 0; |
| fmt.lindex = -1; |
| fmt.tymed = TYMED_ISTREAM; |
| |
| stg.tymed = TYMED_ISTREAM; |
| stg.u.pstm = (IStream *)This->pstrCache; |
| stg.pUnkForRelease = NULL; |
| |
| hr = IBindStatusCallback_OnDataAvailable(This->pbscb, |
| (This->total_read == written) ? |
| BSCF_FIRSTDATANOTIFICATION : |
| BSCF_INTERMEDIATEDATANOTIFICATION, |
| This->total_read + written, |
| &fmt, |
| &stg); |
| } |
| if (written < dwBytes) |
| return STG_E_MEDIUMFULL; |
| else |
| return hr; |
| } |
| return HRESULT_FROM_WIN32(GetLastError()); |
| } |
| |
| static void Binding_FinishedDownload(Binding *This, HRESULT hr) |
| { |
| STGMEDIUM stg; |
| FORMATETC fmt; |
| |
| fmt.ptd = NULL; |
| fmt.dwAspect = 0; |
| fmt.lindex = -1; |
| fmt.tymed = TYMED_ISTREAM; |
| |
| stg.tymed = TYMED_ISTREAM; |
| stg.u.pstm = (IStream *)This->pstrCache; |
| stg.pUnkForRelease = NULL; |
| |
| IBindStatusCallback_OnProgress(This->pbscb, This->total_read, This->expected_size, BINDSTATUS_ENDDOWNLOADDATA, NULL); |
| IBindStatusCallback_OnDataAvailable(This->pbscb, BSCF_LASTDATANOTIFICATION, This->total_read, &fmt, &stg); |
| if (hr) |
| { |
| WCHAR *pwchError = 0; |
| |
| FormatMessageW (FORMAT_MESSAGE_FROM_SYSTEM | |
| FORMAT_MESSAGE_ALLOCATE_BUFFER, |
| NULL, (DWORD) hr, |
| 0, (LPWSTR) &pwchError, |
| 0, NULL); |
| if (!pwchError) |
| { |
| static WCHAR achFormat[] = { '%', '0', '8', 'x', 0 }; |
| |
| pwchError =(WCHAR *) LocalAlloc(LMEM_FIXED, sizeof(WCHAR) * 9); |
| wsprintfW(pwchError, achFormat, hr); |
| } |
| IBindStatusCallback_OnStopBinding(This->pbscb, hr, pwchError); |
| LocalFree(pwchError); |
| } |
| else |
| { |
| IBindStatusCallback_OnStopBinding(This->pbscb, hr, NULL); |
| } |
| IBindStatusCallback_Release(This->pbscb); |
| This->pbscb = 0; |
| } |
| |
| static const IBindingVtbl BindingVtbl = |
| { |
| Binding_QueryInterface, |
| Binding_AddRef, |
| Binding_Release, |
| Binding_Abort, |
| Binding_Suspend, |
| Binding_Resume, |
| Binding_SetPriority, |
| Binding_GetPriority, |
| Binding_GetBindResult |
| }; |
| |
| /* filemoniker data structure */ |
| typedef struct { |
| |
| const IMonikerVtbl* lpvtbl; /* VTable relative to the IMoniker interface.*/ |
| |
| ULONG ref; /* reference counter for this object */ |
| |
| LPOLESTR URLName; /* URL string identified by this URLmoniker */ |
| } URLMonikerImpl; |
| |
| /******************************************************************************* |
| * URLMoniker_QueryInterface |
| *******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| |
| TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppvObject); |
| |
| /* Perform a sanity check on the parameters.*/ |
| if ( (This==0) || (ppvObject==0) ) |
| return E_INVALIDARG; |
| |
| /* Initialize the return parameter */ |
| *ppvObject = 0; |
| |
| /* Compare the riid with the interface IDs implemented by this object.*/ |
| if (IsEqualIID(&IID_IUnknown, riid) || |
| IsEqualIID(&IID_IPersist, riid) || |
| IsEqualIID(&IID_IPersistStream,riid) || |
| IsEqualIID(&IID_IMoniker, riid) |
| ) |
| *ppvObject = iface; |
| |
| /* Check that we obtained an interface.*/ |
| if ((*ppvObject)==0) |
| return E_NOINTERFACE; |
| |
| /* Query Interface always increases the reference count by one when it is successful */ |
| IMoniker_AddRef(iface); |
| |
| return S_OK; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_AddRef |
| ******************************************************************************/ |
| static ULONG WINAPI URLMonikerImpl_AddRef(IMoniker* iface) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| ULONG refCount = InterlockedIncrement(&This->ref); |
| |
| TRACE("(%p)->(ref before=%lu)\n",This, refCount - 1); |
| |
| URLMON_LockModule(); |
| |
| return refCount; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_Release |
| ******************************************************************************/ |
| static ULONG WINAPI URLMonikerImpl_Release(IMoniker* iface) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| ULONG refCount = InterlockedDecrement(&This->ref); |
| |
| TRACE("(%p)->(ref before=%lu)\n",This, refCount + 1); |
| |
| /* destroy the object if there's no more reference on it */ |
| if (!refCount) { |
| HeapFree(GetProcessHeap(),0,This->URLName); |
| HeapFree(GetProcessHeap(),0,This); |
| } |
| |
| URLMON_UnlockModule(); |
| |
| return refCount; |
| } |
| |
| |
| /****************************************************************************** |
| * URLMoniker_GetClassID |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_GetClassID(IMoniker* iface, |
| CLSID *pClassID)/* Pointer to CLSID of object */ |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| |
| TRACE("(%p,%p)\n",This,pClassID); |
| |
| if (pClassID==NULL) |
| return E_POINTER; |
| /* Windows always returns CLSID_StdURLMoniker */ |
| *pClassID = CLSID_StdURLMoniker; |
| return S_OK; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_IsDirty |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_IsDirty(IMoniker* iface) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| /* Note that the OLE-provided implementations of the IPersistStream::IsDirty |
| method in the OLE-provided moniker interfaces always return S_FALSE because |
| their internal state never changes. */ |
| |
| TRACE("(%p)\n",This); |
| |
| return S_FALSE; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_Load |
| * |
| * NOTE |
| * Writes a ULONG containing length of unicode string, followed |
| * by that many unicode characters |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_Load(IMoniker* iface,IStream* pStm) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| |
| HRESULT res; |
| ULONG len; |
| ULONG got; |
| TRACE("(%p,%p)\n",This,pStm); |
| |
| if(!pStm) |
| return E_INVALIDARG; |
| |
| res = IStream_Read(pStm, &len, sizeof(ULONG), &got); |
| if(SUCCEEDED(res)) { |
| if(got == sizeof(ULONG)) { |
| HeapFree(GetProcessHeap(), 0, This->URLName); |
| This->URLName=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(len+1)); |
| if(!This->URLName) |
| res = E_OUTOFMEMORY; |
| else { |
| res = IStream_Read(pStm, This->URLName, len, NULL); |
| This->URLName[len] = 0; |
| } |
| } |
| else |
| res = E_FAIL; |
| } |
| return res; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_Save |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_Save(IMoniker* iface, |
| IStream* pStm,/* pointer to the stream where the object is to be saved */ |
| BOOL fClearDirty)/* Specifies whether to clear the dirty flag */ |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| |
| HRESULT res; |
| ULONG len; |
| TRACE("(%p,%p,%d)\n",This,pStm,fClearDirty); |
| |
| if(!pStm) |
| return E_INVALIDARG; |
| |
| len = strlenW(This->URLName); |
| res=IStream_Write(pStm,&len,sizeof(ULONG),NULL); |
| if(SUCCEEDED(res)) |
| res=IStream_Write(pStm,&This->URLName,len*sizeof(WCHAR),NULL); |
| return res; |
| |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_GetSizeMax |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_GetSizeMax(IMoniker* iface, |
| ULARGE_INTEGER* pcbSize)/* Pointer to size of stream needed to save object */ |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| |
| TRACE("(%p,%p)\n",This,pcbSize); |
| |
| if(!pcbSize) |
| return E_INVALIDARG; |
| |
| pcbSize->u.LowPart = sizeof(ULONG) + (strlenW(This->URLName) * sizeof(WCHAR)); |
| pcbSize->u.HighPart = 0; |
| return S_OK; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_BindToObject |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_BindToObject(IMoniker* iface, |
| IBindCtx* pbc, |
| IMoniker* pmkToLeft, |
| REFIID riid, |
| VOID** ppvResult) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| |
| *ppvResult=0; |
| |
| FIXME("(%p)->(%p,%p,%s,%p): stub\n",This,pbc,pmkToLeft,debugstr_guid(riid), |
| ppvResult); |
| |
| return E_NOTIMPL; |
| } |
| |
| typedef struct { |
| enum {OnProgress, OnDataAvailable} callback; |
| } URLMON_CallbackData; |
| |
| |
| #if 0 |
| static LRESULT CALLBACK URLMON_WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) |
| { |
| return DefWindowProcA(hwnd, msg, wparam, lparam); |
| } |
| |
| static void PostOnProgress(URLMonikerImpl *This, UINT progress, UINT maxprogress, DWORD status, LPCWSTR *str) |
| { |
| } |
| |
| static void CALLBACK URLMON_InternetCallback(HINTERNET hinet, /*DWORD_PTR*/ DWORD context, DWORD status, |
| void *status_info, DWORD status_info_len) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)context; |
| TRACE("handle %p this %p status %08lx\n", hinet, This, status); |
| |
| if(This->filesize == -1) { |
| switch(status) { |
| case INTERNET_STATUS_RESOLVING_NAME: |
| PostOnProgess(This, 0, 0, BINDSTATUS_FINDINGRESOURCE, status_info); |
| break; |
| case INTERNET_STATUS_CONNECTING_TO_SERVER: |
| PostOnProgress(This, 0, 0, BINDSTATUS_CONNECTING, NULL); |
| break; |
| case INTERNET_STATUS_SENDING_REQUEST: |
| PostOnProgress(This, 0, 0, BINDSTATUS_SENDINGREQUEST, NULL); |
| break; |
| case INTERNET_REQUEST_COMPLETE: |
| { |
| DWORD len, lensz = sizeof(len); |
| |
| HttpQueryInfoW(hrequest, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, &len, &lensz, NULL); |
| TRACE("res = %ld gle = %08lx url len = %ld\n", hres, GetLastError(), len); |
| This->filesize = len; |
| break; |
| } |
| } |
| } |
| |
| return; |
| } |
| #endif |
| |
| |
| /****************************************************************************** |
| * URLMoniker_BindToStorage |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_BindToStorage(IMoniker* iface, |
| IBindCtx* pbc, |
| IMoniker* pmkToLeft, |
| REFIID riid, |
| VOID** ppvObject) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| HRESULT hres; |
| BINDINFO bi; |
| DWORD bindf; |
| WCHAR szFileName[MAX_PATH + 1]; |
| Binding *bind; |
| int len; |
| |
| if(pmkToLeft) { |
| FIXME("pmkToLeft != NULL\n"); |
| return E_NOTIMPL; |
| } |
| if(!IsEqualIID(&IID_IStream, riid)) { |
| FIXME("unsupported iid\n"); |
| return E_NOTIMPL; |
| } |
| |
| bind = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(Binding)); |
| bind->lpVtbl = &BindingVtbl; |
| bind->ref = 1; |
| URLMON_LockModule(); |
| |
| len = lstrlenW(This->URLName)+1; |
| bind->URLName = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR)); |
| memcpy(bind->URLName, This->URLName, len*sizeof(WCHAR)); |
| |
| hres = UMCreateStreamOnCacheFile(bind->URLName, 0, szFileName, &bind->hCacheFile, &bind->pstrCache); |
| |
| if(SUCCEEDED(hres)) { |
| TRACE("Created stream...\n"); |
| |
| *ppvObject = (void *) bind->pstrCache; |
| IStream_AddRef((IStream *) bind->pstrCache); |
| |
| hres = IBindCtx_GetObjectParam(pbc, (LPOLESTR)BSCBHolder, (IUnknown**)&bind->pbscb); |
| if(SUCCEEDED(hres)) { |
| TRACE("Got IBindStatusCallback...\n"); |
| |
| memset(&bi, 0, sizeof(bi)); |
| bi.cbSize = sizeof(bi); |
| bindf = 0; |
| hres = IBindStatusCallback_GetBindInfo(bind->pbscb, &bindf, &bi); |
| if(SUCCEEDED(hres)) { |
| WCHAR *urlcopy, *tmpwc; |
| URL_COMPONENTSW url; |
| WCHAR *host, *path, *user, *pass; |
| DWORD lensz = sizeof(bind->expected_size); |
| DWORD dwService = 0; |
| BOOL bSuccess; |
| |
| TRACE("got bindinfo. bindf = %08lx extrainfo = %s bindinfof = %08lx bindverb = %08lx iid %s\n", |
| bindf, debugstr_w(bi.szExtraInfo), bi.grfBindInfoF, bi.dwBindVerb, debugstr_guid(&bi.iid)); |
| hres = IBindStatusCallback_OnStartBinding(bind->pbscb, 0, (IBinding*)bind); |
| TRACE("OnStartBinding rets %08lx\n", hres); |
| |
| /* This class will accept URLs with the backslash in them. But InternetCrackURL will not - it |
| * requires forward slashes (this is the behaviour of Microsoft's INETAPI). So we need to make |
| * a copy of the URL here and change the backslash to a forward slash everywhere it appears - |
| * but only before any '#' or '?', after which backslash should be left alone. |
| */ |
| urlcopy = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * (lstrlenW(bind->URLName) + 1)); |
| lstrcpyW(urlcopy, bind->URLName); |
| for (tmpwc = urlcopy; *tmpwc && *tmpwc != '#' && *tmpwc != '?'; ++tmpwc) |
| if (*tmpwc == '\\') |
| *tmpwc = '/'; |
| |
| #if 0 |
| if(!registered_wndclass) { |
| WNDCLASSA urlmon_wndclass = {0, URLMON_WndProc,0, 0, URLMON_hInstance, 0, 0, 0, NULL, "URLMON_Callback_Window_Class"}; |
| RegisterClassA(&urlmon_wndclass); |
| registered_wndclass = TRUE; |
| } |
| |
| This->hwndCallback = CreateWindowA("URLMON_Callback_Window_Class", NULL, 0, 0, 0, 0, 0, 0, 0, |
| URLMON_hInstance, NULL); |
| |
| #endif |
| bind->expected_size = 0; |
| bind->total_read = 0; |
| |
| memset(&url, 0, sizeof(url)); |
| url.dwStructSize = sizeof(url); |
| url.dwSchemeLength = url.dwHostNameLength = url.dwUrlPathLength = url.dwUserNameLength = url.dwPasswordLength = 1; |
| InternetCrackUrlW(urlcopy, 0, 0, &url); |
| host = HeapAlloc(GetProcessHeap(), 0, (url.dwHostNameLength + 1) * sizeof(WCHAR)); |
| memcpy(host, url.lpszHostName, url.dwHostNameLength * sizeof(WCHAR)); |
| host[url.dwHostNameLength] = '\0'; |
| path = HeapAlloc(GetProcessHeap(), 0, (url.dwUrlPathLength + 1) * sizeof(WCHAR)); |
| memcpy(path, url.lpszUrlPath, url.dwUrlPathLength * sizeof(WCHAR)); |
| path[url.dwUrlPathLength] = '\0'; |
| if (url.dwUserNameLength) |
| { |
| user = HeapAlloc(GetProcessHeap(), 0, ((url.dwUserNameLength + 1) * sizeof(WCHAR))); |
| memcpy(user, url.lpszUserName, url.dwUserNameLength * sizeof(WCHAR)); |
| user[url.dwUserNameLength] = 0; |
| } |
| else |
| { |
| user = 0; |
| } |
| if (url.dwPasswordLength) |
| { |
| pass = HeapAlloc(GetProcessHeap(), 0, ((url.dwPasswordLength + 1) * sizeof(WCHAR))); |
| memcpy(pass, url.lpszPassword, url.dwPasswordLength * sizeof(WCHAR)); |
| pass[url.dwPasswordLength] = 0; |
| } |
| else |
| { |
| pass = 0; |
| } |
| |
| switch ((DWORD) url.nScheme) |
| { |
| case INTERNET_SCHEME_FTP: |
| case INTERNET_SCHEME_GOPHER: |
| case INTERNET_SCHEME_HTTP: |
| case INTERNET_SCHEME_HTTPS: |
| |
| bind->hinternet = InternetOpenA("User Agent", 0, NULL, NULL, 0 /*INTERNET_FLAG_ASYNC*/); |
| /* InternetSetStatusCallback(bind->hinternet, URLMON_InternetCallback);*/ |
| if (!bind->hinternet) |
| { |
| hres = HRESULT_FROM_WIN32(GetLastError()); |
| break; |
| } |
| |
| switch ((DWORD) url.nScheme) |
| { |
| case INTERNET_SCHEME_FTP: |
| if (!url.nPort) |
| url.nPort = INTERNET_DEFAULT_FTP_PORT; |
| dwService = INTERNET_SERVICE_FTP; |
| break; |
| |
| case INTERNET_SCHEME_GOPHER: |
| if (!url.nPort) |
| url.nPort = INTERNET_DEFAULT_GOPHER_PORT; |
| dwService = INTERNET_SERVICE_GOPHER; |
| break; |
| |
| case INTERNET_SCHEME_HTTP: |
| if (!url.nPort) |
| url.nPort = INTERNET_DEFAULT_HTTP_PORT; |
| dwService = INTERNET_SERVICE_HTTP; |
| break; |
| |
| case INTERNET_SCHEME_HTTPS: |
| if (!url.nPort) |
| url.nPort = INTERNET_DEFAULT_HTTPS_PORT; |
| dwService = INTERNET_SERVICE_HTTP; |
| break; |
| } |
| |
| bind->hconnect = InternetConnectW(bind->hinternet, host, url.nPort, user, pass, |
| dwService, 0, (DWORD)bind); |
| if (!bind->hconnect) |
| { |
| hres = HRESULT_FROM_WIN32(GetLastError()); |
| CloseHandle(bind->hinternet); |
| break; |
| } |
| |
| hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, 0x22, NULL); |
| hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_FINDINGRESOURCE, NULL); |
| hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_CONNECTING, NULL); |
| hres = IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_SENDINGREQUEST, NULL); |
| |
| bSuccess = FALSE; |
| |
| switch (dwService) |
| { |
| case INTERNET_SERVICE_GOPHER: |
| bind->hrequest = GopherOpenFileW(bind->hconnect, |
| path, |
| 0, |
| INTERNET_FLAG_RELOAD, |
| 0); |
| if (bind->hrequest) |
| bSuccess = TRUE; |
| else |
| hres = HRESULT_FROM_WIN32(GetLastError()); |
| break; |
| |
| case INTERNET_SERVICE_FTP: |
| bind->hrequest = FtpOpenFileW(bind->hconnect, |
| path, |
| GENERIC_READ, |
| FTP_TRANSFER_TYPE_BINARY | |
| INTERNET_FLAG_TRANSFER_BINARY | |
| INTERNET_FLAG_RELOAD, |
| 0); |
| if (bind->hrequest) |
| bSuccess = TRUE; |
| else |
| hres = HRESULT_FROM_WIN32(GetLastError()); |
| break; |
| |
| case INTERNET_SERVICE_HTTP: |
| bind->hrequest = HttpOpenRequestW(bind->hconnect, NULL, path, NULL, NULL, NULL, 0, (DWORD)bind); |
| if (!bind->hrequest) |
| { |
| hres = HRESULT_FROM_WIN32(GetLastError()); |
| } |
| else if (!HttpSendRequestW(bind->hrequest, NULL, 0, NULL, 0)) |
| { |
| hres = HRESULT_FROM_WIN32(GetLastError()); |
| InternetCloseHandle(bind->hrequest); |
| } |
| else |
| { |
| HttpQueryInfoW(bind->hrequest, |
| HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, |
| &bind->expected_size, |
| &lensz, |
| NULL); |
| bSuccess = TRUE; |
| } |
| break; |
| } |
| if(bSuccess) |
| { |
| TRACE("res = %ld gle = %08lx url len = %ld\n", hres, GetLastError(), bind->expected_size); |
| |
| IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_CACHEFILENAMEAVAILABLE, szFileName); |
| |
| while(1) { |
| char buf[4096]; |
| DWORD bufread; |
| if(InternetReadFile(bind->hrequest, buf, sizeof(buf), &bufread)) { |
| TRACE("read %ld bytes %s...\n", bufread, debugstr_an(buf, 10)); |
| if(bufread == 0) break; |
| hres = Binding_MoreCacheData(bind, buf, bufread); |
| } else |
| break; |
| } |
| InternetCloseHandle(bind->hrequest); |
| hres = S_OK; |
| } |
| |
| InternetCloseHandle(bind->hconnect); |
| InternetCloseHandle(bind->hinternet); |
| break; |
| |
| case INTERNET_SCHEME_FILE: |
| path = bind->URLName + 5; /* Skip the "file:" part */ |
| if ((path[0] != '/' && path[0] != '\\') || |
| (path[1] != '/' && path[1] != '\\')) |
| { |
| hres = E_FAIL; |
| } |
| else |
| { |
| HANDLE h; |
| |
| path += 2; |
| if (path[0] == '/' || path[0] == '\\') |
| ++path; |
| h = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 ); |
| if (h == (HANDLE) HFILE_ERROR) |
| { |
| hres = HRESULT_FROM_WIN32(GetLastError()); |
| } |
| else |
| { |
| char buf[4096]; |
| DWORD bufread; |
| |
| IBindStatusCallback_OnProgress(bind->pbscb, 0, 0, BINDSTATUS_CACHEFILENAMEAVAILABLE, szFileName); |
| |
| while (ReadFile(h, buf, sizeof(buf), &bufread, NULL) && bufread > 0) |
| hres = Binding_MoreCacheData(bind, buf, bufread); |
| |
| CloseHandle(h); |
| hres = S_OK; |
| } |
| } |
| |
| break; |
| |
| default: |
| FIXME("Unsupported URI scheme"); |
| break; |
| } |
| Binding_CloseCacheDownload(bind); |
| Binding_FinishedDownload(bind, hres); |
| |
| if (user) |
| HeapFree(GetProcessHeap(), 0, user); |
| if (pass) |
| HeapFree(GetProcessHeap(), 0, pass); |
| HeapFree(GetProcessHeap(), 0, path); |
| HeapFree(GetProcessHeap(), 0, host); |
| HeapFree(GetProcessHeap(), 0, urlcopy); |
| } |
| } |
| } |
| |
| IBinding_Release((IBinding*)bind); |
| |
| return hres; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_Reduce |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_Reduce(IMoniker* iface, |
| IBindCtx* pbc, |
| DWORD dwReduceHowFar, |
| IMoniker** ppmkToLeft, |
| IMoniker** ppmkReduced) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| |
| TRACE("(%p,%p,%ld,%p,%p)\n",This,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced); |
| |
| if(!ppmkReduced) |
| return E_INVALIDARG; |
| |
| URLMonikerImpl_AddRef(iface); |
| *ppmkReduced = iface; |
| return MK_S_REDUCED_TO_SELF; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_ComposeWith |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_ComposeWith(IMoniker* iface, |
| IMoniker* pmkRight, |
| BOOL fOnlyIfNotGeneric, |
| IMoniker** ppmkComposite) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| FIXME("(%p)->(%p,%d,%p): stub\n",This,pmkRight,fOnlyIfNotGeneric,ppmkComposite); |
| |
| return E_NOTIMPL; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_Enum |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| TRACE("(%p,%d,%p)\n",This,fForward,ppenumMoniker); |
| |
| if(!ppenumMoniker) |
| return E_INVALIDARG; |
| |
| /* Does not support sub-monikers */ |
| *ppenumMoniker = NULL; |
| return S_OK; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_IsEqual |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| CLSID clsid; |
| LPOLESTR urlPath; |
| IBindCtx* bind; |
| HRESULT res; |
| |
| TRACE("(%p,%p)\n",This,pmkOtherMoniker); |
| |
| if(pmkOtherMoniker==NULL) |
| return E_INVALIDARG; |
| |
| IMoniker_GetClassID(pmkOtherMoniker,&clsid); |
| |
| if(!IsEqualCLSID(&clsid,&CLSID_StdURLMoniker)) |
| return S_FALSE; |
| |
| res = CreateBindCtx(0,&bind); |
| if(FAILED(res)) |
| return res; |
| |
| res = S_FALSE; |
| if(SUCCEEDED(IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&urlPath))) { |
| int result = lstrcmpiW(urlPath, This->URLName); |
| CoTaskMemFree(urlPath); |
| if(result == 0) |
| res = S_OK; |
| } |
| IUnknown_Release(bind); |
| return res; |
| } |
| |
| |
| /****************************************************************************** |
| * URLMoniker_Hash |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| |
| int h = 0,i,skip,len; |
| int off = 0; |
| LPOLESTR val; |
| |
| TRACE("(%p,%p)\n",This,pdwHash); |
| |
| if(!pdwHash) |
| return E_INVALIDARG; |
| |
| val = This->URLName; |
| len = lstrlenW(val); |
| |
| if(len < 16) { |
| for(i = len ; i > 0; i--) { |
| h = (h * 37) + val[off++]; |
| } |
| } |
| else { |
| /* only sample some characters */ |
| skip = len / 8; |
| for(i = len; i > 0; i -= skip, off += skip) { |
| h = (h * 39) + val[off]; |
| } |
| } |
| *pdwHash = h; |
| return S_OK; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_IsRunning |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_IsRunning(IMoniker* iface, |
| IBindCtx* pbc, |
| IMoniker* pmkToLeft, |
| IMoniker* pmkNewlyRunning) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| FIXME("(%p)->(%p,%p,%p): stub\n",This,pbc,pmkToLeft,pmkNewlyRunning); |
| |
| return E_NOTIMPL; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_GetTimeOfLastChange |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_GetTimeOfLastChange(IMoniker* iface, |
| IBindCtx* pbc, |
| IMoniker* pmkToLeft, |
| FILETIME* pFileTime) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| FIXME("(%p)->(%p,%p,%p): stub\n",This,pbc,pmkToLeft,pFileTime); |
| |
| return E_NOTIMPL; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_Inverse |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| TRACE("(%p,%p)\n",This,ppmk); |
| |
| return MK_E_NOINVERSE; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_CommonPrefixWith |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| FIXME("(%p)->(%p,%p): stub\n",This,pmkOther,ppmkPrefix); |
| |
| return E_NOTIMPL; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_RelativePathTo |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| FIXME("(%p)->(%p,%p): stub\n",This,pmOther,ppmkRelPath); |
| |
| return E_NOTIMPL; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_GetDisplayName |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_GetDisplayName(IMoniker* iface, |
| IBindCtx* pbc, |
| IMoniker* pmkToLeft, |
| LPOLESTR *ppszDisplayName) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| |
| int len; |
| |
| TRACE("(%p,%p,%p,%p)\n",This,pbc,pmkToLeft,ppszDisplayName); |
| |
| if(!ppszDisplayName) |
| return E_INVALIDARG; |
| |
| /* FIXME: If this is a partial URL, try and get a URL moniker from SZ_URLCONTEXT in the bind context, |
| then look at pmkToLeft to try and complete the URL |
| */ |
| len = lstrlenW(This->URLName)+1; |
| *ppszDisplayName = CoTaskMemAlloc(len*sizeof(WCHAR)); |
| if(!*ppszDisplayName) |
| return E_OUTOFMEMORY; |
| lstrcpyW(*ppszDisplayName, This->URLName); |
| return S_OK; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_ParseDisplayName |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_ParseDisplayName(IMoniker* iface, |
| IBindCtx* pbc, |
| IMoniker* pmkToLeft, |
| LPOLESTR pszDisplayName, |
| ULONG* pchEaten, |
| IMoniker** ppmkOut) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| FIXME("(%p)->(%p,%p,%p,%p,%p): stub\n",This,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut); |
| |
| return E_NOTIMPL; |
| } |
| |
| /****************************************************************************** |
| * URLMoniker_IsSystemMoniker |
| ******************************************************************************/ |
| static HRESULT WINAPI URLMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys) |
| { |
| URLMonikerImpl *This = (URLMonikerImpl *)iface; |
| TRACE("(%p,%p)\n",This,pwdMksys); |
| |
| if(!pwdMksys) |
| return E_INVALIDARG; |
| |
| *pwdMksys = MKSYS_URLMONIKER; |
| return S_OK; |
| } |
| |
| /********************************************************************************/ |
| /* Virtual function table for the URLMonikerImpl class which include IPersist,*/ |
| /* IPersistStream and IMoniker functions. */ |
| static const IMonikerVtbl VT_URLMonikerImpl = |
| { |
| URLMonikerImpl_QueryInterface, |
| URLMonikerImpl_AddRef, |
| URLMonikerImpl_Release, |
| URLMonikerImpl_GetClassID, |
| URLMonikerImpl_IsDirty, |
| URLMonikerImpl_Load, |
| URLMonikerImpl_Save, |
| URLMonikerImpl_GetSizeMax, |
| URLMonikerImpl_BindToObject, |
| URLMonikerImpl_BindToStorage, |
| URLMonikerImpl_Reduce, |
| URLMonikerImpl_ComposeWith, |
| URLMonikerImpl_Enum, |
| URLMonikerImpl_IsEqual, |
| URLMonikerImpl_Hash, |
| URLMonikerImpl_IsRunning, |
| URLMonikerImpl_GetTimeOfLastChange, |
| URLMonikerImpl_Inverse, |
| URLMonikerImpl_CommonPrefixWith, |
| URLMonikerImpl_RelativePathTo, |
| URLMonikerImpl_GetDisplayName, |
| URLMonikerImpl_ParseDisplayName, |
| URLMonikerImpl_IsSystemMoniker |
| }; |
| |
| /****************************************************************************** |
| * URLMoniker_Construct (local function) |
| *******************************************************************************/ |
| static HRESULT URLMonikerImpl_Construct(URLMonikerImpl* This, LPCOLESTR lpszLeftURLName, LPCOLESTR lpszURLName) |
| { |
| HRESULT hres; |
| DWORD sizeStr; |
| |
| TRACE("(%p,%s,%s)\n",This,debugstr_w(lpszLeftURLName),debugstr_w(lpszURLName)); |
| memset(This, 0, sizeof(*This)); |
| |
| /* Initialize the virtual function table. */ |
| This->lpvtbl = &VT_URLMonikerImpl; |
| This->ref = 0; |
| |
| if(lpszLeftURLName) { |
| hres = UrlCombineW(lpszLeftURLName, lpszURLName, NULL, &sizeStr, 0); |
| if(FAILED(hres)) { |
| return hres; |
| } |
| sizeStr++; |
| } |
| else |
| sizeStr = lstrlenW(lpszURLName)+1; |
| |
| This->URLName=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(sizeStr)); |
| |
| if (This->URLName==NULL) |
| return E_OUTOFMEMORY; |
| |
| if(lpszLeftURLName) { |
| hres = UrlCombineW(lpszLeftURLName, lpszURLName, This->URLName, &sizeStr, 0); |
| if(FAILED(hres)) { |
| HeapFree(GetProcessHeap(), 0, This->URLName); |
| return hres; |
| } |
| } |
| else |
| strcpyW(This->URLName,lpszURLName); |
| |
| return S_OK; |
| } |
| |
| /*********************************************************************** |
| * CreateAsyncBindCtx (URLMON.@) |
| */ |
| HRESULT WINAPI CreateAsyncBindCtx(DWORD reserved, IBindStatusCallback *callback, |
| IEnumFORMATETC *format, IBindCtx **pbind) |
| { |
| HRESULT hres; |
| BIND_OPTS bindopts; |
| IBindCtx *bctx; |
| |
| TRACE("(%08lx %p %p %p)\n", reserved, callback, format, pbind); |
| |
| if(!callback) |
| return E_INVALIDARG; |
| if(format) |
| FIXME("format is not supported yet\n"); |
| |
| hres = CreateBindCtx(0, &bctx); |
| if(FAILED(hres)) |
| return hres; |
| |
| bindopts.cbStruct = sizeof(BIND_OPTS); |
| bindopts.grfFlags = BIND_MAYBOTHERUSER; |
| bindopts.grfMode = STGM_READWRITE | STGM_SHARE_EXCLUSIVE; |
| bindopts.dwTickCountDeadline = 0; |
| IBindCtx_SetBindOptions(bctx, &bindopts); |
| |
| hres = IBindCtx_RegisterObjectParam(bctx, (LPOLESTR)BSCBHolder, (IUnknown*)callback); |
| if(FAILED(hres)) { |
| IBindCtx_Release(bctx); |
| return hres; |
| } |
| |
| *pbind = bctx; |
| |
| return S_OK; |
| } |
| /*********************************************************************** |
| * CreateAsyncBindCtxEx (URLMON.@) |
| * |
| * Create an asynchronous bind context. |
| * |
| * FIXME |
| * Not implemented. |
| */ |
| HRESULT WINAPI CreateAsyncBindCtxEx(IBindCtx *ibind, DWORD options, |
| IBindStatusCallback *callback, IEnumFORMATETC *format, IBindCtx** pbind, |
| DWORD reserved) |
| { |
| FIXME("stub, returns failure\n"); |
| return E_INVALIDARG; |
| } |
| |
| |
| /*********************************************************************** |
| * CreateURLMoniker (URLMON.@) |
| * |
| * Create a url moniker. |
| * |
| * PARAMS |
| * pmkContext [I] Context |
| * szURL [I] Url to create the moniker for |
| * ppmk [O] Destination for created moniker. |
| * |
| * RETURNS |
| * Success: S_OK. ppmk contains the created IMoniker object. |
| * Failure: MK_E_SYNTAX if szURL is not a valid url, or |
| * E_OUTOFMEMORY if memory allocation fails. |
| */ |
| HRESULT WINAPI CreateURLMoniker(IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk) |
| { |
| URLMonikerImpl *obj; |
| HRESULT hres; |
| IID iid = IID_IMoniker; |
| LPOLESTR lefturl = NULL; |
| |
| TRACE("(%p, %s, %p)\n", pmkContext, debugstr_w(szURL), ppmk); |
| |
| if(!(obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*obj)))) |
| return E_OUTOFMEMORY; |
| |
| if(pmkContext) { |
| CLSID clsid; |
| IBindCtx* bind; |
| IMoniker_GetClassID(pmkContext, &clsid); |
| if(IsEqualCLSID(&clsid, &CLSID_StdURLMoniker) && SUCCEEDED(CreateBindCtx(0, &bind))) { |
| URLMonikerImpl_GetDisplayName(pmkContext, bind, NULL, &lefturl); |
| IBindCtx_Release(bind); |
| } |
| } |
| |
| hres = URLMonikerImpl_Construct(obj, lefturl, szURL); |
| CoTaskMemFree(lefturl); |
| if(SUCCEEDED(hres)) |
| hres = URLMonikerImpl_QueryInterface((IMoniker*)obj, &iid, (void**)ppmk); |
| else |
| HeapFree(GetProcessHeap(), 0, obj); |
| return hres; |
| } |
| |
| |
| /*********************************************************************** |
| * CoInternetGetSession (URLMON.@) |
| * |
| * Create a new internet session and return an IInternetSession interface |
| * representing it. |
| * |
| * PARAMS |
| * dwSessionMode [I] Mode for the internet session |
| * ppIInternetSession [O] Destination for creates IInternetSession object |
| * dwReserved [I] Reserved, must be 0. |
| * |
| * RETURNS |
| * Success: S_OK. ppIInternetSession contains the IInternetSession interface. |
| * Failure: E_INVALIDARG, if any argument is invalid, or |
| * E_OUTOFMEMORY if memory allocation fails. |
| */ |
| HRESULT WINAPI CoInternetGetSession(DWORD dwSessionMode, IInternetSession **ppIInternetSession, DWORD dwReserved) |
| { |
| FIXME("(%ld, %p, %ld): stub\n", dwSessionMode, ppIInternetSession, dwReserved); |
| |
| if(dwSessionMode) { |
| ERR("dwSessionMode: %ld, must be zero\n", dwSessionMode); |
| } |
| |
| if(dwReserved) { |
| ERR("dwReserved: %ld, must be zero\n", dwReserved); |
| } |
| |
| *ppIInternetSession=NULL; |
| return E_OUTOFMEMORY; |
| } |
| |
| /*********************************************************************** |
| * CoInternetQueryInfo (URLMON.@) |
| * |
| * Retrieves information relevant to a specified URL |
| * |
| * RETURNS |
| * S_OK success |
| * S_FALSE buffer too small |
| * INET_E_QUERYOPTIONUNKNOWN invalid option |
| * |
| */ |
| HRESULT WINAPI CoInternetQueryInfo(LPCWSTR pwzUrl, QUERYOPTION QueryOption, |
| DWORD dwQueryFlags, LPVOID pvBuffer, DWORD cbBuffer, DWORD * pcbBuffer, |
| DWORD dwReserved) |
| { |
| FIXME("(%s, %x, %lx, %p, %lx, %p, %lx): stub\n", debugstr_w(pwzUrl), |
| QueryOption, dwQueryFlags, pvBuffer, cbBuffer, pcbBuffer, dwReserved); |
| return S_OK; |
| } |
| |
| static BOOL URLMON_IsBinary(LPVOID pBuffer, DWORD cbSize) |
| { |
| unsigned int i, binarycount = 0; |
| unsigned char *buff = pBuffer; |
| for(i=0; i<cbSize; i++) { |
| if(buff[i] < 32) |
| binarycount++; |
| } |
| return binarycount > (cbSize-binarycount); |
| } |
| |
| /*********************************************************************** |
| * FindMimeFromData (URLMON.@) |
| * |
| * Determines the Multipurpose Internet Mail Extensions (MIME) type from the data provided. |
| * |
| * NOTE |
| * See http://msdn.microsoft.com/workshop/networking/moniker/overview/appendix_a.asp |
| */ |
| HRESULT WINAPI FindMimeFromData(LPBC pBC, LPCWSTR pwzUrl, LPVOID pBuffer, |
| DWORD cbSize, LPCWSTR pwzMimeProposed, DWORD dwMimeFlags, |
| LPWSTR* ppwzMimeOut, DWORD dwReserved) |
| { |
| static const WCHAR szBinaryMime[] = {'a','p','p','l','i','c','a','t','i','o','n','/','o','c','t','e','t','-','s','t','r','e','a','m','\0'}; |
| static const WCHAR szTextMime[] = {'t','e','x','t','/','p','l','a','i','n','\0'}; |
| static const WCHAR szContentType[] = {'C','o','n','t','e','n','t',' ','T','y','p','e','\0'}; |
| WCHAR szTmpMime[256]; |
| LPCWSTR mimeType = NULL; |
| HKEY hKey = NULL; |
| |
| TRACE("(%p,%s,%p,%ld,%s,0x%lx,%p,0x%lx)\n", pBC, debugstr_w(pwzUrl), pBuffer, cbSize, |
| debugstr_w(pwzMimeProposed), dwMimeFlags, ppwzMimeOut, dwReserved); |
| |
| if((!pwzUrl && (!pBuffer || cbSize <= 0)) || !ppwzMimeOut) |
| return E_INVALIDARG; |
| |
| if(pwzMimeProposed) |
| mimeType = pwzMimeProposed; |
| else { |
| /* Try and find the mime type in the registry */ |
| if(pwzUrl) { |
| LPWSTR ext = strrchrW(pwzUrl, '.'); |
| if(ext) { |
| DWORD dwSize; |
| if(!RegOpenKeyExW(HKEY_CLASSES_ROOT, ext, 0, 0, &hKey)) { |
| if(!RegQueryValueExW(hKey, szContentType, NULL, NULL, (LPBYTE)szTmpMime, &dwSize)) { |
| mimeType = szTmpMime; |
| } |
| RegCloseKey(hKey); |
| } |
| } |
| } |
| } |
| if(!mimeType && pBuffer && cbSize > 0) |
| mimeType = URLMON_IsBinary(pBuffer, cbSize)?szBinaryMime:szTextMime; |
| |
| TRACE("Using %s\n", debugstr_w(mimeType)); |
| *ppwzMimeOut = CoTaskMemAlloc((lstrlenW(mimeType)+1)*sizeof(WCHAR)); |
| if(!*ppwzMimeOut) return E_OUTOFMEMORY; |
| lstrcpyW(*ppwzMimeOut, mimeType); |
| return S_OK; |
| } |
| |
| /*********************************************************************** |
| * IsAsyncMoniker (URLMON.@) |
| */ |
| HRESULT WINAPI IsAsyncMoniker(IMoniker *pmk) |
| { |
| IUnknown *am; |
| |
| TRACE("(%p)\n", pmk); |
| if(!pmk) |
| return E_INVALIDARG; |
| if(SUCCEEDED(IMoniker_QueryInterface(pmk, &IID_IAsyncMoniker, (void**)&am))) { |
| IUnknown_Release(am); |
| return S_OK; |
| } |
| return S_FALSE; |
| } |
| |
| /*********************************************************************** |
| * RegisterBindStatusCallback (URLMON.@) |
| * |
| * Register a bind status callback. |
| * |
| * PARAMS |
| * pbc [I] Binding context |
| * pbsc [I] Callback to register |
| * ppbscPrevious [O] Destination for previous callback |
| * dwReserved [I] Reserved, must be 0. |
| * |
| * RETURNS |
| * Success: S_OK. |
| * Failure: E_INVALIDARG, if any argument is invalid, or |
| * E_OUTOFMEMORY if memory allocation fails. |
| */ |
| HRESULT WINAPI RegisterBindStatusCallback( |
| IBindCtx *pbc, |
| IBindStatusCallback *pbsc, |
| IBindStatusCallback **ppbscPrevious, |
| DWORD dwReserved) |
| { |
| IBindStatusCallback *prev; |
| |
| TRACE("(%p,%p,%p,%lu)\n", pbc, pbsc, ppbscPrevious, dwReserved); |
| |
| if (pbc == NULL || pbsc == NULL) |
| return E_INVALIDARG; |
| |
| if (SUCCEEDED(IBindCtx_GetObjectParam(pbc, (LPOLESTR)BSCBHolder, (IUnknown **)&prev))) |
| { |
| IBindCtx_RevokeObjectParam(pbc, (LPOLESTR)BSCBHolder); |
| if (ppbscPrevious) |
| *ppbscPrevious = prev; |
| else |
| IBindStatusCallback_Release(prev); |
| } |
| |
| return IBindCtx_RegisterObjectParam(pbc, (LPOLESTR)BSCBHolder, (IUnknown *)pbsc); |
| } |
| |
| /*********************************************************************** |
| * RevokeBindStatusCallback (URLMON.@) |
| * |
| * Unregister a bind status callback. |
| * |
| * pbc [I] Binding context |
| * pbsc [I] Callback to unregister |
| * |
| * RETURNS |
| * Success: S_OK. |
| * Failure: E_INVALIDARG, if any argument is invalid, or |
| * E_FAIL if pbsc wasn't registered with pbc. |
| */ |
| HRESULT WINAPI RevokeBindStatusCallback( |
| IBindCtx *pbc, |
| IBindStatusCallback *pbsc) |
| { |
| IBindStatusCallback *callback; |
| HRESULT hr = E_FAIL; |
| |
| TRACE("(%p,%p)\n", pbc, pbsc); |
| |
| if (pbc == NULL || pbsc == NULL) |
| return E_INVALIDARG; |
| |
| if (SUCCEEDED(IBindCtx_GetObjectParam(pbc, (LPOLESTR)BSCBHolder, (IUnknown **)&callback))) |
| { |
| if (callback == pbsc) |
| { |
| IBindCtx_RevokeObjectParam(pbc, (LPOLESTR)BSCBHolder); |
| hr = S_OK; |
| } |
| IBindStatusCallback_Release(pbsc); |
| } |
| |
| return hr; |
| } |
| |
| /*********************************************************************** |
| * ReleaseBindInfo (URLMON.@) |
| * |
| * Release the resources used by the specified BINDINFO structure. |
| * |
| * PARAMS |
| * pbindinfo [I] BINDINFO to release. |
| * |
| * RETURNS |
| * Nothing. |
| */ |
| void WINAPI ReleaseBindInfo(BINDINFO* pbindinfo) |
| { |
| FIXME("(%p)stub!\n", pbindinfo); |
| } |
| |
| /*********************************************************************** |
| * URLDownloadToFileA (URLMON.@) |
| * |
| * Downloads URL szURL to rile szFileName and call lpfnCB callback to |
| * report progress. |
| * |
| * PARAMS |
| * pCaller [I] controlling IUnknown interface. |
| * szURL [I] URL of the file to download |
| * szFileName [I] file name to store the content of the URL |
| * dwReserved [I] reserved - set to 0 |
| * lpfnCB [I] callback for progress report |
| * |
| * RETURNS |
| * S_OK on success |
| * E_OUTOFMEMORY when going out of memory |
| */ |
| HRESULT WINAPI URLDownloadToFileA(LPUNKNOWN pCaller, |
| LPCSTR szURL, |
| LPCSTR szFileName, |
| DWORD dwReserved, |
| LPBINDSTATUSCALLBACK lpfnCB) |
| { |
| UNICODE_STRING szURL_w, szFileName_w; |
| |
| if ((szURL == NULL) || (szFileName == NULL)) { |
| FIXME("(%p,%s,%s,%08lx,%p) cannot accept NULL strings !\n", pCaller, debugstr_a(szURL), debugstr_a(szFileName), dwReserved, lpfnCB); |
| return E_INVALIDARG; /* The error code is not specified in this case... */ |
| } |
| |
| if (RtlCreateUnicodeStringFromAsciiz(&szURL_w, szURL)) { |
| if (RtlCreateUnicodeStringFromAsciiz(&szFileName_w, szFileName)) { |
| HRESULT ret = URLDownloadToFileW(pCaller, szURL_w.Buffer, szFileName_w.Buffer, dwReserved, lpfnCB); |
| |
| RtlFreeUnicodeString(&szURL_w); |
| RtlFreeUnicodeString(&szFileName_w); |
| |
| return ret; |
| } else { |
| RtlFreeUnicodeString(&szURL_w); |
| } |
| } |
| |
| FIXME("(%p,%s,%s,%08lx,%p) could not allocate W strings !\n", pCaller, szURL, szFileName, dwReserved, lpfnCB); |
| return E_OUTOFMEMORY; |
| } |
| |
| /*********************************************************************** |
| * URLDownloadToFileW (URLMON.@) |
| * |
| * Downloads URL szURL to rile szFileName and call lpfnCB callback to |
| * report progress. |
| * |
| * PARAMS |
| * pCaller [I] controlling IUnknown interface. |
| * szURL [I] URL of the file to download |
| * szFileName [I] file name to store the content of the URL |
| * dwReserved [I] reserved - set to 0 |
| * lpfnCB [I] callback for progress report |
| * |
| * RETURNS |
| * S_OK on success |
| * E_OUTOFMEMORY when going out of memory |
| */ |
| HRESULT WINAPI URLDownloadToFileW(LPUNKNOWN pCaller, |
| LPCWSTR szURL, |
| LPCWSTR szFileName, |
| DWORD dwReserved, |
| LPBINDSTATUSCALLBACK lpfnCB) |
| { |
| HINTERNET hinternet, hcon, hreq; |
| BOOL r; |
| CHAR buffer[0x1000]; |
| DWORD sz, total, written; |
| DWORD total_size = 0xFFFFFFFF, arg_size = sizeof(total_size); |
| URL_COMPONENTSW url; |
| WCHAR host[0x80], path[0x100]; |
| HANDLE hfile; |
| static const WCHAR wszAppName[]={'u','r','l','m','o','n','.','d','l','l',0}; |
| |
| /* Note: all error codes would need to be checked agains real Windows behaviour... */ |
| TRACE("(%p,%s,%s,%08lx,%p) stub!\n", pCaller, debugstr_w(szURL), debugstr_w(szFileName), dwReserved, lpfnCB); |
| |
| if ((szURL == NULL) || (szFileName == NULL)) { |
| FIXME(" cannot accept NULL strings !\n"); |
| return E_INVALIDARG; |
| } |
| |
| /* Would be better to use the application name here rather than 'urlmon' :-/ */ |
| hinternet = InternetOpenW(wszAppName, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0); |
| if (hinternet == NULL) { |
| return E_OUTOFMEMORY; |
| } |
| |
| memset(&url, 0, sizeof(url)); |
| url.dwStructSize = sizeof(url); |
| url.lpszHostName = host; |
| url.dwHostNameLength = sizeof(host); |
| url.lpszUrlPath = path; |
| url.dwUrlPathLength = sizeof(path); |
| |
| if (!InternetCrackUrlW(szURL, 0, 0, &url)) { |
| InternetCloseHandle(hinternet); |
| return E_OUTOFMEMORY; |
| } |
| |
| if (lpfnCB) { |
| if (IBindStatusCallback_OnProgress(lpfnCB, 0, 0, BINDSTATUS_CONNECTING, url.lpszHostName) == E_ABORT) { |
| InternetCloseHandle(hinternet); |
| return S_OK; |
| } |
| } |
| |
| hcon = InternetConnectW(hinternet, url.lpszHostName, url.nPort, |
| url.lpszUserName, url.lpszPassword, |
| INTERNET_SERVICE_HTTP, 0, 0); |
| if (!hcon) { |
| InternetCloseHandle(hinternet); |
| return E_OUTOFMEMORY; |
| } |
| |
| hreq = HttpOpenRequestW(hcon, NULL, url.lpszUrlPath, NULL, NULL, NULL, 0, 0); |
| if (!hreq) { |
| InternetCloseHandle(hinternet); |
| InternetCloseHandle(hcon); |
| return E_OUTOFMEMORY; |
| } |
| |
| if (!HttpSendRequestW(hreq, NULL, 0, NULL, 0)) { |
| InternetCloseHandle(hinternet); |
| InternetCloseHandle(hcon); |
| InternetCloseHandle(hreq); |
| return E_OUTOFMEMORY; |
| } |
| |
| if (HttpQueryInfoW(hreq, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, |
| &total_size, &arg_size, NULL)) { |
| TRACE(" total size : %ld\n", total_size); |
| } |
| |
| hfile = CreateFileW(szFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, |
| FILE_ATTRIBUTE_NORMAL, NULL ); |
| if (hfile == INVALID_HANDLE_VALUE) { |
| return E_ACCESSDENIED; |
| } |
| |
| if (lpfnCB) { |
| if (IBindStatusCallback_OnProgress(lpfnCB, 0, total_size != 0xFFFFFFFF ? total_size : 0, |
| BINDSTATUS_BEGINDOWNLOADDATA, szURL) == E_ABORT) { |
| InternetCloseHandle(hreq); |
| InternetCloseHandle(hcon); |
| InternetCloseHandle(hinternet); |
| CloseHandle(hfile); |
| return S_OK; |
| } |
| } |
| |
| total = 0; |
| while (1) { |
| r = InternetReadFile(hreq, buffer, sizeof(buffer), &sz); |
| if (!r) { |
| InternetCloseHandle(hreq); |
| InternetCloseHandle(hcon); |
| InternetCloseHandle(hinternet); |
| |
| CloseHandle(hfile); |
| return E_OUTOFMEMORY; |
| } |
| if (!sz) |
| break; |
| |
| total += sz; |
| |
| if (lpfnCB) { |
| if (IBindStatusCallback_OnProgress(lpfnCB, total, total_size != 0xFFFFFFFF ? total_size : 0, |
| BINDSTATUS_DOWNLOADINGDATA, szURL) == E_ABORT) { |
| InternetCloseHandle(hreq); |
| InternetCloseHandle(hcon); |
| InternetCloseHandle(hinternet); |
| CloseHandle(hfile); |
| return S_OK; |
| } |
| } |
| |
| if (!WriteFile(hfile, buffer, sz, &written, NULL)) { |
| InternetCloseHandle(hreq); |
| InternetCloseHandle(hcon); |
| InternetCloseHandle(hinternet); |
| |
| CloseHandle(hfile); |
| return E_OUTOFMEMORY; |
| } |
| } |
| |
| if (lpfnCB) { |
| if (IBindStatusCallback_OnProgress(lpfnCB, total, total_size != 0xFFFFFFFF ? total_size : 0, |
| BINDSTATUS_ENDDOWNLOADDATA, szURL) == E_ABORT) { |
| InternetCloseHandle(hreq); |
| InternetCloseHandle(hcon); |
| InternetCloseHandle(hinternet); |
| CloseHandle(hfile); |
| return S_OK; |
| } |
| } |
| |
| InternetCloseHandle(hreq); |
| InternetCloseHandle(hcon); |
| InternetCloseHandle(hinternet); |
| |
| CloseHandle(hfile); |
| |
| return S_OK; |
| } |
| |
| /*********************************************************************** |
| * HlinkSimpleNavigateToString (URLMON.@) |
| */ |
| HRESULT WINAPI HlinkSimpleNavigateToString( LPCWSTR szTarget, |
| LPCWSTR szLocation, LPCWSTR szTargetFrameName, IUnknown *pUnk, |
| IBindCtx *pbc, IBindStatusCallback *pbsc, DWORD grfHLNF, DWORD dwReserved) |
| { |
| FIXME("%s\n", debugstr_w( szTarget ) ); |
| return E_NOTIMPL; |
| } |
| |
| /*********************************************************************** |
| * HlinkNavigateString (URLMON.@) |
| */ |
| HRESULT WINAPI HlinkNavigateString( IUnknown *pUnk, LPCWSTR szTarget ) |
| { |
| TRACE("%p %s\n", pUnk, debugstr_w( szTarget ) ); |
| return HlinkSimpleNavigateToString( |
| szTarget, NULL, NULL, pUnk, NULL, NULL, 0, 0 ); |
| } |
| |
| /*********************************************************************** |
| * GetSoftwareUpdateInfo (URLMON.@) |
| */ |
| HRESULT WINAPI GetSoftwareUpdateInfo( LPCWSTR szDistUnit, LPSOFTDISTINFO psdi ) |
| { |
| FIXME("%s %p\n", debugstr_w(szDistUnit), psdi ); |
| return E_FAIL; |
| } |
