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

   1 /*
   2  * Copyright 2005-2006 Jacek Caban for CodeWeavers
   3  * Copyright 2009-2011 Detlef Riekenberg
   4  * Copyright 2011 Thomas Mullaly for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22 #define CONST_VTABLE
  23 #define NONAMELESSUNION
  24
  25 /* needed for IInternetZoneManagerEx2 */
  26 #define _WIN32_IE 0x0700
  27
  28 #include <wine/test.h>
  29 #include <stdarg.h>
  30 #include <stddef.h>
  31 #include <stdio.h>
  32
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "ole2.h"
  36 #include "urlmon.h"
  37
  38 #include "initguid.h"
  39
  40 #define URLZONE_CUSTOM  URLZONE_USER_MIN+1
  41 #define URLZONE_CUSTOM2 URLZONE_CUSTOM+1
  42
  43 #define DEFINE_EXPECT(func) \
  44     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  45
  46 #define SET_EXPECT(func) \
  47     expect_ ## func = TRUE
  48
  49 #define CHECK_EXPECT(func) \
  50     do { \
  51         ok(expect_ ##func, "unexpected call " #func "\n"); \
  52         expect_ ## func = FALSE; \
  53         called_ ## func = TRUE; \
  54     }while(0)
  55
  56 #define CHECK_EXPECT2(func) \
  57     do { \
  58         ok(expect_ ##func, "unexpected call " #func "\n"); \
  59         called_ ## func = TRUE; \
  60     }while(0)
  61
  62 #define CHECK_CALLED(func) \
  63     do { \
  64         ok(called_ ## func, "expected " #func "\n"); \
  65         expect_ ## func = called_ ## func = FALSE; \
  66     }while(0)
  67
  68 DEFINE_EXPECT(ParseUrl_SECURITY_URL_input);
  69 DEFINE_EXPECT(ParseUrl_SECURITY_URL_input2);
  70 DEFINE_EXPECT(ParseUrl_SECURITY_URL_expected);
  71 DEFINE_EXPECT(ParseUrl_SECURITY_URL_http);
  72 DEFINE_EXPECT(ParseUrl_SECURITY_DOMAIN_expected);
  73 DEFINE_EXPECT(ProcessUrlAction);
  74
  75 static HRESULT (WINAPI *pCoInternetCreateSecurityManager)(IServiceProvider *, IInternetSecurityManager**, DWORD);
  76 static HRESULT (WINAPI *pCoInternetCreateZoneManager)(IServiceProvider *, IInternetZoneManager**, DWORD);
  77 static HRESULT (WINAPI *pCoInternetGetSecurityUrl)(LPCWSTR, LPWSTR*, PSUACTION, DWORD);
  78 static HRESULT (WINAPI *pCoInternetGetSecurityUrlEx)(IUri*, IUri**, PSUACTION, DWORD_PTR);
  79 static HRESULT (WINAPI *pCreateUri)(LPCWSTR, DWORD, DWORD_PTR, IUri**);
  80 static HRESULT (WINAPI *pCoInternetGetSession)(DWORD, IInternetSession**, DWORD);
  81 static HRESULT (WINAPI *pCoInternetIsFeatureEnabled)(INTERNETFEATURELIST, DWORD);
  82 static HRESULT (WINAPI *pCoInternetIsFeatureEnabledForUrl)(INTERNETFEATURELIST, DWORD, LPCWSTR, IInternetSecurityManager*);
  83 static HRESULT (WINAPI *pCoInternetIsFeatureZoneElevationEnabled)(LPCWSTR, LPCWSTR, IInternetSecurityManager*, DWORD);
  84
  85 static const WCHAR url1[] = {'r','e','s',':','/','/','m','s','h','t','m','l','.','d','l','l',
  86         '/','b','l','a','n','k','.','h','t','m',0};
  87 static const WCHAR url2[] = {'i','n','d','e','x','.','h','t','m',0};
  88 static const WCHAR url3[] = {'f','i','l','e',':','/','/','c',':','\\','I','n','d','e','x','.','h','t','m',0};
  89 static const WCHAR url4[] = {'f','i','l','e',':','s','o','m','e','%','2','0','f','i','l','e',
  90         '%','2','e','j','p','g',0};
  91 static const WCHAR url5[] = {'h','t','t','p',':','/','/','w','w','w','.','z','o','n','e','3',
  92         '.','w','i','n','e','t','e','s','t',0};
  93 static const WCHAR url6[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
  94 static const WCHAR url7[] = {'f','t','p',':','/','/','z','o','n','e','3',
  95         '.','w','i','n','e','t','e','s','t','/','f','i','l','e','.','t','e','s','t',0};
  96 static const WCHAR url8[] = {'t','e','s','t',':','1','2','3','a','b','c',0};
  97 static const WCHAR url9[] = {'h','t','t','p',':','/','/','w','w','w','.','z','o','n','e','3',
  98         '.','w','i','n','e','t','e','s','t', '/','s','i','t','e','/','a','b','o','u','t',0};
  99 static const WCHAR url10[] = {'f','i','l','e',':','/','/','s','o','m','e','%','2','0','f','i','l','e',
 100         '.','j','p','g',0};
 101 static const WCHAR url11[] = {'f','i','l','e',':','/','/','c',':','/','I','n','d','e','x','.','h','t','m',0};
 102 static const WCHAR url12[] = {'f','i','l','e',':','/','/','/','c',':','/','I','n','d','e','x','.','h','t','m',0};
 103 static const WCHAR url13[] = {'h','t','t','p',':','g','o','o','g','l','e','.','c','o','m',0};
 104 static const WCHAR url14[] = {'z','i','p',':','t','e','s','t','i','n','g','.','c','o','m','/','t','e','s','t','i','n','g',0};
 105 static const WCHAR url15[] = {'h','t','t','p',':','/','/','g','o','o','g','l','e','.','c','o','m','.','u','k',0};
 106 static const WCHAR url16[] = {'f','i','l','e',':','/','/','/','c',':',0};
 107 static const WCHAR url17[] = {'f','i','l','e',':','/','/','/','c',':','c','\\',0};
 108 static const WCHAR url18[] = {'c',':','\\','t','e','s','t','.','h','t','m',0};
 109
 110 static const WCHAR url4e[] = {'f','i','l','e',':','s','o','m','e',' ','f','i','l','e',
 111         '.','j','p','g',0};
 112
 113 static const WCHAR winetestW[] = {'w','i','n','e','t','e','s','t',0};
 114 static const WCHAR security_urlW[] = {'w','i','n','e','t','e','s','t',':','t','e','s','t','i','n','g',0};
 115 static const WCHAR security_url2W[] = {'w','i','n','e','t','e','s','t',':','t','e','s','t','i','n','g','2',0};
 116 static const WCHAR security_expectedW[] = {'w','i','n','e','t','e','s','t',':','z','i','p',0};
 117 static const WCHAR winetest_to_httpW[] = {'w','i','n','e','t','e','s','t',':','h',0};
 118
 119 static const char *szZoneMapDomainsKey = "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\ZoneMap\\Domains";
 120 static const char *szInternetSettingsKey = "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings";
 121
 122 static const BYTE secid1[] = {'f','i','l','e',':',0,0,0,0};
 123 static const BYTE secid2[] = {'*',':','i','n','d','e','x','.','h','t','m',3,0,0,0};
 124 static const BYTE secid5[] = {'h','t','t','p',':','w','w','w','.','z','o','n','e','3',
 125         '.','w','i','n','e','t','e','s','t',3,0,0,0};
 126 static const BYTE secid6[] = {'a','b','o','u','t',':','b','l','a','n','k',3,0,0,0};
 127 static const BYTE secid7[] = {'f','t','p',':','z','o','n','e','3',
 128         '.','w','i','n','e','t','e','s','t',3,0,0,0};
 129 static const BYTE secid10[] =
 130     {'f','i','l','e',':','s','o','m','e','%','2','0','f','i','l','e','.','j','p','g',3,0,0,0};
 131 static const BYTE secid14[] =
 132     {'z','i','p',':','t','e','s','t','i','n','g','.','c','o','m','/','t','e','s','t','i','n','g',3,0,0,0};
 133 static const BYTE secid10_2[] =
 134     {'f','i','l','e',':','s','o','m','e',' ','f','i','l','e','.','j','p','g',3,0,0,0};
 135 static const BYTE secid13[] = {'h','t','t','p',':','c','o','m','.','u','k',3,0,0,0};
 136 static const BYTE secid13_2[] = {'h','t','t','p',':','g','o','o','g','l','e','.','c','o','m','.','u','k',3,0,0,0};
 137
 138 static const GUID CLSID_TestActiveX =
 139     {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xfa,0xf8,0x06,0x46}};
 140
 141 /* Defined as extern in urlmon.idl, but not exported by uuid.lib */
 142 const GUID GUID_CUSTOM_CONFIRMOBJECTSAFETY =
 143     {0x10200490,0xfa38,0x11d0,{0xac,0x0e,0x00,0xa0,0xc9,0xf,0xff,0xc0}};
 144
 145 static int called_securl_http;
 146 static DWORD ProcessUrlAction_policy;
 147
 148 static struct secmgr_test {
 149     LPCWSTR url;
 150     DWORD zone;
 151     HRESULT zone_hres;
 152     DWORD secid_size;
 153     const BYTE *secid;
 154     HRESULT secid_hres;
 155 } secmgr_tests[] = {
 156     {url1, 0,   S_OK, sizeof(secid1), secid1, S_OK},
 157     {url2, 100, 0x80041001, 0, NULL, E_INVALIDARG},
 158     {url3, 0,   S_OK, sizeof(secid1), secid1, S_OK},
 159     {url5, 3,   S_OK, sizeof(secid5), secid5, S_OK},
 160     {url6, 3,   S_OK, sizeof(secid6), secid6, S_OK},
 161     {url7, 3,   S_OK, sizeof(secid7), secid7, S_OK},
 162     {url11,0,   S_OK, sizeof(secid1), secid1, S_OK},
 163     {url12,0,   S_OK, sizeof(secid1), secid1, S_OK},
 164     {url16,0,   S_OK, sizeof(secid1), secid1, S_OK},
 165     {url17,0,   S_OK, sizeof(secid1), secid1, S_OK},
 166     {url18,0,   S_OK, sizeof(secid1), secid1, S_OK}
 167 };
 168
 169 static int strcmp_w(const WCHAR *str1, const WCHAR *str2)
 170 {
 171     DWORD len1 = lstrlenW(str1);
 172     DWORD len2 = lstrlenW(str2);
 173
 174     if(len1!=len2) return 1;
 175     return memcmp(str1, str2, len1*sizeof(WCHAR));
 176 }
 177
 178 static inline void heap_free(void *mem)
 179 {
 180     HeapFree(GetProcessHeap(), 0, mem);
 181 }
 182
 183 static inline LPWSTR a2w(LPCSTR str)
 184 {
 185     LPWSTR ret = NULL;
 186
 187     if(str) {
 188         DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 189         ret = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 190         MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 191     }
 192
 193     return ret;
 194 }
 195
 196 static inline DWORD strcmp_aw(LPCSTR strA, LPCWSTR strB) {
 197     LPWSTR strAW = a2w(strA);
 198     DWORD ret = lstrcmpW(strAW, strB);
 199     heap_free(strAW);
 200     return ret;
 201 }
 202
 203
 204 /* Based on RegDeleteTreeW from dlls/advapi32/registry.c */
 205 static LONG myRegDeleteTreeA(HKEY hKey, LPCSTR lpszSubKey)
 206 {
 207     LONG ret;
 208     DWORD dwMaxSubkeyLen, dwMaxValueLen;
 209     DWORD dwMaxLen, dwSize;
 210     CHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
 211     HKEY hSubKey = hKey;
 212
 213     if(lpszSubKey)
 214     {
 215         ret = RegOpenKeyExA(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
 216         if (ret) return ret;
 217     }
 218
 219     /* Get highest length for keys, values */
 220     ret = RegQueryInfoKeyA(hSubKey, NULL, NULL, NULL, NULL,
 221             &dwMaxSubkeyLen, NULL, NULL, &dwMaxValueLen, NULL, NULL, NULL);
 222     if (ret) goto cleanup;
 223
 224     dwMaxSubkeyLen++;
 225     dwMaxValueLen++;
 226     dwMaxLen = max(dwMaxSubkeyLen, dwMaxValueLen);
 227     if (dwMaxLen > sizeof(szNameBuf)/sizeof(CHAR))
 228     {
 229         /* Name too big: alloc a buffer for it */
 230         if (!(lpszName = HeapAlloc( GetProcessHeap(), 0, dwMaxLen*sizeof(CHAR))))
 231         {
 232             ret = ERROR_NOT_ENOUGH_MEMORY;
 233             goto cleanup;
 234         }
 235     }
 236
 237     /* Recursively delete all the subkeys */
 238     while (TRUE)
 239     {
 240         dwSize = dwMaxLen;
 241         if (RegEnumKeyExA(hSubKey, 0, lpszName, &dwSize, NULL,
 242                           NULL, NULL, NULL)) break;
 243
 244         ret = myRegDeleteTreeA(hSubKey, lpszName);
 245         if (ret) goto cleanup;
 246     }
 247
 248     if (lpszSubKey)
 249         ret = RegDeleteKeyA(hKey, lpszSubKey);
 250     else
 251         while (TRUE)
 252         {
 253             dwSize = dwMaxLen;
 254             if (RegEnumValueA(hKey, 0, lpszName, &dwSize,
 255                   NULL, NULL, NULL, NULL)) break;
 256
 257             ret = RegDeleteValueA(hKey, lpszName);
 258             if (ret) goto cleanup;
 259         }
 260
 261 cleanup:
 262     /* Free buffer if allocated */
 263     if (lpszName != szNameBuf)
 264         heap_free(lpszName);
 265     if(lpszSubKey)
 266         RegCloseKey(hSubKey);
 267     return ret;
 268 }
 269
 270 static HRESULT WINAPI SecurityManager_QueryInterface(IInternetSecurityManager* This,
 271         REFIID riid, void **ppvObject)
 272 {
 273     ok(0, "unexpected call\n");
 274     return E_NOTIMPL;
 275 }
 276
 277 static ULONG WINAPI SecurityManager_AddRef(IInternetSecurityManager* This)
 278 {
 279     return 2;
 280 }
 281
 282 static ULONG WINAPI SecurityManager_Release(IInternetSecurityManager* This)
 283 {
 284     return 1;
 285 }
 286
 287 static HRESULT WINAPI SecurityManager_SetSecuritySite(IInternetSecurityManager* This,
 288         IInternetSecurityMgrSite *pSite)
 289 {
 290     ok(0, "unexpected call\n");
 291     return E_NOTIMPL;
 292 }
 293
 294 static HRESULT WINAPI SecurityManager_GetSecuritySite(IInternetSecurityManager* This,
 295         IInternetSecurityMgrSite **ppSite)
 296 {
 297     ok(0, "unexpected call\n");
 298     return E_NOTIMPL;
 299 }
 300
 301 static HRESULT WINAPI SecurityManager_MapUrlToZone(IInternetSecurityManager* This,
 302         LPCWSTR pwszUrl, DWORD *pdwZone, DWORD dwFlags)
 303 {
 304     ok(0, "unexpected call\n");
 305     return E_NOTIMPL;
 306 }
 307
 308 static HRESULT WINAPI SecurityManager_GetSecurityId(IInternetSecurityManager* This,
 309         LPCWSTR pwszUrl, BYTE *pbSecurityId, DWORD *pcbSecurityId, DWORD_PTR dwReserved)
 310 {
 311     ok(0, "unexpected call\n");
 312     return E_NOTIMPL;
 313 }
 314
 315 static HRESULT WINAPI SecurityManager_ProcessUrlAction(IInternetSecurityManager* This,
 316         LPCWSTR pwszUrl, DWORD dwAction, BYTE *pPolicy, DWORD cbPolicy,
 317         BYTE *pContext, DWORD cbContext, DWORD dwFlags, DWORD dwReserved)
 318 {
 319     CHECK_EXPECT(ProcessUrlAction);
 320     ok(dwAction == URLACTION_FEATURE_ZONE_ELEVATION, "dwAction = %x\n", dwAction);
 321     ok(cbPolicy == sizeof(DWORD), "cbPolicy = %d\n", cbPolicy);
 322     ok(!pContext, "pContext != NULL\n");
 323     ok(dwFlags == PUAF_NOUI, "dwFlags = %x\n", dwFlags);
 324     ok(dwReserved == 0, "dwReserved = %x\n", dwReserved);
 325
 326     *pPolicy = ProcessUrlAction_policy;
 327     return ProcessUrlAction_policy==URLPOLICY_ALLOW ? S_OK : S_FALSE;
 328 }
 329
 330 static HRESULT WINAPI SecurityManager_QueryCustomPolicy(IInternetSecurityManager* This,
 331         LPCWSTR pwszUrl, REFGUID guidKey, BYTE **ppPolicy, DWORD *pcbPolicy,
 332         BYTE *pContext, DWORD cbContext, DWORD dwReserved)
 333 {
 334     ok(0, "unexpected call\n");
 335     return E_NOTIMPL;
 336 }
 337
 338 static HRESULT WINAPI SecurityManager_SetZoneMapping(IInternetSecurityManager* This,
 339         DWORD dwZone, LPCWSTR lpszPattern, DWORD dwFlags)
 340 {
 341     ok(0, "unexpected call\n");
 342     return E_NOTIMPL;
 343 }
 344
 345 static HRESULT WINAPI SecurityManager_GetZoneMappings(IInternetSecurityManager* This,
 346         DWORD dwZone, IEnumString **ppenumString, DWORD dwFlags)
 347 {
 348     ok(0, "unexpected call\n");
 349     return E_NOTIMPL;
 350 }
 351
 352 static const IInternetSecurityManagerVtbl SecurityManagerVtbl = {
 353     SecurityManager_QueryInterface,
 354     SecurityManager_AddRef,
 355     SecurityManager_Release,
 356     SecurityManager_SetSecuritySite,
 357     SecurityManager_GetSecuritySite,
 358     SecurityManager_MapUrlToZone,
 359     SecurityManager_GetSecurityId,
 360     SecurityManager_ProcessUrlAction,
 361     SecurityManager_QueryCustomPolicy,
 362     SecurityManager_SetZoneMapping,
 363     SecurityManager_GetZoneMappings
 364 };
 365
 366 static IInternetSecurityManager security_manager = { &SecurityManagerVtbl };
 367
 368 static void test_SecurityManager(void)
 369 {
 370     int i;
 371     IInternetSecurityManager *secmgr = NULL;
 372     BYTE buf[512];
 373     DWORD zone, size, policy;
 374     HRESULT hres;
 375
 376     if(!pCoInternetCreateSecurityManager) {
 377         return;
 378     }
 379
 380     trace("Testing security manager...\n");
 381
 382     hres = pCoInternetCreateSecurityManager(NULL, &secmgr, 0);
 383     ok(hres == S_OK, "CoInternetCreateSecurityManager failed: %08x\n", hres);
 384     if(FAILED(hres))
 385         return;
 386
 387     for(i=0; i < sizeof(secmgr_tests)/sizeof(secmgr_tests[0]); i++) {
 388         zone = 100;
 389         hres = IInternetSecurityManager_MapUrlToZone(secmgr, secmgr_tests[i].url,
 390                                                      &zone, 0);
 391         ok(hres == secmgr_tests[i].zone_hres /* IE <=6 */
 392            || (FAILED(secmgr_tests[i].zone_hres) && hres == E_INVALIDARG), /* IE7 */
 393            "[%d] MapUrlToZone failed: %08x, expected %08x\n",
 394                 i, hres, secmgr_tests[i].zone_hres);
 395         if(SUCCEEDED(hres))
 396             ok(zone == secmgr_tests[i].zone, "[%d] zone=%d, expected %d\n", i, zone,
 397                secmgr_tests[i].zone);
 398         else
 399             ok(zone == secmgr_tests[i].zone || zone == -1, "[%d] zone=%d\n", i, zone);
 400
 401         size = sizeof(buf);
 402         memset(buf, 0xf0, sizeof(buf));
 403         hres = IInternetSecurityManager_GetSecurityId(secmgr, secmgr_tests[i].url,
 404                 buf, &size, 0);
 405         ok(hres == secmgr_tests[i].secid_hres,
 406            "[%d] GetSecurityId failed: %08x, expected %08x\n",
 407            i, hres, secmgr_tests[i].secid_hres);
 408         if(secmgr_tests[i].secid) {
 409             ok(size == secmgr_tests[i].secid_size, "[%d] size=%d, expected %d\n",
 410                     i, size, secmgr_tests[i].secid_size);
 411             ok(!memcmp(buf, secmgr_tests[i].secid, size), "[%d] wrong secid\n", i);
 412         }
 413     }
 414
 415     zone = 100;
 416     hres = IInternetSecurityManager_MapUrlToZone(secmgr, url10, &zone, 0);
 417     ok(hres == S_OK, "MapUrlToZone failed: %08x, expected S_OK\n", hres);
 418     ok(zone == 3, "zone=%d, expected 3\n", zone);
 419
 420     /* win2k3 translates %20 into a space */
 421     size = sizeof(buf);
 422     memset(buf, 0xf0, sizeof(buf));
 423     hres = IInternetSecurityManager_GetSecurityId(secmgr, url10, buf, &size, 0);
 424     ok(hres == S_OK, "GetSecurityId failed: %08x, expected S_OK\n", hres);
 425     ok(size == sizeof(secid10) ||
 426        size == sizeof(secid10_2), /* win2k3 */
 427        "size=%d\n", size);
 428     ok(!memcmp(buf, secid10, sizeof(secid10)) ||
 429        !memcmp(buf, secid10_2, sizeof(secid10_2)), /* win2k3 */
 430        "wrong secid\n");
 431
 432     zone = 100;
 433     hres = IInternetSecurityManager_MapUrlToZone(secmgr, url13, &zone, 0);
 434     ok(hres == S_OK, "MapUrlToZone failed: %08x\n", hres);
 435     ok(zone == URLZONE_INVALID || broken(zone == URLZONE_INTERNET), "zone=%d\n", zone);
 436
 437     size = sizeof(buf);
 438     memset(buf, 0xf0, sizeof(buf));
 439     hres = IInternetSecurityManager_GetSecurityId(secmgr, url13, buf, &size, 0);
 440     ok(hres == E_INVALIDARG || broken(hres == S_OK), "GetSecurityId failed: %08x\n", hres);
 441
 442     zone = 100;
 443     hres = IInternetSecurityManager_MapUrlToZone(secmgr, url14, &zone, 0);
 444     ok(hres == S_OK, "MapUrlToZone failed: %08x, expected S_OK\n", hres);
 445     ok(zone == URLZONE_INTERNET, "zone=%d\n", zone);
 446
 447     size = sizeof(buf);
 448     memset(buf, 0xf0, sizeof(buf));
 449     hres = IInternetSecurityManager_GetSecurityId(secmgr, url14, buf, &size, 0);
 450     ok(hres == S_OK, "GetSecurityId failed: %08x, expected S_OK\n", hres);
 451     ok(size == sizeof(secid14), "size=%d\n", size);
 452     ok(!memcmp(buf, secid14, size), "wrong secid\n");
 453
 454     zone = 100;
 455     hres = IInternetSecurityManager_MapUrlToZone(secmgr, NULL, &zone, 0);
 456     ok(hres == E_INVALIDARG, "MapUrlToZone failed: %08x, expected E_INVALIDARG\n", hres);
 457     ok(zone == 100 || zone == -1, "zone=%d\n", zone);
 458
 459     size = sizeof(buf);
 460     hres = IInternetSecurityManager_GetSecurityId(secmgr, NULL, buf, &size, 0);
 461     ok(hres == E_INVALIDARG,
 462        "GetSecurityId failed: %08x, expected E_INVALIDARG\n", hres);
 463     hres = IInternetSecurityManager_GetSecurityId(secmgr, secmgr_tests[1].url,
 464                                                   NULL, &size, 0);
 465     ok(hres == E_INVALIDARG,
 466        "GetSecurityId failed: %08x, expected E_INVALIDARG\n", hres);
 467     hres = IInternetSecurityManager_GetSecurityId(secmgr, secmgr_tests[1].url,
 468                                                   buf, NULL, 0);
 469     ok(hres == E_INVALIDARG,
 470        "GetSecurityId failed: %08x, expected E_INVALIDARG\n", hres);
 471
 472     hres = IInternetSecurityManager_ProcessUrlAction(secmgr, NULL, URLACTION_SCRIPT_RUN, (BYTE*)&policy,
 473             sizeof(WCHAR), NULL, 0, 0, 0);
 474     ok(hres == E_INVALIDARG, "ProcessUrlAction failed: %08x, expected E_INVALIDARG\n", hres);
 475
 476     IInternetSecurityManager_Release(secmgr);
 477 }
 478
 479 /* Check if Internet Explorer is configured to run in "Enhanced Security Configuration" (aka hardened mode) */
 480 /* Note: this code is duplicated in dlls/mshtml/tests/mshtml_test.h and dlls/urlmon/tests/sec_mgr.c */
 481 static BOOL is_ie_hardened(void)
 482 {
 483     HKEY zone_map;
 484     DWORD ie_harden, type, size;
 485
 486     ie_harden = 0;
 487     if(RegOpenKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\ZoneMap",
 488                     0, KEY_QUERY_VALUE, &zone_map) == ERROR_SUCCESS) {
 489         size = sizeof(DWORD);
 490         if (RegQueryValueExA(zone_map, "IEHarden", NULL, &type, (LPBYTE) &ie_harden, &size) != ERROR_SUCCESS ||
 491             type != REG_DWORD) {
 492             ie_harden = 0;
 493         }
 494         RegCloseKey(zone_map);
 495     }
 496
 497     return ie_harden != 0;
 498 }
 499
 500 static void test_url_action(IInternetSecurityManager *secmgr, IInternetZoneManager *zonemgr, DWORD action)
 501 {
 502     DWORD res, size, policy, reg_policy;
 503     char buf[10];
 504     HKEY hkey;
 505     HRESULT hres;
 506
 507     /* FIXME: HKEY_CURRENT_USER is most of the time the default but this can be changed on a system.
 508      * The test should be changed to cope with that, if need be.
 509      */
 510     res = RegOpenKeyA(HKEY_CURRENT_USER,
 511             "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\Zones\\3", &hkey);
 512     if(res != ERROR_SUCCESS) {
 513         ok(0, "Could not open zone key\n");
 514         return;
 515     }
 516
 517     wsprintf(buf, "%X", action);
 518     size = sizeof(DWORD);
 519     res = RegQueryValueExA(hkey, buf, NULL, NULL, (BYTE*)&reg_policy, &size);
 520     RegCloseKey(hkey);
 521     if(res != ERROR_SUCCESS || size != sizeof(DWORD)) {
 522         policy = 0xdeadbeef;
 523         hres = IInternetSecurityManager_ProcessUrlAction(secmgr, url9, action, (BYTE*)&policy,
 524                 sizeof(WCHAR), NULL, 0, 0, 0);
 525         ok(hres == E_FAIL || broken(hres == HRESULT_FROM_WIN32(ERROR_NOT_FOUND)),
 526             "(0x%x) got 0x%x (expected E_FAIL)\n", action, hres);
 527         ok(policy == 0xdeadbeef, "(%x) policy=%x\n", action, policy);
 528
 529         policy = 0xdeadbeef;
 530         hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 3, action, (BYTE*)&policy,
 531                 sizeof(DWORD), URLZONEREG_DEFAULT);
 532         ok(hres == E_FAIL || broken(hres == HRESULT_FROM_WIN32(ERROR_NOT_FOUND)),
 533             "(0x%x) got 0x%x (expected E_FAIL)\n", action, hres);
 534         ok(policy == 0xdeadbeef, "(%x) policy=%x\n", action, policy);
 535         return;
 536     }
 537
 538     policy = 0xdeadbeef;
 539     hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 3, action, (BYTE*)&policy,
 540             sizeof(DWORD), URLZONEREG_DEFAULT);
 541     ok(hres == S_OK, "GetZoneActionPolicy failed: %08x\n", hres);
 542     ok(policy == reg_policy, "(%x) policy=%x, expected %x\n", action, policy, reg_policy);
 543
 544     if(policy != URLPOLICY_QUERY) {
 545         if(winetest_interactive || ! is_ie_hardened()) {
 546             BOOL expect_parse_call = !called_securl_http;
 547
 548             policy = 0xdeadbeef;
 549             hres = IInternetSecurityManager_ProcessUrlAction(secmgr, url9, action, (BYTE*)&policy,
 550                     sizeof(WCHAR), NULL, 0, 0, 0);
 551             if(reg_policy == URLPOLICY_DISALLOW)
 552                 ok(hres == S_FALSE, "ProcessUrlAction(%x) failed: %08x, expected S_FALSE\n", action, hres);
 553             else
 554                 ok(hres == S_OK, "ProcessUrlAction(%x) failed: %08x\n", action, hres);
 555             ok(policy == 0xdeadbeef, "(%x) policy=%x\n", action, policy);
 556
 557             policy = 0xdeadbeef;
 558             hres = IInternetSecurityManager_ProcessUrlAction(secmgr, url9, action, (BYTE*)&policy,
 559                     2, NULL, 0, 0, 0);
 560             if(reg_policy == URLPOLICY_DISALLOW)
 561                 ok(hres == S_FALSE, "ProcessUrlAction(%x) failed: %08x, expected S_FALSE\n", action, hres);
 562             else
 563                 ok(hres == S_OK, "ProcessUrlAction(%x) failed: %08x\n", action, hres);
 564             ok(policy == 0xdeadbeef, "(%x) policy=%x\n", action, policy);
 565
 566             policy = 0xdeadbeef;
 567             hres = IInternetSecurityManager_ProcessUrlAction(secmgr, url9, action, (BYTE*)&policy,
 568                     sizeof(DWORD), NULL, 0, 0, 0);
 569             if(reg_policy == URLPOLICY_DISALLOW)
 570                 ok(hres == S_FALSE, "ProcessUrlAction(%x) failed: %08x, expected S_FALSE\n", action, hres);
 571             else
 572                 ok(hres == S_OK, "ProcessUrlAction(%x) failed: %08x\n", action, hres);
 573             ok(policy == reg_policy, "(%x) policy=%x\n", action, policy);
 574
 575             policy = 0xdeadbeef;
 576             hres = IInternetSecurityManager_ProcessUrlAction(secmgr, url9, action, (BYTE*)&policy,
 577                     sizeof(WCHAR), (BYTE*)0xdeadbeef, 16, 0, 0);
 578             if(reg_policy == URLPOLICY_DISALLOW)
 579                 ok(hres == S_FALSE, "ProcessUrlAction(%x) failed: %08x, expected S_FALSE\n", action, hres);
 580             else
 581                 ok(hres == S_OK, "ProcessUrlAction(%x) failed: %08x\n", action, hres);
 582             ok(policy == 0xdeadbeef, "(%x) policy=%x\n", action, policy);
 583
 584             policy = 0xdeadbeef;
 585             if(expect_parse_call)
 586                 SET_EXPECT(ParseUrl_SECURITY_URL_http);
 587             hres = IInternetSecurityManager_ProcessUrlAction(secmgr, winetest_to_httpW, action, (BYTE*)&policy,
 588                     sizeof(DWORD), NULL, 0, 0, 0);
 589             if(expect_parse_call)
 590                 CHECK_CALLED(ParseUrl_SECURITY_URL_http);
 591             if(reg_policy == URLPOLICY_DISALLOW)
 592                 ok(hres == S_FALSE, "ProcessUrlAction(%x) failed: %08x, expected S_FALSE\n", action, hres);
 593             else
 594                 ok(hres == S_OK, "ProcessUrlAction(%x) failed: %08x\n", action, hres);
 595             ok(policy == reg_policy, "(%x) policy=%x\n", action, policy);
 596         }else {
 597             skip("IE running in Enhanced Security Configuration\n");
 598         }
 599     }
 600 }
 601
 602 static void test_special_url_action(IInternetSecurityManager *secmgr, IInternetZoneManager *zonemgr, DWORD action)
 603 {
 604     DWORD policy;
 605     HRESULT hres;
 606
 607     policy = 0xdeadbeef;
 608     hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 3, action, (BYTE*)&policy,
 609             sizeof(DWORD), URLZONEREG_DEFAULT);
 610     ok(hres == S_OK, "GetZoneActionPolicy failed: %08x\n", hres);
 611     ok(policy == URLPOLICY_DISALLOW, "(%x) policy=%x, expected URLPOLICY_DISALLOW\n", action, policy);
 612
 613     policy = 0xdeadbeef;
 614     hres = IInternetSecurityManager_ProcessUrlAction(secmgr, url1, action, (BYTE*)&policy,
 615             sizeof(WCHAR), NULL, 0, 0, 0);
 616     ok(hres == S_FALSE, "ProcessUrlAction(%x) failed: %08x, expected S_FALSE\n", action, hres);
 617
 618     policy = 0xdeadbeef;
 619     hres = IInternetSecurityManager_ProcessUrlAction(secmgr, url1, action, (BYTE*)&policy,
 620             sizeof(DWORD), NULL, 0, 0, 0);
 621     ok(hres == S_FALSE, "ProcessUrlAction(%x) failed: %08x, expected S_FALSE\n", action, hres);
 622     ok(policy == URLPOLICY_DISALLOW, "policy = %x\n", policy);
 623 }
 624
 625 static void test_activex(IInternetSecurityManager *secmgr)
 626 {
 627     DWORD policy, policy_size;
 628     struct CONFIRMSAFETY cs;
 629     BYTE *ppolicy;
 630     HRESULT hres;
 631
 632     policy = 0xdeadbeef;
 633     hres = IInternetSecurityManager_ProcessUrlAction(secmgr, url1, URLACTION_ACTIVEX_RUN, (BYTE*)&policy,
 634             sizeof(DWORD), (BYTE*)&CLSID_TestActiveX, sizeof(CLSID), 0, 0);
 635     ok(hres == S_OK, "ProcessUrlAction(URLACTION_ACTIVEX_RUN) failed: %08x\n", hres);
 636     ok(policy == URLPOLICY_ALLOW || policy == URLPOLICY_DISALLOW, "policy = %x\n", policy);
 637
 638     cs.clsid = CLSID_TestActiveX;
 639     cs.pUnk = (IUnknown*)0xdeadbeef;
 640     cs.dwFlags = 0;
 641     hres = IInternetSecurityManager_QueryCustomPolicy(secmgr, url1, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
 642             &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
 643     ok(hres == HRESULT_FROM_WIN32(ERROR_NOT_FOUND), "QueryCusromPolicy failed: %08x\n", hres);
 644 }
 645
 646 static void test_polices(void)
 647 {
 648     IInternetZoneManager *zonemgr = NULL;
 649     IInternetSecurityManager *secmgr = NULL;
 650     HRESULT hres;
 651
 652     trace("testing polices...\n");
 653
 654     hres = pCoInternetCreateSecurityManager(NULL, &secmgr, 0);
 655     ok(hres == S_OK, "CoInternetCreateSecurityManager failed: %08x\n", hres);
 656     hres = pCoInternetCreateZoneManager(NULL, &zonemgr, 0);
 657     ok(hres == S_OK, "CoInternetCreateZoneManager failed: %08x\n", hres);
 658
 659     test_url_action(secmgr, zonemgr, URLACTION_SCRIPT_RUN);
 660     test_url_action(secmgr, zonemgr, URLACTION_ACTIVEX_RUN);
 661     test_url_action(secmgr, zonemgr, URLACTION_ACTIVEX_OVERRIDE_OBJECT_SAFETY);
 662     test_url_action(secmgr, zonemgr, URLACTION_CHANNEL_SOFTDIST_PERMISSIONS);
 663     test_url_action(secmgr, zonemgr, 0xdeadbeef);
 664
 665     test_special_url_action(secmgr, zonemgr, URLACTION_SCRIPT_OVERRIDE_SAFETY);
 666     test_special_url_action(secmgr, zonemgr, URLACTION_ACTIVEX_OVERRIDE_SCRIPT_SAFETY);
 667
 668     test_activex(secmgr);
 669
 670     IInternetSecurityManager_Release(secmgr);
 671     IInternetZoneManager_Release(zonemgr);
 672 }
 673
 674 /* IE (or at least newer versions of it) seem to cache the keys in ZoneMap
 675  * when urlmon.dll is loaded and it doesn't seem to update its cache, unless
 676  * SetZoneMapping is used.
 677  */
 678 static void test_zone_domain_cache(void)
 679 {
 680     HRESULT hres;
 681     DWORD res, zone;
 682     IInternetSecurityManager *secmgr = NULL;
 683     HKEY domains, domain;
 684
 685     static const WCHAR testing_domain_urlW[] = {'h','t','t','p',':','/','/','t','e','s','t','i','n','g','.',
 686             'd','o','m','a','i','n','/',0};
 687
 688     res = RegOpenKeyA(HKEY_CURRENT_USER, szZoneMapDomainsKey, &domains);
 689     ok(res == ERROR_SUCCESS, "RegOpenKey failed: %d\n", res);
 690     if(res != ERROR_SUCCESS)
 691         return;
 692
 693     res = RegCreateKeyA(domains, "testing.domain", &domain);
 694     ok(res == ERROR_SUCCESS, "RegCreateKey failed: %d\n", res);
 695     if(res != ERROR_SUCCESS) {
 696         RegCloseKey(domains);
 697         return;
 698     }
 699
 700     zone = URLZONE_CUSTOM;
 701     res = RegSetValueExA(domain, "http", 0, REG_DWORD, (BYTE*)&zone, sizeof(DWORD));
 702     ok(res == ERROR_SUCCESS, "RegSetValueEx failed: %d\n", res);
 703
 704     RegCloseKey(domain);
 705
 706     hres = pCoInternetCreateSecurityManager(NULL, &secmgr, 0);
 707     ok(hres == S_OK, "CoInternetCreateSecurityManager failed: %08x\n", hres);
 708
 709     zone = URLZONE_INVALID;
 710     hres = IInternetSecurityManager_MapUrlToZone(secmgr, testing_domain_urlW, &zone, 0);
 711     ok(hres == S_OK, "MapUrlToZone failed: %08x\n", hres);
 712     todo_wine ok(zone == URLZONE_INTERNET, "Got %d, expected URLZONE_INTERNET\n", zone);
 713
 714     /* FIXME: Play nice with ZoneMaps that existed before the test is run. */
 715     res = RegDeleteKeyA(domains, "testing.domain");
 716     ok(res == ERROR_SUCCESS, "RegDeleteKey failed: %d\n", res);
 717
 718     RegCloseKey(domains);
 719     IInternetSecurityManager_Release(secmgr);
 720 }
 721
 722 typedef struct {
 723     const char  *domain;
 724     const char  *subdomain;
 725     const char  *scheme;
 726     DWORD       zone;
 727 } zone_domain_mapping;
 728
 729 /* FIXME: Move these into SetZoneMapping tests when the day comes... */
 730 static const zone_domain_mapping zone_domain_mappings[] = {
 731     /* Implicitly means "*.yabadaba.do". */
 732     {"yabadaba.do",NULL,"http",URLZONE_CUSTOM},
 733     /* The '*' doesn't count as a wildcard, since its not the first component of the subdomain. */
 734     {"super.cool","testing.*","ftp",URLZONE_CUSTOM2},
 735     /* The '*' counts since it's the first component of the subdomain. */
 736     {"super.cool","*.testing","ftp",URLZONE_CUSTOM2},
 737     /* All known scheme types apply to wildcard schemes. */
 738     {"tests.test",NULL,"*",URLZONE_CUSTOM},
 739     /* Due to a defect with how windows checks the mappings, unknown scheme types
 740      * never seem to get mapped properly. */
 741     {"tests.test",NULL,"zip",URLZONE_CUSTOM},
 742     {"www.testing.com",NULL,"http",URLZONE_CUSTOM},
 743     {"www.testing.com","testing","http",URLZONE_CUSTOM2},
 744     {"org",NULL,"http",URLZONE_CUSTOM},
 745     {"org","testing","http",URLZONE_CUSTOM2},
 746     {"wine.testing",NULL,"*",URLZONE_CUSTOM2}
 747 };
 748
 749 static void register_zone_domains(void)
 750 {
 751     HKEY domains;
 752     DWORD res, i;
 753
 754     /* Some Windows versions don't seem to have a "Domains" key in their HKLM. */
 755     res = RegOpenKeyA(HKEY_LOCAL_MACHINE, szZoneMapDomainsKey, &domains);
 756     ok(res == ERROR_SUCCESS || broken(res == ERROR_FILE_NOT_FOUND), "RegOpenKey failed: %d\n", res);
 757     if(res == ERROR_SUCCESS) {
 758         HKEY domain;
 759         DWORD zone = URLZONE_CUSTOM;
 760
 761         res = RegCreateKeyA(domains, "local.machine", &domain);
 762         ok(res == ERROR_SUCCESS, "RegCreateKey failed: %d\n", res);
 763
 764         res = RegSetValueExA(domain, "http", 0, REG_DWORD, (BYTE*)&zone, sizeof(DWORD));
 765         ok(res == ERROR_SUCCESS, "RegSetValueEx failed: %d\n", res);
 766
 767         RegCloseKey(domain);
 768         RegCloseKey(domains);
 769     }
 770
 771     res = RegOpenKeyA(HKEY_CURRENT_USER, szZoneMapDomainsKey, &domains);
 772     ok(res == ERROR_SUCCESS, "RegOpenKey failed: %d\n", res);
 773
 774     for(i = 0; i < sizeof(zone_domain_mappings)/sizeof(zone_domain_mappings[0]); ++i) {
 775         const zone_domain_mapping *test = zone_domain_mappings+i;
 776         HKEY domain;
 777
 778         res = RegCreateKeyA(domains, test->domain, &domain);
 779         ok(res == ERROR_SUCCESS, "RegCreateKey failed with %d on test %d\n", res, i);
 780
 781         /* Only set the value if there's no subdomain. */
 782         if(!test->subdomain) {
 783             res = RegSetValueExA(domain, test->scheme, 0, REG_DWORD, (BYTE*)&test->zone, sizeof(DWORD));
 784             ok(res == ERROR_SUCCESS, "RegSetValueEx failed with %d on test %d\n", res, i);
 785         } else {
 786             HKEY subdomain;
 787
 788             res = RegCreateKeyA(domain, test->subdomain, &subdomain);
 789             ok(res == ERROR_SUCCESS, "RegCreateKey failed with %d on test %d\n", res, i);
 790
 791             res = RegSetValueExA(subdomain, test->scheme, 0, REG_DWORD, (BYTE*)&test->zone, sizeof(DWORD));
 792             ok(res == ERROR_SUCCESS, "RegSetValueEx failed with %d on test %d\n", res, i);
 793
 794             RegCloseKey(subdomain);
 795         }
 796
 797         RegCloseKey(domain);
 798     }
 799
 800     RegCloseKey(domains);
 801 }
 802
 803 static void unregister_zone_domains(void)
 804 {
 805     HKEY domains;
 806     DWORD res, i;
 807
 808     res = RegOpenKeyA(HKEY_LOCAL_MACHINE, szZoneMapDomainsKey, &domains);
 809     ok(res == ERROR_SUCCESS || broken(res == ERROR_FILE_NOT_FOUND), "RegOpenKey failed: %d\n", res);
 810     if(res == ERROR_SUCCESS) {
 811         RegDeleteKeyA(domains, "local.machine");
 812         RegCloseKey(domains);
 813     }
 814
 815     res = RegOpenKeyA(HKEY_CURRENT_USER, szZoneMapDomainsKey, &domains);
 816     ok(res == ERROR_SUCCESS, "RegOpenKey failed: %d\n", res);
 817
 818     for(i = 0; i < sizeof(zone_domain_mappings)/sizeof(zone_domain_mappings[0]); ++i) {
 819         const zone_domain_mapping *test = zone_domain_mappings+i;
 820
 821         /* FIXME: Uses the "cludge" approach to remove the test data from the registry!
 822          *        Although, if domain names are... unique, this shouldn't cause any harm
 823          *        to keys (if any) that existed before the tests.
 824          */
 825         if(test->subdomain) {
 826             HKEY domain;
 827
 828             res = RegOpenKeyA(domains, test->domain, &domain);
 829             if(res == ERROR_SUCCESS) {
 830                 RegDeleteKeyA(domain, test->subdomain);
 831                 RegCloseKey(domain);
 832             }
 833         }
 834         RegDeleteKeyA(domains, test->domain);
 835     }
 836
 837     RegCloseKey(domains);
 838 }
 839
 840 static void run_child_process(void)
 841 {
 842     char cmdline[MAX_PATH];
 843     char path[MAX_PATH];
 844     char **argv;
 845     PROCESS_INFORMATION pi;
 846     STARTUPINFO si = { 0 };
 847     BOOL ret;
 848
 849     GetModuleFileNameA(NULL, path, MAX_PATH);
 850
 851     si.cb = sizeof(si);
 852     winetest_get_mainargs(&argv);
 853     sprintf(cmdline, "\"%s\" %s domain_tests", argv[0], argv[1]);
 854     ret = CreateProcess(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
 855     ok(ret, "Failed to spawn child process: %u\n", GetLastError());
 856     winetest_wait_child_process(pi.hProcess);
 857     CloseHandle(pi.hThread);
 858     CloseHandle(pi.hProcess);
 859 }
 860
 861 typedef struct {
 862     const char  *url;
 863     DWORD       zone;
 864     BOOL        todo;
 865     DWORD       broken_zone;
 866 } zone_mapping_test;
 867
 868 static const zone_mapping_test zone_mapping_tests[] = {
 869     /* Tests for "yabadaba.do" zone mappings. */
 870     {"http://yabadaba.do/",URLZONE_CUSTOM},
 871     {"http://google.yabadaba.do/",URLZONE_CUSTOM},
 872     {"zip://yabadaba.do/",URLZONE_INTERNET},
 873     /* Tests for "super.cool" zone mappings. */
 874     {"ftp://testing.google.super.cool/",URLZONE_INTERNET},
 875     {"ftp://testing.*.super.cool/",URLZONE_CUSTOM2},
 876     {"ftp://google.testing.super.cool/",URLZONE_CUSTOM2},
 877     /* Tests for "tests.test" zone mappings. */
 878     {"http://tests.test/",URLZONE_CUSTOM},
 879     {"http://www.tests.test/",URLZONE_CUSTOM},
 880     {"ftp://tests.test/",URLZONE_CUSTOM},
 881     {"ftp://www.tests.test/",URLZONE_CUSTOM},
 882     {"test://www.tests.test/",URLZONE_INTERNET},
 883     {"test://tests.test/",URLZONE_INTERNET},
 884     {"zip://www.tests.test/",URLZONE_INTERNET},
 885     {"zip://tests.test/",URLZONE_INTERNET},
 886     /* Tests for "www.testing.com" zone mappings. */
 887     {"http://google.www.testing.com/",URLZONE_INTERNET},
 888     {"http://www.testing.com/",URLZONE_CUSTOM,FALSE,URLZONE_INTERNET},
 889     {"http://testing.www.testing.com/",URLZONE_CUSTOM2,FALSE,URLZONE_INTERNET},
 890     /* Tests for "org" zone mappings. */
 891     {"http://google.org/",URLZONE_INTERNET,FALSE,URLZONE_CUSTOM},
 892     {"http://org/",URLZONE_CUSTOM},
 893     {"http://testing.org/",URLZONE_CUSTOM2},
 894     /* Tests for "wine.testing" mapping */
 895     {"*:wine.testing/test",URLZONE_CUSTOM2},
 896     {"http://wine.testing/testing",URLZONE_CUSTOM2}
 897 };
 898
 899 static void test_zone_domain_mappings(void)
 900 {
 901     HRESULT hres;
 902     DWORD i, res;
 903     IInternetSecurityManager *secmgr = NULL;
 904     HKEY domains;
 905     DWORD zone = URLZONE_INVALID;
 906
 907     trace("testing zone domain mappings...\n");
 908
 909     hres = pCoInternetCreateSecurityManager(NULL, &secmgr, 0);
 910     ok(hres == S_OK, "CoInternetCreateSecurityManager failed: %08x\n", hres);
 911
 912     res = RegOpenKeyA(HKEY_LOCAL_MACHINE, szZoneMapDomainsKey, &domains);
 913     if(res == ERROR_SUCCESS) {
 914         static const WCHAR local_machineW[] = {'h','t','t','p',':','/','/','t','e','s','t','.','l','o','c','a','l',
 915                 '.','m','a','c','h','i','n','e','/',0};
 916
 917         hres = IInternetSecurityManager_MapUrlToZone(secmgr, local_machineW, &zone, 0);
 918         ok(hres == S_OK, "MapUrlToZone failed: %08x\n", hres);
 919         ok(zone == URLZONE_CUSTOM, "Expected URLZONE_CUSTOM, but got %d\n", zone);
 920
 921         RegCloseKey(domains);
 922     }
 923
 924     for(i = 0; i < sizeof(zone_mapping_tests)/sizeof(zone_mapping_tests[0]); ++i) {
 925         const zone_mapping_test *test = zone_mapping_tests+i;
 926         LPWSTR urlW = a2w(test->url);
 927         zone = URLZONE_INVALID;
 928
 929         hres = IInternetSecurityManager_MapUrlToZone(secmgr, urlW, &zone, 0);
 930         ok(hres == S_OK, "MapUrlToZone failed: %08x\n", hres);
 931         if(test->todo)
 932             todo_wine
 933                 ok(zone == test->zone || broken(test->broken_zone == zone),
 934                     "Expected %d, but got %d on test %d\n", test->zone, zone, i);
 935         else
 936             ok(zone == test->zone || broken(test->broken_zone == zone),
 937                 "Expected %d, but got %d on test %d\n", test->zone, zone, i);
 938
 939         heap_free(urlW);
 940     }
 941
 942     IInternetSecurityManager_Release(secmgr);
 943 }
 944
 945 static void test_zone_domains(void)
 946 {
 947     if(is_ie_hardened()) {
 948         skip("IE running in Enhanced Security Configuration\n");
 949         return;
 950     } else if(!pCreateUri) {
 951         win_skip("Skipping zone domain tests, IE too old\n");
 952         return;
 953     }
 954
 955     trace("testing zone domains...\n");
 956
 957     test_zone_domain_cache();
 958
 959     register_zone_domains();
 960     run_child_process();
 961     unregister_zone_domains();
 962 }
 963
 964 static void test_CoInternetCreateZoneManager(void)
 965 {
 966     IInternetZoneManager *zonemgr = NULL;
 967     IUnknown *punk = NULL;
 968     HRESULT hr;
 969
 970     trace("simple zone manager tests...\n");
 971
 972     hr = pCoInternetCreateZoneManager(NULL, &zonemgr, 0);
 973     ok(hr == S_OK, "CoInternetCreateZoneManager result: 0x%x\n", hr);
 974     if (FAILED(hr))
 975         return;
 976
 977     hr = IInternetZoneManager_QueryInterface(zonemgr, &IID_IUnknown, (void **) &punk);
 978     ok(SUCCEEDED(hr), "got 0x%x with %p (expected Success)\n", hr, punk);
 979     if (punk)
 980         IUnknown_Release(punk);
 981
 982     hr = IInternetZoneManager_QueryInterface(zonemgr, &IID_IInternetZoneManager, (void **) &punk);
 983     ok(SUCCEEDED(hr), "got 0x%x with %p (expected Success)\n", hr, punk);
 984     if (punk)
 985         IUnknown_Release(punk);
 986
 987
 988     hr = IInternetZoneManager_QueryInterface(zonemgr, &IID_IInternetZoneManagerEx, (void **) &punk);
 989     if (SUCCEEDED(hr)) {
 990         IUnknown_Release(punk);
 991
 992         hr = IInternetZoneManager_QueryInterface(zonemgr, &IID_IInternetZoneManagerEx2, (void **) &punk);
 993         ok(hr == S_OK || broken(hr == E_NOINTERFACE /* some W2K3 */),
 994            "got 0x%x (expected S_OK)\n", hr);
 995         if (punk)
 996             IUnknown_Release(punk);
 997         else
 998             win_skip("InternetZoneManagerEx2 not supported\n");
 999
1000     }
1001     else
1002         win_skip("InternetZoneManagerEx not supported\n");
1003
1004     hr = IInternetZoneManager_Release(zonemgr);
1005     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
1006
1007 }
1008
1009 static void test_CreateZoneEnumerator(void)
1010 {
1011     IInternetZoneManager *zonemgr = NULL;
1012     HRESULT hr;
1013     DWORD dwEnum;
1014     DWORD dwEnum2;
1015     DWORD dwCount;
1016     DWORD dwCount2;
1017
1018     trace("testing zone enumerator...\n");
1019
1020     hr = pCoInternetCreateZoneManager(NULL, &zonemgr, 0);
1021     ok(hr == S_OK, "CoInternetCreateZoneManager result: 0x%x\n", hr);
1022     if (FAILED(hr))
1023         return;
1024
1025     dwEnum=0xdeadbeef;
1026     hr = IInternetZoneManager_CreateZoneEnumerator(zonemgr, &dwEnum, NULL, 0);
1027     ok((hr == E_INVALIDARG) && (dwEnum == 0xdeadbeef),
1028         "got 0x%x with 0x%x (expected E_INVALIDARG with 0xdeadbeef)\n", hr, dwEnum);
1029
1030     dwCount=0xdeadbeef;
1031     hr = IInternetZoneManager_CreateZoneEnumerator(zonemgr, NULL, &dwCount, 0);
1032     ok((hr == E_INVALIDARG) && (dwCount == 0xdeadbeef),
1033         "got 0x%x and 0x%x (expected E_INVALIDARG and 0xdeadbeef)\n", hr, dwCount);
1034
1035     dwEnum=0xdeadbeef;
1036     dwCount=0xdeadbeef;
1037     hr = IInternetZoneManager_CreateZoneEnumerator(zonemgr, &dwEnum, &dwCount, 0xffffffff);
1038     ok((hr == E_INVALIDARG) && (dwEnum == 0xdeadbeef) && (dwCount == 0xdeadbeef),
1039         "got 0x%x with 0x%x and 0x%x (expected E_INVALIDARG with 0xdeadbeef and 0xdeadbeef)\n",
1040         hr, dwEnum, dwCount);
1041
1042     dwEnum=0xdeadbeef;
1043     dwCount=0xdeadbeef;
1044     hr = IInternetZoneManager_CreateZoneEnumerator(zonemgr, &dwEnum, &dwCount, 1);
1045     ok((hr == E_INVALIDARG) && (dwEnum == 0xdeadbeef) && (dwCount == 0xdeadbeef),
1046         "got 0x%x with 0x%x and 0x%x (expected E_INVALIDARG with 0xdeadbeef and 0xdeadbeef)\n",
1047         hr, dwEnum, dwCount);
1048
1049     dwEnum=0xdeadbeef;
1050     dwCount=0xdeadbeef;
1051     /* Normal use */
1052     hr = IInternetZoneManager_CreateZoneEnumerator(zonemgr, &dwEnum, &dwCount, 0);
1053     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
1054
1055     if (SUCCEEDED(hr)) {
1056         dwEnum2=0xdeadbeef;
1057         dwCount2=0xdeadbeef;
1058         hr = IInternetZoneManager_CreateZoneEnumerator(zonemgr, &dwEnum2, &dwCount2, 0);
1059         ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
1060         if (SUCCEEDED(hr)) {
1061             /* native urlmon has an incrementing counter for dwEnum */
1062             hr = IInternetZoneManager_DestroyZoneEnumerator(zonemgr, dwEnum2);
1063             ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
1064         }
1065
1066         hr = IInternetZoneManager_DestroyZoneEnumerator(zonemgr, dwEnum);
1067         ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
1068
1069         /* Destroy the Enumerator twice is detected and handled in native urlmon */
1070         hr = IInternetZoneManager_DestroyZoneEnumerator(zonemgr, dwEnum);
1071         ok((hr == E_INVALIDARG), "got 0x%x (expected E_INVALIDARG)\n", hr);
1072     }
1073
1074     /* ::Release succeed also, when a ::DestroyZoneEnumerator is missing */
1075     hr = IInternetZoneManager_Release(zonemgr);
1076     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
1077 }
1078
1079 static void test_GetZoneActionPolicy(void)
1080 {
1081     IInternetZoneManager *zonemgr = NULL;
1082     BYTE buf[32];
1083     HRESULT hres;
1084     DWORD action = URLACTION_CREDENTIALS_USE; /* Implemented on all IE versions */
1085
1086     trace("testing GetZoneActionPolixy...\n");
1087
1088     hres = pCoInternetCreateZoneManager(NULL, &zonemgr, 0);
1089     ok(hres == S_OK, "CoInternetCreateZoneManager failed: %08x\n", hres);
1090     if(FAILED(hres))
1091         return;
1092
1093     hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 3, action, buf,
1094             sizeof(DWORD), URLZONEREG_DEFAULT);
1095     ok(hres == S_OK, "GetZoneActionPolicy failed: %08x\n", hres);
1096     ok(*(DWORD*)buf == URLPOLICY_CREDENTIALS_SILENT_LOGON_OK ||
1097             *(DWORD*)buf == URLPOLICY_CREDENTIALS_MUST_PROMPT_USER ||
1098             *(DWORD*)buf == URLPOLICY_CREDENTIALS_CONDITIONAL_PROMPT ||
1099             *(DWORD*)buf == URLPOLICY_CREDENTIALS_ANONYMOUS_ONLY,
1100             "unexpected policy=%d\n", *(DWORD*)buf);
1101
1102     hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 3, action, NULL,
1103             sizeof(DWORD), URLZONEREG_DEFAULT);
1104     ok(hres == E_INVALIDARG, "GetZoneActionPolicy failed: %08x, expected E_INVALIDARG\n", hres);
1105
1106     hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 3, action, buf,
1107             2, URLZONEREG_DEFAULT);
1108     ok(hres == E_INVALIDARG, "GetZoneActionPolicy failed: %08x, expected E_INVALIDARG\n", hres);
1109
1110     hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 3, 0x1fff, buf,
1111             sizeof(DWORD), URLZONEREG_DEFAULT);
1112     ok(hres == E_FAIL || broken(hres == HRESULT_FROM_WIN32(ERROR_NOT_FOUND)),
1113             "(0x%x) got 0x%x (expected E_FAIL)\n", action, hres);
1114
1115     hres = IInternetZoneManager_GetZoneActionPolicy(zonemgr, 13, action, buf,
1116             sizeof(DWORD), URLZONEREG_DEFAULT);
1117     ok(hres == E_INVALIDARG, "GetZoneActionPolicy failed: %08x, expected E_INVALIDARG\n", hres);
1118
1119     IInternetZoneManager_Release(zonemgr);
1120 }
1121
1122 static void test_GetZoneAt(void)
1123 {
1124     IInternetZoneManager *zonemgr = NULL;
1125     HRESULT hr;
1126     DWORD dwEnum;
1127     DWORD dwCount;
1128     DWORD dwZone;
1129     DWORD i;
1130
1131     trace("testing GetZoneAt...\n");
1132
1133     hr = pCoInternetCreateZoneManager(NULL, &zonemgr, 0);
1134     ok(hr == S_OK, "CoInternetCreateZoneManager result: 0x%x\n", hr);
1135     if (FAILED(hr))
1136         return;
1137
1138     hr = IInternetZoneManager_CreateZoneEnumerator(zonemgr, &dwEnum, &dwCount, 0);
1139     if (FAILED(hr))
1140         goto cleanup;
1141
1142     if (0) {
1143         /* this crashes with native urlmon */
1144         IInternetZoneManager_GetZoneAt(zonemgr, dwEnum, 0, NULL);
1145     }
1146
1147     dwZone = 0xdeadbeef;
1148     hr = IInternetZoneManager_GetZoneAt(zonemgr, 0xdeadbeef, 0, &dwZone);
1149     ok(hr == E_INVALIDARG,
1150         "got 0x%x with 0x%x (expected E_INVALIDARG)\n", hr, dwZone);
1151
1152     for (i = 0; i < dwCount; i++)
1153     {
1154         dwZone = 0xdeadbeef;
1155         hr = IInternetZoneManager_GetZoneAt(zonemgr, dwEnum, i, &dwZone);
1156         ok(hr == S_OK, "#%d: got x%x with %d (expected S_OK)\n", i, hr, dwZone);
1157     }
1158
1159     dwZone = 0xdeadbeef;
1160     /* MSDN (index .. must be .. less than or equal to) is wrong */
1161     hr = IInternetZoneManager_GetZoneAt(zonemgr, dwEnum, dwCount, &dwZone);
1162     ok(hr == E_INVALIDARG,
1163         "got 0x%x with 0x%x (expected E_INVALIDARG)\n", hr, dwZone);
1164
1165     hr = IInternetZoneManager_DestroyZoneEnumerator(zonemgr, dwEnum);
1166     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
1167
1168 cleanup:
1169     hr = IInternetZoneManager_Release(zonemgr);
1170     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
1171 }
1172
1173 static void test_GetZoneAttributes(void)
1174 {
1175     IInternetZoneManager *zonemgr = NULL;
1176     CHAR buffer [sizeof(ZONEATTRIBUTES) + 32];
1177     ZONEATTRIBUTES* pZA = (ZONEATTRIBUTES*) buffer;
1178     HRESULT hr;
1179     DWORD i;
1180
1181     trace("testing GetZoneAttributes...\n");
1182
1183     hr = pCoInternetCreateZoneManager(NULL, &zonemgr, 0);
1184     ok(hr == S_OK, "CoInternetCreateZoneManager result: 0x%x\n", hr);
1185     if (FAILED(hr))
1186         return;
1187
1188     /* native urlmon has Zone "0" up to Zone "4" since IE4 */
1189     for (i = 0; i < 5; i++) {
1190         memset(buffer, -1, sizeof(buffer));
1191         hr = IInternetZoneManager_GetZoneAttributes(zonemgr, i, pZA);
1192         ok(hr == S_OK, "#%d: got 0x%x (expected S_OK)\n", i, hr);
1193     }
1194
1195     /* IE8 no longer set cbSize */
1196     memset(buffer, -1, sizeof(buffer));
1197     pZA->cbSize = 0;
1198     hr = IInternetZoneManager_GetZoneAttributes(zonemgr, 0, pZA);
1199     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
1200     ok((pZA->cbSize == 0) || (pZA->cbSize == sizeof(ZONEATTRIBUTES)),
1201         "got cbSize = %d (expected 0)\n", pZA->cbSize);
1202
1203     memset(buffer, -1, sizeof(buffer));
1204     pZA->cbSize = 64;
1205     hr = IInternetZoneManager_GetZoneAttributes(zonemgr, 0, pZA);
1206     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
1207     ok((pZA->cbSize == 64) || (pZA->cbSize == sizeof(ZONEATTRIBUTES)),
1208         "got cbSize = %d (expected 64)\n", pZA->cbSize);
1209
1210     memset(buffer, -1, sizeof(buffer));
1211     hr = IInternetZoneManager_GetZoneAttributes(zonemgr, 0, pZA);
1212     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
1213     ok((pZA->cbSize == 0xffffffff) || (pZA->cbSize == sizeof(ZONEATTRIBUTES)),
1214         "got cbSize = 0x%x (expected 0xffffffff)\n", pZA->cbSize);
1215
1216     /* IE8 no longer fail on invalid zones */
1217     memset(buffer, -1, sizeof(buffer));
1218     hr = IInternetZoneManager_GetZoneAttributes(zonemgr, 0xdeadbeef, pZA);
1219     ok(hr == S_OK || (hr == E_FAIL),
1220         "got 0x%x (expected S_OK or E_FAIL)\n", hr);
1221
1222     hr = IInternetZoneManager_GetZoneAttributes(zonemgr, 0, NULL);
1223     ok(hr == E_INVALIDARG, "got 0x%x (expected E_INVALIDARG)\n", hr);
1224
1225     hr = IInternetZoneManager_Release(zonemgr);
1226     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
1227 }
1228
1229 static void test_SetZoneAttributes(void)
1230 {
1231     IInternetZoneManager *zonemgr = NULL;
1232     CHAR buffer [sizeof(ZONEATTRIBUTES) + 16];
1233     ZONEATTRIBUTES* pZA = (ZONEATTRIBUTES*) buffer;
1234     CHAR regpath[MAX_PATH];
1235     HKEY hkey;
1236     HRESULT hr;
1237     DWORD res;
1238
1239     trace("testing SetZoneAttributes...\n");
1240     hr = pCoInternetCreateZoneManager(NULL, &zonemgr, 0);
1241     ok(hr == S_OK, "CoInternetCreateZoneManager result: 0x%x\n", hr);
1242     if (FAILED(hr))
1243         return;
1244
1245     memset(buffer, -1, sizeof(buffer));
1246     hr = IInternetZoneManager_GetZoneAttributes(zonemgr, URLZONE_LOCAL_MACHINE, pZA);
1247     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
1248
1249     sprintf(regpath, "%s\\Zones\\%d", szInternetSettingsKey, URLZONE_CUSTOM);
1250     res = RegCreateKeyA(HKEY_CURRENT_USER, regpath, &hkey);
1251     RegCloseKey(hkey);
1252
1253     ok(res == ERROR_SUCCESS, "got %d (expected ERROR_SUCCESS)\n", res);
1254     if (res != ERROR_SUCCESS)
1255         goto cleanup;
1256
1257     pZA->cbSize = sizeof(ZONEATTRIBUTES);
1258     hr = IInternetZoneManager_SetZoneAttributes(zonemgr, URLZONE_CUSTOM, NULL);
1259     ok(hr == E_INVALIDARG, "got 0x%x (expected E_INVALIDARG)\n", hr);
1260
1261     /* normal use */
1262     hr = IInternetZoneManager_SetZoneAttributes(zonemgr, URLZONE_CUSTOM, pZA);
1263     if (hr == E_FAIL) {
1264         win_skip("SetZoneAttributes not supported: IE too old\n");
1265         goto cleanup;
1266     }
1267     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
1268
1269     /* native urlmon ignores cbSize */
1270     pZA->cbSize = sizeof(ZONEATTRIBUTES) + sizeof(DWORD);
1271     hr = IInternetZoneManager_SetZoneAttributes(zonemgr, URLZONE_CUSTOM, pZA);
1272     ok(hr == S_OK, "got 0x%x for sizeof(ZONEATTRIBUTES) + sizeof(DWORD) (expected S_OK)\n", hr);
1273
1274     pZA->cbSize = sizeof(ZONEATTRIBUTES) - sizeof(DWORD);
1275     hr = IInternetZoneManager_SetZoneAttributes(zonemgr, URLZONE_CUSTOM, pZA);
1276     ok(hr == S_OK, "got 0x%x for sizeof(ZONEATTRIBUTES) - sizeof(DWORD) (expected S_OK)\n", hr);
1277
1278     pZA->cbSize = 0;
1279     hr = IInternetZoneManager_SetZoneAttributes(zonemgr, URLZONE_CUSTOM, pZA);
1280     ok(hr == S_OK, "got 0x%x for size 0 (expected S_OK)\n", hr);
1281
1282     /* The key for the zone must be present, when calling SetZoneAttributes */
1283     myRegDeleteTreeA(HKEY_CURRENT_USER, regpath);
1284     /* E_FAIL is returned from IE6 here, which is reasonable.
1285        All newer IE return S_OK without saving the zone attributes to the registry.
1286        This is a Windows bug, but we have to accept that as standard */
1287     hr = IInternetZoneManager_SetZoneAttributes(zonemgr, URLZONE_CUSTOM, pZA);
1288     ok((hr == S_OK) || broken(hr == E_FAIL), "got 0x%x (expected S_OK)\n", hr);
1289
1290     /* SetZoneAttributes did not create the directory */
1291     res = RegOpenKeyA(HKEY_CURRENT_USER, regpath, &hkey);
1292     ok((res == ERROR_FILE_NOT_FOUND) && (hkey == NULL),
1293         "got %u with %p (expected ERROR_FILE_NOT_FOUND with NULL)\n", res, hkey);
1294
1295     if (hkey) RegCloseKey(hkey);
1296
1297 cleanup:
1298     /* delete zone settings in the registry */
1299     myRegDeleteTreeA(HKEY_CURRENT_USER, regpath);
1300
1301     hr = IInternetZoneManager_Release(zonemgr);
1302     ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr);
1303 }
1304
1305
1306 static void test_InternetSecurityMarshalling(void)
1307 {
1308     IInternetSecurityManager *secmgr = NULL;
1309     IUnknown *unk;
1310     IStream *stream;
1311     HRESULT hres;
1312
1313     trace("testing marshalling...\n");
1314
1315     hres = pCoInternetCreateSecurityManager(NULL, &secmgr, 0);
1316     ok(hres == S_OK, "CoInternetCreateSecurityManager failed: %08x\n", hres);
1317     if(FAILED(hres))
1318         return;
1319
1320     hres = IInternetSecurityManager_QueryInterface(secmgr, &IID_IUnknown, (void**)&unk);
1321     ok(hres == S_OK, "QueryInterface returned: %08x\n", hres);
1322
1323     hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
1324     ok(hres == S_OK, "CreateStreamOnHGlobal returned: %08x\n", hres);
1325
1326     hres = CoMarshalInterface(stream, &IID_IInternetSecurityManager, unk, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1327     /* Not supported in W98 */
1328     ok(hres == S_OK || broken(hres == REGDB_E_IIDNOTREG),
1329         "CoMarshalInterface returned: %08x\n", hres);
1330
1331     IStream_Release(stream);
1332     IUnknown_Release(unk);
1333     IInternetSecurityManager_Release(secmgr);
1334 }
1335
1336 static void test_InternetGetSecurityUrl(void)
1337 {
1338     const WCHAR url5_out[] = {'h','t','t','p',':','w','w','w','.','z','o','n','e','3',
1339                               '.','w','i','n','e','t','e','s','t',0};
1340     const WCHAR url7_out[] = {'f','t','p',':','z','o','n','e','3','.','w','i','n','e','t','e','s','t',0};
1341
1342     const WCHAR *in[] = {url2, url3, url4, url5, url7, url8, url9, url10};
1343     const WCHAR *out_default[] = {url2, url3, url4, url5_out, url7_out, url8, url5_out, url10};
1344     const WCHAR *out_securl[] = {url2, url3, url4, url5, url7, url8, url9, url10};
1345
1346     WCHAR *sec;
1347     DWORD i;
1348     HRESULT hres;
1349
1350     trace("testing CoInternetGetSecurityUrl...\n");
1351
1352     for(i=0; i<sizeof(in)/sizeof(WCHAR*); i++) {
1353         hres = pCoInternetGetSecurityUrl(in[i], &sec, PSU_DEFAULT, 0);
1354         ok(hres == S_OK, "(%d) CoInternetGetSecurityUrl returned: %08x\n", i, hres);
1355         if(hres == S_OK) {
1356             ok(!strcmp_w(sec, out_default[i]), "(%d) Got %s, expected %s\n",
1357                     i, wine_dbgstr_w(sec), wine_dbgstr_w(out_default[i]));
1358             CoTaskMemFree(sec);
1359         }
1360
1361         hres = pCoInternetGetSecurityUrl(in[i], &sec, PSU_SECURITY_URL_ONLY, 0);
1362         ok(hres == S_OK, "(%d) CoInternetGetSecurityUrl returned: %08x\n", i, hres);
1363         if(hres == S_OK) {
1364             ok(!strcmp_w(sec, out_securl[i]), "(%d) Got %s, expected %s\n",
1365                     i, wine_dbgstr_w(sec), wine_dbgstr_w(out_securl[i]));
1366             CoTaskMemFree(sec);
1367         }
1368     }
1369
1370     SET_EXPECT(ParseUrl_SECURITY_URL_input2);
1371     SET_EXPECT(ParseUrl_SECURITY_URL_expected);
1372     SET_EXPECT(ParseUrl_SECURITY_DOMAIN_expected);
1373
1374     hres = pCoInternetGetSecurityUrl(security_url2W, &sec, PSU_DEFAULT, 0);
1375     ok(hres == S_OK, "CoInternetGetSecurityUrl returned 0x%08x, expected S_OK\n", hres);
1376
1377     CHECK_CALLED(ParseUrl_SECURITY_URL_input2);
1378     CHECK_CALLED(ParseUrl_SECURITY_URL_expected);
1379     CHECK_CALLED(ParseUrl_SECURITY_DOMAIN_expected);
1380
1381     ok(!lstrcmpW(security_expectedW, sec), "Expected %s but got %s\n",
1382        wine_dbgstr_w(security_expectedW), wine_dbgstr_w(sec));
1383     CoTaskMemFree(sec);
1384 }
1385
1386 static HRESULT WINAPI InternetProtocolInfo_QueryInterface(IInternetProtocolInfo *iface,
1387                                                           REFIID riid, void **ppv)
1388 {
1389     ok(0, "unexpected call\n");
1390     return E_NOINTERFACE;
1391 }
1392
1393 static ULONG WINAPI InternetProtocolInfo_AddRef(IInternetProtocolInfo *iface)
1394 {
1395     return 2;
1396 }
1397
1398 static ULONG WINAPI InternetProtocolInfo_Release(IInternetProtocolInfo *iface)
1399 {
1400     return 1;
1401 }
1402
1403 static HRESULT WINAPI InternetProtocolInfo_ParseUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
1404         PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult,
1405         DWORD *pcchResult, DWORD dwReserved)
1406 {
1407     const WCHAR *ret = NULL;
1408
1409     ok(pwzResult != NULL, "pwzResult == NULL\n");
1410     ok(pcchResult != NULL, "pcchResult == NULL\n");
1411     ok(!dwParseFlags, "Expected 0, but got 0x%08x\n", dwParseFlags);
1412
1413     switch(ParseAction) {
1414     case PARSE_SECURITY_URL:
1415         if(!strcmp_w(pwzUrl, security_urlW)) {
1416             CHECK_EXPECT(ParseUrl_SECURITY_URL_input);
1417             ok(cchResult == lstrlenW(pwzUrl)+1, "Got %d\n", cchResult);
1418             ret = security_expectedW;
1419         } else if(!strcmp_w(pwzUrl, security_url2W)) {
1420             CHECK_EXPECT(ParseUrl_SECURITY_URL_input2);
1421             ok(cchResult == lstrlenW(pwzUrl)+1, "Got %d\n", cchResult);
1422             ret = security_expectedW;
1423         } else if(!strcmp_w(pwzUrl, security_expectedW)) {
1424             CHECK_EXPECT(ParseUrl_SECURITY_URL_expected);
1425             ok(cchResult == lstrlenW(pwzUrl)+1, "Got %d\n", cchResult);
1426             ret = security_expectedW;
1427         } else if(!strcmp_w(pwzUrl, winetest_to_httpW)) {
1428             switch(++called_securl_http) {
1429             case 1:
1430                 ok(cchResult == lstrlenW(pwzUrl)+1, "Got %d\n", cchResult);
1431                 break;
1432             case 2:
1433                 CHECK_EXPECT(ParseUrl_SECURITY_URL_http);
1434                 ok(cchResult == lstrlenW(url9)+1, "Got %d\n", cchResult);
1435                 break;
1436             default:
1437                 todo_wine CHECK_EXPECT(ParseUrl_SECURITY_URL_http);
1438             }
1439             ret = url9;
1440         } else
1441             ok(0, "Unexpected call, pwzUrl=%s\n", wine_dbgstr_w(pwzUrl));
1442
1443         break;
1444     case PARSE_SECURITY_DOMAIN:
1445
1446         CHECK_EXPECT(ParseUrl_SECURITY_DOMAIN_expected);
1447
1448         ok(!strcmp_w(pwzUrl, security_expectedW), "Expected %s but got %s\n",
1449             wine_dbgstr_w(security_expectedW), wine_dbgstr_w(pwzUrl));
1450         ok(cchResult == lstrlenW(pwzUrl)+1, "Got %d\n", cchResult);
1451         ret = security_expectedW;
1452         break;
1453     default:
1454         ok(0, "Unexpected call, ParseAction=%d pwzUrl=%s\n", ParseAction,
1455             wine_dbgstr_w(pwzUrl));
1456     }
1457
1458     if(!ret)
1459         return E_FAIL;
1460
1461     *pcchResult = lstrlenW(ret)+1;
1462     if(*pcchResult > cchResult)
1463         return S_FALSE;
1464     memcpy(pwzResult, ret, (*pcchResult)*sizeof(WCHAR));
1465     return S_OK;
1466 }
1467
1468 static HRESULT WINAPI InternetProtocolInfo_CombineUrl(IInternetProtocolInfo *iface,
1469         LPCWSTR pwzBaseUrl, LPCWSTR pwzRelativeUrl, DWORD dwCombineFlags,
1470         LPWSTR pwzResult, DWORD cchResult, DWORD *pcchResult, DWORD dwReserved)
1471 {
1472     ok(0, "unexpected call\n");
1473     return E_NOTIMPL;
1474 }
1475
1476 static HRESULT WINAPI InternetProtocolInfo_CompareUrl(IInternetProtocolInfo *iface,
1477         LPCWSTR pwzUrl1, LPCWSTR pwzUrl2, DWORD dwCompareFlags)
1478 {
1479     ok(0, "unexpected call\n");
1480     return E_NOTIMPL;
1481 }
1482
1483 static HRESULT WINAPI InternetProtocolInfo_QueryInfo(IInternetProtocolInfo *iface,
1484         LPCWSTR pwzUrl, QUERYOPTION OueryOption, DWORD dwQueryFlags, LPVOID pBuffer,
1485         DWORD cbBuffer, DWORD *pcbBuf, DWORD dwReserved)
1486 {
1487     ok(0, "unexpected call\n");
1488     return E_NOTIMPL;
1489 }
1490
1491 static const IInternetProtocolInfoVtbl InternetProtocolInfoVtbl = {
1492     InternetProtocolInfo_QueryInterface,
1493     InternetProtocolInfo_AddRef,
1494     InternetProtocolInfo_Release,
1495     InternetProtocolInfo_ParseUrl,
1496     InternetProtocolInfo_CombineUrl,
1497     InternetProtocolInfo_CompareUrl,
1498     InternetProtocolInfo_QueryInfo
1499 };
1500
1501 static IInternetProtocolInfo protocol_info = { &InternetProtocolInfoVtbl };
1502
1503 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
1504 {
1505     if(IsEqualGUID(&IID_IInternetProtocolInfo, riid)) {
1506         *ppv = &protocol_info;
1507         return S_OK;
1508     }
1509
1510     ok(0, "unexpected call\n");
1511     return E_NOINTERFACE;
1512 }
1513
1514 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
1515 {
1516     return 2;
1517 }
1518
1519 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
1520 {
1521     return 1;
1522 }
1523
1524 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *pOuter,
1525                                         REFIID riid, void **ppv)
1526 {
1527     ok(0, "unexpected call\n");
1528     return E_NOTIMPL;
1529 }
1530
1531 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
1532 {
1533     ok(0, "unexpected call\n");
1534     return S_OK;
1535 }
1536
1537 static const IClassFactoryVtbl ClassFactoryVtbl = {
1538     ClassFactory_QueryInterface,
1539     ClassFactory_AddRef,
1540     ClassFactory_Release,
1541     ClassFactory_CreateInstance,
1542     ClassFactory_LockServer
1543 };
1544
1545 static IClassFactory protocol_cf = { &ClassFactoryVtbl };
1546
1547 static void register_protocols(void)
1548 {
1549     IInternetSession *session;
1550     HRESULT hres;
1551
1552     hres = pCoInternetGetSession(0, &session, 0);
1553     ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
1554     if(FAILED(hres))
1555         return;
1556
1557     hres = IInternetSession_RegisterNameSpace(session, &protocol_cf, &IID_NULL,
1558             winetestW, 0, NULL, 0);
1559     ok(hres == S_OK, "RegisterNameSpace failed: %08x\n", hres);
1560
1561     IInternetSession_Release(session);
1562 }
1563
1564 static void unregister_protocols(void) {
1565     IInternetSession *session;
1566     HRESULT hr;
1567
1568     hr = pCoInternetGetSession(0, &session, 0);
1569     ok(hr == S_OK, "CoInternetGetSession failed: 0x%08x\n", hr);
1570     if(FAILED(hr))
1571         return;
1572
1573     hr = IInternetSession_UnregisterNameSpace(session, &protocol_cf, winetestW);
1574     ok(hr == S_OK, "UnregisterNameSpace failed: 0x%08x\n", hr);
1575
1576     IInternetSession_Release(session);
1577 }
1578
1579 static const struct {
1580     const char  *uri;
1581     DWORD       create_flags;
1582     const char  *security_uri;
1583     HRESULT     security_hres;
1584     const char  *default_uri;
1585     HRESULT     default_hres;
1586     BOOL        todo;
1587 } sec_url_ex_tests[] = {
1588     {"index.htm",Uri_CREATE_ALLOW_RELATIVE,"*:index.html",S_OK,"*:index.htm",S_OK},
1589     {"file://c:\\Index.htm",Uri_CREATE_FILE_USE_DOS_PATH,"file:///c:/Index.htm",S_OK,"file:///c:/Index.htm",S_OK},
1590     {"file:some%20file%2ejpg",0,NULL,E_INVALIDARG,NULL,E_INVALIDARG},
1591     {"file:some file.jpg",0,NULL,E_INVALIDARG,NULL,E_INVALIDARG},
1592     {"http://www.zone3.winetest/",0,"http://www.zone3.winetest/",S_OK,"http://www.zone3.winetest/",S_OK},
1593     {"about:blank",0,"about:blank",S_OK,"about:blank",S_OK},
1594     {"ftp://zone3.winetest/file.test",0,"ftp://zone3.winetest/file.test",S_OK,"ftp://zone3.winetest/file.test",S_OK},
1595     {"test:123abc",0,"test:123abc",S_OK,"test:123abc",S_OK},
1596     {"http:google.com/test.file",0,"http:google.com/test.file",S_OK,"http:google.com/test.file",S_OK},
1597     {"ftp://test@ftp.winehq.org/",0,"ftp://ftp.winehq.org/",S_OK,"ftp://ftp.winehq.org/",S_OK},
1598     {"test://google@ftp.winehq.org/",0,"test://google@ftp.winehq.org/",S_OK,"test://google@ftp.winehq.org/",S_OK}
1599 };
1600
1601 static void test_InternetGetSecurityUrlEx(void)
1602 {
1603     HRESULT hr;
1604     DWORD i;
1605     IUri *uri = NULL, *result = NULL;
1606
1607     trace("testing CoInternetGetSecurityUrlEx...\n");
1608
1609     hr = pCoInternetGetSecurityUrlEx(NULL, NULL, PSU_DEFAULT, 0);
1610     ok(hr == E_INVALIDARG, "CoInternetGetSecurityUrlEx returned 0x%08x, expected E_INVALIDARG\n", hr);
1611
1612     result = (void*) 0xdeadbeef;
1613     hr = pCoInternetGetSecurityUrlEx(NULL, &result, PSU_DEFAULT, 0);
1614     ok(hr == E_INVALIDARG, "CoInternetGetSecurityUrlEx returned 0x%08x, expected E_INVALIDARG\n", hr);
1615     ok(result == (void*) 0xdeadbeef, "'result' was %p\n", result);
1616
1617     for(i = 0; i < sizeof(sec_url_ex_tests)/sizeof(sec_url_ex_tests[0]); ++i) {
1618         LPWSTR uriW = a2w(sec_url_ex_tests[i].uri);
1619         uri = NULL;
1620
1621         hr = pCreateUri(uriW, sec_url_ex_tests[i].create_flags, 0, &uri);
1622         ok(hr == S_OK, "CreateUri returned 0x%08x on test %d\n", hr, i);
1623         if(hr == S_OK) {
1624             result = NULL;
1625
1626             hr = pCoInternetGetSecurityUrlEx(uri, &result, PSU_DEFAULT, 0);
1627             if(sec_url_ex_tests[i].todo) {
1628                 todo_wine
1629                     ok(hr == sec_url_ex_tests[i].default_hres,
1630                         "CoInternetGetSecurityUrlEx returned 0x%08x, expected 0x%08x on test %d\n",
1631                         hr, sec_url_ex_tests[i].default_hres, i);
1632             } else {
1633                 ok(hr == sec_url_ex_tests[i].default_hres,
1634                     "CoInternetGetSecurityUrlEx returned 0x%08x, expected 0x%08x on test %d\n",
1635                     hr, sec_url_ex_tests[i].default_hres, i);
1636             }
1637             if(SUCCEEDED(hr)) {
1638                 BSTR received;
1639
1640                 hr = IUri_GetDisplayUri(result, &received);
1641                 ok(hr == S_OK, "GetDisplayUri returned 0x%08x on test %d\n", hr, i);
1642                 if(hr == S_OK) {
1643                     if(sec_url_ex_tests[i].todo) {
1644                         todo_wine
1645                             ok(!strcmp_aw(sec_url_ex_tests[i].default_uri, received),
1646                                 "Expected %s but got %s on test %d\n", sec_url_ex_tests[i].default_uri,
1647                                 wine_dbgstr_w(received), i);
1648                     } else {
1649                         ok(!strcmp_aw(sec_url_ex_tests[i].default_uri, received),
1650                             "Expected %s but got %s on test %d\n", sec_url_ex_tests[i].default_uri,
1651                             wine_dbgstr_w(received), i);
1652                     }
1653                 }
1654                 SysFreeString(received);
1655             }
1656             if(result) IUri_Release(result);
1657
1658             result = NULL;
1659             hr = pCoInternetGetSecurityUrlEx(uri, &result, PSU_SECURITY_URL_ONLY, 0);
1660             if(sec_url_ex_tests[i].todo) {
1661                 todo_wine
1662                     ok(hr == sec_url_ex_tests[i].default_hres,
1663                         "CoInternetGetSecurityUrlEx returned 0x%08x, expected 0x%08x on test %d\n",
1664                         hr, sec_url_ex_tests[i].default_hres, i);
1665             } else {
1666                 ok(hr == sec_url_ex_tests[i].default_hres,
1667                     "CoInternetGetSecurityUrlEx returned 0x%08x, expected 0x%08x on test %d\n",
1668                     hr, sec_url_ex_tests[i].default_hres, i);
1669             }
1670             if(SUCCEEDED(hr)) {
1671                 BSTR received;
1672
1673                 hr = IUri_GetDisplayUri(result, &received);
1674                 ok(hr == S_OK, "GetDisplayUri returned 0x%08x on test %d\n", hr, i);
1675                 if(hr == S_OK) {
1676                     if(sec_url_ex_tests[i].todo) {
1677                         todo_wine
1678                             ok(!strcmp_aw(sec_url_ex_tests[i].default_uri, received),
1679                                 "Expected %s but got %s on test %d\n", sec_url_ex_tests[i].default_uri,
1680                                 wine_dbgstr_w(received), i);
1681                     } else {
1682                         ok(!strcmp_aw(sec_url_ex_tests[i].default_uri, received),
1683                             "Expected %s but got %s on test %d\n", sec_url_ex_tests[i].default_uri,
1684                             wine_dbgstr_w(received), i);
1685                     }
1686                 }
1687                 SysFreeString(received);
1688             }
1689             if(result) IUri_Release(result);
1690         }
1691
1692         if(uri) IUri_Release(uri);
1693         heap_free(uriW);
1694     }
1695 }
1696
1697 static void test_InternetGetSecurityUrlEx_Pluggable(void)
1698 {
1699     HRESULT hr;
1700     IUri *uri = NULL, *result;
1701
1702     trace("testing CoInternetGetSecurityUrlEx for pluggable protocols...\n");
1703
1704     hr = pCreateUri(security_urlW, 0, 0, &uri);
1705     ok(hr == S_OK, "CreateUri returned 0x%08x\n", hr);
1706     if(hr == S_OK) {
1707         SET_EXPECT(ParseUrl_SECURITY_URL_input);
1708         SET_EXPECT(ParseUrl_SECURITY_URL_expected);
1709         SET_EXPECT(ParseUrl_SECURITY_DOMAIN_expected);
1710
1711         hr = pCoInternetGetSecurityUrlEx(uri, &result, PSU_DEFAULT, 0);
1712         ok(hr == S_OK, "CoInternetGetSecurityUrlEx returned 0x%08x, expected S_OK\n", hr);
1713
1714         CHECK_CALLED(ParseUrl_SECURITY_URL_input);
1715         CHECK_CALLED(ParseUrl_SECURITY_URL_expected);
1716         CHECK_CALLED(ParseUrl_SECURITY_DOMAIN_expected);
1717
1718         if(hr == S_OK) {
1719             BSTR received = NULL;
1720
1721             hr = IUri_GetAbsoluteUri(result, &received);
1722             ok(hr == S_OK, "GetAbsoluteUri returned 0x%08x\n", hr);
1723             if(hr == S_OK) {
1724                 ok(!strcmp_w(security_expectedW, received), "Expected %s but got %s\n",
1725                     wine_dbgstr_w(security_expectedW), wine_dbgstr_w(received));
1726             }
1727             SysFreeString(received);
1728         }
1729         if(result) IUri_Release(result);
1730
1731         result = NULL;
1732
1733         SET_EXPECT(ParseUrl_SECURITY_URL_input);
1734         SET_EXPECT(ParseUrl_SECURITY_URL_expected);
1735
1736         hr = pCoInternetGetSecurityUrlEx(uri, &result, PSU_SECURITY_URL_ONLY, 0);
1737         ok(hr == S_OK, "CoInternetGetSecurityUrlEx returned 0x%08x, expected S_OK\n", hr);
1738
1739         CHECK_CALLED(ParseUrl_SECURITY_URL_input);
1740         CHECK_CALLED(ParseUrl_SECURITY_URL_expected);
1741
1742         if(hr == S_OK) {
1743             BSTR received = NULL;
1744
1745             hr = IUri_GetAbsoluteUri(result, &received);
1746             ok(hr == S_OK, "GetAbsoluteUri returned 0x%08x\n", hr);
1747             if(hr == S_OK) {
1748                 ok(!strcmp_w(security_expectedW, received), "Expected %s but got %s\n",
1749                     wine_dbgstr_w(security_expectedW), wine_dbgstr_w(received));
1750             }
1751             SysFreeString(received);
1752         }
1753         if(result) IUri_Release(result);
1754     }
1755     if(uri) IUri_Release(uri);
1756 }
1757
1758 static const BYTE secidex2_1[] = {'z','i','p',':','/','/','t','e','s','t','i','n','g','.','c','o','m','/',3,0,0,0};
1759 static const BYTE secidex2_2[] = {'z','i','p',':','t','e','s','t','i','n','g','.','c','o','m',3,0,0,0};
1760 static const BYTE secidex2_3[] = {'*',':','t','e','s','t','i','n','g','.','c','o','m',3,0,0,0};
1761
1762 static const struct {
1763     const char  *uri;
1764     DWORD       create_flags;
1765     HRESULT     map_hres;
1766     DWORD       zone;
1767     BOOL        map_todo;
1768     const BYTE  *secid;
1769     DWORD       secid_size;
1770     HRESULT     secid_hres;
1771     BOOL        secid_todo;
1772 } sec_mgr_ex2_tests[] = {
1773     {"res://mshtml.dll/blank.htm",0,S_OK,URLZONE_LOCAL_MACHINE,FALSE,secid1,sizeof(secid1),S_OK},
1774     {"index.htm",Uri_CREATE_ALLOW_RELATIVE,0,URLZONE_INTERNET,FALSE,secid2,sizeof(secid2),S_OK},
1775     {"file://c:\\Index.html",0,0,URLZONE_LOCAL_MACHINE,FALSE,secid1,sizeof(secid1),S_OK},
1776     {"http://www.zone3.winetest/",0,0,URLZONE_INTERNET,FALSE,secid5,sizeof(secid5),S_OK},
1777     {"about:blank",0,0,URLZONE_INTERNET,FALSE,secid6,sizeof(secid6),S_OK},
1778     {"ftp://zone3.winetest/file.test",0,0,URLZONE_INTERNET,FALSE,secid7,sizeof(secid7),S_OK},
1779     {"/file/testing/test.test",Uri_CREATE_ALLOW_RELATIVE,0,URLZONE_INTERNET,FALSE,NULL,0,E_INVALIDARG},
1780     {"zip://testing.com/",0,0,URLZONE_INTERNET,FALSE,secidex2_1,sizeof(secidex2_1),S_OK},
1781     {"zip:testing.com",0,0,URLZONE_INTERNET,FALSE,secidex2_2,sizeof(secidex2_2),S_OK},
1782     {"http:google.com",0,S_OK,URLZONE_INVALID,FALSE,NULL,0,E_INVALIDARG},
1783     {"http:/google.com",0,S_OK,URLZONE_INVALID,FALSE,NULL,0,E_INVALIDARG},
1784     {"*:/testing",0,S_OK,URLZONE_INTERNET,FALSE,NULL,0,E_INVALIDARG},
1785     {"*://testing.com",0,S_OK,URLZONE_INTERNET,FALSE,secidex2_3,sizeof(secidex2_3),S_OK}
1786 };
1787
1788 static void test_SecurityManagerEx2(void)
1789 {
1790     HRESULT hres;
1791     DWORD i, zone;
1792     BYTE buf[512];
1793     DWORD buf_size = sizeof(buf);
1794     IInternetSecurityManager *sec_mgr;
1795     IInternetSecurityManagerEx2 *sec_mgr2;
1796     IUri *uri = NULL;
1797
1798     static const WCHAR domainW[] = {'c','o','m','.','u','k',0};
1799
1800     if(!pCreateUri) {
1801         win_skip("Skipping SecurityManagerEx2, IE is too old\n");
1802         return;
1803     }
1804
1805     trace("Testing SecurityManagerEx2...\n");
1806
1807     hres = pCoInternetCreateSecurityManager(NULL, &sec_mgr, 0);
1808     ok(hres == S_OK, "CoInternetCreateSecurityManager failed: %08x\n", hres);
1809
1810     hres = IInternetSecurityManager_QueryInterface(sec_mgr, &IID_IInternetSecurityManagerEx2, (void**)&sec_mgr2);
1811     ok(hres == S_OK, "QueryInterface(IID_IInternetSecurityManagerEx2) failed: %08x\n", hres);
1812
1813     zone = 0xdeadbeef;
1814
1815     hres = IInternetSecurityManagerEx2_MapUrlToZoneEx2(sec_mgr2, NULL, &zone, 0, NULL, NULL);
1816     ok(hres == E_INVALIDARG, "MapUrlToZoneEx2 returned %08x, expected E_INVALIDARG\n", hres);
1817     ok(zone == URLZONE_INVALID, "zone was %d\n", zone);
1818
1819     hres = IInternetSecurityManagerEx2_GetSecurityIdEx2(sec_mgr2, NULL, buf, &buf_size, 0);
1820     ok(hres == E_INVALIDARG, "GetSecurityIdEx2 returned %08x, expected E_INVALIDARG\n", hres);
1821     ok(buf_size == sizeof(buf), "buf_size was %d\n", buf_size);
1822
1823     hres = pCreateUri(url5, 0, 0, &uri);
1824     ok(hres == S_OK, "CreateUri failed: %08x\n", hres);
1825
1826     hres = IInternetSecurityManagerEx2_MapUrlToZoneEx2(sec_mgr2, uri, NULL, 0, NULL, NULL);
1827     ok(hres == E_INVALIDARG, "MapToUrlZoneEx2 returned %08x, expected E_INVALIDARG\n", hres);
1828
1829     buf_size = sizeof(buf);
1830     hres = IInternetSecurityManagerEx2_GetSecurityIdEx2(sec_mgr2, uri, NULL, &buf_size, 0);
1831     ok(hres == E_INVALIDARG || broken(hres == S_OK), "GetSecurityIdEx2 failed: %08x\n", hres);
1832     ok(buf_size == sizeof(buf), "bug_size was %d\n", buf_size);
1833
1834     hres = IInternetSecurityManagerEx2_GetSecurityIdEx2(sec_mgr2, uri, buf, NULL, 0);
1835     ok(hres == E_INVALIDARG, "GetSecurityIdEx2 returned %08x, expected E_INVALIDARG\n", hres);
1836
1837     IUri_Release(uri);
1838
1839     for(i = 0; i < sizeof(sec_mgr_ex2_tests)/sizeof(sec_mgr_ex2_tests[0]); ++i) {
1840         LPWSTR uriW = a2w(sec_mgr_ex2_tests[i].uri);
1841
1842         uri = NULL;
1843         zone = URLZONE_INVALID;
1844
1845         hres = pCreateUri(uriW, sec_mgr_ex2_tests[i].create_flags, 0, &uri);
1846         ok(hres == S_OK, "CreateUri returned %08x for '%s'\n", hres, sec_mgr_ex2_tests[i].uri);
1847
1848         hres = IInternetSecurityManagerEx2_MapUrlToZoneEx2(sec_mgr2, uri, &zone, 0, NULL, NULL);
1849         if(sec_mgr_ex2_tests[i].map_todo) {
1850             todo_wine
1851                 ok(hres == sec_mgr_ex2_tests[i].map_hres, "MapUrlZoneToEx2 returned %08x, expected %08x for '%s'\n",
1852                     hres, sec_mgr_ex2_tests[i].map_hres, sec_mgr_ex2_tests[i].uri);
1853             todo_wine
1854                 ok(zone == sec_mgr_ex2_tests[i].zone, "Expected zone %d, but got %d for '%s'\n", sec_mgr_ex2_tests[i].zone,
1855                     zone, sec_mgr_ex2_tests[i].uri);
1856         } else {
1857             ok(hres == sec_mgr_ex2_tests[i].map_hres, "MapUrlToZoneEx2 returned %08x, expected %08x for '%s'\n",
1858                 hres, sec_mgr_ex2_tests[i].map_hres, sec_mgr_ex2_tests[i].uri);
1859             ok(zone == sec_mgr_ex2_tests[i].zone, "Expected zone %d, but got %d for '%s'\n", sec_mgr_ex2_tests[i].zone,
1860                 zone, sec_mgr_ex2_tests[i].uri);
1861         }
1862
1863         buf_size = sizeof(buf);
1864         memset(buf, 0xf0, buf_size);
1865
1866         hres = IInternetSecurityManagerEx2_GetSecurityIdEx2(sec_mgr2, uri, buf, &buf_size, 0);
1867         if(sec_mgr_ex2_tests[i].secid_todo) {
1868             todo_wine
1869                 ok(hres == sec_mgr_ex2_tests[i].secid_hres, "GetSecurityIdEx2 returned %08x, expected %08x on test '%s'\n",
1870                     hres, sec_mgr_ex2_tests[i].secid_hres, sec_mgr_ex2_tests[i].uri);
1871             if(sec_mgr_ex2_tests[i].secid) {
1872                 todo_wine {
1873                     ok(buf_size == sec_mgr_ex2_tests[i].secid_size, "Got wrong security id size=%d, expected %d on test '%s'\n",
1874                         buf_size, sec_mgr_ex2_tests[i].secid_size, sec_mgr_ex2_tests[i].uri);
1875                     ok(!memcmp(buf, sec_mgr_ex2_tests[i].secid, sec_mgr_ex2_tests[i].secid_size), "Got wrong security id on test '%s'\n",
1876                         sec_mgr_ex2_tests[i].uri);
1877                 }
1878             }
1879         } else {
1880             ok(hres == sec_mgr_ex2_tests[i].secid_hres, "GetSecurityIdEx2 returned %08x, expected %08x on test '%s'\n",
1881                 hres, sec_mgr_ex2_tests[i].secid_hres, sec_mgr_ex2_tests[i].uri);
1882             if(sec_mgr_ex2_tests[i].secid) {
1883                 ok(buf_size == sec_mgr_ex2_tests[i].secid_size, "Got wrong security id size=%d, expected %d on test '%s'\n",
1884                     buf_size, sec_mgr_ex2_tests[i].secid_size, sec_mgr_ex2_tests[i].uri);
1885                 ok(!memcmp(buf, sec_mgr_ex2_tests[i].secid, sec_mgr_ex2_tests[i].secid_size), "Got wrong security id on test '%s'\n",
1886                     sec_mgr_ex2_tests[i].uri);
1887             }
1888         }
1889
1890         heap_free(uriW);
1891         IUri_Release(uri);
1892     }
1893
1894     hres = pCreateUri(url15, 0, 0, &uri);
1895     ok(hres == S_OK, "CreateUri failed: %08x\n", hres);
1896
1897     buf_size = sizeof(buf);
1898     memset(buf, 0xf0, buf_size);
1899
1900     hres = IInternetSecurityManagerEx2_GetSecurityIdEx2(sec_mgr2, uri, buf, &buf_size, (DWORD_PTR)domainW);
1901     ok(hres == S_OK, "GetSecurityIdEx2 failed: %08x\n", hres);
1902     todo_wine ok(buf_size == sizeof(secid13), "buf_size was %d\n", buf_size);
1903     todo_wine ok(!memcmp(buf, secid13, sizeof(secid13)), "Got wrong secid\n");
1904
1905     buf_size = sizeof(buf);
1906     memset(buf, 0xf0, buf_size);
1907
1908     hres = IInternetSecurityManagerEx2_GetSecurityIdEx2(sec_mgr2, uri, buf, &buf_size, 0);
1909     ok(hres == S_OK, "GetSecurityIdEx2 failed: %08x\n", hres);
1910     ok(buf_size == sizeof(secid13_2), "buf_size was %d\n", buf_size);
1911     ok(!memcmp(buf, secid13_2, sizeof(secid13_2)), "Got wrong secid\n");
1912
1913     IUri_Release(uri);
1914
1915     IInternetSecurityManagerEx2_Release(sec_mgr2);
1916     IInternetSecurityManager_Release(sec_mgr);
1917 }
1918
1919 static void test_CoInternetIsFeatureZoneElevationEnabled(void)
1920 {
1921     struct {
1922         const char *url_from;
1923         const char *url_to;
1924         DWORD flags;
1925         HRESULT hres;
1926         DWORD policy_flags;
1927     } testcases[] = {
1928         /*  0 */ { "http://www.winehq.org", "http://www.winehq.org", 0, S_FALSE, URLPOLICY_ALLOW },
1929         /*  1 */ { "http://www.winehq.org", "http://www.winehq.org", 0, S_OK, URLPOLICY_DISALLOW },
1930         /*  2 */ { "http://www.winehq.org", "http://www.codeweavers.com", 0, S_FALSE, URLPOLICY_ALLOW },
1931         /*  3 */ { "http://www.winehq.org", "http://www.codeweavers.com", 0, S_OK, URLPOLICY_DISALLOW },
1932         /*  4 */ { "http://www.winehq.org", "http://www.winehq.org", GET_FEATURE_FROM_PROCESS, S_FALSE, -1 },
1933         /*  5 */ { "http://www.winehq.org", "http://www.winehq.org/dir", GET_FEATURE_FROM_PROCESS, S_FALSE, -1 },
1934         /*  6 */ { "http://www.winehq.org", "http://www.codeweavers.com", GET_FEATURE_FROM_PROCESS, S_FALSE, -1 },
1935         /*  7 */ { "http://www.winehq.org", "ftp://winehq.org", GET_FEATURE_FROM_PROCESS, S_FALSE, -1 },
1936         /*  8 */ { "http://www.winehq.org", "ftp://winehq.org", GET_FEATURE_FROM_PROCESS|0x100, S_FALSE, URLPOLICY_ALLOW },
1937         /*  9 */ { "http://www.winehq.org", "ftp://winehq.org", GET_FEATURE_FROM_REGISTRY, S_FALSE, URLPOLICY_ALLOW },
1938     };
1939
1940     WCHAR *url_from, *url_to;
1941     int i;
1942     HRESULT hres;
1943
1944     if(!pCoInternetIsFeatureZoneElevationEnabled || !pCoInternetIsFeatureEnabled
1945             || !pCoInternetIsFeatureEnabledForUrl) {
1946         win_skip("Skipping CoInternetIsFeatureZoneElevationEnabled tests\n");
1947         return;
1948     }
1949
1950
1951     hres = pCoInternetIsFeatureEnabled(FEATURE_ZONE_ELEVATION, GET_FEATURE_FROM_PROCESS);
1952     ok(SUCCEEDED(hres), "CoInternetIsFeatureEnabled returned %x\n", hres);
1953
1954     trace("Testing CoInternetIsFeatureZoneElevationEnabled... (%x)\n", hres);
1955
1956     for(i=0; i<sizeof(testcases)/sizeof(testcases[0]); i++) {
1957         if(hres==S_OK && testcases[i].flags == GET_FEATURE_FROM_PROCESS)
1958             testcases[i].policy_flags = URLPOLICY_ALLOW;
1959     }
1960
1961     for(i=0; i<sizeof(testcases)/sizeof(testcases[0]); i++) {
1962         url_from = a2w(testcases[i].url_from);
1963         url_to = a2w(testcases[i].url_to);
1964
1965         if(testcases[i].policy_flags != -1) {
1966             ProcessUrlAction_policy = testcases[i].policy_flags;
1967             SET_EXPECT(ProcessUrlAction);
1968         }
1969         hres = pCoInternetIsFeatureZoneElevationEnabled(url_from, url_to,
1970                 &security_manager, testcases[i].flags);
1971         ok(hres == testcases[i].hres, "%d) CoInternetIsFeatureZoneElevationEnabled returned %x\n", i, hres);
1972         if(testcases[i].policy_flags != -1)
1973             CHECK_CALLED(ProcessUrlAction);
1974
1975         if(testcases[i].policy_flags != -1)
1976             SET_EXPECT(ProcessUrlAction);
1977         hres = pCoInternetIsFeatureEnabledForUrl(FEATURE_ZONE_ELEVATION,
1978                 testcases[i].flags, url_to, &security_manager);
1979         ok(hres == testcases[i].hres, "%d) CoInternetIsFeatureEnabledForUrl returned %x\n", i, hres);
1980         if(testcases[i].policy_flags != -1)
1981             CHECK_CALLED(ProcessUrlAction);
1982
1983         heap_free(url_from);
1984         heap_free(url_to);
1985     }
1986 }
1987
1988 START_TEST(sec_mgr)
1989 {
1990     HMODULE hurlmon;
1991     int argc;
1992     char **argv;
1993
1994     hurlmon = GetModuleHandle("urlmon.dll");
1995     pCoInternetCreateSecurityManager = (void*) GetProcAddress(hurlmon, "CoInternetCreateSecurityManager");
1996     pCoInternetCreateZoneManager = (void*) GetProcAddress(hurlmon, "CoInternetCreateZoneManager");
1997     pCoInternetGetSecurityUrl = (void*) GetProcAddress(hurlmon, "CoInternetGetSecurityUrl");
1998     pCoInternetGetSecurityUrlEx = (void*) GetProcAddress(hurlmon, "CoInternetGetSecurityUrlEx");
1999     pCreateUri = (void*) GetProcAddress(hurlmon, "CreateUri");
2000     pCoInternetGetSession = (void*) GetProcAddress(hurlmon, "CoInternetGetSession");
2001     pCoInternetIsFeatureEnabled = (void*) GetProcAddress(hurlmon, "CoInternetIsFeatureEnabled");
2002     pCoInternetIsFeatureEnabledForUrl = (void*) GetProcAddress(hurlmon, "CoInternetIsFeatureEnabledForUrl");
2003     pCoInternetIsFeatureZoneElevationEnabled = (void*) GetProcAddress(hurlmon, "CoInternetIsFeatureZoneElevationEnabled");
2004
2005     if (!pCoInternetCreateSecurityManager || !pCoInternetCreateZoneManager ||
2006         !pCoInternetGetSecurityUrl) {
2007         win_skip("Various CoInternet* functions not present in IE 4.0\n");
2008         return;
2009     }
2010
2011     argc = winetest_get_mainargs(&argv);
2012     if(argc > 2 && !strcmp(argv[2], "domain_tests")) {
2013         test_zone_domain_mappings();
2014         return;
2015     }
2016
2017     OleInitialize(NULL);
2018     register_protocols();
2019
2020     test_InternetGetSecurityUrl();
2021
2022     if(!pCoInternetGetSecurityUrlEx || !pCreateUri)
2023         win_skip("Skipping CoInternetGetSecurityUrlEx tests, IE too old\n");
2024     else {
2025         test_InternetGetSecurityUrlEx();
2026         test_InternetGetSecurityUrlEx_Pluggable();
2027     }
2028
2029     test_SecurityManager();
2030     test_SecurityManagerEx2();
2031     test_polices();
2032     test_zone_domains();
2033     test_CoInternetCreateZoneManager();
2034     test_CreateZoneEnumerator();
2035     test_GetZoneActionPolicy();
2036     test_GetZoneAt();
2037     test_GetZoneAttributes();
2038     test_SetZoneAttributes();
2039     test_InternetSecurityMarshalling();
2040     test_CoInternetIsFeatureZoneElevationEnabled();
2041
2042     unregister_protocols();
2043     OleUninitialize();
2044 }