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 /* 23 * txtproto_print() derived from original code by Hannes Gredler 24 * (hannes (at) juniper.net): 25 * 26 * Redistribution and use in source and binary forms, with or without 27 * modification, are permitted provided that: (1) source code 28 * distributions retain the above copyright notice and this paragraph 29 * in its entirety, and (2) distributions including binary code include 30 * the above copyright notice and this paragraph in its entirety in 31 * the documentation or other materials provided with the distribution. 32 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND 33 * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT 34 * LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 35 * FOR A PARTICULAR PURPOSE. 36 */ 37 38 #define NETDISSECT_REWORKED 39 #ifdef HAVE_CONFIG_H 40 #include "config.h" 41 #endif 42 43 #include <tcpdump-stdinc.h> 44 45 #include <sys/stat.h> 46 47 #ifdef HAVE_FCNTL_H 48 #include <fcntl.h> 49 #endif 50 #include <stdio.h> 51 #include <stdarg.h> 52 #include <stdlib.h> 53 #include <string.h> 54 55 #include "interface.h" 56 57 /* 58 * Print out a null-terminated filename (or other ascii string). 59 * If ep is NULL, assume no truncation check is needed. 60 * Return true if truncated. 61 */ 62 int 63 fn_print(netdissect_options *ndo, 64 register const u_char *s, register const u_char *ep) 65 { 66 register int ret; 67 register u_char c; 68 69 ret = 1; /* assume truncated */ 70 while (ep == NULL || s < ep) { 71 c = *s++; 72 if (c == '\0') { 73 ret = 0; 74 break; 75 } 76 if (!ND_ISASCII(c)) { 77 c = ND_TOASCII(c); 78 ND_PRINT((ndo, "M-")); 79 } 80 if (!ND_ISPRINT(c)) { 81 c ^= 0x40; /* DEL to ?, others to alpha */ 82 ND_PRINT((ndo, "^")); 83 } 84 ND_PRINT((ndo, "%c", c)); 85 } 86 return(ret); 87 } 88 89 /* 90 * Print out a counted filename (or other ascii string). 91 * If ep is NULL, assume no truncation check is needed. 92 * Return true if truncated. 93 */ 94 int 95 fn_printn(netdissect_options *ndo, 96 register const u_char *s, register u_int n, register const u_char *ep) 97 { 98 register u_char c; 99 100 while (n > 0 && (ep == NULL || s < ep)) { 101 n--; 102 c = *s++; 103 if (!ND_ISASCII(c)) { 104 c = ND_TOASCII(c); 105 ND_PRINT((ndo, "M-")); 106 } 107 if (!ND_ISPRINT(c)) { 108 c ^= 0x40; /* DEL to ?, others to alpha */ 109 ND_PRINT((ndo, "^")); 110 } 111 ND_PRINT((ndo, "%c", c)); 112 } 113 return (n == 0) ? 0 : 1; 114 } 115 116 /* 117 * Print out a null-padded filename (or other ascii string). 118 * If ep is NULL, assume no truncation check is needed. 119 * Return true if truncated. 120 */ 121 int 122 fn_printzp(netdissect_options *ndo, 123 register const u_char *s, register u_int n, 124 register const u_char *ep) 125 { 126 register int ret; 127 register u_char c; 128 129 ret = 1; /* assume truncated */ 130 while (n > 0 && (ep == NULL || s < ep)) { 131 n--; 132 c = *s++; 133 if (c == '\0') { 134 ret = 0; 135 break; 136 } 137 if (!ND_ISASCII(c)) { 138 c = ND_TOASCII(c); 139 ND_PRINT((ndo, "M-")); 140 } 141 if (!ND_ISPRINT(c)) { 142 c ^= 0x40; /* DEL to ?, others to alpha */ 143 ND_PRINT((ndo, "^")); 144 } 145 ND_PRINT((ndo, "%c", c)); 146 } 147 return (n == 0) ? 0 : ret; 148 } 149 150 /* 151 * Format the timestamp 152 */ 153 static char * 154 ts_format(netdissect_options *ndo 155 #ifndef HAVE_PCAP_SET_TSTAMP_PRECISION 156 _U_ 157 #endif 158 , int sec, int usec) 159 { 160 static char buf[sizeof("00:00:00.000000000")]; 161 const char *format; 162 163 #ifdef HAVE_PCAP_SET_TSTAMP_PRECISION 164 switch (ndo->ndo_tstamp_precision) { 165 166 case PCAP_TSTAMP_PRECISION_MICRO: 167 format = "%02d:%02d:%02d.%06u"; 168 break; 169 170 case PCAP_TSTAMP_PRECISION_NANO: 171 format = "%02d:%02d:%02d.%09u"; 172 break; 173 174 default: 175 format = "%02d:%02d:%02d.{unknown precision}"; 176 break; 177 } 178 #else 179 format = "%02d:%02d:%02d.%06u"; 180 #endif 181 182 snprintf(buf, sizeof(buf), format, 183 sec / 3600, (sec % 3600) / 60, sec % 60, usec); 184 185 return buf; 186 } 187 188 /* 189 * Print the timestamp 190 */ 191 void 192 ts_print(netdissect_options *ndo, 193 register const struct timeval *tvp) 194 { 195 register int s; 196 struct tm *tm; 197 time_t Time; 198 static unsigned b_sec; 199 static unsigned b_usec; 200 int d_usec; 201 int d_sec; 202 203 switch (ndo->ndo_tflag) { 204 205 case 0: /* Default */ 206 s = (tvp->tv_sec + thiszone) % 86400; 207 ND_PRINT((ndo, "%s ", ts_format(ndo, s, tvp->tv_usec))); 208 break; 209 210 case 1: /* No time stamp */ 211 break; 212 213 case 2: /* Unix timeval style */ 214 ND_PRINT((ndo, "%u.%06u ", 215 (unsigned)tvp->tv_sec, 216 (unsigned)tvp->tv_usec)); 217 break; 218 219 case 3: /* Microseconds since previous packet */ 220 case 5: /* Microseconds since first packet */ 221 if (b_sec == 0) { 222 /* init timestamp for first packet */ 223 b_usec = tvp->tv_usec; 224 b_sec = tvp->tv_sec; 225 } 226 227 d_usec = tvp->tv_usec - b_usec; 228 d_sec = tvp->tv_sec - b_sec; 229 230 while (d_usec < 0) { 231 d_usec += 1000000; 232 d_sec--; 233 } 234 235 ND_PRINT((ndo, "%s ", ts_format(ndo, d_sec, d_usec))); 236 237 if (ndo->ndo_tflag == 3) { /* set timestamp for last packet */ 238 b_sec = tvp->tv_sec; 239 b_usec = tvp->tv_usec; 240 } 241 break; 242 243 case 4: /* Default + Date*/ 244 s = (tvp->tv_sec + thiszone) % 86400; 245 Time = (tvp->tv_sec + thiszone) - s; 246 tm = gmtime (&Time); 247 if (!tm) 248 ND_PRINT((ndo, "Date fail ")); 249 else 250 ND_PRINT((ndo, "%04d-%02d-%02d %s ", 251 tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday, 252 ts_format(ndo, s, tvp->tv_usec))); 253 break; 254 } 255 } 256 257 /* 258 * Print a relative number of seconds (e.g. hold time, prune timer) 259 * in the form 5m1s. This does no truncation, so 32230861 seconds 260 * is represented as 1y1w1d1h1m1s. 261 */ 262 void 263 relts_print(netdissect_options *ndo, 264 int secs) 265 { 266 static const char *lengths[] = {"y", "w", "d", "h", "m", "s"}; 267 static const int seconds[] = {31536000, 604800, 86400, 3600, 60, 1}; 268 const char **l = lengths; 269 const int *s = seconds; 270 271 if (secs == 0) { 272 ND_PRINT((ndo, "0s")); 273 return; 274 } 275 if (secs < 0) { 276 ND_PRINT((ndo, "-")); 277 secs = -secs; 278 } 279 while (secs > 0) { 280 if (secs >= *s) { 281 ND_PRINT((ndo, "%d%s", secs / *s, *l)); 282 secs -= (secs / *s) * *s; 283 } 284 s++; 285 l++; 286 } 287 } 288 289 /* 290 * this is a generic routine for printing unknown data; 291 * we pass on the linefeed plus indentation string to 292 * get a proper output - returns 0 on error 293 */ 294 295 int 296 print_unknown_data(netdissect_options *ndo, const u_char *cp,const char *ident,int len) 297 { 298 if (len < 0) { 299 ND_PRINT((ndo,"%sDissector error: print_unknown_data called with negative length", 300 ident)); 301 return(0); 302 } 303 if (ndo->ndo_snapend - cp < len) 304 len = ndo->ndo_snapend - cp; 305 if (len < 0) { 306 ND_PRINT((ndo,"%sDissector error: print_unknown_data called with pointer past end of packet", 307 ident)); 308 return(0); 309 } 310 hex_print(ndo, ident,cp,len); 311 return(1); /* everything is ok */ 312 } 313 314 /* 315 * Convert a token value to a string; use "fmt" if not found. 316 */ 317 const char * 318 tok2strbuf(register const struct tok *lp, register const char *fmt, 319 register u_int v, char *buf, size_t bufsize) 320 { 321 if (lp != NULL) { 322 while (lp->s != NULL) { 323 if (lp->v == v) 324 return (lp->s); 325 ++lp; 326 } 327 } 328 if (fmt == NULL) 329 fmt = "#%d"; 330 331 (void)snprintf(buf, bufsize, fmt, v); 332 return (const char *)buf; 333 } 334 335 /* 336 * Convert a token value to a string; use "fmt" if not found. 337 */ 338 const char * 339 tok2str(register const struct tok *lp, register const char *fmt, 340 register u_int v) 341 { 342 static char buf[4][128]; 343 static int idx = 0; 344 char *ret; 345 346 ret = buf[idx]; 347 idx = (idx+1) & 3; 348 return tok2strbuf(lp, fmt, v, ret, sizeof(buf[0])); 349 } 350 351 /* 352 * Convert a bit token value to a string; use "fmt" if not found. 353 * this is useful for parsing bitfields, the output strings are seperated 354 * if the s field is positive. 355 */ 356 static char * 357 bittok2str_internal(register const struct tok *lp, register const char *fmt, 358 register u_int v, const char *sep) 359 { 360 static char buf[256]; /* our stringbuffer */ 361 int buflen=0; 362 register u_int rotbit; /* this is the bit we rotate through all bitpositions */ 363 register u_int tokval; 364 const char * sepstr = ""; 365 366 while (lp != NULL && lp->s != NULL) { 367 tokval=lp->v; /* load our first value */ 368 rotbit=1; 369 while (rotbit != 0) { 370 /* 371 * lets AND the rotating bit with our token value 372 * and see if we have got a match 373 */ 374 if (tokval == (v&rotbit)) { 375 /* ok we have found something */ 376 buflen+=snprintf(buf+buflen, sizeof(buf)-buflen, "%s%s", 377 sepstr, lp->s); 378 sepstr = sep; 379 break; 380 } 381 rotbit=rotbit<<1; /* no match - lets shift and try again */ 382 } 383 lp++; 384 } 385 386 if (buflen == 0) 387 /* bummer - lets print the "unknown" message as advised in the fmt string if we got one */ 388 (void)snprintf(buf, sizeof(buf), fmt == NULL ? "#%08x" : fmt, v); 389 return (buf); 390 } 391 392 /* 393 * Convert a bit token value to a string; use "fmt" if not found. 394 * this is useful for parsing bitfields, the output strings are not seperated. 395 */ 396 char * 397 bittok2str_nosep(register const struct tok *lp, register const char *fmt, 398 register u_int v) 399 { 400 return (bittok2str_internal(lp, fmt, v, "")); 401 } 402 403 /* 404 * Convert a bit token value to a string; use "fmt" if not found. 405 * this is useful for parsing bitfields, the output strings are comma seperated. 406 */ 407 char * 408 bittok2str(register const struct tok *lp, register const char *fmt, 409 register u_int v) 410 { 411 return (bittok2str_internal(lp, fmt, v, ", ")); 412 } 413 414 /* 415 * Convert a value to a string using an array; the macro 416 * tok2strary() in <interface.h> is the public interface to 417 * this function and ensures that the second argument is 418 * correct for bounds-checking. 419 */ 420 const char * 421 tok2strary_internal(register const char **lp, int n, register const char *fmt, 422 register int v) 423 { 424 static char buf[128]; 425 426 if (v >= 0 && v < n && lp[v] != NULL) 427 return lp[v]; 428 if (fmt == NULL) 429 fmt = "#%d"; 430 (void)snprintf(buf, sizeof(buf), fmt, v); 431 return (buf); 432 } 433 434 /* 435 * Convert a 32-bit netmask to prefixlen if possible 436 * the function returns the prefix-len; if plen == -1 437 * then conversion was not possible; 438 */ 439 440 int 441 mask2plen(uint32_t mask) 442 { 443 uint32_t bitmasks[33] = { 444 0x00000000, 445 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000, 446 0xf8000000, 0xfc000000, 0xfe000000, 0xff000000, 447 0xff800000, 0xffc00000, 0xffe00000, 0xfff00000, 448 0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000, 449 0xffff8000, 0xffffc000, 0xffffe000, 0xfffff000, 450 0xfffff800, 0xfffffc00, 0xfffffe00, 0xffffff00, 451 0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0, 452 0xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff 453 }; 454 int prefix_len = 32; 455 456 /* let's see if we can transform the mask into a prefixlen */ 457 while (prefix_len >= 0) { 458 if (bitmasks[prefix_len] == mask) 459 break; 460 prefix_len--; 461 } 462 return (prefix_len); 463 } 464 465 #ifdef INET6 466 int 467 mask62plen(const u_char *mask) 468 { 469 u_char bitmasks[9] = { 470 0x00, 471 0x80, 0xc0, 0xe0, 0xf0, 472 0xf8, 0xfc, 0xfe, 0xff 473 }; 474 int byte; 475 int cidr_len = 0; 476 477 for (byte = 0; byte < 16; byte++) { 478 u_int bits; 479 480 for (bits = 0; bits < (sizeof (bitmasks) / sizeof (bitmasks[0])); bits++) { 481 if (mask[byte] == bitmasks[bits]) { 482 cidr_len += bits; 483 break; 484 } 485 } 486 487 if (mask[byte] != 0xff) 488 break; 489 } 490 return (cidr_len); 491 } 492 #endif /* INET6 */ 493 494 /* 495 * Routine to print out information for text-based protocols such as FTP, 496 * HTTP, SMTP, RTSP, SIP, .... 497 */ 498 #define MAX_TOKEN 128 499 500 /* 501 * Fetch a token from a packet, starting at the specified index, 502 * and return the length of the token. 503 * 504 * Returns 0 on error; yes, this is indistinguishable from an empty 505 * token, but an "empty token" isn't a valid token - it just means 506 * either a space character at the beginning of the line (this 507 * includes a blank line) or no more tokens remaining on the line. 508 */ 509 static int 510 fetch_token(netdissect_options *ndo, const u_char *pptr, u_int idx, u_int len, 511 u_char *tbuf, size_t tbuflen) 512 { 513 size_t toklen = 0; 514 515 for (; idx < len; idx++) { 516 if (!ND_TTEST(*(pptr + idx))) { 517 /* ran past end of captured data */ 518 return (0); 519 } 520 if (!isascii(*(pptr + idx))) { 521 /* not an ASCII character */ 522 return (0); 523 } 524 if (isspace(*(pptr + idx))) { 525 /* end of token */ 526 break; 527 } 528 if (!isprint(*(pptr + idx))) { 529 /* not part of a command token or response code */ 530 return (0); 531 } 532 if (toklen + 2 > tbuflen) { 533 /* no room for this character and terminating '\0' */ 534 return (0); 535 } 536 tbuf[toklen] = *(pptr + idx); 537 toklen++; 538 } 539 if (toklen == 0) { 540 /* no token */ 541 return (0); 542 } 543 tbuf[toklen] = '\0'; 544 545 /* 546 * Skip past any white space after the token, until we see 547 * an end-of-line (CR or LF). 548 */ 549 for (; idx < len; idx++) { 550 if (!ND_TTEST(*(pptr + idx))) { 551 /* ran past end of captured data */ 552 break; 553 } 554 if (*(pptr + idx) == '\r' || *(pptr + idx) == '\n') { 555 /* end of line */ 556 break; 557 } 558 if (!isascii(*(pptr + idx)) || !isprint(*(pptr + idx))) { 559 /* not a printable ASCII character */ 560 break; 561 } 562 if (!isspace(*(pptr + idx))) { 563 /* beginning of next token */ 564 break; 565 } 566 } 567 return (idx); 568 } 569 570 /* 571 * Scan a buffer looking for a line ending - LF or CR-LF. 572 * Return the index of the character after the line ending or 0 if 573 * we encounter a non-ASCII or non-printable character or don't find 574 * the line ending. 575 */ 576 static u_int 577 print_txt_line(netdissect_options *ndo, const char *protoname, 578 const char *prefix, const u_char *pptr, u_int idx, u_int len) 579 { 580 u_int startidx; 581 u_int linelen; 582 583 startidx = idx; 584 while (idx < len) { 585 ND_TCHECK(*(pptr+idx)); 586 if (*(pptr+idx) == '\n') { 587 /* 588 * LF without CR; end of line. 589 * Skip the LF and print the line, with the 590 * exception of the LF. 591 */ 592 linelen = idx - startidx; 593 idx++; 594 goto print; 595 } else if (*(pptr+idx) == '\r') { 596 /* CR - any LF? */ 597 if ((idx+1) >= len) { 598 /* not in this packet */ 599 return (0); 600 } 601 ND_TCHECK(*(pptr+idx+1)); 602 if (*(pptr+idx+1) == '\n') { 603 /* 604 * CR-LF; end of line. 605 * Skip the CR-LF and print the line, with 606 * the exception of the CR-LF. 607 */ 608 linelen = idx - startidx; 609 idx += 2; 610 goto print; 611 } 612 613 /* 614 * CR followed by something else; treat this 615 * as if it were binary data, and don't print 616 * it. 617 */ 618 return (0); 619 } else if (!isascii(*(pptr+idx)) || 620 (!isprint(*(pptr+idx)) && *(pptr+idx) != '\t')) { 621 /* 622 * Not a printable ASCII character and not a tab; 623 * treat this as if it were binary data, and 624 * don't print it. 625 */ 626 return (0); 627 } 628 idx++; 629 } 630 631 /* 632 * All printable ASCII, but no line ending after that point 633 * in the buffer; treat this as if it were truncated. 634 */ 635 trunc: 636 linelen = idx - startidx; 637 ND_PRINT((ndo, "%s%.*s[!%s]", prefix, (int)linelen, pptr + startidx, 638 protoname)); 639 return (0); 640 641 print: 642 ND_PRINT((ndo, "%s%.*s", prefix, (int)linelen, pptr + startidx)); 643 return (idx); 644 } 645 646 void 647 txtproto_print(netdissect_options *ndo, const u_char *pptr, u_int len, 648 const char *protoname, const char **cmds, u_int flags) 649 { 650 u_int idx, eol; 651 u_char token[MAX_TOKEN+1]; 652 const char *cmd; 653 int is_reqresp = 0; 654 const char *pnp; 655 656 if (cmds != NULL) { 657 /* 658 * This protocol has more than just request and 659 * response lines; see whether this looks like a 660 * request or response. 661 */ 662 idx = fetch_token(ndo, pptr, 0, len, token, sizeof(token)); 663 if (idx != 0) { 664 /* Is this a valid request name? */ 665 while ((cmd = *cmds++) != NULL) { 666 if (strcasecmp((const char *)token, cmd) == 0) { 667 /* Yes. */ 668 is_reqresp = 1; 669 break; 670 } 671 } 672 673 /* 674 * No - is this a valid response code (3 digits)? 675 * 676 * Is this token the response code, or is the next 677 * token the response code? 678 */ 679 if (flags & RESP_CODE_SECOND_TOKEN) { 680 /* 681 * Next token - get it. 682 */ 683 idx = fetch_token(ndo, pptr, idx, len, token, 684 sizeof(token)); 685 } 686 if (idx != 0) { 687 if (isdigit(token[0]) && isdigit(token[1]) && 688 isdigit(token[2]) && token[3] == '\0') { 689 /* Yes. */ 690 is_reqresp = 1; 691 } 692 } 693 } 694 } else { 695 /* 696 * This protocol has only request and response lines 697 * (e.g., FTP, where all the data goes over a 698 * different connection); assume the payload is 699 * a request or response. 700 */ 701 is_reqresp = 1; 702 } 703 704 /* Capitalize the protocol name */ 705 for (pnp = protoname; *pnp != '\0'; pnp++) 706 ND_PRINT((ndo, "%c", toupper(*pnp))); 707 708 if (is_reqresp) { 709 /* 710 * In non-verbose mode, just print the protocol, followed 711 * by the first line as the request or response info. 712 * 713 * In verbose mode, print lines as text until we run out 714 * of characters or see something that's not a 715 * printable-ASCII line. 716 */ 717 if (ndo->ndo_vflag) { 718 /* 719 * We're going to print all the text lines in the 720 * request or response; just print the length 721 * on the first line of the output. 722 */ 723 ND_PRINT((ndo, ", length: %u", len)); 724 for (idx = 0; 725 idx < len && (eol = print_txt_line(ndo, protoname, "\n\t", pptr, idx, len)) != 0; 726 idx = eol) 727 ; 728 } else { 729 /* 730 * Just print the first text line. 731 */ 732 print_txt_line(ndo, protoname, ": ", pptr, 0, len); 733 } 734 } 735 } 736 737 /* VARARGS */ 738 void 739 error(const char *fmt, ...) 740 { 741 va_list ap; 742 743 (void)fprintf(stderr, "%s: ", program_name); 744 va_start(ap, fmt); 745 (void)vfprintf(stderr, fmt, ap); 746 va_end(ap); 747 if (*fmt) { 748 fmt += strlen(fmt); 749 if (fmt[-1] != '\n') 750 (void)fputc('\n', stderr); 751 } 752 exit(1); 753 /* NOTREACHED */ 754 } 755 756 /* VARARGS */ 757 void 758 warning(const char *fmt, ...) 759 { 760 va_list ap; 761 762 (void)fprintf(stderr, "%s: WARNING: ", program_name); 763 va_start(ap, fmt); 764 (void)vfprintf(stderr, fmt, ap); 765 va_end(ap); 766 if (*fmt) { 767 fmt += strlen(fmt); 768 if (fmt[-1] != '\n') 769 (void)fputc('\n', stderr); 770 } 771 } 772 773 /* 774 * Copy arg vector into a new buffer, concatenating arguments with spaces. 775 */ 776 char * 777 copy_argv(register char **argv) 778 { 779 register char **p; 780 register u_int len = 0; 781 char *buf; 782 char *src, *dst; 783 784 p = argv; 785 if (*p == 0) 786 return 0; 787 788 while (*p) 789 len += strlen(*p++) + 1; 790 791 buf = (char *)malloc(len); 792 if (buf == NULL) 793 error("copy_argv: malloc"); 794 795 p = argv; 796 dst = buf; 797 while ((src = *p++) != NULL) { 798 while ((*dst++ = *src++) != '\0') 799 ; 800 dst[-1] = ' '; 801 } 802 dst[-1] = '\0'; 803 804 return buf; 805 } 806 807 /* 808 * On Windows, we need to open the file in binary mode, so that 809 * we get all the bytes specified by the size we get from "fstat()". 810 * On UNIX, that's not necessary. O_BINARY is defined on Windows; 811 * we define it as 0 if it's not defined, so it does nothing. 812 */ 813 #ifndef O_BINARY 814 #define O_BINARY 0 815 #endif 816 817 char * 818 read_infile(char *fname) 819 { 820 register int i, fd, cc; 821 register char *cp; 822 struct stat buf; 823 824 fd = open(fname, O_RDONLY|O_BINARY); 825 if (fd < 0) 826 error("can't open %s: %s", fname, pcap_strerror(errno)); 827 828 if (fstat(fd, &buf) < 0) 829 error("can't stat %s: %s", fname, pcap_strerror(errno)); 830 831 cp = malloc((u_int)buf.st_size + 1); 832 if (cp == NULL) 833 error("malloc(%d) for %s: %s", (u_int)buf.st_size + 1, 834 fname, pcap_strerror(errno)); 835 cc = read(fd, cp, (u_int)buf.st_size); 836 if (cc < 0) 837 error("read %s: %s", fname, pcap_strerror(errno)); 838 if (cc != buf.st_size) 839 error("short read %s (%d != %d)", fname, cc, (int)buf.st_size); 840 841 close(fd); 842 /* replace "# comment" with spaces */ 843 for (i = 0; i < cc; i++) { 844 if (cp[i] == '#') 845 while (i < cc && cp[i] != '\n') 846 cp[i++] = ' '; 847 } 848 cp[cc] = '\0'; 849 return (cp); 850 } 851 852 void 853 safeputs(netdissect_options *ndo, 854 const u_char *s, const u_int maxlen) 855 { 856 u_int idx = 0; 857 858 while (*s && idx < maxlen) { 859 safeputchar(ndo, *s); 860 idx++; 861 s++; 862 } 863 } 864 865 void 866 safeputchar(netdissect_options *ndo, 867 const u_char c) 868 { 869 ND_PRINT((ndo, (c < 0x80 && ND_ISPRINT(c)) ? "%c" : "\\0x%02x", c)); 870 } 871 872 #ifdef LBL_ALIGN 873 /* 874 * Some compilers try to optimize memcpy(), using the alignment constraint 875 * on the argument pointer type. by using this function, we try to avoid the 876 * optimization. 877 */ 878 void 879 unaligned_memcpy(void *p, const void *q, size_t l) 880 { 881 memcpy(p, q, l); 882 } 883 884 /* As with memcpy(), so with memcmp(). */ 885 int 886 unaligned_memcmp(const void *p, const void *q, size_t l) 887 { 888 return (memcmp(p, q, l)); 889 } 890 #endif 891
