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

wiretap: more work on file type/subtypes. 

Provide a wiretap routine to get an array of all savable file
type/subtypes, sorted with pcap and pcapng at the top, followed by the
other types, sorted either by the name or the description.

Use that routine to list options for the -F flag for various commands

Rename wtap_get_savable_file_types_subtypes() to
wtap_get_savable_file_types_subtypes_for_file(), to indicate that it
provides an array of all file type/subtypes in which a given file can be
saved.  Have it sort all types, other than the default type/subtype and,
if there is one, the "other" type (both of which are put at the top), by
the name or the description.

Don't allow wtap_register_file_type_subtypes() to override any existing
registrations; have them always register a new type.  In that routine,
if there are any emply slots in the table, due to an entry being
unregistered, use it rather than allocating a new slot.

Don't allow unregistration of built-in types.

Rename the "dump open table" to the "file type/subtype table", as it has
entries for all types/subtypes, even if we can't write them.

Initialize that table in a routine that pre-allocates the GArray before
filling it with built-in types/subtypes, so it doesn't keep getting
reallocated.

Get rid of wtap_num_file_types_subtypes - it's just a copy of the size
of the GArray.

Don't have wtap_file_type_subtype_description() crash if handed an
file type/subtype that isn't a valid array index - just return NULL, as
we do with wtap_file_type_subtype_name().

In wtap_name_to_file_type_subtype(), don't use WTAP_FILE_TYPE_SUBTYPE_
names for the backwards-compatibility names - map those names to the
current names, and then look them up.  This reduces the number of
uses of hardwired WTAP_FILE_TYPE_SUBTYPE_ values.

Clean up the type of wtap_module_count - it has no need to be a gulong.

Have built-in wiretap file handlers register names to be used for their
file type/subtypes, rather than building the table in init.lua.

Add a new Lua C function get_wtap_filetypes() to construct the
wtap_filetypes table, based on the registered names, and use it in
init.lua.

Add a #define WSLUA_INTERNAL_FUNCTION to register functions intended
only for internal use in init.lua, so they can be made available from
Lua without being documented.

Get rid of WTAP_NUM_FILE_TYPES_SUBTYPES - most code has no need to use
it, as it can just request arrays of types, and the space of
type/subtype codes can be sparse due to registration in any case, so
code has to be careful using it.

