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