Support a libpcap link-layer type of 17 as DLT_PFLOG unless DLT_LANE8023
[obnox/wireshark/wip.git] / wiretap / libpcap.c
1 /* libpcap.c
2  *
3  * $Id: libpcap.c,v 1.64 2002/01/29 08:55:24 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 #include <stdlib.h>
27 #include <errno.h>
28 #include "wtap-int.h"
29 #include "file_wrappers.h"
30 #include "buffer.h"
31 #include "libpcap.h"
32
33 /* See source to the "libpcap" library for information on the "libpcap"
34    file format. */
35
36 /* On some systems, the FDDI MAC addresses are bit-swapped. */
37 #if !defined(ultrix) && !defined(__alpha) && !defined(__bsdi__)
38 #define BIT_SWAPPED_MAC_ADDRS
39 #endif
40
41
42 /* Try to read the first two records of the capture file. */
43 typedef enum {
44         THIS_FORMAT,            /* the reads succeeded, assume it's this format */
45         BAD_READ,               /* the file is probably not valid */
46         OTHER_FORMAT            /* the file may be valid, but not in this format */
47 } libpcap_try_t;
48 static libpcap_try_t libpcap_try(wtap *wth, int *err);
49
50 static gboolean libpcap_read(wtap *wth, int *err, long *data_offset);
51 static int libpcap_read_header(wtap *wth, int *err,
52     struct pcaprec_ss990915_hdr *hdr, gboolean silent);
53 static void adjust_header(wtap *wth, struct pcaprec_hdr *hdr);
54 static void libpcap_close(wtap *wth);
55 static gboolean libpcap_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
56     const union wtap_pseudo_header *pseudo_header, const u_char *pd, int *err);
57
58 /*
59  * Either LBL NRG wasn't an adequate central registry (e.g., because of
60  * the slow rate of releases from them), or nobody bothered using them
61  * as a central registry, as many different groups have patched libpcap
62  * (and BPF, on the BSDs) to add new encapsulation types, and have ended
63  * up using the same DLT_ values for different encapsulation types.
64  *
65  * For those numerical encapsulation type values that everybody uses for
66  * the same encapsulation type (which inclues those that some platforms
67  * specify different DLT_ names for but don't appear to use), we map
68  * those values to the appropriate Wiretap values.
69  *
70  * For those numerical encapsulation type values that different libpcap
71  * variants use for different encapsulation types, we check what
72  * <pcap.h> defined to determine how to interpret them, so that we
73  * interpret them the way the libpcap with which we're building
74  * Ethereal/Wiretap interprets them (which, if it doesn't support
75  * them at all, means we don't support them either - any capture files
76  * using them are foreign, and we don't hazard a guess as to which
77  * platform they came from; we could, I guess, choose the most likely
78  * platform).
79  */
80
81 #ifdef HAVE_PCAP_H
82 #include <pcap.h>
83 #endif
84
85 static const struct {
86         int     dlt_value;
87         int     wtap_encap_value;
88 } pcap_to_wtap_map[] = {
89         /*
90          * These are the values that are almost certainly the same
91          * in all libpcaps (I've yet to find one where the values
92          * in question are used for some purpose other than the
93          * one below, but...), and that Wiretap and Ethereal
94          * currently support.
95          */
96         { 0,            WTAP_ENCAP_NULL },      /* null encapsulation */
97         { 1,            WTAP_ENCAP_ETHERNET },
98         { 6,            WTAP_ENCAP_TOKEN_RING },        /* IEEE 802 Networks - assume token ring */
99         { 7,            WTAP_ENCAP_ARCNET },
100         { 8,            WTAP_ENCAP_SLIP },
101         { 9,            WTAP_ENCAP_PPP },
102 #ifdef BIT_SWAPPED_MAC_ADDRS
103         { 10,           WTAP_ENCAP_FDDI_BITSWAPPED },
104 #else
105         { 10,           WTAP_ENCAP_FDDI },
106 #endif
107
108         /*
109          * 11 is DLT_ATM_RFC1483 on most platforms; the only libpcaps I've
110          * seen that define anything other than DLT_ATM_RFC1483 as 11 are
111          * the BSD/OS one, which defines DLT_FR as 11, and libpcap 0.5,
112          * which define it as 100, mapping the kernel's value to 100, in
113          * an attempt to hide the different values used on different
114          * platforms.
115          *
116          * If this is a platform where DLT_FR is defined as 11, we
117          * don't handle 11 at all; otherwise, we handle it as
118          * DLT_ATM_RFC1483 (this means we'd misinterpret Frame Relay
119          * captures from BSD/OS if running on platforms other than BSD/OS,
120          * but
121          *
122          *      1) we don't yet support DLT_FR
123          *
124          * and
125          *
126          *      2) nothing short of a heuristic would let us interpret
127          *         them correctly).
128          */
129 #if defined(DLT_FR) && (DLT_FR == 11)
130         /* Put entry for Frame Relay here */
131 #else
132         { 11,           WTAP_ENCAP_ATM_RFC1483 },
133 #endif
134
135         /*
136          * 12 is DLT_RAW on most platforms, but it's DLT_C_HDLC on
137          * BSD/OS, and DLT_LOOP on OpenBSD.
138          *
139          * We don't yet handle DLT_C_HDLC, but we can handle DLT_LOOP
140          * (it's just like DLT_NULL, only with the AF_ value in network
141          * rather than host byte order - Ethereal figures out the
142          * byte order from the data, so we don't care what byte order
143          * it's in), so if DLT_LOOP is defined as 12, interpret 12
144          * as WTAP_ENCAP_NULL, otherwise, unless DLT_C_HDLC is defined
145          * as 12, interpret it as WTAP_ENCAP_RAW_IP.
146          */
147 #if defined(DLT_LOOP) && (DLT_LOOP == 12)
148         { 12,           WTAP_ENCAP_NULL },
149 #elif defined(DLT_C_HDLC) && (DLT_C_HDLC == 12)
150         /*
151          * Put entry for Cisco HDLC here.
152          * XXX - is this just WTAP_ENCAP_CHDLC, i.e. does the frame
153          * start with a 4-byte Cisco HDLC header?
154          */
155 #else
156         { 12,           WTAP_ENCAP_RAW_IP },
157 #endif
158
159         /*
160          * 13 is DLT_SLIP_BSDOS on FreeBSD and NetBSD, but those OSes
161          * don't actually generate it.  I infer that BSD/OS translates
162          * DLT_SLIP from the kernel BPF code to DLT_SLIP_BSDOS in
163          * libpcap, as the BSD/OS link-layer header is different;
164          * however, in BSD/OS, DLT_SLIP_BSDOS is 15.
165          *
166          * From this, I infer that there's no point in handling 13
167          * as DLT_SLIP_BSDOS.
168          *
169          * 13 is DLT_ATM_RFC1483 on BSD/OS.
170          *
171          * 13 is DLT_ENC in OpenBSD, which is, I suspect, some kind
172          * of decrypted IPSEC traffic.
173          */
174 #if defined(DLT_ATM_RFC1483) && (DLT_ATM_RFC1483 == 13)
175         { 13,           WTAP_ENCAP_ATM_RFC1483 },
176 #elif defined(DLT_ENC) && (DLT_ENC == 13)
177         /* Put entry for DLT_ENC here */
178 #endif
179
180         /*
181          * 14 is DLT_PPP_BSDOS on FreeBSD and NetBSD, but those OSes
182          * don't actually generate it.  I infer that BSD/OS translates
183          * DLT_PPP from the kernel BPF code to DLT_PPP_BSDOS in
184          * libpcap, as the BSD/OS link-layer header is different;
185          * however, in BSD/OS, DLT_PPP_BSDOS is 16.
186          *
187          * From this, I infer that there's no point in handling 14
188          * as DLT_PPP_BSDOS.
189          *
190          * 14 is DLT_RAW on BSD/OS and OpenBSD.
191          */
192         { 14,           WTAP_ENCAP_RAW_IP },
193
194         /*
195          * 15 is:
196          *
197          *      DLT_SLIP_BSDOS on BSD/OS;
198          *
199          *      DLT_HIPPI on NetBSD;
200          *
201          *      DLT_LANE8023 with Alexey Kuznetzov's patches for
202          *      Linux libpcap;
203          *
204          *      DLT_I4L_RAWIP with the ISDN4Linux patches for libpcap
205          *      (and on SuSE 6.3);
206          *
207          * but we don't currently handle any of those.
208          */
209
210         /*
211          * 16 is:
212          *
213          *      DLT_PPP_BSDOS on BSD/OS;
214          *
215          *      DLT_HDLC on NetBSD (Cisco HDLC);
216          *
217          *      DLT_CIP with Alexey Kuznetzov's patches for
218          *      Linux libpcap - this is WTAP_ENCAP_LINUX_ATM_CLIP;
219          *
220          *      DLT_I4L_IP with the ISDN4Linux patches for libpcap
221          *      (and on SuSE 6.3).
222          */
223 #if defined(DLT_CIP) && (DLT_CIP == 16)
224         { 16,           WTAP_ENCAP_LINUX_ATM_CLIP },
225 #endif
226 #if defined(DLT_HDLC) && (DLT_HDLC == 16)
227         { 16,           WTAP_ENCAP_CHDLC },
228 #endif
229
230         /*
231          * 17 is DLT_LANE8023 in SuSE 6.3 libpcap; we don't currently
232          * handle it.
233          * It is also used as the PF (Packet Filter) logging format beginning
234          * with OpenBSD 3.0; we use 17 for PF logs unless DLT_LANE8023 is
235          * defined with the value 17.
236          */
237 #if !defined(DLT_LANE8023) || (DLT_LANE8023 != 17)
238         { 17,           WTAP_ENCAP_PFLOG },
239 #endif
240
241         /*
242          * 18 is DLT_CIP in SuSE 6.3 libpcap; if it's the same as the
243          * DLT_CIP of 16 that the Alexey Kuznetzov patches for
244          * libpcap/tcpdump define, it's WTAP_ENCAP_LINUX_ATM_CLIP.
245          * I've not found any libpcap that uses it for any other purpose -
246          * hopefully nobody will do so in the future.
247          */
248         { 18,           WTAP_ENCAP_LINUX_ATM_CLIP },
249
250         /*
251          * 19 is DLT_ATM_CLIP in the libpcap/tcpdump patches in the
252          * recent versions I've seen of the Linux ATM distribution;
253          * I've not yet found any libpcap that uses it for any other
254          * purpose - hopefully nobody will do so in the future.
255          */
256         { 19,           WTAP_ENCAP_LINUX_ATM_CLIP },
257
258         /*
259          * 50 is DLT_PPP_SERIAL in NetBSD; it appears that DLT_PPP
260          * on BSD (at least according to standard tcpdump) has, as
261          * the first octet, an indication of whether the packet was
262          * transmitted or received (rather than having the standard
263          * PPP address value of 0xff), but that DLT_PPP_SERIAL puts
264          * a real live PPP header there, or perhaps a Cisco PPP header
265          * as per section 4.3.1 of RFC 1547 (implementations of this
266          * exist in various BSDs in "sys/net/if_spppsubr.c", and
267          * I think also exist either in standard Linux or in
268          * various Linux patches; the implementations show how to handle
269          * Cisco keepalive packets).
270          *
271          * However, I don't see any obvious place in FreeBSD "if_ppp.c"
272          * where anything other than the standard PPP header would be
273          * passed up.  I see some stuff that sets the first octet
274          * to 0 for incoming and 1 for outgoing packets before applying
275          * a BPF filter to see whether to drop packets whose protocol
276          * field has the 0x8000 bit set, i.e. network control protocols -
277          * those are handed up to userland - but that code puts the
278          * address field back before passing the packet up.
279          *
280          * I also don't see anything immediately obvious that munges
281          * the address field for sync PPP, either.
282          *
283          * Ethereal currently assumes that if the first octet of a
284          * PPP frame is 0xFF, it's the address field and is followed
285          * by a control field and a 2-byte protocol, otherwise the
286          * address and control fields are absent and the frame begins
287          * with a protocol field.  If we ever see a BSD/OS PPP
288          * capture, we'll have to handle it differently, and we may
289          * have to handle standard BSD captures differently if, in fact,
290          * they don't have 0xff 0x03 as the first two bytes - but, as per
291          * the two paragraphs preceding this, it's not clear that
292          * the address field *is* munged into an incoming/outgoing
293          * field when the packet is handed to the BPF device.
294          *
295          * For now, we just map DLT_PPP_SERIAL to WTAP_ENCAP_PPP, as
296          * we treat WTAP_ENCAP_PPP packets as if those beginning with
297          * 0xff have the standard RFC 1662 "PPP in HDLC-like Framing"
298          * 0xff 0x03 address/control header, and DLT_PPP_SERIAL frames
299          * appear to contain that unless they're Cisco frames (if we
300          * ever see a capture with them, we'd need to implement the
301          * RFC 1547 stuff, and the keepalive protocol stuff).
302          *
303          * We may have to distinguish between "PPP where if it doesn't
304          * begin with 0xff there's no HDLC encapsulation and the frame
305          * begins with the protocol field" (which is how we handle
306          * WTAP_ENCAP_PPP now) and "PPP where there's either HDLC
307          * encapsulation or Cisco PPP" (which is what DLT_PPP_SERIAL
308          * is) at some point.
309          *
310          * XXX - NetBSD has DLT_HDLC, which appears to be used for
311          * Cisco HDLC.  Ideally, they should use DLT_PPP_SERIAL
312          * only for real live HDLC-encapsulated PPP, not for Cisco
313          * HDLC.
314          */
315         { 50,           WTAP_ENCAP_PPP },
316
317         /*
318          * These are the values that libpcap 0.5 uses, in an attempt
319          * to work around the confusion decried above, and that Wiretap
320          * and Ethereal currently support.
321          *
322          * The next version of libpcap will probably not use them as
323          * DLT_ values in its API, but will probably use them in capture
324          * file headers.
325          */
326         { 100,          WTAP_ENCAP_ATM_RFC1483 },
327         { 101,          WTAP_ENCAP_RAW_IP },
328 #if 0
329         /*
330          * More values used by libpcap 0.5 as DLT_ values and used by the
331          * current CVS version of libpcap in capture file headers.
332          * They are not yet handled in Ethereal.
333          * If we get a capture that contains them, we'll implement them.
334          */
335         { 102,          WTAP_ENCAP_SLIP_BSDOS },
336         { 103,          WTAP_ENCAP_PPP_BSDOS },
337 #endif
338
339         /*
340          * These ones are handled in Ethereal, though.
341          */
342         { 104,          WTAP_ENCAP_CHDLC },     /* Cisco HDLC */
343         { 106,          WTAP_ENCAP_LINUX_ATM_CLIP },
344
345         /*
346          * Values not yet used by the current CVS version of libpcap,
347          * but reserved for future use; the IEEE 802.11 value is
348          * there for use with a capture program from Axis Communications.
349          */
350         { 105,          WTAP_ENCAP_IEEE_802_11 },
351 #if 0
352         /*
353          * Not yet handled in Ethereal; we don't know what encapsulation
354          * BSD/OS uses, so we don't know whether it can be handed to
355          * the Frame Relay dissector or not.
356          */
357         { 107,          WTAP_ENCAP_FR },        /* Frame Relay */
358 #endif
359         { 108,          WTAP_ENCAP_NULL },      /* OpenBSD loopback */
360 #if 0
361         { 109,          WTAP_ENCAP_ENC },       /* OpenBSD IPSEC enc */
362         { 110,          WTAP_ENCAP_LANE_802_3 },/* ATM LANE 802.3 */
363         { 111,          WTAP_ENCAP_HIPPI },     /* NetBSD HIPPI */
364 #endif
365         { 112,          WTAP_ENCAP_CHDLC },     /* NetBSD HDLC framing */
366
367         /*
368          * Linux "cooked mode" captures, used by the current CVS version
369          * of libpcap.
370          */
371         { 113,          WTAP_ENCAP_SLL },       /* Linux cooked capture */
372
373         { 114,          WTAP_ENCAP_LOCALTALK }, /* Localtalk */
374
375         /*
376          * The tcpdump.org version of libpcap uses 117, rather than 17,
377          * for OpenBSD packet filter logging, so as to avoid conflicting
378          * with DLT_LANE8023 in SuSE 6.3 libpcap.
379          */
380         { 117,          WTAP_ENCAP_PFLOG },
381
382         { 118,          WTAP_ENCAP_CISCO_IOS },
383         { 119,          WTAP_ENCAP_PRISM_HEADER }, /* Prism monitor mode hdr */
384 };
385 #define NUM_PCAP_ENCAPS (sizeof pcap_to_wtap_map / sizeof pcap_to_wtap_map[0])
386
387 int libpcap_open(wtap *wth, int *err)
388 {
389         int bytes_read;
390         guint32 magic;
391         struct pcap_hdr hdr;
392         gboolean byte_swapped;
393         gboolean modified;
394         gboolean aix;
395         int file_encap;
396
397         /* Read in the number that should be at the start of a "libpcap" file */
398         errno = WTAP_ERR_CANT_READ;
399         bytes_read = file_read(&magic, 1, sizeof magic, wth->fh);
400         if (bytes_read != sizeof magic) {
401                 *err = file_error(wth->fh);
402                 if (*err != 0)
403                         return -1;
404                 return 0;
405         }
406         wth->data_offset += sizeof magic;
407
408         switch (magic) {
409
410         case PCAP_MAGIC:
411                 /* Host that wrote it has our byte order, and was running
412                    a program using either standard or ss990417 libpcap. */
413                 byte_swapped = FALSE;
414                 modified = FALSE;
415                 break;
416
417         case PCAP_MODIFIED_MAGIC:
418                 /* Host that wrote it has our byte order, and was running
419                    a program using either ss990915 or ss991029 libpcap. */
420                 byte_swapped = FALSE;
421                 modified = TRUE;
422                 break;
423
424         case PCAP_SWAPPED_MAGIC:
425                 /* Host that wrote it has a byte order opposite to ours,
426                    and was running a program using either standard or
427                    ss990417 libpcap. */
428                 byte_swapped = TRUE;
429                 modified = FALSE;
430                 break;
431
432         case PCAP_SWAPPED_MODIFIED_MAGIC:
433                 /* Host that wrote it out has a byte order opposite to
434                    ours, and was running a program using either ss990915
435                    or ss991029 libpcap. */
436                 byte_swapped = TRUE;
437                 modified = TRUE;
438                 break;
439
440         default:
441                 /* Not a "libpcap" type we know about. */
442                 return 0;
443         }
444
445         /* Read the rest of the header. */
446         errno = WTAP_ERR_CANT_READ;
447         bytes_read = file_read(&hdr, 1, sizeof hdr, wth->fh);
448         if (bytes_read != sizeof hdr) {
449                 *err = file_error(wth->fh);
450                 if (*err != 0)
451                         return -1;
452                 return 0;
453         }
454         wth->data_offset += sizeof hdr;
455
456         if (byte_swapped) {
457                 /* Byte-swap the header fields about which we care. */
458                 hdr.version_major = BSWAP16(hdr.version_major);
459                 hdr.version_minor = BSWAP16(hdr.version_minor);
460                 hdr.snaplen = BSWAP32(hdr.snaplen);
461                 hdr.network = BSWAP32(hdr.network);
462         }
463         if (hdr.version_major < 2) {
464                 /* We only support version 2.0 and later. */
465                 g_message("pcap: major version %u unsupported",
466                     hdr.version_major);
467                 *err = WTAP_ERR_UNSUPPORTED;
468                 return -1;
469         }
470
471         /*
472          * AIX's non-standard tcpdump uses a minor version number of 2.
473          * Unfortunately, older versions of libpcap might have used
474          * that as well.
475          *
476          * The AIX libpcap uses RFC 1573 ifType values rather than
477          * DLT_ values in the header; the ifType values for LAN devices
478          * are:
479          *
480          *      Ethernet        6
481          *      Token Ring      9
482          *      FDDI            15
483          *
484          * which correspond to DLT_IEEE802 (used for Token Ring),
485          * DLT_PPP, and DLT_SLIP_BSDOS, respectively.  We shall
486          * assume that if the minor version number is 2, and
487          * the network type is 6, 9, or 15, that it's AIX libpcap;
488          *
489          * I'm assuming those older versions of libpcap didn't
490          * use DLT_IEEE802 for Token Ring, and didn't use DLT_SLIP_BSDOS
491          * as that came later.  It may have used DLT_SLIP, however, in
492          * which case we're out of luck; we assume it's Token Ring
493          * in AIX libpcap rather than PPP in standard libpcap, as
494          * you're probably more likely to be handing an AIX libpcap
495          * token-ring capture than an old (pre-libpcap 0.4) PPP capture
496          * to Ethereal.
497          */
498         aix = FALSE;    /* assume it's not AIX */
499         if (hdr.version_major == 2 && hdr.version_minor == 2) {
500                 switch (hdr.network) {
501
502                 case 6:
503                         hdr.network = 1;        /* DLT_EN10MB, Ethernet */
504                         aix = TRUE;
505                         break;
506
507                 case 8:
508                         hdr.network = 6;        /* DLT_IEEE802, Token Ring */
509                         aix = TRUE;
510                         break;
511
512                 case 15:
513                         hdr.network = 10;       /* DLT_FDDI, FDDI */
514                         aix = TRUE;
515                         break;
516                 }
517         }
518         file_encap = wtap_pcap_encap_to_wtap_encap(hdr.network);
519         if (file_encap == WTAP_ENCAP_UNKNOWN) {
520                 g_message("pcap: network type %u unknown or unsupported",
521                     hdr.network);
522                 *err = WTAP_ERR_UNSUPPORTED_ENCAP;
523                 return -1;
524         }
525
526         /* This is a libpcap file */
527         wth->capture.pcap = g_malloc(sizeof(libpcap_t));
528         wth->capture.pcap->byte_swapped = byte_swapped;
529         wth->capture.pcap->version_major = hdr.version_major;
530         wth->capture.pcap->version_minor = hdr.version_minor;
531         wth->subtype_read = libpcap_read;
532         wth->subtype_seek_read = wtap_def_seek_read;
533         wth->subtype_close = libpcap_close;
534         wth->file_encap = file_encap;
535         wth->snapshot_length = hdr.snaplen;
536
537         /*
538          * Is this AIX format?
539          */
540         if (aix) {
541                 /*
542                  * Yes.  Skip all the tests for other mutant formats.
543                  */
544                 wth->file_type = WTAP_FILE_PCAP_AIX;
545                 return 1;
546         }
547
548         /*
549          * No.  Let's look at the header for the first record,
550          * and see if, interpreting it as a standard header (if the
551          * magic number was standard) or a modified header (if the
552          * magic number was modified), the position where it says the
553          * header for the *second* record is contains a corrupted header.
554          *
555          * If so, then:
556          *
557          *      If this file had the standard magic number, it may be
558          *      an ss990417 capture file - in that version of Alexey's
559          *      patch, the packet header format was changed but the
560          *      magic number wasn't, and, alas, Red Hat appear to have
561          *      picked up that version of the patch for RH 6.1, meaning
562          *      RH 6.1 has a tcpdump that writes out files that can't
563          *      be read by any software that expects non-modified headers
564          *      if the magic number isn't the modified magic number (e.g.,
565          *      any normal version of tcpdump, and Ethereal if we don't
566          *      do this gross heuristic).
567          *
568          *      If this file had the modified magic number, it may be
569          *      an ss990915 capture file - in that version of Alexey's
570          *      patch, the magic number was changed, but the record
571          *      header had some extra fields, and, alas, SuSE appear
572          *      to have picked up that version of the patch for SuSE
573          *      6.3, meaning that programs expecting the standard per-
574          *      packet header in captures with the modified magic number
575          *      can't read dumps from its tcpdump.
576          *
577          * Oh, and if it has the standard magic number, it might, instead,
578          * be a Nokia libpcap file, so we may need to try that if
579          * neither normal nor ss990417 headers work.
580          */
581         if (modified) {
582                 /*
583                  * Well, we have the magic number from Alexey's
584                  * later two patches.
585                  *
586                  * Try ss991029, the last of his patches, first.
587                  */
588                 wth->file_type = WTAP_FILE_PCAP_SS991029;
589                 switch (libpcap_try(wth, err)) {
590
591                 case BAD_READ:
592                         /*
593                          * Well, we couldn't even read it.
594                          * Give up.
595                          */
596                         return -1;
597
598                 case THIS_FORMAT:
599                         /*
600                          * Well, it looks as if it might be 991029.
601                          * Put the seek pointer back, and return success.
602                          */
603                         file_seek(wth->fh, wth->data_offset, SEEK_SET);
604                         return 1;
605
606                 case OTHER_FORMAT:
607                         /*
608                          * Try the next format.
609                          */
610                         break;
611                 }
612
613                 /*
614                  * Well, it's not completely unreadable,
615                  * but it's not ss991029.  Try ss990915;
616                  * there are no other types to try after that,
617                  * so we put the seek pointer back and treat
618                  * it as 990915.
619                  */
620                 wth->file_type = WTAP_FILE_PCAP_SS990915;
621                 file_seek(wth->fh, wth->data_offset, SEEK_SET);
622         } else {
623                 /*
624                  * Well, we have the standard magic number.
625                  *
626                  * Try the standard format first.
627                  */
628                 wth->file_type = WTAP_FILE_PCAP;
629                 switch (libpcap_try(wth, err)) {
630
631                 case BAD_READ:
632                         /*
633                          * Well, we couldn't even read it.
634                          * Give up.
635                          */
636                         return -1;
637
638                 case THIS_FORMAT:
639                         /*
640                          * Well, it looks as if it might be a standard
641                          * libpcap file.
642                          * Put the seek pointer back, and return success.
643                          */
644                         file_seek(wth->fh, wth->data_offset, SEEK_SET);
645                         return 1;
646
647                 case OTHER_FORMAT:
648                         /*
649                          * Try the next format.
650                          */
651                         break;
652                 }
653
654                 /*
655                  * Well, it's not completely unreadable, but it's not
656                  * a standard file.  Put the seek pointer back and try
657                  * ss990417.
658                  */
659                 wth->file_type = WTAP_FILE_PCAP_SS990417;
660                 file_seek(wth->fh, wth->data_offset, SEEK_SET);
661                 switch (libpcap_try(wth, err)) {
662
663                 case BAD_READ:
664                         /*
665                          * Well, we couldn't even read it.
666                          * Give up.
667                          */
668                         return -1;
669
670                 case THIS_FORMAT:
671                         /*
672                          * Well, it looks as if it might be ss990417.
673                          * Put the seek pointer back, and return success.
674                          */
675                         file_seek(wth->fh, wth->data_offset, SEEK_SET);
676                         return 1;
677
678                 case OTHER_FORMAT:
679                         /*
680                          * Try the next format.
681                          */
682                         break;
683                 }
684
685                 /*
686                  * Well, it's not completely unreadable,
687                  * but it's not a standard file *nor* is it ss990417.
688                  * Try it as a Nokia file; there are no other types
689                  * to try after that, so we put the seek pointer back
690                  * and treat it as a Nokia file.
691                  */
692                 wth->file_type = WTAP_FILE_PCAP_NOKIA;
693                 file_seek(wth->fh, wth->data_offset, SEEK_SET);
694         }
695
696         return 1;
697 }
698
699 /* Try to read the first two records of the capture file. */
700 static libpcap_try_t libpcap_try(wtap *wth, int *err)
701 {
702         /*
703          * pcaprec_ss990915_hdr is the largest header type.
704          */
705         struct pcaprec_ss990915_hdr first_rec_hdr, second_rec_hdr;
706
707         /*
708          * Attempt to read the first record's header.
709          */
710         if (libpcap_read_header(wth, err, &first_rec_hdr, TRUE) == -1) {
711                 if (*err == 0 || *err == WTAP_ERR_SHORT_READ) {
712                         /*
713                          * EOF or short read - assume the file is in this
714                          * format.
715                          * When our client tries to read the first packet
716                          * they will presumably get the same EOF or short
717                          * read.
718                          */
719                         return THIS_FORMAT;
720                 }
721
722                 if (*err == WTAP_ERR_BAD_RECORD) {
723                         /*
724                          * The first record is bogus, so this is probably
725                          * a corrupt file.  Assume the file is in this
726                          * format.  When our client tries to read the
727                          * first packet they will presumably get the
728                          * same bogus record.
729                          */
730                         return THIS_FORMAT;
731                 }
732
733                 /*
734                  * Some other error, e.g. an I/O error; just give up.
735                  */
736                 return BAD_READ;
737         }
738
739         /*
740          * Now skip over the first record's data, under the assumption
741          * that the header is sane.
742          */
743         file_seek(wth->fh, first_rec_hdr.hdr.incl_len, SEEK_CUR);
744
745         /*
746          * Now attempt to read the second record's header.
747          */
748         if (libpcap_read_header(wth, err, &second_rec_hdr, TRUE) == -1) {
749                 if (*err == 0 || *err == WTAP_ERR_SHORT_READ) {
750                         /*
751                          * EOF or short read - assume the file is in this
752                          * format.
753                          * When our client tries to read the second packet
754                          * they will presumably get the same EOF or short
755                          * read.
756                          */
757                         return THIS_FORMAT;
758                 }
759
760                 if (*err == WTAP_ERR_BAD_RECORD) {
761                         /*
762                          * The second record is bogus; maybe it's a
763                          * Capture File From Hell, and what looks like
764                          * the "header" of the next packet is actually
765                          * random junk from the middle of a packet.
766                          * Try the next format; if we run out of formats,
767                          * it probably *is* a corrupt file.
768                          */
769                         return OTHER_FORMAT;
770                 }
771
772                 /*
773                  * Some other error, e.g. an I/O error; just give up.
774                  */
775                 return BAD_READ;
776         }
777
778         /*
779          * OK, the first two records look OK; assume this is the
780          * right format.
781          */
782         return THIS_FORMAT;
783 }
784
785 /* Read the next packet */
786 static gboolean libpcap_read(wtap *wth, int *err, long *data_offset)
787 {
788         struct pcaprec_ss990915_hdr hdr;
789         guint packet_size;
790         int bytes_read;
791
792         bytes_read = libpcap_read_header(wth, err, &hdr, FALSE);
793         if (bytes_read == -1) {
794                 /*
795                  * We failed to read the header.
796                  */
797                 return FALSE;
798         }
799
800         wth->data_offset += bytes_read;
801         packet_size = hdr.hdr.incl_len;
802
803         buffer_assure_space(wth->frame_buffer, packet_size);
804         *data_offset = wth->data_offset;
805         errno = WTAP_ERR_CANT_READ;
806         bytes_read = file_read(buffer_start_ptr(wth->frame_buffer), 1,
807                         packet_size, wth->fh);
808
809         if ((guint)bytes_read != packet_size) {
810                 *err = file_error(wth->fh);
811                 if (*err == 0)
812                         *err = WTAP_ERR_SHORT_READ;
813                 return FALSE;
814         }
815         wth->data_offset += packet_size;
816
817         wth->phdr.ts.tv_sec = hdr.hdr.ts_sec;
818         wth->phdr.ts.tv_usec = hdr.hdr.ts_usec;
819         wth->phdr.caplen = packet_size;
820         wth->phdr.len = hdr.hdr.orig_len;
821         wth->phdr.pkt_encap = wth->file_encap;
822
823         return TRUE;
824 }
825
826 /* Read the header of the next packet; if "silent" is TRUE, don't complain
827    to the console, as we're testing to see if the file appears to be of a
828    particular type.
829
830    Return -1 on an error, or the number of bytes of header read on success. */
831 static int libpcap_read_header(wtap *wth, int *err,
832     struct pcaprec_ss990915_hdr *hdr, gboolean silent)
833 {
834         int     bytes_to_read, bytes_read;
835
836         /* Read record header. */
837         errno = WTAP_ERR_CANT_READ;
838         switch (wth->file_type) {
839
840         case WTAP_FILE_PCAP:
841         case WTAP_FILE_PCAP_AIX:
842                 bytes_to_read = sizeof (struct pcaprec_hdr);
843                 break;
844
845         case WTAP_FILE_PCAP_SS990417:
846         case WTAP_FILE_PCAP_SS991029:
847                 bytes_to_read = sizeof (struct pcaprec_modified_hdr);
848                 break;
849
850         case WTAP_FILE_PCAP_SS990915:
851                 bytes_to_read = sizeof (struct pcaprec_ss990915_hdr);
852                 break;
853
854         case WTAP_FILE_PCAP_NOKIA:
855                 bytes_to_read = sizeof (struct pcaprec_nokia_hdr);
856                 break;
857
858         default:
859                 g_assert_not_reached();
860                 bytes_to_read = 0;
861         }
862         bytes_read = file_read(hdr, 1, bytes_to_read, wth->fh);
863         if (bytes_read != bytes_to_read) {
864                 *err = file_error(wth->fh);
865                 if (*err == 0 && bytes_read != 0) {
866                         *err = WTAP_ERR_SHORT_READ;
867                 }
868                 return -1;
869         }
870
871         adjust_header(wth, &hdr->hdr);
872
873         if (hdr->hdr.incl_len > WTAP_MAX_PACKET_SIZE) {
874                 /*
875                  * Probably a corrupt capture file; return an error,
876                  * so that our caller doesn't blow up trying to allocate
877                  * space for an immensely-large packet, and so that
878                  * the code to try to guess what type of libpcap file
879                  * this is can tell when it's not the type we're guessing
880                  * it is.
881                  */
882                 if (!silent) {
883                         g_message("pcap: File has %u-byte packet, bigger than maximum of %u",
884                             hdr->hdr.incl_len, WTAP_MAX_PACKET_SIZE);
885                 }
886                 *err = WTAP_ERR_BAD_RECORD;
887                 return -1;
888         }
889
890         if (hdr->hdr.orig_len > WTAP_MAX_PACKET_SIZE) {
891                 /*
892                  * Probably a corrupt capture file; return an error,
893                  * so that our caller doesn't blow up trying to
894                  * cope with a huge "real" packet length, and so that
895                  * the code to try to guess what type of libpcap file
896                  * this is can tell when it's not the type we're guessing
897                  * it is.
898                  */
899                 if (!silent) {
900                         g_message("pcap: File has %u-byte packet, bigger than maximum of %u",
901                             hdr->hdr.orig_len, WTAP_MAX_PACKET_SIZE);
902                 }
903                 *err = WTAP_ERR_BAD_RECORD;
904                 return -1;
905         }
906
907         return bytes_read;
908 }
909
910 static void
911 adjust_header(wtap *wth, struct pcaprec_hdr *hdr)
912 {
913         if (wth->capture.pcap->byte_swapped) {
914                 /* Byte-swap the record header fields. */
915                 hdr->ts_sec = BSWAP32(hdr->ts_sec);
916                 hdr->ts_usec = BSWAP32(hdr->ts_usec);
917                 hdr->incl_len = BSWAP32(hdr->incl_len);
918                 hdr->orig_len = BSWAP32(hdr->orig_len);
919         }
920
921         /* If this is AIX, convert the time stamp from seconds/nanoseconds
922            to seconds/microseconds.  */
923         if (wth->file_type == WTAP_FILE_PCAP_AIX)
924                 hdr->ts_usec = hdr->ts_usec/1000;
925
926         /* In file format version 2.3, the "incl_len" and "orig_len" fields
927            were swapped, in order to match the BPF header layout.
928
929            Unfortunately, some files were, according to a comment in the
930            "libpcap" source, written with version 2.3 in their headers
931            but without the interchanged fields, so if "incl_len" is
932            greater than "orig_len" - which would make no sense - we
933            assume that we need to swap them.  */
934         if (wth->capture.pcap->version_major == 2 &&
935             (wth->capture.pcap->version_minor < 3 ||
936              (wth->capture.pcap->version_minor == 3 &&
937               hdr->incl_len > hdr->orig_len))) {
938                 guint32 temp;
939
940                 temp = hdr->orig_len;
941                 hdr->orig_len = hdr->incl_len;
942                 hdr->incl_len = temp;
943         }
944 }
945
946 static void
947 libpcap_close(wtap *wth)
948 {
949         g_free(wth->capture.pcap);
950 }
951
952 int wtap_pcap_encap_to_wtap_encap(int encap)
953 {
954         unsigned int i;
955
956         for (i = 0; i < NUM_PCAP_ENCAPS; i++) {
957                 if (pcap_to_wtap_map[i].dlt_value == encap)
958                         return pcap_to_wtap_map[i].wtap_encap_value;
959         }
960         return WTAP_ENCAP_UNKNOWN;
961 }
962
963 static int wtap_wtap_encap_to_pcap_encap(int encap)
964 {
965         unsigned int i;
966
967         /*
968          * Special-case WTAP_ENCAP_FDDI and WTAP_ENCAP_FDDI_BITSWAPPED;
969          * both of them get mapped to DLT_FDDI (even though that may
970          * mean that the bit order in the FDDI MAC addresses is wrong;
971          * so it goes - libpcap format doesn't record the byte order,
972          * so that's not fixable).
973          */
974         if (encap == WTAP_ENCAP_FDDI || encap == WTAP_ENCAP_FDDI_BITSWAPPED)
975                 return 10;      /* that's DLT_FDDI */
976         for (i = 0; i < NUM_PCAP_ENCAPS; i++) {
977                 if (pcap_to_wtap_map[i].wtap_encap_value == encap)
978                         return pcap_to_wtap_map[i].dlt_value;
979         }
980         return -1;
981 }
982
983 /* Returns 0 if we could write the specified encapsulation type,
984    an error indication otherwise. */
985 int libpcap_dump_can_write_encap(int filetype, int encap)
986 {
987         /* Per-packet encapsulations aren't supported. */
988         if (encap == WTAP_ENCAP_PER_PACKET)
989                 return WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED;
990
991         if (wtap_wtap_encap_to_pcap_encap(encap) == -1)
992                 return WTAP_ERR_UNSUPPORTED_ENCAP;
993
994         return 0;
995 }
996
997 /* Returns TRUE on success, FALSE on failure; sets "*err" to an error code on
998    failure */
999 gboolean libpcap_dump_open(wtap_dumper *wdh, int *err)
1000 {
1001         guint32 magic;
1002         struct pcap_hdr file_hdr;
1003         size_t nwritten;
1004
1005         /* This is a libpcap file */
1006         wdh->subtype_write = libpcap_dump;
1007         wdh->subtype_close = NULL;
1008
1009         /* Write the file header. */
1010         switch (wdh->file_type) {
1011
1012         case WTAP_FILE_PCAP:
1013         case WTAP_FILE_PCAP_SS990417:   /* modified, but with the old magic, sigh */
1014         case WTAP_FILE_PCAP_NOKIA:      /* Nokia libpcap of some sort */
1015                 magic = PCAP_MAGIC;
1016                 break;
1017
1018         case WTAP_FILE_PCAP_SS990915:   /* new magic, extra crap */
1019         case WTAP_FILE_PCAP_SS991029:
1020                 magic = PCAP_MODIFIED_MAGIC;
1021                 break;
1022
1023         default:
1024                 /* We should never get here - our open routine
1025                    should only get called for the types above. */
1026                 *err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
1027                 return FALSE;
1028         }
1029
1030         nwritten = fwrite(&magic, 1, sizeof magic, wdh->fh);
1031         if (nwritten != sizeof magic) {
1032                 if (nwritten == 0 && ferror(wdh->fh))
1033                         *err = errno;
1034                 else
1035                         *err = WTAP_ERR_SHORT_WRITE;
1036                 return FALSE;
1037         }
1038         wdh->bytes_dumped += sizeof magic;
1039
1040         /* current "libpcap" format is 2.4 */
1041         file_hdr.version_major = 2;
1042         file_hdr.version_minor = 4;
1043         file_hdr.thiszone = 0;  /* XXX - current offset? */
1044         file_hdr.sigfigs = 0;   /* unknown, but also apparently unused */
1045         file_hdr.snaplen = wdh->snaplen;
1046         file_hdr.network = wtap_wtap_encap_to_pcap_encap(wdh->encap);
1047         nwritten = fwrite(&file_hdr, 1, sizeof file_hdr, wdh->fh);
1048         if (nwritten != sizeof file_hdr) {
1049                 if (nwritten == 0 && ferror(wdh->fh))
1050                         *err = errno;
1051                 else
1052                         *err = WTAP_ERR_SHORT_WRITE;
1053                 return FALSE;
1054         }
1055         wdh->bytes_dumped += sizeof file_hdr;
1056
1057         return TRUE;
1058 }
1059
1060 /* Write a record for a packet to a dump file.
1061    Returns TRUE on success, FALSE on failure. */
1062 static gboolean libpcap_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
1063     const union wtap_pseudo_header *pseudo_header, const u_char *pd, int *err)
1064 {
1065         struct pcaprec_ss990915_hdr rec_hdr;
1066         size_t hdr_size;
1067         size_t nwritten;
1068
1069         rec_hdr.hdr.ts_sec = phdr->ts.tv_sec;
1070         rec_hdr.hdr.ts_usec = phdr->ts.tv_usec;
1071         rec_hdr.hdr.incl_len = phdr->caplen;
1072         rec_hdr.hdr.orig_len = phdr->len;
1073         switch (wdh->file_type) {
1074
1075         case WTAP_FILE_PCAP:
1076                 hdr_size = sizeof (struct pcaprec_hdr);
1077                 break;
1078
1079         case WTAP_FILE_PCAP_SS990417:   /* modified, but with the old magic, sigh */
1080         case WTAP_FILE_PCAP_SS991029:
1081                 /* XXX - what should we supply here?
1082
1083                    Alexey's "libpcap" looks up the interface in the system's
1084                    interface list if "ifindex" is non-zero, and prints
1085                    the interface name.  It ignores "protocol", and uses
1086                    "pkt_type" to tag the packet as "host", "broadcast",
1087                    "multicast", "other host", "outgoing", or "none of the
1088                    above", but that's it.
1089
1090                    If the capture we're writing isn't a modified or
1091                    RH 6.1 capture, we'd have to do some work to
1092                    generate the packet type and interface index - and
1093                    we can't generate the interface index unless we
1094                    just did the capture ourselves in any case.
1095
1096                    I'm inclined to continue to punt; systems other than
1097                    those with the older patch can read standard "libpcap"
1098                    files, and systems with the older patch, e.g. RH 6.1,
1099                    will just have to live with this. */
1100                 rec_hdr.ifindex = 0;
1101                 rec_hdr.protocol = 0;
1102                 rec_hdr.pkt_type = 0;
1103                 hdr_size = sizeof (struct pcaprec_modified_hdr);
1104                 break;
1105
1106         case WTAP_FILE_PCAP_SS990915:   /* new magic, extra crap at the end */
1107                 rec_hdr.ifindex = 0;
1108                 rec_hdr.protocol = 0;
1109                 rec_hdr.pkt_type = 0;
1110                 rec_hdr.cpu1 = 0;
1111                 rec_hdr.cpu2 = 0;
1112                 hdr_size = sizeof (struct pcaprec_ss990915_hdr);
1113                 break;
1114
1115         case WTAP_FILE_PCAP_NOKIA:      /* old magic, extra crap at the end */
1116                 rec_hdr.ifindex = 0;
1117                 rec_hdr.protocol = 0;
1118                 rec_hdr.pkt_type = 0;
1119                 rec_hdr.cpu1 = 0;
1120                 rec_hdr.cpu2 = 0;
1121                 hdr_size = sizeof (struct pcaprec_nokia_hdr);
1122                 break;
1123
1124         default:
1125                 /* We should never get here - our open routine
1126                    should only get called for the types above. */
1127                 g_assert_not_reached();
1128                 *err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
1129                 return FALSE;
1130         }
1131
1132         nwritten = fwrite(&rec_hdr, 1, hdr_size, wdh->fh);
1133         if (nwritten != hdr_size) {
1134                 if (nwritten == 0 && ferror(wdh->fh))
1135                         *err = errno;
1136                 else
1137                         *err = WTAP_ERR_SHORT_WRITE;
1138                 return FALSE;
1139         }
1140         wdh->bytes_dumped += hdr_size;
1141         nwritten = fwrite(pd, 1, phdr->caplen, wdh->fh);
1142         if (nwritten != phdr->caplen) {
1143                 if (nwritten == 0 && ferror(wdh->fh))
1144                         *err = errno;
1145                 else
1146                         *err = WTAP_ERR_SHORT_WRITE;
1147                 return FALSE;
1148         }
1149         wdh->bytes_dumped += phdr->caplen;
1150         return TRUE;
1151 }