method_v4,
/// Delete the whole IPv6 configuration entry.
method_v6,
+ /// Delete mtu for IPv4.
+ mtu_v4,
+ /// Delete mtu IPv6.
+ mtu_v6,
}
#[api(
schema: IP_SCHEMA,
optional: true,
},
+ mtu_v4: {
+ description: "Maximum Transmission Unit for IPv4.",
+ optional: true,
+ minimum: 46,
+ maximum: 65535,
+ },
+ mtu_v6: {
+ description: "Maximum Transmission Unit for IPv6.",
+ optional: true,
+ minimum: 46,
+ maximum: 65535,
+ },
delete: {
description: "List of properties to delete.",
type: Array,
method_v6: Option<NetworkConfigMethod>,
address: Option<String>,
gateway: Option<String>,
+ mtu_v4: Option<u64>,
+ mtu_v6: Option<u64>,
delete: Option<Vec<DeletableProperty>>,
digest: Option<String>,
) -> Result<(), Error> {
DeletableProperty::gateway_v6 => { interface.gateway_v6 = None; },
DeletableProperty::method_v4 => { interface.method_v4 = None; },
DeletableProperty::method_v6 => { interface.method_v6 = None; },
+ DeletableProperty::mtu_v4 => { interface.mtu_v4 = None; },
+ DeletableProperty::mtu_v6 => { interface.mtu_v6 = None; },
}
}
}
if method_v4.is_some() { interface.method_v4 = method_v4; }
if method_v6.is_some() { interface.method_v6 = method_v6; }
+ if mtu_v4.is_some() { interface.mtu_v4 = mtu_v4; }
+ if mtu_v6.is_some() { interface.mtu_v6 = mtu_v6; }
if let Some(address) = address {
let (_, _, is_v6) = network::parse_cidr(&address)?;
#[serde(skip_serializing_if="Option::is_none")]
/// IPv6 gateway
pub gateway_v6: Option<String>,
+
+ #[serde(skip_serializing_if="Option::is_none")]
+ /// Maximum Transmission Unit for IPv4
+ pub mtu_v4: Option<u64>,
+ #[serde(skip_serializing_if="Option::is_none")]
+ /// Maximum Transmission Unit for IPv6
+ pub mtu_v6: Option<u64>,
+
#[serde(skip_serializing_if="Vec::is_empty")]
pub options_v4: Vec<String>,
#[serde(skip_serializing_if="Vec::is_empty")]
gateway_v4: None,
cidr_v6: None,
gateway_v6: None,
+ mtu_v4: None,
+ mtu_v6: None,
options_v4: Vec::new(),
options_v6: Vec::new(),
}
}
}
+ if let Some(mtu) = &self.mtu_v4 {
+ writeln!(w, " mtu {}", mtu)?;
+ }
+
for option in &self.options_v4 {
writeln!(w, " {}", option)?;
}
}
}
+ if let Some(mtu) = &self.mtu_v6 {
+ writeln!(w, " mtu {}", mtu)?;
+ }
+
for option in &self.options_v6 {
writeln!(w, " {}", option)?;
}
writeln!(w, "auto {}", self.name)?;
}
- if self.method_v4 == self.method_v6 {
+ if self.method_v4 == self.method_v6
+ && self.mtu_v4 == self.mtu_v6
+ && self.options_v4.is_empty() == self.options_v6.is_empty()
+ {
if let Some(method) = self.method_v4 {
writeln!(w, "iface {} {}", self.name, method_to_str(method))?;
self.write_iface_attributes_v4(w, method)?;
Netmask,
Static,
Attribute,
+ MTU,
EOF,
}
map.insert("manual", Token::Manual);
map.insert("netmask", Token::Netmask);
map.insert("static", Token::Static);
+ map.insert("mtu", Token::MTU);
map
};
}
Ok(())
}
+ fn parse_iface_mtu(&mut self) -> Result<u64, Error> {
+ self.eat(Token::MTU)?;
+
+ let mtu = self.next_text()?;
+ let mtu = match u64::from_str_radix(&mtu, 10) {
+ Ok(mtu) => mtu,
+ Err(err) => {
+ bail!("unable to parse mtu value '{}' - {}", mtu, err);
+ }
+ };
+
+ self.eat(Token::Newline)?;
+
+ Ok(mtu)
+ }
+
fn parse_to_eol(&mut self) -> Result<String, Error> {
let mut line = String::new();
loop {
Ok(())
}
- fn parse_iface_attributes(&mut self, interface: &mut Interface) -> Result<(), Error> {
+ fn parse_iface_attributes(&mut self, interface: &mut Interface, family_v4: bool, family_v6: bool) -> Result<(), Error> {
loop {
match self.peek()? {
match self.peek()? {
Token::Address => self.parse_iface_address(interface)?,
Token::Gateway => self.parse_iface_gateway(interface)?,
+ Token::MTU => {
+ let mtu = self.parse_iface_mtu()?;
+ if family_v4 { interface.mtu_v4 = Some(mtu); }
+ if family_v6 { interface.mtu_v6 = Some(mtu); }
+ }
Token::Netmask => bail!("netmask is deprecated and no longer supported"),
_ => {
self.parse_iface_addon_attribute(interface)?;
interface.set_method_v6(config_method)?;
}
- if has_attributes { self.parse_iface_attributes(&mut interface)?; }
+ if has_attributes { self.parse_iface_attributes(&mut interface, address_family_v4, address_family_v6)?; }
} else {
let mut interface = Interface::new(iface.clone());
if address_family_v4 {
interface.set_method_v6(config_method)?;
}
- if has_attributes { self.parse_iface_attributes(&mut interface)?; }
+ if has_attributes { self.parse_iface_attributes(&mut interface, address_family_v4, address_family_v6)?; }
config.interfaces.insert(interface.name.clone(), interface);