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