scriptroute 0.4.14

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3d192161acfbf508dfd7d953bc7ec1a219930d15
+  data.tar.gz: a3c7cbd73442f9aa4cc263830a71b62023f08355
+SHA512:
+  metadata.gz: 3a98db9cec4c8d90da6c8958e68d063d3049c68d88ac612184abfef44a789f8b57120b2325625f3704c770db3a6557aa2ad6336d36655be28067426b0fff69f0
+  data.tar.gz: 77be1bb191576fa8890c8395c1d93577e060cfe4a846989c74c51ae24797e3dbf1c78f091dbedc33ef72c3aa78c373ba391cfe1ee1eed3dd88c70815dee82425

data/bin/sr-ally

@@ -0,0 +1,21 @@
+#! /usr/bin/env ruby
+
+require 'scriptroute/ally'
+require 'scriptroute/ipaddr4'
+
+if(ARGV.length < 2) then
+  puts "ERROR: need two ip addresses to compare."
+  exit 3;
+end
+
+verdict = Ally.new(ARGV[0], ARGV[1]);
+puts verdict
+exit case verdict.to_s
+     when /^ALIAS/
+       0;
+     when /^NOT ALIAS/
+       1;
+     when /^UNKNOWN/
+       2;
+     end
+

data/bin/sr-liveness

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'scriptroute'
+require 'scriptroute/liveness'
+
+if ARGV.empty? then
+  puts "give me hosts to ping"
+end
+Scriptroute::daemon_running_or_exit
+puts Scriptroute::LivenessTest.new(ARGV)
+

data/bin/sr-ping-T

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+# -*- mode: Ruby -*-
+
+require 'scriptroute'
+require 'scriptroute/packets'
+require 'scriptroute/nameify'
+
+$have_socket = begin
+                 require 'socket'
+                 true
+               rescue
+                 false
+               end
+
+Scriptroute::daemon_running_or_exit
+
+i = Scriptroute::ICMPecho.new(0)
+ # i.ip_dst = 0x805f0218 # poplar
+i.ip_dst = Scriptroute::dns_lookup(ARGV[0])
+# i.ip_dst = 0xc6ca4b65 # www.sdsc.edu
+# rr = RecordRoute_option.new
+# IPOPT_TS_TSONLY = 0
+# IPOPT_TS_TSANDADDR = 1
+# IPOPT_TS_PRESPEC = 3
+rr = Scriptroute::Timestamp_option.new(Scriptroute::IPv4option::IPOPT_TS_TSONLY)
+i.ip_ttl=15
+i.add_option(rr)
+
+p = Scriptroute::send_train([ Struct::DelayedPacket.new(0, i) ])
+
+# p[0].response.packet.to_bytes.each_byte { |b| puts "%x " % b }
+
+if (p[0].response != nil) then
+  if ($VERBOSE) then puts p[0].response.packet end
+  resp = ""
+  begin
+    resp = Scriptroute::IPv4.creator(p[0].response.packet.to_bytes) 
+    resp.ip_options.each { |opt| 
+      if(opt.is_a?(Scriptroute::Timestamp_option)) then
+        if(resp.ip_options[0].routers != nil &&
+           resp.ip_options[0].times != nil && resp.ip_options[0].times.length > 0) then
+          opt.times.each_index { |i| 
+            puts Scriptroute.nameify(resp.ip_options[0].routers[i]) + " " + resp.ip_options[0].times[i].to_s
+          }
+        else 
+          opt.times.each_index { |i| 
+            puts resp.ip_options[0].times[i].to_s
+          }
+        end
+      elsif(opt.is_a?(Scriptroute::RecordRoute_option)) then
+        opt.routers.each_index { |i| 
+          puts "%d %s" % [ i+1, Scriptroute.nameify(resp.ip_options[0].routers[i]) ]
+        }
+      else
+        raise "unknown option class %s" % opt.class.to_s
+      end
+    }
+  rescue => e
+    puts "failed due to #{e} parsing: #{resp}"
+  end
+else
+  puts "no response to ping -r from %s" % p[0].probe.packet.ip_dst
+end
+
+# .map { |a| 
+#  a
+  #nameify(a)
+#}
+

