lanet 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1e22dfda5b58811a99f1d763c3ff32d84b2e8e291ab07b8f1ee90e3c1849446
-  data.tar.gz: 70a12c6ea35bd5981acc401f0a7dc482c2f2161c2a67a8b4ffcefc00ac1777a4
+  metadata.gz: 8c54bf6a4ec7bdeafe5e225e2cbbe34a181c1990254cd2fb1d3b975fbe670451
+  data.tar.gz: a3c802ffc1435b5797b32c2083f1512de1ca74309c25387bdf5fa87110c1fa41
 SHA512:
-  metadata.gz: e45f31e4dacefa4d0622f1fdfe8d8cb48dca0c4ad256481a06f8bf7d1dea2ef231be657db2b8c92c1e129faa8375bdc36221152fb7967cca15ae7bc3c5fce89b
-  data.tar.gz: 4cceff6bc76a51aeebb0bc0585ec9228d53151421927e8e8461e39a79f0208ed3a793455f8b9e0714364ce9cb169e987ab757a29e7ad4ab3acc908ab72f8a11f
+  metadata.gz: 54aa773fe7dc3a6699e7d04de688174f656151dd507bfe439c9780a5efa6521dddbc26d7a97e6e4889f5e17d505cbc2e8926567ef9dc0b30b04f171fcdfcb1d9
+  data.tar.gz: c564091430f87f22ef93046ceb2c5a28c210610e9fee78e6d87e082a7380440c20547e1b449b34321bfed8c80e1a83d1707f9daa822fd70cbf053384e8827c00

data/CHANGELOG.md

@@ -5,7 +5,17 @@ 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
+## [0.5.0] - 2025-03-12
+
+### Added
+- Advanced traceroute functionality for network path analysis
+- Multiple protocol support for traceroute: ICMP, UDP, and TCP
+- Load balancing detection in traceroute results
+- CLI command: `traceroute` with protocol selection and customizable parameters
+- Ruby API for programmatic traceroute operations
+- Comprehensive documentation and examples for traceroute feature
+
+## [0.4.0] - 2025-03-10
 
 ### Added
 - Mesh networking functionality for decentralized communication

data/Gemfile.lock

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

data/README.md

@@ -20,6 +20,7 @@ A lightweight, powerful LAN communication tool that enables secure message excha
 - **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
+- **Advanced Traceroute**: Analyze network paths using multiple protocols (ICMP, UDP, and TCP)
 
 ## Security Features
 
@@ -334,6 +335,36 @@ View information about your mesh network:
 lanet mesh info
 ```
 
+#### Tracing the route to a target host
+
+Basic traceroute using UDP (default protocol):
+
+```bash
+# Simple format
+lanet traceroute google.com
+
+# Option format
+lanet traceroute --host google.com
+```
+
+Trace using ICMP protocol:
+
+```bash
+lanet traceroute --host google.com --protocol icmp
+```
+
+Trace using TCP protocol:
+
+```bash
+lanet traceroute --host google.com --protocol tcp --max-hops 15
+```
+
+Customize traceroute parameters:
+
+```bash
+lanet traceroute --host github.com --protocol tcp --max-hops 20 --timeout 2 --queries 4
+```
+
 ### Ruby API
 
 You can also use Lanet programmatically in your Ruby applications:
@@ -443,6 +474,17 @@ end
 
 # Properly stop the mesh node
 mesh.stop
+
+# Trace route to a host with different protocols
+tracer = Lanet.traceroute(protocol: :udp)
+hops = tracer.trace('github.com')
+hops.each do |hop|
+  puts "Hop #{hop[:ttl]}: #{hop[:ip]} - Response: #{hop[:avg_time]}ms"
+end
+
+# Use TCP protocol with custom parameters
+tcp_tracer = Lanet.traceroute(protocol: :tcp, max_hops: 15, timeout: 2)
+tcp_tracer.trace('google.com')
 ```
 
 ## Mesh Network

data/index.html

@@ -243,6 +243,22 @@
             </div>
         </div>
 
