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