contrib/tcpdump/util-print.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 /*
  23  * txtproto_print() derived from original code by Hannes Gredler
  24  * (hannes@gredler.at):
  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[1024+1]; /* our string buffer */
 525         char *bufp = buf;
 526         size_t space_left = sizeof(buf), string_size;
 527         register u_int rotbit; /* this is the bit we rotate through all bitpositions */
 528         register u_int tokval;
 529         const char * sepstr = "";
 530
 531         while (lp != NULL && lp->s != NULL) {
 532             tokval=lp->v;   /* load our first value */
 533             rotbit=1;
 534             while (rotbit != 0) {
 535                 /*
 536                  * lets AND the rotating bit with our token value
 537                  * and see if we have got a match
 538                  */
 539                 if (tokval == (v&rotbit)) {
 540                     /* ok we have found something */
 541                     if (space_left <= 1)
 542                         return (buf); /* only enough room left for NUL, if that */
 543                     string_size = strlcpy(bufp, sepstr, space_left);
 544                     if (string_size >= space_left)
 545                         return (buf);    /* we ran out of room */
 546                     bufp += string_size;
 547                     space_left -= string_size;
 548                     if (space_left <= 1)
 549                         return (buf); /* only enough room left for NUL, if that */
 550                     string_size = strlcpy(bufp, lp->s, space_left);
 551                     if (string_size >= space_left)
 552                         return (buf);    /* we ran out of room */
 553                     bufp += string_size;
 554                     space_left -= string_size;
 555                     sepstr = sep;
 556                     break;
 557                 }
 558                 rotbit=rotbit<<1; /* no match - lets shift and try again */
 559             }
 560             lp++;
 561         }
 562
 563         if (bufp == buf)
 564             /* bummer - lets print the "unknown" message as advised in the fmt string if we got one */
 565             (void)snprintf(buf, sizeof(buf), fmt == NULL ? "#%08x" : fmt, v);
 566         return (buf);
 567 }
 568
 569 /*
 570  * Convert a bit token value to a string; use "fmt" if not found.
 571  * this is useful for parsing bitfields, the output strings are not seperated.
 572  */
 573 char *
 574 bittok2str_nosep(register const struct tok *lp, register const char *fmt,
 575            register u_int v)
 576 {
 577     return (bittok2str_internal(lp, fmt, v, ""));
 578 }
 579
 580 /*
 581  * Convert a bit token value to a string; use "fmt" if not found.
 582  * this is useful for parsing bitfields, the output strings are comma seperated.
 583  */
 584 char *
 585 bittok2str(register const struct tok *lp, register const char *fmt,
 586            register u_int v)
 587 {
 588     return (bittok2str_internal(lp, fmt, v, ", "));
 589 }
 590
 591 /*
 592  * Convert a value to a string using an array; the macro
 593  * tok2strary() in <netdissect.h> is the public interface to
 594  * this function and ensures that the second argument is
 595  * correct for bounds-checking.
 596  */
 597 const char *
 598 tok2strary_internal(register const char **lp, int n, register const char *fmt,
 599         register int v)
 600 {
 601         static char buf[TOKBUFSIZE];
 602
 603         if (v >= 0 && v < n && lp[v] != NULL)
 604                 return lp[v];
 605         if (fmt == NULL)
 606                 fmt = "#%d";
 607         (void)snprintf(buf, sizeof(buf), fmt, v);
 608         return (buf);
 609 }
 610
 611 /*
 612  * Convert a 32-bit netmask to prefixlen if possible
 613  * the function returns the prefix-len; if plen == -1
 614  * then conversion was not possible;
 615  */
 616
 617 int
 618 mask2plen(uint32_t mask)
 619 {
 620         uint32_t bitmasks[33] = {
 621                 0x00000000,
 622                 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000,
 623                 0xf8000000, 0xfc000000, 0xfe000000, 0xff000000,
 624                 0xff800000, 0xffc00000, 0xffe00000, 0xfff00000,
 625                 0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000,
 626                 0xffff8000, 0xffffc000, 0xffffe000, 0xfffff000,
 627                 0xfffff800, 0xfffffc00, 0xfffffe00, 0xffffff00,
 628                 0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0,
 629                 0xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff
 630         };
 631         int prefix_len = 32;
 632
 633         /* let's see if we can transform the mask into a prefixlen */
 634         while (prefix_len >= 0) {
 635                 if (bitmasks[prefix_len] == mask)
 636                         break;
 637                 prefix_len--;
 638         }
 639         return (prefix_len);
 640 }
 641
 642 int
 643 mask62plen(const u_char *mask)
 644 {
 645         u_char bitmasks[9] = {
 646                 0x00,
 647                 0x80, 0xc0, 0xe0, 0xf0,
 648                 0xf8, 0xfc, 0xfe, 0xff
 649         };
 650         int byte;
 651         int cidr_len = 0;
 652
 653         for (byte = 0; byte < 16; byte++) {
 654                 u_int bits;
 655
 656                 for (bits = 0; bits < (sizeof (bitmasks) / sizeof (bitmasks[0])); bits++) {
 657                         if (mask[byte] == bitmasks[bits]) {
 658                                 cidr_len += bits;
 659                                 break;
 660                         }
 661                 }
 662
 663                 if (mask[byte] != 0xff)
 664                         break;
 665         }
 666         return (cidr_len);
 667 }
 668
 669 /*
 670  * Routine to print out information for text-based protocols such as FTP,
 671  * HTTP, SMTP, RTSP, SIP, ....
 672  */
 673 #define MAX_TOKEN       128
 674
 675 /*
 676  * Fetch a token from a packet, starting at the specified index,
 677  * and return the length of the token.
 678  *
 679  * Returns 0 on error; yes, this is indistinguishable from an empty
 680  * token, but an "empty token" isn't a valid token - it just means
 681  * either a space character at the beginning of the line (this
 682  * includes a blank line) or no more tokens remaining on the line.
 683  */
 684 static int
 685 fetch_token(netdissect_options *ndo, const u_char *pptr, u_int idx, u_int len,
 686     u_char *tbuf, size_t tbuflen)
 687 {
 688         size_t toklen = 0;
 689
 690         for (; idx < len; idx++) {
 691                 if (!ND_TTEST(*(pptr + idx))) {
 692                         /* ran past end of captured data */
 693                         return (0);
 694                 }
 695                 if (!isascii(*(pptr + idx))) {
 696                         /* not an ASCII character */
 697                         return (0);
 698                 }
 699                 if (isspace(*(pptr + idx))) {
 700                         /* end of token */
 701                         break;
 702                 }
 703                 if (!isprint(*(pptr + idx))) {
 704                         /* not part of a command token or response code */
 705                         return (0);
 706                 }
 707                 if (toklen + 2 > tbuflen) {
 708                         /* no room for this character and terminating '\0' */
 709                         return (0);
 710                 }
 711                 tbuf[toklen] = *(pptr + idx);
 712                 toklen++;
 713         }
 714         if (toklen == 0) {
 715                 /* no token */
 716                 return (0);
 717         }
 718         tbuf[toklen] = '\0';
 719
 720         /*
 721          * Skip past any white space after the token, until we see
 722          * an end-of-line (CR or LF).
 723          */
 724         for (; idx < len; idx++) {
 725                 if (!ND_TTEST(*(pptr + idx))) {
 726                         /* ran past end of captured data */
 727                         break;
 728                 }
 729                 if (*(pptr + idx) == '\r' || *(pptr + idx) == '\n') {
 730                         /* end of line */
 731                         break;
 732                 }
 733                 if (!isascii(*(pptr + idx)) || !isprint(*(pptr + idx))) {
 734                         /* not a printable ASCII character */
 735                         break;
 736                 }
 737                 if (!isspace(*(pptr + idx))) {
 738                         /* beginning of next token */
 739                         break;
 740                 }
 741         }
 742         return (idx);
 743 }
 744
 745 /*
 746  * Scan a buffer looking for a line ending - LF or CR-LF.
 747  * Return the index of the character after the line ending or 0 if
 748  * we encounter a non-ASCII or non-printable character or don't find
 749  * the line ending.
 750  */
 751 static u_int
 752 print_txt_line(netdissect_options *ndo, const char *protoname,
 753     const char *prefix, const u_char *pptr, u_int idx, u_int len)
 754 {
 755         u_int startidx;
 756         u_int linelen;
 757
 758         startidx = idx;
 759         while (idx < len) {
 760                 ND_TCHECK(*(pptr+idx));
 761                 if (*(pptr+idx) == '\n') {
 762                         /*
 763                          * LF without CR; end of line.
 764                          * Skip the LF and print the line, with the
 765                          * exception of the LF.
 766                          */
 767                         linelen = idx - startidx;
 768                         idx++;
 769                         goto print;
 770                 } else if (*(pptr+idx) == '\r') {
 771                         /* CR - any LF? */
 772                         if ((idx+1) >= len) {
 773                                 /* not in this packet */
 774                                 return (0);
 775                         }
 776                         ND_TCHECK(*(pptr+idx+1));
 777                         if (*(pptr+idx+1) == '\n') {
 778                                 /*
 779                                  * CR-LF; end of line.
 780                                  * Skip the CR-LF and print the line, with
 781                                  * the exception of the CR-LF.
 782                                  */
 783                                 linelen = idx - startidx;
 784                                 idx += 2;
 785                                 goto print;
 786                         }
 787
 788                         /*
 789                          * CR followed by something else; treat this
 790                          * as if it were binary data, and don't print
 791                          * it.
 792                          */
 793                         return (0);
 794                 } else if (!isascii(*(pptr+idx)) ||
 795                     (!isprint(*(pptr+idx)) && *(pptr+idx) != '\t')) {
 796                         /*
 797                          * Not a printable ASCII character and not a tab;
 798                          * treat this as if it were binary data, and
 799                          * don't print it.
 800                          */
 801                         return (0);
 802                 }
 803                 idx++;
 804         }
 805
 806         /*
 807          * All printable ASCII, but no line ending after that point
 808          * in the buffer; treat this as if it were truncated.
 809          */
 810 trunc:
 811         linelen = idx - startidx;
 812         ND_PRINT((ndo, "%s%.*s[!%s]", prefix, (int)linelen, pptr + startidx,
 813             protoname));
 814         return (0);
 815
 816 print:
 817         ND_PRINT((ndo, "%s%.*s", prefix, (int)linelen, pptr + startidx));
 818         return (idx);
 819 }
 820
 821 void
 822 txtproto_print(netdissect_options *ndo, const u_char *pptr, u_int len,
 823     const char *protoname, const char **cmds, u_int flags)
 824 {
 825         u_int idx, eol;
 826         u_char token[MAX_TOKEN+1];
 827         const char *cmd;
 828         int is_reqresp = 0;
 829         const char *pnp;
 830
 831         if (cmds != NULL) {
 832                 /*
 833                  * This protocol has more than just request and
 834                  * response lines; see whether this looks like a
 835                  * request or response.
 836                  */
 837                 idx = fetch_token(ndo, pptr, 0, len, token, sizeof(token));
 838                 if (idx != 0) {
 839                         /* Is this a valid request name? */
 840                         while ((cmd = *cmds++) != NULL) {
 841                                 if (ascii_strcasecmp((const char *)token, cmd) == 0) {
 842                                         /* Yes. */
 843                                         is_reqresp = 1;
 844                                         break;
 845                                 }
 846                         }
 847
 848                         /*
 849                          * No - is this a valid response code (3 digits)?
 850                          *
 851                          * Is this token the response code, or is the next
 852                          * token the response code?
 853                          */
 854                         if (flags & RESP_CODE_SECOND_TOKEN) {
 855                                 /*
 856                                  * Next token - get it.
 857                                  */
 858                                 idx = fetch_token(ndo, pptr, idx, len, token,
 859                                     sizeof(token));
 860                         }
 861                         if (idx != 0) {
 862                                 if (isdigit(token[0]) && isdigit(token[1]) &&
 863                                     isdigit(token[2]) && token[3] == '\0') {
 864                                         /* Yes. */
 865                                         is_reqresp = 1;
 866                                 }
 867                         }
 868                 }
 869         } else {
 870                 /*
 871                  * This protocol has only request and response lines
 872                  * (e.g., FTP, where all the data goes over a
 873                  * different connection); assume the payload is
 874                  * a request or response.
 875                  */
 876                 is_reqresp = 1;
 877         }
 878
 879         /* Capitalize the protocol name */
 880         for (pnp = protoname; *pnp != '\0'; pnp++)
 881                 ND_PRINT((ndo, "%c", toupper((u_char)*pnp)));
 882
 883         if (is_reqresp) {
 884                 /*
 885                  * In non-verbose mode, just print the protocol, followed
 886                  * by the first line as the request or response info.
 887                  *
 888                  * In verbose mode, print lines as text until we run out
 889                  * of characters or see something that's not a
 890                  * printable-ASCII line.
 891                  */
 892                 if (ndo->ndo_vflag) {
 893                         /*
 894                          * We're going to print all the text lines in the
 895                          * request or response; just print the length
 896                          * on the first line of the output.
 897                          */
 898                         ND_PRINT((ndo, ", length: %u", len));
 899                         for (idx = 0;
 900                             idx < len && (eol = print_txt_line(ndo, protoname, "\n\t", pptr, idx, len)) != 0;
 901                             idx = eol)
 902                                 ;
 903                 } else {
 904                         /*
 905                          * Just print the first text line.
 906                          */
 907                         print_txt_line(ndo, protoname, ": ", pptr, 0, len);
 908                 }
 909         }
 910 }
 911
 912 void
 913 safeputs(netdissect_options *ndo,
 914          const u_char *s, const u_int maxlen)
 915 {
 916         u_int idx = 0;
 917
 918         while (idx < maxlen && *s) {
 919                 safeputchar(ndo, *s);
 920                 idx++;
 921                 s++;
 922         }
 923 }
 924
 925 void
 926 safeputchar(netdissect_options *ndo,
 927             const u_char c)
 928 {
 929         ND_PRINT((ndo, (c < 0x80 && ND_ISPRINT(c)) ? "%c" : "\\0x%02x", c));
 930 }
 931
 932 #ifdef LBL_ALIGN
 933 /*
 934  * Some compilers try to optimize memcpy(), using the alignment constraint
 935  * on the argument pointer type.  by using this function, we try to avoid the
 936  * optimization.
 937  */
 938 void
 939 unaligned_memcpy(void *p, const void *q, size_t l)
 940 {
 941         memcpy(p, q, l);
 942 }
 943
 944 /* As with memcpy(), so with memcmp(). */
 945 int
 946 unaligned_memcmp(const void *p, const void *q, size_t l)
 947 {
 948         return (memcmp(p, q, l));
 949 }
 950 #endif
 951