move proxies to sub-processes

src/config/name.rs

@@ -3,6 +3,8 @@ use serde::{Deserialize, Deserializer};
 use std::ffi::OsString;
 use std::fmt::{Display, Formatter};
 use std::path::Path;
+use std::str::FromStr;
+use thiserror::Error;
 
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct NamespaceName(String);
@@ -38,6 +40,12 @@ impl AsRef<Path> for NamespaceName {
     }
 }
 
+impl PartialEq<&str> for NamespaceName {
+    fn eq(&self, other: &&str) -> bool {
+        self.0 == *other
+    }
+}
+
 impl From<NamespaceName> for String {
     fn from(value: NamespaceName) -> Self {
         value.0
@@ -83,6 +91,23 @@ impl<'de> Deserialize<'de> for NamespaceName {
     }
 }
 
+impl FromStr for NamespaceName {
+    type Err = InvalidNamespaceNameError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if !validate_name(s) {
+            return Err(InvalidNamespaceNameError { name: s.into() });
+        }
+        Ok(NamespaceName(s.into()))
+    }
+}
+
+#[derive(Debug, Error)]
+#[error("invalid name for namespace: '{name}'")]
+pub struct InvalidNamespaceNameError {
+    name: String,
+}
+
 /// Check if a name follows the portable filename character set
 fn validate_name(name: &str) -> bool {
     if name.is_empty() {

src/config/source.rs

@@ -4,6 +4,7 @@ use std::fmt::{Display, Formatter};
 use std::net::{IpAddr, SocketAddr};
 use std::path::PathBuf;
 use std::str::FromStr;
+use thiserror::Error;
 
 #[derive(Debug, PartialEq, Clone, Hash, Eq)]
 pub enum ForwardSource {
@@ -77,17 +78,8 @@ impl<'de> Deserialize<'de> for ForwardSource {
             where
                 E: Error,
             {
-                if v.starts_with('/') {
-                    Ok(ForwardSource::Unix(v.into()))
-                } else {
-                    if let Ok(port) = u16::from_str(v) {
-                        return self.visit_u16(port);
-                    }
-                    let addr = v
-                        .parse()
-                        .map_err(|_| E::invalid_value(Unexpected::Str(v), &self))?;
-                    Ok(ForwardSource::Ip(addr))
-                }
+                v.parse()
+                    .map_err(|_| E::invalid_value(Unexpected::Str(v), &self))
             }
         }
 
@@ -95,6 +87,31 @@ impl<'de> Deserialize<'de> for ForwardSource {
     }
 }
 
+impl FromStr for ForwardSource {
+    type Err = InvalidForwardSource;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s.starts_with('/') {
+            Ok(ForwardSource::Unix(s.into()))
+        } else {
+            if let Ok(port) = u16::from_str(s) {
+                let ip = IpAddr::from([0, 0, 0, 0]);
+                return Ok(ForwardSource::Ip(SocketAddr::from((ip, port))));
+            }
+            let addr = s
+                .parse()
+                .map_err(|_| InvalidForwardSource { forward: s.into() })?;
+            Ok(ForwardSource::Ip(addr))
+        }
+    }
+}
+
+#[derive(Debug, Error)]
+#[error("forward source '{forward}' is not a valid unix path or socket address")]
+pub struct InvalidForwardSource {
+    forward: String,
+}
+
 #[test]
 fn test_de() {
     use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};

src/config/target.rs

@@ -3,6 +3,7 @@ use serde::{Deserialize, Deserializer};
 use std::fmt::{Display, Formatter};
 use std::net::{IpAddr, SocketAddr};
 use std::str::FromStr;
+use thiserror::Error;
 
 #[derive(Debug, PartialEq, Clone, Hash, Eq)]
 pub struct ForwardTarget {
@@ -70,13 +71,8 @@ impl<'de> Deserialize<'de> for ForwardTarget {
             where
                 E: Error,
             {
-                if let Ok(port) = u16::from_str(v) {
-                    return self.visit_u16(port);
-                }
-                let addr = v
-                    .parse()
-                    .map_err(|_| E::invalid_value(Unexpected::Str(v), &self))?;
-                Ok(ForwardTarget { addr })
+                v.parse()
+                    .map_err(|_| E::invalid_value(Unexpected::Str(v), &self))
             }
         }
 
@@ -84,6 +80,29 @@ impl<'de> Deserialize<'de> for ForwardTarget {
     }
 }
 
+impl FromStr for ForwardTarget {
+    type Err = InvalidForwardTarget;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if let Ok(port) = u16::from_str(s) {
+            let ip = IpAddr::from([127, 0, 0, 1]);
+            return Ok(ForwardTarget {
+                addr: SocketAddr::from((ip, port)),
+            });
+        }
+        let addr = s
+            .parse()
+            .map_err(|_| InvalidForwardTarget { forward: s.into() })?;
+        Ok(ForwardTarget { addr })
+    }
+}
+
+#[derive(Debug, Error)]
+#[error("forward source '{forward}' is not a valid socket address")]
+pub struct InvalidForwardTarget {
+    forward: String,
+}
+
 #[test]
 fn test_de() {
     use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};