Changeset 2006

Timestamp:

04/30/08 21:46:55 (7 months ago)

Author:

aturner

Message:

merge features/performance -r1879:2005 to trunk. and cleanup. refs #41

Location:

trunk

Files:

• configure.ac (modified) (4 diffs)
• src/Makefile.am (modified) (3 diffs)
• src/common.h (modified) (1 diff)
• src/common/Makefile.am (modified) (2 diffs)
• src/common/rdtsc.c (copied) (copied from features/performance/src/common/rdtsc.c)
• src/common/rdtsc.h (copied) (copied from features/performance/src/common/rdtsc.h)
• src/common/timer.c (modified) (1 diff)
• src/common/timer.h (modified) (7 diffs)
• src/defines.h.in (modified) (2 diffs)
• src/send_packets.c (modified) (17 diffs)
• src/sleep.c (copied) (copied from features/performance/src/sleep.c) (3 diffs)
• src/sleep.h (copied) (copied from features/performance/src/sleep.h)
• src/tcpprep.c (modified) (1 diff)
• src/tcpreplay.c (modified) (5 diffs)
• src/tcpreplay.h (modified) (5 diffs)
• src/tcpreplay_opts.def (modified) (5 diffs)

trunk/configure.ac

@@ -68 +68 @@
         AUTOGEN_MAJOR=`echo ${AUTOGEN_VERSION} | ${SED} 's|^\([[0-9]]\)\.[[0-9]]|\1|'`
         AUTOGEN_MINOR=`echo ${AUTOGEN_VERSION} | ${SED} 's|^\([[0-9]]\)\.\([[0-9]]\)|\2|'`
-        if test ((${AUTOGEN_MAJOR} -eq 5 && ${AUTOGEN_MINOR} -lt 9) || ${AUTOGEN_MAJOR} -lt 5) ; then
+        if ( ${AUTOGEN_MAJOR} -eq 5 && ${AUTOGEN_MINOR} -lt 9 ) || ${AUTOGEN_MAJOR} -lt 5 ; then
                 AC_MSG_RESULT(no)
                 AC_MSG_WARN([${AUTOGEN} is too old (${AUTOGEN_VERSION}) for building from SVN.  Please upgrade to 5.9)])
@@ -1085 +1085 @@
 disable_pcap_findalldevs=no
 
-
+osx_frameworks=no
 dnl these need to be dynamic based on OS
 case $host in
@@ -1112 +1112 @@
         disable_pcap_findalldevs=yes
     fi
+    AC_DEFINE([HAVE_ABSOLUTE_TIME], [1], [Have OS X UpTime()/AbsoluteTime high-precision timing])
+    osx_frameworks=yes
         AC_MSG_RESULT(Apple OS X)
         ;;
@@ -1134 +1136 @@
 esac])
 
+AM_CONDITIONAL([ENABLE_OSX_FRAMEWORKS], test "$osx_frameworks" == "yes")
 
 AC_ARG_WITH(testnic2,

trunk/src/Makefile.am

@@ -60 +60 @@
 
 tcpreplay_LDADD += ./common/libcommon.a $(LIBSTRL) @LNETLIB@ @LPCAPLIB@ $(LIBOPTS_LDADD)
-tcpreplay_SOURCES += send_packets.c signal_handler.c tcpreplay.c
+tcpreplay_SOURCES += send_packets.c signal_handler.c tcpreplay.c sleep.c
+
+if ENABLE_OSX_FRAMEWORKS
+tcpreplay_LDFLAGS = -framework CoreServices -framework Carbon
+endif
 
 tcpreplay_OBJECTS: tcpreplay_opts.h
@@ -94 +98 @@
 tcpbridge_LDADD = ./tcpedit/libtcpedit.a ./common/libcommon.a \
     $(LIBSTRL) @LNETLIB@ @LPCAPLIB@ $(LIBOPTS_LDADD) @DMALLOC_LIB@
-tcpbridge_SOURCES = tcpbridge_opts.c tcpbridge.c bridge.c send_packets.c                
+if ENABLE_OSX_FRAMEWORKS
+tcpbridge_LDFLAGS = -framework CoreServices -framework Carbon
+endif
+tcpbridge_SOURCES = tcpbridge_opts.c tcpbridge.c bridge.c send_packets.c sleep.c
 tcpbridge_OBJECTS: tcpbridge_opts.h
 tcpbridge_opts.h: tcpbridge_opts.c
@@ -104 +111 @@
                  tcpreplay_edit_opts.h tcprewrite.h tcprewrite_opts.h tcpprep_opts.h \
                  tcpprep_opts.def tcprewrite_opts.def tcpreplay_opts.def \
-                 tcpbridge_opts.def tcpbridge.h tcpbridge_opts.h tcpr.h
+                 tcpbridge_opts.def tcpbridge.h tcpbridge_opts.h tcpr.h sleep.h
 
 

trunk/src/common.h

@@ -16 +16 @@
 #include "common/utils.h"
 #include "common/xX.h"
+#include "common/rdtsc.h"
 #include "common/tcpdump.h"
 #include "common/timer.h"

trunk/src/common/Makefile.am

@@ -15 +15 @@
                       fakepcap.c fakepcapnav.c fakepoll.c xX.c utils.c \
                       timer.c svn_version.c abort.c sendpacket.c \
-                          dlt_names.c mac.c interface.c
+                          dlt_names.c mac.c interface.c rdtsc.c
 
 if ENABLE_TCPDUMP
@@ -28 +28 @@
                  fakepcap.h fakepcapnav.h fakepoll.h xX.h utils.h \
                  tcpdump.h timer.h abort.h pcap_dlt.h sendpacket.h \
-                 dlt_names.h mac.h interface.h
+                 dlt_names.h mac.h interface.h rdtsc.h
 
 MOSTLYCLEANFILES = *~

trunk/src/common/timer.c

@@ -57 +57 @@
 }
 
