From 411c11b801d181a12035ef195b7a2390547180bf Mon Sep 17 00:00:00 2001 From: Cameron Gutman Date: Sat, 9 Oct 2010 21:52:25 +0000 Subject: [PATCH] [URLMON] - Sync to WINE 1.3.4 [WININET] - Add a forgotten change to the diff [WINHTTP] - Sync to WINE 1.3.4 - Sync the inet_ntop.c change from wininet - Update the diff svn path=/trunk/; revision=49083 --- reactos/dll/win32/urlmon/binding.c | 7 +- reactos/dll/win32/urlmon/bindprot.c | 17 +- reactos/dll/win32/urlmon/download.c | 14 +- reactos/dll/win32/urlmon/file.c | 379 +- reactos/dll/win32/urlmon/ftp.c | 20 +- reactos/dll/win32/urlmon/gopher.c | 20 +- reactos/dll/win32/urlmon/http.c | 94 +- reactos/dll/win32/urlmon/protocol.c | 4 +- reactos/dll/win32/urlmon/uri.c | 3951 +++++++++++++++++-- reactos/dll/win32/urlmon/urlmon.spec | 1 + reactos/dll/win32/urlmon/urlmon_main.h | 6 +- reactos/dll/win32/winhttp/cookie.c | 13 +- reactos/dll/win32/winhttp/inet_ntop.c | 9 +- reactos/dll/win32/winhttp/main.c | 2 +- reactos/dll/win32/winhttp/net.c | 639 ++- reactos/dll/win32/winhttp/request.c | 833 ++-- reactos/dll/win32/winhttp/session.c | 786 +++- reactos/dll/win32/winhttp/url.c | 6 +- reactos/dll/win32/winhttp/winhttp.rbuild | 2 + reactos/dll/win32/winhttp/winhttp_private.h | 24 +- reactos/dll/win32/winhttp/winhttp_ros.diff | 149 +- reactos/dll/win32/wininet/wininet_ros.diff | 31 +- 22 files changed, 5992 insertions(+), 1015 deletions(-) diff --git a/reactos/dll/win32/urlmon/binding.c b/reactos/dll/win32/urlmon/binding.c index e0f3624ff6b..02053b0cf39 100644 --- a/reactos/dll/win32/urlmon/binding.c +++ b/reactos/dll/win32/urlmon/binding.c @@ -1077,8 +1077,11 @@ static void report_data(Binding *This, DWORD bscf, ULONG progress, ULONG progres } if(This->to_object) { - if(!(This->state & BINDING_OBJAVAIL)) + if(!(This->state & BINDING_OBJAVAIL)) { + IBinding_AddRef(BINDING(This)); create_object(This); + IBinding_Release(BINDING(This)); + } }else { STGMEDIUM stgmed; HRESULT hres; @@ -1519,7 +1522,7 @@ static HRESULT start_binding(IMoniker *mon, Binding *binding_ctx, LPCWSTR url, I } if(binding_ctx) { - set_binding_sink(binding->protocol, PROTSINK(binding)); + set_binding_sink(binding->protocol, PROTSINK(binding), BINDINF(binding)); if(binding_ctx->redirect_url) IBindStatusCallback_OnProgress(binding->callback, 0, 0, BINDSTATUS_REDIRECTING, binding_ctx->redirect_url); report_data(binding, 0, 0, 0); diff --git a/reactos/dll/win32/urlmon/bindprot.c b/reactos/dll/win32/urlmon/bindprot.c index 29b8532b13d..01443e37856 100644 --- a/reactos/dll/win32/urlmon/bindprot.c +++ b/reactos/dll/win32/urlmon/bindprot.c @@ -382,7 +382,7 @@ static ULONG WINAPI BindProtocol_Release(IInternetProtocol *iface) if(This->filter_proxy) IInternetProtocol_Release(PROTOCOL(This->filter_proxy)); - set_binding_sink(PROTOCOL(This), NULL); + set_binding_sink(PROTOCOL(This), NULL, NULL); if(This->notif_hwnd) release_notif_hwnd(This->notif_hwnd); @@ -488,7 +488,7 @@ static HRESULT WINAPI BindProtocol_UnlockRequest(IInternetProtocol *iface) return IInternetProtocol_UnlockRequest(This->protocol_handler); } -void set_binding_sink(IInternetProtocol *bind_protocol, IInternetProtocolSink *sink) +void set_binding_sink(IInternetProtocol *bind_protocol, IInternetProtocolSink *sink, IInternetBindInfo *bind_info) { BindProtocol *This = PROTOCOL_THIS(bind_protocol); IInternetProtocolSink *prev_sink; @@ -505,6 +505,12 @@ void set_binding_sink(IInternetProtocol *bind_protocol, IInternetProtocolSink *s service_provider = InterlockedExchangePointer((void**)&This->service_provider, service_provider); if(service_provider) IServiceProvider_Release(service_provider); + + if(bind_info) + IInternetBindInfo_AddRef(bind_info); + bind_info = InterlockedExchangePointer((void**)&This->bind_info, bind_info); + if(bind_info) + IInternetBindInfo_Release(bind_info); } IWinInetInfo *get_wininet_info(IInternetProtocol *bind_protocol) @@ -619,10 +625,7 @@ static HRESULT WINAPI ProtocolHandler_Start(IInternetProtocol *iface, LPCWSTR sz if(urlmon_protocol) IInternetProtocol_QueryInterface(protocol, &IID_IWinInetInfo, (void**)&This->wininet_info); - IInternetBindInfo_AddRef(pOIBindInfo); - This->bind_info = pOIBindInfo; - - set_binding_sink(PROTOCOL(This), pOIProtSink); + set_binding_sink(PROTOCOL(This), pOIProtSink, pOIBindInfo); hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetPriority, (void**)&priority); if(SUCCEEDED(hres)) { @@ -670,7 +673,7 @@ static HRESULT WINAPI ProtocolHandler_Terminate(IInternetProtocol *iface, DWORD This->filter_proxy = NULL; } - set_binding_sink(PROTOCOL(This), NULL); + set_binding_sink(PROTOCOL(This), NULL, NULL); if(This->bind_info) { IInternetBindInfo_Release(This->bind_info); diff --git a/reactos/dll/win32/urlmon/download.c b/reactos/dll/win32/urlmon/download.c index ebcb9c932c7..fee96062ad6 100644 --- a/reactos/dll/win32/urlmon/download.c +++ b/reactos/dll/win32/urlmon/download.c @@ -119,22 +119,22 @@ static HRESULT WINAPI DownloadBSC_OnLowResource(IBindStatusCallback *iface, DWOR return E_NOTIMPL; } -static void on_progress(DownloadBSC *This, ULONG progress, ULONG progress_max, ULONG status_code, LPCWSTR status_text) +static HRESULT on_progress(DownloadBSC *This, ULONG progress, ULONG progress_max, ULONG status_code, LPCWSTR status_text) { HRESULT hres; if(!This->callback) - return; + return S_OK; hres = IBindStatusCallback_OnProgress(This->callback, progress, progress_max, status_code, status_text); - if(FAILED(hres)) - FIXME("OnProgress failed: %08x\n", hres); + return hres; } static HRESULT WINAPI DownloadBSC_OnProgress(IBindStatusCallback *iface, ULONG ulProgress, ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText) { DownloadBSC *This = STATUSCLB_THIS(iface); + HRESULT hres = S_OK; TRACE("%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode, debugstr_w(szStatusText)); @@ -146,11 +146,11 @@ static HRESULT WINAPI DownloadBSC_OnProgress(IBindStatusCallback *iface, ULONG u case BINDSTATUS_ENDDOWNLOADDATA: case BINDSTATUS_SENDINGREQUEST: case BINDSTATUS_MIMETYPEAVAILABLE: - on_progress(This, ulProgress, ulProgressMax, ulStatusCode, szStatusText); + hres = on_progress(This, ulProgress, ulProgressMax, ulStatusCode, szStatusText); break; case BINDSTATUS_CACHEFILENAMEAVAILABLE: - on_progress(This, ulProgress, ulProgressMax, ulStatusCode, szStatusText); + hres = on_progress(This, ulProgress, ulProgressMax, ulStatusCode, szStatusText); This->cache_file = heap_strdupW(szStatusText); break; @@ -161,7 +161,7 @@ static HRESULT WINAPI DownloadBSC_OnProgress(IBindStatusCallback *iface, ULONG u FIXME("Unsupported status %u\n", ulStatusCode); } - return S_OK; + return hres; } static HRESULT WINAPI DownloadBSC_OnStopBinding(IBindStatusCallback *iface, diff --git a/reactos/dll/win32/urlmon/file.c b/reactos/dll/win32/urlmon/file.c index a517d949222..a1901565336 100644 --- a/reactos/dll/win32/urlmon/file.c +++ b/reactos/dll/win32/urlmon/file.c @@ -17,38 +17,46 @@ */ #include "urlmon_main.h" +#include "winreg.h" +#include "shlwapi.h" + #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(urlmon); typedef struct { - const IInternetProtocolVtbl *lpIInternetProtocolVtbl; - const IInternetPriorityVtbl *lpInternetPriorityVtbl; + const IInternetProtocolExVtbl *lpIInternetProtocolExVtbl; + const IInternetPriorityVtbl *lpInternetPriorityVtbl; HANDLE file; + ULONG size; LONG priority; LONG ref; } FileProtocol; -#define PRIORITY(x) ((IInternetPriority*) &(x)->lpInternetPriorityVtbl) +#define PRIORITY(x) ((IInternetPriority*) &(x)->lpInternetPriorityVtbl) +#define PROTOCOLEX(x) ((IInternetProtocolEx*) &(x)->lpIInternetProtocolExVtbl) -#define PROTOCOL_THIS(iface) DEFINE_THIS(FileProtocol, IInternetProtocol, iface) +#define PROTOCOL_THIS(iface) DEFINE_THIS(FileProtocol, IInternetProtocolEx, iface) -static HRESULT WINAPI FileProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv) +static HRESULT WINAPI FileProtocol_QueryInterface(IInternetProtocolEx *iface, REFIID riid, void **ppv) { FileProtocol *This = PROTOCOL_THIS(iface); *ppv = NULL; if(IsEqualGUID(&IID_IUnknown, riid)) { TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); - *ppv = PROTOCOL(This); + *ppv = PROTOCOLEX(This); }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) { TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv); - *ppv = PROTOCOL(This); + *ppv = PROTOCOLEX(This); }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) { TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv); - *ppv = PROTOCOL(This); + *ppv = PROTOCOLEX(This); + }else if(IsEqualGUID(&IID_IInternetProtocolEx, riid)) { + TRACE("(%p)->(IID_IInternetProtocolEx %p)\n", This, ppv); + *ppv = PROTOCOLEX(This); }else if(IsEqualGUID(&IID_IInternetPriority, riid)) { TRACE("(%p)->(IID_IInternetPriority %p)\n", This, ppv); *ppv = PRIORITY(This); @@ -63,7 +71,7 @@ static HRESULT WINAPI FileProtocol_QueryInterface(IInternetProtocol *iface, REFI return E_NOINTERFACE; } -static ULONG WINAPI FileProtocol_AddRef(IInternetProtocol *iface) +static ULONG WINAPI FileProtocol_AddRef(IInternetProtocolEx *iface) { FileProtocol *This = PROTOCOL_THIS(iface); LONG ref = InterlockedIncrement(&This->ref); @@ -71,7 +79,7 @@ static ULONG WINAPI FileProtocol_AddRef(IInternetProtocol *iface) return ref; } -static ULONG WINAPI FileProtocol_Release(IInternetProtocol *iface) +static ULONG WINAPI FileProtocol_Release(IInternetProtocolEx *iface) { FileProtocol *This = PROTOCOL_THIS(iface); LONG ref = InterlockedDecrement(&This->ref); @@ -79,7 +87,7 @@ static ULONG WINAPI FileProtocol_Release(IInternetProtocol *iface) TRACE("(%p) ref=%d\n", This, ref); if(!ref) { - if(This->file) + if(This->file != INVALID_HANDLE_VALUE) CloseHandle(This->file); heap_free(This); @@ -89,27 +97,168 @@ static ULONG WINAPI FileProtocol_Release(IInternetProtocol *iface) return ref; } -static HRESULT WINAPI FileProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl, +static HRESULT WINAPI FileProtocol_Start(IInternetProtocolEx *iface, LPCWSTR szUrl, IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo, DWORD grfPI, HANDLE_PTR dwReserved) { FileProtocol *This = PROTOCOL_THIS(iface); - BINDINFO bindinfo; - DWORD grfBINDF = 0; - LARGE_INTEGER size; - DWORD len; - LPWSTR url, mime = NULL, file_name; - WCHAR null_char = 0; - BOOL first_call = FALSE; + IUri *uri; HRESULT hres; - static const WCHAR wszFile[] = {'f','i','l','e',':'}; - TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink, pOIBindInfo, grfPI, dwReserved); - if(!szUrl || strlenW(szUrl) < sizeof(wszFile)/sizeof(WCHAR) - || memcmp(szUrl, wszFile, sizeof(wszFile))) + hres = CreateUri(szUrl, Uri_CREATE_FILE_USE_DOS_PATH, 0, &uri); + if(FAILED(hres)) + return hres; + + hres = IInternetProtocolEx_StartEx(PROTOCOLEX(This), uri, pOIProtSink, pOIBindInfo, + grfPI, (HANDLE*)dwReserved); + + IUri_Release(uri); + return hres; +} + +static HRESULT WINAPI FileProtocol_Continue(IInternetProtocolEx *iface, PROTOCOLDATA *pProtocolData) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%p)\n", This, pProtocolData); + return E_NOTIMPL; +} + +static HRESULT WINAPI FileProtocol_Abort(IInternetProtocolEx *iface, HRESULT hrReason, + DWORD dwOptions) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions); + return E_NOTIMPL; +} + +static HRESULT WINAPI FileProtocol_Terminate(IInternetProtocolEx *iface, DWORD dwOptions) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + + TRACE("(%p)->(%08x)\n", This, dwOptions); + + return S_OK; +} + +static HRESULT WINAPI FileProtocol_Suspend(IInternetProtocolEx *iface) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI FileProtocol_Resume(IInternetProtocolEx *iface) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI FileProtocol_Read(IInternetProtocolEx *iface, void *pv, + ULONG cb, ULONG *pcbRead) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + DWORD read = 0; + + TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead); + + if (pcbRead) + *pcbRead = 0; + + if(This->file == INVALID_HANDLE_VALUE) + return INET_E_DATA_NOT_AVAILABLE; + + if (!ReadFile(This->file, pv, cb, &read, NULL)) + return INET_E_DOWNLOAD_FAILURE; + + if(pcbRead) + *pcbRead = read; + + return cb == read ? S_OK : S_FALSE; +} + +static HRESULT WINAPI FileProtocol_Seek(IInternetProtocolEx *iface, LARGE_INTEGER dlibMove, + DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition); + return E_NOTIMPL; +} + +static HRESULT WINAPI FileProtocol_LockRequest(IInternetProtocolEx *iface, DWORD dwOptions) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + + TRACE("(%p)->(%08x)\n", This, dwOptions); + + return S_OK; +} + +static HRESULT WINAPI FileProtocol_UnlockRequest(IInternetProtocolEx *iface) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + + TRACE("(%p)\n", This); + + return S_OK; +} + +static inline HRESULT report_result(IInternetProtocolSink *protocol_sink, HRESULT hres, DWORD res) +{ + IInternetProtocolSink_ReportResult(protocol_sink, hres, res, NULL); + return hres; +} + +static HRESULT open_file(FileProtocol *This, const WCHAR *path, IInternetProtocolSink *protocol_sink) +{ + LARGE_INTEGER size; + HANDLE file; + + file = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL, + OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + if(file == INVALID_HANDLE_VALUE) + return report_result(protocol_sink, INET_E_RESOURCE_NOT_FOUND, GetLastError()); + + if(!GetFileSizeEx(file, &size)) { + CloseHandle(file); + return report_result(protocol_sink, INET_E_RESOURCE_NOT_FOUND, GetLastError()); + } + + This->file = file; + This->size = size.u.LowPart; + + IInternetProtocolSink_ReportProgress(protocol_sink, + BINDSTATUS_CACHEFILENAMEAVAILABLE, path); + return S_OK; +} + +static HRESULT WINAPI FileProtocol_StartEx(IInternetProtocolEx *iface, IUri *pUri, + IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo, + DWORD grfPI, HANDLE *dwReserved) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + BINDINFO bindinfo; + DWORD grfBINDF = 0; + DWORD scheme; + LPWSTR mime = NULL; + WCHAR null_char = 0; + BSTR path, url; + HRESULT hres; + + TRACE("(%p)->(%p %p %p %08x %p)\n", This, pUri, pOIProtSink, + pOIBindInfo, grfPI, dwReserved); + + if(!pUri) + return E_INVALIDARG; + + scheme = 0; + hres = IUri_GetScheme(pUri, &scheme); + if(FAILED(hres)) + return hres; + if(scheme != URL_SCHEME_FILE) return E_INVALIDARG; memset(&bindinfo, 0, sizeof(bindinfo)); @@ -122,170 +271,52 @@ static HRESULT WINAPI FileProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl ReleaseBindInfo(&bindinfo); - len = lstrlenW(szUrl)+16; - url = heap_alloc(len*sizeof(WCHAR)); - hres = CoInternetParseUrl(szUrl, PARSE_ENCODE, 0, url, len, &len, 0); - if(FAILED(hres)) { - heap_free(url); - return hres; - } - if(!(grfBINDF & BINDF_FROMURLMON)) IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_DIRECTBIND, NULL); - if(!This->file) { - WCHAR *ptr; + if(This->file != INVALID_HANDLE_VALUE) { + IInternetProtocolSink_ReportData(pOIProtSink, + BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION, + This->size, This->size); + return S_OK; + } - first_call = TRUE; + IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_SENDINGREQUEST, &null_char); - IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_SENDINGREQUEST, &null_char); + hres = IUri_GetPath(pUri, &path); + if(FAILED(hres)) { + ERR("GetPath failed: %08x\n", hres); + return report_result(pOIProtSink, hres, 0); + } - file_name = url+sizeof(wszFile)/sizeof(WCHAR); - - /* Strip both forward and back slashes */ - if( (file_name[0] == '/' && file_name[1] == '/') || - (file_name[0] == '\\' && file_name[1] == '\\')) - file_name += 2; - if(*file_name == '/') - file_name++; - - for(ptr = file_name; *ptr; ptr++) { - if(*ptr == '?' || *ptr == '#') { - *ptr = 0; - break; - } - } - - if(file_name[1] == '|') - file_name[1] = ':'; - - This->file = CreateFileW(file_name, GENERIC_READ, FILE_SHARE_READ, NULL, - OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); - - if(This->file == INVALID_HANDLE_VALUE) { - This->file = NULL; - IInternetProtocolSink_ReportResult(pOIProtSink, INET_E_RESOURCE_NOT_FOUND, - GetLastError(), NULL); - heap_free(url); - return INET_E_RESOURCE_NOT_FOUND; - } - - IInternetProtocolSink_ReportProgress(pOIProtSink, - BINDSTATUS_CACHEFILENAMEAVAILABLE, file_name); + hres = open_file(This, path, pOIProtSink); + SysFreeString(path); + if(FAILED(hres)) + return hres; + hres = IUri_GetDisplayUri(pUri, &url); + if(hres == S_OK) { hres = FindMimeFromData(NULL, url, NULL, 0, NULL, 0, &mime, 0); + SysFreeString(url); if(SUCCEEDED(hres)) { IInternetProtocolSink_ReportProgress(pOIProtSink, (grfBINDF & BINDF_FROMURLMON) ? - BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE : BINDSTATUS_MIMETYPEAVAILABLE, + BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE : BINDSTATUS_MIMETYPEAVAILABLE, mime); CoTaskMemFree(mime); } } - heap_free(url); + IInternetProtocolSink_ReportData(pOIProtSink, + BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION, + This->size, This->size); - if(GetFileSizeEx(This->file, &size)) - IInternetProtocolSink_ReportData(pOIProtSink, - BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION, - size.u.LowPart, size.u.LowPart); - - if(first_call) - IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL); - - return S_OK; -} - -static HRESULT WINAPI FileProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData) -{ - FileProtocol *This = PROTOCOL_THIS(iface); - FIXME("(%p)->(%p)\n", This, pProtocolData); - return E_NOTIMPL; -} - -static HRESULT WINAPI FileProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason, - DWORD dwOptions) -{ - FileProtocol *This = PROTOCOL_THIS(iface); - FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions); - return E_NOTIMPL; -} - -static HRESULT WINAPI FileProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions) -{ - FileProtocol *This = PROTOCOL_THIS(iface); - - TRACE("(%p)->(%08x)\n", This, dwOptions); - - return S_OK; -} - -static HRESULT WINAPI FileProtocol_Suspend(IInternetProtocol *iface) -{ - FileProtocol *This = PROTOCOL_THIS(iface); - FIXME("(%p)\n", This); - return E_NOTIMPL; -} - -static HRESULT WINAPI FileProtocol_Resume(IInternetProtocol *iface) -{ - FileProtocol *This = PROTOCOL_THIS(iface); - FIXME("(%p)\n", This); - return E_NOTIMPL; -} - -static HRESULT WINAPI FileProtocol_Read(IInternetProtocol *iface, void *pv, - ULONG cb, ULONG *pcbRead) -{ - FileProtocol *This = PROTOCOL_THIS(iface); - DWORD read = 0; - - TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead); - - if (pcbRead) - *pcbRead = 0; - - if(!This->file) - return INET_E_DATA_NOT_AVAILABLE; - - if (!ReadFile(This->file, pv, cb, &read, NULL)) - return INET_E_DOWNLOAD_FAILURE; - - if(pcbRead) - *pcbRead = read; - - return cb == read ? S_OK : S_FALSE; -} - -static HRESULT WINAPI FileProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove, - DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition) -{ - FileProtocol *This = PROTOCOL_THIS(iface); - FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition); - return E_NOTIMPL; -} - -static HRESULT WINAPI FileProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions) -{ - FileProtocol *This = PROTOCOL_THIS(iface); - - TRACE("(%p)->(%08x)\n", This, dwOptions); - - return S_OK; -} - -static HRESULT WINAPI FileProtocol_UnlockRequest(IInternetProtocol *iface) -{ - FileProtocol *This = PROTOCOL_THIS(iface); - - TRACE("(%p)\n", This); - - return S_OK; + return report_result(pOIProtSink, S_OK, 0); } #undef PROTOCOL_THIS -static const IInternetProtocolVtbl FileProtocolVtbl = { +static const IInternetProtocolExVtbl FileProtocolExVtbl = { FileProtocol_QueryInterface, FileProtocol_AddRef, FileProtocol_Release, @@ -298,7 +329,8 @@ static const IInternetProtocolVtbl FileProtocolVtbl = { FileProtocol_Read, FileProtocol_Seek, FileProtocol_LockRequest, - FileProtocol_UnlockRequest + FileProtocol_UnlockRequest, + FileProtocol_StartEx }; #define PRIORITY_THIS(iface) DEFINE_THIS(FileProtocol, InternetPriority, iface) @@ -307,19 +339,19 @@ static HRESULT WINAPI FilePriority_QueryInterface(IInternetPriority *iface, REFIID riid, void **ppv) { FileProtocol *This = PRIORITY_THIS(iface); - return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv); + return IInternetProtocolEx_QueryInterface(PROTOCOLEX(This), riid, ppv); } static ULONG WINAPI FilePriority_AddRef(IInternetPriority *iface) { FileProtocol *This = PRIORITY_THIS(iface); - return IInternetProtocol_AddRef(PROTOCOL(This)); + return IInternetProtocolEx_AddRef(PROTOCOLEX(This)); } static ULONG WINAPI FilePriority_Release(IInternetPriority *iface) { FileProtocol *This = PRIORITY_THIS(iface); - return IInternetProtocol_Release(PROTOCOL(This)); + return IInternetProtocolEx_Release(PROTOCOLEX(This)); } static HRESULT WINAPI FilePriority_SetPriority(IInternetPriority *iface, LONG nPriority) @@ -362,13 +394,12 @@ HRESULT FileProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj) ret = heap_alloc(sizeof(FileProtocol)); - ret->lpIInternetProtocolVtbl = &FileProtocolVtbl; + ret->lpIInternetProtocolExVtbl = &FileProtocolExVtbl; ret->lpInternetPriorityVtbl = &FilePriorityVtbl; - ret->file = NULL; + ret->file = INVALID_HANDLE_VALUE; ret->priority = 0; ret->ref = 1; - *ppobj = PROTOCOL(ret); - + *ppobj = PROTOCOLEX(ret); return S_OK; } diff --git a/reactos/dll/win32/urlmon/ftp.c b/reactos/dll/win32/urlmon/ftp.c index f5e35064c90..4fa0924387d 100644 --- a/reactos/dll/win32/urlmon/ftp.c +++ b/reactos/dll/win32/urlmon/ftp.c @@ -36,14 +36,21 @@ typedef struct { #define ASYNCPROTOCOL_THIS(iface) DEFINE_THIS2(FtpProtocol, base, iface) -static HRESULT FtpProtocol_open_request(Protocol *prot, LPCWSTR url, DWORD request_flags, +static HRESULT FtpProtocol_open_request(Protocol *prot, IUri *uri, DWORD request_flags, HINTERNET internet_session, IInternetBindInfo *bind_info) { FtpProtocol *This = ASYNCPROTOCOL_THIS(prot); + BSTR url; + HRESULT hres; + + hres = IUri_GetAbsoluteUri(uri, &url); + if(FAILED(hres)) + return hres; This->base.request = InternetOpenUrlW(internet_session, url, NULL, 0, request_flags|INTERNET_FLAG_EXISTING_CONNECT|INTERNET_FLAG_PASSIVE, (DWORD_PTR)&This->base); + SysFreeString(url); if (!This->base.request && GetLastError() != ERROR_IO_PENDING) { WARN("InternetOpenUrl failed: %d\n", GetLastError()); return INET_E_RESOURCE_NOT_FOUND; @@ -145,6 +152,8 @@ static HRESULT WINAPI FtpProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl, DWORD grfPI, HANDLE_PTR dwReserved) { FtpProtocol *This = PROTOCOL_THIS(iface); + IUri *uri; + HRESULT hres; static const WCHAR ftpW[] = {'f','t','p',':'}; @@ -154,7 +163,14 @@ static HRESULT WINAPI FtpProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl, if(strncmpW(szUrl, ftpW, sizeof(ftpW)/sizeof(WCHAR))) return MK_E_SYNTAX; - return protocol_start(&This->base, PROTOCOL(This), szUrl, pOIProtSink, pOIBindInfo); + hres = CreateUri(szUrl, 0, 0, &uri); + if(FAILED(hres)) + return hres; + + hres = protocol_start(&This->base, PROTOCOL(This), uri, pOIProtSink, pOIBindInfo); + + IUri_Release(uri); + return hres; } static HRESULT WINAPI FtpProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData) diff --git a/reactos/dll/win32/urlmon/gopher.c b/reactos/dll/win32/urlmon/gopher.c index 18e397285df..d8781ce7925 100644 --- a/reactos/dll/win32/urlmon/gopher.c +++ b/reactos/dll/win32/urlmon/gopher.c @@ -34,13 +34,20 @@ typedef struct { #define ASYNCPROTOCOL_THIS(iface) DEFINE_THIS2(GopherProtocol, base, iface) -static HRESULT GopherProtocol_open_request(Protocol *prot, LPCWSTR url, DWORD request_flags, +static HRESULT GopherProtocol_open_request(Protocol *prot, IUri *uri, DWORD request_flags, HINTERNET internet_session, IInternetBindInfo *bind_info) { GopherProtocol *This = ASYNCPROTOCOL_THIS(prot); + BSTR url; + HRESULT hres; + + hres = IUri_GetAbsoluteUri(uri, &url); + if(FAILED(hres)) + return hres; This->base.request = InternetOpenUrlW(internet_session, url, NULL, 0, request_flags, (DWORD_PTR)&This->base); + SysFreeString(url); if (!This->base.request && GetLastError() != ERROR_IO_PENDING) { WARN("InternetOpenUrl failed: %d\n", GetLastError()); return INET_E_RESOURCE_NOT_FOUND; @@ -125,11 +132,20 @@ static HRESULT WINAPI GopherProtocol_Start(IInternetProtocol *iface, LPCWSTR szU DWORD grfPI, HANDLE_PTR dwReserved) { GopherProtocol *This = PROTOCOL_THIS(iface); + IUri *uri; + HRESULT hres; TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink, pOIBindInfo, grfPI, dwReserved); - return protocol_start(&This->base, PROTOCOL(This), szUrl, pOIProtSink, pOIBindInfo); + hres = CreateUri(szUrl, 0, 0, &uri); + if(FAILED(hres)) + return hres; + + hres = protocol_start(&This->base, PROTOCOL(This), uri, pOIProtSink, pOIBindInfo); + + IUri_Release(uri); + return hres; } static HRESULT WINAPI GopherProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData) diff --git a/reactos/dll/win32/urlmon/http.c b/reactos/dll/win32/urlmon/http.c index fc0b8c4ecfe..722ec501b4d 100644 --- a/reactos/dll/win32/urlmon/http.c +++ b/reactos/dll/win32/urlmon/http.c @@ -67,18 +67,18 @@ static LPWSTR query_http_info(HttpProtocol *This, DWORD option) #define ASYNCPROTOCOL_THIS(iface) DEFINE_THIS2(HttpProtocol, base, iface) -static HRESULT HttpProtocol_open_request(Protocol *prot, LPCWSTR url, DWORD request_flags, +static HRESULT HttpProtocol_open_request(Protocol *prot, IUri *uri, DWORD request_flags, HINTERNET internet_session, IInternetBindInfo *bind_info) { HttpProtocol *This = ASYNCPROTOCOL_THIS(prot); LPWSTR addl_header = NULL, post_cookie = NULL, optional = NULL; IServiceProvider *service_provider = NULL; IHttpNegotiate2 *http_negotiate2 = NULL; - LPWSTR host, user, pass, path; + BSTR url, host, user, pass, path; LPOLESTR accept_mimes[257]; - URL_COMPONENTSW url_comp; + const WCHAR **accept_types; BYTE security_id[512]; - DWORD len = 0; + DWORD len = 0, port; ULONG num; BOOL res, b; HRESULT hres; @@ -88,24 +88,28 @@ static HRESULT HttpProtocol_open_request(Protocol *prot, LPCWSTR url, DWORD requ {'P','O','S','T',0}, {'P','U','T',0}}; - memset(&url_comp, 0, sizeof(url_comp)); - url_comp.dwStructSize = sizeof(url_comp); - url_comp.dwSchemeLength = url_comp.dwHostNameLength = url_comp.dwUrlPathLength = url_comp.dwExtraInfoLength = - url_comp.dwUserNameLength = url_comp.dwPasswordLength = 1; - if (!InternetCrackUrlW(url, 0, 0, &url_comp)) - return MK_E_SYNTAX; + hres = IUri_GetPort(uri, &port); + if(FAILED(hres)) + return hres; - if(!url_comp.nPort) - url_comp.nPort = This->https ? INTERNET_DEFAULT_HTTPS_PORT : INTERNET_DEFAULT_HTTP_PORT; + hres = IUri_GetHost(uri, &host); + if(FAILED(hres)) + return hres; - host = heap_strndupW(url_comp.lpszHostName, url_comp.dwHostNameLength); - user = heap_strndupW(url_comp.lpszUserName, url_comp.dwUserNameLength); - pass = heap_strndupW(url_comp.lpszPassword, url_comp.dwPasswordLength); - This->base.connection = InternetConnectW(internet_session, host, url_comp.nPort, user, pass, - INTERNET_SERVICE_HTTP, This->https ? INTERNET_FLAG_SECURE : 0, (DWORD_PTR)&This->base); - heap_free(pass); - heap_free(user); - heap_free(host); + hres = IUri_GetUserName(uri, &user); + if(SUCCEEDED(hres)) { + hres = IUri_GetPassword(uri, &pass); + + if(SUCCEEDED(hres)) { + This->base.connection = InternetConnectW(internet_session, host, port, user, pass, + INTERNET_SERVICE_HTTP, This->https ? INTERNET_FLAG_SECURE : 0, (DWORD_PTR)&This->base); + SysFreeString(pass); + } + SysFreeString(user); + } + SysFreeString(host); + if(FAILED(hres)) + return hres; if(!This->base.connection) { WARN("InternetConnect failed: %d\n", GetLastError()); return INET_E_CANNOT_CONNECT; @@ -113,27 +117,35 @@ static HRESULT HttpProtocol_open_request(Protocol *prot, LPCWSTR url, DWORD requ num = sizeof(accept_mimes)/sizeof(accept_mimes[0])-1; hres = IInternetBindInfo_GetBindString(bind_info, BINDSTRING_ACCEPT_MIMES, accept_mimes, num, &num); - if(hres != S_OK) { + if(hres == INET_E_USE_DEFAULT_SETTING) { + static const WCHAR default_accept_mimeW[] = {'*','/','*',0}; + static const WCHAR *default_accept_mimes[] = {default_accept_mimeW, NULL}; + + accept_types = default_accept_mimes; + num = 0; + }else if(hres == S_OK) { + accept_types = (const WCHAR**)accept_mimes; + }else { WARN("GetBindString BINDSTRING_ACCEPT_MIMES failed: %08x\n", hres); return INET_E_NO_VALID_MEDIA; } accept_mimes[num] = 0; - path = heap_alloc((url_comp.dwUrlPathLength+url_comp.dwExtraInfoLength+1)*sizeof(WCHAR)); - if(url_comp.dwUrlPathLength) - memcpy(path, url_comp.lpszUrlPath, url_comp.dwUrlPathLength*sizeof(WCHAR)); - if(url_comp.dwExtraInfoLength) - memcpy(path+url_comp.dwUrlPathLength, url_comp.lpszExtraInfo, url_comp.dwExtraInfoLength*sizeof(WCHAR)); - path[url_comp.dwUrlPathLength+url_comp.dwExtraInfoLength] = 0; if(This->https) request_flags |= INTERNET_FLAG_SECURE; - This->base.request = HttpOpenRequestW(This->base.connection, - This->base.bind_info.dwBindVerb < BINDVERB_CUSTOM - ? wszBindVerb[This->base.bind_info.dwBindVerb] : This->base.bind_info.szCustomVerb, - path, NULL, NULL, (LPCWSTR *)accept_mimes, request_flags, (DWORD_PTR)&This->base); - heap_free(path); + + hres = IUri_GetPathAndQuery(uri, &path); + if(SUCCEEDED(hres)) { + This->base.request = HttpOpenRequestW(This->base.connection, + This->base.bind_info.dwBindVerb < BINDVERB_CUSTOM + ? wszBindVerb[This->base.bind_info.dwBindVerb] : This->base.bind_info.szCustomVerb, + path, NULL, NULL, accept_types, request_flags, (DWORD_PTR)&This->base); + SysFreeString(path); + } while(num--) CoTaskMemFree(accept_mimes[num]); + if(FAILED(hres)) + return hres; if (!This->base.request) { WARN("HttpOpenRequest failed: %d\n", GetLastError()); return INET_E_RESOURCE_NOT_FOUND; @@ -153,8 +165,15 @@ static HRESULT HttpProtocol_open_request(Protocol *prot, LPCWSTR url, DWORD requ return hres; } + hres = IUri_GetAbsoluteUri(uri, &url); + if(FAILED(hres)) { + IServiceProvider_Release(service_provider); + return hres; + } + hres = IHttpNegotiate_BeginningTransaction(This->http_negotiate, url, wszHeaders, 0, &addl_header); + SysFreeString(url); if(hres != S_OK) { WARN("IHttpNegotiate_BeginningTransaction failed: %08x\n", hres); IServiceProvider_Release(service_provider); @@ -382,6 +401,8 @@ static HRESULT WINAPI HttpProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl DWORD grfPI, HANDLE_PTR dwReserved) { HttpProtocol *This = PROTOCOL_THIS(iface); + IUri *uri; + HRESULT hres; static const WCHAR httpW[] = {'h','t','t','p',':'}; static const WCHAR httpsW[] = {'h','t','t','p','s',':'}; @@ -394,7 +415,14 @@ static HRESULT WINAPI HttpProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl : strncmpW(szUrl, httpW, sizeof(httpW)/sizeof(WCHAR))) return MK_E_SYNTAX; - return protocol_start(&This->base, PROTOCOL(This), szUrl, pOIProtSink, pOIBindInfo); + hres = CreateUri(szUrl, 0, 0, &uri); + if(FAILED(hres)) + return hres; + + hres = protocol_start(&This->base, PROTOCOL(This), uri, pOIProtSink, pOIBindInfo); + + IUri_Release(uri); + return hres; } static HRESULT WINAPI HttpProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData) diff --git a/reactos/dll/win32/urlmon/protocol.c b/reactos/dll/win32/urlmon/protocol.c index 3f3cbe505bc..b423c67354f 100644 --- a/reactos/dll/win32/urlmon/protocol.c +++ b/reactos/dll/win32/urlmon/protocol.c @@ -234,7 +234,7 @@ HINTERNET get_internet_session(IInternetBindInfo *bind_info) return internet_session; } -HRESULT protocol_start(Protocol *protocol, IInternetProtocol *prot, LPCWSTR url, +HRESULT protocol_start(Protocol *protocol, IInternetProtocol *prot, IUri *uri, IInternetProtocolSink *protocol_sink, IInternetBindInfo *bind_info) { DWORD request_flags; @@ -265,7 +265,7 @@ HRESULT protocol_start(Protocol *protocol, IInternetProtocol *prot, LPCWSTR url, if(protocol->bindf & BINDF_NEEDFILE) request_flags |= INTERNET_FLAG_NEED_FILE; - hres = protocol->vtbl->open_request(protocol, url, request_flags, internet_session, bind_info); + hres = protocol->vtbl->open_request(protocol, uri, request_flags, internet_session, bind_info); if(FAILED(hres)) { protocol_close_connection(protocol); return report_result(protocol, hres); diff --git a/reactos/dll/win32/urlmon/uri.c b/reactos/dll/win32/urlmon/uri.c index 82f48a0cae5..2aee38a46ba 100644 --- a/reactos/dll/win32/urlmon/uri.c +++ b/reactos/dll/win32/urlmon/uri.c @@ -24,9 +24,19 @@ #include "shlwapi.h" #define UINT_MAX 0xffffffff +#define USHORT_MAX 0xffff + +#define ALLOW_NULL_TERM_SCHEME 0x01 +#define ALLOW_NULL_TERM_USER_NAME 0x02 +#define ALLOW_NULL_TERM_PASSWORD 0x04 +#define ALLOW_BRACKETLESS_IP_LITERAL 0x08 +#define SKIP_IP_FUTURE_CHECK 0x10 +#define IGNORE_PORT_DELIMITER 0x20 WINE_DEFAULT_DEBUG_CHANNEL(urlmon); +static const IID IID_IUriObj = {0x4b364760,0x9f51,0x11df,{0x98,0x1c,0x08,0x00,0x20,0x0c,0x9a,0x66}}; + typedef struct { const IUriVtbl *lpIUriVtbl; LONG ref; @@ -37,6 +47,8 @@ typedef struct { WCHAR *canon_uri; DWORD canon_size; DWORD canon_len; + BOOL display_absolute; + DWORD create_flags; INT scheme_start; DWORD scheme_len; @@ -49,13 +61,79 @@ typedef struct { INT host_start; DWORD host_len; Uri_HOST_TYPE host_type; + + USHORT port; + BOOL has_port; + + INT authority_start; + DWORD authority_len; + + INT domain_offset; + + INT path_start; + DWORD path_len; + INT extension_offset; + + INT query_start; + DWORD query_len; + + INT fragment_start; + DWORD fragment_len; } Uri; typedef struct { const IUriBuilderVtbl *lpIUriBuilderVtbl; LONG ref; + + Uri *uri; + DWORD modified_props; + + WCHAR *fragment; + DWORD fragment_len; + + WCHAR *host; + DWORD host_len; + + WCHAR *password; + DWORD password_len; + + WCHAR *path; + DWORD path_len; + + BOOL has_port; + DWORD port; + + WCHAR *query; + DWORD query_len; + + WCHAR *scheme; + DWORD scheme_len; + + WCHAR *username; + DWORD username_len; } UriBuilder; +typedef struct { + const WCHAR *str; + DWORD len; +} h16; + +typedef struct { + /* IPv6 addresses can hold up to 8 h16 components. */ + h16 components[8]; + DWORD h16_count; + + /* An IPv6 can have 1 elision ("::"). */ + const WCHAR *elision; + + /* An IPv6 can contain 1 IPv4 address as the last 32bits of the address. */ + const WCHAR *ipv4; + DWORD ipv4_len; + + INT components_size; + INT elision_size; +} ipv6_address; + typedef struct { BSTR uri; @@ -69,13 +147,32 @@ typedef struct { DWORD scheme_len; URL_SCHEME scheme_type; - const WCHAR *userinfo; - DWORD userinfo_len; - INT userinfo_split; + const WCHAR *username; + DWORD username_len; + + const WCHAR *password; + DWORD password_len; const WCHAR *host; DWORD host_len; Uri_HOST_TYPE host_type; + + BOOL has_ipv6; + ipv6_address ipv6_address; + + BOOL has_port; + const WCHAR *port; + DWORD port_len; + DWORD port_value; + + const WCHAR *path; + DWORD path_len; + + const WCHAR *query; + DWORD query_len; + + const WCHAR *fragment; + DWORD fragment_len; } parse_data; static const CHAR hexDigits[] = "0123456789ABCDEF"; @@ -109,6 +206,44 @@ static const struct { {URL_SCHEME_WILDCARD, {'*',0}} }; +/* List of default ports Windows recognizes. */ +static const struct { + URL_SCHEME scheme; + USHORT port; +} default_ports[] = { + {URL_SCHEME_FTP, 21}, + {URL_SCHEME_HTTP, 80}, + {URL_SCHEME_GOPHER, 70}, + {URL_SCHEME_NNTP, 119}, + {URL_SCHEME_TELNET, 23}, + {URL_SCHEME_WAIS, 210}, + {URL_SCHEME_HTTPS, 443}, +}; + +/* List of 3 character top level domain names Windows seems to recognize. + * There might be more, but, these are the only ones I've found so far. + */ +static const struct { + WCHAR tld_name[4]; +} recognized_tlds[] = { + {{'c','o','m',0}}, + {{'e','d','u',0}}, + {{'g','o','v',0}}, + {{'i','n','t',0}}, + {{'m','i','l',0}}, + {{'n','e','t',0}}, + {{'o','r','g',0}} +}; + +static Uri *get_uri_obj(IUri *uri) +{ + Uri *ret; + HRESULT hres; + + hres = IUri_QueryInterface(uri, &IID_IUriObj, (void**)&ret); + return SUCCEEDED(hres) ? ret : NULL; +} + static inline BOOL is_alpha(WCHAR val) { return ((val >= 'a' && val <= 'z') || (val >= 'A' && val <= 'Z')); } @@ -117,16 +252,23 @@ static inline BOOL is_num(WCHAR val) { return (val >= '0' && val <= '9'); } +static inline BOOL is_drive_path(const WCHAR *str) { + return (is_alpha(str[0]) && (str[1] == ':' || str[1] == '|')); +} + +static inline BOOL is_unc_path(const WCHAR *str) { + return (str[0] == '\\' && str[0] == '\\'); +} + +static inline BOOL is_forbidden_dos_path_char(WCHAR val) { + return (val == '>' || val == '<' || val == '\"'); +} + /* A URI is implicitly a file path if it begins with * a drive letter (eg X:) or starts with "\\" (UNC path). */ static inline BOOL is_implicit_file_path(const WCHAR *str) { - if(is_alpha(str[0]) && str[1] == ':') - return TRUE; - else if(str[0] == '\\' && str[1] == '\\') - return TRUE; - - return FALSE; + return (is_unc_path(str) || (is_alpha(str[0]) && str[1] == ':')); } /* Checks if the URI is a hierarchical URI. A hierarchical @@ -191,6 +333,194 @@ static inline BOOL is_hexdigit(WCHAR val) { (val >= '0' && val <= '9')); } +static inline BOOL is_path_delim(WCHAR val) { + return (!val || val == '#' || val == '?'); +} + +/* List of schemes types Windows seems to expect to be hierarchical. */ +static inline BOOL is_hierarchical_scheme(URL_SCHEME type) { + return(type == URL_SCHEME_HTTP || type == URL_SCHEME_FTP || + type == URL_SCHEME_GOPHER || type == URL_SCHEME_NNTP || + type == URL_SCHEME_TELNET || type == URL_SCHEME_WAIS || + type == URL_SCHEME_FILE || type == URL_SCHEME_HTTPS || + type == URL_SCHEME_RES); +} + +/* Checks if 'flags' contains an invalid combination of Uri_CREATE flags. */ +static inline BOOL has_invalid_flag_combination(DWORD flags) { + return((flags & Uri_CREATE_DECODE_EXTRA_INFO && flags & Uri_CREATE_NO_DECODE_EXTRA_INFO) || + (flags & Uri_CREATE_CANONICALIZE && flags & Uri_CREATE_NO_CANONICALIZE) || + (flags & Uri_CREATE_CRACK_UNKNOWN_SCHEMES && flags & Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES) || + (flags & Uri_CREATE_PRE_PROCESS_HTML_URI && flags & Uri_CREATE_NO_PRE_PROCESS_HTML_URI) || + (flags & Uri_CREATE_IE_SETTINGS && flags & Uri_CREATE_NO_IE_SETTINGS)); +} + +/* Applies each default Uri_CREATE flags to 'flags' if it + * doesn't cause a flag conflict. + */ +static void apply_default_flags(DWORD *flags) { + if(!(*flags & Uri_CREATE_NO_CANONICALIZE)) + *flags |= Uri_CREATE_CANONICALIZE; + if(!(*flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) + *flags |= Uri_CREATE_DECODE_EXTRA_INFO; + if(!(*flags & Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES)) + *flags |= Uri_CREATE_CRACK_UNKNOWN_SCHEMES; + if(!(*flags & Uri_CREATE_NO_PRE_PROCESS_HTML_URI)) + *flags |= Uri_CREATE_PRE_PROCESS_HTML_URI; + if(!(*flags & Uri_CREATE_IE_SETTINGS)) + *flags |= Uri_CREATE_NO_IE_SETTINGS; +} + +/* Determines if the URI is hierarchical using the information already parsed into + * data and using the current location of parsing in the URI string. + * + * Windows considers a URI hierarchical if on of the following is true: + * A.) It's a wildcard scheme. + * B.) It's an implicit file scheme. + * C.) It's a known hierarchical scheme and it has two '\\' after the scheme name. + * (the '\\' will be converted into "//" during canonicalization). + * D.) It's not a relative URI and "//" appears after the scheme name. + */ +static inline BOOL is_hierarchical_uri(const WCHAR **ptr, const parse_data *data) { + const WCHAR *start = *ptr; + + if(data->scheme_type == URL_SCHEME_WILDCARD) + return TRUE; + else if(data->scheme_type == URL_SCHEME_FILE && data->has_implicit_scheme) + return TRUE; + else if(is_hierarchical_scheme(data->scheme_type) && (*ptr)[0] == '\\' && (*ptr)[1] == '\\') { + *ptr += 2; + return TRUE; + } else if(!data->is_relative && check_hierarchical(ptr)) + return TRUE; + + *ptr = start; + return FALSE; +} + +/* Checks if the two Uri's are logically equivalent. It's a simple + * comparison, since they are both of type Uri, and it can access + * the properties of each Uri directly without the need to go + * through the "IUri_Get*" interface calls. + */ +static BOOL are_equal_simple(const Uri *a, const Uri *b) { + if(a->scheme_type == b->scheme_type) { + const BOOL known_scheme = a->scheme_type != URL_SCHEME_UNKNOWN; + const BOOL are_hierarchical = + (a->authority_start > -1 && b->authority_start > -1); + + if(a->scheme_type == URL_SCHEME_FILE) { + if(a->canon_len == b->canon_len) + return !StrCmpIW(a->canon_uri, b->canon_uri); + } + + /* Only compare the scheme names (if any) if their unknown scheme types. */ + if(!known_scheme) { + if((a->scheme_start > -1 && b->scheme_start > -1) && + (a->scheme_len == b->scheme_len)) { + /* Make sure the schemes are the same. */ + if(StrCmpNW(a->canon_uri+a->scheme_start, b->canon_uri+b->scheme_start, a->scheme_len)) + return FALSE; + } else if(a->scheme_len != b->scheme_len) + /* One of the Uri's has a scheme name, while the other doesn't. */ + return FALSE; + } + + /* If they have a userinfo component, perform case sensitive compare. */ + if((a->userinfo_start > -1 && b->userinfo_start > -1) && + (a->userinfo_len == b->userinfo_len)) { + if(StrCmpNW(a->canon_uri+a->userinfo_start, b->canon_uri+b->userinfo_start, a->userinfo_len)) + return FALSE; + } else if(a->userinfo_len != b->userinfo_len) + /* One of the Uri's had a userinfo, while the other one doesn't. */ + return FALSE; + + /* Check if they have a host name. */ + if((a->host_start > -1 && b->host_start > -1) && + (a->host_len == b->host_len)) { + /* Perform a case insensitive compare if they are a known scheme type. */ + if(known_scheme) { + if(StrCmpNIW(a->canon_uri+a->host_start, b->canon_uri+b->host_start, a->host_len)) + return FALSE; + } else if(StrCmpNW(a->canon_uri+a->host_start, b->canon_uri+b->host_start, a->host_len)) + return FALSE; + } else if(a->host_len != b->host_len) + /* One of the Uri's had a host, while the other one didn't. */ + return FALSE; + + if(a->has_port && b->has_port) { + if(a->port != b->port) + return FALSE; + } else if(a->has_port || b->has_port) + /* One had a port, while the other one didn't. */ + return FALSE; + + /* Windows is weird with how it handles paths. For example + * One URI could be "http://google.com" (after canonicalization) + * and one could be "http://google.com/" and the IsEqual function + * would still evaluate to TRUE, but, only if they are both hierarchical + * URIs. + */ + if((a->path_start > -1 && b->path_start > -1) && + (a->path_len == b->path_len)) { + if(StrCmpNW(a->canon_uri+a->path_start, b->canon_uri+b->path_start, a->path_len)) + return FALSE; + } else if(are_hierarchical && a->path_len == -1 && b->path_len == 0) { + if(*(a->canon_uri+a->path_start) != '/') + return FALSE; + } else if(are_hierarchical && b->path_len == 1 && a->path_len == 0) { + if(*(b->canon_uri+b->path_start) != '/') + return FALSE; + } else if(a->path_len != b->path_len) + return FALSE; + + /* Compare the query strings of the two URIs. */ + if((a->query_start > -1 && b->query_start > -1) && + (a->query_len == b->query_len)) { + if(StrCmpNW(a->canon_uri+a->query_start, b->canon_uri+b->query_start, a->query_len)) + return FALSE; + } else if(a->query_len != b->query_len) + return FALSE; + + if((a->fragment_start > -1 && b->fragment_start > -1) && + (a->fragment_len == b->fragment_len)) { + if(StrCmpNW(a->canon_uri+a->fragment_start, b->canon_uri+b->fragment_start, a->fragment_len)) + return FALSE; + } else if(a->fragment_len != b->fragment_len) + return FALSE; + + /* If we get here, the two URIs are equivalent. */ + return TRUE; + } + + return FALSE; +} + +/* Computes the size of the given IPv6 address. + * Each h16 component is 16bits, if there is an IPv4 address, it's + * 32bits. If there's an elision it can be 16bits to 128bits, depending + * on the number of other components. + * + * Modeled after google-url's CheckIPv6ComponentsSize function + */ +static void compute_ipv6_comps_size(ipv6_address *address) { + address->components_size = address->h16_count * 2; + + if(address->ipv4) + /* IPv4 address is 4 bytes. */ + address->components_size += 4; + + if(address->elision) { + /* An elision can be anywhere from 2 bytes up to 16 bytes. + * It size depends on the size of the h16 and IPv4 components. + */ + address->elision_size = 16 - address->components_size; + if(address->elision_size < 2) + address->elision_size = 2; + } else + address->elision_size = 0; +} + /* Taken from dlls/jscript/lex.c */ static int hex_to_int(WCHAR val) { if(val >= '0' && val <= '9') @@ -238,6 +568,343 @@ static inline void pct_encode_val(WCHAR val, WCHAR *dest) { dest[2] = hexDigits[val & 0xf]; } +/* Scans the range of characters [str, end] and returns the last occurrence + * of 'ch' or returns NULL. + */ +static const WCHAR *str_last_of(const WCHAR *str, const WCHAR *end, WCHAR ch) { + const WCHAR *ptr = end; + + while(ptr >= str) { + if(*ptr == ch) + return ptr; + --ptr; + } + + return NULL; +} + +/* Attempts to parse the domain name from the host. + * + * This function also includes the Top-level Domain (TLD) name + * of the host when it tries to find the domain name. If it finds + * a valid domain name it will assign 'domain_start' the offset + * into 'host' where the domain name starts. + * + * It's implied that if a domain name its range is implied to be + * [host+domain_start, host+host_len). + */ +static void find_domain_name(const WCHAR *host, DWORD host_len, + INT *domain_start) { + const WCHAR *last_tld, *sec_last_tld, *end; + + end = host+host_len-1; + + *domain_start = -1; + + /* There has to be at least enough room for a '.' followed by a + * 3 character TLD for a domain to even exist in the host name. + */ + if(host_len < 4) + return; + + last_tld = str_last_of(host, end, '.'); + if(!last_tld) + /* http://hostname -> has no domain name. */ + return; + + sec_last_tld = str_last_of(host, last_tld-1, '.'); + if(!sec_last_tld) { + /* If the '.' is at the beginning of the host there + * has to be at least 3 characters in the TLD for it + * to be valid. + * Ex: .com -> .com as the domain name. + * .co -> has no domain name. + */ + if(last_tld-host == 0) { + if(end-(last_tld-1) < 3) + return; + } else if(last_tld-host == 3) { + DWORD i; + + /* If there's three characters in front of last_tld and + * they are on the list of recognized TLDs, then this + * host doesn't have a domain (since the host only contains + * a TLD name. + * Ex: edu.uk -> has no domain name. + * foo.uk -> foo.uk as the domain name. + */ + for(i = 0; i < sizeof(recognized_tlds)/sizeof(recognized_tlds[0]); ++i) { + if(!StrCmpNIW(host, recognized_tlds[i].tld_name, 3)) + return; + } + } else if(last_tld-host < 3) + /* Anything less than 3 characters is considered part + * of the TLD name. + * Ex: ak.uk -> Has no domain name. + */ + return; + + /* Otherwise the domain name is the whole host name. */ + *domain_start = 0; + } else if(end+1-last_tld > 3) { + /* If the last_tld has more than 3 characters, then it's automatically + * considered the TLD of the domain name. + * Ex: www.winehq.org.uk.test -> uk.test as the domain name. + */ + *domain_start = (sec_last_tld+1)-host; + } else if(last_tld - (sec_last_tld+1) < 4) { + DWORD i; + /* If the sec_last_tld is 3 characters long it HAS to be on the list of + * recognized to still be considered part of the TLD name, otherwise + * its considered the domain name. + * Ex: www.google.com.uk -> google.com.uk as the domain name. + * www.google.foo.uk -> foo.uk as the domain name. + */ + if(last_tld - (sec_last_tld+1) == 3) { + for(i = 0; i < sizeof(recognized_tlds)/sizeof(recognized_tlds[0]); ++i) { + if(!StrCmpNIW(sec_last_tld+1, recognized_tlds[i].tld_name, 3)) { + const WCHAR *domain = str_last_of(host, sec_last_tld-1, '.'); + + if(!domain) + *domain_start = 0; + else + *domain_start = (domain+1) - host; + TRACE("Found domain name %s\n", debugstr_wn(host+*domain_start, + (host+host_len)-(host+*domain_start))); + return; + } + } + + *domain_start = (sec_last_tld+1)-host; + } else { + /* Since the sec_last_tld is less than 3 characters it's considered + * part of the TLD. + * Ex: www.google.fo.uk -> google.fo.uk as the domain name. + */ + const WCHAR *domain = str_last_of(host, sec_last_tld-1, '.'); + + if(!domain) + *domain_start = 0; + else + *domain_start = (domain+1) - host; + } + } else { + /* The second to last TLD has more than 3 characters making it + * the domain name. + * Ex: www.google.test.us -> test.us as the domain name. + */ + *domain_start = (sec_last_tld+1)-host; + } + + TRACE("Found domain name %s\n", debugstr_wn(host+*domain_start, + (host+host_len)-(host+*domain_start))); +} + +/* Removes the dot segments from a hierarchical URIs path component. This + * function performs the removal in place. + * + * This is a modified version of Qt's QUrl function "removeDotsFromPath". + * + * This function returns the new length of the path string. + */ +static DWORD remove_dot_segments(WCHAR *path, DWORD path_len) { + WCHAR *out = path; + const WCHAR *in = out; + const WCHAR *end = out + path_len; + DWORD len; + + while(in < end) { + /* A. if the input buffer begins with a prefix of "/./" or "/.", + * where "." is a complete path segment, then replace that + * prefix with "/" in the input buffer; otherwise, + */ + if(in <= end - 3 && in[0] == '/' && in[1] == '.' && in[2] == '/') { + in += 2; + continue; + } else if(in == end - 2 && in[0] == '/' && in[1] == '.') { + *out++ = '/'; + in += 2; + break; + } + + /* B. if the input buffer begins with a prefix of "/../" or "/..", + * where ".." is a complete path segment, then replace that + * prefix with "/" in the input buffer and remove the last + * segment and its preceding "/" (if any) from the output + * buffer; otherwise, + */ + if(in <= end - 4 && in[0] == '/' && in[1] == '.' && in[2] == '.' && in[3] == '/') { + while(out > path && *(--out) != '/'); + + in += 3; + continue; + } else if(in == end - 3 && in[0] == '/' && in[1] == '.' && in[2] == '.') { + while(out > path && *(--out) != '/'); + + if(*out == '/') + ++out; + + in += 3; + break; + } + + /* C. move the first path segment in the input buffer to the end of + * the output buffer, including the initial "/" character (if + * any) and any subsequent characters up to, but not including, + * the next "/" character or the end of the input buffer. + */ + *out++ = *in++; + while(in < end && *in != '/') + *out++ = *in++; + } + + len = out - path; + TRACE("(%p %d): Path after dot segments removed %s len=%d\n", path, path_len, + debugstr_wn(path, len), len); + return len; +} + +/* Attempts to find the file extension in a given path. */ +static INT find_file_extension(const WCHAR *path, DWORD path_len) { + const WCHAR *end; + + for(end = path+path_len-1; end >= path && *end != '/' && *end != '\\'; --end) { + if(*end == '.') + return end-path; + } + + return -1; +} + +/* Computes the location where the elision should occur in the IPv6 + * address using the numerical values of each component stored in + * 'values'. If the address shouldn't contain an elision then 'index' + * is assigned -1 as it's value. Otherwise 'index' will contain the + * starting index (into values) where the elision should be, and 'count' + * will contain the number of cells the elision covers. + * + * NOTES: + * Windows will expand an elision if the elision only represents 1 h16 + * component of the URI. + * + * Ex: [1::2:3:4:5:6:7] -> [1:0:2:3:4:5:6:7] + * + * If the IPv6 address contains an IPv4 address, the IPv4 address is also + * considered for being included as part of an elision if all it's components + * are zeros. + * + * Ex: [1:2:3:4:5:6:0.0.0.0] -> [1:2:3:4:5:6::] + */ +static void compute_elision_location(const ipv6_address *address, const USHORT values[8], + INT *index, DWORD *count) { + DWORD i, max_len, cur_len; + INT max_index, cur_index; + + max_len = cur_len = 0; + max_index = cur_index = -1; + for(i = 0; i < 8; ++i) { + BOOL check_ipv4 = (address->ipv4 && i == 6); + BOOL is_end = (check_ipv4 || i == 7); + + if(check_ipv4) { + /* Check if the IPv4 address contains only zeros. */ + if(values[i] == 0 && values[i+1] == 0) { + if(cur_index == -1) + cur_index = i; + + cur_len += 2; + ++i; + } + } else if(values[i] == 0) { + if(cur_index == -1) + cur_index = i; + + ++cur_len; + } + + if(is_end || values[i] != 0) { + /* We only consider it for an elision if it's + * more than 1 component long. + */ + if(cur_len > 1 && cur_len > max_len) { + /* Found the new elision location. */ + max_len = cur_len; + max_index = cur_index; + } + + /* Reset the current range for the next range of zeros. */ + cur_index = -1; + cur_len = 0; + } + } + + *index = max_index; + *count = max_len; +} + +/* Removes all the leading and trailing white spaces or + * control characters from the URI and removes all control + * characters inside of the URI string. + */ +static BSTR pre_process_uri(LPCWSTR uri) { + BSTR ret; + DWORD len; + const WCHAR *start, *end; + WCHAR *buf, *ptr; + + len = lstrlenW(uri); + + start = uri; + /* Skip leading controls and whitespace. */ + while(iscntrlW(*start) || isspaceW(*start)) ++start; + + end = uri+len-1; + if(start == end) + /* URI consisted only of control/whitespace. */ + ret = SysAllocStringLen(NULL, 0); + else { + while(iscntrlW(*end) || isspaceW(*end)) --end; + + buf = heap_alloc(((end+1)-start)*sizeof(WCHAR)); + if(!buf) + return NULL; + + for(ptr = buf; start < end+1; ++start) { + if(!iscntrlW(*start)) + *ptr++ = *start; + } + + ret = SysAllocStringLen(buf, ptr-buf); + heap_free(buf); + } + + return ret; +} + +/* Converts the specified IPv4 address into an uint value. + * + * This function assumes that the IPv4 address has already been validated. + */ +static UINT ipv4toui(const WCHAR *ip, DWORD len) { + UINT ret = 0; + DWORD comp_value = 0; + const WCHAR *ptr; + + for(ptr = ip; ptr < ip+len; ++ptr) { + if(*ptr == '.') { + ret <<= 8; + ret += comp_value; + comp_value = 0; + } else + comp_value = comp_value*10 + (*ptr-'0'); + } + + ret <<= 8; + ret += comp_value; + + return ret; +} + /* Converts an IPv4 address in numerical form into it's fully qualified * string form. This function returns the number of characters written * to 'dest'. If 'dest' is NULL this function will return the number of @@ -266,6 +933,70 @@ static DWORD ui2ipv4(WCHAR *dest, UINT address) { return ret; } +/* Converts an h16 component (from an IPv6 address) into it's + * numerical value. + * + * This function assumes that the h16 component has already been validated. + */ +static USHORT h16tous(h16 component) { + DWORD i; + USHORT ret = 0; + + for(i = 0; i < component.len; ++i) { + ret <<= 4; + ret += hex_to_int(component.str[i]); + } + + return ret; +} + +/* Converts an IPv6 address into it's 128 bits (16 bytes) numerical value. + * + * This function assumes that the ipv6_address has already been validated. + */ +static BOOL ipv6_to_number(const ipv6_address *address, USHORT number[8]) { + DWORD i, cur_component = 0; + BOOL already_passed_elision = FALSE; + + for(i = 0; i < address->h16_count; ++i) { + if(address->elision) { + if(address->components[i].str > address->elision && !already_passed_elision) { + /* Means we just passed the elision and need to add it's values to + * 'number' before we do anything else. + */ + DWORD j = 0; + for(j = 0; j < address->elision_size; j+=2) + number[cur_component++] = 0; + + already_passed_elision = TRUE; + } + } + + number[cur_component++] = h16tous(address->components[i]); + } + + /* Case when the elision appears after the h16 components. */ + if(!already_passed_elision && address->elision) { + for(i = 0; i < address->elision_size; i+=2) + number[cur_component++] = 0; + already_passed_elision = TRUE; + } + + if(address->ipv4) { + UINT value = ipv4toui(address->ipv4, address->ipv4_len); + + if(cur_component != 6) { + ERR("(%p %p): Failed sanity check with %d\n", address, number, cur_component); + return FALSE; + } + + number[cur_component++] = (value >> 16) & 0xffff; + number[cur_component] = value & 0xffff; + } + + return TRUE; +} + /* Checks if the characters pointed to by 'ptr' are * a percent encoded data octet. * @@ -427,7 +1158,7 @@ static BOOL check_ipv4address(const WCHAR **ptr, BOOL strict) { * scheme = ALPHA *(ALPHA | NUM | '+' | '-' | '.') as defined by RFC 3896. * NOTE: Windows accepts a number as the first character of a scheme. */ -static BOOL parse_scheme_name(const WCHAR **ptr, parse_data *data) { +static BOOL parse_scheme_name(const WCHAR **ptr, parse_data *data, DWORD extras) { const WCHAR *start = *ptr; data->scheme = NULL; @@ -451,7 +1182,7 @@ static BOOL parse_scheme_name(const WCHAR **ptr, parse_data *data) { return FALSE; /* Schemes must end with a ':' */ - if(**ptr != ':') { + if(**ptr != ':' && !((extras & ALLOW_NULL_TERM_SCHEME) && !**ptr)) { *ptr = start; return FALSE; } @@ -504,7 +1235,7 @@ static BOOL parse_scheme_type(parse_data *data) { * * Returns TRUE if it was able to successfully parse the information. */ -static BOOL parse_scheme(const WCHAR **ptr, parse_data *data, DWORD flags) { +static BOOL parse_scheme(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras) { static const WCHAR fileW[] = {'f','i','l','e',0}; static const WCHAR wildcardW[] = {'*',0}; @@ -524,7 +1255,7 @@ static BOOL parse_scheme(const WCHAR **ptr, parse_data *data, DWORD flags) { ptr, data, flags); return FALSE; } - } else if(!parse_scheme_name(ptr, data)) { + } else if(!parse_scheme_name(ptr, data, extras)) { /* No Scheme was found, this means it could be: * a) an implicit Wildcard scheme * b) a relative URI @@ -556,6 +1287,68 @@ static BOOL parse_scheme(const WCHAR **ptr, parse_data *data, DWORD flags) { return TRUE; } +static BOOL parse_username(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras) { + data->username = *ptr; + + while(**ptr != ':' && **ptr != '@') { + if(**ptr == '%') { + if(!check_pct_encoded(ptr)) { + if(data->scheme_type != URL_SCHEME_UNKNOWN) { + *ptr = data->username; + data->username = NULL; + return FALSE; + } + } else + continue; + } else if(extras & ALLOW_NULL_TERM_USER_NAME && !**ptr) + break; + else if(is_auth_delim(**ptr, data->scheme_type != URL_SCHEME_UNKNOWN)) { + *ptr = data->username; + data->username = NULL; + return FALSE; + } + + ++(*ptr); + } + + data->username_len = *ptr - data->username; + return TRUE; +} + +static BOOL parse_password(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras) { + const WCHAR *start = *ptr; + + if(**ptr != ':') + return TRUE; + + ++(*ptr); + data->password = *ptr; + + while(**ptr != '@') { + if(**ptr == '%') { + if(!check_pct_encoded(ptr)) { + if(data->scheme_type != URL_SCHEME_UNKNOWN) { + *ptr = start; + data->password = NULL; + return FALSE; + } + } else + continue; + } else if(extras & ALLOW_NULL_TERM_PASSWORD && !**ptr) + break; + else if(is_auth_delim(**ptr, data->scheme_type != URL_SCHEME_UNKNOWN)) { + *ptr = start; + data->password = NULL; + return FALSE; + } + + ++(*ptr); + } + + data->password_len = *ptr - data->password; + return TRUE; +} + /* Parses the userinfo part of the URI (if it exists). The userinfo field of * a URI can consist of "username:password@", or just "username@". * @@ -564,7 +1357,7 @@ static BOOL parse_scheme(const WCHAR **ptr, parse_data *data, DWORD flags) { * * NOTES: * 1) If there is more than one ':' in the userinfo part of the URI Windows - * uses the first occurence of ':' to delimit the username and password + * uses the first occurrence of ':' to delimit the username and password * components. * * ex: @@ -576,48 +1369,82 @@ static BOOL parse_scheme(const WCHAR **ptr, parse_data *data, DWORD flags) { * a URI, as long as it's not an authority delimeter character set. */ static void parse_userinfo(const WCHAR **ptr, parse_data *data, DWORD flags) { - data->userinfo = *ptr; - data->userinfo_split = -1; + const WCHAR *start = *ptr; - while(**ptr != '@') { - if(**ptr == ':' && data->userinfo_split == -1) - data->userinfo_split = *ptr - data->userinfo; - else if(**ptr == '%') { - /* If it's a known scheme type, it has to be a valid percent - * encoded value. - */ - if(!check_pct_encoded(ptr)) { - if(data->scheme_type != URL_SCHEME_UNKNOWN) { - *ptr = data->userinfo; - data->userinfo = NULL; - data->userinfo_split = -1; + if(!parse_username(ptr, data, flags, 0)) { + TRACE("(%p %p %x): URI contained no userinfo.\n", ptr, data, flags); + return; + } - TRACE("(%p %p %x): URI contained no userinfo.\n", ptr, data, flags); - return; - } - } else - continue; - } else if(is_auth_delim(**ptr, data->scheme_type != URL_SCHEME_UNKNOWN)) - break; - - ++(*ptr); + if(!parse_password(ptr, data, flags, 0)) { + *ptr = start; + data->username = NULL; + data->username_len = 0; + TRACE("(%p %p %x): URI contained no userinfo.\n", ptr, data, flags); + return; } if(**ptr != '@') { - *ptr = data->userinfo; - data->userinfo = NULL; - data->userinfo_split = -1; + *ptr = start; + data->username = NULL; + data->username_len = 0; + data->password = NULL; + data->password_len = 0; TRACE("(%p %p %x): URI contained no userinfo.\n", ptr, data, flags); return; } - data->userinfo_len = *ptr - data->userinfo; - TRACE("(%p %p %x): Found userinfo=%s userinfo_len=%d split=%d.\n", ptr, data, flags, - debugstr_wn(data->userinfo, data->userinfo_len), data->userinfo_len, data->userinfo_split); + if(data->username) + TRACE("(%p %p %x): Found username %s len=%d.\n", ptr, data, flags, + debugstr_wn(data->username, data->username_len), data->username_len); + + if(data->password) + TRACE("(%p %p %x): Found password %s len=%d.\n", ptr, data, flags, + debugstr_wn(data->password, data->password_len), data->password_len); + ++(*ptr); } +/* Attempts to parse a port from the URI. + * + * NOTES: + * Windows seems to have a cap on what the maximum value + * for a port can be. The max value is USHORT_MAX. + * + * port = *DIGIT + */ +static BOOL parse_port(const WCHAR **ptr, parse_data *data, DWORD flags) { + UINT port = 0; + data->port = *ptr; + + while(!is_auth_delim(**ptr, data->scheme_type != URL_SCHEME_UNKNOWN)) { + if(!is_num(**ptr)) { + *ptr = data->port; + data->port = NULL; + return FALSE; + } + + port = port*10 + (**ptr-'0'); + + if(port > USHORT_MAX) { + *ptr = data->port; + data->port = NULL; + return FALSE; + } + + ++(*ptr); + } + + data->has_port = TRUE; + data->port_value = port; + data->port_len = *ptr - data->port; + + TRACE("(%p %p %x): Found port %s len=%d value=%u\n", ptr, data, flags, + debugstr_wn(data->port, data->port_len), data->port_len, data->port_value); + return TRUE; +} + /* Attempts to parse a IPv4 address from the URI. * * NOTES: @@ -650,7 +1477,15 @@ static BOOL parse_ipv4address(const WCHAR **ptr, parse_data *data, DWORD flags) /* Check if what we found is the only part of the host name (if it isn't * we don't have an IPv4 address). */ - if(!is_auth_delim(**ptr, !is_unknown) && **ptr != ':') { + if(**ptr == ':') { + ++(*ptr); + if(!parse_port(ptr, data, flags)) { + *ptr = data->host; + data->host = NULL; + return FALSE; + } + } else if(!is_auth_delim(**ptr, !is_unknown)) { + /* Found more data which belongs the host, so this isn't an IPv4. */ *ptr = data->host; data->host = NULL; data->has_implicit_ip = FALSE; @@ -659,24 +1494,394 @@ static BOOL parse_ipv4address(const WCHAR **ptr, parse_data *data, DWORD flags) data->host_len = *ptr - data->host; data->host_type = Uri_HOST_IPV4; + TRACE("(%p %p %x): IPv4 address found. host=%s host_len=%d host_type=%d\n", ptr, data, flags, debugstr_wn(data->host, data->host_len), data->host_len, data->host_type); return TRUE; } +/* Attempts to parse the reg-name from the URI. + * + * Because of the way Windows handles ':' this function also + * handles parsing the port. + * + * reg-name = *( unreserved / pct-encoded / sub-delims ) + * + * NOTE: + * Windows allows everything, but, the characters in "auth_delims" and ':' + * to appear in a reg-name, unless it's an unknown scheme type then ':' is + * allowed to appear (even if a valid port isn't after it). + * + * Windows doesn't like host names which start with '[' and end with ']' + * and don't contain a valid IP literal address in between them. + * + * On Windows if an '[' is encountered in the host name the ':' no longer + * counts as a delimiter until you reach the next ']' or an "authority delimeter". + * + * A reg-name CAN be empty. + */ +static BOOL parse_reg_name(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras) { + const BOOL has_start_bracket = **ptr == '['; + const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN; + BOOL inside_brackets = has_start_bracket; + BOOL ignore_col = extras & IGNORE_PORT_DELIMITER; + + /* We have to be careful with file schemes. */ + if(data->scheme_type == URL_SCHEME_FILE) { + /* This is because an implicit file scheme could be "C:\\test" and it + * would trick this function into thinking the host is "C", when after + * canonicalization the host would end up being an empty string. A drive + * path can also have a '|' instead of a ':' after the drive letter. + */ + if(is_drive_path(*ptr)) { + /* Regular old drive paths don't have a host type (or host name). */ + data->host_type = Uri_HOST_UNKNOWN; + data->host = *ptr; + data->host_len = 0; + return TRUE; + } else if(is_unc_path(*ptr)) + /* Skip past the "\\" of a UNC path. */ + *ptr += 2; + } + + data->host = *ptr; + + while(!is_auth_delim(**ptr, known_scheme)) { + if(**ptr == ':' && !ignore_col) { + /* We can ignore ':' if were inside brackets.*/ + if(!inside_brackets) { + const WCHAR *tmp = (*ptr)++; + + /* Attempt to parse the port. */ + if(!parse_port(ptr, data, flags)) { + /* Windows expects there to be a valid port for known scheme types. */ + if(data->scheme_type != URL_SCHEME_UNKNOWN) { + *ptr = data->host; + data->host = NULL; + TRACE("(%p %p %x %x): Expected valid port\n", ptr, data, flags, extras); + return FALSE; + } else + /* Windows gives up on trying to parse a port when it + * encounters 1 invalid port. + */ + ignore_col = TRUE; + } else { + data->host_len = tmp - data->host; + break; + } + } + } else if(**ptr == '%' && known_scheme) { + /* Has to be a legit % encoded value. */ + if(!check_pct_encoded(ptr)) { + *ptr = data->host; + data->host = NULL; + return FALSE; + } else + continue; + } else if(**ptr == ']') + inside_brackets = FALSE; + else if(**ptr == '[') + inside_brackets = TRUE; + + ++(*ptr); + } + + if(has_start_bracket) { + /* Make sure the last character of the host wasn't a ']'. */ + if(*(*ptr-1) == ']') { + TRACE("(%p %p %x %x): Expected an IP literal inside of the host\n", + ptr, data, flags, extras); + *ptr = data->host; + data->host = NULL; + return FALSE; + } + } + + /* Don't overwrite our length if we found a port earlier. */ + if(!data->port) + data->host_len = *ptr - data->host; + + /* If the host is empty, then it's an unknown host type. */ + if(data->host_len == 0) + data->host_type = Uri_HOST_UNKNOWN; + else + data->host_type = Uri_HOST_DNS; + + TRACE("(%p %p %x %x): Parsed reg-name. host=%s len=%d\n", ptr, data, flags, extras, + debugstr_wn(data->host, data->host_len), data->host_len); + return TRUE; +} + +/* Attempts to parse an IPv6 address out of the URI. + * + * IPv6address = 6( h16 ":" ) ls32 + * / "::" 5( h16 ":" ) ls32 + * / [ h16 ] "::" 4( h16 ":" ) ls32 + * / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32 + * / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32 + * / [ *3( h16 ":" ) h16 ] "::" h16 ":" ls32 + * / [ *4( h16 ":" ) h16 ] "::" ls32 + * / [ *5( h16 ":" ) h16 ] "::" h16 + * / [ *6( h16 ":" ) h16 ] "::" + * + * ls32 = ( h16 ":" h16 ) / IPv4address + * ; least-significant 32 bits of address. + * + * h16 = 1*4HEXDIG + * ; 16 bits of address represented in hexadecimal. + * + * Modeled after google-url's 'DoParseIPv6' function. + */ +static BOOL parse_ipv6address(const WCHAR **ptr, parse_data *data, DWORD flags) { + const WCHAR *start, *cur_start; + ipv6_address ip; + + start = cur_start = *ptr; + memset(&ip, 0, sizeof(ipv6_address)); + + for(;; ++(*ptr)) { + /* Check if we're on the last character of the host. */ + BOOL is_end = (is_auth_delim(**ptr, data->scheme_type != URL_SCHEME_UNKNOWN) + || **ptr == ']'); + + BOOL is_split = (**ptr == ':'); + BOOL is_elision = (is_split && !is_end && *(*ptr+1) == ':'); + + /* Check if we're at the end of a component, or + * if we're at the end of the IPv6 address. + */ + if(is_split || is_end) { + DWORD cur_len = 0; + + cur_len = *ptr - cur_start; + + /* h16 can't have a length > 4. */ + if(cur_len > 4) { + *ptr = start; + + TRACE("(%p %p %x): h16 component to long.\n", + ptr, data, flags); + return FALSE; + } + + if(cur_len == 0) { + /* An h16 component can't have the length of 0 unless + * the elision is at the beginning of the address, or + * at the end of the address. + */ + if(!((*ptr == start && is_elision) || + (is_end && (*ptr-2) == ip.elision))) { + *ptr = start; + TRACE("(%p %p %x): IPv6 component cannot have a length of 0.\n", + ptr, data, flags); + return FALSE; + } + } + + if(cur_len > 0) { + /* An IPv6 address can have no more than 8 h16 components. */ + if(ip.h16_count >= 8) { + *ptr = start; + TRACE("(%p %p %x): Not a IPv6 address, to many h16 components.\n", + ptr, data, flags); + return FALSE; + } + + ip.components[ip.h16_count].str = cur_start; + ip.components[ip.h16_count].len = cur_len; + + TRACE("(%p %p %x): Found h16 component %s, len=%d, h16_count=%d\n", + ptr, data, flags, debugstr_wn(cur_start, cur_len), cur_len, + ip.h16_count); + ++ip.h16_count; + } + } + + if(is_end) + break; + + if(is_elision) { + /* A IPv6 address can only have 1 elision ('::'). */ + if(ip.elision) { + *ptr = start; + + TRACE("(%p %p %x): IPv6 address cannot have 2 elisions.\n", + ptr, data, flags); + return FALSE; + } + + ip.elision = *ptr; + ++(*ptr); + } + + if(is_split) + cur_start = *ptr+1; + else { + if(!check_ipv4address(ptr, TRUE)) { + if(!is_hexdigit(**ptr)) { + /* Not a valid character for an IPv6 address. */ + *ptr = start; + return FALSE; + } + } else { + /* Found an IPv4 address. */ + ip.ipv4 = cur_start; + ip.ipv4_len = *ptr - cur_start; + + TRACE("(%p %p %x): Found an attached IPv4 address %s len=%d.\n", + ptr, data, flags, debugstr_wn(ip.ipv4, ip.ipv4_len), + ip.ipv4_len); + + /* IPv4 addresses can only appear at the end of a IPv6. */ + break; + } + } + } + + compute_ipv6_comps_size(&ip); + + /* Make sure the IPv6 address adds up to 16 bytes. */ + if(ip.components_size + ip.elision_size != 16) { + *ptr = start; + TRACE("(%p %p %x): Invalid IPv6 address, did not add up to 16 bytes.\n", + ptr, data, flags); + return FALSE; + } + + if(ip.elision_size == 2) { + /* For some reason on Windows if an elision that represents + * only 1 h16 component is encountered at the very begin or + * end of an IPv6 address, Windows does not consider it a + * valid IPv6 address. + * + * Ex: [::2:3:4:5:6:7] is not valid, even though the sum + * of all the components == 128bits. + */ + if(ip.elision < ip.components[0].str || + ip.elision > ip.components[ip.h16_count-1].str) { + *ptr = start; + TRACE("(%p %p %x): Invalid IPv6 address. Detected elision of 2 bytes at the beginning or end of the address.\n", + ptr, data, flags); + return FALSE; + } + } + + data->host_type = Uri_HOST_IPV6; + data->has_ipv6 = TRUE; + data->ipv6_address = ip; + + TRACE("(%p %p %x): Found valid IPv6 literal %s len=%d\n", + ptr, data, flags, debugstr_wn(start, *ptr-start), + *ptr-start); + return TRUE; +} + +/* IPvFuture = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" ) */ +static BOOL parse_ipvfuture(const WCHAR **ptr, parse_data *data, DWORD flags) { + const WCHAR *start = *ptr; + + /* IPvFuture has to start with a 'v' or 'V'. */ + if(**ptr != 'v' && **ptr != 'V') + return FALSE; + + /* Following the v there must be at least 1 hex digit. */ + ++(*ptr); + if(!is_hexdigit(**ptr)) { + *ptr = start; + return FALSE; + } + + ++(*ptr); + while(is_hexdigit(**ptr)) + ++(*ptr); + + /* End of the hexdigit sequence must be a '.' */ + if(**ptr != '.') { + *ptr = start; + return FALSE; + } + + ++(*ptr); + if(!is_unreserved(**ptr) && !is_subdelim(**ptr) && **ptr != ':') { + *ptr = start; + return FALSE; + } + + ++(*ptr); + while(is_unreserved(**ptr) || is_subdelim(**ptr) || **ptr == ':') + ++(*ptr); + + data->host_type = Uri_HOST_UNKNOWN; + + TRACE("(%p %p %x): Parsed IPvFuture address %s len=%d\n", ptr, data, flags, + debugstr_wn(start, *ptr-start), *ptr-start); + + return TRUE; +} + +/* IP-literal = "[" ( IPv6address / IPvFuture ) "]" */ +static BOOL parse_ip_literal(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras) { + data->host = *ptr; + + if(**ptr != '[' && !(extras & ALLOW_BRACKETLESS_IP_LITERAL)) { + data->host = NULL; + return FALSE; + } else if(**ptr == '[') + ++(*ptr); + + if(!parse_ipv6address(ptr, data, flags)) { + if(extras & SKIP_IP_FUTURE_CHECK || !parse_ipvfuture(ptr, data, flags)) { + *ptr = data->host; + data->host = NULL; + return FALSE; + } + } + + if(**ptr != ']' && !(extras & ALLOW_BRACKETLESS_IP_LITERAL)) { + *ptr = data->host; + data->host = NULL; + return FALSE; + } else if(!**ptr && extras & ALLOW_BRACKETLESS_IP_LITERAL) { + /* The IP literal didn't contain brackets and was followed by + * a NULL terminator, so no reason to even check the port. + */ + data->host_len = *ptr - data->host; + return TRUE; + } + + ++(*ptr); + if(**ptr == ':') { + ++(*ptr); + /* If a valid port is not found, then let it trickle down to + * parse_reg_name. + */ + if(!parse_port(ptr, data, flags)) { + *ptr = data->host; + data->host = NULL; + return FALSE; + } + } else + data->host_len = *ptr - data->host; + + return TRUE; +} + /* Parses the host information from the URI. * * host = IP-literal / IPv4address / reg-name */ -static BOOL parse_host(const WCHAR **ptr, parse_data *data, DWORD flags) { - if(!parse_ipv4address(ptr, data, flags)) { - WARN("(%p %p %x): Only IPv4 parsing is implemented so far.\n", ptr, data, flags); - data->host_type = Uri_HOST_UNKNOWN; +static BOOL parse_host(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras) { + if(!parse_ip_literal(ptr, data, flags, extras)) { + if(!parse_ipv4address(ptr, data, flags)) { + if(!parse_reg_name(ptr, data, flags, extras)) { + TRACE("(%p %p %x %x): Malformed URI, Unknown host type.\n", + ptr, data, flags, extras); + return FALSE; + } + } } - /* TODO parse IP-Literal / reg-name. */ - return TRUE; } @@ -687,12 +1892,126 @@ static BOOL parse_host(const WCHAR **ptr, parse_data *data, DWORD flags) { static BOOL parse_authority(const WCHAR **ptr, parse_data *data, DWORD flags) { parse_userinfo(ptr, data, flags); - if(!parse_host(ptr, data, flags)) + /* Parsing the port will happen during one of the host parsing + * routines (if the URI has a port). + */ + if(!parse_host(ptr, data, flags, 0)) return FALSE; return TRUE; } +/* Attempts to parse the path information of a hierarchical URI. */ +static BOOL parse_path_hierarchical(const WCHAR **ptr, parse_data *data, DWORD flags) { + const WCHAR *start = *ptr; + static const WCHAR slash[] = {'/',0}; + const BOOL is_file = data->scheme_type == URL_SCHEME_FILE; + + if(is_path_delim(**ptr)) { + if(data->scheme_type == URL_SCHEME_WILDCARD) { + /* Wildcard schemes don't get a '/' attached if their path is + * empty. + */ + data->path = NULL; + data->path_len = 0; + } else if(!(flags & Uri_CREATE_NO_CANONICALIZE)) { + /* If the path component is empty, then a '/' is added. */ + data->path = slash; + data->path_len = 1; + } + } else { + while(!is_path_delim(**ptr)) { + if(**ptr == '%' && data->scheme_type != URL_SCHEME_UNKNOWN && !is_file) { + if(!check_pct_encoded(ptr)) { + *ptr = start; + return FALSE; + } else + continue; + } else if(is_forbidden_dos_path_char(**ptr) && is_file && + (flags & Uri_CREATE_FILE_USE_DOS_PATH)) { + /* File schemes with USE_DOS_PATH set aren't allowed to have + * a '<' or '>' or '\"' appear in them. + */ + *ptr = start; + return FALSE; + } else if(**ptr == '\\') { + /* Not allowed to have a backslash if NO_CANONICALIZE is set + * and the scheme is known type (but not a file scheme). + */ + if(flags & Uri_CREATE_NO_CANONICALIZE) { + if(data->scheme_type != URL_SCHEME_FILE && + data->scheme_type != URL_SCHEME_UNKNOWN) { + *ptr = start; + return FALSE; + } + } + } + + ++(*ptr); + } + + /* The only time a URI doesn't have a path is when + * the NO_CANONICALIZE flag is set and the raw URI + * didn't contain one. + */ + if(*ptr == start) { + data->path = NULL; + data->path_len = 0; + } else { + data->path = start; + data->path_len = *ptr - start; + } + } + + if(data->path) + TRACE("(%p %p %x): Parsed path %s len=%d\n", ptr, data, flags, + debugstr_wn(data->path, data->path_len), data->path_len); + else + TRACE("(%p %p %x): The URI contained no path\n", ptr, data, flags); + + return TRUE; +} + +/* Parses the path of a opaque URI (much less strict then the parser + * for a hierarchical URI). + * + * NOTE: + * Windows allows invalid % encoded data to appear in opaque URI paths + * for unknown scheme types. + * + * File schemes with USE_DOS_PATH set aren't allowed to have '<', '>', or '\"' + * appear in them. + */ +static BOOL parse_path_opaque(const WCHAR **ptr, parse_data *data, DWORD flags) { + const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN; + const BOOL is_file = data->scheme_type == URL_SCHEME_FILE; + + data->path = *ptr; + + while(!is_path_delim(**ptr)) { + if(**ptr == '%' && known_scheme) { + if(!check_pct_encoded(ptr)) { + *ptr = data->path; + data->path = NULL; + return FALSE; + } else + continue; + } else if(is_forbidden_dos_path_char(**ptr) && is_file && + (flags & Uri_CREATE_FILE_USE_DOS_PATH)) { + *ptr = data->path; + data->path = NULL; + return FALSE; + } + + ++(*ptr); + } + + data->path_len = *ptr - data->path; + TRACE("(%p %p %x): Parsed opaque URI path %s len=%d\n", ptr, data, flags, + debugstr_wn(data->path, data->path_len), data->path_len); + return TRUE; +} + /* Determines how the URI should be parsed after the scheme information. * * If the scheme is followed, by "//" then, it is treated as an hierarchical URI @@ -717,17 +2036,10 @@ static BOOL parse_authority(const WCHAR **ptr, parse_data *data, DWORD flags) { * (per MSDN documentation). */ static BOOL parse_hierpart(const WCHAR **ptr, parse_data *data, DWORD flags) { - /* Checks if the authority information needs to be parsed. - * - * Relative URI's aren't hierarchical URI's, but, they could trick - * "check_hierarchical" into thinking it is, so we need to explicitly - * make sure it's not relative. Also, if the URI is an implicit file - * scheme it might not contain a "//", but, it's considered hierarchical - * anyways. Wildcard Schemes are always considered hierarchical - */ - if(data->scheme_type == URL_SCHEME_WILDCARD || - data->scheme_type == URL_SCHEME_FILE || - (!data->is_relative && check_hierarchical(ptr))) { + const WCHAR *start = *ptr; + + /* Checks if the authority information needs to be parsed. */ + if(is_hierarchical_uri(ptr, data)) { /* Only treat it as a hierarchical URI if the scheme_type is known or * the Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES flag is not set. */ @@ -740,8 +2052,12 @@ static BOOL parse_hierpart(const WCHAR **ptr, parse_data *data, DWORD flags) { if(!parse_authority(ptr, data, flags)) return FALSE; - return TRUE; - } + return parse_path_hierarchical(ptr, data, flags); + } else + /* Reset ptr to it's starting position so opaque path parsing + * begins at the correct location. + */ + *ptr = start; } /* If it reaches here, then the URI will be treated as an opaque @@ -751,7 +2067,87 @@ static BOOL parse_hierpart(const WCHAR **ptr, parse_data *data, DWORD flags) { TRACE("(%p %p %x): Treating URI as an opaque URI.\n", ptr, data, flags); data->is_opaque = TRUE; - /* TODO: Handle opaque URI's, parse path. */ + if(!parse_path_opaque(ptr, data, flags)) + return FALSE; + + return TRUE; +} + +/* Attempts to parse the query string from the URI. + * + * NOTES: + * If NO_DECODE_EXTRA_INFO flag is set, then invalid percent encoded + * data is allowed appear in the query string. For unknown scheme types + * invalid percent encoded data is allowed to appear reguardless. + */ +static BOOL parse_query(const WCHAR **ptr, parse_data *data, DWORD flags) { + const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN; + + if(**ptr != '?') { + TRACE("(%p %p %x): URI didn't contain a query string.\n", ptr, data, flags); + return TRUE; + } + + data->query = *ptr; + + ++(*ptr); + while(**ptr && **ptr != '#') { + if(**ptr == '%' && known_scheme && + !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) { + if(!check_pct_encoded(ptr)) { + *ptr = data->query; + data->query = NULL; + return FALSE; + } else + continue; + } + + ++(*ptr); + } + + data->query_len = *ptr - data->query; + + TRACE("(%p %p %x): Parsed query string %s len=%d\n", ptr, data, flags, + debugstr_wn(data->query, data->query_len), data->query_len); + return TRUE; +} + +/* Attempts to parse the fragment from the URI. + * + * NOTES: + * If NO_DECODE_EXTRA_INFO flag is set, then invalid percent encoded + * data is allowed appear in the query string. For unknown scheme types + * invalid percent encoded data is allowed to appear reguardless. + */ +static BOOL parse_fragment(const WCHAR **ptr, parse_data *data, DWORD flags) { + const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN; + + if(**ptr != '#') { + TRACE("(%p %p %x): URI didn't contain a fragment.\n", ptr, data, flags); + return TRUE; + } + + data->fragment = *ptr; + + ++(*ptr); + while(**ptr) { + if(**ptr == '%' && known_scheme && + !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) { + if(!check_pct_encoded(ptr)) { + *ptr = data->fragment; + data->fragment = NULL; + return FALSE; + } else + continue; + } + + ++(*ptr); + } + + data->fragment_len = *ptr - data->fragment; + + TRACE("(%p %p %x): Parsed fragment %s len=%d\n", ptr, data, flags, + debugstr_wn(data->fragment, data->fragment_len), data->fragment_len); return TRUE; } @@ -769,16 +2165,128 @@ static BOOL parse_uri(parse_data *data, DWORD flags) { TRACE("(%p %x): BEGINNING TO PARSE URI %s.\n", data, flags, debugstr_w(data->uri)); - if(!parse_scheme(pptr, data, flags)) + if(!parse_scheme(pptr, data, flags, 0)) return FALSE; if(!parse_hierpart(pptr, data, flags)) return FALSE; + if(!parse_query(pptr, data, flags)) + return FALSE; + + if(!parse_fragment(pptr, data, flags)) + return FALSE; + TRACE("(%p %x): FINISHED PARSING URI.\n", data, flags); return TRUE; } +static BOOL canonicalize_username(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) { + const WCHAR *ptr; + + if(!data->username) { + uri->userinfo_start = -1; + return TRUE; + } + + uri->userinfo_start = uri->canon_len; + for(ptr = data->username; ptr < data->username+data->username_len; ++ptr) { + if(*ptr == '%') { + /* Only decode % encoded values for known scheme types. */ + if(data->scheme_type != URL_SCHEME_UNKNOWN) { + /* See if the value really needs decoded. */ + WCHAR val = decode_pct_val(ptr); + if(is_unreserved(val)) { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = val; + + ++uri->canon_len; + + /* Move pass the hex characters. */ + ptr += 2; + continue; + } + } + } else if(!is_reserved(*ptr) && !is_unreserved(*ptr) && *ptr != '\\') { + /* Only percent encode forbidden characters if the NO_ENCODE_FORBIDDEN_CHARACTERS flag + * is NOT set. + */ + if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS)) { + if(!computeOnly) + pct_encode_val(*ptr, uri->canon_uri + uri->canon_len); + + uri->canon_len += 3; + continue; + } + } + + if(!computeOnly) + /* Nothing special, so just copy the character over. */ + uri->canon_uri[uri->canon_len] = *ptr; + ++uri->canon_len; + } + + return TRUE; +} + +static BOOL canonicalize_password(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) { + const WCHAR *ptr; + + if(!data->password) { + uri->userinfo_split = -1; + return TRUE; + } + + if(uri->userinfo_start == -1) + /* Has a password, but, doesn't have a username. */ + uri->userinfo_start = uri->canon_len; + + uri->userinfo_split = uri->canon_len - uri->userinfo_start; + + /* Add the ':' to the userinfo component. */ + if(!computeOnly) + uri->canon_uri[uri->canon_len] = ':'; + ++uri->canon_len; + + for(ptr = data->password; ptr < data->password+data->password_len; ++ptr) { + if(*ptr == '%') { + /* Only decode % encoded values for known scheme types. */ + if(data->scheme_type != URL_SCHEME_UNKNOWN) { + /* See if the value really needs decoded. */ + WCHAR val = decode_pct_val(ptr); + if(is_unreserved(val)) { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = val; + + ++uri->canon_len; + + /* Move pass the hex characters. */ + ptr += 2; + continue; + } + } + } else if(!is_reserved(*ptr) && !is_unreserved(*ptr) && *ptr != '\\') { + /* Only percent encode forbidden characters if the NO_ENCODE_FORBIDDEN_CHARACTERS flag + * is NOT set. + */ + if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS)) { + if(!computeOnly) + pct_encode_val(*ptr, uri->canon_uri + uri->canon_len); + + uri->canon_len += 3; + continue; + } + } + + if(!computeOnly) + /* Nothing special, so just copy the character over. */ + uri->canon_uri[uri->canon_len] = *ptr; + ++uri->canon_len; + } + + return TRUE; +} + /* Canonicalizes the userinfo of the URI represented by the parse_data. * * Canonicalization of the userinfo is a simple process. If there are any percent @@ -788,59 +2296,18 @@ static BOOL parse_uri(parse_data *data, DWORD flags) { * change. */ static BOOL canonicalize_userinfo(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) { - DWORD i = 0; - uri->userinfo_start = uri->userinfo_split = -1; uri->userinfo_len = 0; - if(!data->userinfo) + if(!data->username && !data->password) /* URI doesn't have userinfo, so nothing to do here. */ return TRUE; - uri->userinfo_start = uri->canon_len; + if(!canonicalize_username(data, uri, flags, computeOnly)) + return FALSE; - while(i < data->userinfo_len) { - if(data->userinfo[i] == ':' && uri->userinfo_split == -1) - /* Windows only considers the first ':' as the delimiter. */ - uri->userinfo_split = uri->canon_len - uri->userinfo_start; - else if(data->userinfo[i] == '%') { - /* Only decode % encoded values for known scheme types. */ - if(data->scheme_type != URL_SCHEME_UNKNOWN) { - /* See if the value really needs decoded. */ - WCHAR val = decode_pct_val(data->userinfo + i); - if(is_unreserved(val)) { - if(!computeOnly) - uri->canon_uri[uri->canon_len] = val; - - ++uri->canon_len; - - /* Move pass the hex characters. */ - i += 3; - continue; - } - } - } else if(!is_reserved(data->userinfo[i]) && !is_unreserved(data->userinfo[i]) && - data->userinfo[i] != '\\') { - /* Only percent encode forbidden characters if the NO_ENCODE_FORBIDDEN_CHARACTERS flag - * is NOT set. - */ - if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS)) { - if(!computeOnly) - pct_encode_val(data->userinfo[i], uri->canon_uri + uri->canon_len); - - uri->canon_len += 3; - ++i; - continue; - } - } - - if(!computeOnly) - /* Nothing special, so just copy the character over. */ - uri->canon_uri[uri->canon_len] = data->userinfo[i]; - - ++uri->canon_len; - ++i; - } + if(!canonicalize_password(data, uri, flags, computeOnly)) + return FALSE; uri->userinfo_len = uri->canon_len - uri->userinfo_start; if(!computeOnly) @@ -851,8 +2318,112 @@ static BOOL canonicalize_userinfo(const parse_data *data, Uri *uri, DWORD flags, /* Now insert the '@' after the userinfo. */ if(!computeOnly) uri->canon_uri[uri->canon_len] = '@'; - ++uri->canon_len; + + return TRUE; +} + +/* Attempts to canonicalize a reg_name. + * + * Things that happen: + * 1) If Uri_CREATE_NO_CANONICALIZE flag is not set, then the reg_name is + * lower cased. Unless it's an unknown scheme type, which case it's + * no lower cased reguardless. + * + * 2) Unreserved % encoded characters are decoded for known + * scheme types. + * + * 3) Forbidden characters are % encoded as long as + * Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS flag is not set and + * it isn't an unknown scheme type. + * + * 4) If it's a file scheme and the host is "localhost" it's removed. + */ +static BOOL canonicalize_reg_name(const parse_data *data, Uri *uri, + DWORD flags, BOOL computeOnly) { + static const WCHAR localhostW[] = + {'l','o','c','a','l','h','o','s','t',0}; + const WCHAR *ptr; + const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN; + + uri->host_start = uri->canon_len; + + if(data->scheme_type == URL_SCHEME_FILE && + data->host_len == lstrlenW(localhostW)) { + if(!StrCmpNIW(data->host, localhostW, data->host_len)) { + uri->host_start = -1; + uri->host_len = 0; + uri->host_type = Uri_HOST_UNKNOWN; + return TRUE; + } + } + + for(ptr = data->host; ptr < data->host+data->host_len; ++ptr) { + if(*ptr == '%' && known_scheme) { + WCHAR val = decode_pct_val(ptr); + if(is_unreserved(val)) { + /* If NO_CANONICALZE is not set, then windows lower cases the + * decoded value. + */ + if(!(flags & Uri_CREATE_NO_CANONICALIZE) && isupperW(val)) { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = tolowerW(val); + } else { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = val; + } + ++uri->canon_len; + + /* Skip past the % encoded character. */ + ptr += 2; + continue; + } else { + /* Just copy the % over. */ + if(!computeOnly) + uri->canon_uri[uri->canon_len] = *ptr; + ++uri->canon_len; + } + } else if(*ptr == '\\') { + /* Only unknown scheme types could have made it here with a '\\' in the host name. */ + if(!computeOnly) + uri->canon_uri[uri->canon_len] = *ptr; + ++uri->canon_len; + } else if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS) && + !is_unreserved(*ptr) && !is_reserved(*ptr) && known_scheme) { + if(!computeOnly) { + pct_encode_val(*ptr, uri->canon_uri+uri->canon_len); + + /* The percent encoded value gets lower cased also. */ + if(!(flags & Uri_CREATE_NO_CANONICALIZE)) { + uri->canon_uri[uri->canon_len+1] = tolowerW(uri->canon_uri[uri->canon_len+1]); + uri->canon_uri[uri->canon_len+2] = tolowerW(uri->canon_uri[uri->canon_len+2]); + } + } + + uri->canon_len += 3; + } else { + if(!computeOnly) { + if(!(flags & Uri_CREATE_NO_CANONICALIZE) && known_scheme) + uri->canon_uri[uri->canon_len] = tolowerW(*ptr); + else + uri->canon_uri[uri->canon_len] = *ptr; + } + + ++uri->canon_len; + } + } + + uri->host_len = uri->canon_len - uri->host_start; + + if(!computeOnly) + TRACE("(%p %p %x %d): Canonicalize reg_name=%s len=%d\n", data, uri, flags, + computeOnly, debugstr_wn(uri->canon_uri+uri->host_start, uri->host_len), + uri->host_len); + + if(!computeOnly) + find_domain_name(uri->canon_uri+uri->host_start, uri->host_len, + &(uri->domain_offset)); + return TRUE; } @@ -980,37 +2551,557 @@ static BOOL canonicalize_ipv4address(const parse_data *data, Uri *uri, DWORD fla return TRUE; } +/* Attempts to canonicalize the IPv6 address of the URI. + * + * Multiple things happen during the canonicalization of an IPv6 address: + * 1) Any leading zero's in an h16 component are removed. + * Ex: [0001:0022::] -> [1:22::] + * + * 2) The longest sequence of zero h16 components are compressed + * into a "::" (elision). If there's a tie, the first is choosen. + * + * Ex: [0:0:0:0:1:6:7:8] -> [::1:6:7:8] + * [0:0:0:0:1:2::] -> [::1:2:0:0] + * [0:0:1:2:0:0:7:8] -> [::1:2:0:0:7:8] + * + * 3) If an IPv4 address is attached to the IPv6 address, it's + * also normalized. + * Ex: [::001.002.022.000] -> [::1.2.22.0] + * + * 4) If an elision is present, but, only represents 1 h16 component + * it's expanded. + * + * Ex: [1::2:3:4:5:6:7] -> [1:0:2:3:4:5:6:7] + * + * 5) If the IPv6 address contains an IPv4 address and there exists + * at least 1 non-zero h16 component the IPv4 address is converted + * into two h16 components, otherwise it's normalized and kept as is. + * + * Ex: [::192.200.003.4] -> [::192.200.3.4] + * [ffff::192.200.003.4] -> [ffff::c0c8:3041] + * + * NOTE: + * For unknown scheme types Windows simply copies the address over without any + * changes. + * + * IPv4 address can be included in an elision if all its components are 0's. + */ +static BOOL canonicalize_ipv6address(const parse_data *data, Uri *uri, + DWORD flags, BOOL computeOnly) { + uri->host_start = uri->canon_len; + + if(data->scheme_type == URL_SCHEME_UNKNOWN) { + if(!computeOnly) + memcpy(uri->canon_uri+uri->canon_len, data->host, data->host_len*sizeof(WCHAR)); + uri->canon_len += data->host_len; + } else { + USHORT values[8]; + INT elision_start; + DWORD i, elision_len; + + if(!ipv6_to_number(&(data->ipv6_address), values)) { + TRACE("(%p %p %x %d): Failed to compute numerical value for IPv6 address.\n", + data, uri, flags, computeOnly); + return FALSE; + } + + if(!computeOnly) + uri->canon_uri[uri->canon_len] = '['; + ++uri->canon_len; + + /* Find where the elision should occur (if any). */ + compute_elision_location(&(data->ipv6_address), values, &elision_start, &elision_len); + + TRACE("%p %p %x %d): Elision starts at %d, len=%u\n", data, uri, flags, + computeOnly, elision_start, elision_len); + + for(i = 0; i < 8; ++i) { + BOOL in_elision = (elision_start > -1 && i >= elision_start && + i < elision_start+elision_len); + BOOL do_ipv4 = (i == 6 && data->ipv6_address.ipv4 && !in_elision && + data->ipv6_address.h16_count == 0); + + if(i == elision_start) { + if(!computeOnly) { + uri->canon_uri[uri->canon_len] = ':'; + uri->canon_uri[uri->canon_len+1] = ':'; + } + uri->canon_len += 2; + } + + /* We can ignore the current component if we're in the elision. */ + if(in_elision) + continue; + + /* We only add a ':' if we're not at i == 0, or when we're at + * the very end of elision range since the ':' colon was handled + * earlier. Otherwise we would end up with ":::" after elision. + */ + if(i != 0 && !(elision_start > -1 && i == elision_start+elision_len)) { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = ':'; + ++uri->canon_len; + } + + if(do_ipv4) { + UINT val; + DWORD len; + + /* Combine the two parts of the IPv4 address values. */ + val = values[i]; + val <<= 16; + val += values[i+1]; + + if(!computeOnly) + len = ui2ipv4(uri->canon_uri+uri->canon_len, val); + else + len = ui2ipv4(NULL, val); + + uri->canon_len += len; + ++i; + } else { + /* Write a regular h16 component to the URI. */ + + /* Short circuit for the trivial case. */ + if(values[i] == 0) { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = '0'; + ++uri->canon_len; + } else { + static const WCHAR formatW[] = {'%','x',0}; + + if(!computeOnly) + uri->canon_len += sprintfW(uri->canon_uri+uri->canon_len, + formatW, values[i]); + else { + WCHAR tmp[5]; + uri->canon_len += sprintfW(tmp, formatW, values[i]); + } + } + } + } + + /* Add the closing ']'. */ + if(!computeOnly) + uri->canon_uri[uri->canon_len] = ']'; + ++uri->canon_len; + } + + uri->host_len = uri->canon_len - uri->host_start; + + if(!computeOnly) + TRACE("(%p %p %x %d): Canonicalized IPv6 address %s, len=%d\n", data, uri, flags, + computeOnly, debugstr_wn(uri->canon_uri+uri->host_start, uri->host_len), + uri->host_len); + + return TRUE; +} + +/* Attempts to canonicalize the host of the URI (if any). */ static BOOL canonicalize_host(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) { uri->host_start = -1; uri->host_len = 0; + uri->domain_offset = -1; if(data->host) { switch(data->host_type) { + case Uri_HOST_DNS: + uri->host_type = Uri_HOST_DNS; + if(!canonicalize_reg_name(data, uri, flags, computeOnly)) + return FALSE; + + break; case Uri_HOST_IPV4: uri->host_type = Uri_HOST_IPV4; if(!canonicalize_ipv4address(data, uri, flags, computeOnly)) return FALSE; + break; + case Uri_HOST_IPV6: + if(!canonicalize_ipv6address(data, uri, flags, computeOnly)) + return FALSE; + + uri->host_type = Uri_HOST_IPV6; + break; + case Uri_HOST_UNKNOWN: + if(data->host_len > 0 || data->scheme_type != URL_SCHEME_FILE) { + uri->host_start = uri->canon_len; + + /* Nothing happens to unknown host types. */ + if(!computeOnly) + memcpy(uri->canon_uri+uri->canon_len, data->host, data->host_len*sizeof(WCHAR)); + uri->canon_len += data->host_len; + uri->host_len = data->host_len; + } + + uri->host_type = Uri_HOST_UNKNOWN; break; default: - WARN("(%p %p %x %d): Canonicalization not supported yet\n", data, - uri, flags, computeOnly); + FIXME("(%p %p %x %d): Canonicalization for host type %d not supported.\n", data, + uri, flags, computeOnly, data->host_type); + return FALSE; } } return TRUE; } +static BOOL canonicalize_port(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) { + BOOL has_default_port = FALSE; + USHORT default_port = 0; + DWORD i; + + uri->has_port = FALSE; + + /* Check if the scheme has a default port. */ + for(i = 0; i < sizeof(default_ports)/sizeof(default_ports[0]); ++i) { + if(default_ports[i].scheme == data->scheme_type) { + has_default_port = TRUE; + default_port = default_ports[i].port; + break; + } + } + + if(data->port || has_default_port) + uri->has_port = TRUE; + + /* Possible cases: + * 1) Has a port which is the default port. + * 2) Has a port (not the default). + * 3) Doesn't have a port, but, scheme has a default port. + * 4) No port. + */ + if(has_default_port && data->port && data->port_value == default_port) { + /* If it's the default port and this flag isn't set, don't do anything. */ + if(flags & Uri_CREATE_NO_CANONICALIZE) { + /* Copy the original port over. */ + if(!computeOnly) { + uri->canon_uri[uri->canon_len] = ':'; + memcpy(uri->canon_uri+uri->canon_len+1, data->port, data->port_len*sizeof(WCHAR)); + } + uri->canon_len += data->port_len+1; + } + + uri->port = default_port; + } else if(data->port) { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = ':'; + ++uri->canon_len; + + if(flags & Uri_CREATE_NO_CANONICALIZE) { + /* Copy the original over without changes. */ + if(!computeOnly) + memcpy(uri->canon_uri+uri->canon_len, data->port, data->port_len*sizeof(WCHAR)); + uri->canon_len += data->port_len; + } else { + const WCHAR formatW[] = {'%','u',0}; + INT len = 0; + if(!computeOnly) + len = sprintfW(uri->canon_uri+uri->canon_len, formatW, data->port_value); + else { + WCHAR tmp[6]; + len = sprintfW(tmp, formatW, data->port_value); + } + uri->canon_len += len; + } + + uri->port = data->port_value; + } else if(has_default_port) + uri->port = default_port; + + return TRUE; +} + /* Canonicalizes the authority of the URI represented by the parse_data. */ static BOOL canonicalize_authority(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) { + uri->authority_start = uri->canon_len; + uri->authority_len = 0; + if(!canonicalize_userinfo(data, uri, flags, computeOnly)) return FALSE; if(!canonicalize_host(data, uri, flags, computeOnly)) return FALSE; - /* TODO Canonicalize port information. */ + if(!canonicalize_port(data, uri, flags, computeOnly)) + return FALSE; + if(uri->host_start != -1) + uri->authority_len = uri->canon_len - uri->authority_start; + else + uri->authority_start = -1; + + return TRUE; +} + +/* Attempts to canonicalize the path of a hierarchical URI. + * + * Things that happen: + * 1). Forbidden characters are percent encoded, unless the NO_ENCODE_FORBIDDEN + * flag is set or it's a file URI. Forbidden characters are always encoded + * for file schemes reguardless and forbidden characters are never encoded + * for unknown scheme types. + * + * 2). For known scheme types '\\' are changed to '/'. + * + * 3). Percent encoded, unreserved characters are decoded to their actual values. + * Unless the scheme type is unknown. For file schemes any percent encoded + * character in the unreserved or reserved set is decoded. + * + * 4). For File schemes if the path is starts with a drive letter and doesn't + * start with a '/' then one is appended. + * Ex: file://c:/test.mp3 -> file:///c:/test.mp3 + * + * 5). Dot segments are removed from the path for all scheme types + * unless NO_CANONICALIZE flag is set. Dot segments aren't removed + * for wildcard scheme types. + * + * NOTES: + * file://c:/test%20test -> file:///c:/test%2520test + * file://c:/test%3Etest -> file:///c:/test%253Etest + * file:///c:/test%20test -> file:///c:/test%20test + * file:///c:/test%test -> file:///c:/test%25test + */ +static BOOL canonicalize_path_hierarchical(const parse_data *data, Uri *uri, + DWORD flags, BOOL computeOnly) { + const WCHAR *ptr; + const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN; + const BOOL is_file = data->scheme_type == URL_SCHEME_FILE; + + BOOL escape_pct = FALSE; + + if(!data->path) { + uri->path_start = -1; + uri->path_len = 0; + return TRUE; + } + + uri->path_start = uri->canon_len; + ptr = data->path; + + if(is_file && uri->host_start == -1) { + /* Check if a '/' needs to be appended for the file scheme. */ + if(data->path_len > 1 && is_drive_path(ptr) && !(flags & Uri_CREATE_FILE_USE_DOS_PATH)) { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = '/'; + uri->canon_len++; + escape_pct = TRUE; + } else if(*ptr == '/') { + if(!(flags & Uri_CREATE_FILE_USE_DOS_PATH)) { + /* Copy the extra '/' over. */ + if(!computeOnly) + uri->canon_uri[uri->canon_len] = '/'; + ++uri->canon_len; + } + ++ptr; + } + + if(is_drive_path(ptr)) { + if(!computeOnly) { + uri->canon_uri[uri->canon_len] = *ptr; + /* If theres a '|' after the drive letter, convert it to a ':'. */ + uri->canon_uri[uri->canon_len+1] = ':'; + } + ptr += 2; + uri->canon_len += 2; + } + } + + for(; ptr < data->path+data->path_len; ++ptr) { + if(*ptr == '%') { + const WCHAR *tmp = ptr; + WCHAR val; + + /* Check if the % represents a valid encoded char, or if it needs encoded. */ + BOOL force_encode = !check_pct_encoded(&tmp) && is_file; + val = decode_pct_val(ptr); + + if(force_encode || escape_pct) { + /* Escape the percent sign in the file URI. */ + if(!computeOnly) + pct_encode_val(*ptr, uri->canon_uri+uri->canon_len); + uri->canon_len += 3; + } else if((is_unreserved(val) && known_scheme) || + (is_file && (is_unreserved(val) || is_reserved(val)))) { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = val; + ++uri->canon_len; + + ptr += 2; + continue; + } else { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = *ptr; + ++uri->canon_len; + } + } else if(*ptr == '/' && is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH)) { + /* Convert the '/' back to a '\\'. */ + if(!computeOnly) + uri->canon_uri[uri->canon_len] = '\\'; + ++uri->canon_len; + } else if(*ptr == '\\' && known_scheme) { + if(is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH)) { + /* Don't convert the '\\' to a '/'. */ + if(!computeOnly) + uri->canon_uri[uri->canon_len] = *ptr; + ++uri->canon_len; + } else { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = '/'; + ++uri->canon_len; + } + } else if(known_scheme && !is_unreserved(*ptr) && !is_reserved(*ptr) && + (!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS) || is_file)) { + if(is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH)) { + /* Don't escape the character. */ + if(!computeOnly) + uri->canon_uri[uri->canon_len] = *ptr; + ++uri->canon_len; + } else { + /* Escape the forbidden character. */ + if(!computeOnly) + pct_encode_val(*ptr, uri->canon_uri+uri->canon_len); + uri->canon_len += 3; + } + } else { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = *ptr; + ++uri->canon_len; + } + } + + uri->path_len = uri->canon_len - uri->path_start; + + /* Removing the dot segments only happens when it's not in + * computeOnly mode and it's not a wildcard scheme. File schemes + * with USE_DOS_PATH set don't get dot segments removed. + */ + if(!(is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH)) && + data->scheme_type != URL_SCHEME_WILDCARD) { + if(!(flags & Uri_CREATE_NO_CANONICALIZE) && !computeOnly) { + /* Remove the dot segments (if any) and reset everything to the new + * correct length. + */ + DWORD new_len = remove_dot_segments(uri->canon_uri+uri->path_start, uri->path_len); + uri->canon_len -= uri->path_len-new_len; + uri->path_len = new_len; + } + } + + if(!computeOnly) + TRACE("Canonicalized path %s len=%d\n", + debugstr_wn(uri->canon_uri+uri->path_start, uri->path_len), + uri->path_len); + + return TRUE; +} + +/* Attempts to canonicalize the path for an opaque URI. + * + * For known scheme types: + * 1) forbidden characters are percent encoded if + * NO_ENCODE_FORBIDDEN_CHARACTERS isn't set. + * + * 2) Percent encoded, unreserved characters are decoded + * to their actual values, for known scheme types. + * + * 3) '\\' are changed to '/' for known scheme types + * except for mailto schemes. + * + * 4) For file schemes, if USE_DOS_PATH is set all '/' + * are converted to backslashes. + * + * 5) For file schemes, if USE_DOS_PATH isn't set all '\' + * are converted to forward slashes. + */ +static BOOL canonicalize_path_opaque(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) { + const WCHAR *ptr; + const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN; + const BOOL is_file = data->scheme_type == URL_SCHEME_FILE; + + if(!data->path) { + uri->path_start = -1; + uri->path_len = 0; + return TRUE; + } + + uri->path_start = uri->canon_len; + + /* Windows doesn't allow a "//" to appear after the scheme + * of a URI, if it's an opaque URI. + */ + if(data->scheme && *(data->path) == '/' && *(data->path+1) == '/') { + /* So it inserts a "/." before the "//" if it exists. */ + if(!computeOnly) { + uri->canon_uri[uri->canon_len] = '/'; + uri->canon_uri[uri->canon_len+1] = '.'; + } + + uri->canon_len += 2; + } + + for(ptr = data->path; ptr < data->path+data->path_len; ++ptr) { + if(*ptr == '%' && known_scheme) { + WCHAR val = decode_pct_val(ptr); + + if(is_unreserved(val)) { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = val; + ++uri->canon_len; + + ptr += 2; + continue; + } else { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = *ptr; + ++uri->canon_len; + } + } else if(*ptr == '/' && is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH)) { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = '\\'; + ++uri->canon_len; + } else if(*ptr == '\\' && is_file) { + if(!(flags & Uri_CREATE_FILE_USE_DOS_PATH)) { + /* Convert to a '/'. */ + if(!computeOnly) + uri->canon_uri[uri->canon_len] = '/'; + ++uri->canon_len; + } else { + /* Just copy it over. */ + if(!computeOnly) + uri->canon_uri[uri->canon_len] = *ptr; + ++uri->canon_len; + } + } else if(known_scheme && !is_unreserved(*ptr) && !is_reserved(*ptr) && + !(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS)) { + if(is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH)) { + /* Forbidden characters aren't percent encoded for file schemes + * with USE_DOS_PATH set. + */ + if(!computeOnly) + uri->canon_uri[uri->canon_len] = *ptr; + ++uri->canon_len; + } else if(data->scheme_type == URL_SCHEME_MK && *ptr == '\\') { + /* MK URIs don't get '\\' percent encoded. */ + if(!computeOnly) + uri->canon_uri[uri->canon_len] = *ptr; + ++uri->canon_len; + } else { + if(!computeOnly) + pct_encode_val(*ptr, uri->canon_uri+uri->canon_len); + uri->canon_len += 3; + } + } else { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = *ptr; + ++uri->canon_len; + } + } + + uri->path_len = uri->canon_len - uri->path_start; + + TRACE("(%p %p %x %d): Canonicalized opaque URI path %s len=%d\n", data, uri, flags, computeOnly, + debugstr_wn(uri->canon_uri+uri->path_start, uri->path_len), uri->path_len); return TRUE; } @@ -1021,6 +3112,8 @@ static BOOL canonicalize_authority(const parse_data *data, Uri *uri, DWORD flags * URI is opaque it canonicalizes the path of the URI. */ static BOOL canonicalize_hierpart(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) { + uri->display_absolute = TRUE; + if(!data->is_opaque) { /* "//" is only added for non-wildcard scheme types. */ if(data->scheme_type != URL_SCHEME_WILDCARD) { @@ -1036,14 +3129,160 @@ static BOOL canonicalize_hierpart(const parse_data *data, Uri *uri, DWORD flags, if(!canonicalize_authority(data, uri, flags, computeOnly)) return FALSE; - /* TODO: Canonicalize the path of the URI. */ + /* TODO: Canonicalize the path of the URI. */ + if(!canonicalize_path_hierarchical(data, uri, flags, computeOnly)) + return FALSE; } else { - /* Opaque URI's don't have userinfo. */ + /* Opaque URI's don't have an authority. */ uri->userinfo_start = uri->userinfo_split = -1; uri->userinfo_len = 0; + uri->host_start = -1; + uri->host_len = 0; + uri->host_type = Uri_HOST_UNKNOWN; + uri->has_port = FALSE; + uri->authority_start = -1; + uri->authority_len = 0; + uri->domain_offset = -1; + + if(is_hierarchical_scheme(data->scheme_type)) { + DWORD i; + + /* Absolute URIs aren't displayed for known scheme types + * which should be hierarchical URIs. + */ + uri->display_absolute = FALSE; + + /* Windows also sets the port for these (if they have one). */ + for(i = 0; i < sizeof(default_ports)/sizeof(default_ports[0]); ++i) { + if(data->scheme_type == default_ports[i].scheme) { + uri->has_port = TRUE; + uri->port = default_ports[i].port; + break; + } + } + } + + if(!canonicalize_path_opaque(data, uri, flags, computeOnly)) + return FALSE; } + if(uri->path_start > -1 && !computeOnly) + /* Finding file extensions happens for both types of URIs. */ + uri->extension_offset = find_file_extension(uri->canon_uri+uri->path_start, uri->path_len); + else + uri->extension_offset = -1; + + return TRUE; +} + +/* Attempts to canonicalize the query string of the URI. + * + * Things that happen: + * 1) For known scheme types forbidden characters + * are percent encoded, unless the NO_DECODE_EXTRA_INFO flag is set + * or NO_ENCODE_FORBIDDEN_CHARACTERS is set. + * + * 2) For known scheme types, percent encoded, unreserved characters + * are decoded as long as the NO_DECODE_EXTRA_INFO flag isn't set. + */ +static BOOL canonicalize_query(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) { + const WCHAR *ptr, *end; + const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN; + + if(!data->query) { + uri->query_start = -1; + uri->query_len = 0; + return TRUE; + } + + uri->query_start = uri->canon_len; + + end = data->query+data->query_len; + for(ptr = data->query; ptr < end; ++ptr) { + if(*ptr == '%') { + if(known_scheme && !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) { + WCHAR val = decode_pct_val(ptr); + if(is_unreserved(val)) { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = val; + ++uri->canon_len; + + ptr += 2; + continue; + } + } + } else if(known_scheme && !is_unreserved(*ptr) && !is_reserved(*ptr)) { + if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS) && + !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) { + if(!computeOnly) + pct_encode_val(*ptr, uri->canon_uri+uri->canon_len); + uri->canon_len += 3; + continue; + } + } + + if(!computeOnly) + uri->canon_uri[uri->canon_len] = *ptr; + ++uri->canon_len; + } + + uri->query_len = uri->canon_len - uri->query_start; + + if(!computeOnly) + TRACE("(%p %p %x %d): Canonicalized query string %s len=%d\n", data, uri, flags, + computeOnly, debugstr_wn(uri->canon_uri+uri->query_start, uri->query_len), + uri->query_len); + return TRUE; +} + +static BOOL canonicalize_fragment(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) { + const WCHAR *ptr, *end; + const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN; + + if(!data->fragment) { + uri->fragment_start = -1; + uri->fragment_len = 0; + return TRUE; + } + + uri->fragment_start = uri->canon_len; + + end = data->fragment + data->fragment_len; + for(ptr = data->fragment; ptr < end; ++ptr) { + if(*ptr == '%') { + if(known_scheme && !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) { + WCHAR val = decode_pct_val(ptr); + if(is_unreserved(val)) { + if(!computeOnly) + uri->canon_uri[uri->canon_len] = val; + ++uri->canon_len; + + ptr += 2; + continue; + } + } + } else if(known_scheme && !is_unreserved(*ptr) && !is_reserved(*ptr)) { + if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS) && + !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) { + if(!computeOnly) + pct_encode_val(*ptr, uri->canon_uri+uri->canon_len); + uri->canon_len += 3; + continue; + } + } + + if(!computeOnly) + uri->canon_uri[uri->canon_len] = *ptr; + ++uri->canon_len; + } + + uri->fragment_len = uri->canon_len - uri->fragment_start; + + if(!computeOnly) + TRACE("(%p %p %x %d): Canonicalized fragment %s len=%d\n", data, uri, flags, + computeOnly, debugstr_wn(uri->canon_uri+uri->fragment_start, uri->fragment_len), + uri->fragment_len); return TRUE; } @@ -1109,6 +3348,16 @@ static int compute_canonicalized_length(const parse_data *data, DWORD flags) { return -1; } + if(!canonicalize_query(data, &uri, flags, TRUE)) { + ERR("(%p %x): Failed to compute query string length.\n", data, flags); + return -1; + } + + if(!canonicalize_fragment(data, &uri, flags, TRUE)) { + ERR("(%p %x): Failed to compute fragment length.\n", data, flags); + return -1; + } + TRACE("(%p %x): Finished computing canonicalized URI length. length=%d\n", data, flags, uri.canon_len); return uri.canon_len; @@ -1142,6 +3391,7 @@ static HRESULT canonicalize_uri(const parse_data *data, Uri *uri, DWORD flags) { if(!uri->canon_uri) return E_OUTOFMEMORY; + uri->canon_size = len; if(!canonicalize_scheme(data, uri, flags, FALSE)) { ERR("(%p %p %x): Unable to canonicalize the scheme of the URI.\n", data, uri, flags); heap_free(uri->canon_uri); @@ -1155,15 +3405,513 @@ static HRESULT canonicalize_uri(const parse_data *data, Uri *uri, DWORD flags) { return E_INVALIDARG; } - uri->canon_uri[uri->canon_len] = '\0'; - TRACE("(%p %p %x): finished canonicalizing the URI.\n", data, uri, flags); + if(!canonicalize_query(data, uri, flags, FALSE)) { + ERR("(%p %p %x): Unable to canonicalize query string of the URI.\n", + data, uri, flags); + return E_INVALIDARG; + } + if(!canonicalize_fragment(data, uri, flags, FALSE)) { + ERR("(%p %p %x): Unable to canonicalize fragment of the URI.\n", + data, uri, flags); + return E_INVALIDARG; + } + + /* There's a possibility we didn't use all the space we allocated + * earlier. + */ + if(uri->canon_len < uri->canon_size) { + /* This happens if the URI is hierarchical and dot + * segments were removed from it's path. + */ + WCHAR *tmp = heap_realloc(uri->canon_uri, (uri->canon_len+1)*sizeof(WCHAR)); + if(!tmp) + return E_OUTOFMEMORY; + + uri->canon_uri = tmp; + uri->canon_size = uri->canon_len; + } + + uri->canon_uri[uri->canon_len] = '\0'; + TRACE("(%p %p %x): finished canonicalizing the URI. uri=%s\n", data, uri, flags, debugstr_w(uri->canon_uri)); + + return S_OK; +} + +static HRESULT get_builder_component(LPWSTR *component, DWORD *component_len, + LPCWSTR source, DWORD source_len, + LPCWSTR *output, DWORD *output_len) +{ + if(!output_len) { + if(output) + *output = NULL; + return E_POINTER; + } + + if(!output) { + *output_len = 0; + return E_POINTER; + } + + if(!(*component) && source) { + /* Allocate 'component', and copy the contents from 'source' + * into the new allocation. + */ + *component = heap_alloc((source_len+1)*sizeof(WCHAR)); + if(!(*component)) + return E_OUTOFMEMORY; + + memcpy(*component, source, source_len*sizeof(WCHAR)); + (*component)[source_len] = '\0'; + *component_len = source_len; + } + + *output = *component; + *output_len = *component_len; + return *output ? S_OK : S_FALSE; +} + +/* Allocates 'component' and copies the string from 'new_value' into 'component'. + * If 'prefix' is set and 'new_value' isn't NULL, then it checks if 'new_value' + * starts with 'prefix'. If it doesn't then 'prefix' is prepended to 'component'. + * + * If everything is successful, then will set 'success_flag' in 'flags'. + */ +static HRESULT set_builder_component(LPWSTR *component, DWORD *component_len, LPCWSTR new_value, + WCHAR prefix, DWORD *flags, DWORD success_flag) +{ + heap_free(*component); + + if(!new_value) { + *component = NULL; + *component_len = 0; + } else { + BOOL add_prefix = FALSE; + DWORD len = lstrlenW(new_value); + DWORD pos = 0; + + if(prefix && *new_value != prefix) { + add_prefix = TRUE; + *component = heap_alloc((len+2)*sizeof(WCHAR)); + } else + *component = heap_alloc((len+1)*sizeof(WCHAR)); + + if(!(*component)) + return E_OUTOFMEMORY; + + if(add_prefix) + (*component)[pos++] = prefix; + + memcpy(*component+pos, new_value, (len+1)*sizeof(WCHAR)); + *component_len = len+pos; + } + + *flags |= success_flag; return S_OK; } #define URI(x) ((IUri*) &(x)->lpIUriVtbl) #define URIBUILDER(x) ((IUriBuilder*) &(x)->lpIUriBuilderVtbl) +static void reset_builder(UriBuilder *builder) { + if(builder->uri) + IUri_Release(URI(builder->uri)); + builder->uri = NULL; + + heap_free(builder->fragment); + builder->fragment = NULL; + builder->fragment_len = 0; + + heap_free(builder->host); + builder->host = NULL; + builder->host_len = 0; + + heap_free(builder->password); + builder->password = NULL; + builder->password_len = 0; + + heap_free(builder->path); + builder->path = NULL; + builder->path_len = 0; + + heap_free(builder->query); + builder->query = NULL; + builder->query_len = 0; + + heap_free(builder->scheme); + builder->scheme = NULL; + builder->scheme_len = 0; + + heap_free(builder->username); + builder->username = NULL; + builder->username_len = 0; + + builder->has_port = FALSE; + builder->port = 0; + builder->modified_props = 0; +} + +static HRESULT validate_scheme_name(const UriBuilder *builder, parse_data *data, DWORD flags) { + const WCHAR *component; + const WCHAR *ptr; + const WCHAR **pptr; + DWORD expected_len; + + if(builder->scheme) { + ptr = builder->scheme; + expected_len = builder->scheme_len; + } else if(builder->uri && builder->uri->scheme_start > -1) { + ptr = builder->uri->canon_uri+builder->uri->scheme_start; + expected_len = builder->uri->scheme_len; + } else { + static const WCHAR nullW[] = {0}; + ptr = nullW; + expected_len = 0; + } + + component = ptr; + pptr = &ptr; + if(parse_scheme(pptr, data, flags, ALLOW_NULL_TERM_SCHEME) && + data->scheme_len == expected_len) { + if(data->scheme) + TRACE("(%p %p %x): Found valid scheme component %s len=%d.\n", builder, data, flags, + debugstr_wn(data->scheme, data->scheme_len), data->scheme_len); + } else { + TRACE("(%p %p %x): Invalid scheme component found %s.\n", builder, data, flags, + debugstr_wn(component, expected_len)); + return INET_E_INVALID_URL; + } + + return S_OK; +} + +static HRESULT validate_username(const UriBuilder *builder, parse_data *data, DWORD flags) { + const WCHAR *ptr; + const WCHAR **pptr; + DWORD expected_len; + + if(builder->username) { + ptr = builder->username; + expected_len = builder->username_len; + } else if(!(builder->modified_props & Uri_HAS_USER_NAME) && builder->uri && + builder->uri->userinfo_start > -1 && builder->uri->userinfo_split != 0) { + /* Just use the username from the base Uri. */ + data->username = builder->uri->canon_uri+builder->uri->userinfo_start; + data->username_len = (builder->uri->userinfo_split > -1) ? + builder->uri->userinfo_split : builder->uri->userinfo_len; + ptr = NULL; + } else { + ptr = NULL; + expected_len = 0; + } + + if(ptr) { + const WCHAR *component = ptr; + pptr = &ptr; + if(parse_username(pptr, data, flags, ALLOW_NULL_TERM_USER_NAME) && + data->username_len == expected_len) + TRACE("(%p %p %x): Found valid username component %s len=%d.\n", builder, data, flags, + debugstr_wn(data->username, data->username_len), data->username_len); + else { + TRACE("(%p %p %x): Invalid username component found %s.\n", builder, data, flags, + debugstr_wn(component, expected_len)); + return INET_E_INVALID_URL; + } + } + + return S_OK; +} + +static HRESULT validate_password(const UriBuilder *builder, parse_data *data, DWORD flags) { + const WCHAR *ptr; + const WCHAR **pptr; + DWORD expected_len; + + if(builder->password) { + ptr = builder->password; + expected_len = builder->password_len; + } else if(!(builder->modified_props & Uri_HAS_PASSWORD) && builder->uri && + builder->uri->userinfo_split > -1) { + data->password = builder->uri->canon_uri+builder->uri->userinfo_start+builder->uri->userinfo_split+1; + data->password_len = builder->uri->userinfo_len-builder->uri->userinfo_split-1; + ptr = NULL; + } else { + ptr = NULL; + expected_len = 0; + } + + if(ptr) { + const WCHAR *component = ptr; + pptr = &ptr; + if(parse_password(pptr, data, flags, ALLOW_NULL_TERM_PASSWORD) && + data->password_len == expected_len) + TRACE("(%p %p %x): Found valid password component %s len=%d.\n", builder, data, flags, + debugstr_wn(data->password, data->password_len), data->password_len); + else { + TRACE("(%p %p %x): Invalid password component found %s.\n", builder, data, flags, + debugstr_wn(component, expected_len)); + return INET_E_INVALID_URL; + } + } + + return S_OK; +} + +static HRESULT validate_userinfo(const UriBuilder *builder, parse_data *data, DWORD flags) { + HRESULT hr; + + hr = validate_username(builder, data, flags); + if(FAILED(hr)) + return hr; + + hr = validate_password(builder, data, flags); + if(FAILED(hr)) + return hr; + + return S_OK; +} + +static HRESULT validate_host(const UriBuilder *builder, parse_data *data, DWORD flags) { + const WCHAR *ptr; + const WCHAR **pptr; + DWORD expected_len; + + if(builder->host) { + ptr = builder->host; + expected_len = builder->host_len; + } else if(!(builder->modified_props & Uri_HAS_HOST) && builder->uri && builder->uri->host_start > -1) { + ptr = builder->uri->canon_uri + builder->uri->host_start; + expected_len = builder->uri->host_len; + } else + ptr = NULL; + + if(ptr) { + const WCHAR *component = ptr; + DWORD extras = ALLOW_BRACKETLESS_IP_LITERAL|IGNORE_PORT_DELIMITER|SKIP_IP_FUTURE_CHECK; + pptr = &ptr; + + if(parse_host(pptr, data, flags, extras) && data->host_len == expected_len) + TRACE("(%p %p %x): Found valid host name %s len=%d type=%d.\n", builder, data, flags, + debugstr_wn(data->host, data->host_len), data->host_len, data->host_type); + else { + TRACE("(%p %p %x): Invalid host name found %s.\n", builder, data, flags, + debugstr_wn(component, expected_len)); + return INET_E_INVALID_URL; + } + } + + return S_OK; +} + +static void setup_port(const UriBuilder *builder, parse_data *data, DWORD flags) { + if(builder->modified_props & Uri_HAS_PORT) { + if(builder->has_port) { + data->has_port = TRUE; + data->port_value = builder->port; + } + } else if(builder->uri && builder->uri->has_port) { + data->has_port = TRUE; + data->port_value = builder->uri->port; + } + + if(data->has_port) + TRACE("(%p %p %x): Using %u as port for IUri.\n", builder, data, flags, data->port_value); +} + +static HRESULT validate_path(const UriBuilder *builder, parse_data *data, DWORD flags) { + const WCHAR *ptr = NULL; + const WCHAR **pptr; + DWORD expected_len; + + if(builder->path) { + ptr = builder->path; + expected_len = builder->path_len; + } else if(!(builder->modified_props & Uri_HAS_PATH) && + builder->uri && builder->uri->path_start > -1) { + ptr = builder->uri->canon_uri+builder->uri->path_start; + expected_len = builder->uri->path_len; + } + + if(ptr) { + BOOL valid = FALSE; + const WCHAR *component = ptr; + pptr = &ptr; + + /* How the path is validated depends on what type of + * URI it is. + */ + valid = data->is_opaque ? + parse_path_opaque(pptr, data, flags) : parse_path_hierarchical(pptr, data, flags); + + if(!valid || expected_len != data->path_len) { + TRACE("(%p %p %x): Invalid path componet %s.\n", builder, data, flags, + debugstr_wn(component, expected_len)); + return INET_E_INVALID_URL; + } + + TRACE("(%p %p %x): Valid path component %s len=%d.\n", builder, data, flags, + debugstr_wn(data->path, data->path_len), data->path_len); + } + + return S_OK; +} + +static HRESULT validate_query(const UriBuilder *builder, parse_data *data, DWORD flags) { + const WCHAR *ptr = NULL; + const WCHAR **pptr; + DWORD expected_len; + + if(builder->query) { + ptr = builder->query; + expected_len = builder->query_len; + } else if(!(builder->modified_props & Uri_HAS_QUERY) && builder->uri && + builder->uri->query_start > -1) { + ptr = builder->uri->canon_uri+builder->uri->query_start; + expected_len = builder->uri->query_len; + } + + if(ptr) { + const WCHAR *component = ptr; + pptr = &ptr; + + if(parse_query(pptr, data, flags) && expected_len == data->query_len) + TRACE("(%p %p %x): Valid query component %s len=%d.\n", builder, data, flags, + debugstr_wn(data->query, data->query_len), data->query_len); + else { + TRACE("(%p %p %x): Invalid query component %s.\n", builder, data, flags, + debugstr_wn(component, expected_len)); + return INET_E_INVALID_URL; + } + } + + return S_OK; +} + +static HRESULT validate_fragment(const UriBuilder *builder, parse_data *data, DWORD flags) { + const WCHAR *ptr = NULL; + const WCHAR **pptr; + DWORD expected_len; + + if(builder->fragment) { + ptr = builder->fragment; + expected_len = builder->fragment_len; + } else if(!(builder->modified_props & Uri_HAS_FRAGMENT) && builder->uri && + builder->uri->fragment_start > -1) { + ptr = builder->uri->canon_uri+builder->uri->fragment_start; + expected_len = builder->uri->fragment_len; + } + + if(ptr) { + const WCHAR *component = ptr; + pptr = &ptr; + + if(parse_query(pptr, data, flags) && expected_len == data->fragment_len) + TRACE("(%p %p %x): Valid fragment component %s len=%d.\n", builder, data, flags, + debugstr_wn(data->fragment, data->fragment_len), data->fragment_len); + else { + TRACE("(%p %p %x): Invalid fragment component %s.\n", builder, data, flags, + debugstr_wn(component, expected_len)); + return INET_E_INVALID_URL; + } + } + + return S_OK; +} + +static HRESULT validate_components(const UriBuilder *builder, parse_data *data, DWORD flags) { + HRESULT hr; + + memset(data, 0, sizeof(parse_data)); + + TRACE("(%p %p %x): Beginning to validate builder components.\n", builder, data, flags); + + hr = validate_scheme_name(builder, data, flags); + if(FAILED(hr)) + return hr; + + /* Extra validation for file schemes. */ + if(data->scheme_type == URL_SCHEME_FILE) { + if((builder->password || (builder->uri && builder->uri->userinfo_split > -1)) || + (builder->username || (builder->uri && builder->uri->userinfo_start > -1))) { + TRACE("(%p %p %x): File schemes can't contain a username or password.\n", + builder, data, flags); + return INET_E_INVALID_URL; + } + } + + hr = validate_userinfo(builder, data, flags); + if(FAILED(hr)) + return hr; + + hr = validate_host(builder, data, flags); + if(FAILED(hr)) + return hr; + + /* The URI is opaque if it doesn't have an authority component. */ + data->is_opaque = !data->username && !data->password && !data->host; + + setup_port(builder, data, flags); + + hr = validate_path(builder, data, flags); + if(FAILED(hr)) + return hr; + + hr = validate_query(builder, data, flags); + if(FAILED(hr)) + return hr; + + hr = validate_fragment(builder, data, flags); + if(FAILED(hr)) + return hr; + + TRACE("(%p %p %x): Finished validating builder components.\n", builder, data, flags); + + return S_OK; +} + +static HRESULT build_uri(const UriBuilder *builder, IUri **uri, DWORD create_flags, + DWORD use_orig_flags, DWORD encoding_mask) +{ + HRESULT hr; + parse_data data; + + if(!uri) + return E_POINTER; + + if(encoding_mask && (!builder->uri || builder->modified_props)) { + *uri = NULL; + return E_NOTIMPL; + } + + /* Decide what flags should be used when creating the Uri. */ + if((use_orig_flags & UriBuilder_USE_ORIGINAL_FLAGS) && builder->uri) + create_flags = builder->uri->create_flags; + else { + if(has_invalid_flag_combination(create_flags)) { + *uri = NULL; + return E_INVALIDARG; + } + + /* Set the default flags if they don't cause a conflict. */ + apply_default_flags(&create_flags); + } + + /* Return the base IUri if no changes have been made and the create_flags match. */ + if(builder->uri && !builder->modified_props && builder->uri->create_flags == create_flags) { + *uri = URI(builder->uri); + IUri_AddRef(*uri); + return S_OK; + } + + hr = validate_components(builder, &data, create_flags); + if(FAILED(hr)) { + *uri = NULL; + return hr; + } + + return E_NOTIMPL; +} + #define URI_THIS(iface) DEFINE_THIS(Uri, IUri, iface) static HRESULT WINAPI Uri_QueryInterface(IUri *iface, REFIID riid, void **ppv) @@ -1176,6 +3924,10 @@ static HRESULT WINAPI Uri_QueryInterface(IUri *iface, REFIID riid, void **ppv) }else if(IsEqualGUID(&IID_IUri, riid)) { TRACE("(%p)->(IID_IUri %p)\n", This, ppv); *ppv = URI(This); + }else if(IsEqualGUID(&IID_IUriObj, riid)) { + TRACE("(%p)->(IID_IUriObj %p)\n", This, ppv); + *ppv = This; + return S_OK; }else { TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv); *ppv = NULL; @@ -1241,16 +3993,137 @@ static HRESULT WINAPI Uri_GetPropertyBSTR(IUri *iface, Uri_PROPERTY uriProp, BST } switch(uriProp) { - case Uri_PROPERTY_HOST: - if(This->host_start > -1) { - *pbstrProperty = SysAllocStringLen(This->canon_uri+This->host_start, This->host_len); + case Uri_PROPERTY_ABSOLUTE_URI: + if(!This->display_absolute) { + *pbstrProperty = SysAllocStringLen(NULL, 0); + hres = S_FALSE; + } else { + if(This->scheme_type != URL_SCHEME_UNKNOWN && This->userinfo_start > -1) { + if(This->userinfo_len == 0) { + /* Don't include the '@' after the userinfo component. */ + *pbstrProperty = SysAllocStringLen(NULL, This->canon_len-1); + hres = S_OK; + if(*pbstrProperty) { + /* Copy everything before it. */ + memcpy(*pbstrProperty, This->canon_uri, This->userinfo_start*sizeof(WCHAR)); + + /* And everything after it. */ + memcpy(*pbstrProperty+This->userinfo_start, This->canon_uri+This->userinfo_start+1, + (This->canon_len-This->userinfo_start-1)*sizeof(WCHAR)); + } + } else if(This->userinfo_split == 0 && This->userinfo_len == 1) { + /* Don't include the ":@" */ + *pbstrProperty = SysAllocStringLen(NULL, This->canon_len-2); + hres = S_OK; + if(*pbstrProperty) { + memcpy(*pbstrProperty, This->canon_uri, This->userinfo_start*sizeof(WCHAR)); + memcpy(*pbstrProperty+This->userinfo_start, This->canon_uri+This->userinfo_start+2, + (This->canon_len-This->userinfo_start-2)*sizeof(WCHAR)); + } + } else { + *pbstrProperty = SysAllocString(This->canon_uri); + hres = S_OK; + } + } else { + *pbstrProperty = SysAllocString(This->canon_uri); + hres = S_OK; + } + } + + if(!(*pbstrProperty)) + hres = E_OUTOFMEMORY; + + break; + case Uri_PROPERTY_AUTHORITY: + if(This->authority_start > -1) { + *pbstrProperty = SysAllocStringLen(This->canon_uri+This->authority_start, This->authority_len); hres = S_OK; } else { - /* Canonicalizing/parsing the host of a URI is only partially - * implemented, so return E_NOTIMPL for now. - */ - FIXME("(%p)->(%d %p %x) Partially implemented\n", This, uriProp, pbstrProperty, dwFlags); - return E_NOTIMPL; + *pbstrProperty = SysAllocStringLen(NULL, 0); + hres = S_FALSE; + } + + if(!(*pbstrProperty)) + hres = E_OUTOFMEMORY; + + break; + case Uri_PROPERTY_DISPLAY_URI: + /* The Display URI contains everything except for the userinfo for known + * scheme types. + */ + if(This->scheme_type != URL_SCHEME_UNKNOWN && This->userinfo_start > -1) { + *pbstrProperty = SysAllocStringLen(NULL, This->canon_len-This->userinfo_len); + + if(*pbstrProperty) { + /* Copy everything before the userinfo over. */ + memcpy(*pbstrProperty, This->canon_uri, This->userinfo_start*sizeof(WCHAR)); + /* Copy everything after the userinfo over. */ + memcpy(*pbstrProperty+This->userinfo_start, + This->canon_uri+This->userinfo_start+This->userinfo_len+1, + (This->canon_len-(This->userinfo_start+This->userinfo_len+1))*sizeof(WCHAR)); + } + } else + *pbstrProperty = SysAllocString(This->canon_uri); + + if(!(*pbstrProperty)) + hres = E_OUTOFMEMORY; + else + hres = S_OK; + + break; + case Uri_PROPERTY_DOMAIN: + if(This->domain_offset > -1) { + *pbstrProperty = SysAllocStringLen(This->canon_uri+This->host_start+This->domain_offset, + This->host_len-This->domain_offset); + hres = S_OK; + } else { + *pbstrProperty = SysAllocStringLen(NULL, 0); + hres = S_FALSE; + } + + if(!(*pbstrProperty)) + hres = E_OUTOFMEMORY; + + break; + case Uri_PROPERTY_EXTENSION: + if(This->extension_offset > -1) { + *pbstrProperty = SysAllocStringLen(This->canon_uri+This->path_start+This->extension_offset, + This->path_len-This->extension_offset); + hres = S_OK; + } else { + *pbstrProperty = SysAllocStringLen(NULL, 0); + hres = S_FALSE; + } + + if(!(*pbstrProperty)) + hres = E_OUTOFMEMORY; + + break; + case Uri_PROPERTY_FRAGMENT: + if(This->fragment_start > -1) { + *pbstrProperty = SysAllocStringLen(This->canon_uri+This->fragment_start, This->fragment_len); + hres = S_OK; + } else { + *pbstrProperty = SysAllocStringLen(NULL, 0); + hres = S_FALSE; + } + + if(!(*pbstrProperty)) + hres = E_OUTOFMEMORY; + + break; + case Uri_PROPERTY_HOST: + if(This->host_start > -1) { + /* The '[' and ']' aren't included for IPv6 addresses. */ + if(This->host_type == Uri_HOST_IPV6) + *pbstrProperty = SysAllocStringLen(This->canon_uri+This->host_start+1, This->host_len-2); + else + *pbstrProperty = SysAllocStringLen(This->canon_uri+This->host_start, This->host_len); + + hres = S_OK; + } else { + *pbstrProperty = SysAllocStringLen(NULL, 0); + hres = S_FALSE; } if(!(*pbstrProperty)) @@ -1271,6 +4144,48 @@ static HRESULT WINAPI Uri_GetPropertyBSTR(IUri *iface, Uri_PROPERTY uriProp, BST if(!(*pbstrProperty)) return E_OUTOFMEMORY; + break; + case Uri_PROPERTY_PATH: + if(This->path_start > -1) { + *pbstrProperty = SysAllocStringLen(This->canon_uri+This->path_start, This->path_len); + hres = S_OK; + } else { + *pbstrProperty = SysAllocStringLen(NULL, 0); + hres = S_FALSE; + } + + if(!(*pbstrProperty)) + hres = E_OUTOFMEMORY; + + break; + case Uri_PROPERTY_PATH_AND_QUERY: + if(This->path_start > -1) { + *pbstrProperty = SysAllocStringLen(This->canon_uri+This->path_start, This->path_len+This->query_len); + hres = S_OK; + } else if(This->query_start > -1) { + *pbstrProperty = SysAllocStringLen(This->canon_uri+This->query_start, This->query_len); + hres = S_OK; + } else { + *pbstrProperty = SysAllocStringLen(NULL, 0); + hres = S_FALSE; + } + + if(!(*pbstrProperty)) + hres = E_OUTOFMEMORY; + + break; + case Uri_PROPERTY_QUERY: + if(This->query_start > -1) { + *pbstrProperty = SysAllocStringLen(This->canon_uri+This->query_start, This->query_len); + hres = S_OK; + } else { + *pbstrProperty = SysAllocStringLen(NULL, 0); + hres = S_FALSE; + } + + if(!(*pbstrProperty)) + hres = E_OUTOFMEMORY; + break; case Uri_PROPERTY_RAW_URI: *pbstrProperty = SysAllocString(This->raw_uri); @@ -1306,7 +4221,7 @@ static HRESULT WINAPI Uri_GetPropertyBSTR(IUri *iface, Uri_PROPERTY uriProp, BST break; case Uri_PROPERTY_USER_NAME: - if(This->userinfo_start > -1) { + if(This->userinfo_start > -1 && This->userinfo_split != 0) { /* If userinfo_split is set, that means a password exists * so the username is only from userinfo_start to userinfo_split. */ @@ -1354,22 +4269,87 @@ static HRESULT WINAPI Uri_GetPropertyLength(IUri *iface, Uri_PROPERTY uriProp, D } switch(uriProp) { - case Uri_PROPERTY_HOST: - if(This->host_start == -1) { - /* Canonicalizing/parsing the host of a URI is only partially - * implemented, so return E_NOTIMPL for now. - */ - FIXME("(%p)->(%d %p %x) Partially implemented\n", This, uriProp, pcchProperty, dwFlags); - return E_NOTIMPL; + case Uri_PROPERTY_ABSOLUTE_URI: + if(!This->display_absolute) { + *pcchProperty = 0; + hres = S_FALSE; + } else { + if(This->scheme_type != URL_SCHEME_UNKNOWN) { + if(This->userinfo_start > -1 && This->userinfo_len == 0) + /* Don't include the '@' in the length. */ + *pcchProperty = This->canon_len-1; + else if(This->userinfo_start > -1 && This->userinfo_len == 1 && + This->userinfo_split == 0) + /* Don't include the ":@" in the length. */ + *pcchProperty = This->canon_len-2; + else + *pcchProperty = This->canon_len; + } else + *pcchProperty = This->canon_len; + + hres = S_OK; } + break; + case Uri_PROPERTY_AUTHORITY: + *pcchProperty = This->authority_len; + hres = (This->authority_start > -1) ? S_OK : S_FALSE; + break; + case Uri_PROPERTY_DISPLAY_URI: + if(This->scheme_type != URL_SCHEME_UNKNOWN && This->userinfo_start > -1) + *pcchProperty = This->canon_len-This->userinfo_len-1; + else + *pcchProperty = This->canon_len; + + hres = S_OK; + break; + case Uri_PROPERTY_DOMAIN: + if(This->domain_offset > -1) + *pcchProperty = This->host_len - This->domain_offset; + else + *pcchProperty = 0; + + hres = (This->domain_offset > -1) ? S_OK : S_FALSE; + break; + case Uri_PROPERTY_EXTENSION: + if(This->extension_offset > -1) { + *pcchProperty = This->path_len - This->extension_offset; + hres = S_OK; + } else { + *pcchProperty = 0; + hres = S_FALSE; + } + + break; + case Uri_PROPERTY_FRAGMENT: + *pcchProperty = This->fragment_len; + hres = (This->fragment_start > -1) ? S_OK : S_FALSE; + break; + case Uri_PROPERTY_HOST: *pcchProperty = This->host_len; + + /* '[' and ']' aren't included in the length. */ + if(This->host_type == Uri_HOST_IPV6) + *pcchProperty -= 2; + hres = (This->host_start > -1) ? S_OK : S_FALSE; break; case Uri_PROPERTY_PASSWORD: *pcchProperty = (This->userinfo_split > -1) ? This->userinfo_len-This->userinfo_split-1 : 0; hres = (This->userinfo_split > -1) ? S_OK : S_FALSE; break; + case Uri_PROPERTY_PATH: + *pcchProperty = This->path_len; + hres = (This->path_start > -1) ? S_OK : S_FALSE; + break; + case Uri_PROPERTY_PATH_AND_QUERY: + *pcchProperty = This->path_len+This->query_len; + hres = (This->path_start > -1 || This->query_start > -1) ? S_OK : S_FALSE; + break; + case Uri_PROPERTY_QUERY: + *pcchProperty = This->query_len; + hres = (This->query_start > -1) ? S_OK : S_FALSE; + break; case Uri_PROPERTY_RAW_URI: *pcchProperty = SysStringLen(This->raw_uri); hres = S_OK; @@ -1384,7 +4364,10 @@ static HRESULT WINAPI Uri_GetPropertyLength(IUri *iface, Uri_PROPERTY uriProp, D break; case Uri_PROPERTY_USER_NAME: *pcchProperty = (This->userinfo_split > -1) ? This->userinfo_split : This->userinfo_len; - hres = (This->userinfo_start > -1) ? S_OK : S_FALSE; + if(This->userinfo_split == 0) + hres = S_FALSE; + else + hres = (This->userinfo_start > -1) ? S_OK : S_FALSE; break; default: FIXME("(%p)->(%d %p %x)\n", This, uriProp, pcchProperty, dwFlags); @@ -1420,6 +4403,20 @@ static HRESULT WINAPI Uri_GetPropertyDWORD(IUri *iface, Uri_PROPERTY uriProp, DW } switch(uriProp) { + case Uri_PROPERTY_HOST_TYPE: + *pcchProperty = This->host_type; + hres = S_OK; + break; + case Uri_PROPERTY_PORT: + if(!This->has_port) { + *pcchProperty = 0; + hres = S_FALSE; + } else { + *pcchProperty = This->port; + hres = S_OK; + } + + break; case Uri_PROPERTY_SCHEME: *pcchProperty = This->scheme_type; hres = S_OK; @@ -1435,78 +4432,114 @@ static HRESULT WINAPI Uri_GetPropertyDWORD(IUri *iface, Uri_PROPERTY uriProp, DW static HRESULT WINAPI Uri_HasProperty(IUri *iface, Uri_PROPERTY uriProp, BOOL *pfHasProperty) { Uri *This = URI_THIS(iface); - FIXME("(%p)->(%d %p)\n", This, uriProp, pfHasProperty); + TRACE("(%p)->(%d %p)\n", This, uriProp, pfHasProperty); if(!pfHasProperty) return E_INVALIDARG; - return E_NOTIMPL; + switch(uriProp) { + case Uri_PROPERTY_ABSOLUTE_URI: + *pfHasProperty = This->display_absolute; + break; + case Uri_PROPERTY_AUTHORITY: + *pfHasProperty = This->authority_start > -1; + break; + case Uri_PROPERTY_DISPLAY_URI: + *pfHasProperty = TRUE; + break; + case Uri_PROPERTY_DOMAIN: + *pfHasProperty = This->domain_offset > -1; + break; + case Uri_PROPERTY_EXTENSION: + *pfHasProperty = This->extension_offset > -1; + break; + case Uri_PROPERTY_FRAGMENT: + *pfHasProperty = This->fragment_start > -1; + break; + case Uri_PROPERTY_HOST: + *pfHasProperty = This->host_start > -1; + break; + case Uri_PROPERTY_PASSWORD: + *pfHasProperty = This->userinfo_split > -1; + break; + case Uri_PROPERTY_PATH: + *pfHasProperty = This->path_start > -1; + break; + case Uri_PROPERTY_PATH_AND_QUERY: + *pfHasProperty = (This->path_start > -1 || This->query_start > -1); + break; + case Uri_PROPERTY_QUERY: + *pfHasProperty = This->query_start > -1; + break; + case Uri_PROPERTY_RAW_URI: + *pfHasProperty = TRUE; + break; + case Uri_PROPERTY_SCHEME_NAME: + *pfHasProperty = This->scheme_start > -1; + break; + case Uri_PROPERTY_USER_INFO: + *pfHasProperty = This->userinfo_start > -1; + break; + case Uri_PROPERTY_USER_NAME: + if(This->userinfo_split == 0) + *pfHasProperty = FALSE; + else + *pfHasProperty = This->userinfo_start > -1; + break; + case Uri_PROPERTY_HOST_TYPE: + *pfHasProperty = TRUE; + break; + case Uri_PROPERTY_PORT: + *pfHasProperty = This->has_port; + break; + case Uri_PROPERTY_SCHEME: + *pfHasProperty = TRUE; + break; + case Uri_PROPERTY_ZONE: + *pfHasProperty = FALSE; + break; + default: + FIXME("(%p)->(%d %p): Unsupported property type.\n", This, uriProp, pfHasProperty); + return E_NOTIMPL; + } + + return S_OK; } static HRESULT WINAPI Uri_GetAbsoluteUri(IUri *iface, BSTR *pstrAbsoluteUri) { - Uri *This = URI_THIS(iface); - FIXME("(%p)->(%p)\n", This, pstrAbsoluteUri); - - if(!pstrAbsoluteUri) - return E_POINTER; - - return E_NOTIMPL; + TRACE("(%p)->(%p)\n", iface, pstrAbsoluteUri); + return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_ABSOLUTE_URI, pstrAbsoluteUri, 0); } static HRESULT WINAPI Uri_GetAuthority(IUri *iface, BSTR *pstrAuthority) { - Uri *This = URI_THIS(iface); - FIXME("(%p)->(%p)\n", This, pstrAuthority); - - if(!pstrAuthority) - return E_POINTER; - - return E_NOTIMPL; + TRACE("(%p)->(%p)\n", iface, pstrAuthority); + return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_AUTHORITY, pstrAuthority, 0); } static HRESULT WINAPI Uri_GetDisplayUri(IUri *iface, BSTR *pstrDisplayUri) { - Uri *This = URI_THIS(iface); - FIXME("(%p)->(%p)\n", This, pstrDisplayUri); - - if(!pstrDisplayUri) - return E_POINTER; - - return E_NOTIMPL; + TRACE("(%p)->(%p)\n", iface, pstrDisplayUri); + return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_DISPLAY_URI, pstrDisplayUri, 0); } static HRESULT WINAPI Uri_GetDomain(IUri *iface, BSTR *pstrDomain) { - Uri *This = URI_THIS(iface); - FIXME("(%p)->(%p)\n", This, pstrDomain); - - if(!pstrDomain) - return E_POINTER; - - return E_NOTIMPL; + TRACE("(%p)->(%p)\n", iface, pstrDomain); + return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_DOMAIN, pstrDomain, 0); } static HRESULT WINAPI Uri_GetExtension(IUri *iface, BSTR *pstrExtension) { - Uri *This = URI_THIS(iface); - FIXME("(%p)->(%p)\n", This, pstrExtension); - - if(!pstrExtension) - return E_POINTER; - - return E_NOTIMPL; + TRACE("(%p)->(%p)\n", iface, pstrExtension); + return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_EXTENSION, pstrExtension, 0); } static HRESULT WINAPI Uri_GetFragment(IUri *iface, BSTR *pstrFragment) { - Uri *This = URI_THIS(iface); - FIXME("(%p)->(%p)\n", This, pstrFragment); - - if(!pstrFragment) - return E_POINTER; - - return E_NOTIMPL; + TRACE("(%p)->(%p)\n", iface, pstrFragment); + return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_FRAGMENT, pstrFragment, 0); } static HRESULT WINAPI Uri_GetHost(IUri *iface, BSTR *pstrHost) @@ -1523,50 +4556,31 @@ static HRESULT WINAPI Uri_GetPassword(IUri *iface, BSTR *pstrPassword) static HRESULT WINAPI Uri_GetPath(IUri *iface, BSTR *pstrPath) { - Uri *This = URI_THIS(iface); - FIXME("(%p)->(%p)\n", This, pstrPath); - - if(!pstrPath) - return E_POINTER; - - return E_NOTIMPL; + TRACE("(%p)->(%p)\n", iface, pstrPath); + return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_PATH, pstrPath, 0); } static HRESULT WINAPI Uri_GetPathAndQuery(IUri *iface, BSTR *pstrPathAndQuery) { - Uri *This = URI_THIS(iface); - FIXME("(%p)->(%p)\n", This, pstrPathAndQuery); - - if(!pstrPathAndQuery) - return E_POINTER; - - return E_NOTIMPL; + TRACE("(%p)->(%p)\n", iface, pstrPathAndQuery); + return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_PATH_AND_QUERY, pstrPathAndQuery, 0); } static HRESULT WINAPI Uri_GetQuery(IUri *iface, BSTR *pstrQuery) { - Uri *This = URI_THIS(iface); - FIXME("(%p)->(%p)\n", This, pstrQuery); - - if(!pstrQuery) - return E_POINTER; - - return E_NOTIMPL; + TRACE("(%p)->(%p)\n", iface, pstrQuery); + return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_QUERY, pstrQuery, 0); } static HRESULT WINAPI Uri_GetRawUri(IUri *iface, BSTR *pstrRawUri) { - Uri *This = URI_THIS(iface); - TRACE("(%p)->(%p)\n", This, pstrRawUri); - - /* Just forward the call to GetPropertyBSTR. */ + TRACE("(%p)->(%p)\n", iface, pstrRawUri); return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_RAW_URI, pstrRawUri, 0); } static HRESULT WINAPI Uri_GetSchemeName(IUri *iface, BSTR *pstrSchemeName) { - Uri *This = URI_THIS(iface); - TRACE("(%p)->(%p)\n", This, pstrSchemeName); + TRACE("(%p)->(%p)\n", iface, pstrSchemeName); return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_SCHEME_NAME, pstrSchemeName, 0); } @@ -1584,24 +4598,14 @@ static HRESULT WINAPI Uri_GetUserName(IUri *iface, BSTR *pstrUserName) static HRESULT WINAPI Uri_GetHostType(IUri *iface, DWORD *pdwHostType) { - Uri *This = URI_THIS(iface); - FIXME("(%p)->(%p)\n", This, pdwHostType); - - if(!pdwHostType) - return E_INVALIDARG; - - return E_NOTIMPL; + TRACE("(%p)->(%p)\n", iface, pdwHostType); + return Uri_GetPropertyDWORD(iface, Uri_PROPERTY_HOST_TYPE, pdwHostType, 0); } static HRESULT WINAPI Uri_GetPort(IUri *iface, DWORD *pdwPort) { - Uri *This = URI_THIS(iface); - FIXME("(%p)->(%p)\n", This, pdwPort); - - if(!pdwPort) - return E_INVALIDARG; - - return E_NOTIMPL; + TRACE("(%p)->(%p)\n", iface, pdwPort); + return Uri_GetPropertyDWORD(iface, Uri_PROPERTY_PORT, pdwPort, 0); } static HRESULT WINAPI Uri_GetScheme(IUri *iface, DWORD *pdwScheme) @@ -1613,33 +4617,63 @@ static HRESULT WINAPI Uri_GetScheme(IUri *iface, DWORD *pdwScheme) static HRESULT WINAPI Uri_GetZone(IUri *iface, DWORD *pdwZone) { - Uri *This = URI_THIS(iface); - FIXME("(%p)->(%p)\n", This, pdwZone); - - if(!pdwZone) - return E_INVALIDARG; - - /* Microsoft doesn't seem to have this implemented yet... See - * the comment in Uri_GetPropertyDWORD for more about this. - */ - *pdwZone = URLZONE_INVALID; - return E_NOTIMPL; + TRACE("(%p)->(%p)\n", iface, pdwZone); + return Uri_GetPropertyDWORD(iface, Uri_PROPERTY_ZONE,pdwZone, 0); } static HRESULT WINAPI Uri_GetProperties(IUri *iface, DWORD *pdwProperties) { Uri *This = URI_THIS(iface); - FIXME("(%p)->(%p)\n", This, pdwProperties); + TRACE("(%p)->(%p)\n", This, pdwProperties); if(!pdwProperties) return E_INVALIDARG; - return E_NOTIMPL; + /* All URIs have these. */ + *pdwProperties = Uri_HAS_DISPLAY_URI|Uri_HAS_RAW_URI|Uri_HAS_SCHEME|Uri_HAS_HOST_TYPE; + + if(This->display_absolute) + *pdwProperties |= Uri_HAS_ABSOLUTE_URI; + + if(This->scheme_start > -1) + *pdwProperties |= Uri_HAS_SCHEME_NAME; + + if(This->authority_start > -1) { + *pdwProperties |= Uri_HAS_AUTHORITY; + if(This->userinfo_start > -1) { + *pdwProperties |= Uri_HAS_USER_INFO; + if(This->userinfo_split != 0) + *pdwProperties |= Uri_HAS_USER_NAME; + } + if(This->userinfo_split > -1) + *pdwProperties |= Uri_HAS_PASSWORD; + if(This->host_start > -1) + *pdwProperties |= Uri_HAS_HOST; + if(This->domain_offset > -1) + *pdwProperties |= Uri_HAS_DOMAIN; + } + + if(This->has_port) + *pdwProperties |= Uri_HAS_PORT; + if(This->path_start > -1) + *pdwProperties |= Uri_HAS_PATH|Uri_HAS_PATH_AND_QUERY; + if(This->query_start > -1) + *pdwProperties |= Uri_HAS_QUERY|Uri_HAS_PATH_AND_QUERY; + + if(This->extension_offset > -1) + *pdwProperties |= Uri_HAS_EXTENSION; + + if(This->fragment_start > -1) + *pdwProperties |= Uri_HAS_FRAGMENT; + + return S_OK; } static HRESULT WINAPI Uri_IsEqual(IUri *iface, IUri *pUri, BOOL *pfEqual) { Uri *This = URI_THIS(iface); + Uri *other; + TRACE("(%p)->(%p %p)\n", This, pUri, pfEqual); if(!pfEqual) @@ -1652,8 +4686,16 @@ static HRESULT WINAPI Uri_IsEqual(IUri *iface, IUri *pUri, BOOL *pfEqual) return S_OK; } - FIXME("(%p)->(%p %p)\n", This, pUri, pfEqual); - return E_NOTIMPL; + /* Try to convert it to a Uri (allows for a more simple comparison). */ + if((other = get_uri_obj(pUri))) + *pfEqual = are_equal_simple(This, other); + else { + /* Do it the hard way. */ + FIXME("(%p)->(%p %p) No support for unknown IUri's yet.\n", iface, pUri, pfEqual); + return E_NOTIMPL; + } + + return S_OK; } #undef URI_THIS @@ -1691,9 +4733,35 @@ static const IUriVtbl UriVtbl = { /*********************************************************************** * CreateUri (urlmon.@) + * + * Creates a new IUri object using the URI represented by pwzURI. This function + * parses and validates the components of pwzURI and then canonicalizes the + * parsed components. + * + * PARAMS + * pwzURI [I] The URI to parse, validate, and canonicalize. + * dwFlags [I] Flags which can affect how the parsing/canonicalization is performed. + * dwReserved [I] Reserved (not used). + * ppURI [O] The resulting IUri after parsing/canonicalization occurs. + * + * RETURNS + * Success: Returns S_OK. ppURI contains the pointer to the newly allocated IUri. + * Failure: E_INVALIDARG if there's invalid flag combinations in dwFlags, or an + * invalid parameters, or pwzURI doesn't represnt a valid URI. + * E_OUTOFMEMORY if any memory allocation fails. + * + * NOTES + * Default flags: + * Uri_CREATE_CANONICALIZE, Uri_CREATE_DECODE_EXTRA_INFO, Uri_CREATE_CRACK_UNKNOWN_SCHEMES, + * Uri_CREATE_PRE_PROCESS_HTML_URI, Uri_CREATE_NO_IE_SETTINGS. */ HRESULT WINAPI CreateUri(LPCWSTR pwzURI, DWORD dwFlags, DWORD_PTR dwReserved, IUri **ppURI) { + const DWORD supported_flags = Uri_CREATE_ALLOW_RELATIVE|Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME| + Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME|Uri_CREATE_NO_CANONICALIZE|Uri_CREATE_CANONICALIZE| + Uri_CREATE_DECODE_EXTRA_INFO|Uri_CREATE_NO_DECODE_EXTRA_INFO|Uri_CREATE_CRACK_UNKNOWN_SCHEMES| + Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES|Uri_CREATE_PRE_PROCESS_HTML_URI|Uri_CREATE_NO_PRE_PROCESS_HTML_URI| + Uri_CREATE_NO_IE_SETTINGS|Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS|Uri_CREATE_FILE_USE_DOS_PATH; Uri *ret; HRESULT hr; parse_data data; @@ -1703,11 +4771,21 @@ HRESULT WINAPI CreateUri(LPCWSTR pwzURI, DWORD dwFlags, DWORD_PTR dwReserved, IU if(!ppURI) return E_INVALIDARG; - if(!pwzURI) { + if(!pwzURI || !*pwzURI) { *ppURI = NULL; return E_INVALIDARG; } + /* Check for invalid flags. */ + if(has_invalid_flag_combination(dwFlags)) { + *ppURI = NULL; + return E_INVALIDARG; + } + + /* Currently unsupported. */ + if(dwFlags & ~supported_flags) + FIXME("Ignoring unsupported flag(s) %x\n", dwFlags & ~supported_flags); + ret = heap_alloc(sizeof(Uri)); if(!ret) return E_OUTOFMEMORY; @@ -1715,8 +4793,15 @@ HRESULT WINAPI CreateUri(LPCWSTR pwzURI, DWORD dwFlags, DWORD_PTR dwReserved, IU ret->lpIUriVtbl = &UriVtbl; ret->ref = 1; - /* Create a copy of pwzURI and store it as the raw_uri. */ - ret->raw_uri = SysAllocString(pwzURI); + /* Explicitly set the default flags if it doesn't cause a flag conflict. */ + apply_default_flags(&dwFlags); + + /* Pre process the URI, unless told otherwise. */ + if(!(dwFlags & Uri_CREATE_NO_PRE_PROCESS_HTML_URI)) + ret->raw_uri = pre_process_uri(pwzURI); + else + ret->raw_uri = SysAllocString(pwzURI); + if(!ret->raw_uri) { heap_free(ret); return E_OUTOFMEMORY; @@ -1743,10 +4828,86 @@ HRESULT WINAPI CreateUri(LPCWSTR pwzURI, DWORD dwFlags, DWORD_PTR dwReserved, IU return hr; } + ret->create_flags = dwFlags; + *ppURI = URI(ret); return S_OK; } +/*********************************************************************** + * CreateUriWithFragment (urlmon.@) + * + * Creates a new IUri object. This is almost the same as CreateUri, expect that + * it allows you to explicitly specify a fragment (pwzFragment) for pwzURI. + * + * PARAMS + * pwzURI [I] The URI to parse and perform canonicalization on. + * pwzFragment [I] The explict fragment string which should be added to pwzURI. + * dwFlags [I] The flags which will be passed to CreateUri. + * dwReserved [I] Reserved (not used). + * ppURI [O] The resulting IUri after parsing/canonicalization. + * + * RETURNS + * Success: S_OK. ppURI contains the pointer to the newly allocated IUri. + * Failure: E_INVALIDARG if pwzURI already contains a fragment and pwzFragment + * isn't NULL. Will also return E_INVALIDARG for the same reasons as + * CreateUri will. E_OUTOFMEMORY if any allocations fail. + */ +HRESULT WINAPI CreateUriWithFragment(LPCWSTR pwzURI, LPCWSTR pwzFragment, DWORD dwFlags, + DWORD_PTR dwReserved, IUri **ppURI) +{ + HRESULT hres; + TRACE("(%s %s %x %x %p)\n", debugstr_w(pwzURI), debugstr_w(pwzFragment), dwFlags, (DWORD)dwReserved, ppURI); + + if(!ppURI) + return E_INVALIDARG; + + if(!pwzURI) { + *ppURI = NULL; + return E_INVALIDARG; + } + + /* Check if a fragment should be appended to the URI string. */ + if(pwzFragment) { + WCHAR *uriW; + DWORD uri_len, frag_len; + BOOL add_pound; + + /* Check if the original URI already has a fragment component. */ + if(StrChrW(pwzURI, '#')) { + *ppURI = NULL; + return E_INVALIDARG; + } + + uri_len = lstrlenW(pwzURI); + frag_len = lstrlenW(pwzFragment); + + /* If the fragment doesn't start with a '#', one will be added. */ + add_pound = *pwzFragment != '#'; + + if(add_pound) + uriW = heap_alloc((uri_len+frag_len+2)*sizeof(WCHAR)); + else + uriW = heap_alloc((uri_len+frag_len+1)*sizeof(WCHAR)); + + if(!uriW) + return E_OUTOFMEMORY; + + memcpy(uriW, pwzURI, uri_len*sizeof(WCHAR)); + if(add_pound) + uriW[uri_len++] = '#'; + memcpy(uriW+uri_len, pwzFragment, (frag_len+1)*sizeof(WCHAR)); + + hres = CreateUri(uriW, dwFlags, 0, ppURI); + + heap_free(uriW); + } else + /* A fragment string wasn't specified, so just forward the call. */ + hres = CreateUri(pwzURI, dwFlags, 0, ppURI); + + return hres; +} + #define URIBUILDER_THIS(iface) DEFINE_THIS(UriBuilder, IUriBuilder, iface) static HRESULT WINAPI UriBuilder_QueryInterface(IUriBuilder *iface, REFIID riid, void **ppv) @@ -1786,8 +4947,17 @@ static ULONG WINAPI UriBuilder_Release(IUriBuilder *iface) TRACE("(%p) ref=%d\n", This, ref); - if(!ref) + if(!ref) { + if(This->uri) IUri_Release(URI(This->uri)); + heap_free(This->fragment); + heap_free(This->host); + heap_free(This->password); + heap_free(This->path); + heap_free(This->query); + heap_free(This->scheme); + heap_free(This->username); heap_free(This); + } return ref; } @@ -1798,8 +4968,13 @@ static HRESULT WINAPI UriBuilder_CreateUriSimple(IUriBuilder *iface, IUri **ppIUri) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%d %d %p)\n", This, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri); - return E_NOTIMPL; + HRESULT hr; + TRACE("(%p)->(%d %d %p)\n", This, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri); + + hr = build_uri(This, ppIUri, 0, UriBuilder_USE_ORIGINAL_FLAGS, dwAllowEncodingPropertyMask); + if(hr == E_NOTIMPL) + FIXME("(%p)->(%d %d %p)\n", This, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri); + return hr; } static HRESULT WINAPI UriBuilder_CreateUri(IUriBuilder *iface, @@ -1809,8 +4984,17 @@ static HRESULT WINAPI UriBuilder_CreateUri(IUriBuilder *iface, IUri **ppIUri) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(0x%08x %d %d %p)\n", This, dwCreateFlags, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri); - return E_NOTIMPL; + HRESULT hr; + TRACE("(%p)->(0x%08x %d %d %p)\n", This, dwCreateFlags, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri); + + if(dwCreateFlags == -1) + hr = build_uri(This, ppIUri, 0, UriBuilder_USE_ORIGINAL_FLAGS, dwAllowEncodingPropertyMask); + else + hr = build_uri(This, ppIUri, dwCreateFlags, 0, dwAllowEncodingPropertyMask); + + if(hr == E_NOTIMPL) + FIXME("(%p)->(0x%08x %d %d %p)\n", This, dwCreateFlags, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri); + return hr; } static HRESULT WINAPI UriBuilder_CreateUriWithFlags(IUriBuilder *iface, @@ -1821,149 +5005,317 @@ static HRESULT WINAPI UriBuilder_CreateUriWithFlags(IUriBuilder *iface, IUri **ppIUri) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(0x%08x 0x%08x %d %d %p)\n", This, dwCreateFlags, dwUriBuilderFlags, + HRESULT hr; + TRACE("(%p)->(0x%08x 0x%08x %d %d %p)\n", This, dwCreateFlags, dwUriBuilderFlags, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri); - return E_NOTIMPL; + + hr = build_uri(This, ppIUri, dwCreateFlags, dwUriBuilderFlags, dwAllowEncodingPropertyMask); + if(hr == E_NOTIMPL) + FIXME("(%p)->(0x%08x 0x%08x %d %d %p)\n", This, dwCreateFlags, dwUriBuilderFlags, + dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri); + return hr; } static HRESULT WINAPI UriBuilder_GetIUri(IUriBuilder *iface, IUri **ppIUri) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%p)\n", This, ppIUri); - return E_NOTIMPL; + TRACE("(%p)->(%p)\n", This, ppIUri); + + if(!ppIUri) + return E_POINTER; + + if(This->uri) { + IUri *uri = URI(This->uri); + IUri_AddRef(uri); + *ppIUri = uri; + } else + *ppIUri = NULL; + + return S_OK; } static HRESULT WINAPI UriBuilder_SetIUri(IUriBuilder *iface, IUri *pIUri) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%p)\n", This, pIUri); - return E_NOTIMPL; + TRACE("(%p)->(%p)\n", This, pIUri); + + if(pIUri) { + Uri *uri; + + if((uri = get_uri_obj(pIUri))) { + /* Only reset the builder if it's Uri isn't the same as + * the Uri passed to the function. + */ + if(This->uri != uri) { + reset_builder(This); + + This->uri = uri; + if(uri->has_port) + This->port = uri->port; + + IUri_AddRef(pIUri); + } + } else { + FIXME("(%p)->(%p) Unknown IUri types not supported yet.\n", This, pIUri); + return E_NOTIMPL; + } + } else if(This->uri) + /* Only reset the builder if it's Uri isn't NULL. */ + reset_builder(This); + + return S_OK; } static HRESULT WINAPI UriBuilder_GetFragment(IUriBuilder *iface, DWORD *pcchFragment, LPCWSTR *ppwzFragment) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%p %p)\n", This, pcchFragment, ppwzFragment); - return E_NOTIMPL; + TRACE("(%p)->(%p %p)\n", This, pcchFragment, ppwzFragment); + + if(!This->uri || This->uri->fragment_start == -1 || This->modified_props & Uri_HAS_FRAGMENT) + return get_builder_component(&This->fragment, &This->fragment_len, NULL, 0, ppwzFragment, pcchFragment); + else + return get_builder_component(&This->fragment, &This->fragment_len, This->uri->canon_uri+This->uri->fragment_start, + This->uri->fragment_len, ppwzFragment, pcchFragment); } static HRESULT WINAPI UriBuilder_GetHost(IUriBuilder *iface, DWORD *pcchHost, LPCWSTR *ppwzHost) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%p %p)\n", This, pcchHost, ppwzHost); - return E_NOTIMPL; + TRACE("(%p)->(%p %p)\n", This, pcchHost, ppwzHost); + + if(!This->uri || This->uri->host_start == -1 || This->modified_props & Uri_HAS_HOST) + return get_builder_component(&This->host, &This->host_len, NULL, 0, ppwzHost, pcchHost); + else { + if(This->uri->host_type == Uri_HOST_IPV6) + /* Don't include the '[' and ']' around the address. */ + return get_builder_component(&This->host, &This->host_len, This->uri->canon_uri+This->uri->host_start+1, + This->uri->host_len-2, ppwzHost, pcchHost); + else + return get_builder_component(&This->host, &This->host_len, This->uri->canon_uri+This->uri->host_start, + This->uri->host_len, ppwzHost, pcchHost); + } } static HRESULT WINAPI UriBuilder_GetPassword(IUriBuilder *iface, DWORD *pcchPassword, LPCWSTR *ppwzPassword) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%p %p)\n", This, pcchPassword, ppwzPassword); - return E_NOTIMPL; + TRACE("(%p)->(%p %p)\n", This, pcchPassword, ppwzPassword); + + if(!This->uri || This->uri->userinfo_split == -1 || This->modified_props & Uri_HAS_PASSWORD) + return get_builder_component(&This->password, &This->password_len, NULL, 0, ppwzPassword, pcchPassword); + else { + const WCHAR *start = This->uri->canon_uri+This->uri->userinfo_start+This->uri->userinfo_split+1; + DWORD len = This->uri->userinfo_len-This->uri->userinfo_split-1; + return get_builder_component(&This->password, &This->password_len, start, len, ppwzPassword, pcchPassword); + } } static HRESULT WINAPI UriBuilder_GetPath(IUriBuilder *iface, DWORD *pcchPath, LPCWSTR *ppwzPath) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%p %p)\n", This, pcchPath, ppwzPath); - return E_NOTIMPL; + TRACE("(%p)->(%p %p)\n", This, pcchPath, ppwzPath); + + if(!This->uri || This->uri->path_start == -1 || This->modified_props & Uri_HAS_PATH) + return get_builder_component(&This->path, &This->path_len, NULL, 0, ppwzPath, pcchPath); + else + return get_builder_component(&This->path, &This->path_len, This->uri->canon_uri+This->uri->path_start, + This->uri->path_len, ppwzPath, pcchPath); } static HRESULT WINAPI UriBuilder_GetPort(IUriBuilder *iface, BOOL *pfHasPort, DWORD *pdwPort) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%p %p)\n", This, pfHasPort, pdwPort); - return E_NOTIMPL; + TRACE("(%p)->(%p %p)\n", This, pfHasPort, pdwPort); + + if(!pfHasPort) { + if(pdwPort) + *pdwPort = 0; + return E_POINTER; + } + + if(!pdwPort) { + *pfHasPort = FALSE; + return E_POINTER; + } + + *pfHasPort = This->has_port; + *pdwPort = This->port; + return S_OK; } static HRESULT WINAPI UriBuilder_GetQuery(IUriBuilder *iface, DWORD *pcchQuery, LPCWSTR *ppwzQuery) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%p %p)\n", This, pcchQuery, ppwzQuery); - return E_NOTIMPL; + TRACE("(%p)->(%p %p)\n", This, pcchQuery, ppwzQuery); + + if(!This->uri || This->uri->query_start == -1 || This->modified_props & Uri_HAS_QUERY) + return get_builder_component(&This->query, &This->query_len, NULL, 0, ppwzQuery, pcchQuery); + else + return get_builder_component(&This->query, &This->query_len, This->uri->canon_uri+This->uri->query_start, + This->uri->query_len, ppwzQuery, pcchQuery); } static HRESULT WINAPI UriBuilder_GetSchemeName(IUriBuilder *iface, DWORD *pcchSchemeName, LPCWSTR *ppwzSchemeName) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%p %p)\n", This, pcchSchemeName, ppwzSchemeName); - return E_NOTIMPL; + TRACE("(%p)->(%p %p)\n", This, pcchSchemeName, ppwzSchemeName); + + if(!This->uri || This->uri->scheme_start == -1 || This->modified_props & Uri_HAS_SCHEME_NAME) + return get_builder_component(&This->scheme, &This->scheme_len, NULL, 0, ppwzSchemeName, pcchSchemeName); + else + return get_builder_component(&This->scheme, &This->scheme_len, This->uri->canon_uri+This->uri->scheme_start, + This->uri->scheme_len, ppwzSchemeName, pcchSchemeName); } static HRESULT WINAPI UriBuilder_GetUserName(IUriBuilder *iface, DWORD *pcchUserName, LPCWSTR *ppwzUserName) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%p %p)\n", This, pcchUserName, ppwzUserName); - return E_NOTIMPL; + TRACE("(%p)->(%p %p)\n", This, pcchUserName, ppwzUserName); + + if(!This->uri || This->uri->userinfo_start == -1 || This->uri->userinfo_split == 0 || + This->modified_props & Uri_HAS_USER_NAME) + return get_builder_component(&This->username, &This->username_len, NULL, 0, ppwzUserName, pcchUserName); + else { + const WCHAR *start = This->uri->canon_uri+This->uri->userinfo_start; + + /* Check if there's a password in the userinfo section. */ + if(This->uri->userinfo_split > -1) + /* Don't include the password. */ + return get_builder_component(&This->username, &This->username_len, start, + This->uri->userinfo_split, ppwzUserName, pcchUserName); + else + return get_builder_component(&This->username, &This->username_len, start, + This->uri->userinfo_len, ppwzUserName, pcchUserName); + } } static HRESULT WINAPI UriBuilder_SetFragment(IUriBuilder *iface, LPCWSTR pwzNewValue) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue)); - return E_NOTIMPL; + TRACE("(%p)->(%s)\n", This, debugstr_w(pwzNewValue)); + return set_builder_component(&This->fragment, &This->fragment_len, pwzNewValue, '#', + &This->modified_props, Uri_HAS_FRAGMENT); } static HRESULT WINAPI UriBuilder_SetHost(IUriBuilder *iface, LPCWSTR pwzNewValue) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue)); - return E_NOTIMPL; + TRACE("(%p)->(%s)\n", This, debugstr_w(pwzNewValue)); + + /* Host name can't be set to NULL. */ + if(!pwzNewValue) + return E_INVALIDARG; + + return set_builder_component(&This->host, &This->host_len, pwzNewValue, 0, + &This->modified_props, Uri_HAS_HOST); } static HRESULT WINAPI UriBuilder_SetPassword(IUriBuilder *iface, LPCWSTR pwzNewValue) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue)); - return E_NOTIMPL; + TRACE("(%p)->(%s)\n", This, debugstr_w(pwzNewValue)); + return set_builder_component(&This->password, &This->password_len, pwzNewValue, 0, + &This->modified_props, Uri_HAS_PASSWORD); } static HRESULT WINAPI UriBuilder_SetPath(IUriBuilder *iface, LPCWSTR pwzNewValue) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue)); - return E_NOTIMPL; + TRACE("(%p)->(%s)\n", This, debugstr_w(pwzNewValue)); + return set_builder_component(&This->path, &This->path_len, pwzNewValue, 0, + &This->modified_props, Uri_HAS_PATH); } static HRESULT WINAPI UriBuilder_SetPort(IUriBuilder *iface, BOOL fHasPort, DWORD dwNewValue) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%d %d)\n", This, fHasPort, dwNewValue); - return E_NOTIMPL; + TRACE("(%p)->(%d %d)\n", This, fHasPort, dwNewValue); + + This->has_port = fHasPort; + This->port = dwNewValue; + This->modified_props |= Uri_HAS_PORT; + return S_OK; } static HRESULT WINAPI UriBuilder_SetQuery(IUriBuilder *iface, LPCWSTR pwzNewValue) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue)); - return E_NOTIMPL; + TRACE("(%p)->(%s)\n", This, debugstr_w(pwzNewValue)); + return set_builder_component(&This->query, &This->query_len, pwzNewValue, '?', + &This->modified_props, Uri_HAS_QUERY); } static HRESULT WINAPI UriBuilder_SetSchemeName(IUriBuilder *iface, LPCWSTR pwzNewValue) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue)); - return E_NOTIMPL; + TRACE("(%p)->(%s)\n", This, debugstr_w(pwzNewValue)); + + /* Only set the scheme name if it's not NULL or empty. */ + if(!pwzNewValue || !*pwzNewValue) + return E_INVALIDARG; + + return set_builder_component(&This->scheme, &This->scheme_len, pwzNewValue, 0, + &This->modified_props, Uri_HAS_SCHEME_NAME); } static HRESULT WINAPI UriBuilder_SetUserName(IUriBuilder *iface, LPCWSTR pwzNewValue) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%s)\n", This, debugstr_w(pwzNewValue)); - return E_NOTIMPL; + TRACE("(%p)->(%s)\n", This, debugstr_w(pwzNewValue)); + return set_builder_component(&This->username, &This->username_len, pwzNewValue, 0, + &This->modified_props, Uri_HAS_USER_NAME); } static HRESULT WINAPI UriBuilder_RemoveProperties(IUriBuilder *iface, DWORD dwPropertyMask) { + const DWORD accepted_flags = Uri_HAS_AUTHORITY|Uri_HAS_DOMAIN|Uri_HAS_EXTENSION|Uri_HAS_FRAGMENT|Uri_HAS_HOST| + Uri_HAS_PASSWORD|Uri_HAS_PATH|Uri_HAS_PATH_AND_QUERY|Uri_HAS_QUERY| + Uri_HAS_USER_INFO|Uri_HAS_USER_NAME; + UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(0x%08x)\n", This, dwPropertyMask); - return E_NOTIMPL; + TRACE("(%p)->(0x%08x)\n", This, dwPropertyMask); + + if(dwPropertyMask & ~accepted_flags) + return E_INVALIDARG; + + if(dwPropertyMask & Uri_HAS_FRAGMENT) + UriBuilder_SetFragment(iface, NULL); + + /* Even though you can't set the host name to NULL or an + * empty string, you can still remove it... for some reason. + */ + if(dwPropertyMask & Uri_HAS_HOST) + set_builder_component(&This->host, &This->host_len, NULL, 0, + &This->modified_props, Uri_HAS_HOST); + + if(dwPropertyMask & Uri_HAS_PASSWORD) + UriBuilder_SetPassword(iface, NULL); + + if(dwPropertyMask & Uri_HAS_PATH) + UriBuilder_SetPath(iface, NULL); + + if(dwPropertyMask & Uri_HAS_PORT) + UriBuilder_SetPort(iface, FALSE, 0); + + if(dwPropertyMask & Uri_HAS_QUERY) + UriBuilder_SetQuery(iface, NULL); + + if(dwPropertyMask & Uri_HAS_USER_NAME) + UriBuilder_SetUserName(iface, NULL); + + return S_OK; } static HRESULT WINAPI UriBuilder_HasBeenModified(IUriBuilder *iface, BOOL *pfModified) { UriBuilder *This = URIBUILDER_THIS(iface); - FIXME("(%p)->(%p)\n", This, pfModified); - return E_NOTIMPL; + TRACE("(%p)->(%p)\n", This, pfModified); + + if(!pfModified) + return E_POINTER; + + *pfModified = This->modified_props > 0; + return S_OK; } #undef URIBUILDER_THIS @@ -2006,13 +5358,36 @@ HRESULT WINAPI CreateIUriBuilder(IUri *pIUri, DWORD dwFlags, DWORD_PTR dwReserve TRACE("(%p %x %x %p)\n", pIUri, dwFlags, (DWORD)dwReserved, ppIUriBuilder); - ret = heap_alloc(sizeof(UriBuilder)); + if(!ppIUriBuilder) + return E_POINTER; + + ret = heap_alloc_zero(sizeof(UriBuilder)); if(!ret) return E_OUTOFMEMORY; ret->lpIUriBuilderVtbl = &UriBuilderVtbl; ret->ref = 1; + if(pIUri) { + Uri *uri; + + if((uri = get_uri_obj(pIUri))) { + IUri_AddRef(pIUri); + ret->uri = uri; + + if(uri->has_port) + /* Windows doesn't set 'has_port' to TRUE in this case. */ + ret->port = uri->port; + + } else { + heap_free(ret); + *ppIUriBuilder = NULL; + FIXME("(%p %x %x %p): Unknown IUri types not supported yet.\n", pIUri, dwFlags, + (DWORD)dwReserved, ppIUriBuilder); + return E_NOTIMPL; + } + } + *ppIUriBuilder = URIBUILDER(ret); return S_OK; } diff --git a/reactos/dll/win32/urlmon/urlmon.spec b/reactos/dll/win32/urlmon/urlmon.spec index e79850c4f19..61093850d24 100644 --- a/reactos/dll/win32/urlmon/urlmon.spec +++ b/reactos/dll/win32/urlmon/urlmon.spec @@ -29,6 +29,7 @@ @ stdcall CreateFormatEnumerator(long ptr ptr) @ stdcall CreateIUriBuilder(ptr long long ptr) @ stdcall CreateUri(wstr long long ptr) +@ stdcall CreateUriWithFragment(wstr wstr long long ptr) @ stdcall CreateURLMoniker(ptr wstr ptr) @ stdcall CreateURLMonikerEx(ptr wstr ptr long) @ stdcall -private DllCanUnloadNow() diff --git a/reactos/dll/win32/urlmon/urlmon_main.h b/reactos/dll/win32/urlmon/urlmon_main.h index 071af8dd73e..3aada09ce60 100644 --- a/reactos/dll/win32/urlmon/urlmon_main.h +++ b/reactos/dll/win32/urlmon/urlmon_main.h @@ -78,7 +78,7 @@ HRESULT bind_to_storage(LPCWSTR url, IBindCtx *pbc, REFIID riid, void **ppv); HRESULT bind_to_object(IMoniker *mon, LPCWSTR url, IBindCtx *pbc, REFIID riid, void **ppv); HRESULT create_binding_protocol(LPCWSTR url, BOOL from_urlmon, IInternetProtocol **protocol); -void set_binding_sink(IInternetProtocol *bind_protocol, IInternetProtocolSink *sink); +void set_binding_sink(IInternetProtocol *bind_protocol, IInternetProtocolSink *sink, IInternetBindInfo *bind_info); IWinInetInfo *get_wininet_info(IInternetProtocol*); typedef struct ProtocolVtbl ProtocolVtbl; @@ -105,12 +105,12 @@ typedef struct { } Protocol; struct ProtocolVtbl { - HRESULT (*open_request)(Protocol*,LPCWSTR,DWORD,HINTERNET,IInternetBindInfo*); + HRESULT (*open_request)(Protocol*,IUri*,DWORD,HINTERNET,IInternetBindInfo*); HRESULT (*start_downloading)(Protocol*); void (*close_connection)(Protocol*); }; -HRESULT protocol_start(Protocol*,IInternetProtocol*,LPCWSTR,IInternetProtocolSink*,IInternetBindInfo*); +HRESULT protocol_start(Protocol*,IInternetProtocol*,IUri*,IInternetProtocolSink*,IInternetBindInfo*); HRESULT protocol_continue(Protocol*,PROTOCOLDATA*); HRESULT protocol_read(Protocol*,void*,ULONG,ULONG*); HRESULT protocol_lock_request(Protocol*); diff --git a/reactos/dll/win32/winhttp/cookie.c b/reactos/dll/win32/winhttp/cookie.c index 6c0f8b448e5..af881ea2915 100644 --- a/reactos/dll/win32/winhttp/cookie.c +++ b/reactos/dll/win32/winhttp/cookie.c @@ -39,7 +39,7 @@ static domain_t *add_domain( session_t *session, WCHAR *name ) list_init( &domain->entry ); list_init( &domain->cookies ); - domain->name = name; + domain->name = strdupW( name ); list_add_tail( &session->cookie_cache, &domain->entry ); TRACE("%s\n", debugstr_w(domain->name)); @@ -120,7 +120,7 @@ static BOOL add_cookie( session_t *session, cookie_t *cookie, WCHAR *domain_name } else if ((old_cookie = find_cookie( domain, path, cookie->name ))) delete_cookie( old_cookie ); - cookie->path = path; + cookie->path = strdupW( path ); list_add_tail( &domain->cookies, &cookie->entry ); TRACE("domain %s path %s <- %s=%s\n", debugstr_w(domain_name), debugstr_w(cookie->path), @@ -230,12 +230,9 @@ BOOL set_cookies( request_t *request, const WCHAR *cookies ) ret = add_cookie( session, cookie, cookie_domain, cookie_path ); end: - if (!ret) - { - free_cookie( cookie ); - heap_free( cookie_domain ); - heap_free( cookie_path ); - } + if (!ret) free_cookie( cookie ); + heap_free( cookie_domain ); + heap_free( cookie_path ); heap_free( buffer ); return ret; } diff --git a/reactos/dll/win32/winhttp/inet_ntop.c b/reactos/dll/win32/winhttp/inet_ntop.c index f29d46d1625..3ed42ef6bb0 100644 --- a/reactos/dll/win32/winhttp/inet_ntop.c +++ b/reactos/dll/win32/winhttp/inet_ntop.c @@ -16,8 +16,7 @@ * SOFTWARE. */ -#define ENOSPC 28 -#define EAFNOSUPPORT 52 +#include #ifndef IN6ADDRSZ #define IN6ADDRSZ 16 @@ -64,7 +63,7 @@ inet_ntop(int af, const void *src, char *dst, size_t size) return (inet_ntop6(src, dst, size)); #endif default: - errno = EAFNOSUPPORT; + WSASetLastError(WSAEAFNOSUPPORT); return (NULL); } /* NOTREACHED */ @@ -88,7 +87,7 @@ inet_ntop4(const u_char *src, char *dst, size_t size) char tmp[sizeof "255.255.255.255"]; if (SPRINTF((tmp, fmt, src[0], src[1], src[2], src[3])) > size) { - errno = ENOSPC; + WSASetLastError(WSAEINVAL); return (NULL); } strcpy(dst, tmp); @@ -182,7 +181,7 @@ inet_ntop6(const u_char *src, char *dst, size_t size) * Check for overflow, copy, and we're done. */ if ((size_t)(tp - tmp) > size) { - errno = ENOSPC; + WSASetLastError(WSAEINVAL); return (NULL); } strcpy(dst, tmp); diff --git a/reactos/dll/win32/winhttp/main.c b/reactos/dll/win32/winhttp/main.c index c0ac9cbe51b..b1ce75df4b4 100644 --- a/reactos/dll/win32/winhttp/main.c +++ b/reactos/dll/win32/winhttp/main.c @@ -42,6 +42,7 @@ BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv) DisableThreadLibraryCalls(hInstDLL); break; case DLL_PROCESS_DETACH: + netconn_unload(); break; } return TRUE; @@ -61,7 +62,6 @@ HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) */ HRESULT WINAPI DllCanUnloadNow(void) { - FIXME("()\n"); return S_FALSE; } diff --git a/reactos/dll/win32/winhttp/net.c b/reactos/dll/win32/winhttp/net.c index 897ccbe3e21..d709c311816 100644 --- a/reactos/dll/win32/winhttp/net.c +++ b/reactos/dll/win32/winhttp/net.c @@ -38,10 +38,13 @@ #endif #ifdef HAVE_OPENSSL_SSL_H # include +# include #undef FAR #undef DSA #endif +#define NONAMELESSUNION + #include "wine/debug.h" #include "wine/library.h" @@ -58,10 +61,6 @@ WINE_DEFAULT_DEBUG_CHANNEL(winhttp); -#define DEFAULT_SEND_TIMEOUT 30 -#define DEFAULT_RECEIVE_TIMEOUT 30 -#define RESPONSE_TIMEOUT 30 - #ifndef HAVE_GETADDRINFO /* critical section to protect non-reentrant gethostbyname() */ @@ -80,17 +79,35 @@ static CRITICAL_SECTION cs_gethostbyname = { &critsect_debug, -1, 0, 0, 0, 0 }; #include +static CRITICAL_SECTION init_ssl_cs; +static CRITICAL_SECTION_DEBUG init_ssl_cs_debug = +{ + 0, 0, &init_ssl_cs, + { &init_ssl_cs_debug.ProcessLocksList, + &init_ssl_cs_debug.ProcessLocksList }, + 0, 0, { (DWORD_PTR)(__FILE__ ": init_ssl_cs") } +}; +static CRITICAL_SECTION init_ssl_cs = { &init_ssl_cs_debug, -1, 0, 0, 0, 0 }; + static void *libssl_handle; static void *libcrypto_handle; +#if defined(OPENSSL_VERSION_NUMBER) && (OPENSSL_VERSION_NUMBER> 0x1000000) +static const SSL_METHOD *method; +#else static SSL_METHOD *method; +#endif static SSL_CTX *ctx; +static int hostname_idx; +static int error_idx; +static int conn_idx; #define MAKE_FUNCPTR(f) static typeof(f) * p##f MAKE_FUNCPTR( SSL_library_init ); MAKE_FUNCPTR( SSL_load_error_strings ); MAKE_FUNCPTR( SSLv23_method ); +MAKE_FUNCPTR( SSL_CTX_free ); MAKE_FUNCPTR( SSL_CTX_new ); MAKE_FUNCPTR( SSL_new ); MAKE_FUNCPTR( SSL_free ); @@ -99,21 +116,49 @@ MAKE_FUNCPTR( SSL_connect ); MAKE_FUNCPTR( SSL_shutdown ); MAKE_FUNCPTR( SSL_write ); MAKE_FUNCPTR( SSL_read ); -MAKE_FUNCPTR( SSL_get_verify_result ); +MAKE_FUNCPTR( SSL_get_error ); +MAKE_FUNCPTR( SSL_get_ex_new_index ); +MAKE_FUNCPTR( SSL_get_ex_data ); +MAKE_FUNCPTR( SSL_set_ex_data ); +MAKE_FUNCPTR( SSL_get_ex_data_X509_STORE_CTX_idx ); MAKE_FUNCPTR( SSL_get_peer_certificate ); -MAKE_FUNCPTR( SSL_CTX_get_timeout ); -MAKE_FUNCPTR( SSL_CTX_set_timeout ); MAKE_FUNCPTR( SSL_CTX_set_default_verify_paths ); +MAKE_FUNCPTR( SSL_CTX_set_verify ); +MAKE_FUNCPTR( SSL_get_current_cipher ); +MAKE_FUNCPTR( SSL_CIPHER_get_bits ); -MAKE_FUNCPTR( BIO_new_fp ); +MAKE_FUNCPTR( CRYPTO_num_locks ); +MAKE_FUNCPTR( CRYPTO_set_id_callback ); +MAKE_FUNCPTR( CRYPTO_set_locking_callback ); +MAKE_FUNCPTR( ERR_free_strings ); MAKE_FUNCPTR( ERR_get_error ); MAKE_FUNCPTR( ERR_error_string ); +MAKE_FUNCPTR( X509_STORE_CTX_get_ex_data ); MAKE_FUNCPTR( i2d_X509 ); +MAKE_FUNCPTR( sk_value ); +MAKE_FUNCPTR( sk_num ); #undef MAKE_FUNCPTR +static CRITICAL_SECTION *ssl_locks; +static unsigned int num_ssl_locks; + +static unsigned long ssl_thread_id(void) +{ + return GetCurrentThreadId(); +} + +static void ssl_lock_callback(int mode, int type, const char *file, int line) +{ + if (mode & CRYPTO_LOCK) + EnterCriticalSection( &ssl_locks[type] ); + else + LeaveCriticalSection( &ssl_locks[type] ); +} + #endif /* translate a unix error code into a winsock error code */ +#if 0 static int sock_get_error( int err ) { #if !defined(__MINGW32__) && !defined (_MSC_VER) @@ -179,24 +224,222 @@ static int sock_get_error( int err ) #endif return err; } +#else +#define sock_get_error(x) WSAGetLastError() +#endif + +#ifdef SONAME_LIBSSL +static PCCERT_CONTEXT X509_to_cert_context(X509 *cert) +{ + unsigned char *buffer, *p; + int len; + BOOL malloc = FALSE; + PCCERT_CONTEXT ret; + + p = NULL; + if ((len = pi2d_X509( cert, &p )) < 0) return NULL; + /* + * SSL 0.9.7 and above malloc the buffer if it is null. + * however earlier version do not and so we would need to alloc the buffer. + * + * see the i2d_X509 man page for more details. + */ + if (!p) + { + if (!(buffer = heap_alloc( len ))) return NULL; + p = buffer; + len = pi2d_X509( cert, &p ); + } + else + { + buffer = p; + malloc = TRUE; + } + + ret = CertCreateCertificateContext( X509_ASN_ENCODING, buffer, len ); + + if (malloc) free( buffer ); + else heap_free( buffer ); + + return ret; +} + +static DWORD netconn_verify_cert( PCCERT_CONTEXT cert, HCERTSTORE store, + WCHAR *server, DWORD security_flags ) +{ + BOOL ret; + CERT_CHAIN_PARA chainPara = { sizeof(chainPara), { 0 } }; + PCCERT_CHAIN_CONTEXT chain; + char oid_server_auth[] = szOID_PKIX_KP_SERVER_AUTH; + char *server_auth[] = { oid_server_auth }; + DWORD err = ERROR_SUCCESS; + + TRACE("verifying %s\n", debugstr_w( server )); + chainPara.RequestedUsage.Usage.cUsageIdentifier = 1; + chainPara.RequestedUsage.Usage.rgpszUsageIdentifier = server_auth; + if ((ret = CertGetCertificateChain( NULL, cert, NULL, store, &chainPara, 0, + NULL, &chain ))) + { + if (chain->TrustStatus.dwErrorStatus) + { + static const DWORD supportedErrors = + CERT_TRUST_IS_NOT_TIME_VALID | + CERT_TRUST_IS_UNTRUSTED_ROOT | + CERT_TRUST_IS_NOT_VALID_FOR_USAGE; + + if (chain->TrustStatus.dwErrorStatus & CERT_TRUST_IS_NOT_TIME_VALID) + { + if (!(security_flags & SECURITY_FLAG_IGNORE_CERT_DATE_INVALID)) + err = ERROR_WINHTTP_SECURE_CERT_DATE_INVALID; + } + else if (chain->TrustStatus.dwErrorStatus & + CERT_TRUST_IS_UNTRUSTED_ROOT) + { + if (!(security_flags & SECURITY_FLAG_IGNORE_UNKNOWN_CA)) + err = ERROR_WINHTTP_SECURE_INVALID_CA; + } + else if ((chain->TrustStatus.dwErrorStatus & + CERT_TRUST_IS_OFFLINE_REVOCATION) || + (chain->TrustStatus.dwErrorStatus & + CERT_TRUST_REVOCATION_STATUS_UNKNOWN)) + err = ERROR_WINHTTP_SECURE_CERT_REV_FAILED; + else if (chain->TrustStatus.dwErrorStatus & CERT_TRUST_IS_REVOKED) + err = ERROR_WINHTTP_SECURE_CERT_REVOKED; + else if (chain->TrustStatus.dwErrorStatus & + CERT_TRUST_IS_NOT_VALID_FOR_USAGE) + { + if (!(security_flags & SECURITY_FLAG_IGNORE_CERT_WRONG_USAGE)) + err = ERROR_WINHTTP_SECURE_CERT_WRONG_USAGE; + } + else if (chain->TrustStatus.dwErrorStatus & ~supportedErrors) + err = ERROR_WINHTTP_SECURE_INVALID_CERT; + } + if (!err) + { + CERT_CHAIN_POLICY_PARA policyPara; + SSL_EXTRA_CERT_CHAIN_POLICY_PARA sslExtraPolicyPara; + CERT_CHAIN_POLICY_STATUS policyStatus; + CERT_CHAIN_CONTEXT chainCopy; + + /* Clear chain->TrustStatus.dwErrorStatus so + * CertVerifyCertificateChainPolicy will verify additional checks + * rather than stopping with an existing, ignored error. + */ + memcpy(&chainCopy, chain, sizeof(chainCopy)); + chainCopy.TrustStatus.dwErrorStatus = 0; + sslExtraPolicyPara.u.cbSize = sizeof(sslExtraPolicyPara); + sslExtraPolicyPara.dwAuthType = AUTHTYPE_SERVER; + sslExtraPolicyPara.pwszServerName = server; + policyPara.cbSize = sizeof(policyPara); + policyPara.dwFlags = 0; + policyPara.pvExtraPolicyPara = &sslExtraPolicyPara; + ret = CertVerifyCertificateChainPolicy( CERT_CHAIN_POLICY_SSL, + &chainCopy, &policyPara, + &policyStatus ); + /* Any error in the policy status indicates that the + * policy couldn't be verified. + */ + if (ret && policyStatus.dwError) + { + if (policyStatus.dwError == CERT_E_CN_NO_MATCH) + { + if (!(security_flags & SECURITY_FLAG_IGNORE_CERT_CN_INVALID)) + err = ERROR_WINHTTP_SECURE_CERT_CN_INVALID; + } + else + err = ERROR_WINHTTP_SECURE_INVALID_CERT; + } + } + CertFreeCertificateChain( chain ); + } + else + err = ERROR_WINHTTP_SECURE_CHANNEL_ERROR; + TRACE("returning %08x\n", err); + return err; +} + +static int netconn_secure_verify( int preverify_ok, X509_STORE_CTX *ctx ) +{ + SSL *ssl; + WCHAR *server; + BOOL ret = FALSE; + netconn_t *conn; + HCERTSTORE store = CertOpenStore( CERT_STORE_PROV_MEMORY, 0, 0, + CERT_STORE_CREATE_NEW_FLAG, NULL ); + + ssl = pX509_STORE_CTX_get_ex_data( ctx, pSSL_get_ex_data_X509_STORE_CTX_idx() ); + server = pSSL_get_ex_data( ssl, hostname_idx ); + conn = pSSL_get_ex_data( ssl, conn_idx ); + if (store) + { + X509 *cert; + int i; + PCCERT_CONTEXT endCert = NULL; + + ret = TRUE; + for (i = 0; ret && i < psk_num((struct stack_st *)ctx->chain); i++) + { + PCCERT_CONTEXT context; + + cert = (X509 *)psk_value((struct stack_st *)ctx->chain, i); + if ((context = X509_to_cert_context( cert ))) + { + if (i == 0) + ret = CertAddCertificateContextToStore( store, context, + CERT_STORE_ADD_ALWAYS, &endCert ); + else + ret = CertAddCertificateContextToStore( store, context, + CERT_STORE_ADD_ALWAYS, NULL ); + CertFreeCertificateContext( context ); + } + } + if (!endCert) ret = FALSE; + if (ret) + { + DWORD_PTR err = netconn_verify_cert( endCert, store, server, + conn->security_flags ); + + if (err) + { + pSSL_set_ex_data( ssl, error_idx, (void *)err ); + ret = FALSE; + } + } + CertFreeCertificateContext( endCert ); + CertCloseStore( store, 0 ); + } + return ret; +} +#endif BOOL netconn_init( netconn_t *conn, BOOL secure ) { +#if defined(SONAME_LIBSSL) && defined(SONAME_LIBCRYPTO) + int i; +#endif + conn->socket = -1; if (!secure) return TRUE; #if defined(SONAME_LIBSSL) && defined(SONAME_LIBCRYPTO) - if (libssl_handle) return TRUE; + EnterCriticalSection( &init_ssl_cs ); + if (libssl_handle) + { + LeaveCriticalSection( &init_ssl_cs ); + return TRUE; + } if (!(libssl_handle = wine_dlopen( SONAME_LIBSSL, RTLD_NOW, NULL, 0 ))) { ERR("Trying to use SSL but couldn't load %s. Expect trouble.\n", SONAME_LIBSSL); set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); + LeaveCriticalSection( &init_ssl_cs ); return FALSE; } if (!(libcrypto_handle = wine_dlopen( SONAME_LIBCRYPTO, RTLD_NOW, NULL, 0 ))) { ERR("Trying to use SSL but couldn't load %s. Expect trouble.\n", SONAME_LIBCRYPTO); set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); + LeaveCriticalSection( &init_ssl_cs ); return FALSE; } #define LOAD_FUNCPTR(x) \ @@ -204,11 +447,13 @@ BOOL netconn_init( netconn_t *conn, BOOL secure ) { \ ERR("Failed to load symbol %s\n", #x); \ set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); \ + LeaveCriticalSection( &init_ssl_cs ); \ return FALSE; \ } LOAD_FUNCPTR( SSL_library_init ); LOAD_FUNCPTR( SSL_load_error_strings ); LOAD_FUNCPTR( SSLv23_method ); + LOAD_FUNCPTR( SSL_CTX_free ); LOAD_FUNCPTR( SSL_CTX_new ); LOAD_FUNCPTR( SSL_new ); LOAD_FUNCPTR( SSL_free ); @@ -217,11 +462,16 @@ BOOL netconn_init( netconn_t *conn, BOOL secure ) LOAD_FUNCPTR( SSL_shutdown ); LOAD_FUNCPTR( SSL_write ); LOAD_FUNCPTR( SSL_read ); - LOAD_FUNCPTR( SSL_get_verify_result ); + LOAD_FUNCPTR( SSL_get_error ); + LOAD_FUNCPTR( SSL_get_ex_new_index ); + LOAD_FUNCPTR( SSL_get_ex_data ); + LOAD_FUNCPTR( SSL_set_ex_data ); + LOAD_FUNCPTR( SSL_get_ex_data_X509_STORE_CTX_idx ); LOAD_FUNCPTR( SSL_get_peer_certificate ); - LOAD_FUNCPTR( SSL_CTX_get_timeout ); - LOAD_FUNCPTR( SSL_CTX_set_timeout ); LOAD_FUNCPTR( SSL_CTX_set_default_verify_paths ); + LOAD_FUNCPTR( SSL_CTX_set_verify ); + LOAD_FUNCPTR( SSL_get_current_cipher ); + LOAD_FUNCPTR( SSL_CIPHER_get_bits ); #undef LOAD_FUNCPTR #define LOAD_FUNCPTR(x) \ @@ -229,19 +479,72 @@ BOOL netconn_init( netconn_t *conn, BOOL secure ) { \ ERR("Failed to load symbol %s\n", #x); \ set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); \ + LeaveCriticalSection( &init_ssl_cs ); \ return FALSE; \ } - LOAD_FUNCPTR( BIO_new_fp ); + LOAD_FUNCPTR( CRYPTO_num_locks ); + LOAD_FUNCPTR( CRYPTO_set_id_callback ); + LOAD_FUNCPTR( CRYPTO_set_locking_callback ); + LOAD_FUNCPTR( ERR_free_strings ); LOAD_FUNCPTR( ERR_get_error ); LOAD_FUNCPTR( ERR_error_string ); + LOAD_FUNCPTR( X509_STORE_CTX_get_ex_data ); LOAD_FUNCPTR( i2d_X509 ); + LOAD_FUNCPTR( sk_value ); + LOAD_FUNCPTR( sk_num ); #undef LOAD_FUNCPTR pSSL_library_init(); pSSL_load_error_strings(); - pBIO_new_fp( stderr, BIO_NOCLOSE ); method = pSSLv23_method(); + ctx = pSSL_CTX_new( method ); + if (!pSSL_CTX_set_default_verify_paths( ctx )) + { + ERR("SSL_CTX_set_default_verify_paths failed: %s\n", pERR_error_string( pERR_get_error(), 0 )); + set_last_error( ERROR_OUTOFMEMORY ); + LeaveCriticalSection( &init_ssl_cs ); + return FALSE; + } + hostname_idx = pSSL_get_ex_new_index( 0, (void *)"hostname index", NULL, NULL, NULL ); + if (hostname_idx == -1) + { + ERR("SSL_get_ex_new_index failed: %s\n", pERR_error_string( pERR_get_error(), 0 )); + set_last_error( ERROR_OUTOFMEMORY ); + LeaveCriticalSection( &init_ssl_cs ); + return FALSE; + } + error_idx = pSSL_get_ex_new_index( 0, (void *)"error index", NULL, NULL, NULL ); + if (error_idx == -1) + { + ERR("SSL_get_ex_new_index failed: %s\n", pERR_error_string( pERR_get_error(), 0 )); + set_last_error( ERROR_OUTOFMEMORY ); + LeaveCriticalSection( &init_ssl_cs ); + return FALSE; + } + conn_idx = pSSL_get_ex_new_index( 0, (void *)"netconn index", NULL, NULL, NULL ); + if (conn_idx == -1) + { + ERR("SSL_get_ex_new_index failed: %s\n", pERR_error_string( pERR_get_error(), 0 )); + set_last_error( ERROR_OUTOFMEMORY ); + LeaveCriticalSection( &init_ssl_cs ); + return FALSE; + } + pSSL_CTX_set_verify( ctx, SSL_VERIFY_PEER, netconn_secure_verify ); + + pCRYPTO_set_id_callback(ssl_thread_id); + num_ssl_locks = pCRYPTO_num_locks(); + ssl_locks = HeapAlloc(GetProcessHeap(), 0, num_ssl_locks * sizeof(CRITICAL_SECTION)); + if (!ssl_locks) + { + set_last_error( ERROR_OUTOFMEMORY ); + LeaveCriticalSection( &init_ssl_cs ); + return FALSE; + } + for (i = 0; i < num_ssl_locks; i++) InitializeCriticalSection( &ssl_locks[i] ); + pCRYPTO_set_locking_callback(ssl_lock_callback); + + LeaveCriticalSection( &init_ssl_cs ); #else WARN("SSL support not compiled in.\n"); set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); @@ -250,6 +553,29 @@ BOOL netconn_init( netconn_t *conn, BOOL secure ) return TRUE; } +void netconn_unload( void ) +{ +#if defined(SONAME_LIBSSL) && defined(SONAME_LIBCRYPTO) + if (libcrypto_handle) + { + pERR_free_strings(); + wine_dlclose( libcrypto_handle, NULL, 0 ); + } + if (libssl_handle) + { + if (ctx) + pSSL_CTX_free( ctx ); + wine_dlclose( libssl_handle, NULL, 0 ); + } + if (ssl_locks) + { + int i; + for (i = 0; i < num_ssl_locks; i++) DeleteCriticalSection( &ssl_locks[i] ); + HeapFree( GetProcessHeap(), 0, ssl_locks ); + } +#endif +} + BOOL netconn_connected( netconn_t *conn ) { return (conn->socket != -1); @@ -295,36 +621,72 @@ BOOL netconn_close( netconn_t *conn ) return TRUE; } -BOOL netconn_connect( netconn_t *conn, const struct sockaddr *sockaddr, unsigned int addr_len ) +BOOL netconn_connect( netconn_t *conn, const struct sockaddr *sockaddr, unsigned int addr_len, int timeout ) { - if (connect( conn->socket, sockaddr, addr_len ) == -1) + BOOL ret = FALSE; + int res = 0, state; + + if (timeout > 0) { - WARN("unable to connect to host (%s)\n", strerror(errno)); - set_last_error( sock_get_error( errno ) ); - return FALSE; + state = 1; + ioctlsocket( conn->socket, FIONBIO, &state ); } - return TRUE; + if (connect( conn->socket, sockaddr, addr_len ) < 0) + { + res = sock_get_error( errno ); + if (res == WSAEWOULDBLOCK || res == WSAEINPROGRESS) + { + fd_set outfd; + struct timeval tv; + + FD_ZERO(&outfd); + FD_SET(conn->socket, &outfd); + + tv.tv_sec = 0; + tv.tv_usec = timeout * 1000; + + if (select( 0, NULL, &outfd, NULL, &tv ) > 0) + ret = TRUE; + else + res = sock_get_error( errno ); + } + } + else + ret = TRUE; + if (timeout > 0) + { + state = 0; + ioctlsocket( conn->socket, FIONBIO, &state ); + } + if (!ret) + { + WARN("unable to connect to host (%d)\n", res); + set_last_error( res ); + } + return ret; } -BOOL netconn_secure_connect( netconn_t *conn ) +BOOL netconn_secure_connect( netconn_t *conn, WCHAR *hostname ) { #ifdef SONAME_LIBSSL - X509 *cert; - long res; - - ctx = pSSL_CTX_new( method ); - if (!pSSL_CTX_set_default_verify_paths( ctx )) - { - ERR("SSL_CTX_set_default_verify_paths failed: %s\n", pERR_error_string( pERR_get_error(), 0 )); - set_last_error( ERROR_OUTOFMEMORY ); - return FALSE; - } if (!(conn->ssl_conn = pSSL_new( ctx ))) { ERR("SSL_new failed: %s\n", pERR_error_string( pERR_get_error(), 0 )); set_last_error( ERROR_OUTOFMEMORY ); goto fail; } + if (!pSSL_set_ex_data( conn->ssl_conn, hostname_idx, hostname )) + { + ERR("SSL_set_ex_data failed: %s\n", pERR_error_string( pERR_get_error(), 0 )); + set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); + goto fail; + } + if (!pSSL_set_ex_data( conn->ssl_conn, conn_idx, conn )) + { + ERR("SSL_set_ex_data failed: %s\n", pERR_error_string( pERR_get_error(), 0 )); + set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); + return FALSE; + } if (!pSSL_set_fd( conn->ssl_conn, conn->socket )) { ERR("SSL_set_fd failed: %s\n", pERR_error_string( pERR_get_error(), 0 )); @@ -333,21 +695,14 @@ BOOL netconn_secure_connect( netconn_t *conn ) } if (pSSL_connect( conn->ssl_conn ) <= 0) { - ERR("SSL_connect failed: %s\n", pERR_error_string( pERR_get_error(), 0 )); - set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); + DWORD err; + + err = (DWORD_PTR)pSSL_get_ex_data( conn->ssl_conn, error_idx ); + if (!err) err = ERROR_WINHTTP_SECURE_CHANNEL_ERROR; + ERR("couldn't verify server certificate (%d)\n", err); + set_last_error( err ); goto fail; } - if (!(cert = pSSL_get_peer_certificate( conn->ssl_conn ))) - { - ERR("No certificate for server: %s\n", pERR_error_string( pERR_get_error(), 0 )); - set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); - goto fail; - } - if ((res = pSSL_get_verify_result( conn->ssl_conn )) != X509_V_OK) - { - /* FIXME: we should set an error and return, but we only print an error at the moment */ - ERR("couldn't verify server certificate (%ld)\n", res); - } TRACE("established SSL connection\n"); conn->secure = TRUE; return TRUE; @@ -387,6 +742,8 @@ BOOL netconn_send( netconn_t *conn, const void *msg, size_t len, int flags, int BOOL netconn_recv( netconn_t *conn, void *buf, size_t len, int flags, int *recvd ) { + int ret; + *recvd = 0; if (!netconn_connected( conn )) return FALSE; if (!len) return TRUE; @@ -425,19 +782,29 @@ BOOL netconn_recv( netconn_t *conn, void *buf, size_t len, int flags, int *recvd /* check if we have enough data from the peek buffer */ if (!(flags & MSG_WAITALL) || (*recvd == len)) return TRUE; } - *recvd += pSSL_read( conn->ssl_conn, (char *)buf + *recvd, len - *recvd ); + ret = pSSL_read( conn->ssl_conn, (char *)buf + *recvd, len - *recvd ); + if (ret < 0) + return FALSE; + + /* check if EOF was received */ + if (!ret && (pSSL_get_error( conn->ssl_conn, ret ) == SSL_ERROR_ZERO_RETURN || + pSSL_get_error( conn->ssl_conn, ret ) == SSL_ERROR_SYSCALL )) + { + netconn_close( conn ); + return TRUE; + } if (flags & MSG_PEEK) /* must copy into buffer */ { - conn->peek_len = *recvd; - if (!*recvd) + conn->peek_len = ret; + if (!ret) { heap_free( conn->peek_msg_mem ); conn->peek_msg_mem = NULL; conn->peek_msg = NULL; } - else memcpy( conn->peek_msg, buf, *recvd ); + else memcpy( conn->peek_msg, buf, ret ); } - if (*recvd < 1 && len) return FALSE; + *recvd = ret; return TRUE; #else return FALSE; @@ -474,7 +841,6 @@ BOOL netconn_query_data_available( netconn_t *conn, DWORD *available ) BOOL netconn_get_next_line( netconn_t *conn, char *buffer, DWORD *buflen ) { - struct timeval tv; fd_set infd; BOOL ret = FALSE; DWORD recvd = 0; @@ -484,11 +850,6 @@ BOOL netconn_get_next_line( netconn_t *conn, char *buffer, DWORD *buflen ) if (conn->secure) { #ifdef SONAME_LIBSSL - long timeout; - - timeout = pSSL_CTX_get_timeout( ctx ); - pSSL_CTX_set_timeout( ctx, DEFAULT_RECEIVE_TIMEOUT ); - while (recvd < *buflen) { int dummy; @@ -504,7 +865,6 @@ BOOL netconn_get_next_line( netconn_t *conn, char *buffer, DWORD *buflen ) } if (buffer[recvd] != '\r') recvd++; } - pSSL_CTX_set_timeout( ctx, timeout ); if (ret) { buffer[recvd++] = 0; @@ -516,16 +876,23 @@ BOOL netconn_get_next_line( netconn_t *conn, char *buffer, DWORD *buflen ) return FALSE; #endif } - + FD_ZERO(&infd); FD_SET(conn->socket, &infd); - tv.tv_sec=RESPONSE_TIMEOUT; - tv.tv_usec=0; + while (recvd < *buflen) { - if (select(conn->socket+1,&infd,NULL,NULL,&tv) > 0) + int res; + struct timeval tv, *ptv; + socklen_t len = sizeof(tv); + + if ((res = getsockopt( conn->socket, SOL_SOCKET, SO_RCVTIMEO, (void*)&tv, &len ) != -1)) + ptv = &tv; + else + ptv = NULL; + + if (select( 0, &infd, NULL, NULL, ptv ) > 0) { - int res; if ((res = recv( conn->socket, &buffer[recvd], 1, 0 )) <= 0) { if (res == -1) set_last_error( sock_get_error( errno ) ); @@ -570,7 +937,7 @@ DWORD netconn_set_timeout( netconn_t *netconn, BOOL send, int value ) return ERROR_SUCCESS; } -BOOL netconn_resolve( WCHAR *hostnameW, INTERNET_PORT port, struct sockaddr_in *sa ) +static DWORD resolve_hostname( WCHAR *hostnameW, INTERNET_PORT port, struct sockaddr *sa, socklen_t *sa_len ) { char *hostname; #ifdef HAVE_GETADDRINFO @@ -578,27 +945,53 @@ BOOL netconn_resolve( WCHAR *hostnameW, INTERNET_PORT port, struct sockaddr_in * int ret; #else struct hostent *he; + struct sockaddr_in *sin = (struct sockaddr_in *)sa; #endif - if (!(hostname = strdupWA( hostnameW ))) return FALSE; + if (!(hostname = strdupWA( hostnameW ))) return ERROR_OUTOFMEMORY; #ifdef HAVE_GETADDRINFO memset( &hints, 0, sizeof(struct addrinfo) ); + /* Prefer IPv4 to IPv6 addresses, since some web servers do not listen on + * their IPv6 addresses even though they have IPv6 addresses in the DNS. + */ hints.ai_family = AF_INET; ret = getaddrinfo( hostname, NULL, &hints, &res ); - heap_free( hostname ); if (ret != 0) { - TRACE("failed to get address of %s (%s)\n", debugstr_w(hostnameW), gai_strerror(ret)); - return FALSE; + TRACE("failed to get IPv4 address of %s (%s), retrying with IPv6\n", debugstr_w(hostnameW), gai_strerror(ret)); + hints.ai_family = AF_INET6; + ret = getaddrinfo( hostname, NULL, &hints, &res ); + if (ret != 0) + { + TRACE("failed to get address of %s (%s)\n", debugstr_w(hostnameW), gai_strerror(ret)); + heap_free( hostname ); + return ERROR_WINHTTP_NAME_NOT_RESOLVED; + } + } + heap_free( hostname ); + if (*sa_len < res->ai_addrlen) + { + WARN("address too small\n"); + freeaddrinfo( res ); + return ERROR_WINHTTP_NAME_NOT_RESOLVED; + } + *sa_len = res->ai_addrlen; + memcpy( sa, res->ai_addr, res->ai_addrlen ); + /* Copy port */ + switch (res->ai_family) + { + case AF_INET: + ((struct sockaddr_in *)sa)->sin_port = htons( port ); + break; + case AF_INET6: + ((struct sockaddr_in6 *)sa)->sin6_port = htons( port ); + break; } - memset( sa, 0, sizeof(struct sockaddr_in) ); - memcpy( &sa->sin_addr, &((struct sockaddr_in *)res->ai_addr)->sin_addr, sizeof(struct in_addr) ); - sa->sin_family = res->ai_family; - sa->sin_port = htons( port ); freeaddrinfo( res ); + return ERROR_SUCCESS; #else EnterCriticalSection( &cs_gethostbyname ); @@ -608,15 +1001,69 @@ BOOL netconn_resolve( WCHAR *hostnameW, INTERNET_PORT port, struct sockaddr_in * { TRACE("failed to get address of %s (%d)\n", debugstr_w(hostnameW), h_errno); LeaveCriticalSection( &cs_gethostbyname ); - return FALSE; + return ERROR_WINHTTP_NAME_NOT_RESOLVED; } + if (*sa_len < sizeof(struct sockaddr_in)) + { + WARN("address too small\n"); + LeaveCriticalSection( &cs_gethostbyname ); + return ERROR_WINHTTP_NAME_NOT_RESOLVED; + } + *sa_len = sizeof(struct sockaddr_in); memset( sa, 0, sizeof(struct sockaddr_in) ); - memcpy( &sa->sin_addr, he->h_addr, he->h_length ); - sa->sin_family = he->h_addrtype; - sa->sin_port = htons( port ); + memcpy( &sin->sin_addr, he->h_addr, he->h_length ); + sin->sin_family = he->h_addrtype; + sin->sin_port = htons( port ); LeaveCriticalSection( &cs_gethostbyname ); + return ERROR_SUCCESS; #endif +} + +struct resolve_args +{ + WCHAR *hostname; + INTERNET_PORT port; + struct sockaddr *sa; + socklen_t *sa_len; +}; + +static DWORD CALLBACK resolve_proc( LPVOID arg ) +{ + struct resolve_args *ra = arg; + return resolve_hostname( ra->hostname, ra->port, ra->sa, ra->sa_len ); +} + +BOOL netconn_resolve( WCHAR *hostname, INTERNET_PORT port, struct sockaddr *sa, socklen_t *sa_len, int timeout ) +{ + DWORD ret; + + if (timeout) + { + DWORD status; + HANDLE thread; + struct resolve_args ra; + + ra.hostname = hostname; + ra.port = port; + ra.sa = sa; + ra.sa_len = sa_len; + + thread = CreateThread( NULL, 0, resolve_proc, &ra, 0, NULL ); + if (!thread) return FALSE; + + status = WaitForSingleObject( thread, timeout ); + if (status == WAIT_OBJECT_0) GetExitCodeThread( thread, &ret ); + else ret = ERROR_WINHTTP_TIMEOUT; + CloseHandle( thread ); + } + else ret = resolve_hostname( hostname, port, sa, sa_len ); + + if (ret) + { + set_last_error( ret ); + return FALSE; + } return TRUE; } @@ -624,41 +1071,29 @@ const void *netconn_get_certificate( netconn_t *conn ) { #ifdef SONAME_LIBSSL X509 *cert; - unsigned char *buffer, *p; - int len; - BOOL malloc = FALSE; const CERT_CONTEXT *ret; if (!conn->secure) return NULL; if (!(cert = pSSL_get_peer_certificate( conn->ssl_conn ))) return NULL; - p = NULL; - if ((len = pi2d_X509( cert, &p )) < 0) return NULL; - /* - * SSL 0.9.7 and above malloc the buffer if it is null. - * however earlier version do not and so we would need to alloc the buffer. - * - * see the i2d_X509 man page for more details. - */ - if (!p) - { - if (!(buffer = heap_alloc( len ))) return NULL; - p = buffer; - len = pi2d_X509( cert, &p ); - } - else - { - buffer = p; - malloc = TRUE; - } - - ret = CertCreateCertificateContext( X509_ASN_ENCODING, buffer, len ); - - if (malloc) free( buffer ); - else heap_free( buffer ); - + ret = X509_to_cert_context( cert ); return ret; #else return NULL; #endif } + +int netconn_get_cipher_strength( netconn_t *conn ) +{ +#ifdef SONAME_LIBSSL + SSL_CIPHER *cipher; + int bits = 0; + + if (!conn->secure) return 0; + if (!(cipher = pSSL_get_current_cipher( conn->ssl_conn ))) return 0; + pSSL_CIPHER_get_bits( cipher, &bits ); + return bits; +#else + return 0; +#endif +} diff --git a/reactos/dll/win32/winhttp/request.c b/reactos/dll/win32/winhttp/request.c index dd08028ec1a..80a1b572d4d 100644 --- a/reactos/dll/win32/winhttp/request.c +++ b/reactos/dll/win32/winhttp/request.c @@ -1,5 +1,8 @@ /* + * Copyright 2004 Mike McCormack for CodeWeavers + * Copyright 2006 Rob Shearman for CodeWeavers * Copyright 2008 Hans Leidekker for CodeWeavers + * Copyright 2009 Juan Lang * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -20,14 +23,10 @@ #include "wine/port.h" #include "wine/debug.h" -#include #include #ifdef HAVE_ARPA_INET_H # include #endif -#ifdef HAVE_SYS_SOCKET_H -# include -#endif #include "windef.h" #include "winbase.h" @@ -414,6 +413,7 @@ BOOL add_request_headers( request_t *request, LPCWSTR headers, DWORD len, DWORD header_t *header; if (len == ~0u) len = strlenW( headers ); + if (!len) return TRUE; if (!(buffer = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return FALSE; strcpyW( buffer, headers ); @@ -477,6 +477,47 @@ BOOL WINAPI WinHttpAddRequestHeaders( HINTERNET hrequest, LPCWSTR headers, DWORD return ret; } +static WCHAR *build_request_path( request_t *request ) +{ + WCHAR *ret; + + if (strcmpiW( request->connect->hostname, request->connect->servername )) + { + static const WCHAR http[] = { 'h','t','t','p',0 }; + static const WCHAR https[] = { 'h','t','t','p','s',0 }; + static const WCHAR fmt[] = { '%','s',':','/','/','%','s',0 }; + LPCWSTR scheme = request->netconn.secure ? https : http; + int len; + + len = strlenW( scheme ) + strlenW( request->connect->hostname ); + /* 3 characters for '://', 1 for NUL. */ + len += 4; + if (request->connect->hostport) + { + /* 1 for ':' between host and port, up to 5 for port */ + len += 6; + } + if (request->path) + len += strlenW( request->path ); + if ((ret = heap_alloc( len * sizeof(WCHAR) ))) + { + sprintfW( ret, fmt, scheme, request->connect->hostname ); + if (request->connect->hostport) + { + static const WCHAR colonFmt[] = { ':','%','d',0 }; + + sprintfW( ret + strlenW( ret ), colonFmt, + request->connect->hostport ); + } + if (request->path) + strcatW( ret, request->path ); + } + } + else + ret = request->path; + return ret; +} + static WCHAR *build_request_string( request_t *request ) { static const WCHAR space[] = {' ',0}; @@ -484,7 +525,7 @@ static WCHAR *build_request_string( request_t *request ) static const WCHAR colon[] = {':',' ',0}; static const WCHAR twocrlf[] = {'\r','\n','\r','\n',0}; - WCHAR *ret; + WCHAR *path, *ret; const WCHAR **headers, **p; unsigned int len, i = 0, j; @@ -492,9 +533,10 @@ static WCHAR *build_request_string( request_t *request ) len = request->num_headers * 4 + 7; if (!(headers = heap_alloc( len * sizeof(LPCWSTR) ))) return NULL; + path = build_request_path( request ); headers[i++] = request->verb; headers[i++] = space; - headers[i++] = request->path; + headers[i++] = path; headers[i++] = space; headers[i++] = request->version; @@ -519,13 +561,13 @@ static WCHAR *build_request_string( request_t *request ) len++; if (!(ret = heap_alloc( len * sizeof(WCHAR) ))) - { - heap_free( headers ); - return NULL; - } + goto out; *ret = 0; for (p = headers; *p; p++) strcatW( ret, *p ); +out: + if (path != request->path) + heap_free( path ); heap_free( headers ); return ret; } @@ -562,12 +604,12 @@ static BOOL query_headers( request_t *request, DWORD level, LPCWSTR name, LPVOID if (!(p = headers)) return FALSE; for (len = 0; *p; p++) if (*p != '\r') len++; - if ((len + 1) * sizeof(WCHAR) > *buflen || !buffer) + if (!buffer || (len + 1) * sizeof(WCHAR) > *buflen) { len++; set_last_error( ERROR_INSUFFICIENT_BUFFER ); } - else if (buffer) + else { for (p = headers, q = buffer; *p; p++, q++) { @@ -597,12 +639,12 @@ static BOOL query_headers( request_t *request, DWORD level, LPCWSTR name, LPVOID if (!headers) return FALSE; len = strlenW( headers ) * sizeof(WCHAR); - if (len + sizeof(WCHAR) > *buflen || !buffer) + if (!buffer || len + sizeof(WCHAR) > *buflen) { len += sizeof(WCHAR); set_last_error( ERROR_INSUFFICIENT_BUFFER ); } - else if (buffer) + else { memcpy( buffer, headers, len + sizeof(WCHAR) ); TRACE("returning data: %s\n", debugstr_wn(buffer, len / sizeof(WCHAR))); @@ -612,8 +654,39 @@ static BOOL query_headers( request_t *request, DWORD level, LPCWSTR name, LPVOID if (request_only) heap_free( headers ); return ret; } + case WINHTTP_QUERY_VERSION: + len = strlenW( request->version ) * sizeof(WCHAR); + if (!buffer || len + sizeof(WCHAR) > *buflen) + { + len += sizeof(WCHAR); + set_last_error( ERROR_INSUFFICIENT_BUFFER ); + } + else + { + strcpyW( buffer, request->version ); + TRACE("returning string: %s\n", debugstr_w(buffer)); + ret = TRUE; + } + *buflen = len; + return ret; + + case WINHTTP_QUERY_STATUS_TEXT: + len = strlenW( request->status_text ) * sizeof(WCHAR); + if (!buffer || len + sizeof(WCHAR) > *buflen) + { + len += sizeof(WCHAR); + set_last_error( ERROR_INSUFFICIENT_BUFFER ); + } + else + { + strcpyW( buffer, request->status_text ); + TRACE("returning string: %s\n", debugstr_w(buffer)); + ret = TRUE; + } + *buflen = len; + return ret; + default: - { if (attr >= sizeof(attribute_table)/sizeof(attribute_table[0]) || !attribute_table[attr]) { FIXME("attribute %u not implemented\n", attr); @@ -621,7 +694,7 @@ static BOOL query_headers( request_t *request, DWORD level, LPCWSTR name, LPVOID } TRACE("attribute %s\n", debugstr_w(attribute_table[attr])); header_index = get_header_index( request, attribute_table[attr], requested_index, request_only ); - } + break; } if (header_index >= 0) @@ -636,13 +709,13 @@ static BOOL query_headers( request_t *request, DWORD level, LPCWSTR name, LPVOID if (index) *index += 1; if (level & WINHTTP_QUERY_FLAG_NUMBER) { - int *number = buffer; - if (sizeof(int) > *buflen) + if (!buffer || sizeof(int) > *buflen) { set_last_error( ERROR_INSUFFICIENT_BUFFER ); } - else if (number) + else { + int *number = buffer; *number = atoiW( header->value ); TRACE("returning number: %d\n", *number); ret = TRUE; @@ -652,11 +725,11 @@ static BOOL query_headers( request_t *request, DWORD level, LPCWSTR name, LPVOID else if (level & WINHTTP_QUERY_FLAG_SYSTEMTIME) { SYSTEMTIME *st = buffer; - if (sizeof(SYSTEMTIME) > *buflen) + if (!buffer || sizeof(SYSTEMTIME) > *buflen) { set_last_error( ERROR_INSUFFICIENT_BUFFER ); } - else if (st && (ret = WinHttpTimeToSystemTime( header->value, st ))) + else if ((ret = WinHttpTimeToSystemTime( header->value, st ))) { TRACE("returning time: %04d/%02d/%02d - %d - %02d:%02d:%02d.%02d\n", st->wYear, st->wMonth, st->wDay, st->wDayOfWeek, @@ -666,21 +739,19 @@ static BOOL query_headers( request_t *request, DWORD level, LPCWSTR name, LPVOID } else if (header->value) { - WCHAR *string = buffer; - DWORD len = (strlenW( header->value ) + 1) * sizeof(WCHAR); - if (len > *buflen) + len = strlenW( header->value ) * sizeof(WCHAR); + if (!buffer || len + sizeof(WCHAR) > *buflen) { + len += sizeof(WCHAR); set_last_error( ERROR_INSUFFICIENT_BUFFER ); - *buflen = len; - return FALSE; } - else if (string) + else { - strcpyW( string, header->value ); - TRACE("returning string: %s\n", debugstr_w(string)); + strcpyW( buffer, header->value ); + TRACE("returning string: %s\n", debugstr_w(buffer)); ret = TRUE; } - *buflen = len - sizeof(WCHAR); + *buflen = len; } return ret; } @@ -713,46 +784,198 @@ BOOL WINAPI WinHttpQueryHeaders( HINTERNET hrequest, DWORD level, LPCWSTR name, return ret; } +static LPWSTR concatenate_string_list( LPCWSTR *list, int len ) +{ + LPCWSTR *t; + LPWSTR str; + + for( t = list; *t ; t++ ) + len += strlenW( *t ); + len++; + + str = heap_alloc( len * sizeof(WCHAR) ); + if (!str) return NULL; + *str = 0; + + for( t = list; *t ; t++ ) + strcatW( str, *t ); + + return str; +} + +static LPWSTR build_header_request_string( request_t *request, LPCWSTR verb, + LPCWSTR path, LPCWSTR version ) +{ + static const WCHAR crlf[] = {'\r','\n',0}; + static const WCHAR space[] = { ' ',0 }; + static const WCHAR colon[] = { ':',' ',0 }; + static const WCHAR twocrlf[] = {'\r','\n','\r','\n', 0}; + LPWSTR requestString; + DWORD len, n; + LPCWSTR *req; + UINT i; + LPWSTR p; + + /* allocate space for an array of all the string pointers to be added */ + len = (request->num_headers) * 4 + 10; + req = heap_alloc( len * sizeof(LPCWSTR) ); + if (!req) return NULL; + + /* add the verb, path and HTTP version string */ + n = 0; + req[n++] = verb; + req[n++] = space; + req[n++] = path; + req[n++] = space; + req[n++] = version; + + /* Append custom request headers */ + for (i = 0; i < request->num_headers; i++) + { + if (request->headers[i].is_request) + { + req[n++] = crlf; + req[n++] = request->headers[i].field; + req[n++] = colon; + req[n++] = request->headers[i].value; + + TRACE("Adding custom header %s (%s)\n", + debugstr_w(request->headers[i].field), + debugstr_w(request->headers[i].value)); + } + } + + if( n >= len ) + ERR("oops. buffer overrun\n"); + + req[n] = NULL; + requestString = concatenate_string_list( req, 4 ); + heap_free( req ); + if (!requestString) return NULL; + + /* + * Set (header) termination string for request + * Make sure there's exactly two new lines at the end of the request + */ + p = &requestString[strlenW(requestString)-1]; + while ( (*p == '\n') || (*p == '\r') ) + p--; + strcpyW( p+1, twocrlf ); + + return requestString; +} + +static BOOL read_reply( request_t *request ); + +static BOOL secure_proxy_connect( request_t *request ) +{ + static const WCHAR verbConnect[] = {'C','O','N','N','E','C','T',0}; + static const WCHAR fmt[] = {'%','s',':','%','d',0}; + BOOL ret = FALSE; + LPWSTR path; + connect_t *connect = request->connect; + + path = heap_alloc( (strlenW( connect->hostname ) + 13) * sizeof(WCHAR) ); + if (path) + { + LPWSTR requestString; + + sprintfW( path, fmt, connect->hostname, connect->hostport ); + requestString = build_header_request_string( request, verbConnect, + path, http1_1 ); + heap_free( path ); + if (requestString) + { + LPSTR req_ascii = strdupWA( requestString ); + + heap_free( requestString ); + if (req_ascii) + { + int len = strlen( req_ascii ), bytes_sent; + + ret = netconn_send( &request->netconn, req_ascii, len, 0, &bytes_sent ); + heap_free( req_ascii ); + if (ret) + ret = read_reply( request ); + } + } + } + return ret; +} + +#ifndef INET6_ADDRSTRLEN +#define INET6_ADDRSTRLEN 46 +#endif + static BOOL open_connection( request_t *request ) { connect_t *connect; - char address[32]; + const void *addr; + char address[INET6_ADDRSTRLEN]; WCHAR *addressW; INTERNET_PORT port; + socklen_t slen; if (netconn_connected( &request->netconn )) return TRUE; connect = request->connect; - port = connect->hostport ? connect->hostport : (request->hdr.flags & WINHTTP_FLAG_SECURE ? 443 : 80); + port = connect->serverport ? connect->serverport : (request->hdr.flags & WINHTTP_FLAG_SECURE ? 443 : 80); send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, connect->servername, strlenW(connect->servername) + 1 ); - if (!netconn_resolve( connect->servername, port, &connect->sockaddr )) return FALSE; - inet_ntop( connect->sockaddr.sin_family, &connect->sockaddr.sin_addr, address, sizeof(address) ); + slen = sizeof(connect->sockaddr); + if (!netconn_resolve( connect->servername, port, (struct sockaddr *)&connect->sockaddr, &slen, request->resolve_timeout )) return FALSE; + switch (connect->sockaddr.ss_family) + { + case AF_INET: + addr = &((struct sockaddr_in *)&connect->sockaddr)->sin_addr; + break; + case AF_INET6: + addr = &((struct sockaddr_in6 *)&connect->sockaddr)->sin6_addr; + break; + default: + WARN("unsupported address family %d\n", connect->sockaddr.ss_family); + return FALSE; + } + inet_ntop( connect->sockaddr.ss_family, addr, address, sizeof(address) ); addressW = strdupAW( address ); send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, addressW, strlenW(addressW) + 1 ); - TRACE("connecting to %s:%u\n", address, ntohs(connect->sockaddr.sin_port)); + TRACE("connecting to %s:%u\n", address, port); send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, addressW, 0 ); - if (!netconn_create( &request->netconn, connect->sockaddr.sin_family, SOCK_STREAM, 0 )) + if (!netconn_create( &request->netconn, connect->sockaddr.ss_family, SOCK_STREAM, 0 )) { heap_free( addressW ); return FALSE; } - if (!netconn_connect( &request->netconn, (struct sockaddr *)&connect->sockaddr, sizeof(struct sockaddr_in) )) + netconn_set_timeout( &request->netconn, TRUE, request->send_timeout ); + netconn_set_timeout( &request->netconn, FALSE, request->recv_timeout ); + if (!netconn_connect( &request->netconn, (struct sockaddr *)&connect->sockaddr, slen, request->connect_timeout )) { netconn_close( &request->netconn ); heap_free( addressW ); return FALSE; } - if (request->hdr.flags & WINHTTP_FLAG_SECURE && !netconn_secure_connect( &request->netconn )) + if (request->hdr.flags & WINHTTP_FLAG_SECURE) { - netconn_close( &request->netconn ); - heap_free( addressW ); - return FALSE; + if (connect->session->proxy_server && + strcmpiW( connect->hostname, connect->servername )) + { + if (!secure_proxy_connect( request )) + { + heap_free( addressW ); + return FALSE; + } + } + if (!netconn_secure_connect( &request->netconn, connect->servername )) + { + netconn_close( &request->netconn ); + heap_free( addressW ); + return FALSE; + } } send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, addressW, strlenW(addressW) + 1 ); @@ -847,6 +1070,7 @@ static BOOL send_request( request_t *request, LPCWSTR headers, DWORD headers_len TRACE("full request: %s\n", debugstr_a(req_ascii)); len = strlen(req_ascii); + if (context) request->hdr.context = context; send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST, NULL, 0 ); ret = netconn_send( &request->netconn, req_ascii, len, 0, &bytes_sent ); @@ -929,6 +1153,282 @@ BOOL WINAPI WinHttpSendRequest( HINTERNET hrequest, LPCWSTR headers, DWORD heade return ret; } +#define ARRAYSIZE(array) (sizeof(array) / sizeof((array)[0])) + +static DWORD auth_scheme_from_header( WCHAR *header ) +{ + static const WCHAR basic[] = {'B','a','s','i','c'}; + static const WCHAR ntlm[] = {'N','T','L','M'}; + static const WCHAR passport[] = {'P','a','s','s','p','o','r','t'}; + static const WCHAR digest[] = {'D','i','g','e','s','t'}; + static const WCHAR negotiate[] = {'N','e','g','o','t','i','a','t','e'}; + + if (!strncmpiW( header, basic, ARRAYSIZE(basic) ) && + (header[ARRAYSIZE(basic)] == ' ' || !header[ARRAYSIZE(basic)])) return WINHTTP_AUTH_SCHEME_BASIC; + + if (!strncmpiW( header, ntlm, ARRAYSIZE(ntlm) ) && + (header[ARRAYSIZE(ntlm)] == ' ' || !header[ARRAYSIZE(ntlm)])) return WINHTTP_AUTH_SCHEME_NTLM; + + if (!strncmpiW( header, passport, ARRAYSIZE(passport) ) && + (header[ARRAYSIZE(passport)] == ' ' || !header[ARRAYSIZE(passport)])) return WINHTTP_AUTH_SCHEME_PASSPORT; + + if (!strncmpiW( header, digest, ARRAYSIZE(digest) ) && + (header[ARRAYSIZE(digest)] == ' ' || !header[ARRAYSIZE(digest)])) return WINHTTP_AUTH_SCHEME_DIGEST; + + if (!strncmpiW( header, negotiate, ARRAYSIZE(negotiate) ) && + (header[ARRAYSIZE(negotiate)] == ' ' || !header[ARRAYSIZE(negotiate)])) return WINHTTP_AUTH_SCHEME_NEGOTIATE; + + return 0; +} + +static BOOL query_auth_schemes( request_t *request, DWORD level, LPDWORD supported, LPDWORD first ) +{ + DWORD index = 0; + BOOL ret = FALSE; + + for (;;) + { + WCHAR *buffer; + DWORD size, scheme; + + size = 0; + query_headers( request, level, NULL, NULL, &size, &index ); + if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) break; + + index--; + if (!(buffer = heap_alloc( size ))) return FALSE; + if (!query_headers( request, level, NULL, buffer, &size, &index )) + { + heap_free( buffer ); + return FALSE; + } + scheme = auth_scheme_from_header( buffer ); + if (first && index == 1) *first = scheme; + *supported |= scheme; + + heap_free( buffer ); + ret = TRUE; + } + return ret; +} + +/*********************************************************************** + * WinHttpQueryAuthSchemes (winhttp.@) + */ +BOOL WINAPI WinHttpQueryAuthSchemes( HINTERNET hrequest, LPDWORD supported, LPDWORD first, LPDWORD target ) +{ + BOOL ret = FALSE; + request_t *request; + + TRACE("%p, %p, %p, %p\n", hrequest, supported, first, target); + + if (!(request = (request_t *)grab_object( hrequest ))) + { + set_last_error( ERROR_INVALID_HANDLE ); + return FALSE; + } + if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST) + { + release_object( &request->hdr ); + set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE ); + return FALSE; + } + + if (query_auth_schemes( request, WINHTTP_QUERY_WWW_AUTHENTICATE, supported, first )) + { + *target = WINHTTP_AUTH_TARGET_SERVER; + ret = TRUE; + } + else if (query_auth_schemes( request, WINHTTP_QUERY_PROXY_AUTHENTICATE, supported, first )) + { + *target = WINHTTP_AUTH_TARGET_PROXY; + ret = TRUE; + } + + release_object( &request->hdr ); + return ret; +} + +static UINT encode_base64( const char *bin, unsigned int len, WCHAR *base64 ) +{ + UINT n = 0, x; + static const char base64enc[] = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + + while (len > 0) + { + /* first 6 bits, all from bin[0] */ + base64[n++] = base64enc[(bin[0] & 0xfc) >> 2]; + x = (bin[0] & 3) << 4; + + /* next 6 bits, 2 from bin[0] and 4 from bin[1] */ + if (len == 1) + { + base64[n++] = base64enc[x]; + base64[n++] = '='; + base64[n++] = '='; + break; + } + base64[n++] = base64enc[x | ((bin[1] & 0xf0) >> 4)]; + x = (bin[1] & 0x0f) << 2; + + /* next 6 bits 4 from bin[1] and 2 from bin[2] */ + if (len == 2) + { + base64[n++] = base64enc[x]; + base64[n++] = '='; + break; + } + base64[n++] = base64enc[x | ((bin[2] & 0xc0) >> 6)]; + + /* last 6 bits, all from bin [2] */ + base64[n++] = base64enc[bin[2] & 0x3f]; + bin += 3; + len -= 3; + } + base64[n] = 0; + return n; +} + +static BOOL set_credentials( request_t *request, DWORD target, DWORD scheme, LPCWSTR username, LPCWSTR password ) +{ + static const WCHAR basic[] = {'B','a','s','i','c',' ',0}; + const WCHAR *auth_scheme, *auth_target; + WCHAR *auth_header; + DWORD len, auth_data_len; + char *auth_data; + BOOL ret; + + if (!username || !password) + { + set_last_error( ERROR_INVALID_PARAMETER ); + return FALSE; + } + + switch (target) + { + case WINHTTP_AUTH_TARGET_SERVER: auth_target = attr_authorization; break; + case WINHTTP_AUTH_TARGET_PROXY: auth_target = attr_proxy_authorization; break; + default: + WARN("unknown target %x\n", target); + return FALSE; + } + switch (scheme) + { + case WINHTTP_AUTH_SCHEME_BASIC: + { + int userlen = WideCharToMultiByte( CP_UTF8, 0, username, strlenW( username ), NULL, 0, NULL, NULL ); + int passlen = WideCharToMultiByte( CP_UTF8, 0, password, strlenW( password ), NULL, 0, NULL, NULL ); + + TRACE("basic authentication\n"); + + auth_scheme = basic; + auth_data_len = userlen + 1 + passlen; + if (!(auth_data = heap_alloc( auth_data_len ))) return FALSE; + + WideCharToMultiByte( CP_UTF8, 0, username, -1, auth_data, userlen, NULL, NULL ); + auth_data[userlen] = ':'; + WideCharToMultiByte( CP_UTF8, 0, password, -1, auth_data + userlen + 1, passlen, NULL, NULL ); + break; + } + case WINHTTP_AUTH_SCHEME_NTLM: + case WINHTTP_AUTH_SCHEME_PASSPORT: + case WINHTTP_AUTH_SCHEME_DIGEST: + case WINHTTP_AUTH_SCHEME_NEGOTIATE: + FIXME("unimplemented authentication scheme %x\n", scheme); + return FALSE; + default: + WARN("unknown authentication scheme %x\n", scheme); + return FALSE; + } + + len = strlenW( auth_scheme ) + ((auth_data_len + 2) * 4) / 3; + if (!(auth_header = heap_alloc( (len + 1) * sizeof(WCHAR) ))) + { + heap_free( auth_data ); + return FALSE; + } + strcpyW( auth_header, auth_scheme ); + encode_base64( auth_data, auth_data_len, auth_header + strlenW( auth_header ) ); + + ret = process_header( request, auth_target, auth_header, WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE, TRUE ); + + heap_free( auth_data ); + heap_free( auth_header ); + return ret; +} + +/*********************************************************************** + * WinHttpSetCredentials (winhttp.@) + */ +BOOL WINAPI WinHttpSetCredentials( HINTERNET hrequest, DWORD target, DWORD scheme, LPCWSTR username, + LPCWSTR password, LPVOID params ) +{ + BOOL ret; + request_t *request; + + TRACE("%p, %x, 0x%08x, %s, %p, %p\n", hrequest, target, scheme, debugstr_w(username), password, params); + + if (!(request = (request_t *)grab_object( hrequest ))) + { + set_last_error( ERROR_INVALID_HANDLE ); + return FALSE; + } + if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST) + { + release_object( &request->hdr ); + set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE ); + return FALSE; + } + + ret = set_credentials( request, target, scheme, username, password ); + + release_object( &request->hdr ); + return ret; +} + +static BOOL handle_authorization( request_t *request, DWORD status ) +{ + DWORD schemes, level, target; + const WCHAR *username, *password; + + switch (status) + { + case 401: + target = WINHTTP_AUTH_TARGET_SERVER; + level = WINHTTP_QUERY_WWW_AUTHENTICATE; + break; + + case 407: + target = WINHTTP_AUTH_TARGET_PROXY; + level = WINHTTP_QUERY_PROXY_AUTHENTICATE; + break; + + default: + WARN("unhandled status %u\n", status); + return FALSE; + } + + if (!query_auth_schemes( request, level, &schemes, NULL )) return FALSE; + + if (target == WINHTTP_AUTH_TARGET_SERVER) + { + username = request->connect->username; + password = request->connect->password; + } + else + { + username = request->connect->session->proxy_username; + password = request->connect->session->proxy_password; + } + + if (schemes & WINHTTP_AUTH_SCHEME_BASIC) + return set_credentials( request, target, WINHTTP_AUTH_SCHEME_BASIC, username, password ); + + FIXME("unsupported authentication scheme\n"); + return FALSE; +} + static void clear_response_headers( request_t *request ) { unsigned int i; @@ -1100,13 +1600,12 @@ static BOOL handle_redirect( request_t *request ) hostname[len] = 0; port = uc.nPort ? uc.nPort : (uc.nScheme == INTERNET_SCHEME_HTTPS ? 443 : 80); - if (strcmpiW( connect->servername, hostname ) || connect->serverport != port) + if (strcmpiW( connect->hostname, hostname ) || connect->serverport != port) { heap_free( connect->hostname ); connect->hostname = hostname; - heap_free( connect->servername ); - connect->servername = strdupW( connect->hostname ); - connect->serverport = connect->hostport = port; + connect->hostport = port; + if (!(ret = set_server_for_hostname( connect, hostname, port ))) goto end; netconn_close( &request->netconn ); if (!(ret = netconn_init( &request->netconn, request->hdr.flags & WINHTTP_FLAG_SECURE ))) goto end; @@ -1349,7 +1848,20 @@ static BOOL receive_response( request_t *request, BOOL async ) ret = send_request( request, NULL, 0, NULL, 0, 0, 0, FALSE ); /* recurse synchronously */ continue; } - if (status == 401) FIXME("authentication not supported\n"); + else if (status == 401 || status == 407) + { + if (request->hdr.disable_flags & WINHTTP_DISABLE_AUTHENTICATION) break; + + drain_content( request ); + if (!handle_authorization( request, status )) + { + ret = TRUE; + break; + } + clear_response_headers( request ); + ret = send_request( request, NULL, 0, NULL, 0, 0, 0, FALSE ); + continue; + } break; } @@ -1620,232 +2132,3 @@ BOOL WINAPI WinHttpWriteData( HINTERNET hrequest, LPCVOID buffer, DWORD to_write release_object( &request->hdr ); return ret; } - -#define ARRAYSIZE(array) (sizeof(array) / sizeof((array)[0])) - -static DWORD auth_scheme_from_header( WCHAR *header ) -{ - static const WCHAR basic[] = {'B','a','s','i','c'}; - static const WCHAR ntlm[] = {'N','T','L','M'}; - static const WCHAR passport[] = {'P','a','s','s','p','o','r','t'}; - static const WCHAR digest[] = {'D','i','g','e','s','t'}; - static const WCHAR negotiate[] = {'N','e','g','o','t','i','a','t','e'}; - - if (!strncmpiW( header, basic, ARRAYSIZE(basic) ) && - (header[ARRAYSIZE(basic)] == ' ' || !header[ARRAYSIZE(basic)])) return WINHTTP_AUTH_SCHEME_BASIC; - - if (!strncmpiW( header, ntlm, ARRAYSIZE(ntlm) ) && - (header[ARRAYSIZE(ntlm)] == ' ' || !header[ARRAYSIZE(ntlm)])) return WINHTTP_AUTH_SCHEME_NTLM; - - if (!strncmpiW( header, passport, ARRAYSIZE(passport) ) && - (header[ARRAYSIZE(passport)] == ' ' || !header[ARRAYSIZE(passport)])) return WINHTTP_AUTH_SCHEME_PASSPORT; - - if (!strncmpiW( header, digest, ARRAYSIZE(digest) ) && - (header[ARRAYSIZE(digest)] == ' ' || !header[ARRAYSIZE(digest)])) return WINHTTP_AUTH_SCHEME_DIGEST; - - if (!strncmpiW( header, negotiate, ARRAYSIZE(negotiate) ) && - (header[ARRAYSIZE(negotiate)] == ' ' || !header[ARRAYSIZE(negotiate)])) return WINHTTP_AUTH_SCHEME_NEGOTIATE; - - return 0; -} - -static BOOL query_auth_schemes( request_t *request, DWORD level, LPDWORD supported, LPDWORD first ) -{ - DWORD index = 0; - BOOL ret = FALSE; - - for (;;) - { - WCHAR *buffer; - DWORD size, scheme; - - size = 0; - query_headers( request, level, NULL, NULL, &size, &index ); - if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) break; - - index--; - if (!(buffer = heap_alloc( size ))) return FALSE; - if (!query_headers( request, level, NULL, buffer, &size, &index )) - { - heap_free( buffer ); - return FALSE; - } - scheme = auth_scheme_from_header( buffer ); - if (index == 1) *first = scheme; - *supported |= scheme; - - heap_free( buffer ); - ret = TRUE; - } - return ret; -} - -/*********************************************************************** - * WinHttpQueryAuthSchemes (winhttp.@) - */ -BOOL WINAPI WinHttpQueryAuthSchemes( HINTERNET hrequest, LPDWORD supported, LPDWORD first, LPDWORD target ) -{ - BOOL ret = FALSE; - request_t *request; - - TRACE("%p, %p, %p, %p\n", hrequest, supported, first, target); - - if (!(request = (request_t *)grab_object( hrequest ))) - { - set_last_error( ERROR_INVALID_HANDLE ); - return FALSE; - } - if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST) - { - release_object( &request->hdr ); - set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE ); - return FALSE; - } - - if (query_auth_schemes( request, WINHTTP_QUERY_WWW_AUTHENTICATE, supported, first )) - { - *target = WINHTTP_AUTH_TARGET_SERVER; - ret = TRUE; - } - else if (query_auth_schemes( request, WINHTTP_QUERY_PROXY_AUTHENTICATE, supported, first )) - { - *target = WINHTTP_AUTH_TARGET_PROXY; - ret = TRUE; - } - - release_object( &request->hdr ); - return ret; -} - -static UINT encode_base64( const char *bin, unsigned int len, WCHAR *base64 ) -{ - UINT n = 0, x; - static const char base64enc[] = - "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; - - while (len > 0) - { - /* first 6 bits, all from bin[0] */ - base64[n++] = base64enc[(bin[0] & 0xfc) >> 2]; - x = (bin[0] & 3) << 4; - - /* next 6 bits, 2 from bin[0] and 4 from bin[1] */ - if (len == 1) - { - base64[n++] = base64enc[x]; - base64[n++] = '='; - base64[n++] = '='; - break; - } - base64[n++] = base64enc[x | ((bin[1] & 0xf0) >> 4)]; - x = (bin[1] & 0x0f) << 2; - - /* next 6 bits 4 from bin[1] and 2 from bin[2] */ - if (len == 2) - { - base64[n++] = base64enc[x]; - base64[n++] = '='; - break; - } - base64[n++] = base64enc[x | ((bin[2] & 0xc0) >> 6)]; - - /* last 6 bits, all from bin [2] */ - base64[n++] = base64enc[bin[2] & 0x3f]; - bin += 3; - len -= 3; - } - base64[n] = 0; - return n; -} - -static BOOL set_credentials( request_t *request, DWORD target, DWORD scheme, LPCWSTR username, LPCWSTR password ) -{ - static const WCHAR basic[] = {'B','a','s','i','c',' ',0}; - - const WCHAR *auth_scheme, *auth_target; - WCHAR *auth_header; - DWORD len, auth_data_len; - char *auth_data; - BOOL ret; - - switch (target) - { - case WINHTTP_AUTH_TARGET_SERVER: auth_target = attr_authorization; break; - case WINHTTP_AUTH_TARGET_PROXY: auth_target = attr_proxy_authorization; break; - default: - WARN("unknown target %x\n", target); - return FALSE; - } - switch (scheme) - { - case WINHTTP_AUTH_SCHEME_BASIC: - { - int userlen = WideCharToMultiByte( CP_UTF8, 0, username, strlenW( username ), NULL, 0, NULL, NULL ); - int passlen = WideCharToMultiByte( CP_UTF8, 0, password, strlenW( password ), NULL, 0, NULL, NULL ); - - TRACE("basic authentication\n"); - - auth_scheme = basic; - auth_data_len = userlen + 1 + passlen; - if (!(auth_data = heap_alloc( auth_data_len ))) return FALSE; - - WideCharToMultiByte( CP_UTF8, 0, username, -1, auth_data, userlen, NULL, NULL ); - auth_data[userlen] = ':'; - WideCharToMultiByte( CP_UTF8, 0, password, -1, auth_data + userlen + 1, passlen, NULL, NULL ); - break; - } - case WINHTTP_AUTH_SCHEME_NTLM: - case WINHTTP_AUTH_SCHEME_PASSPORT: - case WINHTTP_AUTH_SCHEME_DIGEST: - case WINHTTP_AUTH_SCHEME_NEGOTIATE: - FIXME("unimplemented authentication scheme %x\n", scheme); - return FALSE; - default: - WARN("unknown authentication scheme %x\n", scheme); - return FALSE; - } - - len = strlenW( auth_scheme ) + ((auth_data_len + 2) * 4) / 3; - if (!(auth_header = heap_alloc( (len + 1) * sizeof(WCHAR) ))) - { - heap_free( auth_data ); - return FALSE; - } - strcpyW( auth_header, auth_scheme ); - encode_base64( auth_data, auth_data_len, auth_header + strlenW( auth_header ) ); - - ret = process_header( request, auth_target, auth_header, WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE, TRUE ); - - heap_free( auth_data ); - heap_free( auth_header ); - return ret; -} - -/*********************************************************************** - * WinHttpSetCredentials (winhttp.@) - */ -BOOL WINAPI WinHttpSetCredentials( HINTERNET hrequest, DWORD target, DWORD scheme, LPCWSTR username, - LPCWSTR password, LPVOID params ) -{ - BOOL ret; - request_t *request; - - TRACE("%p, %x, 0x%08x, %s, %p, %p\n", hrequest, target, scheme, debugstr_w(username), password, params); - - if (!(request = (request_t *)grab_object( hrequest ))) - { - set_last_error( ERROR_INVALID_HANDLE ); - return FALSE; - } - if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST) - { - release_object( &request->hdr ); - set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE ); - return FALSE; - } - - ret = set_credentials( request, target, scheme, username, password ); - - release_object( &request->hdr ); - return ret; -} diff --git a/reactos/dll/win32/winhttp/session.c b/reactos/dll/win32/winhttp/session.c index 11c4b4fbf99..d14b854459f 100644 --- a/reactos/dll/win32/winhttp/session.c +++ b/reactos/dll/win32/winhttp/session.c @@ -21,16 +21,26 @@ #include "wine/debug.h" #include +#include #include "windef.h" #include "winbase.h" #include "winhttp.h" #include "wincrypt.h" +#include "winreg.h" #include "winhttp_private.h" WINE_DEFAULT_DEBUG_CHANNEL(winhttp); +#define DEFAULT_RESOLVE_TIMEOUT 0 +#define DEFAULT_CONNECT_TIMEOUT 20000 +#define DEFAULT_SEND_TIMEOUT 30000 +#define DEFAULT_RECEIVE_TIMEOUT 30000 + +/* FIXME */ +#define CP_UNIXCP CP_ACP + void set_last_error( DWORD error ) { /* FIXME */ @@ -85,6 +95,8 @@ static void session_destroy( object_header_t *hdr ) static BOOL session_query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen ) { + session_t *session = (session_t *)hdr; + switch (option) { case WINHTTP_OPTION_REDIRECT_POLICY: @@ -100,6 +112,22 @@ static BOOL session_query_option( object_header_t *hdr, DWORD option, LPVOID buf *buflen = sizeof(DWORD); return TRUE; } + case WINHTTP_OPTION_RESOLVE_TIMEOUT: + *(DWORD *)buffer = session->resolve_timeout; + *buflen = sizeof(DWORD); + return TRUE; + case WINHTTP_OPTION_CONNECT_TIMEOUT: + *(DWORD *)buffer = session->connect_timeout; + *buflen = sizeof(DWORD); + return TRUE; + case WINHTTP_OPTION_SEND_TIMEOUT: + *(DWORD *)buffer = session->send_timeout; + *buflen = sizeof(DWORD); + return TRUE; + case WINHTTP_OPTION_RECEIVE_TIMEOUT: + *(DWORD *)buffer = session->recv_timeout; + *buflen = sizeof(DWORD); + return TRUE; default: FIXME("unimplemented option %u\n", option); set_last_error( ERROR_INVALID_PARAMETER ); @@ -109,6 +137,8 @@ static BOOL session_query_option( object_header_t *hdr, DWORD option, LPVOID buf static BOOL session_set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen ) { + session_t *session = (session_t *)hdr; + switch (option) { case WINHTTP_OPTION_PROXY: @@ -136,6 +166,18 @@ static BOOL session_set_option( object_header_t *hdr, DWORD option, LPVOID buffe case WINHTTP_OPTION_DISABLE_FEATURE: set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE ); return FALSE; + case WINHTTP_OPTION_RESOLVE_TIMEOUT: + session->resolve_timeout = *(DWORD *)buffer; + return TRUE; + case WINHTTP_OPTION_CONNECT_TIMEOUT: + session->connect_timeout = *(DWORD *)buffer; + return TRUE; + case WINHTTP_OPTION_SEND_TIMEOUT: + session->send_timeout = *(DWORD *)buffer; + return TRUE; + case WINHTTP_OPTION_RECEIVE_TIMEOUT: + session->recv_timeout = *(DWORD *)buffer; + return TRUE; default: FIXME("unimplemented option %u\n", option); set_last_error( ERROR_INVALID_PARAMETER ); @@ -166,13 +208,39 @@ HINTERNET WINAPI WinHttpOpen( LPCWSTR agent, DWORD access, LPCWSTR proxy, LPCWST session->hdr.vtbl = &session_vtbl; session->hdr.flags = flags; session->hdr.refs = 1; - session->access = access; session->hdr.redirect_policy = WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP; + session->resolve_timeout = DEFAULT_RESOLVE_TIMEOUT; + session->connect_timeout = DEFAULT_CONNECT_TIMEOUT; + session->send_timeout = DEFAULT_SEND_TIMEOUT; + session->recv_timeout = DEFAULT_RECEIVE_TIMEOUT; list_init( &session->cookie_cache ); if (agent && !(session->agent = strdupW( agent ))) goto end; - if (proxy && !(session->proxy_server = strdupW( proxy ))) goto end; - if (bypass && !(session->proxy_bypass = strdupW( bypass ))) goto end; + if (access == WINHTTP_ACCESS_TYPE_DEFAULT_PROXY) + { + WINHTTP_PROXY_INFO info; + + WinHttpGetDefaultProxyConfiguration( &info ); + session->access = info.dwAccessType; + if (info.lpszProxy && !(session->proxy_server = strdupW( info.lpszProxy ))) + { + GlobalFree( (LPWSTR)info.lpszProxy ); + GlobalFree( (LPWSTR)info.lpszProxyBypass ); + goto end; + } + if (info.lpszProxyBypass && !(session->proxy_bypass = strdupW( info.lpszProxyBypass ))) + { + GlobalFree( (LPWSTR)info.lpszProxy ); + GlobalFree( (LPWSTR)info.lpszProxyBypass ); + goto end; + } + } + else if (access == WINHTTP_ACCESS_TYPE_NAMED_PROXY) + { + session->access = access; + if (proxy && !(session->proxy_server = strdupW( proxy ))) goto end; + if (bypass && !(session->proxy_bypass = strdupW( bypass ))) goto end; + } if (!(handle = alloc_handle( &session->hdr ))) goto end; session->hdr.handle = handle; @@ -201,13 +269,199 @@ static void connect_destroy( object_header_t *hdr ) heap_free( connect ); } +static BOOL connect_query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen ) +{ + connect_t *connect = (connect_t *)hdr; + + switch (option) + { + case WINHTTP_OPTION_PARENT_HANDLE: + { + if (!buffer || *buflen < sizeof(HINTERNET)) + { + *buflen = sizeof(HINTERNET); + set_last_error( ERROR_INSUFFICIENT_BUFFER ); + return FALSE; + } + + *(HINTERNET *)buffer = ((object_header_t *)connect->session)->handle; + *buflen = sizeof(HINTERNET); + return TRUE; + } + case WINHTTP_OPTION_RESOLVE_TIMEOUT: + *(DWORD *)buffer = connect->session->resolve_timeout; + *buflen = sizeof(DWORD); + return TRUE; + case WINHTTP_OPTION_CONNECT_TIMEOUT: + *(DWORD *)buffer = connect->session->connect_timeout; + *buflen = sizeof(DWORD); + return TRUE; + case WINHTTP_OPTION_SEND_TIMEOUT: + *(DWORD *)buffer = connect->session->send_timeout; + *buflen = sizeof(DWORD); + return TRUE; + case WINHTTP_OPTION_RECEIVE_TIMEOUT: + *(DWORD *)buffer = connect->session->recv_timeout; + *buflen = sizeof(DWORD); + return TRUE; + default: + FIXME("unimplemented option %u\n", option); + set_last_error( ERROR_INVALID_PARAMETER ); + return FALSE; + } +} + static const object_vtbl_t connect_vtbl = { connect_destroy, - NULL, + connect_query_option, NULL }; +static BOOL domain_matches(LPCWSTR server, LPCWSTR domain) +{ + static const WCHAR localW[] = { '<','l','o','c','a','l','>',0 }; + BOOL ret = FALSE; + + if (!strcmpiW( domain, localW ) && !strchrW( server, '.' )) + ret = TRUE; + else if (*domain == '*') + { + if (domain[1] == '.') + { + LPCWSTR dot; + + /* For a hostname to match a wildcard, the last domain must match + * the wildcard exactly. E.g. if the wildcard is *.a.b, and the + * hostname is www.foo.a.b, it matches, but a.b does not. + */ + dot = strchrW( server, '.' ); + if (dot) + { + int len = strlenW( dot + 1 ); + + if (len > strlenW( domain + 2 )) + { + LPCWSTR ptr; + + /* The server's domain is longer than the wildcard, so it + * could be a subdomain. Compare the last portion of the + * server's domain. + */ + ptr = dot + len + 1 - strlenW( domain + 2 ); + if (!strcmpiW( ptr, domain + 2 )) + { + /* This is only a match if the preceding character is + * a '.', i.e. that it is a matching domain. E.g. + * if domain is '*.b.c' and server is 'www.ab.c' they + * do not match. + */ + ret = *(ptr - 1) == '.'; + } + } + else + ret = !strcmpiW( dot + 1, domain + 2 ); + } + } + } + else + ret = !strcmpiW( server, domain ); + return ret; +} + +/* Matches INTERNET_MAX_HOST_NAME_LENGTH in wininet.h, also RFC 1035 */ +#define MAX_HOST_NAME_LENGTH 256 + +static BOOL should_bypass_proxy(session_t *session, LPCWSTR server) +{ + LPCWSTR ptr; + BOOL ret = FALSE; + + if (!session->proxy_bypass) return FALSE; + ptr = session->proxy_bypass; + do { + LPCWSTR tmp = ptr; + + ptr = strchrW( ptr, ';' ); + if (!ptr) + ptr = strchrW( tmp, ' ' ); + if (ptr) + { + if (ptr - tmp < MAX_HOST_NAME_LENGTH) + { + WCHAR domain[MAX_HOST_NAME_LENGTH]; + + memcpy( domain, tmp, (ptr - tmp) * sizeof(WCHAR) ); + domain[ptr - tmp] = 0; + ret = domain_matches( server, domain ); + } + ptr += 1; + } + else if (*tmp) + ret = domain_matches( server, tmp ); + } while (ptr && !ret); + return ret; +} + +BOOL set_server_for_hostname( connect_t *connect, LPCWSTR server, INTERNET_PORT port ) +{ + session_t *session = connect->session; + BOOL ret = TRUE; + + if (session->proxy_server && !should_bypass_proxy(session, server)) + { + LPCWSTR colon; + + if ((colon = strchrW( session->proxy_server, ':' ))) + { + if (!connect->servername || strncmpiW( connect->servername, + session->proxy_server, colon - session->proxy_server - 1 )) + { + heap_free( connect->servername ); + if (!(connect->servername = heap_alloc( + (colon - session->proxy_server + 1) * sizeof(WCHAR) ))) + { + ret = FALSE; + goto end; + } + memcpy( connect->servername, session->proxy_server, + (colon - session->proxy_server) * sizeof(WCHAR) ); + connect->servername[colon - session->proxy_server] = 0; + if (*(colon + 1)) + connect->serverport = atoiW( colon + 1 ); + else + connect->serverport = INTERNET_DEFAULT_PORT; + } + } + else + { + if (!connect->servername || strcmpiW( connect->servername, + session->proxy_server )) + { + heap_free( connect->servername ); + if (!(connect->servername = strdupW( session->proxy_server ))) + { + ret = FALSE; + goto end; + } + connect->serverport = INTERNET_DEFAULT_PORT; + } + } + } + else if (server) + { + heap_free( connect->servername ); + if (!(connect->servername = strdupW( server ))) + { + ret = FALSE; + goto end; + } + connect->serverport = port; + } +end: + return ret; +} + /*********************************************************************** * WinHttpConnect (winhttp.@) */ @@ -252,11 +506,11 @@ HINTERNET WINAPI WinHttpConnect( HINTERNET hsession, LPCWSTR server, INTERNET_PO connect->session = session; list_add_head( &session->hdr.children, &connect->hdr.entry ); - if (server && !(connect->hostname = strdupW( server ))) goto end; + if (!(connect->hostname = strdupW( server ))) goto end; connect->hostport = port; - if (server && !(connect->servername = strdupW( server ))) goto end; - connect->serverport = port; + if (!set_server_for_hostname( connect, server, port )) + goto end; if (!(hconnect = alloc_handle( &connect->hdr ))) goto end; connect->hdr.handle = hconnect; @@ -296,13 +550,40 @@ static void request_destroy( object_header_t *hdr ) heap_free( request ); } +static void str_to_buffer( WCHAR *buffer, const WCHAR *str, LPDWORD buflen ) +{ + int len = 0; + if (str) len = strlenW( str ); + if (buffer && *buflen > len) + { + memcpy( buffer, str, len * sizeof(WCHAR) ); + buffer[len] = 0; + } + *buflen = len * sizeof(WCHAR); +} + +static WCHAR *blob_to_str( DWORD encoding, CERT_NAME_BLOB *blob ) +{ + WCHAR *ret; + DWORD size, format = CERT_SIMPLE_NAME_STR | CERT_NAME_STR_CRLF_FLAG; + + size = CertNameToStrW( encoding, blob, format, NULL, 0 ); + if ((ret = LocalAlloc( 0, size * sizeof(WCHAR) ))) + CertNameToStrW( encoding, blob, format, ret, size ); + + return ret; +} + static BOOL request_query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen ) { + request_t *request = (request_t *)hdr; + switch (option) { case WINHTTP_OPTION_SECURITY_FLAGS: { DWORD flags; + int bits; if (!buffer || *buflen < sizeof(flags)) { @@ -313,6 +594,14 @@ static BOOL request_query_option( object_header_t *hdr, DWORD option, LPVOID buf flags = 0; if (hdr->flags & WINHTTP_FLAG_SECURE) flags |= SECURITY_FLAG_SECURE; + flags |= request->netconn.security_flags; + bits = netconn_get_cipher_strength( &request->netconn ); + if (bits >= 128) + flags |= SECURITY_FLAG_STRENGTH_STRONG; + else if (bits >= 56) + flags |= SECURITY_FLAG_STRENGTH_MEDIUM; + else + flags |= SECURITY_FLAG_STRENGTH_WEAK; *(DWORD *)buffer = flags; *buflen = sizeof(flags); return TRUE; @@ -320,7 +609,6 @@ static BOOL request_query_option( object_header_t *hdr, DWORD option, LPVOID buf case WINHTTP_OPTION_SERVER_CERT_CONTEXT: { const CERT_CONTEXT *cert; - request_t *request = (request_t *)hdr; if (!buffer || *buflen < sizeof(cert)) { @@ -334,6 +622,41 @@ static BOOL request_query_option( object_header_t *hdr, DWORD option, LPVOID buf *buflen = sizeof(cert); return TRUE; } + case WINHTTP_OPTION_SECURITY_CERTIFICATE_STRUCT: + { + const CERT_CONTEXT *cert; + const CRYPT_OID_INFO *oidInfo; + WINHTTP_CERTIFICATE_INFO *ci = buffer; + + FIXME("partial stub\n"); + + if (!buffer || *buflen < sizeof(*ci)) + { + *buflen = sizeof(*ci); + set_last_error( ERROR_INSUFFICIENT_BUFFER ); + return FALSE; + } + if (!(cert = netconn_get_certificate( &request->netconn ))) return FALSE; + + ci->ftExpiry = cert->pCertInfo->NotAfter; + ci->ftStart = cert->pCertInfo->NotBefore; + ci->lpszSubjectInfo = blob_to_str( cert->dwCertEncodingType, &cert->pCertInfo->Subject ); + ci->lpszIssuerInfo = blob_to_str( cert->dwCertEncodingType, &cert->pCertInfo->Issuer ); + ci->lpszProtocolName = NULL; + oidInfo = CryptFindOIDInfo( CRYPT_OID_INFO_OID_KEY, + cert->pCertInfo->SignatureAlgorithm.pszObjId, + 0 ); + if (oidInfo) + ci->lpszSignatureAlgName = (LPWSTR)oidInfo->pwszName; + else + ci->lpszSignatureAlgName = NULL; + ci->lpszEncryptionAlgName = NULL; + ci->dwKeySize = netconn_get_cipher_strength( &request->netconn ); + + CertFreeCertificateContext( cert ); + *buflen = sizeof(*ci); + return TRUE; + } case WINHTTP_OPTION_SECURITY_KEY_BITNESS: { if (!buffer || *buflen < sizeof(DWORD)) @@ -343,10 +666,43 @@ static BOOL request_query_option( object_header_t *hdr, DWORD option, LPVOID buf return FALSE; } - *(DWORD *)buffer = 128; /* FIXME */ + *(DWORD *)buffer = netconn_get_cipher_strength( &request->netconn ); *buflen = sizeof(DWORD); return TRUE; } + case WINHTTP_OPTION_RESOLVE_TIMEOUT: + *(DWORD *)buffer = request->resolve_timeout; + *buflen = sizeof(DWORD); + return TRUE; + case WINHTTP_OPTION_CONNECT_TIMEOUT: + *(DWORD *)buffer = request->connect_timeout; + *buflen = sizeof(DWORD); + return TRUE; + case WINHTTP_OPTION_SEND_TIMEOUT: + *(DWORD *)buffer = request->send_timeout; + *buflen = sizeof(DWORD); + return TRUE; + case WINHTTP_OPTION_RECEIVE_TIMEOUT: + *(DWORD *)buffer = request->recv_timeout; + *buflen = sizeof(DWORD); + return TRUE; + + case WINHTTP_OPTION_USERNAME: + str_to_buffer( buffer, request->connect->username, buflen ); + return TRUE; + + case WINHTTP_OPTION_PASSWORD: + str_to_buffer( buffer, request->connect->password, buflen ); + return TRUE; + + case WINHTTP_OPTION_PROXY_USERNAME: + str_to_buffer( buffer, request->connect->session->proxy_username, buflen ); + return TRUE; + + case WINHTTP_OPTION_PROXY_PASSWORD: + str_to_buffer( buffer, request->connect->session->proxy_password, buflen ); + return TRUE; + default: FIXME("unimplemented option %u\n", option); set_last_error( ERROR_INVALID_PARAMETER ); @@ -354,8 +710,23 @@ static BOOL request_query_option( object_header_t *hdr, DWORD option, LPVOID buf } } +static WCHAR *buffer_to_str( WCHAR *buffer, DWORD buflen ) +{ + WCHAR *ret; + if ((ret = heap_alloc( (buflen + 1) * sizeof(WCHAR)))) + { + memcpy( ret, buffer, buflen * sizeof(WCHAR) ); + ret[buflen] = 0; + return ret; + } + set_last_error( ERROR_OUTOFMEMORY ); + return NULL; +} + static BOOL request_set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen ) { + request_t *request = (request_t *)hdr; + switch (option) { case WINHTTP_OPTION_PROXY: @@ -410,6 +781,73 @@ static BOOL request_set_option( object_header_t *hdr, DWORD option, LPVOID buffe hdr->redirect_policy = policy; return TRUE; } + case WINHTTP_OPTION_SECURITY_FLAGS: + { + DWORD flags; + + if (buflen < sizeof(DWORD)) + { + set_last_error( ERROR_INSUFFICIENT_BUFFER ); + return FALSE; + } + flags = *(DWORD *)buffer; + TRACE("0x%x\n", flags); + if (!(flags & (SECURITY_FLAG_IGNORE_CERT_CN_INVALID | + SECURITY_FLAG_IGNORE_CERT_DATE_INVALID | + SECURITY_FLAG_IGNORE_UNKNOWN_CA | + SECURITY_FLAG_IGNORE_CERT_WRONG_USAGE))) + { + set_last_error( ERROR_INVALID_PARAMETER ); + return FALSE; + } + request->netconn.security_flags = flags; + return TRUE; + } + case WINHTTP_OPTION_RESOLVE_TIMEOUT: + request->resolve_timeout = *(DWORD *)buffer; + return TRUE; + case WINHTTP_OPTION_CONNECT_TIMEOUT: + request->connect_timeout = *(DWORD *)buffer; + return TRUE; + case WINHTTP_OPTION_SEND_TIMEOUT: + request->send_timeout = *(DWORD *)buffer; + return TRUE; + case WINHTTP_OPTION_RECEIVE_TIMEOUT: + request->recv_timeout = *(DWORD *)buffer; + return TRUE; + + case WINHTTP_OPTION_USERNAME: + { + connect_t *connect = request->connect; + + heap_free( connect->username ); + if (!(connect->username = buffer_to_str( buffer, buflen ))) return FALSE; + return TRUE; + } + case WINHTTP_OPTION_PASSWORD: + { + connect_t *connect = request->connect; + + heap_free( connect->password ); + if (!(connect->password = buffer_to_str( buffer, buflen ))) return FALSE; + return TRUE; + } + case WINHTTP_OPTION_PROXY_USERNAME: + { + session_t *session = request->connect->session; + + heap_free( session->proxy_username ); + if (!(session->proxy_username = buffer_to_str( buffer, buflen ))) return FALSE; + return TRUE; + } + case WINHTTP_OPTION_PROXY_PASSWORD: + { + session_t *session = request->connect->session; + + heap_free( session->proxy_password ); + if (!(session->proxy_password = buffer_to_str( buffer, buflen ))) return FALSE; + return TRUE; + } default: FIXME("unimplemented option %u\n", option); set_last_error( ERROR_INVALID_PARAMETER ); @@ -466,6 +904,10 @@ HINTERNET WINAPI WinHttpOpenRequest( HINTERNET hconnect, LPCWSTR verb, LPCWSTR o list_add_head( &connect->hdr.children, &request->hdr.entry ); if (!netconn_init( &request->netconn, request->hdr.flags & WINHTTP_FLAG_SECURE )) goto end; + request->resolve_timeout = connect->session->resolve_timeout; + request->connect_timeout = connect->session->connect_timeout; + request->send_timeout = connect->session->send_timeout; + request->recv_timeout = connect->session->recv_timeout; if (!verb || !verb[0]) verb = getW; if (!(request->verb = strdupW( verb ))) goto end; @@ -648,17 +1090,167 @@ BOOL WINAPI WinHttpDetectAutoProxyConfigUrl( DWORD flags, LPWSTR *url ) return FALSE; } +static const WCHAR Connections[] = { + 'S','o','f','t','w','a','r','e','\\', + 'M','i','c','r','o','s','o','f','t','\\', + 'W','i','n','d','o','w','s','\\', + 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\', + 'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s','\\', + 'C','o','n','n','e','c','t','i','o','n','s',0 }; +static const WCHAR WinHttpSettings[] = { + 'W','i','n','H','t','t','p','S','e','t','t','i','n','g','s',0 }; +static const DWORD WINHTTPSETTINGS_MAGIC = 0x18; +static const DWORD WINHTTP_PROXY_TYPE_DIRECT = 1; +static const DWORD WINHTTP_PROXY_TYPE_PROXY = 2; + +struct winhttp_settings_header +{ + DWORD magic; + DWORD unknown; /* always zero? */ + DWORD flags; /* one of WINHTTP_PROXY_TYPE_* */ +}; + +static inline void copy_char_to_wchar_sz(const BYTE *src, DWORD len, WCHAR *dst) +{ + const BYTE *begin; + + for (begin = src; src - begin < len; src++, dst++) + *dst = *src; + *dst = 0; +} + /*********************************************************************** * WinHttpGetDefaultProxyConfiguration (winhttp.@) */ BOOL WINAPI WinHttpGetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info ) { - FIXME("%p\n", info); + LONG l; + HKEY key; + BOOL got_from_reg = FALSE, direct = TRUE; + char *envproxy; - info->dwAccessType = WINHTTP_ACCESS_TYPE_NO_PROXY; - info->lpszProxy = NULL; - info->lpszProxyBypass = NULL; + TRACE("%p\n", info); + l = RegOpenKeyExW( HKEY_LOCAL_MACHINE, Connections, 0, KEY_READ, &key ); + if (!l) + { + DWORD type, size = 0; + + l = RegQueryValueExW( key, WinHttpSettings, NULL, &type, NULL, &size ); + if (!l && type == REG_BINARY && + size >= sizeof(struct winhttp_settings_header) + 2 * sizeof(DWORD)) + { + BYTE *buf = heap_alloc( size ); + + if (buf) + { + struct winhttp_settings_header *hdr = + (struct winhttp_settings_header *)buf; + DWORD *len = (DWORD *)(hdr + 1); + + l = RegQueryValueExW( key, WinHttpSettings, NULL, NULL, buf, + &size ); + if (!l && hdr->magic == WINHTTPSETTINGS_MAGIC && + hdr->unknown == 0) + { + if (hdr->flags & WINHTTP_PROXY_TYPE_PROXY) + { + BOOL sane = FALSE; + LPWSTR proxy = NULL; + LPWSTR proxy_bypass = NULL; + + /* Sanity-check length of proxy string */ + if ((BYTE *)len - buf + *len <= size) + { + sane = TRUE; + proxy = GlobalAlloc( 0, (*len + 1) * sizeof(WCHAR) ); + if (proxy) + copy_char_to_wchar_sz( (BYTE *)(len + 1), *len, proxy ); + len = (DWORD *)((BYTE *)(len + 1) + *len); + } + if (sane) + { + /* Sanity-check length of proxy bypass string */ + if ((BYTE *)len - buf + *len <= size) + { + proxy_bypass = GlobalAlloc( 0, (*len + 1) * sizeof(WCHAR) ); + if (proxy_bypass) + copy_char_to_wchar_sz( (BYTE *)(len + 1), *len, proxy_bypass ); + } + else + { + sane = FALSE; + GlobalFree( proxy ); + proxy = NULL; + } + } + info->lpszProxy = proxy; + info->lpszProxyBypass = proxy_bypass; + if (sane) + { + got_from_reg = TRUE; + direct = FALSE; + info->dwAccessType = + WINHTTP_ACCESS_TYPE_NAMED_PROXY; + TRACE("http proxy (from registry) = %s, bypass = %s\n", + debugstr_w(info->lpszProxy), + debugstr_w(info->lpszProxyBypass)); + } + } + } + heap_free( buf ); + } + } + RegCloseKey( key ); + } + if (!got_from_reg && (envproxy = getenv( "http_proxy" ))) + { + char *colon, *http_proxy; + + if ((colon = strchr( envproxy, ':' ))) + { + if (*(colon + 1) == '/' && *(colon + 2) == '/') + { + static const char http[] = "http://"; + + /* It's a scheme, check that it's http */ + if (!strncmp( envproxy, http, strlen( http ) )) + http_proxy = envproxy + strlen( http ); + else + { + WARN("unsupported scheme in $http_proxy: %s\n", envproxy); + http_proxy = NULL; + } + } + else + http_proxy = envproxy; + } + else + http_proxy = envproxy; + if (http_proxy) + { + WCHAR *http_proxyW; + int len; + + len = MultiByteToWideChar( CP_UNIXCP, 0, http_proxy, -1, NULL, 0 ); + if ((http_proxyW = GlobalAlloc( 0, len * sizeof(WCHAR)))) + { + MultiByteToWideChar( CP_UNIXCP, 0, http_proxy, -1, http_proxyW, len ); + direct = FALSE; + info->dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY; + info->lpszProxy = http_proxyW; + info->lpszProxyBypass = NULL; + TRACE("http proxy (from environment) = %s\n", + debugstr_w(info->lpszProxy)); + } + } + } + if (direct) + { + info->dwAccessType = WINHTTP_ACCESS_TYPE_NO_PROXY; + info->lpszProxy = NULL; + info->lpszProxyBypass = NULL; + } return TRUE; } @@ -703,9 +1295,106 @@ BOOL WINAPI WinHttpGetProxyForUrl( HINTERNET hsession, LPCWSTR url, WINHTTP_AUTO */ BOOL WINAPI WinHttpSetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info ) { - FIXME("%p [%u, %s, %s]\n", info, info->dwAccessType, debugstr_w(info->lpszProxy), - debugstr_w(info->lpszProxyBypass)); - return TRUE; + LONG l; + HKEY key; + BOOL ret = FALSE; + const WCHAR *src; + + TRACE("%p\n", info); + + if (!info) + { + set_last_error( ERROR_INVALID_PARAMETER ); + return FALSE; + } + switch (info->dwAccessType) + { + case WINHTTP_ACCESS_TYPE_NO_PROXY: + break; + case WINHTTP_ACCESS_TYPE_NAMED_PROXY: + if (!info->lpszProxy) + { + set_last_error( ERROR_INVALID_PARAMETER ); + return FALSE; + } + /* Only ASCII characters are allowed */ + for (src = info->lpszProxy; *src; src++) + if (*src > 0x7f) + { + set_last_error( ERROR_INVALID_PARAMETER ); + return FALSE; + } + if (info->lpszProxyBypass) + { + for (src = info->lpszProxyBypass; *src; src++) + if (*src > 0x7f) + { + set_last_error( ERROR_INVALID_PARAMETER ); + return FALSE; + } + } + break; + default: + set_last_error( ERROR_INVALID_PARAMETER ); + return FALSE; + } + + l = RegCreateKeyExW( HKEY_LOCAL_MACHINE, Connections, 0, NULL, 0, + KEY_WRITE, NULL, &key, NULL ); + if (!l) + { + DWORD size = sizeof(struct winhttp_settings_header) + 2 * sizeof(DWORD); + BYTE *buf; + + if (info->dwAccessType == WINHTTP_ACCESS_TYPE_NAMED_PROXY) + { + size += strlenW( info->lpszProxy ); + if (info->lpszProxyBypass) + size += strlenW( info->lpszProxyBypass ); + } + buf = heap_alloc( size ); + if (buf) + { + struct winhttp_settings_header *hdr = + (struct winhttp_settings_header *)buf; + DWORD *len = (DWORD *)(hdr + 1); + + hdr->magic = WINHTTPSETTINGS_MAGIC; + hdr->unknown = 0; + if (info->dwAccessType == WINHTTP_ACCESS_TYPE_NAMED_PROXY) + { + BYTE *dst; + + hdr->flags = WINHTTP_PROXY_TYPE_PROXY; + *len++ = strlenW( info->lpszProxy ); + for (dst = (BYTE *)len, src = info->lpszProxy; *src; + src++, dst++) + *dst = *src; + len = (DWORD *)dst; + if (info->lpszProxyBypass) + { + *len++ = strlenW( info->lpszProxyBypass ); + for (dst = (BYTE *)len, src = info->lpszProxyBypass; *src; + src++, dst++) + *dst = *src; + } + else + *len++ = 0; + } + else + { + hdr->flags = WINHTTP_PROXY_TYPE_DIRECT; + *len++ = 0; + *len++ = 0; + } + l = RegSetValueExW( key, WinHttpSettings, 0, REG_BINARY, buf, size ); + if (!l) + ret = TRUE; + heap_free( buf ); + } + RegCloseKey( key ); + } + return ret; } /*********************************************************************** @@ -737,8 +1426,69 @@ WINHTTP_STATUS_CALLBACK WINAPI WinHttpSetStatusCallback( HINTERNET handle, WINHT */ BOOL WINAPI WinHttpSetTimeouts( HINTERNET handle, int resolve, int connect, int send, int receive ) { - FIXME("%p, %d, %d, %d, %d\n", handle, resolve, connect, send, receive); - return TRUE; + BOOL ret = TRUE; + object_header_t *hdr; + request_t *request; + session_t *session; + + TRACE("%p, %d, %d, %d, %d\n", handle, resolve, connect, send, receive); + + if (resolve < -1 || connect < -1 || send < -1 || receive < -1) + { + set_last_error( ERROR_INVALID_PARAMETER ); + return FALSE; + } + + if (!(hdr = grab_object( handle ))) + { + set_last_error( ERROR_INVALID_HANDLE ); + return FALSE; + } + + switch(hdr->type) + { + case WINHTTP_HANDLE_TYPE_REQUEST: + request = (request_t *)hdr; + request->connect_timeout = connect; + + if (resolve < 0) resolve = 0; + request->resolve_timeout = resolve; + + if (send < 0) send = 0; + request->send_timeout = send; + + if (receive < 0) receive = 0; + request->recv_timeout = receive; + + if (netconn_connected( &request->netconn )) + { + if (netconn_set_timeout( &request->netconn, TRUE, send )) ret = FALSE; + if (netconn_set_timeout( &request->netconn, FALSE, receive )) ret = FALSE; + } + + release_object( &request->hdr ); + break; + + case WINHTTP_HANDLE_TYPE_SESSION: + session = (session_t *)hdr; + session->connect_timeout = connect; + + if (resolve < 0) resolve = 0; + session->resolve_timeout = resolve; + + if (send < 0) send = 0; + session->send_timeout = send; + + if (receive < 0) receive = 0; + session->recv_timeout = receive; + break; + + default: + release_object( hdr ); + set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE ); + return FALSE; + } + return ret; } static const WCHAR wkday[7][4] = diff --git a/reactos/dll/win32/winhttp/url.c b/reactos/dll/win32/winhttp/url.c index 711987ab809..09835b43c91 100644 --- a/reactos/dll/win32/winhttp/url.c +++ b/reactos/dll/win32/winhttp/url.c @@ -133,7 +133,7 @@ BOOL WINAPI WinHttpCrackUrl( LPCWSTR url, DWORD len, DWORD flags, LPURL_COMPONEN p += 2; if (!p[0]) goto exit; - if ((q = memchrW( p, '@', len - (p - url) ))) + if ((q = memchrW( p, '@', len - (p - url) )) && !(memchrW( p, '/', q - p ))) { if ((r = memchrW( p, ':', q - p ))) { @@ -368,7 +368,7 @@ BOOL WINAPI WinHttpCreateUrl( LPURL_COMPONENTS uc, DWORD flags, LPWSTR url, LPDW TRACE("%p, 0x%08x, %p, %p\n", uc, flags, url, required); - if (!uc || uc->dwStructSize != sizeof(URL_COMPONENTS) || !required) + if (!uc || uc->dwStructSize != sizeof(URL_COMPONENTS) || !required || !url) { set_last_error( ERROR_INVALID_PARAMETER ); return FALSE; @@ -376,7 +376,7 @@ BOOL WINAPI WinHttpCreateUrl( LPURL_COMPONENTS uc, DWORD flags, LPWSTR url, LPDW if (!calc_length( uc, flags, &len )) return FALSE; - if (!url || *required < len) + if (*required < len) { *required = len + 1; set_last_error( ERROR_INSUFFICIENT_BUFFER ); diff --git a/reactos/dll/win32/winhttp/winhttp.rbuild b/reactos/dll/win32/winhttp/winhttp.rbuild index ae79b5baf6e..a812de89a41 100644 --- a/reactos/dll/win32/winhttp/winhttp.rbuild +++ b/reactos/dll/win32/winhttp/winhttp.rbuild @@ -15,6 +15,8 @@ session.c url.c wine + advapi32 + crypt32 shlwapi wininet ws2_32 diff --git a/reactos/dll/win32/winhttp/winhttp_private.h b/reactos/dll/win32/winhttp/winhttp_private.h index 511e124c5a3..5da3ae1d547 100644 --- a/reactos/dll/win32/winhttp/winhttp_private.h +++ b/reactos/dll/win32/winhttp/winhttp_private.h @@ -27,6 +27,9 @@ #include "wine/unicode.h" #include +#ifdef HAVE_SYS_SOCKET_H +# include +#endif #ifdef HAVE_NETINET_IN_H # include #endif @@ -93,6 +96,10 @@ typedef struct object_header_t hdr; LPWSTR agent; DWORD access; + int resolve_timeout; + int connect_timeout; + int send_timeout; + int recv_timeout; LPWSTR proxy_server; LPWSTR proxy_bypass; LPWSTR proxy_username; @@ -110,7 +117,7 @@ typedef struct LPWSTR password; INTERNET_PORT hostport; INTERNET_PORT serverport; - struct sockaddr_in sockaddr; + struct sockaddr_storage sockaddr; } connect_t; typedef struct @@ -121,6 +128,7 @@ typedef struct char *peek_msg; char *peek_msg_mem; size_t peek_len; + DWORD security_flags; } netconn_t; typedef struct @@ -139,6 +147,10 @@ typedef struct LPWSTR version; LPWSTR raw_headers; netconn_t netconn; + int resolve_timeout; + int connect_timeout; + int send_timeout; + int recv_timeout; LPWSTR status_text; DWORD content_length; /* total number of bytes to be read (per chunk) */ DWORD content_read; /* bytes read so far */ @@ -204,22 +216,26 @@ void send_callback( object_header_t *, DWORD, LPVOID, DWORD ); void close_connection( request_t * ); BOOL netconn_close( netconn_t * ); -BOOL netconn_connect( netconn_t *, const struct sockaddr *, unsigned int ); +BOOL netconn_connect( netconn_t *, const struct sockaddr *, unsigned int, int ); BOOL netconn_connected( netconn_t * ); BOOL netconn_create( netconn_t *, int, int, int ); BOOL netconn_get_next_line( netconn_t *, char *, DWORD * ); BOOL netconn_init( netconn_t *, BOOL ); +void netconn_unload( void ); BOOL netconn_query_data_available( netconn_t *, DWORD * ); BOOL netconn_recv( netconn_t *, void *, size_t, int, int * ); -BOOL netconn_resolve( WCHAR *, INTERNET_PORT, struct sockaddr_in * ); -BOOL netconn_secure_connect( netconn_t * ); +BOOL netconn_resolve( WCHAR *, INTERNET_PORT, struct sockaddr *, socklen_t *, int ); +BOOL netconn_secure_connect( netconn_t *, WCHAR * ); BOOL netconn_send( netconn_t *, const void *, size_t, int, int * ); +DWORD netconn_set_timeout( netconn_t *, BOOL, int ); const void *netconn_get_certificate( netconn_t * ); +int netconn_get_cipher_strength( netconn_t * ); BOOL set_cookies( request_t *, const WCHAR * ); BOOL add_cookie_headers( request_t * ); BOOL add_request_headers( request_t *, LPCWSTR, DWORD, DWORD ); void delete_domain( domain_t * ); +BOOL set_server_for_hostname( connect_t *connect, LPCWSTR server, INTERNET_PORT port ); static inline void *heap_alloc( SIZE_T size ) { diff --git a/reactos/dll/win32/winhttp/winhttp_ros.diff b/reactos/dll/win32/winhttp/winhttp_ros.diff index 2ea0e936de6..84b874997ad 100644 --- a/reactos/dll/win32/winhttp/winhttp_ros.diff +++ b/reactos/dll/win32/winhttp/winhttp_ros.diff @@ -1,111 +1,104 @@ ---- net.c Wed Sep 03 14:46:10 2008 -+++ net.c Sun Sep 07 10:54:26 2008 -@@ -59,6 +59,7 @@ - - #define DEFAULT_SEND_TIMEOUT 30 - #define DEFAULT_RECEIVE_TIMEOUT 30 -+#define RESPONSE_TIMEOUT 30 - - #ifndef HAVE_GETADDRINFO - -@@ -110,6 +111,7 @@ - +--- wine-1.3.4/dlls/winhttp/net.c 2010-10-01 14:46:44.000000000 -0400 ++++ dll/win32/winhttp/net.c 2010-10-09 17:04:11.000000000 -0400 +@@ -158,6 +158,7 @@ #endif -+#if 0 /* translate a unix error code into a winsock error code */ ++#if 0 static int sock_get_error( int err ) { -@@ -174,6 +176,9 @@ - } + #if !defined(__MINGW32__) && !defined (_MSC_VER) +@@ -223,6 +224,9 @@ + #endif return err; } +#else +#define sock_get_error(x) WSAGetLastError() +#endif - BOOL netconn_init( netconn_t *conn, BOOL secure ) - { -@@ -282,7 +287,7 @@ - conn->secure = FALSE; - } - #endif -- res = close( conn->socket ); -+ res = closesocket( conn->socket ); - conn->socket = -1; - if (res == -1) - { -@@ -463,7 +468,7 @@ - return TRUE; - } - #ifdef FIONREAD -- if (!(ret = ioctl( conn->socket, FIONREAD, &unread ))) -+ if (!(ret = ioctlsocket( conn->socket, FIONREAD, &unread ))) - { - TRACE("%d bytes of queued, but unread data\n", unread); - *available += unread; -@@ -474,7 +479,8 @@ + #ifdef SONAME_LIBSSL + static PCCERT_CONTEXT X509_to_cert_context(X509 *cert) +@@ -632,11 +636,16 @@ + res = sock_get_error( errno ); + if (res == WSAEWOULDBLOCK || res == WSAEINPROGRESS) + { +- struct pollfd pfd; ++ fd_set outfd; ++ struct timeval tv; ++ ++ FD_ZERO(&outfd); ++ FD_SET(conn->socket, &outfd); + +- pfd.fd = conn->socket; +- pfd.events = POLLOUT; +- if (poll( &pfd, 1, timeout ) > 0) ++ tv.tv_sec = 0; ++ tv.tv_usec = timeout * 1000; ++ ++ if (select( 0, NULL, &outfd, NULL, &tv ) > 0) + ret = TRUE; + else + res = sock_get_error( errno ); +@@ -832,7 +841,7 @@ BOOL netconn_get_next_line( netconn_t *conn, char *buffer, DWORD *buflen ) { - struct pollfd pfd; -+ struct timeval tv; + fd_set infd; BOOL ret = FALSE; DWORD recvd = 0; -@@ -516,11 +522,13 @@ +@@ -867,20 +876,22 @@ + return FALSE; #endif } - +- - pfd.fd = conn->socket; - pfd.events = POLLIN; ++ + FD_ZERO(&infd); + FD_SET(conn->socket, &infd); -+ tv.tv_sec=RESPONSE_TIMEOUT; -+ tv.tv_usec=0; ++ while (recvd < *buflen) { -- if (poll( &pfd, 1, DEFAULT_RECEIVE_TIMEOUT * 1000 ) > 0) -+ if (select(conn->socket+1,&infd,NULL,NULL,&tv) > 0) - { - int res; - if ((res = recv( conn->socket, &buffer[recvd], 1, 0 )) <= 0) ---- request.c Fri Sep 05 17:34:17 2008 -+++ request.c Sun Sep 07 11:29:55 2008 -@@ -20,6 +20,7 @@ - #include "wine/port.h" - #include "wine/debug.h" +- int timeout, res; +- struct timeval tv; ++ int res; ++ struct timeval tv, *ptv; + socklen_t len = sizeof(tv); -+#include - #include - #ifdef HAVE_ARPA_INET_H - # include -@@ -33,6 +34,8 @@ - #include "winhttp.h" + if ((res = getsockopt( conn->socket, SOL_SOCKET, SO_RCVTIMEO, (void*)&tv, &len ) != -1)) +- timeout = tv.tv_sec * 1000 + tv.tv_usec / 1000; ++ ptv = &tv; + else +- timeout = -1; +- if (poll( &pfd, 1, timeout ) > 0) ++ ptv = NULL; ++ ++ if (select( 0, &infd, NULL, NULL, ptv ) > 0) + { + if ((res = recv( conn->socket, &buffer[recvd], 1, 0 )) <= 0) + { +--- wine-1.3.4/dlls/winhttp/session.c 2010-10-01 14:46:44.000000000 -0400 ++++ dll/win32/winhttp/session.c 2010-10-09 17:04:11.000000000 -0400 +@@ -38,6 +38,9 @@ + #define DEFAULT_SEND_TIMEOUT 30000 + #define DEFAULT_RECEIVE_TIMEOUT 30000 + ++/* FIXME */ ++#define CP_UNIXCP CP_ACP ++ + void set_last_error( DWORD error ) + { + /* FIXME */ +--- wine-1.3.4/dlls/winhttp/request.c 2010-10-01 14:46:44.000000000 -0400 ++++ dll/win32/winhttp/request.c 2010-10-09 17:04:11.000000000 -0400 +@@ -34,6 +34,8 @@ #include "winhttp_private.h" -+ -+#include "inet_ntop.c" ++#include "inet_ntop.c" ++ WINE_DEFAULT_DEBUG_CHANNEL(winhttp); ---- winhttp_private.h Thu Sep 04 15:27:29 2008 -+++ winhttp_private.h Sun Sep 07 10:46:54 2008 -@@ -33,8 +33,14 @@ - # include - #endif - #if defined(__MINGW32__) || defined (_MSC_VER) --# include --#endif -+# include "ws2tcpip.h" -+# ifndef MSG_WAITALL -+# define MSG_WAITALL 0 -+# endif -+#else -+# define closesocket close -+# define ioctlsocket ioctl -+#endif /* __MINGW32__ */ - - typedef struct _object_header_t object_header_t; - + static const WCHAR attr_accept[] = {'A','c','c','e','p','t',0}; \ No newline at end of file diff --git a/reactos/dll/win32/wininet/wininet_ros.diff b/reactos/dll/win32/wininet/wininet_ros.diff index 9fce1d677c5..a8721d6ec72 100644 --- a/reactos/dll/win32/wininet/wininet_ros.diff +++ b/reactos/dll/win32/wininet/wininet_ros.diff @@ -37,4 +37,33 @@ +#endif /****************************************************************************** - * NETCON_create \ No newline at end of file + * NETCON_create +--- wine-1.3.4/dlls/wininet/internet.c 2010-10-01 14:46:44.000000000 -0400 ++++ dll/win32/wininet/internet.c 2010-10-09 15:33:04.000000000 -0400 +@@ -3569,19 +3569,22 @@ + + LPSTR INTERNET_GetNextLine(INT nSocket, LPDWORD dwLen) + { +- struct pollfd pfd; ++ fd_set infd; ++ struct timeval tv; + BOOL bSuccess = FALSE; + INT nRecv = 0; + LPSTR lpszBuffer = INTERNET_GetResponseBuffer(); + + TRACE("\n"); + +- pfd.fd = nSocket; +- pfd.events = POLLIN; ++ FD_ZERO(&infd); ++ FD_SET(nSocket,&infd); ++ tv.tv_sec = RESPONSE_TIMEOUT; ++ tv.tv_usec = 0; + + while (nRecv < MAX_REPLY_LEN) + { +- if (poll(&pfd,1, RESPONSE_TIMEOUT * 1000) > 0) ++ if (select(0, &infd, NULL, NULL, &tv) > 0) + { + if (recv(nSocket, &lpszBuffer[nRecv], 1, 0) <= 0) + { \ No newline at end of file