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