wtap_get_num_file_types_subtypes() is no longer used, so remove it.  It
returns the number of elements in the file type/subtype array, which is
not necessarily the name of known file type/subtypes, as there may have
been some deregistered types, and those types do *not* get removed from
the array, they just get cleared so that they're available for future
allocation (we don't want the indices of any registered types to changes
if another type is deregistered, as those indicates are the type/subtype
values, so we can't shrink the array).

Clean up white space and remove some comments that shouldn't have been
added.
This commit is contained in:
Guy Harris 2021-02-16 22:24:47 -08:00
parent 2ff9f3eb78
commit a7256d50b5
72 changed files with 1054 additions and 618 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
debian/libwiretap0.symbols vendored
View File

@ -9,6 +9,7 @@ libwiretap.so.0 libwiretap0 #MINVER#
file_read@Base 1.9.1
file_seek@Base 1.9.1
file_tell@Base 1.9.1
get_backwards_compatibility_lua_table@Base 3.5.0
init_open_routines@Base 1.12.0~rc1
merge_files@Base 1.99.9
merge_files_to_stdout@Base 2.3.0
@ -119,8 +120,8 @@ libwiretap.so.0 libwiretap0 #MINVER#
wtap_get_next_interface_description@Base 3.3.2
wtap_get_num_encap_types@Base 1.9.1
wtap_get_num_file_type_extensions@Base 1.12.0~rc1
wtap_get_num_file_types_subtypes@Base 1.12.0~rc1
wtap_get_savable_file_types_subtypes@Base 1.12.0~rc1
wtap_get_savable_file_types_subtypes_for_file@Base 3.5.0
wtap_get_writable_file_types_subtypes@Base 3.5.0
wtap_has_open_info@Base 1.12.0~rc1
wtap_init@Base 2.3.0
wtap_name_to_encap@Base 2.9.1
@ -137,6 +138,7 @@ libwiretap.so.0 libwiretap0 #MINVER#
wtap_read_so_far@Base 1.9.1
wtap_rec_cleanup@Base 2.5.1
wtap_rec_init@Base 2.5.1
wtap_register_backwards_compatibility_lua_name@Base 3.5.0
wtap_register_encap_type@Base 1.9.1
wtap_register_file_type_extension@Base 1.12.0~rc1
wtap_register_file_type_subtypes@Base 1.12.0~rc1

27
editcap.c
View File

@ -871,13 +871,6 @@ struct string_elem {
const char *lstr; /* The long string */
};
static gint
string_compare(gconstpointer a, gconstpointer b)
{
return strcmp(((const struct string_elem *)a)->sstr,
((const struct string_elem *)b)->sstr);
}
static gint
string_nat_compare(gconstpointer a, gconstpointer b)
{
@ -895,22 +888,16 @@ string_elem_print(gpointer data, gpointer stream_ptr)
static void
list_capture_types(FILE *stream) {
int i;
struct string_elem *captypes;
GSList *list = NULL;
GArray *writable_type_subtypes;
captypes = g_new(struct string_elem,WTAP_NUM_FILE_TYPES_SUBTYPES);
fprintf(stream, "editcap: The available capture file types for the \"-F\" flag are:\n");
for (i = 0; i < WTAP_NUM_FILE_TYPES_SUBTYPES; i++) {
if (wtap_dump_can_open(i)) {
captypes[i].sstr = wtap_file_type_subtype_name(i);
captypes[i].lstr = wtap_file_type_subtype_description(i);
list = g_slist_insert_sorted(list, &captypes[i], string_compare);
}
writable_type_subtypes = wtap_get_writable_file_types_subtypes(FT_SORT_BY_NAME);
for (guint i = 0; i < writable_type_subtypes->len; i++) {
int ft = g_array_index(writable_type_subtypes, int, i);
fprintf(stderr, " %s - %s\n", wtap_file_type_subtype_name(ft),
wtap_file_type_subtype_description(ft));
}
g_slist_foreach(list, string_elem_print, stream);
g_slist_free(list);
g_free(captypes);
g_array_free(writable_type_subtypes, TRUE);
}
static void

6
epan/wslua/make-init-lua.pl
View File

@ -19,7 +19,6 @@ my $WSROOT = shift;
die "'$WSROOT' is not a directory" unless -d $WSROOT;
my $wtap_encaps_table = '';
my $wtap_filetypes_table = '';
my $wtap_tsprecs_table = '';
my $wtap_commenttypes_table = '';
my $ft_types_table = '';
@ -36,7 +35,6 @@ my $menu_groups = '';
my %replacements = %{{
WTAP_ENCAPS => \$wtap_encaps_table,
WTAP_FILETYPES => \$wtap_filetypes_table,
WTAP_TSPRECS => \$wtap_tsprecs_table,
WTAP_COMMENTTYPES => \$wtap_commenttypes_table,
FT_TYPES => \$ft_types_table,
@ -70,7 +68,6 @@ close TEMPLATE;
#
$wtap_encaps_table = "-- Wiretap encapsulations XXX\nwtap_encaps = {\n";
$wtap_filetypes_table = "-- Wiretap file types\nwtap_filetypes = {\n";
$wtap_tsprecs_table = "-- Wiretap timestamp precision types\nwtap_tsprecs = {\n";
$wtap_commenttypes_table = "-- Wiretap file comment types\nwtap_comments = {\n";
$wtap_rec_types_table = "-- Wiretap record_types\nwtap_rec_types = {\n";
@ -85,8 +82,6 @@ while(<WTAP_H>) {
if ( /^#define WTAP_TSPREC_([A-Z0-9_]+)\s+(\d+)/ ) {
$wtap_tsprecs_table .= "\t[\"$1\"] = $2,\n";
# for backwards compatibility we need to add them to the filetypes table too
$wtap_filetypes_table .= "\t[\"TSPREC_$1\"] = $2,\n";
}
if ( /^#define WTAP_COMMENT_([A-Z0-9_]+)\s+(0x\d+)/ ) {
@ -104,7 +99,6 @@ while(<WTAP_H>) {
}
$wtap_encaps_table =~ s/,\n$/\n}\nwtap = wtap_encaps -- for bw compatibility\n/msi;
$wtap_filetypes_table =~ s/,\n$/\n}\n/msi;
$wtap_tsprecs_table =~ s/,\n$/\n}\n/msi;
$wtap_commenttypes_table =~ s/,\n$/\n}\n/msi;
# wtap_rec_types_table has comments at the end (not a comma),

8
epan/wslua/make-reg.pl
View File

@ -16,6 +16,7 @@ use Getopt::Long;
my @classes = ();
my @functions = ();
my @internal_functions = ();
my $source_dir = "";
GetOptions('dir=s' => \$source_dir);
@ -33,6 +34,7 @@ while ($filename = $ARGV[0]) {
while (<FILE>) {
push @classes, $1 if /WSLUA_CLASS_DEFINE(?:_BASE)?\050\s*([A-Za-z0-9]+)/;
push @functions, $1 if /WSLUA_FUNCTION\s+wslua_([a-z_0-9]+)/;
push @internal_functions, $1 if /WSLUA_INTERNAL_FUNCTION\s+wslua_([a-z_0-9]+)/;
}
}
@ -52,6 +54,9 @@ print H "#define WSLUA_DECLARE_FUNCTIONS() \\\n";
for (@functions) {
print H "\tWSLUA_FUNCTION wslua_$_(lua_State* L);\\\n"
}
for (@internal_functions) {
print H "\tWSLUA_INTERNAL_FUNCTION wslua_$_(lua_State* L);\\\n"
}
print H "\n\n";
print H "extern void wslua_register_classes(lua_State* L);\n";
print H "extern void wslua_register_functions(lua_State* L);\n";
@ -83,6 +88,9 @@ print C "void wslua_register_functions(lua_State* L) {\n";
for (@functions) {
print C "\tWSLUA_REGISTER_FUNCTION($_); \n"
}
for (@internal_functions) {
print C "\tWSLUA_REGISTER_FUNCTION($_); \n"
}
print C "}\n\n";
close H;

121
epan/wslua/template-init.lua
View File

@ -78,12 +78,6 @@ end
%WTAP_ENCAPS%
--
-- This pulls in the WTAP_TSPREC_ values that are included in
-- wtap_filetypes for backwards compatibility.
--
%WTAP_FILETYPES%
--
-- Generate the wtap_filetypes items for file types, for backwards
-- compatibility.
@ -94,120 +88,7 @@ end
-- New code should use wtap_name_to_file_type_subtype to
-- look up file types by name.
--
-- "UNKNOWN" is a special case; it has no name.
--
wtap_filetypes["UNKNOWN"] = 0
for filetype = 1, wtap_get_num_file_types_subtypes() - 1 do
local typename = wtap_file_type_subtype_name(filetype)
--
-- In most cases, the old #define was just a capitalized
-- version of the file type name.
--
-- We process the exceptions here.
--
if typename == "nsecpcap" then
wtap_filetypes["PCAP_NSEC"] = filetype
elseif typename == "aixpcap" then
wtap_filetypes["PCAP_AIX"] = filetype
elseif typename == "modpcap" then
wtap_filetypes["PCAP_SS991029"] = filetype
elseif typename == "nokiapcap" then
wtap_filetypes["PCAP_NOKIA"] = filetype
elseif typename == "rh6_1pcap" then
wtap_filetypes["PCAP_SS990417"] = filetype
elseif typename == "suse6_3pcap" then
wtap_filetypes["PCAP_SS990915"] = filetype
elseif typename == "iptrace_1" then
wtap_filetypes["IPTRACE_1_0"] = filetype
elseif typename == "iptrace_2" then
wtap_filetypes["IPTRACE_2_0"] = filetype
elseif typename == "dct2000" then
wtap_filetypes["CATAPULT_DCT2000"] = filetype
elseif typename == "netxray1" then
wtap_filetypes["NETXRAY_OLD"] = filetype
elseif typename == "netxray2" then
-- This is correct; the #define was wrong
wtap_filetypes["NETXRAY_1_0"] = filetype
elseif typename == "etherwatch" then
wtap_filetypes["DBS_ETHERWATCH"] = filetype
elseif typename == "iseries_ascii" then
wtap_filetypes["ISERIES"] = filetype
elseif typename == "iseries_unicode" then
wtap_filetypes["ISERIES_UNICODE"] = filetype
elseif typename == "netmon1" then
wtap_filetypes["NETMON_1_x"] = filetype
elseif typename == "netmon2" then
wtap_filetypes["NETMON_2_x"] = filetype
elseif typename == "ngsniffer" then
wtap_filetypes["NGSNIFFER_UNCOMPRESSED"] = filetype
elseif typename == "ngsniffer_comp" then
wtap_filetypes["NGSNIFFER_COMPRESSED"] = filetype
elseif typename == "ngwsniffer_1_1" then
wtap_filetypes["NETXRAY_1_1"] = filetype
elseif typename == "ngwsniffer_2_0" then
wtap_filetypes["NETXRAY_2_00x"] = filetype
elseif typename == "niobserver" then
wtap_filetypes["NETWORK_INSTRUMENTS"] = filetype
elseif typename == "pppd" then
wtap_filetypes["PPPDUMP"] = filetype
elseif typename == "tcpiptrace" then
wtap_filetypes["VMS"] = filetype
elseif typename == "rf5" then
wtap_filetypes["K12"] = filetype
elseif typename == "visual" then
wtap_filetypes["VISUAL_NETWORKS"] = filetype
elseif typename == "peekclassic56" then
wtap_filetypes["PEEKCLASSIC_V56"] = filetype
elseif typename == "peekclassic7" then
wtap_filetypes["PEEKCLASSIC_V7"] = filetype
elseif typename == "pklg" then
wtap_filetypes["PACKETLOGGER"] = filetype
elseif typename == "dsna" then
wtap_filetypes["DAINTREE_SNA"] = filetype
elseif typename == "nstrace10" then
wtap_filetypes["NETSCALER_1_0"] = filetype
elseif typename == "nstrace20" then
wtap_filetypes["NETSCALER_2_0"] = filetype
elseif typename == "nstrace30" then
wtap_filetypes["NETSCALER_3_0"] = filetype
elseif typename == "nstrace35" then
wtap_filetypes["NETSCALER_3_5"] = filetype
elseif typename == "jpeg" then
wtap_filetypes["JPEG_JFIF"] = filetype
elseif typename == "mp2t" then
wtap_filetypes["MPEG_2_TS"] = filetype
elseif typename == "vwr80211" then
wtap_filetypes["VWR_80211"] = filetype
elseif typename == "vwreth" then
wtap_filetypes["VWR_ETH"] = filetype
elseif typename == "stanag4607" then
wtap_filetypes["STANAG_4607"] = filetype
elseif typename == "logcat-brief" then
wtap_filetypes["LOGCAT_BRIEF"] = filetype
elseif typename == "logcat-process" then
wtap_filetypes["LOGCAT_PROCESS"] = filetype
elseif typename == "logcat-tag" then
wtap_filetypes["LOGCAT_TAG"] = filetype
elseif typename == "logcat-thread" then
wtap_filetypes["LOGCAT_THREAD"] = filetype
elseif typename == "logcat-time" then
wtap_filetypes["LOGCAT_TIME"] = filetype
elseif typename == "logcat-threadtime" then
wtap_filetypes["LOGCAT_THREADTIME"] = filetype
elseif typename == "logcat-long" then
wtap_filetypes["LOGCAT_LONG"] = filetype
elseif typename == "colasoft-pb" then
wtap_filetypes["PACKET_BUILDER"] = filetype
elseif typename == "3gpp32423" then
wtap_filetypes["NETTRACE_3GPP_32_423"] = filetype
elseif typename == "3gpp_log" then
wtap_filetypes["LOG_3GPP"] = filetype
elseif typename == "jpeg" then
wtap_filetypes["JPEG_JFIF"] = filetype
else
wtap_filetypes[string.upper(typename)] = filetype
end
end
wtap_filetypes = get_wtap_filetypes()
%WTAP_TSPRECS%

2
epan/wslua/wslua.h
View File

@ -462,6 +462,8 @@ extern int wslua_reg_attributes(lua_State *L, const wslua_attribute_table *t, gb
#endif
#define WSLUA_FUNCTION extern int
/* This is for functions intended only to be used in init.lua */
#define WSLUA_INTERNAL_FUNCTION extern int
#define WSLUA_REGISTER_FUNCTION(name) { lua_pushcfunction(L, wslua_## name); lua_setglobal(L, #name); }

12
epan/wslua/wslua_file_handler.c
View File

@ -719,16 +719,6 @@ WSLUA_FUNCTION wslua_register_filehandler(lua_State* L) {
if (!verify_filehandler_complete(fh))
return luaL_error(L,"this FileHandler is not complete enough to register");
/* If a Lua file handler is reloaded, try to reuse the previous subtype.
* XXX wtap_register_file_type_subtypes will abort the program if a builtin
* file handler is overridden, so plugin authors should not try that.
*/
int file_type = wtap_name_to_file_type_subtype(fh->finfo.name);
if (file_type == -1) {
/* File type was not registered before, create a new one. */
file_type = WTAP_FILE_TYPE_SUBTYPE_UNKNOWN;
}
if (fh->is_writer) {
if (fh->extensions && fh->extensions[0]) {
char *extension = g_strdup(fh->extensions);
@ -747,7 +737,7 @@ WSLUA_FUNCTION wslua_register_filehandler(lua_State* L) {
fh->finfo.dump_open = wslua_filehandler_dump_open;
}
fh->file_type = wtap_register_file_type_subtypes(&(fh->finfo), file_type);
fh->file_type = wtap_register_file_type_subtypes(&(fh->finfo));
if (fh->is_reader) {
struct open_info oi = { NULL, OPEN_INFO_HEURISTIC, NULL, NULL, NULL, NULL };

48
epan/wslua/wslua_wtap.c
View File

@ -20,6 +20,12 @@
#include "wslua.h"
#include <wiretap/wtap.h>
/*
* Solely for the function that gets the table of backwards-compatibility
* Lua names for file types/subtypes.
*/
#include <wiretap/wtap-int.h>
WSLUA_FUNCTION wslua_wtap_file_type_subtype_description(lua_State* LS) {
/*
Get a string describing a capture file type, given a filetype
@ -84,15 +90,39 @@ WSLUA_FUNCTION wslua_wtap_name_to_file_type_subtype(lua_State* LS) {
WSLUA_RETURN(1); /* The filetype value for the file type with that name, or nil if there is no such file type. */
}
WSLUA_FUNCTION wslua_wtap_get_num_file_types_subtypes(lua_State* LS) {
/*
* init.wslua-only function to return a table to assign to
* wtap_filetypes.
*/
WSLUA_INTERNAL_FUNCTION wslua_get_wtap_filetypes(lua_State* LS) {
/* Get the GArray from which we initialize this. */
const GArray *table = get_backwards_compatibility_lua_table();
/*
Get the total number of filetype values.
* Create the table; it's indexted by strings, not numbers,
* so none of the entries will be in a sequence.
*/
lua_createtable(LS,0,table->len);
for (guint i = 0; i < table->len; i++) {
struct backwards_compatibiliity_lua_name *entry;
Note: as filetype values begin with 0, this is one *greater*
than the largest filetype value.
@since 3.5.0
*/
lua_pushnumber(LS,wtap_get_num_file_types_subtypes());
WSLUA_RETURN(1); /* The total number of registered file types. */
entry = &g_array_index(table,
struct backwards_compatibiliity_lua_name, i);
/*
* Push the name and the ft, in order, so that the ft,
* which should be the value at the top of the stack,
* is at the top of the stack, and the name, which should
* be the value just below that, is the value just below
* it.
*/
lua_pushstring(LS, entry->name);
lua_pushnumber(LS, entry->ft);
/*
* The -3 is the index, relative to the top of the stack, of
* the table; the two elements on top of it are the ft and
* the name, so it's -3.
*/
lua_settable(LS, -3);
}
WSLUA_RETURN(1); /* The table. */
}

40
mergecap.c
View File

@ -101,25 +101,6 @@ mergecap_cmdarg_err_cont(const char *fmt, va_list ap)
fprintf(stderr, "\n");
}
struct string_elem {
const char *sstr; /* The short string */
const char *lstr; /* The long string */
};
static gint
string_compare(gconstpointer a, gconstpointer b)
{
return strcmp(((const struct string_elem *)a)->sstr,
((const struct string_elem *)b)->sstr);
}
static void
string_elem_print(gpointer data, gpointer not_used _U_)
{
fprintf(stderr, " %s - %s\n", ((struct string_elem *)data)->sstr,
((struct string_elem *)data)->lstr);
}
/*
* General errors and warnings are reported with an console message
* in mergecap.
@ -134,23 +115,16 @@ failure_warning_message(const char *msg_format, va_list ap)
static void
list_capture_types(void) {
int i;
struct string_elem *captypes;
GSList *list = NULL;
captypes = g_new(struct string_elem,WTAP_NUM_FILE_TYPES_SUBTYPES);
GArray *writable_type_subtypes;
fprintf(stderr, "mergecap: The available capture file types for the \"-F\" flag are:\n");
for (i = 0; i < WTAP_NUM_FILE_TYPES_SUBTYPES; i++) {
if (wtap_dump_can_open(i)) {
captypes[i].sstr = wtap_file_type_subtype_name(i);
captypes[i].lstr = wtap_file_type_subtype_description(i);
list = g_slist_insert_sorted(list, &captypes[i], string_compare);
}
writable_type_subtypes = wtap_get_writable_file_types_subtypes(FT_SORT_BY_NAME);
for (guint i = 0; i < writable_type_subtypes->len; i++) {
int ft = g_array_index(writable_type_subtypes, int, i);
fprintf(stderr, " %s - %s\n", wtap_file_type_subtype_name(ft),
wtap_file_type_subtype_description(ft));
}
g_slist_foreach(list, string_elem_print, NULL);
g_slist_free(list);
g_free(captypes);
g_array_free(writable_type_subtypes, TRUE);
}
static void

3
plugins/wiretap/usbdump/usbdump.c
View File

@ -334,8 +334,7 @@ wtap_register_usbdump(void)
NULL
};
usbdump_file_type_subtype =
wtap_register_file_type_subtypes(&fi, WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
usbdump_file_type_subtype = wtap_register_file_type_subtypes(&fi);
}
/*

2
tools/make-regs.py
View File

@ -90,7 +90,7 @@ def make_wtap_modules(outfile, infiles):
output += """\
#include "wtap_modules.h"
const gulong wtap_module_count = {0};
const guint wtap_module_count = {0};
""".format(len(wtap_modules))

46
tshark.c
View File

@ -272,6 +272,20 @@ static void failure_message_cont(const char *msg_format, va_list ap);
static GHashTable *output_only_tables = NULL;
static void
list_capture_types(void) {
GArray *writable_type_subtypes;
fprintf(stderr, "tshark: The available capture file types for the \"-F\" flag are:\n");
writable_type_subtypes = wtap_get_writable_file_types_subtypes(FT_SORT_BY_NAME);
for (guint i = 0; i < writable_type_subtypes->len; i++) {
int ft = g_array_index(writable_type_subtypes, int, i);
fprintf(stderr, " %s - %s\n", wtap_file_type_subtype_name(ft),
wtap_file_type_subtype_description(ft));
}
g_array_free(writable_type_subtypes, TRUE);
}
struct string_elem {
const char *sstr; /* The short string */
const char *lstr; /* The long string */
@ -292,39 +306,23 @@ string_elem_print(gpointer data)
((struct string_elem *)data)->lstr);
}
static void
list_capture_types(void) {
int i;
struct string_elem *captypes;
GSList *list = NULL;
captypes = g_new(struct string_elem, WTAP_NUM_FILE_TYPES_SUBTYPES);
fprintf(stderr, "tshark: The available capture file types for the \"-F\" flag are:\n");
for (i = 0; i < WTAP_NUM_FILE_TYPES_SUBTYPES; i++) {
if (wtap_dump_can_open(i)) {
captypes[i].sstr = wtap_file_type_subtype_name(i);
captypes[i].lstr = wtap_file_type_subtype_description(i);
list = g_slist_insert_sorted(list, &captypes[i], string_compare);
}
}
g_slist_free_full(list, string_elem_print);
g_free(captypes);
}
static void
list_read_capture_types(void) {
int i;
guint i;
size_t num_file_types;
struct string_elem *captypes;
GSList *list = NULL;
const char *magic = "Magic-value-based";
const char *heuristic = "Heuristics-based";
/* this is a hack, but WTAP_NUM_FILE_TYPES_SUBTYPES is always >= number of open routines so we're safe */
captypes = g_new(struct string_elem, WTAP_NUM_FILE_TYPES_SUBTYPES);
/* How many readable file types are there? */
num_file_types = 0;
for (i = 0; open_routines[i].name != NULL; i++)
num_file_types++;
captypes = g_new(struct string_elem, num_file_types);
fprintf(stderr, "tshark: The available read file types for the \"-X read_format:\" option are:\n");
for (i = 0; open_routines[i].name != NULL; i++) {
for (i = 0; i < num_file_types && open_routines[i].name != NULL; i++) {
captypes[i].sstr = open_routines[i].name;
captypes[i].lstr = (open_routines[i].type == OPEN_INFO_MAGIC) ? magic : heuristic;
list = g_slist_insert_sorted(list, &captypes[i], string_compare);

5
ui/qt/capture_file_dialog.cpp
View File

@ -813,9 +813,10 @@ QStringList CaptureFileDialog::buildFileSaveAsTypeList(bool must_support_all_com
required_comment_types = 0; /* none of them */
/* What types of file can we save this file as? */
savable_file_types_subtypes = wtap_get_savable_file_types_subtypes(cap_file_->cd_t,
savable_file_types_subtypes = wtap_get_savable_file_types_subtypes_for_file(cap_file_->cd_t,
cap_file_->linktypes,
required_comment_types);
required_comment_types,
FT_SORT_BY_DESCRIPTION);
if (savable_file_types_subtypes != NULL) {
int ft;

10
ui/win32/file_dlg_win32.c
View File

@ -250,9 +250,10 @@ win32_save_as_file(HWND h_wnd, const wchar_t *title, capture_file *cf, GString *
else
required_comment_types = 0; /* none of them */
savable_file_types = wtap_get_savable_file_types_subtypes(cf->cd_t,
savable_file_types = wtap_get_savable_file_types_subtypes_for_file(cf->cd_t,
cf->linktypes,
required_comment_types);
required_comment_types,
FT_SORT_BY_DESCRIPTION);
if (savable_file_types == NULL)
return FALSE; /* shouldn't happen - the "Save As..." item should be disabled if we can't save the file */
g_compressed = FALSE;
@ -328,8 +329,9 @@ win32_export_specified_packets_file(HWND h_wnd, const wchar_t *title,
StringCchCopy(file_name16, MAX_PATH, utf_8to16(file_name->str));
}
savable_file_types = wtap_get_savable_file_types_subtypes(cf->cd_t,
cf->linktypes, 0);
savable_file_types = wtap_get_savable_file_types_subtypes_for_file(cf->cd_t,
cf->linktypes, 0,
FT_SORT_BY_DESCRIPTION);
if (savable_file_types == NULL)
return FALSE; /* shouldn't happen - the "Save As..." item should be disabled if we can't save the file */

11
wiretap/5views.c
View File

@ -461,9 +461,14 @@ static const struct file_type_subtype_info _5views_info = {
void register_5views(void)
{
_5views_file_type_subtype =
wtap_register_file_type_subtypes(&_5views_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
_5views_file_type_subtype = wtap_register_file_type_subtypes(&_5views_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("5VIEWS",
_5views_file_type_subtype);
}
/*

11
wiretap/aethra.c
View File

@ -349,9 +349,14 @@ static const struct file_type_subtype_info aethra_info = {
void register_aethra(void)
{
aethra_file_type_subtype =
wtap_register_file_type_subtypes(&aethra_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
aethra_file_type_subtype = wtap_register_file_type_subtypes(&aethra_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("AETHRA",
aethra_file_type_subtype);
}
/*

10
wiretap/ascendtext.c
View File

@ -465,6 +465,12 @@ static const struct file_type_subtype_info ascend_info = {
void register_ascend(void)
{
ascend_file_type_subtype = wtap_register_file_type_subtypes(&ascend_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
ascend_file_type_subtype = wtap_register_file_type_subtypes(&ascend_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("ASCEND",
ascend_file_type_subtype);
}

10
wiretap/btsnoop.c
View File

@ -434,8 +434,14 @@ static const struct file_type_subtype_info btsnoop_info = {
void register_btsnoop(void)
{
btsnoop_file_type_subtype = wtap_register_file_type_subtypes(&btsnoop_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
btsnoop_file_type_subtype = wtap_register_file_type_subtypes(&btsnoop_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("BTSNOOP",
btsnoop_file_type_subtype);
}
/*

10
wiretap/camins.c
View File

@ -460,8 +460,14 @@ static const struct file_type_subtype_info camins_info = {
void register_camins(void)
{
camins_file_type_subtype = wtap_register_file_type_subtypes(&camins_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
camins_file_type_subtype = wtap_register_file_type_subtypes(&camins_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("CAMINS",
camins_file_type_subtype);
}
/*

17
wiretap/capsa.c
View File

@ -448,12 +448,17 @@ static const struct file_type_subtype_info packet_builder_info = {
void register_capsa(void)
{
capsa_file_type_subtype =
wtap_register_file_type_subtypes(&capsa_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
packet_builder_file_type_subtype =
wtap_register_file_type_subtypes(&packet_builder_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
capsa_file_type_subtype = wtap_register_file_type_subtypes(&capsa_info);
packet_builder_file_type_subtype = wtap_register_file_type_subtypes(&packet_builder_info);
/*
* Register names for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("COLASOFT_CAPSA",
capsa_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("COLASOFT_PACKET_BUILDER",
packet_builder_file_type_subtype);
}
/*

18
wiretap/catapult_dct2000.c
View File

@ -1652,17 +1652,21 @@ free_line_prefix_info(gpointer key, gpointer value,
}
static const struct file_type_subtype_info dct2000_info = {
"Catapult DCT2000 trace (.out format)", "dct2000", "out", NULL,
FALSE, FALSE, 0,
catapult_dct2000_dump_can_write_encap, catapult_dct2000_dump_open, NULL
"Catapult DCT2000 trace (.out format)", "dct2000", "out", NULL,
FALSE, FALSE, 0,
catapult_dct2000_dump_can_write_encap, catapult_dct2000_dump_open, NULL
};
void register_dct2000(void)
{
dct2000_file_type_subtype =
wtap_register_file_type_subtypes(&dct2000_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
dct2000_file_type_subtype = wtap_register_file_type_subtypes(&dct2000_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("CATAPULT_DCT2000",
dct2000_file_type_subtype);
}
/*

11
wiretap/commview.c
View File

@ -608,9 +608,14 @@ static const struct file_type_subtype_info commview_info = {
void register_commview(void)
{
commview_file_type_subtype =
wtap_register_file_type_subtypes(&commview_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
commview_file_type_subtype = wtap_register_file_type_subtypes(&commview_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("COMMVIEW",
commview_file_type_subtype);
}
/*

11
wiretap/cosine.c
View File

@ -496,9 +496,14 @@ static const struct file_type_subtype_info cosine_info = {
void register_cosine(void)
{
cosine_file_type_subtype =
wtap_register_file_type_subtypes(&cosine_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
cosine_file_type_subtype = wtap_register_file_type_subtypes(&cosine_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("COSINE",
cosine_file_type_subtype);
}
/*

10
wiretap/csids.c
View File

@ -217,8 +217,14 @@ static const struct file_type_subtype_info csids_info = {
void register_csids(void)
{
csids_file_type_subtype = wtap_register_file_type_subtypes(&csids_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
csids_file_type_subtype = wtap_register_file_type_subtypes(&csids_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("CSIDS",
csids_file_type_subtype);
}
/*

11
wiretap/daintree-sna.c
View File

@ -262,9 +262,14 @@ static const struct file_type_subtype_info daintree_sna_info = {
void register_daintree_sna(void)
{
daintree_sna_file_type_subtype =
wtap_register_file_type_subtypes(&daintree_sna_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
daintree_sna_file_type_subtype = wtap_register_file_type_subtypes(&daintree_sna_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("DAINTREE_SNA",
daintree_sna_file_type_subtype);
}
/*

10
wiretap/dbs-etherwatch.c
View File

@ -638,8 +638,14 @@ static const struct file_type_subtype_info dbs_etherwatch_info = {
void register_dbs_etherwatch(void)
{
dbs_etherwatch_file_type_subtype = wtap_register_file_type_subtypes(&dbs_etherwatch_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
dbs_etherwatch_file_type_subtype = wtap_register_file_type_subtypes(&dbs_etherwatch_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("DBS_ETHERWATCH",
dbs_etherwatch_file_type_subtype);
}
/*

11
wiretap/dct3trace.c
View File

@ -410,9 +410,14 @@ static const struct file_type_subtype_info dct3trace_info = {
void register_dct3trace(void)
{
dct3trace_file_type_subtype =
wtap_register_file_type_subtypes(&dct3trace_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
dct3trace_file_type_subtype = wtap_register_file_type_subtypes(&dct3trace_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("DCT3TRACE",
dct3trace_file_type_subtype);
}
/*

11
wiretap/dpa400.c
View File

@ -254,9 +254,14 @@ static const struct file_type_subtype_info dpa400_info = {
void register_dpa400(void)
{
dpa400_file_type_subtype =
wtap_register_file_type_subtypes(&dpa400_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
dpa400_file_type_subtype = wtap_register_file_type_subtypes(&dpa400_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("DPA400",
dpa400_file_type_subtype);
}
/*

11
wiretap/eyesdn.c
View File

@ -484,9 +484,14 @@ static const struct file_type_subtype_info eyesdn_info = {
void register_eyesdn(void)
{
eyesdn_file_type_subtype =
wtap_register_file_type_subtypes(&eyesdn_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
eyesdn_file_type_subtype = wtap_register_file_type_subtypes(&eyesdn_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("EYESDN",
eyesdn_file_type_subtype);
}
/*

601
wiretap/file_access.c
View File

@ -15,8 +15,12 @@
#include <wsutil/file_util.h>
#include <wsutil/tempfile.h>
#ifdef HAVE_PLUGINS
#include <wsutil/plugins.h>
#endif
#include "wtap-int.h"
#include "wtap_modules.h"
#include "file_wrappers.h"
#include <wsutil/buffer.h>
#include "lanalyzer.h"
@ -1220,7 +1224,7 @@ wtap_fdreopen(wtap *wth, const char *filename, int *err)
If we need to modify it, we allocate a GArray, copy the entries
in the above table to that GArray, use the copy as the table, and
make all changes to the copy. */
static const struct file_type_subtype_info dump_open_table_base[] = {
static const struct file_type_subtype_info file_type_subtype_table_base[] = {
/* WTAP_FILE_TYPE_SUBTYPE_UNKNOWN (only used internally for initialization) */
{ NULL, NULL, NULL, NULL,
FALSE, FALSE, 0,
@ -1293,108 +1297,125 @@ static const struct file_type_subtype_info dump_open_table_base[] = {
NULL, NULL, NULL }
};
/*
* Pointer to the table we're currently using. It's initialized to point
* to the static table, but, if we have to allocate the GArray, it's
* changed to point to the data in the GArray.
*/
static const struct file_type_subtype_info* dump_open_table = dump_open_table_base;
#define N_DUMP_OPEN_TABLE_BASE_ENTRIES (sizeof(file_type_subtype_table_base) / sizeof(struct file_type_subtype_info))
/*
* Number of elements in the table we're currently using. It's initialized
* to the number of elements in the static table, but, if we have to
* allocate the GArray, it's changed to have the size of the GArray.
* Pointer to the GArray holding the registered file types.
*/
static gint wtap_num_file_types_subtypes = sizeof(dump_open_table_base) / sizeof(struct file_type_subtype_info);
static GArray* file_type_subtype_table_arr;
/*
* Pointer to the GArray; NULL until it's needed.
* Pointer to the table of registered file types in that GArray.
*/
static GArray* dump_open_table_arr = NULL;
static const struct file_type_subtype_info* file_type_subtype_table;
/*
* Create the GArray from the static table if it hasn't already been created.
* Number of elements in the table for builtin file types/subtypes.
*/
static void
init_file_types_subtypes_garray(void)
static guint wtap_num_builtin_file_types_subtypes;
/*
* Initialize the table of file types/subtypes with all the builtin
* types/subtypes.
*/
void
wtap_init_file_type_subtypes(void)
{
if (dump_open_table_arr) return;
/* Don't do this twice. */
g_assert(file_type_subtype_table_arr == NULL);
dump_open_table_arr = g_array_new(FALSE,TRUE,sizeof(struct file_type_subtype_info));
/*
* Estimate the number of file types/subtypes as twice the
* number of modules; that's probably an overestimate, as
* the average number of file types/subtypes registered by
* a module is > 1 but probably < 2, but that shouldn't
* waste too much memory.
*/
file_type_subtype_table_arr = g_array_sized_new(FALSE, TRUE,
sizeof(struct file_type_subtype_info), wtap_module_count*2);
g_array_append_vals(dump_open_table_arr,dump_open_table_base,wtap_num_file_types_subtypes);
/* Copy over the fixed builtin entries. */
g_array_append_vals(file_type_subtype_table_arr, file_type_subtype_table_base,
N_DUMP_OPEN_TABLE_BASE_ENTRIES);
dump_open_table = (const struct file_type_subtype_info*)(void *)dump_open_table_arr->data;
file_type_subtype_table = (const struct file_type_subtype_info*)(void *)file_type_subtype_table_arr->data;
/* Load the builtin plugins that aren't in the table. */
for (guint i = 0; i < wtap_module_count; i++)
wtap_module_reg[i].cb_func();
/* Remember which entries are builtin. */
wtap_num_builtin_file_types_subtypes = file_type_subtype_table_arr->len;
}
/* if subtype is WTAP_FILE_TYPE_SUBTYPE_UNKNOWN, then create a new subtype as well as register it, else replace the
existing entry in that spot */
/*
* Attempt to register a new file type/subtype; fails if a type/subtype
* with that name is already registered.
*/
int
wtap_register_file_type_subtypes(const struct file_type_subtype_info* fi, const int subtype)
wtap_register_file_type_subtypes(const struct file_type_subtype_info* fi)
{
struct file_type_subtype_info* finfo;
/*
* Check for required fields (description and name). If an existing
* file type is overridden (as opposed as creating a new registration),
* prevent internal subtypes from being overridden by Lua plugins.
* Check for required fields (description and name).
*/
if (!fi || !fi->description || !fi->name ||
(subtype != WTAP_FILE_TYPE_SUBTYPE_UNKNOWN &&
(subtype <= (int)G_N_ELEMENTS(dump_open_table_base) ||
subtype > wtap_num_file_types_subtypes))) {
g_error("no file type info or invalid file type to register");
return subtype;
if (!fi || !fi->description || !fi->name) {
g_error("no file type info");
return -1;
}
/* do we want a new registration? */
if (subtype == WTAP_FILE_TYPE_SUBTYPE_UNKNOWN) {
/* register a new one; first verify there isn't one named this already */
if (wtap_name_to_file_type_subtype(fi->name) > -1 ) {
g_error("file type short name \"%s\" already exists", fi->name);
return subtype;
}
/*
* Is this type already registered?
*/
if (wtap_name_to_file_type_subtype(fi->name) != -1) {
/*
* Create the GArray if it hasn't already been created.
* Yes. You don't get to replace an existing handler.
*/
init_file_types_subtypes_garray();
g_array_append_val(dump_open_table_arr,*fi);
dump_open_table = (const struct file_type_subtype_info*)(void *)dump_open_table_arr->data;
return wtap_num_file_types_subtypes++;
}
/* re-register an existing one - verify the names do match (sanity check really) */
if (!dump_open_table[subtype].name || strcmp(dump_open_table[subtype].name,fi->name) != 0) {
g_error("invalid file type name given to register");
return subtype;
g_error("file type \"%s\" is already registered", fi->name);
return -1;
}
/*
* Create the GArray if it hasn't already been created.
* Is there a freed entry in the array, due to a file type
* being de-registered?
*
* Skip the built-in entries, as they're never deregistered
* (and because entry 0, for WTAP_FILE_TYPE_SUBTYPE_UNKNOWN,
* has a null name pointer).
*/
init_file_types_subtypes_garray();
for (guint i = wtap_num_builtin_file_types_subtypes;
i < file_type_subtype_table_arr->len; i++) {
if (file_type_subtype_table[i].name == NULL) {
/*
* We found such an entry.
*
* Get the pointer from the GArray, so that we get a
* non-const pointer.
*/
finfo = &g_array_index(file_type_subtype_table_arr, struct file_type_subtype_info, i);
/*
* Fill in the entry with the new values.
*/
*finfo = *fi;
return (gint)i;
}
}
/*
* Get the pointer from the GArray, so that we get a non-const
* pointer.
* There aren't any free slots, so add a new entry.
* Append this entry to the end of the array, change
* file_type_subtype_table in case the array had to get reallocated,
* increment the number of entries (XXX - just use the array
* length!), and return subtype, which is now set to the
* old number of entries, which is now the index of the new
* entry.
*/
finfo = &g_array_index(dump_open_table_arr, struct file_type_subtype_info, subtype);
/*finfo->description = fi->description;*/
/*finfo->name = fi->name;*/
finfo->default_file_extension = fi->default_file_extension;
finfo->additional_file_extensions = fi->additional_file_extensions;
finfo->writing_must_seek = fi->writing_must_seek;
finfo->has_name_resolution = fi->has_name_resolution;
finfo->supported_comment_types = fi->supported_comment_types;
finfo->can_write_encap = fi->can_write_encap;
finfo->dump_open = fi->dump_open;
finfo->wslua_info = fi->wslua_info;
return subtype;
g_array_append_val(file_type_subtype_table_arr,*fi);
file_type_subtype_table = (const struct file_type_subtype_info*)(void *)file_type_subtype_table_arr->data;
return file_type_subtype_table_arr->len;
}
/* De-registers a file writer - they can never be removed from the GArray, but we can "clear" an entry.
@ -1404,24 +1425,25 @@ wtap_deregister_file_type_subtype(const int subtype)
{
struct file_type_subtype_info* finfo;
if (subtype < 0 || subtype >= wtap_num_file_types_subtypes) {
if (subtype < 0 || subtype >= (int)file_type_subtype_table_arr->len) {
g_error("invalid file type to de-register");
return;
}
/*
* Create the GArray if it hasn't already been created.
*/
init_file_types_subtypes_garray();
if ((guint)subtype >= wtap_num_builtin_file_types_subtypes) {
g_error("built-in file types cannot be de-registered");
return;
}
/*
* Get the pointer from the GArray, so that we get a non-const
* pointer.
*/
finfo = &g_array_index(dump_open_table_arr, struct file_type_subtype_info, subtype);
/* unfortunately, it's not safe to null-out the description or name; bunch of other code doesn't guard aainst that, afaict */
/*finfo->description = NULL;*/
/*finfo->name = NULL;*/
finfo = &g_array_index(file_type_subtype_table_arr, struct file_type_subtype_info, subtype);
/*
* Clear out this entry.
*/
finfo->description = NULL;
finfo->name = NULL;
finfo->default_file_extension = NULL;
finfo->additional_file_extensions = NULL;
finfo->writing_must_seek = FALSE;
@ -1432,12 +1454,6 @@ wtap_deregister_file_type_subtype(const int subtype)
finfo->wslua_info = NULL;
}
int
wtap_get_num_file_types_subtypes(void)
{
return wtap_num_file_types_subtypes;
}
/*
* Given a GArray of WTAP_ENCAP_ types, return the per-file encapsulation
* type that would be needed to write out a file with those types. If
@ -1462,19 +1478,19 @@ wtap_dump_can_write_encap(int filetype, int encap)
{
int result = 0;
if (filetype < 0 || filetype >= wtap_num_file_types_subtypes
|| dump_open_table[filetype].can_write_encap == NULL)
if (filetype < 0 || filetype >= (int)file_type_subtype_table_arr->len ||
file_type_subtype_table[filetype].can_write_encap == NULL)
return FALSE;
result = (*dump_open_table[filetype].can_write_encap)(encap);
result = (*file_type_subtype_table[filetype].can_write_encap)(encap);
if (result != 0) {
/* if the err said to check wslua's can_write_encap, try that */
if (result == WTAP_ERR_CHECK_WSLUA
&& dump_open_table[filetype].wslua_info != NULL
&& dump_open_table[filetype].wslua_info->wslua_can_write_encap != NULL) {
&& file_type_subtype_table[filetype].wslua_info != NULL
&& file_type_subtype_table[filetype].wslua_info->wslua_can_write_encap != NULL) {
result = (*dump_open_table[filetype].wslua_info->wslua_can_write_encap)(encap, dump_open_table[filetype].wslua_info->wslua_data);
result = (*file_type_subtype_table[filetype].wslua_info->wslua_can_write_encap)(encap, file_type_subtype_table[filetype].wslua_info->wslua_data);
}
@ -1546,7 +1562,7 @@ wtap_dump_can_write(const GArray *file_encaps, guint32 required_comment_types)
{
int ft;
for (ft = 0; ft < WTAP_NUM_FILE_TYPES_SUBTYPES; ft++) {
for (ft = 0; ft < (int)file_type_subtype_table_arr->len; ft++) {
/* To save a file with Wiretap, Wiretap has to handle that format,
* and its code to handle that format must be able to write a file
* with this file's encapsulation types.
@ -1561,16 +1577,45 @@ wtap_dump_can_write(const GArray *file_encaps, guint32 required_comment_types)
return FALSE;
}
/*
* Sort by file type/subtype name.
*/
static int
compare_file_type_subtypes_by_name(gconstpointer a, gconstpointer b)
{
int file_type_subtype_a = *(const int *)a;
int file_type_subtype_b = *(const int *)b;
return strcmp(wtap_file_type_subtype_name(file_type_subtype_a),
wtap_file_type_subtype_name(file_type_subtype_b));
}
/*
* Sort by file type/subtype description.
*/
static int
compare_file_type_subtypes_by_description(gconstpointer a, gconstpointer b)
{
int file_type_subtype_a = *(const int *)a;
int file_type_subtype_b = *(const int *)b;
return strcmp(wtap_file_type_subtype_description(file_type_subtype_a),
wtap_file_type_subtype_description(file_type_subtype_b));
}
/**
* Get a GArray of WTAP_FILE_TYPE_SUBTYPE_ values for file types/subtypes
* Get a GArray of file type/subtype values for file types/subtypes
* that can be used to save a file of a given type/subtype with a given
* GArray of encapsulation types and the given bitmask of comment types.
*/
GArray *
wtap_get_savable_file_types_subtypes(int file_type_subtype,
const GArray *file_encaps, guint32 required_comment_types)
wtap_get_savable_file_types_subtypes_for_file(int file_type_subtype,
const GArray *file_encaps, guint32 required_comment_types,
ft_sort_order sort_order)
{
GArray *savable_file_types_subtypes;
int pcap_file_type_subtype = wtap_name_to_file_type_subtype("pcap");
int pcapng_file_type_subtype = wtap_name_to_file_type_subtype("pcapng");
int ft;
int default_file_type_subtype = -1;
int other_file_type_subtype = -1;
@ -1583,7 +1628,7 @@ wtap_get_savable_file_types_subtypes(int file_type_subtype,
} else {
/* OK, find the first file type/subtype we *can* save it as. */
default_file_type_subtype = -1;
for (ft = 0; ft < WTAP_NUM_FILE_TYPES_SUBTYPES; ft++) {
for (ft = 0; ft < (int)file_type_subtype_table_arr->len; ft++) {
if (wtap_dump_can_write_format(ft, file_encaps,
required_comment_types)) {
/* OK, got it. */
@ -1598,34 +1643,38 @@ wtap_get_savable_file_types_subtypes(int file_type_subtype,
return NULL;
}
/* Allocate the array. */
savable_file_types_subtypes = g_array_new(FALSE, FALSE, (guint)sizeof (int));
/* Put the default file type/subtype first in the list. */
g_array_append_val(savable_file_types_subtypes, default_file_type_subtype);
/* If the default is pcap, put pcapng right after it if we can
also write it in pcapng format; otherwise, if the default is
pcapng, put pcap right after it if we can also write it in
pcap format. */
if (default_file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_PCAP) {
if (wtap_dump_can_write_format(WTAP_FILE_TYPE_SUBTYPE_PCAPNG, file_encaps,
/*
* If the default is pcap, put pcapng right after it if we can
* also write it in pcapng format; otherwise, if the default is
* pcapng, put pcap right after it if we can also write it in
* pcap format.
*/
if (default_file_type_subtype == pcap_file_type_subtype) {
if (wtap_dump_can_write_format(pcapng_file_type_subtype,
file_encaps,
required_comment_types))
other_file_type_subtype = pcapng_file_type_subtype;
} else if (default_file_type_subtype == pcapng_file_type_subtype) {
if (wtap_dump_can_write_format(pcap_file_type_subtype,
file_encaps,
required_comment_types))
other_file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PCAPNG;
} else if (default_file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_PCAPNG) {
if (wtap_dump_can_write_format(WTAP_FILE_TYPE_SUBTYPE_PCAP, file_encaps,
required_comment_types))
other_file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PCAP;
other_file_type_subtype = pcap_file_type_subtype;
}
if (other_file_type_subtype != -1)
g_array_append_val(savable_file_types_subtypes, other_file_type_subtype);
/* Add all the other file types/subtypes that work. */
for (ft = 0; ft < WTAP_NUM_FILE_TYPES_SUBTYPES; ft++) {
/* Allocate the array. */
savable_file_types_subtypes = g_array_new(FALSE, FALSE,
sizeof (int));
/*
* First, add the types we don't want to force to the
* beginning of the list.
*/
for (ft = 0; ft < (int)file_type_subtype_table_arr->len; ft++) {
if (ft == WTAP_FILE_TYPE_SUBTYPE_UNKNOWN)
continue; /* not a real file type */
if (ft == default_file_type_subtype || ft == other_file_type_subtype)
continue; /* we've already done this one */
if (ft == default_file_type_subtype ||
ft == other_file_type_subtype)
continue; /* we will done this one later */
if (wtap_dump_can_write_format(ft, file_encaps,
required_comment_types)) {
/* OK, we can write it out in this type. */
@ -1633,9 +1682,97 @@ wtap_get_savable_file_types_subtypes(int file_type_subtype,
}
}
/* Now, sort the list. */
g_array_sort(savable_file_types_subtypes,
(sort_order == FT_SORT_BY_NAME) ? compare_file_type_subtypes_by_name :
compare_file_type_subtypes_by_description);
/*
* If we have a type/subtype to put above the default one,
* do so.
*
* We put this type at the beginning before putting the
* default there, so the default is at the top.
*/
if (other_file_type_subtype != -1)
g_array_prepend_val(savable_file_types_subtypes,
other_file_type_subtype);
/* Put the default file type/subtype first in the list. */
g_array_prepend_val(savable_file_types_subtypes,
default_file_type_subtype);
return savable_file_types_subtypes;
}
/**
* Get a GArray of all writable file type/subtype values.
*/
GArray *
wtap_get_writable_file_types_subtypes(ft_sort_order sort_order)
{
GArray *writable_file_types_subtypes;
int pcap_file_type_subtype = wtap_name_to_file_type_subtype("pcap");
int pcapng_file_type_subtype = wtap_name_to_file_type_subtype("pcapng");
int ft;
/*
* Allocate the array.
* Pre-allocate room enough for all types.
* XXX - that's overkill; just scan the table to find all the
* writable types and count them.
*/
writable_file_types_subtypes = g_array_sized_new(FALSE, FALSE,
sizeof (int), file_type_subtype_table_arr->len);
/*
* First, add the types we don't want to force to the
* beginning of the list.
*/
for (ft = 0; ft < (int)file_type_subtype_table_arr->len; ft++) {
if (ft == WTAP_FILE_TYPE_SUBTYPE_UNKNOWN)
continue; /* not a real file type */
if (ft == pcap_file_type_subtype ||
ft == pcapng_file_type_subtype)
continue; /* we've already done these two */
if (wtap_dump_can_open(ft)) {
/* OK, we can write this type. */
g_array_append_val(writable_file_types_subtypes, ft);
}
}
/* Now, sort the list. */
g_array_sort(writable_file_types_subtypes,
(sort_order == FT_SORT_BY_NAME) ? compare_file_type_subtypes_by_name :
compare_file_type_subtypes_by_description);
/*
* Now, put pcap and pcapng at the beginning, as they're
* our "native" formats. Put pcapng there first, and
* pcap before it.
*/
if (pcapng_file_type_subtype != -1 &&
wtap_dump_can_open(pcapng_file_type_subtype)) {
/*
* We can write pcapng. (If we can't, that's a huge
* mistake.)
*/
g_array_prepend_val(writable_file_types_subtypes,
pcapng_file_type_subtype);
}
if (pcap_file_type_subtype != -1 &&
wtap_dump_can_open(pcap_file_type_subtype)) {
/*
* We can write pcap. (If we can't, that's a huge
* mistake.)
*/
g_array_prepend_val(writable_file_types_subtypes,
pcap_file_type_subtype);
}
return writable_file_types_subtypes;
}
/**
* Return TRUE if files of this file type/subtype use interface IDs
* to associate records with an interface.
@ -1658,22 +1795,22 @@ wtap_uses_interface_ids(int file_type)
const char *
wtap_file_type_subtype_description(int file_type_subtype)
{
if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes) {
g_error("Unknown capture file type %d", file_type_subtype);
/** g_error() does an abort() and thus never returns **/
return "";
} else
return dump_open_table[file_type_subtype].description;
if (file_type_subtype < 0 ||
file_type_subtype >= (int)file_type_subtype_table_arr->len)
return NULL;
else
return file_type_subtype_table[file_type_subtype].description;
}
/* Name to use in, say, a command-line flag specifying the type/subtype. */
const char *
wtap_file_type_subtype_name(int file_type_subtype)
{
if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes)
if (file_type_subtype < 0 ||
file_type_subtype >= (int)file_type_subtype_table_arr->len)
return NULL;
else
return dump_open_table[file_type_subtype].name;
return file_type_subtype_table[file_type_subtype].name;
}
/* Translate a name to a capture file type/subtype. */
@ -1682,32 +1819,39 @@ wtap_name_to_file_type_subtype(const char *name)
{
int file_type_subtype;
for (file_type_subtype = 0; file_type_subtype < wtap_num_file_types_subtypes; file_type_subtype++) {
if (dump_open_table[file_type_subtype].name != NULL &&
strcmp(name, dump_open_table[file_type_subtype].name) == 0)
return file_type_subtype;
}
/*
* We now call the libpcap file format just pcap, but we allow
* the various variants of it to be specified using names
* containing "libpcap" as well as "pcap", for backwards
* compatibility.
*/
if (strcmp(name, "libpcap") == 0)
return WTAP_FILE_TYPE_SUBTYPE_PCAP;
else if (strcmp(name, "nseclibpcap") == 0)
return WTAP_FILE_TYPE_SUBTYPE_PCAP_NSEC;
else if (strcmp(name, "aixlibpcap") == 0)
return WTAP_FILE_TYPE_SUBTYPE_PCAP_AIX;
else if (strcmp(name, "modlibpcap") == 0)
return WTAP_FILE_TYPE_SUBTYPE_PCAP_SS991029;
else if (strcmp(name, "nokialibpcap") == 0)
return WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA;
else if (strcmp(name, "rh6_1libpcap") == 0)
return WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990417;
else if (strcmp(name, "suse6_3libpcap") == 0)
return WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990915;
static const struct name_map {
const char *oldname;
const char *name;
} name_map[] = {
{ "libpcap", "pcap" },
{ "nseclibpcap", "nsecpcap" },
{ "aixlibpcap", "aixpcap" },
{ "modlibpcap", "modpcap" },
{ "nokialibpcap", "nokiapcap" },
{ "rh6_1libpcap", "rh6_1pcap" },
{ "suse6_3libpcap", "suse6_3pcap" }
};
#define N_NAME_MAP_ENTRIES (sizeof name_map / sizeof name_map[0])
for (size_t i = 0; i < N_NAME_MAP_ENTRIES; i++) {
if (strcmp(name_map[i].oldname, name) == 0) {
name = name_map[i].name;
break;
}
}
for (file_type_subtype = 0;
file_type_subtype < (int)file_type_subtype_table_arr->len;
file_type_subtype++) {
if (file_type_subtype_table[file_type_subtype].name != NULL &&
strcmp(name, file_type_subtype_table[file_type_subtype].name) == 0)
return file_type_subtype;
}
return -1; /* no such file type, or we can't write it */
}
@ -1724,20 +1868,20 @@ add_extensions_for_file_type_subtype(int file_type_subtype, GSList *extensions,
* from the list of compressed-file extensions, if there is a
* default extension.
*/
if (dump_open_table[file_type_subtype].default_file_extension != NULL) {
if (file_type_subtype_table[file_type_subtype].default_file_extension != NULL) {
extensions = add_extensions(extensions,
dump_open_table[file_type_subtype].default_file_extension,
file_type_subtype_table[file_type_subtype].default_file_extension,
compression_type_extensions);
}
if (dump_open_table[file_type_subtype].additional_file_extensions != NULL) {
if (file_type_subtype_table[file_type_subtype].additional_file_extensions != NULL) {
/*
* We have additional extensions; add them.
*
* First, split the extension-list string into a set of
* extensions.
*/
extensions_set = g_strsplit(dump_open_table[file_type_subtype].additional_file_extensions,
extensions_set = g_strsplit(file_type_subtype_table[file_type_subtype].additional_file_extensions,
";", 0);
/*
@ -1773,10 +1917,11 @@ wtap_get_file_extensions_list(int file_type_subtype, gboolean include_compressed
{
GSList *extensions, *compression_type_extensions;
if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes)
if (file_type_subtype < 0 ||
file_type_subtype >= (int)file_type_subtype_table_arr->len)
return NULL; /* not a valid file type */
if (dump_open_table[file_type_subtype].default_file_extension == NULL)
if (file_type_subtype_table[file_type_subtype].default_file_extension == NULL)
return NULL; /* valid, but no extensions known */
extensions = NULL; /* empty list, to start with */
@ -1819,7 +1964,6 @@ GSList *
wtap_get_all_file_extensions_list(void)
{
GSList *extensions, *compression_type_extensions;
int i;
extensions = NULL; /* empty list, to start with */
@ -1828,8 +1972,8 @@ wtap_get_all_file_extensions_list(void)
*/
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,
for (int ft = 0; ft < (int)file_type_subtype_table_arr->len; ft++) {
extensions = add_extensions_for_file_type_subtype(ft, extensions,
compression_type_extensions);
}
@ -1860,17 +2004,19 @@ wtap_free_extensions_list(GSList *extensions)
const char *
wtap_default_file_extension(int file_type_subtype)
{
if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes)
if (file_type_subtype < 0 ||
file_type_subtype >= (int)file_type_subtype_table_arr->len)
return NULL;
else
return dump_open_table[file_type_subtype].default_file_extension;
return file_type_subtype_table[file_type_subtype].default_file_extension;
}
gboolean
wtap_dump_can_open(int file_type_subtype)
{
if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes
|| dump_open_table[file_type_subtype].dump_open == NULL)
if (file_type_subtype < 0 ||
file_type_subtype >= (int)file_type_subtype_table_arr->len ||
file_type_subtype_table[file_type_subtype].dump_open == NULL)
return FALSE;
return TRUE;
@ -1885,8 +2031,9 @@ wtap_dump_can_compress(int file_type_subtype)
* seek when writing out a file with this file type,
* return FALSE.
*/
if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes
|| dump_open_table[file_type_subtype].writing_must_seek)
if (file_type_subtype < 0 ||
file_type_subtype >= (int)file_type_subtype_table_arr->len ||
file_type_subtype_table[file_type_subtype].writing_must_seek)
return FALSE;
return TRUE;
@ -1902,8 +2049,9 @@ wtap_dump_can_compress(int file_type_subtype _U_)
gboolean
wtap_dump_has_name_resolution(int file_type_subtype)
{
if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes
|| dump_open_table[file_type_subtype].has_name_resolution == FALSE)
if (file_type_subtype < 0 ||
file_type_subtype >= (int)file_type_subtype_table_arr->len ||
file_type_subtype_table[file_type_subtype].has_name_resolution == FALSE)
return FALSE;
return TRUE;
@ -1914,10 +2062,11 @@ wtap_dump_supports_comment_types(int file_type_subtype, guint32 comment_types)
{
guint32 supported_comment_types;
if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes)
if (file_type_subtype < 0 ||
file_type_subtype >= (int)file_type_subtype_table_arr->len)
return FALSE;
supported_comment_types = dump_open_table[file_type_subtype].supported_comment_types;
supported_comment_types = file_type_subtype_table[file_type_subtype].supported_comment_types;
if ((comment_types & supported_comment_types) == comment_types)
return TRUE;
@ -2242,13 +2391,13 @@ wtap_dump_open_check(int file_type_subtype, int encap, gboolean compressed, int
/* OK, we know how to write that type; can we write the specified
encapsulation type? */
*err = (*dump_open_table[file_type_subtype].can_write_encap)(encap);
*err = (*file_type_subtype_table[file_type_subtype].can_write_encap)(encap);
/* if the err said to check wslua's can_write_encap, try that */
if (*err == WTAP_ERR_CHECK_WSLUA
&& dump_open_table[file_type_subtype].wslua_info != NULL
&& dump_open_table[file_type_subtype].wslua_info->wslua_can_write_encap != NULL) {
&& file_type_subtype_table[file_type_subtype].wslua_info != NULL
&& file_type_subtype_table[file_type_subtype].wslua_info->wslua_can_write_encap != NULL) {
*err = (*dump_open_table[file_type_subtype].wslua_info->wslua_can_write_encap)(encap, dump_open_table[file_type_subtype].wslua_info->wslua_data);
*err = (*file_type_subtype_table[file_type_subtype].wslua_info->wslua_can_write_encap)(encap, file_type_subtype_table[file_type_subtype].wslua_info->wslua_data);
}
@ -2309,7 +2458,7 @@ wtap_dump_open_finish(wtap_dumper *wdh, int file_type_subtype, int *err,
}
/* If this file type requires seeking, and we can't seek, fail. */
if (dump_open_table[file_type_subtype].writing_must_seek && cant_seek) {
if (file_type_subtype_table[file_type_subtype].writing_must_seek && cant_seek) {
*err = WTAP_ERR_CANT_WRITE_TO_PIPE;
return FALSE;
}
@ -2317,11 +2466,11 @@ wtap_dump_open_finish(wtap_dumper *wdh, int file_type_subtype, int *err,
/* Set wdh with wslua data if any - this is how we pass the data
* to the file writer.
*/
if (dump_open_table[file_type_subtype].wslua_info)
wdh->wslua_data = dump_open_table[file_type_subtype].wslua_info->wslua_data;
if (file_type_subtype_table[file_type_subtype].wslua_info)
wdh->wslua_data = file_type_subtype_table[file_type_subtype].wslua_info->wslua_data;
/* Now try to open the file for writing. */
if (!(*dump_open_table[file_type_subtype].dump_open)(wdh, err,
if (!(*file_type_subtype_table[file_type_subtype].dump_open)(wdh, err,
err_info)) {
return FALSE;
}
@ -2432,9 +2581,10 @@ wtap_addrinfo_list_empty(addrinfo_lists_t *addrinfo_lists)
gboolean
wtap_dump_set_addrinfo_list(wtap_dumper *wdh, addrinfo_lists_t *addrinfo_lists)
{
if (!wdh || wdh->file_type_subtype < 0 || wdh->file_type_subtype >= wtap_num_file_types_subtypes
|| dump_open_table[wdh->file_type_subtype].has_name_resolution == FALSE)
return FALSE;
if (!wdh || wdh->file_type_subtype < 0 ||
wdh->file_type_subtype >= (int)file_type_subtype_table_arr->len ||
file_type_subtype_table[wdh->file_type_subtype].has_name_resolution == FALSE)
return FALSE;
wdh->addrinfo_lists = addrinfo_lists;
return TRUE;
}
@ -2609,6 +2759,99 @@ cleanup_open_routines(void)
}
}
/*
* Allow built-in file handlers (but *not* plugin file handlers!) to
* register a "backwards-compatibility" name and file type value, to
* put in the Lua wtap_filetypes table.
*
* This is only to be used as long as we have that table; new Lua
* code should use wtap_name_to_file_type_subtype() to look up
* file types by their name, just as C code should.
*
* The backwards-ccmpatibility names are the old WTAP_FILE_TYPE_SUBTYPE_
* #define name, with WTAP_FILE_TYPE_SUBTYPE_ removed.
*/
static GArray *backwards_compatibility_lua_names;
void
wtap_register_backwards_compatibility_lua_name(const char *name, int ft)
{
struct backwards_compatibiliity_lua_name entry;
/*
* Create the table if it doesn't already exist.
* Use the same size as we do for the file type/subtype table.
*/
if (backwards_compatibility_lua_names == NULL) {
backwards_compatibility_lua_names = g_array_sized_new(FALSE,
TRUE, sizeof(struct backwards_compatibiliity_lua_name),
wtap_module_count*2);
/*
* Extra backwards compatibility hack - add entries
* for time stamp precision values(!), as well as
* for "UNKNOWN" and types that don't yet register
* themselves.
*
* If new WS_TSPREC_ value are added, don't bother
* adding them to this table; any Lua program that
* would use them should use the wtap_tsprecs type.
*
* (Recursion: see "recursion".)
*/
wtap_register_backwards_compatibility_lua_name("TSPREC_SEC",
WTAP_TSPREC_SEC);
wtap_register_backwards_compatibility_lua_name("TSPREC_DSEC",
WTAP_TSPREC_DSEC);
wtap_register_backwards_compatibility_lua_name("TSPREC_CSEC",
WTAP_TSPREC_CSEC);
wtap_register_backwards_compatibility_lua_name("TSPREC_MSEC",
WTAP_TSPREC_MSEC);
wtap_register_backwards_compatibility_lua_name("TSPREC_USEC",
WTAP_TSPREC_USEC);
wtap_register_backwards_compatibility_lua_name("TSPREC_NSEC",
WTAP_TSPREC_NSEC);
wtap_register_backwards_compatibility_lua_name("UNKNOWN",
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
wtap_register_backwards_compatibility_lua_name("PCAP",
WTAP_FILE_TYPE_SUBTYPE_PCAP);
wtap_register_backwards_compatibility_lua_name("PCAPNG",
WTAP_FILE_TYPE_SUBTYPE_PCAPNG);
wtap_register_backwards_compatibility_lua_name("PCAP_NSEC",
WTAP_FILE_TYPE_SUBTYPE_PCAP_NSEC);
wtap_register_backwards_compatibility_lua_name("PCAP_AIX",
WTAP_FILE_TYPE_SUBTYPE_PCAP_AIX);
wtap_register_backwards_compatibility_lua_name("PCAP_SS991029",
WTAP_FILE_TYPE_SUBTYPE_PCAP_SS991029);
wtap_register_backwards_compatibility_lua_name("PCAP_NOKIA",
WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA);
wtap_register_backwards_compatibility_lua_name("PCAP_SS990417",
WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990417);
wtap_register_backwards_compatibility_lua_name("PCAP_SS990915",
WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990915);
wtap_register_backwards_compatibility_lua_name("IPTRACE_1_0",
WTAP_FILE_TYPE_SUBTYPE_IPTRACE_1_0);
wtap_register_backwards_compatibility_lua_name("IPTRACE_2_0",
WTAP_FILE_TYPE_SUBTYPE_IPTRACE_2_0);
wtap_register_backwards_compatibility_lua_name("BER",
WTAP_FILE_TYPE_SUBTYPE_BER);
wtap_register_backwards_compatibility_lua_name("ERF",
WTAP_FILE_TYPE_SUBTYPE_ERF);
wtap_register_backwards_compatibility_lua_name("SYSTEMD_JOURNAL",
WTAP_FILE_TYPE_SUBTYPE_SYSTEMD_JOURNAL);
}
entry.name = name;
entry.ft = ft;
g_array_append_val(backwards_compatibility_lua_names, entry);
}
const GArray *
get_backwards_compatibility_lua_table(void)
{
return backwards_compatibility_lua_names;
}
/*
* Editor modelines - https://www.wireshark.org/tools/modelines.html
*

11
wiretap/hcidump.c
View File

@ -130,9 +130,14 @@ static const struct file_type_subtype_info hcidump_info = {
void register_hcidump(void)
{
hcidump_file_type_subtype =
wtap_register_file_type_subtypes(&hcidump_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
hcidump_file_type_subtype = wtap_register_file_type_subtypes(&hcidump_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("HCIDUMP",
hcidump_file_type_subtype);
}
/*

11
wiretap/i4btrace.c
View File

@ -305,9 +305,14 @@ static const struct file_type_subtype_info i4btrace_info = {
void register_i4btrace(void)
{
i4btrace_file_type_subtype =
wtap_register_file_type_subtypes(&i4btrace_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
i4btrace_file_type_subtype = wtap_register_file_type_subtypes(&i4btrace_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("I4BTRACE",
i4btrace_file_type_subtype);
}
/*

10
wiretap/ipfix.c
View File

@ -336,8 +336,14 @@ static const struct file_type_subtype_info ipfix_info = {
void register_ipfix(void)
{
ipfix_file_type_subtype = wtap_register_file_type_subtypes(&ipfix_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
ipfix_file_type_subtype = wtap_register_file_type_subtypes(&ipfix_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("IPFIX",
ipfix_file_type_subtype);
}
/*

15
wiretap/iseries.c
View File

@ -1066,10 +1066,17 @@ static const struct file_type_subtype_info iseries_unicode_info = {
void register_iseries(void)
{
iseries_file_type_subtype = wtap_register_file_type_subtypes(&iseries_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
iseries_unicode_file_type_subtype = wtap_register_file_type_subtypes(&iseries_unicode_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
iseries_file_type_subtype = wtap_register_file_type_subtypes(&iseries_info);
iseries_unicode_file_type_subtype = wtap_register_file_type_subtypes(&iseries_unicode_info);
/*
* Register names for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("ISERIES",
iseries_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("ISERIES_UNICODE",
iseries_unicode_file_type_subtype);
}
/*

11
wiretap/json.c
View File

@ -68,7 +68,6 @@ wtap_open_return_val json_open(wtap *wth, int *err, gchar **err_info)
}
static const struct file_type_subtype_info json_info = {
/* WTAP_FILE_TYPE_SUBTYPE_JSON */
"JavaScript Object Notation", "json", "json", NULL,
FALSE, FALSE, 0,
NULL, NULL, NULL
@ -76,8 +75,14 @@ static const struct file_type_subtype_info json_info = {
void register_json(void)
{
json_file_type_subtype = wtap_register_file_type_subtypes(&json_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
json_file_type_subtype = wtap_register_file_type_subtypes(&json_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("JSON",
json_file_type_subtype);
}
/*

10
wiretap/k12.c
View File

@ -1401,8 +1401,14 @@ static const struct file_type_subtype_info k12_info = {
void register_k12(void)
{
k12_file_type_subtype = wtap_register_file_type_subtypes(&k12_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
k12_file_type_subtype = wtap_register_file_type_subtypes(&k12_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("K12",
k12_file_type_subtype);
}
/*

10
wiretap/k12text.l
View File

@ -584,6 +584,12 @@ static const struct file_type_subtype_info k12text_info = {
void register_k12text(void)
{
k12text_file_type_subtype = wtap_register_file_type_subtypes(&k12text_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
k12text_file_type_subtype = wtap_register_file_type_subtypes(&k12text_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("K12TEXT",
k12text_file_type_subtype);
}

10
wiretap/lanalyzer.c
View File

@ -972,8 +972,14 @@ static const struct file_type_subtype_info lanalyzer_info = {
void register_lanalyzer(void)
{
lanalyzer_file_type_subtype = wtap_register_file_type_subtypes(&lanalyzer_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
lanalyzer_file_type_subtype = wtap_register_file_type_subtypes(&lanalyzer_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("LANALYZER",
lanalyzer_file_type_subtype);
}
/*

18
wiretap/log3gpp.c
View File

@ -887,16 +887,21 @@ gboolean get_file_time_stamp(gchar* linebuff, time_t *secs, guint32 *usecs)
}
static const struct file_type_subtype_info log3gpp_info = {
"3GPP Log", "3gpp_log", "*.log", NULL,
TRUE, FALSE, 0,
NULL, NULL, NULL
"3GPP Log", "3gpp_log", "*.log", NULL,
TRUE, FALSE, 0,
NULL, NULL, NULL
};
void register_log3gpp(void)
{
log3gpp_file_type_subtype =
wtap_register_file_type_subtypes(&log3gpp_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
log3gpp_file_type_subtype = wtap_register_file_type_subtypes(&log3gpp_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("LOG_3GPP",
log3gpp_file_type_subtype);
}
#if 0
@ -914,6 +919,7 @@ void wtap_register_phonelog(void) {
wf_3gpp_log = wtap_register_file_type_subtypes(&fi, WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
}
#endif
/*
* Editor modelines - https://www.wireshark.org/tools/modelines.html
*

10
wiretap/logcat.c
View File

@ -372,8 +372,14 @@ static const struct file_type_subtype_info logcat_info = {
void register_logcat(void)
{
logcat_file_type_subtype = wtap_register_file_type_subtypes(&logcat_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
logcat_file_type_subtype = wtap_register_file_type_subtypes(&logcat_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("LOGCAT",
logcat_file_type_subtype);
}
/*

40
wiretap/logcat_text.c
View File

@ -672,20 +672,32 @@ static const struct file_type_subtype_info logcat_text_long_info = {
void register_logcat_text(void)
{
logcat_text_brief_file_type_subtype = wtap_register_file_type_subtypes(&logcat_text_brief_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
logcat_text_process_file_type_subtype = wtap_register_file_type_subtypes(&logcat_text_process_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
logcat_text_tag_file_type_subtype = wtap_register_file_type_subtypes(&logcat_text_tag_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
logcat_text_thread_file_type_subtype = wtap_register_file_type_subtypes(&logcat_text_thread_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
logcat_text_time_file_type_subtype = wtap_register_file_type_subtypes(&logcat_text_time_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
logcat_text_threadtime_file_type_subtype = wtap_register_file_type_subtypes(&logcat_text_threadtime_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
logcat_text_long_file_type_subtype = wtap_register_file_type_subtypes(&logcat_text_long_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
logcat_text_brief_file_type_subtype = wtap_register_file_type_subtypes(&logcat_text_brief_info);
logcat_text_process_file_type_subtype = wtap_register_file_type_subtypes(&logcat_text_process_info);
logcat_text_tag_file_type_subtype = wtap_register_file_type_subtypes(&logcat_text_tag_info);
logcat_text_thread_file_type_subtype = wtap_register_file_type_subtypes(&logcat_text_thread_info);
logcat_text_time_file_type_subtype = wtap_register_file_type_subtypes(&logcat_text_time_info);
logcat_text_threadtime_file_type_subtype = wtap_register_file_type_subtypes(&logcat_text_threadtime_info);
logcat_text_long_file_type_subtype = wtap_register_file_type_subtypes(&logcat_text_long_info);
/*
* Register names for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("LOGCAT_BRIEF",
logcat_text_brief_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("LOGCAT_PROCESS",
logcat_text_process_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("LOGCAT_TAG",
logcat_text_tag_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("LOGCAT_THREAD",
logcat_text_thread_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("LOGCAT_TIME",
logcat_text_time_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("LOGCAT_THREADTIME",
logcat_text_threadtime_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("LOGCAT_LONG",
logcat_text_long_file_type_subtype);
}
/*

22
wiretap/mime_file.c
View File

@ -168,16 +168,24 @@ static const struct file_type_subtype_info jpeg_jfif_info = {
void register_mime(void)
{
mime_file_type_subtype =
wtap_register_file_type_subtypes(&mime_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
int jpeg_jfif_file_type_subtype;
mime_file_type_subtype = wtap_register_file_type_subtypes(&mime_info);
/*
* Obsoleted by "mime", so just register it; we don't
* need its return value.
* Obsoleted by "mime", but we want it for the backwards-
* compatibility table for Lua.
*/
wtap_register_file_type_subtypes(&jpeg_jfif_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
jpeg_jfif_file_type_subtype = wtap_register_file_type_subtypes(&jpeg_jfif_info);
/*
* Register names for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("MIME",
mime_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("JPEG_JFIF",
jpeg_jfif_file_type_subtype);
}
/*

10
wiretap/mp2t.c
View File

@ -403,8 +403,14 @@ static const struct file_type_subtype_info mp2t_info = {
void register_mp2t(void)
{
mp2t_file_type_subtype = wtap_register_file_type_subtypes(&mp2t_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
mp2t_file_type_subtype = wtap_register_file_type_subtypes(&mp2t_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("MPEG_2_TS",
mp2t_file_type_subtype);
}
/*

12
wiretap/mp4.c
View File

@ -53,7 +53,6 @@ mp4_open(wtap *wth, int *err, gchar **err_info)
}
static const struct file_type_subtype_info mp4_info = {
/* WTAP_FILE_TYPE_SUBTYPE_MP4 */
"MP4 media", "mp4", "mp4", NULL,
FALSE, FALSE, 0,
NULL, NULL, NULL
@ -61,9 +60,14 @@ static const struct file_type_subtype_info mp4_info = {
void register_mp4(void)
{
mp4_file_type_subtype =
wtap_register_file_type_subtypes(&mp4_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
mp4_file_type_subtype = wtap_register_file_type_subtypes(&mp4_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("MP4",
mp4_file_type_subtype);
}
/*

11
wiretap/mpeg.c
View File

@ -273,9 +273,14 @@ static const struct file_type_subtype_info mpeg_info = {
void register_mpeg(void)
{
mpeg_file_type_subtype =
wtap_register_file_type_subtypes(&mpeg_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
mpeg_file_type_subtype = wtap_register_file_type_subtypes(&mpeg_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("MPEG",
mpeg_file_type_subtype);
}
/*

10
wiretap/mplog.c
View File

@ -262,8 +262,14 @@ static const struct file_type_subtype_info mplog_info = {
void register_mplog(void)
{
mplog_file_type_subtype = wtap_register_file_type_subtypes(&mplog_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
mplog_file_type_subtype = wtap_register_file_type_subtypes(&mplog_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("MPLOG",
mplog_file_type_subtype);
}
/*

17
wiretap/netmon.c
View File

@ -1993,12 +1993,17 @@ static const struct file_type_subtype_info netmon_2_x_info = {
void register_netmon(void)
{
netmon_1_x_file_type_subtype =
wtap_register_file_type_subtypes(&netmon_1_x_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
netmon_2_x_file_type_subtype =
wtap_register_file_type_subtypes(&netmon_2_x_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
netmon_1_x_file_type_subtype = wtap_register_file_type_subtypes(&netmon_1_x_info);
netmon_2_x_file_type_subtype = wtap_register_file_type_subtypes(&netmon_2_x_info);
/*
* Register names for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("NETMON_1_x",
netmon_1_x_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("NETMON_2_x",
netmon_2_x_file_type_subtype);
}
/*

25
wiretap/netscaler.c
View File

@ -2441,14 +2441,23 @@ static const struct file_type_subtype_info nstrace_3_5_info = {
void register_netscaler(void)
{
nstrace_1_0_file_type_subtype = wtap_register_file_type_subtypes(&nstrace_1_0_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
nstrace_2_0_file_type_subtype = wtap_register_file_type_subtypes(&nstrace_2_0_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
nstrace_3_0_file_type_subtype = wtap_register_file_type_subtypes(&nstrace_3_0_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
nstrace_3_5_file_type_subtype = wtap_register_file_type_subtypes(&nstrace_3_5_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
nstrace_1_0_file_type_subtype = wtap_register_file_type_subtypes(&nstrace_1_0_info);
nstrace_2_0_file_type_subtype = wtap_register_file_type_subtypes(&nstrace_2_0_info);
nstrace_3_0_file_type_subtype = wtap_register_file_type_subtypes(&nstrace_3_0_info);
nstrace_3_5_file_type_subtype = wtap_register_file_type_subtypes(&nstrace_3_5_info);
/*
* Register names for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("NETSCALER_1_0",
nstrace_1_0_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("NETSCALER_2_0",
nstrace_2_0_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("NETSCALER_3_0",
nstrace_3_0_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("NETSCALER_3_5",
nstrace_3_5_file_type_subtype);
}
/*

11
wiretap/netscreen.c
View File

@ -458,9 +458,14 @@ static const struct file_type_subtype_info netscreen_info = {
void register_netscreen(void)
{
netscreen_file_type_subtype =
wtap_register_file_type_subtypes(&netscreen_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
netscreen_file_type_subtype = wtap_register_file_type_subtypes(&netscreen_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("NETSCREEN",
netscreen_file_type_subtype);
}
/*

10
wiretap/nettl.c
View File

@ -805,8 +805,14 @@ static const struct file_type_subtype_info nettl_info = {
void register_nettl(void)
{
nettl_file_type_subtype = wtap_register_file_type_subtypes(&nettl_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
nettl_file_type_subtype = wtap_register_file_type_subtypes(&nettl_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("NETTL",
nettl_file_type_subtype);
}
/*

12
wiretap/nettrace_3gpp_32_423.c
View File

@ -832,7 +832,6 @@ nettrace_3gpp_32_423_file_open(wtap *wth, int *err, gchar **err_info)
}
static const struct file_type_subtype_info nettrace_3gpp_32_423_info = {
/* WTAP_FILE_TYPE_SUBTYPE_NETTRACE_3GPP_32_423 */
"3GPP TS 32.423 Trace", "3gpp32423", NULL, NULL,
FALSE, FALSE, 0,
NULL, NULL, NULL
@ -840,9 +839,14 @@ static const struct file_type_subtype_info nettrace_3gpp_32_423_info = {
void register_nettrace_3gpp_32_423(void)
{
nettrace_3gpp_32_423_file_type_subtype =
wtap_register_file_type_subtypes(&nettrace_3gpp_32_423_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
nettrace_3gpp_32_423_file_type_subtype = wtap_register_file_type_subtypes(&nettrace_3gpp_32_423_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("NETTRACE_3GPP_32_423",
nettrace_3gpp_32_423_file_type_subtype);
}
/*

10
wiretap/network_instruments.c
View File

@ -888,8 +888,14 @@ static const struct file_type_subtype_info network_instruments_info = {
void register_network_instruments(void)
{
network_instruments_file_type_subtype = wtap_register_file_type_subtypes(&network_instruments_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
network_instruments_file_type_subtype = wtap_register_file_type_subtypes(&network_instruments_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("NETWORK_INSTRUMENTS",
network_instruments_file_type_subtype);
}
/*

29
wiretap/netxray.c
View File

@ -2121,18 +2121,23 @@ static const struct file_type_subtype_info netxray_2_00x_info = {
void register_netxray(void)
{
netxray_old_file_type_subtype =
wtap_register_file_type_subtypes(&netxray_old_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
netxray_1_0_file_type_subtype =
wtap_register_file_type_subtypes(&netxray_1_0_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
netxray_1_1_file_type_subtype =
wtap_register_file_type_subtypes(&netxray_1_1_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
netxray_2_00x_file_type_subtype =
wtap_register_file_type_subtypes(&netxray_2_00x_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
netxray_old_file_type_subtype = wtap_register_file_type_subtypes(&netxray_old_info);
netxray_1_0_file_type_subtype = wtap_register_file_type_subtypes(&netxray_1_0_info);
netxray_1_1_file_type_subtype = wtap_register_file_type_subtypes(&netxray_1_1_info);
netxray_2_00x_file_type_subtype = wtap_register_file_type_subtypes(&netxray_2_00x_info);
/*
* Register names for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("NETXRAY_OLD",
netxray_old_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("NETXRAY_1_0",
netxray_1_0_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("NETXRAY_1_1",
netxray_1_1_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("NETXRAY_2_00x",
netxray_2_00x_file_type_subtype);
}
/*

17
wiretap/ngsniffer.c
View File

@ -2856,12 +2856,17 @@ static const struct file_type_subtype_info ngsniffer_compressed_info = {
void register_ngsniffer(void)
{
ngsniffer_uncompressed_file_type_subtype =
wtap_register_file_type_subtypes(&ngsniffer_uncompressed_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
ngsniffer_compressed_file_type_subtype =
wtap_register_file_type_subtypes(&ngsniffer_compressed_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
ngsniffer_uncompressed_file_type_subtype = wtap_register_file_type_subtypes(&ngsniffer_uncompressed_info);
ngsniffer_compressed_file_type_subtype = wtap_register_file_type_subtypes(&ngsniffer_compressed_info);
/*
* Register names for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("NGSNIFFER_UNCOMPRESSED",
ngsniffer_uncompressed_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("NGSNIFFER_COMPRESSED",
ngsniffer_compressed_file_type_subtype);
}
/*

11
wiretap/packetlogger.c
View File

@ -385,9 +385,14 @@ static const struct file_type_subtype_info packetlogger_info = {
void register_packetlogger(void)
{
packetlogger_file_type_subtype =
wtap_register_file_type_subtypes(&packetlogger_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
packetlogger_file_type_subtype = wtap_register_file_type_subtypes(&packetlogger_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("PACKETLOGGER",
packetlogger_file_type_subtype);
}
/*

17
wiretap/peekclassic.c
View File

@ -676,12 +676,17 @@ static const struct file_type_subtype_info peekclassic_v7_info = {
void register_peekclassic(void)
{
peekclassic_v56_file_type_subtype =
wtap_register_file_type_subtypes(&peekclassic_v56_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
peekclassic_v7_file_type_subtype =
wtap_register_file_type_subtypes(&peekclassic_v7_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
peekclassic_v56_file_type_subtype = wtap_register_file_type_subtypes(&peekclassic_v56_info);
peekclassic_v7_file_type_subtype = wtap_register_file_type_subtypes(&peekclassic_v7_info);
/*
* Register names for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("PEEKCLASSIC_V56",
peekclassic_v56_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("PEEKCLASSIC_V7",
peekclassic_v7_file_type_subtype);
}
/*

10
wiretap/peektagged.c
View File

@ -893,8 +893,14 @@ static const struct file_type_subtype_info peektagged_info = {
void register_peektagged(void)
{
peektagged_file_type_subtype = wtap_register_file_type_subtypes(&peektagged_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
peektagged_file_type_subtype = wtap_register_file_type_subtypes(&peektagged_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("PEEKTAGGED",
peektagged_file_type_subtype);
}
/*

11
wiretap/pppdump.c
View File

@ -804,9 +804,14 @@ static const struct file_type_subtype_info pppdump_info = {
void register_pppdump(void)
{
pppdump_file_type_subtype =
wtap_register_file_type_subtypes(&pppdump_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
pppdump_file_type_subtype = wtap_register_file_type_subtypes(&pppdump_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("PPPDUMP",
pppdump_file_type_subtype);
}
/*

11
wiretap/radcom.c
View File

@ -380,9 +380,14 @@ static const struct file_type_subtype_info radcom_info = {
void register_radcom(void)
{
radcom_file_type_subtype =
wtap_register_file_type_subtypes(&radcom_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
radcom_file_type_subtype = wtap_register_file_type_subtypes(&radcom_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("RADCOM",
radcom_file_type_subtype);
}
/*

10
wiretap/rfc7468.c
View File

@ -107,8 +107,14 @@ static const struct file_type_subtype_info rfc7468_info = {
void register_rfc7468(void)
{
rfc7468_file_type_subtype = wtap_register_file_type_subtypes(&rfc7468_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
rfc7468_file_type_subtype = wtap_register_file_type_subtypes(&rfc7468_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("RFC7468",
rfc7468_file_type_subtype);
}
/*

10
wiretap/ruby_marshal.c
View File

@ -92,8 +92,14 @@ static const struct file_type_subtype_info ruby_marshal_info = {
void register_ruby_marshal(void)
{
ruby_marshal_file_type_subtype = wtap_register_file_type_subtypes(&ruby_marshal_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
ruby_marshal_file_type_subtype = wtap_register_file_type_subtypes(&ruby_marshal_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("RUBY_MARSHAL",
ruby_marshal_file_type_subtype);
}
/*

17
wiretap/snoop.c
View File

@ -931,12 +931,17 @@ static const struct file_type_subtype_info shomiti_info = {
void register_snoop(void)
{
snoop_file_type_subtype =
wtap_register_file_type_subtypes(&snoop_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
shomiti_file_type_subtype =
wtap_register_file_type_subtypes(&shomiti_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
snoop_file_type_subtype = wtap_register_file_type_subtypes(&snoop_info);
shomiti_file_type_subtype = wtap_register_file_type_subtypes(&shomiti_info);
/*
* Register names for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("SNOOP",
snoop_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("SHOMITI",
shomiti_file_type_subtype);
}
/*

10
wiretap/stanag4607.c
View File

@ -216,8 +216,14 @@ static const struct file_type_subtype_info stanag4607_info = {
void register_stanag4607(void)
{
stanag4607_file_type_subtype = wtap_register_file_type_subtypes(&stanag4607_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
stanag4607_file_type_subtype = wtap_register_file_type_subtypes(&stanag4607_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("STANAG_4607",
stanag4607_file_type_subtype);
}
/*

10
wiretap/tnef.c
View File

@ -52,8 +52,14 @@ static const struct file_type_subtype_info tnef_info = {
void register_tnef(void)
{
tnef_file_type_subtype = wtap_register_file_type_subtypes(&tnef_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
tnef_file_type_subtype = wtap_register_file_type_subtypes(&tnef_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("TNEF",
tnef_file_type_subtype);
}
/*

11
wiretap/toshiba.c
View File

@ -437,9 +437,14 @@ static const struct file_type_subtype_info toshiba_info = {
void register_toshiba(void)
{
toshiba_file_type_subtype =
wtap_register_file_type_subtypes(&toshiba_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
toshiba_file_type_subtype = wtap_register_file_type_subtypes(&toshiba_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("TOSHIBA",
toshiba_file_type_subtype);
}
/*

10
wiretap/visual.c
View File

@ -869,8 +869,14 @@ static const struct file_type_subtype_info visual_info = {
void register_visual(void)
{
visual_file_type_subtype = wtap_register_file_type_subtypes(&visual_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
visual_file_type_subtype = wtap_register_file_type_subtypes(&visual_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("VISUAL_NETWORKS",
visual_file_type_subtype);
}
/*

10
wiretap/vms.c
View File

@ -536,8 +536,14 @@ static const struct file_type_subtype_info vms_info = {
void register_vms(void)
{
vms_file_type_subtype = wtap_register_file_type_subtypes(&vms_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
vms_file_type_subtype = wtap_register_file_type_subtypes(&vms_info);
/*
* Register name for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("VMS",
vms_file_type_subtype);
}
/*

15
wiretap/vwr.c
View File

@ -3384,10 +3384,17 @@ static const struct file_type_subtype_info vwr_eth_info = {
void register_vwr(void)
{
vwr_80211_file_type_subtype = wtap_register_file_type_subtypes(&vwr_80211_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
vwr_eth_file_type_subtype = wtap_register_file_type_subtypes(&vwr_eth_info,
WTAP_FILE_TYPE_SUBTYPE_UNKNOWN);
vwr_80211_file_type_subtype = wtap_register_file_type_subtypes(&vwr_80211_info);
vwr_eth_file_type_subtype = wtap_register_file_type_subtypes(&vwr_eth_info);
/*
* Register names for backwards compatibility with the
* wtap_filetypes table in Lua.
*/
wtap_register_backwards_compatibility_lua_name("VWR_80211",
vwr_80211_file_type_subtype);
wtap_register_backwards_compatibility_lua_name("VWR_ETH",
vwr_eth_file_type_subtype);
}
/*

14
wiretap/wtap-int.h
View File

@ -23,6 +23,8 @@
#define wtap_warn(...) g_warning(__VA_ARGS__)
void wtap_init_file_type_subtypes(void);
WS_DLL_PUBLIC
int wtap_fstat(wtap *wth, ws_statb64 *statb, int *err);
@ -345,6 +347,18 @@ wtap_add_idb(wtap *wth, wtap_block_t idb);
*/
void
wtapng_process_dsb(wtap *wth, wtap_block_t dsb);
void
wtap_register_backwards_compatibility_lua_name(const char *name, int ft);
struct backwards_compatibiliity_lua_name {
const char *name;
int ft;
};
WS_DLL_PUBLIC
const GArray *get_backwards_compatibility_lua_table(void);
#endif /* __WTAP_INT_H__ */
/*

4
wiretap/wtap.c
View File

@ -15,7 +15,6 @@
#include "wtap-int.h"
#include "wtap_opttypes.h"
#include "wtap_modules.h"
#include "pcapng.h"
#include "file_wrappers.h"
@ -1807,8 +1806,7 @@ wtap_init(gboolean load_wiretap_plugins)
init_open_routines();
wtap_opttypes_initialize();
wtap_init_encap_types();
for (gulong i = 0; i < wtap_module_count; i++)
wtap_module_reg[i].cb_func();
wtap_init_file_type_subtypes();
if (load_wiretap_plugins) {
#ifdef HAVE_PLUGINS
libwiretap_plugins = plugins_init(WS_PLUGIN_WIRETAP);

27
wiretap/wtap.h
View File

@ -315,8 +315,6 @@ extern "C" {
#define WTAP_FILE_TYPE_SUBTYPE_ERF 12
#define WTAP_FILE_TYPE_SUBTYPE_SYSTEMD_JOURNAL 13
#define WTAP_NUM_FILE_TYPES_SUBTYPES wtap_get_num_file_types_subtypes()
/* timestamp precision (currently only these values are supported) */
#define WTAP_TSPREC_UNKNOWN -2
#define WTAP_TSPREC_PER_PACKET -1 /* as a per-file value, means per-packet */
@ -2134,14 +2132,29 @@ gboolean wtap_dump_close(wtap_dumper *wdh, int *err, gchar **err_info);
WS_DLL_PUBLIC
gboolean wtap_dump_can_write(const GArray *file_encaps, guint32 required_comment_types);
/*
* Sort the file types by name or by description?
*/
typedef enum {
FT_SORT_BY_NAME,
FT_SORT_BY_DESCRIPTION
} ft_sort_order;
/**
* Get a GArray of WTAP_FILE_TYPE_SUBTYPE_ values for file types/subtypes
* Get a GArray of file type/subtype values for file types/subtypes
* that can be used to save a file of a given type with a given GArray of
* WTAP_ENCAP_ types and the given bitmask of comment types.
*/
WS_DLL_PUBLIC
GArray *wtap_get_savable_file_types_subtypes(int file_type,
const GArray *file_encaps, guint32 required_comment_types);
GArray *wtap_get_savable_file_types_subtypes_for_file(int file_type,
const GArray *file_encaps, guint32 required_comment_types,
ft_sort_order sort_order);
/**
* Get a GArray of all writable file type/subtype values.
*/
WS_DLL_PUBLIC
GArray *wtap_get_writable_file_types_subtypes(ft_sort_order sort_order);
/**
* Return TRUE if files of this file type/subtype use interface IDs
@ -2188,8 +2201,6 @@ WS_DLL_PUBLIC
int wtap_get_num_file_type_extensions(void);
WS_DLL_PUBLIC
int wtap_get_num_encap_types(void);
WS_DLL_PUBLIC
int wtap_get_num_file_types_subtypes(void);
/*** get information for file type extension ***/
WS_DLL_PUBLIC
@ -2226,7 +2237,7 @@ void wtap_deregister_open_info(const gchar *name);
WS_DLL_PUBLIC
unsigned int open_info_name_to_type(const char *name);
WS_DLL_PUBLIC
int wtap_register_file_type_subtypes(const struct file_type_subtype_info* fi, const int subtype);
int wtap_register_file_type_subtypes(const struct file_type_subtype_info* fi);
WS_DLL_PUBLIC
void wtap_deregister_file_type_subtype(const int file_type_subtype);

2
wiretap/wtap_modules.h
View File

@ -28,7 +28,7 @@ typedef struct _wtap_module_reg {
extern wtap_module_reg_t wtap_module_reg[];
extern const gulong wtap_module_count;
extern const guint wtap_module_count;
#ifdef __cplusplus
}