wiretap/pcap-common.c

   1 /* pcap-common.c
   2  * Code common to libpcap and pcap-NG file formats
   3  *
   4  * $Id$
   5  *
   6  * Wiretap Library
   7  * Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
   8  *
   9  * File format support for pcap-ng file format
  10  * Copyright (c) 2007 by Ulf Lamping <ulf.lamping@web.de>
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26
  27 #include "config.h"
  28
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <errno.h>
  32 #include "wtap-int.h"
  33 #include "file_wrappers.h"
  34 #include "atm.h"
  35 #include "erf.h"
  36 #include "pcap-encap.h"
  37 #include "pcap-common.h"
  38
  39 /*
  40  * Map link-layer header types (LINKTYPE_ values) to Wiretap encapsulations.
  41  *
  42  * Either LBL NRG wasn't an adequate central registry (e.g., because of
  43  * the slow rate of releases from them), or nobody bothered using them
  44  * as a central registry, as many different groups have patched libpcap
  45  * (and BPF, on the BSDs) to add new encapsulation types, and have ended
  46  * up using the same DLT_ values for different encapsulation types.
  47  *
  48  * The Tcpdump Group now maintains the list of link-layer header types;
  49  * they introduced a separate namespace of LINKTYPE_ values for the
  50  * values to be used in capture files, and have libpcap map between
  51  * those values in capture file headers and the DLT_ values that the
  52  * pcap_datalink() and pcap_open_dead() APIs use.  See
  53  * http://www.tcpdump.org/linktypes.html for a list of LINKTYPE_ values.
  54  *
  55  * In most cases, the corresponding LINKTYPE_ and DLT_ values are the
  56  * same.  In the cases where the same link-layer header type was given
  57  * different values in different OSes, a new LINKTYPE_ value was defined,
  58  * different from all of the existing DLT_ values.
  59  *
  60  * This table maps LINKTYPE_ values to the corresponding Wiretap
  61  * encapsulation.  For cases where multiple DLT_ values were in use,
  62  * it also checks what <pcap.h> defineds to determine how to interpret
  63  * them, so that if a file was written by a version of libpcap prior
  64  * to the introduction of the LINKTYPE_ values, and has a DLT_ value
  65  * from the OS on which it was written rather than a LINKTYPE_ value
  66  * as its linktype value in the file header, we map the numerical
  67  * DLT_ value, as interpreted by the libpcap with which we're building
  68  * Wireshark/Wiretap interprets them (which, if it doesn't support
  69  * them at all, means we don't support them either - any capture files
  70  * using them are foreign, and we don't hazard a guess as to which
  71  * platform they came from; we could, I guess, choose the most likely
  72  * platform), to the corresponding Wiretap encapsulation.
  73  *
  74  * Note: if you need a new encapsulation type for libpcap files, do
  75  * *N*O*T* use *ANY* of the values listed here!  I.e., do *NOT*
  76  * add a new encapsulation type by changing an existing entry;
  77  * leave the existing entries alone.
  78  *
  79  * Instead, send mail to tcpdump-workers@lists.tcpdump.org, asking for
  80  * a new LINKTYPE_/DLT_ value, and specifying the purpose of the new
  81  * value.  When you get the new LINKTYPE_/DLT_ value, use that numerical
  82  * value in the "linktype_value" field of "pcap_to_wtap_map[]".
  83  */
  84
  85 static const struct {
  86         int     linktype_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 thus assigned as LINKTYPE_ values,
  94          * and that Wiretap and Wireshark currently support.
  95          */
  96         { 0,            WTAP_ENCAP_NULL },      /* null encapsulation */
  97         { 1,            WTAP_ENCAP_ETHERNET },
  98         { 3,            WTAP_ENCAP_AX25 },
  99         { 6,            WTAP_ENCAP_TOKEN_RING },        /* IEEE 802 Networks - assume token ring */
 100         { 7,            WTAP_ENCAP_ARCNET },
 101         { 8,            WTAP_ENCAP_SLIP },
 102         { 9,            WTAP_ENCAP_PPP },
 103 #ifdef BIT_SWAPPED_MAC_ADDRS
 104         { 10,           WTAP_ENCAP_FDDI_BITSWAPPED },
 105 #else
 106         { 10,           WTAP_ENCAP_FDDI },
 107 #endif
 108
 109         { 32,           WTAP_ENCAP_REDBACK },
 110
 111         /*
 112          * 50 is DLT_PPP_SERIAL in NetBSD; it appears that DLT_PPP
 113          * on BSD (at least according to standard tcpdump) has, as
 114          * the first octet, an indication of whether the packet was
 115          * transmitted or received (rather than having the standard
 116          * PPP address value of 0xff), but that DLT_PPP_SERIAL puts
 117          * a real live PPP header there, or perhaps a Cisco PPP header
 118          * as per section 4.3.1 of RFC 1547 (implementations of this
 119          * exist in various BSDs in "sys/net/if_spppsubr.c", and
 120          * I think also exist either in standard Linux or in
 121          * various Linux patches; the implementations show how to handle
 122          * Cisco keepalive packets).
 123          *
 124          * However, I don't see any obvious place in FreeBSD "if_ppp.c"
 125          * where anything other than the standard PPP header would be
 126          * passed up.  I see some stuff that sets the first octet
 127          * to 0 for incoming and 1 for outgoing packets before applying
 128          * a BPF filter to see whether to drop packets whose protocol
 129          * field has the 0x8000 bit set, i.e. network control protocols -
 130          * those are handed up to userland - but that code puts the
 131          * address field back before passing the packet up.
 132          *
 133          * I also don't see anything immediately obvious that munges
 134          * the address field for sync PPP, either.
 135          *
 136          * Wireshark currently assumes that if the first octet of a
 137          * PPP frame is 0xFF, it's the address field and is followed
 138          * by a control field and a 2-byte protocol, otherwise the
 139          * address and control fields are absent and the frame begins
 140          * with a protocol field.  If we ever see a BSD/OS PPP
 141          * capture, we'll have to handle it differently, and we may
 142          * have to handle standard BSD captures differently if, in fact,
 143          * they don't have 0xff 0x03 as the first two bytes - but, as per
 144          * the two paragraphs preceding this, it's not clear that
 145          * the address field *is* munged into an incoming/outgoing
 146          * field when the packet is handed to the BPF device.
 147          *
 148          * For now, we just map DLT_PPP_SERIAL to WTAP_ENCAP_PPP, as
 149          * we treat WTAP_ENCAP_PPP packets as if those beginning with
 150          * 0xff have the standard RFC 1662 "PPP in HDLC-like Framing"
 151          * 0xff 0x03 address/control header, and DLT_PPP_SERIAL frames
 152          * appear to contain that unless they're Cisco frames (if we
 153          * ever see a capture with them, we'd need to implement the
 154          * RFC 1547 stuff, and the keepalive protocol stuff).
 155          *
 156          * We may have to distinguish between "PPP where if it doesn't
 157          * begin with 0xff there's no HDLC encapsulation and the frame
 158          * begins with the protocol field" (which is how we handle
 159          * WTAP_ENCAP_PPP now) and "PPP where there's either HDLC
 160          * encapsulation or Cisco PPP" (which is what DLT_PPP_SERIAL
 161          * is) at some point.
 162          *
 163          * XXX - NetBSD has DLT_HDLC, which appears to be used for
 164          * Cisco HDLC.  Ideally, they should use DLT_PPP_SERIAL
 165          * only for real live HDLC-encapsulated PPP, not for Cisco
 166          * HDLC.
 167          */
 168         { 50,           WTAP_ENCAP_PPP },
 169
 170         /*
 171          * Used by NetBSD and OpenBSD pppoe(4).
 172          */
 173         { 51,           WTAP_ENCAP_PPP_ETHER },
 174
 175         /*
 176          * Apparently used by the Axent Raptor firewall (now Symantec
 177          * Enterprise Firewall).
 178          * Thanks, Axent, for not reserving that type with tcpdump.org
 179          * and not telling anybody about it.
 180          */
 181         { 99,           WTAP_ENCAP_SYMANTEC },
 182
 183         /*
 184          * These are the values that libpcap 0.5 and later use in
 185          * capture file headers, in an attempt to work around the
 186          * confusion decried above, and that Wiretap and Wireshark
 187          * currently support.  I.e., they're the LINKTYPE_ values
 188          * for RFC 1483 ATM and "raw IP", respectively, not the
 189          * DLT_ values for them on all platforms.
 190          */
 191         { 100,          WTAP_ENCAP_ATM_RFC1483 },
 192         { 101,          WTAP_ENCAP_RAW_IP },
 193 #if 0
 194         /*
 195          * More values used by libpcap 0.5 as DLT_ values and used by the
 196          * current CVS version of libpcap in capture file headers.
 197          * They are not yet handled in Wireshark.
 198          * If we get a capture that contains them, we'll implement them.
 199          */
 200         { 102,          WTAP_ENCAP_SLIP_BSDOS },
 201         { 103,          WTAP_ENCAP_PPP_BSDOS },
 202 #endif
 203
 204         /*
 205          * These ones are handled in Wireshark, though.
 206          */
 207         { 104,          WTAP_ENCAP_CHDLC },     /* Cisco HDLC */
 208         { 105,          WTAP_ENCAP_IEEE_802_11 }, /* IEEE 802.11 */
 209         { 106,          WTAP_ENCAP_LINUX_ATM_CLIP },
 210         { 107,          WTAP_ENCAP_FRELAY },    /* Frame Relay */
 211         { 108,          WTAP_ENCAP_NULL },      /* OpenBSD loopback */
 212         { 109,          WTAP_ENCAP_ENC },       /* OpenBSD IPSEC enc */
 213 #if 0
 214         { 110,          WTAP_ENCAP_LANE_802_3 },/* ATM LANE 802.3 */
 215         { 111,          WTAP_ENCAP_HIPPI },     /* NetBSD HIPPI */
 216 #endif
 217         { 112,          WTAP_ENCAP_CHDLC },     /* NetBSD HDLC framing */
 218
 219         /*
 220          * Linux "cooked mode" captures, used by the current CVS version
 221          * of libpcap
 222          * OR
 223          * it could be a packet in Cisco's ERSPAN encapsulation which uses
 224          * this number as well (why can't people stick to protocols when it
 225          * comes to allocating/using DLT types).
 226          */
 227         { 113,          WTAP_ENCAP_SLL },       /* Linux cooked capture */
 228
 229         { 114,          WTAP_ENCAP_LOCALTALK }, /* Localtalk */
 230
 231         /*
 232          * The tcpdump.org version of libpcap uses 117, rather than 17,
 233          * for OpenBSD packet filter logging, so as to avoid conflicting
 234          * with DLT_LANE8023 in SuSE 6.3 libpcap.
 235          */
 236         { 117,          WTAP_ENCAP_PFLOG },
 237
 238         { 118,          WTAP_ENCAP_CISCO_IOS },
 239         { 119,          WTAP_ENCAP_IEEE_802_11_PRISM }, /* 802.11 plus Prism monitor mode radio header */
 240         { 121,          WTAP_ENCAP_HHDLC },     /* HiPath HDLC */
 241         { 122,          WTAP_ENCAP_IP_OVER_FC },   /* RFC 2625 IP-over-FC */
 242         { 123,          WTAP_ENCAP_ATM_PDUS },  /* SunATM */
 243         { 127,          WTAP_ENCAP_IEEE_802_11_RADIOTAP },  /* 802.11 plus radiotap radio header */
 244         { 128,          WTAP_ENCAP_TZSP },      /* Tazmen Sniffer Protocol */
 245         { 129,          WTAP_ENCAP_ARCNET_LINUX },
 246         { 130,          WTAP_ENCAP_JUNIPER_MLPPP }, /* Juniper MLPPP on ML-, LS-, AS- PICs */
 247         { 131,          WTAP_ENCAP_JUNIPER_MLFR }, /* Juniper MLFR (FRF.15) on ML-, LS-, AS- PICs */
 248         { 133,          WTAP_ENCAP_JUNIPER_GGSN},
 249         /*
 250          * Values 132 and 134 not listed here are reserved for use
 251          * in Juniper hardware.
 252          */
 253         { 135,          WTAP_ENCAP_JUNIPER_ATM2 }, /* various encapsulations captured on the ATM2 PIC */
 254         { 136,          WTAP_ENCAP_JUNIPER_SVCS }, /* various encapsulations captured on the services PIC */
 255         { 137,          WTAP_ENCAP_JUNIPER_ATM1 }, /* various encapsulations captured on the ATM1 PIC */
 256
 257         { 138,          WTAP_ENCAP_APPLE_IP_OVER_IEEE1394 },
 258                                                 /* Apple IP-over-IEEE 1394 */
 259
 260         { 139,          WTAP_ENCAP_MTP2_WITH_PHDR },
 261         { 140,          WTAP_ENCAP_MTP2 },
 262         { 141,          WTAP_ENCAP_MTP3 },
 263         { 142,          WTAP_ENCAP_SCCP },
 264         { 143,          WTAP_ENCAP_DOCSIS },
 265         { 144,          WTAP_ENCAP_IRDA },      /* IrDA capture */
 266
 267         /* Reserved for private use. */
 268         { 147,          WTAP_ENCAP_USER0 },
 269         { 148,          WTAP_ENCAP_USER1 },
 270         { 149,          WTAP_ENCAP_USER2 },
 271         { 150,          WTAP_ENCAP_USER3 },
 272         { 151,          WTAP_ENCAP_USER4 },
 273         { 152,          WTAP_ENCAP_USER5 },
 274         { 153,          WTAP_ENCAP_USER6 },
 275         { 154,          WTAP_ENCAP_USER7 },
 276         { 155,          WTAP_ENCAP_USER8 },
 277         { 156,          WTAP_ENCAP_USER9 },
 278         { 157,          WTAP_ENCAP_USER10 },
 279         { 158,          WTAP_ENCAP_USER11 },
 280         { 159,          WTAP_ENCAP_USER12 },
 281         { 160,          WTAP_ENCAP_USER13 },
 282         { 161,          WTAP_ENCAP_USER14 },
 283         { 162,          WTAP_ENCAP_USER15 },
 284
 285         { 163,          WTAP_ENCAP_IEEE_802_11_AVS },  /* 802.11 plus AVS radio header */
 286
 287         /*
 288          * 164 is reserved for Juniper-private chassis-internal
 289          * meta-information such as QoS profiles, etc..
 290          */
 291
 292         { 165,          WTAP_ENCAP_BACNET_MS_TP },
 293
 294         /*
 295          * 166 is reserved for a PPP variant in which the first byte
 296          * of the 0xff03 header, the 0xff, is replaced by a direction
 297          * byte.  I don't know whether any captures look like that,
 298          * but it is used for some Linux IP filtering (ipfilter?).
 299          */
 300
 301         /* Ethernet PPPoE frames captured on a service PIC */
 302         { 167,          WTAP_ENCAP_JUNIPER_PPPOE },
 303
 304         /*
 305          * 168 is reserved for more Juniper private-chassis-
 306          * internal meta-information.
 307          */
 308
 309         { 169,          WTAP_ENCAP_GPRS_LLC },
 310
 311         /*
 312          * 170 and 171 are reserved for ITU-T G.7041/Y.1303 Generic
 313          * Framing Procedure.
 314          */
 315
 316         /* Registered by Gcom, Inc. */
 317         { 172,          WTAP_ENCAP_GCOM_TIE1 },
 318         { 173,          WTAP_ENCAP_GCOM_SERIAL },
 319
 320         { 177,          WTAP_ENCAP_LINUX_LAPD },
 321
 322         /* Ethernet frames prepended with meta-information */
 323         { 178,          WTAP_ENCAP_JUNIPER_ETHER },
 324         /* PPP frames prepended with meta-information */
 325         { 179,          WTAP_ENCAP_JUNIPER_PPP },
 326         /* Frame-Relay frames prepended with meta-information */
 327         { 180,          WTAP_ENCAP_JUNIPER_FRELAY },
 328         /* C-HDLC frames prepended with meta-information */
 329         { 181,          WTAP_ENCAP_JUNIPER_CHDLC },
 330         /* VOIP Frames prepended with meta-information */
 331         { 183,          WTAP_ENCAP_JUNIPER_VP },
 332         /* raw USB packets */
 333         { 186,          WTAP_ENCAP_USB },
 334         /* Bluetooth HCI UART transport (part H:4) frames, like hcidump */
 335         { 187,          WTAP_ENCAP_BLUETOOTH_H4 },
 336         /* IEEE 802.16 MAC Common Part Sublayer */
 337         { 188,          WTAP_ENCAP_IEEE802_16_MAC_CPS },
 338         /* USB packets with Linux-specified header */
 339         { 189,          WTAP_ENCAP_USB_LINUX },
 340         /* CAN 2.0b frame */
 341         { 190,          WTAP_ENCAP_CAN20B },
 342         /* Per-Packet Information header */
 343         { 192,          WTAP_ENCAP_PPI },
 344         /* IEEE 802.15.4 Wireless PAN */
 345         { 195,          WTAP_ENCAP_IEEE802_15_4 },
 346         /* SITA File Encapsulation */
 347         { 196,          WTAP_ENCAP_SITA },
 348         /* Endace Record File Encapsulation */
 349         { 197,          WTAP_ENCAP_ERF },
 350         /* IPMB */
 351         { 199,          WTAP_ENCAP_IPMB },
 352         /* Bluetooth HCI UART transport (part H:4) frames, like hcidump */
 353         { 201,          WTAP_ENCAP_BLUETOOTH_H4_WITH_PHDR },
 354         /* AX.25 packet with a 1-byte KISS header */
 355         { 202,          WTAP_ENCAP_AX25_KISS },
 356         /* LAPD frame */
 357         { 203,          WTAP_ENCAP_LAPD },
 358         /* PPP with pseudoheader */
 359         { 204,          WTAP_ENCAP_PPP_WITH_PHDR },
 360         /* IPMB/I2C */
 361         { 209,          WTAP_ENCAP_I2C },
 362         /* FlexRay frame */
 363         { 210,          WTAP_ENCAP_FLEXRAY },
 364         /* MOST frame */
 365         { 211,          WTAP_ENCAP_MOST },
 366         /* LIN frame */
 367         { 212,          WTAP_ENCAP_LIN },
 368         /* X2E Xoraya serial frame */
 369         { 213,          WTAP_ENCAP_X2E_SERIAL },
 370         /* X2E Xoraya frame */
 371         { 214,          WTAP_ENCAP_X2E_XORAYA },
 372         /* IEEE 802.15.4 Wireless PAN non-ASK PHY */
 373         { 215,          WTAP_ENCAP_IEEE802_15_4_NONASK_PHY },
 374         /* USB packets with padded Linux-specified header */
 375         { 220,          WTAP_ENCAP_USB_LINUX_MMAPPED },
 376         /* Fibre Channel FC-2 frame */
 377         { 224,          WTAP_ENCAP_FIBRE_CHANNEL_FC2 },
 378         /* Fibre Channel FC-2 frame with Delimiter */
 379         { 225,          WTAP_ENCAP_FIBRE_CHANNEL_FC2_WITH_FRAME_DELIMS },
 380         /* Solaris IPNET */
 381         { 226,          WTAP_ENCAP_IPNET },
 382         /* SocketCAN frame */
 383         { 227,          WTAP_ENCAP_SOCKETCAN },
 384         /* Raw IPv4 */
 385         { 228,          WTAP_ENCAP_RAW_IP4 },
 386         /* Raw IPv6 */
 387         { 229,          WTAP_ENCAP_RAW_IP6 },
 388         /* IEEE 802.15.4 Wireless PAN no fcs */
 389         { 230,          WTAP_ENCAP_IEEE802_15_4_NOFCS },
 390         /* D-BUS */
 391         { 231,          WTAP_ENCAP_DBUS },
 392         /* DVB-CI (Common Interface) */
 393         { 235,          WTAP_ENCAP_DVBCI },
 394         /* MUX27010 */
 395         { 236,          WTAP_ENCAP_MUX27010 },
 396         /* NFLOG */
 397         { 239,          WTAP_ENCAP_NFLOG },
 398         /* netANALYZER pseudo-header followed by Ethernet with CRC */
 399         { 240,          WTAP_ENCAP_NETANALYZER },
 400         /* netANALYZER pseudo-header in transparent mode */
 401         { 241,          WTAP_ENCAP_NETANALYZER_TRANSPARENT },
 402         /* IP-over-Infiniband, as specified by RFC 4391 section 6 */
 403         { 242,          WTAP_ENCAP_IP_OVER_IB },
 404         /* ISO/IEC 13818-1 MPEG2-TS packets */
 405         { 243,          WTAP_ENCAP_MPEG_2_TS },
 406         /* NFC LLCP */
 407         { 245,          WTAP_ENCAP_NFC_LLCP },
 408         /* SCTP */
 409         { 248,          WTAP_ENCAP_SCTP},
 410         /* USBPcap */
 411         { 249,          WTAP_ENCAP_USBPCAP},
 412         /* RTAC SERIAL */
 413         { 250,          WTAP_ENCAP_RTAC_SERIAL},
 414         /* Bluetooth Low Energy Link Layer */
 415         { 251,          WTAP_ENCAP_BLUETOOTH_LE_LL},
 416         /* Wireshark Upper PDU export */
 417         { 252,          WTAP_ENCAP_WIRESHARK_UPPER_PDU},
 418
 419         /*
 420          * To repeat:
 421          *
 422          * If you need a new encapsulation type for libpcap files, do
 423          * *N*O*T* use *ANY* of the values listed here!  I.e., do *NOT*
 424          * add a new encapsulation type by changing an existing entry;
 425          * leave the existing entries alone.
 426          *
 427          * Instead, send mail to tcpdump-workers@lists.tcpdump.org, asking
 428          * for a new DLT_ value, and specifying the purpose of the new value.
 429          * When you get the new DLT_ value, use that numerical value in
 430          * the "linktype_value" field of "pcap_to_wtap_map[]".
 431          */
 432
 433         /*
 434          * The following are entries for libpcap type values that have
 435          * different meanings on different OSes.  I.e., these are DLT_
 436          * values that are different on different OSes, and that have
 437          * a separate LINKTYPE_ value assigned to them.
 438          *
 439          * We put these *after* the entries for the LINKTYPE_ values for
 440          * those Wiretap encapsulation types, so that, when writing a
 441          * pcap or pcap-ng file, Wireshark writes the LINKTYPE_ value,
 442          * not the OS's DLT_ value, as the file's link-layer header type
 443          * for pcap or the interface's link-layer header type.
 444          */
 445
 446         /*
 447          * 11 is DLT_ATM_RFC1483 on most platforms; the only libpcaps I've
 448          * seen that define anything other than DLT_ATM_RFC1483 as 11 are
 449          * the BSD/OS one, which defines DLT_FR as 11, and libpcap 0.5,
 450          * which define it as 100, mapping the kernel's value to 100, in
 451          * an attempt to hide the different values used on different
 452          * platforms.
 453          *
 454          * If this is a platform where DLT_FR is defined as 11, we
 455          * don't handle 11 at all; otherwise, we handle it as
 456          * DLT_ATM_RFC1483 (this means we'd misinterpret Frame Relay
 457          * captures from BSD/OS if running on platforms other than BSD/OS,
 458          * but
 459          *
 460          *      1) we don't yet support DLT_FR
 461          *
 462          * and
 463          *
 464          *      2) nothing short of a heuristic would let us interpret
 465          *         them correctly).
 466          */
 467 #if defined(DLT_FR) && (DLT_FR == 11)
 468         { 11,           WTAP_ENCAP_FRELAY },
 469 #else
 470         { 11,           WTAP_ENCAP_ATM_RFC1483 },
 471 #endif
 472
 473         /*
 474          * 12 is DLT_RAW on most platforms, but it's DLT_C_HDLC on
 475          * BSD/OS, and DLT_LOOP on OpenBSD.
 476          *
 477          * We don't yet handle DLT_C_HDLC, but we can handle DLT_LOOP
 478          * (it's just like DLT_NULL, only with the AF_ value in network
 479          * rather than host byte order - Wireshark figures out the
 480          * byte order from the data, so we don't care what byte order
 481          * it's in), so if DLT_LOOP is defined as 12, interpret 12
 482          * as WTAP_ENCAP_NULL, otherwise, unless DLT_C_HDLC is defined
 483          * as 12, interpret it as WTAP_ENCAP_RAW_IP.
 484          */
 485 #if defined(DLT_LOOP) && (DLT_LOOP == 12)
 486         { 12,           WTAP_ENCAP_NULL },
 487 #elif defined(DLT_C_HDLC) && (DLT_C_HDLC == 12)
 488         /*
 489          * Put entry for Cisco HDLC here.
 490          * XXX - is this just WTAP_ENCAP_CHDLC, i.e. does the frame
 491          * start with a 4-byte Cisco HDLC header?
 492          */
 493 #else
 494         { 12,           WTAP_ENCAP_RAW_IP },
 495 #endif
 496
 497         /*
 498          * 13 is DLT_SLIP_BSDOS on FreeBSD and NetBSD, but those OSes
 499          * don't actually generate it.  I infer that BSD/OS translates
 500          * DLT_SLIP from the kernel BPF code to DLT_SLIP_BSDOS in
 501          * libpcap, as the BSD/OS link-layer header is different;
 502          * however, in BSD/OS, DLT_SLIP_BSDOS is 15.
 503          *
 504          * From this, I infer that there's no point in handling 13
 505          * as DLT_SLIP_BSDOS.
 506          *
 507          * 13 is DLT_ATM_RFC1483 on BSD/OS.
 508          *
 509          * 13 is DLT_ENC in OpenBSD, which is, I suspect, some kind
 510          * of decrypted IPsec traffic.
 511          *
 512          * We treat 13 as WTAP_ENCAP_ENC on all systems except those
 513          * that define DLT_ATM_RFC1483 as 13 - presumably only
 514          * BSD/OS does so - so that, on BSD/OS systems, we still
 515          * treate 13 as WTAP_ENCAP_ATM_RFC1483, but, on all other
 516          * systems, we can read OpenBSD DLT_ENC captures.
 517          */
 518 #if defined(DLT_ATM_RFC1483) && (DLT_ATM_RFC1483 == 13)
 519         { 13,           WTAP_ENCAP_ATM_RFC1483 },
 520 #else
 521         { 13,           WTAP_ENCAP_ENC },
 522 #endif
 523
 524         /*
 525          * 14 is DLT_PPP_BSDOS on FreeBSD and NetBSD, but those OSes
 526          * don't actually generate it.  I infer that BSD/OS translates
 527          * DLT_PPP from the kernel BPF code to DLT_PPP_BSDOS in
 528          * libpcap, as the BSD/OS link-layer header is different;
 529          * however, in BSD/OS, DLT_PPP_BSDOS is 16.
 530          *
 531          * From this, I infer that there's no point in handling 14
 532          * as DLT_PPP_BSDOS.
 533          *
 534          * 14 is DLT_RAW on BSD/OS and OpenBSD.
 535          */
 536         { 14,           WTAP_ENCAP_RAW_IP },
 537
 538         /*
 539          * 15 is:
 540          *
 541          *      DLT_SLIP_BSDOS on BSD/OS;
 542          *
 543          *      DLT_HIPPI on NetBSD;
 544          *
 545          *      DLT_LANE8023 with Alexey Kuznetzov's patches for
 546          *      Linux libpcap;
 547          *
 548          *      DLT_I4L_RAWIP with the ISDN4Linux patches for libpcap
 549          *      (and on SuSE 6.3);
 550          *
 551          * but we don't currently handle any of those.
 552          */
 553
 554         /*
 555          * 16 is:
 556          *
 557          *      DLT_PPP_BSDOS on BSD/OS;
 558          *
 559          *      DLT_HDLC on NetBSD (Cisco HDLC);
 560          *
 561          *      DLT_CIP with Alexey Kuznetzov's patches for
 562          *      Linux libpcap - this is WTAP_ENCAP_LINUX_ATM_CLIP;
 563          *
 564          *      DLT_I4L_IP with the ISDN4Linux patches for libpcap
 565          *      (and on SuSE 6.3).
 566          */
 567 #if defined(DLT_CIP) && (DLT_CIP == 16)
 568         { 16,           WTAP_ENCAP_LINUX_ATM_CLIP },
 569 #endif
 570 #if defined(DLT_HDLC) && (DLT_HDLC == 16)
 571         { 16,           WTAP_ENCAP_CHDLC },
 572 #endif
 573
 574         /*
 575          * 17 is DLT_LANE8023 in SuSE 6.3 libpcap; we don't currently
 576          * handle it.
 577          * It is also used as the PF (Packet Filter) logging format beginning
 578          * with OpenBSD 3.0; we use 17 for PF logs unless DLT_LANE8023 is
 579          * defined with the value 17.
 580          */
 581 #if !defined(DLT_LANE8023) || (DLT_LANE8023 != 17)
 582         { 17,           WTAP_ENCAP_OLD_PFLOG },
 583 #endif
 584
 585         /*
 586          * 18 is DLT_CIP in SuSE 6.3 libpcap; if it's the same as the
 587          * DLT_CIP of 16 that the Alexey Kuznetzov patches for
 588          * libpcap/tcpdump define, it's WTAP_ENCAP_LINUX_ATM_CLIP.
 589          * I've not found any libpcap that uses it for any other purpose -
 590          * hopefully nobody will do so in the future.
 591          */
 592         { 18,           WTAP_ENCAP_LINUX_ATM_CLIP },
 593
 594         /*
 595          * 19 is DLT_ATM_CLIP in the libpcap/tcpdump patches in the
 596          * recent versions I've seen of the Linux ATM distribution;
 597          * I've not yet found any libpcap that uses it for any other
 598          * purpose - hopefully nobody will do so in the future.
 599          */
 600         { 19,           WTAP_ENCAP_LINUX_ATM_CLIP },
 601
 602         /*
 603          * To repeat:
 604          *
 605          * If you need a new encapsulation type for libpcap files, do
 606          * *N*O*T* use *ANY* of the values listed here!  I.e., do *NOT*
 607          * add a new encapsulation type by changing an existing entry;
 608          * leave the existing entries alone.
 609          *
 610          * Instead, send mail to tcpdump-workers@lists.tcpdump.org, asking
 611          * for a new DLT_ value, and specifying the purpose of the new value.
 612          * When you get the new DLT_ value, use that numerical value in
 613          * the "linktype_value" field of "pcap_to_wtap_map[]".
 614          */
 615 };
 616 #define NUM_PCAP_ENCAPS (sizeof pcap_to_wtap_map / sizeof pcap_to_wtap_map[0])
 617
 618 int
 619 wtap_pcap_encap_to_wtap_encap(int encap)
 620 {
 621         unsigned int i;
 622
 623         for (i = 0; i < NUM_PCAP_ENCAPS; i++) {
 624                 if (pcap_to_wtap_map[i].linktype_value == encap)
 625                         return pcap_to_wtap_map[i].wtap_encap_value;
 626         }
 627         return WTAP_ENCAP_UNKNOWN;
 628 }
 629
 630 int
 631 wtap_wtap_encap_to_pcap_encap(int encap)
 632 {
 633         unsigned int i;
 634
 635         switch (encap) {
 636
 637         case WTAP_ENCAP_FDDI:
 638         case WTAP_ENCAP_FDDI_BITSWAPPED:
 639                 /*
 640                  * Special-case WTAP_ENCAP_FDDI and
 641                  * WTAP_ENCAP_FDDI_BITSWAPPED; both of them get mapped
 642                  * to DLT_FDDI (even though that may mean that the bit
 643                  * order in the FDDI MAC addresses is wrong; so it goes
 644                  * - libpcap format doesn't record the byte order,
 645                  * so that's not fixable).
 646                  *
 647                  * The pcap_to_wtap_map[] table will only have an
 648                  * entry for one of the above, which is why we have
 649                  * to special-case them.
 650                  */
 651                 return 10;      /* that's DLT_FDDI */
 652
 653         case WTAP_ENCAP_NETTL_FDDI:
 654                 /*
 655                  * This will discard the nettl information, as that's
 656                  * in the pseudo-header.
 657                  *
 658                  * XXX - what about Ethernet and Token Ring?
 659                  */
 660                 return 10;      /* that's DLT_FDDI */
 661
 662         case WTAP_ENCAP_FRELAY_WITH_PHDR:
 663                 /*
 664                  * This will discard the pseudo-header information.
 665                  */
 666                 return 107;
 667
 668         case WTAP_ENCAP_IEEE_802_11_WITH_RADIO:
 669                 /*
 670                  * Map this to DLT_IEEE802_11, for now, even though
 671                  * that means the radio information will be lost.
 672                  * We should try to map those values to radiotap
 673                  * values and write this out as a radiotap file,
 674                  * if possible.
 675                  */
 676                 return 105;
 677         }
 678
 679         for (i = 0; i < NUM_PCAP_ENCAPS; i++) {
 680                 if (pcap_to_wtap_map[i].wtap_encap_value == encap)
 681                         return pcap_to_wtap_map[i].linktype_value;
 682         }
 683         return -1;
 684 }
 685
 686 gboolean
 687 wtap_encap_requires_phdr(int encap) {
 688         if (
 689                 (encap == WTAP_ENCAP_ATM_PDUS) ||
 690                 (encap == WTAP_ENCAP_IRDA) ||
 691                 (encap == WTAP_ENCAP_MTP2_WITH_PHDR) ||
 692                 (encap == WTAP_ENCAP_LINUX_LAPD) ||
 693                 (encap == WTAP_ENCAP_SITA) ||
 694                 (encap == WTAP_ENCAP_ERF) ||
 695                 (encap == WTAP_ENCAP_I2C) ||
 696                 (encap == WTAP_ENCAP_BLUETOOTH_H4_WITH_PHDR) ||
 697                 (encap == WTAP_ENCAP_PPP_WITH_PHDR)
 698         ) {
 699                 return TRUE;
 700         }
 701         return FALSE;
 702 }
 703
 704
 705 /*
 706  * Various pseudo-headers that appear at the beginning of packet data.
 707  *
 708  * We represent them as sets of offsets, as they might not be aligned on
 709  * an appropriate structure boundary in the buffer, and as that makes them
 710  * independent of the way the compiler might align fields.
 711  */
 712
 713 /*
 714  * The link-layer header on SunATM packets.
 715  */
 716 #define SUNATM_FLAGS    0       /* destination and traffic type - 1 byte */
 717 #define SUNATM_VPI      1       /* VPI - 1 byte */
 718 #define SUNATM_VCI      2       /* VCI - 2 bytes */
 719 #define SUNATM_LEN      4       /* length of the header */
 720
 721 /*
 722  * The link-layer header on Nokia IPSO ATM packets.
 723  */
 724 #define NOKIAATM_FLAGS  0       /* destination - 1 byte */
 725 #define NOKIAATM_VPI    1       /* VPI - 1 byte */
 726 #define NOKIAATM_VCI    2       /* VCI - 2 bytes */
 727 #define NOKIAATM_LEN    4       /* length of the header */
 728
 729 /*
 730  * The link-layer header on Nokia IPSO packets.
 731  */
 732 #define NOKIA_LEN       4       /* length of the header */
 733
 734 /*
 735  * The fake link-layer header of IrDA packets as introduced by Jean Tourrilhes
 736  * to libpcap.
 737  */
 738 #define IRDA_SLL_PKTTYPE_OFFSET         0       /* packet type - 2 bytes */
 739 /* 12 unused bytes */
 740 #define IRDA_SLL_PROTOCOL_OFFSET        14      /* protocol, should be ETH_P_LAPD - 2 bytes */
 741 #define IRDA_SLL_LEN                    16      /* length of the header */
 742
 743 /*
 744  * A header containing additional MTP information.
 745  */
 746 #define MTP2_SENT_OFFSET                0       /* 1 byte */
 747 #define MTP2_ANNEX_A_USED_OFFSET        1       /* 1 byte */
 748 #define MTP2_LINK_NUMBER_OFFSET         2       /* 2 bytes */
 749 #define MTP2_HDR_LEN                    4       /* length of the header */
 750
 751 /*
 752  * A header containing additional SITA WAN information.
 753  */
 754 #define SITA_FLAGS_OFFSET               0       /* 1 byte */
 755 #define SITA_SIGNALS_OFFSET             1       /* 1 byte */
 756 #define SITA_ERRORS1_OFFSET             2       /* 1 byte */
 757 #define SITA_ERRORS2_OFFSET             3       /* 1 byte */
 758 #define SITA_PROTO_OFFSET               4       /* 1 byte */
 759 #define SITA_HDR_LEN                    5       /* length of the header */
 760
 761 /*
 762  * The fake link-layer header of LAPD packets.
 763  */
 764 #ifndef ETH_P_LAPD
 765 #define ETH_P_LAPD 0x0030
 766 #endif
 767
 768 #define LAPD_SLL_PKTTYPE_OFFSET         0       /* packet type - 2 bytes */
 769 #define LAPD_SLL_HATYPE_OFFSET          2       /* hardware address type - 2 bytes */
 770 #define LAPD_SLL_HALEN_OFFSET           4       /* hardware address length - 2 bytes */
 771 #define LAPD_SLL_ADDR_OFFSET            6       /* address - 8 bytes */
 772 #define LAPD_SLL_PROTOCOL_OFFSET        14      /* protocol, should be ETH_P_LAPD - 2 bytes */
 773 #define LAPD_SLL_LEN                    16      /* length of the header */
 774
 775 /*
 776  * The NFC LLCP per-packet header.
 777  */
 778 #define LLCP_ADAPTER_OFFSET             0
 779 #define LLCP_FLAGS_OFFSET               1
 780 #define LLCP_HEADER_LEN                 2
 781
 782 /*
 783  * I2C link-layer on-disk format
 784  */
 785 struct i2c_file_hdr {
 786     guint8 bus;
 787     guint8 flags[4];
 788 };
 789
 790 static gboolean
 791 pcap_read_sunatm_pseudoheader(FILE_T fh,
 792     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info)
 793 {
 794         guint8  atm_phdr[SUNATM_LEN];
 795         int     bytes_read;
 796         guint8  vpi;
 797         guint16 vci;
 798
 799         errno = WTAP_ERR_CANT_READ;
 800         bytes_read = file_read(atm_phdr, SUNATM_LEN, fh);
 801         if (bytes_read != SUNATM_LEN) {
 802                 *err = file_error(fh, err_info);
 803                 if (*err == 0)
 804                         *err = WTAP_ERR_SHORT_READ;
 805                 return FALSE;
 806         }
 807
 808         vpi = atm_phdr[SUNATM_VPI];
 809         vci = pntohs(&atm_phdr[SUNATM_VCI]);
 810
 811         switch (atm_phdr[SUNATM_FLAGS] & 0x0F) {
 812
 813         case 0x01:      /* LANE */
 814                 pseudo_header->atm.aal = AAL_5;
 815                 pseudo_header->atm.type = TRAF_LANE;
 816                 break;
 817
 818         case 0x02:      /* RFC 1483 LLC multiplexed traffic */
 819                 pseudo_header->atm.aal = AAL_5;
 820                 pseudo_header->atm.type = TRAF_LLCMX;
 821                 break;
 822
 823         case 0x05:      /* ILMI */
 824                 pseudo_header->atm.aal = AAL_5;
 825                 pseudo_header->atm.type = TRAF_ILMI;
 826                 break;
 827
 828         case 0x06:      /* Q.2931 */
 829                 pseudo_header->atm.aal = AAL_SIGNALLING;
 830                 pseudo_header->atm.type = TRAF_UNKNOWN;
 831                 break;
 832
 833         case 0x03:      /* MARS (RFC 2022) */
 834                 pseudo_header->atm.aal = AAL_5;
 835                 pseudo_header->atm.type = TRAF_UNKNOWN;
 836                 break;
 837
 838         case 0x04:      /* IFMP (Ipsilon Flow Management Protocol; see RFC 1954) */
 839                 pseudo_header->atm.aal = AAL_5;
 840                 pseudo_header->atm.type = TRAF_UNKNOWN; /* XXX - TRAF_IPSILON? */
 841                 break;
 842
 843         default:
 844                 /*
 845                  * Assume it's AAL5, unless it's VPI 0 and VCI 5, in which
 846                  * case assume it's AAL_SIGNALLING; we know nothing more
 847                  * about it.
 848                  *
 849                  * XXX - is this necessary?  Or are we guaranteed that
 850                  * all signalling traffic has a type of 0x06?
 851                  *
 852                  * XXX - is this guaranteed to be AAL5?  Or, if the type is
 853                  * 0x00 ("raw"), might it be non-AAL5 traffic?
 854                  */
 855                 if (vpi == 0 && vci == 5)
 856                         pseudo_header->atm.aal = AAL_SIGNALLING;
 857                 else
 858                         pseudo_header->atm.aal = AAL_5;
 859                 pseudo_header->atm.type = TRAF_UNKNOWN;
 860                 break;
 861         }
 862         pseudo_header->atm.subtype = TRAF_ST_UNKNOWN;
 863
 864         pseudo_header->atm.vpi = vpi;
 865         pseudo_header->atm.vci = vci;
 866         pseudo_header->atm.channel = (atm_phdr[SUNATM_FLAGS] & 0x80) ? 0 : 1;
 867
 868         /* We don't have this information */
 869         pseudo_header->atm.flags = 0;
 870         pseudo_header->atm.cells = 0;
 871         pseudo_header->atm.aal5t_u2u = 0;
 872         pseudo_header->atm.aal5t_len = 0;
 873         pseudo_header->atm.aal5t_chksum = 0;
 874
 875         return TRUE;
 876 }
 877
 878 static gboolean
 879 pcap_read_nokiaatm_pseudoheader(FILE_T fh,
 880     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info)
 881 {
 882         guint8  atm_phdr[NOKIAATM_LEN];
 883         int     bytes_read;
 884         guint8  vpi;
 885         guint16 vci;
 886
 887         errno = WTAP_ERR_CANT_READ;
 888         bytes_read = file_read(atm_phdr, NOKIAATM_LEN, fh);
 889         if (bytes_read != NOKIAATM_LEN) {
 890                 *err = file_error(fh, err_info);
 891                 if (*err == 0)
 892                         *err = WTAP_ERR_SHORT_READ;
 893                 return FALSE;
 894         }
 895
 896         vpi = atm_phdr[NOKIAATM_VPI];
 897         vci = pntohs(&atm_phdr[NOKIAATM_VCI]);
 898
 899         pseudo_header->atm.vpi = vpi;
 900         pseudo_header->atm.vci = vci;
 901         pseudo_header->atm.channel = (atm_phdr[NOKIAATM_FLAGS] & 0x80) ? 0 : 1;
 902
 903         /* We don't have this information */
 904         pseudo_header->atm.flags = 0;
 905         pseudo_header->atm.cells = 0;
 906         pseudo_header->atm.aal5t_u2u = 0;
 907         pseudo_header->atm.aal5t_len = 0;
 908         pseudo_header->atm.aal5t_chksum = 0;
 909
 910         return TRUE;
 911 }
 912
 913 static gboolean
 914 pcap_read_nokia_pseudoheader(FILE_T fh,
 915     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info)
 916 {
 917         guint8  phdr[NOKIA_LEN];
 918         int     bytes_read;
 919
 920         errno = WTAP_ERR_CANT_READ;
 921
 922         /* backtrack to read the 4 mysterious bytes that aren't considered
 923         * part of the packet size
 924         */
 925         if (file_seek(fh, -NOKIA_LEN, SEEK_CUR, err) == -1)
 926         {
 927                 *err = file_error(fh, err_info);
 928                 if (*err == 0)
 929                         *err = WTAP_ERR_SHORT_READ;
 930                 return FALSE;
 931         }
 932
 933         bytes_read = file_read(phdr, NOKIA_LEN, fh);
 934         if (bytes_read != NOKIA_LEN) {
 935                 *err = file_error(fh, err_info);
 936                 if (*err == 0)
 937                         *err = WTAP_ERR_SHORT_READ;
 938                 return FALSE;
 939         }
 940
 941         memcpy(pseudo_header->nokia.stuff, phdr, NOKIA_LEN);
 942
 943         return TRUE;
 944 }
 945
 946 static gboolean
 947 pcap_read_irda_pseudoheader(FILE_T fh, union wtap_pseudo_header *pseudo_header,
 948     int *err, gchar **err_info)
 949 {
 950         guint8  irda_phdr[IRDA_SLL_LEN];
 951         int     bytes_read;
 952
 953         errno = WTAP_ERR_CANT_READ;
 954         bytes_read = file_read(irda_phdr, IRDA_SLL_LEN, fh);
 955         if (bytes_read != IRDA_SLL_LEN) {
 956                 *err = file_error(fh, err_info);
 957                 if (*err == 0)
 958                         *err = WTAP_ERR_SHORT_READ;
 959                 return FALSE;
 960         }
 961
 962         if (pntohs(&irda_phdr[IRDA_SLL_PROTOCOL_OFFSET]) != 0x0017) {
 963                 *err = WTAP_ERR_BAD_FILE;
 964                 if (err_info != NULL)
 965                         *err_info = g_strdup("libpcap: IrDA capture has a packet with an invalid sll_protocol field");
 966                 return FALSE;
 967         }
 968
 969         pseudo_header->irda.pkttype = pntohs(&irda_phdr[IRDA_SLL_PKTTYPE_OFFSET]);
 970
 971         return TRUE;
 972 }
 973
 974 static gboolean
 975 pcap_read_mtp2_pseudoheader(FILE_T fh, union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info)
 976 {
 977         guint8 mtp2_hdr[MTP2_HDR_LEN];
 978         int    bytes_read;
 979
 980         errno = WTAP_ERR_CANT_READ;
 981         bytes_read = file_read(mtp2_hdr, MTP2_HDR_LEN, fh);
 982         if (bytes_read != MTP2_HDR_LEN) {
 983                 *err = file_error(fh, err_info);
 984                 if (*err == 0)
 985                         *err = WTAP_ERR_SHORT_READ;
 986                 return FALSE;
 987         }
 988
 989         pseudo_header->mtp2.sent         = mtp2_hdr[MTP2_SENT_OFFSET];
 990         pseudo_header->mtp2.annex_a_used = mtp2_hdr[MTP2_ANNEX_A_USED_OFFSET];
 991         pseudo_header->mtp2.link_number  = pntohs(&mtp2_hdr[MTP2_LINK_NUMBER_OFFSET]);
 992
 993         return TRUE;
 994 }
 995
 996 static gboolean
 997 pcap_read_lapd_pseudoheader(FILE_T fh, union wtap_pseudo_header *pseudo_header,
 998     int *err, gchar **err_info)
 999 {
1000         guint8  lapd_phdr[LAPD_SLL_LEN];
1001         int     bytes_read;
1002
1003         errno = WTAP_ERR_CANT_READ;
1004         bytes_read = file_read(lapd_phdr, LAPD_SLL_LEN, fh);
1005         if (bytes_read != LAPD_SLL_LEN) {
1006                 *err = file_error(fh, err_info);
1007                 if (*err == 0)
1008                         *err = WTAP_ERR_SHORT_READ;
1009                 return FALSE;
1010         }
1011
1012         if (pntohs(&lapd_phdr[LAPD_SLL_PROTOCOL_OFFSET]) != ETH_P_LAPD) {
1013                 *err = WTAP_ERR_BAD_FILE;
1014                 if (err_info != NULL)
1015                         *err_info = g_strdup("libpcap: LAPD capture has a packet with an invalid sll_protocol field");
1016                 return FALSE;
1017         }
1018
1019         pseudo_header->lapd.pkttype = pntohs(&lapd_phdr[LAPD_SLL_PKTTYPE_OFFSET]);
1020         pseudo_header->lapd.we_network = !!lapd_phdr[LAPD_SLL_ADDR_OFFSET+0];
1021
1022         return TRUE;
1023 }
1024
1025 static gboolean
1026 pcap_read_sita_pseudoheader(FILE_T fh, union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info)
1027 {
1028         guint8  sita_phdr[SITA_HDR_LEN];
1029         int     bytes_read;
1030
1031         errno = WTAP_ERR_CANT_READ;
1032         bytes_read = file_read(sita_phdr, SITA_HDR_LEN, fh);
1033         if (bytes_read != SITA_HDR_LEN) {
1034                 *err = file_error(fh, err_info);
1035                 if (*err == 0)
1036                         *err = WTAP_ERR_SHORT_READ;
1037                 return FALSE;
1038         }
1039
1040         pseudo_header->sita.sita_flags   = sita_phdr[SITA_FLAGS_OFFSET];
1041         pseudo_header->sita.sita_signals = sita_phdr[SITA_SIGNALS_OFFSET];
1042         pseudo_header->sita.sita_errors1 = sita_phdr[SITA_ERRORS1_OFFSET];
1043         pseudo_header->sita.sita_errors2 = sita_phdr[SITA_ERRORS2_OFFSET];
1044         pseudo_header->sita.sita_proto   = sita_phdr[SITA_PROTO_OFFSET];
1045
1046         return TRUE;
1047 }
1048
1049 /*
1050  * When not using the memory-mapped interface to capture USB events,
1051  * code that reads those events can use the MON_IOCX_GET ioctl to
1052  * read a 48-byte header consisting of a "struct linux_usb_phdr", as
1053  * defined below, followed immediately by one of:
1054  *
1055  *      8 bytes of a "struct usb_device_setup_hdr", if "setup_flag"
1056  *      in the preceding "struct linux_usb_phdr" is 0;
1057  *
1058  *      in Linux 2.6.30 or later, 8 bytes of a "struct iso_rec", if
1059  *      this is an isochronous transfer;
1060  *
1061  *      8 bytes of junk, otherwise.
1062  *
1063  * In Linux 2.6.31 and later, it can also use the MON_IOCX_GETX ioctl
1064  * to read a 64-byte header; that header consists of the 48 bytes
1065  * above, followed immediately by 16 bytes of a "struct linux_usb_phdr_ext",
1066  * as defined below.
1067  *
1068  * In Linux 2.6.21 and later, there's a memory-mapped interface to
1069  * capture USB events.  In that interface, the events in the memory-mapped
1070  * buffer have a 64-byte header, followed immediately by the data.
1071  * In Linux 2.6.21 through 2.6.30.x, the 64-byte header is the 48-byte
1072  * header described above, followed by 16 bytes of zeroes; in Linux
1073  * 2.6.31 and later, the 64-byte header is the 64-byte header described
1074  * above.
1075  *
1076  * See linux/Documentation/usb/usbmon.txt and libpcap/pcap/usb.h for details.
1077  *
1078  * With WTAP_ENCAP_USB_LINUX, packets have the 48-byte header; with
1079  * WTAP_ENCAP_USB_LINUX_MMAPPED, they have the 64-byte header.  There
1080  * is no indication of whether the header has the "struct iso_rec", or
1081  * whether the last 16 bytes of a 64-byte header are all zeros or are
1082  * a "struct linux_usb_phdr_ext".
1083  */
1084
1085 /*
1086  * URB transfer_type values
1087  */
1088 #define URB_ISOCHRONOUS   0x0
1089 #define URB_INTERRUPT     0x1
1090 #define URB_CONTROL       0x2
1091 #define URB_BULK          0x3
1092
1093 /*
1094  * Information from the URB for Isochronous transfers.
1095  *
1096  * This structure is 8 bytes long.
1097  */
1098 struct iso_rec {
1099     gint32 error_count;
1100     gint32 numdesc;
1101 };
1102
1103 /*
1104  * Header prepended by Linux kernel to each USB event.
1105  *
1106  * (Setup flag is '-', 'D', 'Z', or 0.  Data flag is '<', '>', 'Z', or 0.)
1107  *
1108  * The values are in *host* byte order.
1109  */
1110 struct linux_usb_phdr {
1111     guint64 id;             /* urb id, to link submission and completion events */
1112     guint8 event_type;      /* Submit ('S'), Completed ('C'), Error ('E') */
1113     guint8 transfer_type;   /* ISO (0), Intr, Control, Bulk (3) */
1114     guint8 endpoint_number; /* Endpoint number (0-15) and transfer direction */
1115     guint8 device_address;  /* 0-127 */
1116     guint16 bus_id;
1117     gint8 setup_flag;       /* 0, if the urb setup header is meaningful */
1118     gint8 data_flag;        /* 0, if urb data is present */
1119     gint64 ts_sec;
1120     gint32 ts_usec;
1121     gint32 status;
1122     guint32 urb_len;        /* whole len of urb this event refers to */
1123     guint32 data_len;       /* amount of urb data really present in this event */
1124
1125     /*
1126      * Packet-type-dependent data.
1127      * USB setup information of setup_flag is true.
1128      * Otherwise, some isochronous transfer information.
1129      */
1130     union {
1131         guint8 data[8];
1132         struct iso_rec iso;
1133     } s;
1134
1135     /*
1136      * This data is provided by Linux 2.6.31 and later kernels.
1137      *
1138      * For WTAP_ENCAP_USB_LINUX, it's not in the pseudo-header, so
1139      * the pseudo-header is always 48 bytes long, including the
1140      * packet-type-dependent data.
1141      *
1142      * For WTAP_ENCAP_USB_LINUX_MMAPPED, the pseudo-header is always
1143      * 64 bytes long, with the packet-type-dependent data preceding
1144      * these last 16 bytes.  In pre-2.6.31 kernels, it's zero padding;
1145      * in 2.6.31 and later, it's the following data.
1146      */
1147     gint32 interval;    /* only for Interrupt and Isochronous events */
1148     gint32 start_frame; /* for Isochronous */
1149     guint32 xfer_flags; /* copy of URB's transfer_flags */
1150     guint32 ndesc;      /* actual number of isochronous descriptors */
1151 };
1152
1153 struct linux_usb_isodesc {
1154     gint32 iso_status;
1155     guint32 iso_off;
1156     guint32 iso_len;
1157     guint32 _pad;
1158 };
1159
1160 /*
1161  * USB setup header as defined in USB specification
1162  * See usb_20.pdf, Chapter 9.3 'USB Device Requests' for details.
1163  * http://www.usb.org/developers/docs/usb_20_122909-2.zip
1164  *
1165  * This structure is 8 bytes long.
1166  */
1167 struct usb_device_setup_hdr {
1168     gint8 bmRequestType;
1169     guint8 bRequest;
1170     guint16 wValue;
1171     guint16 wIndex;
1172     guint16 wLength;
1173 };
1174
1175
1176 /*
1177  * Offset of the *end* of a field within a particular structure.
1178  */
1179 #define END_OFFSETOF(basep, fieldp) \
1180         (((char *)(void *)(fieldp)) - ((char *)(void *)(basep)) + \
1181             sizeof(*fieldp))
1182
1183 static void
1184 pcap_process_linux_usb_pseudoheader(guint packet_size, gboolean byte_swapped,
1185     gboolean header_len_64_bytes, guint8 *pd)
1186 {
1187         struct linux_usb_phdr *phdr;
1188         struct linux_usb_isodesc *pisodesc;
1189         gint32 iso_numdesc, i;
1190
1191         if (byte_swapped) {
1192                 /*
1193                  * Greasy hack, but we never directly direference any of
1194                  * the fields in *phdr, we just get offsets of and
1195                  * addresses of its members, so it's safe.
1196                  */
1197                 phdr = (struct linux_usb_phdr *)(void *)pd;
1198
1199                 if (packet_size < END_OFFSETOF(phdr, &phdr->id))
1200                         return;
1201                 PBSWAP64((guint8 *)&phdr->id);
1202                 if (packet_size < END_OFFSETOF(phdr, &phdr->bus_id))
1203                         return;
1204                 PBSWAP16((guint8 *)&phdr->bus_id);
1205                 if (packet_size < END_OFFSETOF(phdr, &phdr->ts_sec))
1206                         return;
1207                 PBSWAP64((guint8 *)&phdr->ts_sec);
1208                 if (packet_size < END_OFFSETOF(phdr, &phdr->ts_usec))
1209                         return;
1210                 PBSWAP32((guint8 *)&phdr->ts_usec);
1211                 if (packet_size < END_OFFSETOF(phdr, &phdr->status))
1212                         return;
1213                 PBSWAP32((guint8 *)&phdr->status);
1214                 if (packet_size < END_OFFSETOF(phdr, &phdr->urb_len))
1215                         return;
1216                 PBSWAP32((guint8 *)&phdr->urb_len);
1217                 if (packet_size < END_OFFSETOF(phdr, &phdr->data_len))
1218                         return;
1219                 PBSWAP32((guint8 *)&phdr->data_len);
1220
1221                 if (phdr->transfer_type == URB_ISOCHRONOUS) {
1222                         if (packet_size < END_OFFSETOF(phdr, &phdr->s.iso.error_count))
1223                                 return;
1224                         PBSWAP32((guint8 *)&phdr->s.iso.error_count);
1225
1226                         if (packet_size < END_OFFSETOF(phdr, &phdr->s.iso.numdesc))
1227                                 return;
1228                         PBSWAP32((guint8 *)&phdr->s.iso.numdesc);
1229
1230                 }
1231
1232                 if (header_len_64_bytes) {
1233                         /*
1234                          * This is either the "version 1" header, with
1235                          * 16 bytes of additional fields at the end, or
1236                          * a "version 0" header from a memory-mapped
1237                          * capture, with 16 bytes of zeroed-out padding
1238                          * at the end.  Byte swap them as if this were
1239                          * a "version 1" header.
1240                          *
1241                          * Yes, the first argument to END_OFFSETOF() should
1242                          * be phdr, not phdr_ext; we want the offset of
1243                          * the additional fields from the beginning of
1244                          * the packet.
1245                          */
1246                         if (packet_size < END_OFFSETOF(phdr, &phdr->interval))
1247                                 return;
1248                         PBSWAP32((guint8 *)&phdr->interval);
1249                         if (packet_size < END_OFFSETOF(phdr, &phdr->start_frame))
1250                                 return;
1251                         PBSWAP32((guint8 *)&phdr->start_frame);
1252                         if (packet_size < END_OFFSETOF(phdr, &phdr->xfer_flags))
1253                                 return;
1254                         PBSWAP32((guint8 *)&phdr->xfer_flags);
1255                         if (packet_size < END_OFFSETOF(phdr, &phdr->ndesc))
1256                                 return;
1257                         PBSWAP32((guint8 *)&phdr->ndesc);
1258                 }
1259
1260                 if (phdr->transfer_type == URB_ISOCHRONOUS) {
1261                         /* swap the values in struct linux_usb_isodesc */
1262
1263                         /*
1264                          * See previous "Greasy hack" comment.
1265                          */
1266                         if (header_len_64_bytes) {
1267                                 pisodesc = (struct linux_usb_isodesc*)(void *)(pd + 64);
1268                         } else {
1269                                 pisodesc = (struct linux_usb_isodesc*)(void *)(pd + 48);
1270                         }
1271                         iso_numdesc = phdr->s.iso.numdesc;
1272                         for (i = 0; i < iso_numdesc; i++) {
1273                                 /* always check if we have enough data from the
1274                                  * beginnig of the packet (phdr)
1275                                  */
1276                                 if (packet_size < END_OFFSETOF(phdr, &pisodesc->iso_status))
1277                                         return;
1278                                 PBSWAP32((guint8 *)&pisodesc->iso_status);
1279                                 if (packet_size < END_OFFSETOF(phdr, &pisodesc->iso_off))
1280                                         return;
1281                                 PBSWAP32((guint8 *)&pisodesc->iso_off);
1282                                 if (packet_size < END_OFFSETOF(phdr, &pisodesc->iso_len))
1283                                         return;
1284                                 PBSWAP32((guint8 *)&pisodesc->iso_len);
1285                                 if (packet_size < END_OFFSETOF(phdr, &pisodesc->_pad))
1286                                         return;
1287                                 PBSWAP32((guint8 *)&pisodesc->_pad);
1288
1289                                 pisodesc++;
1290                         }
1291                 }
1292         }
1293 }
1294
1295 static gboolean
1296 pcap_read_bt_pseudoheader(FILE_T fh,
1297     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info)
1298 {
1299         int     bytes_read;
1300         struct libpcap_bt_phdr phdr;
1301
1302         errno = WTAP_ERR_CANT_READ;
1303         bytes_read = file_read(&phdr,
1304             sizeof (struct libpcap_bt_phdr), fh);
1305         if (bytes_read != sizeof (struct libpcap_bt_phdr)) {
1306                 *err = file_error(fh, err_info);
1307                 if (*err == 0)
1308                         *err = WTAP_ERR_SHORT_READ;
1309                 return FALSE;
1310         }
1311         pseudo_header->p2p.sent = ((g_ntohl(phdr.direction) & LIBPCAP_BT_PHDR_RECV) == 0)? TRUE: FALSE;
1312         return TRUE;
1313 }
1314
1315 static gboolean
1316 pcap_read_llcp_pseudoheader(FILE_T fh,
1317     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info)
1318 {
1319         int bytes_read;
1320         guint8 phdr[LLCP_HEADER_LEN];
1321
1322         errno = WTAP_ERR_CANT_READ;
1323         bytes_read = file_read(phdr, LLCP_HEADER_LEN, fh);
1324         if (bytes_read != LLCP_HEADER_LEN) {
1325                 *err = file_error(fh, err_info);
1326                 if (*err == 0)
1327                         *err = WTAP_ERR_SHORT_READ;
1328                 return FALSE;
1329         }
1330         pseudo_header->llcp.adapter = phdr[LLCP_ADAPTER_OFFSET];
1331         pseudo_header->llcp.flags = phdr[LLCP_FLAGS_OFFSET];
1332         return TRUE;
1333 }
1334
1335 static gboolean
1336 pcap_read_ppp_pseudoheader(FILE_T fh,
1337     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info)
1338 {
1339         int     bytes_read;
1340         struct libpcap_ppp_phdr phdr;
1341
1342         errno = WTAP_ERR_CANT_READ;
1343         bytes_read = file_read(&phdr,
1344             sizeof (struct libpcap_ppp_phdr), fh);
1345         if (bytes_read != sizeof (struct libpcap_ppp_phdr)) {
1346                 *err = file_error(fh, err_info);
1347                 if (*err == 0)
1348                         *err = WTAP_ERR_SHORT_READ;
1349                 return FALSE;
1350         }
1351         pseudo_header->p2p.sent = (phdr.direction == LIBPCAP_PPP_PHDR_SENT) ? TRUE: FALSE;
1352         return TRUE;
1353 }
1354
1355 static gboolean
1356 pcap_read_erf_pseudoheader(FILE_T fh, struct wtap_pkthdr *whdr,
1357                               union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info)
1358 {
1359   guint8 erf_hdr[sizeof(struct erf_phdr)];
1360   int    bytes_read;
1361
1362   errno = WTAP_ERR_CANT_READ;
1363   bytes_read = file_read(erf_hdr, sizeof(struct erf_phdr), fh);
1364   if (bytes_read != sizeof(struct erf_phdr)) {
1365     *err = file_error(fh, err_info);
1366     if (*err == 0)
1367       *err = WTAP_ERR_SHORT_READ;
1368     return FALSE;
1369   }
1370   pseudo_header->erf.phdr.ts = pletohll(&erf_hdr[0]); /* timestamp */
1371   pseudo_header->erf.phdr.type =  erf_hdr[8];
1372   pseudo_header->erf.phdr.flags = erf_hdr[9];
1373   pseudo_header->erf.phdr.rlen = pntohs(&erf_hdr[10]);
1374   pseudo_header->erf.phdr.lctr = pntohs(&erf_hdr[12]);
1375   pseudo_header->erf.phdr.wlen = pntohs(&erf_hdr[14]);
1376
1377   /* The high 32 bits of the timestamp contain the integer number of seconds
1378    * while the lower 32 bits contain the binary fraction of the second.
1379    * This allows an ultimate resolution of 1/(2^32) seconds, or approximately 233 picoseconds */
1380   if (whdr) {
1381     guint64 ts = pseudo_header->erf.phdr.ts;
1382     whdr->ts.secs = (guint32) (ts >> 32);
1383     ts = ((ts & 0xffffffff) * 1000 * 1000 * 1000);
1384     ts += (ts & 0x80000000) << 1; /* rounding */
1385     whdr->ts.nsecs = ((guint32) (ts >> 32));
1386     if ( whdr->ts.nsecs >= 1000000000) {
1387       whdr->ts.nsecs -= 1000000000;
1388       whdr->ts.secs += 1;
1389     }
1390   }
1391   return TRUE;
1392 }
1393
1394 /*
1395  * If the type of record given in the pseudo header indicate the presence of an extension
1396  * header then, read all the extension headers
1397  */
1398 static gboolean
1399 pcap_read_erf_exheader(FILE_T fh, union wtap_pseudo_header *pseudo_header,
1400                            int *err, gchar **err_info, guint * psize)
1401 {
1402   int bytes_read = 0;
1403   guint8 erf_exhdr[8];
1404   guint64 erf_exhdr_sw;
1405   int i = 0, max = sizeof(pseudo_header->erf.ehdr_list)/sizeof(struct erf_ehdr);
1406   guint8 type;
1407   *psize = 0;
1408   if (pseudo_header->erf.phdr.type & 0x80){
1409     do{
1410       errno = WTAP_ERR_CANT_READ;
1411       bytes_read = file_read(erf_exhdr, 8, fh);
1412       if (bytes_read != 8 ) {
1413         *err = file_error(fh, err_info);
1414         if (*err == 0)
1415           *err = WTAP_ERR_SHORT_READ;
1416         return FALSE;
1417       }
1418       type = erf_exhdr[0];
1419       erf_exhdr_sw = pntohll(erf_exhdr);
1420       if (i < max)
1421         memcpy(&pseudo_header->erf.ehdr_list[i].ehdr, &erf_exhdr_sw, sizeof(erf_exhdr_sw));
1422       *psize += 8;
1423       i++;
1424     } while (type & 0x80);
1425   }
1426   return TRUE;
1427 }
1428
1429 /*
1430  * If the type of record given in the pseudo header indicate the precense of a subheader
1431  * then, read this optional subheader
1432  */
1433 static gboolean
1434 pcap_read_erf_subheader(FILE_T fh, union wtap_pseudo_header *pseudo_header,
1435                            int *err, gchar **err_info, guint * psize)
1436 {
1437   guint8 erf_subhdr[sizeof(union erf_subhdr)];
1438   int    bytes_read;
1439
1440   *psize=0;
1441   switch(pseudo_header->erf.phdr.type & 0x7F) {
1442   case ERF_TYPE_MC_HDLC:
1443   case ERF_TYPE_MC_RAW:
1444   case ERF_TYPE_MC_ATM:
1445   case ERF_TYPE_MC_RAW_CHANNEL:
1446   case ERF_TYPE_MC_AAL5:
1447   case ERF_TYPE_MC_AAL2:
1448   case ERF_TYPE_COLOR_MC_HDLC_POS:
1449     /* Extract the Multi Channel header to include it in the pseudo header part */
1450     errno = WTAP_ERR_CANT_READ;
1451     bytes_read = file_read(erf_subhdr, sizeof(erf_mc_header_t), fh);
1452     if (bytes_read != sizeof(erf_mc_header_t) ) {
1453       *err = file_error(fh, err_info);
1454       if (*err == 0)
1455         *err = WTAP_ERR_SHORT_READ;
1456       return FALSE;
1457     }
1458     pseudo_header->erf.subhdr.mc_hdr = pntohl(&erf_subhdr[0]);
1459     *psize = sizeof(erf_mc_header_t);
1460     break;
1461   case ERF_TYPE_ETH:
1462   case ERF_TYPE_COLOR_ETH:
1463   case ERF_TYPE_DSM_COLOR_ETH:
1464     /* Extract the Ethernet additional header to include it in the pseudo header part */
1465     errno = WTAP_ERR_CANT_READ;
1466     bytes_read = file_read(erf_subhdr, sizeof(erf_eth_header_t), fh);
1467     if (bytes_read != sizeof(erf_eth_header_t) ) {
1468       *err = file_error(fh, err_info);
1469       if (*err == 0)
1470         *err = WTAP_ERR_SHORT_READ;
1471       return FALSE;
1472     }
1473     pseudo_header->erf.subhdr.eth_hdr = pntohs(&erf_subhdr[0]);
1474     *psize = sizeof(erf_eth_header_t);
1475     break;
1476   default:
1477     /* No optional pseudo header for this ERF type */
1478     break;
1479   }
1480   return TRUE;
1481 }
1482
1483 static gboolean
1484 pcap_read_i2c_pseudoheader(FILE_T fh, union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info)
1485 {
1486         struct i2c_file_hdr i2c_hdr;
1487         int    bytes_read;
1488
1489         errno = WTAP_ERR_CANT_READ;
1490         bytes_read = file_read(&i2c_hdr, sizeof (i2c_hdr), fh);
1491         if (bytes_read != sizeof (i2c_hdr)) {
1492                 *err = file_error(fh, err_info);
1493                 if (*err == 0)
1494                         *err = WTAP_ERR_SHORT_READ;
1495                 return FALSE;
1496         }
1497
1498         pseudo_header->i2c.is_event = i2c_hdr.bus & 0x80 ? 1 : 0;
1499         pseudo_header->i2c.bus = i2c_hdr.bus & 0x7f;
1500         pseudo_header->i2c.flags = pntohl(&i2c_hdr.flags);
1501
1502         return TRUE;
1503 }
1504
1505 int
1506 pcap_process_pseudo_header(FILE_T fh, int file_type, int wtap_encap,
1507     guint packet_size, gboolean check_packet_size,
1508     struct wtap_pkthdr *phdr, int *err, gchar **err_info)
1509 {
1510         int phdr_len = 0;
1511         guint size;
1512
1513         switch (wtap_encap) {
1514
1515         case WTAP_ENCAP_ATM_PDUS:
1516                 if (file_type == WTAP_FILE_PCAP_NOKIA) {
1517                         /*
1518                          * Nokia IPSO ATM.
1519                          */
1520                         if (check_packet_size && packet_size < NOKIAATM_LEN) {
1521                                 /*
1522                                  * Uh-oh, the packet isn't big enough to even
1523                                  * have a pseudo-header.
1524                                  */
1525                                 *err = WTAP_ERR_BAD_FILE;
1526                                 *err_info = g_strdup_printf("pcap: Nokia IPSO ATM file has a %u-byte packet, too small to have even an ATM pseudo-header",
1527                                     packet_size);
1528                                 return -1;
1529                         }
1530                         if (!pcap_read_nokiaatm_pseudoheader(fh,
1531                             &phdr->pseudo_header, err, err_info))
1532                                 return -1;      /* Read error */
1533
1534                         phdr_len = NOKIAATM_LEN;
1535                 } else {
1536                         /*
1537                          * SunATM.
1538                          */
1539                         if (check_packet_size && packet_size < SUNATM_LEN) {
1540                                 /*
1541                                  * Uh-oh, the packet isn't big enough to even
1542                                  * have a pseudo-header.
1543                                  */
1544                                 *err = WTAP_ERR_BAD_FILE;
1545                                 *err_info = g_strdup_printf("pcap: SunATM file has a %u-byte packet, too small to have even an ATM pseudo-header",
1546                                     packet_size);
1547                                 return -1;
1548                         }
1549                         if (!pcap_read_sunatm_pseudoheader(fh,
1550                             &phdr->pseudo_header, err, err_info))
1551                                 return -1;      /* Read error */
1552
1553                         phdr_len = SUNATM_LEN;
1554                 }
1555                 break;
1556
1557         case WTAP_ENCAP_ETHERNET:
1558                 if (file_type == WTAP_FILE_PCAP_NOKIA) {
1559                         /*
1560                          * Nokia IPSO.  Psuedo header has already been read, but it's not considered
1561                          * part of the packet size, so reread it to store the data for later (when saving)
1562                          */
1563                         if (!pcap_read_nokia_pseudoheader(fh, &phdr->pseudo_header, err, err_info))
1564                                 return -1;      /* Read error */
1565                 }
1566
1567                 /*
1568                  * We don't know whether there's an FCS in this frame or not.
1569                  */
1570                 phdr->pseudo_header.eth.fcs_len = -1;
1571                 break;
1572
1573         case WTAP_ENCAP_IEEE_802_11:
1574         case WTAP_ENCAP_IEEE_802_11_PRISM:
1575         case WTAP_ENCAP_IEEE_802_11_RADIOTAP:
1576         case WTAP_ENCAP_IEEE_802_11_AVS:
1577                 /*
1578                  * We don't know whether there's an FCS in this frame or not.
1579                  * XXX - are there any OSes where the capture mechanism
1580                  * supplies an FCS?
1581                  */
1582                 phdr->pseudo_header.ieee_802_11.fcs_len = -1;
1583                 phdr->pseudo_header.ieee_802_11.decrypted = FALSE;
1584                 phdr->pseudo_header.ieee_802_11.channel = 0;
1585                 phdr->pseudo_header.ieee_802_11.data_rate = 0;
1586                 phdr->pseudo_header.ieee_802_11.signal_level = 0;
1587                 break;
1588
1589         case WTAP_ENCAP_IRDA:
1590                 if (check_packet_size && packet_size < IRDA_SLL_LEN) {
1591                         /*
1592                          * Uh-oh, the packet isn't big enough to even
1593                          * have a pseudo-header.
1594                          */
1595                         *err = WTAP_ERR_BAD_FILE;
1596                         *err_info = g_strdup_printf("pcap: IrDA file has a %u-byte packet, too small to have even an IrDA pseudo-header",
1597                             packet_size);
1598                         return -1;
1599                 }
1600                 if (!pcap_read_irda_pseudoheader(fh, &phdr->pseudo_header,
1601                     err, err_info))
1602                         return -1;      /* Read error */
1603
1604                 phdr_len = IRDA_SLL_LEN;
1605                 break;
1606
1607         case WTAP_ENCAP_MTP2_WITH_PHDR:
1608                 if (check_packet_size && packet_size < MTP2_HDR_LEN) {
1609                         /*
1610                          * Uh-oh, the packet isn't big enough to even
1611                          * have a pseudo-header.
1612                          */
1613                         *err = WTAP_ERR_BAD_FILE;
1614                         *err_info = g_strdup_printf("pcap: MTP2 file has a %u-byte packet, too small to have even an MTP2 pseudo-header",
1615                             packet_size);
1616                         return -1;
1617                 }
1618                 if (!pcap_read_mtp2_pseudoheader(fh, &phdr->pseudo_header,
1619                     err, err_info))
1620                         return -1;      /* Read error */
1621
1622                 phdr_len = MTP2_HDR_LEN;
1623                 break;
1624
1625         case WTAP_ENCAP_LINUX_LAPD:
1626                 if (check_packet_size && packet_size < LAPD_SLL_LEN) {
1627                         /*
1628                          * Uh-oh, the packet isn't big enough to even
1629                          * have a pseudo-header.
1630                          */
1631                         *err = WTAP_ERR_BAD_FILE;
1632                         *err_info = g_strdup_printf("pcap: LAPD file has a %u-byte packet, too small to have even a LAPD pseudo-header",
1633                             packet_size);
1634                         return -1;
1635                 }
1636                 if (!pcap_read_lapd_pseudoheader(fh, &phdr->pseudo_header,
1637                     err, err_info))
1638                         return -1;      /* Read error */
1639
1640                 phdr_len = LAPD_SLL_LEN;
1641                 break;
1642
1643         case WTAP_ENCAP_SITA:
1644                 if (check_packet_size && packet_size < SITA_HDR_LEN) {
1645                         /*
1646                          * Uh-oh, the packet isn't big enough to even
1647                          * have a pseudo-header.
1648                          */
1649                         *err = WTAP_ERR_BAD_FILE;
1650                         *err_info = g_strdup_printf("pcap: SITA file has a %u-byte packet, too small to have even a SITA pseudo-header",
1651                             packet_size);
1652                         return -1;
1653                 }
1654                 if (!pcap_read_sita_pseudoheader(fh, &phdr->pseudo_header,
1655                     err, err_info))
1656                         return -1;      /* Read error */
1657
1658                 phdr_len = SITA_HDR_LEN;
1659                 break;
1660
1661         case WTAP_ENCAP_BLUETOOTH_H4:
1662                 /* We don't have pseudoheader, so just pretend we received everything. */
1663                 phdr->pseudo_header.p2p.sent = FALSE;
1664                 break;
1665
1666         case WTAP_ENCAP_BLUETOOTH_H4_WITH_PHDR:
1667                 if (check_packet_size &&
1668                     packet_size < sizeof (struct libpcap_bt_phdr)) {
1669                         /*
1670                          * Uh-oh, the packet isn't big enough to even
1671                          * have a pseudo-header.
1672                          */
1673                         *err = WTAP_ERR_BAD_FILE;
1674                         *err_info = g_strdup_printf("pcap: libpcap bluetooth file has a %u-byte packet, too small to have even a pseudo-header",
1675                             packet_size);
1676                         return -1;
1677                 }
1678                 if (!pcap_read_bt_pseudoheader(fh,
1679                     &phdr->pseudo_header, err, err_info))
1680                         return -1;      /* Read error */
1681
1682                 phdr_len = (int)sizeof (struct libpcap_bt_phdr);
1683                 break;
1684
1685         case WTAP_ENCAP_NFC_LLCP:
1686                 if (check_packet_size && packet_size < LLCP_HEADER_LEN) {
1687                         *err = WTAP_ERR_BAD_FILE;
1688                         *err_info = g_strdup_printf("pcap: libpcap llcp file too short");
1689                         return -1;
1690                 }
1691                 if (!pcap_read_llcp_pseudoheader(fh, &phdr->pseudo_header, err, err_info))
1692                         return -1;      /* Read error */
1693                 phdr_len = LLCP_HEADER_LEN;
1694                 break;
1695
1696         case WTAP_ENCAP_PPP_WITH_PHDR:
1697                 if (check_packet_size &&
1698                     packet_size < sizeof (struct libpcap_ppp_phdr)) {
1699                         /*
1700                          * Uh-oh, the packet isn't big enough to even
1701                          * have a pseudo-header.
1702                          */
1703                         *err = WTAP_ERR_BAD_FILE;
1704                         *err_info = g_strdup_printf("pcap: libpcap ppp file has a %u-byte packet, too small to have even a pseudo-header",
1705                             packet_size);
1706                         return -1;
1707                 }
1708                 if (!pcap_read_ppp_pseudoheader(fh,
1709                     &phdr->pseudo_header, err, err_info))
1710                         return -1;      /* Read error */
1711
1712                 phdr_len = (int)sizeof (struct libpcap_ppp_phdr);
1713                 break;
1714
1715         case WTAP_ENCAP_ERF:
1716                 if (check_packet_size &&
1717                     packet_size < sizeof(struct erf_phdr) ) {
1718                         /*
1719                          * Uh-oh, the packet isn't big enough to even
1720                          * have a pseudo-header.
1721                          */
1722                         *err = WTAP_ERR_BAD_FILE;
1723                         *err_info = g_strdup_printf("pcap: ERF file has a %u-byte packet, too small to have even an ERF pseudo-header",
1724                             packet_size);
1725                         return -1;
1726                 }
1727
1728                 if (!pcap_read_erf_pseudoheader(fh, phdr, &phdr->pseudo_header,
1729                     err, err_info))
1730                         return -1;      /* Read error */
1731
1732                 phdr_len = (int)sizeof(struct erf_phdr);
1733
1734                 /* check the optional Extension header */
1735                 if (!pcap_read_erf_exheader(fh, &phdr->pseudo_header, err, err_info,
1736                     &size))
1737                         return -1;      /* Read error */
1738
1739                 phdr_len += size;
1740
1741                 /* check the optional Multi Channel header */
1742                 if (!pcap_read_erf_subheader(fh, &phdr->pseudo_header, err, err_info,
1743                     &size))
1744                         return -1;      /* Read error */
1745
1746                 phdr_len += size;
1747
1748                 if (check_packet_size &&
1749                     packet_size < (guint)phdr_len) {
1750                         /*
1751                          * Uh-oh, the packet isn't big enough for the pseudo-
1752                          * header.
1753                          */
1754                         *err = WTAP_ERR_BAD_FILE;
1755                         *err_info = g_strdup_printf("pcap: ERF file has a %u-byte packet, too small for a pseudo-header with ex- and sub-headers (%d)",
1756                             packet_size, phdr_len);
1757                         return -1;
1758                 }
1759                 break;
1760
1761         case WTAP_ENCAP_I2C:
1762                 if (check_packet_size &&
1763                     packet_size < sizeof (struct i2c_file_hdr)) {
1764                         /*
1765                          * Uh-oh, the packet isn't big enough to even
1766                          * have a pseudo-header.
1767                          */
1768                         *err = WTAP_ERR_BAD_FILE;
1769                         *err_info = g_strdup_printf("pcap: I2C file has a %u-byte packet, too small to have even a I2C pseudo-header",
1770                             packet_size);
1771                         return -1;
1772                 }
1773                 if (!pcap_read_i2c_pseudoheader(fh, &phdr->pseudo_header,
1774                     err, err_info))
1775                         return -1;      /* Read error */
1776
1777                 /*
1778                  * Don't count the pseudo-header as part of the packet.
1779                  */
1780                 phdr_len = (int)sizeof (struct i2c_file_hdr);
1781                 break;
1782         }
1783
1784         return phdr_len;
1785 }
1786
1787 void
1788 pcap_read_post_process(int file_type, int wtap_encap,
1789     union wtap_pseudo_header *pseudo_header,
1790     guint8 *pd, guint packet_size, gboolean bytes_swapped, int fcs_len)
1791 {
1792         switch (wtap_encap) {
1793
1794         case WTAP_ENCAP_ATM_PDUS:
1795                 if (file_type == WTAP_FILE_PCAP_NOKIA) {
1796                         /*
1797                          * Nokia IPSO ATM.
1798                          *
1799                          * Guess the traffic type based on the packet
1800                          * contents.
1801                          */
1802                         atm_guess_traffic_type(pd, packet_size, pseudo_header);
1803                 } else {
1804                         /*
1805                          * SunATM.
1806                          *
1807                          * If this is ATM LANE traffic, try to guess what
1808                          * type of LANE traffic it is based on the packet
1809                          * contents.
1810                          */
1811                         if (pseudo_header->atm.type == TRAF_LANE)
1812                                 atm_guess_lane_type(pd, packet_size,
1813                                     pseudo_header);
1814                 }
1815                 break;
1816
1817         case WTAP_ENCAP_ETHERNET:
1818                 pseudo_header->eth.fcs_len = fcs_len;
1819                 break;
1820
1821         case WTAP_ENCAP_USB_LINUX:
1822                 pcap_process_linux_usb_pseudoheader(packet_size,
1823                     bytes_swapped, FALSE, pd);
1824                 break;
1825
1826         case WTAP_ENCAP_USB_LINUX_MMAPPED:
1827                 pcap_process_linux_usb_pseudoheader(packet_size,
1828                     bytes_swapped, TRUE, pd);
1829                 break;
1830
1831         case WTAP_ENCAP_NETANALYZER:
1832                 /*
1833                  * Not strictly necessary, as the netANALYZER
1834                  * dissector calls the "Ethernet with FCS"
1835                  * dissector, but we might as well set it.
1836                  */
1837                 pseudo_header->eth.fcs_len = 4;
1838                 break;
1839
1840         default:
1841                 break;
1842         }
1843 }
1844
1845 int
1846 pcap_get_phdr_size(int encap, const union wtap_pseudo_header *pseudo_header)
1847 {
1848         int hdrsize;
1849
1850         switch (encap) {
1851
1852         case WTAP_ENCAP_ATM_PDUS:
1853                 hdrsize = SUNATM_LEN;
1854                 break;
1855
1856         case WTAP_ENCAP_IRDA:
1857                 hdrsize = IRDA_SLL_LEN;
1858                 break;
1859
1860         case WTAP_ENCAP_MTP2_WITH_PHDR:
1861                 hdrsize = MTP2_HDR_LEN;
1862                 break;
1863
1864         case WTAP_ENCAP_LINUX_LAPD:
1865                 hdrsize = LAPD_SLL_LEN;
1866                 break;
1867
1868         case WTAP_ENCAP_SITA:
1869                 hdrsize = SITA_HDR_LEN;
1870                 break;
1871
1872         case WTAP_ENCAP_ERF:
1873                 hdrsize = (int)sizeof (struct erf_phdr);
1874                 switch (pseudo_header->erf.phdr.type & 0x7F) {
1875
1876                 case ERF_TYPE_MC_HDLC:
1877                 case ERF_TYPE_MC_RAW:
1878                 case ERF_TYPE_MC_ATM:
1879                 case ERF_TYPE_MC_RAW_CHANNEL:
1880                 case ERF_TYPE_MC_AAL5:
1881                 case ERF_TYPE_MC_AAL2:
1882                 case ERF_TYPE_COLOR_MC_HDLC_POS:
1883                         hdrsize += (int)sizeof(struct erf_mc_hdr);
1884                         break;
1885
1886                 case ERF_TYPE_ETH:
1887                 case ERF_TYPE_COLOR_ETH:
1888                 case ERF_TYPE_DSM_COLOR_ETH:
1889                         hdrsize += (int)sizeof(struct erf_eth_hdr);
1890                         break;
1891
1892                 default:
1893                         break;
1894                 }
1895
1896                 /*
1897                  * Add in the lengths of the extension headers.
1898                  */
1899                 if (pseudo_header->erf.phdr.type & 0x80) {
1900                         int i = 0, max = sizeof(pseudo_header->erf.ehdr_list)/sizeof(struct erf_ehdr);
1901                         guint8 erf_exhdr[8];
1902                         guint8 type;
1903
1904                         do {
1905                                 phtonll(erf_exhdr, pseudo_header->erf.ehdr_list[i].ehdr);
1906                                 type = erf_exhdr[0];
1907                                 hdrsize += 8;
1908                                 i++;
1909                         } while (type & 0x80 && i < max);
1910                 }
1911                 break;
1912
1913         case WTAP_ENCAP_I2C:
1914                 hdrsize = (int)sizeof (struct i2c_file_hdr);
1915                 break;
1916
1917         case WTAP_ENCAP_BLUETOOTH_H4_WITH_PHDR:
1918                 hdrsize = (int)sizeof (struct libpcap_bt_phdr);
1919                 break;
1920
1921         case WTAP_ENCAP_PPP_WITH_PHDR:
1922                 hdrsize = (int)sizeof (struct libpcap_ppp_phdr);
1923                 break;
1924
1925         default:
1926                 hdrsize = 0;
1927                 break;
1928         }
1929
1930         return hdrsize;
1931 }
1932
1933 gboolean
1934 pcap_write_phdr(wtap_dumper *wdh, int encap, const union wtap_pseudo_header *pseudo_header,
1935     int *err)
1936 {
1937         guint8 atm_hdr[SUNATM_LEN];
1938         guint8 irda_hdr[IRDA_SLL_LEN];
1939         guint8 lapd_hdr[LAPD_SLL_LEN];
1940         guint8 mtp2_hdr[MTP2_HDR_LEN];
1941         guint8 sita_hdr[SITA_HDR_LEN];
1942         guint8 erf_hdr[ sizeof(struct erf_mc_phdr)];
1943         struct i2c_file_hdr i2c_hdr;
1944         struct libpcap_bt_phdr bt_hdr;
1945         struct libpcap_ppp_phdr ppp_hdr;
1946         size_t size;
1947
1948         switch (encap) {
1949
1950         case WTAP_ENCAP_ATM_PDUS:
1951                 /*
1952                  * Write the ATM header.
1953                  */
1954                 atm_hdr[SUNATM_FLAGS] =
1955                     (pseudo_header->atm.channel == 0) ? 0x80 : 0x00;
1956                 switch (pseudo_header->atm.aal) {
1957
1958                 case AAL_SIGNALLING:
1959                         /* Q.2931 */
1960                         atm_hdr[SUNATM_FLAGS] |= 0x06;
1961                         break;
1962
1963                 case AAL_5:
1964                         switch (pseudo_header->atm.type) {
1965
1966                         case TRAF_LANE:
1967                                 /* LANE */
1968                                 atm_hdr[SUNATM_FLAGS] |= 0x01;
1969                                 break;
1970
1971                         case TRAF_LLCMX:
1972                                 /* RFC 1483 LLC multiplexed traffic */
1973                                 atm_hdr[SUNATM_FLAGS] |= 0x02;
1974                                 break;
1975
1976                         case TRAF_ILMI:
1977                                 /* ILMI */
1978                                 atm_hdr[SUNATM_FLAGS] |= 0x05;
1979                                 break;
1980                         }
1981                         break;
1982                 }
1983                 atm_hdr[SUNATM_VPI] = (guint8)pseudo_header->atm.vpi;
1984                 phtons(&atm_hdr[SUNATM_VCI], pseudo_header->atm.vci);
1985                 if (!wtap_dump_file_write(wdh, atm_hdr, sizeof(atm_hdr), err))
1986                         return FALSE;
1987                 wdh->bytes_dumped += sizeof(atm_hdr);
1988                 break;
1989
1990         case WTAP_ENCAP_IRDA:
1991                 /*
1992                  * Write the IrDA header.
1993                  */
1994                 memset(irda_hdr, 0, sizeof(irda_hdr));
1995                 phtons(&irda_hdr[IRDA_SLL_PKTTYPE_OFFSET],
1996                     pseudo_header->irda.pkttype);
1997                 phtons(&irda_hdr[IRDA_SLL_PROTOCOL_OFFSET], 0x0017);
1998                 if (!wtap_dump_file_write(wdh, irda_hdr, sizeof(irda_hdr), err))
1999                         return FALSE;
2000                 wdh->bytes_dumped += sizeof(irda_hdr);
2001                 break;
2002
2003         case WTAP_ENCAP_MTP2_WITH_PHDR:
2004                 /*
2005                  * Write the MTP2 header.
2006                  */
2007                 memset(&mtp2_hdr, 0, sizeof(mtp2_hdr));
2008                 mtp2_hdr[MTP2_SENT_OFFSET] = pseudo_header->mtp2.sent;
2009                 mtp2_hdr[MTP2_ANNEX_A_USED_OFFSET] = pseudo_header->mtp2.annex_a_used;
2010                 phtons(&mtp2_hdr[MTP2_LINK_NUMBER_OFFSET],
2011                     pseudo_header->mtp2.link_number);
2012                 if (!wtap_dump_file_write(wdh, mtp2_hdr, sizeof(mtp2_hdr), err))
2013                         return FALSE;
2014                 wdh->bytes_dumped += sizeof(mtp2_hdr);
2015                 break;
2016
2017         case WTAP_ENCAP_LINUX_LAPD:
2018                 /*
2019                  * Write the LAPD header.
2020                  */
2021                 memset(&lapd_hdr, 0, sizeof(lapd_hdr));
2022                 phtons(&lapd_hdr[LAPD_SLL_PKTTYPE_OFFSET],
2023                     pseudo_header->lapd.pkttype);
2024                 phtons(&lapd_hdr[LAPD_SLL_PROTOCOL_OFFSET], ETH_P_LAPD);
2025                 lapd_hdr[LAPD_SLL_ADDR_OFFSET + 0] =
2026                     pseudo_header->lapd.we_network?0x01:0x00;
2027                 if (!wtap_dump_file_write(wdh, lapd_hdr, sizeof(lapd_hdr), err))
2028                         return FALSE;
2029                 wdh->bytes_dumped += sizeof(lapd_hdr);
2030                 break;
2031
2032         case WTAP_ENCAP_SITA:
2033                 /*
2034                  * Write the SITA header.
2035                  */
2036                 memset(&sita_hdr, 0, sizeof(sita_hdr));
2037                 sita_hdr[SITA_FLAGS_OFFSET]   = pseudo_header->sita.sita_flags;
2038                 sita_hdr[SITA_SIGNALS_OFFSET] = pseudo_header->sita.sita_signals;
2039                 sita_hdr[SITA_ERRORS1_OFFSET] = pseudo_header->sita.sita_errors1;
2040                 sita_hdr[SITA_ERRORS2_OFFSET] = pseudo_header->sita.sita_errors2;
2041                 sita_hdr[SITA_PROTO_OFFSET]   = pseudo_header->sita.sita_proto;
2042                 if (!wtap_dump_file_write(wdh, sita_hdr, sizeof(sita_hdr), err))
2043                         return FALSE;
2044                 wdh->bytes_dumped += sizeof(sita_hdr);
2045                 break;
2046
2047         case WTAP_ENCAP_ERF:
2048                 /*
2049                  * Write the ERF header.
2050                  */
2051                 memset(&erf_hdr, 0, sizeof(erf_hdr));
2052                 phtolell(&erf_hdr[0], pseudo_header->erf.phdr.ts);
2053                 erf_hdr[8] = pseudo_header->erf.phdr.type;
2054                 erf_hdr[9] = pseudo_header->erf.phdr.flags;
2055                 phtons(&erf_hdr[10], pseudo_header->erf.phdr.rlen);
2056                 phtons(&erf_hdr[12], pseudo_header->erf.phdr.lctr);
2057                 phtons(&erf_hdr[14], pseudo_header->erf.phdr.wlen);
2058                 size = sizeof(struct erf_phdr);
2059
2060                 switch(pseudo_header->erf.phdr.type & 0x7F) {
2061                 case ERF_TYPE_MC_HDLC:
2062                 case ERF_TYPE_MC_RAW:
2063                 case ERF_TYPE_MC_ATM:
2064                 case ERF_TYPE_MC_RAW_CHANNEL:
2065                 case ERF_TYPE_MC_AAL5:
2066                 case ERF_TYPE_MC_AAL2:
2067                 case ERF_TYPE_COLOR_MC_HDLC_POS:
2068                         phtonl(&erf_hdr[16], pseudo_header->erf.subhdr.mc_hdr);
2069                         size += (int)sizeof(struct erf_mc_hdr);
2070                         break;
2071                 case ERF_TYPE_ETH:
2072                 case ERF_TYPE_COLOR_ETH:
2073                 case ERF_TYPE_DSM_COLOR_ETH:
2074                         phtons(&erf_hdr[16], pseudo_header->erf.subhdr.eth_hdr);
2075                         size += (int)sizeof(struct erf_eth_hdr);
2076                         break;
2077                 default:
2078                         break;
2079                 }
2080                 if (!wtap_dump_file_write(wdh, erf_hdr, size, err))
2081                         return FALSE;
2082                 wdh->bytes_dumped += size;
2083
2084                 /*
2085                  * Now write out the extension headers.
2086                  */
2087                 if (pseudo_header->erf.phdr.type & 0x80) {
2088                         int i = 0, max = sizeof(pseudo_header->erf.ehdr_list)/sizeof(struct erf_ehdr);
2089                         guint8 erf_exhdr[8];
2090                         guint8 type;
2091
2092                         do {
2093                                 phtonll(erf_exhdr, pseudo_header->erf.ehdr_list[i].ehdr);
2094                                 type = erf_exhdr[0];
2095                                 if (!wtap_dump_file_write(wdh, erf_exhdr, 8, err))
2096                                         return FALSE;
2097                                 wdh->bytes_dumped += 8;
2098                                 i++;
2099                         } while (type & 0x80 && i < max);
2100                 }
2101                 break;
2102
2103         case WTAP_ENCAP_I2C:
2104                 /*
2105                  * Write the I2C header.
2106                  */
2107                 memset(&i2c_hdr, 0, sizeof(i2c_hdr));
2108                 i2c_hdr.bus = pseudo_header->i2c.bus |
2109                         (pseudo_header->i2c.is_event ? 0x80 : 0x00);
2110                 phtonl((guint8 *)&i2c_hdr.flags, pseudo_header->i2c.flags);
2111                 if (!wtap_dump_file_write(wdh, &i2c_hdr, sizeof(i2c_hdr), err))
2112                         return FALSE;
2113                 wdh->bytes_dumped += sizeof(i2c_hdr);
2114                 break;
2115
2116         case WTAP_ENCAP_BLUETOOTH_H4_WITH_PHDR:
2117                 bt_hdr.direction = GUINT32_TO_BE(pseudo_header->p2p.sent ? LIBPCAP_BT_PHDR_SENT : LIBPCAP_BT_PHDR_RECV);
2118                 if (!wtap_dump_file_write(wdh, &bt_hdr, sizeof bt_hdr, err))
2119                         return FALSE;
2120                 wdh->bytes_dumped += sizeof bt_hdr;
2121                 break;
2122
2123         case WTAP_ENCAP_PPP_WITH_PHDR:
2124                 ppp_hdr.direction = (pseudo_header->p2p.sent ? LIBPCAP_PPP_PHDR_SENT : LIBPCAP_PPP_PHDR_RECV);
2125                 if (!wtap_dump_file_write(wdh, &ppp_hdr, sizeof ppp_hdr, err))
2126                         return FALSE;
2127                 wdh->bytes_dumped += sizeof ppp_hdr;
2128                 break;
2129         }
2130         return TRUE;
2131 }