Lanet

require 'lanet'

# Generate RSA key pair for signing
key_pair = Lanet::Signer.generate_key_pair
private_key = key_pair[:private_key]
public_key = key_pair[:public_key]

# Set up sender and receiver
sender = Lanet::Sender.new(9000)
encryption_key = "secret-key-123"

# Send a signed and encrypted message
message = "Hello, secure world!"
prepared_message = Lanet::Encryptor.prepare_message(
  message,
  encryption_key,
  private_key
)
sender.send_to("192.168.1.5", prepared_message)

# Receive and verify messages
receiver = Lanet::Receiver.new(9000)
receiver.listen do |data, sender_ip|
  result = Lanet::Encryptor.process_message(
    data,
    encryption_key,
    public_key
  )

  puts "Message: #{result[:content]}"
  puts "Verified: #{result[:verified]}"
  puts "Verification status: #{result[:verification_status]}"
end

require 'lanet'

# Create a scanner and find active devices
scanner = Lanet::Scanner.new
active_hosts = scanner.scan('192.168.1.0/24', 1, 32, true)

active_hosts.each do |host|
  puts "Host: #{host[:ip]}, Hostname: #{host[:hostname]}"
  puts "Response time: #{host[:response_time]}ms"

  if host[:ports]
    puts "Open ports:"
    host[:ports].each do |port, service|
      puts "  - #{port}: #{service}"
    end
  end
end

# Ping a specific host
pinger = Lanet::Ping.new
result = pinger.ping_host('192.168.1.5', true)
puts "Host reachable: #{result[:status]}"
puts "Response time: #{result[:response_time]}ms"

# Broadcast a signed and encrypted message
encryption_key = "network-shared-key"
message = "Important system notification"
signed_message = Lanet::Encryptor.prepare_message(
  message,
  encryption_key,
  private_key
)
sender.broadcast(signed_message)

require 'lanet'

# Create a file transfer instance
file_transfer = Lanet.file_transfer

# Send a file with encryption
file_transfer.send_file(
  '192.168.1.5',
  'document.pdf',
  'encryption_key'
) do |progress, bytes, total|
  puts "Progress: #{progress}% (#{bytes}/#{total} bytes)"
end

# Send a file with encryption and digital signature
key_pair = Lanet::Signer.generate_key_pair
file_transfer.send_file(
  '192.168.1.5',
  'document.pdf',
  'encryption_key',
  key_pair[:private_key]
)

# Receive files
file_transfer.receive_file('./downloads', 'encryption_key') do |event, data|
  case event
  when :start
    puts "Receiving file: #{data[:file_name]}"
    puts "From: #{data[:sender_ip]}"
    puts "Size: #{data[:file_size]} bytes"
  when :progress
    puts "Progress: #{data[:progress]}%"
  when :complete
    puts "File saved to: #{data[:file_path]}"
  when :error
    puts "Error: #{data[:error]}"
  end
end

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

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