feat: Add mesh networking functionality

This commit introduces mesh networking capabilities to Lanet, enabling decentralized communication between devices on a local network.

Key features include:

- **Node discovery:** Nodes automatically discover and connect to each other.
- **Multi-hop routing:** Messages can be routed through intermediate nodes to reach their destination.
- **Self-healing:** The network adapts to changing conditions and node failures.
- **End-to-end encryption:** Messages remain encrypted throughout the routing process.
- **Digital signatures:** Message integrity is ensured through digital signatures.

This functionality is accessible through both the command-line interface and the Ruby API.

This enhancement is ideal for scenarios where:

- Devices may not have direct connectivity.
- No central server or infrastructure is available.
- High resilience and redundancy are required.
- Peer-to-peer communication is desired.

The mesh networking feature significantly expands Lanet's capabilities, making it a more versatile and robust tool for local network communication.

Author: davidesantangelo

CHANGELOG.md

@@ -5,6 +5,15 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0] - 2023-11-15
+
+### Added
+- Mesh networking functionality for decentralized communication
+- Auto-discovery of mesh nodes
+- Message routing through intermediate nodes
+- CLI commands for mesh network operations: `mesh start`, `mesh send`, `mesh info`
+- Ruby API methods for creating and managing mesh networks
+
 ## [0.3.0] - 2025-03-08
 
 ### Added

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lanet (0.3.0)
+    lanet (0.4.0)
       thor (~> 1.2)
 
 GEM

README.md

@@ -19,6 +19,7 @@ A lightweight, powerful LAN communication tool that enables secure message excha
 - **Configurable:**  Adjust port settings, encryption keys, and network scan ranges.
 - **Digital Signatures**: Ensure message authenticity and integrity
 - **File Transfers**: Securely send encrypted files over the LAN with progress tracking and integrity verification
+- **Mesh Networking**: Create resilient mesh networks for decentralized communication, enabling messages to be routed through multiple hops without central infrastructure
 
 ## Security Features
 
@@ -301,6 +302,38 @@ Receive encrypted files with signature verification:
 lanet receive-file --output ./downloads --encryption-key "my_secret_key" --public-key-file lanet_public.key
 ```
 
+#### Mesh Networking
+
+Create a decentralized mesh network where devices can communicate even without direct connectivity:
+
+```bash
+# Start a mesh network node
+lanet mesh start
+
+# Start a mesh network node with custom settings
+lanet mesh start --port 5050 --max-hops 15
+```
+
+Send messages through the mesh network:
+
+```bash
+# Send a message through the mesh network to a specific node ID
+lanet mesh send --target a1b2c3d4-5678-90ef-ghij --message "Hello Mesh Network"
+
+# Send an encrypted message through the mesh network
+lanet mesh send --target a1b2c3d4-5678-90ef-ghij --message "Secret mesh message" --key "secret-key"
+
+# Send a signed message through the mesh network
+lanet mesh send --target a1b2c3d4-5678-90ef-ghij --message "Authenticated mesh message" --private-key-file lanet_private.key
+```
+
+View information about your mesh network:
+
+```bash
+# Display information about mesh network connections
+lanet mesh info
+```
+
 ### Ruby API
 
 You can also use Lanet programmatically in your Ruby applications:
@@ -393,8 +426,42 @@ file_transfer.receive_file('./downloads', 'encryption_key') do |event, data|
     puts "File saved to: #{data[:file_path]}"
   end
 end
+
+# Mesh Networking
+mesh = Lanet.mesh_network
+mesh.start  # Start the mesh node and discovery service
+
+# Send a message through the mesh network
+mesh.send_message(target_node_id, "Hello through the mesh!", "optional-encryption-key")
+
+# Get info about mesh connections
+puts "Node ID: #{mesh.node_id}"
+puts "Connected to #{mesh.connections.size} nodes"
+mesh.connections.each do |node_id, info|
+  puts "  #{node_id} (#{info[:ip]})"
+end
+
+# Properly stop the mesh node
+mesh.stop
 ```
 
+## Mesh Network
+
+The mesh networking feature provides decentralized communication capabilities:
+
+- **Auto-discovery**: Nodes automatically find each other on the network
+- **Multi-hop routing**: Messages can be routed through intermediate nodes
+- **Self-healing**: Adapts to changing network conditions and lost connections
+- **Store and forward**: Messages persist until they can be delivered
+- **End-to-end security**: Messages remain encrypted across multiple hops
+- **Verification**: Digital signatures ensure message integrity through the mesh
+
+Ideal for:
+- IoT networks where devices may not have direct connectivity
+- Ad-hoc networks without fixed infrastructure
+- Networks requiring high resilience and redundancy
+- Applications needing peer-to-peer communication
+
 ## Configuration
 
 Lanet can be configured with several options:

index.html

@@ -227,6 +227,22 @@ <h3>File Transfer <span class="badge badge-new">New in v0.3.0</span></h3>
             <p>Securely transfer files between devices with encryption, digital signatures, and integrity verification.</p>
         </div>
 
