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

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