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