+        <div class="feature">
+            <h3>Mesh Networking <span class="badge badge-new">New in v0.4.0</span></h3>
+            <p>Create resilient, decentralized mesh networks that enable communication between devices even without direct connectivity.</p>
+            
+            <div class="security-feature">
+                <h4>Benefits of Mesh Networking:</h4>
+                <ul>
+                    <li><strong>Decentralization</strong>: No central server or infrastructure needed</li>
+                    <li><strong>Resilience</strong>: Messages can route around failed nodes or connections</li>
+                    <li><strong>Extended Range</strong>: Devices can communicate beyond direct connection range</li>
+                    <li><strong>Scalability</strong>: Network grows stronger with more participating nodes</li>
+                    <li><strong>Self-healing</strong>: Network automatically adapts to changing conditions</li>
+                </ul>
+            </div>
+        </div>
+
         <h2>Command Line Interface</h2>
 
         <div class="note">
@@ -381,6 +397,46 @@ <h4>Receive Files</h4>
             </div>
         </div>
 
+        <div class="cli-section">
+            <h3>Mesh Network Commands <span class="badge badge-new">New in v0.4.0</span></h3>
+
+            <h4>Start a Mesh Network Node</h4>
+            <div class="cli-example">
+                lanet mesh start
+            </div>
+
+            <h4>Start with Custom Settings</h4>
+            <div class="cli-example">
+                lanet mesh start --port 5050 --max-hops 15
+            </div>
+
+            <h4>Send a Message Through the Mesh</h4>
+            <div class="cli-example">
+                lanet mesh send --target a1b2c3d4-5678-90ef-ghij --message "Hello Mesh"
+            </div>
+
+            <h4>Send an Encrypted Mesh Message</h4>
+            <div class="cli-example">
+                lanet mesh send --target a1b2c3d4-5678-90ef-ghij --message "Secret mesh message" --key "secret-key"
+            </div>
+
+            <h4>View Mesh Network Information</h4>
+            <div class="cli-example">
+                lanet mesh info
+            </div>
+
+            <p>Example output when viewing mesh info:</p>
+            <div class="output-example">
+Mesh Node ID: 4f9a8b7c-6d5e-4f3e-2d1c-0b9a8b7c6d5e
+
+Connected nodes:
+  b1c2d3e4-f5g6-7h8i-9j0k-l1m2n3o4p5q6 (192.168.1.5, last seen 12s ago)
+  c5d4e3f2-g1h0-i9j8-k7l6-m5n4o3p2q1r0 (192.168.1.10, last seen 5s ago)
+
+Message cache: 24 messages
+            </div>
+        </div>
+
         <h2>Ruby Code Examples</h2>
 
         <div class="tab-container">
@@ -389,6 +445,7 @@ <h2>Ruby Code Examples</h2>
                 <button class="tab-button" onclick="openTab(event, 'tab-signatures')">Digital Signatures</button>
                 <button class="tab-button" onclick="openTab(event, 'tab-advanced')">Advanced Usage</button>
                 <button class="tab-button" onclick="openTab(event, 'tab-filetransfer')">File Transfer</button>
+                <button class="tab-button" onclick="openTab(event, 'tab-mesh')">Mesh Network</button>
             </div>
 
             <div id="tab-basic" class="tab-content active">
@@ -522,6 +579,53 @@ <h2>Ruby Code Examples</h2>
   end
 end</code></pre>
             </div>
+
+            <div id="tab-mesh" class="tab-content">
+                <pre><code>require 'lanet'
+
+# Create and start a mesh network node
+mesh = Lanet.mesh_network
+mesh.start
+
+puts "Mesh node started with ID: #{mesh.node_id}"
+
+# Send a plain message through the mesh
+begin
+  message_id = mesh.send_message(
+    "target-node-id-here",
+    "Hello through the mesh network!"
+  )
+  puts "Message sent with ID: #{message_id}"
+rescue Lanet::Mesh::Error => e
+  puts "Message sending failed: #{e.message}"
+end
+
+# Send an encrypted and signed message
+encryption_key = "mesh-encryption-key"
+key_pair = Lanet::Signer.generate_key_pair
+private_key = key_pair[:private_key]
+
+begin
+  message_id = mesh.send_message(
+    "target-node-id-here",
+    "Secure mesh message",
+    encryption_key,
+    private_key
+  )
+  puts "Secure message sent with ID: #{message_id}"
+rescue Lanet::Mesh::Error => e
+  puts "Secure message sending failed: #{e.message}"
+end
+
+# Examine mesh connections
+puts "Connected to #{mesh.connections.size} nodes:"
+mesh.connections.each do |node_id, info|
+  puts "  • #{node_id} (#{info[:ip]}, last seen #{Time.now.to_i - info[:last_seen]}s ago)"
+end
+
+# Always stop the mesh node when done
+mesh.stop</code></pre>
+            </div>
         </div>
 
         <h2>Installation</h2>
