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