diff --git a/reactos/lib/urlmon/file.c b/reactos/lib/urlmon/file.c new file mode 100644 index 00000000000..be54cea221e --- /dev/null +++ b/reactos/lib/urlmon/file.c @@ -0,0 +1,283 @@ +/* + * Copyright 2005 Jacek Caban + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include + +#define COBJMACROS + +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "ole2.h" +#include "urlmon.h" +#include "urlmon_main.h" + +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(urlmon); + +typedef struct { + const IInternetProtocolVtbl *lpInternetProtocolVtbl; + + HANDLE file; + + LONG ref; +} FileProtocol; + +#define PROTOCOL_THIS(iface) DEFINE_THIS(FileProtocol, InternetProtocol, iface) + +#define PROTOCOL(x) ((IInternetProtocol*) &(x)->lpInternetProtocolVtbl) + +static HRESULT WINAPI FileProtocol_QueryInterface(IInternetProtocol *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); + }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) { + TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv); + *ppv = PROTOCOL(This); + }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) { + TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv); + *ppv = PROTOCOL(This); + } + + if(*ppv) { + IInternetProtocol_AddRef(iface); + return S_OK; + } + + WARN("not supported interface %s\n", debugstr_guid(riid)); + return E_NOINTERFACE; +} + +static ULONG WINAPI FileProtocol_AddRef(IInternetProtocol *iface) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + LONG ref = InterlockedIncrement(&This->ref); + TRACE("(%p) ref=%ld\n", This, ref); + return ref; +} + +static ULONG WINAPI FileProtocol_Release(IInternetProtocol *iface) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + LONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) ref=%ld\n", This, ref); + + if(!ref) { + if(This->file) + CloseHandle(This->file); + HeapFree(GetProcessHeap(), 0, This); + + URLMON_UnlockModule(); + } + + return ref; +} + +static HRESULT WINAPI FileProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl, + IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo, + DWORD grfPI, DWORD dwReserved) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + BINDINFO bindinfo; + DWORD grfBINDF = 0; + LARGE_INTEGER size; + DWORD len; + LPWSTR url, mime = NULL; + HRESULT hres; + + static const WCHAR wszFile[] = {'f','i','l','e',':'}; + + TRACE("(%p)->(%s %p %p %08lx %ld)\n", This, debugstr_w(szUrl), pOIProtSink, + pOIBindInfo, grfPI, dwReserved); + + memset(&bindinfo, 0, sizeof(bindinfo)); + bindinfo.cbSize = sizeof(BINDINFO); + IInternetBindInfo_GetBindInfo(pOIBindInfo, &grfBINDF, &bindinfo); + + if(lstrlenW(szUrl) < sizeof(wszFile)/sizeof(WCHAR) + || memcmp(szUrl, wszFile, sizeof(wszFile))) + return MK_E_SYNTAX; + + len = lstrlenW(szUrl)+16; + url = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR)); + hres = CoInternetParseUrl(szUrl, PARSE_ENCODE, 0, url, len, &len, 0); + if(FAILED(hres)) { + HeapFree(GetProcessHeap(), 0, url); + return hres; + } + + hres = FindMimeFromData(NULL, url, NULL, 0, NULL, 0, &mime, 0); + if(SUCCEEDED(hres)) + IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_DIRECTBIND, mime); + + if(!This->file) { + This->file = CreateFileW(url+sizeof(wszFile)/sizeof(WCHAR), 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); + HeapFree(GetProcessHeap(), 0, url); + CoTaskMemFree(mime); + return INET_E_RESOURCE_NOT_FOUND; + } + + IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_CACHEFILENAMEAVAILABLE, + url+sizeof(wszFile)/sizeof(WCHAR)); + if(mime) + IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, mime); + IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL); + } + + CoTaskMemFree(mime); + HeapFree(GetProcessHeap(), 0, url); + + if(GetFileSizeEx(This->file, &size)) + IInternetProtocolSink_ReportData(pOIProtSink, + BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION, + size.u.LowPart, size.u.LowPart); + + 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)->(%08lx %08lx)\n", This, hrReason, dwOptions); + return E_NOTIMPL; +} + +static HRESULT WINAPI FileProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + + TRACE("(%p)->(%08lx)\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 %lu %p)\n", This, pv, cb, pcbRead); + + if(!This->file) + return INET_E_DATA_NOT_AVAILABLE; + + ReadFile(This->file, pv, cb, &read, NULL); + + if(pcbRead) + *pcbRead = read; + + return cb == read ? S_OK : S_FALSE; +} + +static HRESULT WINAPI FileProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove, + DWORD dwOrgin, ULARGE_INTEGER *plibNewPosition) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%ld %ld %p)\n", This, dlibMove.u.LowPart, dwOrgin, plibNewPosition); + return E_NOTIMPL; +} + +static HRESULT WINAPI FileProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions) +{ + FileProtocol *This = PROTOCOL_THIS(iface); + + TRACE("(%p)->(%08lx)\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; +} + +#undef PROTOCOL_THIS + +static const IInternetProtocolVtbl FileProtocolVtbl = { + FileProtocol_QueryInterface, + FileProtocol_AddRef, + FileProtocol_Release, + FileProtocol_Start, + FileProtocol_Continue, + FileProtocol_Abort, + FileProtocol_Terminate, + FileProtocol_Suspend, + FileProtocol_Resume, + FileProtocol_Read, + FileProtocol_Seek, + FileProtocol_LockRequest, + FileProtocol_UnlockRequest +}; + +HRESULT FileProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj) +{ + FileProtocol *ret; + + TRACE("(%p %p)\n", pUnkOuter, ppobj); + + URLMON_LockModule(); + + ret = HeapAlloc(GetProcessHeap(), 0, sizeof(FileProtocol)); + + ret->lpInternetProtocolVtbl = &FileProtocolVtbl; + ret->file = NULL; + ret->ref = 1; + + *ppobj = PROTOCOL(ret); + + return S_OK; +} diff --git a/reactos/lib/urlmon/format.c b/reactos/lib/urlmon/format.c new file mode 100644 index 00000000000..309c8cd3b1b --- /dev/null +++ b/reactos/lib/urlmon/format.c @@ -0,0 +1,222 @@ +/* + * Copyright 2005 Jacek Caban + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include + +#define COBJMACROS + +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "ole2.h" +#include "urlmon.h" +#include "urlmon_main.h" + +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(urlmon); + +static WCHAR wszEnumFORMATETC[] = {'_','E','n','u','m','F','O','R','M','A','T','E','T','C','_',0}; + +typedef struct { + const IEnumFORMATETCVtbl *lpEnumFORMATETCVtbl; + + FORMATETC *fetc; + UINT fetc_cnt; + UINT it; + + LONG ref; +} EnumFORMATETC; + +static IEnumFORMATETC *EnumFORMATETC_Create(UINT cfmtetc, FORMATETC *rgfmtetc, UINT it); + +#define ENUMF_THIS(iface) ICOM_THIS_MULTI(EnumFORMATETC, lpEnumFORMATETCVtbl, iface) + +static HRESULT WINAPI EnumFORMATETC_QueryInterface(IEnumFORMATETC *iface, REFIID riid, void **ppv) +{ + TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv); + + *ppv = NULL; + + if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IEnumFORMATETC, riid)) { + *ppv = iface; + return S_OK; + } + + WARN("not supported interface %s\n", debugstr_guid(riid)); + return E_NOINTERFACE; +} + +static ULONG WINAPI EnumFORMATETC_AddRef(IEnumFORMATETC *iface) +{ + ENUMF_THIS(iface); + LONG ref = InterlockedIncrement(&This->ref); + TRACE("(%p) ref=%ld\n", This, ref); + return ref; +} + +static ULONG WINAPI EnumFORMATETC_Release(IEnumFORMATETC *iface) +{ + ENUMF_THIS(iface); + LONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) ref=%ld\n", This, ref); + + if(!ref) { + HeapFree(GetProcessHeap(), 0, This->fetc); + HeapFree(GetProcessHeap(), 0, This); + + URLMON_UnlockModule(); + } + + return ref; +} + +static HRESULT WINAPI EnumFORMATETC_Next(IEnumFORMATETC *iface, ULONG celt, + FORMATETC *rgelt, ULONG *pceltFetched) +{ + ENUMF_THIS(iface); + ULONG cnt; + + TRACE("(%p)->(%ld %p %p)\n", This, celt, rgelt, pceltFetched); + + if(!rgelt) + return E_INVALIDARG; + + if(This->it >= This->fetc_cnt || !celt) { + if(pceltFetched) + *pceltFetched = 0; + return celt ? S_FALSE : S_OK; + } + + cnt = This->fetc_cnt-This->it > celt ? celt : This->fetc_cnt-This->it; + + memcpy(rgelt, This->fetc+This->it, cnt*sizeof(FORMATETC)); + This->it += cnt; + + if(pceltFetched) + *pceltFetched = cnt; + + return cnt == celt ? S_OK : S_FALSE; +} + +static HRESULT WINAPI EnumFORMATETC_Skip(IEnumFORMATETC *iface, ULONG celt) +{ + ENUMF_THIS(iface); + + TRACE("(%p)->(%ld)\n", This, celt); + + This->it += celt; + return This->it > This->fetc_cnt ? S_FALSE : S_OK; +} + +static HRESULT WINAPI EnumFORMATETC_Reset(IEnumFORMATETC *iface) +{ + ENUMF_THIS(iface); + + TRACE("(%p)\n", This); + + This->it = 0; + return S_OK; +} + +static HRESULT WINAPI EnumFORMATETC_Clone(IEnumFORMATETC *iface, IEnumFORMATETC **ppenum) +{ + ENUMF_THIS(iface); + + TRACE("(%p)->(%p)\n", This, ppenum); + + if(!ppenum) + return E_INVALIDARG; + + *ppenum = EnumFORMATETC_Create(This->fetc_cnt, This->fetc, This->it); + return S_OK; +} + +static const IEnumFORMATETCVtbl EnumFORMATETCVtbl = { + EnumFORMATETC_QueryInterface, + EnumFORMATETC_AddRef, + EnumFORMATETC_Release, + EnumFORMATETC_Next, + EnumFORMATETC_Skip, + EnumFORMATETC_Reset, + EnumFORMATETC_Clone +}; + +static IEnumFORMATETC *EnumFORMATETC_Create(UINT cfmtetc, FORMATETC *rgfmtetc, UINT it) +{ + EnumFORMATETC *ret = HeapAlloc(GetProcessHeap(), 0, sizeof(EnumFORMATETC)); + + URLMON_LockModule(); + + ret->lpEnumFORMATETCVtbl = &EnumFORMATETCVtbl; + ret->ref = 1; + ret->it = it; + ret->fetc_cnt = cfmtetc; + + ret->fetc = HeapAlloc(GetProcessHeap(), 0, cfmtetc*sizeof(FORMATETC)); + memcpy(ret->fetc, rgfmtetc, cfmtetc*sizeof(FORMATETC)); + + return (IEnumFORMATETC*)ret; +} + +/********************************************************** + * CreateFormatEnumerator (urlmon.@) + */ +HRESULT WINAPI CreateFormatEnumerator(UINT cfmtetc, FORMATETC *rgfmtetc, + IEnumFORMATETC** ppenumfmtetc) +{ + TRACE("(%d %p %p)\n", cfmtetc, rgfmtetc, ppenumfmtetc); + + if(!ppenumfmtetc) + return E_INVALIDARG; + if(!cfmtetc) + return E_FAIL; + + *ppenumfmtetc = EnumFORMATETC_Create(cfmtetc, rgfmtetc, 0); + return S_OK; +} + +/********************************************************** + * RegisterFormatEnumerator (urlmon.@) + */ +HRESULT WINAPI RegisterFormatEnumerator(LPBC pBC, IEnumFORMATETC *pEFetc, DWORD reserved) +{ + TRACE("(%p %p %ld)\n", pBC, pEFetc, reserved); + + if(reserved) + WARN("reserved != 0\n"); + + if(!pBC || !pEFetc) + return E_INVALIDARG; + + return IBindCtx_RegisterObjectParam(pBC, wszEnumFORMATETC, (IUnknown*)pEFetc); +} + +/********************************************************** + * RevokeFormatEnumerator (urlmon.@) + */ +HRESULT WINAPI RevokeFormatEnumerator(LPBC pbc, IEnumFORMATETC *pEFetc) +{ + TRACE("(%p %p)\n", pbc, pEFetc); + + if(!pbc) + return E_INVALIDARG; + + return IBindCtx_RevokeObjectParam(pbc, wszEnumFORMATETC); +} diff --git a/reactos/lib/urlmon/ftp.c b/reactos/lib/urlmon/ftp.c new file mode 100644 index 00000000000..ef1cceb1036 --- /dev/null +++ b/reactos/lib/urlmon/ftp.c @@ -0,0 +1,202 @@ +/* + * Copyright 2005 Jacek Caban + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include + +#define COBJMACROS + +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "ole2.h" +#include "urlmon.h" +#include "urlmon_main.h" + +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(urlmon); + +typedef struct { + const IInternetProtocolVtbl *lpInternetProtocolVtbl; + LONG ref; +} FtpProtocol; + +#define PROTOCOL_THIS(iface) DEFINE_THIS(FtpProtocol, InternetProtocol, iface) + +#define PROTOCOL(x) ((IInternetProtocol*) &(x)->lpInternetProtocolVtbl) + +static HRESULT WINAPI FtpProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv) +{ + FtpProtocol *This = PROTOCOL_THIS(iface); + + *ppv = NULL; + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); + *ppv = PROTOCOL(This); + }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) { + TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv); + *ppv = PROTOCOL(This); + }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) { + TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv); + *ppv = PROTOCOL(This); + } + + if(*ppv) { + IInternetProtocol_AddRef(iface); + return S_OK; + } + + WARN("not supported interface %s\n", debugstr_guid(riid)); + return E_NOINTERFACE; +} + +static ULONG WINAPI FtpProtocol_AddRef(IInternetProtocol *iface) +{ + FtpProtocol *This = PROTOCOL_THIS(iface); + LONG ref = InterlockedIncrement(&This->ref); + TRACE("(%p) ref=%ld\n", This, ref); + return ref; +} + +static ULONG WINAPI FtpProtocol_Release(IInternetProtocol *iface) +{ + FtpProtocol *This = PROTOCOL_THIS(iface); + LONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) ref=%ld\n", This, ref); + + if(!ref) { + HeapFree(GetProcessHeap(), 0, This); + + URLMON_UnlockModule(); + } + + return ref; +} + +static HRESULT WINAPI FtpProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl, + IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo, + DWORD grfPI, DWORD dwReserved) +{ + FtpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%s %p %p %08lx %ld)\n", This, debugstr_w(szUrl), pOIProtSink, + pOIBindInfo, grfPI, dwReserved); + return E_NOTIMPL; +} + +static HRESULT WINAPI FtpProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData) +{ + FtpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%p)\n", This, pProtocolData); + return E_NOTIMPL; +} + +static HRESULT WINAPI FtpProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason, + DWORD dwOptions) +{ + FtpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%08lx %08lx)\n", This, hrReason, dwOptions); + return E_NOTIMPL; +} + +static HRESULT WINAPI FtpProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions) +{ + FtpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%08lx)\n", This, dwOptions); + return E_NOTIMPL; +} + +static HRESULT WINAPI FtpProtocol_Suspend(IInternetProtocol *iface) +{ + FtpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI FtpProtocol_Resume(IInternetProtocol *iface) +{ + FtpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI FtpProtocol_Read(IInternetProtocol *iface, void *pv, + ULONG cb, ULONG *pcbRead) +{ + FtpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%p %lu %p)\n", This, pv, cb, pcbRead); + return E_NOTIMPL; +} + +static HRESULT WINAPI FtpProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove, + DWORD dwOrgin, ULARGE_INTEGER *plibNewPosition) +{ + FtpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%ld %ld %p)\n", This, dlibMove.u.LowPart, dwOrgin, plibNewPosition); + return E_NOTIMPL; +} + +static HRESULT WINAPI FtpProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions) +{ + FtpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%08lx)\n", This, dwOptions); + return E_NOTIMPL; +} + +static HRESULT WINAPI FtpProtocol_UnlockRequest(IInternetProtocol *iface) +{ + FtpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +#undef PROTOCOL_THIS + +static const IInternetProtocolVtbl FtpProtocolVtbl = { + FtpProtocol_QueryInterface, + FtpProtocol_AddRef, + FtpProtocol_Release, + FtpProtocol_Start, + FtpProtocol_Continue, + FtpProtocol_Abort, + FtpProtocol_Terminate, + FtpProtocol_Suspend, + FtpProtocol_Resume, + FtpProtocol_Read, + FtpProtocol_Seek, + FtpProtocol_LockRequest, + FtpProtocol_UnlockRequest +}; + +HRESULT FtpProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj) +{ + FtpProtocol *ret; + + TRACE("(%p %p)\n", pUnkOuter, ppobj); + + URLMON_LockModule(); + + ret = HeapAlloc(GetProcessHeap(), 0, sizeof(FtpProtocol)); + + ret->lpInternetProtocolVtbl = &FtpProtocolVtbl; + ret->ref = 1; + + *ppobj = PROTOCOL(ret); + + return S_OK; +} diff --git a/reactos/lib/urlmon/http.c b/reactos/lib/urlmon/http.c new file mode 100644 index 00000000000..fd69d6bf55c --- /dev/null +++ b/reactos/lib/urlmon/http.c @@ -0,0 +1,202 @@ +/* + * Copyright 2005 Jacek Caban + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include + +#define COBJMACROS + +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "ole2.h" +#include "urlmon.h" +#include "urlmon_main.h" + +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(urlmon); + +typedef struct { + const IInternetProtocolVtbl *lpInternetProtocolVtbl; + LONG ref; +} HttpProtocol; + +#define PROTOCOL_THIS(iface) DEFINE_THIS(HttpProtocol, InternetProtocol, iface) + +#define PROTOCOL(x) ((IInternetProtocol*) &(x)->lpInternetProtocolVtbl) + +static HRESULT WINAPI HttpProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv) +{ + HttpProtocol *This = PROTOCOL_THIS(iface); + + *ppv = NULL; + if(IsEqualGUID(&IID_IUnknown, riid)) { + TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); + *ppv = PROTOCOL(This); + }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) { + TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv); + *ppv = PROTOCOL(This); + }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) { + TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv); + *ppv = PROTOCOL(This); + } + + if(*ppv) { + IInternetProtocol_AddRef(iface); + return S_OK; + } + + WARN("not supported interface %s\n", debugstr_guid(riid)); + return E_NOINTERFACE; +} + +static ULONG WINAPI HttpProtocol_AddRef(IInternetProtocol *iface) +{ + HttpProtocol *This = PROTOCOL_THIS(iface); + LONG ref = InterlockedIncrement(&This->ref); + TRACE("(%p) ref=%ld\n", This, ref); + return ref; +} + +static ULONG WINAPI HttpProtocol_Release(IInternetProtocol *iface) +{ + HttpProtocol *This = PROTOCOL_THIS(iface); + LONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) ref=%ld\n", This, ref); + + if(!ref) { + HeapFree(GetProcessHeap(), 0, This); + + URLMON_UnlockModule(); + } + + return ref; +} + +static HRESULT WINAPI HttpProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl, + IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo, + DWORD grfPI, DWORD dwReserved) +{ + HttpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%s %p %p %08lx %ld)\n", This, debugstr_w(szUrl), pOIProtSink, + pOIBindInfo, grfPI, dwReserved); + return E_NOTIMPL; +} + +static HRESULT WINAPI HttpProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData) +{ + HttpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%p)\n", This, pProtocolData); + return E_NOTIMPL; +} + +static HRESULT WINAPI HttpProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason, + DWORD dwOptions) +{ + HttpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%08lx %08lx)\n", This, hrReason, dwOptions); + return E_NOTIMPL; +} + +static HRESULT WINAPI HttpProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions) +{ + HttpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%08lx)\n", This, dwOptions); + return E_NOTIMPL; +} + +static HRESULT WINAPI HttpProtocol_Suspend(IInternetProtocol *iface) +{ + HttpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI HttpProtocol_Resume(IInternetProtocol *iface) +{ + HttpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +static HRESULT WINAPI HttpProtocol_Read(IInternetProtocol *iface, void *pv, + ULONG cb, ULONG *pcbRead) +{ + HttpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%p %lu %p)\n", This, pv, cb, pcbRead); + return E_NOTIMPL; +} + +static HRESULT WINAPI HttpProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove, + DWORD dwOrgin, ULARGE_INTEGER *plibNewPosition) +{ + HttpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%ld %ld %p)\n", This, dlibMove.u.LowPart, dwOrgin, plibNewPosition); + return E_NOTIMPL; +} + +static HRESULT WINAPI HttpProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions) +{ + HttpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)->(%08lx)\n", This, dwOptions); + return E_NOTIMPL; +} + +static HRESULT WINAPI HttpProtocol_UnlockRequest(IInternetProtocol *iface) +{ + HttpProtocol *This = PROTOCOL_THIS(iface); + FIXME("(%p)\n", This); + return E_NOTIMPL; +} + +#undef PROTOCOL_THIS + +static const IInternetProtocolVtbl HttpProtocolVtbl = { + HttpProtocol_QueryInterface, + HttpProtocol_AddRef, + HttpProtocol_Release, + HttpProtocol_Start, + HttpProtocol_Continue, + HttpProtocol_Abort, + HttpProtocol_Terminate, + HttpProtocol_Suspend, + HttpProtocol_Resume, + HttpProtocol_Read, + HttpProtocol_Seek, + HttpProtocol_LockRequest, + HttpProtocol_UnlockRequest +}; + +HRESULT HttpProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj) +{ + HttpProtocol *ret; + + TRACE("(%p %p)\n", pUnkOuter, ppobj); + + URLMON_LockModule(); + + ret = HeapAlloc(GetProcessHeap(), 0, sizeof(HttpProtocol)); + + ret->lpInternetProtocolVtbl = &HttpProtocolVtbl; + ret->ref = 1; + + *ppobj = PROTOCOL(ret); + + return S_OK; +} diff --git a/reactos/lib/urlmon/internet.c b/reactos/lib/urlmon/internet.c new file mode 100644 index 00000000000..e1ce8371699 --- /dev/null +++ b/reactos/lib/urlmon/internet.c @@ -0,0 +1,223 @@ +/* + * Copyright 2005 Jacek Caban + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include + +#define COBJMACROS + +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "winreg.h" +#include "shlwapi.h" +#include "ole2.h" +#include "urlmon.h" +#include "urlmon_main.h" + +#include "wine/debug.h" +#include "wine/unicode.h" + +WINE_DEFAULT_DEBUG_CHANNEL(urlmon); + +static HRESULT parse_schema(LPCWSTR url, DWORD flags, LPWSTR result, DWORD size, DWORD *rsize) +{ + WCHAR *ptr; + DWORD len = 0; + + TRACE("(%s %08lx %p %ld %p)\n", debugstr_w(url), flags, result, size, rsize); + + if(flags) + ERR("wrong flags\n"); + + ptr = strchrW(url, ':'); + if(ptr) + len = ptr-url; + + if(len >= size) + return E_POINTER; + + if(len) + memcpy(result, url, len*sizeof(WCHAR)); + result[len] = 0; + + if(rsize) + *rsize = len; + + return S_OK; +} + +static IInternetProtocolInfo *get_protocol_info(LPCWSTR url) +{ + IInternetProtocolInfo *ret = NULL; + WCHAR schema[64], str_clsid[64]; + HKEY hkey = NULL; + DWORD res, type, size, schema_len; + CLSID clsid; + LPWSTR wszKey; + HRESULT hres; + + static const WCHAR wszProtocolsKey[] = + {'P','R','O','T','O','C','O','L','S','\\','H','a','n','d','l','e','r','\\'}; + static const WCHAR wszCLSID[] = {'C','L','S','I','D',0}; + + hres = parse_schema(url, 0, schema, sizeof(schema)/sizeof(schema[0]), &schema_len); + if(FAILED(hres) || !schema_len) + return NULL; + + wszKey = HeapAlloc(GetProcessHeap(), 0, sizeof(wszProtocolsKey)+(schema_len+1)*sizeof(WCHAR)); + memcpy(wszKey, wszProtocolsKey, sizeof(wszProtocolsKey)); + memcpy(wszKey + sizeof(wszProtocolsKey)/sizeof(WCHAR), schema, (schema_len+1)*sizeof(WCHAR)); + + res = RegOpenKeyW(HKEY_CLASSES_ROOT, wszKey, &hkey); + HeapFree(GetProcessHeap(), 0, wszKey); + if(res != ERROR_SUCCESS) { + TRACE("Could not open key %s\n", debugstr_w(wszKey)); + return NULL; + } + + size = sizeof(str_clsid); + res = RegQueryValueExW(hkey, wszCLSID, NULL, &type, (LPBYTE)str_clsid, &size); + RegCloseKey(hkey); + if(res != ERROR_SUCCESS || type != REG_SZ) { + WARN("Could not get protocol CLSID res=%ld\n", res); + return NULL; + } + + hres = CLSIDFromString(str_clsid, &clsid); + if(FAILED(hres)) { + WARN("CLSIDFromString failed: %08lx\n", hres); + return NULL; + } + + CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL, &IID_IInternetProtocolInfo, (void**)&ret); + return ret; +} + +static HRESULT parse_security_url(LPCWSTR url, DWORD flags, LPWSTR result, DWORD size, DWORD *rsize) +{ + IInternetProtocolInfo *protocol_info; + HRESULT hres; + + TRACE("(%s %08lx %p %ld %p)\n", debugstr_w(url), flags, result, size, rsize); + + protocol_info = get_protocol_info(url); + + if(protocol_info) { + hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_SECURITY_URL, + flags, result, size, rsize, 0); + return hres; + } + + return E_FAIL; +} + +static HRESULT parse_encode(LPCWSTR url, DWORD flags, LPWSTR result, DWORD size, DWORD *rsize) +{ + IInternetProtocolInfo *protocol_info; + DWORD prsize; + HRESULT hres; + + TRACE("(%s %08lx %p %ld %p)\n", debugstr_w(url), flags, result, size, rsize); + + protocol_info = get_protocol_info(url); + + if(protocol_info) { + hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_ENCODE, + flags, result, size, rsize, 0); + if(SUCCEEDED(hres)) + return hres; + } + + prsize = size; + hres = UrlUnescapeW((LPWSTR)url, result, &prsize, flags); + + if(rsize) + *rsize = prsize; + + return hres; +} + +static HRESULT parse_path_from_url(LPCWSTR url, DWORD flags, LPWSTR result, DWORD size, DWORD *rsize) +{ + IInternetProtocolInfo *protocol_info; + DWORD prsize; + HRESULT hres; + + TRACE("(%s %08lx %p %ld %p)\n", debugstr_w(url), flags, result, size, rsize); + + protocol_info = get_protocol_info(url); + + if(protocol_info) { + hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_PATH_FROM_URL, + flags, result, size, rsize, 0); + if(SUCCEEDED(hres)) + return hres; + } + + prsize = size; + hres = PathCreateFromUrlW(url, result, &prsize, 0); + + if(rsize) + *rsize = prsize; + return hres; +} + +static HRESULT parse_security_domain(LPCWSTR url, DWORD flags, LPWSTR result, + DWORD size, DWORD *rsize) +{ + IInternetProtocolInfo *protocol_info; + HRESULT hres; + + TRACE("(%s %08lx %p %ld %p)\n", debugstr_w(url), flags, result, size, rsize); + + protocol_info = get_protocol_info(url); + + if(protocol_info) { + hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_SECURITY_DOMAIN, + flags, result, size, rsize, 0); + if(SUCCEEDED(hres)) + return hres; + } + + return E_FAIL; +} + + +HRESULT WINAPI CoInternetParseUrl(LPCWSTR pwzUrl, PARSEACTION ParseAction, DWORD dwFlags, + LPWSTR pszResult, DWORD cchResult, DWORD *pcchResult, DWORD dwReserved) +{ + if(dwReserved) + WARN("dwReserved = %ld\n", dwReserved); + + switch(ParseAction) { + case PARSE_SECURITY_URL: + return parse_security_url(pwzUrl, dwFlags, pszResult, cchResult, pcchResult); + case PARSE_ENCODE: + return parse_encode(pwzUrl, dwFlags, pszResult, cchResult, pcchResult); + case PARSE_PATH_FROM_URL: + return parse_path_from_url(pwzUrl, dwFlags, pszResult, cchResult, pcchResult); + case PARSE_SCHEMA: + return parse_schema(pwzUrl, dwFlags, pszResult, cchResult, pcchResult); + case PARSE_SECURITY_DOMAIN: + return parse_security_domain(pwzUrl, dwFlags, pszResult, cchResult, pcchResult); + default: + FIXME("not supported action %d\n", ParseAction); + } + + return E_NOTIMPL; +} diff --git a/reactos/lib/urlmon/regsvr.c b/reactos/lib/urlmon/regsvr.c index ed819891e54..6ec6b189102 100644 --- a/reactos/lib/urlmon/regsvr.c +++ b/reactos/lib/urlmon/regsvr.c @@ -37,7 +37,6 @@ #include "wine/debug.h" -#include "initguid.h" #include "urlmon_main.h" WINE_DEFAULT_DEBUG_CHANNEL(urlmon); @@ -546,7 +545,7 @@ static struct regsvr_coclass const coclass_list[] = { "urlmon.dll", "Apartment" }, - { &CLSID_HttpsProtocol, + { &CLSID_HttpSProtocol, "https: Asynchronous Pluggable Protocol Handler", NULL, "urlmon.dll", @@ -594,7 +593,7 @@ static HRESULT register_inf(BOOL doregister) INF_SET_CLSID(FtpProtocol); INF_SET_CLSID(GopherProtocol); INF_SET_CLSID(HttpProtocol); - INF_SET_CLSID(HttpsProtocol); + INF_SET_CLSID(HttpSProtocol); INF_SET_CLSID(MkProtocol); for(i = 0; i < sizeof(pse)/sizeof(pse[0]); i++) { diff --git a/reactos/lib/urlmon/rsrc.rc b/reactos/lib/urlmon/rsrc.rc index 3217540f833..af3b5462e9c 100644 --- a/reactos/lib/urlmon/rsrc.rc +++ b/reactos/lib/urlmon/rsrc.rc @@ -17,3 +17,5 @@ */ REGINST REGINST urlmon.inf + +#include "version.rc" diff --git a/reactos/lib/urlmon/sec_mgr.c b/reactos/lib/urlmon/sec_mgr.c index 4017891820a..576e82a6182 100644 --- a/reactos/lib/urlmon/sec_mgr.c +++ b/reactos/lib/urlmon/sec_mgr.c @@ -27,6 +27,7 @@ #include "windef.h" #include "winbase.h" #include "winuser.h" +#include "winreg.h" #include "wine/debug.h" #include "ole2.h" #include "wine/unicode.h" @@ -39,17 +40,84 @@ WINE_DEFAULT_DEBUG_CHANNEL(urlmon); * InternetSecurityManager implementation * */ -typedef struct SecManagerImpl{ +typedef struct { + const IInternetSecurityManagerVtbl* lpInternetSecurityManagerVtbl; - const IInternetSecurityManagerVtbl* lpvtbl1; /* VTable relative to the IInternetSecurityManager interface.*/ - - LONG ref; /* reference counter for this object */ + LONG ref; + IInternetSecurityMgrSite *mgrsite; + IInternetSecurityManager *custom_manager; } SecManagerImpl; +#define SECMGR_THIS(iface) DEFINE_THIS(SecManagerImpl, InternetSecurityManager, iface) + +static HRESULT map_url_to_zone(LPCWSTR url, DWORD *zone) +{ + WCHAR schema[64]; + DWORD res, size=0; + HKEY hkey; + HRESULT hres; + + static const WCHAR wszZoneMapProtocolKey[] = + {'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','\\', + 'Z','o','n','e','M','a','p','\\', + 'P','r','o','t','o','c','o','l','D','e','f','a','u','l','t','s',0}; + static const WCHAR wszFile[] = {'f','i','l','e',0}; + + hres = CoInternetParseUrl(url, PARSE_SCHEMA, 0, schema, sizeof(schema)/sizeof(WCHAR), &size, 0); + if(FAILED(hres)) + return hres; + if(!*schema) + return 0x80041001; + + /* file protocol is a special case */ + if(!strcmpW(schema, wszFile)) { + WCHAR path[MAX_PATH]; + + hres = CoInternetParseUrl(url, PARSE_PATH_FROM_URL, 0, path, + sizeof(path)/sizeof(WCHAR), &size, 0); + + if(SUCCEEDED(hres) && strchrW(path, '\\')) { + *zone = 0; + return S_OK; + } + } + + WARN("domains are not yet implemented\n"); + + res = RegOpenKeyW(HKEY_CURRENT_USER, wszZoneMapProtocolKey, &hkey); + if(res != ERROR_SUCCESS) { + ERR("Could not open key %s\n", debugstr_w(wszZoneMapProtocolKey)); + return E_UNEXPECTED; + } + + size = sizeof(DWORD); + res = RegQueryValueExW(hkey, schema, NULL, NULL, (PBYTE)zone, &size); + if(res == ERROR_SUCCESS) + return S_OK; + + res = RegOpenKeyW(HKEY_LOCAL_MACHINE, wszZoneMapProtocolKey, &hkey); + if(res != ERROR_SUCCESS) { + ERR("Could not open key %s\n", debugstr_w(wszZoneMapProtocolKey)); + return E_UNEXPECTED; + } + + size = sizeof(DWORD); + res = RegQueryValueExW(hkey, schema, NULL, NULL, (PBYTE)zone, &size); + if(res == ERROR_SUCCESS) + return S_OK; + + *zone = 3; + return S_OK; +} + static HRESULT WINAPI SecManagerImpl_QueryInterface(IInternetSecurityManager* iface,REFIID riid,void** ppvObject) { - SecManagerImpl *This = (SecManagerImpl *)iface; + SecManagerImpl *This = SECMGR_THIS(iface); TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppvObject); @@ -66,8 +134,10 @@ static HRESULT WINAPI SecManagerImpl_QueryInterface(IInternetSecurityManager* if *ppvObject = iface; /* Check that we obtained an interface.*/ - if ((*ppvObject)==0) + if (!*ppvObject) { + WARN("not supported interface %s\n", debugstr_guid(riid)); return E_NOINTERFACE; + } /* Query Interface always increases the reference count by one when it is successful */ IInternetSecurityManager_AddRef(iface); @@ -77,24 +147,30 @@ static HRESULT WINAPI SecManagerImpl_QueryInterface(IInternetSecurityManager* if static ULONG WINAPI SecManagerImpl_AddRef(IInternetSecurityManager* iface) { - SecManagerImpl *This = (SecManagerImpl *)iface; + SecManagerImpl *This = SECMGR_THIS(iface); ULONG refCount = InterlockedIncrement(&This->ref); - TRACE("(%p)->(ref before=%lu)\n",This, refCount - 1); + TRACE("(%p) ref=%lu\n", This, refCount); return refCount; } static ULONG WINAPI SecManagerImpl_Release(IInternetSecurityManager* iface) { - SecManagerImpl *This = (SecManagerImpl *)iface; + SecManagerImpl *This = SECMGR_THIS(iface); ULONG refCount = InterlockedDecrement(&This->ref); - TRACE("(%p)->(ref before=%lu)\n",This, refCount + 1); + TRACE("(%p) ref=%lu\n", This, refCount); /* destroy the object if there's no more reference on it */ if (!refCount){ + if(This->mgrsite) + IInternetSecurityMgrSite_Release(This->mgrsite); + if(This->custom_manager) + IInternetSecurityManager_Release(This->custom_manager); + HeapFree(GetProcessHeap(),0,This); + URLMON_UnlockModule(); } @@ -104,32 +180,112 @@ static ULONG WINAPI SecManagerImpl_Release(IInternetSecurityManager* iface) static HRESULT WINAPI SecManagerImpl_SetSecuritySite(IInternetSecurityManager *iface, IInternetSecurityMgrSite *pSite) { - FIXME("(%p)->(%p)\n", iface, pSite); - return E_NOTIMPL; + SecManagerImpl *This = SECMGR_THIS(iface); + + TRACE("(%p)->(%p)\n", This, pSite); + + if(This->mgrsite) + IInternetSecurityMgrSite_Release(This->mgrsite); + + if(This->custom_manager) { + IInternetSecurityManager_Release(This->custom_manager); + This->custom_manager = NULL; + } + + This->mgrsite = pSite; + + if(pSite) { + IServiceProvider *servprov; + HRESULT hres; + + IInternetSecurityMgrSite_AddRef(pSite); + + hres = IInternetSecurityMgrSite_QueryInterface(pSite, &IID_IServiceProvider, + (void**)&servprov); + if(SUCCEEDED(hres)) { + IServiceProvider_QueryService(servprov, &SID_SInternetSecurityManager, + &IID_IInternetSecurityManager, (void**)&This->custom_manager); + IServiceProvider_Release(servprov); + } + } + + return S_OK; } static HRESULT WINAPI SecManagerImpl_GetSecuritySite(IInternetSecurityManager *iface, IInternetSecurityMgrSite **ppSite) { - FIXME("(%p)->( %p)\n", iface, ppSite); - return E_NOTIMPL; + SecManagerImpl *This = SECMGR_THIS(iface); + + TRACE("(%p)->(%p)\n", This, ppSite); + + if(!ppSite) + return E_INVALIDARG; + + if(This->mgrsite) + IInternetSecurityMgrSite_AddRef(This->mgrsite); + + *ppSite = This->mgrsite; + return S_OK; } static HRESULT WINAPI SecManagerImpl_MapUrlToZone(IInternetSecurityManager *iface, LPCWSTR pwszUrl, DWORD *pdwZone, DWORD dwFlags) { - FIXME("(%p)->(%s %p %08lx)\n", iface, debugstr_w(pwszUrl), pdwZone, dwFlags); - return E_NOTIMPL; + SecManagerImpl *This = SECMGR_THIS(iface); + LPWSTR url; + DWORD size; + HRESULT hres; + + TRACE("(%p)->(%s %p %08lx)\n", iface, debugstr_w(pwszUrl), pdwZone, dwFlags); + + if(This->custom_manager) { + hres = IInternetSecurityManager_MapUrlToZone(This->custom_manager, + pwszUrl, pdwZone, dwFlags); + if(hres != INET_E_DEFAULT_ACTION) + return hres; + } + + if(!pwszUrl) + return E_INVALIDARG; + + if(dwFlags) + FIXME("not supported flags: %08lx\n", dwFlags); + + size = (strlenW(pwszUrl)+16) * sizeof(WCHAR); + url = HeapAlloc(GetProcessHeap(), 0, size); + + hres = CoInternetParseUrl(pwszUrl, PARSE_SECURITY_URL, 0, url, size/sizeof(WCHAR), &size, 0); + if(FAILED(hres)) + memcpy(url, pwszUrl, size); + + hres = map_url_to_zone(url, pdwZone); + + HeapFree(GetProcessHeap(), 0, url); + + return hres; } static HRESULT WINAPI SecManagerImpl_GetSecurityId(IInternetSecurityManager *iface, LPCWSTR pwszUrl, BYTE *pbSecurityId, DWORD *pcbSecurityId, - DWORD dwReserved) + DWORD_PTR dwReserved) { - FIXME("(%p)->(%s %p %p %08lx)\n", iface, debugstr_w(pwszUrl), pbSecurityId, pcbSecurityId, + SecManagerImpl *This = SECMGR_THIS(iface); + HRESULT hres; + + TRACE("(%p)->(%s %p %p %08lx)\n", iface, debugstr_w(pwszUrl), pbSecurityId, pcbSecurityId, dwReserved); + + if(This->custom_manager) { + hres = IInternetSecurityManager_GetSecurityId(This->custom_manager, + pwszUrl, pbSecurityId, pcbSecurityId, dwReserved); + if(hres != INET_E_DEFAULT_ACTION) + return hres; + } + + FIXME("Default action is not implemented\n"); return E_NOTIMPL; } @@ -140,8 +296,20 @@ static HRESULT WINAPI SecManagerImpl_ProcessUrlAction(IInternetSecurityManager * BYTE *pContext, DWORD cbContext, DWORD dwFlags, DWORD dwReserved) { - FIXME("(%p)->(%s %08lx %p %08lx %p %08lx %08lx %08lx)\n", iface, debugstr_w(pwszUrl), dwAction, + SecManagerImpl *This = SECMGR_THIS(iface); + HRESULT hres; + + TRACE("(%p)->(%s %08lx %p %08lx %p %08lx %08lx %08lx)\n", iface, debugstr_w(pwszUrl), dwAction, pPolicy, cbPolicy, pContext, cbContext, dwFlags, dwReserved); + + if(This->custom_manager) { + hres = IInternetSecurityManager_ProcessUrlAction(This->custom_manager, pwszUrl, dwAction, + pPolicy, cbPolicy, pContext, cbContext, dwFlags, dwReserved); + if(hres != INET_E_DEFAULT_ACTION) + return hres; + } + + FIXME("Default action is not implemented\n"); return E_NOTIMPL; } @@ -152,22 +320,58 @@ static HRESULT WINAPI SecManagerImpl_QueryCustomPolicy(IInternetSecurityManager BYTE *pContext, DWORD cbContext, DWORD dwReserved) { - FIXME("(%p)->(%s %s %p %p %p %08lx %08lx )\n", iface, debugstr_w(pwszUrl), debugstr_guid(guidKey), + SecManagerImpl *This = SECMGR_THIS(iface); + HRESULT hres; + + TRACE("(%p)->(%s %s %p %p %p %08lx %08lx )\n", iface, debugstr_w(pwszUrl), debugstr_guid(guidKey), ppPolicy, pcbPolicy, pContext, cbContext, dwReserved); + + if(This->custom_manager) { + hres = IInternetSecurityManager_QueryCustomPolicy(This->custom_manager, pwszUrl, guidKey, + ppPolicy, pcbPolicy, pContext, cbContext, dwReserved); + if(hres != INET_E_DEFAULT_ACTION) + return hres; + } + + FIXME("Default action is not implemented\n"); return E_NOTIMPL; } static HRESULT WINAPI SecManagerImpl_SetZoneMapping(IInternetSecurityManager *iface, DWORD dwZone, LPCWSTR pwszPattern, DWORD dwFlags) { - FIXME("(%p)->(%08lx %s %08lx)\n", iface, dwZone, debugstr_w(pwszPattern),dwFlags); + SecManagerImpl *This = SECMGR_THIS(iface); + HRESULT hres; + + TRACE("(%p)->(%08lx %s %08lx)\n", iface, dwZone, debugstr_w(pwszPattern),dwFlags); + + if(This->custom_manager) { + hres = IInternetSecurityManager_SetZoneMapping(This->custom_manager, dwZone, + pwszPattern, dwFlags); + if(hres != INET_E_DEFAULT_ACTION) + return hres; + } + + FIXME("Default action is not implemented\n"); return E_NOTIMPL; } static HRESULT WINAPI SecManagerImpl_GetZoneMappings(IInternetSecurityManager *iface, - DWORD dwZone, IEnumString **ppenumString, DWORD dwFlags) + DWORD dwZone, IEnumString **ppenumString, DWORD dwFlags) { - FIXME("(%p)->(%08lx %p %08lx)\n", iface, dwZone, ppenumString,dwFlags); + SecManagerImpl *This = SECMGR_THIS(iface); + HRESULT hres; + + TRACE("(%p)->(%08lx %p %08lx)\n", iface, dwZone, ppenumString,dwFlags); + + if(This->custom_manager) { + hres = IInternetSecurityManager_GetZoneMappings(This->custom_manager, dwZone, + ppenumString, dwFlags); + if(hres != INET_E_DEFAULT_ACTION) + return hres; + } + + FIXME("Default action is not implemented\n"); return E_NOTIMPL; } @@ -194,8 +398,11 @@ HRESULT SecManagerImpl_Construct(IUnknown *pUnkOuter, LPVOID *ppobj) This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This)); /* Initialize the virtual function table. */ - This->lpvtbl1 = &VT_SecManagerImpl; - This->ref = 1; + This->lpInternetSecurityManagerVtbl = &VT_SecManagerImpl; + + This->ref = 1; + This->mgrsite = NULL; + This->custom_manager = NULL; *ppobj = This; @@ -213,6 +420,46 @@ typedef struct { LONG ref; } ZoneMgrImpl; +static HRESULT open_zone_key(DWORD zone, HKEY *hkey, URLZONEREG zone_reg) +{ + static const WCHAR wszZonesKey[] = + {'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','\\', + 'Z','o','n','e','s','\\',0}; + static const WCHAR wszFormat[] = {'%','s','%','l','d',0}; + + WCHAR key_name[sizeof(wszZonesKey)/sizeof(WCHAR)+8]; + HKEY parent_key; + DWORD res; + + switch(zone_reg) { + case URLZONEREG_DEFAULT: /* FIXME: TEST */ + case URLZONEREG_HKCU: + parent_key = HKEY_CURRENT_USER; + break; + case URLZONEREG_HKLM: + parent_key = HKEY_LOCAL_MACHINE; + break; + default: + WARN("Unknown URLZONEREG: %d\n", zone_reg); + return E_FAIL; + }; + + wsprintfW(key_name, wszFormat, wszZonesKey, zone); + + res = RegOpenKeyW(parent_key, key_name, hkey); + + if(res != ERROR_SUCCESS) { + WARN("RegOpenKey failed\n"); + return E_INVALIDARG; + } + + return S_OK; +} + /******************************************************************** * IInternetZoneManager_QueryInterface */ @@ -324,15 +571,41 @@ static HRESULT WINAPI ZoneMgrImpl_SetZoneCustomPolicy(IInternetZoneManager* ifac * IInternetZoneManager_GetZoneActionPolicy */ static HRESULT WINAPI ZoneMgrImpl_GetZoneActionPolicy(IInternetZoneManager* iface, - DWORD dwZone, - DWORD dwAction, - BYTE* pPolicy, - DWORD cbPolicy, - URLZONEREG urlZoneReg) + DWORD dwZone, DWORD dwAction, BYTE* pPolicy, DWORD cbPolicy, URLZONEREG urlZoneReg) { - FIXME("(%p)->(%08lx %08lx %p %08lx %08x) stub\n", iface, dwZone, dwAction, pPolicy, - cbPolicy, urlZoneReg); - return E_NOTIMPL; + WCHAR action[16]; + HKEY hkey; + LONG res; + DWORD size = cbPolicy; + HRESULT hres; + + static const WCHAR wszFormat[] = {'%','l','X',0}; + + TRACE("(%p)->(%ld %08lx %p %ld %d)\n", iface, dwZone, dwAction, pPolicy, + cbPolicy, urlZoneReg); + + if(!pPolicy) + return E_INVALIDARG; + + hres = open_zone_key(dwZone, &hkey, urlZoneReg); + if(FAILED(hres)) + return hres; + + wsprintfW(action, wszFormat, dwAction); + + res = RegQueryValueExW(hkey, action, NULL, NULL, pPolicy, &size); + if(res == ERROR_MORE_DATA) { + hres = E_INVALIDARG; + }else if(res == ERROR_FILE_NOT_FOUND) { + hres = E_FAIL; + }else if(res != ERROR_SUCCESS) { + ERR("RegQueryValue failed: %ld\n", res); + hres = E_UNEXPECTED; + } + + RegCloseKey(hkey); + + return hres; } /******************************************************************** @@ -468,6 +741,10 @@ HRESULT WINAPI CoInternetCreateSecurityManager( IServiceProvider *pSP, IInternetSecurityManager **ppSM, DWORD dwReserved ) { TRACE("%p %p %ld\n", pSP, ppSM, dwReserved ); + + if(pSP) + FIXME("pSP not supported\n"); + return SecManagerImpl_Construct(NULL, (void**) ppSM); } diff --git a/reactos/lib/urlmon/session.c b/reactos/lib/urlmon/session.c new file mode 100644 index 00000000000..c516b7e0baf --- /dev/null +++ b/reactos/lib/urlmon/session.c @@ -0,0 +1,151 @@ +/* + * Copyright 2005 Jacek Caban + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include + +#define COBJMACROS + +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "ole2.h" +#include "urlmon.h" +#include "urlmon_main.h" + +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(urlmon); + +static HRESULT WINAPI InternetSession_QueryInterface(IInternetSession *iface, + REFIID riid, void **ppv) +{ + TRACE("(%s %p)\n", debugstr_guid(riid), ppv); + + if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetSession, riid)) { + *ppv = iface; + IInternetSession_AddRef(iface); + return S_OK; + } + + *ppv = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI InternetSession_AddRef(IInternetSession *iface) +{ + TRACE("()\n"); + URLMON_LockModule(); + return 2; +} + +static ULONG WINAPI InternetSession_Release(IInternetSession *iface) +{ + TRACE("()\n"); + URLMON_UnlockModule(); + return 1; +} + +static HRESULT WINAPI InternetSession_RegisterNameSpace(IInternetSession *iface, + IClassFactory *pCF, REFCLSID rclsid, LPCWSTR pwzProtocol, ULONG cPatterns, + const LPCWSTR *ppwzPatterns, DWORD dwReserved) +{ + FIXME("(%p %s %s %ld %p %ld)\n", pCF, debugstr_guid(rclsid), debugstr_w(pwzProtocol), + cPatterns, ppwzPatterns, dwReserved); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetSession_UnregisterNameSpace(IInternetSession *iface, + IClassFactory *pCF, LPCWSTR pszProtocol) +{ + FIXME("(%p %s)\n", pCF, debugstr_w(pszProtocol)); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetSession_RegisterMimeFilter(IInternetSession *iface, + IClassFactory *pCF, REFCLSID rclsid, LPCWSTR pwzType) +{ + FIXME("(%p %s %s)\n", pCF, debugstr_guid(rclsid), debugstr_w(pwzType)); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetSession_UnregisterMimeFilter(IInternetSession *iface, + IClassFactory *pCF, LPCWSTR pwzType) +{ + FIXME("(%p %s)\n", pCF, debugstr_w(pwzType)); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetSession_CreateBinding(IInternetSession *iface, + LPBC pBC, LPCWSTR szUrl, IUnknown *pUnkOuter, IUnknown **ppUnk, + IInternetProtocol **ppOInetProt, DWORD dwOption) +{ + FIXME("(%p %s %p %p %p %08lx)\n", pBC, debugstr_w(szUrl), pUnkOuter, ppUnk, + ppOInetProt, dwOption); + return E_NOTIMPL; +} + +static HRESULT WINAPI InternetSession_SetSessionOption(IInternetSession *iface, + DWORD dwOption, LPVOID pBuffer, DWORD dwBufferLength, DWORD dwReserved) +{ + FIXME("(%08lx %p %ld %ld)\n", dwOption, pBuffer, dwBufferLength, dwReserved); + return E_NOTIMPL; +} + +static const IInternetSessionVtbl InternetSessionVtbl = { + InternetSession_QueryInterface, + InternetSession_AddRef, + InternetSession_Release, + InternetSession_RegisterNameSpace, + InternetSession_UnregisterNameSpace, + InternetSession_RegisterMimeFilter, + InternetSession_UnregisterMimeFilter, + InternetSession_CreateBinding, + InternetSession_SetSessionOption +}; + +static IInternetSession InternetSession = { &InternetSessionVtbl }; + +/*********************************************************************** + * CoInternetGetSession (URLMON.@) + * + * Create a new internet session and return an IInternetSession interface + * representing it. + * + * PARAMS + * dwSessionMode [I] Mode for the internet session + * ppIInternetSession [O] Destination for creates IInternetSession object + * dwReserved [I] Reserved, must be 0. + * + * RETURNS + * Success: S_OK. ppIInternetSession contains the IInternetSession interface. + * Failure: E_INVALIDARG, if any argument is invalid, or + * E_OUTOFMEMORY if memory allocation fails. + */ +HRESULT WINAPI CoInternetGetSession(DWORD dwSessionMode, IInternetSession **ppIInternetSession, + DWORD dwReserved) +{ + TRACE("(%ld %p %ld)\n", dwSessionMode, ppIInternetSession, dwReserved); + + if(dwSessionMode) + ERR("dwSessionMode=%ld\n", dwSessionMode); + if(dwReserved) + ERR("dwReserved=%ld\n", dwReserved); + + *ppIInternetSession = &InternetSession; + return S_OK; +} diff --git a/reactos/lib/urlmon/umon.c b/reactos/lib/urlmon/umon.c index b4d7904f100..6bc28ac2591 100644 --- a/reactos/lib/urlmon/umon.c +++ b/reactos/lib/urlmon/umon.c @@ -1179,16 +1179,38 @@ static HRESULT URLMonikerImpl_Construct(URLMonikerImpl* This, LPCOLESTR lpszLeft HRESULT WINAPI CreateAsyncBindCtx(DWORD reserved, IBindStatusCallback *callback, IEnumFORMATETC *format, IBindCtx **pbind) { - HRESULT hres; - BIND_OPTS bindopts; - IBindCtx *bctx; - TRACE("(%08lx %p %p %p)\n", reserved, callback, format, pbind); if(!callback) return E_INVALIDARG; + + return CreateAsyncBindCtxEx(NULL, 0, callback, format, pbind, 0); +} +/*********************************************************************** + * CreateAsyncBindCtxEx (URLMON.@) + * + * Create an asynchronous bind context. + */ +HRESULT WINAPI CreateAsyncBindCtxEx(IBindCtx *ibind, DWORD options, + IBindStatusCallback *callback, IEnumFORMATETC *format, IBindCtx** pbind, + DWORD reserved) +{ + HRESULT hres; + BIND_OPTS bindopts; + IBindCtx *bctx; + + TRACE("(%p %08lx %p %p %p %ld)\n", ibind, options, callback, format, pbind, reserved); + + if(!pbind) + return E_INVALIDARG; + + if(options) + FIXME("not supported options %08lx", options); if(format) - FIXME("format is not supported yet\n"); + FIXME("format is not supported\n"); + + if(reserved) + WARN("reserved=%ld\n", reserved); hres = CreateBindCtx(0, &bctx); if(FAILED(hres)) @@ -1200,31 +1222,13 @@ HRESULT WINAPI CreateAsyncBindCtx(DWORD reserved, IBindStatusCallback *callback, bindopts.dwTickCountDeadline = 0; IBindCtx_SetBindOptions(bctx, &bindopts); - hres = IBindCtx_RegisterObjectParam(bctx, (LPOLESTR)BSCBHolder, (IUnknown*)callback); - if(FAILED(hres)) { - IBindCtx_Release(bctx); - return hres; - } + if(callback) + RegisterBindStatusCallback(bctx, callback, NULL, 0); *pbind = bctx; return S_OK; } -/*********************************************************************** - * CreateAsyncBindCtxEx (URLMON.@) - * - * Create an asynchronous bind context. - * - * FIXME - * Not implemented. - */ -HRESULT WINAPI CreateAsyncBindCtxEx(IBindCtx *ibind, DWORD options, - IBindStatusCallback *callback, IEnumFORMATETC *format, IBindCtx** pbind, - DWORD reserved) -{ - FIXME("stub, returns failure\n"); - return E_INVALIDARG; -} /*********************************************************************** @@ -1274,39 +1278,6 @@ HRESULT WINAPI CreateURLMoniker(IMoniker *pmkContext, LPCWSTR szURL, IMoniker ** return hres; } - -/*********************************************************************** - * CoInternetGetSession (URLMON.@) - * - * Create a new internet session and return an IInternetSession interface - * representing it. - * - * PARAMS - * dwSessionMode [I] Mode for the internet session - * ppIInternetSession [O] Destination for creates IInternetSession object - * dwReserved [I] Reserved, must be 0. - * - * RETURNS - * Success: S_OK. ppIInternetSession contains the IInternetSession interface. - * Failure: E_INVALIDARG, if any argument is invalid, or - * E_OUTOFMEMORY if memory allocation fails. - */ -HRESULT WINAPI CoInternetGetSession(DWORD dwSessionMode, IInternetSession **ppIInternetSession, DWORD dwReserved) -{ - FIXME("(%ld, %p, %ld): stub\n", dwSessionMode, ppIInternetSession, dwReserved); - - if(dwSessionMode) { - ERR("dwSessionMode: %ld, must be zero\n", dwSessionMode); - } - - if(dwReserved) { - ERR("dwReserved: %ld, must be zero\n", dwReserved); - } - - *ppIInternetSession=NULL; - return E_OUTOFMEMORY; -} - /*********************************************************************** * CoInternetQueryInfo (URLMON.@) * @@ -1327,69 +1298,6 @@ HRESULT WINAPI CoInternetQueryInfo(LPCWSTR pwzUrl, QUERYOPTION QueryOption, return S_OK; } -static BOOL URLMON_IsBinary(LPVOID pBuffer, DWORD cbSize) -{ - unsigned int i, binarycount = 0; - unsigned char *buff = pBuffer; - for(i=0; i (cbSize-binarycount); -} - -/*********************************************************************** - * FindMimeFromData (URLMON.@) - * - * Determines the Multipurpose Internet Mail Extensions (MIME) type from the data provided. - * - * NOTE - * See http://msdn.microsoft.com/workshop/networking/moniker/overview/appendix_a.asp - */ -HRESULT WINAPI FindMimeFromData(LPBC pBC, LPCWSTR pwzUrl, LPVOID pBuffer, - DWORD cbSize, LPCWSTR pwzMimeProposed, DWORD dwMimeFlags, - LPWSTR* ppwzMimeOut, DWORD dwReserved) -{ - static const WCHAR szBinaryMime[] = {'a','p','p','l','i','c','a','t','i','o','n','/','o','c','t','e','t','-','s','t','r','e','a','m','\0'}; - static const WCHAR szTextMime[] = {'t','e','x','t','/','p','l','a','i','n','\0'}; - static const WCHAR szContentType[] = {'C','o','n','t','e','n','t',' ','T','y','p','e','\0'}; - WCHAR szTmpMime[256]; - LPCWSTR mimeType = NULL; - HKEY hKey = NULL; - - TRACE("(%p,%s,%p,%ld,%s,0x%lx,%p,0x%lx)\n", pBC, debugstr_w(pwzUrl), pBuffer, cbSize, - debugstr_w(pwzMimeProposed), dwMimeFlags, ppwzMimeOut, dwReserved); - - if((!pwzUrl && (!pBuffer || cbSize <= 0)) || !ppwzMimeOut) - return E_INVALIDARG; - - if(pwzMimeProposed) - mimeType = pwzMimeProposed; - else { - /* Try and find the mime type in the registry */ - if(pwzUrl) { - LPWSTR ext = strrchrW(pwzUrl, '.'); - if(ext) { - DWORD dwSize; - if(!RegOpenKeyExW(HKEY_CLASSES_ROOT, ext, 0, 0, &hKey)) { - if(!RegQueryValueExW(hKey, szContentType, NULL, NULL, (LPBYTE)szTmpMime, &dwSize)) { - mimeType = szTmpMime; - } - RegCloseKey(hKey); - } - } - } - } - if(!mimeType && pBuffer && cbSize > 0) - mimeType = URLMON_IsBinary(pBuffer, cbSize)?szBinaryMime:szTextMime; - - TRACE("Using %s\n", debugstr_w(mimeType)); - *ppwzMimeOut = CoTaskMemAlloc((lstrlenW(mimeType)+1)*sizeof(WCHAR)); - if(!*ppwzMimeOut) return E_OUTOFMEMORY; - lstrcpyW(*ppwzMimeOut, mimeType); - return S_OK; -} - /*********************************************************************** * IsAsyncMoniker (URLMON.@) */ @@ -1445,7 +1353,7 @@ HRESULT WINAPI RegisterBindStatusCallback( IBindStatusCallback_Release(prev); } - return IBindCtx_RegisterObjectParam(pbc, (LPOLESTR)BSCBHolder, (IUnknown *)pbsc); + return IBindCtx_RegisterObjectParam(pbc, (LPOLESTR)BSCBHolder, (IUnknown *)pbsc); } /*********************************************************************** @@ -1486,22 +1394,6 @@ HRESULT WINAPI RevokeBindStatusCallback( return hr; } -/*********************************************************************** - * ReleaseBindInfo (URLMON.@) - * - * Release the resources used by the specified BINDINFO structure. - * - * PARAMS - * pbindinfo [I] BINDINFO to release. - * - * RETURNS - * Nothing. - */ -void WINAPI ReleaseBindInfo(BINDINFO* pbindinfo) -{ - FIXME("(%p)stub!\n", pbindinfo); -} - /*********************************************************************** * URLDownloadToFileA (URLMON.@) * diff --git a/reactos/lib/urlmon/urlmon.inf b/reactos/lib/urlmon/urlmon.inf index d87c8ae0053..efdf4ef81a9 100644 --- a/reactos/lib/urlmon/urlmon.inf +++ b/reactos/lib/urlmon/urlmon.inf @@ -3,11 +3,11 @@ Signature="$CHICAGO$" [RegisterDll] -AddReg=Protocols.Reg +AddReg=Protocols.Reg, ZoneMap.Reg, Zones.Reg [UnregisterDll] -DelReg=Protocols.Reg +DelReg=Protocols.Reg, ZoneMap.Reg, Zones.Reg [Protocols.Reg] @@ -27,3 +27,455 @@ HKCR,"PROTOCOLS\Handler\https",,,"https: Asynchronous Pluggable Protocol Handler HKCR,"PROTOCOLS\Handler\https","CLSID",,"%CLSID_HttpsProtocol%" HKCR,"PROTOCOLS\Handler\mk",,,"mk: Asynchronous Pluggable Protocol Handler" HKCR,"PROTOCOLS\Handler\mk","CLSID",,"%CLSID_MkProtocol%" + + +[ZoneMap.Reg] +HKCU,"Software\Microsoft\Windows\CurrentVersion\Internet Settings",,, +HKCU,"%PATH_ZONEMAP%",,, +HKLM,"%PATH_ZONEMAP%",,, +HKCU,"%PATH_ZONEMAP%","ProxyByPass", 0x10001,0x1 +HKLM,"%PATH_ZONEMAP%","ProxyByPass", 0x10001,0x1 +HKCU,"%PATH_ZONEMAP%","IntranetName", 0x10001,0x1 +HKLM,"%PATH_ZONEMAP%","IntranetName", 0x10001,0x1 +HKCU,"%PATH_ZONEMAP%","UNCAsIntranet",0x10001,0x1 +HKLM,"%PATH_ZONEMAP%","UNCAsIntranet",0x10001,0x1 +HKCU,"%PATH_ZONEMAP_PROTOCOLS%",,, +HKLM,"%PATH_ZONEMAP_PROTOCOLS%",,, +HKCU,"%PATH_ZONEMAP_PROTOCOLS%","http", 0x10001,0x3 +HKLM,"%PATH_ZONEMAP_PROTOCOLS%","http", 0x10001,0x3 +HKCU,"%PATH_ZONEMAP_PROTOCOLS%","https",0x10001,0x3 +HKLM,"%PATH_ZONEMAP_PROTOCOLS%","https",0x10001,0x3 +HKCU,"%PATH_ZONEMAP_PROTOCOLS%","ftp", 0x10001,0x3 +HKLM,"%PATH_ZONEMAP_PROTOCOLS%","ftp", 0x10001,0x3 +HKCU,"%PATH_ZONEMAP_PROTOCOLS%","file", 0x10001,0x3 +HKLM,"%PATH_ZONEMAP_PROTOCOLS%","file", 0x10001,0x3 +HKCU,"%PATH_ZONEMAP_PROTOCOLS%","@ivt", 0x10001,0x1 +HKLM,"%PATH_ZONEMAP_PROTOCOLS%","@ivt",0x10001,0x1 +HKCU,"%PATH_ZONEMAP_DOMAINS%",,, +HKLM,"%PATH_ZONEMAP_DOMAINS%",,, +HKCU,"%PATH_ZONEMAP_RANGES%",,, +HKLM,"%PATH_ZONEMAP_RANGES%",,, + + +[Zones.Reg] +HKCU,"%PATH_ZONES%",,, + +;; Local Zone +HKCU,"%ZONES_LOCAL%",,, +HKLM,"%ZONES_LOCAL%",,, +HKCU,"%ZONES_LOCAL%","DisplayName",,%NAME_LOCAL% +HKLM,"%ZONES_LOCAL%","DisplayName",,%NAME_LOCAL% +HKCU,"%ZONES_LOCAL%","Description",,%DESC_LOCAL% +HKLM,"%ZONES_LOCAL%","Description",,%DESC_LOCAL% +HKCU,"%ZONES_LOCAL%","Icon",,%ZICON_LOCAL% +HKLM,"%ZONES_LOCAL%","Icon",,%ZICON_LOCAL% +HKCU,"%ZONES_LOCAL%","CurrentLevel",0x10001,0x00000 +HKLM,"%ZONES_LOCAL%","CurrentLevel",0x10001,0x00000 +HKCU,"%ZONES_LOCAL%","Flags",0x10001,0x21 +HKLM,"%ZONES_LOCAL%","Flags",0x10001,0x21 +HKCU,"%ZONES_LOCAL%","1001",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1001",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1004",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1004",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1200",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1200",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1201",0x10003,0x1 +HKLM,"%ZONES_LOCAL%","1201",0x10003,0x1 +HKCU,"%ZONES_LOCAL%","1400",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1400",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1402",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1402",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1405",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1405",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1406",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1406",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1407",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1407",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1601",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1601",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1604",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1604",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1605",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1605",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1606",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1606",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1607",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1607",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1608",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1608",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1609",0x10003,0x1 +HKLM,"%ZONES_LOCAL%","1609",0x10003,0x1 +HKCU,"%ZONES_LOCAL%","1800",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1800",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1802",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1802",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1803",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1803",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1804",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1804",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1805",0x10001,0x0 +HKLM,"%ZONES_LOCAL%","1805",0x10001,0x0 +HKCU,"%ZONES_LOCAL%","1A00",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1A00",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1A02",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1A02",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1A03",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1A03",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1A04",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1A04",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1A05",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1A05",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1A06",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1A06",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1A10",0x10003,0x0 +HKLM,"%ZONES_LOCAL%","1A10",0x10003,0x0 +HKCU,"%ZONES_LOCAL%","1C00",0x10003,0x20000 +HKLM,"%ZONES_LOCAL%","1C00",0x10003,0x20000 +HKCU,"%ZONES_LOCAL%","1E05",0x10003,0x30000 +HKLM,"%ZONES_LOCAL%","1E05",0x10003,0x30000 + +;; Intranet Zone +HKCU,"%ZONES_INTRANET%",,, +HKLM,"%ZONES_INTRANET%",,, +HKCU,"%ZONES_INTRANET%","DisplayName",,%NAME_INTRANET% +HKLM,"%ZONES_INTRANET%","DisplayName",,%NAME_INTRANET% +HKCU,"%ZONES_INTRANET%","Description",,%DESC_INTRANET% +HKLM,"%ZONES_INTRANET%","Description",,%DESC_INTRANET% +HKCU,"%ZONES_INTRANET%","Icon",,%ZICON_INTRANET% +HKLM,"%ZONES_INTRANET%","Icon",,%ZICON_INTRANET% +HKCU,"%ZONES_INTRANET%","CurrentLevel",0x10003,0x10500 +HKLM,"%ZONES_INTRANET%","CurrentLevel",0x10003,0x10500 +HKCU,"%ZONES_INTRANET%","MinLevel",0x10001,0x10000 +HKLM,"%ZONES_INTRANET%","MinLevel",0x10001,0x10000 +HKCU,"%ZONES_INTRANET%","RecommendedLevel",0x10001,0x10500 +HKLM,"%ZONES_INTRANET%","RecommendedLevel",0x10001,0x10500 +HKCU,"%ZONES_INTRANET%","Flags",0x10003,0xDB +HKLM,"%ZONES_INTRANET%","Flags",0x10003,0xDB +HKCU,"%ZONES_INTRANET%","1001",0x10003,0x1 +HKLM,"%ZONES_INTRANET%","1001",0x10003,0x1 +HKCU,"%ZONES_INTRANET%","1004",0x10003,0x3 +HKLM,"%ZONES_INTRANET%","1004",0x10003,0x3 +HKCU,"%ZONES_INTRANET%","1200",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1200",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1201",0x10003,0x3 +HKLM,"%ZONES_INTRANET%","1201",0x10003,0x3 +HKCU,"%ZONES_INTRANET%","1400",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1400",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1402",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1402",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1405",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1405",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1406",0x10003,0x1 +HKLM,"%ZONES_INTRANET%","1406",0x10003,0x1 +HKCU,"%ZONES_INTRANET%","1407",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1407",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1601",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1601",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1604",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1604",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1605",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1605",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1606",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1606",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1607",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1607",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1608",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1608",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1609",0x10003,0x1 +HKLM,"%ZONES_INTRANET%","1609",0x10003,0x1 +HKCU,"%ZONES_INTRANET%","1800",0x10003,0x1 +HKLM,"%ZONES_INTRANET%","1800",0x10003,0x1 +HKCU,"%ZONES_INTRANET%","1802",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1802",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1803",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1803",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1804",0x10003,0x1 +HKLM,"%ZONES_INTRANET%","1804",0x10003,0x1 +HKCU,"%ZONES_INTRANET%","1805",0x10001,0x0 +HKLM,"%ZONES_INTRANET%","1805",0x10001,0x0 +HKCU,"%ZONES_INTRANET%","1A00",0x10003,0x20000 +HKLM,"%ZONES_INTRANET%","1A00",0x10003,0x20000 +HKCU,"%ZONES_INTRANET%","1A02",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1A02",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1A03",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1A03",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1A04",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1A04",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1A05",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1A05",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1A06",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1A06",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1A10",0x10003,0x0 +HKLM,"%ZONES_INTRANET%","1A10",0x10003,0x0 +HKCU,"%ZONES_INTRANET%","1C00",0x10003,0x20000 +HKLM,"%ZONES_INTRANET%","1C00",0x10003,0x20000 +HKCU,"%ZONES_INTRANET%","1E05",0x10003,0x20000 +HKLM,"%ZONES_INTRANET%","1E05",0x10003,0x20000 + +;; Trusted Zone +HKCU,"%ZONES_TRUSTED%",,, +HKLM,"%ZONES_TRUSTED%",,, +HKCU,"%ZONES_TRUSTED%","DisplayName",,%NAME_TRUSTED% +HKLM,"%ZONES_TRUSTED%","DisplayName",,%NAME_TRUSTED% +HKCU,"%ZONES_TRUSTED%","Description",,%DESC_TRUSTED% +HKLM,"%ZONES_TRUSTED%","Description",,%DESC_TRUSTED% +HKCU,"%ZONES_TRUSTED%","Icon",,%ZICON_TRUSTED% +HKLM,"%ZONES_TRUSTED%","Icon",,%ZICON_TRUSTED% +HKCU,"%ZONES_TRUSTED%","CurrentLevel",0x10003,0x10000 +HKLM,"%ZONES_TRUSTED%","CurrentLevel",0x10003,0x10000 +HKCU,"%ZONES_TRUSTED%","MinLevel",0x10001,0x10000 +HKLM,"%ZONES_TRUSTED%","MinLevel",0x10001,0x10000 +HKCU,"%ZONES_TRUSTED%","RecommendedLevel",0x10001,0x10000 +HKLM,"%ZONES_TRUSTED%","RecommendedLevel",0x10001,0x10000 +HKCU,"%ZONES_TRUSTED%","Flags",0x10001,0x47 +HKLM,"%ZONES_TRUSTED%","Flags",0x10001,0x47 +HKCU,"%ZONES_TRUSTED%","1001",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1001",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1004",0x10003,0x1 +HKLM,"%ZONES_TRUSTED%","1004",0x10003,0x1 +HKCU,"%ZONES_TRUSTED%","1200",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1200",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1201",0x10003,0x1 +HKLM,"%ZONES_TRUSTED%","1201",0x10003,0x1 +HKCU,"%ZONES_TRUSTED%","1400",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1400",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1402",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1402",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1405",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1405",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1406",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1406",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1407",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1407",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1601",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1601",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1604",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1604",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1605",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1605",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1606",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1606",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1607",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1607",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1608",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1608",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1609",0x10003,0x1 +HKLM,"%ZONES_TRUSTED%","1609",0x10003,0x1 +HKCU,"%ZONES_TRUSTED%","1800",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1800",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1802",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1802",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1803",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1803",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1804",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1804",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1805",0x10001,0x0 +HKLM,"%ZONES_TRUSTED%","1805",0x10001,0x0 +HKCU,"%ZONES_TRUSTED%","1A00",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1A00",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1A02",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1A02",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1A03",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1A03",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1A04",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1A04",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1A05",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1A05",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1A06",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1A06",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1A10",0x10003,0x0 +HKLM,"%ZONES_TRUSTED%","1A10",0x10003,0x0 +HKCU,"%ZONES_TRUSTED%","1C00",0x10003,0x30000 +HKLM,"%ZONES_TRUSTED%","1C00",0x10003,0x30000 +HKCU,"%ZONES_TRUSTED%","1E05",0x10003,0x30000 +HKLM,"%ZONES_TRUSTED%","1E05",0x10003,0x30000 + +;; Internet Zone +HKCU,"%ZONES_INTERNET%",,, +HKLM,"%ZONES_INTERNET%",,, +HKCU,"%ZONES_INTERNET%","DisplayName",,%NAME_INTERNET% +HKLM,"%ZONES_INTERNET%","DisplayName",,%NAME_INTERNET% +HKCU,"%ZONES_INTERNET%","Description",,%DESC_INTERNET% +HKLM,"%ZONES_INTERNET%","Description",,%DESC_INTERNET% +HKCU,"%ZONES_INTERNET%","Icon",,%ZICON_INTERNET% +HKLM,"%ZONES_INTERNET%","Icon",,%ZICON_INTERNET% +HKCU,"%ZONES_INTERNET%","CurrentLevel",0x10003,0x11000 +HKLM,"%ZONES_INTERNET%","CurrentLevel",0x10003,0x11000 +HKCU,"%ZONES_INTERNET%","MinLevel",0x10001,0x11000 +HKLM,"%ZONES_INTERNET%","MinLevel",0x10001,0x11000 +HKCU,"%ZONES_INTERNET%","RecommendedLevel",0x10001,0x11000 +HKLM,"%ZONES_INTERNET%","RecommendedLevel",0x10001,0x11000 +HKCU,"%ZONES_INTERNET%","Flags",0x10001,0x1 +HKLM,"%ZONES_INTERNET%","Flags",0x10001,0x1 +HKCU,"%ZONES_INTERNET%","1001",0x10003,0x1 +HKLM,"%ZONES_INTERNET%","1001",0x10003,0x1 +HKCU,"%ZONES_INTERNET%","1004",0x10003,0x3 +HKLM,"%ZONES_INTERNET%","1004",0x10003,0x3 +HKCU,"%ZONES_INTERNET%","1200",0x10003,0x0 +HKLM,"%ZONES_INTERNET%","1200",0x10003,0x0 +HKCU,"%ZONES_INTERNET%","1201",0x10003,0x3 +HKLM,"%ZONES_INTERNET%","1201",0x10003,0x3 +HKCU,"%ZONES_INTERNET%","1400",0x10003,0x0 +HKLM,"%ZONES_INTERNET%","1400",0x10003,0x0 +HKCU,"%ZONES_INTERNET%","1402",0x10003,0x0 +HKLM,"%ZONES_INTERNET%","1402",0x10003,0x0 +HKCU,"%ZONES_INTERNET%","1405",0x10003,0x0 +HKLM,"%ZONES_INTERNET%","1405",0x10003,0x0 +HKCU,"%ZONES_INTERNET%","1406",0x10003,0x3 +HKLM,"%ZONES_INTERNET%","1406",0x10003,0x3 +HKCU,"%ZONES_INTERNET%","1407",0x10003,0x0 +HKLM,"%ZONES_INTERNET%","1407",0x10003,0x0 +HKCU,"%ZONES_INTERNET%","1601",0x10003,0x1 +HKLM,"%ZONES_INTERNET%","1601",0x10003,0x1 +HKCU,"%ZONES_INTERNET%","1604",0x10003,0x0 +HKLM,"%ZONES_INTERNET%","1604",0x10003,0x0 +HKCU,"%ZONES_INTERNET%","1605",0x10003,0x0 +HKLM,"%ZONES_INTERNET%","1605",0x10003,0x0 +HKCU,"%ZONES_INTERNET%","1606",0x10003,0x0 +HKLM,"%ZONES_INTERNET%","1606",0x10003,0x0 +HKCU,"%ZONES_INTERNET%","1607",0x10003,0x0 +HKLM,"%ZONES_INTERNET%","1607",0x10003,0x0 +HKCU,"%ZONES_INTERNET%","1608",0x10003,0x0 +HKLM,"%ZONES_INTERNET%","1608",0x10003,0x0 +HKCU,"%ZONES_INTERNET%","1609",0x10003,0x1 +HKLM,"%ZONES_INTERNET%","1609",0x10003,0x1 +HKCU,"%ZONES_INTERNET%","1800",0x10003,0x1 +HKLM,"%ZONES_INTERNET%","1800",0x10003,0x1 +HKCU,"%ZONES_INTERNET%","1802",0x10003,0x0 +HKLM,"%ZONES_INTERNET%","1802",0x10003,0x0 +HKCU,"%ZONES_INTERNET%","1803",0x10003,0x0 +HKLM,"%ZONES_INTERNET%","1803",0x10003,0x0 +HKCU,"%ZONES_INTERNET%","1804",0x10003,0x1 +HKLM,"%ZONES_INTERNET%","1804",0x10003,0x1 +HKCU,"%ZONES_INTERNET%","1805",0x10001,0x1 +HKLM,"%ZONES_INTERNET%","1805",0x10001,0x1 +HKCU,"%ZONES_INTERNET%","1A00",0x10003,0x20000 +HKLM,"%ZONES_INTERNET%","1A00",0x10003,0x20000 +HKCU,"%ZONES_INTERNET%","1A02",0x10003,0x0 +HKLM,"%ZONES_INTERNET%","1A02",0x10003,0x0 +HKCU,"%ZONES_INTERNET%","1A03",0x10003,0x0 +HKLM,"%ZONES_INTERNET%","1A03",0x10003,0x0 +HKCU,"%ZONES_INTERNET%","1A04",0x10003,0x3 +HKLM,"%ZONES_INTERNET%","1A04",0x10003,0x3 +HKCU,"%ZONES_INTERNET%","1A05",0x10003,0x1 +HKLM,"%ZONES_INTERNET%","1A05",0x10003,0x1 +HKCU,"%ZONES_INTERNET%","1A06",0x10003,0x0 +HKLM,"%ZONES_INTERNET%","1A06",0x10003,0x0 +HKCU,"%ZONES_INTERNET%","1A10",0x10003,0x1 +HKLM,"%ZONES_INTERNET%","1A10",0x10003,0x1 +HKCU,"%ZONES_INTERNET%","1C00",0x10003,0x10000 +HKLM,"%ZONES_INTERNET%","1C00",0x10003,0x10000 +HKCU,"%ZONES_INTERNET%","1E05",0x10003,0x20000 +HKLM,"%ZONES_INTERNET%","1E05",0x10003,0x20000 + +;; Untrusted Zone +HKCU,"%ZONES_UNTRUSTED%",,, +HKLM,"%ZONES_UNTRUSTED%",,, +HKCU,"%ZONES_UNTRUSTED%","DisplayName",,%NAME_UNTRUSTED% +HKLM,"%ZONES_UNTRUSTED%","DisplayName",,%NAME_UNTRUSTED% +HKCU,"%ZONES_UNTRUSTED%","Description",,%DESC_UNTRUSTED% +HKLM,"%ZONES_UNTRUSTED%","Description",,%DESC_UNTRUSTED% +HKCU,"%ZONES_UNTRUSTED%","Icon",,%ZICON_UNTRUSTED% +HKLM,"%ZONES_UNTRUSTED%","Icon",,%ZICON_UNTRUSTED% +HKCU,"%ZONES_UNTRUSTED%","CurrentLevel",0x10003,0x12000 +HKLM,"%ZONES_UNTRUSTED%","CurrentLevel",0x10003,0x12000 +HKCU,"%ZONES_UNTRUSTED%","MinLevel",0x10001,0x12000 +HKLM,"%ZONES_UNTRUSTED%","MinLevel",0x10001,0x12000 +HKCU,"%ZONES_UNTRUSTED%","RecommendedLevel",0x10001,0x12000 +HKLM,"%ZONES_UNTRUSTED%","RecommendedLevel",0x10001,0x12000 +HKCU,"%ZONES_UNTRUSTED%","Flags",0x10001,0x3 +HKLM,"%ZONES_UNTRUSTED%","Flags",0x10001,0x3 +HKCU,"%ZONES_UNTRUSTED%","1001",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1001",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1004",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1004",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1200",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1200",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1201",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1201",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1400",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1400",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1402",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1402",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1405",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1405",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1406",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1406",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1407",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1407",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1601",0x10003,0x1 +HKLM,"%ZONES_UNTRUSTED%","1601",0x10003,0x1 +HKCU,"%ZONES_UNTRUSTED%","1604",0x10003,0x1 +HKLM,"%ZONES_UNTRUSTED%","1604",0x10003,0x1 +HKCU,"%ZONES_UNTRUSTED%","1605",0x10003,0x0 +HKLM,"%ZONES_UNTRUSTED%","1605",0x10003,0x0 +HKCU,"%ZONES_UNTRUSTED%","1606",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1606",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1607",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1607",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1608",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1608",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1609",0x10003,0x1 +HKLM,"%ZONES_UNTRUSTED%","1609",0x10003,0x1 +HKCU,"%ZONES_UNTRUSTED%","1800",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1800",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1802",0x10003,0x1 +HKLM,"%ZONES_UNTRUSTED%","1802",0x10003,0x1 +HKCU,"%ZONES_UNTRUSTED%","1803",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1803",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1804",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1804",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1805",0x10003,0x1 +HKLM,"%ZONES_UNTRUSTED%","1805",0x10003,0x1 +HKCU,"%ZONES_UNTRUSTED%","1A00",0x10003,0x10000 +HKLM,"%ZONES_UNTRUSTED%","1A00",0x10003,0x10000 +HKCU,"%ZONES_UNTRUSTED%","1A02",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1A02",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1A03",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1A03",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1A04",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1A04",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1A05",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1A05",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1A06",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1A06",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1A10",0x10003,0x3 +HKLM,"%ZONES_UNTRUSTED%","1A10",0x10003,0x3 +HKCU,"%ZONES_UNTRUSTED%","1C00",0x10003,0x0 +HKLM,"%ZONES_UNTRUSTED%","1C00",0x10003,0x0 +HKCU,"%ZONES_UNTRUSTED%","1E05",0x10003,0x10000 +HKLM,"%ZONES_UNTRUSTED%","1E05",0x10003,0x10000 + + +[Strings] +PATH_ZONEMAP="Software\Microsoft\Windows\CurrentVersion\Internet Settings\ZoneMap" +PATH_ZONEMAP_PROTOCOLS="Software\Microsoft\Windows\CurrentVersion\Internet Settings\ZoneMap\ProtocolDefaults" +PATH_ZONEMAP_DOMAINS="Software\Microsoft\Windows\CurrentVersion\Internet Settings\ZoneMap\Domains" +PATH_ZONEMAP_RANGES="Software\Microsoft\Windows\CurrentVersion\Internet Settings\ZoneMap\Ranges" + +PATH_ZONES="Software\Microsoft\Windows\CurrentVersion\Internet Settings\Zones" +ZONES_LOCAL="Software\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\0" +ZONES_INTRANET="Software\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\1" +ZONES_TRUSTED="Software\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\2" +ZONES_INTERNET="Software\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\3" +ZONES_UNTRUSTED="Software\Microsoft\Windows\CurrentVersion\Internet Settings\Zones\4" + +NAME_LOCAL="My Computer" +DESC_LOCAL="Your computer" +ZICON_LOCAL="explorer.exe#0100" + +NAME_INTRANET="Local intranet" +DESC_INTRANET="This zone contains all Web sites that are on your organization's intranet." +ZICON_INTRANET="shell32.dll#0018" + +NAME_TRUSTED="Trusted sites" +DESC_TRUSTED="This zone contains Web sites that you trust not to damage your computer or data." +ZICON_TRUSTED="inetcpl.cpl#00004480" + +NAME_INTERNET="Internet" +DESC_INTERNET="This zone contains all Web sites you haven't placed in other zones" +ZICON_INTERNET="inetcpl.cpl#001313" + +NAME_UNTRUSTED="Restricted sites" +DESC_UNTRUSTED="This zone contains Web sites that could potentially damage your computer or data." +ZICON_UNTRUSTED="inetcpl.cpl#00004481" diff --git a/reactos/lib/urlmon/urlmon.spec b/reactos/lib/urlmon/urlmon.spec index 81bf6b22de4..143c180114b 100644 --- a/reactos/lib/urlmon/urlmon.spec +++ b/reactos/lib/urlmon/urlmon.spec @@ -17,14 +17,14 @@ @ stub CoInternetGetProtocolFlags @ stub CoInternetGetSecurityUrl @ stdcall CoInternetGetSession(long ptr long) -@ stub CoInternetParseUrl +@ stdcall CoInternetParseUrl(wstr long long wstr long ptr long) @ stdcall CoInternetQueryInfo(ptr long long ptr long ptr long) @ stub CompareSecurityIds @ stub CopyBindInfo @ stub CopyStgMedium @ stdcall CreateAsyncBindCtx(long ptr ptr ptr) @ stdcall CreateAsyncBindCtxEx(ptr long ptr ptr ptr long) -@ stub CreateFormatEnumerator +@ stdcall CreateFormatEnumerator(long ptr ptr) @ stdcall CreateURLMoniker(ptr wstr ptr) @ stdcall -private DllCanUnloadNow() @ stdcall -private DllGetClassObject(ptr ptr ptr) @@ -56,12 +56,12 @@ @ stdcall ObtainUserAgentString(long str ptr) @ stub PrivateCoInstall @ stdcall RegisterBindStatusCallback(ptr ptr ptr long) -@ stub RegisterFormatEnumerator +@ stdcall RegisterFormatEnumerator(ptr ptr long) @ stub RegisterMediaTypeClass @ stub RegisterMediaTypes @ stdcall ReleaseBindInfo(ptr) @ stdcall RevokeBindStatusCallback(ptr ptr) -@ stub RevokeFormatEnumerator +@ stdcall RevokeFormatEnumerator(ptr ptr) @ stub SetSoftwareUpdateAdvertisementState @ stub URLDownloadA @ stub URLDownloadToCacheFileA diff --git a/reactos/lib/urlmon/urlmon.xml b/reactos/lib/urlmon/urlmon.xml index 65184d6a8f5..b082bce5162 100644 --- a/reactos/lib/urlmon/urlmon.xml +++ b/reactos/lib/urlmon/urlmon.xml @@ -18,8 +18,14 @@ shlwapi cabinet wininet + file.c + format.c + ftp.c + http.c + internet.c regsvr.c sec_mgr.c + session.c umon.c umstream.c urlmon_main.c diff --git a/reactos/lib/urlmon/urlmon_main.c b/reactos/lib/urlmon/urlmon_main.c index 3dcda86e451..fa2e195a8f6 100644 --- a/reactos/lib/urlmon/urlmon_main.c +++ b/reactos/lib/urlmon/urlmon_main.c @@ -24,12 +24,13 @@ #include "windef.h" #include "winbase.h" -#include "winerror.h" -#include "wtypes.h" +#include "winreg.h" + #define NO_SHLWAPI_REG #include "shlwapi.h" #include "wine/debug.h" +#include "wine/unicode.h" #include "winuser.h" #include "urlmon.h" @@ -101,6 +102,9 @@ struct object_creation_info static const struct object_creation_info object_creation[] = { + { &CLSID_FileProtocol, FileProtocol_Construct }, + { &CLSID_FtpProtocol, FtpProtocol_Construct }, + { &CLSID_HttpProtocol, HttpProtocol_Construct }, { &CLSID_InternetSecurityManager, &SecManagerImpl_Construct }, { &CLSID_InternetZoneManager, ZoneMgrImpl_Construct } }; @@ -361,3 +365,118 @@ HRESULT WINAPI CoGetClassObjectFromURL( REFCLSID rclsid, LPCWSTR szCodeURL, DWOR debugstr_guid(riid), ppv); return E_NOINTERFACE; } + +/*********************************************************************** + * ReleaseBindInfo (URLMON.@) + * + * Release the resources used by the specified BINDINFO structure. + * + * PARAMS + * pbindinfo [I] BINDINFO to release. + * + * RETURNS + * Nothing. + */ +void WINAPI ReleaseBindInfo(BINDINFO* pbindinfo) +{ + TRACE("(%p)\n", pbindinfo); + + if(!pbindinfo) + return; + + CoTaskMemFree(pbindinfo->szExtraInfo); + + if(pbindinfo->pUnk) + IUnknown_Release(pbindinfo->pUnk); +} + +/*********************************************************************** + * FindMimeFromData (URLMON.@) + * + * Determines the Multipurpose Internet Mail Extensions (MIME) type from the data provided. + */ +HRESULT WINAPI FindMimeFromData(LPBC pBC, LPCWSTR pwzUrl, LPVOID pBuffer, + DWORD cbSize, LPCWSTR pwzMimeProposed, DWORD dwMimeFlags, + LPWSTR* ppwzMimeOut, DWORD dwReserved) +{ + TRACE("(%p,%s,%p,%ld,%s,0x%lx,%p,0x%lx)\n", pBC, debugstr_w(pwzUrl), pBuffer, cbSize, + debugstr_w(pwzMimeProposed), dwMimeFlags, ppwzMimeOut, dwReserved); + + if(dwMimeFlags) + WARN("dwMimeFlags=%08lx\n", dwMimeFlags); + if(dwReserved) + WARN("dwReserved=%ld\n", dwReserved); + + /* pBC seams to not be used */ + + if(!ppwzMimeOut || (!pwzUrl && !pBuffer)) + return E_INVALIDARG; + + if(pwzMimeProposed && (!pwzUrl || !pBuffer || (pBuffer && !cbSize))) { + DWORD len; + + if(!pwzMimeProposed) + return E_FAIL; + + len = strlenW(pwzMimeProposed)+1; + *ppwzMimeOut = CoTaskMemAlloc(len*sizeof(WCHAR)); + memcpy(*ppwzMimeOut, pwzMimeProposed, len*sizeof(WCHAR)); + return S_OK; + } + + if(pBuffer) { + UCHAR *ptr = pBuffer; + DWORD len; + LPCWSTR ret; + + static const WCHAR wszAppOctetStream[] = {'a','p','p','l','i','c','a','t','i','o','n','/', + 'o','c','t','e','t','-','s','t','r','e','a','m','\0'}; + static const WCHAR wszTextPlain[] = {'t','e','x','t','/','p','l','a','i','n','\0'}; + + if(!cbSize) + return E_FAIL; + + ret = wszTextPlain; + for(ptr = pBuffer; ptr < (UCHAR*)pBuffer+cbSize-1; ptr++) { + if(*ptr < 0x20 && *ptr != '\n' && *ptr != '\r' && *ptr != '\t') { + ret = wszAppOctetStream; + break; + } + } + + len = strlenW(ret)+1; + *ppwzMimeOut = CoTaskMemAlloc(len*sizeof(WCHAR)); + memcpy(*ppwzMimeOut, ret, len*sizeof(WCHAR)); + return S_OK; + } + + if(pwzUrl) { + HKEY hkey; + DWORD res, size; + LPCWSTR ptr; + WCHAR mime[64]; + + static const WCHAR wszContentType[] = + {'C','o','n','t','e','n','t',' ','T','y','p','e','\0'}; + + ptr = strrchrW(pwzUrl, '.'); + if(!ptr) + return E_FAIL; + + res = RegOpenKeyW(HKEY_CLASSES_ROOT, ptr, &hkey); + if(res != ERROR_SUCCESS) + return E_FAIL; + + size = sizeof(mime); + res = RegQueryValueExW(hkey, wszContentType, NULL, NULL, (LPBYTE)mime, &size); + RegCloseKey(hkey); + if(res != ERROR_SUCCESS) + return E_FAIL; + + *ppwzMimeOut = CoTaskMemAlloc(size); + memcpy(*ppwzMimeOut, mime, size); + return S_OK; + } + + return E_FAIL; +} diff --git a/reactos/lib/urlmon/urlmon_main.h b/reactos/lib/urlmon/urlmon_main.h index 3c912f78c8f..9a012d2fec5 100644 --- a/reactos/lib/urlmon/urlmon_main.h +++ b/reactos/lib/urlmon/urlmon_main.h @@ -27,6 +27,9 @@ extern HINSTANCE URLMON_hInstance; extern HRESULT SecManagerImpl_Construct(IUnknown *pUnkOuter, LPVOID *ppobj); extern HRESULT ZoneMgrImpl_Construct(IUnknown *pUnkOuter, LPVOID *ppobj); +extern HRESULT FileProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj); +extern HRESULT HttpProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj); +extern HRESULT FtpProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj); /********************************************************************** * Dll lifetime tracking declaration for urlmon.dll @@ -36,6 +39,7 @@ static inline void URLMON_LockModule(void) { InterlockedIncrement( &URLMON_refCo static inline void URLMON_UnlockModule(void) { InterlockedDecrement( &URLMON_refCount ); } #define ICOM_THIS_MULTI(impl,field,iface) impl* const This=(impl*)((char*)(iface) - offsetof(impl,field)) +#define DEFINE_THIS(cls,ifc,iface) ((cls*)((BYTE*)(iface)-offsetof(cls,lp ## ifc ## Vtbl))) typedef struct { @@ -50,13 +54,4 @@ typedef struct HRESULT UMCreateStreamOnCacheFile(LPCWSTR pszURL, DWORD dwSize, LPWSTR pszFileName, HANDLE *phfile, IUMCacheStream **ppstr); void UMCloseCacheFileStream(IUMCacheStream *pstr); -DEFINE_GUID(CLSID_CdlProtocol, 0x3dd53d40, 0x7b8b, 0x11D0, 0xb0,0x13, 0x00,0xaa,0x00,0x59,0xce,0x02); -DEFINE_GUID(CLSID_FileProtocol, 0x79EAC9E7, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B); -DEFINE_GUID(CLSID_FtpProtocol, 0x79EAC9E3, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B); -DEFINE_GUID(CLSID_GopherProtocol, 0x79EAC9E4, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B); -DEFINE_GUID(CLSID_HttpProtocol, 0x79EAC9E2, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B); -DEFINE_GUID(CLSID_HttpsProtocol, 0x79EAC9E5, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B); -DEFINE_GUID(CLSID_MkProtocol, 0x79EAC9E6, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B); - - #endif /* __WINE_URLMON_MAIN_H */ diff --git a/reactos/lib/urlmon/version.rc b/reactos/lib/urlmon/version.rc new file mode 100644 index 00000000000..4f532951a83 --- /dev/null +++ b/reactos/lib/urlmon/version.rc @@ -0,0 +1,27 @@ +/* + * Copyright 2005 + * + * Stefan Leichter + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#define WINE_FILENAME_STR "urlmon.dll" +#define WINE_FILEVERSION 6,0,2800,1485 +#define WINE_FILEVERSION_STR "6.0.2800.1485" +#define WINE_PRODUCTVERSION 6,0,2800,1485 +#define WINE_PRODUCTVERSION_STR "6.0.2800.1485" + +#include "wine/wine_common_ver.rc" diff --git a/reactos/w32api/include/urlmon.h b/reactos/w32api/include/urlmon.h index 062d0e4cd63..b0b32c6c597 100644 --- a/reactos/w32api/include/urlmon.h +++ b/reactos/w32api/include/urlmon.h @@ -3258,6 +3258,13 @@ DEFINE_GUID(CLSID_InternetZoneManager, 0x7B8A2D95, 0x0AC9, 0x11D1, 0x89, 0x6C, 0 DEFINE_GUID(IID_IAsyncMoniker, 0x79EAC9D3, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B); DEFINE_GUID(IID_IAsyncBindCtx, 0x79EAC9D4, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B); DEFINE_GUID(CLSID_StdURLMoniker, 0x79EAC9E0, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B); +DEFINE_GUID(CLSID_CdlProtocol, 0x3dd53d40, 0x7b8b, 0x11D0, 0xb0,0x13, 0x00,0xaa,0x00,0x59,0xce,0x02); +DEFINE_GUID(CLSID_FileProtocol, 0x79EAC9E7, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B); +DEFINE_GUID(CLSID_FtpProtocol, 0x79EAC9E3, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B); +DEFINE_GUID(CLSID_GopherProtocol, 0x79EAC9E4, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B); +DEFINE_GUID(CLSID_HttpProtocol, 0x79EAC9E2, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B); +DEFINE_GUID(CLSID_HttpSProtocol, 0x79EAC9E5, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B); +DEFINE_GUID(CLSID_MkProtocol, 0x79EAC9E6, 0xBAF9, 0x11CE, 0x8C,0x82, 0x00,0xAA,0x00,0x4B,0xA9,0x0B); #define MK_S_ASYNCHRONOUS 0x000401E8 #define S_ASYNCHRONOUS MK_S_ASYNCHRONOUS #define INET_E_ERROR_FIRST 0x800C0002L @@ -3282,6 +3289,7 @@ DEFINE_GUID(CLSID_StdURLMoniker, 0x79EAC9E0, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0 #define INET_E_REDIRECT_TO_DIR 0x800C0015L #define INET_E_CANNOT_LOCK_REQUEST 0x800C0016L #define INET_E_ERROR_LAST INET_E_REDIRECT_TO_DIR +#define INET_E_DEFAULT_ACTION INET_E_USE_DEFAULT_PROTOCOLHANDLER HRESULT WINAPI CoGetClassObjectFromURL(REFCLSID, LPCWSTR, DWORD, DWORD, LPCWSTR, LPBINDCTX, DWORD, LPVOID, REFIID, LPVOID*); HRESULT WINAPI CreateURLMoniker(IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk); HRESULT WINAPI RegisterBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc, IBindStatusCallback **ppbsc, DWORD dwReserved); @@ -3297,6 +3305,7 @@ HRESULT WINAPI CoInternetCreateSecurityManager(IServiceProvider*,IInternetSecuri HRESULT WINAPI CoInternetCombineUrl(LPCWSTR,LPCWSTR,DWORD,LPWSTR,DWORD,DWORD*,DWORD); HRESULT WINAPI CoInternetCompareUrl(LPCWSTR,LPCWSTR,DWORD); HRESULT WINAPI CoInternetCreateZoneManager(IServiceProvider*, IInternetZoneManager**, DWORD); +HRESULT WINAPI CoInternetParseUrl(LPCWSTR,PARSEACTION,DWORD,LPWSTR,DWORD,DWORD*,DWORD); HRESULT WINAPI CoInternetQueryInfo(LPCWSTR,QUERYOPTION,DWORD,LPVOID,DWORD,DWORD*,DWORD); HRESULT WINAPI GetSoftwareUpdateInfo( LPCWSTR szDistUnit, LPSOFTDISTINFO psdi); HRESULT WINAPI FaultInIEFeature(HWND,uCLSSPEC*,QUERYCONTEXT*,DWORD);