contrib/tcpdump-3.9/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.95.2.6 2006/02/08 01:40:09 hannes 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 null-terminated 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 out a null-padded filename (or other ascii string).
 109  * If ep is NULL, assume no truncation check is needed.
 110  * Return true if truncated.
 111  */
 112 int
 113 fn_printzp(register const u_char *s, register u_int n,
 114           register const u_char *ep)
 115 {
 116         register int ret;
 117         register u_char c;
 118
 119         ret = 1;                        /* assume truncated */
 120         while (n > 0 && (ep == NULL || s < ep)) {
 121                 n--;
 122                 c = *s++;
 123                 if (c == '\0') {
 124                         ret = 0;
 125                         break;
 126                 }
 127                 if (!isascii(c)) {
 128                         c = toascii(c);
 129                         putchar('M');
 130                         putchar('-');
 131                 }
 132                 if (!isprint(c)) {
 133                         c ^= 0x40;      /* DEL to ?, others to alpha */
 134                         putchar('^');
 135                 }
 136                 putchar(c);
 137         }
 138         return (n == 0) ? 0 : ret;
 139 }
 140
 141 /*
 142  * Print the timestamp
 143  */
 144 void
 145 ts_print(register const struct timeval *tvp)
 146 {
 147         register int s;
 148         struct tm *tm;
 149         time_t Time;
 150         static unsigned b_sec;
 151         static unsigned b_usec;
 152
 153         switch (tflag) {
 154
 155         case 0: /* Default */
 156                 s = (tvp->tv_sec + thiszone) % 86400;
 157                 (void)printf("%02d:%02d:%02d.%06u ",
 158                              s / 3600, (s % 3600) / 60, s % 60,
 159                              (unsigned)tvp->tv_usec);
 160                 break;
 161
 162         case 1: /* No time stamp */
 163                 break;
 164
 165         case 2: /* Unix timeval style */
 166                 (void)printf("%u.%06u ",
 167                              (unsigned)tvp->tv_sec,
 168                              (unsigned)tvp->tv_usec);
 169                 break;
 170
 171         case 3: /* Microseconds since previous packet */
 172                 if (b_sec == 0) {
 173                         printf("000000 ");
 174                 } else {
 175                         int d_usec = tvp->tv_usec - b_usec;
 176                         int d_sec = tvp->tv_sec - b_sec;
 177
 178                         while (d_usec < 0) {
 179                                 d_usec += 1000000;
 180                                 d_sec--;
 181                         }
 182                         if (d_sec)
 183                                 printf("%d. ", d_sec);
 184                         printf("%06d ", d_usec);
 185                 }
 186                 b_sec = tvp->tv_sec;
 187                 b_usec = tvp->tv_usec;
 188                 break;
 189
 190         case 4: /* Default + Date*/
 191                 s = (tvp->tv_sec + thiszone) % 86400;
 192                 Time = (tvp->tv_sec + thiszone) - s;
 193                 tm = gmtime (&Time);
 194                 if (!tm)
 195                         printf("Date fail  ");
 196                 else
 197                         printf("%04d-%02d-%02d ",
 198                                    tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday);
 199                 printf("%02d:%02d:%02d.%06u ",
 200                            s / 3600, (s % 3600) / 60, s % 60, (unsigned)tvp->tv_usec);
 201                 break;
 202         }
 203 }
 204
 205 /*
 206  * Print a relative number of seconds (e.g. hold time, prune timer)
 207  * in the form 5m1s.  This does no truncation, so 32230861 seconds
 208  * is represented as 1y1w1d1h1m1s.
 209  */
 210 void
 211 relts_print(int secs)
 212 {
 213         static const char *lengths[] = {"y", "w", "d", "h", "m", "s"};
 214         static const int seconds[] = {31536000, 604800, 86400, 3600, 60, 1};
 215         const char **l = lengths;
 216         const int *s = seconds;
 217
 218         if (secs == 0) {
 219                 (void)printf("0s");
 220                 return;
 221         }
 222         if (secs < 0) {
 223                 (void)printf("-");
 224                 secs = -secs;
 225         }
 226         while (secs > 0) {
 227                 if (secs >= *s) {
 228                         (void)printf("%d%s", secs / *s, *l);
 229                         secs -= (secs / *s) * *s;
 230                 }
 231                 s++;
 232                 l++;
 233         }
 234 }
 235
 236 /*
 237  *  this is a generic routine for printing unknown data;
 238  *  we pass on the linefeed plus indentation string to
 239  *  get a proper output - returns 0 on error
 240  */
 241
 242 int
 243 print_unknown_data(const u_char *cp,const char *ident,int len)
 244 {
 245         if (len < 0) {
 246                 printf("%sDissector error: print_unknown_data called with negative length",
 247                     ident);
 248                 return(0);
 249         }
 250         if (snapend - cp < len)
 251                 len = snapend - cp;
 252         if (len < 0) {
 253                 printf("%sDissector error: print_unknown_data called with pointer past end of packet",
 254                     ident);
 255                 return(0);
 256         }
 257         hex_print(ident,cp,len);
 258         return(1); /* everything is ok */
 259 }
 260
 261 /*
 262  * Convert a token value to a string; use "fmt" if not found.
 263  */
 264 const char *
 265 tok2strbuf(register const struct tok *lp, register const char *fmt,
 266            register int v, char *buf, size_t bufsize)
 267 {
 268         if (lp != NULL) {
 269                 while (lp->s != NULL) {
 270                         if (lp->v == v)
 271                                 return (lp->s);
 272                         ++lp;
 273                 }
 274         }
 275         if (fmt == NULL)
 276                 fmt = "#%d";
 277
 278         (void)snprintf(buf, bufsize, fmt, v);
 279         return (const char *)buf;
 280 }
 281
 282 /*
 283  * Convert a token value to a string; use "fmt" if not found.
 284  */
 285 const char *
 286 tok2str(register const struct tok *lp, register const char *fmt,
 287         register int v)
 288 {
 289         static char buf[4][128];
 290         static int idx = 0;
 291         char *ret;
 292
 293         ret = buf[idx];
 294         idx = (idx+1) & 3;
 295         return tok2strbuf(lp, fmt, v, ret, sizeof(buf[0]));
 296 }
 297
 298 /*
 299  * Convert a bit token value to a string; use "fmt" if not found.
 300  * this is useful for parsing bitfields, the output strings are comma seperated
 301  */
 302 char *
 303 bittok2str(register const struct tok *lp, register const char *fmt,
 304            register int v)
 305 {
 306         static char buf[256]; /* our stringbuffer */
 307         int buflen=0;
 308         register int rotbit; /* this is the bit we rotate through all bitpositions */
 309         register int tokval;
 310
 311         while (lp->s != NULL && lp != NULL) {
 312             tokval=lp->v;   /* load our first value */
 313             rotbit=1;
 314             while (rotbit != 0) {
 315                 /*
 316                  * lets AND the rotating bit with our token value
 317                  * and see if we have got a match
 318                  */
 319                 if (tokval == (v&rotbit)) {
 320                     /* ok we have found something */
 321                     buflen+=snprintf(buf+buflen, sizeof(buf)-buflen, "%s, ",lp->s);
 322                     break;
 323                 }
 324                 rotbit=rotbit<<1; /* no match - lets shift and try again */
 325             }
 326             lp++;
 327         }
 328
 329         if (buflen != 0) { /* did we find anything */
 330             /* yep, set the the trailing zero 2 bytes before to eliminate the last comma & whitespace */
 331             buf[buflen-2] = '\0';
 332             return (buf);
 333         }
 334         else {
 335             /* bummer - lets print the "unknown" message as advised in the fmt string if we got one */
 336             if (fmt == NULL)
 337                 fmt = "#%d";
 338             (void)snprintf(buf, sizeof(buf), fmt, v);
 339             return (buf);
 340         }
 341 }
 342
 343 /*
 344  * Convert a value to a string using an array; the macro
 345  * tok2strary() in <interface.h> is the public interface to
 346  * this function and ensures that the second argument is
 347  * correct for bounds-checking.
 348  */
 349 const char *
 350 tok2strary_internal(register const char **lp, int n, register const char *fmt,
 351         register int v)
 352 {
 353         static char buf[128];
 354
 355         if (v >= 0 && v < n && lp[v] != NULL)
 356                 return lp[v];
 357         if (fmt == NULL)
 358                 fmt = "#%d";
 359         (void)snprintf(buf, sizeof(buf), fmt, v);
 360         return (buf);
 361 }
 362
 363 /*
 364  * Convert a 32-bit netmask to prefixlen if possible
 365  * the function returns the prefix-len; if plen == -1
 366  * then conversion was not possible;
 367  */
 368
 369 int
 370 mask2plen (u_int32_t mask)
 371 {
 372         u_int32_t bitmasks[33] = {
 373                 0x00000000,
 374                 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000,
 375                 0xf8000000, 0xfc000000, 0xfe000000, 0xff000000,
 376                 0xff800000, 0xffc00000, 0xffe00000, 0xfff00000,
 377                 0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000,
 378                 0xffff8000, 0xffffc000, 0xffffe000, 0xfffff000,
 379                 0xfffff800, 0xfffffc00, 0xfffffe00, 0xffffff00,
 380                 0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0,
 381                 0xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff
 382         };
 383         int prefix_len = 32;
 384
 385         /* let's see if we can transform the mask into a prefixlen */
 386         while (prefix_len >= 0) {
 387                 if (bitmasks[prefix_len] == mask)
 388                         break;
 389                 prefix_len--;
 390         }
 391         return (prefix_len);
 392 }
 393
 394 /* VARARGS */
 395 void
 396 error(const char *fmt, ...)
 397 {
 398         va_list ap;
 399
 400         (void)fprintf(stderr, "%s: ", program_name);
 401         va_start(ap, fmt);
 402         (void)vfprintf(stderr, fmt, ap);
 403         va_end(ap);
 404         if (*fmt) {
 405                 fmt += strlen(fmt);
 406                 if (fmt[-1] != '\n')
 407                         (void)fputc('\n', stderr);
 408         }
 409         exit(1);
 410         /* NOTREACHED */
 411 }
 412
 413 /* VARARGS */
 414 void
 415 warning(const char *fmt, ...)
 416 {
 417         va_list ap;
 418
 419         (void)fprintf(stderr, "%s: WARNING: ", program_name);
 420         va_start(ap, fmt);
 421         (void)vfprintf(stderr, fmt, ap);
 422         va_end(ap);
 423         if (*fmt) {
 424                 fmt += strlen(fmt);
 425                 if (fmt[-1] != '\n')
 426                         (void)fputc('\n', stderr);
 427         }
 428 }
 429
 430 /*
 431  * Copy arg vector into a new buffer, concatenating arguments with spaces.
 432  */
 433 char *
 434 copy_argv(register char **argv)
 435 {
 436         register char **p;
 437         register u_int len = 0;
 438         char *buf;
 439         char *src, *dst;
 440
 441         p = argv;
 442         if (*p == 0)
 443                 return 0;
 444
 445         while (*p)
 446                 len += strlen(*p++) + 1;
 447
 448         buf = (char *)malloc(len);
 449         if (buf == NULL)
 450                 error("copy_argv: malloc");
 451
 452         p = argv;
 453         dst = buf;
 454         while ((src = *p++) != NULL) {
 455                 while ((*dst++ = *src++) != '\0')
 456                         ;
 457                 dst[-1] = ' ';
 458         }
 459         dst[-1] = '\0';
 460
 461         return buf;
 462 }
 463
 464 /*
 465  * On Windows, we need to open the file in binary mode, so that
 466  * we get all the bytes specified by the size we get from "fstat()".
 467  * On UNIX, that's not necessary.  O_BINARY is defined on Windows;
 468  * we define it as 0 if it's not defined, so it does nothing.
 469  */
 470 #ifndef O_BINARY
 471 #define O_BINARY        0
 472 #endif
 473
 474 char *
 475 read_infile(char *fname)
 476 {
 477         register int i, fd, cc;
 478         register char *cp;
 479         struct stat buf;
 480
 481         fd = open(fname, O_RDONLY|O_BINARY);
 482         if (fd < 0)
 483                 error("can't open %s: %s", fname, pcap_strerror(errno));
 484
 485         if (fstat(fd, &buf) < 0)
 486                 error("can't stat %s: %s", fname, pcap_strerror(errno));
 487
 488         cp = malloc((u_int)buf.st_size + 1);
 489         if (cp == NULL)
 490                 error("malloc(%d) for %s: %s", (u_int)buf.st_size + 1,
 491                         fname, pcap_strerror(errno));
 492         cc = read(fd, cp, (u_int)buf.st_size);
 493         if (cc < 0)
 494                 error("read %s: %s", fname, pcap_strerror(errno));
 495         if (cc != buf.st_size)
 496                 error("short read %s (%d != %d)", fname, cc, (int)buf.st_size);
 497
 498         close(fd);
 499         /* replace "# comment" with spaces */
 500         for (i = 0; i < cc; i++) {
 501                 if (cp[i] == '#')
 502                         while (i < cc && cp[i] != '\n')
 503                                 cp[i++] = ' ';
 504         }
 505         cp[cc] = '\0';
 506         return (cp);
 507 }
 508
 509 void
 510 safeputs(const char *s, int maxlen)
 511 {
 512     int idx = 0;
 513         while (*s && idx < maxlen) {
 514                 safeputchar(*s);
 515                 idx++;
 516                 s++;
 517         }
 518 }
 519
 520 void
 521 safeputchar(int c)
 522 {
 523         unsigned char ch;
 524
 525         ch = (unsigned char)(c & 0xff);
 526         if (ch < 0x80 && isprint(ch))
 527                 printf("%c", ch);
 528         else
 529                 printf("\\%03o", ch);
 530 }