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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use windows_firewall::FirewallRule;

pub fn assert_firewall_rule_eq(actual: &FirewallRule, expected: &FirewallRule) {
    assert_eq!(actual.name(), expected.name(), "Rule name mismatch");
    assert_eq!(
        actual.direction(),
        expected.direction(),
        "Direction mismatch"
    );
    assert_eq!(
        actual.enabled(),
        expected.enabled(),
        "Enabled flag mismatch"
    );
    assert_eq!(actual.action(), expected.action(), "Action mismatch");

    if let Some(desc) = expected.description() {
        assert_eq!(
            actual.description(),
            &Some(desc.clone()),
            "Description mismatch"
        );
    }
    if let Some(app) = expected.application_name() {
        assert_eq!(
            actual.application_name(),
            &Some(app.clone()),
            "Application name mismatch"
        );
    }
    if let Some(service) = expected.service_name() {
        assert_eq!(
            actual.service_name(),
            &Some(service.clone()),
            "Service name mismatch"
        );
    }
    if let Some(protocol) = expected.protocol() {
        assert_eq!(actual.protocol(), &Some(*protocol), "Protocol mismatch");
    }
    if let Some(local_ports) = expected.local_ports() {
        assert_eq!(
            actual.local_ports(),
            &Some(local_ports.clone()),
            "Local ports mismatch"
        );
    }
    if let Some(remote_ports) = expected.remote_ports() {
        assert_eq!(
            actual.remote_ports(),
            &Some(remote_ports.clone()),
            "Remote ports mismatch"
        );
    }
    if let Some(local_addrs) = expected.local_addresses() {
        assert_eq!(
            actual.local_addresses(),
            &Some(local_addrs.clone()),
            "Local addresses mismatch"
        );
    }
    if let Some(remote_addrs) = expected.remote_addresses() {
        assert_eq!(
            actual.remote_addresses(),
            &Some(remote_addrs.clone()),
            "Remote addresses mismatch"
        );
    }
    if let Some(icmp) = expected.icmp_types_and_codes() {
        assert_eq!(
            actual.icmp_types_and_codes(),
            &Some(icmp.clone()),
            "ICMP types and codes mismatch"
        );
    }
    if let Some(interface) = expected.interfaces() {
        assert_eq!(
            actual.interfaces(),
            &Some(interface.clone()),
            "Interfaces mismatch"
        );
    }
    if let Some(interface_types) = expected.interface_types() {
        assert_eq!(
            actual.interface_types(),
            &Some(interface_types.clone()),
            "Interface types mismatch"
        );
    }
    if let Some(grouping) = expected.grouping() {
        assert_eq!(
            actual.grouping(),
            &Some(grouping.clone()),
            "Grouping mismatch"
        );
    }
    if let Some(profiles) = expected.profiles() {
        assert_eq!(actual.profiles(), &Some(*profiles), "Profiles mismatch");
    }
    if let Some(edge) = expected.edge_traversal() {
        assert_eq!(
            actual.edge_traversal(),
            &Some(*edge),
            "Edge traversal mismatch"
        );
    }
}