wiretap/libpcap.c

   1 /* libpcap.c
   2  *
   3  * $Id: libpcap.c,v 1.48 2001/03/15 09:11:03 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, int *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 #define NUM_PCAP_ENCAPS (sizeof pcap_to_wtap_map / sizeof pcap_to_wtap_map[0])
 368
 369 int libpcap_open(wtap *wth, int *err)
 370 {
 371         int bytes_read;
 372         guint32 magic;
 373         struct pcap_hdr hdr;
 374         gboolean byte_swapped;
 375         gboolean modified;
 376         int file_encap;
 377
 378         /* Read in the number that should be at the start of a "libpcap" file */
 379         errno = WTAP_ERR_CANT_READ;
 380         bytes_read = file_read(&magic, 1, sizeof magic, wth->fh);
 381         if (bytes_read != sizeof magic) {
 382                 *err = file_error(wth->fh);
 383                 if (*err != 0)
 384                         return -1;
 385                 return 0;
 386         }
 387         wth->data_offset += sizeof magic;
 388
 389         switch (magic) {
 390
 391         case PCAP_MAGIC:
 392                 /* Host that wrote it has our byte order, and was running
 393                    a program using either standard or ss990417 libpcap. */
 394                 byte_swapped = FALSE;
 395                 modified = FALSE;
 396                 break;
 397
 398         case PCAP_MODIFIED_MAGIC:
 399                 /* Host that wrote it has our byte order, and was running
 400                    a program using either ss990915 or ss991029 libpcap. */
 401                 byte_swapped = FALSE;
 402                 modified = TRUE;
 403                 break;
 404
 405         case PCAP_SWAPPED_MAGIC:
 406                 /* Host that wrote it has a byte order opposite to ours,
 407                    and was running a program using either standard or
 408                    ss990417 libpcap. */
 409                 byte_swapped = TRUE;
 410                 modified = FALSE;
 411                 break;
 412
 413         case PCAP_SWAPPED_MODIFIED_MAGIC:
 414                 /* Host that wrote it out has a byte order opposite to
 415                    ours, and was running a program using either ss990915
 416                    or ss991029 libpcap. */
 417                 byte_swapped = TRUE;
 418                 modified = TRUE;
 419                 break;
 420
 421         default:
 422                 /* Not a "libpcap" type we know about. */
 423                 return 0;
 424         }
 425
 426         /* Read the rest of the header. */
 427         errno = WTAP_ERR_CANT_READ;
 428         bytes_read = file_read(&hdr, 1, sizeof hdr, wth->fh);
 429         if (bytes_read != sizeof hdr) {
 430                 *err = file_error(wth->fh);
 431                 if (*err != 0)
 432                         return -1;
 433                 return 0;
 434         }
 435         wth->data_offset += sizeof hdr;
 436
 437         if (byte_swapped) {
 438                 /* Byte-swap the header fields about which we care. */
 439                 hdr.version_major = BSWAP16(hdr.version_major);
 440                 hdr.version_minor = BSWAP16(hdr.version_minor);
 441                 hdr.snaplen = BSWAP32(hdr.snaplen);
 442                 hdr.network = BSWAP32(hdr.network);
 443         }
 444         if (hdr.version_major < 2) {
 445                 /* We only support version 2.0 and later. */
 446                 g_message("pcap: major version %u unsupported",
 447                     hdr.version_major);
 448                 *err = WTAP_ERR_UNSUPPORTED;
 449                 return -1;
 450         }
 451         file_encap = wtap_pcap_encap_to_wtap_encap(hdr.network);
 452         if (file_encap == WTAP_ENCAP_UNKNOWN) {
 453                 g_message("pcap: network type %u unknown or unsupported",
 454                     hdr.network);
 455                 *err = WTAP_ERR_UNSUPPORTED_ENCAP;
 456                 return -1;
 457         }
 458
 459         /* This is a libpcap file */
 460         wth->capture.pcap = g_malloc(sizeof(libpcap_t));
 461         wth->capture.pcap->byte_swapped = byte_swapped;
 462         wth->capture.pcap->version_major = hdr.version_major;
 463         wth->capture.pcap->version_minor = hdr.version_minor;
 464         wth->subtype_read = libpcap_read;
 465         wth->subtype_seek_read = wtap_def_seek_read;
 466         wth->subtype_close = libpcap_close;
 467         wth->file_encap = file_encap;
 468         wth->snapshot_length = hdr.snaplen;
 469
 470         /*
 471          * Yes.  Let's look at the header for the first record,
 472          * and see if, interpreting it as a standard header (if the
 473          * magic number was standard) or a modified header (if the
 474          * magic number was modified), the position where it says the
 475          * header for the *second* record is contains a corrupted header.
 476          *
 477          * If so, then:
 478          *
 479          *      If this file had the standard magic number, it may be
 480          *      an ss990417 capture file - in that version of Alexey's
 481          *      patch, the packet header format was changed but the
 482          *      magic number wasn't, and, alas, Red Hat appear to have
 483          *      picked up that version of the patch for RH 6.1, meaning
 484          *      RH 6.1 has a tcpdump that writes out files that can't
 485          *      be read by any software that expects non-modified headers
 486          *      if the magic number isn't the modified magic number (e.g.,
 487          *      any normal version of tcpdump, and Ethereal if we don't
 488          *      do this gross heuristic).
 489          *
 490          *      If this file had the modified magic number, it may be
 491          *      an ss990915 capture file - in that version of Alexey's
 492          *      patch, the magic number was changed, but the record
 493          *      header had some extra fields, and, alas, SuSE appear
 494          *      to have picked up that version of the patch for SuSE
 495          *      6.3, meaning that programs expecting the standard per-
 496          *      packet header in captures with the modified magic number
 497          *      can't read dumps from its tcpdump.
 498          *
 499          * Oh, and if it has the standard magic number, it might, instead,
 500          * be a Nokia libpcap file, so we may need to try that if
 501          * neither normal nor ss990417 headers work.
 502          */
 503         if (modified) {
 504                 /*
 505                  * Well, we have the magic number from Alexey's
 506                  * later two patches.
 507                  *
 508                  * Try ss991029, the last of his patches, first.
 509                  */
 510                 wth->file_type = WTAP_FILE_PCAP_SS991029;
 511                 switch (libpcap_try(wth, err)) {
 512
 513                 case BAD_READ:
 514                         /*
 515                          * Well, we couldn't even read it.
 516                          * Give up.
 517                          */
 518                         return -1;
 519
 520                 case THIS_FORMAT:
 521                         /*
 522                          * Well, it looks as if it might be 991029.
 523                          * Put the seek pointer back, and return success.
 524                          */
 525                         file_seek(wth->fh, wth->data_offset, SEEK_SET);
 526                         return 1;
 527
 528                 case OTHER_FORMAT:
 529                         /*
 530                          * Try the next format.
 531                          */
 532                         break;
 533                 }
 534
 535                 /*
 536                  * Well, it's not completely unreadable,
 537                  * but it's not ss991029.  Try ss990915;
 538                  * there are no other types to try after that,
 539                  * so we put the seek pointer back and treat
 540                  * it as 990915.
 541                  */
 542                 wth->file_type = WTAP_FILE_PCAP_SS990915;
 543                 file_seek(wth->fh, wth->data_offset, SEEK_SET);
 544         } else {
 545                 /*
 546                  * Well, we have the standard magic number.
 547                  *
 548                  * Try the standard format first.
 549                  */
 550                 wth->file_type = WTAP_FILE_PCAP;
 551                 switch (libpcap_try(wth, err)) {
 552
 553                 case BAD_READ:
 554                         /*
 555                          * Well, we couldn't even read it.
 556                          * Give up.
 557                          */
 558                         return -1;
 559
 560                 case THIS_FORMAT:
 561                         /*
 562                          * Well, it looks as if it might be a standard
 563                          * libpcap file.
 564                          * Put the seek pointer back, and return success.
 565                          */
 566                         file_seek(wth->fh, wth->data_offset, SEEK_SET);
 567                         return 1;
 568
 569                 case OTHER_FORMAT:
 570                         /*
 571                          * Try the next format.
 572                          */
 573                         break;
 574                 }
 575
 576                 /*
 577                  * Well, it's not completely unreadable, but it's not
 578                  * a standard file.  Put the seek pointer back and try
 579                  * ss990417.
 580                  */
 581                 wth->file_type = WTAP_FILE_PCAP_SS990417;
 582                 file_seek(wth->fh, wth->data_offset, SEEK_SET);
 583                 switch (libpcap_try(wth, err)) {
 584
 585                 case BAD_READ:
 586                         /*
 587                          * Well, we couldn't even read it.
 588                          * Give up.
 589                          */
 590                         return -1;
 591
 592                 case THIS_FORMAT:
 593                         /*
 594                          * Well, it looks as if it might be ss990417.
 595                          * Put the seek pointer back, and return success.
 596                          */
 597                         file_seek(wth->fh, wth->data_offset, SEEK_SET);
 598                         return 1;
 599
 600                 case OTHER_FORMAT:
 601                         /*
 602                          * Try the next format.
 603                          */
 604                         break;
 605                 }
 606
 607                 /*
 608                  * Well, it's not completely unreadable,
 609                  * but it's not a standard file *nor* is it ss990417.
 610                  * Try it as a Nokia file; there are no other types
 611                  * to try after that, so we put the seek pointer back
 612                  * and treat it as a Nokia file.
 613                  */
 614                 wth->file_type = WTAP_FILE_PCAP_NOKIA;
 615                 file_seek(wth->fh, wth->data_offset, SEEK_SET);
 616         }
 617
 618         return 1;
 619 }
 620
 621 /* Try to read the first two records of the capture file. */
 622 static libpcap_try_t libpcap_try(wtap *wth, int *err)
 623 {
 624         /*
 625          * pcaprec_ss990915_hdr is the largest header type.
 626          */
 627         struct pcaprec_ss990915_hdr first_rec_hdr, second_rec_hdr;
 628
 629         /*
 630          * Attempt to read the first record's header.
 631          */
 632         if (libpcap_read_header(wth, err, &first_rec_hdr, TRUE) == -1) {
 633                 if (*err == 0 || *err == WTAP_ERR_SHORT_READ) {
 634                         /*
 635                          * EOF or short read - assume the file is in this
 636                          * format.
 637                          * When our client tries to read the first packet
 638                          * they will presumably get the same EOF or short
 639                          * read.
 640                          */
 641                         return THIS_FORMAT;
 642                 }
 643
 644                 if (*err == WTAP_ERR_BAD_RECORD) {
 645                         /*
 646                          * The first record is bogus, so this is probably
 647                          * a corrupt file.  Assume the file is in this
 648                          * format.  When our client tries to read the
 649                          * first packet they will presumably get the
 650                          * same bogus record.
 651                          */
 652                         return THIS_FORMAT;
 653                 }
 654
 655                 /*
 656                  * Some other error, e.g. an I/O error; just give up.
 657                  */
 658                 return BAD_READ;
 659         }
 660
 661         /*
 662          * Now skip over the first record's data, under the assumption
 663          * that the header is sane.
 664          */
 665         file_seek(wth->fh, first_rec_hdr.hdr.incl_len, SEEK_CUR);
 666
 667         /*
 668          * Now attempt to read the second record's header.
 669          */
 670         if (libpcap_read_header(wth, err, &second_rec_hdr, TRUE) == -1) {
 671                 if (*err == 0 || *err == WTAP_ERR_SHORT_READ) {
 672                         /*
 673                          * EOF or short read - assume the file is in this
 674                          * format.
 675                          * When our client tries to read the second packet
 676                          * they will presumably get the same EOF or short
 677                          * read.
 678                          */
 679                         return THIS_FORMAT;
 680                 }
 681
 682                 if (*err == WTAP_ERR_BAD_RECORD) {
 683                         /*
 684                          * The second record is bogus; maybe it's a
 685                          * Capture File From Hell, and what looks like
 686                          * the "header" of the next packet is actually
 687                          * random junk from the middle of a packet.
 688                          * Try the next format; if we run out of formats,
 689                          * it probably *is* a corrupt file.
 690                          */
 691                         return OTHER_FORMAT;
 692                 }
 693
 694                 /*
 695                  * Some other error, e.g. an I/O error; just give up.
 696                  */
 697                 return BAD_READ;
 698         }
 699
 700         /*
 701          * OK, the first two records look OK; assume this is the
 702          * right format.
 703          */
 704         return THIS_FORMAT;
 705 }
 706
 707 /* Read the next packet */
 708 static gboolean libpcap_read(wtap *wth, int *err, int *data_offset)
 709 {
 710         struct pcaprec_ss990915_hdr hdr;
 711         guint packet_size;
 712         int bytes_read;
 713
 714         bytes_read = libpcap_read_header(wth, err, &hdr, FALSE);
 715         if (bytes_read == -1) {
 716                 /*
 717                  * We failed to read the header.
 718                  */
 719                 return FALSE;
 720         }
 721
 722         wth->data_offset += bytes_read;
 723         packet_size = hdr.hdr.incl_len;
 724
 725         buffer_assure_space(wth->frame_buffer, packet_size);
 726         *data_offset = wth->data_offset;
 727         errno = WTAP_ERR_CANT_READ;
 728         bytes_read = file_read(buffer_start_ptr(wth->frame_buffer), 1,
 729                         packet_size, wth->fh);
 730
 731         if (bytes_read != packet_size) {
 732                 *err = file_error(wth->fh);
 733                 if (*err == 0)
 734                         *err = WTAP_ERR_SHORT_READ;
 735                 return FALSE;
 736         }
 737         wth->data_offset += packet_size;
 738
 739         wth->phdr.ts.tv_sec = hdr.hdr.ts_sec;
 740         wth->phdr.ts.tv_usec = hdr.hdr.ts_usec;
 741         wth->phdr.caplen = packet_size;
 742         wth->phdr.len = hdr.hdr.orig_len;
 743         wth->phdr.pkt_encap = wth->file_encap;
 744
 745         return TRUE;
 746 }
 747
 748 /* Read the header of the next packet; if "silent" is TRUE, don't complain
 749    to the console, as we're testing to see if the file appears to be of a
 750    particular type.
 751
 752    Return -1 on an error, or the number of bytes of header read on success. */
 753 static int libpcap_read_header(wtap *wth, int *err,
 754     struct pcaprec_ss990915_hdr *hdr, gboolean silent)
 755 {
 756         int     bytes_to_read, bytes_read;
 757
 758         /* Read record header. */
 759         errno = WTAP_ERR_CANT_READ;
 760         switch (wth->file_type) {
 761
 762         case WTAP_FILE_PCAP:
 763                 bytes_to_read = sizeof (struct pcaprec_hdr);
 764                 break;
 765
 766         case WTAP_FILE_PCAP_SS990417:
 767         case WTAP_FILE_PCAP_SS991029:
 768                 bytes_to_read = sizeof (struct pcaprec_modified_hdr);
 769                 break;
 770
 771         case WTAP_FILE_PCAP_SS990915:
 772                 bytes_to_read = sizeof (struct pcaprec_ss990915_hdr);
 773                 break;
 774
 775         case WTAP_FILE_PCAP_NOKIA:
 776                 bytes_to_read = sizeof (struct pcaprec_nokia_hdr);
 777                 break;
 778
 779         default:
 780                 g_assert_not_reached();
 781                 bytes_to_read = 0;
 782         }
 783         bytes_read = file_read(hdr, 1, bytes_to_read, wth->fh);
 784         if (bytes_read != bytes_to_read) {
 785                 *err = file_error(wth->fh);
 786                 if (*err == 0 && bytes_read != 0) {
 787                         *err = WTAP_ERR_SHORT_READ;
 788                 }
 789                 return -1;
 790         }
 791
 792         adjust_header(wth, &hdr->hdr);
 793
 794         if (hdr->hdr.incl_len > WTAP_MAX_PACKET_SIZE) {
 795                 /*
 796                  * Probably a corrupt capture file; return an error,
 797                  * so that our caller doesn't blow up trying to allocate
 798                  * space for an immensely-large packet, and so that
 799                  * the code to try to guess what type of libpcap file
 800                  * this is can tell when it's not the type we're guessing
 801                  * it is.
 802                  */
 803                 if (!silent) {
 804                         g_message("pcap: File has %u-byte packet, bigger than maximum of %u",
 805                             hdr->hdr.incl_len, WTAP_MAX_PACKET_SIZE);
 806                 }
 807                 *err = WTAP_ERR_BAD_RECORD;
 808                 return -1;
 809         }
 810
 811         if (hdr->hdr.orig_len > WTAP_MAX_PACKET_SIZE) {
 812                 /*
 813                  * Probably a corrupt capture file; return an error,
 814                  * so that our caller doesn't blow up trying to
 815                  * cope with a huge "real" packet length, and so that
 816                  * the code to try to guess what type of libpcap file
 817                  * this is can tell when it's not the type we're guessing
 818                  * it is.
 819                  */
 820                 if (!silent) {
 821                         g_message("pcap: File has %u-byte packet, bigger than maximum of %u",
 822                             hdr->hdr.orig_len, WTAP_MAX_PACKET_SIZE);
 823                 }
 824                 *err = WTAP_ERR_BAD_RECORD;
 825                 return -1;
 826         }
 827
 828         return bytes_read;
 829 }
 830
 831 static void
 832 adjust_header(wtap *wth, struct pcaprec_hdr *hdr)
 833 {
 834         if (wth->capture.pcap->byte_swapped) {
 835                 /* Byte-swap the record header fields. */
 836                 hdr->ts_sec = BSWAP32(hdr->ts_sec);
 837                 hdr->ts_usec = BSWAP32(hdr->ts_usec);
 838                 hdr->incl_len = BSWAP32(hdr->incl_len);
 839                 hdr->orig_len = BSWAP32(hdr->orig_len);
 840         }
 841
 842         /* In file format version 2.3, the "incl_len" and "orig_len" fields
 843            were swapped, in order to match the BPF header layout.
 844
 845            Unfortunately, some files were, according to a comment in the
 846            "libpcap" source, written with version 2.3 in their headers
 847            but without the interchanged fields, so if "incl_len" is
 848            greater than "orig_len" - which would make no sense - we
 849            assume that we need to swap them.  */
 850         if (wth->capture.pcap->version_major == 2 &&
 851             (wth->capture.pcap->version_minor < 3 ||
 852              (wth->capture.pcap->version_minor == 3 &&
 853               hdr->incl_len > hdr->orig_len))) {
 854                 guint32 temp;
 855
 856                 temp = hdr->orig_len;
 857                 hdr->orig_len = hdr->incl_len;
 858                 hdr->incl_len = temp;
 859         }
 860 }
 861
 862 static void
 863 libpcap_close(wtap *wth)
 864 {
 865         g_free(wth->capture.pcap);
 866 }
 867
 868 int wtap_pcap_encap_to_wtap_encap(int encap)
 869 {
 870         int i;
 871
 872         for (i = 0; i < NUM_PCAP_ENCAPS; i++) {
 873                 if (pcap_to_wtap_map[i].dlt_value == encap)
 874                         return pcap_to_wtap_map[i].wtap_encap_value;
 875         }
 876         return WTAP_ENCAP_UNKNOWN;
 877 }
 878
 879 static int wtap_wtap_encap_to_pcap_encap(int encap)
 880 {
 881         int i;
 882
 883         /*
 884          * Special-case WTAP_ENCAP_FDDI and WTAP_ENCAP_FDDI_BITSWAPPED;
 885          * both of them get mapped to DLT_FDDI (even though that may
 886          * mean that the bit order in the FDDI MAC addresses is wrong;
 887          * so it goes - libpcap format doesn't record the byte order,
 888          * so that's not fixable).
 889          */
 890         if (encap == WTAP_ENCAP_FDDI || encap == WTAP_ENCAP_FDDI_BITSWAPPED)
 891                 return 10;      /* that's DLT_FDDI */
 892         for (i = 0; i < NUM_PCAP_ENCAPS; i++) {
 893                 if (pcap_to_wtap_map[i].wtap_encap_value == encap)
 894                         return pcap_to_wtap_map[i].dlt_value;
 895         }
 896         return -1;
 897 }
 898
 899 /* Returns 0 if we could write the specified encapsulation type,
 900    an error indication otherwise. */
 901 int libpcap_dump_can_write_encap(int filetype, int encap)
 902 {
 903         /* Per-packet encapsulations aren't supported. */
 904         if (encap == WTAP_ENCAP_PER_PACKET)
 905                 return WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED;
 906
 907         if (wtap_wtap_encap_to_pcap_encap(encap) == -1)
 908                 return WTAP_ERR_UNSUPPORTED_ENCAP;
 909
 910         return 0;
 911 }
 912
 913 /* Returns TRUE on success, FALSE on failure; sets "*err" to an error code on
 914    failure */
 915 gboolean libpcap_dump_open(wtap_dumper *wdh, int *err)
 916 {
 917         guint32 magic;
 918         struct pcap_hdr file_hdr;
 919         int nwritten;
 920
 921         /* This is a libpcap file */
 922         wdh->subtype_write = libpcap_dump;
 923         wdh->subtype_close = NULL;
 924
 925         /* Write the file header. */
 926         switch (wdh->file_type) {
 927
 928         case WTAP_FILE_PCAP:
 929         case WTAP_FILE_PCAP_SS990417:   /* modified, but with the old magic, sigh */
 930         case WTAP_FILE_PCAP_NOKIA:      /* Nokia libpcap of some sort */
 931                 magic = PCAP_MAGIC;
 932                 break;
 933
 934         case WTAP_FILE_PCAP_SS990915:   /* new magic, extra crap */
 935         case WTAP_FILE_PCAP_SS991029:
 936                 magic = PCAP_MODIFIED_MAGIC;
 937                 break;
 938
 939         default:
 940                 /* We should never get here - our open routine
 941                    should only get called for the types above. */
 942                 *err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
 943                 return FALSE;
 944         }
 945
 946         nwritten = fwrite(&magic, 1, sizeof magic, wdh->fh);
 947         if (nwritten != sizeof magic) {
 948                 if (nwritten < 0)
 949                         *err = errno;
 950                 else
 951                         *err = WTAP_ERR_SHORT_WRITE;
 952                 return FALSE;
 953         }
 954
 955         /* current "libpcap" format is 2.4 */
 956         file_hdr.version_major = 2;
 957         file_hdr.version_minor = 4;
 958         file_hdr.thiszone = 0;  /* XXX - current offset? */
 959         file_hdr.sigfigs = 0;   /* unknown, but also apparently unused */
 960         file_hdr.snaplen = wdh->snaplen;
 961         file_hdr.network = wtap_wtap_encap_to_pcap_encap(wdh->encap);
 962         nwritten = fwrite(&file_hdr, 1, sizeof file_hdr, wdh->fh);
 963         if (nwritten != sizeof file_hdr) {
 964                 if (nwritten < 0)
 965                         *err = errno;
 966                 else
 967                         *err = WTAP_ERR_SHORT_WRITE;
 968                 return FALSE;
 969         }
 970
 971         return TRUE;
 972 }
 973
 974 /* Write a record for a packet to a dump file.
 975    Returns TRUE on success, FALSE on failure. */
 976 static gboolean libpcap_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
 977     const union wtap_pseudo_header *pseudo_header, const u_char *pd, int *err)
 978 {
 979         struct pcaprec_ss990915_hdr rec_hdr;
 980         int hdr_size;
 981         int nwritten;
 982
 983         rec_hdr.hdr.ts_sec = phdr->ts.tv_sec;
 984         rec_hdr.hdr.ts_usec = phdr->ts.tv_usec;
 985         rec_hdr.hdr.incl_len = phdr->caplen;
 986         rec_hdr.hdr.orig_len = phdr->len;
 987         switch (wdh->file_type) {
 988
 989         case WTAP_FILE_PCAP:
 990                 hdr_size = sizeof (struct pcaprec_hdr);
 991                 break;
 992
 993         case WTAP_FILE_PCAP_SS990417:   /* modified, but with the old magic, sigh */
 994         case WTAP_FILE_PCAP_SS991029:
 995                 /* XXX - what should we supply here?
 996
 997                    Alexey's "libpcap" looks up the interface in the system's
 998                    interface list if "ifindex" is non-zero, and prints
 999                    the interface name.  It ignores "protocol", and uses
1000                    "pkt_type" to tag the packet as "host", "broadcast",
1001                    "multicast", "other host", "outgoing", or "none of the
1002                    above", but that's it.
1003
1004                    If the capture we're writing isn't a modified or
1005                    RH 6.1 capture, we'd have to do some work to
1006                    generate the packet type and interface index - and
1007                    we can't generate the interface index unless we
1008                    just did the capture ourselves in any case.
1009
1010                    I'm inclined to continue to punt; systems other than
1011                    those with the older patch can read standard "libpcap"
1012                    files, and systems with the older patch, e.g. RH 6.1,
1013                    will just have to live with this. */
1014                 rec_hdr.ifindex = 0;
1015                 rec_hdr.protocol = 0;
1016                 rec_hdr.pkt_type = 0;
1017                 hdr_size = sizeof (struct pcaprec_modified_hdr);
1018                 break;
1019
1020         case WTAP_FILE_PCAP_SS990915:   /* new magic, extra crap at the end */
1021                 rec_hdr.ifindex = 0;
1022                 rec_hdr.protocol = 0;
1023                 rec_hdr.pkt_type = 0;
1024                 rec_hdr.cpu1 = 0;
1025                 rec_hdr.cpu2 = 0;
1026                 hdr_size = sizeof (struct pcaprec_ss990915_hdr);
1027                 break;
1028
1029         case WTAP_FILE_PCAP_NOKIA:      /* old magic, extra crap at the end */
1030                 rec_hdr.ifindex = 0;
1031                 rec_hdr.protocol = 0;
1032                 rec_hdr.pkt_type = 0;
1033                 rec_hdr.cpu1 = 0;
1034                 rec_hdr.cpu2 = 0;
1035                 hdr_size = sizeof (struct pcaprec_nokia_hdr);
1036                 break;
1037
1038         default:
1039                 /* We should never get here - our open routine
1040                    should only get called for the types above. */
1041                 g_assert_not_reached();
1042                 *err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
1043                 return FALSE;
1044         }
1045
1046         nwritten = fwrite(&rec_hdr, 1, hdr_size, wdh->fh);
1047         if (nwritten != hdr_size) {
1048                 if (nwritten < 0)
1049                         *err = errno;
1050                 else
1051                         *err = WTAP_ERR_SHORT_WRITE;
1052                 return FALSE;
1053         }
1054         nwritten = fwrite(pd, 1, phdr->caplen, wdh->fh);
1055         if (nwritten != phdr->caplen) {
1056                 if (nwritten < 0)
1057                         *err = errno;
1058                 else
1059                         *err = WTAP_ERR_SHORT_WRITE;
1060                 return FALSE;
1061         }
1062         return TRUE;
1063 }