Function set_rules

resources/windows_firewall/src/firewall.rs:405–460

(input: &FirewallRuleList)

}

pub fn set_rules(input: &FirewallRuleList) -> Result<FirewallRuleList, FirewallError> {
    if input.rules.is_empty() {
        return Err(t!("set.rulesArrayEmpty").to_string().into());
    }

    let store = FirewallStore::open()?;
    let mut results = Vec::new();

    for desired in &input.rules {
        if desired.selector_name().is_none() {
            return Err(t!("set.selectorRequired").to_string().into());
        }

        match store.find_by_selector(desired)? {
            Some(rule) => {
                let current = rule_to_model(&rule)?;
                let rule_name = current.name.clone().unwrap_or_else(|| desired.selector_name().unwrap_or_default().to_string());

                if desired.exist == Some(false) {
                    store.remove_rule(&rule_name)?;
                    results.push(desired.missing_from_input());
                    continue;
                }

                apply_rule_properties(&rule, desired, current.protocol)?;
                results.push(rule_to_model(&rule)?);
            }
            None => {
                if desired.exist == Some(false) {
                    results.push(desired.missing_from_input());
                    continue;
                }

                let rule_name = desired.name.clone()
                    .ok_or_else(|| t!("set.selectorRequired").to_string())?;
                let rule = store.create_rule_object()?;
                unsafe { rule.SetName(&BSTR::from(rule_name.as_str())) }
                    .map_err(|error| t!("firewall.ruleAddFailed", name = rule_name.as_str(), error = error.to_string()).to_string())?;

                apply_rule_properties(&rule, desired, None)?;
                unsafe { store.rules.Add(&rule) }
                    .map_err(|error| t!("firewall.ruleAddFailed", name = rule_name.as_str(), error = error.to_string()).to_string())?;

                let created = store
                    .find_by_selector(&FirewallRule {
                        name: Some(rule_name),
                        ..FirewallRule::default()
                    })?
                    .ok_or_else(|| t!("firewall.ruleLookupFailed", name = desired.selector_name().unwrap_or("<unknown>"), error = "created rule not found").to_string())?;
                results.push(rule_to_model(&created)?);
            }
        }
    }

    Ok(FirewallRuleList { rules: results })
}

pub fn export_rules(filters: Option<&FirewallRuleList>) -> Result<FirewallRuleList, FirewallError> {