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.109 2007-01-29 09:59:42 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 char * ts_format(register int, register int); 48 49 /* 50 * Print out a null-terminated filename (or other ascii string). 51 * If ep is NULL, assume no truncation check is needed. 52 * Return true if truncated. 53 */ 54 int 55 fn_print(register const u_char *s, register const u_char *ep) 56 { 57 register int ret; 58 register u_char c; 59 60 ret = 1; /* assume truncated */ 61 while (ep == NULL || s < ep) { 62 c = *s++; 63 if (c == '\0') { 64 ret = 0; 65 break; 66 } 67 if (!ND_ISASCII(c)) { 68 c = ND_TOASCII(c); 69 putchar('M'); 70 putchar('-'); 71 } 72 if (!ND_ISPRINT(c)) { 73 c ^= 0x40; /* DEL to ?, others to alpha */ 74 putchar('^'); 75 } 76 putchar(c); 77 } 78 return(ret); 79 } 80 81 /* 82 * Print out a counted filename (or other ascii string). 83 * If ep is NULL, assume no truncation check is needed. 84 * Return true if truncated. 85 */ 86 int 87 fn_printn(register const u_char *s, register u_int n, 88 register const u_char *ep) 89 { 90 register u_char c; 91 92 while (n > 0 && (ep == NULL || s < ep)) { 93 n--; 94 c = *s++; 95 if (!ND_ISASCII(c)) { 96 c = ND_TOASCII(c); 97 putchar('M'); 98 putchar('-'); 99 } 100 if (!ND_ISPRINT(c)) { 101 c ^= 0x40; /* DEL to ?, others to alpha */ 102 putchar('^'); 103 } 104 putchar(c); 105 } 106 return (n == 0) ? 0 : 1; 107 } 108 109 /* 110 * Print out a null-padded filename (or other ascii string). 111 * If ep is NULL, assume no truncation check is needed. 112 * Return true if truncated. 113 */ 114 int 115 fn_printzp(register const u_char *s, register u_int n, 116 register const u_char *ep) 117 { 118 register int ret; 119 register u_char c; 120 121 ret = 1; /* assume truncated */ 122 while (n > 0 && (ep == NULL || s < ep)) { 123 n--; 124 c = *s++; 125 if (c == '\0') { 126 ret = 0; 127 break; 128 } 129 if (!ND_ISASCII(c)) { 130 c = ND_TOASCII(c); 131 putchar('M'); 132 putchar('-'); 133 } 134 if (!ND_ISPRINT(c)) { 135 c ^= 0x40; /* DEL to ?, others to alpha */ 136 putchar('^'); 137 } 138 putchar(c); 139 } 140 return (n == 0) ? 0 : ret; 141 } 142 143 /* 144 * Format the timestamp 145 */ 146 char * 147 ts_format(register int sec, register int usec) 148 { 149 static char buf[sizeof("00:00:00.000000")]; 150 (void)snprintf(buf, sizeof(buf), "%02d:%02d:%02d.%06u", 151 sec / 3600, (sec % 3600) / 60, sec % 60, usec); 152 153 return buf; 154 } 155 156 /* 157 * Print the timestamp 158 */ 159 void 160 ts_print(register const struct timeval *tvp) 161 { 162 register int s; 163 struct tm *tm; 164 time_t Time; 165 static unsigned b_sec; 166 static unsigned b_usec; 167 int d_usec; 168 int d_sec; 169 170 switch (tflag) { 171 172 case 0: /* Default */ 173 s = (tvp->tv_sec + thiszone) % 86400; 174 (void)printf("%s ", ts_format(s, tvp->tv_usec)); 175 break; 176 177 case 1: /* No time stamp */ 178 break; 179 180 case 2: /* Unix timeval style */ 181 (void)printf("%u.%06u ", 182 (unsigned)tvp->tv_sec, 183 (unsigned)tvp->tv_usec); 184 break; 185 186 case 3: /* Microseconds since previous packet */ 187 case 5: /* Microseconds since first packet */ 188 if (b_sec == 0) { 189 /* init timestamp for first packet */ 190 b_usec = tvp->tv_usec; 191 b_sec = tvp->tv_sec; 192 } 193 194 d_usec = tvp->tv_usec - b_usec; 195 d_sec = tvp->tv_sec - b_sec; 196 197 while (d_usec < 0) { 198 d_usec += 1000000; 199 d_sec--; 200 } 201 202 (void)printf("%s ", ts_format(d_sec, d_usec)); 203 204 if (tflag == 3) { /* set timestamp for last packet */ 205 b_sec = tvp->tv_sec; 206 b_usec = tvp->tv_usec; 207 } 208 break; 209 210 case 4: /* Default + Date*/ 211 s = (tvp->tv_sec + thiszone) % 86400; 212 Time = (tvp->tv_sec + thiszone) - s; 213 tm = gmtime (&Time); 214 if (!tm) 215 printf("Date fail "); 216 else 217 printf("%04d-%02d-%02d %s ", 218 tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday, 219 ts_format(s, tvp->tv_usec)); 220 break; 221 } 222 } 223 224 /* 225 * Print a relative number of seconds (e.g. hold time, prune timer) 226 * in the form 5m1s. This does no truncation, so 32230861 seconds 227 * is represented as 1y1w1d1h1m1s. 228 */ 229 void 230 relts_print(int secs) 231 { 232 static const char *lengths[] = {"y", "w", "d", "h", "m", "s"}; 233 static const int seconds[] = {31536000, 604800, 86400, 3600, 60, 1}; 234 const char **l = lengths; 235 const int *s = seconds; 236 237 if (secs == 0) { 238 (void)printf("0s"); 239 return; 240 } 241 if (secs < 0) { 242 (void)printf("-"); 243 secs = -secs; 244 } 245 while (secs > 0) { 246 if (secs >= *s) { 247 (void)printf("%d%s", secs / *s, *l); 248 secs -= (secs / *s) * *s; 249 } 250 s++; 251 l++; 252 } 253 } 254 255 /* 256 * this is a generic routine for printing unknown data; 257 * we pass on the linefeed plus indentation string to 258 * get a proper output - returns 0 on error 259 */ 260 261 int 262 print_unknown_data(const u_char *cp,const char *ident,int len) 263 { 264 if (len < 0) { 265 printf("%sDissector error: print_unknown_data called with negative length", 266 ident); 267 return(0); 268 } 269 if (snapend - cp < len) 270 len = snapend - cp; 271 if (len < 0) { 272 printf("%sDissector error: print_unknown_data called with pointer past end of packet", 273 ident); 274 return(0); 275 } 276 hex_print(ident,cp,len); 277 return(1); /* everything is ok */ 278 } 279 280 /* 281 * Convert a token value to a string; use "fmt" if not found. 282 */ 283 const char * 284 tok2strbuf(register const struct tok *lp, register const char *fmt, 285 register int v, char *buf, size_t bufsize) 286 { 287 if (lp != NULL) { 288 while (lp->s != NULL) { 289 if (lp->v == v) 290 return (lp->s); 291 ++lp; 292 } 293 } 294 if (fmt == NULL) 295 fmt = "#%d"; 296 297 (void)snprintf(buf, bufsize, fmt, v); 298 return (const char *)buf; 299 } 300 301 /* 302 * Convert a token value to a string; use "fmt" if not found. 303 */ 304 const char * 305 tok2str(register const struct tok *lp, register const char *fmt, 306 register int v) 307 { 308 static char buf[4][128]; 309 static int idx = 0; 310 char *ret; 311 312 ret = buf[idx]; 313 idx = (idx+1) & 3; 314 return tok2strbuf(lp, fmt, v, ret, sizeof(buf[0])); 315 } 316 317 /* 318 * Convert a bit token value to a string; use "fmt" if not found. 319 * this is useful for parsing bitfields, the output strings are seperated 320 * if the s field is positive. 321 */ 322 static char * 323 bittok2str_internal(register const struct tok *lp, register const char *fmt, 324 register int v, register int sep) 325 { 326 static char buf[256]; /* our stringbuffer */ 327 int buflen=0; 328 register int rotbit; /* this is the bit we rotate through all bitpositions */ 329 register int tokval; 330 331 while (lp != NULL && lp->s != NULL) { 332 tokval=lp->v; /* load our first value */ 333 rotbit=1; 334 while (rotbit != 0) { 335 /* 336 * lets AND the rotating bit with our token value 337 * and see if we have got a match 338 */ 339 if (tokval == (v&rotbit)) { 340 /* ok we have found something */ 341 buflen+=snprintf(buf+buflen, sizeof(buf)-buflen, "%s%s", 342 lp->s, sep ? ", " : ""); 343 break; 344 } 345 rotbit=rotbit<<1; /* no match - lets shift and try again */ 346 } 347 lp++; 348 } 349 350 /* user didn't want string seperation - no need to cut off trailing seperators */ 351 if (!sep) { 352 return (buf); 353 } 354 355 if (buflen != 0) { /* did we find anything */ 356 /* yep, set the the trailing zero 2 bytes before to eliminate the last comma & whitespace */ 357 buf[buflen-2] = '\0'; 358 return (buf); 359 } 360 else { 361 /* bummer - lets print the "unknown" message as advised in the fmt string if we got one */ 362 if (fmt == NULL) 363 fmt = "#%d"; 364 (void)snprintf(buf, sizeof(buf), fmt, v); 365 return (buf); 366 } 367 } 368 369 /* 370 * Convert a bit token value to a string; use "fmt" if not found. 371 * this is useful for parsing bitfields, the output strings are not seperated. 372 */ 373 char * 374 bittok2str_nosep(register const struct tok *lp, register const char *fmt, 375 register int v) 376 { 377 return (bittok2str_internal(lp, fmt, v, 0)); 378 } 379 380 /* 381 * Convert a bit token value to a string; use "fmt" if not found. 382 * this is useful for parsing bitfields, the output strings are comma seperated. 383 */ 384 char * 385 bittok2str(register const struct tok *lp, register const char *fmt, 386 register int v) 387 { 388 return (bittok2str_internal(lp, fmt, v, 1)); 389 } 390 391 /* 392 * Convert a value to a string using an array; the macro 393 * tok2strary() in <interface.h> is the public interface to 394 * this function and ensures that the second argument is 395 * correct for bounds-checking. 396 */ 397 const char * 398 tok2strary_internal(register const char **lp, int n, register const char *fmt, 399 register int v) 400 { 401 static char buf[128]; 402 403 if (v >= 0 && v < n && lp[v] != NULL) 404 return lp[v]; 405 if (fmt == NULL) 406 fmt = "#%d"; 407 (void)snprintf(buf, sizeof(buf), fmt, v); 408 return (buf); 409 } 410 411 /* 412 * Convert a 32-bit netmask to prefixlen if possible 413 * the function returns the prefix-len; if plen == -1 414 * then conversion was not possible; 415 */ 416 417 int 418 mask2plen(u_int32_t mask) 419 { 420 u_int32_t bitmasks[33] = { 421 0x00000000, 422 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000, 423 0xf8000000, 0xfc000000, 0xfe000000, 0xff000000, 424 0xff800000, 0xffc00000, 0xffe00000, 0xfff00000, 425 0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000, 426 0xffff8000, 0xffffc000, 0xffffe000, 0xfffff000, 427 0xfffff800, 0xfffffc00, 0xfffffe00, 0xffffff00, 428 0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0, 429 0xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff 430 }; 431 int prefix_len = 32; 432 433 /* let's see if we can transform the mask into a prefixlen */ 434 while (prefix_len >= 0) { 435 if (bitmasks[prefix_len] == mask) 436 break; 437 prefix_len--; 438 } 439 return (prefix_len); 440 } 441 442 #ifdef INET6 443 int 444 mask62plen(const u_char *mask) 445 { 446 u_char bitmasks[9] = { 447 0x00, 448 0x80, 0xc0, 0xe0, 0xf0, 449 0xf8, 0xfc, 0xfe, 0xff 450 }; 451 int byte; 452 int cidr_len = 0; 453 454 for (byte = 0; byte < 16; byte++) { 455 u_int bits; 456 457 for (bits = 0; bits < (sizeof (bitmasks) / sizeof (bitmasks[0])); bits++) { 458 if (mask[byte] == bitmasks[bits]) { 459 cidr_len += bits; 460 break; 461 } 462 } 463 464 if (mask[byte] != 0xff) 465 break; 466 } 467 return (cidr_len); 468 } 469 #endif /* INET6 */ 470 471 /* VARARGS */ 472 void 473 error(const char *fmt, ...) 474 { 475 va_list ap; 476 477 (void)fprintf(stderr, "%s: ", program_name); 478 va_start(ap, fmt); 479 (void)vfprintf(stderr, fmt, ap); 480 va_end(ap); 481 if (*fmt) { 482 fmt += strlen(fmt); 483 if (fmt[-1] != '\n') 484 (void)fputc('\n', stderr); 485 } 486 exit(1); 487 /* NOTREACHED */ 488 } 489 490 /* VARARGS */ 491 void 492 warning(const char *fmt, ...) 493 { 494 va_list ap; 495 496 (void)fprintf(stderr, "%s: WARNING: ", program_name); 497 va_start(ap, fmt); 498 (void)vfprintf(stderr, fmt, ap); 499 va_end(ap); 500 if (*fmt) { 501 fmt += strlen(fmt); 502 if (fmt[-1] != '\n') 503 (void)fputc('\n', stderr); 504 } 505 } 506 507 /* 508 * Copy arg vector into a new buffer, concatenating arguments with spaces. 509 */ 510 char * 511 copy_argv(register char **argv) 512 { 513 register char **p; 514 register u_int len = 0; 515 char *buf; 516 char *src, *dst; 517 518 p = argv; 519 if (*p == 0) 520 return 0; 521 522 while (*p) 523 len += strlen(*p++) + 1; 524 525 buf = (char *)malloc(len); 526 if (buf == NULL) 527 error("copy_argv: malloc"); 528 529 p = argv; 530 dst = buf; 531 while ((src = *p++) != NULL) { 532 while ((*dst++ = *src++) != '\0') 533 ; 534 dst[-1] = ' '; 535 } 536 dst[-1] = '\0'; 537 538 return buf; 539 } 540 541 /* 542 * On Windows, we need to open the file in binary mode, so that 543 * we get all the bytes specified by the size we get from "fstat()". 544 * On UNIX, that's not necessary. O_BINARY is defined on Windows; 545 * we define it as 0 if it's not defined, so it does nothing. 546 */ 547 #ifndef O_BINARY 548 #define O_BINARY 0 549 #endif 550 551 char * 552 read_infile(char *fname) 553 { 554 register int i, fd, cc; 555 register char *cp; 556 struct stat buf; 557 558 fd = open(fname, O_RDONLY|O_BINARY); 559 if (fd < 0) 560 error("can't open %s: %s", fname, pcap_strerror(errno)); 561 562 if (fstat(fd, &buf) < 0) 563 error("can't stat %s: %s", fname, pcap_strerror(errno)); 564 565 cp = malloc((u_int)buf.st_size + 1); 566 if (cp == NULL) 567 error("malloc(%d) for %s: %s", (u_int)buf.st_size + 1, 568 fname, pcap_strerror(errno)); 569 cc = read(fd, cp, (u_int)buf.st_size); 570 if (cc < 0) 571 error("read %s: %s", fname, pcap_strerror(errno)); 572 if (cc != buf.st_size) 573 error("short read %s (%d != %d)", fname, cc, (int)buf.st_size); 574 575 close(fd); 576 /* replace "# comment" with spaces */ 577 for (i = 0; i < cc; i++) { 578 if (cp[i] == '#') 579 while (i < cc && cp[i] != '\n') 580 cp[i++] = ' '; 581 } 582 cp[cc] = '\0'; 583 return (cp); 584 } 585 586 void 587 safeputs(const char *s, int maxlen) 588 { 589 int idx = 0; 590 591 while (*s && idx < maxlen) { 592 safeputchar(*s); 593 idx++; 594 s++; 595 } 596 } 597 598 void 599 safeputchar(int c) 600 { 601 unsigned char ch; 602 603 ch = (unsigned char)(c & 0xff); 604 if (ch < 0x80 && ND_ISPRINT(ch)) 605 printf("%c", ch); 606 else 607 printf("\\0x%02x", ch); 608 } 609 610 #ifdef LBL_ALIGN 611 /* 612 * Some compilers try to optimize memcpy(), using the alignment constraint 613 * on the argument pointer type. by using this function, we try to avoid the 614 * optimization. 615 */ 616 void 617 unaligned_memcpy(void *p, const void *q, size_t l) 618 { 619 memcpy(p, q, l); 620 } 621 622 /* As with memcpy(), so with memcmp(). */ 623 int 624 unaligned_memcmp(const void *p, const void *q, size_t l) 625 { 626 return (memcmp(p, q, l)); 627 } 628 #endif 629
