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

   1 /*
   2  * Internet Security and Zone Manager
   3  *
   4  * Copyright (c) 2004 Huw D M Davies
   5  * Copyright 2004 Jacek Caban
   6  * Copyright 2009 Detlef Riekenberg
   7  * Copyright 2011 Thomas Mullaly for CodeWeavers
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include <stdio.h>
  25
  26 #include "urlmon_main.h"
  27 #include "winreg.h"
  28 #include "wininet.h"
  29
  30 #define NO_SHLWAPI_REG
  31 #include "shlwapi.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  36
  37 static const WCHAR currentlevelW[] = {'C','u','r','r','e','n','t','L','e','v','e','l',0};
  38 static const WCHAR descriptionW[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
  39 static const WCHAR displaynameW[] = {'D','i','s','p','l','a','y','N','a','m','e',0};
  40 static const WCHAR fileW[] = {'f','i','l','e',0};
  41 static const WCHAR flagsW[] = {'F','l','a','g','s',0};
  42 static const WCHAR iconW[] = {'I','c','o','n',0};
  43 static const WCHAR minlevelW[] = {'M','i','n','L','e','v','e','l',0};
  44 static const WCHAR recommendedlevelW[] = {'R','e','c','o','m','m','e','n','d','e','d',
  45                                           'L','e','v','e','l',0};
  46 static const WCHAR wszZonesKey[] = {'S','o','f','t','w','a','r','e','\\',
  47                                     'M','i','c','r','o','s','o','f','t','\\',
  48                                     'W','i','n','d','o','w','s','\\',
  49                                     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  50                                     'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s','\\',
  51                                     'Z','o','n','e','s','\\',0};
  52 static const WCHAR wszZoneMapDomainsKey[] = {'S','o','f','t','w','a','r','e','\\',
  53                                              'M','i','c','r','o','s','o','f','t','\\',
  54                                              'W','i','n','d','o','w','s','\\',
  55                                              'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  56                                              'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s','\\',
  57                                              'Z','o','n','e','M','a','p','\\',
  58                                              'D','o','m','a','i','n','s',0};
  59
  60 /********************************************************************
  61  * get_string_from_reg [internal]
  62  *
  63  * helper to get a string from the reg.
  64  *
  65  */
  66 static void get_string_from_reg(HKEY hcu, HKEY hklm, LPCWSTR name, LPWSTR out, DWORD maxlen)
  67 {
  68     DWORD type = REG_SZ;
  69     DWORD len = maxlen * sizeof(WCHAR);
  70     DWORD res;
  71
  72     res = RegQueryValueExW(hcu, name, NULL, &type, (LPBYTE) out, &len);
  73
  74     if (res && hklm) {
  75         len = maxlen * sizeof(WCHAR);
  76         type = REG_SZ;
  77         res = RegQueryValueExW(hklm, name, NULL, &type, (LPBYTE) out, &len);
  78     }
  79
  80     if (res) {
  81         TRACE("%s failed: %d\n", debugstr_w(name), res);
  82         *out = '\0';
  83     }
  84 }
  85
  86 /********************************************************************
  87  * get_dword_from_reg [internal]
  88  *
  89  * helper to get a dword from the reg.
  90  *
  91  */
  92 static void get_dword_from_reg(HKEY hcu, HKEY hklm, LPCWSTR name, LPDWORD out)
  93 {
  94     DWORD type = REG_DWORD;
  95     DWORD len = sizeof(DWORD);
  96     DWORD res;
  97
  98     res = RegQueryValueExW(hcu, name, NULL, &type, (LPBYTE) out, &len);
  99
 100     if (res && hklm) {
 101         len = sizeof(DWORD);
 102         type = REG_DWORD;
 103         res = RegQueryValueExW(hklm, name, NULL, &type, (LPBYTE) out, &len);
 104     }
 105
 106     if (res) {
 107         TRACE("%s failed: %d\n", debugstr_w(name), res);
 108         *out = 0;
 109     }
 110 }
 111
 112 static HRESULT get_zone_from_reg(LPCWSTR schema, DWORD *zone)
 113 {
 114     DWORD res, size;
 115     HKEY hkey;
 116
 117     static const WCHAR wszZoneMapProtocolKey[] =
 118         {'S','o','f','t','w','a','r','e','\\',
 119          'M','i','c','r','o','s','o','f','t','\\',
 120          'W','i','n','d','o','w','s','\\',
 121          'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 122          'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s','\\',
 123          'Z','o','n','e','M','a','p','\\',
 124          'P','r','o','t','o','c','o','l','D','e','f','a','u','l','t','s',0};
 125
 126     res = RegOpenKeyW(HKEY_CURRENT_USER, wszZoneMapProtocolKey, &hkey);
 127     if(res != ERROR_SUCCESS) {
 128         ERR("Could not open key %s\n", debugstr_w(wszZoneMapProtocolKey));
 129         return E_UNEXPECTED;
 130     }
 131
 132     size = sizeof(DWORD);
 133     res = RegQueryValueExW(hkey, schema, NULL, NULL, (PBYTE)zone, &size);
 134     RegCloseKey(hkey);
 135     if(res == ERROR_SUCCESS)
 136         return S_OK;
 137
 138     res = RegOpenKeyW(HKEY_LOCAL_MACHINE, wszZoneMapProtocolKey, &hkey);
 139     if(res != ERROR_SUCCESS) {
 140         ERR("Could not open key %s\n", debugstr_w(wszZoneMapProtocolKey));
 141         return E_UNEXPECTED;
 142     }
 143
 144     size = sizeof(DWORD);
 145     res = RegQueryValueExW(hkey, schema, NULL, NULL, (PBYTE)zone, &size);
 146     RegCloseKey(hkey);
 147     if(res == ERROR_SUCCESS)
 148         return S_OK;
 149
 150     *zone = 3;
 151     return S_OK;
 152 }
 153
 154 /********************************************************************
 155  * matches_domain_pattern [internal]
 156  *
 157  * Checks if the given string matches the specified domain pattern.
 158  *
 159  * This function looks for explicit wildcard domain components iff
 160  * they appear at the very beginning of the 'pattern' string
 161  *
 162  *  pattern = "*.google.com"
 163  */
 164 static BOOL matches_domain_pattern(LPCWSTR pattern, LPCWSTR str, BOOL implicit_wildcard, LPCWSTR *matched)
 165 {
 166     BOOL matches = FALSE;
 167     DWORD pattern_len = strlenW(pattern);
 168     DWORD str_len = strlenW(str);
 169
 170     TRACE("(%d) Checking if %s matches %s\n", implicit_wildcard, debugstr_w(str), debugstr_w(pattern));
 171
 172     *matched = NULL;
 173     if(str_len >= pattern_len) {
 174         /* Check if there's an explicit wildcard in the pattern. */
 175         if(pattern[0] == '*' && pattern[1] == '.') {
 176             /* Make sure that 'str' matches the wildcard pattern.
 177              *
 178              * Example:
 179              *  pattern = "*.google.com"
 180              *
 181              * So in this case 'str' would have to end with ".google.com" in order
 182              * to map to this pattern.
 183              */
 184             if(str_len >= pattern_len+1 && !strcmpiW(str+(str_len-pattern_len+1), pattern+1)) {
 185                 /* Check if there's another '.' inside of the "unmatched" portion
 186                  * of 'str'.
 187                  *
 188                  * Example:
 189                  *  pattern = "*.google.com"
 190                  *  str     = "test.testing.google.com"
 191                  *
 192                  * The currently matched portion is ".google.com" in 'str', we need
 193                  * see if there's a '.' inside of the unmatched portion ("test.testing"), because
 194                  * if there is and 'implicit_wildcard' isn't set, then this isn't
 195                  * a match.
 196                  */
 197                 const WCHAR *ptr;
 198                 if(str_len > pattern_len+1 && (ptr = memrchrW(str, '.', str_len-pattern_len-2))) {
 199                     if(implicit_wildcard) {
 200                         matches = TRUE;
 201                         *matched = ptr+1;
 202                     }
 203                 } else {
 204                     matches = TRUE;
 205                     *matched = str;
 206                 }
 207             }
 208         } else if(implicit_wildcard && str_len > pattern_len) {
 209             /* When the pattern has an implicit wildcard component, it means
 210              * that anything goes in 'str' as long as it ends with the pattern
 211              * and that the beginning of the match has a '.' before it.
 212              *
 213              * Example:
 214              *  pattern = "google.com"
 215              *  str     = "www.google.com"
 216              *
 217              * Implicitly matches the pattern, where as:
 218              *
 219              *  pattern = "google.com"
 220              *  str     = "wwwgoogle.com"
 221              *
 222              * Doesn't match the pattern.
 223              */
 224             if(str_len > pattern_len) {
 225                 if(str[str_len-pattern_len-1] == '.' && !strcmpiW(str+(str_len-pattern_len), pattern)) {
 226                     matches = TRUE;
 227                     *matched = str+(str_len-pattern_len);
 228                 }
 229             }
 230         } else {
 231             /* The pattern doesn't have an implicit wildcard, or an explicit wildcard,
 232              * so 'str' has to be an exact match to the 'pattern'.
 233              */
 234             if(!strcmpiW(str, pattern)) {
 235                 matches = TRUE;
 236                 *matched = str;
 237             }
 238         }
 239     }
 240
 241     if(matches)
 242         TRACE("Found a match: matched=%s\n", debugstr_w(*matched));
 243     else
 244         TRACE("No match found\n");
 245
 246     return matches;
 247 }
 248
 249 static BOOL get_zone_for_scheme(HKEY key, LPCWSTR schema, DWORD *zone)
 250 {
 251     static const WCHAR wildcardW[] = {'*',0};
 252
 253     DWORD res;
 254     DWORD size = sizeof(DWORD);
 255     DWORD type;
 256
 257     /* See if the key contains a value for the scheme first. */
 258     res = RegQueryValueExW(key, schema, NULL, &type, (BYTE*)zone, &size);
 259     if(type != REG_DWORD)
 260         WARN("Unexpected value type %d for value %s, expected REG_DWORD\n", type, debugstr_w(schema));
 261
 262     if(res != ERROR_SUCCESS || type != REG_DWORD) {
 263         /* Try to get the zone for the wildcard scheme. */
 264         size = sizeof(DWORD);
 265         res = RegQueryValueExW(key, wildcardW, NULL, &type, (BYTE*)zone, &size);
 266         if(type != REG_DWORD)
 267             WARN("Unexpected value type %d for value %s, expected REG_DWORD\n", type, debugstr_w(wildcardW));
 268     }
 269
 270     return res == ERROR_SUCCESS && type == REG_DWORD;
 271 }
 272
 273 /********************************************************************
 274  * search_domain_for_zone [internal]
 275  *
 276  * Searches the specified 'domain' registry key to see if 'host' maps into it, or any
 277  * of it's subdomain registry keys.
 278  *
 279  * Returns S_OK if a match is found, S_FALSE if no matches were found, or an error code.
 280  */
 281 static HRESULT search_domain_for_zone(HKEY domains, LPCWSTR domain, DWORD domain_len, LPCWSTR schema,
 282                                       LPCWSTR host, DWORD host_len, DWORD *zone)
 283 {
 284     BOOL found = FALSE;
 285     HKEY domain_key;
 286     DWORD res;
 287     LPCWSTR matched;
 288
 289     if(host_len >= domain_len && matches_domain_pattern(domain, host, TRUE, &matched)) {
 290         res = RegOpenKeyW(domains, domain, &domain_key);
 291         if(res != ERROR_SUCCESS) {
 292             ERR("Failed to open domain key %s: %d\n", debugstr_w(domain), res);
 293             return E_UNEXPECTED;
 294         }
 295
 296         if(matched == host)
 297             found = get_zone_for_scheme(domain_key, schema, zone);
 298         else {
 299             INT domain_offset;
 300             DWORD subdomain_count, subdomain_len;
 301             BOOL check_domain = TRUE;
 302
 303             find_domain_name(domain, domain_len, &domain_offset);
 304
 305             res = RegQueryInfoKeyW(domain_key, NULL, NULL, NULL, &subdomain_count, &subdomain_len,
 306                                    NULL, NULL, NULL, NULL, NULL, NULL);
 307             if(res != ERROR_SUCCESS) {
 308                 ERR("Unable to query info for key %s: %d\n", debugstr_w(domain), res);
 309                 RegCloseKey(domain_key);
 310                 return E_UNEXPECTED;
 311             }
 312
 313             if(subdomain_count) {
 314                 WCHAR *subdomain;
 315                 WCHAR *component;
 316                 DWORD i;
 317
 318                 subdomain = heap_alloc((subdomain_len+1)*sizeof(WCHAR));
 319                 if(!subdomain) {
 320                     RegCloseKey(domain_key);
 321                     return E_OUTOFMEMORY;
 322                 }
 323
 324                 component = heap_strndupW(host, matched-host-1);
 325                 if(!component) {
 326                     heap_free(subdomain);
 327                     RegCloseKey(domain_key);
 328                     return E_OUTOFMEMORY;
 329                 }
 330
 331                 for(i = 0; i < subdomain_count; ++i) {
 332                     DWORD len = subdomain_len+1;
 333                     const WCHAR *sub_matched;
 334
 335                     res = RegEnumKeyExW(domain_key, i, subdomain, &len, NULL, NULL, NULL, NULL);
 336                     if(res != ERROR_SUCCESS) {
 337                         heap_free(component);
 338                         heap_free(subdomain);
 339                         RegCloseKey(domain_key);
 340                         return E_UNEXPECTED;
 341                     }
 342
 343                     if(matches_domain_pattern(subdomain, component, FALSE, &sub_matched)) {
 344                         HKEY subdomain_key;
 345
 346                         res = RegOpenKeyW(domain_key, subdomain, &subdomain_key);
 347                         if(res != ERROR_SUCCESS) {
 348                             ERR("Unable to open subdomain key %s of %s: %d\n", debugstr_w(subdomain),
 349                                 debugstr_w(domain), res);
 350                             heap_free(component);
 351                             heap_free(subdomain);
 352                             RegCloseKey(domain_key);
 353                             return E_UNEXPECTED;
 354                         }
 355
 356                         found = get_zone_for_scheme(subdomain_key, schema, zone);
 357                         check_domain = FALSE;
 358                         RegCloseKey(subdomain_key);
 359                         break;
 360                     }
 361                 }
 362                 heap_free(subdomain);
 363                 heap_free(component);
 364             }
 365
 366             /* There's a chance that 'host' implicitly mapped into 'domain', in
 367              * which case we check to see if 'domain' contains zone information.
 368              *
 369              * This can only happen if 'domain' is it's own domain name.
 370              *  Example:
 371              *      "google.com" (domain name = "google.com")
 372              *
 373              *  So if:
 374              *      host = "www.google.com"
 375              *
 376              *  Then host would map directly into the "google.com" domain key.
 377              *
 378              * If 'domain' has more than just it's domain name, or it does not
 379              * have a domain name, then we don't perform the check. The reason
 380              * for this is that these domains don't allow implicit mappings.
 381              *  Example:
 382              *      domain = "org" (has no domain name)
 383              *      host   = "www.org"
 384              *
 385              *  The mapping would only happen if the "org" key had an explicit subkey
 386              *  called "www".
 387              */
 388             if(check_domain && !domain_offset && !strchrW(host, matched-host-1))
 389                 found = get_zone_for_scheme(domain_key, schema, zone);
 390         }
 391         RegCloseKey(domain_key);
 392     }
 393
 394     return found ? S_OK : S_FALSE;
 395 }
 396
 397 static HRESULT search_for_domain_mapping(HKEY domains, LPCWSTR schema, LPCWSTR host, DWORD host_len, DWORD *zone)
 398 {
 399     WCHAR *domain;
 400     DWORD domain_count, domain_len, i;
 401     DWORD res;
 402     HRESULT hres = S_FALSE;
 403
 404     res = RegQueryInfoKeyW(domains, NULL, NULL, NULL, &domain_count, &domain_len,
 405                            NULL, NULL, NULL, NULL, NULL, NULL);
 406     if(res != ERROR_SUCCESS) {
 407         WARN("Failed to retrieve information about key\n");
 408         return E_UNEXPECTED;
 409     }
 410
 411     if(!domain_count)
 412         return S_FALSE;
 413
 414     domain = heap_alloc((domain_len+1)*sizeof(WCHAR));
 415     if(!domain)
 416         return E_OUTOFMEMORY;
 417
 418     for(i = 0; i < domain_count; ++i) {
 419         DWORD len = domain_len+1;
 420
 421         res = RegEnumKeyExW(domains, i, domain, &len, NULL, NULL, NULL, NULL);
 422         if(res != ERROR_SUCCESS) {
 423             heap_free(domain);
 424             return E_UNEXPECTED;
 425         }
 426
 427         hres = search_domain_for_zone(domains, domain, len, schema, host, host_len, zone);
 428         if(FAILED(hres) || hres == S_OK)
 429             break;
 430     }
 431
 432     heap_free(domain);
 433     return hres;
 434 }
 435
 436 static HRESULT get_zone_from_domains(LPCWSTR url, LPCWSTR schema, DWORD *zone)
 437 {
 438     HRESULT hres;
 439     WCHAR *host_name;
 440     DWORD host_len = lstrlenW(url)+1;
 441     DWORD res;
 442     HKEY domains;
 443
 444     host_name = heap_alloc(host_len*sizeof(WCHAR));
 445     if(!host_name)
 446         return E_OUTOFMEMORY;
 447
 448     hres = CoInternetParseUrl(url, PARSE_DOMAIN, 0, host_name, host_len, &host_len, 0);
 449     if(hres == S_FALSE) {
 450         WCHAR *tmp = heap_realloc(host_name, (host_len+1)*sizeof(WCHAR));
 451         if(!tmp) {
 452             heap_free(host_name);
 453             return E_OUTOFMEMORY;
 454         }
 455
 456         host_name = tmp;
 457         hres = CoInternetParseUrl(url, PARSE_DOMAIN, 0, host_name, host_len+1, &host_len, 0);
 458     }
 459
 460     /* Windows doesn't play nice with unknown scheme types when it tries
 461      * to check if a host name maps into any domains.
 462      *
 463      * The reason is with how CoInternetParseUrl handles unknown scheme types
 464      * when it's parsing the domain of a URL (IE it always returns E_FAIL).
 465      *
 466      * Windows doesn't compenstate for this and simply doesn't check if
 467      * the URL maps into any domains.
 468      */
 469     if(hres != S_OK) {
 470         heap_free(host_name);
 471         if(hres == E_FAIL)
 472             return S_FALSE;
 473         return hres;
 474     }
 475
 476     /* First try CURRENT_USER. */
 477     res = RegOpenKeyW(HKEY_CURRENT_USER, wszZoneMapDomainsKey, &domains);
 478     if(res == ERROR_SUCCESS) {
 479         hres = search_for_domain_mapping(domains, schema, host_name, host_len, zone);
 480         RegCloseKey(domains);
 481     } else
 482         WARN("Failed to open HKCU's %s key\n", debugstr_w(wszZoneMapDomainsKey));
 483
 484     /* If that doesn't work try LOCAL_MACHINE. */
 485     if(hres == S_FALSE) {
 486         res = RegOpenKeyW(HKEY_LOCAL_MACHINE, wszZoneMapDomainsKey, &domains);
 487         if(res == ERROR_SUCCESS) {
 488             hres = search_for_domain_mapping(domains, schema, host_name, host_len, zone);
 489             RegCloseKey(domains);
 490         } else
 491             WARN("Failed to open HKLM's %s key\n", debugstr_w(wszZoneMapDomainsKey));
 492     }
 493
 494     heap_free(host_name);
 495     return hres;
 496 }
 497
 498 static HRESULT map_url_to_zone(LPCWSTR url, DWORD *zone, LPWSTR *ret_url)
 499 {
 500     LPWSTR secur_url;
 501     WCHAR schema[64];
 502     DWORD size=0;
 503     HRESULT hres;
 504
 505     *zone = URLZONE_INVALID;
 506
 507     hres = CoInternetGetSecurityUrl(url, &secur_url, PSU_SECURITY_URL_ONLY, 0);
 508     if(hres != S_OK) {
 509         size = strlenW(url)*sizeof(WCHAR);
 510
 511         secur_url = heap_alloc(size);
 512         if(!secur_url)
 513             return E_OUTOFMEMORY;
 514
 515         memcpy(secur_url, url, size);
 516     }
 517
 518     hres = CoInternetParseUrl(secur_url, PARSE_SCHEMA, 0, schema, sizeof(schema)/sizeof(WCHAR), &size, 0);
 519     if(FAILED(hres) || !*schema) {
 520         heap_free(secur_url);
 521         return E_INVALIDARG;
 522     }
 523
 524     /* file protocol is a special case */
 525     if(!strcmpW(schema, fileW)) {
 526         WCHAR path[MAX_PATH], root[20];
 527         WCHAR *ptr;
 528
 529         hres = CoInternetParseUrl(secur_url, PARSE_PATH_FROM_URL, 0, path,
 530                 sizeof(path)/sizeof(WCHAR), &size, 0);
 531
 532         if(SUCCEEDED(hres) && (ptr = strchrW(path, '\\')) && ptr-path < sizeof(root)/sizeof(WCHAR)) {
 533             UINT type;
 534
 535             memcpy(root, path, (ptr-path)*sizeof(WCHAR));
 536             root[ptr-path] = 0;
 537
 538             type = GetDriveTypeW(root);
 539
 540             switch(type) {
 541             case DRIVE_UNKNOWN:
 542             case DRIVE_NO_ROOT_DIR:
 543                 break;
 544             case DRIVE_REMOVABLE:
 545             case DRIVE_FIXED:
 546             case DRIVE_CDROM:
 547             case DRIVE_RAMDISK:
 548                 *zone = URLZONE_LOCAL_MACHINE;
 549                 hres = S_OK;
 550                 break;
 551             case DRIVE_REMOTE:
 552                 *zone = URLZONE_INTERNET;
 553                 hres = S_OK;
 554                 break;
 555             default:
 556                 FIXME("unsupported drive type %d\n", type);
 557             }
 558         }
 559     }
 560
 561     if(*zone == URLZONE_INVALID) {
 562         hres = get_zone_from_domains(secur_url, schema, zone);
 563         if(hres == S_FALSE)
 564             hres = get_zone_from_reg(schema, zone);
 565     }
 566
 567     if(FAILED(hres) || !ret_url)
 568         heap_free(secur_url);
 569     else
 570         *ret_url = secur_url;
 571
 572     return hres;
 573 }
 574
 575 static HRESULT open_zone_key(HKEY parent_key, DWORD zone, HKEY *hkey)
 576 {
 577     static const WCHAR wszFormat[] = {'%','s','%','u',0};
 578
 579     WCHAR key_name[sizeof(wszZonesKey)/sizeof(WCHAR)+12];
 580     DWORD res;
 581
 582     wsprintfW(key_name, wszFormat, wszZonesKey, zone);
 583
 584     res = RegOpenKeyW(parent_key, key_name, hkey);
 585
 586     if(res != ERROR_SUCCESS) {
 587         WARN("RegOpenKey failed\n");
 588         return E_INVALIDARG;
 589     }
 590
 591     return S_OK;
 592 }
 593
 594 static HRESULT get_action_policy(DWORD zone, DWORD action, BYTE *policy, DWORD size, URLZONEREG zone_reg)
 595 {
 596     HKEY parent_key;
 597     HKEY hkey;
 598     LONG res;
 599     HRESULT hres;
 600
 601     switch(action) {
 602     case URLACTION_SCRIPT_OVERRIDE_SAFETY:
 603     case URLACTION_ACTIVEX_OVERRIDE_SCRIPT_SAFETY:
 604         *(DWORD*)policy = URLPOLICY_DISALLOW;
 605         return S_OK;
 606     }
 607
 608     switch(zone_reg) {
 609     case URLZONEREG_DEFAULT:
 610     case URLZONEREG_HKCU:
 611         parent_key = HKEY_CURRENT_USER;
 612         break;
 613     case URLZONEREG_HKLM:
 614         parent_key = HKEY_LOCAL_MACHINE;
 615         break;
 616     default:
 617         WARN("Unknown URLZONEREG: %d\n", zone_reg);
 618         return E_FAIL;
 619     };
 620
 621     hres = open_zone_key(parent_key, zone, &hkey);
 622     if(SUCCEEDED(hres)) {
 623         WCHAR action_str[16];
 624         DWORD len = size;
 625
 626         static const WCHAR formatW[] = {'%','X',0};
 627
 628         wsprintfW(action_str, formatW, action);
 629
 630         res = RegQueryValueExW(hkey, action_str, NULL, NULL, policy, &len);
 631         if(res == ERROR_MORE_DATA) {
 632             hres = E_INVALIDARG;
 633         }else if(res == ERROR_FILE_NOT_FOUND) {
 634             hres = E_FAIL;
 635         }else if(res != ERROR_SUCCESS) {
 636             ERR("RegQueryValue failed: %d\n", res);
 637             hres = E_UNEXPECTED;
 638         }
 639
 640         RegCloseKey(hkey);
 641     }
 642
 643     if(FAILED(hres) && zone_reg == URLZONEREG_DEFAULT)
 644         return get_action_policy(zone, action, policy, size, URLZONEREG_HKLM);
 645
 646     return hres;
 647 }
 648
 649 /***********************************************************************
 650  *           InternetSecurityManager implementation
 651  *
 652  */
 653 typedef struct {
 654     IInternetSecurityManager IInternetSecurityManager_iface;
 655
 656     LONG ref;
 657
 658     IInternetSecurityMgrSite *mgrsite;
 659     IInternetSecurityManager *custom_manager;
 660 } SecManagerImpl;
 661
 662 static inline SecManagerImpl *impl_from_IInternetSecurityManager(IInternetSecurityManager *iface)
 663 {
 664     return CONTAINING_RECORD(iface, SecManagerImpl, IInternetSecurityManager_iface);
 665 }
 666
 667 static HRESULT WINAPI SecManagerImpl_QueryInterface(IInternetSecurityManager* iface,REFIID riid,void** ppvObject)
 668 {
 669     SecManagerImpl *This = impl_from_IInternetSecurityManager(iface);
 670
 671     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppvObject);
 672
 673     /* Perform a sanity check on the parameters.*/
 674     if ( (This==0) || (ppvObject==0) )
 675         return E_INVALIDARG;
 676
 677     /* Initialize the return parameter */
 678     *ppvObject = 0;
 679
 680     /* Compare the riid with the interface IDs implemented by this object.*/
 681     if (IsEqualIID(&IID_IUnknown, riid) ||
 682         IsEqualIID(&IID_IInternetSecurityManager, riid))
 683         *ppvObject = iface;
 684
 685     /* Check that we obtained an interface.*/
 686     if (!*ppvObject) {
 687         WARN("not supported interface %s\n", debugstr_guid(riid));
 688         return E_NOINTERFACE;
 689     }
 690
 691     /* Query Interface always increases the reference count by one when it is successful */
 692     IInternetSecurityManager_AddRef(iface);
 693
 694     return S_OK;
 695 }
 696
 697 static ULONG WINAPI SecManagerImpl_AddRef(IInternetSecurityManager* iface)
 698 {
 699     SecManagerImpl *This = impl_from_IInternetSecurityManager(iface);
 700     ULONG refCount = InterlockedIncrement(&This->ref);
 701
 702     TRACE("(%p) ref=%u\n", This, refCount);
 703
 704     return refCount;
 705 }
 706
 707 static ULONG WINAPI SecManagerImpl_Release(IInternetSecurityManager* iface)
 708 {
 709     SecManagerImpl *This = impl_from_IInternetSecurityManager(iface);
 710     ULONG refCount = InterlockedDecrement(&This->ref);
 711
 712     TRACE("(%p) ref=%u\n", This, refCount);
 713
 714     /* destroy the object if there's no more reference on it */
 715     if (!refCount){
 716         if(This->mgrsite)
 717             IInternetSecurityMgrSite_Release(This->mgrsite);
 718         if(This->custom_manager)
 719             IInternetSecurityManager_Release(This->custom_manager);
 720
 721         heap_free(This);
 722
 723         URLMON_UnlockModule();
 724     }
 725
 726     return refCount;
 727 }
 728
 729 static HRESULT WINAPI SecManagerImpl_SetSecuritySite(IInternetSecurityManager *iface,
 730                                                      IInternetSecurityMgrSite *pSite)
 731 {
 732     SecManagerImpl *This = impl_from_IInternetSecurityManager(iface);
 733
 734     TRACE("(%p)->(%p)\n", This, pSite);
 735
 736     if(This->mgrsite)
 737         IInternetSecurityMgrSite_Release(This->mgrsite);
 738
 739     if(This->custom_manager) {
 740         IInternetSecurityManager_Release(This->custom_manager);
 741         This->custom_manager = NULL;
 742     }
 743
 744     This->mgrsite = pSite;
 745
 746     if(pSite) {
 747         IServiceProvider *servprov;
 748         HRESULT hres;
 749
 750         IInternetSecurityMgrSite_AddRef(pSite);
 751
 752         hres = IInternetSecurityMgrSite_QueryInterface(pSite, &IID_IServiceProvider,
 753                 (void**)&servprov);
 754         if(SUCCEEDED(hres)) {
 755             IServiceProvider_QueryService(servprov, &SID_SInternetSecurityManager,
 756                     &IID_IInternetSecurityManager, (void**)&This->custom_manager);
 757             IServiceProvider_Release(servprov);
 758         }
 759     }
 760
 761     return S_OK;
 762 }
 763
 764 static HRESULT WINAPI SecManagerImpl_GetSecuritySite(IInternetSecurityManager *iface,
 765                                                      IInternetSecurityMgrSite **ppSite)
 766 {
 767     SecManagerImpl *This = impl_from_IInternetSecurityManager(iface);
 768
 769     TRACE("(%p)->(%p)\n", This, ppSite);
 770
 771     if(!ppSite)
 772         return E_INVALIDARG;
 773
 774     if(This->mgrsite)
 775         IInternetSecurityMgrSite_AddRef(This->mgrsite);
 776
 777     *ppSite = This->mgrsite;
 778     return S_OK;
 779 }
 780
 781 static HRESULT WINAPI SecManagerImpl_MapUrlToZone(IInternetSecurityManager *iface,
 782                                                   LPCWSTR pwszUrl, DWORD *pdwZone,
 783                                                   DWORD dwFlags)
 784 {
 785     SecManagerImpl *This = impl_from_IInternetSecurityManager(iface);
 786     HRESULT hres;
 787
 788     TRACE("(%p)->(%s %p %08x)\n", iface, debugstr_w(pwszUrl), pdwZone, dwFlags);
 789
 790     if(This->custom_manager) {
 791         hres = IInternetSecurityManager_MapUrlToZone(This->custom_manager,
 792                 pwszUrl, pdwZone, dwFlags);
 793         if(hres != INET_E_DEFAULT_ACTION)
 794             return hres;
 795     }
 796
 797     if(!pwszUrl) {
 798         *pdwZone = URLZONE_INVALID;
 799         return E_INVALIDARG;
 800     }
 801
 802     if(dwFlags)
 803         FIXME("not supported flags: %08x\n", dwFlags);
 804
 805     return map_url_to_zone(pwszUrl, pdwZone, NULL);
 806 }
 807
 808 static HRESULT WINAPI SecManagerImpl_GetSecurityId(IInternetSecurityManager *iface,
 809         LPCWSTR pwszUrl, BYTE *pbSecurityId, DWORD *pcbSecurityId, DWORD_PTR dwReserved)
 810 {
 811     SecManagerImpl *This = impl_from_IInternetSecurityManager(iface);
 812     LPWSTR url, ptr, ptr2;
 813     DWORD zone, len;
 814     HRESULT hres;
 815
 816     static const WCHAR wszFile[] = {'f','i','l','e',':'};
 817
 818     TRACE("(%p)->(%s %p %p %08lx)\n", iface, debugstr_w(pwszUrl), pbSecurityId,
 819           pcbSecurityId, dwReserved);
 820
 821     if(This->custom_manager) {
 822         hres = IInternetSecurityManager_GetSecurityId(This->custom_manager,
 823                 pwszUrl, pbSecurityId, pcbSecurityId, dwReserved);
 824         if(hres != INET_E_DEFAULT_ACTION)
 825             return hres;
 826     }
 827
 828     if(!pwszUrl || !pbSecurityId || !pcbSecurityId)
 829         return E_INVALIDARG;
 830
 831     if(dwReserved)
 832         FIXME("dwReserved is not supported\n");
 833
 834     hres = map_url_to_zone(pwszUrl, &zone, &url);
 835     if(FAILED(hres))
 836         return hres == 0x80041001 ? E_INVALIDARG : hres;
 837
 838     /* file protocol is a special case */
 839     if(strlenW(url) >= sizeof(wszFile)/sizeof(WCHAR)
 840             && !memcmp(url, wszFile, sizeof(wszFile)) && strchrW(url, '\\')) {
 841
 842         static const BYTE secidFile[] = {'f','i','l','e',':'};
 843
 844         heap_free(url);
 845
 846         if(*pcbSecurityId < sizeof(secidFile)+sizeof(zone))
 847             return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
 848
 849         memcpy(pbSecurityId, secidFile, sizeof(secidFile));
 850         *(DWORD*)(pbSecurityId+sizeof(secidFile)) = zone;
 851
 852         *pcbSecurityId = sizeof(secidFile)+sizeof(zone);
 853         return S_OK;
 854     }
 855
 856     ptr = strchrW(url, ':');
 857     ptr2 = ++ptr;
 858     while(*ptr2 == '/')
 859         ptr2++;
 860     if(ptr2 != ptr)
 861         memmove(ptr, ptr2, (strlenW(ptr2)+1)*sizeof(WCHAR));
 862
 863     ptr = strchrW(ptr, '/');
 864     if(ptr)
 865         *ptr = 0;
 866
 867     len = WideCharToMultiByte(CP_ACP, 0, url, -1, NULL, 0, NULL, NULL)-1;
 868
 869     if(len+sizeof(DWORD) > *pcbSecurityId) {
 870         heap_free(url);
 871         return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
 872     }
 873
 874     WideCharToMultiByte(CP_ACP, 0, url, -1, (LPSTR)pbSecurityId, len, NULL, NULL);
 875     heap_free(url);
 876
 877     *(DWORD*)(pbSecurityId+len) = zone;
 878
 879     *pcbSecurityId = len+sizeof(DWORD);
 880
 881     return S_OK;
 882 }
 883
 884
 885 static HRESULT WINAPI SecManagerImpl_ProcessUrlAction(IInternetSecurityManager *iface,
 886                                                       LPCWSTR pwszUrl, DWORD dwAction,
 887                                                       BYTE *pPolicy, DWORD cbPolicy,
 888                                                       BYTE *pContext, DWORD cbContext,
 889                                                       DWORD dwFlags, DWORD dwReserved)
 890 {
 891     SecManagerImpl *This = impl_from_IInternetSecurityManager(iface);
 892     DWORD zone, policy;
 893     HRESULT hres;
 894
 895     TRACE("(%p)->(%s %08x %p %08x %p %08x %08x %08x)\n", iface, debugstr_w(pwszUrl), dwAction,
 896           pPolicy, cbPolicy, pContext, cbContext, dwFlags, dwReserved);
 897
 898     if(This->custom_manager) {
 899         hres = IInternetSecurityManager_ProcessUrlAction(This->custom_manager, pwszUrl, dwAction,
 900                 pPolicy, cbPolicy, pContext, cbContext, dwFlags, dwReserved);
 901         if(hres != INET_E_DEFAULT_ACTION)
 902             return hres;
 903     }
 904
 905     if(dwFlags || dwReserved)
 906         FIXME("Unsupported arguments\n");
 907
 908     if(!pwszUrl)
 909         return E_INVALIDARG;
 910
 911     hres = map_url_to_zone(pwszUrl, &zone, NULL);
 912     if(FAILED(hres))
 913         return hres;
 914
 915     hres = get_action_policy(zone, dwAction, (BYTE*)&policy, sizeof(policy), URLZONEREG_DEFAULT);
 916     if(FAILED(hres))
 917         return hres;
 918
 919     TRACE("policy %x\n", policy);
 920     if(cbPolicy >= sizeof(DWORD))
 921         *(DWORD*)pPolicy = policy;
 922
 923     switch(GetUrlPolicyPermissions(policy)) {
 924     case URLPOLICY_ALLOW:
 925     case URLPOLICY_CHANNEL_SOFTDIST_PRECACHE:
 926         return S_OK;
 927     case URLPOLICY_DISALLOW:
 928         return S_FALSE;
 929     case URLPOLICY_QUERY:
 930         FIXME("URLPOLICY_QUERY not implemented\n");
 931         return E_FAIL;
 932     default:
 933         FIXME("Not implemented policy %x\n", policy);
 934     }
 935
 936     return E_FAIL;
 937 }
 938
 939
 940 static HRESULT WINAPI SecManagerImpl_QueryCustomPolicy(IInternetSecurityManager *iface,
 941                                                        LPCWSTR pwszUrl, REFGUID guidKey,
 942                                                        BYTE **ppPolicy, DWORD *pcbPolicy,
 943                                                        BYTE *pContext, DWORD cbContext,
 944                                                        DWORD dwReserved)
 945 {
 946     SecManagerImpl *This = impl_from_IInternetSecurityManager(iface);
 947     HRESULT hres;
 948
 949     TRACE("(%p)->(%s %s %p %p %p %08x %08x )\n", iface, debugstr_w(pwszUrl), debugstr_guid(guidKey),
 950           ppPolicy, pcbPolicy, pContext, cbContext, dwReserved);
 951
 952     if(This->custom_manager) {
 953         hres = IInternetSecurityManager_QueryCustomPolicy(This->custom_manager, pwszUrl, guidKey,
 954                 ppPolicy, pcbPolicy, pContext, cbContext, dwReserved);
 955         if(hres != INET_E_DEFAULT_ACTION)
 956             return hres;
 957     }
 958
 959     WARN("Unknown guidKey %s\n", debugstr_guid(guidKey));
 960     return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
 961 }
 962
 963 static HRESULT WINAPI SecManagerImpl_SetZoneMapping(IInternetSecurityManager *iface,
 964                                                     DWORD dwZone, LPCWSTR pwszPattern, DWORD dwFlags)
 965 {
 966     SecManagerImpl *This = impl_from_IInternetSecurityManager(iface);
 967     HRESULT hres;
 968
 969     TRACE("(%p)->(%08x %s %08x)\n", iface, dwZone, debugstr_w(pwszPattern),dwFlags);
 970
 971     if(This->custom_manager) {
 972         hres = IInternetSecurityManager_SetZoneMapping(This->custom_manager, dwZone,
 973                 pwszPattern, dwFlags);
 974         if(hres != INET_E_DEFAULT_ACTION)
 975             return hres;
 976     }
 977
 978     FIXME("Default action is not implemented\n");
 979     return E_NOTIMPL;
 980 }
 981
 982 static HRESULT WINAPI SecManagerImpl_GetZoneMappings(IInternetSecurityManager *iface,
 983         DWORD dwZone, IEnumString **ppenumString, DWORD dwFlags)
 984 {
 985     SecManagerImpl *This = impl_from_IInternetSecurityManager(iface);
 986     HRESULT hres;
 987
 988     TRACE("(%p)->(%08x %p %08x)\n", iface, dwZone, ppenumString,dwFlags);
 989
 990     if(This->custom_manager) {
 991         hres = IInternetSecurityManager_GetZoneMappings(This->custom_manager, dwZone,
 992                 ppenumString, dwFlags);
 993         if(hres != INET_E_DEFAULT_ACTION)
 994             return hres;
 995     }
 996
 997     FIXME("Default action is not implemented\n");
 998     return E_NOTIMPL;
 999 }
