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