URLMON: Added MapUrlToZone and GetSecurityId implementation

Jacek Caban jack at itma.pwr.wroc.pl
Sat Sep 10 08:19:27 CDT 2005


Changelog:
    Added MapUrlToZone and GetSecurityId implementation
-------------- next part --------------
Index: dlls/urlmon/sec_mgr.c
===================================================================
RCS file: /home/wine/wine/dlls/urlmon/sec_mgr.c,v
retrieving revision 1.9
diff -u -p -r1.9 sec_mgr.c
--- dlls/urlmon/sec_mgr.c	7 Sep 2005 09:23:18 -0000	1.9
+++ dlls/urlmon/sec_mgr.c	10 Sep 2005 13:13:01 -0000
@@ -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"
@@ -35,6 +36,70 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
 
+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 HRESULT get_zone(LPCWSTR url, DWORD *pzone)
+{
+    static const WCHAR wszFile[] = {'f','i','l','e',0};
+
+    LPCWSTR ptr;
+    WCHAR schema[64];
+    DWORD res, size;
+    HKEY hkey;
+    HRESULT hres;
+
+    hres = CoInternetParseUrl(url, PARSE_SCHEMA, 0, schema, sizeof(schema)/sizeof(WCHAR), &size, 0);
+    if(FAILED(hres))
+        return hres;
+    if(!*schema)
+        return E_INVALIDARG;
+    
+    /* file protocol is a special case */
+    if(!strcmpW(schema, wszFile)) {
+        ptr = url + sizeof(wszFile)/sizeof(WCHAR);
+        while(*ptr == '/')
+            ptr++;
+        if(strchrW(ptr, '\\')) {
+            *pzone = 0;
+            return S_OK;
+        }
+    }
+
+    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)pzone, &size);
+    if(res == ERROR_SUCCESS)
+        return S_OK;
+
+    WARN("domains and regions are not yet implemented\n");
+
+    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)pzone, &size);
+    if(res == ERROR_SUCCESS)
+        return S_OK;
+
+    *pzone = 3;
+    return S_OK;
+}
+
 /***********************************************************************
  *           InternetSecurityManager implementation
  *
@@ -169,6 +234,9 @@ static HRESULT WINAPI SecManagerImpl_Map
                                                   DWORD dwFlags)
 {
     SecManagerImpl *This = SECMGR_THIS(iface);
+    int len;
+    LPWSTR securl;
+    DWORD size;
     HRESULT hres;
 
     TRACE("(%p)->(%s %p %08lx)\n", iface, debugstr_w(pwszUrl), pdwZone, dwFlags);
@@ -180,8 +248,21 @@ static HRESULT WINAPI SecManagerImpl_Map
             return hres;
     }
 
-    FIXME("Default action is not implemented\n");
-    return E_NOTIMPL;
+    if(!pwszUrl)
+        return E_INVALIDARG;
+
+    len = strlenW(pwszUrl)+1;
+    securl = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
+
+    hres = CoInternetParseUrl(pwszUrl, PARSE_SECURITY_URL, 0, securl, len, &size, 0);
+    if(SUCCEEDED(hres))
+        hres = get_zone(securl, pdwZone);
+    else
+        hres = get_zone(pwszUrl, pdwZone);
+
+    HeapFree(GetProcessHeap(), 0, securl);
+
+    return hres;
 }
 
 static HRESULT WINAPI SecManagerImpl_GetSecurityId(IInternetSecurityManager *iface, 
@@ -190,8 +271,13 @@ static HRESULT WINAPI SecManagerImpl_Get
                                                    DWORD_PTR dwReserved)
 {
     SecManagerImpl *This = SECMGR_THIS(iface);
+    int len;
+    LPWSTR buf, ptr, ptr2;
+    DWORD size, zone;
     HRESULT hres;
 
+    static const WCHAR wszFile[] = {'f','i','l','e',':'};
+
     TRACE("(%p)->(%s %p %p %08lx)\n", iface, debugstr_w(pwszUrl), pbSecurityId, pcbSecurityId,
           dwReserved);
 
@@ -202,8 +288,63 @@ static HRESULT WINAPI SecManagerImpl_Get
             return hres;
     }
 
-    FIXME("Default action is not implemented\n");
-    return E_NOTIMPL;
+    if(!pwszUrl || !pbSecurityId || !pcbSecurityId)
+        return E_INVALIDARG;
+
+    if(dwReserved)
+        FIXME("dwReserved is not supported\n");
+
+    len = strlenW(pwszUrl)+1;
+    buf = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
+
+    hres = CoInternetParseUrl(pwszUrl, PARSE_SECURITY_URL, 0, buf, len, &size, 0);
+    if(FAILED(hres))
+        memcpy(buf, pwszUrl, len*sizeof(WCHAR));
+
+    hres = get_zone(buf, &zone);
+    if(FAILED(hres)) {
+        HeapFree(GetProcessHeap(), 0, buf);
+        return hres;
+    }
+
+    /* file protocol is a special case */
+    if(strlenW(pwszUrl) >= sizeof(wszFile)/sizeof(WCHAR)
+            && !memcmp(pwszUrl, wszFile, sizeof(wszFile))
+            && strchrW(pwszUrl, '\\')) {
+        static const BYTE wszFileSecId[] = {'f','i','l','e',':',0,0,0,0};
+
+        if(*pcbSecurityId < sizeof(wszFileSecId))
+            return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
+
+        memcpy(pbSecurityId, wszFileSecId, sizeof(wszFileSecId));
+        *pcbSecurityId = sizeof(wszFileSecId);
+        return S_OK;
+    }
+
+    ptr = strchrW(buf, ':');
+    ptr2 = ++ptr;
+    while(*ptr2 == '/')
+        ptr2++;
+    if(ptr2 != ptr)
+        memmove(ptr, ptr2, (strlenW(ptr2)+1)*sizeof(WCHAR));
+
+    ptr = strchrW(ptr, '/');
+    if(ptr)
+        *ptr = 0;
+
+    len = WideCharToMultiByte(CP_ACP, 0, buf, -1, NULL, 0, NULL, NULL)-1;
+
+    if(len+sizeof(DWORD) > *pcbSecurityId)
+        return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
+
+    WideCharToMultiByte(CP_ACP, 0, buf, -1, pbSecurityId, -1, NULL, NULL);
+    HeapFree(GetProcessHeap(), 0, buf);
+
+    *(DWORD*)(pbSecurityId+len) = zone;
+
+    *pcbSecurityId = len+sizeof(DWORD);
+
+    return S_OK;
 }
 
 
