关闭/打开防火墙 [英] Turn off/on firewall

问题描述

嗨 我如何:
关闭/打开防火墙
使用Visual C ++ MFC 2010吗?
其他所有代码，都无法真正发挥作用！
非常感谢

解决方案

在这里看一下文章.在VB中将其转换为本文的c ++并不难.

以编程方式禁用/启用Windows防火墙 [ http://www.vedivi.com/support/blog/72- configure-your-firewall-in-c.html [ ^ ]

我找不到以下代码的原始链接，但我在我更改Windows防火墙的项目之一:

 /*  
    版权所有(c)Microsoft Corporation

    概要

        Windows防火墙COM界面的示例代码.
*/

#include   "  stdafx.h"
 #include   <   windows.h  > 
 #include   <   crtdbg.h  > 
 #include   <   netfw.h  > 
 #include   <   objbase.h  > 
 #include   <   oleauto.h  > 
 #include   <   stdio.h  > 


HRESULT WindowsFirewallInitialize(OUT INetFwProfile ** fwProfile)
{
    HRESULT hr = S_OK;
    INetFwMgr * fwMgr = NULL;
    INetFwPolicy * fwPolicy = NULL;

    _ASSERT(fwProfile！= NULL);

    * fwProfile = NULL;

    // 创建防火墙设置管理器的实例.
    hr = CoCreateInstance(
             __ uuidof (NetFwMgr)，
            无效的，
            CLSCTX_INPROC_SERVER，
             __ uuidof (INetFwMgr)，
            (无效 **)& fwMgr
            );
    如果(FAILED(hr))
    {
        printf(" ，hr)；
        转到错误；
    }

    // 检索本地防火墙策略.
    hr = fwMgr-> get_LocalPolicy(& fwPolicy);
    如果(FAILED(hr))
    {
        printf(" ，hr)；
        转到错误；
    }

    // 检索当前有效的防火墙配置文件.
    hr = fwPolicy-> get_CurrentProfile(fwProfile);
    如果(FAILED(hr))
    {
        printf(" ，hr)；
        转到错误；
    }

错误:

    // 释放本地防火墙策略.
    如果(fwPolicy！= NULL)
    {
        fwPolicy-> Release();
    }

    // 释放防火墙设置管理器.
    如果(fwMgr！= NULL)
    {
        fwMgr-> Release();
    }

    返回小时；
}


无效 WindowsFirewallCleanup(IN INetFwProfile * fwProfile)
{
    // 释放防火墙配置文件.
    如果(fwProfile！= NULL)
    {
        fwProfile-> Release();
    }
}


HRESULT WindowsFirewallIsOn(INNetFwProfile * fwProfile，OUT BOOL * fwOn)
{
    HRESULT hr = S_OK;
    VARIANT_BOOL fwEnabled;

    _ASSERT(fwProfile！= NULL);
    _ASSERT(fwOn！= NULL);

    * fwOn = FALSE;

    // 获取防火墙的当前状态.
    hr = fwProfile-> get_FirewallEnabled(& fwEnabled);
    如果(FAILED(hr))
    {
        printf(" ，hr)；
        转到错误；
    }

    // 检查防火墙是否打开.
    如果(fwEnabled！= VARIANT_FALSE)
    {
        * fwOn = TRUE;
        printf(" )；
    }
    其他
    {
        printf(" );
    }

错误:

    返回小时；
}


HRESULT WindowsFirewallTurnOn(在INetFwProfile * fwProfile中)
{
    HRESULT hr = S_OK;
    BOOL fwOn;

    _ASSERT(fwProfile！= NULL);

    // 检查防火墙是否关闭.
    hr = WindowsFirewallIsOn(fwProfile，& fwOn);
    如果(FAILED(hr))
    {
        printf(" ，hr)；
        转到错误；
    }

    // 如果是，则将其打开.
    如果(！fwOn)
    {
        // 打开防火墙.
        hr = fwProfile-> put_FirewallEnabled(VARIANT_TRUE);
        如果(FAILED(hr))
        {
            printf(" ，hr)；
            转到错误；
        }

        printf(" )；
    }

错误:

    返回小时；
}


HRESULT WindowsFirewallTurnOff(在INetFwProfile * fwProfile中)
{
    HRESULT hr = S_OK;
    BOOL fwOn;

    _ASSERT(fwProfile！= NULL);

    // 检查防火墙是否打开.
    hr = WindowsFirewallIsOn(fwProfile，& fwOn);
    如果(FAILED(hr))
    {
        printf(" ，hr)；
        转到错误；
    }

    // 如果是，请将其关闭.
    如果(fwOn)
    {
        // 关闭防火墙.
        hr = fwProfile-> put_FirewallEnabled(VARIANT_FALSE);
        如果(FAILED(hr))
        {
            printf(" ，hr)；
            转到错误；
        }

        printf(" )；
    }

错误:

    返回小时；
}


HRESULT WindowsFirewallAppIsEnabled(
            在INetFwProfile * fwProfile中，
            IN  const   wchar_t  * fwProcessImageFileName，
            OUT BOOL * fwAppEnabled
            )
{
    HRESULT hr = S_OK;
    BSTR fwBstrProcessImageFileName = NULL;
    VARIANT_BOOL fwEnabled;
    INetFwAuthorizedApplication * fwApp = NULL;
    INetFwAuthorizedApplications * fwApps = NULL;

    _ASSERT(fwProfile！= NULL);
    _ASSERT(fwProcessImageFileName！= NULL);
    _ASSERT(fwAppEnabled！= NULL);

    * fwAppEnabled = FALSE;

    // 检索授权的应用程序集合.
    hr = fwProfile-> get_AuthorizedApplications(& fwApps);
    如果(FAILED(hr))
    {
        printf(" ，hr);
        转到错误；
    }

    // 为过程映像文件名分配BSTR.
    fwBstrProcessImageFileName = SysAllocString(fwProcessImageFileName);
    如果(fwBstrProcessImageFileName == NULL)
    {
        hr = E_OUTOFMEMORY;
        printf(" ，hr)；
        转到错误；
    }

    // 尝试检索授权的应用程序.
    hr = fwApps-> Item(fwBstrProcessImageFileName，& fwApp);
    如果(SUCCEEDED(hr))
    {
        // 了解是否已启用授权的应用程序.
        hr = fwApp-> get_Enabled(& fwEnabled);
        如果(FAILED(hr))
        {
            printf(" ，hr);
            转到错误；
        }

        如果(fwEnabled！= VARIANT_FALSE)
        {
            // 授权的应用程序已启用.
            * fwAppEnabled = TRUE;

            printf(
                " ，
                fwProcessImageFileName
                );
        }
        其他
        {
            printf(
                " ，
                fwProcessImageFileName
                );
        }
    }
    其他
    {
        // 授权的应用程序不在集合中.
        hr = S_OK;

        printf(
            " ，
            fwProcessImageFileName
            );
    }

错误:

    // 释放BSTR.
    SysFreeString(fwBstrProcessImageFileName);

    // 释放授权的应用程序实例.
    如果(fwApp！= NULL)
    {
        fwApp-> Release();
    }

    // 释放授权的应用程序集合.
    如果(fwApps！= NULL)
    {
        fwApps-> Release();
    }

    返回小时；
}


HRESULT WindowsFirewallAddApp(
            在INetFwProfile * fwProfile中，
            IN  const   wchar_t  * fwProcessImageFileName，
            IN  const   wchar_t  * fwName
            )
{
    HRESULT hr = S_OK;
    BOOL fwAppEnabled;
    BSTR fwBstrName = NULL;
    BSTR fwBstrProcessImageFileName = NULL;
    INetFwAuthorizedApplication * fwApp = NULL;
    INetFwAuthorizedApplications * fwApps = NULL;

    _ASSERT(fwProfile！= NULL);
    _ASSERT(fwProcessImageFileName！= NULL);
    _ASSERT(fwName！= NULL);

    // 首先检查该应用程序是否已被授权.
    hr = WindowsFirewallAppIsEnabled(
            fwProfile，
            fwProcessImageFileName，
            & fwAppEnabled
            );
    如果(FAILED(hr))
    {
        printf(" ，hr)；
        转到错误；
    }

    // 仅在未获得授权的情况下添加应用程序.
    如果(！fwAppEnabled)
    {
        // 检索授权的应用程序集合.
        hr = fwProfile-> get_AuthorizedApplications(& fwApps);
        如果(FAILED(hr))
        {
            printf(" ，hr);
            转到错误；
        }

        // 创建授权应用程序的实例.
        hr = CoCreateInstance(
                 __ uuidof (NetFwAuthorizedApplication)，
                无效的，
                CLSCTX_INPROC_SERVER，
                 __ uuidof (INetFwAuthorizedApplication)，
                ( void  **)& fwApp
                );
        如果(FAILED(hr))
        {
            printf(" ，hr)；
            转到错误；
        }

        // 为过程映像文件名分配BSTR.
        fwBstrProcessImageFileName = SysAllocString(fwProcessImageFileName);
        如果(fwBstrProcessImageFileName == NULL)
        {
            hr = E_OUTOFMEMORY;
            printf(" ，hr)；
            转到错误；
        }

        // 设置过程映像文件名.
        hr = fwApp-> put_ProcessImageFileName(fwBstrProcessImageFileName);
        如果(FAILED(hr))
        {
            printf(" ，hr)；
            转到错误；
        }

        // 为应用程序友好名称分配BSTR.
        fwBstrName = SysAllocString(fwName);
        如果(SysStringLen(fwBstrName)==  0 )
        {
            hr = E_OUTOFMEMORY;
            printf(" ，hr)；
            转到错误；
        }

        // 设置应用程序友好名称.
        hr = fwApp-> put_Name(fwBstrName);
        如果(FAILED(hr))
        {
            printf(" ，hr)；
            转到错误；
        }

        // 将应用程序添加到集合中.
        hr = fwApps-> Add(fwApp);
        如果(FAILED(hr))
        {
            printf(" ，hr)；
            转到错误；
        }

        printf(
            " ，
            fwProcessImageFileName
            );
    }

错误:

    // 释放BSTR.
    SysFreeString(fwBstrName);
    SysFreeString(fwBstrProcessImageFileName);

    // 释放授权的应用程序实例.
    如果(fwApp！= NULL)
    {
        fwApp-> Release();
    }

    // 释放授权的应用程序集合.
    如果(fwApps！= NULL)
    {
        fwApps-> Release();
    }

    返回小时；
}


HRESULT WindowsFirewallPortIsEnabled(
            在INetFwProfile * fwProfile中，
            IN LONG portNumber，
            在NET_FW_IP_PROTOCOL ipProtocol中，
            OUT BOOL * fwPortEnabled
            )
{
    HRESULT hr = S_OK;
    VARIANT_BOOL fwEnabled;
    INetFwOpenPort * fwOpenPort = NULL;
    INetFwOpenPorts * fwOpenPorts = NULL;

    _ASSERT(fwProfile！= NULL);
    _ASSERT(fwPortEnabled！= NULL);

    * fwPortEnabled =否；

    // 检索全局开放的端口集合.
    hr = fwProfile-> get_GloballyOpenPorts(& fwOpenPorts);
    如果(FAILED(hr))
    {
        printf(" ，hr);
        转到错误；
    }

    // 尝试检索全局打开的端口.
    hr = fwOpenPorts-> Item(portNumber，ipProtocol，& fwOpenPort);
    如果(SUCCEEDED(hr))
    {
        // 了解是否启用了全局打开的端口.
        hr = fwOpenPort-> get_Enabled(& fwEnabled);
        如果(FAILED(hr))
        {
            printf(" ，hr);
            转到错误；
        }

        如果(fwEnabled！= VARIANT_FALSE)
        {
            // 启用了全局打开的端口.
            * fwPortEnabled = TRUE;

            printf(" ，portNumber)；
        }
        其他
        {
            printf(" ，portNumber)；
        }
    }
    其他
    {
        // 全局开放的端口不在集合中.
        hr = S_OK;

        printf(" ，portNumber)；
    }

错误:

    // 释放全局打开的端口.
    如果(fwOpenPort！= NULL)
    {
        fwOpenPort-> Release();
    }

    // 释放全局开放的端口集合.
    如果(fwOpenPorts！= NULL)
    {
        fwOpenPorts-> Release();
    }

    返回小时；
}


HRESULT WindowsFirewallPortAdd(
            在INetFwProfile * fwProfile中，
            IN LONG portNumber，
            在NET_FW_IP_PROTOCOL ipProtocol中，
            IN  const   wchar_t  *名称
            )
{
    HRESULT hr = S_OK;
    布尔fwPortEnabled;
    BSTR fwBstrName = NULL;
    INetFwOpenPort * fwOpenPort = NULL;
    INetFwOpenPorts * fwOpenPorts = NULL;

    _ASSERT(fwProfile！= NULL);
    _ASSERT(name！= NULL);

    // 首先检查端口是否已添加.
    hr = WindowsFirewallPortIsEnabled(
            fwProfile，
            portNumber，
            ipProtocol，
            & fwPortEnabled
            );
    如果(FAILED(hr))
    {
        printf(" ，hr)；
        转到错误；
    }

    // 仅在尚未添加端口的情况下添加端口.
    如果(！fwPortEnabled)
    {
        // 检索全局打开的端口的集合.
        hr = fwProfile-> get_GloballyOpenPorts(& fwOpenPorts);
        如果(FAILED(hr))
        {
            printf(" ，hr);
            转到错误；
        }

        // 创建一个开放端口的实例.
        hr = CoCreateInstance(
                 __ uuidof (NetFwOpenPort)，
                无效的，
                CLSCTX_INPROC_SERVER，
                 __ uuidof (INetFwOpenPort)，
                (无效 **)& fwOpenPort
                );
        如果(FAILED(hr))
        {
            printf(" ，hr)；
            转到错误；
        }

        // 设置端口号.
        hr = fwOpenPort-> put_Port(portNumber);
        如果(FAILED(hr))
        {
            printf(" ，hr)；
            转到错误；
        }

        // 设置IP协议.
        hr = fwOpenPort-> put_Protocol(ipProtocol);
        如果(FAILED(hr))
        {
            printf(" ，hr)；
            转到错误；
        }

        // 为端口的友好名称分配一个BSTR.
        fwBstrName = SysAllocString(名称);
        如果(SysStringLen(fwBstrName)==  0 )
        {
            hr = E_OUTOFMEMORY;
            printf(" ，hr)；
            转到错误；
        }

        // 设置端口的友好名称.
        hr = fwOpenPort-> put_Name(fwBstrName);
        如果(FAILED(hr))
        {
            printf(" ，hr)；
            转到错误；
        }

        // 打开端口并将其添加到集合中.
        hr = fwOpenPorts-> Add(fwOpenPort);
        如果(FAILED(hr))
        {
            printf(" ，hr)；
            转到错误；
        }

        printf(" ，portNumber)；
    }

错误:

    // 释放BSTR.
    SysFreeString(fwBstrName);

    // 释放打开的端口实例.
    如果(fwOpenPort！= NULL)
    {
        fwOpenPort-> Release();
    }

    // 释放全局开放的端口集合.
    如果(fwOpenPorts！= NULL)
    {
        fwOpenPorts-> Release();
    }

    返回小时；
}



//  int __cdecl wmain(int argc，wchar_t * argv [])
//  {
//  HRESULT hr = S_OK; 
//  HRESULT comInit = E_FAIL; 
//  INetFwProfile * fwProfile = NULL; 
//  
// //初始化COM.
//  comInit = CoInitializeEx(
//  0，
//  COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE 
// ); 
//  
// //忽略RPC_E_CHANGED_MODE；这只是意味着COM已经存在
// //用其他模式初始化.由于我们不在乎模式是什么，
// //我们将仅使用现有模式.
// 如果(comInit！= RPC_E_CHANGED_MODE)
//  {
//  hr = comInit; 
// 如果(FAILED(hr))
//  {
//  printf("CoInitializeEx失败:0x％08lx \ n"，hr); 
// 转到错误； 
// } 
// } 
//  
// //检索当前有效的防火墙配置文件.
//  hr = WindowsFirewallInitialize(& fwProfile); 
// 如果(FAILED(hr))
//  {
//  printf("WindowsFirewallInitialize失败:0x％08lx \ n"，hr); 
// 转到错误； 
// } 
//  
// //关闭防火墙.
//  hr = WindowsFirewallTurnOff(fwProfile); 
// 如果(FAILED(hr))
//  {
//  printf("WindowsFirewallTurnOff失败:0x％08lx \ n"，hr); 
// 转到错误； 
// } 
//  
// //打开防火墙.
//  hr = WindowsFirewallTurnOn(fwProfile); 
// 如果(FAILED(hr))
//  {
//  printf("WindowsFirewallTurnOn失败:0x％08lx \ n"，hr); 
// 转到错误； 
// } 
//  
// //将Windows Messenger添加到授权的应用程序集合中.
//  hr = WindowsFirewallAddApp(
//  fwProfile，
//  L％ProgramFiles％\\ Messenger \\ msmsgs.exe"，
//  L"Windows Messenger" 
// ); 
// 如果(FAILED(hr))
//  {
//  printf("WindowsFirewallAddApp失败:0x％08lx \ n"，hr); 
// 转到错误； 
// } 
//  
// //将TCP :: 80添加到全局打开的端口列表中.
//  hr = WindowsFirewallPortAdd(fwProfile，80，NET_FW_IP_PROTOCOL_TCP，L"WWW"); 
// 如果(FAILED(hr))
//  {
//  printf("WindowsFirewallPortAdd失败:0x％08lx \ n"，hr); 
// 转到错误； 
// } 
//  
// 错误:
//  
// //释放防火墙配置文件.
//  WindowsFirewallCleanup(fwProfile); 
//  
// //未初始化COM.
// 如果(SUCCEEDED(comInit))
//  {
//  CoUninitialize(); 
// } 
//  
// 返回0； 
// } 


 bool  AddFirewallException( const   wchar_t  * fwProcessImageFileName， 常量  wchar_t  * fwDisplayName)
{
    HRESULT hr = S_OK;
    HRESULT comInit = E_FAIL;
    INetFwProfile * fwProfile = NULL;

    // 初始化COM.
    comInit = CoInitializeEx(
                 0 ，
                COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE
                );

   // 忽略RPC_E_CHANGED_MODE；这只是意味着COM已经存在
   // 用其他模式初始化.由于我们不在乎模式是什么，
   // 我们将仅使用现有模式.
   如果(comInit！= RPC_E_CHANGED_MODE)
   {
        hr = comInit;
        如果(FAILED(hr))
        {
            printf(" ，hr)；
            转到错误；
        }
   }

    // 检索当前有效的防火墙配置文件.
    hr = WindowsFirewallInitialize(& fwProfile);
    如果(FAILED(hr))
    {
        printf(" ，hr);
        转到错误；
    }

    // 将Windows Messenger添加到授权的应用程序集合中.
    hr = WindowsFirewallAddApp(
            fwProfile，
            fwProcessImageFileName，
            fwDisplayName
            );
    如果(FAILED(hr))
    {
        printf(" ，hr)；
        转到错误；
    }

错误:

    // 释放防火墙配置文件.
    WindowsFirewallCleanup(fwProfile);

    // 未初始化COM.
    如果(SUCCEEDED(comInit))
    {
        CoUninitialize();
    }

    返回！FAILED(hr);
}</stdio.h></oleauto.h></objbase.h></netfw.h></crtdbg.h</windows.h> 

hi How Can I:
Turn off/on firewall
with Visual C++ MFC 2010 ?
all of other codes,did''nt work truly!
thanks a lot

解决方案

Take a look at the article here.. its in VB not much harder to get it to c++ for the article.

Programmatically disable/enable Windows firewall[^]

Also, you can refer to this one.

http://www.vedivi.com/support/blog/72-configure-your-firewall-in-c.html[^]

I couldn''t find the original link that I got the following code from, but I use this in one of my projects to change the windows firewall:

 /*
    Copyright (c) Microsoft Corporation

    SYNOPSIS

        Sample code for the Windows Firewall COM interface.
*/

#include "stdafx.h"
#include <windows.h>
#include <crtdbg.h>
#include <netfw.h>
#include <objbase.h>
#include <oleauto.h>
#include <stdio.h>


HRESULT WindowsFirewallInitialize(OUT INetFwProfile** fwProfile)
{
    HRESULT hr = S_OK;
    INetFwMgr* fwMgr = NULL;
    INetFwPolicy* fwPolicy = NULL;

    _ASSERT(fwProfile != NULL);

    *fwProfile = NULL;

    // Create an instance of the firewall settings manager.
    hr = CoCreateInstance(
            __uuidof(NetFwMgr),
            NULL,
            CLSCTX_INPROC_SERVER,
            __uuidof(INetFwMgr),
            (void**)&fwMgr
            );
    if (FAILED(hr))
    {
        printf("CoCreateInstance failed: 0x%08lx\n", hr);
        goto error;
    }

    // Retrieve the local firewall policy.
    hr = fwMgr->get_LocalPolicy(&fwPolicy);
    if (FAILED(hr))
    {
        printf("get_LocalPolicy failed: 0x%08lx\n", hr);
        goto error;
    }

    // Retrieve the firewall profile currently in effect.
    hr = fwPolicy->get_CurrentProfile(fwProfile);
    if (FAILED(hr))
    {
        printf("get_CurrentProfile failed: 0x%08lx\n", hr);
        goto error;
    }

error:

    // Release the local firewall policy.
    if (fwPolicy != NULL)
    {
        fwPolicy->Release();
    }

    // Release the firewall settings manager.
    if (fwMgr != NULL)
    {
        fwMgr->Release();
    }

    return hr;
}


void WindowsFirewallCleanup(IN INetFwProfile* fwProfile)
{
    // Release the firewall profile.
    if (fwProfile != NULL)
    {
        fwProfile->Release();
    }
}


HRESULT WindowsFirewallIsOn(IN INetFwProfile* fwProfile, OUT BOOL* fwOn)
{
    HRESULT hr = S_OK;
    VARIANT_BOOL fwEnabled;

    _ASSERT(fwProfile != NULL);
    _ASSERT(fwOn != NULL);

    *fwOn = FALSE;

    // Get the current state of the firewall.
    hr = fwProfile->get_FirewallEnabled(&fwEnabled);
    if (FAILED(hr))
    {
        printf("get_FirewallEnabled failed: 0x%08lx\n", hr);
        goto error;
    }

    // Check to see if the firewall is on.
    if (fwEnabled != VARIANT_FALSE)
    {
        *fwOn = TRUE;
        printf("The firewall is on.\n");
    }
    else
    {
        printf("The firewall is off.\n");
    }

error:

    return hr;
}


HRESULT WindowsFirewallTurnOn(IN INetFwProfile* fwProfile)
{
    HRESULT hr = S_OK;
    BOOL fwOn;

    _ASSERT(fwProfile != NULL);

    // Check to see if the firewall is off.
    hr = WindowsFirewallIsOn(fwProfile, &fwOn);
    if (FAILED(hr))
    {
        printf("WindowsFirewallIsOn failed: 0x%08lx\n", hr);
        goto error;
    }

    // If it is, turn it on.
    if (!fwOn)
    {
        // Turn the firewall on.
        hr = fwProfile->put_FirewallEnabled(VARIANT_TRUE);
        if (FAILED(hr))
        {
            printf("put_FirewallEnabled failed: 0x%08lx\n", hr);
            goto error;
        }

        printf("The firewall is now on.\n");
    }

error:

    return hr;
}


HRESULT WindowsFirewallTurnOff(IN INetFwProfile* fwProfile)
{
    HRESULT hr = S_OK;
    BOOL fwOn;

    _ASSERT(fwProfile != NULL);

    // Check to see if the firewall is on.
    hr = WindowsFirewallIsOn(fwProfile, &fwOn);
    if (FAILED(hr))
    {
        printf("WindowsFirewallIsOn failed: 0x%08lx\n", hr);
        goto error;
    }

    // If it is, turn it off.
    if (fwOn)
    {
        // Turn the firewall off.
        hr = fwProfile->put_FirewallEnabled(VARIANT_FALSE);
        if (FAILED(hr))
        {
            printf("put_FirewallEnabled failed: 0x%08lx\n", hr);
            goto error;
        }

        printf("The firewall is now off.\n");
    }

error:

    return hr;
}


HRESULT WindowsFirewallAppIsEnabled(
            IN INetFwProfile* fwProfile,
            IN const wchar_t* fwProcessImageFileName,
            OUT BOOL* fwAppEnabled
            )
{
    HRESULT hr = S_OK;
    BSTR fwBstrProcessImageFileName = NULL;
    VARIANT_BOOL fwEnabled;
    INetFwAuthorizedApplication* fwApp = NULL;
    INetFwAuthorizedApplications* fwApps = NULL;

    _ASSERT(fwProfile != NULL);
    _ASSERT(fwProcessImageFileName != NULL);
    _ASSERT(fwAppEnabled != NULL);

    *fwAppEnabled = FALSE;

    // Retrieve the authorized application collection.
    hr = fwProfile->get_AuthorizedApplications(&fwApps);
    if (FAILED(hr))
    {
        printf("get_AuthorizedApplications failed: 0x%08lx\n", hr);
        goto error;
    }

    // Allocate a BSTR for the process image file name.
    fwBstrProcessImageFileName = SysAllocString(fwProcessImageFileName);
    if (fwBstrProcessImageFileName == NULL)
    {
        hr = E_OUTOFMEMORY;
        printf("SysAllocString failed: 0x%08lx\n", hr);
        goto error;
    }

    // Attempt to retrieve the authorized application.
    hr = fwApps->Item(fwBstrProcessImageFileName, &fwApp);
    if (SUCCEEDED(hr))
    {
        // Find out if the authorized application is enabled.
        hr = fwApp->get_Enabled(&fwEnabled);
        if (FAILED(hr))
        {
            printf("get_Enabled failed: 0x%08lx\n", hr);
            goto error;
        }

        if (fwEnabled != VARIANT_FALSE)
        {
            // The authorized application is enabled.
            *fwAppEnabled = TRUE;

            printf(
                "Authorized application %lS is enabled in the firewall.\n",
                fwProcessImageFileName
                );
        }
        else
        {
            printf(
                "Authorized application %lS is disabled in the firewall.\n",
                fwProcessImageFileName
                );
        }
    }
    else
    {
        // The authorized application was not in the collection.
        hr = S_OK;

        printf(
            "Authorized application %lS is disabled in the firewall.\n",
            fwProcessImageFileName
            );
    }

error:

    // Free the BSTR.
    SysFreeString(fwBstrProcessImageFileName);

    // Release the authorized application instance.
    if (fwApp != NULL)
    {
        fwApp->Release();
    }

    // Release the authorized application collection.
    if (fwApps != NULL)
    {
        fwApps->Release();
    }

    return hr;
}


HRESULT WindowsFirewallAddApp(
            IN INetFwProfile* fwProfile,
            IN const wchar_t* fwProcessImageFileName,
            IN const wchar_t* fwName
            )
{
    HRESULT hr = S_OK;
    BOOL fwAppEnabled;
    BSTR fwBstrName = NULL;
    BSTR fwBstrProcessImageFileName = NULL;
    INetFwAuthorizedApplication* fwApp = NULL;
    INetFwAuthorizedApplications* fwApps = NULL;

    _ASSERT(fwProfile != NULL);
    _ASSERT(fwProcessImageFileName != NULL);
    _ASSERT(fwName != NULL);

    // First check to see if the application is already authorized.
    hr = WindowsFirewallAppIsEnabled(
            fwProfile,
            fwProcessImageFileName,
            &fwAppEnabled
            );
    if (FAILED(hr))
    {
        printf("WindowsFirewallAppIsEnabled failed: 0x%08lx\n", hr);
        goto error;
    }

    // Only add the application if it isn't already authorized.
    if (!fwAppEnabled)
    {
        // Retrieve the authorized application collection.
        hr = fwProfile->get_AuthorizedApplications(&fwApps);
        if (FAILED(hr))
        {
            printf("get_AuthorizedApplications failed: 0x%08lx\n", hr);
            goto error;
        }

        // Create an instance of an authorized application.
        hr = CoCreateInstance(
                __uuidof(NetFwAuthorizedApplication),
                NULL,
                CLSCTX_INPROC_SERVER,
                __uuidof(INetFwAuthorizedApplication),
                (void**)&fwApp
                );
        if (FAILED(hr))
        {
            printf("CoCreateInstance failed: 0x%08lx\n", hr);
            goto error;
        }

        // Allocate a BSTR for the process image file name.
        fwBstrProcessImageFileName = SysAllocString(fwProcessImageFileName);
        if (fwBstrProcessImageFileName == NULL)
        {
            hr = E_OUTOFMEMORY;
            printf("SysAllocString failed: 0x%08lx\n", hr);
            goto error;
        }

        // Set the process image file name.
        hr = fwApp->put_ProcessImageFileName(fwBstrProcessImageFileName);
        if (FAILED(hr))
        {
            printf("put_ProcessImageFileName failed: 0x%08lx\n", hr);
            goto error;
        }

        // Allocate a BSTR for the application friendly name.
        fwBstrName = SysAllocString(fwName);
        if (SysStringLen(fwBstrName) == 0)
        {
            hr = E_OUTOFMEMORY;
            printf("SysAllocString failed: 0x%08lx\n", hr);
            goto error;
        }

        // Set the application friendly name.
        hr = fwApp->put_Name(fwBstrName);
        if (FAILED(hr))
        {
            printf("put_Name failed: 0x%08lx\n", hr);
            goto error;
        }

        // Add the application to the collection.
        hr = fwApps->Add(fwApp);
        if (FAILED(hr))
        {
            printf("Add failed: 0x%08lx\n", hr);
            goto error;
        }

        printf(
            "Authorized application %lS is now enabled in the firewall.\n",
            fwProcessImageFileName
            );
    }

error:

    // Free the BSTRs.
    SysFreeString(fwBstrName);
    SysFreeString(fwBstrProcessImageFileName);

    // Release the authorized application instance.
    if (fwApp != NULL)
    {
        fwApp->Release();
    }

    // Release the authorized application collection.
    if (fwApps != NULL)
    {
        fwApps->Release();
    }

    return hr;
}


HRESULT WindowsFirewallPortIsEnabled(
            IN INetFwProfile* fwProfile,
            IN LONG portNumber,
            IN NET_FW_IP_PROTOCOL ipProtocol,
            OUT BOOL* fwPortEnabled
            )
{
    HRESULT hr = S_OK;
    VARIANT_BOOL fwEnabled;
    INetFwOpenPort* fwOpenPort = NULL;
    INetFwOpenPorts* fwOpenPorts = NULL;

    _ASSERT(fwProfile != NULL);
    _ASSERT(fwPortEnabled != NULL);

    *fwPortEnabled = FALSE;

    // Retrieve the globally open ports collection.
    hr = fwProfile->get_GloballyOpenPorts(&fwOpenPorts);
    if (FAILED(hr))
    {
        printf("get_GloballyOpenPorts failed: 0x%08lx\n", hr);
        goto error;
    }

    // Attempt to retrieve the globally open port.
    hr = fwOpenPorts->Item(portNumber, ipProtocol, &fwOpenPort);
    if (SUCCEEDED(hr))
    {
        // Find out if the globally open port is enabled.
        hr = fwOpenPort->get_Enabled(&fwEnabled);
        if (FAILED(hr))
        {
            printf("get_Enabled failed: 0x%08lx\n", hr);
            goto error;
        }

        if (fwEnabled != VARIANT_FALSE)
        {
            // The globally open port is enabled.
            *fwPortEnabled = TRUE;

            printf("Port %ld is open in the firewall.\n", portNumber);
        }
        else
        {
            printf("Port %ld is not open in the firewall.\n", portNumber);
        }
    }
    else
    {
        // The globally open port was not in the collection.
        hr = S_OK;

        printf("Port %ld is not open in the firewall.\n", portNumber);
    }

error:

    // Release the globally open port.
    if (fwOpenPort != NULL)
    {
        fwOpenPort->Release();
    }

    // Release the globally open ports collection.
    if (fwOpenPorts != NULL)
    {
        fwOpenPorts->Release();
    }

    return hr;
}


HRESULT WindowsFirewallPortAdd(
            IN INetFwProfile* fwProfile,
            IN LONG portNumber,
            IN NET_FW_IP_PROTOCOL ipProtocol,
            IN const wchar_t* name
            )
{
    HRESULT hr = S_OK;
    BOOL fwPortEnabled;
    BSTR fwBstrName = NULL;
    INetFwOpenPort* fwOpenPort = NULL;
    INetFwOpenPorts* fwOpenPorts = NULL;

    _ASSERT(fwProfile != NULL);
    _ASSERT(name != NULL);

    // First check to see if the port is already added.
    hr = WindowsFirewallPortIsEnabled(
            fwProfile,
            portNumber,
            ipProtocol,
            &fwPortEnabled
            );
    if (FAILED(hr))
    {
        printf("WindowsFirewallPortIsEnabled failed: 0x%08lx\n", hr);
        goto error;
    }

    // Only add the port if it isn't already added.
    if (!fwPortEnabled)
    {
        // Retrieve the collection of globally open ports.
        hr = fwProfile->get_GloballyOpenPorts(&fwOpenPorts);
        if (FAILED(hr))
        {
            printf("get_GloballyOpenPorts failed: 0x%08lx\n", hr);
            goto error;
        }

        // Create an instance of an open port.
        hr = CoCreateInstance(
                __uuidof(NetFwOpenPort),
                NULL,
                CLSCTX_INPROC_SERVER,
                __uuidof(INetFwOpenPort),
                (void**)&fwOpenPort
                );
        if (FAILED(hr))
        {
            printf("CoCreateInstance failed: 0x%08lx\n", hr);
            goto error;
        }

        // Set the port number.
        hr = fwOpenPort->put_Port(portNumber);
        if (FAILED(hr))
        {
            printf("put_Port failed: 0x%08lx\n", hr);
            goto error;
        }

        // Set the IP protocol.
        hr = fwOpenPort->put_Protocol(ipProtocol);
        if (FAILED(hr))
        {
            printf("put_Protocol failed: 0x%08lx\n", hr);
            goto error;
        }

        // Allocate a BSTR for the friendly name of the port.
        fwBstrName = SysAllocString(name);
        if (SysStringLen(fwBstrName) == 0)
        {
            hr = E_OUTOFMEMORY;
            printf("SysAllocString failed: 0x%08lx\n", hr);
            goto error;
        }

        // Set the friendly name of the port.
        hr = fwOpenPort->put_Name(fwBstrName);
        if (FAILED(hr))
        {
            printf("put_Name failed: 0x%08lx\n", hr);
            goto error;
        }

        // Opens the port and adds it to the collection.
        hr = fwOpenPorts->Add(fwOpenPort);
        if (FAILED(hr))
        {
            printf("Add failed: 0x%08lx\n", hr);
            goto error;
        }

        printf("Port %ld is now open in the firewall.\n", portNumber);
    }

error:

    // Free the BSTR.
    SysFreeString(fwBstrName);

    // Release the open port instance.
    if (fwOpenPort != NULL)
    {
        fwOpenPort->Release();
    }

    // Release the globally open ports collection.
    if (fwOpenPorts != NULL)
    {
        fwOpenPorts->Release();
    }

    return hr;
}



//int __cdecl wmain(int argc, wchar_t* argv[])
//{
//    HRESULT hr = S_OK;
//    HRESULT comInit = E_FAIL;
//    INetFwProfile* fwProfile = NULL;
//
//    // Initialize COM.
//    comInit = CoInitializeEx(
//                0,
//                COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE
//                );
//
//   // Ignore RPC_E_CHANGED_MODE; this just means that COM has already been
//   // initialized with a different mode. Since we don't care what the mode is,
//   // we'll just use the existing mode.
//   if (comInit != RPC_E_CHANGED_MODE)
//   {
//        hr = comInit;
//        if (FAILED(hr))
//        {
//            printf("CoInitializeEx failed: 0x%08lx\n", hr);
//            goto error;
//        }
//   }
//
//    // Retrieve the firewall profile currently in effect.
//    hr = WindowsFirewallInitialize(&fwProfile);
//    if (FAILED(hr))
//    {
//        printf("WindowsFirewallInitialize failed: 0x%08lx\n", hr);
//        goto error;
//    }
//
//    // Turn off the firewall.
//    hr = WindowsFirewallTurnOff(fwProfile);
//    if (FAILED(hr))
//    {
//        printf("WindowsFirewallTurnOff failed: 0x%08lx\n", hr);
//        goto error;
//    }
//
//    // Turn on the firewall.
//    hr = WindowsFirewallTurnOn(fwProfile);
//    if (FAILED(hr))
//    {
//        printf("WindowsFirewallTurnOn failed: 0x%08lx\n", hr);
//        goto error;
//    }
//
//    // Add Windows Messenger to the authorized application collection.
//    hr = WindowsFirewallAddApp(
//            fwProfile,
//            L"%ProgramFiles%\\Messenger\\msmsgs.exe",
//            L"Windows Messenger"
//            );
//    if (FAILED(hr))
//    {
//        printf("WindowsFirewallAddApp failed: 0x%08lx\n", hr);
//        goto error;
//    }
//
//    // Add TCP::80 to list of globally open ports.
//    hr = WindowsFirewallPortAdd(fwProfile, 80, NET_FW_IP_PROTOCOL_TCP, L"WWW");
//    if (FAILED(hr))
//    {
//        printf("WindowsFirewallPortAdd failed: 0x%08lx\n", hr);
//        goto error;
//    }
//
//error:
//
//    // Release the firewall profile.
//    WindowsFirewallCleanup(fwProfile);
//
//    // Uninitialize COM.
//    if (SUCCEEDED(comInit))
//    {
//        CoUninitialize();
//    }
//
//    return 0;
//}


bool AddFirewallException(const wchar_t* fwProcessImageFileName, const wchar_t* fwDisplayName)
{
    HRESULT hr = S_OK;
    HRESULT comInit = E_FAIL;
    INetFwProfile* fwProfile = NULL;

    // Initialize COM.
    comInit = CoInitializeEx(
                0,
                COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE
                );

   // Ignore RPC_E_CHANGED_MODE; this just means that COM has already been
   // initialized with a different mode. Since we don't care what the mode is,
   // we'll just use the existing mode.
   if (comInit != RPC_E_CHANGED_MODE)
   {
        hr = comInit;
        if (FAILED(hr))
        {
            printf("CoInitializeEx failed: 0x%08lx\n", hr);
            goto error;
        }
   }

    // Retrieve the firewall profile currently in effect.
    hr = WindowsFirewallInitialize(&fwProfile);
    if (FAILED(hr))
    {
        printf("WindowsFirewallInitialize failed: 0x%08lx\n", hr);
        goto error;
    }

    // Add Windows Messenger to the authorized application collection.
    hr = WindowsFirewallAddApp(
            fwProfile,
            fwProcessImageFileName,
            fwDisplayName
            );
    if (FAILED(hr))
    {
        printf("WindowsFirewallAddApp failed: 0x%08lx\n", hr);
        goto error;
    }

error:

    // Release the firewall profile.
    WindowsFirewallCleanup(fwProfile);

    // Uninitialize COM.
    if (SUCCEEDED(comInit))
    {
        CoUninitialize();
    }

    return !FAILED(hr);
}</stdio.h></oleauto.h></objbase.h></netfw.h></crtdbg.h></windows.h>

这篇关于关闭/打开防火墙的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！