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