+        <div class="feature">
+            <h3>Advanced Traceroute <span class="badge badge-new">New in v0.5.0</span></h3>
+            <p>Analyze network paths with multi-protocol traceroute capabilities to understand connectivity and troubleshoot network issues.</p>
+            
+            <div class="security-feature">
+                <h4>Features of Advanced Traceroute:</h4>
+                <ul>
+                    <li><strong>Multi-protocol support</strong>: Use ICMP, UDP, or TCP protocols for different network environments</li>
+                    <li><strong>Load balancing detection</strong>: Identify multi-path routing and load balancers in the network</li>
+                    <li><strong>Response time analysis</strong>: Measure latency at each hop in the network path</li>
+                    <li><strong>Customizable parameters</strong>: Adjust max hops, timeouts, and query count for different scenarios</li>
+                    <li><strong>Hostname resolution</strong>: Automatically resolve IP addresses to hostnames for easier identification</li>
+                </ul>
+            </div>
+        </div>
+
         <h2>Command Line Interface</h2>
 
         <div class="note">
@@ -437,6 +453,48 @@ Message cache: 24 messages
             </div>
         </div>
 
+        <div class="cli-section">
+            <h3>Traceroute Commands <span class="badge badge-new">New in v0.5.0</span></h3>
+
+            <h4>Basic Traceroute (UDP protocol)</h4>
+            <div class="cli-example">
+                lanet traceroute --host google.com
+            </div>
+
+            <h4>Traceroute with ICMP Protocol</h4>
+            <div class="cli-example">
+                lanet traceroute --host google.com --protocol icmp
+            </div>
+
+            <h4>Traceroute with TCP Protocol</h4>
+            <div class="cli-example">
+                lanet traceroute --host github.com --protocol tcp
+            </div>
+
+            <h4>Customize Traceroute Parameters</h4>
+            <div class="cli-example">
+                lanet traceroute --host cloudflare.com --protocol tcp --max-hops 20 --timeout 2 --queries 4
+            </div>
+
+            <p>Example output of a traceroute:</p>
+            <div class="output-example">
+Tracing route to github.com using UDP protocol
+Maximum hops: 30, Timeout: 1s, Queries: 3
+======================================================================
+TTL  IP Address        Hostname                         Response Time
+----------------------------------------------------------------------
+  1  192.168.1.1       router.home                      2.34ms
+  2  172.16.42.1       isp-gateway.net                  8.72ms
+  3  216.58.223.14                                      15.35ms
+  4  172.217.170.78    edge-router.google.com           22.89ms
+  5  *                 *                                Request timed out
+  6  140.82.121.4      github.com                       45.23ms
+     Destination unreachable
+======================================================================
+Trace complete.
+            </div>
+        </div>
+
         <h2>Ruby Code Examples</h2>
 
         <div class="tab-container">
@@ -446,6 +504,7 @@ Message cache: 24 messages
                 <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>
+                <button class="tab-button" onclick="openTab(event, 'tab-traceroute')">Traceroute</button>
             </div>
 
             <div id="tab-basic" class="tab-content active">
@@ -626,6 +685,51 @@ end
 # Always stop the mesh node when done
 mesh.stop</code></pre>
             </div>
