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