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