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