windows_firewall 0.7.0

A crate for managing Windows Firewall rules and settings.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use scopeguard::guard;
use windows::Win32::NetworkManagement::WindowsFirewall::INetFwRule;
use windows::Win32::System::Com::{COINIT_APARTMENTTHREADED, CoInitializeEx, CoUninitialize};
use windows_firewall::count_rules;
use windows_firewall::{list_incoming_rules, list_outgoing_rules, list_rules};

use helpers::build::build_tcp_full_rule;
use helpers::constants::RULE_NAME;

use crate::helpers::auto_remove_firewall_rule::AutoRemoveFirewallRule;
use crate::helpers::utils::assert_firewall_rule_eq;

mod helpers;

#[test]
fn test_list_rules() {
    let rule_name = format!("{RULE_NAME}_list_rules");
    let rule = build_tcp_full_rule(&rule_name);
    let _guard = AutoRemoveFirewallRule::add(&rule).unwrap();

    let count = count_rules().expect("Failed to count rules");
    let rules = list_rules().expect("Failed to list outgoing rules");

    assert_eq!(
        count as usize,
        rules.len(),
        "Count of rules should match the length of the rules list"
    );

    let fetched = rules
        .iter()
        .find(|r| *r.name() == rule_name)
        .unwrap_or_else(|| {
            panic!(
                "Firewall rule '{}' not found in list_rules() output",
                rule_name
            )
        });

    assert_firewall_rule_eq(fetched, &rule);
}

#[test]
fn test_list_incoming_rules() {
    let rules = list_incoming_rules();
    assert!(rules.is_ok(), "Failed to list incoming rules");
}

#[test]
fn test_list_outgoing_rules() {
    let rules = list_outgoing_rules();
    assert!(rules.is_ok(), "Failed to list outgoing rules");
}

#[test]
fn test_firewall_rules_conversion() {
    let firewall_rules = list_rules().expect("Failed to retrieve firewall rules");

    unsafe {
        CoInitializeEx(None, COINIT_APARTMENTTHREADED).unwrap();
    }

    let _com_cleanup = guard((), |()| unsafe { CoUninitialize() });

    let inetfw_rules = firewall_rules
        .iter()
        .map(|rule| INetFwRule::try_from(rule).expect("Failed to convert to INetFwRule"));

    assert_eq!(
        firewall_rules.len(),
        inetfw_rules.len(),
        "Conversion changed the number of rules!"
    );
}