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