Fix files that had Gilbert's old e-mail address or that didn't have my
[obnox/wireshark/wip.git] / wiretap / snoop.c
1 /* snoop.c
2  *
3  * $Id: snoop.c,v 1.24 2000/01/22 06:22:43 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 <errno.h>
27 #include "wtap.h"
28 #include "file_wrappers.h"
29 #include "buffer.h"
30 #include "snoop.h"
31 #ifdef HAVE_NETINET_IN_H
32 #include <netinet/in.h>
33 #endif
34
35 /* See RFC 1761 for a description of the "snoop" file format. */
36
37 /* Magic number in "snoop" files. */
38 static const char snoop_magic[] = {
39         's', 'n', 'o', 'o', 'p', '\0', '\0', '\0'
40 };
41
42 /* "snoop" file header (minus magic number). */
43 struct snoop_hdr {
44         guint32 version;        /* version number (should be 2) */
45         guint32 network;        /* network type */
46 };
47
48 /* "snoop" record header. */
49 struct snooprec_hdr {
50         guint32 orig_len;       /* actual length of packet */
51         guint32 incl_len;       /* number of octets captured in file */
52         guint32 rec_len;        /* length of record */
53         guint32 cum_drops;      /* cumulative number of dropped packets */
54         guint32 ts_sec;         /* timestamp seconds */
55         guint32 ts_usec;        /* timestamp microseconds */
56 };
57
58 static int snoop_read(wtap *wth, int *err);
59 static gboolean snoop_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
60     const u_char *pd, int *err);
61
62 /*
63  * See
64  * 
65  *      http://www.opengroup.org/onlinepubs/9638599/apdxf.htm
66  *
67  * for the "dlpi.h" header file specified by The Open Group, which lists
68  * the DL_ values for various protocols; Solaris 7 uses the same values.
69  *
70  * The page at
71  *
72  *      http://mrpink.lerc.nasa.gov/118x/support.html
73  *
74  * has links to modified versions of "tcpdump" and "libpcap" for SUNatm
75  * DLPI support; they suggest the 3.0 verson of SUNatm uses those
76  * values.
77  *
78  * It also has a link to "convert.c", which is a program to convert files
79  * from the format written by the "atmsnoop" program that comes with the
80  * SunATM package to regular "snoop" format, claims that "SunATM 2.1 claimed
81  * to be DL_FDDI (don't ask why).  SunATM 3.0 claims to be DL_IPATM, which
82  * is 0x12".
83  *
84  * It also says that "ATM Mac header is 12 bytes long.", and seems to imply
85  * that in an "atmsnoop" file, the header contains 2 bytes (direction and
86  * VPI?), 2 bytes of VCI, 6 bytes of something, and 2 bytes of Ethernet
87  * type; if those 6 bytes are 2 bytes of DSAP, 2 bytes of LSAP, 1 byte
88  * of LLC control, and 3 bytes of SNAP OUI, that'd mean that an ATM
89  * pseudo-header in an "atmsnoop" file is probably 1 byte of direction,
90  * 1 byte of VPI, and 2 bytes of VCI.
91  *
92  * The aforementioned page also has a link to some capture files from
93  * "atmsnoop"; this version of "snoop.c" appears to be able to read them.
94  *
95  * Source to an "atmdump" package, which includes a modified version of
96  * "libpcap" to handle SunATM DLPI and an ATM driver for FreeBSD, and
97  * also includes "atmdump", which is a modified "tcpdump", says that an
98  * ATM packet handed up from the Sun driver for the Sun SBus ATM card on
99  * Solaris 2.5.1 has 1 byte of direction, 1 byte of VPI, 2 bytes of VCI,
100  * and then the ATM PDU, and suggests that the direction byte is 0x80 for
101  * "transmitted" (presumably meaning DTE->DCE) and presumably not 0x80 for
102  * "received" (presumably meaning DCE->DTE).
103  *
104  * In fact, the "direction" byte appears to have some other stuff, perhaps
105  * a traffic type, in the lower 7 bits, with the 8th bit indicating the
106  * direction.
107  *
108  * I don't know what the encapsulation of any of the other types is, so I
109  * leave them all as WTAP_ENCAP_UNKNOWN.  I also don't know whether "snoop"
110  * can handle any of them (it presumably can't handle ATM, otherwise Sun
111  * wouldn't have supplied "atmsnoop"; even if it can't, this may be useful
112  * reference information for anybody doing code to use DLPI to do raw packet
113  * captures on those network types.
114  */
115 int snoop_open(wtap *wth, int *err)
116 {
117         int bytes_read;
118         char magic[sizeof snoop_magic];
119         struct snoop_hdr hdr;
120         static const int snoop_encap[] = {
121                 WTAP_ENCAP_ETHERNET,    /* IEEE 802.3 */
122                 WTAP_ENCAP_UNKNOWN,     /* IEEE 802.4 Token Bus */
123                 WTAP_ENCAP_TR,
124                 WTAP_ENCAP_UNKNOWN,     /* IEEE 802.6 Metro Net */
125                 WTAP_ENCAP_ETHERNET,
126                 WTAP_ENCAP_UNKNOWN,     /* HDLC */
127                 WTAP_ENCAP_UNKNOWN,     /* Character Synchronous, e.g. bisync */
128                 WTAP_ENCAP_UNKNOWN,     /* IBM Channel-to-Channel */
129                 WTAP_ENCAP_FDDI_BITSWAPPED,
130                 WTAP_ENCAP_UNKNOWN,     /* Other */
131                 WTAP_ENCAP_UNKNOWN,     /* Frame Relay LAPF */
132                 WTAP_ENCAP_UNKNOWN,     /* Multi-protocol over Frame Relay */
133                 WTAP_ENCAP_UNKNOWN,     /* Character Async (e.g., SLIP and PPP?) */
134                 WTAP_ENCAP_UNKNOWN,     /* X.25 Classical IP */
135                 WTAP_ENCAP_UNKNOWN,     /* software loopback */
136                 WTAP_ENCAP_UNKNOWN,     /* not defined in "dlpi.h" */
137                 WTAP_ENCAP_UNKNOWN,     /* Fibre Channel */
138                 WTAP_ENCAP_UNKNOWN,     /* ATM */
139                 WTAP_ENCAP_ATM_SNIFFER, /* ATM Classical IP */
140                 WTAP_ENCAP_UNKNOWN,     /* X.25 LAPB */
141                 WTAP_ENCAP_UNKNOWN,     /* ISDN */
142                 WTAP_ENCAP_UNKNOWN,     /* HIPPI */
143                 WTAP_ENCAP_UNKNOWN,     /* 100VG-AnyLAN Ethernet */
144                 WTAP_ENCAP_UNKNOWN,     /* 100VG-AnyLAN Token Ring */
145                 WTAP_ENCAP_UNKNOWN,     /* "ISO 8802/3 and Ethernet" */
146                 WTAP_ENCAP_UNKNOWN,     /* 100BaseT (but that's just Ethernet) */
147         };
148         #define NUM_SNOOP_ENCAPS (sizeof snoop_encap / sizeof snoop_encap[0])
149
150         /* Read in the string that should be at the start of a "snoop" file */
151         file_seek(wth->fh, 0, SEEK_SET);
152         wth->data_offset = 0;
153         errno = WTAP_ERR_CANT_READ;
154         bytes_read = file_read(magic, 1, sizeof magic, wth->fh);
155         if (bytes_read != sizeof magic) {
156                 *err = file_error(wth->fh);
157                 if (*err != 0)
158                         return -1;
159                 return 0;
160         }
161         wth->data_offset += sizeof magic;
162
163         if (memcmp(magic, snoop_magic, sizeof snoop_magic) != 0) {
164                 return 0;
165         }
166
167         /* Read the rest of the header. */
168         errno = WTAP_ERR_CANT_READ;
169         bytes_read = file_read(&hdr, 1, sizeof hdr, wth->fh);
170         if (bytes_read != sizeof hdr) {
171                 *err = file_error(wth->fh);
172                 if (*err != 0)
173                         return -1;
174                 return 0;
175         }
176         wth->data_offset += sizeof hdr;
177
178         hdr.version = ntohl(hdr.version);
179         if (hdr.version != 2) {
180                 /* We only support version 2. */
181                 g_message("snoop: version %u unsupported", hdr.version);
182                 *err = WTAP_ERR_UNSUPPORTED;
183                 return -1;
184         }
185         hdr.network = ntohl(hdr.network);
186         if (hdr.network >= NUM_SNOOP_ENCAPS
187             || snoop_encap[hdr.network] == WTAP_ENCAP_UNKNOWN) {
188                 g_message("snoop: network type %u unknown or unsupported",
189                     hdr.network);
190                 *err = WTAP_ERR_UNSUPPORTED;
191                 return -1;
192         }
193
194         /* This is a snoop file */
195         wth->file_type = WTAP_FILE_SNOOP;
196         wth->subtype_read = snoop_read;
197         wth->file_encap = snoop_encap[hdr.network];
198         wth->snapshot_length = 16384;   /* XXX - not available in header */
199         return 1;
200 }
201
202 /* Read the next packet */
203 static int snoop_read(wtap *wth, int *err)
204 {
205         guint32 rec_size;
206         guint32 packet_size;
207         guint32 orig_size;
208         int     bytes_read;
209         struct snooprec_hdr hdr;
210         char    atm_phdr[4];
211         int     data_offset;
212         char    padbuf[4];
213         int     padbytes;
214         int     bytes_to_read;
215
216         /* Read record header. */
217         errno = WTAP_ERR_CANT_READ;
218         bytes_read = file_read(&hdr, 1, sizeof hdr, wth->fh);
219         if (bytes_read != sizeof hdr) {
220                 *err = file_error(wth->fh);
221                 if (*err != 0)
222                         return -1;
223                 if (bytes_read != 0) {
224                         *err = WTAP_ERR_SHORT_READ;
225                         return -1;
226                 }
227                 return 0;
228         }
229         wth->data_offset += sizeof hdr;
230
231         rec_size = ntohl(hdr.rec_len);
232         orig_size = ntohl(hdr.orig_len);
233         packet_size = ntohl(hdr.incl_len);
234         if (packet_size > WTAP_MAX_PACKET_SIZE) {
235                 /*
236                  * Probably a corrupt capture file; don't blow up trying
237                  * to allocate space for an immensely-large packet.
238                  */
239                 g_message("snoop: File has %u-byte packet, bigger than maximum of %u",
240                     packet_size, WTAP_MAX_PACKET_SIZE);
241                 *err = WTAP_ERR_BAD_RECORD;
242                 return -1;
243         }
244
245         /*
246          * If this is an ATM packet, the first four bytes are the
247          * direction of the packet (transmit/receive), the VPI, and
248          * the VCI; read them and generate the pseudo-header from
249          * them.
250          */
251         if (wth->file_encap == WTAP_ENCAP_ATM_SNIFFER) {
252                 if (packet_size < 4) {
253                         /*
254                          * Uh-oh, the packet isn't big enough to even
255                          * have a pseudo-header.
256                          */
257                         g_message("snoop: atmsnoop file has a %u-byte packet, too small to have even an ATM pseudo-header\n",
258                             packet_size);
259                         *err = WTAP_ERR_BAD_RECORD;
260                         return -1;
261                 }
262                 errno = WTAP_ERR_CANT_READ;
263                 bytes_read = file_read(atm_phdr, 1, 4, wth->fh);
264                 if (bytes_read != 4) {
265                         *err = file_error(wth->fh);
266                         if (*err == 0)
267                                 *err = WTAP_ERR_SHORT_READ;
268                         return -1;
269                 }
270
271                 wth->phdr.pseudo_header.ngsniffer_atm.channel =
272                     (atm_phdr[0] & 0x80) ? 1 : 0;
273                 wth->phdr.pseudo_header.ngsniffer_atm.Vpi = atm_phdr[1];
274                 wth->phdr.pseudo_header.ngsniffer_atm.Vci = pntohs(&atm_phdr[2]);
275
276                 /* We don't have this information */
277                 wth->phdr.pseudo_header.ngsniffer_atm.cells = 0;
278                 wth->phdr.pseudo_header.ngsniffer_atm.aal5t_u2u = 0;
279                 wth->phdr.pseudo_header.ngsniffer_atm.aal5t_len = 0;
280                 wth->phdr.pseudo_header.ngsniffer_atm.aal5t_chksum = 0;
281
282                 /*
283                  * Assume it's AAL5; we know nothing more about it.
284                  *
285                  * For what it's worth, in one "atmsnoop" capture,
286                  * the lower 7 bits of the first byte of the header
287                  * were 0x05 for ILMI traffic, 0x06 for Signalling
288                  * AAL traffic, and 0x02 for at least some RFC 1483-style
289                  * LLC multiplexed traffic.
290                  */
291                 wth->phdr.pseudo_header.ngsniffer_atm.AppTrafType =
292                     ATT_AAL5|ATT_HL_UNKNOWN;
293                 wth->phdr.pseudo_header.ngsniffer_atm.AppHLType =
294                     AHLT_UNKNOWN;
295
296                 /*
297                  * Don't count the pseudo-header as part of the packet.
298                  */
299                 rec_size -= 4;
300                 orig_size -= 4;
301                 packet_size -= 4;
302                 wth->data_offset += 4;
303         }
304
305         buffer_assure_space(wth->frame_buffer, packet_size);
306         data_offset = wth->data_offset;
307         errno = WTAP_ERR_CANT_READ;
308         bytes_read = file_read(buffer_start_ptr(wth->frame_buffer), 1,
309                         packet_size, wth->fh);
310
311         if (bytes_read != packet_size) {
312                 *err = file_error(wth->fh);
313                 if (*err == 0)
314                         *err = WTAP_ERR_SHORT_READ;
315                 return -1;
316         }
317         wth->data_offset += packet_size;
318
319         wth->phdr.ts.tv_sec = ntohl(hdr.ts_sec);
320         wth->phdr.ts.tv_usec = ntohl(hdr.ts_usec);
321         wth->phdr.caplen = packet_size;
322         wth->phdr.len = orig_size;
323         wth->phdr.pkt_encap = wth->file_encap;
324
325         /*
326          * Skip over the padding (don't "fseek()", as the standard
327          * I/O library on some platforms discards buffered data if
328          * you do that, which means it does a lot more reads).
329          * There's probably not much padding (it's probably padded only
330          * to a 4-byte boundary), so we probably need only do one read.
331          */
332         padbytes = rec_size - (sizeof hdr + packet_size);
333         while (padbytes != 0) {
334                 bytes_to_read = padbytes;
335                 if (bytes_to_read > sizeof padbuf)
336                         bytes_to_read = sizeof padbuf;
337                 errno = WTAP_ERR_CANT_READ;
338                 bytes_read = file_read(padbuf, 1, bytes_to_read, wth->fh);
339                 if (bytes_read != bytes_to_read) {
340                         *err = file_error(wth->fh);
341                         if (*err == 0)
342                                 *err = WTAP_ERR_SHORT_READ;
343                         return -1;
344                 }
345                 wth->data_offset += bytes_read;
346                 padbytes -= bytes_read;
347         }
348
349         return data_offset;
350 }
351
352 static const int wtap_encap[] = {
353         -1,             /* WTAP_ENCAP_UNKNOWN -> unsupported */
354         0x04,           /* WTAP_ENCAP_ETHERNET -> DL_ETHER */
355         0x02,           /* WTAP_ENCAP_TR -> DL_TPR */
356         -1,             /* WTAP_ENCAP_SLIP -> unsupported */
357         -1,             /* WTAP_ENCAP_PPP -> unsupported */
358         0x08,           /* WTAP_ENCAP_FDDI -> DL_FDDI */
359         0x08,           /* WTAP_ENCAP_FDDI_BITSWAPPED -> DL_FDDI */
360         -1,             /* WTAP_ENCAP_RAW_IP -> unsupported */
361         -1,             /* WTAP_ENCAP_ARCNET -> unsupported */
362         -1,             /* WTAP_ENCAP_ATM_RFC1483 -> unsupported */
363         -1,             /* WTAP_ENCAP_LINUX_ATM_CLIP -> unsupported */
364         -1,             /* WTAP_ENCAP_LAPB -> unsupported*/
365         -1,             /* WTAP_ENCAP_ATM_SNIFFER -> unsupported */
366         0               /* WTAP_ENCAP_NULL -> DLT_NULL */
367 };
368 #define NUM_WTAP_ENCAPS (sizeof wtap_encap / sizeof wtap_encap[0])
369
370 /* Returns 0 if we could write the specified encapsulation type,
371    an error indication otherwise. */
372 int snoop_dump_can_write_encap(int filetype, int encap)
373 {
374         /* Per-packet encapsulations aren't supported. */
375         if (encap == WTAP_ENCAP_PER_PACKET)
376                 return WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED;
377
378         if (encap < 0 || encap >= NUM_WTAP_ENCAPS || wtap_encap[encap] == -1)
379                 return WTAP_ERR_UNSUPPORTED_ENCAP;
380
381         return 0;
382 }
383
384 /* Returns TRUE on success, FALSE on failure; sets "*err" to an error code on
385    failure */
386 gboolean snoop_dump_open(wtap_dumper *wdh, int *err)
387 {
388         struct snoop_hdr file_hdr;
389         int nwritten;
390
391         /* This is a snoop file */
392         wdh->subtype_write = snoop_dump;
393         wdh->subtype_close = NULL;
394
395         /* Write the file header. */
396         nwritten = fwrite(&snoop_magic, 1, sizeof snoop_magic, wdh->fh);
397         if (nwritten != sizeof snoop_magic) {
398                 if (nwritten < 0)
399                         *err = errno;
400                 else
401                         *err = WTAP_ERR_SHORT_WRITE;
402                 return FALSE;
403         }
404
405         /* current "snoop" format is 2 */
406         file_hdr.version = htonl(2);
407         file_hdr.network = htonl(wtap_encap[wdh->encap]);
408         nwritten = fwrite(&file_hdr, 1, sizeof file_hdr, wdh->fh);
409         if (nwritten != sizeof file_hdr) {
410                 if (nwritten < 0)
411                         *err = errno;
412                 else
413                         *err = WTAP_ERR_SHORT_WRITE;
414                 return FALSE;
415         }
416
417         return TRUE;
418 }
419
420 /* Write a record for a packet to a dump file.
421    Returns TRUE on success, FALSE on failure. */
422 static gboolean snoop_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
423     const u_char *pd, int *err)
424 {
425         struct snooprec_hdr rec_hdr;
426         int nwritten;
427         int reclen;
428         int padlen;
429         static char zeroes[4];
430
431         /* Record length = header length plus data length... */
432         reclen = sizeof rec_hdr + phdr->caplen;
433
434         /* ... plus enough bytes to pad it to a 4-byte boundary. */
435         padlen = ((reclen + 3) & ~3) - reclen;
436         reclen += padlen;
437
438         rec_hdr.orig_len = htonl(phdr->len);
439         rec_hdr.incl_len = htonl(phdr->caplen);
440         rec_hdr.rec_len = htonl(reclen);
441         rec_hdr.cum_drops = 0;
442         rec_hdr.ts_sec = htonl(phdr->ts.tv_sec);
443         rec_hdr.ts_usec = htonl(phdr->ts.tv_usec);
444         nwritten = fwrite(&rec_hdr, 1, sizeof rec_hdr, wdh->fh);
445         if (nwritten != sizeof rec_hdr) {
446                 if (nwritten < 0)
447                         *err = errno;
448                 else
449                         *err = WTAP_ERR_SHORT_WRITE;
450                 return FALSE;
451         }
452         nwritten = fwrite(pd, 1, phdr->caplen, wdh->fh);
453         if (nwritten != phdr->caplen) {
454                 if (nwritten < 0)
455                         *err = errno;
456                 else
457                         *err = WTAP_ERR_SHORT_WRITE;
458                 return FALSE;
459         }
460
461         /* Now write the padding. */
462         nwritten = fwrite(zeroes, 1, padlen, wdh->fh);
463         if (nwritten != padlen) {
464                 if (nwritten < 0)
465                         *err = errno;
466                 else
467                         *err = WTAP_ERR_SHORT_WRITE;
468                 return FALSE;
469         }
470         return TRUE;
471 }