-/*
- * converts a float to a timeval structure
- * converted to a #define
-void
-float2timer(float time, struct timeval *tvp)
+/* Divide tvs by div, storing the result in tvs */
+void timesdiv(struct timespec *tvs, float div)
 {
-    float n;
+    double interval;
+    
+    if (div == 0 || div == 1)
+        return;
+        
+    interval = ((double)tvs->tv_sec * 1000000000 + tvs->tv_nsec) / (double)div;
+    tvs->tv_sec = interval / (int)1000000000;
+    tvs->tv_nsec = interval - (tvs->tv_nsec * 1000000000);
+}
 
-    n = time;
-
-    tvp->tv_sec = n;
-
-    n -= tvp->tv_sec;
-    tvp->tv_usec = n * 100000;
-
-}
- */

trunk/src/common/timer.h

@@ -43 +43 @@
 #include <math.h>
 
+#ifdef HAVE_ABSOLUTE_TIME
+#include <CoreServices/CoreServices.h>
+#endif
+
+/* AbsoluteTime methods */
+#ifndef NonZero
+#define NonZero(x) ((x).hi | (x).lo)
+#endif
+#ifndef SetZero
+#define SetZero(x) do { (x).hi = 0 ; (x).lo = 0; } while(0)
+#endif
+#ifndef CopyAbsolute
+#define CopyAbsolute(x, y) do { (x).lo = (y).lo ; (x).hi = (y).hi; } while (0)
+#endif
+#ifndef AbsoluteCmp
+#define AbsoluteCmp(left, right, cmp)       \
+        (((left)->hi == (right)->hi) ?              \
+        ((left)->lo cmp (right)->lo) :              \
+        ((left)->hi cmp (right)->hi))
+#endif
+
 /*
- * 1 sec = 1,000,000 microsec
+ * 1 sec = 1,0000 millisec (ms)
+ * 1 sec = 1,000,000 microsec (us)
+ * 1 sec = 1,000,000,000 nanosec (ns)
+ * 1 millisec = 1,000 microsec
  * 1 microsec = 1,000 nanosec
- * 1 sec = 1,000,000,000 nanosec
  */
 
 void timerdiv(struct timeval *tvp, float div);
+void timesdiv(struct timespec *tvs, float div);
 
 /* convert float time to struct timeval *tvp */
@@ -57 +81 @@
         tvp->tv_sec = time;                     \
         tvp->tv_usec = (time - tvp->tv_sec) * 100000; \
-    } while (0);
+    } while (0)
 #endif
 
@@ -67 +91 @@
 #endif
 
