dlls/hnetcfg/policy.c

   1 /*
   2  * Copyright 2009 Hans Leidekker for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20 #include <stdio.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "ole2.h"
  28 #include "netfw.h"
  29
  30 #include "wine/debug.h"
  31 #include "hnetcfg_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(hnetcfg);
  34
  35 typedef struct fw_policy
  36 {
  37     INetFwPolicy INetFwPolicy_iface;
  38     LONG refs;
  39 } fw_policy;
  40
  41 static inline fw_policy *impl_from_INetFwPolicy( INetFwPolicy *iface )
  42 {
  43     return CONTAINING_RECORD(iface, fw_policy, INetFwPolicy_iface);
  44 }
  45
  46 typedef struct fw_policy2
  47 {
  48     INetFwPolicy2 INetFwPolicy2_iface;
  49     INetFwRules   *fw_policy2_rules;
  50     LONG refs;
  51 } fw_policy2;
  52
  53 static inline fw_policy2 *impl_from_INetFwPolicy2( INetFwPolicy2 *iface )
  54 {
  55     return CONTAINING_RECORD(iface, fw_policy2, INetFwPolicy2_iface);
  56 }
  57
  58 typedef struct fw_rules
  59 {
  60     INetFwRules INetFwRules_iface;
  61     LONG refs;
  62 } fw_rules;
  63
  64 static inline fw_rules *impl_from_INetFwRules( INetFwRules *iface )
  65 {
  66     return CONTAINING_RECORD(iface, fw_rules, INetFwRules_iface);
  67 }
  68
  69 static HRESULT WINAPI netfw_rules_QueryInterface(
  70     INetFwRules *iface,
  71     REFIID riid,
  72     void **object)
  73 {
  74     fw_rules *This = impl_from_INetFwRules( iface );
  75
  76     TRACE("%p %s %p\n", This, debugstr_guid( riid ), object );
  77
  78     if ( IsEqualGUID( riid, &IID_INetFwRules ) ||
  79          IsEqualGUID( riid, &IID_IDispatch ) ||
  80          IsEqualGUID( riid, &IID_IUnknown ) )
  81     {
  82         *object = iface;
  83     }
  84     else
  85     {
  86         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  87         return E_NOINTERFACE;
  88     }
  89     INetFwRules_AddRef( iface );
  90     return S_OK;
  91 }
  92
  93 static ULONG WINAPI netfw_rules_AddRef(
  94     INetFwRules *iface )
  95 {
  96     fw_rules *This = impl_from_INetFwRules( iface );
  97     return InterlockedIncrement( &This->refs );
  98 }
  99
 100 static ULONG WINAPI netfw_rules_Release(
 101     INetFwRules *iface )
 102 {
 103     fw_rules *This = impl_from_INetFwRules( iface );
 104     LONG refs = InterlockedDecrement( &This->refs );
 105     if (!refs)
 106     {
 107         TRACE("destroying %p\n", This);
 108         HeapFree( GetProcessHeap(), 0, This );
 109     }
 110     return refs;
 111 }
 112
 113 static HRESULT WINAPI netfw_rules_GetTypeInfoCount(
 114     INetFwRules *iface,
 115     UINT *pctinfo )
 116 {
 117     fw_rules *This = impl_from_INetFwRules( iface );
 118
 119     TRACE("%p %p\n", This, pctinfo);
 120     *pctinfo = 1;
 121     return S_OK;
 122 }
 123
 124 static HRESULT WINAPI netfw_rules_GetTypeInfo(
 125     INetFwRules *iface,
 126     UINT iTInfo,
 127     LCID lcid,
 128     ITypeInfo **ppTInfo)
 129 {
 130     fw_rules *This = impl_from_INetFwRules( iface );
 131
 132     TRACE("%p %u %u %p\n", This, iTInfo, lcid, ppTInfo);
 133     return get_typeinfo( INetFwRules_tid, ppTInfo );
 134 }
 135
 136 static HRESULT WINAPI netfw_rules_GetIDsOfNames(
 137     INetFwRules *iface,
 138     REFIID riid,
 139     LPOLESTR *rgszNames,
 140     UINT cNames,
 141     LCID lcid,
 142     DISPID *rgDispId)
 143 {
 144     fw_rules *This = impl_from_INetFwRules( iface );
 145     ITypeInfo *typeinfo;
 146     HRESULT hr;
 147
 148     TRACE("%p %s %p %u %u %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 149
 150     hr = get_typeinfo( INetFwRules_tid, &typeinfo );
 151     if (SUCCEEDED(hr))
 152     {
 153         hr = ITypeInfo_GetIDsOfNames( typeinfo, rgszNames, cNames, rgDispId );
 154         ITypeInfo_Release( typeinfo );
 155     }
 156     return hr;
 157 }
 158
 159 static HRESULT WINAPI netfw_rules_Invoke(
 160     INetFwRules *iface,
 161     DISPID dispIdMember,
 162     REFIID riid,
 163     LCID lcid,
 164     WORD wFlags,
 165     DISPPARAMS *pDispParams,
 166     VARIANT *pVarResult,
 167     EXCEPINFO *pExcepInfo,
 168     UINT *puArgErr)
 169 {
 170     fw_rules *This = impl_from_INetFwRules( iface );
 171     ITypeInfo *typeinfo;
 172     HRESULT hr;
 173
 174     TRACE("%p %d %s %d %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
 175           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 176
 177     hr = get_typeinfo( INetFwRules_tid, &typeinfo );
 178     if (SUCCEEDED(hr))
 179     {
 180         hr = ITypeInfo_Invoke( typeinfo, &This->INetFwRules_iface, dispIdMember,
 181                                wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
 182         ITypeInfo_Release( typeinfo );
 183     }
 184     return hr;
 185 }
 186
 187 static HRESULT WINAPI netfw_rules_get_Count(
 188     INetFwRules *iface,
 189     LONG *count)
 190 {
 191     fw_rules *This = impl_from_INetFwRules( iface );
 192
 193     FIXME("%p, %p\n", This, count);
 194
 195     if (count)
 196         *count = 0;
 197
 198     return S_OK;
 199 }
 200
 201 static HRESULT WINAPI netfw_rules_Add(
 202     INetFwRules *iface,
 203     INetFwRule *rule)
 204 {
 205     fw_rules *This = impl_from_INetFwRules( iface );
 206
 207     FIXME("%p, %p\n", This, rule);
 208     return E_NOTIMPL;
 209 }
 210
 211 static HRESULT WINAPI netfw_rules_Remove(
 212     INetFwRules *iface,
 213     BSTR name)
 214 {
 215     fw_rules *This = impl_from_INetFwRules( iface );
 216
 217     FIXME("%p, %s\n", This, debugstr_w(name));
 218     return E_NOTIMPL;
 219 }
 220
 221 static HRESULT WINAPI netfw_rules_Item(
 222     INetFwRules *iface,
 223     BSTR name,
 224     INetFwRule **rule)
 225 {
 226     fw_rules *This = impl_from_INetFwRules( iface );
 227
 228     FIXME("%p, %s, %p\n", This, debugstr_w(name), rule);
 229     return E_NOTIMPL;
 230 }
 231
 232 static HRESULT WINAPI netfw_rules_get__NewEnum(
 233     INetFwRules *iface,
 234     IUnknown **newEnum)
 235 {
 236     fw_rules *This = impl_from_INetFwRules( iface );
 237
 238     FIXME("%p, %p\n", This, newEnum);
 239
 240     if (!newEnum) return E_POINTER;
 241     *newEnum = NULL;
 242
 243     return E_NOTIMPL;
 244 }
 245
 246 static const struct INetFwRulesVtbl fw_rules_vtbl =
 247 {
 248     netfw_rules_QueryInterface,
 249     netfw_rules_AddRef,
 250     netfw_rules_Release,
 251     netfw_rules_GetTypeInfoCount,
 252     netfw_rules_GetTypeInfo,
 253     netfw_rules_GetIDsOfNames,
 254     netfw_rules_Invoke,
 255     netfw_rules_get_Count,
 256     netfw_rules_Add,
 257     netfw_rules_Remove,
 258     netfw_rules_Item,
 259     netfw_rules_get__NewEnum
 260 };
 261
 262 static HRESULT create_INetFwRules(INetFwRules **object)
 263 {
 264     fw_rules *rules;
 265
 266     TRACE("(%p)\n", object);
 267
 268     rules = HeapAlloc( GetProcessHeap(), 0, sizeof(*rules) );
 269     if (!rules) return E_OUTOFMEMORY;
 270
 271     rules->INetFwRules_iface.lpVtbl = &fw_rules_vtbl;
 272     rules->refs = 1;
 273
 274     *object = &rules->INetFwRules_iface;
 275
 276     TRACE("returning iface %p\n", *object);
 277     return S_OK;
 278 }
 279
 280 static ULONG WINAPI fw_policy_AddRef(
 281     INetFwPolicy *iface )
 282 {
 283     fw_policy *fw_policy = impl_from_INetFwPolicy( iface );
 284     return InterlockedIncrement( &fw_policy->refs );
 285 }
 286
 287 static ULONG WINAPI fw_policy_Release(
 288     INetFwPolicy *iface )
 289 {
 290     fw_policy *fw_policy = impl_from_INetFwPolicy( iface );
 291     LONG refs = InterlockedDecrement( &fw_policy->refs );
 292     if (!refs)
 293     {
 294         TRACE("destroying %p\n", fw_policy);
 295         HeapFree( GetProcessHeap(), 0, fw_policy );
 296     }
 297     return refs;
 298 }
 299
 300 static HRESULT WINAPI fw_policy_QueryInterface(
 301     INetFwPolicy *iface,
 302     REFIID riid,
 303     void **ppvObject )
 304 {
 305     fw_policy *This = impl_from_INetFwPolicy( iface );
 306
 307     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
 308
 309     if ( IsEqualGUID( riid, &IID_INetFwPolicy ) ||
 310          IsEqualGUID( riid, &IID_IDispatch ) ||
 311          IsEqualGUID( riid, &IID_IUnknown ) )
 312     {
 313         *ppvObject = iface;
 314     }
 315     else
 316     {
 317         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 318         return E_NOINTERFACE;
 319     }
 320     INetFwPolicy_AddRef( iface );
 321     return S_OK;
 322 }
 323
 324 static HRESULT WINAPI fw_policy_GetTypeInfoCount(
 325     INetFwPolicy *iface,
 326     UINT *pctinfo )
 327 {
 328     fw_policy *This = impl_from_INetFwPolicy( iface );
 329
 330     TRACE("%p %p\n", This, pctinfo);
 331     *pctinfo = 1;
 332     return S_OK;
 333 }
 334
 335 static HRESULT WINAPI fw_policy_GetTypeInfo(
 336     INetFwPolicy *iface,
 337     UINT iTInfo,
 338     LCID lcid,
 339     ITypeInfo **ppTInfo )
 340 {
 341     fw_policy *This = impl_from_INetFwPolicy( iface );
 342
 343     TRACE("%p %u %u %p\n", This, iTInfo, lcid, ppTInfo);
 344     return get_typeinfo( INetFwPolicy_tid, ppTInfo );
 345 }
 346
 347 static HRESULT WINAPI fw_policy_GetIDsOfNames(
 348     INetFwPolicy *iface,
 349     REFIID riid,
 350     LPOLESTR *rgszNames,
 351     UINT cNames,
 352     LCID lcid,
 353     DISPID *rgDispId )
 354 {
 355     fw_policy *This = impl_from_INetFwPolicy( iface );
 356     ITypeInfo *typeinfo;
 357     HRESULT hr;
 358
 359     TRACE("%p %s %p %u %u %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 360
 361     hr = get_typeinfo( INetFwPolicy_tid, &typeinfo );
 362     if (SUCCEEDED(hr))
 363     {
 364         hr = ITypeInfo_GetIDsOfNames( typeinfo, rgszNames, cNames, rgDispId );
 365         ITypeInfo_Release( typeinfo );
 366     }
 367     return hr;
 368 }
 369
 370 static HRESULT WINAPI fw_policy_Invoke(
 371     INetFwPolicy *iface,
 372     DISPID dispIdMember,
 373     REFIID riid,
 374     LCID lcid,
 375     WORD wFlags,
 376     DISPPARAMS *pDispParams,
 377     VARIANT *pVarResult,
 378     EXCEPINFO *pExcepInfo,
 379     UINT *puArgErr )
 380 {
 381     fw_policy *This = impl_from_INetFwPolicy( iface );
 382     ITypeInfo *typeinfo;
 383     HRESULT hr;
 384
 385     TRACE("%p %d %s %d %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
 386           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 387
 388     hr = get_typeinfo( INetFwPolicy_tid, &typeinfo );
 389     if (SUCCEEDED(hr))
 390     {
 391         hr = ITypeInfo_Invoke( typeinfo, &This->INetFwPolicy_iface, dispIdMember,
 392                                wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
 393         ITypeInfo_Release( typeinfo );
 394     }
 395     return hr;
 396 }
 397
 398 static HRESULT WINAPI fw_policy_get_CurrentProfile(
 399     INetFwPolicy *iface,
 400     INetFwProfile **profile )
 401 {
 402     fw_policy *This = impl_from_INetFwPolicy( iface );
 403
 404     TRACE("%p, %p\n", This, profile);
 405     return NetFwProfile_create( NULL, (void **)profile );
 406 }
 407
 408 static HRESULT WINAPI fw_policy_GetProfileByType(
 409     INetFwPolicy *iface,
 410     NET_FW_PROFILE_TYPE profileType,
 411     INetFwProfile **profile )
 412 {
 413     fw_policy *This = impl_from_INetFwPolicy( iface );
 414
 415     FIXME("%p, %u, %p\n", This, profileType, profile);
 416     return E_NOTIMPL;
 417 }
 418
 419 static const struct INetFwPolicyVtbl fw_policy_vtbl =
 420 {
 421     fw_policy_QueryInterface,
 422     fw_policy_AddRef,
 423     fw_policy_Release,
 424     fw_policy_GetTypeInfoCount,
 425     fw_policy_GetTypeInfo,
 426     fw_policy_GetIDsOfNames,
 427     fw_policy_Invoke,
 428     fw_policy_get_CurrentProfile,
 429     fw_policy_GetProfileByType
 430 };
 431
 432 HRESULT NetFwPolicy_create( IUnknown *pUnkOuter, LPVOID *ppObj )
 433 {
 434     fw_policy *fp;
 435
 436     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 437
 438     fp = HeapAlloc( GetProcessHeap(), 0, sizeof(*fp) );
 439     if (!fp) return E_OUTOFMEMORY;
 440
 441     fp->INetFwPolicy_iface.lpVtbl = &fw_policy_vtbl;
 442     fp->refs = 1;
 443
 444     *ppObj = &fp->INetFwPolicy_iface;
 445
 446     TRACE("returning iface %p\n", *ppObj);
 447     return S_OK;
 448 }
 449
 450 static HRESULT WINAPI fwpolicy2_QueryInterface(INetFwPolicy2 *iface, REFIID riid, void **out)
 451 {
 452     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 453
 454     TRACE("%p %s %p\n", This, debugstr_guid( riid ), out );
 455
 456     if ( IsEqualGUID( riid, &IID_INetFwPolicy2 ) ||
 457          IsEqualGUID( riid, &IID_IDispatch ) ||
 458          IsEqualGUID( riid, &IID_IUnknown ) )
 459     {
 460         *out = iface;
 461     }
 462     else if( IsEqualGUID( riid, &IID_INetFwRules ) )
 463     {
 464         TRACE("INetFwRules not supported\n");
 465         return E_NOINTERFACE;
 466     }
 467     else
 468     {
 469         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 470         return E_NOINTERFACE;
 471     }
 472     INetFwPolicy2_AddRef( iface );
 473     return S_OK;
 474 }
 475
 476 static ULONG WINAPI fwpolicy2_AddRef(INetFwPolicy2 *iface)
 477 {
 478     fw_policy2 *fw_policy = impl_from_INetFwPolicy2( iface );
 479     return InterlockedIncrement( &fw_policy->refs );
 480 }
 481
 482 static ULONG WINAPI fwpolicy2_Release(INetFwPolicy2 *iface)
 483 {
 484     fw_policy2 *fw_policy = impl_from_INetFwPolicy2( iface );
 485     LONG refs = InterlockedDecrement( &fw_policy->refs );
 486     if (!refs)
 487     {
 488         INetFwRules_Release(fw_policy->fw_policy2_rules);
 489         TRACE("destroying %p\n", fw_policy);
 490         HeapFree( GetProcessHeap(), 0, fw_policy );
 491     }
 492     return refs;
 493 }
 494
 495 static HRESULT WINAPI fwpolicy2_GetTypeInfoCount(INetFwPolicy2 *iface, UINT *pctinfo)
 496 {
 497     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 498
 499     TRACE("%p %p\n", This, pctinfo);
 500     *pctinfo = 1;
 501     return S_OK;
 502 }
 503
 504 static HRESULT WINAPI fwpolicy2_GetTypeInfo(INetFwPolicy2 *iface, UINT iTInfo, LCID lcid, ITypeInfo **info)
 505 {
 506     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 507
 508     TRACE("%p %u %u %p\n", This, iTInfo, lcid, info);
 509     return get_typeinfo( INetFwPolicy2_tid, info );
 510 }
 511
 512 static HRESULT WINAPI fwpolicy2_GetIDsOfNames(INetFwPolicy2 *iface, REFIID riid, LPOLESTR *rgszNames,
 513                         UINT cNames, LCID lcid, DISPID *rgDispId)
 514 {
 515     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 516     ITypeInfo *typeinfo;
 517     HRESULT hr;
 518
 519     TRACE("%p %s %p %u %u %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 520
 521     hr = get_typeinfo( INetFwPolicy2_tid, &typeinfo );
 522     if (SUCCEEDED(hr))
 523     {
 524         hr = ITypeInfo_GetIDsOfNames( typeinfo, rgszNames, cNames, rgDispId );
 525         ITypeInfo_Release( typeinfo );
 526     }
 527     return hr;
 528 }
 529
 530 static HRESULT WINAPI fwpolicy2_Invoke(INetFwPolicy2 *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 531                 WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 532 {
 533     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 534     ITypeInfo *typeinfo;
 535     HRESULT hr;
 536
 537     TRACE("%p %d %s %d %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
 538           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 539
 540     hr = get_typeinfo( INetFwPolicy2_tid, &typeinfo );
 541     if (SUCCEEDED(hr))
 542     {
 543         hr = ITypeInfo_Invoke( typeinfo, &This->INetFwPolicy2_iface, dispIdMember,
 544                                wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
 545         ITypeInfo_Release( typeinfo );
 546     }
 547     return hr;
 548 }
 549
 550 static HRESULT WINAPI fwpolicy2_get_CurrentProfileTypes(INetFwPolicy2 *iface, LONG *profile)
 551 {
 552     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 553
 554     FIXME("%p %p\n", This, profile);
 555     return E_NOTIMPL;
 556 }
 557
 558 static HRESULT WINAPI fwpolicy2_get_FirewallEnabled(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL *enabled)
 559 {
 560     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 561
 562     FIXME("%p %d %p\n", This, profileType, enabled);
 563     return E_NOTIMPL;
 564 }
 565
 566 static HRESULT WINAPI fwpolicy2_put_FirewallEnabled(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL enabled)
 567 {
 568     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 569
 570     FIXME("%p %d %d\n", This, profileType, enabled);
 571     return E_NOTIMPL;
 572 }
 573
 574 static HRESULT WINAPI fwpolicy2_get_ExcludedInterfaces(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT *interfaces)
 575 {
 576     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 577
 578     FIXME("%p %d %p\n", This, profileType, interfaces);
 579     return E_NOTIMPL;
 580 }
 581
 582 static HRESULT WINAPI fwpolicy2_put_ExcludedInterfaces(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT interfaces)
 583 {
 584     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 585     FIXME("%p %d\n", This, profileType);
 586     return E_NOTIMPL;
 587 }
 588
 589 static HRESULT WINAPI fwpolicy2_get_BlockAllInboundTraffic(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL *block)
 590 {
 591     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 592
 593     FIXME("%p %d %p\n", This, profileType, block);
 594     return E_NOTIMPL;
 595 }
 596
 597 static HRESULT WINAPI fwpolicy2_put_BlockAllInboundTraffic(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL block)
 598 {
 599     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 600
 601     FIXME("%p %d %d\n", This, profileType, block);
 602     return E_NOTIMPL;
 603 }
 604
 605 static HRESULT WINAPI fwpolicy2_get_NotificationsDisabled(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL *disabled)
 606 {
 607     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 608
 609     FIXME("%p %d %p\n", This, profileType, disabled);
 610     return E_NOTIMPL;
 611 }
 612
 613 static HRESULT WINAPI fwpolicy2_put_NotificationsDisabled(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL disabled)
 614 {
 615     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 616
 617     FIXME("%p %d %d\n", This, profileType, disabled);
 618     return E_NOTIMPL;
 619 }
 620
 621 static HRESULT WINAPI fwpolicy2_get_UnicastResponsesToMulticastBroadcastDisabled(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL *disabled)
 622 {
 623     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 624
 625     FIXME("%p %d %p\n", This, profileType, disabled);
 626     return E_NOTIMPL;
 627 }
 628
 629 static HRESULT WINAPI fwpolicy2_put_UnicastResponsesToMulticastBroadcastDisabled(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL disabled)
 630 {
 631     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 632
 633     FIXME("%p %d %d\n", This, profileType, disabled);
 634     return E_NOTIMPL;
 635 }
 636
 637 static HRESULT WINAPI fwpolicy2_get_Rules(INetFwPolicy2 *iface, INetFwRules **rules)
 638 {
 639     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 640
 641     TRACE("%p %p\n", This, rules);
 642
 643     if(!rules)
 644         return E_POINTER;
 645
 646     *rules = This->fw_policy2_rules;
 647     INetFwRules_AddRef(This->fw_policy2_rules);
 648
 649     return S_OK;
 650 }
 651
 652 static HRESULT WINAPI fwpolicy2_get_ServiceRestriction(INetFwPolicy2 *iface, INetFwServiceRestriction **ServiceRestriction)
 653 {
 654     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 655
 656     FIXME("%p %p\n", This, ServiceRestriction);
 657     return E_NOTIMPL;
 658 }
 659
 660 static HRESULT WINAPI fwpolicy2_EnableRuleGroup(INetFwPolicy2 *iface, LONG bitmask, BSTR group, VARIANT_BOOL enable)
 661 {
 662     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 663
 664     FIXME("%p %d %s %d\n", This, bitmask, debugstr_w(group), enable);
 665     return E_NOTIMPL;
 666 }
 667
 668 static HRESULT WINAPI fwpolicy2_IsRuleGroupEnabled(INetFwPolicy2 *iface, LONG bitmask, BSTR group, VARIANT_BOOL *enabled)
 669 {
 670     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 671
 672     FIXME("%p %d %s %p\n", This, bitmask, debugstr_w(group), enabled);
 673     return E_NOTIMPL;
 674 }
 675
 676 static HRESULT WINAPI fwpolicy2_RestoreLocalFirewallDefaults(INetFwPolicy2 *iface)
 677 {
 678     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 679
 680     FIXME("%p\n", This);
 681     return E_NOTIMPL;
 682 }
 683
 684 static HRESULT WINAPI fwpolicy2_get_DefaultInboundAction(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, NET_FW_ACTION *action)
 685 {
 686     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 687
 688     FIXME("%p %d %p\n", This, profileType, action);
 689     return E_NOTIMPL;
 690 }
 691
 692 static HRESULT WINAPI fwpolicy2_put_DefaultInboundAction(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, NET_FW_ACTION action)
 693 {
 694     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 695
 696     FIXME("%p %d %d\n", This, profileType, action);
 697     return E_NOTIMPL;
 698 }
 699
 700 static HRESULT WINAPI fwpolicy2_get_DefaultOutboundAction(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, NET_FW_ACTION *action)
 701 {
 702     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 703
 704     FIXME("%p %d %p\n", This, profileType, action);
 705     return E_NOTIMPL;
 706 }
 707
 708 static HRESULT WINAPI fwpolicy2_put_DefaultOutboundAction(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, NET_FW_ACTION action)
 709 {
 710     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 711
 712     FIXME("%p %d %d\n", This, profileType, action);
 713     return E_NOTIMPL;
 714 }
 715
 716 static HRESULT WINAPI fwpolicy2_get_IsRuleGroupCurrentlyEnabled(INetFwPolicy2 *iface, BSTR group, VARIANT_BOOL *enabled)
 717 {
 718     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 719
 720     FIXME("%p %s %p\n", This, debugstr_w(group), enabled);
 721     return E_NOTIMPL;
 722 }
 723
 724 static HRESULT WINAPI fwpolicy2_get_LocalPolicyModifyState(INetFwPolicy2 *iface, NET_FW_MODIFY_STATE *modifyState)
 725 {
 726     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
 727
 728     FIXME("%p %p\n", This, modifyState);
 729     return E_NOTIMPL;
 730 }
 731
 732 static const struct INetFwPolicy2Vtbl fw_policy2_vtbl =
 733 {
 734     fwpolicy2_QueryInterface,
 735     fwpolicy2_AddRef,
 736     fwpolicy2_Release,
 737     fwpolicy2_GetTypeInfoCount,
 738     fwpolicy2_GetTypeInfo,
 739     fwpolicy2_GetIDsOfNames,
 740     fwpolicy2_Invoke,
 741     fwpolicy2_get_CurrentProfileTypes,
 742     fwpolicy2_get_FirewallEnabled,
 743     fwpolicy2_put_FirewallEnabled,
 744     fwpolicy2_get_ExcludedInterfaces,
 745     fwpolicy2_put_ExcludedInterfaces,
 746     fwpolicy2_get_BlockAllInboundTraffic,
 747     fwpolicy2_put_BlockAllInboundTraffic,
 748     fwpolicy2_get_NotificationsDisabled,
 749     fwpolicy2_put_NotificationsDisabled,
 750     fwpolicy2_get_UnicastResponsesToMulticastBroadcastDisabled,
 751     fwpolicy2_put_UnicastResponsesToMulticastBroadcastDisabled,
 752     fwpolicy2_get_Rules,
 753     fwpolicy2_get_ServiceRestriction,
 754     fwpolicy2_EnableRuleGroup,
 755     fwpolicy2_IsRuleGroupEnabled,
 756     fwpolicy2_RestoreLocalFirewallDefaults,
 757     fwpolicy2_get_DefaultInboundAction,
 758     fwpolicy2_put_DefaultInboundAction,
 759     fwpolicy2_get_DefaultOutboundAction,
 760     fwpolicy2_put_DefaultOutboundAction,
 761     fwpolicy2_get_IsRuleGroupCurrentlyEnabled,
 762     fwpolicy2_get_LocalPolicyModifyState
 763 };
 764
 765 HRESULT NetFwPolicy2_create( IUnknown *outer, void **obj )
 766 {
 767     fw_policy2 *fp;
 768
 769     TRACE("(%p,%p)\n", outer, obj);
 770
 771     fp = HeapAlloc( GetProcessHeap(), 0, sizeof(*fp) );
 772     if (!fp) return E_OUTOFMEMORY;
 773
 774     fp->INetFwPolicy2_iface.lpVtbl = &fw_policy2_vtbl;
 775     fp->refs = 1;
 776
 777     *obj = &fp->INetFwPolicy2_iface;
 778
 779     if (FAILED(create_INetFwRules(&fp->fw_policy2_rules)))
 780     {
 781         HeapFree( GetProcessHeap(), 0, fp );
 782         return E_OUTOFMEMORY;
 783     }
 784
 785     TRACE("returning iface %p\n", *obj);
 786     return S_OK;
 787 }