git.oblomov.eu Git - wine/blob - dlls/urlmon/tests/sec_mgr.c

   1 /*
   2  * Copyright 2005-2006 Jacek Caban for CodeWeavers
   3  * Copyright 2009 Detlef Riekenberg
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #define COBJMACROS
  21 #define CONST_VTABLE
  22 #define NONAMELESSUNION
  23
  24 /* needed for IInternetZoneManagerEx2 */
  25 #define _WIN32_IE 0x0700
  26
  27 #include <wine/test.h>
  28 #include <stdarg.h>
  29 #include <stddef.h>
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "ole2.h"
  34 #include "urlmon.h"
  35
  36 #include "initguid.h"
  37
  38 static const WCHAR url1[] = {'r','e','s',':','/','/','m','s','h','t','m','l','.','d','l','l',
  39         '/','b','l','a','n','k','.','h','t','m',0};
  40 static const WCHAR url2[] = {'i','n','d','e','x','.','h','t','m',0};
  41 static const WCHAR url3[] = {'f','i','l','e',':','/','/','c',':','\\','I','n','d','e','x','.','h','t','m',0};
  42 static const WCHAR url4[] = {'f','i','l','e',':','s','o','m','e','%','2','0','f','i','l','e',
  43         '%','2','e','j','p','g',0};
  44 static const WCHAR url5[] = {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q',
  45         '.','o','r','g',0};
  46 static const WCHAR url6[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
  47 static const WCHAR url7[] = {'f','t','p',':','/','/','w','i','n','e','h','q','.','o','r','g','/',
  48         'f','i','l','e','.','t','e','s','t',0};
  49 static const WCHAR url8[] = {'t','e','s','t',':','1','2','3','a','b','c',0};
  50 static const WCHAR url9[] =
  51     {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q','.','o','r','g',
  52      '/','s','i','t','e','/','a','b','o','u','t',0};
  53 static const WCHAR url10[] = {'f','i','l','e',':','/','/','s','o','m','e','%','2','0','f','i','l','e',
  54         '.','j','p','g',0};
  55
  56 static const WCHAR url4e[] = {'f','i','l','e',':','s','o','m','e',' ','f','i','l','e',
  57         '.','j','p','g',0};
  58
  59
  60 static const BYTE secid1[] = {'f','i','l','e',':',0,0,0,0};
  61 static const BYTE secid5[] = {'h','t','t','p',':','w','w','w','.','w','i','n','e','h','q',
  62     '.','o','r','g',3,0,0,0};
  63 static const BYTE secid6[] = {'a','b','o','u','t',':','b','l','a','n','k',3,0,0,0};
  64 static const BYTE secid7[] = {'f','t','p',':','w','i','n','e','h','q','.','o','r','g',
  65                               3,0,0,0};
  66 static const BYTE secid10[] =
  67     {'f','i','l','e',':','s','o','m','e','%','2','0','f','i','l','e','.','j','p','g',3,0,0,0};
  68 static const BYTE secid10_2[] =
  69     {'f','i','l','e',':','s','o','m','e',' ','f','i','l','e','.','j','p','g',3,0,0,0};
  70
  71 static struct secmgr_test {
  72     LPCWSTR url;
  73     DWORD zone;
  74     HRESULT zone_hres;
  75     DWORD secid_size;
  76     const BYTE *secid;
  77     HRESULT secid_hres;
  78 } secmgr_tests[] = {
  79     {url1, 0,   S_OK, sizeof(secid1), secid1, S_OK},
  80     {url2, 100, 0x80041001, 0, NULL, E_INVALIDARG},
  81     {url3, 0,   S_OK, sizeof(secid1), secid1, S_OK},
  82     {url5, 3,   S_OK, sizeof(secid5), secid5, S_OK},
  83     {url6, 3,   S_OK, sizeof(secid6), secid6, S_OK},
  84     {url7, 3,   S_OK, sizeof(secid7), secid7, S_OK}
  85 };
  86
  87 static void test_SecurityManager(void)
  88 {
  89     int i;
  90     IInternetSecurityManager *secmgr = NULL;
  91     BYTE buf[512];
  92     DWORD zone, size, policy;
  93     HRESULT hres;
  94
  95     hres = CoInternetCreateSecurityManager(NULL, &secmgr, 0);
  96     ok(hres == S_OK, "CoInternetCreateSecurityManager failed: %08x\n", hres);
  97     if(FAILED(hres))
  98         return;
  99
 100     for(i=0; i < sizeof(secmgr_tests)/sizeof(secmgr_tests[0]); i++) {
 101         zone = 100;
 102         hres = IInternetSecurityManager_MapUrlToZone(secmgr, secmgr_tests[i].url,
 103                                                      &zone, 0);
 104         ok(hres == secmgr_tests[i].zone_hres /* IE <=6 */
 105            || (FAILED(secmgr_tests[i].zone_hres) && hres == E_INVALIDARG), /* IE7 */
 106            "[%d] MapUrlToZone failed: %08x, expected %08x\n",
 107                 i, hres, secmgr_tests[i].zone_hres);
 108         if(SUCCEEDED(hres))
 109             ok(zone == secmgr_tests[i].zone, "[%d] zone=%d, expected %d\n", i, zone,
 110                secmgr_tests[i].zone);
 111         else
 112             ok(zone == secmgr_tests[i].zone || zone == -1, "[%d] zone=%d\n", i, zone);
 113
 114         size = sizeof(buf);
 115         memset(buf, 0xf0, sizeof(buf));
 116         hres = IInternetSecurityManager_GetSecurityId(secmgr, secmgr_tests[i].url,
 117                 buf, &size, 0);
 118         ok(hres == secmgr_tests[i].secid_hres,
 119            "[%d] GetSecurityId failed: %08x, expected %08x\n",
 120            i, hres, secmgr_tests[i].secid_hres);
 121         if(secmgr_tests[i].secid) {
 122             ok(size == secmgr_tests[i].secid_size, "[%d] size=%d, expected %d\n",
 123                     i, size, secmgr_tests[i].secid_size);
 124             ok(!memcmp(buf, secmgr_tests[i].secid, size), "[%d] wrong secid\n", i);
 125         }
 126     }
 127
 128     zone = 100;
 129     hres = IInternetSecurityManager_MapUrlToZone(secmgr, url10, &zone, 0);
 130     ok(hres == S_OK, "MapUrlToZone failed: %08x, expected S_OK\n", hres);
 131     ok(zone == 3, "zone=%d, expected 3\n", zone);
 132
 133     /* win2k3 translates %20 into a space */
 134     size = sizeof(buf);
 135     memset(buf, 0xf0, sizeof(buf));
 136     hres = IInternetSecurityManager_GetSecurityId(secmgr, url10, buf, &size, 0);
 137     ok(hres == S_OK, "GetSecurityId failed: %08x, expected S_OK\n", hres);
 138     ok(size == sizeof(secid10) ||
 139        size == sizeof(secid10_2), /* win2k3 */
 140        "size=%d\n", size);
 141     ok(!memcmp(buf, secid10, size) ||
 142        !memcmp(buf, secid10_2, size), /* win2k3 */
 143        "wrong secid\n");
 144
 145     zone = 100;
 146     hres = IInternetSecurityManager_MapUrlToZone(secmgr, NULL, &zone, 0);
 147     ok(hres == E_INVALIDARG, "MapUrlToZone failed: %08x, expected E_INVALIDARG\n", hres);
 148     ok(zone == 100 || zone == -1, "zone=%d\n", zone);
 149
 150     size = sizeof(buf);
 151     hres = IInternetSecurityManager_GetSecurityId(secmgr, NULL, buf, &size, 0);
 152     ok(hres == E_INVALIDARG,
 153        "GetSecurityId failed: %08x, expected E_INVALIDARG\n", hres);
 154     hres = IInternetSecurityManager_GetSecurityId(secmgr, secmgr_tests[1].url,
 155                                                   NULL, &size, 0);
 156     ok(hres == E_INVALIDARG,
 157        "GetSecurityId failed: %08x, expected E_INVALIDARG\n", hres);
 158     hres = IInternetSecurityManager_GetSecurityId(secmgr, secmgr_tests[1].url,
 159                                                   buf, NULL, 0);
 160     ok(hres == E_INVALIDARG,
 161        "GetSecurityId failed: %08x, expected E_INVALIDARG\n", hres);
 162
 163     hres = IInternetSecurityManager_ProcessUrlAction(secmgr, NULL, URLACTION_SCRIPT_RUN, (BYTE*)&policy,
 164             sizeof(WCHAR), NULL, 0, 0, 0);
 165     ok(hres == E_INVALIDARG, "ProcessUrlAction failed: %08x, expected E_INVALIDARG\n", hres);
 166
 167     IInternetSecurityManager_Release(secmgr);
 168 }
 169
 170 /* Check if Internet Explorer is configured to run in "Enhanced Security Configuration" (aka hardened mode) */
 171 /* Note: this code is duplicated in dlls/mshtml/tests/mshtml_test.h and dlls/urlmon/tests/sec_mgr.c */
 172 static BOOL is_ie_hardened(void)
 173 {
 174     HKEY zone_map;
 175     DWORD ie_harden, type, size;
 176
 177     ie_harden = 0;
 178     if(RegOpenKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\ZoneMap",
 179                     0, KEY_QUERY_VALUE, &zone_map) == ERROR_SUCCESS) {
 180         size = sizeof(DWORD);
 181         if (RegQueryValueExA(zone_map, "IEHarden", NULL, &type, (LPBYTE) &ie_harden, &size) != ERROR_SUCCESS ||
 182             type != REG_DWORD) {
 183             ie_harden = 0;
 184         }
 185         RegCloseKey(zone_map);
 186     }
 187
 188     return ie_harden != 0;
 189 }
 190
 191 static void test_url_action(IInternetSecurityManager *secmgr, IInternetZoneManager *zonemgr, DWORD action)
 192 {
 193     DWORD res, size, policy, reg_policy;
 194     char buf[10];
 195     HKEY hkey;
 196     HRESULT hres;
 197
 198     /* FIXME: HKEY_CURRENT_USER is most of the time the default but this can be changed on a system.
 199      * The test should be changed to cope with that, if need be.
 200      */
 201     res = RegOpenKeyA(HKEY_CURRENT_USER,
 202             "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\Zones\\3", &hkey);
 203     if(res != ERROR_SUCCESS) {
 204         ok(0, "Could not open zone key\n");
 205         return;
 206     }
 207
 208     wsprintf(buf, "%X", action);
 209     size = sizeof(DWORD);
 210     res = RegQueryValueExA(hkey, buf, NULL, NULL, (BYTE*)&reg_policy, &size);
 211     RegCloseKey(hkey);
 212     if(res != ERROR_SUCCESS || size != sizeof(DWORD)) {
 213         policy = 0xdeadbeef;
 214         hres = IInternetSecurityManager_ProcessUrlAction(secmgr, url9, action, (BYTE*)&policy,
 215                 sizeof(WCHAR), NULL, 0, 0, 0);
 216         ok(hres == E_FAIL || broken(hres == HRESULT_FROM_WIN32(ERROR_NOT_FOUND)),
 217             "(0x%x) got 0x%x (expected E_FAIL)\n", action, hres);
 218         ok(policy == 0xdeadbeef, "(%x) policy=%x\n", action, policy);
 219
 220         policy = 0xdeadbeef;
 221         hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 3, action, (BYTE*)&policy,
 222                 sizeof(DWORD), URLZONEREG_DEFAULT);
 223         ok(hres == E_FAIL || broken(hres == HRESULT_FROM_WIN32(ERROR_NOT_FOUND)),
 224             "(0x%x) got 0x%x (expected E_FAIL)\n", action, hres);
 225         ok(policy == 0xdeadbeef, "(%x) policy=%x\n", action, policy);
 226         return;
 227     }
 228
 229     policy = 0xdeadbeef;
 230     hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 3, action, (BYTE*)&policy,
 231             sizeof(DWORD), URLZONEREG_DEFAULT);
 232     ok(hres == S_OK, "GetZoneActionPolicy failed: %08x\n", hres);
 233     ok(policy == reg_policy, "(%x) policy=%x, expected %x\n", action, policy, reg_policy);
 234
 235     if(policy != URLPOLICY_QUERY) {
 236         if(winetest_interactive || ! is_ie_hardened()) {
 237             policy = 0xdeadbeef;
 238             hres = IInternetSecurityManager_ProcessUrlAction(secmgr, url9, action, (BYTE*)&policy,
 239                     sizeof(WCHAR), NULL, 0, 0, 0);
 240             if(reg_policy == URLPOLICY_DISALLOW)
 241                 ok(hres == S_FALSE, "ProcessUrlAction(%x) failed: %08x, expected S_FALSE\n", action, hres);
 242             else
 243                 ok(hres == S_OK, "ProcessUrlAction(%x) failed: %08x\n", action, hres);
 244             ok(policy == 0xdeadbeef, "(%x) policy=%x\n", action, policy);
 245         }else {
 246             skip("IE running in Enhanced Security Configuration\n");
 247         }
 248     }
 249 }
 250
 251 static void test_special_url_action(IInternetSecurityManager *secmgr, IInternetZoneManager *zonemgr, DWORD action)
 252 {
 253     DWORD policy;
 254     HRESULT hres;
 255
 256     policy = 0xdeadbeef;
 257     hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 3, action, (BYTE*)&policy,
 258             sizeof(DWORD), URLZONEREG_DEFAULT);
 259     ok(hres == S_OK, "GetZoneActionPolicy failed: %08x\n", hres);
 260     ok(policy == URLPOLICY_DISALLOW, "(%x) policy=%x, expected URLPOLICY_DISALLOW\n", action, policy);
 261
 262     policy = 0xdeadbeef;
 263     hres = IInternetSecurityManager_ProcessUrlAction(secmgr, url1, action, (BYTE*)&policy,
 264             sizeof(WCHAR), NULL, 0, 0, 0);
 265     ok(hres == S_FALSE, "ProcessUrlAction(%x) failed: %08x, expected S_FALSE\n", action, hres);
 266 }
 267
 268 static void test_polices(void)
 269 {
 270     IInternetZoneManager *zonemgr = NULL;
 271     IInternetSecurityManager *secmgr = NULL;
 272     HRESULT hres;
 273
 274     hres = CoInternetCreateSecurityManager(NULL, &secmgr, 0);
 275     ok(hres == S_OK, "CoInternetCreateSecurityManager failed: %08x\n", hres);
 276     hres = CoInternetCreateZoneManager(NULL, &zonemgr, 0);
 277     ok(hres == S_OK, "CoInternetCreateZoneManager failed: %08x\n", hres);
 278
 279     test_url_action(secmgr, zonemgr, URLACTION_SCRIPT_RUN);
 280     test_url_action(secmgr, zonemgr, URLACTION_ACTIVEX_OVERRIDE_OBJECT_SAFETY);
 281     test_url_action(secmgr, zonemgr, URLACTION_CHANNEL_SOFTDIST_PERMISSIONS);
 282     test_url_action(secmgr, zonemgr, 0xdeadbeef);
 283
 284     test_special_url_action(secmgr, zonemgr, URLACTION_SCRIPT_OVERRIDE_SAFETY);
 285
 286     IInternetSecurityManager_Release(secmgr);
 287     IInternetZoneManager_Release(zonemgr);
 288 }
 289
 290 static void test_CoInternetCreateZoneManager(void)
 291 {
 292     IInternetZoneManager *zonemgr = NULL;
 293     IUnknown *punk = NULL;
 294     HRESULT hr;
 295
 296     hr = CoInternetCreateZoneManager(NULL, &zonemgr, 0);
 297     ok(hr == S_OK, "CoInternetCreateZoneManager result: 0x%x\n", hr);
 298     if (FAILED(hr))
 299         return;
 300
 301     hr = IInternetZoneManager_QueryInterface(zonemgr, &IID_IUnknown, (void **) &punk);
 302     ok(SUCCEEDED(hr), "got 0x%x with %p (expected Success)\n", hr, punk);
 303     if (punk)
 304         IUnknown_Release(punk);
 305
 306     hr = IInternetZoneManager_QueryInterface(zonemgr, &IID_IInternetZoneManager, (void **) &punk);
 307     ok(SUCCEEDED(hr), "got 0x%x with %p (expected Success)\n", hr, punk);
 308     if (punk)
 309         IUnknown_Release(punk);
 310
 311
 312     hr = IInternetZoneManager_QueryInterface(zonemgr, &IID_IInternetZoneManagerEx, (void **) &punk);
 313     if (SUCCEEDED(hr)) {
 314         IUnknown_Release(punk);
 315
 316         hr = IInternetZoneManager_QueryInterface(zonemgr, &IID_IInternetZoneManagerEx2, (void **) &punk);
 317         if (punk)
 318             IUnknown_Release(punk);
 319         else
 320             win_skip("InternetZoneManagerEx2 not supported\n");
 321
 322     }
 323     else
 324         win_skip("InternetZoneManagerEx not supported\n");
 325
 326     hr = IInternetZoneManager_Release(zonemgr);
 327     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
 328
 329 }
 330
 331 static void test_CreateZoneEnumerator(void)
 332 {
 333     IInternetZoneManager *zonemgr = NULL;
 334     HRESULT hr;
 335     DWORD dwEnum;
 336     DWORD dwEnum2;
 337     DWORD dwCount;
 338     DWORD dwCount2;
 339
 340     hr = CoInternetCreateZoneManager(NULL, &zonemgr, 0);
 341     ok(hr == S_OK, "CoInternetCreateZoneManager result: 0x%x\n", hr);
 342     if (FAILED(hr))
 343         return;
 344
 345     dwEnum=0xdeadbeef;
 346     hr = IInternetZoneManager_CreateZoneEnumerator(zonemgr, &dwEnum, NULL, 0);
 347     ok((hr == E_INVALIDARG) && (dwEnum == 0xdeadbeef),
 348         "got 0x%x with 0x%x (expected E_INVALIDARG with 0xdeadbeef)\n", hr, dwEnum);
 349
 350     dwCount=0xdeadbeef;
 351     hr = IInternetZoneManager_CreateZoneEnumerator(zonemgr, NULL, &dwCount, 0);
 352     ok((hr == E_INVALIDARG) && (dwCount == 0xdeadbeef),
 353         "got 0x%x and 0x%x (expected E_INVALIDARG and 0xdeadbeef)\n", hr, dwCount);
 354
 355     dwEnum=0xdeadbeef;
 356     dwCount=0xdeadbeef;
 357     hr = IInternetZoneManager_CreateZoneEnumerator(zonemgr, &dwEnum, &dwCount, 0xffffffff);
 358     ok((hr == E_INVALIDARG) && (dwEnum == 0xdeadbeef) && (dwCount == 0xdeadbeef),
 359         "got 0x%x with 0x%x and 0x%x (expected E_INVALIDARG with 0xdeadbeef and 0xdeadbeef)\n",
 360         hr, dwEnum, dwCount);
 361
 362     dwEnum=0xdeadbeef;
 363     dwCount=0xdeadbeef;
 364     hr = IInternetZoneManager_CreateZoneEnumerator(zonemgr, &dwEnum, &dwCount, 1);
 365     ok((hr == E_INVALIDARG) && (dwEnum == 0xdeadbeef) && (dwCount == 0xdeadbeef),
 366         "got 0x%x with 0x%x and 0x%x (expected E_INVALIDARG with 0xdeadbeef and 0xdeadbeef)\n",
 367         hr, dwEnum, dwCount);
 368
 369     dwEnum=0xdeadbeef;
 370     dwCount=0xdeadbeef;
 371     /* Normal use */
 372     hr = IInternetZoneManager_CreateZoneEnumerator(zonemgr, &dwEnum, &dwCount, 0);
 373     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
 374
 375     if (SUCCEEDED(hr)) {
 376         dwEnum2=0xdeadbeef;
 377         dwCount2=0xdeadbeef;
 378         hr = IInternetZoneManager_CreateZoneEnumerator(zonemgr, &dwEnum2, &dwCount2, 0);
 379         ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
 380         if (SUCCEEDED(hr)) {
 381             /* native urlmon has an incrementing counter for dwEnum */
 382             hr = IInternetZoneManager_DestroyZoneEnumerator(zonemgr, dwEnum2);
 383             ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
 384         }
 385
 386         hr = IInternetZoneManager_DestroyZoneEnumerator(zonemgr, dwEnum);
 387         ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
 388
 389         /* Destroy the Enumerator twice is detected and handled in native urlmon */
 390         hr = IInternetZoneManager_DestroyZoneEnumerator(zonemgr, dwEnum);
 391         ok((hr == E_INVALIDARG), "got 0x%x (expected E_INVALIDARG)\n", hr);
 392     }
 393
 394     /* ::Release succeed also, when a ::DestroyZoneEnumerator is missing */
 395     hr = IInternetZoneManager_Release(zonemgr);
 396     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
 397 }
 398
 399 static void test_GetZoneActionPolicy(void)
 400 {
 401     IInternetZoneManager *zonemgr = NULL;
 402     BYTE buf[32];
 403     HRESULT hres;
 404     DWORD action = URLACTION_CREDENTIALS_USE; /* Implemented on all IE versions */
 405
 406     hres = CoInternetCreateZoneManager(NULL, &zonemgr, 0);
 407     ok(hres == S_OK, "CoInternetCreateZoneManager failed: %08x\n", hres);
 408     if(FAILED(hres))
 409         return;
 410
 411     hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 3, action, buf,
 412             sizeof(DWORD), URLZONEREG_DEFAULT);
 413     ok(hres == S_OK, "GetZoneActionPolicy failed: %08x\n", hres);
 414     ok(*(DWORD*)buf == URLPOLICY_CREDENTIALS_SILENT_LOGON_OK ||
 415             *(DWORD*)buf == URLPOLICY_CREDENTIALS_MUST_PROMPT_USER ||
 416             *(DWORD*)buf == URLPOLICY_CREDENTIALS_CONDITIONAL_PROMPT ||
 417             *(DWORD*)buf == URLPOLICY_CREDENTIALS_ANONYMOUS_ONLY,
 418             "unexpected policy=%d\n", *(DWORD*)buf);
 419
 420     hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 3, action, NULL,
 421             sizeof(DWORD), URLZONEREG_DEFAULT);
 422     ok(hres == E_INVALIDARG, "GetZoneActionPolicy failed: %08x, expected E_INVALIDARG\n", hres);
 423
 424     hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 3, action, buf,
 425             2, URLZONEREG_DEFAULT);
 426     ok(hres == E_INVALIDARG, "GetZoneActionPolicy failed: %08x, expected E_INVALIDARG\n", hres);
 427
 428     hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 3, 0x1fff, buf,
 429             sizeof(DWORD), URLZONEREG_DEFAULT);
 430     ok(hres == E_FAIL || broken(hres == HRESULT_FROM_WIN32(ERROR_NOT_FOUND)),
 431             "(0x%x) got 0x%x (expected E_FAIL)\n", action, hres);
 432
 433     hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 13, action, buf,
 434             sizeof(DWORD), URLZONEREG_DEFAULT);
 435     ok(hres == E_INVALIDARG, "GetZoneActionPolicy failed: %08x, expected E_INVALIDARG\n", hres);
 436
 437     IInternetZoneManager_Release(zonemgr);
 438 }
 439
 440 static void test_GetZoneAt(void)
 441 {
 442     IInternetZoneManager *zonemgr = NULL;
 443     HRESULT hr;
 444     DWORD dwEnum;
 445     DWORD dwCount;
 446     DWORD dwZone;
 447     DWORD i;
 448
 449     hr = CoInternetCreateZoneManager(NULL, &zonemgr, 0);
 450     ok(hr == S_OK, "CoInternetCreateZoneManager result: 0x%x\n", hr);
 451     if (FAILED(hr))
 452         return;
 453
 454     hr = IInternetZoneManager_CreateZoneEnumerator(zonemgr, &dwEnum, &dwCount, 0);
 455     if (FAILED(hr))
 456         goto cleanup;
 457
 458     if (0) {
 459         /* this crashes with native urlmon */
 460         hr = IInternetZoneManager_GetZoneAt(zonemgr, dwEnum, 0, NULL);
 461     }
 462
 463     dwZone = 0xdeadbeef;
 464     hr = IInternetZoneManager_GetZoneAt(zonemgr, 0xdeadbeef, 0, &dwZone);
 465     ok(hr == E_INVALIDARG,
 466         "got 0x%x with 0x%x (expected E_INVALIDARG)\n", hr, dwZone);
 467
 468     for (i = 0; i < dwCount; i++)
 469     {
 470         dwZone = 0xdeadbeef;
 471         hr = IInternetZoneManager_GetZoneAt(zonemgr, dwEnum, i, &dwZone);
 472         ok(hr == S_OK, "#%d: got x%x with %d (expected S_OK)\n", i, hr, dwZone);
 473     }
 474
 475     dwZone = 0xdeadbeef;
 476     /* MSDN (index .. must be .. less than or equal to) is wrong */
 477     hr = IInternetZoneManager_GetZoneAt(zonemgr, dwEnum, dwCount, &dwZone);
 478     ok(hr == E_INVALIDARG,
 479         "got 0x%x with 0x%x (expected E_INVALIDARG)\n", hr, dwZone);
 480
 481     hr = IInternetZoneManager_DestroyZoneEnumerator(zonemgr, dwEnum);
 482     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
 483
 484 cleanup:
 485     hr = IInternetZoneManager_Release(zonemgr);
 486     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
 487 }
 488
 489 static void test_GetZoneAttributes(void)
 490 {
 491     IInternetZoneManager *zonemgr = NULL;
 492     CHAR buffer [sizeof(ZONEATTRIBUTES) + 32];
 493     ZONEATTRIBUTES* pZA = (ZONEATTRIBUTES*) buffer;
 494     HRESULT hr;
 495     DWORD i;
 496
 497     hr = CoInternetCreateZoneManager(NULL, &zonemgr, 0);
 498     ok(hr == S_OK, "CoInternetCreateZoneManager result: 0x%x\n", hr);
 499     if (FAILED(hr))
 500         return;
 501
 502     /* native urlmon has Zone "0" up to Zone "4" since IE4 */
 503     for (i = 0; i < 5; i++) {
 504         memset(buffer, -1, sizeof(buffer));
 505         hr = IInternetZoneManager_GetZoneAttributes(zonemgr, i, pZA);
 506         ok(hr == S_OK, "#%d: got 0x%x (expected S_OK)\n", i, hr);
 507     }
 508
 509     /* IE8 no longer set cbSize */
 510     memset(buffer, -1, sizeof(buffer));
 511     pZA->cbSize = 0;
 512     hr = IInternetZoneManager_GetZoneAttributes(zonemgr, 0, pZA);
 513     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
 514     ok((pZA->cbSize == 0) || (pZA->cbSize == sizeof(ZONEATTRIBUTES)),
 515         "got cbSize = %d (expected 0)\n", pZA->cbSize);
 516
 517     memset(buffer, -1, sizeof(buffer));
 518     pZA->cbSize = 64;
 519     hr = IInternetZoneManager_GetZoneAttributes(zonemgr, 0, pZA);
 520     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
 521     ok((pZA->cbSize == 64) || (pZA->cbSize == sizeof(ZONEATTRIBUTES)),
 522         "got cbSize = %d (expected 64)\n", pZA->cbSize);
 523
 524     memset(buffer, -1, sizeof(buffer));
 525     hr = IInternetZoneManager_GetZoneAttributes(zonemgr, 0, pZA);
 526     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
 527     ok((pZA->cbSize == 0xffffffff) || (pZA->cbSize == sizeof(ZONEATTRIBUTES)),
 528         "got cbSize = 0x%x (expected 0xffffffff)\n", pZA->cbSize);
 529
 530     /* IE8 no longer fail on invalid zones */
 531     memset(buffer, -1, sizeof(buffer));
 532     hr = IInternetZoneManager_GetZoneAttributes(zonemgr, 0xdeadbeef, pZA);
 533     ok(hr == S_OK || (hr == E_FAIL),
 534         "got 0x%x (expected S_OK or E_FAIL)\n", hr);
 535
 536     hr = IInternetZoneManager_GetZoneAttributes(zonemgr, 0, NULL);
 537     ok(hr == E_INVALIDARG, "got 0x%x (expected E_INVALIDARG)\n", hr);
 538
 539     hr = IInternetZoneManager_Release(zonemgr);
 540     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
 541 }
 542
 543
 544 START_TEST(sec_mgr)
 545 {
 546     OleInitialize(NULL);
 547
 548     test_SecurityManager();
 549     test_polices();
 550     test_CoInternetCreateZoneManager();
 551     test_CreateZoneEnumerator();
 552     test_GetZoneActionPolicy();
 553     test_GetZoneAt();
 554     test_GetZoneAttributes();
 555
 556     OleUninitialize();
 557 }