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.98 2005-05-06 07:56:54 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 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 : 1;
 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 (snapend - cp < len)
 246                 len = snapend - cp;
 247         hex_print(ident,cp,len);
 248         return(1); /* everything is ok */
 249 }
 250
 251 /*
 252  * Convert a token value to a string; use "fmt" if not found.
 253  */
 254 const char *
 255 tok2strbuf(register const struct tok *lp, register const char *fmt,
 256            register int v, char *buf, size_t bufsize)
 257 {
 258         if (lp != NULL) {
 259                 while (lp->s != NULL) {
 260                         if (lp->v == v)
 261                                 return (lp->s);
 262                         ++lp;
 263                 }
 264         }
 265         if (fmt == NULL)
 266                 fmt = "#%d";
 267
 268         (void)snprintf(buf, bufsize, fmt, v);
 269         return (const char *)buf;
 270 }
 271
 272 /*
 273  * Convert a token value to a string; use "fmt" if not found.
 274  */
 275 const char *
 276 tok2str(register const struct tok *lp, register const char *fmt,
 277         register int v)
 278 {
 279         static char buf[4][128];
 280         static int idx = 0;
 281         char *ret;
 282
 283         ret = buf[idx];
 284         idx = (idx+1) & 3;
 285         return tok2strbuf(lp, fmt, v, ret, sizeof(buf[0]));
 286 }
 287
 288 /*
 289  * Convert a bit token value to a string; use "fmt" if not found.
 290  * this is useful for parsing bitfields, the output strings are comma seperated
 291  */
 292 char *
 293 bittok2str(register const struct tok *lp, register const char *fmt,
 294            register int v)
 295 {
 296         static char buf[256]; /* our stringbuffer */
 297         int buflen=0;
 298         register int rotbit; /* this is the bit we rotate through all bitpositions */
 299         register int tokval;
 300
 301         while (lp->s != NULL && lp != NULL) {
 302             tokval=lp->v;   /* load our first value */
 303             rotbit=1;
 304             while (rotbit != 0) {
 305                 /*
 306                  * lets AND the rotating bit with our token value
 307                  * and see if we have got a match
 308                  */
 309                 if (tokval == (v&rotbit)) {
 310                     /* ok we have found something */
 311                     buflen+=snprintf(buf+buflen, sizeof(buf)-buflen, "%s, ",lp->s);
 312                     break;
 313                 }
 314                 rotbit=rotbit<<1; /* no match - lets shift and try again */
 315             }
 316             lp++;
 317         }
 318
 319         if (buflen != 0) { /* did we find anything */
 320             /* yep, set the the trailing zero 2 bytes before to eliminate the last comma & whitespace */
 321             buf[buflen-2] = '\0';
 322             return (buf);
 323         }
 324         else {
 325             /* bummer - lets print the "unknown" message as advised in the fmt string if we got one */
 326             if (fmt == NULL)
 327                 fmt = "#%d";
 328             (void)snprintf(buf, sizeof(buf), fmt, v);
 329             return (buf);
 330         }
 331 }
 332
 333 /*
 334  * Convert a value to a string using an array; the macro
 335  * tok2strary() in <interface.h> is the public interface to
 336  * this function and ensures that the second argument is
 337  * correct for bounds-checking.
 338  */
 339 const char *
 340 tok2strary_internal(register const char **lp, int n, register const char *fmt,
 341         register int v)
 342 {
 343         static char buf[128];
 344
 345         if (v >= 0 && v < n && lp[v] != NULL)
 346                 return lp[v];
 347         if (fmt == NULL)
 348                 fmt = "#%d";
 349         (void)snprintf(buf, sizeof(buf), fmt, v);
 350         return (buf);
 351 }
 352
 353 /*
 354  * Convert a 32-bit netmask to prefixlen if possible
 355  * the function returns the prefix-len; if plen == -1
 356  * then conversion was not possible;
 357  */
 358
 359 int
 360 mask2plen (u_int32_t mask)
 361 {
 362         u_int32_t bitmasks[33] = {
 363                 0x00000000,
 364                 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000,
 365                 0xf8000000, 0xfc000000, 0xfe000000, 0xff000000,
 366                 0xff800000, 0xffc00000, 0xffe00000, 0xfff00000,
 367                 0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000,
 368                 0xffff8000, 0xffffc000, 0xffffe000, 0xfffff000,
 369                 0xfffff800, 0xfffffc00, 0xfffffe00, 0xffffff00,
 370                 0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0,
 371                 0xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff
 372         };
 373         int prefix_len = 32;
 374
 375         /* let's see if we can transform the mask into a prefixlen */
 376         while (prefix_len >= 0) {
 377                 if (bitmasks[prefix_len] == mask)
 378                         break;
 379                 prefix_len--;
 380         }
 381         return (prefix_len);
 382 }
 383
 384 /* VARARGS */
 385 void
 386 error(const char *fmt, ...)
 387 {
 388         va_list ap;
 389
 390         (void)fprintf(stderr, "%s: ", program_name);
 391         va_start(ap, fmt);
 392         (void)vfprintf(stderr, fmt, ap);
 393         va_end(ap);
 394         if (*fmt) {
 395                 fmt += strlen(fmt);
 396                 if (fmt[-1] != '\n')
 397                         (void)fputc('\n', stderr);
 398         }
 399         exit(1);
 400         /* NOTREACHED */
 401 }
 402
 403 /* VARARGS */
 404 void
 405 warning(const char *fmt, ...)
 406 {
 407         va_list ap;
 408
 409         (void)fprintf(stderr, "%s: WARNING: ", program_name);
 410         va_start(ap, fmt);
 411         (void)vfprintf(stderr, fmt, ap);
 412         va_end(ap);
 413         if (*fmt) {
 414                 fmt += strlen(fmt);
 415                 if (fmt[-1] != '\n')
 416                         (void)fputc('\n', stderr);
 417         }
 418 }
 419
 420 /*
 421  * Copy arg vector into a new buffer, concatenating arguments with spaces.
 422  */
 423 char *
 424 copy_argv(register char **argv)
 425 {
 426         register char **p;
 427         register u_int len = 0;
 428         char *buf;
 429         char *src, *dst;
 430
 431         p = argv;
 432         if (*p == 0)
 433                 return 0;
 434
 435         while (*p)
 436                 len += strlen(*p++) + 1;
 437
 438         buf = (char *)malloc(len);
 439         if (buf == NULL)
 440                 error("copy_argv: malloc");
 441
 442         p = argv;
 443         dst = buf;
 444         while ((src = *p++) != NULL) {
 445                 while ((*dst++ = *src++) != '\0')
 446                         ;
 447                 dst[-1] = ' ';
 448         }
 449         dst[-1] = '\0';
 450
 451         return buf;
 452 }
 453
 454 /*
 455  * On Windows, we need to open the file in binary mode, so that
 456  * we get all the bytes specified by the size we get from "fstat()".
 457  * On UNIX, that's not necessary.  O_BINARY is defined on Windows;
 458  * we define it as 0 if it's not defined, so it does nothing.
 459  */
 460 #ifndef O_BINARY
 461 #define O_BINARY        0
 462 #endif
 463
 464 char *
 465 read_infile(char *fname)
 466 {
 467         register int i, fd, cc;
 468         register char *cp;
 469         struct stat buf;
 470
 471         fd = open(fname, O_RDONLY|O_BINARY);
 472         if (fd < 0)
 473                 error("can't open %s: %s", fname, pcap_strerror(errno));
 474
 475         if (fstat(fd, &buf) < 0)
 476                 error("can't stat %s: %s", fname, pcap_strerror(errno));
 477
 478         cp = malloc((u_int)buf.st_size + 1);
 479         if (cp == NULL)
 480                 error("malloc(%d) for %s: %s", (u_int)buf.st_size + 1,
 481                         fname, pcap_strerror(errno));
 482         cc = read(fd, cp, (u_int)buf.st_size);
 483         if (cc < 0)
 484                 error("read %s: %s", fname, pcap_strerror(errno));
 485         if (cc != buf.st_size)
 486                 error("short read %s (%d != %d)", fname, cc, (int)buf.st_size);
 487
 488         close(fd);
 489         /* replace "# comment" with spaces */
 490         for (i = 0; i < cc; i++) {
 491                 if (cp[i] == '#')
 492                         while (i < cc && cp[i] != '\n')
 493                                 cp[i++] = ' ';
 494         }
 495         cp[cc] = '\0';
 496         return (cp);
 497 }
 498
 499 void
 500 safeputs(const char *s)
 501 {
 502         while (*s) {
 503                 safeputchar(*s);
 504                 s++;
 505         }
 506 }
 507
 508 void
 509 safeputchar(int c)
 510 {
 511         unsigned char ch;
 512
 513         ch = (unsigned char)(c & 0xff);
 514         if (ch < 0x80 && isprint(ch))
 515                 printf("%c", ch);
 516         else
 517                 printf("\\%03o", ch);
 518 }