mshtml: Added IHTMLButtonElement::name implementation.
[wine] / dlls / mshtml / protocol.c
index 78b9bfb..021ce55 100644 (file)
@@ -13,7 +13,7 @@
  *
  * 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
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
 #include "config.h"
 #include "winbase.h"
 #include "winuser.h"
 #include "ole2.h"
-#include "docobj.h"
-
-#include "mshtml.h"
 
 #include "wine/debug.h"
-#include "wine/unicode.h"
 
 #include "mshtml_private.h"
 
@@ -42,31 +38,30 @@ WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  * common ProtocolFactory implementation
  */
 
-#define PROTOCOLINFO(x) ((IInternetProtocolInfo*) &(x)->lpInternetProtocolInfoVtbl)
-#define CLASSFACTORY(x) ((IClassFactory*)         &(x)->lpClassFactoryVtbl)
-
 typedef struct {
-    const IInternetProtocolInfoVtbl *lpInternetProtocolInfoVtbl;
-    const IClassFactoryVtbl         *lpClassFactoryVtbl;
+    IInternetProtocolInfo IInternetProtocolInfo_iface;
+    IClassFactory         IClassFactory_iface;
 } ProtocolFactory;
 
-#define PROTOCOLINFO_THIS(iface) \
-    (ProtocolFactory*)((char*)(iface)-offsetof(ProtocolFactory,lpInternetProtocolInfoVtbl))
+static inline ProtocolFactory *impl_from_IInternetProtocolInfo(IInternetProtocolInfo *iface)
+{
+    return CONTAINING_RECORD(iface, ProtocolFactory, IInternetProtocolInfo_iface);
+}
 
 static HRESULT WINAPI InternetProtocolInfo_QueryInterface(IInternetProtocolInfo *iface, REFIID riid, void **ppv)
 {
-    ProtocolFactory *This = PROTOCOLINFO_THIS(iface);
+    ProtocolFactory *This = impl_from_IInternetProtocolInfo(iface);
 
     *ppv = NULL;
     if(IsEqualGUID(&IID_IUnknown, riid)) {
         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
-        *ppv = PROTOCOLINFO(This);
+        *ppv = &This->IInternetProtocolInfo_iface;
     }else if(IsEqualGUID(&IID_IInternetProtocolInfo, riid)) {
         TRACE("(%p)->(IID_IInternetProtocolInfo %p)\n", This, ppv);
-        *ppv = PROTOCOLINFO(This);
+        *ppv = &This->IInternetProtocolInfo_iface;
     }else if(IsEqualGUID(&IID_IClassFactory, riid)) {
         TRACE("(%p)->(IID_IClassFactory %p)\n", This, ppv);
-        *ppv = CLASSFACTORY(This);
+        *ppv = &This->IClassFactory_iface;
     }
 
     if(!*ppv) {
@@ -80,72 +75,101 @@ static HRESULT WINAPI InternetProtocolInfo_QueryInterface(IInternetProtocolInfo
 
 static ULONG WINAPI InternetProtocolInfo_AddRef(IInternetProtocolInfo *iface)
 {
-    ProtocolFactory *This = PROTOCOLINFO_THIS(iface);
-    TRACE("(%p)\n", This);
+    TRACE("(%p)\n", iface);
     return 2;
 }
 
 static ULONG WINAPI InternetProtocolInfo_Release(IInternetProtocolInfo *iface)
 {
-    ProtocolFactory *This = PROTOCOLINFO_THIS(iface);
-    TRACE("(%p)\n", This);
+    TRACE("(%p)\n", iface);
     return 1;
 }
 
-#undef PROTOCOLINFO_THIS
+static HRESULT WINAPI InternetProtocolInfo_CombineUrl(IInternetProtocolInfo *iface,
+        LPCWSTR pwzBaseUrl, LPCWSTR pwzRelativeUrl, DWORD dwCombineFlags, LPWSTR pwzResult,
+        DWORD cchResult, DWORD* pcchResult, DWORD dwReserved)
+{
+    TRACE("%p)->(%s %s %08x %p %d %p %d)\n", iface, debugstr_w(pwzBaseUrl),
+            debugstr_w(pwzRelativeUrl), dwCombineFlags, pwzResult, cchResult,
+            pcchResult, dwReserved);
+
+    return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
+}
+
+static HRESULT WINAPI InternetProtocolInfo_CompareUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl1,
+        LPCWSTR pwzUrl2, DWORD dwCompareFlags)
+{
+    TRACE("%p)->(%s %s %08x)\n", iface, debugstr_w(pwzUrl1), debugstr_w(pwzUrl2), dwCompareFlags);
+    return E_NOTIMPL;
+}
 
-#define CLASSFACTORY_THIS(iface) \
-    (ProtocolFactory*)((char*)(iface)-offsetof(ProtocolFactory,lpClassFactoryVtbl))
+static inline ProtocolFactory *impl_from_IClassFactory(IClassFactory *iface)
+{
+    return CONTAINING_RECORD(iface, ProtocolFactory, IClassFactory_iface);
+}
 
 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 {
-    ProtocolFactory *This = CLASSFACTORY_THIS(iface);
-    return IInternetProtocolInfo_QueryInterface(PROTOCOLINFO(This), riid, ppv);
+    ProtocolFactory *This = impl_from_IClassFactory(iface);
+    return IInternetProtocolInfo_QueryInterface(&This->IInternetProtocolInfo_iface, riid, ppv);
 }
 
 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 {
-    ProtocolFactory *This = CLASSFACTORY_THIS(iface);
-    return IInternetProtocolInfo_AddRef(PROTOCOLINFO(This));
+    ProtocolFactory *This = impl_from_IClassFactory(iface);
+    return IInternetProtocolInfo_AddRef(&This->IInternetProtocolInfo_iface);
 }
 
 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 {
-    ProtocolFactory *This = CLASSFACTORY_THIS(iface);
-    return IInternetProtocolInfo_Release(PROTOCOLINFO(This));
+    ProtocolFactory *This = impl_from_IClassFactory(iface);
+    return IInternetProtocolInfo_Release(&This->IInternetProtocolInfo_iface);
 }
 
 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
 {
-    ProtocolFactory *This = CLASSFACTORY_THIS(iface);
-    FIXME("(%p)->(%x)\n", This, dolock);
+    TRACE("(%p)->(%x)\n", iface, dolock);
     return S_OK;
 }
 
-#undef CLASSFACTORY_THIS
-
 /********************************************************************
  * AboutProtocol implementation
  */
 
 typedef struct {
-    const IInternetProtocolVtbl *lpInternetProtocolVtbl;
+    IInternetProtocol IInternetProtocol_iface;
+
     LONG ref;
+
+    BYTE *data;
+    ULONG data_len;
+    ULONG cur;
+
+    IUnknown *pUnkOuter;
 } AboutProtocol;
 
+static inline AboutProtocol *AboutProtocol_from_IInternetProtocol(IInternetProtocol *iface)
+{
+    return CONTAINING_RECORD(iface, AboutProtocol, IInternetProtocol_iface);
+}
+
 static HRESULT WINAPI AboutProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
 {
+    AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
+
     *ppv = NULL;
 
     if(IsEqualGUID(&IID_IUnknown, riid)) {
         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
-        *ppv = iface;
+        if(This->pUnkOuter)
+            return IUnknown_QueryInterface(This->pUnkOuter, riid, ppv);
+        *ppv = &This->IInternetProtocol_iface;
     }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
         TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", iface, ppv);
-        *ppv = iface;
+        *ppv = &This->IInternetProtocol_iface;
     }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
         TRACE("(%p)->(IID_IInternetProtocol %p)\n", iface, ppv);
-        *ppv = iface;
+        *ppv = &This->IInternetProtocol_iface;
     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
         FIXME("IServiceProvider is not implemented\n");
         return E_NOINTERFACE;
@@ -162,38 +186,102 @@ static HRESULT WINAPI AboutProtocol_QueryInterface(IInternetProtocol *iface, REF
 
 static ULONG WINAPI AboutProtocol_AddRef(IInternetProtocol *iface)
 {
-    AboutProtocol *This = (AboutProtocol*)iface;
+    AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
     ULONG ref = InterlockedIncrement(&This->ref);
-    TRACE("(%p) ref=%ld\n", iface, ref);
-    return ref;
+    TRACE("(%p) ref=%d\n", iface, ref);
+    return This->pUnkOuter ? IUnknown_AddRef(This->pUnkOuter) : ref;
 }
 
 static ULONG WINAPI AboutProtocol_Release(IInternetProtocol *iface)
 {
-    AboutProtocol *This = (AboutProtocol*)iface;
+    AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
+    IUnknown *pUnkOuter = This->pUnkOuter;
     ULONG ref = InterlockedDecrement(&This->ref);
 
-    TRACE("(%p) ref=%lx\n", iface, ref);
+    TRACE("(%p) ref=%x\n", iface, ref);
 
-    if(!ref)
-        HeapFree(GetProcessHeap(), 0, This);
+    if(!ref) {
+        heap_free(This->data);
+        heap_free(This);
+    }
 
-    return ref;
+    return pUnkOuter ? IUnknown_Release(pUnkOuter) : ref;
 }
 
 static HRESULT WINAPI AboutProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
         IInternetProtocolSink* pOIProtSink, IInternetBindInfo* pOIBindInfo,
-        DWORD grfPI, DWORD dwReserved)
+        DWORD grfPI, HANDLE_PTR dwReserved)
 {
-    AboutProtocol *This = (AboutProtocol*)iface;
-    FIXME("(%p)->(%s %p %p %08lx %ld)\n", This, debugstr_w(szUrl), pOIProtSink,
+    AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
+    BINDINFO bindinfo;
+    DWORD grfBINDF = 0;
+    LPCWSTR text = NULL;
+    DWORD data_len;
+    BYTE *data;
+    HRESULT hres;
+
+    static const WCHAR html_begin[] = {0xfeff,'<','H','T','M','L','>',0};
+    static const WCHAR html_end[] = {'<','/','H','T','M','L','>',0};
+    static const WCHAR wszBlank[] = {'b','l','a','n','k',0};
+    static const WCHAR wszAbout[] = {'a','b','o','u','t',':'};
+    static const WCHAR wszTextHtml[] = {'t','e','x','t','/','h','t','m','l',0};
+
+    /* NOTE:
+     * the about protocol seems not to work as I would expect. It creates html document
+     * for a given url, eg. about:some_text -> <HTML>some_text</HTML> except for the case when
+     * some_text = "blank", when document is blank (<HTML></HMTL>). The same happens
+     * when the url does not have "about:" in the beginning.
+     */
+
+    TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink,
             pOIBindInfo, grfPI, dwReserved);
-    return E_NOTIMPL;
+
+    memset(&bindinfo, 0, sizeof(bindinfo));
+    bindinfo.cbSize = sizeof(BINDINFO);
+    hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &grfBINDF, &bindinfo);
+    if(FAILED(hres))
+        return hres;
+    ReleaseBindInfo(&bindinfo);
+
+    TRACE("bindf %x\n", grfBINDF);
+
+    if(strlenW(szUrl)>=sizeof(wszAbout)/sizeof(WCHAR) && !memcmp(wszAbout, szUrl, sizeof(wszAbout))) {
+        text = szUrl + sizeof(wszAbout)/sizeof(WCHAR);
+        if(!strcmpW(wszBlank, text))
+            text = NULL;
+    }
+
+    data_len = sizeof(html_begin)+sizeof(html_end)-sizeof(WCHAR)
+        + (text ? strlenW(text)*sizeof(WCHAR) : 0);
+    data = heap_alloc(data_len);
+    if(!data)
+        return E_OUTOFMEMORY;
+
+    heap_free(This->data);
+    This->data = data;
+    This->data_len = data_len;
+
+    memcpy(This->data, html_begin, sizeof(html_begin));
+    if(text)
+        strcatW((LPWSTR)This->data, text);
+    strcatW((LPWSTR)This->data, html_end);
+    
+    This->cur = 0;
+
+    IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, wszTextHtml);
+
+    IInternetProtocolSink_ReportData(pOIProtSink,
+            BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE,
+            This->data_len, This->data_len);
+
+    IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
+
+    return S_OK;
 }
 
 static HRESULT WINAPI AboutProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA* pProtocolData)
 {
-    AboutProtocol *This = (AboutProtocol*)iface;
+    AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
     FIXME("(%p)->(%p)\n", This, pProtocolData);
     return E_NOTIMPL;
 }
