Add some infrastructure for the use of Ethereal, so it can make a list
authorguy <guy@f5534014-38df-0310-8fa8-9805f1628bb7>
Sat, 4 Dec 1999 08:32:14 +0000 (08:32 +0000)
committerguy <guy@f5534014-38df-0310-8fa8-9805f1628bb7>
Sat, 4 Dec 1999 08:32:14 +0000 (08:32 +0000)
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.

git-svn-id: http://anonsvn.wireshark.org/wireshark/trunk@1200 f5534014-38df-0310-8fa8-9805f1628bb7

wiretap/file.c
wiretap/libpcap.c
wiretap/libpcap.h
wiretap/netmon.c
wiretap/netmon.h
wiretap/snoop.c
wiretap/snoop.h
wiretap/wtap.c
wiretap/wtap.h

index 47158af9adb15285b69e71769b639dabc3f3d4c3..063bfb0c3350486c5ac004d4deb0a2eedadde821 100644 (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) {
index 550b43ddc1aaac25a50580a3da190a414fa87ae0..85ee54d29dce608f61fa1f99b4909f72a13bcce6 100644 (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;
-}
index cf0ead2a27e9e5796a594a1c720ca0806cb8157b..7cc0cfbda0e68b2c70c2f2a36ceb81352d2f8a20 100644 (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);
index 6e1db29a968f4c4cde054df8fd5c0c98c703f396..0921e24a433b356412fa194bbe86f6f5c6d8ec10 100644 (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 TRUE on success, FALSE on failure; sets "*err" to an error code on
-   failure */
-gboolean netmon_dump_open(wtap_dumper *wdh, int *err)
+/* 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 (wdh->encap == WTAP_ENCAP_PER_PACKET) {
-               *err = WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED;
-               return FALSE;
-       }
+       if (encap == WTAP_ENCAP_PER_PACKET)
+               return WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED;
 
-       if (wdh->encap < 0 || wdh->encap >= NUM_WTAP_ENCAPS
-           || wtap_encap[wdh->encap] == -1) {
-               *err = WTAP_ERR_UNSUPPORTED_ENCAP;
-               return FALSE;
-       }
+       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)
+{
        /* This is a netmon file */
        wdh->subtype_write = netmon_dump;
        wdh->subtype_close = netmon_dump_close;
index 468d6775ad9ce8ba146e22659ee6cf31f1f19692..0efd7abe7d5506bb9f03f7648cc496f2a636d890 100644 (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);
index 0a36c3a8a30f89a1b8628a1e6f721dfbaa57f8c8..b7fea213a635916a1d311a33637345b694bfb39a 100644 (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;
-}
index a740d1b62cec856e6e118336dac83eb29a304ee2..4e104da02f548016c2f8f61fe08300247a816b19 100644 (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);
index c141bb9693ef41977668d821d082d527ee8786e5..85afa247d4c3af7abeb4901f1d5e658b0a1fc256 100644 (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",
index 721f2701bd58a61fcaf9328260c045f9dce31cb0..58883ab1b3a697bb63914eec34a617f35245f067 100644 (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>
 #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,