+#ifndef TIMESPEC_TO_TIMEVAL
+#define TIMESPEC_TO_TIMEVAL(tv, ts) {           \
+    (tv)->tv_sec = (ts)->tv_sec;                \
+    (tv)->tv_usec = (ts)->tv_nsec / 1000; }
+#endif
+
+#ifndef ROUND_TIMESPEC_TO_MICROSEC
+#define ROUND_TIMESPEC_TO_MICROSEC(ts)      \
+    do {                                    \
+        (ts)->tv_nsec = ((((ts)->tv_nsec / 1000) + ((ts)->tv_nsec % 1000 >= 500 ? 1 : 0)) * 1000);   \
+    } while (0)
+#endif
+
+
+
 /* zero out a timer */
 #ifndef timerclear
@@ -72 +111 @@
 #endif
 
+/* zero out a timespec */
+#ifndef timesclear
+#define timesclear(tvs)     (tvs)->tv_sec = (tvs)->tv_nsec = 0
+#endif
+
 /* is timer non-zero? */
 #ifndef timerisset
 #define timerisset(tvp)         ((tvp)->tv_sec || (tvp)->tv_usec)
 #endif
+
+/* is timespec non-zero? */
+#ifndef timesisset
+#define timesisset(tvs)         ((tvs)->tv_sec || (tvs)->tv_nsec)
+#endif
+
 
 /* add tvp and uvp and store in vvp */
@@ -103 +153 @@
 #endif
 
+#ifndef timessub
+#define timessub(tsp, usp, vsp)                                 \
+        do {                                                                    \
+                (vsp)->tv_sec = (tsp)->tv_sec - (usp)->tv_sec;          \
+                (vsp)->tv_nsec = (tsp)->tv_nsec - (usp)->tv_nsec;       \
+                if ((vsp)->tv_nsec < 0) {                               \
+                        (vsp)->tv_sec--;                                    \
+                        (vsp)->tv_nsec += 1000000000;           \
+                }                                                                   \
+        } while (0)
+#endif
+
 /* compare tvp and uvp using cmp */
 #ifndef timercmp
@@ -109 +171 @@
         ((tvp)->tv_usec cmp (uvp)->tv_usec) :           \
         ((tvp)->tv_sec cmp (uvp)->tv_sec))
+#endif
+
+#ifndef timescmp
+#define timescmp(tsp, usp, cmp)                             \
+        (((tsp)->tv_sec == (usp)->tv_sec) ?                 \
+        ((tsp)->tv_nsec cmp (usp)->tv_nsec) :           \
+        ((tsp)->tv_sec cmp (usp)->tv_sec))
 #endif
 
@@ -122 +191 @@
         } while(0)
 
-
-/* device tvp by x.  store in tvp */
-#define timerdiv2(tvp, x)                                               \
-        do {                                                                    \
-                (tvp)->tv_sec = (tvp)->tv_sec / x;              \
-                (tvp)->tv_usec = (tvp)->tv_usec / x;    \
-        } while(0)
-
-#endif
-
+#ifdef HAVE_ABSOLUTE_TIME
+    typedef AbsoluteTime delta_t;
+#else
+    typedef struct timeval delta_t;
+#endif
+
+/*
+ * starts a timer so we can figure out how much time has passed
+ * when we call get_delta_timer()
+ */
+static inline void
+start_delta_time(delta_t *ctx)
+{
+#ifdef HAVE_ABSOLUTE_TIME
+    *ctx = UpTime();
+#else
+    gettimeofday(ctx, NULL);
+#endif
+}
+
+/* 
+ * returns the amount of time that has passed since the 
+ * last time you called start_delta_time()
+ */
+static inline void
+get_delta_time(delta_t *ctx, struct timespec *ret)
+{
+/* OS X has absolute time */
+#ifdef HAVE_ABSOLUTE_TIME
+    AbsoluteTime now, delta;
+    Nanoseconds nano;
+    
+    now = UpTime();
+    
+    if (! NonZero(*ctx)) {
+        timesclear(ret);
+    } else {
+        delta = SubAbsoluteFromAbsolute(now, *ctx);
+        nano = AbsoluteToNanoseconds(delta);
+        NANOSEC_TO_TIMESPEC(UnsignedWideToUInt64(nano) / 10, ret);
+    }
+    
+/* Everyone else just uses gettimeofday */
+#else
+    struct timeval now, delta;
+    
+    gettimeofday(&now, NULL);
+
+    if (!timerisset(ctx)) {
+        timesclear(ret);
+    } else {
+        timersub(&now, ctx, &delta);
+        TIMEVAL_TO_TIMESPEC(&delta, ret);
+    }
+#endif
+}
+
+#endif /* _TIMER_H_ */

