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