+
+            <div id="tab-traceroute" class="tab-content">
+                <pre><code>require 'lanet'
+
+# Create a traceroute instance with UDP protocol (default)
+tracer = Lanet.traceroute
+results = tracer.trace('github.com')
+
+# Display the results
+puts "Path to github.com:"
+results.each do |hop|
+  if hop[:ip].nil?
+    puts "Hop #{hop[:ttl]}: * * * Request timed out"
+  else
+    hostname = hop[:hostname] ? hop[:hostname] : ""
+    time = hop[:avg_time] ? "#{hop[:avg_time]}ms" : "*"
+    puts "Hop #{hop[:ttl]}: #{hop[:ip]} (#{hostname}) #{time}"
+    
+    # Check for load balancing (multiple IPs at the same hop)
+    if hop[:all_ips] && hop[:all_ips].size > 1
+      puts "  Multiple IPs detected (load balancing):"
+      hop[:all_ips].each { |ip| puts "  - #{ip}" }
+    end
+  end
+end
+
+# Use ICMP protocol (may require root/admin privileges)
+begin
+  icmp_tracer = Lanet.traceroute(protocol: :icmp, max_hops: 10)
+  icmp_tracer.trace('google.com')
+rescue StandardError => e
+  puts "Error with ICMP traceroute: #{e.message}"
+end
+
+# Use TCP protocol with custom parameters
+tcp_tracer = Lanet.traceroute(protocol: :tcp, max_hops: 15, 
+                             timeout: 2, queries: 4)
+tcp_results = tcp_tracer.trace('cloudflare.com')
+
+# Analyze a specific hop
+interesting_hop = tcp_results[5] # Sixth hop
+if interesting_hop && interesting_hop[:unreachable]
+  puts "Destination unreachable at hop #{interesting_hop[:ttl]}"
+end</code></pre>
+            </div>
         </div>
 
         <h2>Installation</h2>
@@ -640,7 +744,7 @@ mesh.stop</code></pre>
         <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.4.0 - Secure Network Communications Library</p>
+            <p>Lanet v0.5.0 - Secure Network Communications Library</p>
         </footer>
     </div>
 

data/lib/lanet/cli.rb

@@ -6,6 +6,7 @@ require "lanet/receiver"
 require "lanet/scanner"
 require "lanet/ping"
 require "lanet/encryptor"
+require "lanet/traceroute"
 
 module Lanet
   class CLI < Thor
@@ -366,6 +367,62 @@ module Lanet
       mesh.stop
     end
 
+    desc "traceroute [HOST]", "Trace the route to a target host using different protocols"
+    method_option :host, type: :string, desc: "Target host to trace route"
+    method_option :protocol, type: :string, default: "udp", desc: "Protocol to use (icmp, udp, tcp)"
+    method_option :max_hops, type: :numeric, default: 30, desc: "Maximum number of hops"
+    method_option :timeout, type: :numeric, default: 1, desc: "Timeout in seconds for each probe"
+    method_option :queries, type: :numeric, default: 3, desc: "Number of queries per hop"
+    def traceroute(single_host = nil)
+      # Use the positional parameter if provided, otherwise use the --host option
+      target_host = single_host || options[:host]
+
+      # Ensure we have a host to trace
+      unless target_host
+        puts "Error: No host specified. Please provide a host as an argument or use --host option."
+        return
+      end
+
+      tracer = Lanet::Traceroute.new(
+        protocol: options[:protocol].to_sym,
+        max_hops: options[:max_hops],
+        timeout: options[:timeout],
+        queries: options[:queries]
+      )
+
+      puts "Tracing route to #{target_host} using #{options[:protocol].upcase} protocol"
+      puts "Maximum hops: #{options[:max_hops]}, Timeout: #{options[:timeout]}s, Queries: #{options[:queries]}"
+      puts "=" * 70
+      puts format("%3s  %-15s  %-30s  %-10s", "TTL", "IP Address", "Hostname", "Response Time")
+      puts "-" * 70
+
+      tracer.trace(target_host).each do |hop|
+        if hop[:ip].nil?
+          puts format("%3d  %-15s  %-30s  %-10s", hop[:ttl], "*", "*", "Request timed out")
+        else
+          hostname = hop[:hostname] || ""
+          time_str = hop[:avg_time] ? "#{hop[:avg_time]}ms" : "*"
+          puts format("%3d  %-15s  %-30s  %-10s", hop[:ttl], hop[:ip], hostname, time_str)
+
+          # Show all IPs if there are multiple (for load balancing detection)
+          if hop[:all_ips] && hop[:all_ips].size > 1
+            puts "     Multiple IPs detected (possible load balancing):"
+            hop[:all_ips].each do |ip|
+              puts "     - #{ip}"
+            end
+          end
+
+          # Show unreachable marker
+          puts "     Destination unreachable" if hop[:unreachable]
+        end
+      end
+      puts "=" * 70
+      puts "Trace complete."
+    rescue StandardError => e
+      puts "Error performing traceroute: #{e.message}"
+      puts e.backtrace if options[:verbose]
+    end
+
     private
 
     def display_ping_details(host, result)