trunk/src/defines.h.in

@@ -162 +162 @@
 
 /* struct timeval print structs */
-#define TIMEVAL_FORMAT "%lu.%06lu"
+#define TIMEVAL_FORMAT "%lus %luusec"
+#define TIMESPEC_FORMAT "%lus %lunsec"
 
 /* force a word or half-word swap on both Big and Little endian systems */
@@ -232 +233 @@
 
 
+/* Time converters */
+#define SEC_TO_MILLISEC(x) (x * 1000)
+#define SEC_TO_MICROSEC(x) (x * 1000000)
+#define SEC_TO_NANOSEC(x)  ((u_int64_t)x * 1000000000)
+
+#define MILLISEC_TO_SEC(x) (x / 1000)
+#define MICROSEC_TO_SEC(x) (x / 1000000)
+#define NANOSEC_TO_SEC(x)  ((u_int64_t)x / 1000000000)
+
+#define TIMEVAL_TO_MILLISEC(x)  (((x)->tv_sec * 1000) + ((x)->tv_usec / 1000))
+#define TIMEVAL_TO_MICROSEC(x)  (((x)->tv_sec * 1000000) + (x)->tv_usec)
+#define TIMEVAL_TO_NANOSEC(x)   ((u_int64_t)((x)->tv_sec * 1000000000) + ((u_int64_t)(x)->tv_usec * 1000))
+
+#define MILLISEC_TO_TIMEVAL(x, tv)          \
+    do {                                    \
+        (tv)->tv_sec = (x) / 1000;          \
+        (tv)->tv_usec = (x * 1000) - ((tv)->tv_sec * 1000000);   \
+    } while(0)
+    
+#define MICROSEC_TO_TIMEVAL(x, tv)          \
+    do {                                    \
+        (tv)->tv_sec = (x) / 1000000;       \
+        (tv)->tv_usec = (x) - ((tv)->tv_sec * 1000000);   \
+    } while(0)
+
+#define NANOSEC_TO_TIMEVAL(x, tv)           \
+    do {                                    \
+        (tv)->tv_sec =  (x) / 1000000000;   \
+        (tv)->tv_usec = ((x) % 1000000000) / 1000);   \
+    } while(0)
+
+#define NANOSEC_TO_TIMESPEC(x, ts)          \
+    do {                                    \
+        (ts)->tv_sec = (x) / 1000000000;    \
+        (ts)->tv_nsec = (x) % 1000000000;   \
+    } while(0)
+
+#define TIMESPEC_TO_MILLISEC(x)  (((x)->tv_sec * 1000) + ((x)->tv_nsec / 1000000))
+#define TIMESPEC_TO_MICROSEC(x)  (((x)->tv_sec * 1000000) + (x)->tv_nsec / 1000)
+#define TIMESPEC_TO_NANOSEC(x) ((u_int64_t)((x)->tv_sec * 1000000000) + ((u_int64_t)(x)->tv_nsec))
+
 #endif /* DEFINES */

trunk/src/send_packets.c

@@ -2 +2 @@
 
 /*
- * Copyright (c) 2001-2007 Aaron Turner.
+ * Copyright (c) 2001-2008 Aaron Turner.
  * All rights reserved.
  *
@@ -31 +31 @@
  */
 
+#define ADJUSTER_OFFSET 5 /* number of usec to compensate for packet timing */
 
 #include "config.h"
@@ -59 +60 @@
 
 #include "send_packets.h"
+#include "sleep.h"
 
 extern tcpreplay_opt_t options;
@@ -69 +71 @@
 #endif
 
-static void do_sleep(struct timeval *time, struct timeval *last, int len, int accurate, 
-    sendpacket_t *sp, COUNTER counter);
-static u_int32_t sleep_loop(struct timeval time);
-static u_char *get_next_packet(pcap_t *pcap, struct pcap_pkthdr *pkthdr, int file_idx, packet_cache_t **prev_packet);
+static void do_sleep(struct timeval *time, struct timeval *last, int len, 
+    int accurate, sendpacket_t *sp, COUNTER counter, delta_t *ctx);
+static const u_char *get_next_packet(pcap_t *pcap, struct pcap_pkthdr *pkthdr, 
+    int file_idx, packet_cache_t **prev_packet);
+static u_int32_t get_user_count(sendpacket_t *sp, COUNTER counter);
 
 /**
@@ -92 +95 @@
     struct pcap_pkthdr *pkthdr_ptr;
 #endif
-
+    delta_t delta_ctx;
+    
     /* register signals */
     didsig = 0;
