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