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  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdio.h>
  23
  24 #include "urlmon_main.h"
  25 #include "winreg.h"
  26
  27 #include "wine/debug.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  30
  31 /***********************************************************************
  32  *           InternetSecurityManager implementation
  33  *
  34  */
  35 typedef struct {
  36     const IInternetSecurityManagerVtbl* lpInternetSecurityManagerVtbl;
  37
  38     LONG ref;
  39
  40     IInternetSecurityMgrSite *mgrsite;
  41     IInternetSecurityManager *custom_manager;
  42 } SecManagerImpl;
  43
  44 #define SECMGR_THIS(iface) DEFINE_THIS(SecManagerImpl, InternetSecurityManager, iface)
  45
  46 static HRESULT map_url_to_zone(LPCWSTR url, DWORD *zone)
  47 {
  48     WCHAR schema[64];
  49     DWORD res, size=0;
  50     HKEY hkey;
  51     HRESULT hres;
  52
  53     static const WCHAR wszZoneMapProtocolKey[] =
  54         {'S','o','f','t','w','a','r','e','\\',
  55                     'M','i','c','r','o','s','o','f','t','\\',
  56                     'W','i','n','d','o','w','s','\\',
  57                     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  58                     'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s','\\',
  59                     'Z','o','n','e','M','a','p','\\',
  60                     'P','r','o','t','o','c','o','l','D','e','f','a','u','l','t','s',0};
  61     static const WCHAR wszFile[] = {'f','i','l','e',0};
  62
  63     *zone = -1;
  64
  65     hres = CoInternetParseUrl(url, PARSE_SCHEMA, 0, schema, sizeof(schema)/sizeof(WCHAR), &size, 0);
  66     if(FAILED(hres))
  67         return hres;
  68     if(!*schema)
  69         return 0x80041001;
  70
  71     /* file protocol is a special case */
  72     if(!strcmpW(schema, wszFile)) {
  73         WCHAR path[MAX_PATH];
  74
  75         hres = CoInternetParseUrl(url, PARSE_PATH_FROM_URL, 0, path,
  76                 sizeof(path)/sizeof(WCHAR), &size, 0);
  77
  78         if(SUCCEEDED(hres) && strchrW(path, '\\')) {
  79             *zone = 0;
  80             return S_OK;
  81         }
  82     }
  83
  84     WARN("domains are not yet implemented\n");
  85
  86     res = RegOpenKeyW(HKEY_CURRENT_USER, wszZoneMapProtocolKey, &hkey);
  87     if(res != ERROR_SUCCESS) {
  88         ERR("Could not open key %s\n", debugstr_w(wszZoneMapProtocolKey));
  89         return E_UNEXPECTED;
  90     }
  91
  92     size = sizeof(DWORD);
  93     res = RegQueryValueExW(hkey, schema, NULL, NULL, (PBYTE)zone, &size);
  94     RegCloseKey(hkey);
  95     if(res == ERROR_SUCCESS)
  96         return S_OK;
  97
  98     res = RegOpenKeyW(HKEY_LOCAL_MACHINE, wszZoneMapProtocolKey, &hkey);
  99     if(res != ERROR_SUCCESS) {
 100         ERR("Could not open key %s\n", debugstr_w(wszZoneMapProtocolKey));
 101         return E_UNEXPECTED;
 102     }
 103
 104     size = sizeof(DWORD);
 105     res = RegQueryValueExW(hkey, schema, NULL, NULL, (PBYTE)zone, &size);
 106     RegCloseKey(hkey);
 107     if(res == ERROR_SUCCESS)
 108         return S_OK;
 109
 110     *zone = 3;
 111     return S_OK;
 112 }
 113
 114 static HRESULT WINAPI SecManagerImpl_QueryInterface(IInternetSecurityManager* iface,REFIID riid,void** ppvObject)
 115 {
 116     SecManagerImpl *This = SECMGR_THIS(iface);
 117
 118     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppvObject);
 119
 120     /* Perform a sanity check on the parameters.*/
 121     if ( (This==0) || (ppvObject==0) )
 122         return E_INVALIDARG;
 123
 124     /* Initialize the return parameter */
 125     *ppvObject = 0;
 126
 127     /* Compare the riid with the interface IDs implemented by this object.*/
 128     if (IsEqualIID(&IID_IUnknown, riid) ||
 129         IsEqualIID(&IID_IInternetSecurityManager, riid))
 130         *ppvObject = iface;
 131
 132     /* Check that we obtained an interface.*/
 133     if (!*ppvObject) {
 134         WARN("not supported interface %s\n", debugstr_guid(riid));
 135         return E_NOINTERFACE;
 136     }
 137
 138     /* Query Interface always increases the reference count by one when it is successful */
 139     IInternetSecurityManager_AddRef(iface);
 140
 141     return S_OK;
 142 }
 143
 144 static ULONG WINAPI SecManagerImpl_AddRef(IInternetSecurityManager* iface)
 145 {
 146     SecManagerImpl *This = SECMGR_THIS(iface);
 147     ULONG refCount = InterlockedIncrement(&This->ref);
 148
 149     TRACE("(%p) ref=%u\n", This, refCount);
 150
 151     return refCount;
 152 }
 153
 154 static ULONG WINAPI SecManagerImpl_Release(IInternetSecurityManager* iface)
 155 {
 156     SecManagerImpl *This = SECMGR_THIS(iface);
 157     ULONG refCount = InterlockedDecrement(&This->ref);
 158
 159     TRACE("(%p) ref=%u\n", This, refCount);
 160
 161     /* destroy the object if there's no more reference on it */
 162     if (!refCount){
 163         if(This->mgrsite)
 164             IInternetSecurityMgrSite_Release(This->mgrsite);
 165         if(This->custom_manager)
 166             IInternetSecurityManager_Release(This->custom_manager);
 167
 168         heap_free(This);
 169
 170         URLMON_UnlockModule();
 171     }
 172
 173     return refCount;
 174 }
 175
 176 static HRESULT WINAPI SecManagerImpl_SetSecuritySite(IInternetSecurityManager *iface,
 177                                                      IInternetSecurityMgrSite *pSite)
 178 {
 179     SecManagerImpl *This = SECMGR_THIS(iface);
 180
 181     TRACE("(%p)->(%p)\n", This, pSite);
 182
 183     if(This->mgrsite)
 184         IInternetSecurityMgrSite_Release(This->mgrsite);
 185
 186     if(This->custom_manager) {
 187         IInternetSecurityManager_Release(This->custom_manager);
 188         This->custom_manager = NULL;
 189     }
 190
 191     This->mgrsite = pSite;
 192
 193     if(pSite) {
 194         IServiceProvider *servprov;
 195         HRESULT hres;
 196
 197         IInternetSecurityMgrSite_AddRef(pSite);
 198
 199         hres = IInternetSecurityMgrSite_QueryInterface(pSite, &IID_IServiceProvider,
 200                 (void**)&servprov);
 201         if(SUCCEEDED(hres)) {
 202             IServiceProvider_QueryService(servprov, &SID_SInternetSecurityManager,
 203                     &IID_IInternetSecurityManager, (void**)&This->custom_manager);
 204             IServiceProvider_Release(servprov);
 205         }
 206     }
 207
 208     return S_OK;
 209 }
 210
 211 static HRESULT WINAPI SecManagerImpl_GetSecuritySite(IInternetSecurityManager *iface,
 212                                                      IInternetSecurityMgrSite **ppSite)
 213 {
 214     SecManagerImpl *This = SECMGR_THIS(iface);
 215
 216     TRACE("(%p)->(%p)\n", This, ppSite);
 217
 218     if(!ppSite)
 219         return E_INVALIDARG;
 220
 221     if(This->mgrsite)
 222         IInternetSecurityMgrSite_AddRef(This->mgrsite);
 223
 224     *ppSite = This->mgrsite;
 225     return S_OK;
 226 }
 227
 228 static HRESULT WINAPI SecManagerImpl_MapUrlToZone(IInternetSecurityManager *iface,
 229                                                   LPCWSTR pwszUrl, DWORD *pdwZone,
 230                                                   DWORD dwFlags)
 231 {
 232     SecManagerImpl *This = SECMGR_THIS(iface);
 233     LPWSTR url;
 234     DWORD size;
 235     HRESULT hres;
 236
 237     TRACE("(%p)->(%s %p %08x)\n", iface, debugstr_w(pwszUrl), pdwZone, dwFlags);
 238
 239     if(This->custom_manager) {
 240         hres = IInternetSecurityManager_MapUrlToZone(This->custom_manager,
 241                 pwszUrl, pdwZone, dwFlags);
 242         if(hres != INET_E_DEFAULT_ACTION)
 243             return hres;
 244     }
 245
 246     if(!pwszUrl) {
 247         *pdwZone = -1;
 248         return E_INVALIDARG;
 249     }
 250
 251     if(dwFlags)
 252         FIXME("not supported flags: %08x\n", dwFlags);
 253
 254     size = (strlenW(pwszUrl)+16) * sizeof(WCHAR);
 255     url = heap_alloc(size);
 256
 257     hres = CoInternetParseUrl(pwszUrl, PARSE_SECURITY_URL, 0, url, size/sizeof(WCHAR), &size, 0);
 258     if(FAILED(hres))
 259         memcpy(url, pwszUrl, size);
 260
 261     hres = map_url_to_zone(url, pdwZone);
 262
 263     heap_free(url);
 264
 265     return hres;
 266 }
 267
 268 static HRESULT WINAPI SecManagerImpl_GetSecurityId(IInternetSecurityManager *iface,
 269         LPCWSTR pwszUrl, BYTE *pbSecurityId, DWORD *pcbSecurityId, DWORD_PTR dwReserved)
 270 {
 271     SecManagerImpl *This = SECMGR_THIS(iface);
 272     LPWSTR buf, ptr, ptr2;
 273     DWORD size, zone, len;
 274     HRESULT hres;
 275
 276     static const WCHAR wszFile[] = {'f','i','l','e',':'};
 277
 278     TRACE("(%p)->(%s %p %p %08lx)\n", iface, debugstr_w(pwszUrl), pbSecurityId,
 279           pcbSecurityId, dwReserved);
 280
 281     if(This->custom_manager) {
 282         hres = IInternetSecurityManager_GetSecurityId(This->custom_manager,
 283                 pwszUrl, pbSecurityId, pcbSecurityId, dwReserved);
 284         if(hres != INET_E_DEFAULT_ACTION)
 285             return hres;
 286     }
 287
 288     if(!pwszUrl || !pbSecurityId || !pcbSecurityId)
 289         return E_INVALIDARG;
 290
 291     if(dwReserved)
 292         FIXME("dwReserved is not supported\n");
 293
 294     len = strlenW(pwszUrl)+1;
 295     buf = heap_alloc((len+16)*sizeof(WCHAR));
 296
 297     hres = CoInternetParseUrl(pwszUrl, PARSE_SECURITY_URL, 0, buf, len, &size, 0);
 298     if(FAILED(hres))
 299         memcpy(buf, pwszUrl, len*sizeof(WCHAR));
 300
 301     hres = map_url_to_zone(buf, &zone);
 302     if(FAILED(hres)) {
 303         heap_free(buf);
 304         return hres == 0x80041001 ? E_INVALIDARG : hres;
 305     }
 306
 307     /* file protocol is a special case */
 308     if(strlenW(pwszUrl) >= sizeof(wszFile)/sizeof(WCHAR)
 309             && !memcmp(buf, wszFile, sizeof(wszFile))) {
 310
 311         static const BYTE secidFile[] = {'f','i','l','e',':'};
 312
 313         heap_free(buf);
 314
 315         if(*pcbSecurityId < sizeof(secidFile)+sizeof(zone))
 316             return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
 317
 318         memcpy(pbSecurityId, secidFile, sizeof(secidFile));
 319         *(DWORD*)(pbSecurityId+sizeof(secidFile)) = zone;
 320
 321         *pcbSecurityId = sizeof(secidFile)+sizeof(zone);
 322         return S_OK;
 323     }
 324
 325     ptr = strchrW(buf, ':');
 326     ptr2 = ++ptr;
 327     while(*ptr2 == '/')
 328         ptr2++;
 329     if(ptr2 != ptr)
 330         memmove(ptr, ptr2, (strlenW(ptr2)+1)*sizeof(WCHAR));
 331
 332     ptr = strchrW(ptr, '/');
 333     if(ptr)
 334         *ptr = 0;
 335
 336     len = WideCharToMultiByte(CP_ACP, 0, buf, -1, NULL, 0, NULL, NULL)-1;
 337
 338     if(len+sizeof(DWORD) > *pcbSecurityId) {
 339         heap_free(buf);
 340         return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
 341     }
 342
 343     WideCharToMultiByte(CP_ACP, 0, buf, -1, (LPSTR)pbSecurityId, -1, NULL, NULL);
 344     heap_free(buf);
 345
 346     *(DWORD*)(pbSecurityId+len) = zone;
 347
 348     *pcbSecurityId = len+sizeof(DWORD);
 349
 350     return S_OK;
 351 }
 352
 353
 354 static HRESULT WINAPI SecManagerImpl_ProcessUrlAction(IInternetSecurityManager *iface,
 355                                                       LPCWSTR pwszUrl, DWORD dwAction,
 356                                                       BYTE *pPolicy, DWORD cbPolicy,
 357                                                       BYTE *pContext, DWORD cbContext,
 358                                                       DWORD dwFlags, DWORD dwReserved)
 359 {
 360     SecManagerImpl *This = SECMGR_THIS(iface);
 361     HRESULT hres;
 362
 363     TRACE("(%p)->(%s %08x %p %08x %p %08x %08x %08x)\n", iface, debugstr_w(pwszUrl), dwAction,
 364           pPolicy, cbPolicy, pContext, cbContext, dwFlags, dwReserved);
 365
 366     if(This->custom_manager) {
 367         hres = IInternetSecurityManager_ProcessUrlAction(This->custom_manager, pwszUrl, dwAction,
 368                 pPolicy, cbPolicy, pContext, cbContext, dwFlags, dwReserved);
 369         if(hres != INET_E_DEFAULT_ACTION)
 370             return hres;
 371     }
 372
 373     FIXME("Default action is not implemented\n");
 374     return E_NOTIMPL;
 375 }
 376
 377
 378 static HRESULT WINAPI SecManagerImpl_QueryCustomPolicy(IInternetSecurityManager *iface,
 379                                                        LPCWSTR pwszUrl, REFGUID guidKey,
 380                                                        BYTE **ppPolicy, DWORD *pcbPolicy,
 381                                                        BYTE *pContext, DWORD cbContext,
 382                                                        DWORD dwReserved)
 383 {
 384     SecManagerImpl *This = SECMGR_THIS(iface);
 385     HRESULT hres;
 386
 387     TRACE("(%p)->(%s %s %p %p %p %08x %08x )\n", iface, debugstr_w(pwszUrl), debugstr_guid(guidKey),
 388           ppPolicy, pcbPolicy, pContext, cbContext, dwReserved);
 389
 390     if(This->custom_manager) {
 391         hres = IInternetSecurityManager_QueryCustomPolicy(This->custom_manager, pwszUrl, guidKey,
 392                 ppPolicy, pcbPolicy, pContext, cbContext, dwReserved);
 393         if(hres != INET_E_DEFAULT_ACTION)
 394             return hres;
 395     }
 396
 397     FIXME("Default action is not implemented\n");
 398     return E_NOTIMPL;
 399 }
 400
 401 static HRESULT WINAPI SecManagerImpl_SetZoneMapping(IInternetSecurityManager *iface,
 402                                                     DWORD dwZone, LPCWSTR pwszPattern, DWORD dwFlags)
 403 {
 404     SecManagerImpl *This = SECMGR_THIS(iface);
 405     HRESULT hres;
 406
 407     TRACE("(%p)->(%08x %s %08x)\n", iface, dwZone, debugstr_w(pwszPattern),dwFlags);
 408
 409     if(This->custom_manager) {
 410         hres = IInternetSecurityManager_SetZoneMapping(This->custom_manager, dwZone,
 411                 pwszPattern, dwFlags);
 412         if(hres != INET_E_DEFAULT_ACTION)
 413             return hres;
 414     }
 415
 416     FIXME("Default action is not implemented\n");
 417     return E_NOTIMPL;
 418 }
 419
 420 static HRESULT WINAPI SecManagerImpl_GetZoneMappings(IInternetSecurityManager *iface,
 421         DWORD dwZone, IEnumString **ppenumString, DWORD dwFlags)
 422 {
 423     SecManagerImpl *This = SECMGR_THIS(iface);
 424     HRESULT hres;
 425
 426     TRACE("(%p)->(%08x %p %08x)\n", iface, dwZone, ppenumString,dwFlags);
 427
 428     if(This->custom_manager) {
 429         hres = IInternetSecurityManager_GetZoneMappings(This->custom_manager, dwZone,
 430                 ppenumString, dwFlags);
 431         if(hres != INET_E_DEFAULT_ACTION)
 432             return hres;
 433     }
 434
 435     FIXME("Default action is not implemented\n");
 436     return E_NOTIMPL;
 437 }
 438
 439 static const IInternetSecurityManagerVtbl VT_SecManagerImpl =
 440 {
 441     SecManagerImpl_QueryInterface,
 442     SecManagerImpl_AddRef,
 443     SecManagerImpl_Release,
 444     SecManagerImpl_SetSecuritySite,
 445     SecManagerImpl_GetSecuritySite,
 446     SecManagerImpl_MapUrlToZone,
 447     SecManagerImpl_GetSecurityId,
 448     SecManagerImpl_ProcessUrlAction,
 449     SecManagerImpl_QueryCustomPolicy,
 450     SecManagerImpl_SetZoneMapping,
 451     SecManagerImpl_GetZoneMappings
 452 };
 453
 454 HRESULT SecManagerImpl_Construct(IUnknown *pUnkOuter, LPVOID *ppobj)
 455 {
 456     SecManagerImpl *This;
 457
 458     TRACE("(%p,%p)\n",pUnkOuter,ppobj);
 459     This = heap_alloc(sizeof(*This));
 460
 461     /* Initialize the virtual function table. */
 462     This->lpInternetSecurityManagerVtbl = &VT_SecManagerImpl;
 463
 464     This->ref = 1;
 465     This->mgrsite = NULL;
 466     This->custom_manager = NULL;
 467
 468     *ppobj = This;
 469
 470     URLMON_LockModule();
 471
 472     return S_OK;
 473 }
 474
 475 /***********************************************************************
 476  *           InternetZoneManager implementation
 477  *
 478  */
 479 typedef struct {
 480     const IInternetZoneManagerVtbl* lpVtbl;
 481     LONG ref;
 482 } ZoneMgrImpl;
 483
 484 static HRESULT open_zone_key(DWORD zone, HKEY *hkey, URLZONEREG zone_reg)
 485 {
 486     static const WCHAR wszZonesKey[] =
 487         {'S','o','f','t','w','a','r','e','\\',
 488             'M','i','c','r','o','s','o','f','t','\\',
 489             'W','i','n','d','o','w','s','\\',
 490             'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 491             'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s','\\',
 492             'Z','o','n','e','s','\\',0};
 493     static const WCHAR wszFormat[] = {'%','s','%','l','d',0};
 494
 495     WCHAR key_name[sizeof(wszZonesKey)/sizeof(WCHAR)+8];
 496     HKEY parent_key;
 497     DWORD res;
 498
 499     switch(zone_reg) {
 500     case URLZONEREG_DEFAULT: /* FIXME: TEST */
 501     case URLZONEREG_HKCU:
 502         parent_key = HKEY_CURRENT_USER;
 503         break;
 504     case URLZONEREG_HKLM:
 505         parent_key = HKEY_LOCAL_MACHINE;
 506         break;
 507     default:
 508         WARN("Unknown URLZONEREG: %d\n", zone_reg);
 509         return E_FAIL;
 510     };
 511
 512     wsprintfW(key_name, wszFormat, wszZonesKey, zone);
 513
 514     res = RegOpenKeyW(parent_key, key_name, hkey);
 515
 516     if(res != ERROR_SUCCESS) {
 517         WARN("RegOpenKey failed\n");
 518         return E_INVALIDARG;
 519     }
 520
 521     return S_OK;
 522 }
 523
 524 /********************************************************************
 525  *      IInternetZoneManager_QueryInterface
 526  */
 527 static HRESULT WINAPI ZoneMgrImpl_QueryInterface(IInternetZoneManager* iface, REFIID riid, void** ppvObject)
 528 {
 529     ZoneMgrImpl* This = (ZoneMgrImpl*)iface;
 530
 531     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppvObject);
 532
 533     if(!This || !ppvObject)
 534         return E_INVALIDARG;
 535
 536     if(!IsEqualIID(&IID_IUnknown, riid) && !IsEqualIID(&IID_IInternetZoneManager, riid)) {
 537         FIXME("Unknown interface: %s\n", debugstr_guid(riid));
 538         *ppvObject = NULL;
 539         return E_NOINTERFACE;
 540     }
 541
 542     *ppvObject = iface;
 543     IInternetZoneManager_AddRef(iface);
 544
 545     return S_OK;
 546 }
 547
 548 /********************************************************************
 549  *      IInternetZoneManager_AddRef
 550  */
 551 static ULONG WINAPI ZoneMgrImpl_AddRef(IInternetZoneManager* iface)
 552 {
 553     ZoneMgrImpl* This = (ZoneMgrImpl*)iface;
 554     ULONG refCount = InterlockedIncrement(&This->ref);
 555
 556     TRACE("(%p)->(ref before=%u)\n",This, refCount - 1);
 557
 558     return refCount;
 559 }
 560
 561 /********************************************************************
 562  *      IInternetZoneManager_Release
 563  */
 564 static ULONG WINAPI ZoneMgrImpl_Release(IInternetZoneManager* iface)
 565 {
 566     ZoneMgrImpl* This = (ZoneMgrImpl*)iface;
 567     ULONG refCount = InterlockedDecrement(&This->ref);
 568
 569     TRACE("(%p)->(ref before=%u)\n",This, refCount + 1);
 570
 571     if(!refCount) {
 572         heap_free(This);
 573         URLMON_UnlockModule();
 574     }
 575
 576     return refCount;
 577 }
 578
 579 /********************************************************************
 580  *      IInternetZoneManager_GetZoneAttributes
 581  */
 582 static HRESULT WINAPI ZoneMgrImpl_GetZoneAttributes(IInternetZoneManager* iface,
 583                                                     DWORD dwZone,
 584                                                     ZONEATTRIBUTES* pZoneAttributes)
 585 {
 586     FIXME("(%p)->(%d %p) stub\n", iface, dwZone, pZoneAttributes);
 587     return E_NOTIMPL;
 588 }
 589
 590 /********************************************************************
 591  *      IInternetZoneManager_SetZoneAttributes
 592  */
 593 static HRESULT WINAPI ZoneMgrImpl_SetZoneAttributes(IInternetZoneManager* iface,
 594                                                     DWORD dwZone,
 595                                                     ZONEATTRIBUTES* pZoneAttributes)
 596 {
 597     FIXME("(%p)->(%08x %p) stub\n", iface, dwZone, pZoneAttributes);
 598     return E_NOTIMPL;
 599 }
 600
 601 /********************************************************************
 602  *      IInternetZoneManager_GetZoneCustomPolicy
 603  */
 604 static HRESULT WINAPI ZoneMgrImpl_GetZoneCustomPolicy(IInternetZoneManager* iface,
 605                                                       DWORD dwZone,
 606                                                       REFGUID guidKey,
 607                                                       BYTE** ppPolicy,
 608                                                       DWORD* pcbPolicy,
 609                                                       URLZONEREG ulrZoneReg)
 610 {
 611     FIXME("(%p)->(%08x %s %p %p %08x) stub\n", iface, dwZone, debugstr_guid(guidKey),
 612                                                     ppPolicy, pcbPolicy, ulrZoneReg);
 613     return E_NOTIMPL;
 614 }
 615
 616 /********************************************************************
 617  *      IInternetZoneManager_SetZoneCustomPolicy
 618  */
 619 static HRESULT WINAPI ZoneMgrImpl_SetZoneCustomPolicy(IInternetZoneManager* iface,
 620                                                       DWORD dwZone,
 621                                                       REFGUID guidKey,
 622                                                       BYTE* ppPolicy,
 623                                                       DWORD cbPolicy,
 624                                                       URLZONEREG ulrZoneReg)
 625 {
 626     FIXME("(%p)->(%08x %s %p %08x %08x) stub\n", iface, dwZone, debugstr_guid(guidKey),
 627                                                     ppPolicy, cbPolicy, ulrZoneReg);
 628     return E_NOTIMPL;
 629 }
 630
 631 /********************************************************************
 632  *      IInternetZoneManager_GetZoneActionPolicy
 633  */
 634 static HRESULT WINAPI ZoneMgrImpl_GetZoneActionPolicy(IInternetZoneManager* iface,
 635         DWORD dwZone, DWORD dwAction, BYTE* pPolicy, DWORD cbPolicy, URLZONEREG urlZoneReg)
 636 {
 637     WCHAR action[16];
 638     HKEY hkey;
 639     LONG res;
 640     DWORD size = cbPolicy;
 641     HRESULT hres;
 642
 643     static const WCHAR wszFormat[] = {'%','l','X',0};
 644
 645     TRACE("(%p)->(%d %08x %p %d %d)\n", iface, dwZone, dwAction, pPolicy,
 646             cbPolicy, urlZoneReg);
 647
 648     if(!pPolicy)
 649         return E_INVALIDARG;
 650
 651     hres = open_zone_key(dwZone, &hkey, urlZoneReg);
 652     if(FAILED(hres))
 653         return hres;
 654
 655     wsprintfW(action, wszFormat, dwAction);
 656
 657     res = RegQueryValueExW(hkey, action, NULL, NULL, pPolicy, &size);
 658     if(res == ERROR_MORE_DATA) {
 659         hres = E_INVALIDARG;
 660     }else if(res == ERROR_FILE_NOT_FOUND) {
 661         hres = E_FAIL;
 662     }else if(res != ERROR_SUCCESS) {
 663         ERR("RegQueryValue failed: %d\n", res);
 664         hres = E_UNEXPECTED;
 665     }
 666
 667     RegCloseKey(hkey);
 668
 669     return hres;
 670 }
 671
 672 /********************************************************************
 673  *      IInternetZoneManager_SetZoneActionPolicy
 674  */
 675 static HRESULT WINAPI ZoneMgrImpl_SetZoneActionPolicy(IInternetZoneManager* iface,
 676                                                       DWORD dwZone,
 677                                                       DWORD dwAction,
 678                                                       BYTE* pPolicy,
 679                                                       DWORD cbPolicy,
 680                                                       URLZONEREG urlZoneReg)
 681 {
 682     FIXME("(%p)->(%08x %08x %p %08x %08x) stub\n", iface, dwZone, dwAction, pPolicy,
 683                                                        cbPolicy, urlZoneReg);
 684     return E_NOTIMPL;
 685 }
 686
 687 /********************************************************************
 688  *      IInternetZoneManager_PromptAction
 689  */
 690 static HRESULT WINAPI ZoneMgrImpl_PromptAction(IInternetZoneManager* iface,
 691                                                DWORD dwAction,
 692                                                HWND hwndParent,
 693                                                LPCWSTR pwszUrl,
 694                                                LPCWSTR pwszText,
 695                                                DWORD dwPromptFlags)
 696 {
 697     FIXME("%p %08x %p %s %s %08x\n", iface, dwAction, hwndParent,
 698           debugstr_w(pwszUrl), debugstr_w(pwszText), dwPromptFlags );
 699     return E_NOTIMPL;
 700 }
 701
 702 /********************************************************************
 703  *      IInternetZoneManager_LogAction
 704  */
 705 static HRESULT WINAPI ZoneMgrImpl_LogAction(IInternetZoneManager* iface,
 706                                             DWORD dwAction,
 707                                             LPCWSTR pwszUrl,
 708                                             LPCWSTR pwszText,
 709                                             DWORD dwLogFlags)
 710 {
 711     FIXME("(%p)->(%08x %s %s %08x) stub\n", iface, dwAction, debugstr_w(pwszUrl),
 712                                               debugstr_w(pwszText), dwLogFlags);
 713     return E_NOTIMPL;
 714 }
 715
 716 /********************************************************************
 717  *      IInternetZoneManager_CreateZoneEnumerator
 718  */
 719 static HRESULT WINAPI ZoneMgrImpl_CreateZoneEnumerator(IInternetZoneManager* iface,
 720                                                        DWORD* pdwEnum,
 721                                                        DWORD* pdwCount,
 722                                                        DWORD dwFlags)
 723 {
 724     FIXME("(%p)->(%p %p %08x) stub\n", iface, pdwEnum, pdwCount, dwFlags);
 725     return E_NOTIMPL;
 726 }
 727
 728 /********************************************************************
 729  *      IInternetZoneManager_GetZoneAt
 730  */
 731 static HRESULT WINAPI ZoneMgrImpl_GetZoneAt(IInternetZoneManager* iface,
 732                                             DWORD dwEnum,
 733                                             DWORD dwIndex,
 734                                             DWORD* pdwZone)
 735 {
 736     FIXME("(%p)->(%08x %08x %p) stub\n", iface, dwEnum, dwIndex, pdwZone);
 737     return E_NOTIMPL;
 738 }
 739
 740 /********************************************************************
 741  *      IInternetZoneManager_DestroyZoneEnumerator
 742  */
 743 static HRESULT WINAPI ZoneMgrImpl_DestroyZoneEnumerator(IInternetZoneManager* iface,
 744                                                         DWORD dwEnum)
 745 {
 746     FIXME("(%p)->(%08x) stub\n", iface, dwEnum);
 747     return E_NOTIMPL;
 748 }
 749
 750 /********************************************************************
 751  *      IInternetZoneManager_CopyTemplatePoliciesToZone
 752  */
 753 static HRESULT WINAPI ZoneMgrImpl_CopyTemplatePoliciesToZone(IInternetZoneManager* iface,
 754                                                              DWORD dwTemplate,
 755                                                              DWORD dwZone,
 756                                                              DWORD dwReserved)
 757 {
 758     FIXME("(%p)->(%08x %08x %08x) stub\n", iface, dwTemplate, dwZone, dwReserved);
 759     return E_NOTIMPL;
 760 }
 761
 762 /********************************************************************
 763  *      IInternetZoneManager_Construct
 764  */
 765 static const IInternetZoneManagerVtbl ZoneMgrImplVtbl = {
 766     ZoneMgrImpl_QueryInterface,
 767     ZoneMgrImpl_AddRef,
 768     ZoneMgrImpl_Release,
 769     ZoneMgrImpl_GetZoneAttributes,
 770     ZoneMgrImpl_SetZoneAttributes,
 771     ZoneMgrImpl_GetZoneCustomPolicy,
 772     ZoneMgrImpl_SetZoneCustomPolicy,
 773     ZoneMgrImpl_GetZoneActionPolicy,
 774     ZoneMgrImpl_SetZoneActionPolicy,
 775     ZoneMgrImpl_PromptAction,
 776     ZoneMgrImpl_LogAction,
 777     ZoneMgrImpl_CreateZoneEnumerator,
 778     ZoneMgrImpl_GetZoneAt,
 779     ZoneMgrImpl_DestroyZoneEnumerator,
 780     ZoneMgrImpl_CopyTemplatePoliciesToZone,
 781 };
 782
 783 HRESULT ZoneMgrImpl_Construct(IUnknown *pUnkOuter, LPVOID *ppobj)
 784 {
 785     ZoneMgrImpl* ret = heap_alloc(sizeof(ZoneMgrImpl));
 786
 787     TRACE("(%p %p)\n", pUnkOuter, ppobj);
 788     ret->lpVtbl = &ZoneMgrImplVtbl;
 789     ret->ref = 1;
 790     *ppobj = (IInternetZoneManager*)ret;
 791
 792     URLMON_LockModule();
 793
 794     return S_OK;
 795 }
 796
 797 /***********************************************************************
 798  *           CoInternetCreateSecurityManager (URLMON.@)
 799  *
 800  */
 801 HRESULT WINAPI CoInternetCreateSecurityManager( IServiceProvider *pSP,
 802     IInternetSecurityManager **ppSM, DWORD dwReserved )
 803 {
 804     TRACE("%p %p %d\n", pSP, ppSM, dwReserved );
 805
 806     if(pSP)
 807         FIXME("pSP not supported\n");
 808
 809     return SecManagerImpl_Construct(NULL, (void**) ppSM);
 810 }
 811
 812 /********************************************************************
 813  *      CoInternetCreateZoneManager (URLMON.@)
 814  */
 815 HRESULT WINAPI CoInternetCreateZoneManager(IServiceProvider* pSP, IInternetZoneManager** ppZM, DWORD dwReserved)
 816 {
 817     TRACE("(%p %p %x)\n", pSP, ppZM, dwReserved);
 818     return ZoneMgrImpl_Construct(NULL, (void**)ppZM);
 819 }