rename crates

2 files changed, 114 insertions, 0 deletions

diff --git a/p2p/src/utils/mod.rs b/p2p/src/utils/mod.rs
new file mode 100644
index 0000000..e8ff9d0
--- /dev/null
+++ b/p2p/src/utils/mod.rs
@@ -0,0 +1,21 @@
+mod version;
+
+pub use version::{version_match, Version, VersionInt};
+
+use std::net::IpAddr;
+
+use karyons_net::Addr;
+
+/// Check if two addresses belong to the same subnet.
+pub fn subnet_match(addr: &Addr, other_addr: &Addr) -> bool {
+    match (addr, other_addr) {
+        (Addr::Ip(IpAddr::V4(ip)), Addr::Ip(IpAddr::V4(other_ip))) => {
+            // XXX Consider moving this to a different location
+            if other_ip.is_loopback() && ip.is_loopback() {
+                return false;
+            }
+            ip.octets()[0..3] == other_ip.octets()[0..3]
+        }
+        _ => false,
+    }
+}
diff --git a/p2p/src/utils/version.rs b/p2p/src/utils/version.rs
new file mode 100644
index 0000000..4986495
--- /dev/null
+++ b/p2p/src/utils/version.rs
@@ -0,0 +1,93 @@
+use std::str::FromStr;
+
+use bincode::{Decode, Encode};
+use semver::VersionReq;
+
+use crate::{Error, Result};
+
+/// Represents the network version and protocol version used in Karyons p2p.
+///
+/// # Example
+///
+/// ```
+/// use karyons_p2p::Version;
+///
+/// let version: Version = "0.2.0, >0.1.0".parse().unwrap();
+///
+/// let version: Version = "0.2.0".parse().unwrap();
+///
+/// ```
+#[derive(Debug, Clone)]
+pub struct Version {
+    pub v: VersionInt,
+    pub req: VersionReq,
+}
+
+impl Version {
+    /// Creates a new Version
+    pub fn new(v: VersionInt, req: VersionReq) -> Self {
+        Self { v, req }
+    }
+}
+
+#[derive(Debug, Decode, Encode, Clone)]
+pub struct VersionInt {
+    major: u64,
+    minor: u64,
+    patch: u64,
+}
+
+impl FromStr for Version {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self> {
+        let v: Vec<&str> = s.split(", ").collect();
+        if v.is_empty() || v.len() > 2 {
+            return Err(Error::ParseError(format!("Invalid version{s}")));
+        }
+
+        let version: VersionInt = v[0].parse()?;
+        let req: VersionReq = if v.len() > 1 { v[1] } else { v[0] }.parse()?;
+
+        Ok(Self { v: version, req })
+    }
+}
+
+impl FromStr for VersionInt {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self> {
+        let v: Vec<&str> = s.split('.').collect();
+        if v.len() < 2 || v.len() > 3 {
+            return Err(Error::ParseError(format!("Invalid version{s}")));
+        }
+
+        let major = v[0].parse::<u64>()?;
+        let minor = v[1].parse::<u64>()?;
+        let patch = v.get(2).unwrap_or(&"0").parse::<u64>()?;
+
+        Ok(Self {
+            major,
+            minor,
+            patch,
+        })
+    }
+}
+
+impl std::fmt::Display for VersionInt {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}.{}.{}", self.major, self.minor, self.patch)
+    }
+}
+
+impl From<VersionInt> for semver::Version {
+    fn from(v: VersionInt) -> Self {
+        semver::Version::new(v.major, v.minor, v.patch)
+    }
+}
+
+/// Check if a version satisfies a version request.
+pub fn version_match(version_req: &VersionReq, version: &VersionInt) -> bool {
+    let version: semver::Version = version.clone().into();
+    version_req.matches(&version)
+}