Index: dlls/urlmon/urlmon.inf
===================================================================
RCS file: /home/wine/wine/dlls/urlmon/urlmon.inf,v
retrieving revision 1.1
diff -u -p -r1.1 urlmon.inf
--- dlls/urlmon/urlmon.inf	5 Jul 2005 14:06:43 -0000	1.1
+++ dlls/urlmon/urlmon.inf	10 Sep 2005 13:13:01 -0000
@@ -3,11 +3,11 @@ Signature="$CHICAGO$"
 
 
 [RegisterDll]
-AddReg=Protocols.Reg
+AddReg=Protocols.Reg, ZoneMap.Reg
 
 
 [UnregisterDll]
-DelReg=Protocols.Reg
+DelReg=Protocols.Reg, ZoneMap.Reg
 
 
 [Protocols.Reg]
@@ -27,3 +27,38 @@ HKCR,"PROTOCOLS\Handler\https",,,"https:
 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%",,,
+
+
+[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"
Index: dlls/urlmon/tests/misc.c
===================================================================
RCS file: /home/wine/wine/dlls/urlmon/tests/misc.c,v
retrieving revision 1.4
diff -u -p -r1.4 misc.c
--- dlls/urlmon/tests/misc.c	9 Sep 2005 09:08:56 -0000	1.4
+++ dlls/urlmon/tests/misc.c	10 Sep 2005 13:13:01 -0000
@@ -207,7 +207,10 @@ static const WCHAR url1[] = {'r','e','s'
 static const WCHAR url2[] = {'i','n','d','e','x','.','h','t','m',0};
 static const WCHAR url3[] = {'f','i','l','e',':','c',':','\\','I','n','d','e','x','.','h','t','m',0};
 static const WCHAR url4[] = {'f','i','l','e',':','s','o','m','e','%','2','0','f','i','l','e',
-        '%','2','E','j','p','g',0};
+        '%','2','e','j','p','g',0};
+static const WCHAR url5[] = {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q',
+        '.','o','r','g',0};
+static const WCHAR url6[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
 
 static const WCHAR url4e[] = {'f','i','l','e',':','s','o','m','e',' ','f','i','l','e',
         '.','j','p','g',0};
@@ -217,10 +220,13 @@ static const WCHAR path4[] = {'s','o','m
 
 static const WCHAR wszRes[] = {'r','e','s',0};
 static const WCHAR wszFile[] = {'f','i','l','e',0};
+static const WCHAR wszHttp[] = {'h','t','t','p',0};
+static const WCHAR wszAbout[] = {'a','b','o','u','t',0};
 static const WCHAR wszEmpty[] = {0};
 
 struct parse_test {
     LPCWSTR url;
+    HRESULT secur_hres;
     LPCWSTR encoded_url;
     HRESULT path_hres;
     LPCWSTR path;
@@ -228,10 +234,12 @@ struct parse_test {
 };
 
 static const struct parse_test parse_tests[] = {
-    {url1, url1,  E_INVALIDARG, NULL, wszRes},
-    {url2, url2,  E_INVALIDARG, NULL, wszEmpty},
-    {url3, url3,  S_OK, path3,        wszFile},
-    {url4, url4e, S_OK, path4,        wszFile}
+    {url1, S_OK,   url1,  E_INVALIDARG, NULL, wszRes},
+    {url2, E_FAIL, url2,  E_INVALIDARG, NULL, wszEmpty},
+    {url3, E_FAIL, url3,  S_OK, path3,        wszFile},
+    {url4, E_FAIL, url4e, S_OK, path4,        wszFile},
+    {url5, E_FAIL, url5,  E_INVALIDARG, NULL, wszHttp},
+    {url6, S_OK,   url6,  E_INVALIDARG, NULL, wszAbout}
 };
 
 static void test_CoInternetParseUrl(void)
@@ -249,6 +257,12 @@ static void test_CoInternetParseUrl(void
 
     for(i=0; i < sizeof(parse_tests)/sizeof(parse_tests[0]); i++) {
         memset(buf, 0xf0, sizeof(buf));
+        hres = CoInternetParseUrl(parse_tests[i].url, PARSE_SECURITY_URL, 0, buf,
+                sizeof(buf)/sizeof(WCHAR), &size, 0);
+        ok(hres == parse_tests[i].secur_hres, "[%d] security url failed: %08lx, expected %08lx\n",
+                i, hres, parse_tests[i].secur_hres);
+
+        memset(buf, 0xf0, sizeof(buf));
         hres = CoInternetParseUrl(parse_tests[i].url, PARSE_ENCODE, 0, buf,
                 sizeof(buf)/sizeof(WCHAR), &size, 0);
         ok(hres == S_OK, "[%d] encoding failed: %08lx\n", i, hres);
@@ -258,7 +272,8 @@ static void test_CoInternetParseUrl(void
         memset(buf, 0xf0, sizeof(buf));
         hres = CoInternetParseUrl(parse_tests[i].url, PARSE_PATH_FROM_URL, 0, buf,
                 sizeof(buf)/sizeof(WCHAR), &size, 0);
-        ok(hres == parse_tests[i].path_hres, "[%d] path failed: %08lx\n", i, hres);
+        ok(hres == parse_tests[i].path_hres, "[%d] path failed: %08lx, expected %08lx\n",
+                i, hres, parse_tests[i].path_hres);
         if(parse_tests[i].path) {
             ok(size == lstrlenW(parse_tests[i].path), "[%d] wrong size\n", i);
             ok(!lstrcmpW(parse_tests[i].path, buf), "[%d] wrong path\n", i);
@@ -273,9 +288,89 @@ static void test_CoInternetParseUrl(void
     }
 }
 
+struct secmgr_test {
+    LPCWSTR url;
+    HRESULT hres;
+    DWORD zone;
+    DWORD size;
+    const BYTE *secid;
+};
+
+static const BYTE secid1[] = {'f','i','l','e',':',0,0,0,0};
+static const BYTE secid4[] ={'f','i','l','e',':','s','o','m','e','%','2','0','f','i',
+    'l','e','%','2','e','j','p','g',3,0,0,0};
+static const BYTE secid5[] = {'h','t','t','p',':','w','w','w','.','w','i','n','e','h','q',
+    '.','o','r','g',3,0,0,0};
+static const BYTE secid6[] = {'a','b','o','u','t',':','b','l','a','n','k',3,0,0,0};
+
+static const struct secmgr_test secmgr_tests[]  = {
+    /* {url1, S_OK, 0, sizeof(secid1), secid1}, FIXME */
+    {url2, E_INVALIDARG, 0xffff, 0, NULL},
+    {url3, S_OK, 0, sizeof(secid1), secid1},
+    {url4, S_OK, 3, sizeof(secid4), secid4},
+    {url5, S_OK, 3, sizeof(secid5), secid5},
+    {url6, S_OK, 3, sizeof(secid6), secid6}
+};
+
+static void test_SecurityManager(void)
+{
+    IInternetSecurityManager *secmgr;
+    BYTE buf[512];
+    DWORD size, zone;
+    int i;
+    HRESULT hres;
+
+    hres = CoInternetCreateSecurityManager(NULL, &secmgr, 0);
+    ok(hres == S_OK, "CoInternetCreateSecurityManager failed: %08lx\n", hres);
+    if(FAILED(hres))
+        return;
+
+    hres = IInternetSecurityManager_MapUrlToZone(secmgr, NULL, &zone, 0);
+    ok(hres == E_INVALIDARG, "MapUrlToZone failed: %08lx, expected E_INVALIDARG\n", hres);
+
+    size = sizeof(buf);
+    hres = IInternetSecurityManager_GetSecurityId(secmgr, NULL, buf, &size, 0);
+    ok(hres == E_INVALIDARG, "GetSecurityId failed: %08lx, expected E_INVALIDARG\n", hres);
+    hres = IInternetSecurityManager_GetSecurityId(secmgr, secmgr_tests[1].url, NULL, &size, 0);
+    ok(hres == E_INVALIDARG, "GetSecurityId failed: %08lx, expected E_INVALIDARG\n", hres);
+    hres = IInternetSecurityManager_GetSecurityId(secmgr, secmgr_tests[1].url, buf, NULL, 0);
+    ok(hres == E_INVALIDARG, "GetSecurityId failed: %08lx, expected E_INVALIDARG\n", hres);
+
+    size = 4;
+    hres = IInternetSecurityManager_GetSecurityId(secmgr, secmgr_tests[1].url, buf, &size, 0);
+    ok(hres == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER),
+            "GetSecurityId failed: %08lx, expected HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)\n",
+            hres);
+
+    for(i=0; i < sizeof(secmgr_tests)/sizeof(secmgr_tests[0]); i++) {
+        hres = IInternetSecurityManager_MapUrlToZone(secmgr, secmgr_tests[i].url, &zone, 0);
+        if(secmgr_tests[i].zone != 0xffff) {
+            ok(hres == secmgr_tests[i].hres, "[%d] MapUrlToZone failed: %08lx, expected %08lx\n",
+                    i, hres, secmgr_tests[i].hres);
+            ok(zone == secmgr_tests[i].zone, "[%d] zone=%ld, expected %ld\n",
+                    i, zone, secmgr_tests[i].zone);
+        }
+
+        size = sizeof(buf);
+        memset(buf, 0xf0, sizeof(buf));
+        hres = IInternetSecurityManager_GetSecurityId(secmgr, secmgr_tests[i].url,
+                buf, &size, 0);
+        ok(hres == secmgr_tests[i].hres, "[%d] GetSecurityId failed: %08lx, expected %08lx\n",
+                i, hres, secmgr_tests[i].hres);
+        if(secmgr_tests[i].secid) {
+            ok(size == secmgr_tests[i].size, "[%d] size=%ld, expected %ld\n",
+                    i, size, secmgr_tests[i].size);
+            ok(!memcmp(buf, secmgr_tests[i].secid, size), "[%d] wrong secid\n", i);
+        }
+    }
+
+    IInternetSecurityManager_Release(secmgr);
+}
+
 START_TEST(misc)
 {
     test_CreateFormatEnum();
     test_RegisterFormatEnumerator();
     test_CoInternetParseUrl();
+    test_SecurityManager();
 }


More information about the wine-patches mailing list