osmith
/
wireshark
forked from osmocom/wireshark
1
0
Fork 0
Code Pull Requests Releases Wiki Activity

Add some infrastructure for the use of Ethereal, so it can make a list 

of all the file types in which a file can be saved.

Giving each dumpable file type a routine that checks whether a file of a
given file type and encapsulation can be written lets us hoist some
checks into common code from out of the open routines.

If the "dump close" routine for a dump stream is NULL, have that mean
that there's no action that needs to be taken on a close by the code to
handle that file type; some file types don't need that, as they can be
written purely sequentially.

svn path=/trunk/; revision=1200
This commit is contained in:
Guy Harris 1999-12-04 08:32:14 +00:00
parent c5447af40a
commit 3b93574402
9 changed files with 244 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

177
wiretap/file.c
View File

@ -1,6 +1,6 @@
/* file.c
*
* $Id: file.c,v 1.32 1999/12/04 05:37:36 guy Exp $
* $Id: file.c,v 1.33 1999/12/04 08:32:11 guy Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@verdict.uthscsa.edu>
@ -171,6 +171,114 @@ success:
return wth;
}
/* Table of the file types we know about. */
const static struct file_type_info {
const char *name;
int (*can_dump_encap)(int, int);
int (*dump_open)(wtap_dumper *, int *);
} dump_open_table[WTAP_NUM_FILE_TYPES] = {
/* WTAP_FILE_UNKNOWN */
{ NULL,
NULL, NULL },
/* WTAP_FILE_WTAP */
{ "Wiretap (Ethereal)",
NULL, NULL },
/* WTAP_FILE_PCAP */
{ "libpcap (tcpdump)",
libpcap_dump_can_dump_encap, libpcap_dump_open },
/* WTAP_FILE_PCAP_MODIFIED */
{ "modified libpcap (tcpdump)",
NULL, NULL },
/* WTAP_FILE_LANALYZER */
{ "Novell LANalyzer",
NULL, NULL },
/* WTAP_FILE_NGSNIFFER */
{ "Network Associates Sniffer (DOS-based)",
NULL, NULL },
/* WTAP_FILE_SNOOP */
{ "snoop",
snoop_dump_can_dump_encap, snoop_dump_open },
/* WTAP_FILE_IPTRACE_1_0 */
{ "AIX iptrace 1.0",
NULL, NULL },
/* WTAP_FILE_IPTRACE_2_0 */
{ "AIX iptrace 2.0",
NULL, NULL },
/* WTAP_FILE_NETMON_1_x */
{ "Microsoft Network Monitor 1.x",
netmon_dump_can_dump_encap, netmon_dump_open },
/* WTAP_FILE_NETMON_2_x */
{ "Microsoft Network Monitor 2.x",
NULL, NULL },
/* WTAP_FILE_NETXRAY_1_0 */
{ "Cinco Networks NetXRay",
NULL, NULL },
/* WTAP_FILE_NETXRAY_1_1 */
{ "Network Associates Sniffer (Windows-based) 1.1",
NULL, NULL },
/* WTAP_FILE_NETXRAY_2_001 */
{ "Network Associates Sniffer (Windows-based) 2.001",
NULL, NULL },
/* WTAP_FILE_RADCOM */
{ "RADCOM WAN/LAN analyzer",
NULL, NULL },
/* WTAP_FILE_ASCEND */
{ "Lucent/Ascend access server trace",
NULL, NULL },
/* WTAP_FILE_NETTL */
{ "HP-UX nettl trace",
NULL, NULL },
/* WTAP_FILE_TOSHIBA */
{ "Toshiba Compact ISDN Router snoop trace",
NULL, NULL }
};
const char *wtap_file_type_string(wtap *wth)
{
if (wth->file_type < 0 || wth->file_type >= WTAP_NUM_ENCAP_TYPES) {
g_error("Unknown capture file type %d", wth->file_type);
return NULL;
} else
return dump_open_table[wth->file_type].name;
}
gboolean wtap_can_open(int filetype)
{
if (filetype < 0 || filetype >= WTAP_NUM_ENCAP_TYPES
|| dump_open_table[filetype].dump_open == NULL)
return FALSE;
return TRUE;
}
gboolean wtap_can_dump_encap(int filetype, int encap)
{
if (filetype < 0 || filetype >= WTAP_NUM_ENCAP_TYPES
|| dump_open_table[filetype].can_dump_encap == NULL)
return FALSE;
if ((*dump_open_table[filetype].can_dump_encap)(filetype, encap) != 0)
return FALSE;
return TRUE;
}
static wtap_dumper* wtap_dump_open_common(FILE *fh, int filetype,
int encap, int snaplen, int *err);
@ -207,22 +315,33 @@ wtap_dumper* wtap_dump_fdopen(int fd, int filetype, int encap, int snaplen,
return wtap_dump_open_common(fh, filetype, encap, snaplen, err);
}
const static struct dump_type {
guint type;
int (*dump_open)(wtap_dumper *, int *);
} dump_open_table[] = {
{ WTAP_FILE_PCAP, libpcap_dump_open },
{ WTAP_FILE_SNOOP, snoop_dump_open },
{ WTAP_FILE_NETMON_1_x, netmon_dump_open },
{ 0, NULL }
};
static wtap_dumper* wtap_dump_open_common(FILE *fh, int filetype, int encap,
int snaplen, int *err)
{
wtap_dumper *wdh;
const struct dump_type *dtp;
if (filetype < 0 || filetype >= WTAP_NUM_ENCAP_TYPES
|| dump_open_table[filetype].dump_open == NULL) {
/* Invalid type, or type we don't know how to write. */
*err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
/* NOTE: this means the FD handed to "wtap_dump_fdopen()"
will be closed if we can't write that file type. */
fclose(fh);
return NULL;
}
/* OK, we know how to write that type; can we write the specified
encapsulation type? */
*err = (*dump_open_table[filetype].can_dump_encap)(filetype, encap);
if (*err != 0) {
/* NOTE: this means the FD handed to "wtap_dump_fdopen()"
will be closed if we can't write that encapsulation type. */
fclose(fh);
return NULL;
}
/* OK, we can write the specified encapsulation type. Allocate
a data structure for the output stream. */
wdh = g_malloc(sizeof (wtap_dumper));
if (wdh == NULL) {
*err = errno;
@ -235,24 +354,21 @@ static wtap_dumper* wtap_dump_open_common(FILE *fh, int filetype, int encap,
wdh->file_type = filetype;
wdh->snaplen = snaplen;
wdh->encap = encap;
wdh->private.opaque = NULL;
for (dtp = &dump_open_table[0]; dtp->dump_open != NULL; dtp++) {
if (filetype == dtp->type) {
if (!(*dtp->dump_open)(wdh, err)) {
/* The attempt failed. */
g_free(wdh);
fclose(fh);
return NULL;
}
return wdh; /* success! */
}
wdh->subtype_write = NULL;
wdh->subtype_close = NULL;
/* Now try to open the file for writing. */
if (!(*dump_open_table[filetype].dump_open)(wdh, err)) {
/* The attempt failed. */
g_free(wdh);
/* NOTE: this means the FD handed to "wtap_dump_fdopen()"
will be closed if the open fails. */
fclose(fh);
return NULL;
}
*err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
g_free(wdh);
fclose(fh);
return NULL;
return wdh; /* success! */
}
FILE* wtap_dump_file(wtap_dumper *wdh)
@ -270,8 +386,11 @@ gboolean wtap_dump_close(wtap_dumper *wdh, int *err)
{
gboolean ret = TRUE;
if (!(wdh->subtype_close)(wdh, err))
ret = FALSE;
if (wdh->subtype_close != NULL) {
/* There's a close routine for this dump stream. */
if (!(wdh->subtype_close)(wdh, err))
ret = FALSE;
}
errno = WTAP_ERR_CANT_CLOSE;
if (fclose(wdh->fh) == EOF) {
if (ret) {

74
wiretap/libpcap.c
View File

@ -1,6 +1,6 @@
/* libpcap.c
*
* $Id: libpcap.c,v 1.24 1999/12/04 05:14:38 guy Exp $
* $Id: libpcap.c,v 1.25 1999/12/04 08:32:13 guy Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@verdict.uthscsa.edu>
@ -100,7 +100,6 @@ static int libpcap_read(wtap *wth, int *err);
static void adjust_header(wtap *wth, struct pcaprec_hdr *hdr);
static gboolean libpcap_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
const u_char *pd, int *err);
static gboolean libpcap_dump_close(wtap_dumper *wdh, int *err);
/*
* XXX - this is a bit of a mess. OpenBSD, and perhaps NetBSD, and
@ -460,46 +459,49 @@ int wtap_pcap_encap_to_wtap_encap(int encap)
return pcap_encap[encap];
}
static const int wtap_encap[] = {
-1, /* WTAP_ENCAP_UNKNOWN -> unsupported */
1, /* WTAP_ENCAP_ETHERNET -> DLT_EN10MB */
6, /* WTAP_ENCAP_TR -> DLT_IEEE802 */
8, /* WTAP_ENCAP_SLIP -> DLT_SLIP */
9, /* WTAP_ENCAP_PPP -> DLT_PPP */
10, /* WTAP_ENCAP_FDDI -> DLT_FDDI */
10, /* WTAP_ENCAP_FDDI_BITSWAPPED -> DLT_FDDI */
12, /* WTAP_ENCAP_RAW_IP -> DLT_RAW */
7, /* WTAP_ENCAP_ARCNET -> DLT_ARCNET */
11, /* WTAP_ENCAP_ATM_RFC1483 -> DLT_ATM_RFC1483 */
19, /* WTAP_ENCAP_LINUX_ATM_CLIP */
-1, /* WTAP_ENCAP_LAPB -> unsupported*/
-1, /* WTAP_ENCAP_ATM_SNIFFER -> unsupported */
0 /* WTAP_ENCAP_NULL -> DLT_NULL */
};
#define NUM_WTAP_ENCAPS (sizeof wtap_encap / sizeof wtap_encap[0])
/* Returns 0 if we could write the specified encapsulation type,
an error indication otherwise. */
int libpcap_dump_can_dump_encap(int filetype, int encap)
{
/* Per-packet encapsulations aren't supported. */
if (encap == WTAP_ENCAP_PER_PACKET)
return WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED;
if (encap < 0 || encap >= NUM_WTAP_ENCAPS || wtap_encap[encap] == -1)
return WTAP_ERR_UNSUPPORTED_ENCAP;
return 0;
}
/* Returns TRUE on success, FALSE on failure; sets "*err" to an error code on
failure */
gboolean libpcap_dump_open(wtap_dumper *wdh, int *err)
{
static const guint32 pcap_magic = PCAP_MAGIC;
struct pcap_hdr file_hdr;
static const int wtap_encap[] = {
-1, /* WTAP_ENCAP_UNKNOWN -> unsupported */
1, /* WTAP_ENCAP_ETHERNET -> DLT_EN10MB */
6, /* WTAP_ENCAP_TR -> DLT_IEEE802 */
8, /* WTAP_ENCAP_SLIP -> DLT_SLIP */
9, /* WTAP_ENCAP_PPP -> DLT_PPP */
10, /* WTAP_ENCAP_FDDI -> DLT_FDDI */
10, /* WTAP_ENCAP_FDDI_BITSWAPPED -> DLT_FDDI */
12, /* WTAP_ENCAP_RAW_IP -> DLT_RAW */
7, /* WTAP_ENCAP_ARCNET -> DLT_ARCNET */
11, /* WTAP_ENCAP_ATM_RFC1483 -> DLT_ATM_RFC1483 */
19, /* WTAP_ENCAP_LINUX_ATM_CLIP */
-1, /* WTAP_ENCAP_LAPB -> unsupported*/
-1, /* WTAP_ENCAP_ATM_SNIFFER -> unsupported */
0 /* WTAP_ENCAP_NULL -> DLT_NULL */
};
#define NUM_WTAP_ENCAPS (sizeof wtap_encap / sizeof wtap_encap[0])
int nwritten;
/* Per-packet encapsulations aren't supported. */
if (wdh->encap == WTAP_ENCAP_PER_PACKET) {
*err = WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED;
return FALSE;
}
if (wdh->encap < 0 || wdh->encap >= NUM_WTAP_ENCAPS
|| wtap_encap[wdh->encap] == -1) {
*err = WTAP_ERR_UNSUPPORTED_ENCAP;
return FALSE;
}
/* This is a libpcap file */
wdh->subtype_write = libpcap_dump;
wdh->subtype_close = libpcap_dump_close;
wdh->subtype_close = NULL;
/* Write the file header. */
nwritten = fwrite(&pcap_magic, 1, sizeof pcap_magic, wdh->fh);
@ -560,11 +562,3 @@ static gboolean libpcap_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
}
return TRUE;
}
/* Finish writing to a dump file.
Returns TRUE on success, FALSE on failure. */
static gboolean libpcap_dump_close(wtap_dumper *wdh, int *err)
{
/* Nothing to do here. */
return TRUE;
}

3
wiretap/libpcap.h
View File

@ -1,6 +1,6 @@
/* libpcap.h
*
* $Id: libpcap.h,v 1.4 1999/12/04 05:14:39 guy Exp $
* $Id: libpcap.h,v 1.5 1999/12/04 08:32:13 guy Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@verdict.uthscsa.edu>
@ -23,3 +23,4 @@
int libpcap_open(wtap *wth, int *err);
gboolean libpcap_dump_open(wtap_dumper *wdh, int *err);
int libpcap_dump_can_dump_encap(int filetype, int encap);

28
wiretap/netmon.c
View File

@ -1,6 +1,6 @@
/* netmon.c
*
* $Id: netmon.c,v 1.19 1999/12/04 06:21:45 guy Exp $
* $Id: netmon.c,v 1.20 1999/12/04 08:32:12 guy Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@verdict.uthscsa.edu>
@ -388,22 +388,24 @@ static const int wtap_encap[] = {
};
#define NUM_WTAP_ENCAPS (sizeof wtap_encap / sizeof wtap_encap[0])
/* Returns 0 if we could write the specified encapsulation type,
an error indication otherwise. */
int netmon_dump_can_dump_encap(int filetype, int encap)
{
/* Per-packet encapsulations aren't supported. */
if (encap == WTAP_ENCAP_PER_PACKET)
return WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED;
if (encap < 0 || encap >= NUM_WTAP_ENCAPS || wtap_encap[encap] == -1)
return WTAP_ERR_UNSUPPORTED_ENCAP;
return 0;
}
/* Returns TRUE on success, FALSE on failure; sets "*err" to an error code on
failure */
gboolean netmon_dump_open(wtap_dumper *wdh, int *err)
{
/* Per-packet encapsulations aren't supported. */
if (wdh->encap == WTAP_ENCAP_PER_PACKET) {
*err = WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED;
return FALSE;
}
if (wdh->encap < 0 || wdh->encap >= NUM_WTAP_ENCAPS
|| wtap_encap[wdh->encap] == -1) {
*err = WTAP_ERR_UNSUPPORTED_ENCAP;
return FALSE;
}
/* This is a netmon file */
wdh->subtype_write = netmon_dump;
wdh->subtype_close = netmon_dump_close;

3
wiretap/netmon.h
View File

@ -1,6 +1,6 @@
/* netmon.h
*
* $Id: netmon.h,v 1.3 1999/12/04 05:14:39 guy Exp $
* $Id: netmon.h,v 1.4 1999/12/04 08:32:12 guy Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@verdict.uthscsa.edu>
@ -23,3 +23,4 @@
int netmon_open(wtap *wth, int *err);
gboolean netmon_dump_open(wtap_dumper *wdh, int *err);
int netmon_dump_can_dump_encap(int filetype, int encap);

74
wiretap/snoop.c
View File

@ -1,6 +1,6 @@
/* snoop.c
*
* $Id: snoop.c,v 1.19 1999/12/04 05:14:39 guy Exp $
* $Id: snoop.c,v 1.20 1999/12/04 08:32:12 guy Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@verdict.uthscsa.edu>
@ -58,7 +58,6 @@ struct snooprec_hdr {
static int snoop_read(wtap *wth, int *err);
static gboolean snoop_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
const u_char *pd, int *err);
static gboolean snoop_dump_close(wtap_dumper *wdh, int *err);
/*
* See
@ -350,45 +349,48 @@ static int snoop_read(wtap *wth, int *err)
return data_offset;
}
static const int wtap_encap[] = {
-1, /* WTAP_ENCAP_UNKNOWN -> unsupported */
0x04, /* WTAP_ENCAP_ETHERNET -> DL_ETHER */
0x02, /* WTAP_ENCAP_TR -> DL_TPR */
-1, /* WTAP_ENCAP_SLIP -> unsupported */
-1, /* WTAP_ENCAP_PPP -> unsupported */
0x08, /* WTAP_ENCAP_FDDI -> DL_FDDI */
0x08, /* WTAP_ENCAP_FDDI_BITSWAPPED -> DL_FDDI */
-1, /* WTAP_ENCAP_RAW_IP -> unsupported */
-1, /* WTAP_ENCAP_ARCNET -> unsupported */
-1, /* WTAP_ENCAP_ATM_RFC1483 -> unsupported */
-1, /* WTAP_ENCAP_LINUX_ATM_CLIP -> unsupported */
-1, /* WTAP_ENCAP_LAPB -> unsupported*/
-1, /* WTAP_ENCAP_ATM_SNIFFER -> unsupported */
0 /* WTAP_ENCAP_NULL -> DLT_NULL */
};
#define NUM_WTAP_ENCAPS (sizeof wtap_encap / sizeof wtap_encap[0])
/* Returns 0 if we could write the specified encapsulation type,
an error indication otherwise. */
int snoop_dump_can_dump_encap(int filetype, int encap)
{
/* Per-packet encapsulations aren't supported. */
if (encap == WTAP_ENCAP_PER_PACKET)
return WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED;
if (encap < 0 || encap >= NUM_WTAP_ENCAPS || wtap_encap[encap] == -1)
return WTAP_ERR_UNSUPPORTED_ENCAP;
return 0;
}
/* Returns TRUE on success, FALSE on failure; sets "*err" to an error code on
failure */
gboolean snoop_dump_open(wtap_dumper *wdh, int *err)
{
struct snoop_hdr file_hdr;
static const int wtap_encap[] = {
-1, /* WTAP_ENCAP_UNKNOWN -> unsupported */
0x04, /* WTAP_ENCAP_ETHERNET -> DL_ETHER */
0x02, /* WTAP_ENCAP_TR -> DL_TPR */
-1, /* WTAP_ENCAP_SLIP -> unsupported */
-1, /* WTAP_ENCAP_PPP -> unsupported */
0x08, /* WTAP_ENCAP_FDDI -> DL_FDDI */
0x08, /* WTAP_ENCAP_FDDI_BITSWAPPED -> DL_FDDI */
-1, /* WTAP_ENCAP_RAW_IP -> unsupported */
-1, /* WTAP_ENCAP_ARCNET -> unsupported */
-1, /* WTAP_ENCAP_ATM_RFC1483 -> unsupported */
-1, /* WTAP_ENCAP_LINUX_ATM_CLIP -> unsupported */
-1, /* WTAP_ENCAP_LAPB -> unsupported*/
-1, /* WTAP_ENCAP_ATM_SNIFFER -> unsupported */
0 /* WTAP_ENCAP_NULL -> DLT_NULL */
};
#define NUM_WTAP_ENCAPS (sizeof wtap_encap / sizeof wtap_encap[0])
int nwritten;
/* Per-packet encapsulations aren't supported. */
if (wdh->encap == WTAP_ENCAP_PER_PACKET) {
*err = WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED;
return FALSE;
}
if (wdh->encap < 0 || wdh->encap >= NUM_WTAP_ENCAPS
|| wtap_encap[wdh->encap] == -1) {
*err = WTAP_ERR_UNSUPPORTED_ENCAP;
return FALSE;
}
/* This is a snoop file */
wdh->subtype_write = snoop_dump;
wdh->subtype_close = snoop_dump_close;
wdh->subtype_close = NULL;
/* Write the file header. */
nwritten = fwrite(&snoop_magic, 1, sizeof snoop_magic, wdh->fh);
@ -467,11 +469,3 @@ static gboolean snoop_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
}
return TRUE;
}
/* Finish writing to a dump file.
Returns TRUE on success, FALSE on failure. */
static gboolean snoop_dump_close(wtap_dumper *wdh, int *err)
{
/* Nothing to do here. */
return TRUE;
}

3
wiretap/snoop.h
View File

@ -1,6 +1,6 @@
/* snoop.h
*
* $Id: snoop.h,v 1.4 1999/12/04 05:14:39 guy Exp $
* $Id: snoop.h,v 1.5 1999/12/04 08:32:13 guy Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@verdict.uthscsa.edu>
@ -23,3 +23,4 @@
int snoop_open(wtap *wth, int *err);
gboolean snoop_dump_open(wtap_dumper *wdh, int *err);
int snoop_dump_can_dump_encap(int filetype, int encap);

62
wiretap/wtap.c
View File

@ -1,6 +1,6 @@
/* wtap.c
*
* $Id: wtap.c,v 1.31 1999/11/26 17:57:14 gram Exp $
* $Id: wtap.c,v 1.32 1999/12/04 08:32:13 guy Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@verdict.uthscsa.edu>
@ -57,66 +57,6 @@ int wtap_file_encap(wtap *wth)
return wth->file_encap;
}
const char *wtap_file_type_string(wtap *wth)
{
switch (wth->file_type) {
case WTAP_FILE_WTAP:
return "wiretap";
case WTAP_FILE_PCAP:
return "pcap";
case WTAP_FILE_PCAP_MODIFIED:
return "pcap-modified";
case WTAP_FILE_LANALYZER:
return "Novell LANalyzer";
case WTAP_FILE_NGSNIFFER:
return "Network Associates Sniffer (DOS-based)";
case WTAP_FILE_SNOOP:
return "snoop";
case WTAP_FILE_IPTRACE_1_0:
return "AIX iptrace 1.0";
case WTAP_FILE_IPTRACE_2_0:
return "AIX iptrace 2.0";
case WTAP_FILE_NETMON_1_x:
return "Microsoft Network Monitor 1.x";
case WTAP_FILE_NETMON_2_x:
return "Microsoft Network Monitor 2.x";
case WTAP_FILE_NETXRAY_1_0:
return "Cinco Networks NetXRay";
case WTAP_FILE_NETXRAY_1_1:
return "Network Associates Sniffer (Windows-based) 1.1";
case WTAP_FILE_NETXRAY_2_001:
return "Network Associates Sniffer (Windows-based) 2.001";
case WTAP_FILE_RADCOM:
return "RADCOM WAN/LAN analyzer";
case WTAP_FILE_ASCEND:
return "Lucent/Ascend access server trace";
case WTAP_FILE_NETTL:
return "HP-UX nettl trace";
case WTAP_FILE_TOSHIBA:
return "Toshiba Compact ISDN Router snoop trace";
default:
g_error("Unknown capture file type %d", wth->file_type);
return NULL;
}
}
static const char *wtap_errlist[] = {
"The file isn't a plain file",
"The file isn't a capture file in a known format",

7
wiretap/wtap.h
View File

@ -1,6 +1,6 @@
/* wtap.h
*
* $Id: wtap.h,v 1.51 1999/12/04 05:22:21 guy Exp $
* $Id: wtap.h,v 1.52 1999/12/04 08:32:14 guy Exp $
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@verdict.uthscsa.edu>
@ -118,6 +118,9 @@
#define WTAP_FILE_NETTL 16
#define WTAP_FILE_TOSHIBA 17
/* last WTAP_FILE_ value + 1 */
#define WTAP_NUM_FILE_TYPES 18
/*
* Maximum packet size we'll support.
*/
@ -385,6 +388,8 @@ void wtap_close(wtap *wth);
int wtap_seek_read (int file_type, FILE *fh, int seek_off, guint8 *pd, int len);
int wtap_def_seek_read (FILE *fh, int seek_off, guint8 *pd, int len);
gboolean wtap_dump_can_open(int filetype);
gboolean wtap_dump_can_write_encap(int filetype, int encap);
wtap_dumper* wtap_dump_open(const char *filename, int filetype, int encap,
int snaplen, int *err);
wtap_dumper* wtap_dump_fdopen(int fd, int filetype, int encap, int snaplen,