@@ -536,7 +640,7 @@ <h2>Documentation</h2>
         <p>For complete documentation, please visit the <a href="https://github.com/davidesantangelo/lanet">GitHub repository</a>.</p>
 
         <footer style="margin-top: 40px; text-align: center; color: #7f8c8d;">
-            <p>Lanet v0.3.0 - Secure Network Communications Library</p>
+            <p>Lanet v0.4.0 - Secure Network Communications Library</p>
         </footer>
     </div>
 

lib/lanet.rb

@@ -8,6 +8,7 @@
 require "lanet/cli"
 require "lanet/ping"
 require "lanet/file_transfer"
+require "lanet/mesh"
 
 module Lanet
   class Error < StandardError; end
@@ -50,5 +51,10 @@ def pinger(timeout: 1, count: 3)
     def file_transfer(port = 5001)
       FileTransfer.new(port)
     end
+
+    # Create a new mesh network instance
+    def mesh_network(port = 5050, max_hops = 10)
+      Mesh.new(port, max_hops)
+    end
   end
 end

lib/lanet/cli.rb

@@ -278,6 +278,94 @@ def version
       puts "Lanet version #{Lanet::VERSION}"
     end
 
+    desc "mesh start", "Start a mesh network node"
+    option :port, type: :numeric, default: 5050, desc: "Port for mesh communication"
+    option :max_hops, type: :numeric, default: 10, desc: "Maximum number of hops for message routing"
+    def mesh_start
+      mesh = Lanet::Mesh.new(options[:port], options[:max_hops])
+
+      puts "Starting mesh network node with ID: #{mesh.node_id}"
+      puts "Listening on port: #{options[:port]}"
+      puts "Press Ctrl+C to stop"
+
+      mesh.start
+
+      # Keep the process running
+      begin
+        loop do
+          sleep 1
+        end
+      rescue Interrupt
+        puts "\nStopping mesh network node..."
+        mesh.stop
+      end
+    end
+
+    desc "mesh send", "Send a message through the mesh network"
+    option :target, type: :string, required: true, desc: "Target node ID"
+    option :message, type: :string, required: true, desc: "Message to send"
+    option :key, type: :string, desc: "Encryption key (optional)"
+    option :private_key_file, type: :string, desc: "Path to private key file for signing (optional)"
+    option :port, type: :numeric, default: 5050, desc: "Port for mesh communication"
+    def mesh_send
+      mesh = Lanet::Mesh.new(options[:port])
+
+      private_key = nil
+      if options[:private_key_file]
+        begin
+          private_key = File.read(options[:private_key_file])
+          puts "Message will be digitally signed"
+        rescue StandardError => e
+          puts "Error reading private key file: #{e.message}"
+          return
+        end
+      end
+
+      # Initialize the mesh network
+      mesh.start
+
+      begin
+        message_id = mesh.send_message(
+          options[:target],
+          options[:message],
+          options[:key],
+          private_key
+        )
+
+        puts "Message sent through mesh network"
+        puts "Message ID: #{message_id}"
+      rescue Lanet::Mesh::Error => e
+        puts "Error sending mesh message: #{e.message}"
+      ensure
+        mesh.stop
+      end
+    end
+
+    desc "mesh info", "Display information about the mesh network"
+    option :port, type: :numeric, default: 5050, desc: "Port for mesh communication"
+    def mesh_info
+      mesh = Lanet::Mesh.new(options[:port])
+
+      # Load state if available
+      mesh.start
+
+      puts "Mesh Node ID: #{mesh.node_id}"
+      puts "\nConnected nodes:"
+
+      if mesh.connections.empty?
+        puts "  No direct connections"
+      else
+        mesh.connections.each do |node_id, info|
+          last_seen = Time.now.to_i - info[:last_seen]
+          puts "  #{node_id} (#{info[:ip]}, last seen #{last_seen}s ago)"
+        end
+      end
+
+      puts "\nMessage cache: #{mesh.message_cache.size} messages"
+
+      mesh.stop
+    end
+
     private
 
     def display_ping_details(host, result)

lib/lanet/file_transfer.rb

@@ -122,7 +122,10 @@ def send_file(target_ip, file_path, encryption_key = nil, private_key = nil, pro
     end
 
     ### Receive File Method
-    def receive_file(output_dir, encryption_key = nil, public_key = nil, progress_callback = nil)
+    def receive_file(output_dir, encryption_key = nil, public_key = nil, progress_callback = nil, &block)
+      # Use the block parameter if provided and progress_callback is nil
+      progress_callback = block if block_given? && progress_callback.nil?
+
       FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
       receiver = UDPSocket.new
       receiver.bind("0.0.0.0", @port)
@@ -131,6 +134,10 @@ def receive_file(output_dir, encryption_key = nil, public_key = nil, progress_ca
       begin
         loop do
           data, addr = receiver.recvfrom(65_536) # Large buffer for chunks
+
+          # Skip if we received nil data or address
+          next if addr.nil? || data.nil?
+
           sender_ip = addr[3]
           result = Lanet::Encryptor.process_message(data, encryption_key, public_key)
           next unless result[:content]&.length&.> 2