data/bin/sr-rockettrace

@@ -0,0 +1,51 @@
+#! /usr/bin/env ruby
+
+require 'scriptroute'
+require 'scriptroute/rockettrace'
+require 'scriptroute/nameify'
+require 'scriptroute/commando'
+
+c = Commando.new(ARGV,  # allows substitution by srclient.rb
+                 [ CommandoVar.new( [ "-S", "--start-ttl" ], 
+                                   "hops out to start" , 
+                                   :$StartTTL, 1),
+                   CommandoVar.new( [ "-n", "--numeric" ], 
+                                   "do no hostname lookup or interpretation" , 
+                                   :$Numeric, false),
+                   CommandoVar.new( [ "-q", "--queries" ], 
+                                   "number of probes at each ttl" , 
+                                   :$Repetitions, 3),
+                   # todo CommandoVar.new( "--use-icmp", 
+                   # todo                 "use icmp probes instead of udp" ,
+                   # todo                 :$UseICMP, false ) ],
+                   CommandoVar.new( [ "-o", "--output" ], 
+                                   "file to use instead of stdout" , 
+                                   :$Output, ""),
+                   CommandoVar.new( "--use-tcp", 
+                                   "use tcp probes instead of udp" ,
+                                   :$UseTCP, false ) ],
+                 "destination-host")
+
+raise "must start with a positive ttl" if($StartTTL <= 0)
+if(ARGV[0] == nil) then
+  c.usage
+  exit
+end
+
+Scriptroute::daemon_running_or_exit
+
+if($Output != "") then
+  $stdout.reopen(File.open($Output,"a"))
+end
+
+Destination = (ARGV[0] =~ /(\d{1,3}\.){3}\d{1,3}/) ? ARGV[0] : Scriptroute.dns_lookup(ARGV[0])
+puts Scriptroute::Rockettrace.new(Destination, $StartTTL, $UseTCP, $Repetitions).to_s(lambda { |x| 
+    if($Numeric) then
+      x
+    elsif(x=='' || x==nil)
+      "[empty]"
+    else
+      Scriptroute.nameify(x) 
+    end        
+})
+

data/bin/sr-traceroute

@@ -0,0 +1,35 @@
+#! /usr/bin/env ruby
+
+require 'scriptroute'
+
+Scriptroute::daemon_running_or_exit
+
+probe = Scriptroute::UDP.new(12) 
+
+probe.ip_dst = Scriptroute::dns_lookup(ARGV[0])
+
+unreach = false
+
+puts "Traceroute to #{ARGV[0]} (#{probe.ip_dst})"
+
+catch(:unreachable) do 
+  ( 1..64 ).each { |ttl|
+    ( 1..3 ).each { |rep|
+      probe.ip_ttl = ttl
+      # some boxes refuse to reply to additional probes to the same uh_dport.  
+      probe.uh_dport = 33434 + ttl + rep 
+      packets = Scriptroute::send_train([ Struct::DelayedPacket.new(0,probe) ])
+      response = (packets[0].response) ?  packets[0].response.packet : nil
+      if(response) then
+        puts '%d %s %5.3f ms' % [ ttl, response.ip_src, packets[0].rtt * 1000.0 ]
+        if(response.is_a?(Scriptroute::ICMP)) then
+          unreach = true if(response.icmp_type == Scriptroute::ICMP::ICMP_UNREACH)
+        end
+      else
+        puts '%d *' %  [ ttl ]
+      end
+      $stdout.flush
+    }
+    throw :unreachable if(unreach)
+  }
+end

data/bin/tulip