@@ -201,59 +289,76 @@ static HRESULT WINAPI AboutProtocol_Continue(IInternetProtocol *iface, PROTOCOLD
 static HRESULT WINAPI AboutProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
         DWORD dwOptions)
 {
-    AboutProtocol *This = (AboutProtocol*)iface;
-    FIXME("(%p)->(%08lx %08lx)\n", This, hrReason, dwOptions);
+    AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
+    FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
     return E_NOTIMPL;
 }
 
 static HRESULT WINAPI AboutProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
 {
-    AboutProtocol *This = (AboutProtocol*)iface;
-    FIXME("(%p)->(%08lx)\n", This, dwOptions);
-    return E_NOTIMPL;
+    AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
+    TRACE("(%p)->(%08x)\n", This, dwOptions);
+    return S_OK;
 }
 
 static HRESULT WINAPI AboutProtocol_Suspend(IInternetProtocol *iface)
 {
-    AboutProtocol *This = (AboutProtocol*)iface;
+    AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
     FIXME("(%p)\n", This);
     return E_NOTIMPL;
 }
 
 static HRESULT WINAPI AboutProtocol_Resume(IInternetProtocol *iface)
 {
-    AboutProtocol *This = (AboutProtocol*)iface;
+    AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
     FIXME("(%p)\n", This);
     return E_NOTIMPL;
 }
 
 static HRESULT WINAPI AboutProtocol_Read(IInternetProtocol *iface, void* pv, ULONG cb, ULONG* pcbRead)
 {
-    AboutProtocol *This = (AboutProtocol*)iface;
-    FIXME("(%p)->(%lu %p)\n", This, cb, pcbRead);
-    return E_NOTIMPL;
+    AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
+
+    TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
+
+    if(!This->data)
+        return E_FAIL;
+
+    *pcbRead = (cb > This->data_len-This->cur ? This->data_len-This->cur : cb);
+
+    if(!*pcbRead)
+        return S_FALSE;
+
+    memcpy(pv, This->data+This->cur, *pcbRead);
+    This->cur += *pcbRead;
+
+    return S_OK;
 }
 
 static HRESULT WINAPI AboutProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
         DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
 {
-    AboutProtocol *This = (AboutProtocol*)iface;
-    FIXME("(%p)->(%ld %ld %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
+    AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
+    FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
     return E_NOTIMPL;
 }
 
 static HRESULT WINAPI AboutProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
 {
-    AboutProtocol *This = (AboutProtocol*)iface;
-    FIXME("(%p)->(%ld)\n", This, dwOptions);
-    return E_NOTIMPL;
+    AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
+
+    TRACE("(%p)->(%d)\n", This, dwOptions);
+
+    return S_OK;
 }
 
 static HRESULT WINAPI AboutProtocol_UnlockRequest(IInternetProtocol *iface)
 {
-    AboutProtocol *This = (AboutProtocol*)iface;
-    FIXME("(%p)\n", This);
-    return E_NOTIMPL;
+    AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
+
+    TRACE("(%p)\n", This);
+
+    return S_OK;
 }
 
 static const IInternetProtocolVtbl AboutProtocolVtbl = {
@@ -276,18 +381,31 @@ static HRESULT WINAPI AboutProtocolFactory_CreateInstance(IClassFactory *iface,
         REFIID riid, void **ppv)
 {
     AboutProtocol *ret;
-    HRESULT hres;
+    HRESULT hres = S_OK;
 
-    TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
+    TRACE("(%p)->(%p %s %p)\n", iface, pUnkOuter, debugstr_guid(riid), ppv);
 
-    ret = HeapAlloc(GetProcessHeap(), 0, sizeof(AboutProtocol));
-    ret->lpInternetProtocolVtbl = &AboutProtocolVtbl;
+    ret = heap_alloc(sizeof(AboutProtocol));
+    ret->IInternetProtocol_iface.lpVtbl = &AboutProtocolVtbl;
     ret->ref = 0;
 
-    hres = IUnknown_QueryInterface((IUnknown*)ret, riid, ppv);
+    ret->data = NULL;
+    ret->data_len = 0;
+    ret->cur = 0;
+    ret->pUnkOuter = pUnkOuter;
+
+    if(pUnkOuter) {
+        ret->ref = 1;
+        if(IsEqualGUID(&IID_IUnknown, riid))
+            *ppv = &ret->IInternetProtocol_iface;
+        else
+            hres = E_INVALIDARG;
+    }else {
+        hres = IInternetProtocol_QueryInterface(&ret->IInternetProtocol_iface, riid, ppv);
+    }
 
     if(FAILED(hres))
-        HeapFree(GetProcessHeap(), 0, ret);
+        heap_free(ret);
 
     return hres;
 }
@@ -296,34 +414,81 @@ static HRESULT WINAPI AboutProtocolInfo_ParseUrl(IInternetProtocolInfo *iface, L
         PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult,
         DWORD* pcchResult, DWORD dwReserved)
 {
-    FIXME("%p)->(%s %08x %08lx %p %ld %p %ld)\n", iface, debugstr_w(pwzUrl), ParseAction,
+    TRACE("%p)->(%s %d %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), ParseAction,
             dwParseFlags, pwzResult, cchResult, pcchResult, dwReserved);
-    return E_NOTIMPL;
-}
 
-static HRESULT WINAPI AboutProtocolInfo_CombineUrl(IInternetProtocolInfo *iface, LPCWSTR pwzBaseUrl,
-        LPCWSTR pwzRelativeUrl, DWORD dwCombineFlags, LPWSTR pwzResult, DWORD cchResult,
-        DWORD* pcchResult, DWORD dwReserved)
-{
-    FIXME("%p)->(%s %s %08lx %p %ld %p %ld)\n", iface, debugstr_w(pwzBaseUrl), debugstr_w(pwzRelativeUrl),
-            dwCombineFlags, pwzResult, cchResult, pcchResult, dwReserved);
-    return E_NOTIMPL;
-}
+    if(ParseAction == PARSE_SECURITY_URL) {
+        unsigned int len = strlenW(pwzUrl)+1;
 
-static HRESULT WINAPI AboutProtocolInfo_CompareUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl1,
-        LPCWSTR pwzUrl2, DWORD dwCompareFlags)
-{
-    FIXME("%p)->(%s %s %08lx)\n", iface, debugstr_w(pwzUrl1), debugstr_w(pwzUrl2), dwCompareFlags);
-    return E_NOTIMPL;
+        *pcchResult = len;
+        if(len > cchResult)
+            return S_FALSE;
+
+        memcpy(pwzResult, pwzUrl, len*sizeof(WCHAR));
+        return S_OK;
+    }
+
+    if(ParseAction == PARSE_DOMAIN) {
+        if(!pcchResult)
+            return E_POINTER;
+
+        if(pwzUrl)
+            *pcchResult = strlenW(pwzUrl)+1;
+        else
+            *pcchResult = 1;
+        return E_FAIL;
+    }
+
+    return INET_E_DEFAULT_ACTION;
 }
 
 static HRESULT WINAPI AboutProtocolInfo_QueryInfo(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
         QUERYOPTION QueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD* pcbBuf,
         DWORD dwReserved)
 {
-    FIXME("%p)->(%s %08x %08lx %p %ld %p %ld)\n", iface, debugstr_w(pwzUrl), QueryOption, dwQueryFlags, pBuffer,
-            cbBuffer, pcbBuf, dwReserved);
-    return E_NOTIMPL;
+    TRACE("%p)->(%s %08x %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), QueryOption, dwQueryFlags, pBuffer,
+          cbBuffer, pcbBuf, dwReserved);
+
+    switch(QueryOption) {
+    case QUERY_CAN_NAVIGATE:
+        return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
+
+    case QUERY_USES_NETWORK:
+        if(!pBuffer || cbBuffer < sizeof(DWORD))
+            return E_FAIL;
+
+        *(DWORD*)pBuffer = 0;
+        if(pcbBuf)
+            *pcbBuf = sizeof(DWORD);
+
+        break;
+
+    case QUERY_IS_CACHED:
+        FIXME("Unsupported option QUERY_IS_CACHED\n");
+        return E_NOTIMPL;
+    case QUERY_IS_INSTALLEDENTRY:
+        FIXME("Unsupported option QUERY_IS_INSTALLEDENTRY\n");
+        return E_NOTIMPL;
+    case QUERY_IS_CACHED_OR_MAPPED:
+        FIXME("Unsupported option QUERY_IS_CACHED_OR_MAPPED\n");
+        return E_NOTIMPL;
+    case QUERY_IS_SECURE:
+        FIXME("Unsupported option QUERY_IS_SECURE\n");
+        return E_NOTIMPL;
+    case QUERY_IS_SAFE:
+        FIXME("Unsupported option QUERY_IS_SAFE\n");
+        return E_NOTIMPL;
+    case QUERY_USES_HISTORYFOLDER:
+        FIXME("Unsupported option QUERY_USES_HISTORYFOLDER\n");
+        return E_FAIL;
+    case QUERY_IS_CACHED_AND_USABLE_OFFLINE:
+        FIXME("Unsupported option QUERY_IS_CACHED_AND_USABLE_OFFLINE\n");
+        return E_NOTIMPL;
+    default:
+        return E_FAIL;
+    }
+
+    return S_OK;
 }
 
 static const IInternetProtocolInfoVtbl AboutProtocolInfoVtbl = {
@@ -331,8 +496,8 @@ static const IInternetProtocolInfoVtbl AboutProtocolInfoVtbl = {
     InternetProtocolInfo_AddRef,
     InternetProtocolInfo_Release,
     AboutProtocolInfo_ParseUrl,
-    AboutProtocolInfo_CombineUrl,
-    AboutProtocolInfo_CompareUrl,
+    InternetProtocolInfo_CombineUrl,
+    InternetProtocolInfo_CompareUrl,
     AboutProtocolInfo_QueryInfo
 };
 
@@ -345,8 +510,8 @@ static const IClassFactoryVtbl AboutProtocolFactoryVtbl = {
 };
 
 static ProtocolFactory AboutProtocolFactory = {
-    &AboutProtocolInfoVtbl,
-    &AboutProtocolFactoryVtbl
+    { &AboutProtocolInfoVtbl },
+    { &AboutProtocolFactoryVtbl }
 };
 
 /********************************************************************
@@ -354,27 +519,38 @@ static ProtocolFactory AboutProtocolFactory = {
  */
 
 typedef struct {
-    const IInternetProtocolVtbl *lpInternetProtocolVtbl;
+    IInternetProtocol IInternetProtocol_iface;
     LONG ref;
 
     BYTE *data;
     ULONG data_len;
     ULONG cur;
+
+    IUnknown *pUnkOuter;
 } ResProtocol;
 
+static inline ResProtocol *ResProtocol_from_IInternetProtocol(IInternetProtocol *iface)
+{
+    return CONTAINING_RECORD(iface, ResProtocol, IInternetProtocol_iface);
+}
+
 static HRESULT WINAPI ResProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
 {
+    ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
+
     *ppv = NULL;
 
     if(IsEqualGUID(&IID_IUnknown, riid)) {
         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
-        *ppv = iface;
+        if(This->pUnkOuter)
+            return IUnknown_QueryInterface(This->pUnkOuter, &IID_IUnknown, ppv);
+        *ppv = &This->IInternetProtocol_iface;
     }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
         TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", iface, ppv);
-        *ppv = iface;
+        *ppv = &This->IInternetProtocol_iface;
     }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
         TRACE("(%p)->(IID_IInternetProtocol %p)\n", iface, ppv);
-        *ppv = iface;
+        *ppv = &This->IInternetProtocol_iface;
     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
         FIXME("IServiceProvider is not implemented\n");
         return E_NOINTERFACE;
@@ -391,97 +567,134 @@ static HRESULT WINAPI ResProtocol_QueryInterface(IInternetProtocol *iface, REFII
 
 static ULONG WINAPI ResProtocol_AddRef(IInternetProtocol *iface)
 {
-    ResProtocol *This = (ResProtocol*)iface;
+    ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
     ULONG ref = InterlockedIncrement(&This->ref);
-    TRACE("(%p) ref=%ld\n", iface, ref);
-    return ref;
+    TRACE("(%p) ref=%d\n", iface, ref);
+    return This->pUnkOuter ? IUnknown_AddRef(This->pUnkOuter) : ref;
 }
 
 static ULONG WINAPI ResProtocol_Release(IInternetProtocol *iface)
 {
     ResProtocol *This = (ResProtocol*)iface;
+    IUnknown *pUnkOuter = This->pUnkOuter;
     ULONG ref = InterlockedDecrement(&This->ref);
 
-    TRACE("(%p) ref=%lx\n", iface, ref);
+    TRACE("(%p) ref=%x\n", iface, ref);
 
     if(!ref) {
-        HeapFree(GetProcessHeap(), 0, This->data);
-        HeapFree(GetProcessHeap(), 0, This);
+        heap_free(This->data);
+        heap_free(This);
     }
 
-    return ref;
+    return pUnkOuter ? IUnknown_Release(pUnkOuter) : ref;
 }
 
 static HRESULT WINAPI ResProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
         IInternetProtocolSink* pOIProtSink, IInternetBindInfo* pOIBindInfo,
-        DWORD grfPI, DWORD dwReserved)
+        DWORD grfPI, HANDLE_PTR dwReserved)
 {
-    ResProtocol *This = (ResProtocol*)iface;
-    DWORD grfBINDF = 0;
+    ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
+    DWORD grfBINDF = 0, len;
     BINDINFO bindinfo;
-    int len;
-    WCHAR dll[MAX_PATH];
-    LPCWSTR url_dll, url_file;
+    LPWSTR url_dll, url_file, url, mime, res_type = (LPWSTR)RT_HTML;
     HMODULE hdll;
     HRSRC src;
+    HRESULT hres;
 
     static const WCHAR wszRes[] = {'r','e','s',':','/','/'};
 
-    TRACE("(%p)->(%s %p %p %08lx %ld)\n", This, debugstr_w(szUrl), pOIProtSink,
+    TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink,
             pOIBindInfo, grfPI, dwReserved);
 
     memset(&bindinfo, 0, sizeof(bindinfo));
     bindinfo.cbSize = sizeof(BINDINFO);
-    IInternetBindInfo_GetBindInfo(pOIBindInfo, &grfBINDF, &bindinfo);
-
-    /* FIXME:
-     * Implement MIME type checking
-     * Use CoInternetParseUrl (not implemented yet)
-     */
+    hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &grfBINDF, &bindinfo);
+    if(FAILED(hres))
+        return hres;
+    ReleaseBindInfo(&bindinfo);
+
+    len = strlenW(szUrl)+16;
+    url = heap_alloc(len*sizeof(WCHAR));
+    hres = CoInternetParseUrl(szUrl, PARSE_ENCODE, 0, url, len, &len, 0);
+    if(FAILED(hres)) {
+        WARN("CoInternetParseUrl failed: %08x\n", hres);
+        heap_free(url);
+        IInternetProtocolSink_ReportResult(pOIProtSink, hres, 0, NULL);
+        return hres;
+    }
 
-    len = strlenW(szUrl);
-    if(len < sizeof(wszRes)/sizeof(wszRes[0]) || memcmp(szUrl, wszRes, sizeof(wszRes))) {
-        WARN("Wrong protocol of url: %s\n", debugstr_w(szUrl));
-        IInternetProtocolSink_ReportResult(pOIProtSink, MK_E_SYNTAX, 0, NULL);
-        return MK_E_SYNTAX;
+    if(len < sizeof(wszRes)/sizeof(wszRes[0]) || memcmp(url, wszRes, sizeof(wszRes))) {
+        WARN("Wrong protocol of url: %s\n", debugstr_w(url));
+        IInternetProtocolSink_ReportResult(pOIProtSink, E_INVALIDARG, 0, NULL);
+        heap_free(url);
+        return E_INVALIDARG;
     }
 
-    url_dll = szUrl + sizeof(wszRes)/sizeof(wszRes[0]);
-    if(!(url_file = strchrW(url_dll, '/'))) {
-        WARN("wrong url: %s\n", debugstr_w(szUrl));
+    url_dll = url + sizeof(wszRes)/sizeof(wszRes[0]);
+    if(!(url_file = strrchrW(url_dll, '/'))) {
+        WARN("wrong url: %s\n", debugstr_w(url));
         IInternetProtocolSink_ReportResult(pOIProtSink, MK_E_SYNTAX, 0, NULL);
+        heap_free(url);
         return MK_E_SYNTAX;
     }
 
-    memcpy(dll, url_dll, (url_file-url_dll)*sizeof(WCHAR));
-    dll[url_file-url_dll] = 0;
-
-    hdll = LoadLibraryExW(dll, NULL, LOAD_LIBRARY_AS_DATAFILE);
+    *url_file++ = 0;
+    hdll = LoadLibraryExW(url_dll, NULL, LOAD_LIBRARY_AS_DATAFILE);
     if(!hdll) {
-        WARN("Could not open dll: %s\n", debugstr_w(dll));
-        IInternetProtocolSink_ReportResult(pOIProtSink, HRESULT_FROM_WIN32(GetLastError()), 0, NULL);
-        return HRESULT_FROM_WIN32(GetLastError());
+        if (!(res_type = strrchrW(url_dll, '/'))) {
+            WARN("Could not open dll: %s\n", debugstr_w(url_dll));
+            IInternetProtocolSink_ReportResult(pOIProtSink, HRESULT_FROM_WIN32(GetLastError()), 0, NULL);
+            heap_free(url);
+            return HRESULT_FROM_WIN32(GetLastError());
+        }
+        *res_type++ = 0;
+
+        hdll = LoadLibraryExW(url_dll, NULL, LOAD_LIBRARY_AS_DATAFILE);
+        if(!hdll) {
+            WARN("Could not open dll: %s\n", debugstr_w(url_dll));
+            IInternetProtocolSink_ReportResult(pOIProtSink, HRESULT_FROM_WIN32(GetLastError()), 0, NULL);
+            heap_free(url);
+            return HRESULT_FROM_WIN32(GetLastError());
+        }
     }
 
-    src = FindResourceW(hdll, ++url_file, (LPCWSTR)RT_HTML);
+    TRACE("trying to find resource type %s, name %s\n", debugstr_w(res_type), debugstr_w(url_file));
+
+    src = FindResourceW(hdll, url_file, res_type);
     if(!src) {
-        WARN("Could not find resource: %s\n", debugstr_w(url_file));
-        IInternetProtocolSink_ReportResult(pOIProtSink, HRESULT_FROM_WIN32(GetLastError()), 0, NULL);
-        return HRESULT_FROM_WIN32(GetLastError());
+        LPWSTR endpoint = NULL;
+        DWORD file_id = strtolW(url_file, &endpoint, 10);
+        if(endpoint == url_file+strlenW(url_file))
+            src = FindResourceW(hdll, MAKEINTRESOURCEW(file_id), MAKEINTRESOURCEW(RT_HTML));
+
+        if(!src) {
+            WARN("Could not find resource\n");
+            IInternetProtocolSink_ReportResult(pOIProtSink,
+                    HRESULT_FROM_WIN32(GetLastError()), 0, NULL);
+            heap_free(url);
+            return HRESULT_FROM_WIN32(GetLastError());
+        }
     }
 
     if(This->data) {
         WARN("data already loaded\n");
-        HeapFree(GetProcessHeap(), 0, This->data);
+        heap_free(This->data);
     }
 
     This->data_len = SizeofResource(hdll, src);
-    This->data = HeapAlloc(GetProcessHeap(), 0, This->data_len);
+    This->data = heap_alloc(This->data_len);
     memcpy(This->data, LoadResource(hdll, src), This->data_len);
     This->cur = 0;
 
     FreeLibrary(hdll);
 
+    hres = FindMimeFromData(NULL, url_file, This->data, This->data_len, NULL, 0, &mime, 0);
+    heap_free(url);
+    if(SUCCEEDED(hres)) {
+        IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, mime);
+        CoTaskMemFree(mime);
+    }
+
     IInternetProtocolSink_ReportData(pOIProtSink,
             BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE,
             This->data_len, This->data_len);
@@ -493,7 +706,7 @@ static HRESULT WINAPI ResProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
 
 static HRESULT WINAPI ResProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA* pProtocolData)
 {
-    ResProtocol *This = (ResProtocol*)iface;
+    ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
     FIXME("(%p)->(%p)\n", This, pProtocolData);
     return E_NOTIMPL;
 }
@@ -501,16 +714,16 @@ static HRESULT WINAPI ResProtocol_Continue(IInternetProtocol *iface, PROTOCOLDAT
 static HRESULT WINAPI ResProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
         DWORD dwOptions)
 {
-    ResProtocol *This = (ResProtocol*)iface;
-    FIXME("(%p)->(%08lx %08lx)\n", This, hrReason, dwOptions);
+    ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
+    FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
     return E_NOTIMPL;
 }
 
 static HRESULT WINAPI ResProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
 {
-    ResProtocol *This = (ResProtocol*)iface;
+    ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
 
-    TRACE("(%p)->(%08lx)\n", This, dwOptions);
+    TRACE("(%p)->(%08x)\n", This, dwOptions);
 
     /* test show that we don't have to do anything here */
     return S_OK;
@@ -518,23 +731,23 @@ static HRESULT WINAPI ResProtocol_Terminate(IInternetProtocol *iface, DWORD dwOp
 
 static HRESULT WINAPI ResProtocol_Suspend(IInternetProtocol *iface)
 {
-    ResProtocol *This = (ResProtocol*)iface;
+    ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
     FIXME("(%p)\n", This);
     return E_NOTIMPL;
 }
 
 static HRESULT WINAPI ResProtocol_Resume(IInternetProtocol *iface)
 {
-    ResProtocol *This = (ResProtocol*)iface;
+    ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
     FIXME("(%p)\n", This);
     return E_NOTIMPL;
 }
 
 static HRESULT WINAPI ResProtocol_Read(IInternetProtocol *iface, void* pv, ULONG cb, ULONG* pcbRead)
 {
-    ResProtocol *This = (ResProtocol*)iface;
+    ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
 
-    TRACE("(%p)->(%p %lu %p)\n", This, pv, cb, pcbRead);
+    TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
 
     if(!This->data)
         return E_FAIL;
@@ -544,7 +757,7 @@ static HRESULT WINAPI ResProtocol_Read(IInternetProtocol *iface, void* pv, ULONG
     if(!*pcbRead)
         return S_FALSE;
 
-    memcpy(pv, This->data, *pcbRead);
+    memcpy(pv, This->data+This->cur, *pcbRead);
     This->cur += *pcbRead;
 
     return S_OK;
@@ -553,16 +766,16 @@ static HRESULT WINAPI ResProtocol_Read(IInternetProtocol *iface, void* pv, ULONG
 static HRESULT WINAPI ResProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
         DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
 {
-    ResProtocol *This = (ResProtocol*)iface;
-    FIXME("(%p)->(%ld %ld %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
+    ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
+    FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
     return E_NOTIMPL;
 }
 
 static HRESULT WINAPI ResProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
 {
-    ResProtocol *This = (ResProtocol*)iface;
+    ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
 
-    TRACE("(%p)->(%ld)\n", This, dwOptions);
+    TRACE("(%p)->(%d)\n", This, dwOptions);
 
     /* test show that we don't have to do anything here */
     return S_OK;
@@ -570,7 +783,7 @@ static HRESULT WINAPI ResProtocol_LockRequest(IInternetProtocol *iface, DWORD dw
 
 static HRESULT WINAPI ResProtocol_UnlockRequest(IInternetProtocol *iface)
 {
-    ResProtocol *This = (ResProtocol*)iface;
+    ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
 
     TRACE("(%p)\n", This);
 
@@ -598,21 +811,30 @@ static HRESULT WINAPI ResProtocolFactory_CreateInstance(IClassFactory *iface, IU
         REFIID riid, void **ppv)
 {
     ResProtocol *ret;
-    HRESULT hres;
+    HRESULT hres = S_OK;
 
-    TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
+    TRACE("(%p)->(%p %s %p)\n", iface, pUnkOuter, debugstr_guid(riid), ppv);
 
-    ret = HeapAlloc(GetProcessHeap(), 0, sizeof(ResProtocol));
-    ret->lpInternetProtocolVtbl = &ResProtocolVtbl;
+    ret = heap_alloc(sizeof(ResProtocol));
+    ret->IInternetProtocol_iface.lpVtbl = &ResProtocolVtbl;
     ret->ref = 0;
     ret->data = NULL;
     ret->data_len = 0;
     ret->cur = 0;
-
-    hres = IUnknown_QueryInterface((IUnknown*)ret, riid, ppv);
+    ret->pUnkOuter = pUnkOuter;
+
+    if(pUnkOuter) {
+        ret->ref = 1;
+        if(IsEqualGUID(&IID_IUnknown, riid))
+            *ppv = &ret->IInternetProtocol_iface;
+        else
+            hres = E_FAIL;
+    }else {
+        hres = IInternetProtocol_QueryInterface(&ret->IInternetProtocol_iface, riid, ppv);
+    }
 
     if(FAILED(hres))
-        HeapFree(GetProcessHeap(), 0, ret);
+        heap_free(ret);
 
     return hres;
 }
@@ -621,34 +843,104 @@ static HRESULT WINAPI ResProtocolInfo_ParseUrl(IInternetProtocolInfo *iface, LPC
         PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult,
         DWORD* pcchResult, DWORD dwReserved)
 {
-    FIXME("%p)->(%s %08x %08lx %p %ld %p %ld)\n", iface, debugstr_w(pwzUrl), ParseAction,
+    TRACE("%p)->(%s %d %x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), ParseAction,
             dwParseFlags, pwzResult, cchResult, pcchResult, dwReserved);
-    return E_NOTIMPL;
-}
 
-static HRESULT WINAPI ResProtocolInfo_CombineUrl(IInternetProtocolInfo *iface, LPCWSTR pwzBaseUrl,
-        LPCWSTR pwzRelativeUrl, DWORD dwCombineFlags, LPWSTR pwzResult, DWORD cchResult,
-        DWORD* pcchResult, DWORD dwReserved)
-{
-    FIXME("%p)->(%s %s %08lx %p %ld %p %ld)\n", iface, debugstr_w(pwzBaseUrl), debugstr_w(pwzRelativeUrl),
-            dwCombineFlags, pwzResult, cchResult, pcchResult, dwReserved);
-    return E_NOTIMPL;
-}
+    if(ParseAction == PARSE_SECURITY_URL) {
+        WCHAR file_part[MAX_PATH], full_path[MAX_PATH];
+        WCHAR *ptr;
+        DWORD size, len;
+
+        static const WCHAR wszFile[] = {'f','i','l','e',':','/','/'};
+        static const WCHAR wszRes[] = {'r','e','s',':','/','/'};
+
+        if(strlenW(pwzUrl) <= sizeof(wszRes)/sizeof(WCHAR) || memcmp(pwzUrl, wszRes, sizeof(wszRes)))
+            return E_INVALIDARG;
+
+        ptr = strchrW(pwzUrl + sizeof(wszRes)/sizeof(WCHAR), '/');
+        if(!ptr)
+            return E_INVALIDARG;
+
+        len = ptr - (pwzUrl + sizeof(wszRes)/sizeof(WCHAR));
+        if(len >= sizeof(file_part)/sizeof(WCHAR)) {
+            FIXME("Too long URL\n");
+            return MK_E_SYNTAX;
+        }
+
+        memcpy(file_part, pwzUrl + sizeof(wszRes)/sizeof(WCHAR), len*sizeof(WCHAR));
+        file_part[len] = 0;
+
+        len = SearchPathW(NULL, file_part, NULL, sizeof(full_path)/sizeof(WCHAR), full_path, NULL);
+        if(!len) {
+            HMODULE module;
+
+            /* SearchPath does not work well with winelib files (like our test executable),
+             * so we also try to load the library here */
+            module = LoadLibraryExW(file_part, NULL, LOAD_LIBRARY_AS_DATAFILE);
+            if(!module) {
+                WARN("Could not find file %s\n", debugstr_w(file_part));
+                return MK_E_SYNTAX;
+            }
+
+            len = GetModuleFileNameW(module, full_path, sizeof(full_path)/sizeof(WCHAR));
+            FreeLibrary(module);
+            if(!len)
+                return E_FAIL;
+        }
+
+        size = sizeof(wszFile)/sizeof(WCHAR) + len + 1;
+        if(pcchResult)
+            *pcchResult = size;
+        if(size > cchResult)
+            return S_FALSE;
+
+        memcpy(pwzResult, wszFile, sizeof(wszFile));
+        memcpy(pwzResult + sizeof(wszFile)/sizeof(WCHAR), full_path, (len+1)*sizeof(WCHAR));
+        return S_OK;
+    }
 
-static HRESULT WINAPI ResProtocolInfo_CompareUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl1,
-        LPCWSTR pwzUrl2, DWORD dwCompareFlags)
-{
-    FIXME("%p)->(%s %s %08lx)\n", iface, debugstr_w(pwzUrl1), debugstr_w(pwzUrl2), dwCompareFlags);
-    return E_NOTIMPL;
+    if(ParseAction == PARSE_DOMAIN) {
+        if(!pcchResult)
+            return E_POINTER;
+
+        if(pwzUrl)
+            *pcchResult = strlenW(pwzUrl)+1;
+        else
+            *pcchResult = 1;
+        return E_FAIL;
+    }
+
+    return INET_E_DEFAULT_ACTION;
 }
 
 static HRESULT WINAPI ResProtocolInfo_QueryInfo(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
         QUERYOPTION QueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD* pcbBuf,
         DWORD dwReserved)
 {
-    FIXME("%p)->(%s %08x %08lx %p %ld %p %ld)\n", iface, debugstr_w(pwzUrl), QueryOption, dwQueryFlags, pBuffer,
-            cbBuffer, pcbBuf, dwReserved);
-    return E_NOTIMPL;
+    TRACE("%p)->(%s %08x %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), QueryOption, dwQueryFlags, pBuffer,
+          cbBuffer, pcbBuf, dwReserved);
+
+    switch(QueryOption) {
+    case QUERY_USES_NETWORK:
+        if(!pBuffer || cbBuffer < sizeof(DWORD))
+            return E_FAIL;
+
+        *(DWORD*)pBuffer = 0;
+        if(pcbBuf)
+            *pcbBuf = sizeof(DWORD);
+        break;
+
+    case QUERY_IS_SECURE:
+        FIXME("QUERY_IS_SECURE not supported\n");
+        return E_NOTIMPL;
+    case QUERY_IS_SAFE:
+        FIXME("QUERY_IS_SAFE not supported\n");
+        return E_NOTIMPL;
+    default:
+        return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
+    }
+
+    return S_OK;
 }
 
 static const IInternetProtocolInfoVtbl ResProtocolInfoVtbl = {
@@ -656,8 +948,8 @@ static const IInternetProtocolInfoVtbl ResProtocolInfoVtbl = {
     InternetProtocolInfo_AddRef,
     InternetProtocolInfo_Release,
     ResProtocolInfo_ParseUrl,
-    ResProtocolInfo_CombineUrl,
-    ResProtocolInfo_CompareUrl,
+    InternetProtocolInfo_CombineUrl,
+    InternetProtocolInfo_CompareUrl,
     ResProtocolInfo_QueryInfo
 };
 
@@ -670,8 +962,91 @@ static const IClassFactoryVtbl ResProtocolFactoryVtbl = {
 };
 
 static ProtocolFactory ResProtocolFactory = {
-    &ResProtocolInfoVtbl,
-    &ResProtocolFactoryVtbl
+    { &ResProtocolInfoVtbl },
+    { &ResProtocolFactoryVtbl }
+};
+
+/********************************************************************
+ * JSProtocol implementation
+ */
+
+static HRESULT WINAPI JSProtocolFactory_CreateInstance(IClassFactory *iface, IUnknown *pUnkOuter,
+        REFIID riid, void **ppv)
+{
+    FIXME("(%p)->(%p %s %p)\n", iface, pUnkOuter, debugstr_guid(riid), ppv);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI JSProtocolInfo_ParseUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
+        PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult,
+        DWORD* pcchResult, DWORD dwReserved)
+{
+    TRACE("%p)->(%s %d %x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), ParseAction,
+          dwParseFlags, pwzResult, cchResult, pcchResult, dwReserved);
+
+    switch(ParseAction) {
+    case PARSE_SECURITY_URL:
+        FIXME("PARSE_SECURITY_URL\n");
+        return E_NOTIMPL;
+    case PARSE_DOMAIN:
+        FIXME("PARSE_DOMAIN\n");
+        return E_NOTIMPL;
+    default:
+        return INET_E_DEFAULT_ACTION;
+    }
+
+    return S_OK;
+}
+
+static HRESULT WINAPI JSProtocolInfo_QueryInfo(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
+        QUERYOPTION QueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD* pcbBuf,
+        DWORD dwReserved)
+{
+    TRACE("%p)->(%s %08x %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), QueryOption, dwQueryFlags, pBuffer,
+          cbBuffer, pcbBuf, dwReserved);
+
+    switch(QueryOption) {
+    case QUERY_USES_NETWORK:
+        if(!pBuffer || cbBuffer < sizeof(DWORD))
+            return E_FAIL;
+
+        *(DWORD*)pBuffer = 0;
+        if(pcbBuf)
+            *pcbBuf = sizeof(DWORD);
+        break;
+
+    case QUERY_IS_SECURE:
+        FIXME("QUERY_IS_SECURE not supported\n");
+        return E_NOTIMPL;
+
+    default:
+        return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
+    }
+
+    return S_OK;
+}
+
+static const IInternetProtocolInfoVtbl JSProtocolInfoVtbl = {
+    InternetProtocolInfo_QueryInterface,
+    InternetProtocolInfo_AddRef,
+    InternetProtocolInfo_Release,
+    JSProtocolInfo_ParseUrl,
+    InternetProtocolInfo_CombineUrl,
+    InternetProtocolInfo_CompareUrl,
+    JSProtocolInfo_QueryInfo
+};
+
+static const IClassFactoryVtbl JSProtocolFactoryVtbl = {
+    ClassFactory_QueryInterface,
+    ClassFactory_AddRef,
+    ClassFactory_Release,
+    JSProtocolFactory_CreateInstance,
+    ClassFactory_LockServer
+};
+
+static ProtocolFactory JSProtocolFactory = {
+    { &JSProtocolInfoVtbl },
+    { &JSProtocolFactoryVtbl }
 };
 
 HRESULT ProtocolFactory_Create(REFCLSID rclsid, REFIID riid, void **ppv)
@@ -682,11 +1057,13 @@ HRESULT ProtocolFactory_Create(REFCLSID rclsid, REFIID riid, void **ppv)
         cf = &AboutProtocolFactory;
     else if(IsEqualGUID(&CLSID_ResProtocol, rclsid))
         cf = &ResProtocolFactory;
+    else if(IsEqualGUID(&CLSID_JSProtocol, rclsid))
+        cf = &JSProtocolFactory;
 
     if(!cf) {
         FIXME("not implemented protocol %s\n", debugstr_guid(rclsid));
         return CLASS_E_CLASSNOTAVAILABLE;
     }
-
-    return IUnknown_QueryInterface((IUnknown*)cf, riid, ppv);
+    return IInternetProtocolInfo_QueryInterface(&cf->IInternetProtocolInfo_iface, riid, ppv);
 }