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 } 531
