lanet 0.2.1 → 0.4.0

data/lib/lanet/cli.rb

@@ -178,11 +178,194 @@ module Lanet
       puts "Share your public key with others who need to verify your messages."
     end
 
+    desc "send-file", "Send a file to a specific target"
+    option :target, type: :string, required: true, desc: "Target IP address"
+    option :file, type: :string, required: true, desc: "File 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: 5001, desc: "Port number"
+    def send_file
+      unless File.exist?(options[:file]) && File.file?(options[:file])
+        puts "Error: File not found or is not a regular file: #{options[:file]}"
+        return
+      end
+
+      private_key = nil
+      if options[:private_key_file]
+        begin
+          private_key = File.read(options[:private_key_file])
+          puts "File will be digitally signed"
+        rescue StandardError => e
+          puts "Error reading private key file: #{e.message}"
+          return
+        end
+      end
+
+      file_transfer = Lanet::FileTransfer.new(options[:port])
+
+      puts "Sending file #{File.basename(options[:file])} to #{options[:target]}..."
+      puts "File size: #{File.size(options[:file])} bytes"
+
+      begin
+        file_transfer.send_file(
+          options[:target],
+          options[:file],
+          options[:key],
+          private_key
+        ) do |progress, bytes, total|
+          # Update progress bar
+          print "\rProgress: #{progress}% (#{bytes}/#{total} bytes)"
+        end
+
+        puts "\nFile sent successfully!"
+      rescue Lanet::FileTransfer::Error => e
+        puts "\nError: #{e.message}"
+      end
+    end
+
+    desc "receive-file", "Listen for incoming files"
+    option :output, type: :string, default: "./received", desc: "Output directory for received files"
+    option :encryption_key, type: :string, desc: "Encryption key (optional)"
+    option :public_key_file, type: :string, desc: "Path to public key file for verification (optional)"
+    option :port, type: :numeric, default: 5001, desc: "Port number"
+    def receive_file
+      public_key = nil
+      if options[:public_key_file]
+        begin
+          public_key = File.read(options[:public_key_file])
+          puts "Digital signature verification enabled"
+        rescue StandardError => e
+          puts "Error reading public key file: #{e.message}"
+          return
+        end
+      end
+
+      output_dir = File.expand_path(options[:output])
+      FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
+
+      puts "Listening for incoming files on port #{options[:port]}..."
+      puts "Files will be saved to #{output_dir}"
+      puts "Press Ctrl+C to stop"
+
+      file_transfer = Lanet::FileTransfer.new(options[:port])
+
+      begin
+        file_transfer.receive_file(
+          output_dir,
+          options[:encryption_key],
+          public_key
+        ) do |event, data|
+          case event
+          when :start
+            puts "\nReceiving file: #{data[:file_name]} from #{data[:sender_ip]}"
+            puts "Size: #{data[:file_size]} bytes"
+            puts "Transfer ID: #{data[:transfer_id]}"
+          when :progress
+            print "\rProgress: #{data[:progress]}% (#{data[:bytes_received]}/#{data[:total_bytes]} bytes)"
+          when :complete
+            puts "\nFile received and saved to: #{data[:file_path]}"
+          when :error
+            puts "\nError during file transfer: #{data[:error]}"
+          end
+        end
+      rescue Interrupt
+        puts "\nFile receiver stopped."
+      end
+    end
+
     desc "version", "Display the version of Lanet"
     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)
@@ -259,19 +442,5 @@ module Lanet
       puts "\nOutput:"
       puts result[:output]
     end
-
-    # Override method_missing to provide helpful error messages for common mistakes
-    def method_missing(method, *args)
-      if method.to_s == "ping" && args.any?
-        invoke "ping", [], { host: args.first, timeout: options[:timeout], count: options[:count],
-                             quiet: options[:quiet], continuous: options[:continuous] }
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(method, include_private = false)
-      method.to_s == "ping" || super
-    end
   end
 end