@@ -0,0 +1,183 @@
+#! /usr/bin/env ruby
+
+# require "srclient";
+require "scriptroute";
+require "scriptroute/tulip/helper.rb";
+require "scriptroute/tulip/reordering.rb";
+require "scriptroute/tulip/loss.rb";
+require "scriptroute/tulip/queuing.rb";
+
+FIXCLOCK = "/usr/bin/awk -f scriptroute/fixclock";
+
+   ################### defaults ################
+
+$count = 1000;
+$lag = 1000;
+$spread = 0;
+$start = 1;
+$end = 30;
+
+$skipRTrtrs = true;
+$printFrequency = -1;
+$allhops = true;
+$dstonly = false;
+$nonames = false;
+$prefixpath = 0;
+
+$verbose = 0;
+$version = "0.0.1"
+
+MAX_TRAIN = 4000;
+
+    #################### usage ##################
+def usage() 
+  puts "usage: tulip <reordering|loss|queuing> [options] <destination>\n";
+  puts "options:";
+  puts "--count <num>: number of measurements to use [#{$count}]";
+  puts "--lag <lag>: milliseconds to wait between successive measurements of the path [#{$lag}]";
+  puts "--spread <spread>: millisecond separation between probes in a single measurement [#{$spread}]";
+  puts "--start <start>: hop number to start diagnosis from [#{$start}]";
+  puts "--end <end>: hop number to end diagnosis at [#{$end}]";
+  puts "";
+  puts "--noskip: stop querying rate-limiting routers [skipping]";
+  puts "--mode <parallel|binary>: binary search not yet implemented";
+  puts "--printfrequency <frequency>: number of measurements to print the analysis [at the end]";
+  puts "--noallhops: use round trip measurements for hops that don't support forward primitives [on]";
+  puts "--dstonly: only probe end to end path [off]";
+  puts "--nonames: don't resolve ip addresses [resolve]";
+  puts "--prefixpath <hops>: number of initial hops to excuse for local load balancing [#{$prefixpath}]";
+  puts "";
+  puts "--help: display this message";
+  puts "--verbose <level>: level of verbosity (0-10) [#{$verbose}]";
+  puts "--version: print version information and exit";
+  puts "";
+  exit 1;
+end
+  
+def printVersionAndExit()
+  puts "tulip version: #{$version}";
+  exit 0;
+end
+
+    #################### command line processing #############
+
+printVersionAndExit() if (ARGV.index("--version"));
+usage() if (ARGV.length < 2);
+
+pathology = ARGV.shift();
+if (pathology[0,1] == "r") then
+  pathology = "reordering";
+elsif (pathology[0,1] == "l") then
+  pathology = "loss";
+elsif (pathology[0,1] == "q") then
+  pathology = "queuing";
+else 
+  puts "ERROR: unknown pathology";
+  usage();
+end
+
+switch = ARGV.shift();
+while (switch and switch[0,2] == "--") 
+  if (switch == "--count")     then $count = ARGV.shift.to_i;
+  elsif (switch == "--lag")    then $lag = ARGV.shift.to_i;
+  elsif (switch == "--spread") then $spread = ARGV.shift.to_f;
+  elsif (switch == "--start")  then $start = ARGV.shift.to_i;
+  elsif (switch == "--end")    then $end = ARGV.shift.to_i;
+  elsif (switch == "--printfrequency") then $printFrequency = ARGV.shift.to_i;
+  elsif (switch == "--help")    then usage();
+  elsif (switch == "--verbose") then $verbose = ARGV.shift.to_i;
+  elsif (switch == "--noskip")  then $skipRTrtrs = false;
+  elsif (switch == "--noallhops") then $allhops = false;
+  elsif (switch == "--dstonly") then $dstonly = true;
+  elsif (switch == "--nonames") then $nonames = true;
+  elsif (switch == "--prefixpath") then $prefixpath = ARGV.shift.to_i;
+  else 
+    puts "ERROR: unknown option\n";
+    usage();
+  end
+  switch = ARGV.shift();
+end
+
+Scriptroute::daemon_running_or_exit
+
+begin
+  destination = IPSocket.getaddress(switch) or switch;
+rescue SocketError
+  puts "ERROR: unknown destination '#{switch}'";
+  usage();
+end
+
+if ($verbose>0) then
+  puts "pathology=%s count=%d lag=%d spread=%d start=%d end=%d verbose=%d destination=%s allhops=%s" % [pathology, $count, $lag, $spread, $start, $end, $verbose, destination, $allhops];
+end
+
+  ########## determine hop characteristics #########
+
+puts "tracing to #{destination} ......" if ($verbose >= 1);
+tpath = Scriptroute::Tulip::TracePath.new(destination, !$nonames); 
+
+ #todo: get rid of this ugly hack
+$global_tpath = tpath;
+
+puts " ----- pathto #{destination} ----- \n#{tpath.to_s}\n";
+if (tpath.status_code == "incomplete") then
+  puts "incomplete trace\n";
+end
+
+puts "discovering routers that support forward path diagnosis .....\n" if ($verbose >=1);
+hopDetails = Array.new();
+if ($dstonly) then 
+  hopDetails[tpath.path.length-1] = [destination, 255, "udp", true, destination];
+else 
+  middle = $start; 
+  while (middle <= [$end, tpath.path.length - 1].min)
+  
+    router, ttl = tpath.path[middle].ip, tpath.path[middle].hop;
+  
+    ## for loss and reordering (ip-ids) ##
+    if (pathology == "reordering" || pathology == "loss") then
+      if (Scriptroute::Tulip::LangChecker.increasingIPIDs(destination, ttl, "udp")) then
+	hopDetails[middle] = [destination, ttl, "udp", true, router];
+      else
+	subpath = Scriptroute::Tulip::TracePath.new(router);
+	subset = tpath.subset(subpath);
+	puts " ----- subpathto #{router} (#{middle}) is #{subset} -----\n#{subpath.to_s}\n" if ($verbose>0);
+	if (subset) then
+	  type, canCheckForward = Scriptroute::Tulip::LangChecker.getBestOption4IPIDs(router, "echo", "udp", "tcp", "tstamp");
+	  if (canCheckForward) then
+	    hopDetails[middle] = [router, 255, type, true, router]
+	  else
+	    hopDetails[middle] = [destination, ttl, "udp", false, router] if ($allhops or middle == tpath.path.length - 1);
+	  end
+	else
+	  hopDetails[middle] = [destination, ttl, "udp", false, router] if ($allhops or middle == tpath.path.length - 1);
+	end
+      end
+      ## queuing (timestamps)
+    else 
+      if Scriptroute::Tulip::(LangChecker.getBestOption(router, "tstamp")) then
+	subpath = Scriptroute::Tulip::TracePath.new(router);
+	subset = tpath.subset(subpath);
+	puts " ----- subpathto #{router} (#{middle}) is #{subset} -----\n#{subpath.to_s}\n" if ($verbose>0);
+	if (subset) then
+	  hopDetails[middle] = [router, 255, "tstamp", true, router];
+	else 
+	  hopDetails[middle] = [router, 255, "tstamp", false, router] if ($allhops or middle == tpath.path.length - 1);
+	end
+      else
+	hopDetails[middle] = [destination, ttl, "udp", false, router] if ($allhops or middle == tpath.path.length - 1);
+      end
+    end
+    
+    middle+=1;
+  end
+end
+
+
+(1..hopDetails.length-1).map { |i| puts "hopdetails: #{tpath.path[i].hop}. #{hopDetails[i].join(" ")}" if (hopDetails[i])} if ($verbose>0);
+
+
+if    (pathology == "reordering") then  Scriptroute::Tulip::ReorderingDoctor.new(hopDetails);
+elsif (pathology == "loss")       then  Scriptroute::Tulip::LossDoctor.new(hopDetails);
+else                                    Scriptroute::Tulip::QueuingDoctor.new(hopDetails);
+end

