Can define network filters

virtweb_backend/src/libvirt_rest_structures/vm.rs

@@ -24,11 +24,24 @@ pub enum VMArchitecture {
     X86_64,
 }
 
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct NWFilterParam {
+    name: String,
+    value: String,
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct NWFilterRef {
+    name: String,
+    parameters: Vec<NWFilterParam>,
+}
+
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct Network {
-    mac: String,
     #[serde(flatten)]
     r#type: NetworkType,
+    mac: String,
+    nwfilterref: Option<NWFilterRef>,
 }
 
 #[derive(serde::Serialize, serde::Deserialize)]
@@ -157,6 +170,67 @@ impl VMInfo {
             false => (None, None),
         };
 
+        // Process network card
+        let mut networks = vec![];
+        for n in &self.networks {
+            let mac = NetMacAddress {
+                address: n.mac.to_string(),
+            };
+
+            let model = Some(NetIntModelXML {
+                r#type: "virtio".to_string(),
+            });
+
+            let filterref = if let Some(n) = &n.nwfilterref {
+                if !regex!("^[a-zA-Z0-9\\_\\-]+$").is_match(&n.name) {
+                    log::error!("Filter ref name {} is invalid", n.name);
+                    return Err(StructureExtraction("Network filter ref name is invalid!").into());
+                }
+
+                for p in &n.parameters {
+                    if !regex!("^[a-zA-Z0-9_-]+$").is_match(&p.name) {
+                        return Err(StructureExtraction(
+                            "Network filter ref parameter name is invalid!",
+                        )
+                        .into());
+                    }
+                }
+
+                Some(NetIntfilterRefXML {
+                    filter: n.name.to_string(),
+                    parameters: n
+                        .parameters
+                        .iter()
+                        .map(|f| NetIntFilterParameterXML {
+                            name: f.name.to_string(),
+                            value: f.value.to_string(),
+                        })
+                        .collect(),
+                })
+            } else {
+                None
+            };
+
+            networks.push(match &n.r#type {
+                NetworkType::UserspaceSLIRPStack => DomainNetInterfaceXML {
+                    mac,
+                    r#type: "user".to_string(),
+                    source: None,
+                    model,
+                    filterref,
+                },
+                NetworkType::DefinedNetwork { network } => DomainNetInterfaceXML {
+                    mac,
+                    r#type: "network".to_string(),
+                    source: Some(NetIntSourceXML {
+                        network: network.to_string(),
+                    }),
+                    model,
+                    filterref,
+                },
+            })
+        }
+
         // Check disks name for duplicates
         for disk in &self.disks {
             if self.disks.iter().filter(|d| d.name == disk.name).count() > 1 {
@@ -164,7 +238,8 @@ impl VMInfo {
             }
         }
 
-        // Apply disks configuration
+        // Apply disks configuration. Starting from now, the function should ideally never fail due to
+        // bad user input
         for disk in &self.disks {
             disk.check_config()?;
             disk.apply_config(uuid)?;
@@ -199,34 +274,6 @@ impl VMInfo {
             })
         }
 
-        let mut networks = vec![];
-        for n in &self.networks {
-            networks.push(match &n.r#type {
-                NetworkType::UserspaceSLIRPStack => DomainNetInterfaceXML {
-                    mac: NetMacAddress {
-                        address: n.mac.to_string(),
-                    },
-                    r#type: "user".to_string(),
-                    source: None,
-                    model: Some(NetIntModelXML {
-                        r#type: "virtio".to_string(),
-                    }),
-                },
-                NetworkType::DefinedNetwork { network } => DomainNetInterfaceXML {
-                    mac: NetMacAddress {
-                        address: n.mac.to_string(),
-                    },
-                    r#type: "network".to_string(),
-                    source: Some(NetIntSourceXML {
-                        network: network.to_string(),
-                    }),
-                    model: Some(NetIntModelXML {
-                        r#type: "virtio".to_string(),
-                    }),
-                },
-            })
-        }
-
         Ok(DomainXML {
             r#type: "kvm".to_string(),
             name: self.name.to_string(),
@@ -376,6 +423,17 @@ impl VMInfo {
                                 )));
                             }
                         },
+                        nwfilterref: d.filterref.as_ref().map(|f| NWFilterRef {
+                            name: f.filter.to_string(),
+                            parameters: f
+                                .parameters
+                                .iter()
+                                .map(|p| NWFilterParam {
+                                    name: p.name.to_string(),
+                                    value: p.value.to_string(),
+                                })
+                                .collect(),
+                        }),
                     })
                 })
                 .collect::<Result<Vec<_>, _>>()?,