Address Michael's comments.

[tcpdump] / util.c

diff --git a/util.c b/util.c
index 13d299749ac8e380bd16179e0b9698269a5c791c..a2ef36d70b78ae53f151e5d08912356ccb589384 100644 (file)
--- a/util.c
+++ b/util.c
@@ -21,7 +21,7 @@
 
 #ifndef lint
 static const char rcsid[] _U_ =
 
 #ifndef lint
 static const char rcsid[] _U_ =

-    "@(#) $Header: /tcpdump/master/tcpdump/util.c,v 1.103 2005-12-13 08:37:23 hannes Exp $ (LBL)";
+    "@(#) $Header: /tcpdump/master/tcpdump/util.c,v 1.109 2007-01-29 09:59:42 hannes Exp $ (LBL)";

 #endif
 
 #ifdef HAVE_CONFIG_H
 #endif
 
 #ifdef HAVE_CONFIG_H


@@ -164,6 +164,8 @@ ts_print(register const struct timeval *tvp)
        time_t Time;
        static unsigned b_sec;
        static unsigned b_usec;
        time_t Time;
        static unsigned b_sec;
        static unsigned b_usec;

+       int d_usec;
+       int d_sec;

 
        switch (tflag) {
 
 
        switch (tflag) {
 


@@ -183,14 +185,14 @@ ts_print(register const struct timeval *tvp)
 
        case 3: /* Microseconds since previous packet */
         case 5: /* Microseconds since first packet */
 
        case 3: /* Microseconds since previous packet */
         case 5: /* Microseconds since first packet */

-               if (b_sec == 0 && tflag == 5) {
+               if (b_sec == 0) {

                         /* init timestamp for first packet */
                         b_usec = tvp->tv_usec;
                         b_sec = tvp->tv_sec;                        
                 }
 
                         /* init timestamp for first packet */
                         b_usec = tvp->tv_usec;
                         b_sec = tvp->tv_sec;                        
                 }
 

-                int d_usec = tvp->tv_usec - b_usec;
-                int d_sec = tvp->tv_sec - b_sec;
+                d_usec = tvp->tv_usec - b_usec;
+                d_sec = tvp->tv_sec - b_sec;

                 
                 while (d_usec < 0) {
                     d_usec += 1000000;
                 
                 while (d_usec < 0) {
                     d_usec += 1000000;


@@ -314,18 +316,19 @@ tok2str(register const struct tok *lp, register const char *fmt,
 
 /*
  * Convert a bit token value to a string; use "fmt" if not found.
 
 /*
  * Convert a bit token value to a string; use "fmt" if not found.

- * this is useful for parsing bitfields, the output strings are comma seperated
+ * this is useful for parsing bitfields, the output strings are seperated
+ * if the s field is positive.

  */
  */

-char *
-bittok2str(register const struct tok *lp, register const char *fmt,
-          register int v)
+static char *
+bittok2str_internal(register const struct tok *lp, register const char *fmt,
+          register int v, register int sep)

 {
         static char buf[256]; /* our stringbuffer */
         int buflen=0;
         register int rotbit; /* this is the bit we rotate through all bitpositions */
         register int tokval;
 
 {
         static char buf[256]; /* our stringbuffer */
         int buflen=0;
         register int rotbit; /* this is the bit we rotate through all bitpositions */
         register int tokval;
 

-       while (lp->s != NULL && lp != NULL) {
+       while (lp != NULL && lp->s != NULL) {

             tokval=lp->v;   /* load our first value */
             rotbit=1;
             while (rotbit != 0) {
             tokval=lp->v;   /* load our first value */
             rotbit=1;
             while (rotbit != 0) {


@@ -335,7 +338,8 @@ bittok2str(register const struct tok *lp, register const char *fmt,
                  */
                if (tokval == (v&rotbit)) {
                     /* ok we have found something */
                  */
                if (tokval == (v&rotbit)) {
                     /* ok we have found something */

-                    buflen+=snprintf(buf+buflen, sizeof(buf)-buflen, "%s, ",lp->s);
+                    buflen+=snprintf(buf+buflen, sizeof(buf)-buflen, "%s%s",
+                                     lp->s, sep ? ", " : "");

                     break;
                 }
                 rotbit=rotbit<<1; /* no match - lets shift and try again */
                     break;
                 }
                 rotbit=rotbit<<1; /* no match - lets shift and try again */


@@ -343,6 +347,11 @@ bittok2str(register const struct tok *lp, register const char *fmt,
             lp++;
        }
 
             lp++;
        }
 

+        /* user didn't want string seperation - no need to cut off trailing seperators */
+        if (!sep) {
+            return (buf);
+        }
+

         if (buflen != 0) { /* did we find anything */
             /* yep, set the the trailing zero 2 bytes before to eliminate the last comma & whitespace */
             buf[buflen-2] = '\0';
         if (buflen != 0) { /* did we find anything */
             /* yep, set the the trailing zero 2 bytes before to eliminate the last comma & whitespace */
             buf[buflen-2] = '\0';


@@ -357,6 +366,28 @@ bittok2str(register const struct tok *lp, register const char *fmt,
         }
 }
 
         }
 }
 

+/*
+ * Convert a bit token value to a string; use "fmt" if not found.
+ * this is useful for parsing bitfields, the output strings are not seperated.
+ */
+char *
+bittok2str_nosep(register const struct tok *lp, register const char *fmt,
+          register int v)
+{
+    return (bittok2str_internal(lp, fmt, v, 0));
+}
+
+/*
+ * Convert a bit token value to a string; use "fmt" if not found.
+ * this is useful for parsing bitfields, the output strings are comma seperated.
+ */
+char *
+bittok2str(register const struct tok *lp, register const char *fmt,
+          register int v)
+{
+    return (bittok2str_internal(lp, fmt, v, 1));
+}
+

 /*
  * Convert a value to a string using an array; the macro
  * tok2strary() in <interface.h> is the public interface to
 /*
  * Convert a value to a string using an array; the macro
  * tok2strary() in <interface.h> is the public interface to


@@ -384,7 +415,7 @@ tok2strary_internal(register const char **lp, int n, register const char *fmt,
  */
 
 int
  */
 
 int

-mask2plen (u_int32_t mask)
+mask2plen(u_int32_t mask)

 {
        u_int32_t bitmasks[33] = {
                0x00000000,
 {
        u_int32_t bitmasks[33] = {
                0x00000000,


@@ -408,6 +439,35 @@ mask2plen (u_int32_t mask)
        return (prefix_len);
 }
 
        return (prefix_len);
 }
 

+#ifdef INET6
+int
+mask62plen(const u_char *mask)
+{
+       u_char bitmasks[9] = {
+               0x00,
+               0x80, 0xc0, 0xe0, 0xf0,
+               0xf8, 0xfc, 0xfe, 0xff
+       };
+       int byte;
+       int cidr_len = 0;
+
+       for (byte = 0; byte < 16; byte++) {
+               u_int bits;
+
+               for (bits = 0; bits < (sizeof (bitmasks) / sizeof (bitmasks[0])); bits++) {
+                       if (mask[byte] == bitmasks[bits]) {
+                               cidr_len += bits;
+                               break;
+                       }
+               }
+
+               if (mask[byte] != 0xff)
+                       break;
+       }
+       return (cidr_len);
+}
+#endif /* INET6 */
+

 /* VARARGS */
 void
 error(const char *fmt, ...)
 /* VARARGS */
 void
 error(const char *fmt, ...)


@@ -524,10 +584,13 @@ read_infile(char *fname)
 }
 
 void
 }
 
 void

-safeputs(const char *s)
+safeputs(const char *s, int maxlen)

 {
 {

-       while (*s) {
+       int idx = 0;
+
+       while (*s && idx < maxlen) {

                safeputchar(*s);
                safeputchar(*s);

+                idx++;

                s++;
        }
 }
                s++;
        }
 }


@@ -541,5 +604,5 @@ safeputchar(int c)
        if (ch < 0x80 && isprint(ch))
                printf("%c", ch);
        else
        if (ch < 0x80 && isprint(ch))
                printf("%c", ch);
        else

-               printf("\\%03o", ch);
+               printf("\\0x%02x", ch);

 }
 }