igmp: import initial IGMPv2 implementation

This is a work-in-progress implementation of the IGMPv2 protocol.

Signed-off-by: fliqqs <[email protected]>

Author: fliqqs

Cargo.lock

@@ -33,6 +33,7 @@ yang3.workspace = true
 holo-interface = { path = "../holo-interface", optional = true  }
 holo-bfd = { path = "../holo-bfd", optional = true }
 holo-bgp = { path = "../holo-bgp", optional = true }
+holo-igmp = { path = "../holo-igmp", optional = true }
 holo-isis = { path = "../holo-isis", optional = true }
 holo-keychain = { path = "../holo-keychain", optional = true }
 holo-ldp = { path = "../holo-ldp", optional = true }
@@ -71,6 +72,7 @@ base = [
 protocols = [
   "bfd",
   "bgp",
+  "igmp",
   "isis",
   "ldp",
   "ospf",
@@ -88,6 +90,7 @@ system = ["dep:holo-system"]
 # Protocols
 bfd = ["dep:holo-bfd", "holo-routing/bfd"]
 bgp = ["dep:holo-bgp", "holo-routing/bgp"]
+igmp = ["dep:holo-igmp", "holo-routing/igmp"]
 isis = ["dep:holo-isis", "holo-routing/isis"]
 ldp = ["dep:holo-ldp", "holo-routing/ldp"]
 ospf = ["dep:holo-ospf", "holo-routing/ospf"]

holo-daemon/Cargo.toml

@@ -6,20 +6,43 @@ license.workspace = true
 edition.workspace = true
 
 [dependencies]
-internet-checksum.workspace = true
-holo-utils = { path = "../holo-utils" }
-holo-protocol = { path = "../holo-protocol" }
-serde.workspace = true
-serde_json.workspace = true
+async-trait.workspace = true
+bitflags.workspace = true
 bytes.workspace = true
+chrono.workspace = true
+derive-new.workspace = true
+enum-as-inner.workspace = true
+generational-arena.workspace = true
+internet-checksum.workspace = true
+ipnetwork.workspace = true
+itertools.workspace = true
+libc.workspace = true
 num-derive.workspace = true
 num-traits.workspace = true
+rand.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+serde_with.workspace = true
+tokio.workspace = true
+tracing.workspace = true
+yang3.workspace = true
+
+holo-northbound = { path = "../holo-northbound" }
+holo-protocol = { path = "../holo-protocol" }
+holo-utils = { path = "../holo-utils" }
+holo-yang = { path = "../holo-yang" }
 
 [dev-dependencies]
 const-addrs.workspace = true
-criterion.workspace = true
-maplit.workspace = true
 yang3 = { workspace = true, features = ["bundled"] }
 
+holo-igmp = { path = ".", features = ["testing"] }
 holo-protocol = { path = "../holo-protocol", features = ["testing"] }
-holo-utils = { path = "../holo-utils", features = ["testing"] }
+holo-utils = { path = "../holo-utils", features = ["testing"] }
+
+[lints]
+workspace = true
+
+[features]
+default = []
+testing = []

holo-igmp/Cargo.toml

@@ -0,0 +1,19 @@
+Copyright (c) 2023 The Holo Core Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

holo-igmp/LICENSE

@@ -0,0 +1,43 @@
+//
+// Copyright (c) The Holo Core Contributors
+//
+// SPDX-License-Identifier: MIT
+//
+
+use holo_utils::ibus::IbusMsg;
+use tracing::{debug, debug_span};
+
+// IGMP debug messages.
+#[derive(Debug)]
+pub enum Debug<'a> {
+    IbusRx(&'a IbusMsg),
+}
+
+// ===== impl Debug =====
+
+impl Debug<'_> {
+    // Log debug message using the tracing API.
+    pub(crate) fn log(&self) {
+        match self {
+            Debug::IbusRx(msg) => {
+                // Parent span(s): igmp-instance
+                debug_span!("internal-bus").in_scope(|| {
+                    debug_span!("input").in_scope(|| {
+                        let data = serde_json::to_string(&msg).unwrap();
+                        debug!(%data, "{}", self);
+                    })
+                })
+            }
+        }
+    }
+}
+
+impl std::fmt::Display for Debug<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Debug::IbusRx(..) => {
+                write!(f, "message")
+            }
+        }
+    }
+}

holo-igmp/src/debug.rs

@@ -0,0 +1,100 @@
+//
+// Copyright (c) The Holo Core Contributors
+//
+// SPDX-License-Identifier: MIT
+//
+
+use tracing::warn;
+
+// IGMP errors.
+#[derive(Debug)]
+pub enum Error {
+    // I/O errors
+    IoError(IoError),
+}
+
+// IGMP I/O errors.
+#[derive(Debug)]
+pub enum IoError {
+    SocketError(std::io::Error),
+    RecvError(std::io::Error),
+    SendError(std::io::Error),
+}
+
+// ===== impl Error =====
+
+impl Error {
+    pub(crate) fn log(&self) {
+        match self {
+            Error::IoError(error) => {
+                error.log();
+            }
+        }
+    }
+}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::IoError(error) => error.fmt(f),
+        }
+    }
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Error::IoError(error) => Some(error),
+            //_ => None,
+        }
+    }
+}
+
+impl From<IoError> for Error {
+    fn from(error: IoError) -> Error {
+        Error::IoError(error)
+    }
+}
+
+// ===== impl IoError =====
+
+impl IoError {
+    pub(crate) fn log(&self) {
+        match self {
+            IoError::SocketError(error) => {
+                warn!(error = %with_source(error), "{}", self);
+            }
+            IoError::RecvError(error) | IoError::SendError(error) => {
+                warn!(error = %with_source(error), "{}", self);
+            }
+        }
+    }
+}
+
+impl std::fmt::Display for IoError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            IoError::SocketError(..) => {
+                write!(f, "failed to create raw IP socket")
+            }
+            IoError::RecvError(..) => {
+                write!(f, "failed to receive IP packet")
+            }
+            IoError::SendError(..) => {
+                write!(f, "failed to send IP packet")
+            }
+        }
+    }
+}
+
+impl std::error::Error for IoError {}
+
+// ===== global functions =====
+
+fn with_source<E: std::error::Error>(error: E) -> String {
+    if let Some(source) = error.source() {
+        format!("{} ({})", error, with_source(source))
+    } else {
+        error.to_string()
+    }
+}

holo-igmp/src/error.rs

@@ -0,0 +1,20 @@
+//
+// Copyright (c) The Holo Core Contributors
+//
+// SPDX-License-Identifier: MIT
+//
+
+use crate::error::Error;
+use crate::instance::Instance;
+use crate::packet::{DecodeResult, Packet};
+
+// ===== TCP connection request =====
+
+pub(crate) fn process_packet(
+    _instance: &mut Instance,
+    _packet: DecodeResult<Packet>,
+) -> Result<(), Error> {
+    // TODO
+
+    Ok(())
+}

holo-igmp/src/events.rs

@@ -0,0 +1,8 @@
+//
+// Copyright (c) The Holo Core Contributors
+//
+// SPDX-License-Identifier: MIT
+//
+
+pub mod rx;
+pub mod tx;

holo-igmp/src/ibus/mod.rs

@@ -0,0 +1,5 @@
+//
+// Copyright (c) The Holo Core Contributors
+//
+// SPDX-License-Identifier: MIT
+//

holo-igmp/src/ibus/rx.rs

@@ -0,0 +1,5 @@
+//
+// Copyright (c) The Holo Core Contributors
+//
+// SPDX-License-Identifier: MIT
+//