The Tcpdump Group git mirrors - tcpdump/blob - util.c

   1 /*
   2  * Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996, 1997
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that: (1) source code distributions
   7  * retain the above copyright notice and this paragraph in its entirety, (2)
   8  * distributions including binary code include the above copyright notice and
   9  * this paragraph in its entirety in the documentation or other materials
  10  * provided with the distribution, and (3) all advertising materials mentioning
  11  * features or use of this software display the following acknowledgement:
  12  * ``This product includes software developed by the University of California,
  13  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  14  * the University nor the names of its contributors may be used to endorse
  15  * or promote products derived from this software without specific prior
  16  * written permission.
  17  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20  */
  21
  22 #ifndef lint
  23 static const char rcsid[] _U_ =
  24     "@(#) $Header: /tcpdump/master/tcpdump/util.c,v 1.87.2.4 2004-04-28 22:09:23 guy Exp $ (LBL)";
  25 #endif
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include <tcpdump-stdinc.h>
  32
  33 #include <sys/stat.h>
  34
  35 #include <errno.h>
  36 #ifdef HAVE_FCNTL_H
  37 #include <fcntl.h>
  38 #endif
  39 #include <pcap.h>
  40 #include <stdio.h>
  41 #include <stdarg.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44
  45 #include "interface.h"
  46
  47 /*
  48  * Print out a filename (or other ascii string).
  49  * If ep is NULL, assume no truncation check is needed.
  50  * Return true if truncated.
  51  */
  52 int
  53 fn_print(register const u_char *s, register const u_char *ep)
  54 {
  55         register int ret;
  56         register u_char c;
  57
  58         ret = 1;                        /* assume truncated */
  59         while (ep == NULL || s < ep) {
  60                 c = *s++;
  61                 if (c == '\0') {
  62                         ret = 0;
  63                         break;
  64                 }
  65                 if (!isascii(c)) {
  66                         c = toascii(c);
  67                         putchar('M');
  68                         putchar('-');
  69                 }
  70                 if (!isprint(c)) {
  71                         c ^= 0x40;      /* DEL to ?, others to alpha */
  72                         putchar('^');
  73                 }
  74                 putchar(c);
  75         }
  76         return(ret);
  77 }
  78
  79 /*
  80  * Print out a counted filename (or other ascii string).
  81  * If ep is NULL, assume no truncation check is needed.
  82  * Return true if truncated.
  83  */
  84 int
  85 fn_printn(register const u_char *s, register u_int n,
  86           register const u_char *ep)
  87 {
  88         register u_char c;
  89
  90         while (n > 0 && (ep == NULL || s < ep)) {
  91                 n--;
  92                 c = *s++;
  93                 if (!isascii(c)) {
  94                         c = toascii(c);
  95                         putchar('M');
  96                         putchar('-');
  97                 }
  98                 if (!isprint(c)) {
  99                         c ^= 0x40;      /* DEL to ?, others to alpha */
 100                         putchar('^');
 101                 }
 102                 putchar(c);
 103         }
 104         return (n == 0) ? 0 : 1;
 105 }
 106
 107 /*
 108  * Print the timestamp
 109  */
 110 void
 111 ts_print(register const struct timeval *tvp)
 112 {
 113         register int s;
 114         struct tm *tm;
 115         time_t Time;
 116         static unsigned b_sec;
 117         static unsigned b_usec;
 118
 119         switch(tflag) {
 120         case 1: /* Default */
 121                 s = (tvp->tv_sec + thiszone) % 86400;
 122                 (void)printf("%02d:%02d:%02d.%06u ",
 123                              s / 3600, (s % 3600) / 60, s % 60,
 124                              (unsigned)tvp->tv_usec);
 125                 break;
 126         case -1: /* Unix timeval style */
 127                 (void)printf("%u.%06u ",
 128                              (unsigned)tvp->tv_sec,
 129                              (unsigned)tvp->tv_usec);
 130                 break;
 131         case -2:
 132                 if (b_sec == 0) {
 133                         printf("000000 ");
 134                 } else {
 135                         int d_usec = tvp->tv_usec - b_usec;
 136                         int d_sec = tvp->tv_sec - b_sec;
 137
 138                         while (d_usec < 0) {
 139                                 d_usec += 1000000;
 140                                 d_sec--;
 141                         }
 142                         if (d_sec)
 143                                 printf("%d. ", d_sec);
 144                         printf("%06d ", d_usec);
 145                 }
 146                 b_sec = tvp->tv_sec;
 147                 b_usec = tvp->tv_usec;
 148                 break;
 149         case -3: /* Default + Date*/
 150                 s = (tvp->tv_sec + thiszone) % 86400;
 151                 Time = (tvp->tv_sec + thiszone) - s;
 152                 tm = gmtime (&Time);
 153                 if (!tm)
 154                         printf("Date fail  ");
 155                 else
 156                         printf("%04d-%02d-%02d ",
 157                                    tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday);
 158                 printf("%02d:%02d:%02d.%06u ",
 159                            s / 3600, (s % 3600) / 60, s % 60, (unsigned)tvp->tv_usec);
 160                 break;
 161         }
 162 }
 163
 164 /*
 165  * Print a relative number of seconds (e.g. hold time, prune timer)
 166  * in the form 5m1s.  This does no truncation, so 32230861 seconds
 167  * is represented as 1y1w1d1h1m1s.
 168  */
 169 void
 170 relts_print(int secs)
 171 {
 172         static const char *lengths[] = {"y", "w", "d", "h", "m", "s"};
 173         static const int seconds[] = {31536000, 604800, 86400, 3600, 60, 1};
 174         const char **l = lengths;
 175         const int *s = seconds;
 176
 177         if (secs == 0) {
 178                 (void)printf("0s");
 179                 return;
 180         }
 181         if (secs < 0) {
 182                 (void)printf("-");
 183                 secs = -secs;
 184         }
 185         while (secs > 0) {
 186                 if (secs >= *s) {
 187                         (void)printf("%d%s", secs / *s, *l);
 188                         secs -= (secs / *s) * *s;
 189                 }
 190                 s++;
 191                 l++;
 192         }
 193 }
 194
 195 /*
 196  *  this is a generic routine for printing unknown data;
 197  *  we pass on the linefeed plus indentation string to
 198  *  get a proper output - returns 0 on error
 199  */
 200
 201 int
 202 print_unknown_data(const u_char *cp,const char *ident,int len)
 203 {
 204         hex_print(ident,cp,len);
 205         return(1); /* everything is ok */
 206 }
 207
 208 /*
 209  * Convert a token value to a string; use "fmt" if not found.
 210  */
 211 const char *
 212 tok2str(register const struct tok *lp, register const char *fmt,
 213         register int v)
 214 {
 215         static char buf[4][128];
 216         static int idx = 0;
 217         char *ret;
 218
 219         while (lp->s != NULL) {
 220                 if (lp->v == v)
 221                         return (lp->s);
 222                 ++lp;
 223         }
 224         if (fmt == NULL)
 225                 fmt = "#%d";
 226         ret = buf[idx];
 227         (void)snprintf(ret, sizeof(buf[0]), fmt, v);
 228         idx = (idx+1) & 3;
 229         return (ret);
 230 }
 231
 232 /*
 233  * Convert a bit token value to a string; use "fmt" if not found.
 234  * this is useful for parsing bitfields, the output strings are comma seperated
 235  */
 236 char *
 237 bittok2str(register const struct tok *lp, register const char *fmt,
 238         register int v)
 239 {
 240         static char buf[256]; /* our stringbuffer */
 241         int buflen=0;
 242         register int rotbit; /* this is the bit we rotate through all bitpositions */
 243         register int tokval;
 244
 245         while (lp->s != NULL) {
 246             tokval=lp->v;   /* load our first value */
 247             rotbit=1;
 248             while (rotbit != 0) {
 249                 /*
 250                  * lets AND the rotating bit with our token value
 251                  * and see if we have got a match
 252                  */
 253                 if (tokval == (v&rotbit)) {
 254                     /* ok we have found something */
 255                     buflen+=snprintf(buf+buflen, sizeof(buf)-buflen, "%s, ",lp->s);
 256                     break;
 257                 }
 258                 rotbit=rotbit<<1; /* no match - lets shift and try again */
 259             }
 260             lp++;
 261         }
 262
 263         if (buflen != 0) { /* did we find anything */
 264             /* yep, set the the trailing zero 2 bytes before to eliminate the last comma & whitespace */
 265             buf[buflen-2] = '\0';
 266             return (buf);
 267         }
 268         else {
 269             /* bummer - lets print the "unknown" message as advised in the fmt string if we got one */
 270             if (fmt == NULL)
 271                 fmt = "#%d";
 272             (void)snprintf(buf, sizeof(buf), fmt, v);
 273             return (buf);
 274         }
 275 }
 276
 277 /*
 278  * Convert a value to a string using an array; the macro
 279  * tok2strary() in <interface.h> is the public interface to
 280  * this function and ensures that the second argument is
 281  * correct for bounds-checking.
 282  */
 283 const char *
 284 tok2strary_internal(register const char **lp, int n, register const char *fmt,
 285         register int v)
 286 {
 287         static char buf[128];
 288
 289         if (v >= 0 && v < n && lp[v] != NULL)
 290                 return lp[v];
 291         if (fmt == NULL)
 292                 fmt = "#%d";
 293         (void)snprintf(buf, sizeof(buf), fmt, v);
 294         return (buf);
 295 }
 296
 297 /*
 298  * Convert a 32-bit netmask to prefixlen if possible
 299  * the function returns the prefix-len; if plen == -1
 300  * then conversion was not possible;
 301  */
 302
 303 int
 304 mask2plen (u_int32_t mask)
 305 {
 306         u_int32_t bitmasks[33] = {
 307                 0x00000000,
 308                 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000,
 309                 0xf8000000, 0xfc000000, 0xfe000000, 0xff000000,
 310                 0xff800000, 0xffc00000, 0xffe00000, 0xfff00000,
 311                 0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000,
 312                 0xffff8000, 0xffffc000, 0xffffe000, 0xfffff000,
 313                 0xfffff800, 0xfffffc00, 0xfffffe00, 0xffffff00,
 314                 0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0,
 315                 0xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff
 316         };
 317         int prefix_len = 32;
 318
 319         /* let's see if we can transform the mask into a prefixlen */
 320         while (prefix_len >= 0) {
 321                 if (bitmasks[prefix_len] == mask)
 322                         break;
 323                 prefix_len--;
 324         }
 325         return (prefix_len);
 326 }
 327
 328 /* VARARGS */
 329 void
 330 error(const char *fmt, ...)
 331 {
 332         va_list ap;
 333
 334         (void)fprintf(stderr, "%s: ", program_name);
 335         va_start(ap, fmt);
 336         (void)vfprintf(stderr, fmt, ap);
 337         va_end(ap);
 338         if (*fmt) {
 339                 fmt += strlen(fmt);
 340                 if (fmt[-1] != '\n')
 341                         (void)fputc('\n', stderr);
 342         }
 343         exit(1);
 344         /* NOTREACHED */
 345 }
 346
 347 /* VARARGS */
 348 void
 349 warning(const char *fmt, ...)
 350 {
 351         va_list ap;
 352
 353         (void)fprintf(stderr, "%s: WARNING: ", program_name);
 354         va_start(ap, fmt);
 355         (void)vfprintf(stderr, fmt, ap);
 356         va_end(ap);
 357         if (*fmt) {
 358                 fmt += strlen(fmt);
 359                 if (fmt[-1] != '\n')
 360                         (void)fputc('\n', stderr);
 361         }
 362 }
 363
 364 /*
 365  * Copy arg vector into a new buffer, concatenating arguments with spaces.
 366  */
 367 char *
 368 copy_argv(register char **argv)
 369 {
 370         register char **p;
 371         register u_int len = 0;
 372         char *buf;
 373         char *src, *dst;
 374
 375         p = argv;
 376         if (*p == 0)
 377                 return 0;
 378
 379         while (*p)
 380                 len += strlen(*p++) + 1;
 381
 382         buf = (char *)malloc(len);
 383         if (buf == NULL)
 384                 error("copy_argv: malloc");
 385
 386         p = argv;
 387         dst = buf;
 388         while ((src = *p++) != NULL) {
 389                 while ((*dst++ = *src++) != '\0')
 390                         ;
 391                 dst[-1] = ' ';
 392         }
 393         dst[-1] = '\0';
 394
 395         return buf;
 396 }
 397
 398 /*
 399  * On Windows, we need to open the file in binary mode, so that
 400  * we get all the bytes specified by the size we get from "fstat()".
 401  * On UNIX, that's not necessary.  O_BINARY is defined on Windows;
 402  * we define it as 0 if it's not defined, so it does nothing.
 403  */
 404 #ifndef O_BINARY
 405 #define O_BINARY        0
 406 #endif
 407
 408 char *
 409 read_infile(char *fname)
 410 {
 411         register int i, fd, cc;
 412         register char *cp;
 413         struct stat buf;
 414
 415         fd = open(fname, O_RDONLY|O_BINARY);
 416         if (fd < 0)
 417                 error("can't open %s: %s", fname, pcap_strerror(errno));
 418
 419         if (fstat(fd, &buf) < 0)
 420                 error("can't stat %s: %s", fname, pcap_strerror(errno));
 421
 422         cp = malloc((u_int)buf.st_size + 1);
 423         if (cp == NULL)
 424                 error("malloc(%d) for %s: %s", (u_int)buf.st_size + 1,
 425                         fname, pcap_strerror(errno));
 426         cc = read(fd, cp, (u_int)buf.st_size);
 427         if (cc < 0)
 428                 error("read %s: %s", fname, pcap_strerror(errno));
 429         if (cc != buf.st_size)
 430                 error("short read %s (%d != %d)", fname, cc, (int)buf.st_size);
 431
 432         close(fd);
 433         /* replace "# comment" with spaces */
 434         for (i = 0; i < cc; i++) {
 435                 if (cp[i] == '#')
 436                         while (i < cc && cp[i] != '\n')
 437                                 cp[i++] = ' ';
 438         }
 439         cp[cc] = '\0';
 440         return (cp);
 441 }
 442
 443 void
 444 safeputs(const char *s)
 445 {
 446         while (*s) {
 447                 safeputchar(*s);
 448                 s++;
 449         }
 450 }
 451
 452 void
 453 safeputchar(int c)
 454 {
 455         unsigned char ch;
 456
 457         ch = (unsigned char)(c & 0xff);
 458         if (ch < 0x80 && isprint(ch))
 459                 printf("%c", ch);
 460         else
 461                 printf("\\%03o", ch);
 462 }