rb-wartslib 0.9.10

data/ext/sclist.h

@@ -0,0 +1,34 @@
+/*
+** Ruby bindings to scamper_list_t and scamper_cycle_t.
+**
+** --------------------------------------------------------------------------
+** Copyright (C) 2007 The Regents of the University of California.
+**
+** This program is free software; you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation; either version 2 of the License, or
+** (at your option) any later version.
+** 
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+** 
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+**
+** $Id: sclist.h,v 1.2 2007/11/29 01:32:57 youngh Exp $
+**/
+
+#ifndef __SCLIST_H
+#define __SCLIST_H
+
+#include "scamper_list.h"
+
+VALUE sclist_create(scamper_list_t *list);
+VALUE sccycle_create(scamper_cycle_t *cycle, int type);
+void Init_sclist(void);
+void Init_sccycle(void);
+
+#endif  # __SCLIST_H

data/ext/sctrace.c

@@ -0,0 +1,873 @@
+/*
+** Ruby bindings to scamper_trace_t and its nested structures (e.g.,
+** scamper_list_t, scamper_cycle_t, and scamper_trace_hop_t).
+**
+** General implementation notes:
+**
+**  * The scamper library sets scamper_trace.firsthop to 0 for arts files,
+**    so don't rely on it being useful in general.
+**  * scamper_trace.cycle can be NULL if user invokes a run from the scamper
+**    command line (and doesn't specify a cycle), or no cycle is specified
+**    in a 'source add' command.
+**
+** --------------------------------------------------------------------------
+** Copyright (C) 2007 The Regents of the University of California.
+**
+** This program is free software; you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation; either version 2 of the License, or
+** (at your option) any later version.
+** 
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+** 
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+**
+** $Id: sctrace.c,v 1.45 2007/11/29 20:02:20 youngh Exp $
+**/
+
+#include "ruby.h"
+
+#if defined(__HAVE_STDINT_H__)
+#include <stdint.h>
+#endif
+
+#include "scamper_file.h"
+#include "sctrace.h"
+#include "sclist.h"
+
+extern VALUE mWarts;
+extern void sccycle_free(void *data);  /* for type checking purposes only */
+
+VALUE cTrace; /* Don't make this static, since it's referenced in scfile.c. */
+
+static ID iv_element_type, iv_dest_response, iv_list, iv_cycle;
+static ID meth_write_trace;
+
+/*-------------------------------------------------------------------------*/
+
+#define DEF_CONST(name) \
+  rb_define_const(cTrace, #name, INT2FIX(SCAMPER_TRACE_##name));
+
+
+/*-------------------------------------------------------------------------*/
+
+#define DEF_ATTR(name) \
+  rb_define_method(cTrace, #name, sctrace_attr_##name, 0);
+
+#define NUM_ATTR_FIELD_FUN(name,field)		  \
+  static VALUE sctrace_attr_##name(VALUE self) \
+  { \
+    scamper_trace_t *trace; \
+    Data_Get_Struct(self, scamper_trace_t, trace); \
+    return UINT2NUM(trace->field); \
+  }
+
+#define NUM_ATTR_FUN(name) NUM_ATTR_FIELD_FUN(name,name)
+
+#define STRUCT_NUM_ATTR_FUN(name,sname,field)  \
+  static VALUE sctrace_attr_##name(VALUE self) \
+  { \
+    scamper_trace_t *trace; \
+    Data_Get_Struct(self, scamper_trace_t, trace); \
+    return UINT2NUM(trace->sname ? trace->sname->field : 0); \
+  }
+
+#define STRUCT_STR_ATTR_FUN(name,sname,field)   \
+  static VALUE sctrace_attr_##name(VALUE self) \
+  { \
+    scamper_trace_t *trace; \
+    char *ptr = NULL; \
+    Data_Get_Struct(self, scamper_trace_t, trace); \
+    if (trace->sname) { \
+      ptr = trace->sname->field;		\
+    } \
+    return rb_str_new2(ptr ? ptr : ""); \
+  }
+
+STRUCT_NUM_ATTR_FUN(list_id, list, id);
+STRUCT_STR_ATTR_FUN(list_name, list, name);
+STRUCT_STR_ATTR_FUN(list_descr, list, descr);
+STRUCT_STR_ATTR_FUN(list_monitor, list, monitor);
+
+STRUCT_NUM_ATTR_FUN(cycle_id, cycle, id);
+STRUCT_NUM_ATTR_FUN(cycle_start_time, cycle, start_time);
+STRUCT_NUM_ATTR_FUN(cycle_stop_time, cycle, stop_time);
+STRUCT_STR_ATTR_FUN(cycle_hostname, cycle, hostname);
+
+NUM_ATTR_FIELD_FUN(start, start.tv_sec);
+NUM_ATTR_FIELD_FUN(start_usec, start.tv_usec);
+
+NUM_ATTR_FUN(hop_count);
+NUM_ATTR_FUN(stop_reason);
+NUM_ATTR_FUN(stop_data);
+NUM_ATTR_FUN(type);
+NUM_ATTR_FUN(flags);
+NUM_ATTR_FUN(attempts);
+NUM_ATTR_FUN(hoplimit);
+NUM_ATTR_FUN(gaplimit);
+NUM_ATTR_FUN(firsthop);
+NUM_ATTR_FUN(tos);
+NUM_ATTR_FUN(wait);
+NUM_ATTR_FUN(loops);
+NUM_ATTR_FUN(probe_size);
+NUM_ATTR_FUN(sport);
+NUM_ATTR_FUN(dport);
+
+
+/*-------------------------------------------------------------------------*/
+
+static scamper_trace_hop_t *find_trace_hop(scamper_trace_t *trace,
+					   int hop, int attempt)
+{
+  scamper_trace_hop_t *trace_hop;
+
+  if (hop < 0 || hop >= trace->hop_count || attempt < 0) {
+    return NULL;
+  }
+
+  trace_hop = trace->hops[hop];
+  while (trace_hop && attempt > 0) {
+    --attempt;
+    trace_hop = trace_hop->hop_next;
+  }
+  return trace_hop;
+}
+
+
+#define DEF_HOP_ATTR(name) \
+  rb_define_method(cTrace, #name, sctrace_attr_##name, -1);
+
+/* Because this declares variables, this macro must occur
+   immediately after the variable declarations in a function. */
+#define PROCESS_HOP_PARAMS \
+  VALUE hop, attempt; \
+  if (rb_scan_args(argc, argv, "11", &hop, &attempt) == 1) { \
+    attempt = INT2FIX(0); \
+  }
+
+#define NUM_HOP_ATTR_FIELD_FUN(name,field)		  \
+  static VALUE sctrace_attr_hop_##name(int argc, VALUE *argv, VALUE self) \
+  { \
+    scamper_trace_t *trace; \
+    scamper_trace_hop_t *trace_hop; \
+    PROCESS_HOP_PARAMS; \
+    Data_Get_Struct(self, scamper_trace_t, trace); \
+    trace_hop = find_trace_hop(trace, NUM2INT(hop), NUM2INT(attempt));	\
+    if (!trace_hop) { \
+      return Qnil; \
+    } \
+    return UINT2NUM(trace_hop->hop_##field); \
+  }
+
+#define NUM_HOP_ATTR_FUN(name) NUM_HOP_ATTR_FIELD_FUN(name,name)
+
+#define STR_HOP_ATTR_FIELD_FUN(name,field)		  \
+  static VALUE sctrace_attr_hop_##name(int argc, VALUE *argv, VALUE self) \
+  { \
+    scamper_trace_t *trace; \
+    scamper_trace_hop_t *trace_hop; \
+    char *ptr; \
+    PROCESS_HOP_PARAMS; \
+    Data_Get_Struct(self, scamper_trace_t, trace); \
+    trace_hop = find_trace_hop(trace, NUM2INT(hop), NUM2INT(attempt));	\
+    if (!trace_hop) { \
+      return Qnil; \
+    } \
+    ptr = trace_hop->hop_##field; \
+    ptr = (ptr ? ptr : ""); \
+    return rb_str_new2(ptr); \
+  }
+
+#define STR_HOP_ATTR_FUN(name) STR_HOP_ATTR_FIELD_FUN(name,name)
+
+NUM_HOP_ATTR_FUN(flags);
+NUM_HOP_ATTR_FUN(probe_id);
+NUM_HOP_ATTR_FUN(probe_ttl);
+NUM_HOP_ATTR_FUN(reply_ttl);
+NUM_HOP_ATTR_FUN(probe_size);
+NUM_HOP_ATTR_FUN(reply_size);
+NUM_HOP_ATTR_FUN(icmp_type);
+NUM_HOP_ATTR_FUN(icmp_code);
+NUM_HOP_ATTR_FUN(tcp_flags);
+NUM_HOP_ATTR_FIELD_FUN(rtt_sec, rtt.tv_sec);
+NUM_HOP_ATTR_FIELD_FUN(rtt_usec, rtt.tv_usec);
+
+
+/*-------------------------------------------------------------------------*/
+
+#define DEF_HOP_ICMP_QUERY(name) \
+  rb_define_method(cTrace, "hop_icmp_" #name "?", sctrace_hop_icmp_##name, -1);
+
+#define HOP_ICMP_QUERY_FUN(name,macro)		  \
+  static VALUE sctrace_hop_icmp_##name(int argc, VALUE *argv, VALUE self) \
+  { \
+    scamper_trace_t *trace; \
+    scamper_trace_hop_t *trace_hop; \
+    PROCESS_HOP_PARAMS; \
+    Data_Get_Struct(self, scamper_trace_t, trace); \
+    trace_hop = find_trace_hop(trace, NUM2INT(hop), NUM2INT(attempt));	\
+    if (!trace_hop) { \
+      return Qnil; \
+    } \
+    return SCAMPER_TRACE_HOP_IS_ICMP_##macro(trace_hop) ? Qtrue : Qfalse; \
+  }
+
+HOP_ICMP_QUERY_FUN(ttl_exp, TTL_EXP);
+HOP_ICMP_QUERY_FUN(ttl_exp_trans, TTL_EXP_TRANS);
+HOP_ICMP_QUERY_FUN(packet_too_big, PACKET_TOO_BIG);
+HOP_ICMP_QUERY_FUN(unreach, UNREACH);
+HOP_ICMP_QUERY_FUN(unreach_port, UNREACH_PORT);
+HOP_ICMP_QUERY_FUN(echo_reply, ECHO_REPLY);
+
+
+/***************************************************************************/
+
+static void sctrace_free(void *data)
+{
+  if (data) {
+    scamper_trace_free((scamper_trace_t *)data);
+  }
+}
+
+static VALUE sctrace_alloc(VALUE klass)
+{
+  return Data_Wrap_Struct(klass, 0, sctrace_free, 0);
+}
+
+
+static VALUE sctrace_init(VALUE self)
+{
+  /*
+  ** Workaround for bug in scamper-cvs-20070523-p8: scamper wrote a trace
+  ** with hop_count = 5 and hops == NULL, which triggers a segfault.
+  *
+  *  Program received signal SIGSEGV, Segmentation fault.
+  *  0x283f06cc in find_trace_hop (trace=0x8635e40, hop=4, attempt=0)
+  *     at sctrace.c:109
+  *  109       trace_hop = trace->hops[hop];
+  *  (gdb) p trace
+  *  $1 = (scamper_trace_t *) 0x8635e40
+  *  (gdb) p *trace
+  * $2 = {list = 0x829f2c0, cycle = 0x829f2e0, src = 0x82a7d50, dst = 0x86c39e0,
+  * start = {tv_sec = 1189778005, tv_usec = 809855}, hops = 0x0, hop_count = 5,
+  * stop_reason = 5 '\005', stop_data = 0 '\0', type = 2 '\002', flags = 0 '\0',
+  * attempts = 3 '\003', hoplimit = 0 '\0', gaplimit = 0 '\0',
+  * firsthop = 1 '\001', tos = 0 '\0', wait = 5 '\005', loops = 1 '\001',
+  * probe_size = 44, sport = 46235, dport = 33545, tlvs = 0x0, pmtud = 0x0}
+  */
+  scamper_trace_t *trace = NULL;
+  Data_Get_Struct(self, scamper_trace_t, trace);
+  if (trace && !trace->hops) {
+    trace->hop_count = 0;
+  }
+
+  rb_ivar_set(self, iv_element_type, INT2FIX(SCAMPER_FILE_OBJ_TRACE));
+  rb_ivar_set(self, iv_dest_response, Qnil);
+  rb_ivar_set(self, iv_list, Qnil);
+  rb_ivar_set(self, iv_cycle, Qnil);
+  return self;
+}
+
+
+static VALUE sctrace_src(VALUE self)
+{
+  scamper_trace_t *trace;
+  char buf[128];
+
+  Data_Get_Struct(self, scamper_trace_t, trace);
+  return rb_str_new2(scamper_addr_tostr(trace->src, buf, 128));
+}
+
+
+static VALUE sctrace_dst(VALUE self)
+{
+  scamper_trace_t *trace;
+  char buf[128];
+
+  Data_Get_Struct(self, scamper_trace_t, trace);
+  return rb_str_new2(scamper_addr_tostr(trace->dst, buf, 128));
+}
+
+
+static VALUE sctrace_src_cmp(VALUE self, VALUE other)
+{
+  scamper_trace_t *self_trace;
+  scamper_trace_t *other_trace;
+
+  if (other == self) {
+    return INT2FIX(0);
+  }
+
+  /* See Pragmatic Programmer's book. */
+  if (TYPE(other) != T_DATA || RDATA(other)->dfree != sctrace_free) {
+    rb_raise(rb_eTypeError, "wrong argument type");
+  }
+
+  Data_Get_Struct(self, scamper_trace_t, self_trace);
+  Data_Get_Struct(other, scamper_trace_t, other_trace);
+  return INT2FIX(scamper_addr_cmp(self_trace->src, other_trace->src));
+}
+
+
+static VALUE sctrace_dst_cmp(VALUE self, VALUE other)
+{
+  scamper_trace_t *self_trace;
+  scamper_trace_t *other_trace;
+
+  if (other == self) {
+    return INT2FIX(0);
+  }
+
+  /* See Pragmatic Programmer's book. */
+  if (TYPE(other) != T_DATA || RDATA(other)->dfree != sctrace_free) {
+    rb_raise(rb_eTypeError, "wrong argument type");
+  }
+
+  Data_Get_Struct(self, scamper_trace_t, self_trace);
+  Data_Get_Struct(other, scamper_trace_t, other_trace);
+  return INT2FIX(scamper_addr_cmp(self_trace->dst, other_trace->dst));
+}
+
+
+static VALUE sctrace_write_to(VALUE self, VALUE file)
+{
+  rb_funcall(file, meth_write_trace, 1, self);
+  return self;
+}
+
+
+static VALUE sctrace_list(VALUE self)
+{
+  VALUE retval = rb_ivar_get(self, iv_list);
+  if (NIL_P(retval)) {
+    scamper_trace_t *trace;
+    Data_Get_Struct(self, scamper_trace_t, trace);
+    if (!trace->list) {  /* not sure this can ever be NULL; better safe than */
+      return Qnil;
+    }
+
+    retval = sclist_create(scamper_list_use(trace->list));
+    rb_ivar_set(self, iv_list, retval);
+  }
+  return retval;
+}
+
+
+static VALUE sctrace_cycle(VALUE self)
+{
+  VALUE retval = rb_ivar_get(self, iv_cycle);
+  if (NIL_P(retval)) {
+    scamper_trace_t *trace;
+    Data_Get_Struct(self, scamper_trace_t, trace);
+    if (!trace->cycle) { /* may be NULL if no cycle specified at scamper run */
+      return Qnil;
+    }
+
+    retval = sccycle_create(scamper_cycle_use(trace->cycle),
+			    SCAMPER_FILE_OBJ_CYCLE_DEF);
+    rb_ivar_set(self, iv_cycle, retval);
+  }
+  return retval;
+}
+
+
+static VALUE sctrace_set_cycle(VALUE self, VALUE cycle_v)
+{
+  scamper_trace_t *trace;
+  scamper_cycle_t *cycle;
+
+  Data_Get_Struct(self, scamper_trace_t, trace);
+
+  /* See Pragmatic Programmer's book. */
+  if (TYPE(cycle_v) != T_DATA || RDATA(cycle_v)->dfree != sccycle_free) {
+    rb_raise(rb_eTypeError, "wrong argument type");
+  }
+
+  Data_Get_Struct(cycle_v, scamper_cycle_t, cycle);
+
+  scamper_list_free(trace->list);
+  scamper_cycle_free(trace->cycle);
+
+  trace->list = cycle->list;
+  trace->cycle = cycle;
+
+  scamper_list_use(trace->list);
+  scamper_cycle_use(trace->cycle);
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+static VALUE sctrace_attr_hop_addr(int argc, VALUE *argv, VALUE self)
+{
+  scamper_trace_t *trace;
+  scamper_trace_hop_t *trace_hop;
+  char buf[128];
+
+  PROCESS_HOP_PARAMS;
+  Data_Get_Struct(self, scamper_trace_t, trace);
+  trace_hop = find_trace_hop(trace, NUM2INT(hop), NUM2INT(attempt));
+  if (!trace_hop) {
+    return Qnil;
+  }
+  return rb_str_new2(scamper_addr_tostr(trace_hop->hop_addr, buf, 128));
+}
+
+
+static VALUE sctrace_attr_hop_rtt(int argc, VALUE *argv, VALUE self)
+{
+  scamper_trace_t *trace;
+  scamper_trace_hop_t *trace_hop;
+
+  PROCESS_HOP_PARAMS;
+  Data_Get_Struct(self, scamper_trace_t, trace);
+  trace_hop = find_trace_hop(trace, NUM2INT(hop), NUM2INT(attempt));
+  if (!trace_hop) {
+    return Qnil;
+  }
+  return rb_float_new(1000.0 * trace_hop->hop_rtt.tv_sec
+		      + trace_hop->hop_rtt.tv_usec / 1000.0);
+}
+
+
+/* This is faster than calling sprintf("%0.3f"). */
+static VALUE sctrace_attr_hop_rtt_str(int argc, VALUE *argv, VALUE self)
+{
+  scamper_trace_t *trace;
+  scamper_trace_hop_t *trace_hop;
+  VALUE retval;
+  char buf[128];
+
+  PROCESS_HOP_PARAMS;
+  Data_Get_Struct(self, scamper_trace_t, trace);
+  trace_hop = find_trace_hop(trace, NUM2INT(hop), NUM2INT(attempt));
+  if (!trace_hop) {
+    return Qnil;
+  }
+  
+  sprintf(buf, "%d.%03d",
+	  1000 * trace_hop->hop_rtt.tv_sec + trace_hop->hop_rtt.tv_usec / 1000,
+	  trace_hop->hop_rtt.tv_usec % 1000);
+  return rb_str_new2(buf);
+}
+
+
+static VALUE sctrace_hop_exists(int argc, VALUE *argv, VALUE self)
+{
+  scamper_trace_t *trace;
+  scamper_trace_hop_t *trace_hop;
+
+  PROCESS_HOP_PARAMS;
+  Data_Get_Struct(self, scamper_trace_t, trace);
+  trace_hop = find_trace_hop(trace, NUM2INT(hop), NUM2INT(attempt));
+  return (trace_hop ? Qtrue : Qfalse);
+}
+
+
+static VALUE sctrace_each_hop(VALUE self)
+{
+  scamper_trace_t *trace;
+  scamper_trace_hop_t *trace_hop;
+  VALUE yield_args;
+  int hop;
+
+  Data_Get_Struct(self, scamper_trace_t, trace);
+
+  if (trace->hop_count == 0) {
+    return self;
+  }
+
+  yield_args = rb_ary_new();
+  for (hop = 0; hop < trace->hop_count; hop++) {
+    trace_hop = find_trace_hop(trace, hop, 0);
+
+    rb_ary_store(yield_args, 0, INT2FIX(hop));
+    rb_ary_store(yield_args, 1, (trace_hop ? Qtrue : Qfalse));
+    rb_yield(yield_args);
+  }
+
+  return self;
+}
+
+
+static VALUE sctrace_each_attempt(VALUE self, VALUE hop)
+{
+  scamper_trace_t *trace;
+  scamper_trace_hop_t *trace_hop;
+
+  Data_Get_Struct(self, scamper_trace_t, trace);
+
+  trace_hop = find_trace_hop(trace, NUM2INT(hop), 0);
+  if (trace_hop) {
+    int attempt = 0;
+    rb_yield(INT2FIX(0));
+    while (trace_hop = trace_hop->hop_next) {
+      rb_yield(INT2FIX(++attempt));
+    }
+  }
+
+  return self;
+}
+
+
+static VALUE sctrace_each_hop_and_attempt(VALUE self)
+{
+  scamper_trace_t *trace;
+  scamper_trace_hop_t *trace_hop;
+  VALUE yield_args;
+  int hop;
+
+  Data_Get_Struct(self, scamper_trace_t, trace);
+
+  yield_args = rb_ary_new();
+  for (hop = 0; hop < trace->hop_count; hop++) {
+    int attempt = 0;
+    trace_hop = find_trace_hop(trace, hop, 0);
+
+    rb_ary_store(yield_args, 0, INT2FIX(hop));
+    rb_ary_store(yield_args, 1, INT2FIX(0));
+    rb_ary_store(yield_args, 2, (trace_hop ? Qtrue : Qfalse));
+    rb_yield(yield_args);
+
+    if (trace_hop) {
+      rb_ary_store(yield_args, 2, Qtrue);
+      while (trace_hop = trace_hop->hop_next) {
+	rb_ary_store(yield_args, 1, INT2FIX(++attempt));
+	rb_yield(yield_args);
+      }
+    }
+  }
+
+  return self;
+}
+
+
+/*
+** Whether the given hop represents a response from the destination.
+**
+** Note that there can be more than one response from the destination
+** in a given trace.
+**
+** For compatibility, the code of this function is based on
+** scamper-cvs-20070523h:sc_analysis_dump.c:print_trace().  Therefore,
+** under the strictest interpretation of copyright, the following code
+** is licensed under GPLv2 (no later), the license of scamper itself.
+*/
+static int hop_is_dest_response(scamper_trace_t *trace,
+				scamper_trace_hop_t *trace_hop)
+{
+  if (trace->hop_count > 0 && trace->stop_reason != SCAMPER_TRACE_STOP_ERROR) {
+    if (SCAMPER_TRACE_HOP_IS_ICMP_UNREACH_PORT(trace_hop)) {
+      if (trace->type == SCAMPER_TRACE_TYPE_UDP
+	  || trace->type == SCAMPER_TRACE_TYPE_UDP_PARIS
+	  || trace->type == SCAMPER_TRACE_TYPE_TCP) {
+	return 1;
+      }
+    }
+
+    if (SCAMPER_TRACE_HOP_IS_ICMP_ECHO_REPLY(trace_hop)) {
+      if (trace->type == SCAMPER_TRACE_TYPE_ICMP_ECHO
+	  || trace->type == SCAMPER_TRACE_TYPE_ICMP_ECHO_PARIS) {
+	return 1;
+      }
+    }
+
+    if ((trace_hop->hop_flags & SCAMPER_TRACE_HOP_FLAG_TCP) != 0 &&
+	trace->type == SCAMPER_TRACE_TYPE_TCP) {
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+
+static VALUE sctrace_hop_dest_response(int argc, VALUE *argv, VALUE self)
+{
+  scamper_trace_t *trace;
+  scamper_trace_hop_t *trace_hop;
+
+  PROCESS_HOP_PARAMS;
+  Data_Get_Struct(self, scamper_trace_t, trace);
+  trace_hop = find_trace_hop(trace, NUM2INT(hop), NUM2INT(attempt));
+  if (!trace_hop) {
+    return Qnil;
+  }
+  return hop_is_dest_response(trace, trace_hop) ? Qtrue : Qfalse;
+}
+
+
+/*
+** NOTE: This uses the same algorithm as sc_analysis_dump for compatibility.
+**       Specifically, it examines the hops in reverse order by hop number
+**       and thus picks out the last response from the destination.
+**       (Yes, there are traces with multiple responses from the destination
+**       at different hop distances.)
+*/
+static VALUE sctrace_find_dest_response(VALUE self)
+{
+  scamper_trace_t *trace;
+  scamper_trace_hop_t *trace_hop;
+  int hop, attempt;
+  VALUE retval;
+
+  retval = rb_ivar_get(self, iv_dest_response);
+  if (!NIL_P(retval)) {
+    return (RARRAY(retval)->len == 0 ? Qnil : retval);
+  }
+
+  retval = rb_ary_new();
+  retval = rb_ivar_set(self, iv_dest_response, retval);
+
+  Data_Get_Struct(self, scamper_trace_t, trace);
+
+  /* sc_analysis_dump checks stop_reason like this, though I don't know why. */
+  if (trace->hop_count == 0
+      || trace->stop_reason == SCAMPER_TRACE_STOP_ERROR) {
+    return Qnil;
+  }
+
+  for (hop = trace->hop_count - 1; hop >= 0; hop--) {
+    attempt = 0;
+    trace_hop = find_trace_hop(trace, hop, 0);
+    while (trace_hop) {
+      if (hop_is_dest_response(trace, trace_hop)) {
+	rb_ary_push(retval, INT2FIX(hop));
+	rb_ary_push(retval, INT2FIX(attempt));
+	return retval;
+      }
+
+      ++attempt;
+      trace_hop = trace_hop->hop_next;
+    }
+  }
+
+  return Qnil;
+}
+
+
+static VALUE sctrace_dest_rtt(VALUE self)
+{
+  scamper_trace_t *trace;
+  scamper_trace_hop_t *trace_hop;
+  VALUE dest_response;
+  int hop, attempt;
+
+  dest_response = sctrace_find_dest_response(self);
+  if (NIL_P(dest_response)) {
+    return Qnil;
+  }
+
+  hop = FIX2INT(rb_ary_entry(dest_response, 0));
+  attempt = FIX2INT(rb_ary_entry(dest_response, 1));
+
+  Data_Get_Struct(self, scamper_trace_t, trace);
+  trace_hop = find_trace_hop(trace, hop, attempt);
+  return rb_float_new(1000.0 * trace_hop->hop_rtt.tv_sec
+		      + trace_hop->hop_rtt.tv_usec / 1000.0);
+}
+
+
+/* This is faster than calling sprintf("%0.3f"). */
+static VALUE sctrace_dest_rtt_str(VALUE self)
+{
+  scamper_trace_t *trace;
+  scamper_trace_hop_t *trace_hop;
+  VALUE dest_response;
+  char buf[128];
+  int hop, attempt;
+
+  dest_response = sctrace_find_dest_response(self);
+  if (NIL_P(dest_response)) {
+    return Qnil;
+  }
+
+  hop = FIX2INT(rb_ary_entry(dest_response, 0));
+  attempt = FIX2INT(rb_ary_entry(dest_response, 1));
+
+  Data_Get_Struct(self, scamper_trace_t, trace);
+  trace_hop = find_trace_hop(trace, hop, attempt);
+
+  sprintf(buf, "%d.%03d",
+	  1000 * trace_hop->hop_rtt.tv_sec + trace_hop->hop_rtt.tv_usec / 1000,
+	  trace_hop->hop_rtt.tv_usec % 1000);
+  return rb_str_new2(buf);
+}
+
+
+/* NOTE: This uses the same algorithm as sc_analysis_dump for compatibility. */
+static VALUE sctrace_complete(VALUE self)
+{
+  scamper_trace_t *trace;
+  scamper_trace_hop_t *trace_hop;
+  VALUE dest_response;
+  int dest_hop;
+  int hop, attempt;
+
+  dest_response = sctrace_find_dest_response(self);
+  if (NIL_P(dest_response)) {
+    return Qfalse;
+  }
+  dest_hop = FIX2INT(rb_ary_entry(dest_response, 0));
+
+  Data_Get_Struct(self, scamper_trace_t, trace);
+
+  for (hop = 0; hop < trace->hop_count && hop < dest_hop; hop++) {
+    if (!find_trace_hop(trace, hop, 0)) {
+      return Qfalse;
+    }
+  }
+  return hop == dest_hop ? Qtrue : Qfalse;
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+VALUE sctrace_create(scamper_trace_t *trace)
+{
+  VALUE obj = Data_Wrap_Struct(cTrace, 0, sctrace_free, trace);
+
+  if (NIL_P(sctrace_init(obj))) {
+   return Qnil;
+  }
+
+  return obj;
+}
+
+
+/***************************************************************************/
+/***************************************************************************/
+
+void Init_sctrace(void)
+{
+  ID private_class_method_ID, private_ID;
+  ID new_ID, dup_ID, clone_ID;
+
+  iv_element_type = rb_intern("@element_type");
+  iv_dest_response = rb_intern("@dest_response");
+  iv_list = rb_intern("@list");
+  iv_cycle = rb_intern("@cycle");
+  meth_write_trace = rb_intern("write_trace");
+
+  cTrace = rb_define_class_under(mWarts, "Trace", rb_cObject);
+
+  DEF_CONST(STOP_NONE);
+  DEF_CONST(STOP_COMPLETED);
+  DEF_CONST(STOP_UNREACH);
+  DEF_CONST(STOP_ICMP);
+  DEF_CONST(STOP_LOOP);
+  DEF_CONST(STOP_DEAD);
+  DEF_CONST(STOP_ERROR);
+#ifdef SCAMPER_TRACE_STOP_HOPLIMIT  /* scamper-cvs-20070523 */
+  DEF_CONST(STOP_HOPLIMIT);
+#endif
+
+  DEF_CONST(FLAG_ALLATTEMPTS);
+  DEF_CONST(FLAG_PMTUD);
+  DEF_CONST(FLAG_DL);
+
+  DEF_CONST(TYPE_ICMP_ECHO);
+  DEF_CONST(TYPE_UDP);
+  DEF_CONST(TYPE_TCP);
+  DEF_CONST(TYPE_ICMP_ECHO_PARIS);
+  DEF_CONST(TYPE_UDP_PARIS);
+
+  DEF_CONST(HOP_FLAG_TS_SOCK_RX);
+  DEF_CONST(HOP_FLAG_TS_DL_TX);
+  DEF_CONST(HOP_FLAG_TS_DL_RX);
+  DEF_CONST(HOP_FLAG_TS_TSC);
+  DEF_CONST(HOP_FLAG_REPLY_TTL);
+
+  DEF_ATTR(list_id);
+  DEF_ATTR(list_name);
+  DEF_ATTR(list_descr);
+  DEF_ATTR(list_monitor);
+
+  DEF_ATTR(cycle_id);
+  DEF_ATTR(cycle_start_time);
+  DEF_ATTR(cycle_stop_time);
+  DEF_ATTR(cycle_hostname);
+
+  DEF_ATTR(start);
+  DEF_ATTR(start_usec);
+
+  DEF_ATTR(hop_count);
+  DEF_ATTR(stop_reason);
+  DEF_ATTR(stop_data);
+  DEF_ATTR(type);
+  DEF_ATTR(flags);
+  DEF_ATTR(attempts);
+  DEF_ATTR(hoplimit);
+  DEF_ATTR(gaplimit);
+  DEF_ATTR(firsthop);
+  DEF_ATTR(tos);
+  DEF_ATTR(wait);
+  DEF_ATTR(loops);
+  DEF_ATTR(probe_size);
+  DEF_ATTR(sport);
+  DEF_ATTR(dport);
+
+  DEF_HOP_ATTR(hop_addr);
+  DEF_HOP_ATTR(hop_flags);
+  DEF_HOP_ATTR(hop_probe_id);
+  DEF_HOP_ATTR(hop_probe_ttl);
+  DEF_HOP_ATTR(hop_reply_ttl);
+  DEF_HOP_ATTR(hop_probe_size);
+  DEF_HOP_ATTR(hop_reply_size);
+  DEF_HOP_ATTR(hop_icmp_type);
+  DEF_HOP_ATTR(hop_icmp_code);
+  DEF_HOP_ATTR(hop_tcp_flags);
+  DEF_HOP_ATTR(hop_rtt);
+  DEF_HOP_ATTR(hop_rtt_str);
+  DEF_HOP_ATTR(hop_rtt_sec);
+  DEF_HOP_ATTR(hop_rtt_usec);
+
+  rb_define_alloc_func(cTrace, sctrace_alloc);
+
+  rb_define_attr(cTrace, "element_type", 1, 0);
+
+  rb_define_method(cTrace, "initialize", sctrace_init, 0);
+  rb_define_method(cTrace, "src", sctrace_src, 0);
+  rb_define_method(cTrace, "dst", sctrace_dst, 0);
+  rb_define_method(cTrace, "src_cmp", sctrace_src_cmp, 1);
+  rb_define_method(cTrace, "dst_cmp", sctrace_dst_cmp, 1);
+  rb_define_method(cTrace, "write_to", sctrace_write_to, 1);
+  rb_define_method(cTrace, "list", sctrace_list, 0);
+  rb_define_method(cTrace, "cycle", sctrace_cycle, 0);
+  rb_define_method(cTrace, "cycle=", sctrace_set_cycle, 1);
+  rb_define_method(cTrace, "hop_exists?", sctrace_hop_exists, -1);
+  rb_define_method(cTrace, "hop_dest_response?", sctrace_hop_dest_response,-1);
+  rb_define_method(cTrace, "find_dest_response", sctrace_find_dest_response,0);
+  rb_define_method(cTrace, "complete?", sctrace_complete, 0);
+  rb_define_method(cTrace, "dest_rtt", sctrace_dest_rtt, 0);
+  rb_define_method(cTrace, "dest_rtt_str", sctrace_dest_rtt_str, 0);
+  rb_define_method(cTrace, "each_hop", sctrace_each_hop, 0);
+  rb_define_method(cTrace, "each_attempt", sctrace_each_attempt, 1);
+  rb_define_method(cTrace, "each_hop_and_attempt",
+		   sctrace_each_hop_and_attempt, 0);
+
+  rb_define_alias(cTrace, "dest_responded?", "find_dest_response");
+  rb_define_alias(cTrace, "each", "each_hop_and_attempt");
+
+  DEF_HOP_ICMP_QUERY(ttl_exp);
+  DEF_HOP_ICMP_QUERY(ttl_exp_trans);
+  DEF_HOP_ICMP_QUERY(packet_too_big);
+  DEF_HOP_ICMP_QUERY(unreach);
+  DEF_HOP_ICMP_QUERY(unreach_port);
+  DEF_HOP_ICMP_QUERY(echo_reply);
+
+  private_class_method_ID = rb_intern("private_class_method");
+  private_ID = rb_intern("private");
+  new_ID = rb_intern("new");
+  dup_ID = rb_intern("dup");
+  clone_ID = rb_intern("clone");
+
+  rb_funcall(cTrace, private_class_method_ID, 1, ID2SYM(new_ID));
+  rb_funcall(cTrace, private_ID, 1, ID2SYM(dup_ID));
+  rb_funcall(cTrace, private_ID, 1, ID2SYM(clone_ID));
+}