@@ -160 +164 @@
         /*
          * we have to cast the ts, since OpenBSD sucks
-         * had to be special and use bpf_timeval 
+         * had to be special and use bpf_timeval.
+         * Only sleep if we're not in top speed mode (-t)
          */
-        do_sleep((struct timeval *)&pkthdr.ts, &last, pktlen, options.accurate, sp, packetnum);
-            
+        if (options.speed.mode != SPEED_TOPSPEED)
+            do_sleep((struct timeval *)&pkthdr.ts, &last, pktlen, options.accurate, sp, packetnum, &delta_ctx);
+        
+        /* mark the time when we send the packet */
+        start_delta_time(&delta_ctx);
+        
         /* write packet out on network */
         if (sendpacket(sp, pktdata, pktlen) < (int)pktlen)
             warnx("Unable to send packet: %s", sendpacket_geterr(sp));
-                
+
         /* 
          * track the time of the "last packet sent".  Again, because of OpenBSD
@@ -194 +203 @@
  * will be updated as new entries are added (or retrieved) from the cache list.
  */
-static u_char *
+static const u_char *
 get_next_packet(pcap_t *pcap, struct pcap_pkthdr *pkthdr, int file_idx, 
     packet_cache_t **prev_packet)
@@ -233 +242 @@
                          * We should read the pcap file, and cache the results
                          */
-                        pktdata = pcap_next(pcap, pkthdr);
+                        pktdata = (u_char *)pcap_next(pcap, pkthdr);
                         if (pktdata != NULL) {
                                 if (*prev_packet == NULL) {
@@ -263 +272 @@
                  * Read pcap file as normal
                  */
-                pktdata = pcap_next(pcap, pkthdr);
+                pktdata = (u_char *)pcap_next(pcap, pkthdr);
         }
 
+    /* this get's casted to a const on the way out */
         return pktdata;
 }
@@ -310 +320 @@
  */
 static void
