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

Add an API to get a list of compressed-file extensions, and use it. 

Move all the compressed-file type stuff to wiretap/file_wrappers.c.

Rename wtap_compressed_file_extension() to
wtap_compression_type_extension() for consistency with the other
compression-type-extension routine names.

Move the declarations of the compression-type-extension routines in the
header file.

wtap_compression_type_extension() now returns NULL for
WTAP_UNCOMPRESSED; there's no need to special-case it.

Get rid of the now-unused wtap_compression_type_supported() and
WTAP_NUM_COMPRESSION_TYPES.

Change-Id: Ib93874079bea669a0c87104513dba0d21390455a
Reviewed-on: https://code.wireshark.org/review/30729
Petri-Dish: Guy Harris <guy@alum.mit.edu>
Tested-by: Petri Dish Buildbot
Reviewed-by: Guy Harris <guy@alum.mit.edu>
This commit is contained in:
Guy Harris 2018-11-19 16:06:38 -08:00
parent 2f17546932
commit ba34545293
5 changed files with 148 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ui/qt/main_window.cpp
View File

@ -1662,10 +1662,10 @@ void MainWindow::fileAddExtension(QString &file_name, int file_type, wtap_compre
type we'll be using. */
extensions_list = wtap_get_file_extensions_list(file_type, FALSE);
/* Get the extension for the compression type we'll be using, or
NULL if we won't be compressing it. */
compressed_file_extension =
(compression_type == WTAP_UNCOMPRESSED) ? NULL : wtap_compressed_file_extension(compression_type);
/* Get the extension for the compression type we'll be using;
NULL is returned if the type isn't supported or compression
is not being done. */
compressed_file_extension = wtap_compression_type_extension(compression_type);
if (extensions_list != NULL) {
GSList *extension;

146
wiretap/file_access.c
View File

@ -83,45 +83,22 @@
*/
static GSList *
add_extensions(GSList *extensions, const gchar *extension,
gboolean include_compressed)
GSList *compression_type_extensions)
{
/*
* Add the specified extension.
*/
extensions = g_slist_prepend(extensions, g_strdup(extension));
if (include_compressed) {
/*
* We were asked to include the extensions for
* compressed-file versions of that extension; do so.
*/
for (int compression_type = (int)WTAP_UNCOMPRESSED;
compression_type < (int)WTAP_NUM_COMPRESSION_TYPES;
compression_type++) {
if (compression_type == (int)WTAP_UNCOMPRESSED) {
/*
* This isn't a compression type, so it has
* no extension.
*/
continue;
}
if (!wtap_compression_type_supported((wtap_compression_type)compression_type)) {
/*
* We don't support this compression type,
* so don't include its extension.
*/
continue;
}
/*
* It's a supported compression type, so append its
* extension to the extension we were handed, and
* include that as an extension pair.
*/
extensions = g_slist_prepend(extensions,
g_strdup_printf("%s.%s", extension,
wtap_compressed_file_extension((wtap_compression_type)compression_type)));
}
/*
* Add whatever compressed versions we were supplied.
*/
for (GSList *compression_type_extension = compression_type_extensions;
compression_type_extension != NULL;
compression_type_extension = g_slist_next(compression_type_extension)) {
extensions = g_slist_prepend(extensions,
g_strdup_printf("%s.%s", extension,
(const char *)compression_type_extension->data));
}
return extensions;
@ -212,7 +189,8 @@ wtap_get_file_extension_type_name(int extension_type)
}
static GSList *
add_extensions_for_file_extensions_type(int extension_type, GSList *extensions)
add_extensions_for_file_extensions_type(int extension_type, GSList *extensions,
GSList *compression_type_extensions)
{
gchar **extensions_set, **extensionp, *extension;
@ -232,7 +210,8 @@ add_extensions_for_file_extensions_type(int extension_type, GSList *extensions)
* Add the extension, and all compressed variants
* of it.
*/
extensions = add_extensions(extensions, extension, TRUE);
extensions = add_extensions(extensions, extension,
compression_type_extensions);
}
g_strfreev(extensions_set);
@ -247,19 +226,26 @@ add_extensions_for_file_extensions_type(int extension_type, GSList *extensions)
GSList *
wtap_get_file_extension_type_extensions(guint extension_type)
{
GSList *extensions;
GSList *extensions, *compression_type_extensions;
if (extension_type >= file_type_extensions_arr->len)
return NULL; /* not a valid extension type */
extensions = NULL; /* empty list, to start with */
/*
* Get compression-type extensions, if any.
*/
compression_type_extensions = wtap_get_all_compression_type_extensions_list();
/*
* Add all this file extension type's extensions, with compressed
* variants.
*/
extensions = add_extensions_for_file_extensions_type(extension_type,
extensions);
extensions, compression_type_extensions);
g_slist_free(compression_type_extensions);
return extensions;
}
@ -283,13 +269,18 @@ wtap_get_file_extension_type_extensions(guint extension_type)
GSList *
wtap_get_all_capture_file_extensions_list(void)
{
GSList *extensions;
GSList *extensions, *compression_type_extensions;
unsigned int i;
init_file_type_extensions();
extensions = NULL; /* empty list, to start with */
/*
* Get compression-type extensions, if any.
*/
compression_type_extensions = wtap_get_all_compression_type_extensions_list();
for (i = 0; i < file_type_extensions_arr->len; i++) {
/*
* Is this a capture file, rather than one of the
@ -301,10 +292,12 @@ wtap_get_all_capture_file_extensions_list(void)
* extensions, with compressed variants.
*/
extensions = add_extensions_for_file_extensions_type(i,
extensions);
extensions, compression_type_extensions);
}
}
g_slist_free(compression_type_extensions);
return extensions;
}
@ -658,39 +651,26 @@ get_file_extension(const char *pathname)
return NULL; /* only one component, with no "." */
}
/*
* Get compression-type extensions, if any.
*/
GSList *compression_type_extensions = wtap_get_all_compression_type_extensions_list();
/*
* Is the last component one of the extensions used for compressed
* files?
*/
extensionp = components[ncomponents - 1];
for (int compression_type = (int)WTAP_UNCOMPRESSED;
compression_type < (int)WTAP_NUM_COMPRESSION_TYPES;
compression_type++) {
if (compression_type == (int)WTAP_UNCOMPRESSED) {
/*
* This isn't a compression type, so it has no
* extension.
*/
continue;
}
if (!wtap_compression_type_supported((wtap_compression_type)compression_type)) {
/*
* We don't support this compression type, so don't
* include its extension.
*/
continue;
}
/*
* Is the extension the extension corresponding to this
* compression type?
*/
if (strcmp(extensionp, wtap_compressed_file_extension((wtap_compression_type)compression_type)) == 0) {
for (GSList *compression_type_extension = compression_type_extensions;
compression_type_extension != NULL;
compression_type_extension = g_slist_next(compression_type_extension)) {
if (strcmp(extensionp, (const char *)compression_type_extension->data) == 0) {
/*
* Yes, so it's one of the compressed-file extensions.
* Is there an extension before that?
*/
if (ncomponents == 2) {
g_slist_free(compression_type_extensions);
g_strfreev(components);
return NULL; /* no, only two components */
}
@ -698,12 +678,15 @@ get_file_extension(const char *pathname)
/*
* Yes, return that extension.
*/
g_slist_free(compression_type_extensions);
extensionp = g_strdup(components[ncomponents - 2]);
g_strfreev(components);
return extensionp;
}
}
g_slist_free(compression_type_extensions);
/*
* The extension isn't one of the compressed-file extensions;
* return it.
@ -2066,19 +2049,20 @@ wtap_short_string_to_file_type_subtype(const char *short_name)
static GSList *
add_extensions_for_file_type_subtype(int file_type_subtype, GSList *extensions,
gboolean include_compressed)
GSList *compression_type_extensions)
{
gchar **extensions_set, **extensionp;
gchar *extension;
/*
* Add the default extension, and all compressed variants of
* it if requested, if there is a default extension.
* Add the default extension, and all of the compressed variants
* from the list of compressed-file extensions, if there is a
* default extension.
*/
if (dump_open_table[file_type_subtype].default_file_extension != NULL) {
extensions = add_extensions(extensions,
dump_open_table[file_type_subtype].default_file_extension,
include_compressed);
compression_type_extensions);
}
if (dump_open_table[file_type_subtype].additional_file_extensions != NULL) {
@ -2103,7 +2087,7 @@ add_extensions_for_file_type_subtype(int file_type_subtype, GSList *extensions,
* of it if requested.
*/
extensions = add_extensions(extensions, extension,
include_compressed);
compression_type_extensions);
}
g_strfreev(extensions_set);
@ -2122,7 +2106,7 @@ add_extensions_for_file_type_subtype(int file_type_subtype, GSList *extensions,
GSList *
wtap_get_file_extensions_list(int file_type_subtype, gboolean include_compressed)
{
GSList *extensions;
GSList *extensions, *compression_type_extensions;
if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes)
return NULL; /* not a valid file type */
@ -2136,8 +2120,21 @@ wtap_get_file_extensions_list(int file_type_subtype, gboolean include_compressed
* Add all this file type's extensions, with compressed
* variants if include_compressed is true.
*/
if (include_compressed) {
/*
* Get compression-type extensions, if any.
*/
compression_type_extensions = wtap_get_all_compression_type_extensions_list();
} else {
/*
* We don't want the compressed file extensions.
*/
compression_type_extensions = NULL;
}
extensions = add_extensions_for_file_type_subtype(file_type_subtype, extensions,
include_compressed);
compression_type_extensions);
g_slist_free(compression_type_extensions);
return extensions;
}
@ -2156,16 +2153,23 @@ wtap_get_file_extensions_list(int file_type_subtype, gboolean include_compressed
GSList *
wtap_get_all_file_extensions_list(void)
{
GSList *extensions;
GSList *extensions, *compression_type_extensions;
int i;
extensions = NULL; /* empty list, to start with */
/*
* Get compression-type extensions, if any.
*/
compression_type_extensions = wtap_get_all_compression_type_extensions_list();
for (i = 0; i < WTAP_NUM_FILE_TYPES_SUBTYPES; i++) {
extensions = add_extensions_for_file_type_subtype(i, extensions,
TRUE); /* include compressed-file extensions */
compression_type_extensions);
}
g_slist_free(compression_type_extensions);
return extensions;
}

59
wiretap/file_wrappers.c
View File

@ -43,6 +43,65 @@
* Lzip format: http://www.nongnu.org/lzip/
*/
/*
* List of compression types supported.
*/
static struct compression_type {
wtap_compression_type type;
const char *extension;
const char *description;
} compression_types[] = {
#ifdef HAVE_ZLIB
{ WTAP_GZIP_COMPRESSED, "gz", "gzip compressed" },
#endif
{ WTAP_UNCOMPRESSED, NULL, NULL }
};
wtap_compression_type
wtap_get_compression_type(wtap *wth)
{
gboolean is_compressed;
is_compressed = file_iscompressed((wth->fh == NULL) ? wth->random_fh : wth->fh);
return is_compressed ? WTAP_GZIP_COMPRESSED : WTAP_UNCOMPRESSED;
}
const char *
wtap_compression_type_description(wtap_compression_type compression_type)
{
for (struct compression_type *p = compression_types;
p->type != WTAP_UNCOMPRESSED; p++) {
if (p->type == compression_type)
return p->description;
}
return NULL;
}
const char *
wtap_compression_type_extension(wtap_compression_type compression_type)
{
for (struct compression_type *p = compression_types;
p->type != WTAP_UNCOMPRESSED; p++) {
if (p->type == compression_type)
return p->extension;
}
return NULL;
}
GSList *
wtap_get_all_compression_type_extensions_list(void)
{
GSList *extensions;
extensions = NULL; /* empty list, to start with */
for (struct compression_type *p = compression_types;
p->type != WTAP_UNCOMPRESSED; p++)
extensions = g_slist_prepend(extensions, (gpointer)p->extension);
return extensions;
}
/* #define GZBUFSIZE 8192 */
#define GZBUFSIZE 4096

61
wiretap/wtap.c
View File

@ -77,67 +77,6 @@ wtap_file_type_subtype(wtap *wth)
return wth->file_type_subtype;
}
wtap_compression_type
wtap_get_compression_type(wtap *wth)
{
gboolean is_compressed;
is_compressed = file_iscompressed((wth->fh == NULL) ? wth->random_fh : wth->fh);
return is_compressed ? WTAP_GZIP_COMPRESSED : WTAP_UNCOMPRESSED;
}
/*
* Indicate whether a given compression type is supported.
*/
static const gboolean compression_type_supported[WTAP_NUM_COMPRESSION_TYPES] = {
TRUE,
#ifdef HAVE_ZLIB
TRUE
#else
FALSE
#endif
};
gboolean
wtap_compression_type_supported(wtap_compression_type compression_type)
{
g_assert(compression_type >= 0 && compression_type < WTAP_NUM_COMPRESSION_TYPES);
return compression_type_supported[compression_type];
}
static const char *compression_type_descriptions[WTAP_NUM_COMPRESSION_TYPES] = {
NULL, /* uncompressed */
"gzip compressed"
};
const char *
wtap_compression_type_description(wtap_compression_type compression_type)
{
g_assert(compression_type >= 0 && compression_type < WTAP_NUM_COMPRESSION_TYPES);
return compression_type_descriptions[compression_type];
}
/*
* List of extensions for compressed files.
* If we add support for more compressed file types, this table
* might be expanded to include routines to handle the various
* compression types.
*
* The entry is NULL for WTAP_UNCOMPRESSED, as it's not a compression type,
* and thus has no suffix to indicate the compression type.
*/
static const char *compressed_file_extensions[WTAP_NUM_COMPRESSION_TYPES] = {
NULL,
"gz"
};
const char *
wtap_compressed_file_extension(wtap_compression_type compression_type)
{
g_assert(compression_type >= 0 && compression_type < WTAP_NUM_COMPRESSION_TYPES);
return compressed_file_extensions[compression_type];
}
guint
wtap_snapshot_length(wtap *wth)
{

20
wiretap/wtap.h
View File

@ -1695,10 +1695,18 @@ void wtap_rec_cleanup(wtap_rec *rec);
*/
typedef enum {
WTAP_UNCOMPRESSED,
WTAP_GZIP_COMPRESSED,
WTAP_NUM_COMPRESSION_TYPES
WTAP_GZIP_COMPRESSED
} wtap_compression_type;
WS_DLL_PUBLIC
wtap_compression_type wtap_get_compression_type(wtap *wth);
WS_DLL_PUBLIC
const char *wtap_compression_type_description(wtap_compression_type compression_type);
WS_DLL_PUBLIC
const char *wtap_compression_type_extension(wtap_compression_type compression_type);
WS_DLL_PUBLIC
GSList *wtap_get_all_compression_type_extensions_list(void);
/*** get various information snippets about the current file ***/
/** Return an approximation of the amount of data we've read sequentially
@ -1708,14 +1716,6 @@ gint64 wtap_read_so_far(wtap *wth);
WS_DLL_PUBLIC
gint64 wtap_file_size(wtap *wth, int *err);
WS_DLL_PUBLIC
wtap_compression_type wtap_get_compression_type(wtap *wth);
WS_DLL_PUBLIC
gboolean wtap_compression_type_supported(wtap_compression_type compression_type);
WS_DLL_PUBLIC
const char *wtap_compression_type_description(wtap_compression_type compression_type);
WS_DLL_PUBLIC
const char *wtap_compressed_file_extension(wtap_compression_type compression_type);
WS_DLL_PUBLIC
guint wtap_snapshot_length(wtap *wth); /* per file */
WS_DLL_PUBLIC
int wtap_file_type_subtype(wtap *wth);