Merge pull request appneta#283 from appneta/Release_4.2.0beta1

fklassen · web-flow · commit 54ab894f79c6 · 2017-02-28T00:09:08.000-08:00
Release 4.2.0 beta1
diff --git a/.travis.yml b/.travis.yml
@@ -7,17 +7,8 @@ addons:
     packages:
     - libpcap-dev
 
-cache:
-  apt: true
-
 matrix:
   include:
-    - os: osx
-      osx_image: xcode6.4
-      compiler: gcc
-      before_install:
-        - brew update
-        - brew install autogen homebrew/dupes/libpcap
     - os: osx
       osx_image: xcode8.2
       compiler: clang
diff --git a/configure.ac b/configure.ac
@@ -2,7 +2,7 @@
 dnl $Id$
 
 AC_PREREQ([2.69])
-AC_INIT([tcpreplay],[4.1.2],[https://github.com/appneta/tcpreplay/issues],[tcpreplay],[http://tcpreplay.sourceforge.net/])
+AC_INIT([tcpreplay],[4.2.0],[https://github.com/appneta/tcpreplay/issues],[tcpreplay],[http://tcpreplay.sourceforge.net/])
 AC_CONFIG_SRCDIR([src/tcpreplay.c])
 AM_CONFIG_HEADER([src/config.h])
 AC_CONFIG_AUX_DIR(config)
@@ -17,8 +17,8 @@ AC_CONFIG_MACRO_DIR([m4])
 
 dnl Set version info here!
 MAJOR_VERSION=4
-MINOR_VERSION=1
-MICRO_VERSION=2
+MINOR_VERSION=2
+MICRO_VERSION=0-beta1
 TCPREPLAY_VERSION=$MAJOR_VERSION.$MINOR_VERSION.$MICRO_VERSION
 PACKAGE_URL=http://tcpreplay.appneta.com/
 
diff --git a/docs/CHANGELOG b/docs/CHANGELOG
@@ -1,3 +1,15 @@
+02/26/2017 Version 4.2.0beta1
+    - Netmap startup delay increase (#209)
+    - tcpcapinfo buffer overflow vulnerablily (#278)
+    - Update git-clone instructions by Kyle McDonald (#277) 
+    - Allow fractions for --pps option (#270)
+    - Print per-loop stats with --stats=0 (#269)
+    - Add protection against packet drift by Guillaume Scott (#268)
+    - Include Travis-CI build support by Ilya Shipitsin (#264) (#285)
+    - Netmap shutdown delay implemention (#255)
+    - First and last packet times in --stats output (#239)
+    - tcprewrite fix checksum properly for fragmented packets (#190)
+
 11/19/2016 Version 4.1.2
     - Fix compilation with musl C library (#260)
     - Support parallel builds (#259)
diff --git a/src/common/flows.c b/src/common/flows.c
@@ -147,7 +147,7 @@ static inline flow_entry_type_t hash_put_data(flow_hash_table_t *fht, const uint
             res = FLOW_ENTRY_INVALID;
     }
 
-    dbgx(2, "flow type=%d\n", (int)res);
+    dbgx(2, "flow type=%d", (int)res);
     return res;
 }
 
@@ -321,7 +321,7 @@ flow_hash_table_t *flow_hash_table_init(size_t n)
 {
     flow_hash_table_t *fht;
     if (!is_power_of_2(n))
-        errx(-1, "invalid table size: %zu\n", n);
+        errx(-1, "invalid table size: %zu", n);
 
     fht = safe_malloc(sizeof(*fht));
     fht->num_buckets = n;
diff --git a/src/common/netmap.c b/src/common/netmap.c
@@ -502,9 +502,16 @@ void sendpacket_close_netmap(void *p)
     fprintf(stderr, "Switching network driver for %s to normal mode... ",
             sp->device);
     fflush(NULL);
-      /* flush any remaining packets */
+
+    /* flush any remaining packets */
     ioctl(sp->handle.fd, NIOCTXSYNC, NULL);
 
+    /* wait for traffic to be sent */
+    dbgx(2, "Waiting %d seconds for phy reset...", sp->netmap_delay);
+    sleep(sp->netmap_delay);
+    dbg(2, "Ready!");
+
+
 #ifdef linux
     if (!sp->is_vale) {
         /* restore original settings:
diff --git a/src/common/sendpacket.h b/src/common/sendpacket.h
@@ -127,6 +127,7 @@ struct sendpacket_s {
     struct tcpr_ether_addr ether;
 #if defined HAVE_QUICK_TX || defined HAVE_NETMAP
     int first_packet;
+    int netmap_delay;
 #endif
 
 #ifdef HAVE_QUICK_TX
diff --git a/src/common/utils.c b/src/common/utils.c
@@ -157,10 +157,10 @@ packet_stats(const tcpreplay_stats_t *stats)
     }
 
     if (diff_us >= 1000000)
-        printf("Actual: " COUNTER_SPEC " packets (" COUNTER_SPEC " bytes) sent in %zd.%02zd seconds.\n",
-                stats->pkts_sent, stats->bytes_sent, (ssize_t)diff.tv_sec, (ssize_t)(diff.tv_usec / (100 * 1000)));
+        printf("Actual: " COUNTER_SPEC " packets (" COUNTER_SPEC " bytes) sent in %zd.%02zd seconds\n",
+                stats->pkts_sent, stats->bytes_sent, (ssize_t)diff.tv_sec, (ssize_t)(diff.tv_usec / (10 * 1000)));
     else
-        printf("Actual: " COUNTER_SPEC " packets (" COUNTER_SPEC " bytes) sent in %zd.%06zd seconds.\n",
+        printf("Actual: " COUNTER_SPEC " packets (" COUNTER_SPEC " bytes) sent in %zd.%06zd seconds\n",
                 stats->pkts_sent, stats->bytes_sent, (ssize_t)diff.tv_sec, (ssize_t)diff.tv_usec);
 
 
@@ -177,6 +177,29 @@ packet_stats(const tcpreplay_stats_t *stats)
                 stats->failed);
 }
 
+/**
+ * fills a buffer with a string representing the given time
+ *
+ * @param when: the time that should be formatted
+ * @param buf: a buffer to write to
+ * @param len: length of the buffer
+ * @return: string containing date, or -1 on error
+ */
+int format_date_time(struct timeval *when, char *buf, size_t len)
+{
+    struct tm *tm;
+    char tmp[64];
+
+    assert(len);
+
+    tm = localtime(&when->tv_sec);
+    if (!tm)
+        return -1;
+
+    strftime(tmp, sizeof tmp, "%Y-%m-%d %H:%M:%S.%%06u", tm);
+    return snprintf(buf, len, tmp, when->tv_usec);
+}
+
 /**
  * reads a hexstring in the format of xx,xx,xx,xx spits it back into *hex
  * up to hexlen bytes.  Returns actual number of bytes returned.  On error
diff --git a/src/common/utils.h b/src/common/utils.h
@@ -46,6 +46,7 @@ typedef struct {
 
 int read_hexstring(const char *l2string, u_char *hex, const int hexlen);
 void packet_stats(const tcpreplay_stats_t *stats);
+int format_date_time(struct timeval *when, char *buf, size_t len);
 
 /* our "safe" implimentations of functions which allocate memory */
 #define safe_malloc(x) _our_safe_malloc(x, __FUNCTION__, __LINE__, __FILE__)
diff --git a/src/send_packets.c b/src/send_packets.c
@@ -1170,10 +1170,13 @@ static bool calc_sleep_time(tcpreplay_t *ctx, struct timeval *pkt_time_delta,
           */
          now_us = TIMSTAMP_TO_MICROSEC(sent_timestamp);
          if (now_us) {
-             COUNTER pps = ctx->options->speed.speed * (ctx->options->speed.pps_multi > 0 ? ctx->options->speed.pps_multi : 1);;
+             COUNTER pph = ctx->options->speed.speed * (ctx->options->speed.pps_multi > 0 ? ctx->options->speed.pps_multi : (60 * 60));;
              COUNTER pkts_sent = ctx->stats.pkts_sent;
-             /* packets * 1000000 divided by pps = microseconds */
-             COUNTER next_tx_us = (pkts_sent * 1000000) / pps;
+             /*
+              * packets * 1000000 divided by pps = microseconds
+              * packets per sec (pps) = packets per hour / (60 * 60)
+              */
+             COUNTER next_tx_us = (pkts_sent * 1000000) * (60 * 60) / pph;
              COUNTER tx_us = now_us - *start_us;
              if (next_tx_us > tx_us)
                  NANOSEC_TO_TIMESPEC((next_tx_us - tx_us) * 1000, &ctx->nap);
diff --git a/src/tcpcapinfo.c b/src/tcpcapinfo.c
@@ -281,6 +281,15 @@ main(int argc, char *argv[])
                 caplen = pcap_ph.caplen;
             }
 
+            if (caplentoobig) {
+                printf("\n\nCapture file appears to be damaged or corrupt.\n"
+                        "Contains packet of size %u, bigger than snap length %u\n",
+                        caplen, pcap_fh.snaplen);
+
+                close(fd);
+                break;
+            }
+
             /* check to make sure timestamps don't go backwards */
             if (last_sec > 0 && last_usec > 0) {
                 if ((pcap_ph.ts.tv_sec == last_sec) ? 
@@ -306,7 +315,7 @@ main(int argc, char *argv[])
                 }
 
                 close(fd);
-                continue;
+                break;
             }
 
             /* print the frame checksum */
diff --git a/src/tcpedit/edit_packet.c b/src/tcpedit/edit_packet.c
@@ -63,7 +63,8 @@ fix_ipv4_checksums(tcpedit_t *tcpedit, struct pcap_pkthdr *pkthdr, ipv4_hdr_t *i
     
 
     /* calc the L4 checksum if we have the whole packet && not a frag or first frag */
-    if (pkthdr->caplen == pkthdr->len && (htons(ip_hdr->ip_off) & IP_OFFMASK) == 0) {
+    if (pkthdr->caplen == pkthdr->len &&
+            (htons(ip_hdr->ip_off) & (IP_MF | IP_OFFMASK)) == 0) {
         ret1 = do_checksum(tcpedit, (u_char *) ip_hdr, 
                 ip_hdr->ip_p, ntohs(ip_hdr->ip_len) - (ip_hdr->ip_hl << 2));
         if (ret1 < 0)
diff --git a/src/tcpedit/tcpedit.c b/src/tcpedit/tcpedit.c
@@ -330,7 +330,7 @@ tcpedit_init(tcpedit_t **tcpedit_ex, int dlt)
     tcpedit->runtime.dlt1 = dlt;
     tcpedit->runtime.dlt2 = dlt;
     
-    dbgx(1, "Input file (1) datalink type is %s\n",
+    dbgx(1, "Input file (1) datalink type is %s",
             pcap_datalink_val_to_name(dlt));
 
 #ifdef FORCE_ALIGN
@@ -494,7 +494,7 @@ tcpedit_close(tcpedit_t *tcpedit)
 
     assert(tcpedit);
     dbgx(1, "tcpedit processed " COUNTER_SPEC " bytes in " COUNTER_SPEC
-            " packets.\n", tcpedit->runtime.total_bytes, 
+            " packets.", tcpedit->runtime.total_bytes,
             tcpedit->runtime.pkts_edited);
 
     /* free buffer if required */
diff --git a/src/tcpreplay_api.c b/src/tcpreplay_api.c
@@ -98,6 +98,9 @@ tcpreplay_init()
     /* set the default MTU size */
     ctx->options->mtu = DEFAULT_MTU;
 
+    /* disable periodic statistics */
+    ctx->options->stats = -1;
+
     /* disable limit send */
     ctx->options->limit_send = -1;
 
@@ -175,8 +178,9 @@ tcpreplay_post_args(tcpreplay_t *ctx, int argc)
         options->speed.mode = speed_topspeed;
         options->speed.speed = 0;
     } else if (HAVE_OPT(PPS)) {
+        n = atof(OPT_ARG(PPS));
+        options->speed.speed = (COUNTER)(n * 60.0 * 60.0); /* convert to packets per hour */
         options->speed.mode = speed_packetrate;
-        options->speed.speed = (float)OPT_VALUE_PPS;
         options->speed.pps_multi = OPT_VALUE_PPS_MULTI;
     } else if (HAVE_OPT(ONEATATIME)) {
         options->speed.mode = speed_oneatatime;
@@ -383,6 +387,10 @@ tcpreplay_post_args(tcpreplay_t *ctx, int argc)
         goto out;
     }
 
+#if defined HAVE_NETMAP
+    ctx->intf1->netmap_delay = ctx->options->netmap_delay;
+#endif
+
     ctx->intf1dlt = sendpacket_get_dlt(ctx->intf1);
 
     if (HAVE_OPT(INTF2)) {
@@ -412,6 +420,10 @@ tcpreplay_post_args(tcpreplay_t *ctx, int argc)
             tcpreplay_seterr(ctx, "Can't open %s: %s", options->intf2_name, ebuf);
         }
 
+#if defined HAVE_NETMAP
+        ctx->intf2->netmap_delay = ctx->options->netmap_delay;
+#endif
+
         ctx->intf2dlt = sendpacket_get_dlt(ctx->intf2);
         if (ctx->intf2dlt != ctx->intf1dlt) {
             tcpreplay_seterr(ctx, "DLT type mismatch for %s (%s) and %s (%s)",
@@ -1148,7 +1160,8 @@ tcpreplay_prepare(tcpreplay_t *ctx)
 int
 tcpreplay_replay(tcpreplay_t *ctx)
 {
-    int rcode;
+    int rcode, loop, total_loops;
+    char buf[64];
 
     assert(ctx);
 
@@ -1171,36 +1184,60 @@ tcpreplay_replay(tcpreplay_t *ctx)
         return -1;
     }
 
+    if (ctx->options->stats >= 0) {
+        if (format_date_time(&ctx->stats.start_time, buf, sizeof(buf)) > 0)
+            printf("Test start: %s ...\n", buf);
+    }
 
     ctx->running = true;
+    total_loops = ctx->options->loop;
+    loop = 0;
 
     /* main loop, when not looping forever (or until abort) */
     if (ctx->options->loop > 0) {
         while (ctx->options->loop-- && !ctx->abort) {  /* limited loop */
+            if (ctx->options->stats == 0)
+                printf("Loop %d of %d...\n", ++loop, total_loops);
             if ((rcode = tcpr_replay_index(ctx)) < 0)
                 return rcode;
-            if (ctx->options->loop > 0 && !ctx->abort && ctx->options->loopdelay_ms > 0)
-            	usleep(ctx->options->loopdelay_ms * 1000);
+            if (ctx->options->loop > 0) {
+                if (!ctx->abort && ctx->options->loopdelay_ms > 0) {
+                    usleep(ctx->options->loopdelay_ms * 1000);
+                    gettimeofday(&ctx->stats.end_time, NULL);
+                }
+
+                if (ctx->options->stats == 0)
+                    packet_stats(&ctx->stats);
+            }
         }
     } else {
         while (!ctx->abort) { /* loop forever unless user aborts */
+            if (ctx->options->stats == 0)
+                printf("Loop %d...\n", ++loop);
             if ((rcode = tcpr_replay_index(ctx)) < 0)
                 return rcode;
+
+            if (ctx->options->stats == 0 && !ctx->abort)
+                packet_stats(&ctx->stats);
         }
     }
 
     ctx->running = false;
 
 #ifdef HAVE_QUICK_TX
     /* flush any remaining netmap packets */
-    if (ctx->options->quick_tx)
+    if (ctx->options->quick_tx) {
         quick_tx_wait_for_tx_complete(ctx->intf1->qtx_dev);
+        if (ctx->stats.bytes_sent >= 0)
+            gettimeofday(&ctx->stats.end_time, NULL);
+    }
 #endif
 
-    if (ctx->stats.bytes_sent > 0) {
-           if (gettimeofday(&ctx->stats.end_time, NULL) < 0)
-               errx(-1, "gettimeofday() failed: %s",  strerror(errno));
+    if (ctx->options->stats >= 0) {
+        if (format_date_time(&ctx->stats.end_time, buf, sizeof(buf)) > 0)
+            printf("Test complete: %s\n", buf);
     }
+
     return 0;
 }
 
diff --git a/src/tcpreplay_opts.def b/src/tcpreplay_opts.def
@@ -401,10 +401,17 @@ flag = {
     flags-cant  = oneatatime;
     flags-cant  = topspeed;
     value       = p;
-    arg-type    = number;
+    arg-type    = string;
     max         = 1;
     descrip     = "Replay packets at a given packets/sec";
-    doc         = "";
+    doc         = <<- EOText
+Specify a value to regulate the packet replay to a specific packet-per-second rate.
+Examples:
+@example
+    200 will replay traffic at 200 packets per second
+    0.25 will replay traffic at 15 packets per minute
+@end example
+EOText;
 };
 
 flag = {
@@ -498,13 +505,12 @@ EOText;
 flag = {
     ifdef       = HAVE_NETMAP;
     name        = nm-delay;
-    flags-must  = netmap;
     arg-type    = number;
-    arg-default = 4;
+    arg-default = 10;
     descrip     = "Netmap startup delay";
     doc         = <<- EOText
 Number of seconds to delay after netmap is loaded. Required to ensure interfaces
-are fully up before netmap transmit. Requires netmap option. Default is 4 seconds.
+are fully up before netmap transmit. Requires netmap option. Default is 10 seconds.
 EOText;
 };
 
@@ -589,10 +595,10 @@ EOText;
 flag = {
     name        = stats;
     arg-type    = number;
-    arg-range   = "1->";
-    descrip     = "Print statistics every X seconds";
+    arg-range   = "0->";
+    descrip     = "Print statistics every X seconds, or every loop if '0'";
     doc         = <<- EOText
-Note that this is very much a "best effort" and long delays between
+Note that timed delays are a "best effort" and long delays between
 sending packets may cause equally long delays between printing statistics.
 EOText;
 };
diff --git a/src/tcprewrite.c b/src/tcprewrite.c

Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ static inline flow_entry_type_t hash_put_data(flow_hash_table_t *fht, const uint`
`147`	`147`	`res = FLOW_ENTRY_INVALID;`
`148`	`148`	`}`
`149`	`149`
`150`		`- dbgx(2, "flow type=%d\n", (int)res);`
	`150`	`+ dbgx(2, "flow type=%d", (int)res);`
`151`	`151`	`return res;`
`152`	`152`	`}`
`153`	`153`
`@@ -321,7 +321,7 @@ flow_hash_table_t *flow_hash_table_init(size_t n)`
`321`	`321`	`{`
`322`	`322`	`flow_hash_table_t *fht;`
`323`	`323`	`if (!is_power_of_2(n))`
`324`		`- errx(-1, "invalid table size: %zu\n", n);`
	`324`	`+ errx(-1, "invalid table size: %zu", n);`
`325`	`325`
`326`	`326`	`fht = safe_malloc(sizeof(*fht));`
`327`	`327`	`fht->num_buckets = n;`