In the final scene of the horror movie, just when you think the monster
[obnox/wireshark/wip.git] / wiretap / file.c
1 /* file.c
2  *
3  * $Id: file.c,v 1.56 2000/07/26 06:04:32 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
27 #include <stdio.h>
28 #include <fcntl.h>
29 #include <string.h>
30 #include <stdlib.h>
31 #include <sys/stat.h>
32 #include <errno.h>
33
34 #ifdef HAVE_IO_H
35 #include <io.h> /* open/close on win32 */
36 #endif
37
38 #include "wtap-int.h"
39 #include "file_wrappers.h"
40 #include "buffer.h"
41 #include "lanalyzer.h"
42 #include "ngsniffer.h"
43 #include "radcom.h"
44 #include "ascend.h"
45 #include "nettl.h"
46 #include "libpcap.h"
47 #include "snoop.h"
48 #include "iptrace.h"
49 #include "netmon.h"
50 #include "netxray.h"
51 #include "toshiba.h"
52 #include "i4btrace.h"
53
54 /* The open_file_* routines should return:
55  *
56  *      -1 on an I/O error;
57  *
58  *      1 if the file they're reading is one of the types it handles;
59  *
60  *      0 if the file they're reading isn't the type they're checking for.
61  *
62  * If the routine handles this type of file, it should set the "file_type"
63  * field in the "struct wtap" to the type of the file.
64  *
65  * XXX - I need to drag my damn ANSI C spec in to figure out how to
66  * declare a "const" array of pointers to functions; putting "const"
67  * right after "static" isn't the right answer, at least according
68  * to GCC, which whines if I do that.
69  *
70  * Put the trace files that are merely saved telnet-sessions last, since it's
71  * possible that you could have captured someone a router telnet-session
72  * using another tool. So, a libpcap trace of an toshiba "snoop" session
73  * should be discovered as a libpcap file, not a toshiba file.
74  */
75
76 static int (*open_routines[])(wtap *, int *) = {
77         /* Files that have magic bytes in fixed locations. These
78          * are easy to identify.
79          */
80         libpcap_open,
81         lanalyzer_open,
82         ngsniffer_open,
83         snoop_open,
84         iptrace_open,
85         netmon_open,
86         netxray_open,
87         radcom_open,
88         nettl_open,
89
90         /* Files whose magic headers are in text *somewhere* in the
91          * file (usually because the trace is just a saved copy of
92          * the telnet session). 
93          */
94         ascend_open,
95         toshiba_open,
96         i4btrace_open,
97 };
98
99 int wtap_def_seek_read(wtap *wth, int seek_off,
100         union wtap_pseudo_header *pseudo_header, guint8 *pd, int len)
101 {
102         file_seek(wth->random_fh, seek_off, SEEK_SET);
103
104         return file_read(pd, sizeof(guint8), len, wth->random_fh);
105 }
106
107 #define N_FILE_TYPES    (sizeof open_routines / sizeof open_routines[0])
108
109 /* Opens a file and prepares a wtap struct.
110    If "do_random" is TRUE, it opens the file twice; the second open
111    allows the application to do random-access I/O without moving
112    the seek offset for sequential I/O, which is used by Ethereal
113    so that it can do sequential I/O to a capture file that's being
114    written to as new packets arrive independently of random I/O done
115    to display protocol trees for packets when they're selected. */
116 wtap* wtap_open_offline(const char *filename, int *err, gboolean do_random)
117 {
118         struct stat statb;
119         wtap    *wth;
120         int     i;
121
122         /* First, make sure the file is valid */
123         if (stat(filename, &statb) < 0) {
124                 *err = errno;
125                 return NULL;
126         }
127 #ifndef WIN32
128         if (! S_ISREG(statb.st_mode) && ! S_ISFIFO(statb.st_mode)) {
129                 if (S_ISDIR(statb.st_mode))
130                         *err = EISDIR;
131                 else
132                         *err = WTAP_ERR_NOT_REGULAR_FILE;
133                 return NULL;
134         }
135 #endif
136
137         errno = ENOMEM;
138         wth = g_malloc(sizeof(wtap));
139         if (wth == NULL) {
140                 *err = errno;
141                 return NULL;
142         }
143
144 /* Win32 needs the O_BINARY flag for open() */
145 #ifndef O_BINARY
146 #define O_BINARY        0
147 #endif
148
149         /* Open the file */
150         errno = WTAP_ERR_CANT_OPEN;
151         wth->fd = open(filename, O_RDONLY|O_BINARY);
152         if (wth->fd < 0) {
153                 *err = errno;
154                 g_free(wth);
155                 return NULL;
156         }
157         if (!(wth->fh = filed_open(wth->fd, "rb"))) {
158                 *err = errno;
159                 g_free(wth);
160                 return NULL;
161         }
162
163         if (do_random) {
164                 if (!(wth->random_fh = file_open(filename, "rb"))) {
165                         *err = errno;
166                         file_close(wth->fh);
167                         g_free(wth);
168                         return NULL;
169                 }
170         } else
171                 wth->random_fh = NULL;
172
173         /* initialization */
174         wth->file_encap = WTAP_ENCAP_UNKNOWN;
175         wth->data_offset = 0;
176         wth->subtype_sequential_close = NULL;
177         wth->subtype_close = NULL;
178
179         /* Try all file types */
180         for (i = 0; i < N_FILE_TYPES; i++) {
181                 switch ((*open_routines[i])(wth, err)) {
182
183                 case -1:
184                         /* I/O error - give up */
185                         file_close(wth->fh);
186                         g_free(wth);
187                         return NULL;
188
189                 case 0:
190                         /* No I/O error, but not that type of file */
191                         break;
192
193                 case 1:
194                         /* We found the file type */
195                         goto success;
196                 }
197         }
198
199         /* Well, it's not one of the types of file we know about. */
200         if (wth->random_fh != NULL)
201                 file_close(wth->random_fh);
202         file_close(wth->fh);
203         g_free(wth);
204         *err = WTAP_ERR_FILE_UNKNOWN_FORMAT;
205         return NULL;
206
207 success:
208         wth->frame_buffer = g_malloc(sizeof(struct Buffer));
209         buffer_init(wth->frame_buffer, 1500);
210         return wth;
211 }
212
213 /* Table of the file types we know about. */
214 const static struct file_type_info {
215         const char *name;
216         const char *short_name;
217         int     (*can_write_encap)(int, int);
218         int     (*dump_open)(wtap_dumper *, int *);
219 } dump_open_table[WTAP_NUM_FILE_TYPES] = {
220         /* WTAP_FILE_UNKNOWN */
221         { NULL, NULL,
222           NULL, NULL },
223
224         /* WTAP_FILE_WTAP */
225         { "Wiretap (Ethereal)", NULL,
226           NULL, NULL },
227
228         /* WTAP_FILE_PCAP */
229         { "libpcap (tcpdump, Ethereal, etc.)", "libpcap",
230           libpcap_dump_can_write_encap, libpcap_dump_open },
231
232         /* WTAP_FILE_PCAP_SS990417 */
233         { "Red Hat Linux 6.1 libpcap (tcpdump)", "rh6_1libpcap",
234           libpcap_dump_can_write_encap, libpcap_dump_open },
235
236         /* WTAP_FILE_PCAP_SS990915 */
237         { "SuSE Linux 6.3 libpcap (tcpdump)", "suse6_3libpcap",
238           libpcap_dump_can_write_encap, libpcap_dump_open },
239
240         /* WTAP_FILE_PCAP_SS991029 */
241         { "modified libpcap (tcpdump)", "modlibpcap",
242           libpcap_dump_can_write_encap, libpcap_dump_open },
243
244         /* WTAP_FILE_LANALYZER */
245         { "Novell LANalyzer", NULL,
246           NULL, NULL },
247
248         /* WTAP_FILE_NGSNIFFER_UNCOMPRESSED */
249         { "Network Associates Sniffer (DOS-based)", "ngsniffer",
250           ngsniffer_dump_can_write_encap, ngsniffer_dump_open },
251
252         /* WTAP_FILE_NGSNIFFER_COMPRESSED */
253         { "Network Associates Sniffer (DOS-based), compressed", "ngsniffer_comp",
254           NULL, NULL },
255
256         /* WTAP_FILE_SNOOP */
257         { "Sun snoop", "snoop",
258           snoop_dump_can_write_encap, snoop_dump_open },
259
260         /* WTAP_FILE_IPTRACE_1_0 */
261         { "AIX iptrace 1.0", NULL,
262           NULL, NULL },
263
264         /* WTAP_FILE_IPTRACE_2_0 */
265         { "AIX iptrace 2.0", NULL,
266           NULL, NULL },
267
268         /* WTAP_FILE_NETMON_1_x */
269         { "Microsoft Network Monitor 1.x", "netmon1",
270           netmon_dump_can_write_encap, netmon_dump_open },
271
272         /* WTAP_FILE_NETMON_2_x */
273         { "Microsoft Network Monitor 2.x", NULL,
274           NULL, NULL },
275
276         /* WTAP_FILE_NETXRAY_1_0 */
277         { "Cinco Networks NetXRay", NULL,
278           NULL, NULL },
279
280         /* WTAP_FILE_NETXRAY_1_1 */
281         { "Network Associates Sniffer (Windows-based) 1.1", "ngwsniffer_1_1",
282           netxray_dump_can_write_encap, netxray_dump_open_1_1 },
283
284         /* WTAP_FILE_NETXRAY_2_00x */
285         { "Network Associates Sniffer (Windows-based) 2.00x", NULL,
286           NULL, NULL },
287
288         /* WTAP_FILE_RADCOM */
289         { "RADCOM WAN/LAN analyzer", NULL,
290           NULL, NULL },
291
292         /* WTAP_FILE_ASCEND */
293         { "Lucent/Ascend access server trace", NULL,
294           NULL, NULL },
295
296         /* WTAP_FILE_NETTL */
297         { "HP-UX nettl trace", NULL,
298           NULL, NULL },
299
300         /* WTAP_FILE_TOSHIBA */
301         { "Toshiba Compact ISDN Router snoop trace", NULL,
302           NULL, NULL },
303
304         /* WTAP_FILE_I4BTRACE */
305         { "I4B ISDN trace", NULL,
306           NULL, NULL },
307
308 };
309
310 /* Name that should be somewhat descriptive. */
311 const char *wtap_file_type_string(int filetype)
312 {
313         if (filetype < 0 || filetype >= WTAP_NUM_FILE_TYPES) {
314                 g_error("Unknown capture file type %d", filetype);
315                 return NULL;
316         } else
317                 return dump_open_table[filetype].name;
318 }
319
320 /* Name to use in, say, a command-line flag specifying the type. */
321 const char *wtap_file_type_short_string(int filetype)
322 {
323         if (filetype < 0 || filetype >= WTAP_NUM_FILE_TYPES)
324                 return NULL;
325         else
326                 return dump_open_table[filetype].short_name;
327 }
328
329 /* Translate a short name to a capture file type. */
330 int wtap_short_string_to_file_type(const char *short_name)
331 {
332         int filetype;
333
334         for (filetype = 0; filetype < WTAP_NUM_FILE_TYPES; filetype++) {
335                 if (dump_open_table[filetype].short_name != NULL &&
336                     strcmp(short_name, dump_open_table[filetype].short_name) == 0)
337                         return filetype;
338         }
339         return -1;      /* no such file type, or we can't write it */
340 }
341
342 gboolean wtap_dump_can_open(int filetype)
343 {
344         if (filetype < 0 || filetype >= WTAP_NUM_FILE_TYPES
345             || dump_open_table[filetype].dump_open == NULL)
346                 return FALSE;
347
348         return TRUE;
349 }
350
351 gboolean wtap_dump_can_write_encap(int filetype, int encap)
352 {
353         if (filetype < 0 || filetype >= WTAP_NUM_FILE_TYPES
354             || dump_open_table[filetype].can_write_encap == NULL)
355                 return FALSE;
356
357         if ((*dump_open_table[filetype].can_write_encap)(filetype, encap) != 0)
358                 return FALSE;
359
360         return TRUE;
361 }
362
363 static wtap_dumper* wtap_dump_open_common(FILE *fh, int filetype,
364     int encap, int snaplen, int *err);
365
366 wtap_dumper* wtap_dump_open(const char *filename, int filetype, int encap,
367                                 int snaplen, int *err)
368 {
369         FILE *fh;
370
371         /* In case "fopen()" fails but doesn't set "errno", set "errno"
372            to a generic "the open failed" error. */
373         errno = WTAP_ERR_CANT_OPEN;
374         fh = fopen(filename, "wb");
375         if (fh == NULL) {
376                 *err = errno;
377                 return NULL;    /* can't create file */
378         }
379         return wtap_dump_open_common(fh, filetype, encap, snaplen, err);
380 }
381
382 wtap_dumper* wtap_dump_fdopen(int fd, int filetype, int encap, int snaplen,
383                                 int *err)
384 {
385         FILE *fh;
386
387         /* In case "fopen()" fails but doesn't set "errno", set "errno"
388            to a generic "the open failed" error. */
389         errno = WTAP_ERR_CANT_OPEN;
390         fh = fdopen(fd, "wb");
391         if (fh == NULL) {
392                 *err = errno;
393                 return NULL;    /* can't create standard I/O stream */
394         }
395         return wtap_dump_open_common(fh, filetype, encap, snaplen, err);
396 }
397
398 static wtap_dumper* wtap_dump_open_common(FILE *fh, int filetype, int encap,
399                                         int snaplen, int *err)
400 {
401         wtap_dumper *wdh;
402
403         if (filetype < 0 || filetype >= WTAP_NUM_FILE_TYPES
404             || dump_open_table[filetype].dump_open == NULL) {
405                 /* Invalid type, or type we don't know how to write. */
406                 *err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
407                 /* NOTE: this means the FD handed to "wtap_dump_fdopen()"
408                    will be closed if we can't write that file type. */
409                 fclose(fh);
410                 return NULL;
411         }
412
413         /* OK, we know how to write that type; can we write the specified
414            encapsulation type? */
415         *err = (*dump_open_table[filetype].can_write_encap)(filetype, encap);
416         if (*err != 0) {
417                 /* NOTE: this means the FD handed to "wtap_dump_fdopen()"
418                    will be closed if we can't write that encapsulation type. */
419                 fclose(fh);
420                 return NULL;
421         }
422
423         /* OK, we can write the specified encapsulation type.  Allocate
424            a data structure for the output stream. */
425         wdh = g_malloc(sizeof (wtap_dumper));
426         if (wdh == NULL) {
427                 *err = errno;
428                 /* NOTE: this means the FD handed to "wtap_dump_fdopen()"
429                    will be closed if the malloc fails. */
430                 fclose(fh);
431                 return NULL;
432         }
433         wdh->fh = fh;
434         wdh->file_type = filetype;
435         wdh->snaplen = snaplen;
436         wdh->encap = encap;
437         wdh->dump.opaque = NULL;
438         wdh->subtype_write = NULL;
439         wdh->subtype_close = NULL;
440
441         /* Now try to open the file for writing. */
442         if (!(*dump_open_table[filetype].dump_open)(wdh, err)) {
443                 /* The attempt failed. */
444                 g_free(wdh);
445                 /* NOTE: this means the FD handed to "wtap_dump_fdopen()"
446                    will be closed if the open fails. */
447                 fclose(fh);
448                 return NULL;
449         }
450
451         return wdh;     /* success! */
452 }
453
454 FILE* wtap_dump_file(wtap_dumper *wdh)
455 {
456         return wdh->fh;
457 }
458
459 gboolean wtap_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
460     const union wtap_pseudo_header *pseudo_header, const u_char *pd, int *err)
461 {
462         return (wdh->subtype_write)(wdh, phdr, pseudo_header, pd, err);
463 }
464
465 gboolean wtap_dump_close(wtap_dumper *wdh, int *err)
466 {
467         gboolean ret = TRUE;
468
469         if (wdh->subtype_close != NULL) {
470                 /* There's a close routine for this dump stream. */
471                 if (!(wdh->subtype_close)(wdh, err))
472                         ret = FALSE;
473         }
474         errno = WTAP_ERR_CANT_CLOSE;
475         if (fclose(wdh->fh) == EOF) {
476                 if (ret) {
477                         /* The per-format close function succeeded,
478                            but the fclose didn't.  Save the reason
479                            why, if our caller asked for it. */
480                         if (err != NULL)
481                                 *err = errno;
482                 }
483                 ret = FALSE;
484         }
485         if (wdh->dump.opaque != NULL)
486                 g_free(wdh->dump.opaque);
487         g_free(wdh);
488         return ret;
489 }