Hoist a bunch of stuff that should be done by all if_print routines into

[tcpdump] / util.c

diff --git a/util.c b/util.c
index fc3a603a3d67fe108ef0a7c82064cee67ea3827b..84d4a076122d8c0144908b709edf8e63e808d3a6 100644 (file)
--- a/util.c
+++ b/util.c
@@ -21,19 +21,17 @@
 
 #ifndef lint
 static const char rcsid[] =
-    "@(#) $Header: /tcpdump/master/tcpdump/util.c,v 1.70 2001-09-10 00:28:54 fenner Exp $ (LBL)";
+    "@(#) $Header: /tcpdump/master/tcpdump/util.c,v 1.81 2002-11-07 20:07:58 hannes Exp $ (LBL)";
 #endif
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/file.h>
+#include <tcpdump-stdinc.h>
+
 #include <sys/stat.h>
 
-#include <ctype.h>
 #include <errno.h>
 #ifdef HAVE_FCNTL_H
 #include <fcntl.h>
@@ -43,10 +41,6 @@ static const char rcsid[] =
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
-#ifdef TIME_WITH_SYS_TIME
-#include <time.h>
-#endif
-#include <unistd.h>
 
 #include "interface.h"
 
@@ -145,7 +139,7 @@ ts_print(register const struct timeval *tvp)
                } else {
                        int d_usec = tvp->tv_usec - b_usec;
                        int d_sec = tvp->tv_sec - b_sec;
-                       
+
                        while (d_usec < 0) {
                                d_usec += 1000000;
                                d_sec--;
@@ -183,10 +177,14 @@ relts_print(int secs)
        const char **l = lengths;
        const int *s = seconds;
 
-       if (secs <= 0) {
+       if (secs == 0) {
                (void)printf("0s");
                return;
        }
+       if (secs < 0) {
+               (void)printf("-");
+               secs = -secs;
+       }
        while (secs > 0) {
                if (secs >= *s) {
                        (void)printf("%d%s", secs / *s, *l);
@@ -197,6 +195,37 @@ relts_print(int secs)
        }
 }
 
+/*
+ *  this is a generic routine for printing unknown data;
+ *  we pass on the linefeed plus indentation string to
+ *  get a proper output - returns 0 on error
+ */
+
+int
+print_unknown_data(const u_char *cp,const char *lf,int len)
+{
+        int i;
+
+        if (len ==0)
+           return(0);
+
+       printf("%s0x0000: ",lf);
+       for(i=0;i<len;i++) {
+           if (!TTEST2(*(cp+i), 1)) {
+              printf("%spacket exceeded snapshot",lf);
+              return(0);
+            }
+           printf("%02x",*(cp+i));
+           if (i%2)
+               printf(" ");
+           if (i/16!=(i+1)/16) {
+               if (i<(len-1))
+                   printf("%s0x%04x: ",lf,i);
+           }
+       }
+       return(1); /* everything is ok */
+}
+
 /*
  * Convert a token value to a string; use "fmt" if not found.
  */
@@ -217,6 +246,70 @@ tok2str(register const struct tok *lp, register const char *fmt,
        return (buf);
 }
 
+/*
+ * 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)
+{
+        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) {
+            tokval=lp->v;   /* load our first value */
+            rotbit=1;
+            while (rotbit != 0) {
+                /*
+                 * lets AND the rotating bit with our token value
+                 * and see if we have got a match
+                 */
+               if (tokval == (v&rotbit)) {
+                    /* ok we have found something */
+                    buflen+=snprintf(buf+buflen, sizeof(buf)-buflen, "%s, ",lp->s);
+                    break;
+                }
+                rotbit=rotbit<<1; /* no match - lets shift and try again */
+            }
+            lp++;
+       }
+
+        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';
+            return (buf);
+        }
+        else {
+            /* bummer - lets print the "unknown" message as advised in the fmt string if we got one */
+            if (fmt == NULL)
+               fmt = "#%d";
+            (void)snprintf(buf, sizeof(buf), fmt, v);
+            return (buf);
+        }
+}
+
+/*
+ * Convert a value to a string using an array; the macro
+ * tok2strary() in <interface.h> is the public interface to
+ * this function and ensures that the second argument is
+ * correct for bounds-checking.
+ */
+const char *
+tok2strary_internal(register const char **lp, int n, register const char *fmt,
+       register int v)
+{
+       static char buf[128];
+
+       if (v >= 0 && v < n && lp[v] != NULL)
+               return lp[v];
+       if (fmt == NULL)
+               fmt = "#%d";
+       (void)snprintf(buf, sizeof(buf), fmt, v);
+       return (buf);
+}
 
 /* VARARGS */
 void
@@ -310,7 +403,16 @@ read_infile(char *fname)
        if (cc < 0)
                error("read %s: %s", fname, pcap_strerror(errno));
        if (cc != buf.st_size)
+#ifndef WIN32
                error("short read %s (%d != %d)", fname, cc, (int)buf.st_size);
+#else
+/* Windows seems not to like the final \xa character */
+       {
+               char *pdest;
+               pdest=strchr( cp, '\xa');
+               *pdest=0;
+       }
+#endif /* WIN32 */
        cp[(int)buf.st_size] = '\0';
 
        return (cp);
@@ -331,8 +433,8 @@ safeputchar(int c)
        unsigned char ch;
 
        ch = (unsigned char)(c & 0xff);
-       if (c < 0x80 && isprint(c))
-               printf("%c", c & 0xff);
+       if (ch < 0x80 && isprint(ch))
+               printf("%c", ch);
        else
-               printf("\\%03o", c & 0xff);
+               printf("\\%03o", ch);
 }