nmstate 2.2.60

Library for networking management in a declarative manner
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

// SPDX-License-Identifier: Apache-2.0

use std::net::IpAddr;

use serde::{Deserialize, Serialize};

use crate::{BaseInterface, ErrorKind, InterfaceType, NmstateError};

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
#[non_exhaustive]
/// IP Tunnel interface. The example YAML output of a
/// [crate::NetworkState] with an ipip interface would be:
/// ```yaml
/// ---
/// interfaces:
///   - name: ipip0
///     type: ip-tunnel
///     state: up
///     ip-tunnel:
///       type: ipip
///       local: 192.0.2.1
///       remote: 192.0.2.2
///       ttl: 255
/// ```
pub struct IpTunnelInterface {
    #[serde(flatten)]
    pub base: BaseInterface,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// Deserialize and serialize to `ip-tunnel`.
    pub ip_tunnel: Option<IpTunnelConfig>,
}

impl Default for IpTunnelInterface {
    fn default() -> Self {
        Self {
            base: BaseInterface {
                iface_type: InterfaceType::IpTunnel,
                ..Default::default()
            },
            ip_tunnel: None,
        }
    }
}

impl IpTunnelInterface {
    pub fn new() -> Self {
        Self::default()
    }

    pub(crate) fn sanitize(
        &mut self,
        is_desired: bool,
    ) -> Result<(), NmstateError> {
        if is_desired
            && let Some(conf) = &mut self.ip_tunnel
            && let Some(flow_label) = conf.flow_label
            && flow_label > 0xFFFFF
        {
            return Err(NmstateError::new(
                ErrorKind::InvalidArgument,
                "Flow label must be less than 0xFFFFF".to_string(),
            ));
        }

        Ok(())
    }
}

#[derive(
    Serialize, Deserialize, Debug, Default, PartialEq, Eq, Clone, Copy,
)]
#[serde(rename_all = "kebab-case")]
#[non_exhaustive]
pub enum IpTunnelMode {
    #[default]
    Unknown,
    Ipip,
    Sit,
    Ip6ip6,
    Ipip6,
}

#[derive(
    Serialize, Deserialize, Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy,
)]
#[serde(rename_all = "kebab-case")]
#[non_exhaustive]
pub enum Ip6TunnelFlag {
    IgnEncapLimit,
    UseOrigTclass,
    UseOrigFlowlabel,
    Mip6Dev,
    RcvDscpCopy,
    UseOrigFwMark,
    AllowLocalRemote,
    CapXmit,
    CapRcv,
    CapPerPacket,
}

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
#[non_exhaustive]
#[derive(Default)]
pub struct IpTunnelConfig {
    /// The mode of the IP tunnel.
    pub mode: Option<IpTunnelMode>,

    /// The parent interface name of the IP tunnel.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub base_iface: Option<String>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub local: Option<IpAddr>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub remote: Option<IpAddr>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub ttl: Option<u8>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub tos: Option<u8>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub flow_label: Option<u32>,

    /// The flags of a ipip6 or ip6ip6 tunnel.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ip6tun_flags: Option<Vec<Ip6TunnelFlag>>,

    /// The PMTU discovery flag of the IP tunnel.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pmtu_disc: Option<bool>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub encap_limit: Option<u8>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub fwmark: Option<u32>,
}