33b3bcc53ba1484fdc99457232dfdc6ff9f6665b
[obnox/wireshark/wip.git] / wiretap / libpcap.c
1 /* libpcap.c
2  *
3  * $Id$
4  *
5  * Wiretap Library
6  * Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  */
22
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26
27 #ifdef HAVE_PCAP_H
28 #include <pcap.h>
29 #endif
30
31 #include <stdlib.h>
32 #include <string.h>
33 #include <errno.h>
34 #include "wtap-int.h"
35 #include "file_wrappers.h"
36 #include "buffer.h"
37 #include "atm.h"
38 #include "libpcap.h"
39
40 #ifdef HAVE_PCAP_H
41 # ifdef HAVE_SYS_TYPES_H
42 #   include <sys/types.h>
43 # endif
44 #include "wtap-capture.h"
45 #endif
46
47 /*
48  * The link-layer header on SunATM packets.
49  */
50 struct sunatm_hdr {
51         guint8  flags;          /* destination and traffic type */
52         guint8  vpi;            /* VPI */
53         guint16 vci;            /* VCI */
54 };
55
56 /*
57  * The link-layer header on Nokia IPSO ATM packets.
58  */
59 struct nokiaatm_hdr {
60         guint8  flags;          /* destination */
61         guint8  vpi;            /* VPI */
62         guint16 vci;            /* VCI */
63 };
64
65 /*
66  * The fake link-layer header of IrDA packets as introduced by Jean Tourrilhes
67  * to libpcap.
68  */
69 struct irda_sll_hdr {
70     guint16 sll_pkttype;    /* packet type */
71     guint8 unused[12];      /* usused SLL header fields */
72     guint16 sll_protocol;   /* protocol, should be 0x0017 */
73 };
74
75 /* See source to the "libpcap" library for information on the "libpcap"
76    file format. */
77
78 /* On some systems, the FDDI MAC addresses are bit-swapped. */
79 #if !defined(ultrix) && !defined(__alpha) && !defined(__bsdi__)
80 #define BIT_SWAPPED_MAC_ADDRS
81 #endif
82
83 /* Try to read the first two records of the capture file. */
84 typedef enum {
85         THIS_FORMAT,            /* the reads succeeded, assume it's this format */
86         BAD_READ,               /* the file is probably not valid */
87         OTHER_FORMAT            /* the file may be valid, but not in this format */
88 } libpcap_try_t;
89 static libpcap_try_t libpcap_try(wtap *wth, int *err);
90
91 static gboolean libpcap_read(wtap *wth, int *err, gchar **err_info,
92     long *data_offset);
93 static gboolean libpcap_seek_read(wtap *wth, long seek_off,
94     union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
95     int *err, gchar **err_info);
96 static int libpcap_read_header(wtap *wth, int *err, gchar **err_info,
97     struct pcaprec_ss990915_hdr *hdr);
98 static void adjust_header(wtap *wth, struct pcaprec_hdr *hdr);
99 static void libpcap_get_sunatm_pseudoheader(const struct sunatm_hdr *atm_phdr,
100     union wtap_pseudo_header *pseudo_header);
101 static gboolean libpcap_read_sunatm_pseudoheader(FILE_T fh,
102     union wtap_pseudo_header *pseudo_header, int *err);
103 static gboolean libpcap_read_nokiaatm_pseudoheader(FILE_T fh,
104     union wtap_pseudo_header *pseudo_header, int *err);
105 static gboolean libpcap_get_irda_pseudoheader(const struct irda_sll_hdr *irda_phdr,
106     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info);
107 static gboolean libpcap_read_irda_pseudoheader(FILE_T fh,
108     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info);
109 static gboolean libpcap_read_rec_data(FILE_T fh, guchar *pd, int length,
110     int *err);
111 static void libpcap_close(wtap *wth);
112 static gboolean libpcap_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
113     const union wtap_pseudo_header *pseudo_header, const guchar *pd, int *err);
114
115 /*
116  * Either LBL NRG wasn't an adequate central registry (e.g., because of
117  * the slow rate of releases from them), or nobody bothered using them
118  * as a central registry, as many different groups have patched libpcap
119  * (and BPF, on the BSDs) to add new encapsulation types, and have ended
120  * up using the same DLT_ values for different encapsulation types.
121  *
122  * For those numerical encapsulation type values that everybody uses for
123  * the same encapsulation type (which inclues those that some platforms
124  * specify different DLT_ names for but don't appear to use), we map
125  * those values to the appropriate Wiretap values.
126  *
127  * For those numerical encapsulation type values that different libpcap
128  * variants use for different encapsulation types, we check what
129  * <pcap.h> defined to determine how to interpret them, so that we
130  * interpret them the way the libpcap with which we're building
131  * Ethereal/Wiretap interprets them (which, if it doesn't support
132  * them at all, means we don't support them either - any capture files
133  * using them are foreign, and we don't hazard a guess as to which
134  * platform they came from; we could, I guess, choose the most likely
135  * platform).
136  *
137  * Note: if you need a new encapsulation type for libpcap files, do
138  * *N*O*T* use *ANY* of the values listed here!  I.e., do *NOT*
139  * add a new encapsulation type by changing an existing entry;
140  * leave the existing entries alone.
141  *
142  * Instead, send mail to tcpdump-workers@tcpdump.org, asking for a new
143  * DLT_ value, and specifying the purpose of the new value.  When you
144  * get the new DLT_ value, use that numerical value in the "dlt_value"
145  * field of "pcap_to_wtap_map[]".
146  */
147
148 static const struct {
149         int     dlt_value;
150         int     wtap_encap_value;
151 } pcap_to_wtap_map[] = {
152         /*
153          * These are the values that are almost certainly the same
154          * in all libpcaps (I've yet to find one where the values
155          * in question are used for some purpose other than the
156          * one below, but...), and that Wiretap and Ethereal
157          * currently support.
158          */
159         { 0,            WTAP_ENCAP_NULL },      /* null encapsulation */
160         { 1,            WTAP_ENCAP_ETHERNET },
161         { 6,            WTAP_ENCAP_TOKEN_RING },        /* IEEE 802 Networks - assume token ring */
162         { 7,            WTAP_ENCAP_ARCNET },
163         { 8,            WTAP_ENCAP_SLIP },
164         { 9,            WTAP_ENCAP_PPP },
165 #ifdef BIT_SWAPPED_MAC_ADDRS
166         { 10,           WTAP_ENCAP_FDDI_BITSWAPPED },
167 #else
168         { 10,           WTAP_ENCAP_FDDI },
169 #endif
170
171         { 32,           WTAP_ENCAP_REDBACK },
172
173         /*
174          * 50 is DLT_PPP_SERIAL in NetBSD; it appears that DLT_PPP
175          * on BSD (at least according to standard tcpdump) has, as
176          * the first octet, an indication of whether the packet was
177          * transmitted or received (rather than having the standard
178          * PPP address value of 0xff), but that DLT_PPP_SERIAL puts
179          * a real live PPP header there, or perhaps a Cisco PPP header
180          * as per section 4.3.1 of RFC 1547 (implementations of this
181          * exist in various BSDs in "sys/net/if_spppsubr.c", and
182          * I think also exist either in standard Linux or in
183          * various Linux patches; the implementations show how to handle
184          * Cisco keepalive packets).
185          *
186          * However, I don't see any obvious place in FreeBSD "if_ppp.c"
187          * where anything other than the standard PPP header would be
188          * passed up.  I see some stuff that sets the first octet
189          * to 0 for incoming and 1 for outgoing packets before applying
190          * a BPF filter to see whether to drop packets whose protocol
191          * field has the 0x8000 bit set, i.e. network control protocols -
192          * those are handed up to userland - but that code puts the
193          * address field back before passing the packet up.
194          *
195          * I also don't see anything immediately obvious that munges
196          * the address field for sync PPP, either.
197          *
198          * Ethereal currently assumes that if the first octet of a
199          * PPP frame is 0xFF, it's the address field and is followed
200          * by a control field and a 2-byte protocol, otherwise the
201          * address and control fields are absent and the frame begins
202          * with a protocol field.  If we ever see a BSD/OS PPP
203          * capture, we'll have to handle it differently, and we may
204          * have to handle standard BSD captures differently if, in fact,
205          * they don't have 0xff 0x03 as the first two bytes - but, as per
206          * the two paragraphs preceding this, it's not clear that
207          * the address field *is* munged into an incoming/outgoing
208          * field when the packet is handed to the BPF device.
209          *
210          * For now, we just map DLT_PPP_SERIAL to WTAP_ENCAP_PPP, as
211          * we treat WTAP_ENCAP_PPP packets as if those beginning with
212          * 0xff have the standard RFC 1662 "PPP in HDLC-like Framing"
213          * 0xff 0x03 address/control header, and DLT_PPP_SERIAL frames
214          * appear to contain that unless they're Cisco frames (if we
215          * ever see a capture with them, we'd need to implement the
216          * RFC 1547 stuff, and the keepalive protocol stuff).
217          *
218          * We may have to distinguish between "PPP where if it doesn't
219          * begin with 0xff there's no HDLC encapsulation and the frame
220          * begins with the protocol field" (which is how we handle
221          * WTAP_ENCAP_PPP now) and "PPP where there's either HDLC
222          * encapsulation or Cisco PPP" (which is what DLT_PPP_SERIAL
223          * is) at some point.
224          *
225          * XXX - NetBSD has DLT_HDLC, which appears to be used for
226          * Cisco HDLC.  Ideally, they should use DLT_PPP_SERIAL
227          * only for real live HDLC-encapsulated PPP, not for Cisco
228          * HDLC.
229          */
230         { 50,           WTAP_ENCAP_PPP },
231
232         /*
233          * Apparently used by the Axent Raptor firewall (now Symantec
234          * Enterprise Firewall).
235          * Thanks, Axent, for not reserving that type with tcpdump.org
236          * and not telling anybody about it.
237          */
238         { 99,           WTAP_ENCAP_SYMANTEC },
239
240         /*
241          * These are the values that libpcap 0.5 and later use in
242          * capture file headers, in an attempt to work around the
243          * confusion decried above, and that Wiretap and Ethereal
244          * currently support.
245          */
246         { 100,          WTAP_ENCAP_ATM_RFC1483 },
247         { 101,          WTAP_ENCAP_RAW_IP },
248 #if 0
249         /*
250          * More values used by libpcap 0.5 as DLT_ values and used by the
251          * current CVS version of libpcap in capture file headers.
252          * They are not yet handled in Ethereal.
253          * If we get a capture that contains them, we'll implement them.
254          */
255         { 102,          WTAP_ENCAP_SLIP_BSDOS },
256         { 103,          WTAP_ENCAP_PPP_BSDOS },
257 #endif
258
259         /*
260          * These ones are handled in Ethereal, though.
261          */
262         { 104,          WTAP_ENCAP_CHDLC },     /* Cisco HDLC */
263         { 105,          WTAP_ENCAP_IEEE_802_11 }, /* IEEE 802.11 */
264         { 106,          WTAP_ENCAP_LINUX_ATM_CLIP },
265         { 107,          WTAP_ENCAP_FRELAY },    /* Frame Relay */
266         { 108,          WTAP_ENCAP_NULL },      /* OpenBSD loopback */
267         { 109,          WTAP_ENCAP_ENC },       /* OpenBSD IPSEC enc */
268 #if 0
269         { 110,          WTAP_ENCAP_LANE_802_3 },/* ATM LANE 802.3 */
270         { 111,          WTAP_ENCAP_HIPPI },     /* NetBSD HIPPI */
271 #endif
272         { 112,          WTAP_ENCAP_CHDLC },     /* NetBSD HDLC framing */
273
274         /*
275          * Linux "cooked mode" captures, used by the current CVS version
276          * of libpcap.
277          */
278         { 113,          WTAP_ENCAP_SLL },       /* Linux cooked capture */
279
280         { 114,          WTAP_ENCAP_LOCALTALK }, /* Localtalk */
281
282         /*
283          * The tcpdump.org version of libpcap uses 117, rather than 17,
284          * for OpenBSD packet filter logging, so as to avoid conflicting
285          * with DLT_LANE8023 in SuSE 6.3 libpcap.
286          */
287         { 117,          WTAP_ENCAP_PFLOG },
288
289         { 118,          WTAP_ENCAP_CISCO_IOS },
290         { 119,          WTAP_ENCAP_PRISM_HEADER }, /* Prism monitor mode hdr */
291         { 121,          WTAP_ENCAP_HHDLC },     /* HiPath HDLC */
292         { 122,          WTAP_ENCAP_IP_OVER_FC },   /* RFC 2625 IP-over-FC */
293         { 123,          WTAP_ENCAP_ATM_PDUS },  /* SunATM */
294         { 127,          WTAP_ENCAP_IEEE_802_11_WLAN_RADIOTAP },  /* 802.11 plus radiotap WLAN header */
295         { 128,          WTAP_ENCAP_TZSP },      /* Tazmen Sniffer Protocol */
296         { 129,          WTAP_ENCAP_ARCNET_LINUX },
297
298         /*
299          * Values 130 through 137 not listed here are reserved for use
300          * in Juniper hardware.
301          */
302         { 135,          WTAP_ENCAP_JUNIPER_ATM2 }, /* various encapsulations captured on the ATM2 PIC */
303         { 137,          WTAP_ENCAP_JUNIPER_ATM1 }, /* various encapsulations captured on the ATM1 PIC */
304
305         { 138,          WTAP_ENCAP_APPLE_IP_OVER_IEEE1394 },
306                                                 /* Apple IP-over-IEEE 1394 */
307
308         /* 139 is reserved for SS7 */
309
310         { 140,          WTAP_ENCAP_MTP2 },
311         { 141,          WTAP_ENCAP_MTP3 },
312         { 143,          WTAP_ENCAP_DOCSIS },
313         { 144,          WTAP_ENCAP_IRDA },      /* IrDA capture */
314
315         /* Reserved for private use. */
316         { 147,          WTAP_ENCAP_USER0 },
317         { 148,          WTAP_ENCAP_USER1 },
318         { 149,          WTAP_ENCAP_USER2 },
319         { 150,          WTAP_ENCAP_USER3 },
320         { 151,          WTAP_ENCAP_USER4 },
321         { 152,          WTAP_ENCAP_USER5 },
322         { 153,          WTAP_ENCAP_USER6 },
323         { 154,          WTAP_ENCAP_USER7 },
324         { 155,          WTAP_ENCAP_USER8 },
325         { 156,          WTAP_ENCAP_USER9 },
326         { 157,          WTAP_ENCAP_USER10 },
327         { 158,          WTAP_ENCAP_USER11 },
328         { 159,          WTAP_ENCAP_USER12 },
329         { 160,          WTAP_ENCAP_USER13 },
330         { 161,          WTAP_ENCAP_USER14 },
331         { 162,          WTAP_ENCAP_USER15 },
332
333         { 163,          WTAP_ENCAP_IEEE_802_11_WLAN_AVS },  /* 802.11 plus AVS WLAN header */
334
335         /*
336          * 164 is reserved for Juniper-private chassis-internal
337          * meta-information such as QoS profiles, etc..
338          */
339
340         { 165,          WTAP_ENCAP_BACNET_MS_TP },
341
342         /*
343          * 166 is reserved for a PPP variant in which the first byte
344          * of the 0xff03 header, the 0xff, is replaced by a direction
345          * byte.  I don't know whether any captures look like that,
346          * but it is used for some Linux IP filtering (ipfilter?).
347          *
348          * 167 and 168 are reserved for more Juniper private-chassis-
349          * internal meta-information.
350          */
351
352         { 169,          WTAP_ENCAP_GPRS_LLC },
353
354         /*
355          * 170 and 171 are reserved for ITU-T G.7041/Y.1303 Generic
356          * Framing Procedure.
357          */
358
359         /*
360          * To repeat:
361          *
362          * If you need a new encapsulation type for libpcap files, do
363          * *N*O*T* use *ANY* of the values listed here!  I.e., do *NOT*
364          * add a new encapsulation type by changing an existing entry;
365          * leave the existing entries alone.
366          *
367          * Instead, send mail to tcpdump-workers@tcpdump.org, asking for
368          * a new DLT_ value, and specifying the purpose of the new value.
369          * When you get the new DLT_ value, use that numerical value in
370          * the "dlt_value" field of "pcap_to_wtap_map[]".
371          */
372
373         /*
374          * The following are entries for libpcap type values that have
375          * different meanings on different OSes.
376          *
377          * We put these *after* the entries for the platform-independent
378          * libpcap type values for those Wiretap encapsulation types, so
379          * that Ethereal chooses the platform-independent libpcap type
380          * value for those encapsulatioin types, not the platform-dependent
381          * one.
382          */
383
384         /*
385          * 11 is DLT_ATM_RFC1483 on most platforms; the only libpcaps I've
386          * seen that define anything other than DLT_ATM_RFC1483 as 11 are
387          * the BSD/OS one, which defines DLT_FR as 11, and libpcap 0.5,
388          * which define it as 100, mapping the kernel's value to 100, in
389          * an attempt to hide the different values used on different
390          * platforms.
391          *
392          * If this is a platform where DLT_FR is defined as 11, we
393          * don't handle 11 at all; otherwise, we handle it as
394          * DLT_ATM_RFC1483 (this means we'd misinterpret Frame Relay
395          * captures from BSD/OS if running on platforms other than BSD/OS,
396          * but
397          *
398          *      1) we don't yet support DLT_FR
399          *
400          * and
401          *
402          *      2) nothing short of a heuristic would let us interpret
403          *         them correctly).
404          */
405 #if defined(DLT_FR) && (DLT_FR == 11)
406         { 11,           WTAP_ENCAP_FRELAY },
407 #else
408         { 11,           WTAP_ENCAP_ATM_RFC1483 },
409 #endif
410
411         /*
412          * 12 is DLT_RAW on most platforms, but it's DLT_C_HDLC on
413          * BSD/OS, and DLT_LOOP on OpenBSD.
414          *
415          * We don't yet handle DLT_C_HDLC, but we can handle DLT_LOOP
416          * (it's just like DLT_NULL, only with the AF_ value in network
417          * rather than host byte order - Ethereal figures out the
418          * byte order from the data, so we don't care what byte order
419          * it's in), so if DLT_LOOP is defined as 12, interpret 12
420          * as WTAP_ENCAP_NULL, otherwise, unless DLT_C_HDLC is defined
421          * as 12, interpret it as WTAP_ENCAP_RAW_IP.
422          */
423 #if defined(DLT_LOOP) && (DLT_LOOP == 12)
424         { 12,           WTAP_ENCAP_NULL },
425 #elif defined(DLT_C_HDLC) && (DLT_C_HDLC == 12)
426         /*
427          * Put entry for Cisco HDLC here.
428          * XXX - is this just WTAP_ENCAP_CHDLC, i.e. does the frame
429          * start with a 4-byte Cisco HDLC header?
430          */
431 #else
432         { 12,           WTAP_ENCAP_RAW_IP },
433 #endif
434
435         /*
436          * 13 is DLT_SLIP_BSDOS on FreeBSD and NetBSD, but those OSes
437          * don't actually generate it.  I infer that BSD/OS translates
438          * DLT_SLIP from the kernel BPF code to DLT_SLIP_BSDOS in
439          * libpcap, as the BSD/OS link-layer header is different;
440          * however, in BSD/OS, DLT_SLIP_BSDOS is 15.
441          *
442          * From this, I infer that there's no point in handling 13
443          * as DLT_SLIP_BSDOS.
444          *
445          * 13 is DLT_ATM_RFC1483 on BSD/OS.
446          *
447          * 13 is DLT_ENC in OpenBSD, which is, I suspect, some kind
448          * of decrypted IPSEC traffic.
449          */
450 #if defined(DLT_ATM_RFC1483) && (DLT_ATM_RFC1483 == 13)
451         { 13,           WTAP_ENCAP_ATM_RFC1483 },
452 #elif defined(DLT_ENC) && (DLT_ENC == 13)
453         { 13,           WTAP_ENCAP_ENC },
454 #endif
455
456         /*
457          * 14 is DLT_PPP_BSDOS on FreeBSD and NetBSD, but those OSes
458          * don't actually generate it.  I infer that BSD/OS translates
459          * DLT_PPP from the kernel BPF code to DLT_PPP_BSDOS in
460          * libpcap, as the BSD/OS link-layer header is different;
461          * however, in BSD/OS, DLT_PPP_BSDOS is 16.
462          *
463          * From this, I infer that there's no point in handling 14
464          * as DLT_PPP_BSDOS.
465          *
466          * 14 is DLT_RAW on BSD/OS and OpenBSD.
467          */
468         { 14,           WTAP_ENCAP_RAW_IP },
469
470         /*
471          * 15 is:
472          *
473          *      DLT_SLIP_BSDOS on BSD/OS;
474          *
475          *      DLT_HIPPI on NetBSD;
476          *
477          *      DLT_LANE8023 with Alexey Kuznetzov's patches for
478          *      Linux libpcap;
479          *
480          *      DLT_I4L_RAWIP with the ISDN4Linux patches for libpcap
481          *      (and on SuSE 6.3);
482          *
483          * but we don't currently handle any of those.
484          */
485
486         /*
487          * 16 is:
488          *
489          *      DLT_PPP_BSDOS on BSD/OS;
490          *
491          *      DLT_HDLC on NetBSD (Cisco HDLC);
492          *
493          *      DLT_CIP with Alexey Kuznetzov's patches for
494          *      Linux libpcap - this is WTAP_ENCAP_LINUX_ATM_CLIP;
495          *
496          *      DLT_I4L_IP with the ISDN4Linux patches for libpcap
497          *      (and on SuSE 6.3).
498          */
499 #if defined(DLT_CIP) && (DLT_CIP == 16)
500         { 16,           WTAP_ENCAP_LINUX_ATM_CLIP },
501 #endif
502 #if defined(DLT_HDLC) && (DLT_HDLC == 16)
503         { 16,           WTAP_ENCAP_CHDLC },
504 #endif
505
506         /*
507          * 17 is DLT_LANE8023 in SuSE 6.3 libpcap; we don't currently
508          * handle it.
509          * It is also used as the PF (Packet Filter) logging format beginning
510          * with OpenBSD 3.0; we use 17 for PF logs unless DLT_LANE8023 is
511          * defined with the value 17.
512          */
513 #if !defined(DLT_LANE8023) || (DLT_LANE8023 != 17)
514         { 17,           WTAP_ENCAP_OLD_PFLOG },
515 #endif
516
517         /*
518          * 18 is DLT_CIP in SuSE 6.3 libpcap; if it's the same as the
519          * DLT_CIP of 16 that the Alexey Kuznetzov patches for
520          * libpcap/tcpdump define, it's WTAP_ENCAP_LINUX_ATM_CLIP.
521          * I've not found any libpcap that uses it for any other purpose -
522          * hopefully nobody will do so in the future.
523          */
524         { 18,           WTAP_ENCAP_LINUX_ATM_CLIP },
525
526         /*
527          * 19 is DLT_ATM_CLIP in the libpcap/tcpdump patches in the
528          * recent versions I've seen of the Linux ATM distribution;
529          * I've not yet found any libpcap that uses it for any other
530          * purpose - hopefully nobody will do so in the future.
531          */
532         { 19,           WTAP_ENCAP_LINUX_ATM_CLIP },
533
534         /*
535          * nettl (HP-UX) mappings to standard DLT values
536          */
537
538         { 1,            WTAP_ENCAP_NETTL_ETHERNET },
539         { 6,            WTAP_ENCAP_NETTL_TOKEN_RING },
540         { 10,           WTAP_ENCAP_NETTL_FDDI },
541         { 101,          WTAP_ENCAP_NETTL_RAW_IP },
542
543         /*
544          * To repeat:
545          *
546          * If you need a new encapsulation type for libpcap files, do
547          * *N*O*T* use *ANY* of the values listed here!  I.e., do *NOT*
548          * add a new encapsulation type by changing an existing entry;
549          * leave the existing entries alone.
550          *
551          * Instead, send mail to tcpdump-workers@tcpdump.org, asking for
552          * a new DLT_ value, and specifying the purpose of the new value.
553          * When you get the new DLT_ value, use that numerical value in
554          * the "dlt_value" field of "pcap_to_wtap_map[]".
555          */
556
557 };
558 #define NUM_PCAP_ENCAPS (sizeof pcap_to_wtap_map / sizeof pcap_to_wtap_map[0])
559
560 int wtap_pcap_encap_to_wtap_encap(int encap)
561 {
562         unsigned int i;
563
564         for (i = 0; i < NUM_PCAP_ENCAPS; i++) {
565                 if (pcap_to_wtap_map[i].dlt_value == encap)
566                         return pcap_to_wtap_map[i].wtap_encap_value;
567         }
568         return WTAP_ENCAP_UNKNOWN;
569 }
570
571
572 int libpcap_open(wtap *wth, int *err, gchar **err_info)
573 {
574         int bytes_read;
575         guint32 magic;
576         struct pcap_hdr hdr;
577         gboolean byte_swapped;
578         gboolean modified;
579         gboolean aix;
580         int file_encap;
581
582         /* Read in the number that should be at the start of a "libpcap" file */
583         errno = WTAP_ERR_CANT_READ;
584         bytes_read = file_read(&magic, 1, sizeof magic, wth->fh);
585         if (bytes_read != sizeof magic) {
586                 *err = file_error(wth->fh);
587                 if (*err != 0)
588                         return -1;
589                 return 0;
590         }
591         wth->data_offset += sizeof magic;
592
593         switch (magic) {
594
595         case PCAP_MAGIC:
596                 /* Host that wrote it has our byte order, and was running
597                    a program using either standard or ss990417 libpcap. */
598                 byte_swapped = FALSE;
599                 modified = FALSE;
600                 break;
601
602         case PCAP_MODIFIED_MAGIC:
603                 /* Host that wrote it has our byte order, and was running
604                    a program using either ss990915 or ss991029 libpcap. */
605                 byte_swapped = FALSE;
606                 modified = TRUE;
607                 break;
608
609         case PCAP_SWAPPED_MAGIC:
610                 /* Host that wrote it has a byte order opposite to ours,
611                    and was running a program using either standard or
612                    ss990417 libpcap. */
613                 byte_swapped = TRUE;
614                 modified = FALSE;
615                 break;
616
617         case PCAP_SWAPPED_MODIFIED_MAGIC:
618                 /* Host that wrote it out has a byte order opposite to
619                    ours, and was running a program using either ss990915
620                    or ss991029 libpcap. */
621                 byte_swapped = TRUE;
622                 modified = TRUE;
623                 break;
624
625         default:
626                 /* Not a "libpcap" type we know about. */
627                 return 0;
628         }
629
630         /* Read the rest of the header. */
631         errno = WTAP_ERR_CANT_READ;
632         bytes_read = file_read(&hdr, 1, sizeof hdr, wth->fh);
633         if (bytes_read != sizeof hdr) {
634                 *err = file_error(wth->fh);
635                 if (*err != 0)
636                         return -1;
637                 return 0;
638         }
639         wth->data_offset += sizeof hdr;
640
641         if (byte_swapped) {
642                 /* Byte-swap the header fields about which we care. */
643                 hdr.version_major = BSWAP16(hdr.version_major);
644                 hdr.version_minor = BSWAP16(hdr.version_minor);
645                 hdr.snaplen = BSWAP32(hdr.snaplen);
646                 hdr.network = BSWAP32(hdr.network);
647         }
648         if (hdr.version_major < 2) {
649                 /* We only support version 2.0 and later. */
650                 *err = WTAP_ERR_UNSUPPORTED;
651                 *err_info = g_strdup_printf("pcap: major version %u unsupported",
652                     hdr.version_major);
653                 return -1;
654         }
655
656         /*
657          * AIX's non-standard tcpdump uses a minor version number of 2.
658          * Unfortunately, older versions of libpcap might have used
659          * that as well.
660          *
661          * The AIX libpcap uses RFC 1573 ifType values rather than
662          * DLT_ values in the header; the ifType values for LAN devices
663          * are:
664          *
665          *      Ethernet        6
666          *      Token Ring      9
667          *      FDDI            15
668          *
669          * which correspond to DLT_IEEE802 (used for Token Ring),
670          * DLT_PPP, and DLT_SLIP_BSDOS, respectively.  The ifType value
671          * for a loopback interface is 24, which currently isn't
672          * used by any version of libpcap I know about (and, as
673          * tcpdump.org are assigning DLT_ values above 100, and
674          * NetBSD started assigning values starting at 50, and
675          * the values chosen by other libpcaps appear to stop at
676          * 19, it's probably not going to be used by any libpcap
677          * in the future).
678          *
679          * We shall assume that if the minor version number is 2, and
680          * the network type is 6, 9, 15, or 24, that it's AIX libpcap.
681          *
682          * I'm assuming those older versions of libpcap didn't
683          * use DLT_IEEE802 for Token Ring, and didn't use DLT_SLIP_BSDOS
684          * as that came later.  It may have used DLT_PPP, however, in
685          * which case we're out of luck; we assume it's Token Ring
686          * in AIX libpcap rather than PPP in standard libpcap, as
687          * you're probably more likely to be handing an AIX libpcap
688          * token-ring capture than an old (pre-libpcap 0.4) PPP capture
689          * to Ethereal.
690          */
691         aix = FALSE;    /* assume it's not AIX */
692         if (hdr.version_major == 2 && hdr.version_minor == 2) {
693                 switch (hdr.network) {
694
695                 case 6:
696                         hdr.network = 1;        /* DLT_EN10MB, Ethernet */
697                         aix = TRUE;
698                         break;
699
700                 case 9:
701                         hdr.network = 6;        /* DLT_IEEE802, Token Ring */
702                         aix = TRUE;
703                         break;
704
705                 case 15:
706                         hdr.network = 10;       /* DLT_FDDI, FDDI */
707                         aix = TRUE;
708                         break;
709
710                 case 24:
711                         hdr.network = 0;        /* DLT_NULL, loopback */
712                         aix = TRUE;
713                         break;
714                 }
715         }
716
717         /*
718          * We treat a DLT_ value of 13 specially - it appears that in
719          * Nokia libpcap format, it's some form of ATM with what I
720          * suspect is a pseudo-header (even though Nokia's IPSO is
721          * based on FreeBSD, which #defines DLT_SLIP_BSDOS as 13).
722          *
723          * We don't yet know whether this is a Nokia capture, so if
724          * "wtap_pcap_encap_to_wtap_encap()" returned WTAP_ENCAP_UNKNOWN
725          * but "hdr.network" is 13, we don't treat that as an error yet.
726          */
727         file_encap = wtap_pcap_encap_to_wtap_encap(hdr.network);
728         if (file_encap == WTAP_ENCAP_UNKNOWN && hdr.network != 13) {
729                 *err = WTAP_ERR_UNSUPPORTED_ENCAP;
730                 *err_info = g_strdup_printf("pcap: network type %u unknown or unsupported",
731                     hdr.network);
732                 return -1;
733         }
734
735         /* This is a libpcap file */
736         wth->capture.pcap = g_malloc(sizeof(libpcap_t));
737         wth->capture.pcap->byte_swapped = byte_swapped;
738         wth->capture.pcap->version_major = hdr.version_major;
739         wth->capture.pcap->version_minor = hdr.version_minor;
740         wth->subtype_read = libpcap_read;
741         wth->subtype_seek_read = libpcap_seek_read;
742         wth->subtype_close = libpcap_close;
743         wth->file_encap = file_encap;
744         wth->snapshot_length = hdr.snaplen;
745
746         /* In file format version 2.3, the order of the "incl_len" and
747            "orig_len" fields in the per-packet header was reversed,
748            in order to match the BPF header layout.
749
750            Therefore, in files with versions prior to that, we must swap
751            those two fields.
752
753            Unfortunately, some files were, according to a comment in the
754            "libpcap" source, written with version 2.3 in their headers
755            but without the interchanged fields, so if "incl_len" is
756            greater than "orig_len" - which would make no sense - we
757            assume that we need to swap them in version 2.3 files
758            as well.
759
760            In addition, DG/UX's tcpdump uses version 543.0, and writes
761            the two fields in the pre-2.3 order. */
762         switch (hdr.version_major) {
763
764         case 2:
765                 if (hdr.version_minor < 3)
766                         wth->capture.pcap->lengths_swapped = SWAPPED;
767                 else if (hdr.version_minor == 3)
768                         wth->capture.pcap->lengths_swapped = MAYBE_SWAPPED;
769                 else
770                         wth->capture.pcap->lengths_swapped = NOT_SWAPPED;
771                 break;
772
773         case 543:
774                 wth->capture.pcap->lengths_swapped = SWAPPED;
775                 break;
776
777         default:
778                 wth->capture.pcap->lengths_swapped = NOT_SWAPPED;
779                 break;
780         }
781
782         /*
783          * Is this AIX format?
784          */
785         if (aix) {
786                 /*
787                  * Yes.  Skip all the tests for other mutant formats.
788                  */
789                 wth->file_type = WTAP_FILE_PCAP_AIX;
790                 return 1;
791         }
792
793         /*
794          * No.  Let's look at the header for the first record,
795          * and see if, interpreting it as a standard header (if the
796          * magic number was standard) or a modified header (if the
797          * magic number was modified), the position where it says the
798          * header for the *second* record is contains a corrupted header.
799          *
800          * If so, then:
801          *
802          *      If this file had the standard magic number, it may be
803          *      an ss990417 capture file - in that version of Alexey's
804          *      patch, the packet header format was changed but the
805          *      magic number wasn't, and, alas, Red Hat appear to have
806          *      picked up that version of the patch for RH 6.1, meaning
807          *      RH 6.1 has a tcpdump that writes out files that can't
808          *      be read by any software that expects non-modified headers
809          *      if the magic number isn't the modified magic number (e.g.,
810          *      any normal version of tcpdump, and Ethereal if we don't
811          *      do this gross heuristic).
812          *
813          *      If this file had the modified magic number, it may be
814          *      an ss990915 capture file - in that version of Alexey's
815          *      patch, the magic number was changed, but the record
816          *      header had some extra fields, and, alas, SuSE appear
817          *      to have picked up that version of the patch for SuSE
818          *      6.3, meaning that programs expecting the standard per-
819          *      packet header in captures with the modified magic number
820          *      can't read dumps from its tcpdump.
821          *
822          * Oh, and if it has the standard magic number, it might, instead,
823          * be a Nokia libpcap file, so we may need to try that if
824          * neither normal nor ss990417 headers work.
825          */
826         if (modified) {
827                 /*
828                  * Well, we have the magic number from Alexey's
829                  * later two patches.
830                  *
831                  * Try ss991029, the last of his patches, first.
832                  */
833                 wth->file_type = WTAP_FILE_PCAP_SS991029;
834                 switch (libpcap_try(wth, err)) {
835
836                 case BAD_READ:
837                         /*
838                          * Well, we couldn't even read it.
839                          * Give up.
840                          */
841                         g_free(wth->capture.pcap);
842                         return -1;
843
844                 case THIS_FORMAT:
845                         /*
846                          * Well, it looks as if it might be 991029.
847                          * Put the seek pointer back, and return success.
848                          */
849                         if (file_seek(wth->fh, wth->data_offset, SEEK_SET, err) == -1) {
850                                 g_free(wth->capture.pcap);
851                                 return -1;
852                         }
853                         return 1;
854
855                 case OTHER_FORMAT:
856                         /*
857                          * Try the next format.
858                          */
859                         break;
860                 }
861
862                 /*
863                  * Well, it's not completely unreadable,
864                  * but it's not ss991029.  Try ss990915;
865                  * there are no other types to try after that,
866                  * so we put the seek pointer back and treat
867                  * it as 990915.
868                  */
869                 wth->file_type = WTAP_FILE_PCAP_SS990915;
870                 if (file_seek(wth->fh, wth->data_offset, SEEK_SET, err) == -1) {
871                         g_free(wth->capture.pcap);
872                         return -1;
873                 }
874         } else {
875                 /*
876                  * Well, we have the standard magic number.
877                  *
878                  * Try the standard format first.
879                  */
880                 wth->file_type = WTAP_FILE_PCAP;
881                 switch (libpcap_try(wth, err)) {
882
883                 case BAD_READ:
884                         /*
885                          * Well, we couldn't even read it.
886                          * Give up.
887                          */
888                         g_free(wth->capture.pcap);
889                         return -1;
890
891                 case THIS_FORMAT:
892                         /*
893                          * Well, it looks as if it might be a standard
894                          * libpcap file.
895                          * Put the seek pointer back, and return success.
896                          */
897                         if (file_seek(wth->fh, wth->data_offset, SEEK_SET, err) == -1) {
898                                 g_free(wth->capture.pcap);
899                                 return -1;
900                         }
901                         return 1;
902
903                 case OTHER_FORMAT:
904                         /*
905                          * Try the next format.
906                          */
907                         break;
908                 }
909
910                 /*
911                  * Well, it's not completely unreadable, but it's not
912                  * a standard file.  Put the seek pointer back and try
913                  * ss990417.
914                  */
915                 wth->file_type = WTAP_FILE_PCAP_SS990417;
916                 if (file_seek(wth->fh, wth->data_offset, SEEK_SET, err) == -1) {
917                         g_free(wth->capture.pcap);
918                         return -1;
919                 }
920                 switch (libpcap_try(wth, err)) {
921
922                 case BAD_READ:
923                         /*
924                          * Well, we couldn't even read it.
925                          * Give up.
926                          */
927                         g_free(wth->capture.pcap);
928                         return -1;
929
930                 case THIS_FORMAT:
931                         /*
932                          * Well, it looks as if it might be ss990417.
933                          * Put the seek pointer back, and return success.
934                          */
935                         if (file_seek(wth->fh, wth->data_offset, SEEK_SET, err) == -1) {
936                                 g_free(wth->capture.pcap);
937                                 return -1;
938                         }
939                         return 1;
940
941                 case OTHER_FORMAT:
942                         /*
943                          * Try the next format.
944                          */
945                         break;
946                 }
947
948                 /*
949                  * Well, it's not completely unreadable,
950                  * but it's not a standard file *nor* is it ss990417.
951                  * Try it as a Nokia file; there are no other types
952                  * to try after that, so we put the seek pointer back
953                  * and treat it as a Nokia file.
954                  */
955                 wth->file_type = WTAP_FILE_PCAP_NOKIA;
956                 if (file_seek(wth->fh, wth->data_offset, SEEK_SET, err) == -1) {
957                         g_free(wth->capture.pcap);
958                         return -1;
959                 }
960         }
961
962         if (hdr.network == 13) {
963                 /*
964                  * OK, if this was a Nokia capture, make it
965                  * WTAP_ENCAP_ATM_PDUS, otherwise return
966                  * an error.
967                  */
968                 if (wth->file_type == WTAP_FILE_PCAP_NOKIA)
969                         wth->file_encap = WTAP_ENCAP_ATM_PDUS;
970                 else {
971                         *err = WTAP_ERR_UNSUPPORTED_ENCAP;
972                         *err_info = g_strdup_printf("pcap: network type %u unknown or unsupported",
973                             hdr.network);
974                         return -1;
975                 }
976         }
977
978         return 1;
979 }
980
981 /* Try to read the first two records of the capture file. */
982 static libpcap_try_t libpcap_try(wtap *wth, int *err)
983 {
984         /*
985          * pcaprec_ss990915_hdr is the largest header type.
986          */
987         struct pcaprec_ss990915_hdr first_rec_hdr, second_rec_hdr;
988
989         /*
990          * Attempt to read the first record's header.
991          */
992         if (libpcap_read_header(wth, err, NULL, &first_rec_hdr) == -1) {
993                 if (*err == 0 || *err == WTAP_ERR_SHORT_READ) {
994                         /*
995                          * EOF or short read - assume the file is in this
996                          * format.
997                          * When our client tries to read the first packet
998                          * they will presumably get the same EOF or short
999                          * read.
1000                          */
1001                         return THIS_FORMAT;
1002                 }
1003
1004                 if (*err == WTAP_ERR_BAD_RECORD) {
1005                         /*
1006                          * The first record is bogus, so this is probably
1007                          * a corrupt file.  Assume the file is in this
1008                          * format.  When our client tries to read the
1009                          * first packet they will presumably get the
1010                          * same bogus record.
1011                          */
1012                         return THIS_FORMAT;
1013                 }
1014
1015                 /*
1016                  * Some other error, e.g. an I/O error; just give up.
1017                  */
1018                 return BAD_READ;
1019         }
1020
1021         /*
1022          * Now skip over the first record's data, under the assumption
1023          * that the header is sane.
1024          */
1025         if (file_seek(wth->fh, first_rec_hdr.hdr.incl_len, SEEK_CUR, err) == -1)
1026                 return BAD_READ;
1027
1028         /*
1029          * Now attempt to read the second record's header.
1030          */
1031         if (libpcap_read_header(wth, err, NULL, &second_rec_hdr) == -1) {
1032                 if (*err == 0 || *err == WTAP_ERR_SHORT_READ) {
1033                         /*
1034                          * EOF or short read - assume the file is in this
1035                          * format.
1036                          * When our client tries to read the second packet
1037                          * they will presumably get the same EOF or short
1038                          * read.
1039                          */
1040                         return THIS_FORMAT;
1041                 }
1042
1043                 if (*err == WTAP_ERR_BAD_RECORD) {
1044                         /*
1045                          * The second record is bogus; maybe it's a
1046                          * Capture File From Hell, and what looks like
1047                          * the "header" of the next packet is actually
1048                          * random junk from the middle of a packet.
1049                          * Try the next format; if we run out of formats,
1050                          * it probably *is* a corrupt file.
1051                          */
1052                         return OTHER_FORMAT;
1053                 }
1054
1055                 /*
1056                  * Some other error, e.g. an I/O error; just give up.
1057                  */
1058                 return BAD_READ;
1059         }
1060
1061         /*
1062          * OK, the first two records look OK; assume this is the
1063          * right format.
1064          */
1065         return THIS_FORMAT;
1066 }
1067
1068 /* Read the next packet */
1069 static gboolean libpcap_read(wtap *wth, int *err, gchar **err_info,
1070     long *data_offset)
1071 {
1072         struct pcaprec_ss990915_hdr hdr;
1073         guint packet_size;
1074         guint orig_size;
1075         int bytes_read;
1076         guchar fddi_padding[3];
1077
1078         bytes_read = libpcap_read_header(wth, err, err_info, &hdr);
1079         if (bytes_read == -1) {
1080                 /*
1081                  * We failed to read the header.
1082                  */
1083                 return FALSE;
1084         }
1085
1086         wth->data_offset += bytes_read;
1087         packet_size = hdr.hdr.incl_len;
1088         orig_size = hdr.hdr.orig_len;
1089
1090         /*
1091          * AIX appears to put 3 bytes of padding in front of FDDI
1092          * frames; strip that crap off.
1093          */
1094         if (wth->file_type == WTAP_FILE_PCAP_AIX &&
1095             (wth->file_encap == WTAP_ENCAP_FDDI ||
1096              wth->file_encap == WTAP_ENCAP_FDDI_BITSWAPPED)) {
1097                 /*
1098                  * The packet size is really a record size and includes
1099                  * the padding.
1100                  */
1101                 packet_size -= 3;
1102                 orig_size -= 3;
1103                 wth->data_offset += 3;
1104
1105                 /*
1106                  * Read the padding.
1107                  */
1108                 if (!libpcap_read_rec_data(wth->fh, fddi_padding, 3, err))
1109                         return FALSE;   /* Read error */
1110         }
1111
1112         *data_offset = wth->data_offset;
1113
1114         /*
1115          * If this is an ATM packet, the first four bytes are the
1116          * direction of the packet (transmit/receive), the VPI, and
1117          * the VCI; read them and generate the pseudo-header from
1118          * them.
1119          */
1120         switch (wth->file_encap) {
1121
1122         case WTAP_ENCAP_ATM_PDUS:
1123                 if (wth->file_type == WTAP_FILE_PCAP_NOKIA) {
1124                         /*
1125                          * Nokia IPSO ATM.
1126                          */
1127                         if (packet_size < sizeof (struct nokiaatm_hdr)) {
1128                                 /*
1129                                  * Uh-oh, the packet isn't big enough to even
1130                                  * have a pseudo-header.
1131                                  */
1132                                 *err = WTAP_ERR_BAD_RECORD;
1133                                 *err_info = g_strdup_printf("libpcap: Nokia IPSO ATM file has a %u-byte packet, too small to have even an ATM pseudo-header\n",
1134                                     packet_size);
1135                                 return FALSE;
1136                         }
1137                         if (!libpcap_read_nokiaatm_pseudoheader(wth->fh,
1138                             &wth->pseudo_header, err))
1139                                 return FALSE;   /* Read error */
1140
1141                         /*
1142                          * Don't count the pseudo-header as part of the
1143                          * packet.
1144                          */
1145                         orig_size -= sizeof (struct nokiaatm_hdr);
1146                         packet_size -= sizeof (struct nokiaatm_hdr);
1147                         wth->data_offset += sizeof (struct nokiaatm_hdr);
1148                 } else {
1149                         /*
1150                          * SunATM.
1151                          */
1152                         if (packet_size < sizeof (struct sunatm_hdr)) {
1153                                 /*
1154                                  * Uh-oh, the packet isn't big enough to even
1155                                  * have a pseudo-header.
1156                                  */
1157                                 *err = WTAP_ERR_BAD_RECORD;
1158                                 *err_info = g_strdup_printf("libpcap: SunATM file has a %u-byte packet, too small to have even an ATM pseudo-header\n",
1159                                     packet_size);
1160                                 return FALSE;
1161                         }
1162                         if (!libpcap_read_sunatm_pseudoheader(wth->fh,
1163                             &wth->pseudo_header, err))
1164                                 return FALSE;   /* Read error */
1165
1166                         /*
1167                          * Don't count the pseudo-header as part of the
1168                          * packet.
1169                          */
1170                         orig_size -= sizeof (struct sunatm_hdr);
1171                         packet_size -= sizeof (struct sunatm_hdr);
1172                         wth->data_offset += sizeof (struct sunatm_hdr);
1173                 }
1174                 break;
1175
1176         case WTAP_ENCAP_ETHERNET:
1177                 /*
1178                  * We don't know whether there's an FCS in this frame or not.
1179                  */
1180                 wth->pseudo_header.eth.fcs_len = -1;
1181                 break;
1182
1183         case WTAP_ENCAP_IEEE_802_11:
1184         case WTAP_ENCAP_PRISM_HEADER:
1185         case WTAP_ENCAP_IEEE_802_11_WLAN_RADIOTAP:
1186         case WTAP_ENCAP_IEEE_802_11_WLAN_AVS:
1187                 /*
1188                  * We don't know whether there's an FCS in this frame or not.
1189                  * XXX - are there any OSes where the capture mechanism
1190                  * supplies an FCS?
1191                  */
1192                 wth->pseudo_header.ieee_802_11.fcs_len = -1;
1193                 break;
1194
1195         case WTAP_ENCAP_IRDA:
1196                 if (packet_size < sizeof (struct irda_sll_hdr)) {
1197                         /*
1198                          * Uh-oh, the packet isn't big enough to even
1199                          * have a pseudo-header.
1200                          */
1201                         *err = WTAP_ERR_BAD_RECORD;
1202                         *err_info = g_strdup_printf("libpcap: IrDA file has a %u-byte packet, too small to have even an IrDA pseudo-header\n",
1203                             packet_size);
1204                         return FALSE;
1205                 }
1206                 if (!libpcap_read_irda_pseudoheader(wth->fh, &wth->pseudo_header,
1207                     err, err_info))
1208                         return FALSE;   /* Read error */
1209
1210                 /*
1211                  * Don't count the pseudo-header as part of the packet.
1212                  */
1213                 orig_size -= sizeof (struct irda_sll_hdr);
1214                 packet_size -= sizeof (struct irda_sll_hdr);
1215                 wth->data_offset += sizeof (struct irda_sll_hdr);
1216                 break;
1217         }
1218
1219         buffer_assure_space(wth->frame_buffer, packet_size);
1220         if (!libpcap_read_rec_data(wth->fh, buffer_start_ptr(wth->frame_buffer),
1221             packet_size, err))
1222                 return FALSE;   /* Read error */
1223         wth->data_offset += packet_size;
1224
1225         wth->phdr.ts.tv_sec = hdr.hdr.ts_sec;
1226         wth->phdr.ts.tv_usec = hdr.hdr.ts_usec;
1227         wth->phdr.caplen = packet_size;
1228         wth->phdr.len = orig_size;
1229
1230         if (wth->file_encap == WTAP_ENCAP_ATM_PDUS) {
1231                 if (wth->file_type == WTAP_FILE_PCAP_NOKIA) {
1232                         /*
1233                          * Nokia IPSO ATM.
1234                          *
1235                          * Guess the traffic type based on the packet
1236                          * contents.
1237                          */
1238                         atm_guess_traffic_type(buffer_start_ptr(wth->frame_buffer),
1239                             wth->phdr.caplen, &wth->pseudo_header);
1240                 } else {
1241                         /*
1242                          * SunATM.
1243                          *
1244                          * If this is ATM LANE traffic, try to guess what
1245                          * type of LANE traffic it is based on the packet
1246                          * contents.
1247                          */
1248                         if (wth->pseudo_header.atm.type == TRAF_LANE) {
1249                                 atm_guess_lane_type(buffer_start_ptr(wth->frame_buffer),
1250                                     wth->phdr.caplen, &wth->pseudo_header);
1251                         }
1252                 }
1253         }
1254
1255         return TRUE;
1256 }
1257
1258 static gboolean
1259 libpcap_seek_read(wtap *wth, long seek_off,
1260     union wtap_pseudo_header *pseudo_header, guchar *pd, int length,
1261     int *err, gchar **err_info)
1262 {
1263         if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
1264                 return FALSE;
1265
1266         switch (wth->file_encap) {
1267
1268         case WTAP_ENCAP_ATM_PDUS:
1269                 if (wth->file_type == WTAP_FILE_PCAP_NOKIA) {
1270                         /*
1271                          * Nokia IPSO ATM.
1272                          */
1273                         if (!libpcap_read_nokiaatm_pseudoheader(wth->random_fh,
1274                             pseudo_header, err)) {
1275                                 /* Read error */
1276                                 return FALSE;
1277                         }
1278                 } else {
1279                         /*
1280                          * SunATM.
1281                          */
1282                         if (!libpcap_read_sunatm_pseudoheader(wth->random_fh,
1283                             pseudo_header, err)) {
1284                                 /* Read error */
1285                                 return FALSE;
1286                         }
1287                 }
1288                 break;
1289
1290         case WTAP_ENCAP_ETHERNET:
1291                 /*
1292                  * We don't know whether there's an FCS in this frame or not.
1293                  */
1294                 pseudo_header->eth.fcs_len = -1;
1295                 break;
1296
1297         case WTAP_ENCAP_IEEE_802_11:
1298         case WTAP_ENCAP_PRISM_HEADER:
1299         case WTAP_ENCAP_IEEE_802_11_WLAN_RADIOTAP:
1300         case WTAP_ENCAP_IEEE_802_11_WLAN_AVS:
1301                 /*
1302                  * We don't know whether there's an FCS in this frame or not.
1303                  * XXX - are there any OSes where the capture mechanism
1304                  * supplies an FCS?
1305                  */
1306                 pseudo_header->ieee_802_11.fcs_len = -1;
1307                 break;
1308
1309         case WTAP_ENCAP_IRDA:
1310                 if (!libpcap_read_irda_pseudoheader(wth->random_fh, pseudo_header,
1311                     err, err_info)) {
1312                         /* Read error */
1313                         return FALSE;
1314                 }
1315                 break;
1316         }
1317
1318         /*
1319          * Read the packet data.
1320          */
1321         if (!libpcap_read_rec_data(wth->random_fh, pd, length, err))
1322                 return FALSE;   /* failed */
1323
1324         if (wth->file_encap == WTAP_ENCAP_ATM_PDUS) {
1325                 if (wth->file_type == WTAP_FILE_PCAP_NOKIA) {
1326                         /*
1327                          * Nokia IPSO ATM.
1328                          *
1329                          * Guess the traffic type based on the packet
1330                          * contents.
1331                          */
1332                         atm_guess_traffic_type(pd, length, pseudo_header);
1333                 } else {
1334                         /*
1335                          * SunATM.
1336                          *
1337                          * If this is ATM LANE traffic, try to guess what
1338                          * type of LANE traffic it is based on the packet
1339                          * contents.
1340                          */
1341                         if (pseudo_header->atm.type == TRAF_LANE)
1342                                 atm_guess_lane_type(pd, length, pseudo_header);
1343                 }
1344         }
1345         return TRUE;
1346 }
1347
1348 /* Read the header of the next packet.
1349
1350    Return -1 on an error, or the number of bytes of header read on success. */
1351 static int libpcap_read_header(wtap *wth, int *err, gchar **err_info,
1352     struct pcaprec_ss990915_hdr *hdr)
1353 {
1354         int     bytes_to_read, bytes_read;
1355
1356         /* Read record header. */
1357         errno = WTAP_ERR_CANT_READ;
1358         switch (wth->file_type) {
1359
1360         case WTAP_FILE_PCAP:
1361         case WTAP_FILE_PCAP_AIX:
1362                 bytes_to_read = sizeof (struct pcaprec_hdr);
1363                 break;
1364
1365         case WTAP_FILE_PCAP_SS990417:
1366         case WTAP_FILE_PCAP_SS991029:
1367                 bytes_to_read = sizeof (struct pcaprec_modified_hdr);
1368                 break;
1369
1370         case WTAP_FILE_PCAP_SS990915:
1371                 bytes_to_read = sizeof (struct pcaprec_ss990915_hdr);
1372                 break;
1373
1374         case WTAP_FILE_PCAP_NOKIA:
1375                 bytes_to_read = sizeof (struct pcaprec_nokia_hdr);
1376                 break;
1377
1378         default:
1379                 g_assert_not_reached();
1380                 bytes_to_read = 0;
1381         }
1382         bytes_read = file_read(hdr, 1, bytes_to_read, wth->fh);
1383         if (bytes_read != bytes_to_read) {
1384                 *err = file_error(wth->fh);
1385                 if (*err == 0 && bytes_read != 0) {
1386                         *err = WTAP_ERR_SHORT_READ;
1387                 }
1388                 return -1;
1389         }
1390
1391         adjust_header(wth, &hdr->hdr);
1392
1393         if (hdr->hdr.incl_len > WTAP_MAX_PACKET_SIZE) {
1394                 /*
1395                  * Probably a corrupt capture file; return an error,
1396                  * so that our caller doesn't blow up trying to allocate
1397                  * space for an immensely-large packet, and so that
1398                  * the code to try to guess what type of libpcap file
1399                  * this is can tell when it's not the type we're guessing
1400                  * it is.
1401                  */
1402                 *err = WTAP_ERR_BAD_RECORD;
1403                 if (err_info != NULL) {
1404                         *err_info = g_strdup_printf("pcap: File has %u-byte packet, bigger than maximum of %u",
1405                             hdr->hdr.incl_len, WTAP_MAX_PACKET_SIZE);
1406                 }
1407                 return -1;
1408         }
1409
1410         if (hdr->hdr.orig_len > WTAP_MAX_PACKET_SIZE) {
1411                 /*
1412                  * Probably a corrupt capture file; return an error,
1413                  * so that our caller doesn't blow up trying to
1414                  * cope with a huge "real" packet length, and so that
1415                  * the code to try to guess what type of libpcap file
1416                  * this is can tell when it's not the type we're guessing
1417                  * it is.
1418                  */
1419                 *err = WTAP_ERR_BAD_RECORD;
1420                 if (err_info != NULL) {
1421                         *err_info = g_strdup_printf("pcap: File has %u-byte packet, bigger than maximum of %u",
1422                             hdr->hdr.orig_len, WTAP_MAX_PACKET_SIZE);
1423                 }
1424                 return -1;
1425         }
1426
1427         return bytes_read;
1428 }
1429
1430 static void
1431 adjust_header(wtap *wth, struct pcaprec_hdr *hdr)
1432 {
1433         guint32 temp;
1434
1435         if (wth->capture.pcap->byte_swapped) {
1436                 /* Byte-swap the record header fields. */
1437                 hdr->ts_sec = BSWAP32(hdr->ts_sec);
1438                 hdr->ts_usec = BSWAP32(hdr->ts_usec);
1439                 hdr->incl_len = BSWAP32(hdr->incl_len);
1440                 hdr->orig_len = BSWAP32(hdr->orig_len);
1441         }
1442
1443         /* If this is AIX, convert the time stamp from seconds/nanoseconds
1444            to seconds/microseconds.  */
1445         if (wth->file_type == WTAP_FILE_PCAP_AIX)
1446                 hdr->ts_usec = hdr->ts_usec/1000;
1447
1448         /* Swap the "incl_len" and "orig_len" fields, if necessary. */
1449         switch (wth->capture.pcap->lengths_swapped) {
1450
1451         case NOT_SWAPPED:
1452                 break;
1453
1454         case MAYBE_SWAPPED:
1455                 if (hdr->incl_len <= hdr->orig_len) {
1456                         /*
1457                          * The captured length is <= the actual length,
1458                          * so presumably they weren't swapped.
1459                          */
1460                         break;
1461                 }
1462                 /* FALLTHROUGH */
1463
1464         case SWAPPED:
1465                 temp = hdr->orig_len;
1466                 hdr->orig_len = hdr->incl_len;
1467                 hdr->incl_len = temp;
1468                 break;
1469         }
1470 }
1471
1472 static void
1473 libpcap_get_sunatm_pseudoheader(const struct sunatm_hdr *atm_phdr,
1474     union wtap_pseudo_header *pseudo_header)
1475 {
1476         guint8  vpi;
1477         guint16 vci;
1478
1479         vpi = atm_phdr->vpi;
1480         vci = pntohs(&atm_phdr->vci);
1481
1482         switch (atm_phdr->flags & 0x0F) {
1483
1484         case 0x01:      /* LANE */
1485                 pseudo_header->atm.aal = AAL_5;
1486                 pseudo_header->atm.type = TRAF_LANE;
1487                 break;
1488
1489         case 0x02:      /* RFC 1483 LLC multiplexed traffic */
1490                 pseudo_header->atm.aal = AAL_5;
1491                 pseudo_header->atm.type = TRAF_LLCMX;
1492                 break;
1493
1494         case 0x05:      /* ILMI */
1495                 pseudo_header->atm.aal = AAL_5;
1496                 pseudo_header->atm.type = TRAF_ILMI;
1497                 break;
1498
1499         case 0x06:      /* Q.2931 */
1500                 pseudo_header->atm.aal = AAL_SIGNALLING;
1501                 pseudo_header->atm.type = TRAF_UNKNOWN;
1502                 break;
1503
1504         case 0x03:      /* MARS (RFC 2022) */
1505                 pseudo_header->atm.aal = AAL_5;
1506                 pseudo_header->atm.type = TRAF_UNKNOWN;
1507                 break;
1508
1509         case 0x04:      /* IFMP (Ipsilon Flow Management Protocol; see RFC 1954) */
1510                 pseudo_header->atm.aal = AAL_5;
1511                 pseudo_header->atm.type = TRAF_UNKNOWN; /* XXX - TRAF_IPSILON? */
1512                 break;
1513
1514         default:
1515                 /*
1516                  * Assume it's AAL5, unless it's VPI 0 and VCI 5, in which
1517                  * case assume it's AAL_SIGNALLING; we know nothing more
1518                  * about it.
1519                  *
1520                  * XXX - is this necessary?  Or are we guaranteed that
1521                  * all signalling traffic has a type of 0x06?
1522                  *
1523                  * XXX - is this guaranteed to be AAL5?  Or, if the type is
1524                  * 0x00 ("raw"), might it be non-AAL5 traffic?
1525                  */
1526                 if (vpi == 0 && vci == 5)
1527                         pseudo_header->atm.aal = AAL_SIGNALLING;
1528                 else
1529                         pseudo_header->atm.aal = AAL_5;
1530                 pseudo_header->atm.type = TRAF_UNKNOWN;
1531                 break;
1532         }
1533         pseudo_header->atm.subtype = TRAF_ST_UNKNOWN;
1534
1535         pseudo_header->atm.vpi = vpi;
1536         pseudo_header->atm.vci = vci;
1537         pseudo_header->atm.channel = (atm_phdr->flags & 0x80) ? 0 : 1;
1538
1539         /* We don't have this information */
1540         pseudo_header->atm.flags = 0;
1541         pseudo_header->atm.cells = 0;
1542         pseudo_header->atm.aal5t_u2u = 0;
1543         pseudo_header->atm.aal5t_len = 0;
1544         pseudo_header->atm.aal5t_chksum = 0;
1545 }
1546
1547 static gboolean
1548 libpcap_read_sunatm_pseudoheader(FILE_T fh,
1549     union wtap_pseudo_header *pseudo_header, int *err)
1550 {
1551         struct sunatm_hdr atm_phdr;
1552         int     bytes_read;
1553
1554         errno = WTAP_ERR_CANT_READ;
1555         bytes_read = file_read(&atm_phdr, 1, sizeof (struct sunatm_hdr), fh);
1556         if (bytes_read != sizeof (struct sunatm_hdr)) {
1557                 *err = file_error(fh);
1558                 if (*err == 0)
1559                         *err = WTAP_ERR_SHORT_READ;
1560                 return FALSE;
1561         }
1562
1563         libpcap_get_sunatm_pseudoheader(&atm_phdr, pseudo_header);
1564
1565         return TRUE;
1566 }
1567
1568 static gboolean
1569 libpcap_read_nokiaatm_pseudoheader(FILE_T fh,
1570     union wtap_pseudo_header *pseudo_header, int *err)
1571 {
1572         struct nokiaatm_hdr atm_phdr;
1573         int     bytes_read;
1574         guint8  vpi;
1575         guint16 vci;
1576
1577         errno = WTAP_ERR_CANT_READ;
1578         bytes_read = file_read(&atm_phdr, 1, sizeof (struct nokiaatm_hdr), fh);
1579         if (bytes_read != sizeof (struct nokiaatm_hdr)) {
1580                 *err = file_error(fh);
1581                 if (*err == 0)
1582                         *err = WTAP_ERR_SHORT_READ;
1583                 return FALSE;
1584         }
1585
1586         vpi = atm_phdr.vpi;
1587         vci = pntohs(&atm_phdr.vci);
1588
1589         pseudo_header->atm.vpi = vpi;
1590         pseudo_header->atm.vci = vci;
1591         pseudo_header->atm.channel = (atm_phdr.flags & 0x80) ? 0 : 1;
1592
1593         /* We don't have this information */
1594         pseudo_header->atm.flags = 0;
1595         pseudo_header->atm.cells = 0;
1596         pseudo_header->atm.aal5t_u2u = 0;
1597         pseudo_header->atm.aal5t_len = 0;
1598         pseudo_header->atm.aal5t_chksum = 0;
1599
1600         return TRUE;
1601 }
1602
1603 static gboolean
1604 libpcap_get_irda_pseudoheader(const struct irda_sll_hdr *irda_phdr,
1605     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info)
1606 {
1607         if (pntohs(&irda_phdr->sll_protocol) != 0x0017) {
1608                 *err = WTAP_ERR_BAD_RECORD;
1609                 if (err_info != NULL)
1610                         *err_info = g_strdup("libpcap: IrDA capture has a packet with an invalid sll_protocol field\n");
1611                 return FALSE;
1612         }
1613
1614         pseudo_header->irda.pkttype = pntohs(&irda_phdr->sll_pkttype);
1615
1616         return TRUE;
1617 }
1618
1619 static gboolean
1620 libpcap_read_irda_pseudoheader(FILE_T fh, union wtap_pseudo_header *pseudo_header,
1621     int *err, gchar **err_info)
1622 {
1623         struct irda_sll_hdr irda_phdr;
1624         int     bytes_read;
1625
1626         errno = WTAP_ERR_CANT_READ;
1627         bytes_read = file_read(&irda_phdr, 1, sizeof (struct irda_sll_hdr), fh);
1628         if (bytes_read != sizeof (struct irda_sll_hdr)) {
1629                 *err = file_error(fh);
1630                 if (*err == 0)
1631                         *err = WTAP_ERR_SHORT_READ;
1632                 return FALSE;
1633         }
1634
1635         return libpcap_get_irda_pseudoheader(&irda_phdr, pseudo_header, err,
1636             err_info);
1637 }
1638
1639 static gboolean
1640 libpcap_read_rec_data(FILE_T fh, guchar *pd, int length, int *err)
1641 {
1642         int     bytes_read;
1643
1644         errno = WTAP_ERR_CANT_READ;
1645         bytes_read = file_read(pd, 1, length, fh);
1646
1647         if (bytes_read != length) {
1648                 *err = file_error(fh);
1649                 if (*err == 0)
1650                         *err = WTAP_ERR_SHORT_READ;
1651                 return FALSE;
1652         }
1653         return TRUE;
1654 }
1655
1656 static void
1657 libpcap_close(wtap *wth)
1658 {
1659         g_free(wth->capture.pcap);
1660 }
1661
1662 static int wtap_wtap_encap_to_pcap_encap(int encap)
1663 {
1664         unsigned int i;
1665
1666         switch (encap) {
1667
1668         case WTAP_ENCAP_FDDI:
1669         case WTAP_ENCAP_FDDI_BITSWAPPED:
1670         case WTAP_ENCAP_NETTL_FDDI:
1671                 /*
1672                  * Special-case WTAP_ENCAP_FDDI and
1673                  * WTAP_ENCAP_FDDI_BITSWAPPED; both of them get mapped
1674                  * to DLT_FDDI (even though that may mean that the bit
1675                  * order in the FDDI MAC addresses is wrong; so it goes
1676                  * - libpcap format doesn't record the byte order,
1677                  * so that's not fixable).
1678                  */
1679                 return 10;      /* that's DLT_FDDI */
1680
1681         case WTAP_ENCAP_PPP_WITH_PHDR:
1682                 /*
1683                  * Also special-case PPP with direction bits; map it to
1684                  * PPP, even though that means that the direction of the
1685                  * packet is lost.
1686                  */
1687                 return 9;
1688
1689         case WTAP_ENCAP_FRELAY_WITH_PHDR:
1690                 /*
1691                  * Do the same with Frame Relay.
1692                  */
1693                 return 107;
1694
1695         case WTAP_ENCAP_IEEE_802_11_WITH_RADIO:
1696                 /*
1697                  * Map this to DLT_IEEE802_11, for now, even though
1698                  * that means the radio information will be lost.
1699                  * Once tcpdump support for the BSD radiotap header
1700                  * is sufficiently widespread, we should probably
1701                  * use that, instead - although we should probably
1702                  * ultimately just have WTAP_ENCAP_IEEE_802_11
1703                  * as the only Wiretap encapsulation for 802.11,
1704                  * and have the pseudo-header include a radiotap-style
1705                  * list of attributes.  If we do that, though, we
1706                  * should probably bypass the regular Wiretap code
1707                  * when writing out packets during a capture, and just
1708                  * do the equivalent of a libpcap write (unfortunately,
1709                  * libpcap doesn't have an "open dump by file descriptor"
1710                  * function, so we can't just use "pcap_dump()"), so
1711                  * that we don't spend cycles mapping from libpcap to
1712                  * Wiretap and then back to libpcap.  (There are other
1713                  * reasons to do that, e.g. to handle AIX libpcap better.)
1714                  */
1715                 return 105;
1716         }
1717
1718         for (i = 0; i < NUM_PCAP_ENCAPS; i++) {
1719                 if (pcap_to_wtap_map[i].wtap_encap_value == encap)
1720                         return pcap_to_wtap_map[i].dlt_value;
1721         }
1722         return -1;
1723 }
1724
1725 #ifdef HAVE_PCAP_H
1726 /*
1727  * Given a Wiretap encapsulation type, and raw packet data and the packet
1728  * header from libpcap, process any pseudo-header in the packet,
1729  * fill in the Wiretap packet header, and return a pointer to the
1730  * beginning of the non-pseudo-header data in the packet.
1731  */
1732 const guchar *
1733 wtap_process_pcap_packet(gint linktype, const struct pcap_pkthdr *phdr,
1734     const guchar *pd, union wtap_pseudo_header *pseudo_header,
1735     struct wtap_pkthdr *whdr, int *err)
1736 {
1737         /* "phdr->ts" may not necessarily be a "struct timeval" - it may
1738            be a "struct bpf_timeval", with member sizes wired to 32
1739            bits - and we may go that way ourselves in the future, so
1740            copy the members individually. */
1741         whdr->ts.tv_sec = phdr->ts.tv_sec;
1742         whdr->ts.tv_usec = phdr->ts.tv_usec;
1743         whdr->caplen = phdr->caplen;
1744         whdr->len = phdr->len;
1745         whdr->pkt_encap = linktype;
1746
1747         /*
1748          * If this is an ATM packet, the first four bytes are the
1749          * direction of the packet (transmit/receive), the VPI, and
1750          * the VCI; read them and generate the pseudo-header from
1751          * them.
1752          */
1753         if (linktype == WTAP_ENCAP_ATM_PDUS) {
1754                 if (whdr->caplen < sizeof (struct sunatm_hdr)) {
1755                         /*
1756                          * Uh-oh, the packet isn't big enough to even
1757                          * have a pseudo-header.
1758                          */
1759                         g_message("libpcap: SunATM capture has a %u-byte packet, too small to have even an ATM pseudo-header\n",
1760                             whdr->caplen);
1761                         *err = WTAP_ERR_BAD_RECORD;
1762                         return NULL;
1763                 }
1764                 libpcap_get_sunatm_pseudoheader((const struct sunatm_hdr *)pd,
1765                     pseudo_header);
1766
1767                 /*
1768                  * Don't count the pseudo-header as part of the packet.
1769                  */
1770                 whdr->len -= sizeof (struct sunatm_hdr);
1771                 whdr->caplen -= sizeof (struct sunatm_hdr);
1772                 pd += sizeof (struct sunatm_hdr);
1773
1774                 /*
1775                  * If this is ATM LANE traffic, try to guess what type of
1776                  * LANE traffic it is based on the packet contents.
1777                  */
1778                 if (pseudo_header->atm.type == TRAF_LANE)
1779                         atm_guess_lane_type(pd, whdr->caplen, pseudo_header);
1780         }
1781         else if (linktype == WTAP_ENCAP_IRDA) {
1782                 if (whdr->caplen < sizeof (struct irda_sll_hdr)) {
1783                         /*
1784                          * Uh-oh, the packet isn't big enough to even
1785                          * have a pseudo-header.
1786                          */
1787                         g_message("libpcap: IrDA capture has a %u-byte packet, too small to have even an IrDA pseudo-header\n",
1788                             whdr->caplen);
1789                         *err = WTAP_ERR_BAD_RECORD;
1790                         return NULL;
1791                 }
1792                 if (!libpcap_get_irda_pseudoheader((const struct irda_sll_hdr *)pd,
1793                         pseudo_header, err, NULL))
1794                         return NULL;
1795
1796                 /*
1797                  * Don't count the pseudo-header as part of the packet.
1798                  */
1799                 whdr->len -= sizeof (struct irda_sll_hdr);
1800                 whdr->caplen -= sizeof (struct irda_sll_hdr);
1801                 pd += sizeof (struct irda_sll_hdr);
1802         }
1803         return pd;
1804 }
1805 #endif
1806
1807 /* Returns 0 if we could write the specified encapsulation type,
1808    an error indication otherwise. */
1809 int libpcap_dump_can_write_encap(int encap)
1810 {
1811         /* Per-packet encapsulations aren't supported. */
1812         if (encap == WTAP_ENCAP_PER_PACKET)
1813                 return WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED;
1814
1815         if (wtap_wtap_encap_to_pcap_encap(encap) == -1)
1816                 return WTAP_ERR_UNSUPPORTED_ENCAP;
1817
1818         return 0;
1819 }
1820
1821 /* Returns TRUE on success, FALSE on failure; sets "*err" to an error code on
1822    failure */
1823 gboolean libpcap_dump_open(wtap_dumper *wdh, gboolean cant_seek _U_, int *err)
1824 {
1825         guint32 magic;
1826         struct pcap_hdr file_hdr;
1827         size_t nwritten;
1828
1829         /* This is a libpcap file */
1830         wdh->subtype_write = libpcap_dump;
1831         wdh->subtype_close = NULL;
1832
1833         /* Write the file header. */
1834         switch (wdh->file_type) {
1835
1836         case WTAP_FILE_PCAP:
1837         case WTAP_FILE_PCAP_SS990417:   /* modified, but with the old magic, sigh */
1838         case WTAP_FILE_PCAP_NOKIA:      /* Nokia libpcap of some sort */
1839                 magic = PCAP_MAGIC;
1840                 break;
1841
1842         case WTAP_FILE_PCAP_SS990915:   /* new magic, extra crap */
1843         case WTAP_FILE_PCAP_SS991029:
1844                 magic = PCAP_MODIFIED_MAGIC;
1845                 break;
1846
1847         default:
1848                 /* We should never get here - our open routine
1849                    should only get called for the types above. */
1850                 *err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
1851                 return FALSE;
1852         }
1853
1854         nwritten = fwrite(&magic, 1, sizeof magic, wdh->fh);
1855         if (nwritten != sizeof magic) {
1856                 if (nwritten == 0 && ferror(wdh->fh))
1857                         *err = errno;
1858                 else
1859                         *err = WTAP_ERR_SHORT_WRITE;
1860                 return FALSE;
1861         }
1862         wdh->bytes_dumped += sizeof magic;
1863
1864         /* current "libpcap" format is 2.4 */
1865         file_hdr.version_major = 2;
1866         file_hdr.version_minor = 4;
1867         file_hdr.thiszone = 0;  /* XXX - current offset? */
1868         file_hdr.sigfigs = 0;   /* unknown, but also apparently unused */
1869         /*
1870          * Tcpdump cannot handle capture files with a snapshot length of 0,
1871          * as BPF filters return either 0 if they fail or the snapshot length
1872          * if they succeed, and a snapshot length of 0 means success is
1873          * indistinguishable from failure and the filter expression would
1874          * reject all packets.
1875          *
1876          * A snapshot length of 0, inside Wiretap, means "snapshot length
1877          * unknown"; if the snapshot length supplied to us is 0, we make
1878          * the snapshot length in the header file WTAP_MAX_PACKET_SIZE.
1879          */
1880         file_hdr.snaplen = (wdh->snaplen != 0) ? wdh->snaplen :
1881                                                  WTAP_MAX_PACKET_SIZE;
1882         file_hdr.network = wtap_wtap_encap_to_pcap_encap(wdh->encap);
1883         nwritten = fwrite(&file_hdr, 1, sizeof file_hdr, wdh->fh);
1884         if (nwritten != sizeof file_hdr) {
1885                 if (nwritten == 0 && ferror(wdh->fh))
1886                         *err = errno;
1887                 else
1888                         *err = WTAP_ERR_SHORT_WRITE;
1889                 return FALSE;
1890         }
1891         wdh->bytes_dumped += sizeof file_hdr;
1892
1893         return TRUE;
1894 }
1895
1896 /* Write a record for a packet to a dump file.
1897    Returns TRUE on success, FALSE on failure. */
1898 static gboolean libpcap_dump(wtap_dumper *wdh,
1899         const struct wtap_pkthdr *phdr,
1900         const union wtap_pseudo_header *pseudo_header _U_,
1901         const guchar *pd, int *err)
1902 {
1903         struct pcaprec_ss990915_hdr rec_hdr;
1904         size_t hdr_size;
1905         size_t nwritten;
1906         struct sunatm_hdr atm_hdr;
1907         struct irda_sll_hdr irda_hdr;
1908         int hdrsize;
1909
1910         if (wdh->encap == WTAP_ENCAP_ATM_PDUS)
1911                 hdrsize = sizeof (struct sunatm_hdr);
1912         else if (wdh->encap == WTAP_ENCAP_IRDA)
1913                 hdrsize = sizeof (struct irda_sll_hdr);
1914         else
1915                 hdrsize = 0;
1916
1917         rec_hdr.hdr.ts_sec = phdr->ts.tv_sec;
1918         rec_hdr.hdr.ts_usec = phdr->ts.tv_usec;
1919         rec_hdr.hdr.incl_len = phdr->caplen + hdrsize;
1920         rec_hdr.hdr.orig_len = phdr->len + hdrsize;
1921         switch (wdh->file_type) {
1922
1923         case WTAP_FILE_PCAP:
1924                 hdr_size = sizeof (struct pcaprec_hdr);
1925                 break;
1926
1927         case WTAP_FILE_PCAP_SS990417:   /* modified, but with the old magic, sigh */
1928         case WTAP_FILE_PCAP_SS991029:
1929                 /* XXX - what should we supply here?
1930
1931                    Alexey's "libpcap" looks up the interface in the system's
1932                    interface list if "ifindex" is non-zero, and prints
1933                    the interface name.  It ignores "protocol", and uses
1934                    "pkt_type" to tag the packet as "host", "broadcast",
1935                    "multicast", "other host", "outgoing", or "none of the
1936                    above", but that's it.
1937
1938                    If the capture we're writing isn't a modified or
1939                    RH 6.1 capture, we'd have to do some work to
1940                    generate the packet type and interface index - and
1941                    we can't generate the interface index unless we
1942                    just did the capture ourselves in any case.
1943
1944                    I'm inclined to continue to punt; systems other than
1945                    those with the older patch can read standard "libpcap"
1946                    files, and systems with the older patch, e.g. RH 6.1,
1947                    will just have to live with this. */
1948                 rec_hdr.ifindex = 0;
1949                 rec_hdr.protocol = 0;
1950                 rec_hdr.pkt_type = 0;
1951                 hdr_size = sizeof (struct pcaprec_modified_hdr);
1952                 break;
1953
1954         case WTAP_FILE_PCAP_SS990915:   /* new magic, extra crap at the end */
1955                 rec_hdr.ifindex = 0;
1956                 rec_hdr.protocol = 0;
1957                 rec_hdr.pkt_type = 0;
1958                 rec_hdr.cpu1 = 0;
1959                 rec_hdr.cpu2 = 0;
1960                 hdr_size = sizeof (struct pcaprec_ss990915_hdr);
1961                 break;
1962
1963         case WTAP_FILE_PCAP_NOKIA:      /* old magic, extra crap at the end */
1964                 rec_hdr.ifindex = 0;
1965                 rec_hdr.protocol = 0;
1966                 rec_hdr.pkt_type = 0;
1967                 rec_hdr.cpu1 = 0;
1968                 rec_hdr.cpu2 = 0;
1969                 hdr_size = sizeof (struct pcaprec_nokia_hdr);
1970                 break;
1971
1972         default:
1973                 /* We should never get here - our open routine
1974                    should only get called for the types above. */
1975                 g_assert_not_reached();
1976                 *err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
1977                 return FALSE;
1978         }
1979
1980         nwritten = fwrite(&rec_hdr, 1, hdr_size, wdh->fh);
1981         if (nwritten != hdr_size) {
1982                 if (nwritten == 0 && ferror(wdh->fh))
1983                         *err = errno;
1984                 else
1985                         *err = WTAP_ERR_SHORT_WRITE;
1986                 return FALSE;
1987         }
1988         wdh->bytes_dumped += hdr_size;
1989
1990         if (wdh->encap == WTAP_ENCAP_ATM_PDUS) {
1991                 /*
1992                  * Write the ATM header.
1993                  */
1994                 atm_hdr.flags =
1995                     (pseudo_header->atm.channel == 0) ? 0x80 : 0x00;
1996                 switch (pseudo_header->atm.aal) {
1997
1998                 case AAL_SIGNALLING:
1999                         /* Q.2931 */
2000                         atm_hdr.flags |= 0x06;
2001                         break;
2002
2003                 case AAL_5:
2004                         switch (pseudo_header->atm.type) {
2005
2006                         case TRAF_LANE:
2007                                 /* LANE */
2008                                 atm_hdr.flags |= 0x01;
2009                                 break;
2010
2011                         case TRAF_LLCMX:
2012                                 /* RFC 1483 LLC multiplexed traffic */
2013                                 atm_hdr.flags |= 0x02;
2014                                 break;
2015
2016                         case TRAF_ILMI:
2017                                 /* ILMI */
2018                                 atm_hdr.flags |= 0x05;
2019                                 break;
2020                         }
2021                         break;
2022                 }
2023                 atm_hdr.vpi = (guint8) pseudo_header->atm.vpi;
2024                 atm_hdr.vci = phtons(&pseudo_header->atm.vci);
2025                 nwritten = fwrite(&atm_hdr, 1, sizeof atm_hdr, wdh->fh);
2026                 if (nwritten != sizeof atm_hdr) {
2027                         if (nwritten == 0 && ferror(wdh->fh))
2028                                 *err = errno;
2029                         else
2030                                 *err = WTAP_ERR_SHORT_WRITE;
2031                         return FALSE;
2032                 }
2033                 wdh->bytes_dumped += sizeof atm_hdr;
2034         }
2035         else if (wdh->encap == WTAP_ENCAP_IRDA) {
2036                 /*
2037                  * Write the IrDA header.
2038                  */
2039                 memset(&irda_hdr, 0, sizeof(irda_hdr));
2040                 irda_hdr.sll_pkttype  = phtons(&pseudo_header->irda.pkttype);
2041                 irda_hdr.sll_protocol = g_htons(0x0017);
2042                 nwritten = fwrite(&irda_hdr, 1, sizeof(irda_hdr), wdh->fh);
2043                 if (nwritten != sizeof(irda_hdr)) {
2044                         if (nwritten == 0 && ferror(wdh->fh))
2045                                 *err = errno;
2046                         else
2047                                 *err = WTAP_ERR_SHORT_WRITE;
2048                         return FALSE;
2049                 }
2050                 wdh->bytes_dumped += sizeof(irda_hdr);
2051         }
2052
2053         nwritten = fwrite(pd, 1, phdr->caplen, wdh->fh);
2054         if (nwritten != phdr->caplen) {
2055                 if (nwritten == 0 && ferror(wdh->fh))
2056                         *err = errno;
2057                 else
2058                         *err = WTAP_ERR_SHORT_WRITE;
2059                 return FALSE;
2060         }
2061         wdh->bytes_dumped += phdr->caplen;
2062         return TRUE;
2063 }