1000
1001 static const IInternetSecurityManagerVtbl VT_SecManagerImpl =
1002 {
1003     SecManagerImpl_QueryInterface,
1004     SecManagerImpl_AddRef,
1005     SecManagerImpl_Release,
1006     SecManagerImpl_SetSecuritySite,
1007     SecManagerImpl_GetSecuritySite,
1008     SecManagerImpl_MapUrlToZone,
1009     SecManagerImpl_GetSecurityId,
1010     SecManagerImpl_ProcessUrlAction,
1011     SecManagerImpl_QueryCustomPolicy,
1012     SecManagerImpl_SetZoneMapping,
1013     SecManagerImpl_GetZoneMappings
1014 };
1015
1016 HRESULT SecManagerImpl_Construct(IUnknown *pUnkOuter, LPVOID *ppobj)
1017 {
1018     SecManagerImpl *This;
1019
1020     TRACE("(%p,%p)\n",pUnkOuter,ppobj);
1021     This = heap_alloc(sizeof(*This));
1022
1023     /* Initialize the virtual function table. */
1024     This->IInternetSecurityManager_iface.lpVtbl = &VT_SecManagerImpl;
1025
1026     This->ref = 1;
1027     This->mgrsite = NULL;
1028     This->custom_manager = NULL;
1029
1030     *ppobj = This;
1031
1032     URLMON_LockModule();
1033
1034     return S_OK;
1035 }
1036
1037 /***********************************************************************
1038  *           InternetZoneManager implementation
1039  *
1040  */
1041 typedef struct {
1042     IInternetZoneManagerEx2 IInternetZoneManagerEx2_iface;
1043     LONG ref;
1044     LPDWORD *zonemaps;
1045     DWORD zonemap_count;
1046 } ZoneMgrImpl;
1047
1048 static inline ZoneMgrImpl *impl_from_IInternetZoneManagerEx2(IInternetZoneManagerEx2 *iface)
1049 {
1050     return CONTAINING_RECORD(iface, ZoneMgrImpl, IInternetZoneManagerEx2_iface);
1051 }
1052
1053
1054 /***********************************************************************
1055  * build_zonemap_from_reg [internal]
1056  *
1057  * Enumerate the Zones in the Registry and return the Zones in a DWORD-array
1058  * The number of the Zones is returned in data[0]
1059  */
1060 static LPDWORD build_zonemap_from_reg(void)
1061 {
1062     WCHAR name[32];
1063     HKEY hkey;
1064     LPDWORD data = NULL;
1065     DWORD allocated = 6; /* space for the zonecount and Zone "0" up to Zone "4" */
1066     DWORD used = 0;
1067     DWORD res;
1068     DWORD len;
1069
1070
1071     res = RegOpenKeyW(HKEY_CURRENT_USER, wszZonesKey, &hkey);
1072     if (res)
1073         return NULL;
1074
1075     data = heap_alloc(allocated * sizeof(DWORD));
1076     if (!data)
1077         goto cleanup;
1078
1079     while (!res) {
1080         name[0] = '\0';
1081         len = sizeof(name) / sizeof(name[0]);
1082         res = RegEnumKeyExW(hkey, used, name, &len, NULL, NULL, NULL, NULL);
1083
1084         if (!res) {
1085             used++;
1086             if (used == allocated) {
1087                 LPDWORD new_data;
1088
1089                 allocated *= 2;
1090                 new_data = heap_realloc_zero(data, allocated * sizeof(DWORD));
1091                 if (!new_data)
1092                     goto cleanup;
1093
1094                 data = new_data;
1095             }
1096             data[used] = atoiW(name);
1097         }
1098     }
1099     if (used) {
1100         RegCloseKey(hkey);
1101         data[0] = used;
1102         return data;
1103     }
1104
1105 cleanup:
1106     /* something failed */
1107     RegCloseKey(hkey);
1108     heap_free(data);
1109     return NULL;
1110 }
1111
1112 /********************************************************************
1113  *      IInternetZoneManager_QueryInterface
1114  */
1115 static HRESULT WINAPI ZoneMgrImpl_QueryInterface(IInternetZoneManagerEx2* iface, REFIID riid, void** ppvObject)
1116 {
1117     ZoneMgrImpl* This = impl_from_IInternetZoneManagerEx2(iface);
1118
1119     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppvObject);
1120
1121     if(!This || !ppvObject)
1122         return E_INVALIDARG;
1123
1124     if(IsEqualIID(&IID_IUnknown, riid)) {
1125         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppvObject);
1126     }else if(IsEqualIID(&IID_IInternetZoneManager, riid)) {
1127         TRACE("(%p)->(IID_InternetZoneManager %p)\n", This, ppvObject);
1128     }else if(IsEqualIID(&IID_IInternetZoneManagerEx, riid)) {
1129         TRACE("(%p)->(IID_InternetZoneManagerEx %p)\n", This, ppvObject);
1130     }else if(IsEqualIID(&IID_IInternetZoneManagerEx2, riid)) {
1131         TRACE("(%p)->(IID_InternetZoneManagerEx2 %p)\n", This, ppvObject);
1132     }
1133     else
1134     {
1135         FIXME("Unknown interface: %s\n", debugstr_guid(riid));
1136         *ppvObject = NULL;
1137         return E_NOINTERFACE;
1138     }
1139
1140     *ppvObject = iface;
1141     IInternetZoneManager_AddRef(iface);
1142     return S_OK;
1143 }
1144
1145 /********************************************************************
1146  *      IInternetZoneManager_AddRef
1147  */
1148 static ULONG WINAPI ZoneMgrImpl_AddRef(IInternetZoneManagerEx2* iface)
1149 {
1150     ZoneMgrImpl* This = impl_from_IInternetZoneManagerEx2(iface);
1151     ULONG refCount = InterlockedIncrement(&This->ref);
1152
1153     TRACE("(%p)->(ref before=%u)\n",This, refCount - 1);
1154
1155     return refCount;
1156 }
1157
1158 /********************************************************************
1159  *      IInternetZoneManager_Release
1160  */
1161 static ULONG WINAPI ZoneMgrImpl_Release(IInternetZoneManagerEx2* iface)
1162 {
1163     ZoneMgrImpl* This = impl_from_IInternetZoneManagerEx2(iface);
1164     ULONG refCount = InterlockedDecrement(&This->ref);
1165
1166     TRACE("(%p)->(ref before=%u)\n",This, refCount + 1);
1167
1168     if(!refCount) {
1169         while (This->zonemap_count) heap_free(This->zonemaps[--This->zonemap_count]);
1170         heap_free(This->zonemaps);
1171         heap_free(This);
1172         URLMON_UnlockModule();
1173     }
1174
1175     return refCount;
1176 }
1177
1178 /********************************************************************
1179  *      IInternetZoneManager_GetZoneAttributes
1180  */
1181 static HRESULT WINAPI ZoneMgrImpl_GetZoneAttributes(IInternetZoneManagerEx2* iface,
1182                                                     DWORD dwZone,
1183                                                     ZONEATTRIBUTES* pZoneAttributes)
1184 {
1185     ZoneMgrImpl* This = impl_from_IInternetZoneManagerEx2(iface);
1186     HRESULT hr;
1187     HKEY hcu;
1188     HKEY hklm = NULL;
1189
1190     TRACE("(%p)->(%d %p)\n", This, dwZone, pZoneAttributes);
1191
1192     if (!pZoneAttributes)
1193         return E_INVALIDARG;
1194
1195     hr = open_zone_key(HKEY_CURRENT_USER, dwZone, &hcu);
1196     if (FAILED(hr))
1197         return S_OK;  /* IE6 and older returned E_FAIL here */
1198
1199     hr = open_zone_key(HKEY_LOCAL_MACHINE, dwZone, &hklm);
1200     if (FAILED(hr))
1201         TRACE("Zone %d not in HKLM\n", dwZone);
1202
1203     get_string_from_reg(hcu, hklm, displaynameW, pZoneAttributes->szDisplayName, MAX_ZONE_PATH);
1204     get_string_from_reg(hcu, hklm, descriptionW, pZoneAttributes->szDescription, MAX_ZONE_DESCRIPTION);
1205     get_string_from_reg(hcu, hklm, iconW, pZoneAttributes->szIconPath, MAX_ZONE_PATH);
1206     get_dword_from_reg(hcu, hklm, minlevelW, &pZoneAttributes->dwTemplateMinLevel);
1207     get_dword_from_reg(hcu, hklm, currentlevelW, &pZoneAttributes->dwTemplateCurrentLevel);
1208     get_dword_from_reg(hcu, hklm, recommendedlevelW, &pZoneAttributes->dwTemplateRecommended);
1209     get_dword_from_reg(hcu, hklm, flagsW, &pZoneAttributes->dwFlags);
1210
1211     RegCloseKey(hklm);
1212     RegCloseKey(hcu);
1213     return S_OK;
1214 }
1215
1216 /********************************************************************
1217  *      IInternetZoneManager_SetZoneAttributes
1218  */
1219 static HRESULT WINAPI ZoneMgrImpl_SetZoneAttributes(IInternetZoneManagerEx2* iface,
1220                                                     DWORD dwZone,
1221                                                     ZONEATTRIBUTES* pZoneAttributes)
1222 {
1223     FIXME("(%p)->(%08x %p) stub\n", iface, dwZone, pZoneAttributes);
1224     return E_NOTIMPL;
1225 }
1226
1227 /********************************************************************
1228  *      IInternetZoneManager_GetZoneCustomPolicy
1229  */
1230 static HRESULT WINAPI ZoneMgrImpl_GetZoneCustomPolicy(IInternetZoneManagerEx2* iface,
1231                                                       DWORD dwZone,
1232                                                       REFGUID guidKey,
1233                                                       BYTE** ppPolicy,
1234                                                       DWORD* pcbPolicy,
1235                                                       URLZONEREG ulrZoneReg)
1236 {
1237     FIXME("(%p)->(%08x %s %p %p %08x) stub\n", iface, dwZone, debugstr_guid(guidKey),
1238                                                     ppPolicy, pcbPolicy, ulrZoneReg);
1239     return E_NOTIMPL;
1240 }
1241
1242 /********************************************************************
1243  *      IInternetZoneManager_SetZoneCustomPolicy
1244  */
1245 static HRESULT WINAPI ZoneMgrImpl_SetZoneCustomPolicy(IInternetZoneManagerEx2* iface,
1246                                                       DWORD dwZone,
1247                                                       REFGUID guidKey,
1248                                                       BYTE* ppPolicy,
1249                                                       DWORD cbPolicy,
1250                                                       URLZONEREG ulrZoneReg)
1251 {
1252     FIXME("(%p)->(%08x %s %p %08x %08x) stub\n", iface, dwZone, debugstr_guid(guidKey),
1253                                                     ppPolicy, cbPolicy, ulrZoneReg);
1254     return E_NOTIMPL;
1255 }
1256
1257 /********************************************************************
1258  *      IInternetZoneManager_GetZoneActionPolicy
1259  */
1260 static HRESULT WINAPI ZoneMgrImpl_GetZoneActionPolicy(IInternetZoneManagerEx2* iface,
1261         DWORD dwZone, DWORD dwAction, BYTE* pPolicy, DWORD cbPolicy, URLZONEREG urlZoneReg)
1262 {
1263     TRACE("(%p)->(%d %08x %p %d %d)\n", iface, dwZone, dwAction, pPolicy,
1264             cbPolicy, urlZoneReg);
1265
1266     if(!pPolicy)
1267         return E_INVALIDARG;
1268
1269     return get_action_policy(dwZone, dwAction, pPolicy, cbPolicy, urlZoneReg);
1270 }
1271
1272 /********************************************************************
1273  *      IInternetZoneManager_SetZoneActionPolicy
1274  */
1275 static HRESULT WINAPI ZoneMgrImpl_SetZoneActionPolicy(IInternetZoneManagerEx2* iface,
1276                                                       DWORD dwZone,
1277                                                       DWORD dwAction,
1278                                                       BYTE* pPolicy,
1279                                                       DWORD cbPolicy,
1280                                                       URLZONEREG urlZoneReg)
1281 {
1282     FIXME("(%p)->(%08x %08x %p %08x %08x) stub\n", iface, dwZone, dwAction, pPolicy,
1283                                                        cbPolicy, urlZoneReg);
1284     return E_NOTIMPL;
1285 }
1286
1287 /********************************************************************
1288  *      IInternetZoneManager_PromptAction
1289  */
1290 static HRESULT WINAPI ZoneMgrImpl_PromptAction(IInternetZoneManagerEx2* iface,
1291                                                DWORD dwAction,
1292                                                HWND hwndParent,
1293                                                LPCWSTR pwszUrl,
1294                                                LPCWSTR pwszText,
1295                                                DWORD dwPromptFlags)
1296 {
1297     FIXME("%p %08x %p %s %s %08x\n", iface, dwAction, hwndParent,
1298           debugstr_w(pwszUrl), debugstr_w(pwszText), dwPromptFlags );
1299     return E_NOTIMPL;
1300 }
1301
1302 /********************************************************************
1303  *      IInternetZoneManager_LogAction
1304  */
1305 static HRESULT WINAPI ZoneMgrImpl_LogAction(IInternetZoneManagerEx2* iface,
1306                                             DWORD dwAction,
1307                                             LPCWSTR pwszUrl,
1308                                             LPCWSTR pwszText,
1309                                             DWORD dwLogFlags)
1310 {
1311     FIXME("(%p)->(%08x %s %s %08x) stub\n", iface, dwAction, debugstr_w(pwszUrl),
1312                                               debugstr_w(pwszText), dwLogFlags);
1313     return E_NOTIMPL;
1314 }
1315
1316 /********************************************************************
1317  *      IInternetZoneManager_CreateZoneEnumerator
1318  */
1319 static HRESULT WINAPI ZoneMgrImpl_CreateZoneEnumerator(IInternetZoneManagerEx2* iface,
1320                                                        DWORD* pdwEnum,
1321                                                        DWORD* pdwCount,
1322                                                        DWORD dwFlags)
1323 {
1324     ZoneMgrImpl* This = impl_from_IInternetZoneManagerEx2(iface);
1325     LPDWORD * new_maps;
1326     LPDWORD data;
1327     DWORD i;
1328
1329     TRACE("(%p)->(%p, %p, 0x%08x)\n", This, pdwEnum, pdwCount, dwFlags);
1330     if (!pdwEnum || !pdwCount || (dwFlags != 0))
1331         return E_INVALIDARG;
1332
1333     data = build_zonemap_from_reg();
1334     TRACE("found %d zones\n", data ? data[0] : -1);
1335
1336     if (!data)
1337         return E_FAIL;
1338
1339     for (i = 0; i < This->zonemap_count; i++) {
1340         if (This->zonemaps && !This->zonemaps[i]) {
1341             This->zonemaps[i] = data;
1342             *pdwEnum = i;
1343             *pdwCount = data[0];
1344             return S_OK;
1345         }
1346     }
1347
1348     if (This->zonemaps) {
1349         /* try to double the nr. of pointers in the array */
1350         new_maps = heap_realloc_zero(This->zonemaps, This->zonemap_count * 2 * sizeof(LPDWORD));
1351         if (new_maps)
1352             This->zonemap_count *= 2;
1353     }
1354     else
1355     {
1356         This->zonemap_count = 2;
1357         new_maps = heap_alloc_zero(This->zonemap_count * sizeof(LPDWORD));
1358     }
1359
1360     if (!new_maps) {
1361         heap_free(data);
1362         return E_FAIL;
1363     }
1364     This->zonemaps = new_maps;
1365     This->zonemaps[i] = data;
1366     *pdwEnum = i;
1367     *pdwCount = data[0];
1368     return S_OK;
1369 }
1370
1371 /********************************************************************
1372  *      IInternetZoneManager_GetZoneAt
1373  */
1374 static HRESULT WINAPI ZoneMgrImpl_GetZoneAt(IInternetZoneManagerEx2* iface,
1375                                             DWORD dwEnum,
1376                                             DWORD dwIndex,
1377                                             DWORD* pdwZone)
1378 {
1379     ZoneMgrImpl* This = impl_from_IInternetZoneManagerEx2(iface);
1380     LPDWORD data;
1381
1382     TRACE("(%p)->(0x%08x, %d, %p)\n", This, dwEnum, dwIndex, pdwZone);
1383
1384     /* make sure, that dwEnum and dwIndex are in the valid range */
1385     if (dwEnum < This->zonemap_count) {
1386         if ((data = This->zonemaps[dwEnum])) {
1387             if (dwIndex < data[0]) {
1388                 *pdwZone = data[dwIndex + 1];
1389                 return S_OK;
1390             }
1391         }
1392     }
1393     return E_INVALIDARG;
1394 }
1395
1396 /********************************************************************
1397  *      IInternetZoneManager_DestroyZoneEnumerator
1398  */
1399 static HRESULT WINAPI ZoneMgrImpl_DestroyZoneEnumerator(IInternetZoneManagerEx2* iface,
1400                                                         DWORD dwEnum)
1401 {
1402     ZoneMgrImpl* This = impl_from_IInternetZoneManagerEx2(iface);
1403     LPDWORD data;
1404
1405     TRACE("(%p)->(0x%08x)\n", This, dwEnum);
1406     /* make sure, that dwEnum is valid */
1407     if (dwEnum < This->zonemap_count) {
1408         if ((data = This->zonemaps[dwEnum])) {
1409             This->zonemaps[dwEnum] = NULL;
1410             heap_free(data);
1411             return S_OK;
1412         }
1413     }
1414     return E_INVALIDARG;
1415 }
1416
1417 /********************************************************************
1418  *      IInternetZoneManager_CopyTemplatePoliciesToZone
1419  */
1420 static HRESULT WINAPI ZoneMgrImpl_CopyTemplatePoliciesToZone(IInternetZoneManagerEx2* iface,
1421                                                              DWORD dwTemplate,
1422                                                              DWORD dwZone,
1423                                                              DWORD dwReserved)
1424 {
1425     FIXME("(%p)->(%08x %08x %08x) stub\n", iface, dwTemplate, dwZone, dwReserved);
1426     return E_NOTIMPL;
1427 }
1428
1429 /********************************************************************
1430  *      IInternetZoneManagerEx_GetZoneActionPolicyEx
1431  */
1432 static HRESULT WINAPI ZoneMgrImpl_GetZoneActionPolicyEx(IInternetZoneManagerEx2* iface,
1433                                                         DWORD dwZone,
1434                                                         DWORD dwAction,
1435                                                         BYTE* pPolicy,
1436                                                         DWORD cbPolicy,
1437                                                         URLZONEREG urlZoneReg,
1438                                                         DWORD dwFlags)
1439 {
1440     TRACE("(%p)->(%d, 0x%x, %p, %d, %d, 0x%x)\n", iface, dwZone,
1441             dwAction, pPolicy, cbPolicy, urlZoneReg, dwFlags);
1442
1443     if(!pPolicy)
1444         return E_INVALIDARG;
1445
1446     if (dwFlags)
1447         FIXME("dwFlags 0x%x ignored\n", dwFlags);
1448
1449     return get_action_policy(dwZone, dwAction, pPolicy, cbPolicy, urlZoneReg);
1450 }
1451
1452 /********************************************************************
1453  *      IInternetZoneManagerEx_SetZoneActionPolicyEx
1454  */
1455 static HRESULT WINAPI ZoneMgrImpl_SetZoneActionPolicyEx(IInternetZoneManagerEx2* iface,
1456                                                         DWORD dwZone,
1457                                                         DWORD dwAction,
1458                                                         BYTE* pPolicy,
1459                                                         DWORD cbPolicy,
1460                                                         URLZONEREG urlZoneReg,
1461                                                         DWORD dwFlags)
1462 {
1463     FIXME("(%p)->(%d, 0x%x, %p, %d, %d, 0x%x) stub\n", iface, dwZone, dwAction, pPolicy,
1464                                                        cbPolicy, urlZoneReg, dwFlags);
1465     return E_NOTIMPL;
1466 }
1467
1468 /********************************************************************
1469  *      IInternetZoneManagerEx2_GetZoneAttributesEx
1470  */
1471 static HRESULT WINAPI ZoneMgrImpl_GetZoneAttributesEx(IInternetZoneManagerEx2* iface,
1472                                                       DWORD dwZone,
1473                                                       ZONEATTRIBUTES* pZoneAttributes,
1474                                                       DWORD dwFlags)
1475 {
1476     TRACE("(%p)->(%d, %p, 0x%x)\n", iface, dwZone, pZoneAttributes, dwFlags);
1477
1478     if (dwFlags)
1479         FIXME("dwFlags 0x%x ignored\n", dwFlags);
1480
1481     return IInternetZoneManager_GetZoneAttributes(iface, dwZone, pZoneAttributes);
1482 }
1483
1484
1485 /********************************************************************
1486  *      IInternetZoneManagerEx2_GetZoneSecurityState
1487  */
1488 static HRESULT WINAPI ZoneMgrImpl_GetZoneSecurityState(IInternetZoneManagerEx2* iface,
1489                                                        DWORD dwZoneIndex,
1490                                                        BOOL fRespectPolicy,
1491                                                        LPDWORD pdwState,
1492                                                        BOOL *pfPolicyEncountered)
1493 {
1494     FIXME("(%p)->(%d, %d, %p, %p) stub\n", iface, dwZoneIndex, fRespectPolicy,
1495                                            pdwState, pfPolicyEncountered);
1496
1497     *pdwState = SECURITY_IE_STATE_GREEN;
1498
1499     if (pfPolicyEncountered)
1500         *pfPolicyEncountered = FALSE;
1501
1502     return S_OK;
1503 }
1504
1505 /********************************************************************
1506  *      IInternetZoneManagerEx2_GetIESecurityState
1507  */
1508 static HRESULT WINAPI ZoneMgrImpl_GetIESecurityState(IInternetZoneManagerEx2* iface,
1509                                                      BOOL fRespectPolicy,
1510                                                      LPDWORD pdwState,
1511                                                      BOOL *pfPolicyEncountered,
1512                                                      BOOL fNoCache)
1513 {
1514     FIXME("(%p)->(%d, %p, %p, %d) stub\n", iface, fRespectPolicy, pdwState,
1515                                            pfPolicyEncountered, fNoCache);
1516
1517     *pdwState = SECURITY_IE_STATE_GREEN;
1518
1519     if (pfPolicyEncountered)
1520         *pfPolicyEncountered = FALSE;
1521
1522     return S_OK;
1523 }
1524
1525 /********************************************************************
1526  *      IInternetZoneManagerEx2_FixInsecureSettings
1527  */
1528 static HRESULT WINAPI ZoneMgrImpl_FixInsecureSettings(IInternetZoneManagerEx2* iface)
1529 {
1530     FIXME("(%p) stub\n", iface);
1531     return S_OK;
1532 }
1533
1534 /********************************************************************
1535  *      IInternetZoneManager_Construct
1536  */
1537 static const IInternetZoneManagerEx2Vtbl ZoneMgrImplVtbl = {
1538     ZoneMgrImpl_QueryInterface,
1539     ZoneMgrImpl_AddRef,
1540     ZoneMgrImpl_Release,
1541     /* IInternetZoneManager */
1542     ZoneMgrImpl_GetZoneAttributes,
1543     ZoneMgrImpl_SetZoneAttributes,
1544     ZoneMgrImpl_GetZoneCustomPolicy,
1545     ZoneMgrImpl_SetZoneCustomPolicy,
1546     ZoneMgrImpl_GetZoneActionPolicy,
1547     ZoneMgrImpl_SetZoneActionPolicy,
1548     ZoneMgrImpl_PromptAction,
1549     ZoneMgrImpl_LogAction,
1550     ZoneMgrImpl_CreateZoneEnumerator,
1551     ZoneMgrImpl_GetZoneAt,
1552     ZoneMgrImpl_DestroyZoneEnumerator,
1553     ZoneMgrImpl_CopyTemplatePoliciesToZone,
1554     /* IInternetZoneManagerEx */
1555     ZoneMgrImpl_GetZoneActionPolicyEx,
1556     ZoneMgrImpl_SetZoneActionPolicyEx,
1557     /* IInternetZoneManagerEx2 */
1558     ZoneMgrImpl_GetZoneAttributesEx,
1559     ZoneMgrImpl_GetZoneSecurityState,
1560     ZoneMgrImpl_GetIESecurityState,
1561     ZoneMgrImpl_FixInsecureSettings,
1562 };
1563
1564 HRESULT ZoneMgrImpl_Construct(IUnknown *pUnkOuter, LPVOID *ppobj)
1565 {
1566     ZoneMgrImpl* ret = heap_alloc_zero(sizeof(ZoneMgrImpl));
1567
1568     TRACE("(%p %p)\n", pUnkOuter, ppobj);
1569     ret->IInternetZoneManagerEx2_iface.lpVtbl = &ZoneMgrImplVtbl;
1570     ret->ref = 1;
1571     *ppobj = (IInternetZoneManagerEx*)ret;
1572
1573     URLMON_LockModule();
1574
1575     return S_OK;
1576 }
1577
1578 /***********************************************************************
1579  *           CoInternetCreateSecurityManager (URLMON.@)
1580  *
1581  */
1582 HRESULT WINAPI CoInternetCreateSecurityManager( IServiceProvider *pSP,
1583     IInternetSecurityManager **ppSM, DWORD dwReserved )
1584 {
1585     TRACE("%p %p %d\n", pSP, ppSM, dwReserved );
1586
1587     if(pSP)
1588         FIXME("pSP not supported\n");
1589
1590     return SecManagerImpl_Construct(NULL, (void**) ppSM);
1591 }
1592
1593 /********************************************************************
1594  *      CoInternetCreateZoneManager (URLMON.@)
1595  */
1596 HRESULT WINAPI CoInternetCreateZoneManager(IServiceProvider* pSP, IInternetZoneManager** ppZM, DWORD dwReserved)
1597 {
1598     TRACE("(%p %p %x)\n", pSP, ppZM, dwReserved);
1599     return ZoneMgrImpl_Construct(NULL, (void**)ppZM);
1600 }
1601
1602 static HRESULT parse_security_url(const WCHAR *url, PSUACTION action, WCHAR **result) {
1603     IInternetProtocolInfo *protocol_info;
1604     WCHAR *tmp, *new_url = NULL, *alloc_url = NULL;
1605     DWORD size, new_size;
1606     HRESULT hres = S_OK, parse_hres;
1607
1608     while(1) {
1609         TRACE("parsing %s\n", debugstr_w(url));
1610
1611         protocol_info = get_protocol_info(url);
1612         if(!protocol_info)
1613             break;
1614
1615         size = strlenW(url)+1;
1616         new_url = CoTaskMemAlloc(size*sizeof(WCHAR));
1617         if(!new_url) {
1618             hres = E_OUTOFMEMORY;
1619             break;
1620         }
1621
1622         new_size = 0;
1623         parse_hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_SECURITY_URL, 0, new_url, size, &new_size, 0);
1624         if(parse_hres == S_FALSE) {
1625             if(!new_size) {
1626                 hres = E_UNEXPECTED;
1627                 break;
1628             }
1629
1630             tmp = CoTaskMemRealloc(new_url, new_size*sizeof(WCHAR));
1631             if(!tmp) {
1632                 hres = E_OUTOFMEMORY;
1633                 break;
1634             }
1635             new_url = tmp;
1636             parse_hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_SECURITY_URL, 0, new_url,
1637                     new_size, &new_size, 0);
1638             if(parse_hres == S_FALSE) {
1639                 hres = E_FAIL;
1640                 break;
1641             }
1642         }
1643
1644         if(parse_hres != S_OK || !strcmpW(url, new_url))
1645             break;
1646
1647         CoTaskMemFree(alloc_url);
1648         url = alloc_url = new_url;
1649         new_url = NULL;
1650     }
1651
1652     CoTaskMemFree(new_url);
1653
1654     if(hres != S_OK) {
1655         WARN("failed: %08x\n", hres);
1656         CoTaskMemFree(alloc_url);
1657         return hres;
1658     }
1659
1660     if(action == PSU_DEFAULT && (protocol_info = get_protocol_info(url))) {
1661         size = strlenW(url)+1;
1662         new_url = CoTaskMemAlloc(size * sizeof(WCHAR));
1663         if(new_url) {
1664             new_size = 0;
1665             parse_hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_SECURITY_DOMAIN, 0,
1666                     new_url, size, &new_size, 0);
1667             if(parse_hres == S_FALSE) {
1668                 if(new_size) {
1669                     tmp = CoTaskMemRealloc(new_url, new_size*sizeof(WCHAR));
1670                     if(tmp) {
1671                         new_url = tmp;
1672                         parse_hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_SECURITY_DOMAIN, 0, new_url,
1673                                 new_size, &new_size, 0);
1674                         if(parse_hres == S_FALSE)
1675                             hres = E_FAIL;
1676                     }else {
1677                         hres = E_OUTOFMEMORY;
1678                     }
1679                 }else {
1680                     hres = E_UNEXPECTED;
1681                 }
1682             }
1683
1684             if(hres == S_OK && parse_hres == S_OK) {
1685                 CoTaskMemFree(alloc_url);
1686                 url = alloc_url = new_url;
1687                 new_url = NULL;
1688             }
1689
1690             CoTaskMemFree(new_url);
1691         }else {
1692             hres = E_OUTOFMEMORY;
1693         }
1694         IInternetProtocolInfo_Release(protocol_info);
1695     }
1696
1697     if(FAILED(hres)) {
1698         WARN("failed %08x\n", hres);
1699         CoTaskMemFree(alloc_url);
1700         return hres;
1701     }
1702
1703     if(!alloc_url) {
1704         size = strlenW(url)+1;
1705         alloc_url = CoTaskMemAlloc(size * sizeof(WCHAR));
1706         if(!alloc_url)
1707             return E_OUTOFMEMORY;
1708         memcpy(alloc_url, url, size * sizeof(WCHAR));
1709     }
1710
1711     *result = alloc_url;
1712     return S_OK;
1713 }
1714
1715 /********************************************************************
1716  *      CoInternetGetSecurityUrl (URLMON.@)
1717  */
1718 HRESULT WINAPI CoInternetGetSecurityUrl(LPCWSTR pwzUrl, LPWSTR *ppwzSecUrl, PSUACTION psuAction, DWORD dwReserved)
1719 {
1720     WCHAR *secure_url;
1721     HRESULT hres;
1722
1723     TRACE("(%p,%p,%u,%u)\n", pwzUrl, ppwzSecUrl, psuAction, dwReserved);
1724
1725     hres = parse_security_url(pwzUrl, psuAction, &secure_url);
1726     if(FAILED(hres))
1727         return hres;
1728
1729     if(psuAction != PSU_SECURITY_URL_ONLY) {
1730         PARSEDURLW parsed_url = { sizeof(parsed_url) };
1731         DWORD size;
1732
1733         /* FIXME: Use helpers from uri.c */
1734         if(SUCCEEDED(ParseURLW(secure_url, &parsed_url))) {
1735             WCHAR *new_url;
1736
1737             switch(parsed_url.nScheme) {
1738             case URL_SCHEME_FTP:
1739             case URL_SCHEME_HTTP:
1740             case URL_SCHEME_HTTPS:
1741                 size = strlenW(secure_url)+1;
1742                 new_url = CoTaskMemAlloc(size * sizeof(WCHAR));
1743                 if(new_url)
1744                     hres = UrlGetPartW(secure_url, new_url, &size, URL_PART_HOSTNAME, URL_PARTFLAG_KEEPSCHEME);
1745                 else
1746                     hres = E_OUTOFMEMORY;
1747                 CoTaskMemFree(secure_url);
1748                 if(hres != S_OK) {
1749                     WARN("UrlGetPart failed: %08x\n", hres);
1750                     CoTaskMemFree(new_url);
1751                     return FAILED(hres) ? hres : E_FAIL;
1752                 }
1753                 secure_url = new_url;
1754             }
1755         }
1756     }
1757
1758     *ppwzSecUrl = secure_url;
1759     return S_OK;
1760 }
1761
1762 /********************************************************************
1763  *      CoInternetGetSecurityUrlEx (URLMON.@)
1764  */
1765 HRESULT WINAPI CoInternetGetSecurityUrlEx(IUri *pUri, IUri **ppSecUri, PSUACTION psuAction, DWORD_PTR dwReserved)
1766 {
1767     URL_SCHEME scheme_type;
1768     BSTR secure_uri;
1769     WCHAR *ret_url;
1770     HRESULT hres;
1771
1772     TRACE("(%p,%p,%u,%u)\n", pUri, ppSecUri, psuAction, (DWORD)dwReserved);
1773
1774     if(!pUri || !ppSecUri)
1775         return E_INVALIDARG;
1776
1777     hres = IUri_GetDisplayUri(pUri, &secure_uri);
1778     if(FAILED(hres))
1779         return hres;
1780
1781     hres = parse_security_url(secure_uri, psuAction, &ret_url);
1782     SysFreeString(secure_uri);
1783     if(FAILED(hres))
1784         return hres;
1785
1786     hres = CreateUri(ret_url, Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME, 0, ppSecUri);
1787     if(FAILED(hres)) {
1788         CoTaskMemFree(ret_url);
1789         return hres;
1790     }
1791
1792     /* File URIs have to hierarchical. */
1793     hres = IUri_GetScheme(pUri, (DWORD*)&scheme_type);
1794     if(SUCCEEDED(hres) && scheme_type == URL_SCHEME_FILE) {
1795         const WCHAR *tmp = ret_url;
1796
1797         /* Check and see if a "//" is after the scheme name. */
1798         tmp += sizeof(fileW)/sizeof(WCHAR);
1799         if(*tmp != '/' || *(tmp+1) != '/')
1800             hres = E_INVALIDARG;
1801     }
1802
1803     if(SUCCEEDED(hres))
1804         hres = CreateUri(ret_url, Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME, 0, ppSecUri);
1805     CoTaskMemFree(ret_url);
1806     return hres;
1807 }