wiretap/libpcap.c

   1 /* libpcap.c
   2  *
   3  * $Id: libpcap.c,v 1.56 2001/11/09 07:44:51 guy Exp $
   4  *
   5  * Wiretap Library
   6  * Copyright (c) 1998 by Gilbert Ramirez <gram@xiexie.org>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21  *
  22  */
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include "wtap-int.h"
  29 #include "file_wrappers.h"
  30 #include "buffer.h"
  31 #include "libpcap.h"
  32
  33 /* See source to the "libpcap" library for information on the "libpcap"
  34    file format. */
  35
  36 /* On some systems, the FDDI MAC addresses are bit-swapped. */
  37 #if !defined(ultrix) && !defined(__alpha) && !defined(__bsdi__)
  38 #define BIT_SWAPPED_MAC_ADDRS
  39 #endif
  40
  41
  42 /* Try to read the first two records of the capture file. */
  43 typedef enum {
  44         THIS_FORMAT,            /* the reads succeeded, assume it's this format */
  45         BAD_READ,               /* the file is probably not valid */
  46         OTHER_FORMAT            /* the file may be valid, but not in this format */
  47 } libpcap_try_t;
  48 static libpcap_try_t libpcap_try(wtap *wth, int *err);
  49
  50 static gboolean libpcap_read(wtap *wth, int *err, long *data_offset);
  51 static int libpcap_read_header(wtap *wth, int *err,
  52     struct pcaprec_ss990915_hdr *hdr, gboolean silent);
  53 static void adjust_header(wtap *wth, struct pcaprec_hdr *hdr);
  54 static void libpcap_close(wtap *wth);
  55 static gboolean libpcap_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
  56     const union wtap_pseudo_header *pseudo_header, const u_char *pd, int *err);
  57
  58 /*
  59  * Either LBL NRG wasn't an adequate central registry (e.g., because of
  60  * the slow rate of releases from them), or nobody bothered using them
  61  * as a central registry, as many different groups have patched libpcap
  62  * (and BPF, on the BSDs) to add new encapsulation types, and have ended
  63  * up using the same DLT_ values for different encapsulation types.
  64  *
  65  * For those numerical encapsulation type values that everybody uses for
  66  * the same encapsulation type (which inclues those that some platforms
  67  * specify different DLT_ names for but don't appear to use), we map
  68  * those values to the appropriate Wiretap values.
  69  *
  70  * For those numerical encapsulation type values that different libpcap
  71  * variants use for different encapsulation types, we check what
  72  * <pcap.h> defined to determine how to interpret them, so that we
  73  * interpret them the way the libpcap with which we're building
  74  * Ethereal/Wiretap interprets them (which, if it doesn't support
  75  * them at all, means we don't support them either - any capture files
  76  * using them are foreign, and we don't hazard a guess as to which
  77  * platform they came from; we could, I guess, choose the most likely
  78  * platform).
  79  */
  80
  81 #ifdef HAVE_PCAP_H
  82 #include <pcap.h>
  83 #endif
  84
  85 static const struct {
  86         int     dlt_value;
  87         int     wtap_encap_value;
  88 } pcap_to_wtap_map[] = {
  89         /*
  90          * These are the values that are almost certainly the same
  91          * in all libpcaps (I've yet to find one where the values
  92          * in question are used for some purpose other than the
  93          * one below, but...), and that Wiretap and Ethereal
  94          * currently support.
  95          */
  96         { 0,            WTAP_ENCAP_NULL },      /* null encapsulation */
  97         { 1,            WTAP_ENCAP_ETHERNET },
  98         { 6,            WTAP_ENCAP_TOKEN_RING },        /* IEEE 802 Networks - assume token ring */
  99         { 7,            WTAP_ENCAP_ARCNET },
 100         { 8,            WTAP_ENCAP_SLIP },
 101         { 9,            WTAP_ENCAP_PPP },
 102 #ifdef BIT_SWAPPED_MAC_ADDRS
 103         { 10,           WTAP_ENCAP_FDDI_BITSWAPPED },
 104 #else
 105         { 10,           WTAP_ENCAP_FDDI },
 106 #endif
 107
 108         /*
 109          * 11 is DLT_ATM_RFC1483 on most platforms; the only libpcaps I've
 110          * seen that define anything other than DLT_ATM_RFC1483 as 11 are
 111          * the BSD/OS one, which defines DLT_FR as 11, and libpcap 0.5,
 112          * which define it as 100, mapping the kernel's value to 100, in
 113          * an attempt to hide the different values used on different
 114          * platforms.
 115          *
 116          * If this is a platform where DLT_FR is defined as 11, we
 117          * don't handle 11 at all; otherwise, we handle it as
 118          * DLT_ATM_RFC1483 (this means we'd misinterpret Frame Relay
 119          * captures from BSD/OS if running on platforms other than BSD/OS,
 120          * but
 121          *
 122          *      1) we don't yet support DLT_FR
 123          *
 124          * and
 125          *
 126          *      2) nothing short of a heuristic would let us interpret
 127          *         them correctly).
 128          */
 129 #if defined(DLT_FR) && (DLT_FR == 11)
 130         /* Put entry for Frame Relay here */
 131 #else
 132         { 11,           WTAP_ENCAP_ATM_RFC1483 },
 133 #endif
 134
 135         /*
 136          * 12 is DLT_RAW on most platforms, but it's DLT_C_HDLC on
 137          * BSD/OS, and DLT_LOOP on OpenBSD.
 138          *
 139          * We don't yet handle DLT_C_HDLC, but we can handle DLT_LOOP
 140          * (it's just like DLT_NULL, only with the AF_ value in network
 141          * rather than host byte order - Ethereal figures out the
 142          * byte order from the data, so we don't care what byte order
 143          * it's in), so if DLT_LOOP is defined as 12, interpret 12
 144          * as WTAP_ENCAP_NULL, otherwise, unless DLT_C_HDLC is defined
 145          * as 12, interpret it as WTAP_ENCAP_RAW_IP.
 146          */
 147 #if defined(DLT_LOOP) && (DLT_LOOP == 12)
 148         { 12,           WTAP_ENCAP_NULL },
 149 #elif defined(DLT_C_HDLC) && (DLT_C_HDLC == 12)
 150         /*
 151          * Put entry for Cisco HDLC here.
 152          * XXX - is this just WTAP_ENCAP_CHDLC, i.e. does the frame
 153          * start with a 4-byte Cisco HDLC header?
 154          */
 155 #else
 156         { 12,           WTAP_ENCAP_RAW_IP },
 157 #endif
 158
 159         /*
 160          * 13 is DLT_SLIP_BSDOS on FreeBSD and NetBSD, but those OSes
 161          * don't actually generate it.  I infer that BSD/OS translates
 162          * DLT_SLIP from the kernel BPF code to DLT_SLIP_BSDOS in
 163          * libpcap, as the BSD/OS link-layer header is different;
 164          * however, in BSD/OS, DLT_SLIP_BSDOS is 15.
 165          *
 166          * From this, I infer that there's no point in handling 13
 167          * as DLT_SLIP_BSDOS.
 168          *
 169          * 13 is DLT_ATM_RFC1483 on BSD/OS.
 170          *
 171          * 13 is DLT_ENC in OpenBSD, which is, I suspect, some kind
 172          * of decrypted IPSEC traffic.
 173          */
 174 #if defined(DLT_ATM_RFC1483) && (DLT_ATM_RFC1483 == 13)
 175         { 13,           WTAP_ENCAP_ATM_RFC1483 },
 176 #elif defined(DLT_ENC) && (DLT_ENC == 13)
 177         /* Put entry for DLT_ENC here */
 178 #endif
 179
 180         /*
 181          * 14 is DLT_PPP_BSDOS on FreeBSD and NetBSD, but those OSes
 182          * don't actually generate it.  I infer that BSD/OS translates
 183          * DLT_PPP from the kernel BPF code to DLT_PPP_BSDOS in
 184          * libpcap, as the BSD/OS link-layer header is different;
 185          * however, in BSD/OS, DLT_PPP_BSDOS is 16.
 186          *
 187          * From this, I infer that there's no point in handling 14
 188          * as DLT_PPP_BSDOS.
 189          *
 190          * 14 is DLT_RAW on BSD/OS and OpenBSD.
 191          */
 192         { 14,           WTAP_ENCAP_RAW_IP },
 193
 194         /*
 195          * 15 is:
 196          *
 197          *      DLT_SLIP_BSDOS on BSD/OS;
 198          *
 199          *      DLT_HIPPI on NetBSD;
 200          *
 201          *      DLT_LANE8023 with Alexey Kuznetzov's patches for
 202          *      Linux libpcap;
 203          *
 204          *      DLT_I4L_RAWIP with the ISDN4Linux patches for libpcap
 205          *      (and on SuSE 6.3);
 206          *
 207          * but we don't currently handle any of those.
 208          */
 209
 210         /*
 211          * 16 is:
 212          *
 213          *      DLT_PPP_BSDOS on BSD/OS;
 214          *
 215          *      DLT_HDLC on NetBSD (Cisco HDLC);
 216          *
 217          *      DLT_CIP with Alexey Kuznetzov's patches for
 218          *      Linux libpcap - this is WTAP_ENCAP_LINUX_ATM_CLIP;
 219          *
 220          *      DLT_I4L_IP with the ISDN4Linux patches for libpcap
 221          *      (and on SuSE 6.3).
 222          */
 223 #if defined(DLT_CIP) && (DLT_CIP == 16)
 224         { 16,           WTAP_ENCAP_LINUX_ATM_CLIP },
 225 #endif
 226 #if defined(DLT_HDLC) && (DLT_HDLC == 16)
 227         { 16,           WTAP_ENCAP_CHDLC },
 228 #endif
 229
 230         /*
 231          * 17 is DLT_LANE8023 in SuSE 6.3 libpcap; we don't currently
 232          * handle it.
 233          */
 234
 235         /*
 236          * 18 is DLT_CIP in SuSE 6.3 libpcap; if it's the same as the
 237          * DLT_CIP of 16 that the Alexey Kuznetzov patches for
 238          * libpcap/tcpdump define, it's WTAP_ENCAP_LINUX_ATM_CLIP.
 239          * I've not found any libpcap that uses it for any other purpose -
 240          * hopefully nobody will do so in the future.
 241          */
 242         { 18,           WTAP_ENCAP_LINUX_ATM_CLIP },
 243
 244         /*
 245          * 19 is DLT_ATM_CLIP in the libpcap/tcpdump patches in the
 246          * recent versions I've seen of the Linux ATM distribution;
 247          * I've not yet found any libpcap that uses it for any other
 248          * purpose - hopefully nobody will do so in the future.
 249          */
 250         { 19,           WTAP_ENCAP_LINUX_ATM_CLIP },
 251
 252         /*
 253          * 50 is DLT_PPP_SERIAL in NetBSD; it appears that DLT_PPP
 254          * on BSD (at least according to standard tcpdump) has, as
 255          * the first octet, an indication of whether the packet was
 256          * transmitted or received (rather than having the standard
 257          * PPP address value of 0xff), but that DLT_PPP_SERIAL puts
 258          * a real live PPP header there, or perhaps a Cisco PPP header
 259          * as per section 4.3.1 of RFC 1547 (implementations of this
 260          * exist in various BSDs in "sys/net/if_spppsubr.c", and
 261          * I think also exist either in standard Linux or in
 262          * various Linux patches; the implementations show how to handle
 263          * Cisco keepalive packets).
 264          *
 265          * However, I don't see any obvious place in FreeBSD "if_ppp.c"
 266          * where anything other than the standard PPP header would be
 267          * passed up.  I see some stuff that sets the first octet
 268          * to 0 for incoming and 1 for outgoing packets before applying
 269          * a BPF filter to see whether to drop packets whose protocol
 270          * field has the 0x8000 bit set, i.e. network control protocols -
 271          * those are handed up to userland - but that code puts the
 272          * address field back before passing the packet up.
 273          *
 274          * I also don't see anything immediately obvious that munges
 275          * the address field for sync PPP, either.
 276          *
 277          * Ethereal currently assumes that if the first octet of a
 278          * PPP frame is 0xFF, it's the address field and is followed
 279          * by a control field and a 2-byte protocol, otherwise the
 280          * address and control fields are absent and the frame begins
 281          * with a protocol field.  If we ever see a BSD/OS PPP
 282          * capture, we'll have to handle it differently, and we may
 283          * have to handle standard BSD captures differently if, in fact,
 284          * they don't have 0xff 0x03 as the first two bytes - but, as per
 285          * the two paragraphs preceding this, it's not clear that
 286          * the address field *is* munged into an incoming/outgoing
 287          * field when the packet is handed to the BPF device.
 288          *
 289          * For now, we just map DLT_PPP_SERIAL to WTAP_ENCAP_PPP, as
 290          * we treat WTAP_ENCAP_PPP packets as if those beginning with
 291          * 0xff have the standard RFC 1662 "PPP in HDLC-like Framing"
 292          * 0xff 0x03 address/control header, and DLT_PPP_SERIAL frames
 293          * appear to contain that unless they're Cisco frames (if we
 294          * ever see a capture with them, we'd need to implement the
 295          * RFC 1547 stuff, and the keepalive protocol stuff).
 296          *
 297          * We may have to distinguish between "PPP where if it doesn't
 298          * begin with 0xff there's no HDLC encapsulation and the frame
 299          * begins with the protocol field" (which is how we handle
 300          * WTAP_ENCAP_PPP now) and "PPP where there's either HDLC
 301          * encapsulation or Cisco PPP" (which is what DLT_PPP_SERIAL
 302          * is) at some point.
 303          *
 304          * XXX - NetBSD has DLT_HDLC, which appears to be used for
 305          * Cisco HDLC.  Ideally, they should use DLT_PPP_SERIAL
 306          * only for real live HDLC-encapsulated PPP, not for Cisco
 307          * HDLC.
 308          */
 309         { 50,           WTAP_ENCAP_PPP },
 310
 311         /*
 312          * These are the values that libpcap 0.5 uses, in an attempt
 313          * to work around the confusion decried above, and that Wiretap
 314          * and Ethereal currently support.
 315          *
 316          * The next version of libpcap will probably not use them as
 317          * DLT_ values in its API, but will probably use them in capture
 318          * file headers.
 319          */
 320         { 100,          WTAP_ENCAP_ATM_RFC1483 },
 321         { 101,          WTAP_ENCAP_RAW_IP },
 322 #if 0
 323         /*
 324          * More values used by libpcap 0.5 as DLT_ values and used by the
 325          * current CVS version of libpcap in capture file headers.
 326          * They are not yet handled in Ethereal.
 327          * If we get a capture that contains them, we'll implement them.
 328          */
 329         { 102,          WTAP_ENCAP_SLIP_BSDOS },
 330         { 103,          WTAP_ENCAP_PPP_BSDOS },
 331 #endif
 332
 333         /*
 334          * These ones are handled in Ethereal, though.
 335          */
 336         { 104,          WTAP_ENCAP_CHDLC },     /* Cisco HDLC */
 337         { 106,          WTAP_ENCAP_LINUX_ATM_CLIP },
 338
 339         /*
 340          * Values not yet used by the current CVS version of libpcap,
 341          * but reserved for future use; the IEEE 802.11 value is
 342          * there for use with a capture program from Axis Communications.
 343          */
 344         { 105,          WTAP_ENCAP_IEEE_802_11 },
 345 #if 0
 346         /*
 347          * Not yet handled in Ethereal; we don't know what encapsulation
 348          * BSD/OS uses, so we don't know whether it can be handed to
 349          * the Frame Relay dissector or not.
 350          */
 351         { 107,          WTAP_ENCAP_FR },        /* Frame Relay */
 352 #endif
 353         { 108,          WTAP_ENCAP_NULL },      /* OpenBSD loopback */
 354 #if 0
 355         { 109,          WTAP_ENCAP_ENC },       /* OpenBSD IPSEC enc */
 356         { 110,          WTAP_ENCAP_LANE_802_3 },/* ATM LANE 802.3 */
 357         { 111,          WTAP_ENCAP_HIPPI },     /* NetBSD HIPPI */
 358 #endif
 359         { 112,          WTAP_ENCAP_CHDLC },     /* NetBSD HDLC framing */
 360
 361         /*
 362          * Linux "cooked mode" captures, used by the current CVS version
 363          * of libpcap.
 364          */
 365         { 113,          WTAP_ENCAP_SLL },       /* Linux cooked capture */
 366
 367     { 118,      WTAP_ENCAP_CISCO_IOS },
 368 };
 369 #define NUM_PCAP_ENCAPS (sizeof pcap_to_wtap_map / sizeof pcap_to_wtap_map[0])
 370
 371 int libpcap_open(wtap *wth, int *err)
 372 {
 373         int bytes_read;
 374         guint32 magic;
 375         struct pcap_hdr hdr;
 376         gboolean byte_swapped;
 377         gboolean modified;
 378         gboolean aix;
 379         int file_encap;
 380
 381         /* Read in the number that should be at the start of a "libpcap" file */
 382         errno = WTAP_ERR_CANT_READ;
 383         bytes_read = file_read(&magic, 1, sizeof magic, wth->fh);
 384         if (bytes_read != sizeof magic) {
 385                 *err = file_error(wth->fh);
 386                 if (*err != 0)
 387                         return -1;
 388                 return 0;
 389         }
 390         wth->data_offset += sizeof magic;
 391
 392         switch (magic) {
 393
 394         case PCAP_MAGIC:
 395                 /* Host that wrote it has our byte order, and was running
 396                    a program using either standard or ss990417 libpcap. */
 397                 byte_swapped = FALSE;
 398                 modified = FALSE;
 399                 break;
 400
 401         case PCAP_MODIFIED_MAGIC:
 402                 /* Host that wrote it has our byte order, and was running
 403                    a program using either ss990915 or ss991029 libpcap. */
 404                 byte_swapped = FALSE;
 405                 modified = TRUE;
 406                 break;
 407
 408         case PCAP_SWAPPED_MAGIC:
 409                 /* Host that wrote it has a byte order opposite to ours,
 410                    and was running a program using either standard or
 411                    ss990417 libpcap. */
 412                 byte_swapped = TRUE;
 413                 modified = FALSE;
 414                 break;
 415
 416         case PCAP_SWAPPED_MODIFIED_MAGIC:
 417                 /* Host that wrote it out has a byte order opposite to
 418                    ours, and was running a program using either ss990915
 419                    or ss991029 libpcap. */
 420                 byte_swapped = TRUE;
 421                 modified = TRUE;
 422                 break;
 423
 424         default:
 425                 /* Not a "libpcap" type we know about. */
 426                 return 0;
 427         }
 428
 429         /* Read the rest of the header. */
 430         errno = WTAP_ERR_CANT_READ;
 431         bytes_read = file_read(&hdr, 1, sizeof hdr, wth->fh);
 432         if (bytes_read != sizeof hdr) {
 433                 *err = file_error(wth->fh);
 434                 if (*err != 0)
 435                         return -1;
 436                 return 0;
 437         }
 438         wth->data_offset += sizeof hdr;
 439
 440         if (byte_swapped) {
 441                 /* Byte-swap the header fields about which we care. */
 442                 hdr.version_major = BSWAP16(hdr.version_major);
 443                 hdr.version_minor = BSWAP16(hdr.version_minor);
 444                 hdr.snaplen = BSWAP32(hdr.snaplen);
 445                 hdr.network = BSWAP32(hdr.network);
 446         }
 447         if (hdr.version_major < 2) {
 448                 /* We only support version 2.0 and later. */
 449                 g_message("pcap: major version %u unsupported",
 450                     hdr.version_major);
 451                 *err = WTAP_ERR_UNSUPPORTED;
 452                 return -1;
 453         }
 454
 455         /*
 456          * AIX's non-standard tcpdump uses a minor version number of 2.
 457          * Unfortunately, older versions of libpcap might have used
 458          * that as well.
 459          *
 460          * The AIX libpcap uses RFC 1573 ifType values rather than
 461          * DLT_ values in the header; the ifType values for LAN devices
 462          * are:
 463          *
 464          *      Ethernet        6
 465          *      Token Ring      9
 466          *      FDDI            15
 467          *
 468          * which correspond to DLT_IEEE802 (used for Token Ring),
 469          * DLT_PPP, and DLT_SLIP_BSDOS, respectively.  We shall
 470          * assume that if the minor version number is 2, and
 471          * the network type is 6, 9, or 15, that it's AIX libpcap;
 472          *
 473          * I'm assuming those older versions of libpcap didn't
 474          * use DLT_IEEE802 for Token Ring, and didn't use DLT_SLIP_BSDOS
 475          * as that came later.  It may have used DLT_SLIP, however, in
 476          * which case we're out of luck; we assume it's Token Ring
 477          * in AIX libpcap rather than PPP in standard libpcap, as
 478          * you're probably more likely to be handing an AIX libpcap
 479          * token-ring capture than an old (pre-libpcap 0.4) PPP capture
 480          * to Ethereal.
 481          */
 482         aix = FALSE;    /* assume it's not AIX */
 483         if (hdr.version_major == 2 && hdr.version_minor == 2) {
 484                 switch (hdr.network) {
 485
 486                 case 6:
 487                         hdr.network = 1;        /* DLT_EN10MB, Ethernet */
 488                         aix = TRUE;
 489                         break;
 490
 491                 case 8:
 492                         hdr.network = 6;        /* DLT_IEEE802, Token Ring */
 493                         aix = TRUE;
 494                         break;
 495
 496                 case 15:
 497                         hdr.network = 10;       /* DLT_FDDI, FDDI */
 498                         aix = TRUE;
 499                         break;
 500                 }
 501         }
 502         file_encap = wtap_pcap_encap_to_wtap_encap(hdr.network);
 503         if (file_encap == WTAP_ENCAP_UNKNOWN) {
 504                 g_message("pcap: network type %u unknown or unsupported",
 505                     hdr.network);
 506                 *err = WTAP_ERR_UNSUPPORTED_ENCAP;
 507                 return -1;
 508         }
 509
 510         /* This is a libpcap file */
 511         wth->capture.pcap = g_malloc(sizeof(libpcap_t));
 512         wth->capture.pcap->byte_swapped = byte_swapped;
 513         wth->capture.pcap->version_major = hdr.version_major;
 514         wth->capture.pcap->version_minor = hdr.version_minor;
 515         wth->subtype_read = libpcap_read;
 516         wth->subtype_seek_read = wtap_def_seek_read;
 517         wth->subtype_close = libpcap_close;
 518         wth->file_encap = file_encap;
 519         wth->snapshot_length = hdr.snaplen;
 520
 521         /*
 522          * Is this AIX format?
 523          */
 524         if (aix) {
 525                 /*
 526                  * Yes.  Skip all the tests for other mutant formats.
 527                  */
 528                 wth->file_type = WTAP_FILE_PCAP_AIX;
 529                 return 1;
 530         }
 531
 532         /*
 533          * No.  Let's look at the header for the first record,
 534          * and see if, interpreting it as a standard header (if the
 535          * magic number was standard) or a modified header (if the
 536          * magic number was modified), the position where it says the
 537          * header for the *second* record is contains a corrupted header.
 538          *
 539          * If so, then:
 540          *
 541          *      If this file had the standard magic number, it may be
 542          *      an ss990417 capture file - in that version of Alexey's
 543          *      patch, the packet header format was changed but the
 544          *      magic number wasn't, and, alas, Red Hat appear to have
 545          *      picked up that version of the patch for RH 6.1, meaning
 546          *      RH 6.1 has a tcpdump that writes out files that can't
 547          *      be read by any software that expects non-modified headers
 548          *      if the magic number isn't the modified magic number (e.g.,
 549          *      any normal version of tcpdump, and Ethereal if we don't
 550          *      do this gross heuristic).
 551          *
 552          *      If this file had the modified magic number, it may be
 553          *      an ss990915 capture file - in that version of Alexey's
 554          *      patch, the magic number was changed, but the record
 555          *      header had some extra fields, and, alas, SuSE appear
 556          *      to have picked up that version of the patch for SuSE
 557          *      6.3, meaning that programs expecting the standard per-
 558          *      packet header in captures with the modified magic number
 559          *      can't read dumps from its tcpdump.
 560          *
 561          * Oh, and if it has the standard magic number, it might, instead,
 562          * be a Nokia libpcap file, so we may need to try that if
 563          * neither normal nor ss990417 headers work.
 564          */
 565         if (modified) {
 566                 /*
 567                  * Well, we have the magic number from Alexey's
 568                  * later two patches.
 569                  *
 570                  * Try ss991029, the last of his patches, first.
 571                  */
 572                 wth->file_type = WTAP_FILE_PCAP_SS991029;
 573                 switch (libpcap_try(wth, err)) {
 574
 575                 case BAD_READ:
 576                         /*
 577                          * Well, we couldn't even read it.
 578                          * Give up.
 579                          */
 580                         return -1;
 581
 582                 case THIS_FORMAT:
 583                         /*
 584                          * Well, it looks as if it might be 991029.
 585                          * Put the seek pointer back, and return success.
 586                          */
 587                         file_seek(wth->fh, wth->data_offset, SEEK_SET);
 588                         return 1;
 589
 590                 case OTHER_FORMAT:
 591                         /*
 592                          * Try the next format.
 593                          */
 594                         break;
 595                 }
 596
 597                 /*
 598                  * Well, it's not completely unreadable,
 599                  * but it's not ss991029.  Try ss990915;
 600                  * there are no other types to try after that,
 601                  * so we put the seek pointer back and treat
 602                  * it as 990915.
 603                  */
 604                 wth->file_type = WTAP_FILE_PCAP_SS990915;
 605                 file_seek(wth->fh, wth->data_offset, SEEK_SET);
 606         } else {
 607                 /*
 608                  * Well, we have the standard magic number.
 609                  *
 610                  * Try the standard format first.
 611                  */
 612                 wth->file_type = WTAP_FILE_PCAP;
 613                 switch (libpcap_try(wth, err)) {
 614
 615                 case BAD_READ:
 616                         /*
 617                          * Well, we couldn't even read it.
 618                          * Give up.
 619                          */
 620                         return -1;
 621
 622                 case THIS_FORMAT:
 623                         /*
 624                          * Well, it looks as if it might be a standard
 625                          * libpcap file.
 626                          * Put the seek pointer back, and return success.
 627                          */
 628                         file_seek(wth->fh, wth->data_offset, SEEK_SET);
 629                         return 1;
 630
 631                 case OTHER_FORMAT:
 632                         /*
 633                          * Try the next format.
 634                          */
 635                         break;
 636                 }
 637
 638                 /*
 639                  * Well, it's not completely unreadable, but it's not
 640                  * a standard file.  Put the seek pointer back and try
 641                  * ss990417.
 642                  */
 643                 wth->file_type = WTAP_FILE_PCAP_SS990417;
 644                 file_seek(wth->fh, wth->data_offset, SEEK_SET);
 645                 switch (libpcap_try(wth, err)) {
 646
 647                 case BAD_READ:
 648                         /*
 649                          * Well, we couldn't even read it.
 650                          * Give up.
 651                          */
 652                         return -1;
 653
 654                 case THIS_FORMAT:
 655                         /*
 656                          * Well, it looks as if it might be ss990417.
 657                          * Put the seek pointer back, and return success.
 658                          */
 659                         file_seek(wth->fh, wth->data_offset, SEEK_SET);
 660                         return 1;
 661
 662                 case OTHER_FORMAT:
 663                         /*
 664                          * Try the next format.
 665                          */
 666                         break;
 667                 }
 668
 669                 /*
 670                  * Well, it's not completely unreadable,
 671                  * but it's not a standard file *nor* is it ss990417.
 672                  * Try it as a Nokia file; there are no other types
 673                  * to try after that, so we put the seek pointer back
 674                  * and treat it as a Nokia file.
 675                  */
 676                 wth->file_type = WTAP_FILE_PCAP_NOKIA;
 677                 file_seek(wth->fh, wth->data_offset, SEEK_SET);
 678         }
 679
 680         return 1;
 681 }
 682
 683 /* Try to read the first two records of the capture file. */
 684 static libpcap_try_t libpcap_try(wtap *wth, int *err)
 685 {
 686         /*
 687          * pcaprec_ss990915_hdr is the largest header type.
 688          */
 689         struct pcaprec_ss990915_hdr first_rec_hdr, second_rec_hdr;
 690
 691         /*
 692          * Attempt to read the first record's header.
 693          */
 694         if (libpcap_read_header(wth, err, &first_rec_hdr, TRUE) == -1) {
 695                 if (*err == 0 || *err == WTAP_ERR_SHORT_READ) {
 696                         /*
 697                          * EOF or short read - assume the file is in this
 698                          * format.
 699                          * When our client tries to read the first packet
 700                          * they will presumably get the same EOF or short
 701                          * read.
 702                          */
 703                         return THIS_FORMAT;
 704                 }
 705
 706                 if (*err == WTAP_ERR_BAD_RECORD) {
 707                         /*
 708                          * The first record is bogus, so this is probably
 709                          * a corrupt file.  Assume the file is in this
 710                          * format.  When our client tries to read the
 711                          * first packet they will presumably get the
 712                          * same bogus record.
 713                          */
 714                         return THIS_FORMAT;
 715                 }
 716
 717                 /*
 718                  * Some other error, e.g. an I/O error; just give up.
 719                  */
 720                 return BAD_READ;
 721         }
 722
 723         /*
 724          * Now skip over the first record's data, under the assumption
 725          * that the header is sane.
 726          */
 727         file_seek(wth->fh, first_rec_hdr.hdr.incl_len, SEEK_CUR);
 728
 729         /*
 730          * Now attempt to read the second record's header.
 731          */
 732         if (libpcap_read_header(wth, err, &second_rec_hdr, TRUE) == -1) {
 733                 if (*err == 0 || *err == WTAP_ERR_SHORT_READ) {
 734                         /*
 735                          * EOF or short read - assume the file is in this
 736                          * format.
 737                          * When our client tries to read the second packet
 738                          * they will presumably get the same EOF or short
 739                          * read.
 740                          */
 741                         return THIS_FORMAT;
 742                 }
 743
 744                 if (*err == WTAP_ERR_BAD_RECORD) {
 745                         /*
 746                          * The second record is bogus; maybe it's a
 747                          * Capture File From Hell, and what looks like
 748                          * the "header" of the next packet is actually
 749                          * random junk from the middle of a packet.
 750                          * Try the next format; if we run out of formats,
 751                          * it probably *is* a corrupt file.
 752                          */
 753                         return OTHER_FORMAT;
 754                 }
 755
 756                 /*
 757                  * Some other error, e.g. an I/O error; just give up.
 758                  */
 759                 return BAD_READ;
 760         }
 761
 762         /*
 763          * OK, the first two records look OK; assume this is the
 764          * right format.
 765          */
 766         return THIS_FORMAT;
 767 }
 768
 769 /* Read the next packet */
 770 static gboolean libpcap_read(wtap *wth, int *err, long *data_offset)
 771 {
 772         struct pcaprec_ss990915_hdr hdr;
 773         guint packet_size;
 774         int bytes_read;
 775
 776         bytes_read = libpcap_read_header(wth, err, &hdr, FALSE);
 777         if (bytes_read == -1) {
 778                 /*
 779                  * We failed to read the header.
 780                  */
 781                 return FALSE;
 782         }
 783
 784         wth->data_offset += bytes_read;
 785         packet_size = hdr.hdr.incl_len;
 786
 787         buffer_assure_space(wth->frame_buffer, packet_size);
 788         *data_offset = wth->data_offset;
 789         errno = WTAP_ERR_CANT_READ;
 790         bytes_read = file_read(buffer_start_ptr(wth->frame_buffer), 1,
 791                         packet_size, wth->fh);
 792
 793         if ((guint)bytes_read != packet_size) {
 794                 *err = file_error(wth->fh);
 795                 if (*err == 0)
 796                         *err = WTAP_ERR_SHORT_READ;
 797                 return FALSE;
 798         }
 799         wth->data_offset += packet_size;
 800
 801         wth->phdr.ts.tv_sec = hdr.hdr.ts_sec;
 802         wth->phdr.ts.tv_usec = hdr.hdr.ts_usec;
 803         wth->phdr.caplen = packet_size;
 804         wth->phdr.len = hdr.hdr.orig_len;
 805         wth->phdr.pkt_encap = wth->file_encap;
 806
 807         return TRUE;
 808 }
 809
 810 /* Read the header of the next packet; if "silent" is TRUE, don't complain
 811    to the console, as we're testing to see if the file appears to be of a
 812    particular type.
 813
 814    Return -1 on an error, or the number of bytes of header read on success. */
 815 static int libpcap_read_header(wtap *wth, int *err,
 816     struct pcaprec_ss990915_hdr *hdr, gboolean silent)
 817 {
 818         int     bytes_to_read, bytes_read;
 819
 820         /* Read record header. */
 821         errno = WTAP_ERR_CANT_READ;
 822         switch (wth->file_type) {
 823
 824         case WTAP_FILE_PCAP:
 825         case WTAP_FILE_PCAP_AIX:
 826                 bytes_to_read = sizeof (struct pcaprec_hdr);
 827                 break;
 828
 829         case WTAP_FILE_PCAP_SS990417:
 830         case WTAP_FILE_PCAP_SS991029:
 831                 bytes_to_read = sizeof (struct pcaprec_modified_hdr);
 832                 break;
 833
 834         case WTAP_FILE_PCAP_SS990915:
 835                 bytes_to_read = sizeof (struct pcaprec_ss990915_hdr);
 836                 break;
 837
 838         case WTAP_FILE_PCAP_NOKIA:
 839                 bytes_to_read = sizeof (struct pcaprec_nokia_hdr);
 840                 break;
 841
 842         default:
 843                 g_assert_not_reached();
 844                 bytes_to_read = 0;
 845         }
 846         bytes_read = file_read(hdr, 1, bytes_to_read, wth->fh);
 847         if (bytes_read != bytes_to_read) {
 848                 *err = file_error(wth->fh);
 849                 if (*err == 0 && bytes_read != 0) {
 850                         *err = WTAP_ERR_SHORT_READ;
 851                 }
 852                 return -1;
 853         }
 854
 855         adjust_header(wth, &hdr->hdr);
 856
 857         if (hdr->hdr.incl_len > WTAP_MAX_PACKET_SIZE) {
 858                 /*
 859                  * Probably a corrupt capture file; return an error,
 860                  * so that our caller doesn't blow up trying to allocate
 861                  * space for an immensely-large packet, and so that
 862                  * the code to try to guess what type of libpcap file
 863                  * this is can tell when it's not the type we're guessing
 864                  * it is.
 865                  */
 866                 if (!silent) {
 867                         g_message("pcap: File has %u-byte packet, bigger than maximum of %u",
 868                             hdr->hdr.incl_len, WTAP_MAX_PACKET_SIZE);
 869                 }
 870                 *err = WTAP_ERR_BAD_RECORD;
 871                 return -1;
 872         }
 873
 874         if (hdr->hdr.orig_len > WTAP_MAX_PACKET_SIZE) {
 875                 /*
 876                  * Probably a corrupt capture file; return an error,
 877                  * so that our caller doesn't blow up trying to
 878                  * cope with a huge "real" packet length, and so that
 879                  * the code to try to guess what type of libpcap file
 880                  * this is can tell when it's not the type we're guessing
 881                  * it is.
 882                  */
 883                 if (!silent) {
 884                         g_message("pcap: File has %u-byte packet, bigger than maximum of %u",
 885                             hdr->hdr.orig_len, WTAP_MAX_PACKET_SIZE);
 886                 }
 887                 *err = WTAP_ERR_BAD_RECORD;
 888                 return -1;
 889         }
 890
 891         return bytes_read;
 892 }
 893
 894 static void
 895 adjust_header(wtap *wth, struct pcaprec_hdr *hdr)
 896 {
 897         if (wth->capture.pcap->byte_swapped) {
 898                 /* Byte-swap the record header fields. */
 899                 hdr->ts_sec = BSWAP32(hdr->ts_sec);
 900                 hdr->ts_usec = BSWAP32(hdr->ts_usec);
 901                 hdr->incl_len = BSWAP32(hdr->incl_len);
 902                 hdr->orig_len = BSWAP32(hdr->orig_len);
 903         }
 904
 905         /* If this is AIX, convert the time stamp from seconds/nanoseconds
 906            to seconds/microseconds.  */
 907         if (wth->file_type == WTAP_FILE_PCAP_AIX)
 908                 hdr->ts_usec = hdr->ts_usec/1000;
 909
 910         /* In file format version 2.3, the "incl_len" and "orig_len" fields
 911            were swapped, in order to match the BPF header layout.
 912
 913            Unfortunately, some files were, according to a comment in the
 914            "libpcap" source, written with version 2.3 in their headers
 915            but without the interchanged fields, so if "incl_len" is
 916            greater than "orig_len" - which would make no sense - we
 917            assume that we need to swap them.  */
 918         if (wth->capture.pcap->version_major == 2 &&
 919             (wth->capture.pcap->version_minor < 3 ||
 920              (wth->capture.pcap->version_minor == 3 &&
 921               hdr->incl_len > hdr->orig_len))) {
 922                 guint32 temp;
 923
 924                 temp = hdr->orig_len;
 925                 hdr->orig_len = hdr->incl_len;
 926                 hdr->incl_len = temp;
 927         }
 928 }
 929
 930 static void
 931 libpcap_close(wtap *wth)
 932 {
 933         g_free(wth->capture.pcap);
 934 }
 935
 936 int wtap_pcap_encap_to_wtap_encap(int encap)
 937 {
 938         unsigned int i;
 939
 940         for (i = 0; i < NUM_PCAP_ENCAPS; i++) {
 941                 if (pcap_to_wtap_map[i].dlt_value == encap)
 942                         return pcap_to_wtap_map[i].wtap_encap_value;
 943         }
 944         return WTAP_ENCAP_UNKNOWN;
 945 }
 946
 947 static int wtap_wtap_encap_to_pcap_encap(int encap)
 948 {
 949         unsigned int i;
 950
 951         /*
 952          * Special-case WTAP_ENCAP_FDDI and WTAP_ENCAP_FDDI_BITSWAPPED;
 953          * both of them get mapped to DLT_FDDI (even though that may
 954          * mean that the bit order in the FDDI MAC addresses is wrong;
 955          * so it goes - libpcap format doesn't record the byte order,
 956          * so that's not fixable).
 957          */
 958         if (encap == WTAP_ENCAP_FDDI || encap == WTAP_ENCAP_FDDI_BITSWAPPED)
 959                 return 10;      /* that's DLT_FDDI */
 960         for (i = 0; i < NUM_PCAP_ENCAPS; i++) {
 961                 if (pcap_to_wtap_map[i].wtap_encap_value == encap)
 962                         return pcap_to_wtap_map[i].dlt_value;
 963         }
 964         return -1;
 965 }
 966
 967 /* Returns 0 if we could write the specified encapsulation type,
 968    an error indication otherwise. */
 969 int libpcap_dump_can_write_encap(int filetype, int encap)
 970 {
 971         /* Per-packet encapsulations aren't supported. */
 972         if (encap == WTAP_ENCAP_PER_PACKET)
 973                 return WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED;
 974
 975         if (wtap_wtap_encap_to_pcap_encap(encap) == -1)
 976                 return WTAP_ERR_UNSUPPORTED_ENCAP;
 977
 978         return 0;
 979 }
 980
 981 /* Returns TRUE on success, FALSE on failure; sets "*err" to an error code on
 982    failure */
 983 gboolean libpcap_dump_open(wtap_dumper *wdh, int *err)
 984 {
 985         guint32 magic;
 986         struct pcap_hdr file_hdr;
 987         size_t nwritten;
 988
 989         /* This is a libpcap file */
 990         wdh->subtype_write = libpcap_dump;
 991         wdh->subtype_close = NULL;
 992
 993         /* Write the file header. */
 994         switch (wdh->file_type) {
 995
 996         case WTAP_FILE_PCAP:
 997         case WTAP_FILE_PCAP_SS990417:   /* modified, but with the old magic, sigh */
 998         case WTAP_FILE_PCAP_NOKIA:      /* Nokia libpcap of some sort */
 999                 magic = PCAP_MAGIC;
1000                 break;
1001
1002         case WTAP_FILE_PCAP_SS990915:   /* new magic, extra crap */
1003         case WTAP_FILE_PCAP_SS991029:
1004                 magic = PCAP_MODIFIED_MAGIC;
1005                 break;
1006
1007         default:
1008                 /* We should never get here - our open routine
1009                    should only get called for the types above. */
1010                 *err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
1011                 return FALSE;
1012         }
1013
1014         nwritten = fwrite(&magic, 1, sizeof magic, wdh->fh);
1015         if (nwritten != sizeof magic) {
1016                 if (nwritten == 0 && ferror(wdh->fh))
1017                         *err = errno;
1018                 else
1019                         *err = WTAP_ERR_SHORT_WRITE;
1020                 return FALSE;
1021         }
1022
1023         /* current "libpcap" format is 2.4 */
1024         file_hdr.version_major = 2;
1025         file_hdr.version_minor = 4;
1026         file_hdr.thiszone = 0;  /* XXX - current offset? */
1027         file_hdr.sigfigs = 0;   /* unknown, but also apparently unused */
1028         file_hdr.snaplen = wdh->snaplen;
1029         file_hdr.network = wtap_wtap_encap_to_pcap_encap(wdh->encap);
1030         nwritten = fwrite(&file_hdr, 1, sizeof file_hdr, wdh->fh);
1031         if (nwritten != sizeof file_hdr) {
1032                 if (nwritten == 0 && ferror(wdh->fh))
1033                         *err = errno;
1034                 else
1035                         *err = WTAP_ERR_SHORT_WRITE;
1036                 return FALSE;
1037         }
1038
1039         return TRUE;
1040 }
1041
1042 /* Write a record for a packet to a dump file.
1043    Returns TRUE on success, FALSE on failure. */
1044 static gboolean libpcap_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
1045     const union wtap_pseudo_header *pseudo_header, const u_char *pd, int *err)
1046 {
1047         struct pcaprec_ss990915_hdr rec_hdr;
1048         size_t hdr_size;
1049         size_t nwritten;
1050
1051         rec_hdr.hdr.ts_sec = phdr->ts.tv_sec;
1052         rec_hdr.hdr.ts_usec = phdr->ts.tv_usec;
1053         rec_hdr.hdr.incl_len = phdr->caplen;
1054         rec_hdr.hdr.orig_len = phdr->len;
1055         switch (wdh->file_type) {
1056
1057         case WTAP_FILE_PCAP:
1058                 hdr_size = sizeof (struct pcaprec_hdr);
1059                 break;
1060
1061         case WTAP_FILE_PCAP_SS990417:   /* modified, but with the old magic, sigh */
1062         case WTAP_FILE_PCAP_SS991029:
1063                 /* XXX - what should we supply here?
1064
1065                    Alexey's "libpcap" looks up the interface in the system's
1066                    interface list if "ifindex" is non-zero, and prints
1067                    the interface name.  It ignores "protocol", and uses
1068                    "pkt_type" to tag the packet as "host", "broadcast",
1069                    "multicast", "other host", "outgoing", or "none of the
1070                    above", but that's it.
1071
1072                    If the capture we're writing isn't a modified or
1073                    RH 6.1 capture, we'd have to do some work to
1074                    generate the packet type and interface index - and
1075                    we can't generate the interface index unless we
1076                    just did the capture ourselves in any case.
1077
1078                    I'm inclined to continue to punt; systems other than
1079                    those with the older patch can read standard "libpcap"
1080                    files, and systems with the older patch, e.g. RH 6.1,
1081                    will just have to live with this. */
1082                 rec_hdr.ifindex = 0;
1083                 rec_hdr.protocol = 0;
1084                 rec_hdr.pkt_type = 0;
1085                 hdr_size = sizeof (struct pcaprec_modified_hdr);
1086                 break;
1087
1088         case WTAP_FILE_PCAP_SS990915:   /* new magic, extra crap at the end */
1089                 rec_hdr.ifindex = 0;
1090                 rec_hdr.protocol = 0;
1091                 rec_hdr.pkt_type = 0;
1092                 rec_hdr.cpu1 = 0;
1093                 rec_hdr.cpu2 = 0;
1094                 hdr_size = sizeof (struct pcaprec_ss990915_hdr);
1095                 break;
1096
1097         case WTAP_FILE_PCAP_NOKIA:      /* old magic, extra crap at the end */
1098                 rec_hdr.ifindex = 0;
1099                 rec_hdr.protocol = 0;
1100                 rec_hdr.pkt_type = 0;
1101                 rec_hdr.cpu1 = 0;
1102                 rec_hdr.cpu2 = 0;
1103                 hdr_size = sizeof (struct pcaprec_nokia_hdr);
1104                 break;
1105
1106         default:
1107                 /* We should never get here - our open routine
1108                    should only get called for the types above. */
1109                 g_assert_not_reached();
1110                 *err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
1111                 return FALSE;
1112         }
1113
1114         nwritten = fwrite(&rec_hdr, 1, hdr_size, wdh->fh);
1115         if (nwritten != hdr_size) {
1116                 if (nwritten == 0 && ferror(wdh->fh))
1117                         *err = errno;
1118                 else
1119                         *err = WTAP_ERR_SHORT_WRITE;
1120                 return FALSE;
1121         }
1122         nwritten = fwrite(pd, 1, phdr->caplen, wdh->fh);
1123         if (nwritten != phdr->caplen) {
1124                 if (nwritten == 0 && ferror(wdh->fh))
1125                         *err = errno;
1126                 else
1127                         *err = WTAP_ERR_SHORT_WRITE;
1128                 return FALSE;
1129         }
1130         return TRUE;
1131 }