data/lib/scriptroute.rb

@@ -0,0 +1,327 @@
+# @author Neil Spring
+
+require 'socket'
+require 'timeout'
+require 'base64'
+require 'resolv'
+require 'scriptroute/packets'
+require 'scriptroute/ally'
+require 'scriptroute/rockettrace'
+require 'scriptroute/nameify'
+
+module Scriptroute
+
+class ScriptrouteError < StandardError
+end
+
+# A ScriptrouteConnection is an object that wraps the TCP
+# socket used to connect to a scriptroute daemon.  It likely
+# need not be used directly, unless accessing low level
+# scriptroute commands not wrapped by the general
+# Scriptroute module
+class ScriptrouteConnection
+  Client_name = "%s(%d)" % [  defined?(Etc) ? Etc.getlogin : ENV['USER'], Process.uid ]
+  # this version is designed to emulate the 0.4.14 version of srinterpreter.
+  VERSION = '0.4.14'  
+  def initialize
+    begin
+      timeout(5) do 
+        @s = TCPSocket.new 'localhost', 3356
+      end
+      reply = ""
+      reply = one_line_command( "interpret v%s %s\n" % [ VERSION, Client_name ]  )
+      if reply =~ /proceed( Hz=(\d+))/ then
+        # puts "negotiated."
+      else
+        puts "failed to negotiate: %s" % reply
+      end
+    rescue Errno::ECONNREFUSED => e
+      $stderr.puts "Connection refused connecting to scriptrouted, ensure that it is running"
+      raise e
+    end
+  end
+  # @param t [String] the command to issue, newline optional
+  # @return [String, nil] the one-line reply, or nil if the connection timed out or was terminated.
+  def one_line_command(t)
+    begin
+      reply = nil
+      timeout(2) do 
+        issue_command t
+        reply = @s.readline
+      end
+    rescue EOFError
+    end
+    return reply
+  end
+  # @return [Hash] the configuration of the scriptroute daemon
+  def get_config
+    ret = Hash.new
+    timeout(5) do 
+      issue_command "showconfig\n"
+      l = "do/while"
+      # showconfig ends reply with an empty line.
+      while l !~ /^#done/  && l !~ /^$/ 
+        l = @s.readline
+        if l =~ /^(\S+)\s+=\s+(.+)$/ then
+          ret[$1] = $2
+        elsif l =~ /^(\S+)\s+=\s*$/ then
+          ret[$1] = nil
+        elsif l =~ /^$/ then
+          # end. 
+        else
+          puts "unparsed config: %s" % l 
+        end
+      end 
+    end
+    ret
+  end
+  # @param t [String] the command to issue, newline optional
+  def issue_command(t)
+    # $stderr.puts "writing %s" % t
+    if t[-1] == "\n" then
+      @s.write t
+    else
+      @s.write "%s\n" % [ t ]
+    end
+  end
+  # @return [String,nil] A one-line reply, or nil if the connection terminated.
+  def get_reply
+    begin
+      @s.readline
+    rescue EOFError
+      nil
+    end
+  end
+end
+
+  # A DelayedPacket is for constructing trains in send_train.
+  Struct.new("DelayedPacket", :delay, :packet)
+
+  # TimedPacket is a time, packet tuple, with a tsc value thrown in in case its useful
+  class TimedPacket
+    # @return [Float,nil]
+    attr_accessor :time
+    # @return [Fixnum,nil] The output of rdtsc can be a more
+    #   useful value in calculating rtt when NTP's adjustments
+    #   via skew cause trouble.
+    attr_accessor :tsc
+    # @return [IPv4]
+    attr_accessor :packet
+
+    # @param time [Float,nil] Seconds since the epoch, or nil if we didn't see the packet leave due to pcap (happens)
+    # @param tsc [Fixnum,nil] Value of the cycle counter (rdtsc) or nil if not supported
+    # @param packet [IPv4] The packet received.
+    def initialize(time, tsc, packet)
+      raise ArgumentError, "no packet" unless packet
+      raise ArgumentError, "packet of the wrong class" unless packet.is_a?(IPv4)
+      @time = time
+      @tsc = tsc
+      @packet = packet
+    end
+  end
+
+  # A ProbeResponse is a pair of a probe and its response.
+  # Scriptroute is designed around the idea that a general
+  # purpose engine can recognize the response to any probe,
+  # and be in charge of doing so, so that measurement tools
+  # need not have the rights to look at every packet.  
+  # 
+  # This design does limit somewhat, since probes that are 
+  # capable of soliciting more than one response (e.g., via 
+  # fragmentation) will not be managed properly.
+  class ProbeResponse
+    # @return [TimedPacket]
+    attr_accessor :probe
+    # @return [TimedPacket]
+    attr_accessor :response
+    # @return [Float,nil] Provides the apparent round trip time of this probe-response pair, or nil if either time is missing.
+    def rtt
+      if response and probe and probe.time then
+        response.time - probe.time
+      else
+        nil
+      end
+    end
+  end
+  private
+
+  # Connection pool in case the script requires more than one connection to the server (for concurrent tests).
+  class ConnectionPool
+    @@connections_cache = []
+    # Connection pool mutex.
+    @@connections_mutex = Mutex.new
+    # Fetch from the connection pool or create a new connection
+    # @return [ScriptrouteConnection]
+    def ConnectionPool.get_idle_connection 
+      @@connections_mutex.lock
+      if @@connections_cache.empty? then
+        @@connections_mutex.unlock
+        return ScriptrouteConnection.new
+      else
+        ret = @@connections_cache.shift
+        @@connections_mutex.unlock
+        return ret
+      end
+    end
+    # @param c [ScriptrouteConnection] the connection to return to the pool
+    # @return [void]
+    def ConnectionPool.return_idle_connection(c)
+      @@connections_mutex.synchronize {
+        @@connections_cache.push(c)
+      }
+    end
+  end
+  public
+  # Take a block to be executed with a ScriptrouteConnection
+  # from the pool.  This is the function to use, since it
+  # manages the pooled connections explicitly.  A leak in
+  # connections would be bad.
+  # @yield [ScriptrouteConnection] the connection for this block.
+  # @return the output of the block
+  def Scriptroute::with_scriptroute_connection
+    c = ConnectionPool.get_idle_connection
+    r = yield c
+    ConnectionPool.return_idle_connection(c)
+    r
+  end
+  # Check if the daemon is running by making a connection or
+  # checking the pool for an unused but working connection.
+  # @return [Boolean]
+  def Scriptroute::is_daemon_running?
+    begin
+      with_scriptroute_connection do |c|
+      end
+      return true
+    rescue Errno::ECONNREFUSED
+      return false
+    end
+  end
+  # Exit failure if the scriptroute daemon does not appear
+  # to be running.  This is useful at the beginning of
+  # scripts that expect the daemon to run, to avoid adding
+  # extra error checking later.
+  # @return [true] if the script does ot exit because the daemon
+  #   is not running.
+  def Scriptroute::daemon_running_or_exit
+    begin
+      with_scriptroute_connection do |c|
+      end
+      return true
+    rescue Errno::ECONNREFUSED
+      puts "Ensure that the scriptroute daemon is running and try again"
+      exit 1
+    end
+  end
+  # Query for the version of the daemon; useful if there's a
+  # feature only supported in a particular version.  @return
+  # @return [String] the version string provided by of the running daemon
+  def Scriptroute::DaemonVersion
+    with_scriptroute_connection do |c|
+      puts c.one_line_command("version\n")
+    end
+  end
+  # @return [String] An IP address associated with the
+  #   hostname.  Currently just invokes Resolv.getaddress.
+  def Scriptroute::dns_lookup(name)
+    Resolv.getaddress name
+  end
+  # @return [Hash] the configuration of the running daemon,
+  #  useful for checking rate limiting parameters or filters
+  #  if a specially configured daemon is needed.
+  def Scriptroute::DaemonConfig
+    ret = nil
+    with_scriptroute_connection do |c|
+      ret = c.get_config
+    end
+    ret
+  end
+  # no op for backward compatibility with the srinterpreter version
+  # that had a dedicated packet instance
+  # @param s [String] A marshaled packet.
+  # @return [String] The input parameter, which is sufficient for this implementation of {Scriptroute::send_train}.
+  def Scriptroute::pkt_from_string(s)
+    s
+  end
+  # This is the nut.
+  # @param train [Array<Struct::DelayedPacket,Array>] an array of Struct::DelayedPacket entries or arrays containing delay, packet pairs.
+  # @return [Array<Scriptroute::ProbeResponse>] an array of Scriptroute::ProbeResponse entries, comprising a probe and response.
+  def Scriptroute::send_train(train)
+    ret = nil
+    return [] if train.empty? # easy?
+    with_scriptroute_connection do |c|
+      # issue the send train command.
+      i = 1;
+      total_delay = 0
+      train.map! { |boxcar|
+        raise ArgumentError, 'nil entry' unless boxcar
+        if boxcar.is_a?(Array) then
+          Struct::DelayedPacket.new(*boxcar)
+        else
+          raise ArgumentError, 'not a boxcar or an array' unless boxcar.is_a?(Struct::DelayedPacket)
+          boxcar
+        end
+      }
+      train.each { |boxcar|
+        # needs validation.
+        delay = boxcar[:delay]
+        packet = boxcar[:packet]
+        raise "no packet" unless packet
+        if packet.is_a?(Scriptroute::IPv4) then
+          packet = packet.marshal
+        end
+        raise "packet is #{packet.class}, not a string" unless packet.is_a?(String)
+        encoded_packet = Base64.strict_encode64(packet) # strict_encode means no line feeds added.
+        c.issue_command "sendtrain %d/%d %f %d %s\n" % [ i, train.length, delay<0 ? 0 : delay, encoded_packet.length, encoded_packet ]
+        i+=1
+        total_delay += delay
+      }
+
+      # allocate space for the responses, array of probe response pairs, each of which will be a time/packet pair.
+      ret = Array.new(i-1) { ProbeResponse.new }
+
+      # collect, waiting maybe 5 minutes more than needed just in case the daemon hangs on us.
+      begin
+        timeout(total_delay + 300) do
+          while l = c.get_reply and l !~ /^done/ and l =~ /\S+/ do
+            if l =~ /^ERROR/ then
+              # have to throw an exception, although individual packet errors are possible, that's
+              # not communicated by the daemon.
+              $stderr.puts l
+              if l=~ /disjoint train \missing packet #(\d+)/ then
+                ret[ $1.to_i ].probe = nil
+                ret[ $1.to_i ].response = nil
+              end
+              raise ScriptrouteError, l
+            else
+              if l =~ /^(-?\d+\.\d+)\/(\d+) (\d+)([<>]) \d+ (\S+)$/ then
+                tv_s = $1.to_f
+                rdtsc = $2
+                pk = $3.to_i - 1
+                io = ($4 == '>') ? 0 : 1
+                st = $5
+                packet_string = Base64.strict_decode64(st)
+                p = IPv4.creator(packet_string)
+                tv_s = nil if tv_s < 0 # didn't see it leave.
+                tp = TimedPacket.new(tv_s, rdtsc, p)
+                if io == 0 then
+                  ret[ pk ].probe = tp
+                else
+                  ret[ pk ].response = tp
+                end
+              else
+                puts "unparsed send_train response: #{l}"
+              end
+            end
+          end # while
+        end # timeout
+      rescue TimeoutError
+        $stderr.puts "timed out parsing responses for send_train"
+      end
+    end
+    return ret
+  end
+end
+
+# Local Variables:
+# compile-command: "rake test"
+# End: