The "file types" we have are actually combinations of types and
authorGuy Harris <guy@alum.mit.edu>
Fri, 8 Nov 2013 09:53:01 +0000 (09:53 -0000)
committerGuy Harris <guy@alum.mit.edu>
Fri, 8 Nov 2013 09:53:01 +0000 (09:53 -0000)
subtypes, e.g. Network Monitor version 1 and Network Monitor version 2
are separate "file types", even though they both come from Network
Monitor.

Rename various functions, #defines, and variables appropriately.

svn path=/trunk/; revision=53166

72 files changed:
capinfos.c
capture_info.c
editcap.c
epan/wslua/wslua_dumper.c
file.c
mergecap.c
randpkt.c
rawshark.c
reordercap.c
tshark.c
ui/gtk/capture_file_dlg.c
ui/gtk/drag_and_drop.c
ui/gtk/export_pdu_dlg.c
ui/gtk/file_import_dlg.c
ui/gtk/gsm_map_summary.c
ui/gtk/mtp3_summary.c
ui/gtk/summary_dlg.c
ui/qt/capture_file_dialog.cpp
ui/qt/import_text_dialog.cpp
ui/qt/summary_dialog.cpp
wiretap/5views.c
wiretap/aethra.c
wiretap/ascendtext.c
wiretap/ber.c
wiretap/btsnoop.c
wiretap/camins.c
wiretap/catapult_dct2000.c
wiretap/commview.c
wiretap/cosine.c
wiretap/csids.c
wiretap/daintree-sna.c
wiretap/dbs-etherwatch.c
wiretap/dct3trace.c
wiretap/erf.c
wiretap/eyesdn.c
wiretap/file_access.c
wiretap/hcidump.c
wiretap/i4btrace.c
wiretap/ipfix.c
wiretap/iptrace.c
wiretap/iseries.c
wiretap/k12.c
wiretap/k12text.l
wiretap/lanalyzer.c
wiretap/libpcap.c
wiretap/mime_file.c
wiretap/mp2t.c
wiretap/mpeg.c
wiretap/netmon.c
wiretap/netscaler.c
wiretap/netscreen.c
wiretap/nettl.c
wiretap/network_instruments.c
wiretap/netxray.c
wiretap/ngsniffer.c
wiretap/packetlogger.c
wiretap/pcap-common.c
wiretap/pcapng.c
wiretap/peekclassic.c
wiretap/peektagged.c
wiretap/pppdump.c
wiretap/radcom.c
wiretap/snoop.c
wiretap/stanag4607.c
wiretap/tnef.c
wiretap/toshiba.c
wiretap/visual.c
wiretap/vms.c
wiretap/vwr.c
wiretap/wtap-int.h
wiretap/wtap.c
wiretap/wtap.h

index 6dfb994d0e864ea6e8d80b2b14f6c60e2a4fdfce..ad20ea5e98f7e62f152eed4015b3a580e149716c 100644 (file)
@@ -469,7 +469,7 @@ print_stats(const gchar *filename, capture_info *cf_info)
   gchar                 *size_string;
 
   /* Build printable strings for various stats */
   gchar                 *size_string;
 
   /* Build printable strings for various stats */
-  file_type_string = wtap_file_type_string(cf_info->file_type);
+  file_type_string = wtap_file_type_subtype_string(cf_info->file_type);
   file_encap_string = wtap_encap_string(cf_info->file_encap);
   start_time_t = (time_t)cf_info->start_time;
   stop_time_t = (time_t)cf_info->stop_time;
   file_encap_string = wtap_encap_string(cf_info->file_encap);
   start_time_t = (time_t)cf_info->start_time;
   stop_time_t = (time_t)cf_info->stop_time;
@@ -644,7 +644,7 @@ print_stats_table(const gchar *filename, capture_info *cf_info)
   time_t                stop_time_t;
 
   /* Build printable strings for various stats */
   time_t                stop_time_t;
 
   /* Build printable strings for various stats */
-  file_type_string = wtap_file_type_string(cf_info->file_type);
+  file_type_string = wtap_file_type_subtype_string(cf_info->file_type);
   file_encap_string = wtap_encap_string(cf_info->file_encap);
   start_time_t = (time_t)cf_info->start_time;
   stop_time_t = (time_t)cf_info->stop_time;
   file_encap_string = wtap_encap_string(cf_info->file_encap);
   start_time_t = (time_t)cf_info->start_time;
   stop_time_t = (time_t)cf_info->stop_time;
@@ -941,7 +941,7 @@ process_cap_file(wtap *wth, const char *filename)
   cf_info.filesize = size;
 
   /* File Type */
   cf_info.filesize = size;
 
   /* File Type */
-  cf_info.file_type = wtap_file_type(wth);
+  cf_info.file_type = wtap_file_type_subtype(wth);
   cf_info.iscompressed = wtap_iscompressed(wth);
 
   /* File Encapsulation */
   cf_info.iscompressed = wtap_iscompressed(wth);
 
   /* File Encapsulation */
index fdb1ead30c55969b4e62e9ecb30101fd7e1c174a..42a9a16ade9a9c4fab79b310eccbb90209b45006 100644 (file)
@@ -132,7 +132,7 @@ cf_open_error_message(int err, gchar *err_info, gboolean for_writing,
             /* Seen only when opening a capture file for writing. */
             g_snprintf(errmsg_errno, sizeof(errmsg_errno),
                        "The file \"%%s\" is a pipe, and %s capture files can't be "
             /* Seen only when opening a capture file for writing. */
             g_snprintf(errmsg_errno, sizeof(errmsg_errno),
                        "The file \"%%s\" is a pipe, and %s capture files can't be "
-                       "written to a pipe.", wtap_file_type_string(file_type));
+                       "written to a pipe.", wtap_file_type_subtype_string(file_type));
             errmsg = errmsg_errno;
             break;
 
             errmsg = errmsg_errno;
             break;
 
@@ -220,7 +220,7 @@ gboolean capture_info_new_file(const char *new_filename)
 
     info_data.wtap = wtap_open_offline(new_filename, &err, &err_info, FALSE);
     if (!info_data.wtap) {
 
     info_data.wtap = wtap_open_offline(new_filename, &err, &err_info, FALSE);
     if (!info_data.wtap) {
-        err_msg = g_strdup_printf(cf_open_error_message(err, err_info, FALSE, WTAP_FILE_PCAP),
+        err_msg = g_strdup_printf(cf_open_error_message(err, err_info, FALSE, WTAP_FILE_TYPE_SUBTYPE_UNKNOWN),
                                   new_filename);
         g_warning("capture_info_new_file: %d (%s)", err, err_msg);
         g_free (err_msg);
                                   new_filename);
         g_warning("capture_info_new_file: %d (%s)", err, err_msg);
         g_free (err_msg);
index 7b09db165374f2a45aec30b07b01339e86414858..c3a03bcc5e6608a11de6306261bf5c1180bd6048 100644 (file)
--- a/editcap.c
+++ b/editcap.c
@@ -157,9 +157,9 @@ static struct select_item selectfrm[MAX_SELECTIONS];
 static int max_selected = -1;
 static int keep_em = 0;
 #ifdef PCAP_NG_DEFAULT
 static int max_selected = -1;
 static int keep_em = 0;
 #ifdef PCAP_NG_DEFAULT
-static int out_file_type = WTAP_FILE_PCAPNG; /* default to pcapng   */
+static int out_file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PCAPNG; /* default to pcapng   */
 #else
 #else
-static int out_file_type = WTAP_FILE_PCAP;   /* default to pcap     */
+static int out_file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PCAP;   /* default to pcap     */
 #endif
 static int out_frame_type = -2;              /* Leave frame type alone */
 static int verbose = 0;                      /* Not so verbose         */
 #endif
 static int out_frame_type = -2;              /* Leave frame type alone */
 static int verbose = 0;                      /* Not so verbose         */
@@ -810,12 +810,12 @@ list_capture_types(void) {
     struct string_elem *captypes;
     GSList *list = NULL;
 
     struct string_elem *captypes;
     GSList *list = NULL;
 
-    captypes = g_new(struct string_elem,WTAP_NUM_FILE_TYPES);
+    captypes = g_new(struct string_elem,WTAP_NUM_FILE_TYPES_SUBTYPES);
     fprintf(stderr, "editcap: The available capture file types for the \"-F\" flag are:\n");
     fprintf(stderr, "editcap: The available capture file types for the \"-F\" flag are:\n");
-    for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
+    for (i = 0; i < WTAP_NUM_FILE_TYPES_SUBTYPES; i++) {
         if (wtap_dump_can_open(i)) {
         if (wtap_dump_can_open(i)) {
-            captypes[i].sstr = wtap_file_type_short_string(i);
-            captypes[i].lstr = wtap_file_type_string(i);
+            captypes[i].sstr = wtap_file_type_subtype_short_string(i);
+            captypes[i].lstr = wtap_file_type_subtype_string(i);
             list = g_slist_insert_sorted(list, &captypes[i], string_compare);
         }
     }
             list = g_slist_insert_sorted(list, &captypes[i], string_compare);
         }
     }
@@ -1037,8 +1037,8 @@ main(int argc, char *argv[])
             break;
 
         case 'F':
             break;
 
         case 'F':
-            out_file_type = wtap_short_string_to_file_type(optarg);
-            if (out_file_type < 0) {
+            out_file_type_subtype = wtap_short_string_to_file_type_subtype(optarg);
+            if (out_file_type_subtype < 0) {
                 fprintf(stderr, "editcap: \"%s\" isn't a valid capture file type\n\n",
                         optarg);
                 list_capture_types();
                 fprintf(stderr, "editcap: \"%s\" isn't a valid capture file type\n\n",
                         optarg);
                 list_capture_types();
@@ -1176,7 +1176,7 @@ main(int argc, char *argv[])
 
     if (verbose) {
         fprintf(stderr, "File %s is a %s capture file.\n", argv[optind],
 
     if (verbose) {
         fprintf(stderr, "File %s is a %s capture file.\n", argv[optind],
-                wtap_file_type_string(wtap_file_type(wth)));
+                wtap_file_type_subtype_string(wtap_file_type_subtype(wth)));
     }
 
     shb_hdr = wtap_file_get_shb_info(wth);
     }
 
     shb_hdr = wtap_file_get_shb_info(wth);
@@ -1228,7 +1228,7 @@ main(int argc, char *argv[])
                     shb_hdr->shb_user_appl = appname;
                 }
 
                     shb_hdr->shb_user_appl = appname;
                 }
 
-                pdh = wtap_dump_open_ng(filename, out_file_type, out_frame_type,
+                pdh = wtap_dump_open_ng(filename, out_file_type_subtype, out_frame_type,
                                         snaplen ? MIN(snaplen, wtap_snapshot_length(wth)) : wtap_snapshot_length(wth),
                                         FALSE /* compressed */, shb_hdr, idb_inf, &err);
 
                                         snaplen ? MIN(snaplen, wtap_snapshot_length(wth)) : wtap_snapshot_length(wth),
                                         FALSE /* compressed */, shb_hdr, idb_inf, &err);
 
@@ -1259,7 +1259,7 @@ main(int argc, char *argv[])
                     if (verbose)
                         fprintf(stderr, "Continuing writing in file %s\n", filename);
 
                     if (verbose)
                         fprintf(stderr, "Continuing writing in file %s\n", filename);
 
-                    pdh = wtap_dump_open_ng(filename, out_file_type, out_frame_type,
+                    pdh = wtap_dump_open_ng(filename, out_file_type_subtype, out_frame_type,
                                             snaplen ? MIN(snaplen, wtap_snapshot_length(wth)) : wtap_snapshot_length(wth),
                                             FALSE /* compressed */, shb_hdr, idb_inf, &err);
 
                                             snaplen ? MIN(snaplen, wtap_snapshot_length(wth)) : wtap_snapshot_length(wth),
                                             FALSE /* compressed */, shb_hdr, idb_inf, &err);
 
@@ -1287,7 +1287,7 @@ main(int argc, char *argv[])
                     if (verbose)
                         fprintf(stderr, "Continuing writing in file %s\n", filename);
 
                     if (verbose)
                         fprintf(stderr, "Continuing writing in file %s\n", filename);
 
-                    pdh = wtap_dump_open_ng(filename, out_file_type, out_frame_type,
+                    pdh = wtap_dump_open_ng(filename, out_file_type_subtype, out_frame_type,
                                             snaplen ? MIN(snaplen, wtap_snapshot_length(wth)) : wtap_snapshot_length(wth),
                                             FALSE /* compressed */, shb_hdr, idb_inf, &err);
                     if (pdh == NULL) {
                                             snaplen ? MIN(snaplen, wtap_snapshot_length(wth)) : wtap_snapshot_length(wth),
                                             FALSE /* compressed */, shb_hdr, idb_inf, &err);
                     if (pdh == NULL) {
@@ -1482,7 +1482,7 @@ main(int argc, char *argv[])
                     int real_data_start = 0;
 
                     /* Protect non-protocol data */
                     int real_data_start = 0;
 
                     /* Protect non-protocol data */
-                    if (wtap_file_type(wth) == WTAP_FILE_CATAPULT_DCT2000)
+                    if (wtap_file_type_subtype(wth) == WTAP_FILE_TYPE_SUBTYPE_CATAPULT_DCT2000)
                         real_data_start = find_dct2000_real_data(buf);
 
                     for (i = real_data_start; i < (int) phdr->caplen; i++) {
                         real_data_start = find_dct2000_real_data(buf);
 
                     for (i = real_data_start; i < (int) phdr->caplen; i++) {
@@ -1576,7 +1576,7 @@ main(int argc, char *argv[])
             g_free (filename);
             filename = g_strdup(argv[optind+1]);
 
             g_free (filename);
             filename = g_strdup(argv[optind+1]);
 
-            pdh = wtap_dump_open_ng(filename, out_file_type, out_frame_type,
+            pdh = wtap_dump_open_ng(filename, out_file_type_subtype, out_frame_type,
                                     snaplen ? MIN(snaplen, wtap_snapshot_length(wth)): wtap_snapshot_length(wth),
                                     FALSE /* compressed */, shb_hdr, idb_inf, &err);
             if (pdh == NULL) {
                                     snaplen ? MIN(snaplen, wtap_snapshot_length(wth)): wtap_snapshot_length(wth),
                                     FALSE /* compressed */, shb_hdr, idb_inf, &err);
             if (pdh == NULL) {
index 8c923988c201faa96b884fd3f7421b58eff00a97..bdd29b93984de4724f38047850759703a33a7bf6 100644 (file)
@@ -207,7 +207,7 @@ WSLUA_CONSTRUCTOR Dumper_new(lua_State* L) {
 #define WSLUA_OPTARG_Dumper_new_ENCAP 3 /* The encapsulation to be used in the file to be created */
     Dumper d;
     const char* fname = luaL_checkstring(L,WSLUA_ARG_Dumper_new_FILENAME);
 #define WSLUA_OPTARG_Dumper_new_ENCAP 3 /* The encapsulation to be used in the file to be created */
     Dumper d;
     const char* fname = luaL_checkstring(L,WSLUA_ARG_Dumper_new_FILENAME);
-    int filetype = luaL_optint(L,WSLUA_OPTARG_Dumper_new_FILETYPE,WTAP_FILE_PCAP);
+    int filetype = luaL_optint(L,WSLUA_OPTARG_Dumper_new_FILETYPE,WTAP_FILE_TYPE_SUBTYPE_PCAP);
     int encap  = luaL_optint(L,WSLUA_OPTARG_Dumper_new_ENCAP,WTAP_ENCAP_ETHERNET);
     int err = 0;
     const char* filename;
     int encap  = luaL_optint(L,WSLUA_OPTARG_Dumper_new_ENCAP,WTAP_ENCAP_ETHERNET);
     int err = 0;
     const char* filename;
@@ -223,12 +223,12 @@ WSLUA_CONSTRUCTOR Dumper_new(lua_State* L) {
         switch (err) {
         case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
             luaL_error(L,"Files of file type %s cannot be written",
         switch (err) {
         case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
             luaL_error(L,"Files of file type %s cannot be written",
-                       wtap_file_type_string(filetype));
+                       wtap_file_type_subtype_string(filetype));
             break;
 
         case WTAP_ERR_UNSUPPORTED_ENCAP:
             luaL_error(L,"Files of file type %s don't support encapsulation %s",
             break;
 
         case WTAP_ERR_UNSUPPORTED_ENCAP:
             luaL_error(L,"Files of file type %s don't support encapsulation %s",
-                       wtap_file_type_string(filetype),
+                       wtap_file_type_subtype_string(filetype),
                        wtap_encap_short_string(encap));
             break;
 
                        wtap_encap_short_string(encap));
             break;
 
@@ -338,7 +338,7 @@ WSLUA_METHOD Dumper_new_for_current(lua_State* L) {
 #define WSLUA_OPTARG_Dumper_new_for_current_FILETYPE 2 /* The file type. Defaults to pcap. */
     Dumper d;
     const char* fname = luaL_checkstring(L,1);
 #define WSLUA_OPTARG_Dumper_new_for_current_FILETYPE 2 /* The file type. Defaults to pcap. */
     Dumper d;
     const char* fname = luaL_checkstring(L,1);
-    int filetype = luaL_optint(L,WSLUA_OPTARG_Dumper_new_for_current_FILETYPE,WTAP_FILE_PCAP);
+    int filetype = luaL_optint(L,WSLUA_OPTARG_Dumper_new_for_current_FILETYPE,WTAP_FILE_TYPE_SUBTYPE_PCAP);
     int encap;
     int err = 0;
     const char* filename;
     int encap;
     int err = 0;
     const char* filename;
@@ -358,12 +358,12 @@ WSLUA_METHOD Dumper_new_for_current(lua_State* L) {
         switch (err) {
         case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
             luaL_error(L,"Files of file type %s cannot be written",
         switch (err) {
         case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
             luaL_error(L,"Files of file type %s cannot be written",
-                       wtap_file_type_string(filetype));
+                       wtap_file_type_subtype_string(filetype));
             break;
 
         case WTAP_ERR_UNSUPPORTED_ENCAP:
             luaL_error(L,"Files of file type %s don't support encapsulation %s",
             break;
 
         case WTAP_ERR_UNSUPPORTED_ENCAP:
             luaL_error(L,"Files of file type %s don't support encapsulation %s",
-                       wtap_file_type_string(filetype),
+                       wtap_file_type_subtype_string(filetype),
                        wtap_encap_short_string(encap));
             break;
 
                        wtap_encap_short_string(encap));
             break;
 
diff --git a/file.c b/file.c
index 950d553578e43e0038e3f5529918551f68c8f046..4a936af5ecd2d6fe472999684f1f7844a33c776a 100644 (file)
--- a/file.c
+++ b/file.c
@@ -376,7 +376,7 @@ cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
 
   cf->computed_elapsed = 0;
 
 
   cf->computed_elapsed = 0;
 
-  cf->cd_t        = wtap_file_type(cf->wth);
+  cf->cd_t        = wtap_file_type_subtype(cf->wth);
   cf->linktypes = g_array_sized_new(FALSE, FALSE, (guint) sizeof(int), 1);
   cf->count     = 0;
   cf->packet_comment_count = 0;
   cf->linktypes = g_array_sized_new(FALSE, FALSE, (guint) sizeof(int), 1);
   cf->count     = 0;
   cf->packet_comment_count = 0;
@@ -409,7 +409,7 @@ cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
   packet_list_queue_draw();
   cf_callback_invoke(cf_cb_file_opened, cf);
 
   packet_list_queue_draw();
   cf_callback_invoke(cf_cb_file_opened, cf);
 
-  if (cf->cd_t == WTAP_FILE_BER) {
+  if (cf->cd_t == WTAP_FILE_TYPE_SUBTYPE_BER) {
     /* tell the BER dissector the file name */
     ber_set_filename(cf->filename);
   }
     /* tell the BER dissector the file name */
     ber_set_filename(cf->filename);
   }
@@ -1349,7 +1349,7 @@ cf_merge_files(char **out_filenamep, int in_file_count,
    * We need something similar when merging pcapng files possibly with an option to say
    * the same interface(s) used in all in files. SHBs comments should be merged together.
    */
    * We need something similar when merging pcapng files possibly with an option to say
    * the same interface(s) used in all in files. SHBs comments should be merged together.
    */
-  if ((selected_frame_type == WTAP_ENCAP_PER_PACKET)&&(file_type == WTAP_FILE_PCAP)) {
+  if ((selected_frame_type == WTAP_ENCAP_PER_PACKET)&&(file_type == WTAP_FILE_TYPE_SUBTYPE_PCAP)) {
     /* Write output in pcapng format */
     wtapng_section_t            *shb_hdr;
     wtapng_iface_descriptions_t *idb_inf, *idb_inf_merge_file;
     /* Write output in pcapng format */
     wtapng_section_t            *shb_hdr;
     wtapng_iface_descriptions_t *idb_inf, *idb_inf_merge_file;
@@ -1362,7 +1362,7 @@ cf_merge_files(char **out_filenamep, int in_file_count,
     comment_gstr = g_string_new("");
     g_string_append_printf(comment_gstr, "%s \n",shb_hdr->opt_comment);
     g_string_append_printf(comment_gstr, "File created by merging: \n");
     comment_gstr = g_string_new("");
     g_string_append_printf(comment_gstr, "%s \n",shb_hdr->opt_comment);
     g_string_append_printf(comment_gstr, "File created by merging: \n");
-    file_type = WTAP_FILE_PCAPNG;
+    file_type = WTAP_FILE_TYPE_SUBTYPE_PCAPNG;
 
     for (i = 0; i < in_file_count; i++) {
         g_string_append_printf(comment_gstr, "File%d: %s \n",i+1,in_files[i].filename);
 
     for (i = 0; i < in_file_count; i++) {
         g_string_append_printf(comment_gstr, "File%d: %s \n",i+1,in_files[i].filename);
@@ -1523,9 +1523,10 @@ cf_merge_files(char **out_filenamep, int in_file_count,
       break;
     }
 
       break;
     }
 
-    /* If we have WTAP_ENCAP_PER_PACKETend the infiles are of type WTAP_FILE_PCAP
-     * we need to set the interface id in the paket header = the interface index we used
-     * in the IDBs interface description for this file(encapsulation type).
+    /* If we have WTAP_ENCAP_PER_PACKET and the infiles are of type
+     * WTAP_FILE_TYPE_SUBTYPE_PCAP, we need to set the interface id
+     * in the paket header = the interface index we used in the IDBs
+     * interface description for this file(encapsulation type).
      */
     if (fake_interface_ids) {
       struct wtap_pkthdr *phdr;
      */
     if (fake_interface_ids) {
       struct wtap_pkthdr *phdr;
@@ -1623,7 +1624,7 @@ cf_merge_files(char **out_filenamep, int in_file_count,
         simple_error_message_box(
                       "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.",
                       in_file->packet_num, display_basename,
         simple_error_message_box(
                       "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.",
                       in_file->packet_num, display_basename,
-                      wtap_file_type_string(file_type));
+                      wtap_file_type_subtype_string(file_type));
         g_free(display_basename);
         break;
 
         g_free(display_basename);
         break;
 
@@ -4144,7 +4145,7 @@ save_packet(capture_file *cf _U_, frame_data *fdata,
          */
         simple_error_message_box(
                       "Frame %u has a network type that can't be saved in a \"%s\" file.",
          */
         simple_error_message_box(
                       "Frame %u has a network type that can't be saved in a \"%s\" file.",
-                      fdata->num, wtap_file_type_string(args->file_type));
+                      fdata->num, wtap_file_type_subtype_string(args->file_type));
         break;
 
       default:
         break;
 
       default:
@@ -4322,7 +4323,7 @@ rescan_file(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
   /* No user changes yet. */
   cf->unsaved_changes = FALSE;
 
   /* No user changes yet. */
   cf->unsaved_changes = FALSE;
 
-  cf->cd_t        = wtap_file_type(cf->wth);
+  cf->cd_t        = wtap_file_type_subtype(cf->wth);
   cf->linktypes = g_array_sized_new(FALSE, FALSE, (guint) sizeof(int), 1);
 
   cf->snap      = wtap_snapshot_length(cf->wth);
   cf->linktypes = g_array_sized_new(FALSE, FALSE, (guint) sizeof(int), 1);
 
   cf->snap      = wtap_snapshot_length(cf->wth);
@@ -4986,7 +4987,7 @@ cf_open_failure_alert_box(const char *filename, int err, gchar *err_info,
       simple_error_message_box(
             "The file \"%s\" is a pipe, and %s capture files can't be "
             "written to a pipe.",
       simple_error_message_box(
             "The file \"%s\" is a pipe, and %s capture files can't be "
             "written to a pipe.",
-            display_basename, wtap_file_type_string(file_type));
+            display_basename, wtap_file_type_subtype_string(file_type));
       break;
 
     case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
       break;
 
     case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
index 3a84aeb74b8df34709a20aa8cde4837bc59a1b97..1a575424543884dec7a2e33c4c635df0c4a2d062 100644 (file)
@@ -165,13 +165,13 @@ list_capture_types(void) {
   struct string_elem *captypes;
   GSList *list = NULL;
 
   struct string_elem *captypes;
   GSList *list = NULL;
 
-  captypes = g_new(struct string_elem,WTAP_NUM_FILE_TYPES);
+  captypes = g_new(struct string_elem,WTAP_NUM_FILE_TYPES_SUBTYPES);
 
   fprintf(stderr, "mergecap: The available capture file types for the \"-F\" flag are:\n");
 
   fprintf(stderr, "mergecap: The available capture file types for the \"-F\" flag are:\n");
-  for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
+  for (i = 0; i < WTAP_NUM_FILE_TYPES_SUBTYPES; i++) {
     if (wtap_dump_can_open(i)) {
     if (wtap_dump_can_open(i)) {
-      captypes[i].sstr = wtap_file_type_short_string(i);
-      captypes[i].lstr = wtap_file_type_string(i);
+      captypes[i].sstr = wtap_file_type_subtype_short_string(i);
+      captypes[i].lstr = wtap_file_type_subtype_string(i);
       list = g_slist_insert_sorted(list, &captypes[i], string_compare);
     }
   }
       list = g_slist_insert_sorted(list, &captypes[i], string_compare);
     }
   }
@@ -209,9 +209,9 @@ main(int argc, char *argv[])
   int          in_file_count = 0;
   guint        snaplen = 0;
 #ifdef PCAP_NG_DEFAULT
   int          in_file_count = 0;
   guint        snaplen = 0;
 #ifdef PCAP_NG_DEFAULT
-  int          file_type = WTAP_FILE_PCAPNG;    /* default to pcap format */
+  int          file_type = WTAP_FILE_TYPE_SUBTYPE_PCAPNG;    /* default to pcap format */
 #else
 #else
-  int          file_type = WTAP_FILE_PCAP;      /* default to pcapng format */
+  int          file_type = WTAP_FILE_TYPE_SUBTYPE_PCAP;      /* default to pcapng format */
 #endif
   int          frame_type = -2;
   int          out_fd;
 #endif
   int          frame_type = -2;
   int          out_fd;
@@ -240,7 +240,7 @@ main(int argc, char *argv[])
       break;
 
     case 'F':
       break;
 
     case 'F':
-      file_type = wtap_short_string_to_file_type(optarg);
+      file_type = wtap_short_string_to_file_type_subtype(optarg);
       if (file_type < 0) {
         fprintf(stderr, "mergecap: \"%s\" isn't a valid capture file type\n",
                 optarg);
       if (file_type < 0) {
         fprintf(stderr, "mergecap: \"%s\" isn't a valid capture file type\n",
                 optarg);
@@ -326,7 +326,7 @@ main(int argc, char *argv[])
   if (verbose) {
     for (i = 0; i < in_file_count; i++)
       fprintf(stderr, "mergecap: %s is type %s.\n", argv[optind + i],
   if (verbose) {
     for (i = 0; i < in_file_count; i++)
       fprintf(stderr, "mergecap: %s is type %s.\n", argv[optind + i],
-              wtap_file_type_string(wtap_file_type(in_files[i].wth)));
+              wtap_file_type_subtype_string(wtap_file_type_subtype(in_files[i].wth)));
   }
 
   if (snaplen == 0) {
   }
 
   if (snaplen == 0) {
@@ -389,7 +389,7 @@ main(int argc, char *argv[])
   }
 
   /* prepare the outfile */
   }
 
   /* prepare the outfile */
-  if(file_type == WTAP_FILE_PCAPNG ){
+  if(file_type == WTAP_FILE_TYPE_SUBTYPE_PCAPNG ){
     wtapng_section_t *shb_hdr;
     GString *comment_gstr;
 
     wtapng_section_t *shb_hdr;
     GString *comment_gstr;
 
index 2316e71af6415143817dd6ae220175813b4ad871..e1695a2caa05927031bd6c52a87e1c432086560b 100644 (file)
--- a/randpkt.c
+++ b/randpkt.c
@@ -552,7 +552,7 @@ main(int argc, char **argv)
        example = find_example(produce_type);
 
 
        example = find_example(produce_type);
 
 
-       dump = wtap_dump_open(produce_filename, WTAP_FILE_PCAP,
+       dump = wtap_dump_open(produce_filename, WTAP_FILE_TYPE_SUBTYPE_PCAP,
                example->sample_wtap_encap, produce_max_bytes, FALSE /* compressed */, &err);
        if (!dump) {
                fprintf(stderr,
                example->sample_wtap_encap, produce_max_bytes, FALSE /* compressed */, &err);
        if (!dump) {
                fprintf(stderr,
index 8e762b625fa0e91b71f16c37c810cc46f10aa9f2..c95d19bfd9da4bd96b34c11b0bf0c4ffc4973dd0 100644 (file)
@@ -1674,7 +1674,7 @@ raw_cf_open(capture_file *cf, const char *fname)
     /* No user changes yet. */
     cf->unsaved_changes = FALSE;
 
     /* No user changes yet. */
     cf->unsaved_changes = FALSE;
 
-    cf->cd_t      = WTAP_FILE_UNKNOWN;
+    cf->cd_t      = WTAP_FILE_TYPE_SUBTYPE_UNKNOWN;
     cf->count     = 0;
     cf->drops_known = FALSE;
     cf->drops     = 0;
     cf->count     = 0;
     cf->drops_known = FALSE;
     cf->drops     = 0;
index 2303b100dc08a0ee538e9c5b05ba809a0573cd2d..69b5dbd9eaf76b5521372e2e48134e608f047c2d 100644 (file)
@@ -226,13 +226,13 @@ int main(int argc, char *argv[])
         }
         exit(1);
     }
         }
         exit(1);
     }
-    DEBUG_PRINT("file_type is %u\n", wtap_file_type(wth));
+    DEBUG_PRINT("file_type_subtype is %u\n", wtap_file_type_subtype(wth));
 
     shb_hdr = wtap_file_get_shb_info(wth);
     idb_inf = wtap_file_get_idb_info(wth);
 
     /* Open outfile (same filetype/encap as input file) */
 
     shb_hdr = wtap_file_get_shb_info(wth);
     idb_inf = wtap_file_get_idb_info(wth);
 
     /* Open outfile (same filetype/encap as input file) */
-    pdh = wtap_dump_open_ng(outfile, wtap_file_type(wth), wtap_file_encap(wth),
+    pdh = wtap_dump_open_ng(outfile, wtap_file_type_subtype(wth), wtap_file_encap(wth),
                             65535, FALSE, shb_hdr, idb_inf, &err);
     g_free(idb_inf);
     if (pdh == NULL) {
                             65535, FALSE, shb_hdr, idb_inf, &err);
     g_free(idb_inf);
     if (pdh == NULL) {
index db098fa99470edd15fa01b2ec690dec70074fd9a..2db6fa5c7b9c973bc062975ce0db1b01bc77e608 100644 (file)
--- a/tshark.c
+++ b/tshark.c
@@ -221,13 +221,13 @@ list_capture_types(void) {
   struct string_elem *captypes;
   GSList             *list = NULL;
 
   struct string_elem *captypes;
   GSList             *list = NULL;
 
-  captypes = g_new(struct string_elem, WTAP_NUM_FILE_TYPES);
+  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");
 
   fprintf(stderr, "tshark: The available capture file types for the \"-F\" flag are:\n");
-  for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
+  for (i = 0; i < WTAP_NUM_FILE_TYPES_SUBTYPES; i++) {
     if (wtap_dump_can_open(i)) {
     if (wtap_dump_can_open(i)) {
-      captypes[i].sstr = wtap_file_type_short_string(i);
-      captypes[i].lstr = wtap_file_type_string(i);
+      captypes[i].sstr = wtap_file_type_subtype_short_string(i);
+      captypes[i].lstr = wtap_file_type_subtype_string(i);
       list = g_slist_insert_sorted(list, &captypes[i], string_compare);
     }
   }
       list = g_slist_insert_sorted(list, &captypes[i], string_compare);
     }
   }
@@ -915,9 +915,9 @@ main(int argc, char *argv[])
 #endif
   gboolean             quiet = FALSE;
 #ifdef PCAP_NG_DEFAULT
 #endif
   gboolean             quiet = FALSE;
 #ifdef PCAP_NG_DEFAULT
-  volatile int         out_file_type = WTAP_FILE_PCAPNG;
+  volatile int         out_file_type = WTAP_FILE_TYPE_SUBTYPE_PCAPNG;
 #else
 #else
-  volatile int         out_file_type = WTAP_FILE_PCAP;
+  volatile int         out_file_type = WTAP_FILE_TYPE_SUBTYPE_PCAP;
 #endif
   volatile gboolean    out_file_name_res = FALSE;
   gchar               *volatile cf_name = NULL;
 #endif
   volatile gboolean    out_file_name_res = FALSE;
   gchar               *volatile cf_name = NULL;
@@ -1314,7 +1314,7 @@ main(int argc, char *argv[])
       }
       break;
     case 'F':
       }
       break;
     case 'F':
-      out_file_type = wtap_short_string_to_file_type(optarg);
+      out_file_type = wtap_short_string_to_file_type_subtype(optarg);
       if (out_file_type < 0) {
         cmdarg_err("\"%s\" isn't a valid capture file type", optarg);
         list_capture_types();
       if (out_file_type < 0) {
         cmdarg_err("\"%s\" isn't a valid capture file type", optarg);
         list_capture_types();
@@ -1735,11 +1735,13 @@ main(int argc, char *argv[])
         /* They specified a "-w" flag, so we'll be saving to a capture file. */
 
         /* When capturing, we only support writing pcap or pcap-ng format. */
         /* They specified a "-w" flag, so we'll be saving to a capture file. */
 
         /* When capturing, we only support writing pcap or pcap-ng format. */
-        if (out_file_type != WTAP_FILE_PCAP && out_file_type != WTAP_FILE_PCAPNG) {
+        if (out_file_type != WTAP_FILE_TYPE_SUBTYPE_PCAP &&
+            out_file_type != WTAP_FILE_TYPE_SUBTYPE_PCAPNG) {
           cmdarg_err("Live captures can only be saved in libpcap format.");
           return 1;
         }
           cmdarg_err("Live captures can only be saved in libpcap format.");
           return 1;
         }
-        if (global_capture_opts.capture_comment && out_file_type != WTAP_FILE_PCAPNG) {
+        if (global_capture_opts.capture_comment &&
+            out_file_type != WTAP_FILE_TYPE_SUBTYPE_PCAPNG) {
           cmdarg_err("A capture comment can only be written to a pcapng file.");
           return 1;
         }
           cmdarg_err("A capture comment can only be written to a pcapng file.");
           return 1;
         }
@@ -2997,7 +2999,8 @@ load_cap_file(capture_file *cf, char *save_file, int out_file_type,
         shb_hdr->shb_user_appl = appname;
     }
 
         shb_hdr->shb_user_appl = appname;
     }
 
-    if (linktype != WTAP_ENCAP_PER_PACKET && out_file_type == WTAP_FILE_PCAP)
+    if (linktype != WTAP_ENCAP_PER_PACKET &&
+        out_file_type == WTAP_FILE_TYPE_SUBTYPE_PCAP)
         pdh = wtap_dump_open(save_file, out_file_type, linktype,
             snapshot_length, FALSE /* compressed */, &err);
     else
         pdh = wtap_dump_open(save_file, out_file_type, linktype,
             snapshot_length, FALSE /* compressed */, &err);
     else
@@ -3018,7 +3021,7 @@ load_cap_file(capture_file *cf, char *save_file, int out_file_type,
       case WTAP_ERR_UNSUPPORTED_ENCAP:
       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
         cmdarg_err("The capture file being read can't be written as a "
       case WTAP_ERR_UNSUPPORTED_ENCAP:
       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
         cmdarg_err("The capture file being read can't be written as a "
-          "\"%s\" file.", wtap_file_type_short_string(out_file_type));
+          "\"%s\" file.", wtap_file_type_subtype_short_string(out_file_type));
         break;
 
       case WTAP_ERR_CANT_OPEN:
         break;
 
       case WTAP_ERR_CANT_OPEN:
@@ -3054,7 +3057,7 @@ load_cap_file(capture_file *cf, char *save_file, int out_file_type,
   if (pdh && out_file_name_res) {
     if (!wtap_dump_set_addrinfo_list(pdh, get_addrinfo_list())) {
       cmdarg_err("The file format \"%s\" doesn't support name resolution information.",
   if (pdh && out_file_name_res) {
     if (!wtap_dump_set_addrinfo_list(pdh, get_addrinfo_list())) {
       cmdarg_err("The file format \"%s\" doesn't support name resolution information.",
-                 wtap_file_type_short_string(out_file_type));
+                 wtap_file_type_subtype_short_string(out_file_type));
     }
   }
 
     }
   }
 
@@ -3155,7 +3158,7 @@ load_cap_file(capture_file *cf, char *save_file, int out_file_type,
                 fprintf(stderr,
                         "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
                         framenum, cf->filename,
                 fprintf(stderr,
                         "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
                         framenum, cf->filename,
-                        wtap_file_type_short_string(out_file_type));
+                        wtap_file_type_subtype_short_string(out_file_type));
                 break;
 
               default:
                 break;
 
               default:
@@ -3219,7 +3222,7 @@ load_cap_file(capture_file *cf, char *save_file, int out_file_type,
               fprintf(stderr,
                       "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
                       framenum, cf->filename,
               fprintf(stderr,
                       "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
                       framenum, cf->filename,
-                      wtap_file_type_short_string(out_file_type));
+                      wtap_file_type_subtype_short_string(out_file_type));
               break;
 
             default:
               break;
 
             default:
@@ -3886,7 +3889,7 @@ cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
   /* No user changes yet. */
   cf->unsaved_changes = FALSE;
 
   /* No user changes yet. */
   cf->unsaved_changes = FALSE;
 
-  cf->cd_t      = wtap_file_type(cf->wth);
+  cf->cd_t      = wtap_file_type_subtype(cf->wth);
   cf->count     = 0;
   cf->drops_known = FALSE;
   cf->drops     = 0;
   cf->count     = 0;
   cf->drops_known = FALSE;
   cf->drops     = 0;
@@ -4024,7 +4027,7 @@ cf_open_error_message(int err, gchar *err_info, gboolean for_writing,
       /* Seen only when opening a capture file for writing. */
       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
                  "The file \"%%s\" is a pipe, and \"%s\" capture files can't be "
       /* Seen only when opening a capture file for writing. */
       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
                  "The file \"%%s\" is a pipe, and \"%s\" capture files can't be "
-                 "written to a pipe.", wtap_file_type_short_string(file_type));
+                 "written to a pipe.", wtap_file_type_subtype_short_string(file_type));
       errmsg = errmsg_errno;
       break;
 
       errmsg = errmsg_errno;
       break;
 
@@ -4037,7 +4040,7 @@ cf_open_error_message(int err, gchar *err_info, gboolean for_writing,
       if (for_writing) {
         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
                    "TShark can't save this capture as a \"%s\" file.",
       if (for_writing) {
         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
                    "TShark can't save this capture as a \"%s\" file.",
-                   wtap_file_type_short_string(file_type));
+                   wtap_file_type_subtype_short_string(file_type));
       } else {
         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
                  "The file \"%%s\" is a capture for a network type that TShark doesn't support.\n"
       } else {
         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
                  "The file \"%%s\" is a capture for a network type that TShark doesn't support.\n"
@@ -4051,7 +4054,7 @@ cf_open_error_message(int err, gchar *err_info, gboolean for_writing,
       if (for_writing) {
         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
                    "TShark can't save this capture as a \"%s\" file.",
       if (for_writing) {
         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
                    "TShark can't save this capture as a \"%s\" file.",
-                   wtap_file_type_short_string(file_type));
+                   wtap_file_type_subtype_short_string(file_type));
         errmsg = errmsg_errno;
       } else
         errmsg = "The file \"%s\" is a capture for a network type that TShark doesn't support.";
         errmsg = errmsg_errno;
       } else
         errmsg = "The file \"%s\" is a capture for a network type that TShark doesn't support.";
index 72e7e79194e70787b31dd61d8989fec08a2f1e53..76690c1f9bbe8e20a448252adc10788d82001e8b 100644 (file)
@@ -162,7 +162,7 @@ preview_set_filename(GtkWidget *prev, const gchar *cf_name)
   gtk_label_set_text(GTK_LABEL(label), string_buff);
 
   /* type */
   gtk_label_set_text(GTK_LABEL(label), string_buff);
 
   /* type */
-  g_strlcpy(string_buff, wtap_file_type_string(wtap_file_type(wth)), PREVIEW_STR_MAX);
+  g_strlcpy(string_buff, wtap_file_type_subtype_string(wtap_file_type_subtype(wth)), PREVIEW_STR_MAX);
   label = (GtkWidget *)g_object_get_data(G_OBJECT(prev), PREVIEW_FORMAT_KEY);
   gtk_label_set_text(GTK_LABEL(label), string_buff);
 
   label = (GtkWidget *)g_object_get_data(G_OBJECT(prev), PREVIEW_FORMAT_KEY);
   gtk_label_set_text(GTK_LABEL(label), string_buff);
 
@@ -1483,7 +1483,7 @@ set_file_type_list(GtkWidget *combo_box, capture_file *cf,
                    gboolean must_support_all_comments)
 {
   guint32 required_comment_types;
                    gboolean must_support_all_comments)
 {
   guint32 required_comment_types;
-  GArray *savable_file_types;
+  GArray *savable_file_types_subtypes;
   guint   i;
   int     ft;
   int     default_ft = -1;
   guint   i;
   int     ft;
   int     default_ft = -1;
@@ -1495,22 +1495,23 @@ set_file_type_list(GtkWidget *combo_box, capture_file *cf,
     required_comment_types = 0; /* none of them */
 
   /* What types of file can we save this file as? */
     required_comment_types = 0; /* none of them */
 
   /* What types of file can we save this file as? */
-  savable_file_types = wtap_get_savable_file_types(cf->cd_t, cf->linktypes,
-                                                   required_comment_types);
+  savable_file_types_subtypes = wtap_get_savable_file_types_subtypes(cf->cd_t,
+                                                                     cf->linktypes,
+                                                                     required_comment_types);
 
 
-  if (savable_file_types != NULL) {
+  if (savable_file_types_subtypes != NULL) {
     /* OK, we have at least one file type we can save this file as.
        (If we didn't, we shouldn't have gotten here in the first
        place.)  Add them all to the combo box.  */
     /* OK, we have at least one file type we can save this file as.
        (If we didn't, we shouldn't have gotten here in the first
        place.)  Add them all to the combo box.  */
-    for (i = 0; i < savable_file_types->len; i++) {
-      ft = g_array_index(savable_file_types, int, i);
+    for (i = 0; i < savable_file_types_subtypes->len; i++) {
+      ft = g_array_index(savable_file_types_subtypes, int, i);
       if (default_ft == -1)
         default_ft = ft; /* first file type is the default */
       ws_combo_box_append_text_and_pointer(GTK_COMBO_BOX(combo_box),
       if (default_ft == -1)
         default_ft = ft; /* first file type is the default */
       ws_combo_box_append_text_and_pointer(GTK_COMBO_BOX(combo_box),
-                                           wtap_file_type_string(ft),
+                                           wtap_file_type_subtype_string(ft),
                                            GINT_TO_POINTER(ft));
     }
                                            GINT_TO_POINTER(ft));
     }
-    g_array_free(savable_file_types, TRUE);
+    g_array_free(savable_file_types_subtypes, TRUE);
   }
 
   return default_ft;
   }
 
   return default_ft;
index cb12955316c493511155654dd50d0c4718072084..93e438a698802d3bac88726434ded69e7fe601a5 100644 (file)
@@ -215,7 +215,7 @@ dnd_open_file_cmd(gchar *cf_names_freeme)
         /* merge the files in chronological order */
         tmpname = NULL;
         if (cf_merge_files(&tmpname, in_file_count, in_filenames,
         /* merge the files in chronological order */
         tmpname = NULL;
         if (cf_merge_files(&tmpname, in_file_count, in_filenames,
-                           WTAP_FILE_PCAP, FALSE) == CF_OK) {
+                           WTAP_FILE_TYPE_SUBTYPE_PCAP, FALSE) == CF_OK) {
             /* Merge succeeded; close the currently-open file and try
                to open the merged capture file. */
             cf_close(&cfile);
             /* Merge succeeded; close the currently-open file and try
                to open the merged capture file. */
             cf_close(&cfile);
index a8799a7dc7c9feef0c03fe9587d1e530b9df846b..046bd5483e833f6c71690e69a972a7a1439fd1b6 100644 (file)
@@ -180,7 +180,7 @@ exp_pdu_file_open(exp_pdu_t *exp_pdu_tap_data)
 
     g_array_append_val(idb_inf->interface_data, int_data);
 
 
     g_array_append_val(idb_inf->interface_data, int_data);
 
-    exp_pdu_tap_data->wdh = wtap_dump_fdopen_ng(import_file_fd, WTAP_FILE_PCAPNG, WTAP_ENCAP_WIRESHARK_UPPER_PDU, WTAP_MAX_PACKET_SIZE, FALSE, shb_hdr, idb_inf, &err);
+    exp_pdu_tap_data->wdh = wtap_dump_fdopen_ng(import_file_fd, WTAP_FILE_TYPE_SUBTYPE_PCAPNG, WTAP_ENCAP_WIRESHARK_UPPER_PDU, WTAP_MAX_PACKET_SIZE, FALSE, shb_hdr, idb_inf, &err);
     if (exp_pdu_tap_data->wdh == NULL) {
         open_failure_alert_box(capfile_name, err, TRUE);
         goto end;
     if (exp_pdu_tap_data->wdh == NULL) {
         open_failure_alert_box(capfile_name, err, TRUE);
         goto end;
index 68990f4f7da6ec629b0873489b17d4f2bb4bab3b..0ab5a4c5c64a684fd6c076c8532fe2957e2ddf3b 100644 (file)
@@ -516,7 +516,7 @@ file_import_open(text_import_info_t *info)
 
     g_array_append_val(idb_inf->interface_data, int_data);
 
 
     g_array_append_val(idb_inf->interface_data, int_data);
 
-    info->wdh = wtap_dump_fdopen_ng(import_file_fd, WTAP_FILE_PCAPNG, info->encapsulation, info->max_frame_length, FALSE, shb_hdr, idb_inf, &err);
+    info->wdh = wtap_dump_fdopen_ng(import_file_fd, WTAP_FILE_TYPE_SUBTYPE_PCAPNG, info->encapsulation, info->max_frame_length, FALSE, shb_hdr, idb_inf, &err);
     if (info->wdh == NULL) {
         open_failure_alert_box(capfile_name, err, TRUE);
         fclose(info->import_text_file);
     if (info->wdh == NULL) {
         open_failure_alert_box(capfile_name, err, TRUE);
         fclose(info->import_text_file);
index c3fdcf5c3097b9e40f7e757017e96e28808e7acf..863508383862a63fffa608329f72f6a13ab6d6ab 100644 (file)
@@ -114,7 +114,7 @@ void gsm_map_stat_gtk_sum_cb(GtkAction *action _U_, gpointer user_data _U_)
   add_string_to_box(string_buff, file_box);
 
   /* format */
   add_string_to_box(string_buff, file_box);
 
   /* format */
-  g_snprintf(string_buff, SUM_STR_MAX, "Format: %s", wtap_file_type_string(summary.file_type));
+  g_snprintf(string_buff, SUM_STR_MAX, "Format: %s", wtap_file_type_subtype_string(summary.file_type));
   add_string_to_box(string_buff, file_box);
 
   if (summary.has_snap) {
   add_string_to_box(string_buff, file_box);
 
   if (summary.has_snap) {
index ed3ff11d57c0fe01e2dd949fb5f01f6d5a71e108..72686c16c2d7fc7757e36975d6f14325109c5294 100644 (file)
@@ -316,7 +316,7 @@ mtp3_sum_gtk_sum_cb(GtkAction *action _U_, gpointer user_data _U_)
     add_string_to_box(string_buff, file_box);
 
     /* format */
     add_string_to_box(string_buff, file_box);
 
     /* format */
-    file_type = wtap_file_type_string(summary.file_type);
+    file_type = wtap_file_type_subtype_string(summary.file_type);
     g_snprintf(string_buff, SUM_STR_MAX, "Format: %s", (file_type ? file_type : "N/A"));
     add_string_to_box(string_buff, file_box);
 
     g_snprintf(string_buff, SUM_STR_MAX, "Format: %s", (file_type ? file_type : "N/A"));
     add_string_to_box(string_buff, file_box);
 
index 4b706eb39485006aa4edc2e86c99f3103ca951d7..8941976739e1c1566081cb87604d1c4f693be241 100644 (file)
@@ -269,7 +269,7 @@ summary_open_cb(GtkWidget *w _U_, gpointer d _U_)
 
   /* format */
   g_snprintf(string_buff, SUM_STR_MAX, "%s%s",
 
   /* format */
   g_snprintf(string_buff, SUM_STR_MAX, "%s%s",
-             wtap_file_type_string(summary.file_type),
+             wtap_file_type_subtype_string(summary.file_type),
              summary.iscompressed? " (gzip compressed)" : "");
   add_string_to_grid(grid, &row, "Format:", string_buff);
 
              summary.iscompressed? " (gzip compressed)" : "");
   add_string_to_grid(grid, &row, "Format:", string_buff);
 
@@ -716,7 +716,7 @@ summary_to_texbuff(GtkTextBuffer *buffer)
 
   /* format */
   g_snprintf(string_buff, SUM_STR_MAX, INDENT "Format: %s%s",
 
   /* format */
   g_snprintf(string_buff, SUM_STR_MAX, INDENT "Format: %s%s",
-             wtap_file_type_string(summary.file_type),
+             wtap_file_type_subtype_string(summary.file_type),
              summary.iscompressed? " (gzip compressed)\n" : "\n");
   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
 
              summary.iscompressed? " (gzip compressed)\n" : "\n");
   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
 
index 2ff11b190a4772042285575ce492e66cd1bcebc3..6b452352ed7567b9265e2ed81ec744e3c7950bca 100644 (file)
@@ -334,7 +334,7 @@ QString CaptureFileDialog::fileType(int ft, bool extension_globs)
     QString filter;
     GSList *extensions_list;
 
     QString filter;
     GSList *extensions_list;
 
-    filter = wtap_file_type_string(ft);
+    filter = wtap_file_type_subtype_string(ft);
 
     if (!extension_globs) {
         return filter;
 
     if (!extension_globs) {
         return filter;
@@ -672,7 +672,7 @@ int CaptureFileDialog::merge(QString &file_name) {
 QStringList CaptureFileDialog::buildFileSaveAsTypeList(bool must_support_all_comments) {
     QStringList filters;
     guint32 required_comment_types;
 QStringList CaptureFileDialog::buildFileSaveAsTypeList(bool must_support_all_comments) {
     QStringList filters;
     guint32 required_comment_types;
-    GArray *savable_file_types;
+    GArray *savable_file_types_subtypes;
     guint i;
 
     type_hash_.clear();
     guint i;
 
     type_hash_.clear();
@@ -684,25 +684,25 @@ 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? */
         required_comment_types = 0; /* none of them */
 
   /* What types of file can we save this file as? */
-    savable_file_types = wtap_get_savable_file_types(cap_file_->cd_t,
-                                                     cap_file_->linktypes,
-                                                     required_comment_types);
+    savable_file_types_subtypes = wtap_get_savable_file_types_subtypes(cap_file_->cd_t,
+                                                                       cap_file_->linktypes,
+                                                                       required_comment_types);
 
 
-    if (savable_file_types != NULL) {
+    if (savable_file_types_subtypes != NULL) {
         QString file_type;
         int ft;
         /* OK, we have at least one file type we can save this file as.
            (If we didn't, we shouldn't have gotten here in the first
            place.)  Add them all to the combo box.  */
         QString file_type;
         int ft;
         /* OK, we have at least one file type we can save this file as.
            (If we didn't, we shouldn't have gotten here in the first
            place.)  Add them all to the combo box.  */
-        for (i = 0; i < savable_file_types->len; i++) {
-            ft = g_array_index(savable_file_types, int, i);
+        for (i = 0; i < savable_file_types_subtypes->len; i++) {
+            ft = g_array_index(savable_file_types_subtypes, int, i);
             if (default_ft_ < 1)
                 default_ft_ = ft; /* first file type is the default */
             file_type = fileType(ft);
             filters << file_type;
             type_hash_[file_type] = ft;
         }
             if (default_ft_ < 1)
                 default_ft_ = ft; /* first file type is the default */
             file_type = fileType(ft);
             filters << file_type;
             type_hash_[file_type] = ft;
         }
-        g_array_free(savable_file_types, TRUE);
+        g_array_free(savable_file_types_subtypes, TRUE);
     }
 
     return filters;
     }
 
     return filters;
@@ -777,7 +777,7 @@ void CaptureFileDialog::preview(const QString & path)
     }
 
     // Format
     }
 
     // Format
-    preview_format_.setText(QString::fromUtf8(wtap_file_type_string(wtap_file_type(wth))));
+    preview_format_.setText(QString::fromUtf8(wtap_file_type_subtype_string(wtap_file_type_subtype(wth))));
 
     // Size
     preview_size_.setText(QString(tr("%1 bytes")).arg(wtap_file_size(wth, &err)));
 
     // Size
     preview_size_.setText(QString(tr("%1 bytes")).arg(wtap_file_size(wth, &err)));
index eafaf80cb08f5b2f301dbfb082ef8f94d9df4780..a38d19b7c8a7802069332f38b1840cdcaa524f11 100644 (file)
@@ -122,7 +122,7 @@ void ImportTextDialog::convertTextFile() {
     import_file_fd = create_tempfile(&tmpname, "import");
     capfile_name_.append(tmpname);
 
     import_file_fd = create_tempfile(&tmpname, "import");
     capfile_name_.append(tmpname);
 
-    import_info_.wdh = wtap_dump_fdopen(import_file_fd, WTAP_FILE_PCAP, import_info_.encapsulation, import_info_.max_frame_length, FALSE, &err);
+    import_info_.wdh = wtap_dump_fdopen(import_file_fd, WTAP_FILE_TYPE_SUBTYPE_PCAP, import_info_.encapsulation, import_info_.max_frame_length, FALSE, &err);
     qDebug() << capfile_name_ << ":" << import_info_.wdh << import_info_.encapsulation << import_info_.max_frame_length;
     if (import_info_.wdh == NULL) {
         open_failure_alert_box(capfile_name_.toUtf8().constData(), err, TRUE);
     qDebug() << capfile_name_ << ":" << import_info_.wdh << import_info_.encapsulation << import_info_.max_frame_length;
     if (import_info_.wdh == NULL) {
         open_failure_alert_box(capfile_name_.toUtf8().constData(), err, TRUE);
index 8c688b29364dcc4da4c0c1e9c64cb1f414ebb27f..f0ccf60455904ac896fea59257d95f446c05bca1 100644 (file)
@@ -134,7 +134,7 @@ QString SummaryDialog::SummaryToString()
     out << "\t" << tr("Name:\t\t%1\n").arg(summary_.filename);
     out << "\t" << tr("Length:\t\t%1 bytes\n").arg(summary_.file_length);
     out << "\t" << tr("Format:\t\t%1%2\n")
     out << "\t" << tr("Name:\t\t%1\n").arg(summary_.filename);
     out << "\t" << tr("Length:\t\t%1 bytes\n").arg(summary_.file_length);
     out << "\t" << tr("Format:\t\t%1%2\n")
-           .arg(wtap_file_type_string(summary_.file_type))
+           .arg(wtap_file_type_subtype_string(summary_.file_type))
            .arg(summary_.iscompressed? tr(" (gzip compressed)") : "");
     out << "\t" << tr("Encapsulation:\t\t%1\n").arg(ui->lEncapsulation->text());
 
            .arg(summary_.iscompressed? tr(" (gzip compressed)") : "");
     out << "\t" << tr("Encapsulation:\t\t%1\n").arg(ui->lEncapsulation->text());
 
@@ -281,7 +281,7 @@ void SummaryDialog::UpdateValues()
     ui->lLength->setText(QString(tr("%1 bytes (%2 Mbytes)")).arg((ulong)summary_.file_length).arg((float)summary_.file_length/1048576));
 
     /* format */
     ui->lLength->setText(QString(tr("%1 bytes (%2 Mbytes)")).arg((ulong)summary_.file_length).arg((float)summary_.file_length/1048576));
 
     /* format */
-    ui->lFormat->setText(QString("%1%2").arg(wtap_file_type_string(summary_.file_type), summary_.iscompressed? tr(" (gzip compressed)") : ""));
+    ui->lFormat->setText(QString("%1%2").arg(wtap_file_type_subtype_string(summary_.file_type), summary_.iscompressed? tr(" (gzip compressed)") : ""));
 
     /* encapsulation */
     if (summary_.file_encap_type == WTAP_ENCAP_PER_PACKET)
 
     /* encapsulation */
     if (summary_.file_encap_type == WTAP_ENCAP_PER_PACKET)
index 461616a6d377531420f688ee91cefc99f3d980e6..5e665a8e90c08e18b10281d2937ef1340e4055d9 100644 (file)
@@ -183,7 +183,7 @@ int _5views_open(wtap *wth, int *err, gchar **err_info)
        }
 
        /* This is a 5views capture file */
        }
 
        /* This is a 5views capture file */
-       wth->file_type = WTAP_FILE_5VIEWS;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_5VIEWS;
        wth->subtype_read = _5views_read;
        wth->subtype_seek_read = _5views_seek_read;
        wth->file_encap = encap;
        wth->subtype_read = _5views_read;
        wth->subtype_seek_read = _5views_seek_read;
        wth->file_encap = encap;
index 316242d84c6b9eb47e0ee384144d5bb93b45e7e4..2abb01f1af6d0fa5fa7abee5209f41124141c424 100644 (file)
@@ -152,7 +152,7 @@ int aethra_open(wtap *wth, int *err, gchar **err_info)
                        *err = WTAP_ERR_SHORT_READ;
                return -1;
        }
                        *err = WTAP_ERR_SHORT_READ;
                return -1;
        }
-       wth->file_type = WTAP_FILE_AETHRA;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_AETHRA;
        aethra = (aethra_t *)g_malloc(sizeof(aethra_t));
        wth->priv = (void *)aethra;
        wth->subtype_read = aethra_read;
        aethra = (aethra_t *)g_malloc(sizeof(aethra_t));
        wth->priv = (void *)aethra;
        wth->subtype_read = aethra_read;
index 393ae65636ec58ad13f677b737d46c9aeb3ec646..5c8636f7dac23e4da9c8f3a9f91d5bf5bfbc394f 100644 (file)
@@ -182,7 +182,7 @@ int ascend_open(wtap *wth, int *err, gchar **err_info)
     return 0;
   }
 
     return 0;
   }
 
-  wth->file_type = WTAP_FILE_ASCEND;
+  wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_ASCEND;
 
   switch(wth->phdr.pseudo_header.ascend.type) {
     case ASCEND_PFX_ISDN_X:
 
   switch(wth->phdr.pseudo_header.ascend.type) {
     case ASCEND_PFX_ISDN_X:
index 5c83eb9a7032ed51beef10036472d95a957634ea..31fe4e1c12eff34e121b3bcc22b6c8bf9ee76b2d 100644 (file)
@@ -176,7 +176,7 @@ int ber_open(wtap *wth, int *err, gchar **err_info)
   if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
     return -1;
 
   if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
     return -1;
 
-  wth->file_type = WTAP_FILE_BER;
+  wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_BER;
   wth->file_encap = WTAP_ENCAP_BER;
   wth->snapshot_length = 0;
 
   wth->file_encap = WTAP_ENCAP_BER;
   wth->snapshot_length = 0;
 
index ce16c2fa6d6a5d3d209f2ca2ddab36cf0e58d56f..784dd9982dbfaf316b3c7951e12e7a0a4a82b8cd 100644 (file)
@@ -148,7 +148,7 @@ int btsnoop_open(wtap *wth, int *err, gchar **err_info)
        wth->file_encap = file_encap;
        wth->snapshot_length = 0;       /* not available in header */
        wth->tsprecision = WTAP_FILE_TSPREC_USEC;
        wth->file_encap = file_encap;
        wth->snapshot_length = 0;       /* not available in header */
        wth->tsprecision = WTAP_FILE_TSPREC_USEC;
-       wth->file_type = WTAP_FILE_BTSNOOP;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_BTSNOOP;
        return 1;
 }
 
        return 1;
 }
 
@@ -381,9 +381,9 @@ gboolean btsnoop_dump_open_h1(wtap_dumper *wdh, int *err)
     wdh->subtype_close = NULL;
 
     /* Write the file header. */
     wdh->subtype_close = NULL;
 
     /* Write the file header. */
-    switch (wdh->file_type) {
+    switch (wdh->file_type_subtype) {
 
 
-    case WTAP_FILE_BTSNOOP:
+    case WTAP_FILE_TYPE_SUBTYPE_BTSNOOP:
         wdh->tsprecision = WTAP_FILE_TSPREC_USEC;
         break;
 
         wdh->tsprecision = WTAP_FILE_TSPREC_USEC;
         break;
 
@@ -423,9 +423,9 @@ gboolean btsnoop_dump_open_h4(wtap_dumper *wdh, int *err)
     wdh->subtype_close = NULL;
 
     /* Write the file header. */
     wdh->subtype_close = NULL;
 
     /* Write the file header. */
-    switch (wdh->file_type) {
+    switch (wdh->file_type_subtype) {
 
 
-    case WTAP_FILE_BTSNOOP:
+    case WTAP_FILE_TYPE_SUBTYPE_BTSNOOP:
         wdh->tsprecision = WTAP_FILE_TSPREC_USEC;
         break;
 
         wdh->tsprecision = WTAP_FILE_TSPREC_USEC;
         break;
 
index 4fc9b3b3d28e4a9cdac705be73560d0186ba4a35..716320142090f7db5836d615b43c89aaa2ea8247 100644 (file)
@@ -356,7 +356,7 @@ int camins_open(wtap *wth, int *err, gchar **err_info _U_)
 
    wth->subtype_read = camins_read;
    wth->subtype_seek_read = camins_seek_read;
 
    wth->subtype_read = camins_read;
    wth->subtype_seek_read = camins_seek_read;
-   wth->file_type = WTAP_FILE_CAMINS;
+   wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_CAMINS;
 
    *err = 0;
    return 1;
 
    *err = 0;
    return 1;
index 1e540fcd28a7d09370543a0b4349af2a484a1ee9..605d60d2a3fc7e96df37b2db147e878a64357801 100644 (file)
@@ -252,7 +252,7 @@ catapult_dct2000_open(wtap *wth, int *err, gchar **err_info)
     /* File is for us. Fill in details so packets can be read   */
 
     /* Set our file type */
     /* File is for us. Fill in details so packets can be read   */
 
     /* Set our file type */
-    wth->file_type = WTAP_FILE_CATAPULT_DCT2000;
+    wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_CATAPULT_DCT2000;
 
     /* Use our own encapsulation to send all packets to our stub dissector */
     wth->file_encap = WTAP_ENCAP_CATAPULT_DCT2000;
 
     /* Use our own encapsulation to send all packets to our stub dissector */
     wth->file_encap = WTAP_ENCAP_CATAPULT_DCT2000;
index ac45aea74c49fc823f9e9ee4349bbdac8215e2bd..310131a01a15903cc7ea7dc0d497d41d6babf4dc 100644 (file)
@@ -124,7 +124,7 @@ int commview_open(wtap *wth, int *err, gchar **err_info)
        wth->subtype_read = commview_read;
        wth->subtype_seek_read = commview_seek_read;
 
        wth->subtype_read = commview_read;
        wth->subtype_seek_read = commview_seek_read;
 
-       wth->file_type = WTAP_FILE_COMMVIEW;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_COMMVIEW;
        wth->file_encap = WTAP_ENCAP_PER_PACKET;
        wth->tsprecision = WTAP_FILE_TSPREC_USEC;
 
        wth->file_encap = WTAP_ENCAP_PER_PACKET;
        wth->tsprecision = WTAP_FILE_TSPREC_USEC;
 
index df41707dcba9c4f6d60414079114a0a04e3cd47e..9a5976a9bcbf2b7f50e6b804d3ab790be7f8159e 100644 (file)
@@ -279,7 +279,7 @@ int cosine_open(wtap *wth, int *err, gchar **err_info)
                return -1;
 
        wth->file_encap = WTAP_ENCAP_COSINE;
                return -1;
 
        wth->file_encap = WTAP_ENCAP_COSINE;
-       wth->file_type = WTAP_FILE_COSINE;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_COSINE;
        wth->snapshot_length = 0; /* not known */
        wth->subtype_read = cosine_read;
        wth->subtype_seek_read = cosine_seek_read;
        wth->snapshot_length = 0; /* not known */
        wth->subtype_read = cosine_read;
        wth->subtype_seek_read = cosine_seek_read;
index 7872dbf71faf82b98c24fe6a420c70eb8b04442f..abfc1b31e14dac4472a2fbcbb6d81dc3be317723 100644 (file)
@@ -137,7 +137,7 @@ int csids_open(wtap *wth, int *err, gchar **err_info)
   wth->priv = (void *)csids;
   csids->byteswapped = byteswap;
   wth->file_encap = WTAP_ENCAP_RAW_IP;
   wth->priv = (void *)csids;
   csids->byteswapped = byteswap;
   wth->file_encap = WTAP_ENCAP_RAW_IP;
-  wth->file_type = WTAP_FILE_CSIDS;
+  wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_CSIDS;
   wth->snapshot_length = 0; /* not known */
   wth->subtype_read = csids_read;
   wth->subtype_seek_read = csids_seek_read;
   wth->snapshot_length = 0; /* not known */
   wth->subtype_read = csids_read;
   wth->subtype_seek_read = csids_seek_read;
index 7cc5bfa841eae4932cdd854f2ef2b07fad938b46..a13eea01f7b8f871ea398fc58a38ea75c495fa7e 100644 (file)
@@ -127,7 +127,7 @@ int daintree_sna_open(wtap *wth, int *err, gchar **err_info)
        wth->subtype_seek_read = daintree_sna_seek_read;
 
        /* set up for file type */
        wth->subtype_seek_read = daintree_sna_seek_read;
 
        /* set up for file type */
-       wth->file_type = WTAP_FILE_DAINTREE_SNA;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_DAINTREE_SNA;
        wth->file_encap = WTAP_ENCAP_IEEE802_15_4_NOFCS;
        wth->tsprecision = WTAP_FILE_TSPREC_USEC;
        wth->snapshot_length = 0; /* not available in header */
        wth->file_encap = WTAP_ENCAP_IEEE802_15_4_NOFCS;
        wth->tsprecision = WTAP_FILE_TSPREC_USEC;
        wth->snapshot_length = 0; /* not available in header */
index 0079cdc91882848932d006aeffdd2a3442cbf754..3aeb1b4122384663bbf53de61252e8f6ae9c1a9e 100644 (file)
@@ -189,7 +189,7 @@ int dbs_etherwatch_open(wtap *wth, int *err, gchar **err_info)
        }
 
        wth->file_encap = WTAP_ENCAP_ETHERNET;
        }
 
        wth->file_encap = WTAP_ENCAP_ETHERNET;
-       wth->file_type = WTAP_FILE_DBS_ETHERWATCH;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_DBS_ETHERWATCH;
        wth->snapshot_length = 0;       /* not known */
        wth->subtype_read = dbs_etherwatch_read;
        wth->subtype_seek_read = dbs_etherwatch_seek_read;
        wth->snapshot_length = 0;       /* not known */
        wth->subtype_read = dbs_etherwatch_read;
        wth->subtype_seek_read = dbs_etherwatch_seek_read;
index 37fc379f7f39709d6e4d5ee77c3848e5a522eba9..c298dd3f6098317afb1094d1efe04c92a74aa43c 100644 (file)
@@ -180,7 +180,7 @@ int dct3trace_open(wtap *wth, int *err, gchar **err_info)
        }
 
        wth->file_encap = WTAP_ENCAP_GSM_UM;
        }
 
        wth->file_encap = WTAP_ENCAP_GSM_UM;
-       wth->file_type = WTAP_FILE_DCT3TRACE;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_DCT3TRACE;
        wth->snapshot_length = 0; /* not known */
        wth->subtype_read = dct3trace_read;
        wth->subtype_seek_read = dct3trace_seek_read;
        wth->snapshot_length = 0; /* not known */
        wth->subtype_read = dct3trace_read;
        wth->subtype_seek_read = dct3trace_seek_read;
index 9297e8fc9369a78d1ecf9a012bfe2c8b02abce36..6e7c782b00202b662f54d783973154160998cc5b 100644 (file)
@@ -265,7 +265,7 @@ extern int erf_open(wtap *wth, int *err, gchar **err_info)
   }
 
   /* This is an ERF file */
   }
 
   /* This is an ERF file */
-  wth->file_type = WTAP_FILE_ERF;
+  wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_ERF;
   wth->snapshot_length = 0;     /* not available in header, only in frame */
 
   /*
   wth->snapshot_length = 0;     /* not available in header, only in frame */
 
   /*
@@ -702,8 +702,8 @@ int erf_dump_open(wtap_dumper *wdh, int *err)
   wdh->subtype_write = erf_dump;
   wdh->subtype_close = NULL;
 
   wdh->subtype_write = erf_dump;
   wdh->subtype_close = NULL;
 
-  switch(wdh->file_type){
-    case WTAP_FILE_ERF:
+  switch(wdh->file_type_subtype){
+    case WTAP_FILE_TYPE_SUBTYPE_ERF:
       wdh->tsprecision = WTAP_FILE_TSPREC_NSEC;
       break;
     default:
       wdh->tsprecision = WTAP_FILE_TSPREC_NSEC;
       break;
     default:
index 40e3d25d97fade3bb66f5657e930f8479bd964f9..0afd272881f7fcabf1431b09d275fe81d2b4001f 100644 (file)
@@ -142,7 +142,7 @@ int eyesdn_open(wtap *wth, int *err, gchar **err_info)
                return 0;
 
        wth->file_encap = WTAP_ENCAP_PER_PACKET;
                return 0;
 
        wth->file_encap = WTAP_ENCAP_PER_PACKET;
-       wth->file_type = WTAP_FILE_EYESDN;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_EYESDN;
        wth->snapshot_length = 0; /* not known */
        wth->subtype_read = eyesdn_read;
        wth->subtype_seek_read = eyesdn_seek_read;
        wth->snapshot_length = 0; /* not known */
        wth->subtype_read = eyesdn_read;
        wth->subtype_seek_read = eyesdn_seek_read;
index 4f79e60328e2039727d8afb227508266b82ef88a..ee5eb747a2e62fa259e8384e1af55f5d5b000427 100644 (file)
@@ -603,7 +603,7 @@ success:
        wth->frame_buffer = (struct Buffer *)g_malloc(sizeof(struct Buffer));
        buffer_init(wth->frame_buffer, 1500);
 
        wth->frame_buffer = (struct Buffer *)g_malloc(sizeof(struct Buffer));
        buffer_init(wth->frame_buffer, 1500);
 
-       if(wth->file_type == WTAP_FILE_PCAP){
+       if(wth->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_PCAP){
 
                wtapng_if_descr_t descr;
 
 
                wtapng_if_descr_t descr;
 
@@ -694,300 +694,300 @@ wtap_fdreopen(wtap *wth, const char *filename, int *err)
 }
 
 /* Table of the file types we know about.
 }
 
 /* Table of the file types we know about.
-   Entries must be sorted by WTAP_FILE_xxx values in ascending order */
-static const struct file_type_info dump_open_table_base[] = {
-       /* WTAP_FILE_UNKNOWN (only used internally for initialization) */
+   Entries must be sorted by WTAP_FILE_TYPE_SUBTYPE_xxx values in ascending order */
+static const struct file_type_subtype_info dump_open_table_base[] = {
+       /* WTAP_FILE_TYPE_SUBTYPE_UNKNOWN (only used internally for initialization) */
        { NULL, NULL, NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { NULL, NULL, NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_PCAP */
+       /* WTAP_FILE_TYPE_SUBTYPE_PCAP */
         /* Gianluca Varenni suggests that we add "deprecated" to the description. */
        { "Wireshark/tcpdump/... - pcap", "pcap", "pcap", "cap;dmp",
          FALSE, FALSE, 0,
          libpcap_dump_can_write_encap, libpcap_dump_open },
 
         /* Gianluca Varenni suggests that we add "deprecated" to the description. */
        { "Wireshark/tcpdump/... - pcap", "pcap", "pcap", "cap;dmp",
          FALSE, FALSE, 0,
          libpcap_dump_can_write_encap, libpcap_dump_open },
 
-       /* WTAP_FILE_PCAPNG */
+       /* WTAP_FILE_TYPE_SUBTYPE_PCAPNG */
        { "Wireshark/... - pcapng", "pcapng", "pcapng", "ntar",
          FALSE, TRUE, WTAP_COMMENT_PER_SECTION|WTAP_COMMENT_PER_INTERFACE|WTAP_COMMENT_PER_PACKET,
          pcapng_dump_can_write_encap, pcapng_dump_open },
 
        { "Wireshark/... - pcapng", "pcapng", "pcapng", "ntar",
          FALSE, TRUE, WTAP_COMMENT_PER_SECTION|WTAP_COMMENT_PER_INTERFACE|WTAP_COMMENT_PER_PACKET,
          pcapng_dump_can_write_encap, pcapng_dump_open },
 
-       /* WTAP_FILE_PCAP_NSEC */
+       /* WTAP_FILE_TYPE_SUBTYPE_PCAP_NSEC */
        { "Wireshark - nanosecond libpcap", "nseclibpcap", "pcap", "cap;dmp",
          FALSE, FALSE, 0,
          libpcap_dump_can_write_encap, libpcap_dump_open },
 
        { "Wireshark - nanosecond libpcap", "nseclibpcap", "pcap", "cap;dmp",
          FALSE, FALSE, 0,
          libpcap_dump_can_write_encap, libpcap_dump_open },
 
-       /* WTAP_FILE_PCAP_AIX */
+       /* WTAP_FILE_TYPE_SUBTYPE_PCAP_AIX */
        { "AIX tcpdump - libpcap", "aixlibpcap", "pcap", "cap;dmp",
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "AIX tcpdump - libpcap", "aixlibpcap", "pcap", "cap;dmp",
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_PCAP_SS991029 */
+       /* WTAP_FILE_TYPE_SUBTYPE_PCAP_SS991029 */
        { "Modified tcpdump - libpcap", "modlibpcap", "pcap", "cap;dmp",
          FALSE, FALSE, 0,
          libpcap_dump_can_write_encap, libpcap_dump_open },
 
        { "Modified tcpdump - libpcap", "modlibpcap", "pcap", "cap;dmp",
          FALSE, FALSE, 0,
          libpcap_dump_can_write_encap, libpcap_dump_open },
 
-       /* WTAP_FILE_PCAP_NOKIA */
+       /* WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA */
        { "Nokia tcpdump - libpcap ", "nokialibpcap", "pcap", "cap;dmp",
          FALSE, FALSE, 0,
          libpcap_dump_can_write_encap, libpcap_dump_open },
 
        { "Nokia tcpdump - libpcap ", "nokialibpcap", "pcap", "cap;dmp",
          FALSE, FALSE, 0,
          libpcap_dump_can_write_encap, libpcap_dump_open },
 
-       /* WTAP_FILE_PCAP_SS990417 */
+       /* WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990417 */
        { "RedHat 6.1 tcpdump - libpcap", "rh6_1libpcap", "pcap", "cap;dmp",
          FALSE, FALSE, 0,
          libpcap_dump_can_write_encap, libpcap_dump_open },
 
        { "RedHat 6.1 tcpdump - libpcap", "rh6_1libpcap", "pcap", "cap;dmp",
          FALSE, FALSE, 0,
          libpcap_dump_can_write_encap, libpcap_dump_open },
 
-       /* WTAP_FILE_PCAP_SS990915 */
+       /* WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990915 */
        { "SuSE 6.3 tcpdump - libpcap", "suse6_3libpcap", "pcap", "cap;dmp",
          FALSE, FALSE, 0,
          libpcap_dump_can_write_encap, libpcap_dump_open },
 
        { "SuSE 6.3 tcpdump - libpcap", "suse6_3libpcap", "pcap", "cap;dmp",
          FALSE, FALSE, 0,
          libpcap_dump_can_write_encap, libpcap_dump_open },
 
-       /* WTAP_FILE_5VIEWS */
+       /* WTAP_FILE_TYPE_SUBTYPE_5VIEWS */
        { "InfoVista 5View capture", "5views", "5vw", NULL,
           TRUE, FALSE, 0,
          _5views_dump_can_write_encap, _5views_dump_open },
 
        { "InfoVista 5View capture", "5views", "5vw", NULL,
           TRUE, FALSE, 0,
          _5views_dump_can_write_encap, _5views_dump_open },
 
-       /* WTAP_FILE_IPTRACE_1_0 */
+       /* WTAP_FILE_TYPE_SUBTYPE_IPTRACE_1_0 */
        { "AIX iptrace 1.0", "iptrace_1", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "AIX iptrace 1.0", "iptrace_1", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_IPTRACE_2_0 */
+       /* WTAP_FILE_TYPE_SUBTYPE_IPTRACE_2_0 */
        { "AIX iptrace 2.0", "iptrace_2", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "AIX iptrace 2.0", "iptrace_2", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_BER */
+       /* WTAP_FILE_TYPE_SUBTYPE_BER */
        { "ASN.1 Basic Encoding Rules", "ber", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "ASN.1 Basic Encoding Rules", "ber", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_HCIDUMP */
+       /* WTAP_FILE_TYPE_SUBTYPE_HCIDUMP */
        { "Bluetooth HCI dump", "hcidump", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "Bluetooth HCI dump", "hcidump", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_CATAPULT_DCT2000 */
+       /* WTAP_FILE_TYPE_SUBTYPE_CATAPULT_DCT2000 */
        { "Catapult DCT2000 trace (.out format)", "dct2000", "out", NULL,
          FALSE, FALSE, 0,
          catapult_dct2000_dump_can_write_encap, catapult_dct2000_dump_open },
 
        { "Catapult DCT2000 trace (.out format)", "dct2000", "out", NULL,
          FALSE, FALSE, 0,
          catapult_dct2000_dump_can_write_encap, catapult_dct2000_dump_open },
 
-       /* WTAP_FILE_NETXRAY_OLD */
+       /* WTAP_FILE_TYPE_SUBTYPE_NETXRAY_OLD */
        { "Cinco Networks NetXRay 1.x", "netxray1", "cap", NULL,
          TRUE, FALSE, 0,
          NULL, NULL },
 
        { "Cinco Networks NetXRay 1.x", "netxray1", "cap", NULL,
          TRUE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_NETXRAY_1_0 */
+       /* WTAP_FILE_TYPE_SUBTYPE_NETXRAY_1_0 */
        { "Cinco Networks NetXRay 2.0 or later", "netxray2", "cap", NULL,
          TRUE, FALSE, 0,
          NULL, NULL },
 
        { "Cinco Networks NetXRay 2.0 or later", "netxray2", "cap", NULL,
          TRUE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_COSINE */
+       /* WTAP_FILE_TYPE_SUBTYPE_COSINE */
        { "CoSine IPSX L2 capture", "cosine", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "CoSine IPSX L2 capture", "cosine", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_CSIDS */
+       /* WTAP_FILE_TYPE_SUBTYPE_CSIDS */
        { "CSIDS IPLog", "csids", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "CSIDS IPLog", "csids", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_DBS_ETHERWATCH */
+       /* WTAP_FILE_TYPE_SUBTYPE_DBS_ETHERWATCH */
        { "DBS Etherwatch (VMS)", "etherwatch", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL},
 
        { "DBS Etherwatch (VMS)", "etherwatch", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL},
 
-       /* WTAP_FILE_ERF */
+       /* WTAP_FILE_TYPE_SUBTYPE_ERF */
        { "Endace ERF capture", "erf", "erf", NULL,
          FALSE, FALSE, 0,
          erf_dump_can_write_encap, erf_dump_open },
 
        { "Endace ERF capture", "erf", "erf", NULL,
          FALSE, FALSE, 0,
          erf_dump_can_write_encap, erf_dump_open },
 
-       /* WTAP_FILE_EYESDN */
+       /* WTAP_FILE_TYPE_SUBTYPE_EYESDN */
        { "EyeSDN USB S0/E1 ISDN trace format", "eyesdn", "trc", NULL,
           FALSE, FALSE, 0,
           eyesdn_dump_can_write_encap, eyesdn_dump_open },
 
        { "EyeSDN USB S0/E1 ISDN trace format", "eyesdn", "trc", NULL,
           FALSE, FALSE, 0,
           eyesdn_dump_can_write_encap, eyesdn_dump_open },
 
-       /* WTAP_FILE_NETTL */
+       /* WTAP_FILE_TYPE_SUBTYPE_NETTL */
        { "HP-UX nettl trace", "nettl", "trc0", "trc1",
          FALSE, FALSE, 0,
          nettl_dump_can_write_encap, nettl_dump_open },
 
        { "HP-UX nettl trace", "nettl", "trc0", "trc1",
          FALSE, FALSE, 0,
          nettl_dump_can_write_encap, nettl_dump_open },
 
-       /* WTAP_FILE_ISERIES */
+       /* WTAP_FILE_TYPE_SUBTYPE_ISERIES */
        { "IBM iSeries comm. trace (ASCII)", "iseries_ascii", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "IBM iSeries comm. trace (ASCII)", "iseries_ascii", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_ISERIES_UNICODE */
+       /* WTAP_FILE_TYPE_SUBTYPE_ISERIES_UNICODE */
        { "IBM iSeries comm. trace (UNICODE)", "iseries_unicode", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "IBM iSeries comm. trace (UNICODE)", "iseries_unicode", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_I4BTRACE */
+       /* WTAP_FILE_TYPE_SUBTYPE_I4BTRACE */
        { "I4B ISDN trace", "i4btrace", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "I4B ISDN trace", "i4btrace", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_ASCEND */
+       /* WTAP_FILE_TYPE_SUBTYPE_ASCEND */
        { "Lucent/Ascend access server trace", "ascend", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "Lucent/Ascend access server trace", "ascend", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_NETMON_1_x */
+       /* WTAP_FILE_TYPE_SUBTYPE_NETMON_1_x */
        { "Microsoft NetMon 1.x", "netmon1", "cap", NULL,
          TRUE, FALSE, 0,
          netmon_dump_can_write_encap_1_x, netmon_dump_open },
 
        { "Microsoft NetMon 1.x", "netmon1", "cap", NULL,
          TRUE, FALSE, 0,
          netmon_dump_can_write_encap_1_x, netmon_dump_open },
 
-       /* WTAP_FILE_NETMON_2_x */
+       /* WTAP_FILE_TYPE_SUBTYPE_NETMON_2_x */
        { "Microsoft NetMon 2.x", "netmon2", "cap", NULL,
          TRUE, FALSE, 0,
          netmon_dump_can_write_encap_2_x, netmon_dump_open },
 
        { "Microsoft NetMon 2.x", "netmon2", "cap", NULL,
          TRUE, FALSE, 0,
          netmon_dump_can_write_encap_2_x, netmon_dump_open },
 
-       /* WTAP_FILE_NGSNIFFER_UNCOMPRESSED */
+       /* WTAP_FILE_TYPE_SUBTYPE_NGSNIFFER_UNCOMPRESSED */
        { "Sniffer (DOS)", "ngsniffer", "cap", "enc;trc;fdc;syc",
          FALSE, FALSE, 0,
          ngsniffer_dump_can_write_encap, ngsniffer_dump_open },
 
        { "Sniffer (DOS)", "ngsniffer", "cap", "enc;trc;fdc;syc",
          FALSE, FALSE, 0,
          ngsniffer_dump_can_write_encap, ngsniffer_dump_open },
 
-       /* WTAP_FILE_NGSNIFFER_COMPRESSED */
+       /* WTAP_FILE_TYPE_SUBTYPE_NGSNIFFER_COMPRESSED */
        { "Sniffer (DOS), compressed", "ngsniffer_comp", "cap", "enc;trc;fdc;syc",
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "Sniffer (DOS), compressed", "ngsniffer_comp", "cap", "enc;trc;fdc;syc",
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_NETXRAY_1_1 */
+       /* WTAP_FILE_TYPE_SUBTYPE_NETXRAY_1_1 */
        { "NetXray, Sniffer (Windows) 1.1", "ngwsniffer_1_1", "cap", NULL,
          TRUE, FALSE, 0,
          netxray_dump_can_write_encap_1_1, netxray_dump_open_1_1 },
 
        { "NetXray, Sniffer (Windows) 1.1", "ngwsniffer_1_1", "cap", NULL,
          TRUE, FALSE, 0,
          netxray_dump_can_write_encap_1_1, netxray_dump_open_1_1 },
 
-       /* WTAP_FILE_NETXRAY_2_00x */
+       /* WTAP_FILE_TYPE_SUBTYPE_NETXRAY_2_00x */
        { "Sniffer (Windows) 2.00x", "ngwsniffer_2_0", "cap", "caz",
          TRUE, FALSE, 0,
          netxray_dump_can_write_encap_2_0, netxray_dump_open_2_0 },
 
        { "Sniffer (Windows) 2.00x", "ngwsniffer_2_0", "cap", "caz",
          TRUE, FALSE, 0,
          netxray_dump_can_write_encap_2_0, netxray_dump_open_2_0 },
 
-       /* WTAP_FILE_NETWORK_INSTRUMENTS */
+       /* WTAP_FILE_TYPE_SUBTYPE_NETWORK_INSTRUMENTS */
        { "Network Instruments Observer", "niobserver", "bfr", NULL,
          FALSE, FALSE, 0,
          network_instruments_dump_can_write_encap, network_instruments_dump_open },
 
        { "Network Instruments Observer", "niobserver", "bfr", NULL,
          FALSE, FALSE, 0,
          network_instruments_dump_can_write_encap, network_instruments_dump_open },
 
-       /* WTAP_FILE_LANALYZER */
+       /* WTAP_FILE_TYPE_SUBTYPE_LANALYZER */
        { "Novell LANalyzer","lanalyzer", "tr1", NULL,
          TRUE, FALSE, 0,
          lanalyzer_dump_can_write_encap, lanalyzer_dump_open },
 
        { "Novell LANalyzer","lanalyzer", "tr1", NULL,
          TRUE, FALSE, 0,
          lanalyzer_dump_can_write_encap, lanalyzer_dump_open },
 
-       /* WTAP_FILE_PPPDUMP */
+       /* WTAP_FILE_TYPE_SUBTYPE_PPPDUMP */
        { "pppd log (pppdump format)", "pppd", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "pppd log (pppdump format)", "pppd", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_RADCOM */
+       /* WTAP_FILE_TYPE_SUBTYPE_RADCOM */
        { "RADCOM WAN/LAN analyzer", "radcom", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "RADCOM WAN/LAN analyzer", "radcom", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_SNOOP */
+       /* WTAP_FILE_TYPE_SUBTYPE_SNOOP */
        { "Sun snoop", "snoop", "snoop", "cap",
          FALSE, FALSE, 0,
          snoop_dump_can_write_encap, snoop_dump_open },
 
        { "Sun snoop", "snoop", "snoop", "cap",
          FALSE, FALSE, 0,
          snoop_dump_can_write_encap, snoop_dump_open },
 
-       /* WTAP_FILE_SHOMITI */
+       /* WTAP_FILE_TYPE_SUBTYPE_SHOMITI */
        { "Shomiti/Finisar Surveyor", "shomiti", "cap", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "Shomiti/Finisar Surveyor", "shomiti", "cap", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_VMS */
+       /* WTAP_FILE_TYPE_SUBTYPE_VMS */
        { "TCPIPtrace (VMS)", "tcpiptrace", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL},
 
        { "TCPIPtrace (VMS)", "tcpiptrace", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL},
 
-       /* WTAP_FILE_K12 */
+       /* WTAP_FILE_TYPE_SUBTYPE_K12 */
        { "Tektronix K12xx 32-bit .rf5 format", "rf5", "rf5", NULL,
           TRUE, FALSE, 0,
           k12_dump_can_write_encap, k12_dump_open },
 
        { "Tektronix K12xx 32-bit .rf5 format", "rf5", "rf5", NULL,
           TRUE, FALSE, 0,
           k12_dump_can_write_encap, k12_dump_open },
 
-       /* WTAP_FILE_TOSHIBA */
+       /* WTAP_FILE_TYPE_SUBTYPE_TOSHIBA */
        { "Toshiba Compact ISDN Router snoop", "toshiba", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "Toshiba Compact ISDN Router snoop", "toshiba", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_VISUAL_NETWORKS */
+       /* WTAP_FILE_TYPE_SUBTYPE_VISUAL_NETWORKS */
        { "Visual Networks traffic capture", "visual", NULL, NULL,
          TRUE, FALSE, 0,
          visual_dump_can_write_encap, visual_dump_open },
 
        { "Visual Networks traffic capture", "visual", NULL, NULL,
          TRUE, FALSE, 0,
          visual_dump_can_write_encap, visual_dump_open },
 
-       /* WTAP_FILE_PEEKCLASSIC_V56 */
+       /* WTAP_FILE_TYPE_SUBTYPE_PEEKCLASSIC_V56 */
        { "WildPackets classic (V5 and V6)", "peekclassic56", "pkt", "tpc;apc;wpz",
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "WildPackets classic (V5 and V6)", "peekclassic56", "pkt", "tpc;apc;wpz",
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_PEEKCLASSIC_V7 */
+       /* WTAP_FILE_TYPE_SUBTYPE_PEEKCLASSIC_V7 */
        { "WildPackets classic (V7)", "peekclassic7", "pkt", "tpc;apc;wpz",
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "WildPackets classic (V7)", "peekclassic7", "pkt", "tpc;apc;wpz",
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_PEEKTAGGED */
+       /* WTAP_FILE_TYPE_SUBTYPE_PEEKTAGGED */
        { "WildPackets tagged", "peektagged", "pkt", "tpc;apc;wpz",
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "WildPackets tagged", "peektagged", "pkt", "tpc;apc;wpz",
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_MPEG */
+       /* WTAP_FILE_TYPE_SUBTYPE_MPEG */
        { "MPEG", "mpeg", "mpeg", "mpg;mp3",
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "MPEG", "mpeg", "mpeg", "mpg;mp3",
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_K12TEXT  */
+       /* WTAP_FILE_TYPE_SUBTYPE_K12TEXT  */
        { "K12 text file", "k12text", "txt", NULL,
          FALSE, FALSE, 0,
          k12text_dump_can_write_encap, k12text_dump_open },
 
        { "K12 text file", "k12text", "txt", NULL,
          FALSE, FALSE, 0,
          k12text_dump_can_write_encap, k12text_dump_open },
 
-       /* WTAP_FILE_NETSCREEN */
+       /* WTAP_FILE_TYPE_SUBTYPE_NETSCREEN */
        { "NetScreen snoop text file", "netscreen", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "NetScreen snoop text file", "netscreen", "txt", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_COMMVIEW */
+       /* WTAP_FILE_TYPE_SUBTYPE_COMMVIEW */
        { "TamoSoft CommView", "commview", "ncf", NULL,
          FALSE, FALSE, 0,
          commview_dump_can_write_encap, commview_dump_open },
 
        { "TamoSoft CommView", "commview", "ncf", NULL,
          FALSE, FALSE, 0,
          commview_dump_can_write_encap, commview_dump_open },
 
-       /* WTAP_FILE_BTSNOOP */
+       /* WTAP_FILE_TYPE_SUBTYPE_BTSNOOP */
        { "Symbian OS btsnoop", "btsnoop", "log", NULL,
          FALSE, FALSE, 0,
          btsnoop_dump_can_write_encap, btsnoop_dump_open_h4 },
 
        { "Symbian OS btsnoop", "btsnoop", "log", NULL,
          FALSE, FALSE, 0,
          btsnoop_dump_can_write_encap, btsnoop_dump_open_h4 },
 
-       /* WTAP_FILE_TNEF */
+       /* WTAP_FILE_TYPE_SUBTYPE_TNEF */
        { "Transport-Neutral Encapsulation Format", "tnef", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "Transport-Neutral Encapsulation Format", "tnef", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_DCT3TRACE */
+       /* WTAP_FILE_TYPE_SUBTYPE_DCT3TRACE */
        { "Gammu DCT3 trace", "dct3trace", "xml", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "Gammu DCT3 trace", "dct3trace", "xml", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_PACKETLOGGER */
+       /* WTAP_FILE_TYPE_SUBTYPE_PACKETLOGGER */
        { "PacketLogger", "pklg", "pklg", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "PacketLogger", "pklg", "pklg", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_DAINTREE_SNA */
+       /* WTAP_FILE_TYPE_SUBTYPE_DAINTREE_SNA */
        { "Daintree SNA", "dsna", "dcf", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "Daintree SNA", "dsna", "dcf", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_NETSCALER_1_0 */
+       /* WTAP_FILE_TYPE_SUBTYPE_NETSCALER_1_0 */
        { "NetScaler Trace (Version 1.0)", "nstrace10", NULL, NULL,
          TRUE, FALSE, 0,
          nstrace_10_dump_can_write_encap, nstrace_dump_open },
 
        { "NetScaler Trace (Version 1.0)", "nstrace10", NULL, NULL,
          TRUE, FALSE, 0,
          nstrace_10_dump_can_write_encap, nstrace_dump_open },
 
-       /* WTAP_FILE_NETSCALER_2_0 */
+       /* WTAP_FILE_TYPE_SUBTYPE_NETSCALER_2_0 */
        { "NetScaler Trace (Version 2.0)", "nstrace20", "cap", NULL,
          TRUE, FALSE, 0,
          nstrace_20_dump_can_write_encap, nstrace_dump_open },
 
        { "NetScaler Trace (Version 2.0)", "nstrace20", "cap", NULL,
          TRUE, FALSE, 0,
          nstrace_20_dump_can_write_encap, nstrace_dump_open },
 
-       /* WTAP_FILE_JPEG_JFIF */
+       /* WTAP_FILE_TYPE_SUBTYPE_JPEG_JFIF */
        { "JPEG/JFIF", "jpeg", "jpg", "jpeg;jfif",
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "JPEG/JFIF", "jpeg", "jpg", "jpeg;jfif",
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_IPFIX */
+       /* WTAP_FILE_TYPE_SUBTYPE_IPFIX */
        { "IPFIX File Format", "ipfix", "pfx", "ipfix",
          FALSE, FALSE, 0,
          NULL, NULL },
        { "IPFIX File Format", "ipfix", "pfx", "ipfix",
          FALSE, FALSE, 0,
          NULL, NULL },
@@ -997,68 +997,68 @@ static const struct file_type_info dump_open_table_base[] = {
           FALSE, FALSE, 0,
           NULL, NULL },
 
           FALSE, FALSE, 0,
           NULL, NULL },
 
-       /* WTAP_FILE_AETHRA */
+       /* WTAP_FILE_TYPE_SUBTYPE_AETHRA */
        { "Aethra .aps file", "aethra", "aps", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "Aethra .aps file", "aethra", "aps", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_MPEG_2_TS */
+       /* WTAP_FILE_TYPE_SUBTYPE_MPEG_2_TS */
        { "MPEG2 transport stream", "mp2t", "mp2t", "ts;mpg",
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "MPEG2 transport stream", "mp2t", "mp2t", "ts;mpg",
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_VWR_80211 */
+       /* WTAP_FILE_TYPE_SUBTYPE_VWR_80211 */
        { "Ixia IxVeriWave .vwr Raw 802.11 Capture", "vwr80211", "vwr", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "Ixia IxVeriWave .vwr Raw 802.11 Capture", "vwr80211", "vwr", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_VWR_ETH */
+       /* WTAP_FILE_TYPE_SUBTYPE_VWR_ETH */
        { "Ixia IxVeriWave .vwr Raw Ethernet Capture", "vwreth", "vwr", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "Ixia IxVeriWave .vwr Raw Ethernet Capture", "vwreth", "vwr", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_CAMINS */
+       /* WTAP_FILE_TYPE_SUBTYPE_CAMINS */
        { "CAM Inspector file", "camins", "camins", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
        { "CAM Inspector file", "camins", "camins", NULL,
          FALSE, FALSE, 0,
          NULL, NULL },
 
-       /* WTAP_FILE_STANAG_4607 */
+       /* WTAP_FILE_TYPE_SUBTYPE_STANAG_4607 */
        { "STANAG 4607 Format", "stanag4607", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL }
 
 };
 
        { "STANAG 4607 Format", "stanag4607", NULL, NULL,
          FALSE, FALSE, 0,
          NULL, NULL }
 
 };
 
-gint wtap_num_file_types = sizeof(dump_open_table_base) / sizeof(struct file_type_info);
+gint wtap_num_file_types_subtypes = sizeof(dump_open_table_base) / sizeof(struct file_type_subtype_info);
 
 static GArray*  dump_open_table_arr = NULL;
 
 static GArray*  dump_open_table_arr = NULL;
-static const struct file_type_info* dump_open_table = dump_open_table_base;
+static const struct file_type_subtype_info* dump_open_table = dump_open_table_base;
 
 /* initialize the file types array if it has not being initialized yet */
 
 /* initialize the file types array if it has not being initialized yet */
-static void init_file_types(void) {
+static void init_file_types_subtypes(void) {
 
        if (dump_open_table_arr) return;
 
 
        if (dump_open_table_arr) return;
 
-       dump_open_table_arr = g_array_new(FALSE,TRUE,sizeof(struct file_type_info));
+       dump_open_table_arr = g_array_new(FALSE,TRUE,sizeof(struct file_type_subtype_info));
 
 
-       g_array_append_vals(dump_open_table_arr,dump_open_table_base,wtap_num_file_types);
+       g_array_append_vals(dump_open_table_arr,dump_open_table_base,wtap_num_file_types_subtypes);
 
 
-       dump_open_table = (const struct file_type_info*)(void *)dump_open_table_arr->data;
+       dump_open_table = (const struct file_type_subtype_info*)(void *)dump_open_table_arr->data;
 }
 
 }
 
-int wtap_register_file_type(const struct file_type_info* fi) {
-       init_file_types();
+int wtap_register_file_type_subtypes(const struct file_type_subtype_info* fi) {
+       init_file_types_subtypes();
 
        g_array_append_val(dump_open_table_arr,*fi);
 
 
        g_array_append_val(dump_open_table_arr,*fi);
 
-       dump_open_table = (const struct file_type_info*)(void *)dump_open_table_arr->data;
+       dump_open_table = (const struct file_type_subtype_info*)(void *)dump_open_table_arr->data;
 
 
-       return wtap_num_file_types++;
+       return wtap_num_file_types_subtypes++;
 }
 
 }
 
-int wtap_get_num_file_types(void)
+int wtap_get_num_file_types_subtypes(void)
 {
 {
-       return wtap_num_file_types;
+       return wtap_num_file_types_subtypes;
 }
 
 /*
 }
 
 /*
@@ -1083,7 +1083,7 @@ wtap_dump_file_encap_type(const GArray *file_encaps)
 static gboolean
 wtap_dump_can_write_encap(int filetype, int encap)
 {
 static gboolean
 wtap_dump_can_write_encap(int filetype, int encap)
 {
-       if (filetype < 0 || filetype >= wtap_num_file_types
+       if (filetype < 0 || filetype >= wtap_num_file_types_subtypes
            || dump_open_table[filetype].can_write_encap == NULL)
                return FALSE;
 
            || dump_open_table[filetype].can_write_encap == NULL)
                return FALSE;
 
@@ -1154,7 +1154,7 @@ wtap_dump_can_write(const GArray *file_encaps, guint32 required_comment_types)
 {
   int ft;
 
 {
   int ft;
 
-  for (ft = 0; ft < WTAP_NUM_FILE_TYPES; ft++) {
+  for (ft = 0; ft < WTAP_NUM_FILE_TYPES_SUBTYPES; 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. */
     /* 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. */
@@ -1169,108 +1169,108 @@ wtap_dump_can_write(const GArray *file_encaps, guint32 required_comment_types)
 }
 
 /**
 }
 
 /**
- * Get a GArray of WTAP_FILE_ values for file types that can be used
- * to save a file of a given type with a given GArray of encapsulation
- * types and the given bitmask of comment types.
+ * Get a GArray of WTAP_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 *
  */
 GArray *
-wtap_get_savable_file_types(int file_type, const GArray *file_encaps,
-    guint32 required_comment_types)
+wtap_get_savable_file_types_subtypes(int file_type_subtype,
+    const GArray *file_encaps, guint32 required_comment_types)
 {
 {
-       GArray *savable_file_types;
+       GArray *savable_file_types_subtypes;
        int ft;
        int ft;
-       int default_file_type = -1;
-       int other_file_type = -1;
+       int default_file_type_subtype = -1;
+       int other_file_type_subtype = -1;
 
 
-       /* Can we save this file in its own file type? */
-       if (wtap_dump_can_write_format(file_type, file_encaps,
+       /* Can we save this file in its own file type/subtype? */
+       if (wtap_dump_can_write_format(file_type_subtype, file_encaps,
                                       required_comment_types)) {
                                       required_comment_types)) {
-               /* Yes - make that the default file type. */
-               default_file_type = file_type;
+               /* Yes - make that the default file type/subtype. */
+               default_file_type_subtype = file_type_subtype;
        } else {
        } else {
-               /* OK, find the first file type we *can* save it as. */
-               default_file_type = -1;
-               for (ft = 0; ft < WTAP_NUM_FILE_TYPES; ft++) {
+               /* 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++) {
                        if (wtap_dump_can_write_format(ft, file_encaps,
                                                       required_comment_types)) {
                                /* OK, got it. */
                        if (wtap_dump_can_write_format(ft, file_encaps,
                                                       required_comment_types)) {
                                /* OK, got it. */
-                               default_file_type = ft;
+                               default_file_type_subtype = ft;
                        }
                }
        }
 
                        }
                }
        }
 
-       if (default_file_type == -1) {
-               /* We don't support writing this file as any file type. */
+       if (default_file_type_subtype == -1) {
+               /* We don't support writing this file as any file type/subtype. */
                return NULL;
        }
 
        /* Allocate the array. */
                return NULL;
        }
 
        /* Allocate the array. */
-       savable_file_types = g_array_new(FALSE, FALSE, (guint)sizeof (int));
+       savable_file_types_subtypes = g_array_new(FALSE, FALSE, (guint)sizeof (int));
 
 
-       /* Put the default file format first in the list. */
-       g_array_append_val(savable_file_types, default_file_type);
+       /* 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 pcap-NG right after it if we can
           also write it in pcap-NG format; otherwise, if the default is
           pcap-NG, put pcap right after it if we can also write it in
           pcap format. */
 
        /* If the default is pcap, put pcap-NG right after it if we can
           also write it in pcap-NG format; otherwise, if the default is
           pcap-NG, put pcap right after it if we can also write it in
           pcap format. */
-       if (default_file_type == WTAP_FILE_PCAP) {
-               if (wtap_dump_can_write_format(WTAP_FILE_PCAPNG, file_encaps,
+       if (default_file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_PCAP) {
+               if (wtap_dump_can_write_format(WTAP_FILE_TYPE_SUBTYPE_PCAPNG, file_encaps,
                                               required_comment_types))
                                               required_comment_types))
-                       other_file_type = WTAP_FILE_PCAPNG;
-       } else if (default_file_type == WTAP_FILE_PCAPNG) {
-               if (wtap_dump_can_write_format(WTAP_FILE_PCAP, file_encaps,
+                       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))
                                               required_comment_types))
-                       other_file_type = WTAP_FILE_PCAP;
+                       other_file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PCAP;
        }
        }
-       if (other_file_type != -1)
-               g_array_append_val(savable_file_types, other_file_type);
+       if (other_file_type_subtype != -1)
+               g_array_append_val(savable_file_types_subtypes, other_file_type_subtype);
 
 
-       /* Add all the other file types that work. */
-       for (ft = 0; ft < WTAP_NUM_FILE_TYPES; ft++) {
-               if (ft == WTAP_FILE_UNKNOWN)
+       /* Add all the other file types/subtypes that work. */
+       for (ft = 0; ft < WTAP_NUM_FILE_TYPES_SUBTYPES; ft++) {
+               if (ft == WTAP_FILE_TYPE_SUBTYPE_UNKNOWN)
                        continue;       /* not a real file type */
                        continue;       /* not a real file type */
-               if (ft == default_file_type || ft == other_file_type)
+               if (ft == default_file_type_subtype || ft == other_file_type_subtype)
                        continue;       /* we've already done this one */
                if (wtap_dump_can_write_format(ft, file_encaps,
                                               required_comment_types)) {
                        /* OK, we can write it out in this type. */
                        continue;       /* we've already done this one */
                if (wtap_dump_can_write_format(ft, file_encaps,
                                               required_comment_types)) {
                        /* OK, we can write it out in this type. */
-                       g_array_append_val(savable_file_types, ft);
+                       g_array_append_val(savable_file_types_subtypes, ft);
                }
        }
 
                }
        }
 
-       return savable_file_types;
+       return savable_file_types_subtypes;
 }
 
 /* Name that should be somewhat descriptive. */
 }
 
 /* Name that should be somewhat descriptive. */
-const char *wtap_file_type_string(int filetype)
+const char *wtap_file_type_subtype_string(int file_type_subtype)
 {
 {
-       if (filetype < 0 || filetype >= wtap_num_file_types) {
-               g_error("Unknown capture file type %d", filetype);
+       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
                /** g_error() does an abort() and thus never returns **/
                return "";
        } else
-               return dump_open_table[filetype].name;
+               return dump_open_table[file_type_subtype].name;
 }
 
 }
 
-/* Name to use in, say, a command-line flag specifying the type. */
-const char *wtap_file_type_short_string(int filetype)
+/* Name to use in, say, a command-line flag specifying the type/subtype. */
+const char *wtap_file_type_subtype_short_string(int file_type_subtype)
 {
 {
-       if (filetype < 0 || filetype >= wtap_num_file_types)
+       if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes)
                return NULL;
        else
                return NULL;
        else
-               return dump_open_table[filetype].short_name;
+               return dump_open_table[file_type_subtype].short_name;
 }
 
 }
 
-/* Translate a short name to a capture file type. */
-int wtap_short_string_to_file_type(const char *short_name)
+/* Translate a short name to a capture file type/subtype. */
+int wtap_short_string_to_file_type_subtype(const char *short_name)
 {
 {
-       int filetype;
+       int file_type_subtype;
 
 
-       for (filetype = 0; filetype < wtap_num_file_types; filetype++) {
-               if (dump_open_table[filetype].short_name != NULL &&
-                   strcmp(short_name, dump_open_table[filetype].short_name) == 0)
-                       return filetype;
+       for (file_type_subtype = 0; file_type_subtype < wtap_num_file_types_subtypes; file_type_subtype++) {
+               if (dump_open_table[file_type_subtype].short_name != NULL &&
+                   strcmp(short_name, dump_open_table[file_type_subtype].short_name) == 0)
+                       return file_type_subtype;
        }
 
        /*
        }
 
        /*
@@ -1279,13 +1279,13 @@ int wtap_short_string_to_file_type(const char *short_name)
         * backwards compatibility.
         */
        if (strcmp(short_name, "libpcap") == 0)
         * backwards compatibility.
         */
        if (strcmp(short_name, "libpcap") == 0)
-               return WTAP_FILE_PCAP;
+               return WTAP_FILE_TYPE_SUBTYPE_PCAP;
 
        return -1;      /* no such file type, or we can't write it */
 }
 
 static GSList *
 
        return -1;      /* no such file type, or we can't write it */
 }
 
 static GSList *
-add_extensions_for_filetype(int filetype, GSList *extensions,
+add_extensions_for_file_type_subtype(int file_type_subtype, GSList *extensions,
     GSList *compressed_file_extensions)
 {
        gchar **extensions_set, **extensionp;
     GSList *compressed_file_extensions)
 {
        gchar **extensions_set, **extensionp;
@@ -1296,17 +1296,17 @@ add_extensions_for_filetype(int filetype, GSList *extensions,
         * it.
         */
        extensions = add_extensions(extensions,
         * it.
         */
        extensions = add_extensions(extensions,
-           dump_open_table[filetype].default_file_extension,
+           dump_open_table[file_type_subtype].default_file_extension,
            compressed_file_extensions);
 
            compressed_file_extensions);
 
-       if (dump_open_table[filetype].additional_file_extensions != NULL) {
+       if (dump_open_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.
                 */
                /*
                 * We have additional extensions; add them.
                 *
                 * First, split the extension-list string into a set of
                 * extensions.
                 */
-               extensions_set = g_strsplit(dump_open_table[filetype].additional_file_extensions,
+               extensions_set = g_strsplit(dump_open_table[file_type_subtype].additional_file_extensions,
                    ";", 0);
 
                /*
                    ";", 0);
 
                /*
@@ -1337,15 +1337,15 @@ add_extensions_for_filetype(int filetype, GSList *extensions,
 
    All strings in the list are allocated with g_malloc() and must be freed
    with g_free(). */
 
    All strings in the list are allocated with g_malloc() and must be freed
    with g_free(). */
-GSList *wtap_get_file_extensions_list(int filetype, gboolean include_compressed)
+GSList *wtap_get_file_extensions_list(int file_type_subtype, gboolean include_compressed)
 {
        GSList *compressed_file_extensions;
        GSList *extensions;
 
 {
        GSList *compressed_file_extensions;
        GSList *extensions;
 
-       if (filetype < 0 || filetype >= wtap_num_file_types)
+       if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes)
                return NULL;    /* not a valid file type */
 
                return NULL;    /* not a valid file type */
 
-       if (dump_open_table[filetype].default_file_extension == NULL)
+       if (dump_open_table[file_type_subtype].default_file_extension == NULL)
                return NULL;    /* valid, but no extensions known */
 
        extensions = NULL;      /* empty list, to start with */
                return NULL;    /* valid, but no extensions known */
 
        extensions = NULL;      /* empty list, to start with */
@@ -1363,7 +1363,7 @@ GSList *wtap_get_file_extensions_list(int filetype, gboolean include_compressed)
         * Add all this file type's extensions, with compressed
         * variants.
         */
         * Add all this file type's extensions, with compressed
         * variants.
         */
-       extensions = add_extensions_for_filetype(filetype, extensions,
+       extensions = add_extensions_for_file_type_subtype(file_type_subtype, extensions,
            compressed_file_extensions);
 
        g_slist_free(compressed_file_extensions);
            compressed_file_extensions);
 
        g_slist_free(compressed_file_extensions);
@@ -1387,90 +1387,90 @@ void wtap_free_extensions_list(GSList *extensions)
 
 /* Return the default file extension to use with the specified file type;
    that's just the extension, without any ".". */
 
 /* Return the default file extension to use with the specified file type;
    that's just the extension, without any ".". */
-const char *wtap_default_file_extension(int filetype)
+const char *wtap_default_file_extension(int file_type_subtype)
 {
 {
-       if (filetype < 0 || filetype >= wtap_num_file_types)
+       if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes)
                return NULL;
        else
                return NULL;
        else
-               return dump_open_table[filetype].default_file_extension;
+               return dump_open_table[file_type_subtype].default_file_extension;
 }
 
 }
 
-gboolean wtap_dump_can_open(int filetype)
+gboolean wtap_dump_can_open(int file_type_subtype)
 {
 {
-       if (filetype < 0 || filetype >= wtap_num_file_types
-           || dump_open_table[filetype].dump_open == NULL)
+       if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes
+           || dump_open_table[file_type_subtype].dump_open == NULL)
                return FALSE;
 
        return TRUE;
 }
 
 #ifdef HAVE_LIBZ
                return FALSE;
 
        return TRUE;
 }
 
 #ifdef HAVE_LIBZ
-gboolean wtap_dump_can_compress(int filetype)
+gboolean wtap_dump_can_compress(int file_type_subtype)
 {
        /*
         * If this is an unknown file type, or if we have to
         * seek when writing out a file with this file type,
         * return FALSE.
         */
 {
        /*
         * If this is an unknown file type, or if we have to
         * seek when writing out a file with this file type,
         * return FALSE.
         */
-       if (filetype < 0 || filetype >= wtap_num_file_types
-           || dump_open_table[filetype].writing_must_seek)
+       if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes
+           || dump_open_table[file_type_subtype].writing_must_seek)
                return FALSE;
 
        return TRUE;
 }
 #else
                return FALSE;
 
        return TRUE;
 }
 #else
-gboolean wtap_dump_can_compress(int filetype _U_)
+gboolean wtap_dump_can_compress(int file_type_subtype _U_)
 {
        return FALSE;
 }
 #endif
 
 {
        return FALSE;
 }
 #endif
 
-gboolean wtap_dump_has_name_resolution(int filetype)
+gboolean wtap_dump_has_name_resolution(int file_type_subtype)
 {
 {
-       if (filetype < 0 || filetype >= wtap_num_file_types
-           || dump_open_table[filetype].has_name_resolution == FALSE)
+       if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes
+           || dump_open_table[file_type_subtype].has_name_resolution == FALSE)
                return FALSE;
 
        return TRUE;
 }
 
                return FALSE;
 
        return TRUE;
 }
 
-gboolean wtap_dump_supports_comment_types(int filetype, guint32 comment_types)
+gboolean wtap_dump_supports_comment_types(int file_type_subtype, guint32 comment_types)
 {
        guint32 supported_comment_types;
 
 {
        guint32 supported_comment_types;
 
-       if (filetype < 0 || filetype >= wtap_num_file_types)
+       if (file_type_subtype < 0 || file_type_subtype >= wtap_num_file_types_subtypes)
                return FALSE;
 
                return FALSE;
 
-       supported_comment_types = dump_open_table[filetype].supported_comment_types;
+       supported_comment_types = dump_open_table[file_type_subtype].supported_comment_types;
 
        if ((comment_types & supported_comment_types) == comment_types)
                return TRUE;
        return FALSE;
 }
 
 
        if ((comment_types & supported_comment_types) == comment_types)
                return TRUE;
        return FALSE;
 }
 
-static gboolean wtap_dump_open_check(int filetype, int encap, gboolean comressed, int *err);
-static wtap_dumper* wtap_dump_alloc_wdh(int filetype, int encap, int snaplen,
+static gboolean wtap_dump_open_check(int file_type_subtype, int encap, gboolean comressed, int *err);
+static wtap_dumper* wtap_dump_alloc_wdh(int file_type_subtype, int encap, int snaplen,
                                        gboolean compressed, int *err);
                                        gboolean compressed, int *err);
-static gboolean wtap_dump_open_finish(wtap_dumper *wdh, int filetype, gboolean compressed, int *err);
+static gboolean wtap_dump_open_finish(wtap_dumper *wdh, int file_type_subtype, gboolean compressed, int *err);
 
 static WFILE_T wtap_dump_file_open(wtap_dumper *wdh, const char *filename);
 static WFILE_T wtap_dump_file_fdopen(wtap_dumper *wdh, int fd);
 static int wtap_dump_file_close(wtap_dumper *wdh);
 
 
 static WFILE_T wtap_dump_file_open(wtap_dumper *wdh, const char *filename);
 static WFILE_T wtap_dump_file_fdopen(wtap_dumper *wdh, int fd);
 static int wtap_dump_file_close(wtap_dumper *wdh);
 
-wtap_dumper* wtap_dump_open(const char *filename, int filetype, int encap,
+wtap_dumper* wtap_dump_open(const char *filename, int file_type_subtype, int encap,
                                int snaplen, gboolean compressed, int *err)
 {
                                int snaplen, gboolean compressed, int *err)
 {
-       return wtap_dump_open_ng(filename, filetype, encap,snaplen, compressed, NULL, NULL, err);
+       return wtap_dump_open_ng(filename, file_type_subtype, encap,snaplen, compressed, NULL, NULL, err);
 }
 
 static wtap_dumper *
 }
 
 static wtap_dumper *
-wtap_dump_init_dumper(int filetype, int encap, int snaplen, gboolean compressed,
+wtap_dump_init_dumper(int file_type_subtype, int encap, int snaplen, gboolean compressed,
     wtapng_section_t *shb_hdr, wtapng_iface_descriptions_t *idb_inf, int *err)
 {
        wtap_dumper *wdh;
 
        /* Allocate a data structure for the output stream. */
     wtapng_section_t *shb_hdr, wtapng_iface_descriptions_t *idb_inf, int *err)
 {
        wtap_dumper *wdh;
 
        /* Allocate a data structure for the output stream. */
-       wdh = wtap_dump_alloc_wdh(filetype, encap, snaplen, compressed, err);
+       wdh = wtap_dump_alloc_wdh(file_type_subtype, encap, snaplen, compressed, err);
        if (wdh == NULL)
                return NULL;    /* couldn't allocate it */
 
        if (wdh == NULL)
                return NULL;    /* couldn't allocate it */
 
@@ -1506,7 +1506,7 @@ wtap_dump_init_dumper(int filetype, int encap, int snaplen, gboolean compressed,
        return wdh;
 }
 
        return wdh;
 }
 
-wtap_dumper* wtap_dump_open_ng(const char *filename, int filetype, int encap,
+wtap_dumper* wtap_dump_open_ng(const char *filename, int file_type_subtype, int encap,
                                int snaplen, gboolean compressed, wtapng_section_t *shb_hdr, wtapng_iface_descriptions_t *idb_inf, int *err)
 {
        wtap_dumper *wdh;
                                int snaplen, gboolean compressed, wtapng_section_t *shb_hdr, wtapng_iface_descriptions_t *idb_inf, int *err)
 {
        wtap_dumper *wdh;
@@ -1514,11 +1514,11 @@ wtap_dumper* wtap_dump_open_ng(const char *filename, int filetype, int encap,
 
        /* Check whether we can open a capture file with that file type
           and that encapsulation. */
 
        /* Check whether we can open a capture file with that file type
           and that encapsulation. */
-       if (!wtap_dump_open_check(filetype, encap, compressed, err))
+       if (!wtap_dump_open_check(file_type_subtype, encap, compressed, err))
                return NULL;
 
        /* Allocate and initialize a data structure for the output stream. */
                return NULL;
 
        /* Allocate and initialize a data structure for the output stream. */
-       wdh = wtap_dump_init_dumper(filetype, encap, snaplen, compressed,
+       wdh = wtap_dump_init_dumper(file_type_subtype, encap, snaplen, compressed,
            shb_hdr, idb_inf, err);
        if (wdh == NULL)
                return NULL;
            shb_hdr, idb_inf, err);
        if (wdh == NULL)
                return NULL;
@@ -1552,7 +1552,7 @@ wtap_dumper* wtap_dump_open_ng(const char *filename, int filetype, int encap,
                wdh->fh = fh;
        }
 
                wdh->fh = fh;
        }
 
-       if (!wtap_dump_open_finish(wdh, filetype, compressed, err)) {
+       if (!wtap_dump_open_finish(wdh, file_type_subtype, compressed, err)) {
                /* Get rid of the file we created; we couldn't finish
                   opening it. */
                if (wdh->fh != stdout) {
                /* Get rid of the file we created; we couldn't finish
                   opening it. */
                if (wdh->fh != stdout) {
@@ -1565,13 +1565,13 @@ wtap_dumper* wtap_dump_open_ng(const char *filename, int filetype, int encap,
        return wdh;
 }
 
        return wdh;
 }
 
-wtap_dumper* wtap_dump_fdopen(int fd, int filetype, int encap, int snaplen,
+wtap_dumper* wtap_dump_fdopen(int fd, int file_type_subtype, int encap, int snaplen,
                                gboolean compressed, int *err)
 {
                                gboolean compressed, int *err)
 {
-       return wtap_dump_fdopen_ng(fd, filetype, encap, snaplen, compressed, NULL, NULL, err);
+       return wtap_dump_fdopen_ng(fd, file_type_subtype, encap, snaplen, compressed, NULL, NULL, err);
 }
 
 }
 
-wtap_dumper* wtap_dump_fdopen_ng(int fd, int filetype, int encap, int snaplen,
+wtap_dumper* wtap_dump_fdopen_ng(int fd, int file_type_subtype, int encap, int snaplen,
                                gboolean compressed, wtapng_section_t *shb_hdr, wtapng_iface_descriptions_t *idb_inf, int *err)
 {
        wtap_dumper *wdh;
                                gboolean compressed, wtapng_section_t *shb_hdr, wtapng_iface_descriptions_t *idb_inf, int *err)
 {
        wtap_dumper *wdh;
@@ -1579,11 +1579,11 @@ wtap_dumper* wtap_dump_fdopen_ng(int fd, int filetype, int encap, int snaplen,
 
        /* Check whether we can open a capture file with that file type
           and that encapsulation. */
 
        /* Check whether we can open a capture file with that file type
           and that encapsulation. */
-       if (!wtap_dump_open_check(filetype, encap, compressed, err))
+       if (!wtap_dump_open_check(file_type_subtype, encap, compressed, err))
                return NULL;
 
        /* Allocate and initialize a data structure for the output stream. */
                return NULL;
 
        /* Allocate and initialize a data structure for the output stream. */
-       wdh = wtap_dump_init_dumper(filetype, encap, snaplen, compressed,
+       wdh = wtap_dump_init_dumper(file_type_subtype, encap, snaplen, compressed,
            shb_hdr, idb_inf, err);
        if (wdh == NULL)
                return NULL;
            shb_hdr, idb_inf, err);
        if (wdh == NULL)
                return NULL;
@@ -1610,7 +1610,7 @@ wtap_dumper* wtap_dump_fdopen_ng(int fd, int filetype, int encap, int snaplen,
        }
        wdh->fh = fh;
 
        }
        wdh->fh = fh;
 
-       if (!wtap_dump_open_finish(wdh, filetype, compressed, err)) {
+       if (!wtap_dump_open_finish(wdh, file_type_subtype, compressed, err)) {
                wtap_dump_file_close(wdh);
                g_free(wdh);
                return NULL;
                wtap_dump_file_close(wdh);
                g_free(wdh);
                return NULL;
@@ -1618,9 +1618,9 @@ wtap_dumper* wtap_dump_fdopen_ng(int fd, int filetype, int encap, int snaplen,
        return wdh;
 }
 
        return wdh;
 }
 
-static gboolean wtap_dump_open_check(int filetype, int encap, gboolean compressed, int *err)
+static gboolean wtap_dump_open_check(int file_type_subtype, int encap, gboolean compressed, int *err)
 {
 {
-       if (!wtap_dump_can_open(filetype)) {
+       if (!wtap_dump_can_open(file_type_subtype)) {
                /* Invalid type, or type we don't know how to write. */
                *err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
                return FALSE;
                /* Invalid type, or type we don't know how to write. */
                *err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
                return FALSE;
@@ -1628,17 +1628,17 @@ static gboolean wtap_dump_open_check(int filetype, int encap, gboolean compresse
 
        /* OK, we know how to write that type; can we write the specified
           encapsulation type? */
 
        /* OK, we know how to write that type; can we write the specified
           encapsulation type? */
-       *err = (*dump_open_table[filetype].can_write_encap)(encap);
+       *err = (*dump_open_table[file_type_subtype].can_write_encap)(encap);
        if (*err != 0)
                return FALSE;
 
        if (*err != 0)
                return FALSE;
 
-       /* if compression is wanted, do we support this for this filetype? */
-       if(compressed && !wtap_dump_can_compress(filetype)) {
+       /* if compression is wanted, do we support this for this file_type_subtype? */
+       if(compressed && !wtap_dump_can_compress(file_type_subtype)) {
                *err = WTAP_ERR_COMPRESSION_NOT_SUPPORTED;
                return FALSE;
        }
 
                *err = WTAP_ERR_COMPRESSION_NOT_SUPPORTED;
                return FALSE;
        }
 
-       *err = (*dump_open_table[filetype].can_write_encap)(encap);
+       *err = (*dump_open_table[file_type_subtype].can_write_encap)(encap);
        if (*err != 0)
                return FALSE;
 
        if (*err != 0)
                return FALSE;
 
@@ -1646,7 +1646,7 @@ static gboolean wtap_dump_open_check(int filetype, int encap, gboolean compresse
        return TRUE;
 }
 
        return TRUE;
 }
 
-static wtap_dumper* wtap_dump_alloc_wdh(int filetype, int encap, int snaplen,
+static wtap_dumper* wtap_dump_alloc_wdh(int file_type_subtype, int encap, int snaplen,
                                        gboolean compressed, int *err)
 {
        wtap_dumper *wdh;
                                        gboolean compressed, int *err)
 {
        wtap_dumper *wdh;
@@ -1657,14 +1657,14 @@ static wtap_dumper* wtap_dump_alloc_wdh(int filetype, int encap, int snaplen,
                return NULL;
        }
 
                return NULL;
        }
 
-       wdh->file_type = filetype;
+       wdh->file_type_subtype = file_type_subtype;
        wdh->snaplen = snaplen;
        wdh->encap = encap;
        wdh->compressed = compressed;
        return wdh;
 }
 
        wdh->snaplen = snaplen;
        wdh->encap = encap;
        wdh->compressed = compressed;
        return wdh;
 }
 
-static gboolean wtap_dump_open_finish(wtap_dumper *wdh, int filetype, gboolean compressed, int *err)
+static gboolean wtap_dump_open_finish(wtap_dumper *wdh, int file_type_subtype, gboolean compressed, int *err)
 {
        int fd;
        gboolean cant_seek;
 {
        int fd;
        gboolean cant_seek;
@@ -1685,13 +1685,13 @@ static gboolean wtap_dump_open_finish(wtap_dumper *wdh, int filetype, gboolean c
        }
 
        /* If this file type requires seeking, and we can't seek, fail. */
        }
 
        /* If this file type requires seeking, and we can't seek, fail. */
-       if (dump_open_table[filetype].writing_must_seek && cant_seek) {
+       if (dump_open_table[file_type_subtype].writing_must_seek && cant_seek) {
                *err = WTAP_ERR_CANT_WRITE_TO_PIPE;
                return FALSE;
        }
 
        /* Now try to open the file for writing. */
                *err = WTAP_ERR_CANT_WRITE_TO_PIPE;
                return FALSE;
        }
 
        /* Now try to open the file for writing. */
-       if (!(*dump_open_table[filetype].dump_open)(wdh, err)) {
+       if (!(*dump_open_table[file_type_subtype].dump_open)(wdh, err)) {
                return FALSE;
        }
 
                return FALSE;
        }
 
@@ -1760,8 +1760,8 @@ void wtap_set_bytes_dumped(wtap_dumper *wdh, gint64 bytes_dumped)
 
 gboolean wtap_dump_set_addrinfo_list(wtap_dumper *wdh, addrinfo_lists_t *addrinfo_lists)
 {
 
 gboolean wtap_dump_set_addrinfo_list(wtap_dumper *wdh, addrinfo_lists_t *addrinfo_lists)
 {
-       if (!wdh || wdh->file_type < 0 || wdh->file_type >= wtap_num_file_types
-               || dump_open_table[wdh->file_type].has_name_resolution == FALSE)
+       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;
        wdh->addrinfo_lists = addrinfo_lists;
        return TRUE;
                        return FALSE;
        wdh->addrinfo_lists = addrinfo_lists;
        return TRUE;
index 1d77389b8234595cd8ee4ab4e9ef272e9529b2c4..6530a1207a697e83f20f2c419b33af99b728e7f1 100644 (file)
@@ -124,7 +124,7 @@ int hcidump_open(wtap *wth, int *err, gchar **err_info)
        if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
                return -1;
 
        if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
                return -1;
 
-       wth->file_type = WTAP_FILE_HCIDUMP;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_HCIDUMP;
        wth->file_encap = WTAP_ENCAP_BLUETOOTH_H4_WITH_PHDR;
        wth->snapshot_length = 0;
 
        wth->file_encap = WTAP_ENCAP_BLUETOOTH_H4_WITH_PHDR;
        wth->snapshot_length = 0;
 
index b41192233327cc520746f1d1c7417d23cc9a52e7..ccdce4db12d1c36b23ec7bdce073c180aa68270d 100644 (file)
@@ -97,7 +97,7 @@ int i4btrace_open(wtap *wth, int *err, gchar **err_info)
 
        /* Get capture start time */
 
 
        /* Get capture start time */
 
-       wth->file_type = WTAP_FILE_I4BTRACE;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_I4BTRACE;
        i4btrace = (i4btrace_t *)g_malloc(sizeof(i4btrace_t));
        wth->priv = (void *)i4btrace;
        wth->subtype_read = i4btrace_read;
        i4btrace = (i4btrace_t *)g_malloc(sizeof(i4btrace_t));
        wth->priv = (void *)i4btrace;
        wth->subtype_read = i4btrace_read;
index fbba7db7fe5532442b2b2705d7ab2bf2c53072f1..53ffa032e74041513739583b09661bf367dca96c 100644 (file)
@@ -271,7 +271,7 @@ ipfix_open(wtap *wth, int *err, gchar **err_info)
     wth->subtype_read = ipfix_read;
     wth->subtype_seek_read = ipfix_seek_read;
     wth->subtype_close = ipfix_close;
     wth->subtype_read = ipfix_read;
     wth->subtype_seek_read = ipfix_seek_read;
     wth->subtype_close = ipfix_close;
-    wth->file_type = WTAP_FILE_IPFIX;
+    wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_IPFIX;
 
     /* go back to beginning of file */
     if (file_seek (wth->fh, 0, SEEK_SET, err) != 0)
 
     /* go back to beginning of file */
     if (file_seek (wth->fh, 0, SEEK_SET, err) != 0)
index 5d3ea6b6faac67913bdd7f46e5d189aa7190fc3e..4e5e8d49053eafc63b5051b1bae80fa731fc56fc 100644 (file)
@@ -69,13 +69,13 @@ int iptrace_open(wtap *wth, int *err, gchar **err_info)
        name[11] = '\0';
 
        if (strcmp(name, "iptrace 1.0") == 0) {
        name[11] = '\0';
 
        if (strcmp(name, "iptrace 1.0") == 0) {
-               wth->file_type = WTAP_FILE_IPTRACE_1_0;
+               wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_IPTRACE_1_0;
                wth->subtype_read = iptrace_read_1_0;
                wth->subtype_seek_read = iptrace_seek_read_1_0;
                wth->tsprecision = WTAP_FILE_TSPREC_SEC;
        }
        else if (strcmp(name, "iptrace 2.0") == 0) {
                wth->subtype_read = iptrace_read_1_0;
                wth->subtype_seek_read = iptrace_seek_read_1_0;
                wth->tsprecision = WTAP_FILE_TSPREC_SEC;
        }
        else if (strcmp(name, "iptrace 2.0") == 0) {
-               wth->file_type = WTAP_FILE_IPTRACE_2_0;
+               wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_IPTRACE_2_0;
                wth->subtype_read = iptrace_read_2_0;
                wth->subtype_seek_read = iptrace_seek_read_2_0;
                wth->tsprecision = WTAP_FILE_TSPREC_NSEC;
                wth->subtype_read = iptrace_read_2_0;
                wth->subtype_seek_read = iptrace_seek_read_2_0;
                wth->tsprecision = WTAP_FILE_TSPREC_NSEC;
index 4136008d03e5b259529ab25234fc037c0b0a1de4..fafb4393c0c5c1f70cca4005d07e83080715144b 100644 (file)
@@ -247,7 +247,7 @@ iseries_open (wtap * wth, int *err, gchar ** err_info)
           }
 
         wth->file_encap        = WTAP_ENCAP_ETHERNET;
           }
 
         wth->file_encap        = WTAP_ENCAP_ETHERNET;
-        wth->file_type         = WTAP_FILE_ISERIES;
+        wth->file_type_subtype         = WTAP_FILE_TYPE_SUBTYPE_ISERIES;
         wth->snapshot_length   = 0;
         wth->subtype_read      = iseries_read;
         wth->subtype_seek_read = iseries_seek_read;
         wth->snapshot_length   = 0;
         wth->subtype_read      = iseries_read;
         wth->subtype_seek_read = iseries_seek_read;
@@ -287,7 +287,7 @@ iseries_open (wtap * wth, int *err, gchar ** err_info)
               }
 
             wth->file_encap        = WTAP_ENCAP_ETHERNET;
               }
 
             wth->file_encap        = WTAP_ENCAP_ETHERNET;
-            wth->file_type         = WTAP_FILE_ISERIES;
+            wth->file_type_subtype         = WTAP_FILE_TYPE_SUBTYPE_ISERIES;
             wth->snapshot_length   = 0;
             wth->subtype_read      = iseries_read;
             wth->subtype_seek_read = iseries_seek_read;
             wth->snapshot_length   = 0;
             wth->subtype_read      = iseries_read;
             wth->subtype_seek_read = iseries_seek_read;
index 4268119161e0464b5ae23775e0038c317512b3f4..8bca6903461a6a503b8e9faf457b9f11f26b3230 100644 (file)
@@ -754,7 +754,7 @@ int k12_open(wtap *wth, int *err, gchar **err_info) {
         }
     } while(1);
 
         }
     } while(1);
 
-    wth->file_type = WTAP_FILE_K12;
+    wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_K12;
     wth->file_encap = WTAP_ENCAP_K12;
     wth->snapshot_length = 0;
     wth->subtype_read = k12_read;
     wth->file_encap = WTAP_ENCAP_K12;
     wth->snapshot_length = 0;
     wth->subtype_read = k12_read;
index 7e28f781b565e754c5b829e7ca6c1c18541fae2f..24cc279e90109af8537d14b2cb866e17c51190a0 100644 (file)
@@ -347,12 +347,12 @@ k12text_open(wtap *wth, int *err, gchar **err_info _U_)
        k12text = (k12text_t *)g_malloc(sizeof(k12text_t));
        wth->priv = (void *)k12text;
        k12text->next_frame_offset = 0;
        k12text = (k12text_t *)g_malloc(sizeof(k12text_t));
        wth->priv = (void *)k12text;
        k12text->next_frame_offset = 0;
-       wth->file_type = WTAP_FILE_K12TEXT;
+       wth->file_type = WTAP_FILE_TYPE_SUBTYPE_K12TEXT;
        wth->file_encap = WTAP_ENCAP_PER_PACKET;
        wth->snapshot_length = 0;
        wth->subtype_read = k12text_read;
        wth->subtype_seek_read = k12text_seek_read;
        wth->file_encap = WTAP_ENCAP_PER_PACKET;
        wth->snapshot_length = 0;
        wth->subtype_read = k12text_read;
        wth->subtype_seek_read = k12text_seek_read;
-       wth->tsprecision = WTAP_FILE_TSPREC_NSEC;
+       wth->tsprecision = WTAP_FILE_TYPE_SUBTYPE_TSPREC_NSEC;
 
        return 1;
 }
 
        return 1;
 }
index 0da1462c219dbc7015949a3d302949d8c6edab01..5c4b9002f47470d504a50dca96bb66c71667555f 100644 (file)
@@ -342,7 +342,7 @@ int lanalyzer_open(wtap *wth, int *err, gchar **err_info)
        /* If we made it this far, then the file is a LANAlyzer file.
         * Let's get some info from it. Note that we get wth->snapshot_length
         * from a record later in the file. */
        /* If we made it this far, then the file is a LANAlyzer file.
         * Let's get some info from it. Note that we get wth->snapshot_length
         * from a record later in the file. */
-       wth->file_type = WTAP_FILE_LANALYZER;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_LANALYZER;
        lanalyzer = (lanalyzer_t *)g_malloc(sizeof(lanalyzer_t));
        wth->priv = (void *)lanalyzer;
        wth->subtype_read = lanalyzer_read;
        lanalyzer = (lanalyzer_t *)g_malloc(sizeof(lanalyzer_t));
        wth->priv = (void *)lanalyzer;
        wth->subtype_read = lanalyzer_read;
index 6a64c3d1e605ca38081908b6e593ae7871bcf0d4..907f2311f928bb94660cd64d327fc9434c1d3928 100644 (file)
@@ -310,7 +310,7 @@ int libpcap_open(wtap *wth, int *err, gchar **err_info)
                 * and for the ERF link-layer header type, and set the
                 * precision to nanosecond precision.
                 */
                 * and for the ERF link-layer header type, and set the
                 * precision to nanosecond precision.
                 */
-               wth->file_type = WTAP_FILE_PCAP_AIX;
+               wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PCAP_AIX;
                wth->tsprecision = WTAP_FILE_TSPREC_NSEC;
                return 1;
        }
                wth->tsprecision = WTAP_FILE_TSPREC_NSEC;
                return 1;
        }
@@ -355,7 +355,7 @@ int libpcap_open(wtap *wth, int *err, gchar **err_info)
                 *
                 * Try ss991029, the last of his patches, first.
                 */
                 *
                 * Try ss991029, the last of his patches, first.
                 */
-               wth->file_type = WTAP_FILE_PCAP_SS991029;
+               wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PCAP_SS991029;
                first_packet_offset = file_tell(wth->fh);
                switch (libpcap_try(wth, err)) {
 
                first_packet_offset = file_tell(wth->fh);
                switch (libpcap_try(wth, err)) {
 
@@ -390,7 +390,7 @@ int libpcap_open(wtap *wth, int *err, gchar **err_info)
                 * so we put the seek pointer back and treat
                 * it as 990915.
                 */
                 * so we put the seek pointer back and treat
                 * it as 990915.
                 */
-               wth->file_type = WTAP_FILE_PCAP_SS990915;
+               wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990915;
                if (file_seek(wth->fh, first_packet_offset, SEEK_SET, err) == -1) {
                        return -1;
                }
                if (file_seek(wth->fh, first_packet_offset, SEEK_SET, err) == -1) {
                        return -1;
                }
@@ -401,9 +401,9 @@ int libpcap_open(wtap *wth, int *err, gchar **err_info)
                 * Try the standard format first.
                 */
                if(wth->tsprecision == WTAP_FILE_TSPREC_NSEC) {
                 * Try the standard format first.
                 */
                if(wth->tsprecision == WTAP_FILE_TSPREC_NSEC) {
-                       wth->file_type = WTAP_FILE_PCAP_NSEC;
+                       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PCAP_NSEC;
                } else {
                } else {
-                       wth->file_type = WTAP_FILE_PCAP;
+                       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PCAP;
                }
                first_packet_offset = file_tell(wth->fh);
                switch (libpcap_try(wth, err)) {
                }
                first_packet_offset = file_tell(wth->fh);
                switch (libpcap_try(wth, err)) {
@@ -438,7 +438,7 @@ int libpcap_open(wtap *wth, int *err, gchar **err_info)
                 * a standard file.  Put the seek pointer back and try
                 * ss990417.
                 */
                 * a standard file.  Put the seek pointer back and try
                 * ss990417.
                 */
-               wth->file_type = WTAP_FILE_PCAP_SS990417;
+               wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990417;
                if (file_seek(wth->fh, first_packet_offset, SEEK_SET, err) == -1) {
                        return -1;
                }
                if (file_seek(wth->fh, first_packet_offset, SEEK_SET, err) == -1) {
                        return -1;
                }
@@ -475,7 +475,7 @@ int libpcap_open(wtap *wth, int *err, gchar **err_info)
                 * to try after that, so we put the seek pointer back
                 * and treat it as a Nokia file.
                 */
                 * to try after that, so we put the seek pointer back
                 * and treat it as a Nokia file.
                 */
-               wth->file_type = WTAP_FILE_PCAP_NOKIA;
+               wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA;
                if (file_seek(wth->fh, first_packet_offset, SEEK_SET, err) == -1) {
                        return -1;
                }
                if (file_seek(wth->fh, first_packet_offset, SEEK_SET, err) == -1) {
                        return -1;
                }
@@ -491,7 +491,7 @@ done:
         * If this is a Nokia capture, treat 13 as WTAP_ENCAP_ATM_PDUS,
         * rather than as what we normally treat it.
         */
         * If this is a Nokia capture, treat 13 as WTAP_ENCAP_ATM_PDUS,
         * rather than as what we normally treat it.
         */
-       if (wth->file_type == WTAP_FILE_PCAP_NOKIA && hdr.network == 13)
+       if (wth->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA && hdr.network == 13)
                wth->file_encap = WTAP_ENCAP_ATM_PDUS;
 
        if (wth->file_encap == WTAP_ENCAP_ERF) {
                wth->file_encap = WTAP_ENCAP_ATM_PDUS;
 
        if (wth->file_encap == WTAP_ENCAP_ERF) {
@@ -644,7 +644,7 @@ libpcap_read_packet(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
         * AIX appears to put 3 bytes of padding in front of FDDI
         * frames; strip that crap off.
         */
         * AIX appears to put 3 bytes of padding in front of FDDI
         * frames; strip that crap off.
         */
-       if (wth->file_type == WTAP_FILE_PCAP_AIX &&
+       if (wth->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_PCAP_AIX &&
            (wth->file_encap == WTAP_ENCAP_FDDI ||
             wth->file_encap == WTAP_ENCAP_FDDI_BITSWAPPED)) {
                /*
            (wth->file_encap == WTAP_ENCAP_FDDI ||
             wth->file_encap == WTAP_ENCAP_FDDI_BITSWAPPED)) {
                /*
@@ -661,7 +661,7 @@ libpcap_read_packet(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
                        return FALSE;
        }
 
                        return FALSE;
        }
 
-       phdr_len = pcap_process_pseudo_header(fh, wth->file_type,
+       phdr_len = pcap_process_pseudo_header(fh, wth->file_type_subtype,
            wth->file_encap, packet_size, TRUE, phdr, err, err_info);
        if (phdr_len < 0)
                return FALSE;   /* error */
            wth->file_encap, packet_size, TRUE, phdr, err, err_info);
        if (phdr_len < 0)
                return FALSE;   /* error */
@@ -696,7 +696,7 @@ libpcap_read_packet(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
                return FALSE;   /* failed */
 
        libpcap = (libpcap_t *)wth->priv;
                return FALSE;   /* failed */
 
        libpcap = (libpcap_t *)wth->priv;
-       pcap_read_post_process(wth->file_type, wth->file_encap,
+       pcap_read_post_process(wth->file_type_subtype, wth->file_encap,
            &phdr->pseudo_header, buffer_start_ptr(buf), packet_size,
            libpcap->byte_swapped, -1);
        return TRUE;
            &phdr->pseudo_header, buffer_start_ptr(buf), packet_size,
            libpcap->byte_swapped, -1);
        return TRUE;
@@ -712,24 +712,24 @@ static int libpcap_read_header(wtap *wth, FILE_T fh, int *err, gchar **err_info,
 
        /* Read record header. */
        errno = WTAP_ERR_CANT_READ;
 
        /* Read record header. */
        errno = WTAP_ERR_CANT_READ;
-       switch (wth->file_type) {
+       switch (wth->file_type_subtype) {
 
 
-       case WTAP_FILE_PCAP:
-       case WTAP_FILE_PCAP_AIX:
-       case WTAP_FILE_PCAP_NSEC:
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP:
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_AIX:
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_NSEC:
                bytes_to_read = sizeof (struct pcaprec_hdr);
                break;
 
                bytes_to_read = sizeof (struct pcaprec_hdr);
                break;
 
-       case WTAP_FILE_PCAP_SS990417:
-       case WTAP_FILE_PCAP_SS991029:
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990417:
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_SS991029:
                bytes_to_read = sizeof (struct pcaprec_modified_hdr);
                break;
 
                bytes_to_read = sizeof (struct pcaprec_modified_hdr);
                break;
 
-       case WTAP_FILE_PCAP_SS990915:
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990915:
                bytes_to_read = sizeof (struct pcaprec_ss990915_hdr);
                break;
 
                bytes_to_read = sizeof (struct pcaprec_ss990915_hdr);
                break;
 
-       case WTAP_FILE_PCAP_NOKIA:
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA:
                bytes_to_read = sizeof (struct pcaprec_nokia_hdr);
                break;
 
                bytes_to_read = sizeof (struct pcaprec_nokia_hdr);
                break;
 
@@ -848,22 +848,22 @@ gboolean libpcap_dump_open(wtap_dumper *wdh, int *err)
        wdh->subtype_close = NULL;
 
        /* Write the file header. */
        wdh->subtype_close = NULL;
 
        /* Write the file header. */
-       switch (wdh->file_type) {
+       switch (wdh->file_type_subtype) {
 
 
-       case WTAP_FILE_PCAP:
-       case WTAP_FILE_PCAP_SS990417:   /* modified, but with the old magic, sigh */
-       case WTAP_FILE_PCAP_NOKIA:      /* Nokia libpcap of some sort */
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP:
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990417:      /* modified, but with the old magic, sigh */
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA: /* Nokia libpcap of some sort */
                magic = PCAP_MAGIC;
                wdh->tsprecision = WTAP_FILE_TSPREC_USEC;
                break;
 
                magic = PCAP_MAGIC;
                wdh->tsprecision = WTAP_FILE_TSPREC_USEC;
                break;
 
-       case WTAP_FILE_PCAP_SS990915:   /* new magic, extra crap */
-       case WTAP_FILE_PCAP_SS991029:
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990915:      /* new magic, extra crap */
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_SS991029:
                magic = PCAP_MODIFIED_MAGIC;
                wdh->tsprecision = WTAP_FILE_TSPREC_USEC;
                break;
 
                magic = PCAP_MODIFIED_MAGIC;
                wdh->tsprecision = WTAP_FILE_TSPREC_USEC;
                break;
 
-       case WTAP_FILE_PCAP_NSEC:               /* same as WTAP_FILE_PCAP, but nsec precision */
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_NSEC:          /* same as WTAP_FILE_TYPE_SUBTYPE_PCAP, but nsec precision */
                magic = PCAP_NSEC_MAGIC;
                wdh->tsprecision = WTAP_FILE_TSPREC_NSEC;
                break;
                magic = PCAP_NSEC_MAGIC;
                wdh->tsprecision = WTAP_FILE_TSPREC_NSEC;
                break;
@@ -932,15 +932,15 @@ static gboolean libpcap_dump(wtap_dumper *wdh,
                return FALSE;
        }
 
                return FALSE;
        }
 
-       switch (wdh->file_type) {
+       switch (wdh->file_type_subtype) {
 
 
-       case WTAP_FILE_PCAP:
-       case WTAP_FILE_PCAP_NSEC:
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP:
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_NSEC:
                hdr_size = sizeof (struct pcaprec_hdr);
                break;
 
                hdr_size = sizeof (struct pcaprec_hdr);
                break;
 
-       case WTAP_FILE_PCAP_SS990417:   /* modified, but with the old magic, sigh */
-       case WTAP_FILE_PCAP_SS991029:
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990417:      /* modified, but with the old magic, sigh */
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_SS991029:
                /* XXX - what should we supply here?
 
                   Alexey's "libpcap" looks up the interface in the system's
                /* XXX - what should we supply here?
 
                   Alexey's "libpcap" looks up the interface in the system's
@@ -966,7 +966,7 @@ static gboolean libpcap_dump(wtap_dumper *wdh,
                hdr_size = sizeof (struct pcaprec_modified_hdr);
                break;
 
                hdr_size = sizeof (struct pcaprec_modified_hdr);
                break;
 
-       case WTAP_FILE_PCAP_SS990915:   /* new magic, extra crap at the end */
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990915:      /* new magic, extra crap at the end */
                rec_hdr.ifindex = 0;
                rec_hdr.protocol = 0;
                rec_hdr.pkt_type = 0;
                rec_hdr.ifindex = 0;
                rec_hdr.protocol = 0;
                rec_hdr.pkt_type = 0;
@@ -975,7 +975,7 @@ static gboolean libpcap_dump(wtap_dumper *wdh,
                hdr_size = sizeof (struct pcaprec_ss990915_hdr);
                break;
 
                hdr_size = sizeof (struct pcaprec_ss990915_hdr);
                break;
 
-       case WTAP_FILE_PCAP_NOKIA:      /* old magic, extra crap at the end */
+       case WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA: /* old magic, extra crap at the end */
                /* restore the "mysterious stuff" that came with the packet */
                memcpy(&rec_hdr.ifindex, pseudo_header->nokia.stuff, 4);
                /* not written */
                /* restore the "mysterious stuff" that came with the packet */
                memcpy(&rec_hdr.ifindex, pseudo_header->nokia.stuff, 4);
                /* not written */
index 7265bc02205834093964c94dee340442556a6641..64449e563934c6f468a419d0d929bf9ee3332606 100644 (file)
@@ -193,7 +193,7 @@ mime_file_open(wtap *wth, int *err, gchar **err_info)
        if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
                return -1;
 
        if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
                return -1;
 
-       wth->file_type = WTAP_FILE_MIME;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_MIME;
        wth->file_encap = WTAP_ENCAP_MIME;
        wth->tsprecision = WTAP_FILE_TSPREC_SEC;
        wth->subtype_read = mime_read;
        wth->file_encap = WTAP_ENCAP_MIME;
        wth->tsprecision = WTAP_FILE_TSPREC_SEC;
        wth->subtype_read = mime_read;
index 5aafab145912a28c5cf0d017bdb6409552b431ce..345aae6b949df76f3e1091cfec0a739ac905b081 100644 (file)
@@ -229,7 +229,7 @@ mp2t_open(wtap *wth, int *err, gchar **err_info)
         return -1;
     }
 
         return -1;
     }
 
-    wth->file_type = WTAP_FILE_MPEG_2_TS;
+    wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_MPEG_2_TS;
     wth->file_encap = WTAP_ENCAP_MPEG_2_TS;
     wth->tsprecision = WTAP_FILE_TSPREC_NSEC;
     wth->subtype_read = mp2t_read;
     wth->file_encap = WTAP_ENCAP_MPEG_2_TS;
     wth->tsprecision = WTAP_FILE_TSPREC_NSEC;
     wth->subtype_read = mp2t_read;
index f8d1abc632e9c0bafb0a4652518489c3f8c167bc..2f93292f4410b545777a3e37460def8904b9c435 100644 (file)
@@ -268,7 +268,7 @@ good_magic:
        if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
                return -1;
 
        if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
                return -1;
 
-       wth->file_type = WTAP_FILE_MPEG;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_MPEG;
        wth->file_encap = WTAP_ENCAP_MPEG;
        wth->tsprecision = WTAP_FILE_TSPREC_NSEC;
        wth->subtype_read = mpeg_read;
        wth->file_encap = WTAP_ENCAP_MPEG;
        wth->tsprecision = WTAP_FILE_TSPREC_NSEC;
        wth->subtype_read = mpeg_read;
index 9223b78dbd443be12db247518fa9a9769b2c884a..bc30ef136bbb56327f9b4f1643f30951d1e15379 100644 (file)
@@ -236,11 +236,11 @@ int netmon_open(wtap *wth, int *err, gchar **err_info)
        switch (hdr.ver_major) {
 
        case 1:
        switch (hdr.ver_major) {
 
        case 1:
-               file_type = WTAP_FILE_NETMON_1_x;
+               file_type = WTAP_FILE_TYPE_SUBTYPE_NETMON_1_x;
                break;
 
        case 2:
                break;
 
        case 2:
-               file_type = WTAP_FILE_NETMON_2_x;
+               file_type = WTAP_FILE_TYPE_SUBTYPE_NETMON_2_x;
                break;
 
        default:
                break;
 
        default:
@@ -259,7 +259,7 @@ int netmon_open(wtap *wth, int *err, gchar **err_info)
        }
 
        /* This is a netmon file */
        }
 
        /* This is a netmon file */
-       wth->file_type = file_type;
+       wth->file_type_subtype = file_type;
        netmon = (netmon_t *)g_malloc(sizeof(netmon_t));
        wth->priv = (void *)netmon;
        wth->subtype_read = netmon_read;
        netmon = (netmon_t *)g_malloc(sizeof(netmon_t));
        wth->priv = (void *)netmon;
        wth->subtype_read = netmon_read;
@@ -1108,9 +1108,9 @@ static gboolean netmon_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
                nsecs += 1000000000;
                secs--;
        }
                nsecs += 1000000000;
                secs--;
        }
-       switch (wdh->file_type) {
+       switch (wdh->file_type_subtype) {
 
 
-       case WTAP_FILE_NETMON_1_x:
+       case WTAP_FILE_TYPE_SUBTYPE_NETMON_1_x:
                rec_1_x_hdr.ts_delta = htolel(secs*1000 + (nsecs + 500000)/1000000);
                rec_1_x_hdr.orig_len = htoles(phdr->len + atm_hdrsize);
                rec_1_x_hdr.incl_len = htoles(phdr->caplen + atm_hdrsize);
                rec_1_x_hdr.ts_delta = htolel(secs*1000 + (nsecs + 500000)/1000000);
                rec_1_x_hdr.orig_len = htoles(phdr->len + atm_hdrsize);
                rec_1_x_hdr.incl_len = htoles(phdr->caplen + atm_hdrsize);
@@ -1118,7 +1118,7 @@ static gboolean netmon_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
                hdr_size = sizeof rec_1_x_hdr;
                break;
 
                hdr_size = sizeof rec_1_x_hdr;
                break;
 
-       case WTAP_FILE_NETMON_2_x:
+       case WTAP_FILE_TYPE_SUBTYPE_NETMON_2_x:
                rec_2_x_hdr.ts_delta = htolell(secs*1000000 + (nsecs + 500)/1000);
                rec_2_x_hdr.orig_len = htolel(phdr->len + atm_hdrsize);
                rec_2_x_hdr.incl_len = htolel(phdr->caplen + atm_hdrsize);
                rec_2_x_hdr.ts_delta = htolell(secs*1000000 + (nsecs + 500)/1000);
                rec_2_x_hdr.orig_len = htolel(phdr->len + atm_hdrsize);
                rec_2_x_hdr.incl_len = htolel(phdr->caplen + atm_hdrsize);
@@ -1244,9 +1244,9 @@ static gboolean netmon_dump_close(wtap_dumper *wdh, int *err)
        if (wtap_dump_file_seek(wdh, 0, SEEK_SET, err) == -1)
                return FALSE;
        memset(&file_hdr, '\0', sizeof file_hdr);
        if (wtap_dump_file_seek(wdh, 0, SEEK_SET, err) == -1)
                return FALSE;
        memset(&file_hdr, '\0', sizeof file_hdr);
-       switch (wdh->file_type) {
+       switch (wdh->file_type_subtype) {
 
 
-       case WTAP_FILE_NETMON_1_x:
+       case WTAP_FILE_TYPE_SUBTYPE_NETMON_1_x:
                magicp = netmon_1_x_magic;
                magic_size = sizeof netmon_1_x_magic;
                /* NetMon file version, for 1.x, is 1.1 */
                magicp = netmon_1_x_magic;
                magic_size = sizeof netmon_1_x_magic;
                /* NetMon file version, for 1.x, is 1.1 */
@@ -1254,7 +1254,7 @@ static gboolean netmon_dump_close(wtap_dumper *wdh, int *err)
                file_hdr.ver_minor = 1;
                break;
 
                file_hdr.ver_minor = 1;
                break;
 
-       case WTAP_FILE_NETMON_2_x:
+       case WTAP_FILE_TYPE_SUBTYPE_NETMON_2_x:
                magicp = netmon_2_x_magic;
                magic_size = sizeof netmon_2_x_magic;
                /*
                magicp = netmon_2_x_magic;
                magic_size = sizeof netmon_2_x_magic;
                /*
index e55659cd0e44c4cfb571579bb65a54d6d53cd939..ad5039294ed81e6f85b6123c964188d63ab44d9a 100644 (file)
@@ -634,19 +634,19 @@ int nstrace_open(wtap *wth, int *err, gchar **err_info)
     nstrace_buf = (gchar *)g_malloc(NSPR_PAGESIZE);
     page_size = GET_READ_PAGE_SIZE(file_size);
 
     nstrace_buf = (gchar *)g_malloc(NSPR_PAGESIZE);
     page_size = GET_READ_PAGE_SIZE(file_size);
 
-    switch ((wth->file_type = nspm_signature_version(wth, nstrace_buf, page_size)))
+    switch ((wth->file_type_subtype = nspm_signature_version(wth, nstrace_buf, page_size)))
     {
     {
-    case WTAP_FILE_NETSCALER_1_0:
+    case WTAP_FILE_TYPE_SUBTYPE_NETSCALER_1_0:
         wth->file_encap = WTAP_ENCAP_NSTRACE_1_0;
         break;
 
         wth->file_encap = WTAP_ENCAP_NSTRACE_1_0;
         break;
 
-    case WTAP_FILE_NETSCALER_2_0:
+    case WTAP_FILE_TYPE_SUBTYPE_NETSCALER_2_0:
         wth->file_encap = WTAP_ENCAP_NSTRACE_2_0;
         break;
 
     default:
         *err = WTAP_ERR_UNSUPPORTED;
         wth->file_encap = WTAP_ENCAP_NSTRACE_2_0;
         break;
 
     default:
         *err = WTAP_ERR_UNSUPPORTED;
-        *err_info = g_strdup_printf("nstrace: file type %d unsupported", wth->file_type);
+        *err_info = g_strdup_printf("nstrace: file type %d unsupported", wth->file_type_subtype);
         g_free(nstrace_buf);
         return 0;
     }
         g_free(nstrace_buf);
         return 0;
     }
@@ -668,14 +668,14 @@ int nstrace_open(wtap *wth, int *err, gchar **err_info)
         return 0;
     }
 
         return 0;
     }
 
-    switch (wth->file_type)
+    switch (wth->file_type_subtype)
     {
     {
-    case WTAP_FILE_NETSCALER_1_0:
+    case WTAP_FILE_TYPE_SUBTYPE_NETSCALER_1_0:
         wth->subtype_read = nstrace_read_v10;
         wth->subtype_seek_read = nstrace_seek_read_v10;
         break;
 
         wth->subtype_read = nstrace_read_v10;
         wth->subtype_seek_read = nstrace_seek_read_v10;
         break;
 
-    case WTAP_FILE_NETSCALER_2_0:
+    case WTAP_FILE_TYPE_SUBTYPE_NETSCALER_2_0:
         wth->subtype_read = nstrace_read_v20;
         wth->subtype_seek_read = nstrace_seek_read_v20;
         break;
         wth->subtype_read = nstrace_read_v20;
         wth->subtype_seek_read = nstrace_seek_read_v20;
         break;
@@ -760,7 +760,7 @@ nspm_signature_version(wtap *wth, gchar *nstrace_buf, gint32 len)
                 (pletohs(&sigv10p->nsprRecordSize) <= len) &&
                 ((gint32)sizeof(NSPR_SIGSTR_V10) <= len) &&
                 (!nspm_signature_isv10(sigv10p->sig_Signature)))
                 (pletohs(&sigv10p->nsprRecordSize) <= len) &&
                 ((gint32)sizeof(NSPR_SIGSTR_V10) <= len) &&
                 (!nspm_signature_isv10(sigv10p->sig_Signature)))
-                return WTAP_FILE_NETSCALER_1_0;
+                return WTAP_FILE_TYPE_SUBTYPE_NETSCALER_1_0;
 #undef    sigv10p
 
 #define sigv20p    ((nspr_signature_v20_t*)dp)
 #undef    sigv10p
 
 #define sigv20p    ((nspr_signature_v20_t*)dp)
@@ -768,7 +768,7 @@ nspm_signature_version(wtap *wth, gchar *nstrace_buf, gint32 len)
                 (sigv20p->sig_RecordSize <= len) &&
                 ((gint32)sizeof(NSPR_SIGSTR_V20) <= len) &&
                 (!nspm_signature_isv20(sigv20p->sig_Signature)))
                 (sigv20p->sig_RecordSize <= len) &&
                 ((gint32)sizeof(NSPR_SIGSTR_V20) <= len) &&
                 (!nspm_signature_isv20(sigv20p->sig_Signature)))
-                return WTAP_FILE_NETSCALER_2_0;
+                return WTAP_FILE_TYPE_SUBTYPE_NETSCALER_2_0;
 #undef    sigv20p
         }
     }
 #undef    sigv20p
         }
     }
@@ -835,9 +835,9 @@ nstrace_set_start_time_ver(20)
 */
 static gboolean nstrace_set_start_time(wtap *wth)
 {
 */
 static gboolean nstrace_set_start_time(wtap *wth)
 {
-    if (wth->file_type == WTAP_FILE_NETSCALER_1_0)
+    if (wth->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_NETSCALER_1_0)
         return nstrace_set_start_time_v10(wth);
         return nstrace_set_start_time_v10(wth);
-    else if (wth->file_type == WTAP_FILE_NETSCALER_2_0)
+    else if (wth->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_NETSCALER_2_0)
         return nstrace_set_start_time_v20(wth);
 
     return FALSE;
         return nstrace_set_start_time_v20(wth);
 
     return FALSE;
@@ -1346,7 +1346,7 @@ static gboolean nstrace_add_signature(wtap_dumper *wdh, int *err)
 {
     nstrace_dump_t *nstrace = (nstrace_dump_t *)wdh->priv;
 
 {
     nstrace_dump_t *nstrace = (nstrace_dump_t *)wdh->priv;
 
-    if (wdh->file_type == WTAP_FILE_NETSCALER_1_0)
+    if (wdh->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_NETSCALER_1_0)
     {
         guint16 val16b;
         nspr_signature_v10_t sig10;
     {
         guint16 val16b;
         nspr_signature_v10_t sig10;
@@ -1367,7 +1367,7 @@ static gboolean nstrace_add_signature(wtap_dumper *wdh, int *err)
         /* Move forward the page offset */
         nstrace->page_offset += (guint16) nspr_signature_v10_s;
 
         /* Move forward the page offset */
         nstrace->page_offset += (guint16) nspr_signature_v10_s;
 
-    } else if (wdh->file_type == WTAP_FILE_NETSCALER_2_0)
+    } else if (wdh->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_NETSCALER_2_0)
     {
         nspr_signature_v20_t sig20;
 
     {
         nspr_signature_v20_t sig20;
 
@@ -1400,7 +1400,7 @@ nstrace_add_abstime(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
     nstrace_dump_t *nstrace = (nstrace_dump_t *)wdh->priv;
     guint64 nsg_creltime;
 
     nstrace_dump_t *nstrace = (nstrace_dump_t *)wdh->priv;
     guint64 nsg_creltime;
 
-    if (wdh->file_type == WTAP_FILE_NETSCALER_1_0)
+    if (wdh->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_NETSCALER_1_0)
     {
         guint16 val16;
         guint32 reltime;
     {
         guint16 val16;
         guint32 reltime;
@@ -1427,7 +1427,7 @@ nstrace_add_abstime(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
         /* Move forward the page offset */
         nstrace->page_offset += nspr_abstime_v10_s;
 
         /* Move forward the page offset */
         nstrace->page_offset += nspr_abstime_v10_s;
 
-    } else if (wdh->file_type == WTAP_FILE_NETSCALER_2_0)
+    } else if (wdh->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_NETSCALER_2_0)
     {
         guint32 reltime;
         guint64 abstime;
     {
         guint32 reltime;
         guint64 abstime;
@@ -1470,12 +1470,12 @@ static gboolean nstrace_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
     if (nstrace->page_offset == 0)
     {
         /* Add the signature record and abs time record */
     if (nstrace->page_offset == 0)
     {
         /* Add the signature record and abs time record */
-        if (wdh->file_type == WTAP_FILE_NETSCALER_1_0)
+        if (wdh->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_NETSCALER_1_0)
         {
             if (!nstrace_add_signature(wdh, err) ||
                 !nstrace_add_abstime(wdh, phdr, pd, err))
                 return FALSE;
         {
             if (!nstrace_add_signature(wdh, err) ||
                 !nstrace_add_abstime(wdh, phdr, pd, err))
                 return FALSE;
-        } else if (wdh->file_type == WTAP_FILE_NETSCALER_2_0)
+        } else if (wdh->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_NETSCALER_2_0)
         {
             if (!nstrace_add_signature(wdh, err) ||
                 !nstrace_add_abstime(wdh, phdr, pd, err))
         {
             if (!nstrace_add_signature(wdh, err) ||
                 !nstrace_add_abstime(wdh, phdr, pd, err))
@@ -1491,7 +1491,7 @@ static gboolean nstrace_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
     {
     case NSPR_HEADER_VERSION100:
 
     {
     case NSPR_HEADER_VERSION100:
 
-        if (wdh->file_type == WTAP_FILE_NETSCALER_1_0)
+        if (wdh->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_NETSCALER_1_0)
         {
             if (nstrace->page_offset + phdr->caplen >= nstrace->page_len)
             {
         {
             if (nstrace->page_offset + phdr->caplen >= nstrace->page_len)
             {
@@ -1511,7 +1511,7 @@ static gboolean nstrace_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
                 return FALSE;
 
             nstrace->page_offset += (guint16) phdr->caplen;
                 return FALSE;
 
             nstrace->page_offset += (guint16) phdr->caplen;
-        } else if (wdh->file_type == WTAP_FILE_NETSCALER_2_0)
+        } else if (wdh->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_NETSCALER_2_0)
         {
             *err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
             return FALSE;
         {
             *err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
             return FALSE;
@@ -1526,11 +1526,11 @@ static gboolean nstrace_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
     case NSPR_HEADER_VERSION204:
     case NSPR_HEADER_VERSION205:
     case NSPR_HEADER_VERSION206:
     case NSPR_HEADER_VERSION204:
     case NSPR_HEADER_VERSION205:
     case NSPR_HEADER_VERSION206:
-        if (wdh->file_type == WTAP_FILE_NETSCALER_1_0)
+        if (wdh->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_NETSCALER_1_0)
         {
             *err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
             return FALSE;
         {
             *err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
             return FALSE;
-        } else if (wdh->file_type == WTAP_FILE_NETSCALER_2_0)
+        } else if (wdh->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_NETSCALER_2_0)
         {
             if (nstrace->page_offset + phdr->caplen >= nstrace->page_len)
             {
         {
             if (nstrace->page_offset + phdr->caplen >= nstrace->page_len)
             {
index 3ed5c2303eba45e35bd263a6567641db4e4bbe13..e3970ee40d869e18147b07b2ef5831e1092cc071 100644 (file)
@@ -182,7 +182,7 @@ int netscreen_open(wtap *wth, int *err, gchar **err_info)
                return -1;
 
        wth->file_encap = WTAP_ENCAP_UNKNOWN;
                return -1;
 
        wth->file_encap = WTAP_ENCAP_UNKNOWN;
-       wth->file_type = WTAP_FILE_NETSCREEN;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_NETSCREEN;
        wth->snapshot_length = 0; /* not known */
        wth->subtype_read = netscreen_read;
        wth->subtype_seek_read = netscreen_seek_read;
        wth->snapshot_length = 0; /* not known */
        wth->subtype_read = netscreen_read;
        wth->subtype_seek_read = netscreen_seek_read;
index 4e96499fd75c6b2dd60688a0a4b038a44ecec0d3..07f92828630c8e91612c6c9a8e6a4adae86cd0bd 100644 (file)
@@ -223,7 +223,7 @@ int nettl_open(wtap *wth, int *err, gchar **err_info)
     }
 
     /* This is an nettl file */
     }
 
     /* This is an nettl file */
-    wth->file_type = WTAP_FILE_NETTL;
+    wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_NETTL;
     nettl = g_new(nettl_t,1);
     wth->priv = (void *)nettl;
     if (file_hdr.os_vers[2] == '1' && file_hdr.os_vers[3] == '1')
     nettl = g_new(nettl_t,1);
     wth->priv = (void *)nettl;
     if (file_hdr.os_vers[2] == '1' && file_hdr.os_vers[3] == '1')
index 861470473bc3d4e5d1cc86ae58d4cea28cddb270..eff7fa1bd4507f3eb515113ddb674ee36a765fce 100644 (file)
@@ -251,7 +251,7 @@ int network_instruments_open(wtap *wth, int *err, gchar **err_info)
     wth->subtype_sequential_close = NULL;
     wth->snapshot_length = 0;    /* not available in header */
     wth->tsprecision = WTAP_FILE_TSPREC_NSEC;
     wth->subtype_sequential_close = NULL;
     wth->snapshot_length = 0;    /* not available in header */
     wth->tsprecision = WTAP_FILE_TSPREC_NSEC;
-    wth->file_type = WTAP_FILE_NETWORK_INSTRUMENTS;
+    wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_NETWORK_INSTRUMENTS;
 
     /* reset the pointer to the first packet */
     if (file_seek(wth->fh, header_offset, SEEK_SET, err) == -1)
 
     /* reset the pointer to the first packet */
     if (file_seek(wth->fh, header_offset, SEEK_SET, err) == -1)
index 7b3a3d45c89ae8437405c8a7c8df20bb99fd2420..4dae5932cc4de425db0fda649103ff1bebe123bb 100644 (file)
@@ -408,7 +408,7 @@ int netxray_open(wtap *wth, int *err, gchar **err_info)
        if (is_old) {
                version_major = 0;
                version_minor = 0;
        if (is_old) {
                version_major = 0;
                version_minor = 0;
-               file_type = WTAP_FILE_NETXRAY_OLD;
+               file_type = WTAP_FILE_TYPE_SUBTYPE_NETXRAY_OLD;
        } else {
                /* It appears that version 1.1 files (as produced by Windows
                 * Sniffer Pro 2.0.01) have the time stamp in microseconds,
        } else {
                /* It appears that version 1.1 files (as produced by Windows
                 * Sniffer Pro 2.0.01) have the time stamp in microseconds,
@@ -420,27 +420,27 @@ int netxray_open(wtap *wth, int *err, gchar **err_info)
                if (memcmp(hdr.version, vers_1_0, sizeof vers_1_0) == 0) {
                        version_major = 1;
                        version_minor = 0;
                if (memcmp(hdr.version, vers_1_0, sizeof vers_1_0) == 0) {
                        version_major = 1;
                        version_minor = 0;
-                       file_type = WTAP_FILE_NETXRAY_1_0;
+                       file_type = WTAP_FILE_TYPE_SUBTYPE_NETXRAY_1_0;
                } else if (memcmp(hdr.version, vers_1_1, sizeof vers_1_1) == 0) {
                        version_major = 1;
                        version_minor = 1;
                } else if (memcmp(hdr.version, vers_1_1, sizeof vers_1_1) == 0) {
                        version_major = 1;
                        version_minor = 1;
-                       file_type = WTAP_FILE_NETXRAY_1_1;
+                       file_type = WTAP_FILE_TYPE_SUBTYPE_NETXRAY_1_1;
                } else if (memcmp(hdr.version, vers_2_000, sizeof vers_2_000) == 0) {
                        version_major = 2;
                        version_minor = 0;
                } else if (memcmp(hdr.version, vers_2_000, sizeof vers_2_000) == 0) {
                        version_major = 2;
                        version_minor = 0;
-                       file_type = WTAP_FILE_NETXRAY_2_00x;
+                       file_type = WTAP_FILE_TYPE_SUBTYPE_NETXRAY_2_00x;
                } else if (memcmp(hdr.version, vers_2_001, sizeof vers_2_001) == 0) {
                        version_major = 2;
                        version_minor = 1;
                } else if (memcmp(hdr.version, vers_2_001, sizeof vers_2_001) == 0) {
                        version_major = 2;
                        version_minor = 1;
-                       file_type = WTAP_FILE_NETXRAY_2_00x;
+                       file_type = WTAP_FILE_TYPE_SUBTYPE_NETXRAY_2_00x;
                } else if (memcmp(hdr.version, vers_2_002, sizeof vers_2_002) == 0) {
                        version_major = 2;
                        version_minor = 2;
                } else if (memcmp(hdr.version, vers_2_002, sizeof vers_2_002) == 0) {
                        version_major = 2;
                        version_minor = 2;
-                       file_type = WTAP_FILE_NETXRAY_2_00x;
+                       file_type = WTAP_FILE_TYPE_SUBTYPE_NETXRAY_2_00x;
                } else if (memcmp(hdr.version, vers_2_003, sizeof vers_2_003) == 0) {
                        version_major = 2;
                        version_minor = 3;
                } else if (memcmp(hdr.version, vers_2_003, sizeof vers_2_003) == 0) {
                        version_major = 2;
                        version_minor = 3;
-                       file_type = WTAP_FILE_NETXRAY_2_00x;
+                       file_type = WTAP_FILE_TYPE_SUBTYPE_NETXRAY_2_00x;
                } else {
                        *err = WTAP_ERR_UNSUPPORTED;
                        *err_info = g_strdup_printf("netxray: version \"%.8s\" unsupported", hdr.version);
                } else {
                        *err = WTAP_ERR_UNSUPPORTED;
                        *err_info = g_strdup_printf("netxray: version \"%.8s\" unsupported", hdr.version);
@@ -491,17 +491,17 @@ int netxray_open(wtap *wth, int *err, gchar **err_info)
            + (double)pletohl(&hdr.timehi)*4294967296.0;
        switch (file_type) {
 
            + (double)pletohl(&hdr.timehi)*4294967296.0;
        switch (file_type) {
 
-       case WTAP_FILE_NETXRAY_OLD:
+       case WTAP_FILE_TYPE_SUBTYPE_NETXRAY_OLD:
                ticks_per_sec = 1000.0;
                wth->tsprecision = WTAP_FILE_TSPREC_MSEC;
                break;
 
                ticks_per_sec = 1000.0;
                wth->tsprecision = WTAP_FILE_TSPREC_MSEC;
                break;
 
-       case WTAP_FILE_NETXRAY_1_0:
+       case WTAP_FILE_TYPE_SUBTYPE_NETXRAY_1_0:
                ticks_per_sec = 1000.0;
                wth->tsprecision = WTAP_FILE_TSPREC_MSEC;
                break;
 
                ticks_per_sec = 1000.0;
                wth->tsprecision = WTAP_FILE_TSPREC_MSEC;
                break;
 
-       case WTAP_FILE_NETXRAY_1_1:
+       case WTAP_FILE_TYPE_SUBTYPE_NETXRAY_1_1:
                /*
                 * In version 1.1 files (as produced by Windows Sniffer
                 * Pro 2.0.01), the time stamp is in microseconds,
                /*
                 * In version 1.1 files (as produced by Windows Sniffer
                 * Pro 2.0.01), the time stamp is in microseconds,
@@ -512,7 +512,7 @@ int netxray_open(wtap *wth, int *err, gchar **err_info)
                wth->tsprecision = WTAP_FILE_TSPREC_USEC;
                break;
 
                wth->tsprecision = WTAP_FILE_TSPREC_USEC;
                break;
 
-       case WTAP_FILE_NETXRAY_2_00x:
+       case WTAP_FILE_TYPE_SUBTYPE_NETXRAY_2_00x:
                /*
                 * Get the time stamp units from the appropriate TpS
                 * table or from the file header.
                /*
                 * Get the time stamp units from the appropriate TpS
                 * table or from the file header.
@@ -773,7 +773,7 @@ int netxray_open(wtap *wth, int *err, gchar **err_info)
                file_encap = netxray_encap[network_type];
 
        /* This is a netxray file */
                file_encap = netxray_encap[network_type];
 
        /* This is a netxray file */
-       wth->file_type = file_type;
+       wth->file_type_subtype = file_type;
        netxray = (netxray_t *)g_malloc(sizeof(netxray_t));
        wth->priv = (void *)netxray;
        wth->subtype_read = netxray_read;
        netxray = (netxray_t *)g_malloc(sizeof(netxray_t));
        wth->priv = (void *)netxray;
        wth->subtype_read = netxray_read;
index 044426e14680a4920d77c9eef0ce65c751e9b8fa..a1d34cd6b057485fcd4d76fb9826f73d866897f4 100644 (file)
@@ -653,9 +653,9 @@ ngsniffer_open(wtap *wth, int *err, gchar **err_info)
 
        /* compressed or uncompressed Sniffer file? */
        if (version.format != 1) {
 
        /* compressed or uncompressed Sniffer file? */
        if (version.format != 1) {
-               wth->file_type = WTAP_FILE_NGSNIFFER_COMPRESSED;
+               wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_NGSNIFFER_COMPRESSED;
        } else {
        } else {
-               wth->file_type = WTAP_FILE_NGSNIFFER_UNCOMPRESSED;
+               wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_NGSNIFFER_UNCOMPRESSED;
        }
 
        /* Set encap type before reading header records because the
        }
 
        /* Set encap type before reading header records because the
@@ -2487,7 +2487,7 @@ ng_file_read(void *buffer, unsigned int nbytes, wtap *wth, gboolean is_random,
                comp_stream = &ngsniffer->seq;
        }
 
                comp_stream = &ngsniffer->seq;
        }
 
-       if (wth->file_type == WTAP_FILE_NGSNIFFER_UNCOMPRESSED) {
+       if (wth->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_NGSNIFFER_UNCOMPRESSED) {
                errno = WTAP_ERR_CANT_READ;
                copied_bytes = file_read(buffer, copybytes, infile);
                if ((unsigned int) copied_bytes != copybytes)
                errno = WTAP_ERR_CANT_READ;
                copied_bytes = file_read(buffer, copybytes, infile);
                if ((unsigned int) copied_bytes != copybytes)
@@ -2655,7 +2655,7 @@ ng_file_skip_seq(wtap *wth, gint64 delta, int *err, gchar **err_info)
 
        ngsniffer = (ngsniffer_t *)wth->priv;
 
 
        ngsniffer = (ngsniffer_t *)wth->priv;
 
-       if (wth->file_type == WTAP_FILE_NGSNIFFER_UNCOMPRESSED) {
+       if (wth->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_NGSNIFFER_UNCOMPRESSED) {
                ngsniffer->seq.uncomp_offset += delta;
                return file_skip(wth->fh, delta, err);
        }
                ngsniffer->seq.uncomp_offset += delta;
                return file_skip(wth->fh, delta, err);
        }
@@ -2700,7 +2700,7 @@ ng_file_seek_rand(wtap *wth, gint64 offset, int *err, gchar **err_info)
 
        ngsniffer = (ngsniffer_t *)wth->priv;
 
 
        ngsniffer = (ngsniffer_t *)wth->priv;
 
-       if (wth->file_type == WTAP_FILE_NGSNIFFER_UNCOMPRESSED) {
+       if (wth->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_NGSNIFFER_UNCOMPRESSED) {
                if (file_seek(wth->random_fh, offset, SEEK_SET, err) == -1)
                        return FALSE;
                return TRUE;
                if (file_seek(wth->random_fh, offset, SEEK_SET, err) == -1)
                        return FALSE;
                return TRUE;
index 93e050d34f18c585fde90e714226fbb4745c21d4..e905f8bed084c4cc2f5c65ad76fe063a01b9bd7b 100644 (file)
@@ -89,7 +89,7 @@ int packetlogger_open(wtap *wth, int *err, gchar **err_info)
        wth->subtype_read = packetlogger_read;
        wth->subtype_seek_read = packetlogger_seek_read;
 
        wth->subtype_read = packetlogger_read;
        wth->subtype_seek_read = packetlogger_seek_read;
 
-       wth->file_type = WTAP_FILE_PACKETLOGGER;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PACKETLOGGER;
        wth->file_encap = WTAP_ENCAP_PACKETLOGGER;
        wth->tsprecision = WTAP_FILE_TSPREC_USEC;
 
        wth->file_encap = WTAP_ENCAP_PACKETLOGGER;
        wth->tsprecision = WTAP_FILE_TSPREC_USEC;
 
index c5013a9dc6574e6a9a8db2079850b8defdf91344..66d81dfc9af7e03b86132393b6b893e087194997 100644 (file)
@@ -1513,7 +1513,7 @@ pcap_process_pseudo_header(FILE_T fh, int file_type, int wtap_encap,
        switch (wtap_encap) {
 
        case WTAP_ENCAP_ATM_PDUS:
        switch (wtap_encap) {
 
        case WTAP_ENCAP_ATM_PDUS:
-               if (file_type == WTAP_FILE_PCAP_NOKIA) {
+               if (file_type == WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA) {
                        /*
                         * Nokia IPSO ATM.
                         */
                        /*
                         * Nokia IPSO ATM.
                         */
@@ -1555,7 +1555,7 @@ pcap_process_pseudo_header(FILE_T fh, int file_type, int wtap_encap,
                break;
 
        case WTAP_ENCAP_ETHERNET:
                break;
 
        case WTAP_ENCAP_ETHERNET:
-               if (file_type == WTAP_FILE_PCAP_NOKIA) {
+               if (file_type == WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA) {
                        /*
                         * Nokia IPSO.  Psuedo header has already been read, but it's not considered
                         * part of the packet size, so reread it to store the data for later (when saving)
                        /*
                         * Nokia IPSO.  Psuedo header has already been read, but it's not considered
                         * part of the packet size, so reread it to store the data for later (when saving)
@@ -1792,7 +1792,7 @@ pcap_read_post_process(int file_type, int wtap_encap,
        switch (wtap_encap) {
 
        case WTAP_ENCAP_ATM_PDUS:
        switch (wtap_encap) {
 
        case WTAP_ENCAP_ATM_PDUS:
-               if (file_type == WTAP_FILE_PCAP_NOKIA) {
+               if (file_type == WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA) {
                        /*
                         * Nokia IPSO ATM.
                         *
                        /*
                         * Nokia IPSO ATM.
                         *
index e920e2a4d0ccca4f013ee4669bdac40cd9400182..c96fc84afd331551485c317e0620ceb3d94a56ec 100644 (file)
@@ -1130,7 +1130,7 @@ pcapng_read_packet_block(FILE_T fh, pcapng_block_header_t *bh, pcapng_t *pn, wta
 
         memset((void *)&wblock->packet_header->pseudo_header, 0, sizeof(union wtap_pseudo_header));
         pseudo_header_len = pcap_process_pseudo_header(fh,
 
         memset((void *)&wblock->packet_header->pseudo_header, 0, sizeof(union wtap_pseudo_header));
         pseudo_header_len = pcap_process_pseudo_header(fh,
-                                                       WTAP_FILE_PCAPNG,
+                                                       WTAP_FILE_TYPE_SUBTYPE_PCAPNG,
                                                        int_data.wtap_encap,
                                                        packet.cap_len,
                                                        TRUE,
                                                        int_data.wtap_encap,
                                                        packet.cap_len,
                                                        TRUE,
@@ -1272,7 +1272,7 @@ pcapng_read_packet_block(FILE_T fh, pcapng_block_header_t *bh, pcapng_t *pn, wta
 
         g_free(option_content);
 
 
         g_free(option_content);
 
-        pcap_read_post_process(WTAP_FILE_PCAPNG, int_data.wtap_encap,
+        pcap_read_post_process(WTAP_FILE_TYPE_SUBTYPE_PCAPNG, int_data.wtap_encap,
             (union wtap_pseudo_header *)&wblock->packet_header->pseudo_header,
             buffer_start_ptr(wblock->frame_buffer),
             (int) (packet.cap_len - pseudo_header_len),
             (union wtap_pseudo_header *)&wblock->packet_header->pseudo_header,
             buffer_start_ptr(wblock->frame_buffer),
             (int) (packet.cap_len - pseudo_header_len),
@@ -1412,7 +1412,7 @@ pcapng_read_simple_packet_block(FILE_T fh, pcapng_block_header_t *bh, pcapng_t *
 
         memset((void *)&wblock->packet_header->pseudo_header, 0, sizeof(union wtap_pseudo_header));
         pseudo_header_len = pcap_process_pseudo_header(fh,
 
         memset((void *)&wblock->packet_header->pseudo_header, 0, sizeof(union wtap_pseudo_header));
         pseudo_header_len = pcap_process_pseudo_header(fh,
-                                                       WTAP_FILE_PCAPNG,
+                                                       WTAP_FILE_TYPE_SUBTYPE_PCAPNG,
                                                        int_data.wtap_encap,
                                                        simple_packet.cap_len,
                                                        TRUE,
                                                        int_data.wtap_encap,
                                                        simple_packet.cap_len,
                                                        TRUE,
@@ -1450,7 +1450,7 @@ pcapng_read_simple_packet_block(FILE_T fh, pcapng_block_header_t *bh, pcapng_t *
                 block_read += 4 - (simple_packet.cap_len % 4);
         }
 
                 block_read += 4 - (simple_packet.cap_len % 4);
         }
 
-        pcap_read_post_process(WTAP_FILE_PCAPNG, int_data.wtap_encap,
+        pcap_read_post_process(WTAP_FILE_TYPE_SUBTYPE_PCAPNG, int_data.wtap_encap,
             (union wtap_pseudo_header *)&wblock->packet_header->pseudo_header,
             buffer_start_ptr(wblock->frame_buffer),
             (int) simple_packet.cap_len,
             (union wtap_pseudo_header *)&wblock->packet_header->pseudo_header,
             buffer_start_ptr(wblock->frame_buffer),
             (int) simple_packet.cap_len,
@@ -2220,7 +2220,7 @@ pcapng_open(wtap *wth, int *err, gchar **err_info)
         wth->subtype_read = pcapng_read;
         wth->subtype_seek_read = pcapng_seek_read;
         wth->subtype_close = pcapng_close;
         wth->subtype_read = pcapng_read;
         wth->subtype_seek_read = pcapng_seek_read;
         wth->subtype_close = pcapng_close;
-        wth->file_type = WTAP_FILE_PCAPNG;
+        wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PCAPNG;
 
         /* Read IDBs */
         wth->interface_data = g_array_new(FALSE, FALSE, sizeof(wtapng_if_descr_t));
 
         /* Read IDBs */
         wth->interface_data = g_array_new(FALSE, FALSE, sizeof(wtapng_if_descr_t));
index 471e5ee6931a528c0d417130ebd647b09c05a47e..f516775d479d46898c5a1f7cec8d66463abb6112 100644 (file)
@@ -334,7 +334,7 @@ int peekclassic_open(wtap *wth, int *err, gchar **err_info)
 
        case 5:
        case 6:
 
        case 5:
        case 6:
-               wth->file_type = WTAP_FILE_PEEKCLASSIC_V56;
+               wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PEEKCLASSIC_V56;
                /*
                 * XXX - can we get the file encapsulation from the
                 * header in the same way we do for V7 files?
                /*
                 * XXX - can we get the file encapsulation from the
                 * header in the same way we do for V7 files?
@@ -345,7 +345,7 @@ int peekclassic_open(wtap *wth, int *err, gchar **err_info)
                break;
 
        case 7:
                break;
 
        case 7:
-               wth->file_type = WTAP_FILE_PEEKCLASSIC_V7;
+               wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PEEKCLASSIC_V7;
                wth->file_encap = file_encap;
                wth->subtype_read = peekclassic_read_v7;
                wth->subtype_seek_read = peekclassic_seek_read_v7;
                wth->file_encap = file_encap;
                wth->subtype_read = peekclassic_read_v7;
                wth->subtype_seek_read = peekclassic_seek_read_v7;
index 2407edd47491e2ba135e52437ad3f66629aeb298..53677d92e7845ab5db589806949d55d85381f20e 100644 (file)
@@ -334,7 +334,7 @@ int peektagged_open(wtap *wth, int *err, gchar **err_info)
      */
     file_encap = peektagged_encap[mediaSubType];
 
      */
     file_encap = peektagged_encap[mediaSubType];
 
-    wth->file_type = WTAP_FILE_PEEKTAGGED;
+    wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PEEKTAGGED;
     wth->file_encap = file_encap;
     wth->subtype_read = peektagged_read;
     wth->subtype_seek_read = peektagged_seek_read;
     wth->file_encap = file_encap;
     wth->subtype_read = peektagged_read;
     wth->subtype_seek_read = peektagged_seek_read;
index 2993e7f8f5b308a964d35097658d92b6a576f54b..cc82c0948508b42d904277fd9528793a6adf7d13 100644 (file)
@@ -295,7 +295,7 @@ pppdump_open(wtap *wth, int *err, gchar **err_info)
 
        state->offset = 5;
        wth->file_encap = WTAP_ENCAP_PPP_WITH_PHDR;
 
        state->offset = 5;
        wth->file_encap = WTAP_ENCAP_PPP_WITH_PHDR;
-       wth->file_type = WTAP_FILE_PPPDUMP;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PPPDUMP;
 
        wth->snapshot_length = PPPD_BUF_SIZE; /* just guessing */
        wth->subtype_read = pppdump_read;
 
        wth->snapshot_length = PPPD_BUF_SIZE; /* just guessing */
        wth->subtype_read = pppdump_read;
index 8e0ca6e1ade22d5bcbafdb0a48bce583959130ab..8efcb91efc648b1c473021693e8d90b52e910445 100644 (file)
@@ -163,7 +163,7 @@ int radcom_open(wtap *wth, int *err, gchar **err_info)
        }
 
        /* This is a radcom file */
        }
 
        /* This is a radcom file */
-       wth->file_type = WTAP_FILE_RADCOM;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_RADCOM;
        wth->subtype_read = radcom_read;
        wth->subtype_seek_read = radcom_seek_read;
        wth->snapshot_length = 0; /* not available in header, only in frame */
        wth->subtype_read = radcom_read;
        wth->subtype_seek_read = radcom_seek_read;
        wth->snapshot_length = 0; /* not available in header, only in frame */
index c37ba064f7baf684ebb9e53010c2002335ca66a7..ccde4f57c46e13587b59b198b0f02930d7c3d1cd 100644 (file)
@@ -397,7 +397,7 @@ int snoop_open(wtap *wth, int *err, gchar **err_info)
                file_encap = shomiti_encap[hdr.network];
 
                /* This is a Shomiti file */
                file_encap = shomiti_encap[hdr.network];
 
                /* This is a Shomiti file */
-               wth->file_type = WTAP_FILE_SHOMITI;
+               wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_SHOMITI;
        } else if (hdr.network & SNOOP_PRIVATE_BIT) {
                if ((hdr.network^SNOOP_PRIVATE_BIT) >= NUM_SNOOP_PRIVATE_ENCAPS
                    || snoop_private_encap[hdr.network^SNOOP_PRIVATE_BIT] == WTAP_ENCAP_UNKNOWN) {
        } else if (hdr.network & SNOOP_PRIVATE_BIT) {
                if ((hdr.network^SNOOP_PRIVATE_BIT) >= NUM_SNOOP_PRIVATE_ENCAPS
                    || snoop_private_encap[hdr.network^SNOOP_PRIVATE_BIT] == WTAP_ENCAP_UNKNOWN) {
@@ -409,7 +409,7 @@ int snoop_open(wtap *wth, int *err, gchar **err_info)
                file_encap = snoop_private_encap[hdr.network^SNOOP_PRIVATE_BIT];
 
                /* This is a snoop file */
                file_encap = snoop_private_encap[hdr.network^SNOOP_PRIVATE_BIT];
 
                /* This is a snoop file */
-               wth->file_type = WTAP_FILE_SNOOP;
+               wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_SNOOP;
        } else {
                if (hdr.network >= NUM_SNOOP_ENCAPS
                    || snoop_encap[hdr.network] == WTAP_ENCAP_UNKNOWN) {
        } else {
                if (hdr.network >= NUM_SNOOP_ENCAPS
                    || snoop_encap[hdr.network] == WTAP_ENCAP_UNKNOWN) {
@@ -421,7 +421,7 @@ int snoop_open(wtap *wth, int *err, gchar **err_info)
                file_encap = snoop_encap[hdr.network];
 
                /* This is a snoop file */
                file_encap = snoop_encap[hdr.network];
 
                /* This is a snoop file */
-               wth->file_type = WTAP_FILE_SNOOP;
+               wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_SNOOP;
        }
 
        /*
        }
 
        /*
@@ -600,7 +600,7 @@ snoop_read_packet(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
                 * this frame; if this is a Shomit file, we assume there
                 * is.  (XXX - or should we treat it a "maybe"?)
                 */
                 * this frame; if this is a Shomit file, we assume there
                 * is.  (XXX - or should we treat it a "maybe"?)
                 */
-               if (wth->file_type == WTAP_FILE_SHOMITI)
+               if (wth->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_SHOMITI)
                        phdr->pseudo_header.eth.fcs_len = 4;
                else
                        phdr->pseudo_header.eth.fcs_len = 0;
                        phdr->pseudo_header.eth.fcs_len = 4;
                else
                        phdr->pseudo_header.eth.fcs_len = 0;
index e62ea429b560602dabd4d85a385dff87c7db6616..df521ebacb88351761ce779c3f7c44e671c65e8e 100644 (file)
@@ -187,7 +187,7 @@ int stanag4607_open(wtap *wth, int *err, gchar **err_info)
   if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
     return -1;
 
   if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
     return -1;
 
-  wth->file_type = WTAP_FILE_STANAG_4607;
+  wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_STANAG_4607;
   wth->file_encap = WTAP_ENCAP_STANAG_4607;
   wth->snapshot_length = 0; /* not known */
 
   wth->file_encap = WTAP_ENCAP_STANAG_4607;
   wth->snapshot_length = 0; /* not known */
 
index 4edc6a7ffa9bfd9b707682cf4b95dd77fa350ec0..c726381fcc8994e5e84a4e500235d33ed4342323 100644 (file)
@@ -116,7 +116,7 @@ int tnef_open(wtap *wth, int *err, gchar **err_info)
   if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
     return -1;
 
   if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
     return -1;
 
-  wth->file_type = WTAP_FILE_TNEF;
+  wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_TNEF;
   wth->file_encap = WTAP_ENCAP_TNEF;
   wth->snapshot_length = 0;
 
   wth->file_encap = WTAP_ENCAP_TNEF;
   wth->snapshot_length = 0;
 
index c530075bff8f2da2fb6c86aa8e18667d461325e8..d35b2c8023b1068bc5160e5671ffd346264540a8 100644 (file)
@@ -207,7 +207,7 @@ int toshiba_open(wtap *wth, int *err, gchar **err_info)
        }
 
        wth->file_encap = WTAP_ENCAP_PER_PACKET;
        }
 
        wth->file_encap = WTAP_ENCAP_PER_PACKET;
-       wth->file_type = WTAP_FILE_TOSHIBA;
+       wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_TOSHIBA;
        wth->snapshot_length = 0; /* not known */
        wth->subtype_read = toshiba_read;
        wth->subtype_seek_read = toshiba_seek_read;
        wth->snapshot_length = 0; /* not known */
        wth->subtype_read = toshiba_read;
        wth->subtype_seek_read = toshiba_seek_read;
index 3fc3384621603fdc86b19cc62e55bb6c353069de..c0bf4d3ee2a55e541b475ffdff4da6dca0e70c64 100644 (file)
@@ -260,7 +260,7 @@ int visual_open(wtap *wth, int *err, gchar **err_info)
     }
 
     /* Fill in the wiretap struct with data from the file header */
     }
 
     /* Fill in the wiretap struct with data from the file header */
-    wth->file_type = WTAP_FILE_VISUAL_NETWORKS;
+    wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_VISUAL_NETWORKS;
     wth->file_encap = encap;
     wth->snapshot_length = pletohs(&vfile_hdr.max_length);
 
     wth->file_encap = encap;
     wth->snapshot_length = pletohs(&vfile_hdr.max_length);
 
index 6850323c9cd59f3490ffd8a86e7f370f165184b4..50582940be25c0e40d641e39c82a5648789e0d04 100644 (file)
@@ -248,7 +248,7 @@ int vms_open(wtap *wth, int *err, gchar **err_info)
     }
 
     wth->file_encap = WTAP_ENCAP_RAW_IP;
     }
 
     wth->file_encap = WTAP_ENCAP_RAW_IP;
-    wth->file_type = WTAP_FILE_VMS;
+    wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_VMS;
     wth->snapshot_length = 0; /* not known */
     wth->subtype_read = vms_read;
     wth->subtype_seek_read = vms_seek_read;
     wth->snapshot_length = 0; /* not known */
     wth->subtype_read = vms_read;
     wth->subtype_seek_read = vms_seek_read;
index aa8cfd01ad6240836f32a3c52022e1afeae3ac1c..54203f27748048ea0ed80c40030d723bc5a5fa30 100644 (file)
@@ -678,9 +678,9 @@ int vwr_open(wtap *wth, int *err, gchar **err_info)
     wth->file_encap = WTAP_ENCAP_IXVERIWAVE;
 
     if (fpgaVer == S2_W_FPGA || fpgaVer == S1_W_FPGA || fpgaVer == S3_W_FPGA)
     wth->file_encap = WTAP_ENCAP_IXVERIWAVE;
 
     if (fpgaVer == S2_W_FPGA || fpgaVer == S1_W_FPGA || fpgaVer == S3_W_FPGA)
-        wth->file_type = WTAP_FILE_VWR_80211;
+        wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_VWR_80211;
     else if (fpgaVer == vVW510012_E_FPGA || fpgaVer == vVW510024_E_FPGA)
     else if (fpgaVer == vVW510012_E_FPGA || fpgaVer == vVW510024_E_FPGA)
-        wth->file_type = WTAP_FILE_VWR_ETH;
+        wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_VWR_ETH;
 
     return 1;
 }
 
     return 1;
 }
index 056b0fe1e90f4f56d04dc100c177ec51a4b96c91..2477ec700732e732db7a3618b4bd47e6461978d8 100644 (file)
@@ -52,7 +52,7 @@ typedef gboolean (*subtype_seek_read_func)(struct wtap*, gint64,
 struct wtap {
     FILE_T                      fh;
     FILE_T                      random_fh;              /**< Secondary FILE_T for random access */
 struct wtap {
     FILE_T                      fh;
     FILE_T                      random_fh;              /**< Secondary FILE_T for random access */
-    int                         file_type;
+    int                         file_type_subtype;
     guint                       snapshot_length;
     struct Buffer               *frame_buffer;
     struct wtap_pkthdr          phdr;
     guint                       snapshot_length;
     struct Buffer               *frame_buffer;
     struct wtap_pkthdr          phdr;
@@ -93,7 +93,7 @@ typedef gboolean (*subtype_close_func)(struct wtap_dumper*, int*);
 
 struct wtap_dumper {
     WFILE_T                 fh;
 
 struct wtap_dumper {
     WFILE_T                 fh;
-    int                     file_type;
+    int                     file_type_subtype;
     int                     snaplen;
     int                     encap;
     gboolean                compressed;
     int                     snaplen;
     int                     encap;
     gboolean                compressed;
index 181a11071112dc1558bd894bfeb73d24f2bb4f03..bf9981a84c361fc23d4d81a6853d795baeda47f8 100644 (file)
@@ -71,9 +71,9 @@ wtap_fstat(wtap *wth, ws_statb64 *statb, int *err)
 }
 
 int
 }
 
 int
-wtap_file_type(wtap *wth)
+wtap_file_type_subtype(wtap *wth)
 {
 {
-       return wth->file_type;
+       return wth->file_type_subtype;
 }
 
 gboolean
 }
 
 gboolean
index a2d79bebc4f5eb6a083eb9c6a5f258ccd7c0ecc7..9ff595ca2df6da1fa1fb601e850ee135e9eca308 100644 (file)
@@ -252,77 +252,79 @@ extern "C" {
 
 #define WTAP_NUM_ENCAP_TYPES                    wtap_get_num_encap_types()
 
 
 #define WTAP_NUM_ENCAP_TYPES                    wtap_get_num_encap_types()
 
-/* File types that can be read by wiretap.
+/* File types/subtypes that can be read by wiretap.
    We support writing many of these file types, too, so we
    We support writing many of these file types, too, so we
-   distinguish between different versions of them. */
-#define WTAP_FILE_UNKNOWN                        0
-#define WTAP_FILE_PCAP                           1
-#define WTAP_FILE_PCAPNG                         2
-#define WTAP_FILE_PCAP_NSEC                      3
-#define WTAP_FILE_PCAP_AIX                       4
-#define WTAP_FILE_PCAP_SS991029                  5
-#define WTAP_FILE_PCAP_NOKIA                     6
-#define WTAP_FILE_PCAP_SS990417                  7
-#define WTAP_FILE_PCAP_SS990915                  8
-#define WTAP_FILE_5VIEWS                         9
-#define WTAP_FILE_IPTRACE_1_0                   10
-#define WTAP_FILE_IPTRACE_2_0                   11
-#define WTAP_FILE_BER                           12
-#define WTAP_FILE_HCIDUMP                       13
-#define WTAP_FILE_CATAPULT_DCT2000              14
-#define WTAP_FILE_NETXRAY_OLD                   15
-#define WTAP_FILE_NETXRAY_1_0                   16
-#define WTAP_FILE_COSINE                        17
-#define WTAP_FILE_CSIDS                         18
-#define WTAP_FILE_DBS_ETHERWATCH                19
-#define WTAP_FILE_ERF                           20
-#define WTAP_FILE_EYESDN                        21
-#define WTAP_FILE_NETTL                         22
-#define WTAP_FILE_ISERIES                       23
-#define WTAP_FILE_ISERIES_UNICODE               24
-#define WTAP_FILE_I4BTRACE                      25
-#define WTAP_FILE_ASCEND                        26
-#define WTAP_FILE_NETMON_1_x                    27
-#define WTAP_FILE_NETMON_2_x                    28
-#define WTAP_FILE_NGSNIFFER_UNCOMPRESSED        29
-#define WTAP_FILE_NGSNIFFER_COMPRESSED          30
-#define WTAP_FILE_NETXRAY_1_1                   31
-#define WTAP_FILE_NETXRAY_2_00x                 32
-#define WTAP_FILE_NETWORK_INSTRUMENTS           33
-#define WTAP_FILE_LANALYZER                     34
-#define WTAP_FILE_PPPDUMP                       35
-#define WTAP_FILE_RADCOM                        36
-#define WTAP_FILE_SNOOP                         37
-#define WTAP_FILE_SHOMITI                       38
-#define WTAP_FILE_VMS                           39
-#define WTAP_FILE_K12                           40
-#define WTAP_FILE_TOSHIBA                       41
-#define WTAP_FILE_VISUAL_NETWORKS               42
-#define WTAP_FILE_PEEKCLASSIC_V56               43
-#define WTAP_FILE_PEEKCLASSIC_V7                44
-#define WTAP_FILE_PEEKTAGGED                    45
-#define WTAP_FILE_MPEG                          46
-#define WTAP_FILE_K12TEXT                       47
-#define WTAP_FILE_NETSCREEN                     48
-#define WTAP_FILE_COMMVIEW                      49
-#define WTAP_FILE_BTSNOOP                       50
-#define WTAP_FILE_TNEF                          51
-#define WTAP_FILE_DCT3TRACE                     52
-#define WTAP_FILE_PACKETLOGGER                  53
-#define WTAP_FILE_DAINTREE_SNA                  54
-#define WTAP_FILE_NETSCALER_1_0                 55
-#define WTAP_FILE_NETSCALER_2_0                 56
-#define WTAP_FILE_JPEG_JFIF                     57 /* obsoleted by WTAP_FILE_MIME */
-#define WTAP_FILE_IPFIX                         58
-#define WTAP_FILE_MIME                          59
-#define WTAP_FILE_AETHRA                        60
-#define WTAP_FILE_MPEG_2_TS                     61
-#define WTAP_FILE_VWR_80211                     62
-#define WTAP_FILE_VWR_ETH                       63
-#define WTAP_FILE_CAMINS                        64
-#define WTAP_FILE_STANAG_4607                   65
-
-#define WTAP_NUM_FILE_TYPES                     wtap_get_num_file_types()
+   distinguish between different subtypes of them, as
+   different subtypes need to be written in a different
+   fashion. */
+#define WTAP_FILE_TYPE_SUBTYPE_UNKNOWN                        0
+#define WTAP_FILE_TYPE_SUBTYPE_PCAP                           1
+#define WTAP_FILE_TYPE_SUBTYPE_PCAPNG                         2
+#define WTAP_FILE_TYPE_SUBTYPE_PCAP_NSEC                      3
+#define WTAP_FILE_TYPE_SUBTYPE_PCAP_AIX                       4
+#define WTAP_FILE_TYPE_SUBTYPE_PCAP_SS991029                  5
+#define WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA                     6
+#define WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990417                  7
+#define WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990915                  8
+#define WTAP_FILE_TYPE_SUBTYPE_5VIEWS                         9
+#define WTAP_FILE_TYPE_SUBTYPE_IPTRACE_1_0                   10
+#define WTAP_FILE_TYPE_SUBTYPE_IPTRACE_2_0                   11
+#define WTAP_FILE_TYPE_SUBTYPE_BER                           12
+#define WTAP_FILE_TYPE_SUBTYPE_HCIDUMP                       13
+#define WTAP_FILE_TYPE_SUBTYPE_CATAPULT_DCT2000              14
+#define WTAP_FILE_TYPE_SUBTYPE_NETXRAY_OLD                   15
+#define WTAP_FILE_TYPE_SUBTYPE_NETXRAY_1_0                   16
+#define WTAP_FILE_TYPE_SUBTYPE_COSINE                        17
+#define WTAP_FILE_TYPE_SUBTYPE_CSIDS                         18
+#define WTAP_FILE_TYPE_SUBTYPE_DBS_ETHERWATCH                19
+#define WTAP_FILE_TYPE_SUBTYPE_ERF                           20
+#define WTAP_FILE_TYPE_SUBTYPE_EYESDN                        21
+#define WTAP_FILE_TYPE_SUBTYPE_NETTL                         22
+#define WTAP_FILE_TYPE_SUBTYPE_ISERIES                       23
+#define WTAP_FILE_TYPE_SUBTYPE_ISERIES_UNICODE               24
+#define WTAP_FILE_TYPE_SUBTYPE_I4BTRACE                      25
+#define WTAP_FILE_TYPE_SUBTYPE_ASCEND                        26
+#define WTAP_FILE_TYPE_SUBTYPE_NETMON_1_x                    27
+#define WTAP_FILE_TYPE_SUBTYPE_NETMON_2_x                    28
+#define WTAP_FILE_TYPE_SUBTYPE_NGSNIFFER_UNCOMPRESSED        29
+#define WTAP_FILE_TYPE_SUBTYPE_NGSNIFFER_COMPRESSED          30
+#define WTAP_FILE_TYPE_SUBTYPE_NETXRAY_1_1                   31
+#define WTAP_FILE_TYPE_SUBTYPE_NETXRAY_2_00x                 32
+#define WTAP_FILE_TYPE_SUBTYPE_NETWORK_INSTRUMENTS           33
+#define WTAP_FILE_TYPE_SUBTYPE_LANALYZER                     34
+#define WTAP_FILE_TYPE_SUBTYPE_PPPDUMP                       35
+#define WTAP_FILE_TYPE_SUBTYPE_RADCOM                        36
+#define WTAP_FILE_TYPE_SUBTYPE_SNOOP                         37
+#define WTAP_FILE_TYPE_SUBTYPE_SHOMITI                       38
+#define WTAP_FILE_TYPE_SUBTYPE_VMS                           39
+#define WTAP_FILE_TYPE_SUBTYPE_K12                           40
+#define WTAP_FILE_TYPE_SUBTYPE_TOSHIBA                       41
+#define WTAP_FILE_TYPE_SUBTYPE_VISUAL_NETWORKS               42
+#define WTAP_FILE_TYPE_SUBTYPE_PEEKCLASSIC_V56               43
+#define WTAP_FILE_TYPE_SUBTYPE_PEEKCLASSIC_V7                44
+#define WTAP_FILE_TYPE_SUBTYPE_PEEKTAGGED                    45
+#define WTAP_FILE_TYPE_SUBTYPE_MPEG                          46
+#define WTAP_FILE_TYPE_SUBTYPE_K12TEXT                       47
+#define WTAP_FILE_TYPE_SUBTYPE_NETSCREEN                     48
+#define WTAP_FILE_TYPE_SUBTYPE_COMMVIEW                      49
+#define WTAP_FILE_TYPE_SUBTYPE_BTSNOOP                       50
+#define WTAP_FILE_TYPE_SUBTYPE_TNEF                          51
+#define WTAP_FILE_TYPE_SUBTYPE_DCT3TRACE                     52
+#define WTAP_FILE_TYPE_SUBTYPE_PACKETLOGGER                  53
+#define WTAP_FILE_TYPE_SUBTYPE_DAINTREE_SNA                  54
+#define WTAP_FILE_TYPE_SUBTYPE_NETSCALER_1_0                 55
+#define WTAP_FILE_TYPE_SUBTYPE_NETSCALER_2_0                 56
+#define WTAP_FILE_TYPE_SUBTYPE_JPEG_JFIF                     57 /* obsoleted by WTAP_FILE_TYPE_SUBTYPE_MIME */
+#define WTAP_FILE_TYPE_SUBTYPE_IPFIX                         58
+#define WTAP_FILE_TYPE_SUBTYPE_MIME                          59
+#define WTAP_FILE_TYPE_SUBTYPE_AETHRA                        60
+#define WTAP_FILE_TYPE_SUBTYPE_MPEG_2_TS                     61
+#define WTAP_FILE_TYPE_SUBTYPE_VWR_80211                     62
+#define WTAP_FILE_TYPE_SUBTYPE_VWR_ETH                       63
+#define WTAP_FILE_TYPE_SUBTYPE_CAMINS                        64
+#define WTAP_FILE_TYPE_SUBTYPE_STANAG_4607                   65
+
+#define WTAP_NUM_FILE_TYPES_SUBTYPES  wtap_get_num_file_types_subtypes()
 
 /* timestamp precision (currently only these values are supported) */
 #define WTAP_FILE_TSPREC_SEC        0
 
 /* timestamp precision (currently only these values are supported) */
 #define WTAP_FILE_TSPREC_SEC        0
@@ -1141,7 +1143,7 @@ typedef int (*wtap_open_routine_t)(struct wtap*, int *, char **);
 #define WTAP_COMMENT_PER_INTERFACE     0x00000002      /* per-interface */
 #define WTAP_COMMENT_PER_PACKET                0x00000004      /* per-packet */
 
 #define WTAP_COMMENT_PER_INTERFACE     0x00000002      /* per-interface */
 #define WTAP_COMMENT_PER_PACKET                0x00000004      /* per-packet */
 
-struct file_type_info {
+struct file_type_subtype_info {
     /* the file type name */
     /* should be NULL for all "pseudo" types that are only internally used and not read/writeable */
     const char *name;
     /* the file type name */
     /* should be NULL for all "pseudo" types that are only internally used and not read/writeable */
     const char *name;
@@ -1246,7 +1248,7 @@ gboolean wtap_iscompressed(wtap *wth);
 WS_DLL_PUBLIC
 guint wtap_snapshot_length(wtap *wth); /* per file */
 WS_DLL_PUBLIC
 WS_DLL_PUBLIC
 guint wtap_snapshot_length(wtap *wth); /* per file */
 WS_DLL_PUBLIC
-int wtap_file_type(wtap *wth);
+int wtap_file_type_subtype(wtap *wth);
 WS_DLL_PUBLIC
 int wtap_file_encap(wtap *wth);
 WS_DLL_PUBLIC
 WS_DLL_PUBLIC
 int wtap_file_encap(wtap *wth);
 WS_DLL_PUBLIC
@@ -1343,21 +1345,21 @@ WS_DLL_PUBLIC
 gboolean wtap_dump_can_write(const GArray *file_encaps, guint32 required_comment_types);
 
 /**
 gboolean wtap_dump_can_write(const GArray *file_encaps, guint32 required_comment_types);
 
 /**
- * Get a GArray of WTAP_FILE_ values for file types 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.
+ * Get a GArray of WTAP_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
  */
 WS_DLL_PUBLIC
-GArray *wtap_get_savable_file_types(int file_type, const GArray *file_encaps,
-    guint32 required_comment_types);
+GArray *wtap_get_savable_file_types_subtypes(int file_type,
+    const GArray *file_encaps, guint32 required_comment_types);
 
 /*** various string converter functions ***/
 WS_DLL_PUBLIC
 
 /*** various string converter functions ***/
 WS_DLL_PUBLIC
-const char *wtap_file_type_string(int filetype);
+const char *wtap_file_type_subtype_string(int file_type_subtype);
 WS_DLL_PUBLIC
 WS_DLL_PUBLIC
-const char *wtap_file_type_short_string(int filetype);
+const char *wtap_file_type_subtype_short_string(int file_type_subtype);
 WS_DLL_PUBLIC
 WS_DLL_PUBLIC
-int wtap_short_string_to_file_type(const char *short_name);
+int wtap_short_string_to_file_type_subtype(const char *short_name);
 
 /*** various file extension functions ***/
 WS_DLL_PUBLIC
 
 /*** various file extension functions ***/
 WS_DLL_PUBLIC
@@ -1385,7 +1387,7 @@ int wtap_get_num_file_type_extensions(void);
 WS_DLL_PUBLIC
 int wtap_get_num_encap_types(void);
 WS_DLL_PUBLIC
 WS_DLL_PUBLIC
 int wtap_get_num_encap_types(void);
 WS_DLL_PUBLIC
-int wtap_get_num_file_types(void);
+int wtap_get_num_file_types_subtypes(void);
 
 /*** get information for file type extension ***/
 WS_DLL_PUBLIC
 
 /*** get information for file type extension ***/
 WS_DLL_PUBLIC
@@ -1399,7 +1401,7 @@ void wtap_register_file_type_extension(const struct file_extension_info *ei);
 WS_DLL_PUBLIC
 void wtap_register_open_routine(wtap_open_routine_t, gboolean has_magic);
 WS_DLL_PUBLIC
 WS_DLL_PUBLIC
 void wtap_register_open_routine(wtap_open_routine_t, gboolean has_magic);
 WS_DLL_PUBLIC
-int wtap_register_file_type(const struct file_type_info* fi);
+int wtap_register_file_type(const struct file_type_subtype_info* fi);
 WS_DLL_PUBLIC
 int wtap_register_encap_type(const char* name, const char* short_name);
 
 WS_DLL_PUBLIC
 int wtap_register_encap_type(const char* name, const char* short_name);