-do_sleep(struct timeval *time, struct timeval *last, int len, int accurate, sendpacket_t *sp,
-    COUNTER counter)
+do_sleep(struct timeval *time, struct timeval *last, int len, int accurate, 
+    sendpacket_t *sp, COUNTER counter, delta_t *delta_ctx)
 {
     static struct timeval didsleep = { 0, 0 };
@@ -318 +328 @@
     static struct timeval totalsleep = { 0, 0 };
 #endif
-    struct timeval nap, now, delta;
-    struct timespec ignore, sleep;
+    struct timespec adjuster = { 0, 0 };
+    static struct timespec nap = { 0, 0 }, delta_time = {0, 0};
+    struct timeval nap_for, now, sleep_until;
+    struct timespec nap_this_time;
+    static int32_t nsec_adjuster = -1, nsec_times = -1;
     float n;
-    struct pollfd poller[1];        /* use poll to read from the keyboard */
-    char input[EBUF_SIZE];
-    static u_int32_t send = 0;      /* remember # of packets to send btw calls */
-    u_int32_t loop;
-
-    /* just return if topspeed */
-    if (options.speed.mode == SPEED_TOPSPEED)
+    static u_int32_t send = 0;      /* accellerator.   # of packets to send w/o sleeping */
+    u_int64_t ppnsec; /* packets per usec */
+
+
+#ifdef TCPREPLAY
+    adjuster.tv_nsec = OPT_VALUE_SLEEP_ACCEL * 1000;
+    dbgx(2, "Adjuster: " TIMEVAL_FORMAT, adjuster.tv_sec, adjuster.tv_nsec);
+#else
+    adjuster.tv_nsec = 0;
+#endif
+    
+    /* acclerator time? */
+    if (send > 0) {
+        send --;
         return;
-
-    dbgx(3, "Last time: " TIMEVAL_FORMAT, last->tv_sec, last->tv_usec);
-
-    if (gettimeofday(&now, NULL) < 0) {
+    }
+        
+    dbgx(4, "Last time: " TIMEVAL_FORMAT, last->tv_sec, last->tv_usec);
+
+    if (gettimeofday(&now, NULL) < 0)
         errx(1, "Error gettimeofday: %s", strerror(errno));
-    }
-
-    dbgx(3, "Now time: " TIMEVAL_FORMAT, now.tv_sec, now.tv_usec);
+
+    dbgx(4, "Now time: " TIMEVAL_FORMAT, now.tv_sec, now.tv_usec);
 
     /* First time through for this file */
     if (pkts_sent == 0 || ((options.speed.mode != SPEED_MBPSRATE) && (counter == 0))) {
         start = now;
-        timerclear(&delta);
+        timerclear(&sleep_until);
         timerclear(&didsleep);
     }
     else {
-        timersub(&now, &start, &delta);
+        timersub(&now, &start, &sleep_until);
     }
 
     switch(options.speed.mode) {
+    /* 
+     * If top speed, you shouldn't even be here, but handle it anyways
+     */
+    case SPEED_TOPSPEED:
+        notice("you shouldn't call do_sleep() in top speed mode.");
+        return;
+        break;
+        
     case SPEED_MULTIPLIER:
         /* 
@@ -354 +382 @@
          */
         if (timerisset(last) && timercmp(time, last, >)) {
-            timersub(time, last, &nap);
-            timerdiv(&nap, options.speed.speed);
+            timersub(time, last, &nap_for);
+            TIMEVAL_TO_TIMESPEC(&nap_for, &nap);
+            timesdiv(&nap, options.speed.speed);
         }
         else {
@@ -363 +392 @@
              * last packet.
              */
-            timerclear(&nap);
-        }
+            timesclear(&nap);
+        }        
         break;
 
@@ -375 +404 @@
             n = (float)len / (options.speed.speed * 1024 * 1024 / 8); /* convert Mbps to bps */
             nap.tv_sec = n;
-            nap.tv_usec = (n - nap.tv_sec) * 1000000;
+            nap.tv_nsec = (n - nap.tv_sec)  * 1000000000;
+            
             dbgx(3, "packet size %d\t\tequals %f bps\t\tnap " TIMEVAL_FORMAT, len, n, 
-                nap.tv_sec, nap.tv_usec);
+                nap.tv_sec, nap.tv_nsec);
         }
         else {
-            timerclear(&nap);
+            /* don't sleep at all for the first packet */
+            timesclear(&nap);
         }
         break;
 
     case SPEED_PACKETRATE:
-        /* run in packets/sec */
-        n = 1 / options.speed.speed;
-        nap.tv_sec = n;
-        n -= nap.tv_sec;
-        nap.tv_usec = n * 1000000;
-        break;
-
+        /* only need to calculate this the first time */
+        if (! timesisset(&nap)) {
+            /* run in packets/sec */
+            ppnsec = 1000000000 / options.speed.speed;
+            NANOSEC_TO_TIMESPEC(ppnsec, &nap);
+            dbgx(1, "sending 1 packet per %lu nsec", nap.tv_nsec);
+        }
+        break;
+        
     case SPEED_ONEATATIME:
         /* do we skip prompting for a key press? */
         if (send == 0) {
-            printf("**** Next packet #" COUNTER_SPEC " out %s.  How many packets do you wish to send? ",
-                counter, (sp == options.intf1 ? options.intf1_name : options.intf2_name));
-            fflush(NULL);
-            poller[0].fd = STDIN_FILENO;
-            poller[0].events = POLLIN | POLLPRI | POLLNVAL;
-            poller[0].revents = 0;
-
-            if (fcntl(0, F_SETFL, fcntl(0, F_GETFL) & ~O_NONBLOCK)) 
-                   errx(1, "Unable to clear non-blocking flag on stdin: %s", strerror(errno));
-
-            /* wait for the input */
-            if (poll(poller, 1, -1) < 0)
-                errx(1, "Error reading user input from stdin: %s", strerror(errno));
-            
-            /*
-             * read to the end of the line or EBUF_SIZE,
-             * Note, if people are stupid, and type in more text then EBUF_SIZE
-             * then the next fgets() will pull in that data, which will have poor 
-             * results.  fuck them.
-             */
-            if (fgets(input, sizeof(input), stdin) == NULL) {
-                errx(1, "Unable to process user input for fd %d: %s", fileno(stdin), strerror(errno));
-            } else if (strlen(input) > 1) {
-                send = strtoul(input, NULL, 0);
-            }
-
-            /* how many packets should we send? */
-            if (send == 0) {
-