data/lib/lanet/file_transfer.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "tempfile"
+require "zlib"
+require "securerandom"
+require "base64"
+require "json"
+require "socket"
+require "timeout"
+
+module Lanet
+  class FileTransfer
+    # Constants
+    # Use smaller chunks in tests to avoid "Message too long" errors
+    CHUNK_SIZE = if ENV["LANET_TEST_CHUNK_SIZE"]
+                   ENV["LANET_TEST_CHUNK_SIZE"].to_i
+                 elsif ENV["RACK_ENV"] == "test"
+                   8192 # 8KB in test environment
+                 else
+                   65_536 # 64KB in production
+                 end
+
+    MAX_RETRIES = 3
+    TIMEOUT = ENV["RACK_ENV"] == "test" ? 2 : 10 # Seconds
+
+    # Message types
+    FILE_HEADER = "FH"  # File metadata
+    FILE_CHUNK  = "FC"  # File data chunk
+    FILE_END    = "FE"  # End of transfer
+    FILE_ACK    = "FA"  # Acknowledgment
+    FILE_ERROR  = "FR"  # Error message
+
+    # Custom error class
+    class Error < StandardError; end
+
+    # Attributes for tracking progress
+    attr_reader :progress, :file_size, :transferred_bytes
+
+    ### Initialization
+    def initialize(port = nil)
+      @port = port || 5001 # Default port for file transfers
+      @progress = 0.0
+      @file_size = 0
+      @transferred_bytes = 0
+      @sender = Lanet::Sender.new(@port) # Assumes Lanet::Sender is defined elsewhere
+      @cancellation_requested = false
+    end
+
+    ### Send File Method
+    def send_file(target_ip, file_path, encryption_key = nil, private_key = nil, progress_callback = nil)
+      # Validate file
+      unless File.exist?(file_path) && File.file?(file_path)
+        raise Error, "File not found or is not a regular file: #{file_path}"
+      end
+
+      # Initialize transfer state
+      @file_size = File.size(file_path)
+      @transferred_bytes = 0
+      @progress = 0.0
+      @cancellation_requested = false
+      transfer_id = SecureRandom.uuid
+      chunk_index = 0
+
+      receiver = nil
+
+      begin
+        # Send file header
+        file_name = File.basename(file_path)
+        file_checksum = calculate_file_checksum(file_path)
+        header_data = {
+          id: transfer_id,
+          name: file_name,
+          size: @file_size,
+          checksum: file_checksum,
+          timestamp: Time.now.to_i
+        }.to_json
+        header_message = Lanet::Encryptor.prepare_message("#{FILE_HEADER}#{header_data}", encryption_key, private_key)
+        @sender.send_to(target_ip, header_message)
+
+        # Wait for initial ACK
+        receiver = UDPSocket.new
+        receiver.bind("0.0.0.0", @port)
+        wait_for_ack(receiver, target_ip, transfer_id, encryption_key, "initial")
+
+        # Send file chunks
+        File.open(file_path, "rb") do |file|
+          until file.eof? || @cancellation_requested
+            chunk = file.read(CHUNK_SIZE)
+            chunk_data = {
+              id: transfer_id,
+              index: chunk_index,
+              data: Base64.strict_encode64(chunk)
+            }.to_json
+            chunk_message = Lanet::Encryptor.prepare_message("#{FILE_CHUNK}#{chunk_data}", encryption_key, private_key)
+            @sender.send_to(target_ip, chunk_message)
+
+            chunk_index += 1
+            @transferred_bytes += chunk.bytesize
+            @progress = (@transferred_bytes.to_f / @file_size * 100).round(2)
+            progress_callback&.call(@progress, @transferred_bytes, @file_size)
+
+            sleep(0.01) # Prevent overwhelming the receiver
+          end
+        end
+
+        # Send end marker and wait for final ACK
+        unless @cancellation_requested
+          end_data = { id: transfer_id, total_chunks: chunk_index }.to_json
+          end_message = Lanet::Encryptor.prepare_message("#{FILE_END}#{end_data}", encryption_key, private_key)
+          @sender.send_to(target_ip, end_message)
+          wait_for_ack(receiver, target_ip, transfer_id, encryption_key, "final")
+          true # Transfer successful
+        end
+      rescue StandardError => e
+        send_error(target_ip, transfer_id, e.message, encryption_key, private_key)
+        raise Error, "File transfer failed: #{e.message}"
+      ensure
+        receiver&.close
+      end
+    end
+
+    ### Receive File Method
+    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)
+      active_transfers = {}
+
+      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
+
+          message_type = result[:content][0..1]
+          message_data = result[:content][2..]
+
+          case message_type
+          when FILE_HEADER
+            handle_file_header(sender_ip, message_data, active_transfers, encryption_key, progress_callback)
+          when FILE_CHUNK
+            handle_file_chunk(sender_ip, message_data, active_transfers, progress_callback, encryption_key)
+          when FILE_END
+            handle_file_end(sender_ip, message_data, active_transfers, output_dir, encryption_key, progress_callback)
+          when FILE_ERROR
+            handle_file_error(sender_ip, message_data, active_transfers, progress_callback)
+          end
+        end
+      rescue Interrupt
+        puts "\nFile receiver stopped."
+      ensure
+        cleanup_transfers(active_transfers)
+        receiver.close
+      end
+    end
+
+    ### Cancel Transfer
+    def cancel_transfer
+      @cancellation_requested = true
+    end
+
+    private
+
+    ### Helper Methods
+
+    def calculate_file_checksum(file_path)
+      Digest::SHA256.file(file_path).hexdigest
+    end
+
+    def send_error(target_ip, transfer_id, message, encryption_key, private_key = nil)
+      error_data = { id: transfer_id, message: message, timestamp: Time.now.to_i }.to_json
+      error_message = Lanet::Encryptor.prepare_message("#{FILE_ERROR}#{error_data}", encryption_key, private_key)
+      @sender.send_to(target_ip, error_message)
+    end
+
+    def wait_for_ack(receiver, target_ip, transfer_id, encryption_key, context)
+      Timeout.timeout(TIMEOUT) do
+        data, addr = receiver.recvfrom(1024)
+        sender_ip = addr[3]
+        if sender_ip == target_ip
+          result = Lanet::Encryptor.process_message(data, encryption_key)
+          return if result[:content]&.start_with?(FILE_ACK) && result[:content][2..] == transfer_id
+
+          # Valid ACK received
+
+          raise Error, "Invalid #{context} ACK received: #{result[:content]}"
+
+        end
+      end
+    rescue Timeout::Error
+      raise Error, "Timeout waiting for #{context} transfer acknowledgment"
+    end
+
+    def handle_file_header(sender_ip, message_data, active_transfers, encryption_key, callback)
+      header = JSON.parse(message_data)
+      transfer_id = header["id"]
+      active_transfers[transfer_id] = {
+        sender_ip: sender_ip,
+        file_name: header["name"],
+        file_size: header["size"],
+        expected_checksum: header["checksum"],
+        temp_file: Tempfile.new([File.basename(header["name"], ".*"), File.extname(header["name"])]),
+        chunks_received: 0,
+        timestamp: Time.now
+      }
+      ack_message = Lanet::Encryptor.prepare_message("#{FILE_ACK}#{transfer_id}", encryption_key)
+      @sender.send_to(sender_ip, ack_message)
+      callback&.call(:start, {
+                       transfer_id: transfer_id,
+                       sender_ip: sender_ip,
+                       file_name: header["name"],
+                       file_size: header["size"]
+                     })
+    rescue JSON::ParserError => e
+      send_error(sender_ip, "unknown", "Invalid header format: #{e.message}", encryption_key)
+    end
+
+    def handle_file_chunk(sender_ip, message_data, active_transfers, callback, encryption_key)
+      chunk = JSON.parse(message_data)
+      transfer_id = chunk["id"]
+      transfer = active_transfers[transfer_id]
+      if transfer && transfer[:sender_ip] == sender_ip
+        chunk_data = Base64.strict_decode64(chunk["data"])
+        transfer[:temp_file].write(chunk_data)
+        transfer[:chunks_received] += 1
+        bytes_received = transfer[:temp_file].size
+        progress = (bytes_received.to_f / transfer[:file_size] * 100).round(2)
+        callback&.call(:progress, {
+                         transfer_id: transfer_id,
+                         sender_ip: sender_ip,
+                         file_name: transfer[:file_name],
+                         progress: progress,
+                         bytes_received: bytes_received,
+                         total_bytes: transfer[:file_size]
+                       })
+      end
+    rescue JSON::ParserError => e
+      send_error(sender_ip, "unknown", "Invalid chunk format: #{e.message}", encryption_key)
+    end
+
+    def handle_file_end(sender_ip, message_data, active_transfers, output_dir, encryption_key, callback)
+      end_data = JSON.parse(message_data)
+      transfer_id = end_data["id"]
+      transfer = active_transfers[transfer_id]
+      if transfer && transfer[:sender_ip] == sender_ip
+        transfer[:temp_file].close
+        calculated_checksum = calculate_file_checksum(transfer[:temp_file].path)
+        if calculated_checksum == transfer[:expected_checksum]
+          final_path = File.join(output_dir, transfer[:file_name])
+          FileUtils.mv(transfer[:temp_file].path, final_path)
+          ack_message = Lanet::Encryptor.prepare_message("#{FILE_ACK}#{transfer_id}", encryption_key)
+          @sender.send_to(sender_ip, ack_message)
+          callback&.call(:complete, {
+                           transfer_id: transfer_id,
+                           sender_ip: sender_ip,
+                           file_name: transfer[:file_name],
+                           file_path: final_path
+                         })
+        else
+          error_msg = "Checksum verification failed"
+          send_error(sender_ip, transfer_id, error_msg, encryption_key)
+          callback&.call(:error, {
+                           transfer_id: transfer_id,
+                           sender_ip: sender_ip,
+                           error: error_msg
+                         })
+        end
+        transfer[:temp_file].unlink
+        active_transfers.delete(transfer_id)
+      end
+    rescue JSON::ParserError => e
+      send_error(sender_ip, "unknown", "Invalid end marker format: #{e.message}", encryption_key)
+    end
+
+    def handle_file_error(sender_ip, message_data, active_transfers, callback)
+      error_data = JSON.parse(message_data)
+      transfer_id = error_data["id"]
+      if callback && active_transfers[transfer_id]
+        callback.call(:error, {
+                        transfer_id: transfer_id,
+                        sender_ip: sender_ip,
+                        error: error_data["message"]
+                      })
+        if active_transfers[transfer_id]
+          active_transfers[transfer_id][:temp_file].close
+          active_transfers[transfer_id][:temp_file].unlink
+          active_transfers.delete(transfer_id)
+        end
+      end
+    rescue JSON::ParserError
+      # Ignore malformed error messages
+    end
+
+    def cleanup_transfers(active_transfers)
+      active_transfers.each_value do |transfer|
+        transfer[:temp_file].close
+        begin
+          transfer[:temp_file].unlink
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end