data/lib/lanet/traceroute.rb

@@ -0,0 +1,426 @@
+# frozen_string_literal: true
+
+require "socket"
+require "timeout"
+require "resolv"
+
+module Lanet
+  class Traceroute
+    # Supported protocols
+    PROTOCOLS = %i[icmp udp tcp].freeze
+
+    # Default settings
+    DEFAULT_MAX_HOPS = 30
+    DEFAULT_TIMEOUT = 1
+    DEFAULT_QUERIES = 3
+    DEFAULT_PORT = 33_434 # Starting port for UDP traceroute
+
+    attr_reader :results, :protocol, :max_hops, :timeout, :queries
+
+    def initialize(protocol: :udp, max_hops: DEFAULT_MAX_HOPS, timeout: DEFAULT_TIMEOUT, queries: DEFAULT_QUERIES)
+      @protocol = protocol.to_sym
+      @max_hops = max_hops
+      @timeout = timeout
+      @queries = queries
+      @results = []
+
+      return if PROTOCOLS.include?(@protocol)
+
+      raise ArgumentError, "Protocol must be one of #{PROTOCOLS.join(", ")}"
+    end
+
+    def trace(destination)
+      @results = []
+      destination_ip = resolve_destination(destination)
+
+      begin
+        case @protocol
+        when :icmp
+          trace_icmp(destination_ip)
+        when :udp
+          trace_udp(destination_ip)
+        when :tcp
+          trace_tcp(destination_ip)
+        end
+      rescue StandardError => e
+        raise e unless e.message.include?("Must run as root/administrator")
+
+        # Fall back to system traceroute command if we don't have root privileges
+        trace_using_system_command(destination)
+      end
+
+      @results
+    end
+
+    private
+
+    def trace_using_system_command(destination)
+      # Build the appropriate system traceroute command
+      system_cmd = case @protocol
+                   when :icmp
+                     "traceroute -I"
+                   when :tcp
+                     "traceroute -T"
+                   else
+                     "traceroute" # UDP is the default for most traceroute commands
+                   end
+
+      # Add options for max hops, timeout, and queries/retries
+      system_cmd += " -m #{@max_hops} -w #{@timeout} -q #{@queries} #{destination}"
+
+      # Execute the command and capture output
+      output = `#{system_cmd}`
+
+      # Parse the output to build our results
+      parse_system_traceroute_output(output)
+    end
+
+    def parse_system_traceroute_output(output)
+      lines = output.split("\n")
+
+      # Skip only the header line which typically starts with "traceroute to..."
+      lines.shift if lines.any? && lines.first.start_with?("traceroute to")
+
+      # Process each line of output
+      lines.each do |line|
+        # Extract hop number and details
+        next unless line =~ /^\s*(\d+)\s+(.+)$/
+
+        hop_num = Regexp.last_match(1).to_i
+        hop_details = Regexp.last_match(2)
+
+        # Parse the hop details
+        hostname = nil
+        avg_time = nil
+
+        # Check for timeout indicated by asterisks
+        if ["* * *", "*"].include?(hop_details.strip)
+          # All timeouts at this hop
+          @results << { ttl: hop_num, ip: nil, hostname: nil, avg_time: nil, timeouts: @queries }
+          next
+        end
+
+        # Extract all IPs from the hop details to support load-balancing detection
+        all_ips = extract_multiple_ips(hop_details)
+
+        # Extract the first IP (primary IP for this hop)
+        ip = all_ips&.first
+
+        # Try to extract hostname if present
+        # Format: "hostname (ip)"
+        if hop_details =~ /([^\s(]+)\s+\(([0-9.]+)\)/
+          hostname = Regexp.last_match(1)
+          # We already have the IP from all_ips, so no need to set it again
+        end
+
+        # Extract response times - typically format is "X.XXX ms Y.YYY ms Z.ZZZ ms"
+        times = hop_details.scan(/(\d+\.\d+)\s*ms/).flatten.map(&:to_f)
+        avg_time = (times.sum / times.size).round(2) if times.any?
+
+        # Add to results
+        @results << {
+          ttl: hop_num,
+          ip: ip,
+          hostname: hostname,
+          avg_time: avg_time,
+          timeouts: @queries - times.size,
+          # Include all IPs if there are multiple
+          all_ips: all_ips&.size && all_ips.size > 1 ? all_ips : nil
+        }
+      end
+    end
+
+    def extract_multiple_ips(hop_details)
+      # Match all IP addresses in the hop details
+      ips = hop_details.scan(/\b(?:\d{1,3}\.){3}\d{1,3}\b/).uniq
+
+      # If no IPs were found in a non-timeout line, there might be a special format
+      if ips.empty? && !hop_details.include?("*")
+        # Try to find any IP-like patterns (some traceroute outputs format differently)
+        potential_ips = hop_details.split(/\s+/).select do |part|
+          part =~ /\b(?:\d{1,3}\.){3}\d{1,3}\b/
+        end
+        ips = potential_ips unless potential_ips.empty?
+      end
+
+      ips
+    end
+
+    def resolve_destination(destination)
+      # If destination is already an IPv4 address, return it
+      return destination if destination =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/
+
+      # Otherwise, resolve the hostname to an IPv4 address
+      begin
+        addresses = Resolv.getaddresses(destination)
+
+        # If no addresses are returned, the hostname is unresolvable
+        raise Resolv::ResolvError, "no address for #{destination}" if addresses.empty?
+
+        # Find the first IPv4 address
+        ipv4_address = addresses.find { |addr| addr =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/ }
+
+        # If no IPv4 address is found, raise an error
+        raise "No IPv4 address found for hostname: #{destination}" if ipv4_address.nil?
+
+        ipv4_address
+      rescue Resolv::ResolvError => e
+        raise "Unable to resolve hostname: #{e.message}"
+      end
+    end
+
+    def get_hostname(ip)
+      Timeout.timeout(1) { Resolv.getname(ip) }
+    rescue StandardError
+      nil
+    end
+
+    def trace_icmp(destination_ip)
+      # ICMP traceroute implementation
+      1.upto(@max_hops) do |ttl|
+        hop_info = trace_hop_icmp(destination_ip, ttl)
+        @results << hop_info
+
+        # Stop if we've reached the destination
+        break if hop_info[:ip] == destination_ip
+        # Stop if we've hit an unreachable marker
+        break if hop_info[:unreachable]
+      end
+    end
+
+    def trace_hop_icmp(destination_ip, ttl)
+      hop_info = { ttl: ttl, responses: [] }
+
+      # Use ping with increasing TTL values
+      @queries.times do
+        Time.now
+        cmd = ping_command_with_ttl(destination_ip, ttl)
+
+        ip = nil
+        response_time = nil
+
+        # Execute the ping command and parse the output
+        begin
+          output = `#{cmd}`
+
+          # Parse the response to get the responding IP
+          if output =~ /from (\d+\.\d+\.\d+\.\d+).*time=(\d+\.?\d*)/
+            ip = ::Regexp.last_match(1)
+            response_time = ::Regexp.last_match(2).to_f
+          end
+        rescue StandardError
+          # Handle errors
+        end
+
+        hop_info[:responses] << {
+          ip: ip,
+          response_time: response_time,
+          timeout: ip.nil?
+        }
+      end
+
+      # Process the responses
+      process_hop_responses(hop_info)
+    end
+
+    def ping_command_with_ttl(ip, ttl)
+      case RbConfig::CONFIG["host_os"]
+      when /mswin|mingw|cygwin/
+        "ping -n 1 -i #{ttl} -w #{@timeout * 1000} #{ip}"
+      when /darwin/
+        "ping -c 1 -m #{ttl} -t #{@timeout} #{ip}"
+      else
+        "ping -c 1 -t #{ttl} -W #{@timeout} #{ip}"
+      end
+    end
+
+    def trace_udp(destination_ip)
+      1.upto(@max_hops) do |ttl|
+        hop_info = trace_hop_udp(destination_ip, ttl)
+        @results << hop_info
+
+        # Stop if we've reached the destination or hit a destination unreachable
+        break if hop_info[:ip] == destination_ip || hop_info[:unreachable]
+      end
+    end
+
+    def trace_hop_udp(destination_ip, ttl)
+      hop_info = { ttl: ttl, responses: [] }
+
+      # Create a listener socket for ICMP responses
+      icmp_socket = create_icmp_socket
+
+      @queries.times do |i|
+        start_time = Time.now
+        port = DEFAULT_PORT + i + (ttl * @queries)
+
+        begin
+          # Create and configure the sending socket
+          sender = UDPSocket.new
+          sender.setsockopt(Socket::IPPROTO_IP, Socket::IP_TTL, ttl)
+
+          # Send the UDP packet
+          Timeout.timeout(@timeout) do
+            sender.send("TRACE", 0, destination_ip, port)
+
+            # Wait for ICMP response
+            data, addr = icmp_socket.recvfrom(512)
+            response_time = ((Time.now - start_time) * 1000).round(2)
+
+            # The responding IP is in addr[2]
+            ip = addr[2]
+
+            # Check if we've received an ICMP destination unreachable message
+            unreachable = data.bytes[20] == 3 # ICMP Type 3 is Destination Unreachable
+
+            hop_info[:responses] << {
+              ip: ip,
+              response_time: response_time,
+              timeout: false,
+              unreachable: unreachable
+            }
+          end
+        rescue Timeout::Error
+          hop_info[:responses] << { ip: nil, response_time: nil, timeout: true }
+        rescue StandardError => e
+          hop_info[:responses] << { ip: nil, response_time: nil, timeout: true, error: e.message }
+        ensure
+          sender&.close
+        end
+      end
+
+      icmp_socket.close
+      process_hop_responses(hop_info)
+    end
+
+    def create_icmp_socket
+      socket = Socket.new(Socket::AF_INET, Socket::SOCK_RAW, Socket::IPPROTO_ICMP)
+      if RbConfig::CONFIG["host_os"] =~ /mswin|mingw|cygwin/
+      # Windows requires different socket setup
+      else
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+      end
+      socket
+    rescue Errno::EPERM, Errno::EACCES
+      raise "Must run as root/administrator to create raw sockets for traceroute"
+    end
+
+    def trace_tcp(destination_ip)
+      1.upto(@max_hops) do |ttl|
+        hop_info = trace_hop_tcp(destination_ip, ttl)
+        @results << hop_info
+
+        # Stop if we've reached the destination
+        break if hop_info[:ip] == destination_ip
+        # Stop if we've hit an unreachable marker
+        break if hop_info[:unreachable]
+      end
+    end
+
+    def trace_hop_tcp(destination_ip, ttl)
+      hop_info = { ttl: ttl, responses: [] }
+
+      @queries.times do |i|
+        # Use different ports for each query
+        port = 80 + i
+        start_time = Time.now
+
+        begin
+          # Create TCP socket with specific TTL
+          socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+          socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_TTL, ttl)
+
+          # Attempt to connect with timeout
+          Timeout.timeout(@timeout) do
+            sockaddr = Socket.sockaddr_in(port, destination_ip)
+            socket.connect_nonblock(sockaddr)
+          end
+
+          # If we get here, we successfully connected (likely at the final hop)
+          response_time = ((Time.now - start_time) * 1000).round(2)
+          hop_info[:responses] << {
+            ip: destination_ip,
+            response_time: response_time,
+            timeout: false
+          }
+        rescue IO::WaitWritable
+          # Connection in progress - need to use select for non-blocking socket
+          response_time = nil
+          ip = nil
+
+          begin
+            Timeout.timeout(@timeout) do
+              _, writable, = IO.select(nil, [socket], nil, @timeout)
+              if writable&.any?
+                # Socket is writable, check for errors
+                begin
+                  socket.connect_nonblock(sockaddr) # Will raise Errno::EISCONN if connected
+                rescue Errno::EISCONN
+                  # Successfully connected
+                  response_time = ((Time.now - start_time) * 1000).round(2)
+                  ip = destination_ip
+                rescue SystemCallError
+                  # Get the intermediary IP from the error
+                  # This is a simplification - in reality, we'd need to use raw sockets
+                  # and analyze TCP packets with specific TTL values
+                  ip = nil
+                end
+              end
+            end
+          rescue Timeout::Error
+            hop_info[:responses] << { ip: nil, response_time: nil, timeout: true }
+          end
+
+          if ip
+            hop_info[:responses] << {
+              ip: ip,
+              response_time: response_time,
+              timeout: false
+            }
+          end
+        rescue SystemCallError, Timeout::Error
+          hop_info[:responses] << { ip: nil, response_time: nil, timeout: true }
+        ensure
+          socket&.close
+        end
+      end
+
+      process_hop_responses(hop_info)
+    end
+
+    def process_hop_responses(hop_info)
+      # Count timeouts
+      timeouts = hop_info[:responses].count { |r| r[:timeout] }
+
+      # If all queries timed out
+      return { ttl: hop_info[:ttl], ip: nil, hostname: nil, avg_time: nil, timeouts: timeouts } if timeouts == @queries
+
+      # Get all responding IPs (could be different if load balancing is in effect)
+      ips = hop_info[:responses].map { |r| r[:ip] }.compact.uniq
+
+      # Most common responding IP
+      ip = ips.max_by { |i| hop_info[:responses].count { |r| r[:ip] == i } }
+
+      # Calculate average response time for responses from the most common IP
+      valid_times = hop_info[:responses].select { |r| r[:ip] == ip && r[:response_time] }.map { |r| r[:response_time] }
+      avg_time = valid_times.empty? ? nil : (valid_times.sum / valid_times.size).round(2)
+
+      # Check if any responses indicated "unreachable"
+      unreachable = hop_info[:responses].any? { |r| r[:unreachable] }
+
+      # Get hostname for the IP
+      hostname = get_hostname(ip)
+
+      {
+        ttl: hop_info[:ttl],
+        ip: ip,
+        hostname: hostname,
+        avg_time: avg_time,
+        timeouts: timeouts,
+        unreachable: unreachable,
+        # Include all IPs if there are different ones (for load balancing detection)
+        all_ips: ips.size > 1 ? ips : nil
+      }
+    end
+  end
+end

data/lib/lanet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lanet
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/lanet.rb

@@ -9,6 +9,7 @@ require "lanet/cli"
 require "lanet/ping"
 require "lanet/file_transfer"
 require "lanet/mesh"
+require "lanet/traceroute"
 
 module Lanet
   class Error < StandardError; end
@@ -56,5 +57,10 @@ module Lanet
     def mesh_network(port = 5050, max_hops = 10)
       Mesh.new(port, max_hops)
     end
+
+    # Create a new traceroute instance
+    def traceroute(protocol: :udp, max_hops: 30, timeout: 1, queries: 3)
+      Traceroute.new(protocol: protocol, max_hops: max_hops, timeout: timeout, queries: queries)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lanet
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Davide Santangelo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-10 00:00:00.000000000 Z
+date: 2025-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -100,6 +100,7 @@ files:
 - lib/lanet/scanner.rb
 - lib/lanet/sender.rb
 - lib/lanet/signer.rb
+- lib/lanet/traceroute.rb
 - lib/lanet/version.rb
 - sig/lanet.rbs
 homepage: https://github.com/davidesantangelo/lanet