diff options
Diffstat (limited to 'wiretap/wtap.c')
| -rw-r--r-- | wiretap/wtap.c | 2142 |
1 files changed, 2142 insertions, 0 deletions
diff --git a/wiretap/wtap.c b/wiretap/wtap.c new file mode 100644 index 00000000..18432ef2 --- /dev/null +++ b/wiretap/wtap.c @@ -0,0 +1,2142 @@ +/* wtap.c + * + * Wiretap Library + * Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu> + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ + +#include <config.h> + +#define WS_LOG_DOMAIN LOG_DOMAIN_WIRETAP + +#include <string.h> + +#include <sys/types.h> + +#include "wtap-int.h" +#include "wtap_opttypes.h" + +#include "file_wrappers.h" +#include <wsutil/file_util.h> +#include <wsutil/buffer.h> +#include <wsutil/ws_assert.h> +#include <wsutil/wslog.h> +#include <wsutil/exported_pdu_tlvs.h> +#ifdef HAVE_PLUGINS +#include <wsutil/plugins.h> +#endif + +#ifdef HAVE_PLUGINS +static plugins_t *libwiretap_plugins = NULL; +#endif + +#define PADDING4(x) ((((x + 3) >> 2) << 2) - x) + +static GSList *wtap_plugins = NULL; + +#ifdef HAVE_PLUGINS +void +wtap_register_plugin(const wtap_plugin *plug) +{ + wtap_plugins = g_slist_prepend(wtap_plugins, (wtap_plugin *)plug); +} +#else /* HAVE_PLUGINS */ +void +wtap_register_plugin(const wtap_plugin *plug _U_) +{ + ws_warning("wtap_register_plugin: built without support for binary plugins"); +} +#endif /* HAVE_PLUGINS */ + +int +wtap_plugins_supported(void) +{ +#ifdef HAVE_PLUGINS + return plugins_supported() ? 0 : 1; +#else + return -1; +#endif +} + +static void +call_plugin_register_wtap_module(gpointer data, gpointer user_data _U_) +{ + wtap_plugin *plug = (wtap_plugin *)data; + + if (plug->register_wtap_module) { + plug->register_wtap_module(); + } +} + +/* + * Return the size of the file, as reported by the OS. + * (gint64, in case that's 64 bits.) + */ +gint64 +wtap_file_size(wtap *wth, int *err) +{ + ws_statb64 statb; + + if (file_fstat((wth->fh == NULL) ? wth->random_fh : wth->fh, + &statb, err) == -1) + return -1; + return statb.st_size; +} + +/* + * Do an fstat on the file. + */ +int +wtap_fstat(wtap *wth, ws_statb64 *statb, int *err) +{ + if (file_fstat((wth->fh == NULL) ? wth->random_fh : wth->fh, + statb, err) == -1) + return -1; + return 0; +} + +int +wtap_file_type_subtype(wtap *wth) +{ + return wth->file_type_subtype; +} + +guint +wtap_snapshot_length(wtap *wth) +{ + return wth->snapshot_length; +} + +int +wtap_file_encap(wtap *wth) +{ + return wth->file_encap; +} + +int +wtap_file_tsprec(wtap *wth) +{ + return wth->file_tsprec; +} + +guint +wtap_file_get_num_shbs(wtap *wth) +{ + return wth->shb_hdrs->len; +} + +wtap_block_t +wtap_file_get_shb(wtap *wth, guint shb_num) +{ + if ((wth == NULL) || (wth->shb_hdrs == NULL) || (shb_num >= wth->shb_hdrs->len)) + return NULL; + + return g_array_index(wth->shb_hdrs, wtap_block_t, shb_num); +} + +GArray* +wtap_file_get_shb_for_new_file(wtap *wth) +{ + guint shb_count; + wtap_block_t shb_hdr_src, shb_hdr_dest; + GArray* shb_hdrs; + + if ((wth == NULL) || (wth->shb_hdrs == NULL) || (wth->shb_hdrs->len == 0)) + return NULL; + + shb_hdrs = g_array_new(FALSE, FALSE, sizeof(wtap_block_t)); + + for (shb_count = 0; shb_count < wth->shb_hdrs->len; shb_count++) { + shb_hdr_src = g_array_index(wth->shb_hdrs, wtap_block_t, shb_count); + shb_hdr_dest = wtap_block_make_copy(shb_hdr_src); + g_array_append_val(shb_hdrs, shb_hdr_dest); + } + + return shb_hdrs; +} + +/* + * XXX - replace with APIs that let us handle multiple comments. + */ +void +wtap_write_shb_comment(wtap *wth, gchar *comment) +{ + if ((wth != NULL) && (wth->shb_hdrs != NULL) && (wth->shb_hdrs->len > 0)) { + wtap_block_set_nth_string_option_value(g_array_index(wth->shb_hdrs, wtap_block_t, 0), OPT_COMMENT, 0, comment, (gsize)(comment ? strlen(comment) : 0)); + } +} + +wtapng_iface_descriptions_t * +wtap_file_get_idb_info(wtap *wth) +{ + wtapng_iface_descriptions_t *idb_info; + + idb_info = g_new(wtapng_iface_descriptions_t,1); + + idb_info->interface_data = wth->interface_data; + + return idb_info; +} + +wtap_block_t +wtap_get_next_interface_description(wtap *wth) +{ + if (wth->next_interface_data < wth->interface_data->len) { + /* + * We have an IDB to return. Advance to the next + * IDB, and return this one. + */ + wtap_block_t idb; + + idb = g_array_index(wth->interface_data, wtap_block_t, + wth->next_interface_data); + wth->next_interface_data++; + return idb; + } + + /* + * We've returned all the interface descriptions we currently + * have. (There may be more in the future, if we read more.) + */ + return NULL; +} + +void +wtap_file_add_decryption_secrets(wtap *wth, const wtap_block_t dsb) +{ + if (!wth->dsbs) { + wth->dsbs = g_array_new(FALSE, FALSE, sizeof(wtap_block_t)); + } + g_array_append_val(wth->dsbs, dsb); +} + +gboolean +wtap_file_discard_decryption_secrets(wtap *wth) +{ + if (!wth->dsbs || wth->dsbs->len == 0) + return FALSE; + + wtap_block_array_free(wth->dsbs); + wth->dsbs = NULL; + return TRUE; +} + +void +wtap_file_add_sysdig_meta_event(wtap *wth, const wtap_block_t mev) +{ + if (!wth->sysdig_meta_events) { + wth->sysdig_meta_events = g_array_new(FALSE, FALSE, sizeof(wtap_block_t)); + } + g_array_append_val(wth->sysdig_meta_events, mev); +} + +gboolean +wtap_file_discard_sysdig_meta_events(wtap *wth) +{ + if (!wth->sysdig_meta_events || wth->sysdig_meta_events->len == 0) + return false; + + wtap_block_array_free(wth->sysdig_meta_events); + wth->sysdig_meta_events = NULL; + return true; +} + +void +wtap_add_idb(wtap *wth, wtap_block_t idb) +{ + g_array_append_val(wth->interface_data, idb); +} + +static wtap_block_t +wtap_generate_idb(int encap, int tsprec, int snaplen) +{ + wtap_block_t idb; + wtapng_if_descr_mandatory_t *if_descr_mand; + + ws_assert(encap != WTAP_ENCAP_UNKNOWN && + encap != WTAP_ENCAP_PER_PACKET && + encap != WTAP_ENCAP_NONE); + + idb = wtap_block_create(WTAP_BLOCK_IF_ID_AND_INFO); + + if_descr_mand = (wtapng_if_descr_mandatory_t*)wtap_block_get_mandatory_data(idb); + if_descr_mand->wtap_encap = encap; + if_descr_mand->tsprecision = tsprec; + if (tsprec < 0 || tsprec > WS_TSPREC_MAX) { + /* + * Either WTAP_TSPREC_PER_PACKET, WTAP_TSPREC_UNKNOWN, + * or not a valid WTAP_TSPREC_ value. + * + * Unknown timestamp precision; use the default of + * microsecond resolution. + */ + tsprec = 6; /* microsecond resolution */ + } + + /* + * Compute 10^{params->tsprec}. + */ + if_descr_mand->time_units_per_second = 1; + for (int i = 0; i < tsprec; i++) + if_descr_mand->time_units_per_second *= 10; + + if (tsprec != WTAP_TSPREC_USEC) { + /* + * Microsecond precision is the default, so we only + * add an option if the precision isn't microsecond + * precision. + */ + wtap_block_add_uint8_option(idb, OPT_IDB_TSRESOL, tsprec); + } + if (snaplen == 0) { + /* + * No snapshot length was specified. Pick an + * appropriate snapshot length for this + * link-layer type. + * + * We use WTAP_MAX_PACKET_SIZE_STANDARD for everything except + * D-Bus, which has a maximum packet size of 128MB, + * and EBHSCR, which has a maximum packet size of 8MB, + * which is more than we want to put into files + * with other link-layer header types, as that + * might cause some software reading those files + * to allocate an unnecessarily huge chunk of + * memory for a packet buffer. + */ + if (encap == WTAP_ENCAP_DBUS) + snaplen = 128*1024*1024; + else if (encap == WTAP_ENCAP_EBHSCR) + snaplen = 8*1024*1024; + else + snaplen = WTAP_MAX_PACKET_SIZE_STANDARD; + } + if_descr_mand->snap_len = snaplen; + if_descr_mand->num_stat_entries = 0; /* Number of ISBs */ + if_descr_mand->interface_statistics = NULL; + + return idb; +} + +void +wtap_add_generated_idb(wtap *wth) +{ + wtap_block_t idb; + + idb = wtap_generate_idb(wth->file_encap, wth->file_tsprec, wth->snapshot_length); + /* + * Add this IDB. + */ + wtap_add_idb(wth, idb); +} + +void +wtap_free_idb_info(wtapng_iface_descriptions_t *idb_info) +{ + if (idb_info == NULL) + return; + + wtap_block_array_free(idb_info->interface_data); + g_free(idb_info); +} + +gchar * +wtap_get_debug_if_descr(const wtap_block_t if_descr, + const int indent, + const char* line_end) +{ + char* tmp_content; + wtapng_if_descr_mandatory_t* if_descr_mand; + GString *info = g_string_new(""); + gint64 itmp64; + guint64 tmp64; + guint8 tmp8; + if_filter_opt_t if_filter; + + ws_assert(if_descr); + + if_descr_mand = (wtapng_if_descr_mandatory_t*)wtap_block_get_mandatory_data(if_descr); + if (wtap_block_get_string_option_value(if_descr, OPT_IDB_NAME, &tmp_content) == WTAP_OPTTYPE_SUCCESS) { + g_string_printf(info, + "%*cName = %s%s", indent, ' ', + tmp_content ? tmp_content : "UNKNOWN", + line_end); + } + + if (wtap_block_get_string_option_value(if_descr, OPT_IDB_DESCRIPTION, &tmp_content) == WTAP_OPTTYPE_SUCCESS) { + g_string_append_printf(info, + "%*cDescription = %s%s", indent, ' ', + tmp_content ? tmp_content : "NONE", + line_end); + } + + g_string_append_printf(info, + "%*cEncapsulation = %s (%d - %s)%s", indent, ' ', + wtap_encap_description(if_descr_mand->wtap_encap), + if_descr_mand->wtap_encap, + wtap_encap_name(if_descr_mand->wtap_encap), + line_end); + + if (wtap_block_get_string_option_value(if_descr, OPT_IDB_HARDWARE, &tmp_content) == WTAP_OPTTYPE_SUCCESS) { + g_string_append_printf(info, + "%*cHardware = %s%s", indent, ' ', + tmp_content ? tmp_content : "NONE", + line_end); + } + + if (wtap_block_get_uint64_option_value(if_descr, OPT_IDB_SPEED, &tmp64) == WTAP_OPTTYPE_SUCCESS) { + g_string_append_printf(info, + "%*cSpeed = %" PRIu64 "%s", indent, ' ', + tmp64, + line_end); + } + + g_string_append_printf(info, + "%*cCapture length = %u%s", indent, ' ', + if_descr_mand->snap_len, + line_end); + + if (wtap_block_get_uint8_option_value(if_descr, OPT_IDB_FCSLEN, &tmp8) == WTAP_OPTTYPE_SUCCESS) { + g_string_append_printf(info, + "%*cFCS length = %u%s", indent, ' ', + tmp8, + line_end); + } + + g_string_append_printf(info, + "%*cTime precision = %s (%d)%s", indent, ' ', + wtap_tsprec_string(if_descr_mand->tsprecision), + if_descr_mand->tsprecision, + line_end); + + g_string_append_printf(info, + "%*cTime ticks per second = %" PRIu64 "%s", indent, ' ', + if_descr_mand->time_units_per_second, + line_end); + + if (wtap_block_get_uint8_option_value(if_descr, OPT_IDB_TSRESOL, &tmp8) == WTAP_OPTTYPE_SUCCESS) { + g_string_append_printf(info, + "%*cTime resolution = 0x%.2x%s", indent, ' ', + tmp8, + line_end); + } + + if (wtap_block_get_int64_option_value(if_descr, OPT_IDB_TSOFFSET, &itmp64) == WTAP_OPTTYPE_SUCCESS) { + g_string_append_printf(info, + "%*cTimestamp offset = %" G_GINT64_FORMAT "%s", indent, ' ', + itmp64, + line_end); + } + + if (wtap_block_get_if_filter_option_value(if_descr, OPT_IDB_FILTER, &if_filter) == WTAP_OPTTYPE_SUCCESS) { + switch (if_filter.type) { + + case if_filter_pcap: + g_string_append_printf(info, + "%*cFilter string = %s%s", indent, ' ', + if_filter.data.filter_str, + line_end); + break; + + case if_filter_bpf: + g_string_append_printf(info, + "%*cBPF filter length = %u%s", indent, ' ', + if_filter.data.bpf_prog.bpf_prog_len, + line_end); + break; + + default: + g_string_append_printf(info, + "%*cUnknown filter type %u%s", indent, ' ', + if_filter.type, + line_end); + break; + } + } + + if (wtap_block_get_string_option_value(if_descr, OPT_IDB_OS, &tmp_content) == WTAP_OPTTYPE_SUCCESS) { + g_string_append_printf(info, + "%*cOperating system = %s%s", indent, ' ', + tmp_content ? tmp_content : "UNKNOWN", + line_end); + } + + /* + * XXX - support multiple comments. + */ + if (wtap_block_get_nth_string_option_value(if_descr, OPT_COMMENT, 0, &tmp_content) == WTAP_OPTTYPE_SUCCESS) { + g_string_append_printf(info, + "%*cComment = %s%s", indent, ' ', + tmp_content ? tmp_content : "NONE", + line_end); + } + + g_string_append_printf(info, + "%*cNumber of stat entries = %u%s", indent, ' ', + if_descr_mand->num_stat_entries, + line_end); + + return g_string_free(info, FALSE); +} + +wtap_block_t +wtap_file_get_nrb(wtap *wth) +{ + if ((wth == NULL) || (wth->nrbs == NULL) || (wth->nrbs->len == 0)) + return NULL; + + return g_array_index(wth->nrbs, wtap_block_t, 0); +} + +GArray* +wtap_file_get_nrb_for_new_file(wtap *wth) +{ + guint nrb_count; + wtap_block_t nrb_src, nrb_dest; + GArray* nrbs; + + if ((wth == NULL || wth->nrbs == NULL) || (wth->nrbs->len == 0)) + return NULL; + + nrbs = g_array_new(FALSE, FALSE, sizeof(wtap_block_t)); + + for (nrb_count = 0; nrb_count < wth->nrbs->len; nrb_count++) { + nrb_src = g_array_index(wth->nrbs, wtap_block_t, nrb_count); + nrb_dest = wtap_block_make_copy(nrb_src); + g_array_append_val(nrbs, nrb_dest); + } + + return nrbs; +} + +void +wtap_dump_params_init(wtap_dump_params *params, wtap *wth) +{ + memset(params, 0, sizeof(*params)); + if (wth == NULL) + return; + + params->encap = wtap_file_encap(wth); + params->snaplen = wtap_snapshot_length(wth); + params->tsprec = wtap_file_tsprec(wth); + params->shb_hdrs = wtap_file_get_shb_for_new_file(wth); + params->idb_inf = wtap_file_get_idb_info(wth); + /* Assume that the input handle remains open until the dumper is closed. + * Refer to the DSBs from the input file, wtap_dump will then copy DSBs + * as they become available. */ + params->nrbs_growing = wth->nrbs; + params->dsbs_growing = wth->dsbs; + params->sysdig_mev_growing = wth->sysdig_meta_events; + params->dont_copy_idbs = FALSE; +} + +/* + * XXX - eventually, we should make this wtap_dump_params_init(), + * and have everything copy IDBs as they're read. + */ +void +wtap_dump_params_init_no_idbs(wtap_dump_params *params, wtap *wth) +{ + memset(params, 0, sizeof(*params)); + if (wth == NULL) + return; + + params->encap = wtap_file_encap(wth); + params->snaplen = wtap_snapshot_length(wth); + params->tsprec = wtap_file_tsprec(wth); + params->shb_hdrs = wtap_file_get_shb_for_new_file(wth); + params->idb_inf = wtap_file_get_idb_info(wth); + /* Assume that the input handle remains open until the dumper is closed. + * Refer to the DSBs from the input file, wtap_dump will then copy DSBs + * as they become available. */ + params->nrbs_growing = wth->nrbs; + params->dsbs_growing = wth->dsbs; + params->dont_copy_idbs = TRUE; +} + +void +wtap_dump_params_discard_name_resolution(wtap_dump_params *params) +{ + params->nrbs_growing = NULL; +} + +void +wtap_dump_params_discard_decryption_secrets(wtap_dump_params *params) +{ + params->dsbs_initial = NULL; + params->dsbs_growing = NULL; +} + +void +wtap_dump_params_discard_sysdig_meta_events(wtap_dump_params *params) +{ + params->sysdig_mev_growing = NULL; +} + +void +wtap_dump_params_cleanup(wtap_dump_params *params) +{ + wtap_block_array_free(params->shb_hdrs); + /* params->idb_inf is currently expected to be freed by the caller. */ + + memset(params, 0, sizeof(*params)); +} + +wtap_block_t +wtap_dump_params_generate_idb(const wtap_dump_params *params) +{ + return wtap_generate_idb(params->encap, params->tsprec, params->snaplen); +} + +/* Table of the encapsulation types we know about. */ +struct encap_type_info { + const char *name; + const char *description; +}; + +static struct encap_type_info encap_table_base[] = { + /* WTAP_ENCAP_UNKNOWN */ + { "unknown", "Unknown" }, + + /* WTAP_ENCAP_ETHERNET */ + { "ether", "Ethernet" }, + + /* WTAP_ENCAP_TOKEN_RING */ + { "tr", "Token Ring" }, + + /* WTAP_ENCAP_SLIP */ + { "slip", "SLIP" }, + + /* WTAP_ENCAP_PPP */ + { "ppp", "PPP" }, + + /* WTAP_ENCAP_FDDI */ + { "fddi", "FDDI" }, + + /* WTAP_ENCAP_FDDI_BITSWAPPED */ + { "fddi-swapped", "FDDI with bit-swapped MAC addresses" }, + + /* WTAP_ENCAP_RAW_IP */ + { "rawip", "Raw IP" }, + + /* WTAP_ENCAP_ARCNET */ + { "arcnet", "ARCNET" }, + + /* WTAP_ENCAP_ARCNET_LINUX */ + { "arcnet_linux", "Linux ARCNET" }, + + /* WTAP_ENCAP_ATM_RFC1483 */ + { "atm-rfc1483", "RFC 1483 ATM" }, + + /* WTAP_ENCAP_LINUX_ATM_CLIP */ + { "linux-atm-clip", "Linux ATM CLIP" }, + + /* WTAP_ENCAP_LAPB */ + { "lapb", "LAPB" }, + + /* WTAP_ENCAP_ATM_PDUS */ + { "atm-pdus", "ATM PDUs" }, + + /* WTAP_ENCAP_ATM_PDUS_UNTRUNCATED */ + { "atm-pdus-untruncated", "ATM PDUs - untruncated" }, + + /* WTAP_ENCAP_NULL */ + { "null", "NULL/Loopback" }, + + /* WTAP_ENCAP_ASCEND */ + { "ascend", "Lucent/Ascend access equipment" }, + + /* WTAP_ENCAP_ISDN */ + { "isdn", "ISDN" }, + + /* WTAP_ENCAP_IP_OVER_FC */ + { "ip-over-fc", "RFC 2625 IP-over-Fibre Channel" }, + + /* WTAP_ENCAP_PPP_WITH_PHDR */ + { "ppp-with-direction", "PPP with Directional Info" }, + + /* WTAP_ENCAP_IEEE_802_11 */ + { "ieee-802-11", "IEEE 802.11 Wireless LAN" }, + + /* WTAP_ENCAP_IEEE_802_11_PRISM */ + { "ieee-802-11-prism", "IEEE 802.11 plus Prism II monitor mode radio header" }, + + /* WTAP_ENCAP_IEEE_802_11_WITH_RADIO */ + { "ieee-802-11-radio", "IEEE 802.11 Wireless LAN with radio information" }, + + /* WTAP_ENCAP_IEEE_802_11_RADIOTAP */ + { "ieee-802-11-radiotap", "IEEE 802.11 plus radiotap radio header" }, + + /* WTAP_ENCAP_IEEE_802_11_AVS */ + { "ieee-802-11-avs", "IEEE 802.11 plus AVS radio header" }, + + /* WTAP_ENCAP_SLL */ + { "linux-sll", "Linux cooked-mode capture v1" }, + + /* WTAP_ENCAP_FRELAY */ + { "frelay", "Frame Relay" }, + + /* WTAP_ENCAP_FRELAY_WITH_PHDR */ + { "frelay-with-direction", "Frame Relay with Directional Info" }, + + /* WTAP_ENCAP_CHDLC */ + { "chdlc", "Cisco HDLC" }, + + /* WTAP_ENCAP_CISCO_IOS */ + { "ios", "Cisco IOS internal" }, + + /* WTAP_ENCAP_LOCALTALK */ + { "ltalk", "Localtalk" }, + + /* WTAP_ENCAP_OLD_PFLOG */ + { "pflog-old", "OpenBSD PF Firewall logs, pre-3.4" }, + + /* WTAP_ENCAP_HHDLC */ + { "hhdlc", "HiPath HDLC" }, + + /* WTAP_ENCAP_DOCSIS */ + { "docsis", "Data Over Cable Service Interface Specification" }, + + /* WTAP_ENCAP_COSINE */ + { "cosine", "CoSine L2 debug log" }, + + /* WTAP_ENCAP_WFLEET_HDLC */ + { "whdlc", "Wellfleet HDLC" }, + + /* WTAP_ENCAP_SDLC */ + { "sdlc", "SDLC" }, + + /* WTAP_ENCAP_TZSP */ + { "tzsp", "Tazmen sniffer protocol" }, + + /* WTAP_ENCAP_ENC */ + { "enc", "OpenBSD enc(4) encapsulating interface" }, + + /* WTAP_ENCAP_PFLOG */ + { "pflog", "OpenBSD PF Firewall logs" }, + + /* WTAP_ENCAP_CHDLC_WITH_PHDR */ + { "chdlc-with-direction", "Cisco HDLC with Directional Info" }, + + /* WTAP_ENCAP_BLUETOOTH_H4 */ + { "bluetooth-h4", "Bluetooth H4" }, + + /* WTAP_ENCAP_MTP2 */ + { "mtp2", "SS7 MTP2" }, + + /* WTAP_ENCAP_MTP3 */ + { "mtp3", "SS7 MTP3" }, + + /* WTAP_ENCAP_IRDA */ + { "irda", "IrDA" }, + + /* WTAP_ENCAP_USER0 */ + { "user0", "USER 0" }, + + /* WTAP_ENCAP_USER1 */ + { "user1", "USER 1" }, + + /* WTAP_ENCAP_USER2 */ + { "user2", "USER 2" }, + + /* WTAP_ENCAP_USER3 */ + { "user3", "USER 3" }, + + /* WTAP_ENCAP_USER4 */ + { "user4", "USER 4" }, + + /* WTAP_ENCAP_USER5 */ + { "user5", "USER 5" }, + + /* WTAP_ENCAP_USER6 */ + { "user6", "USER 6" }, + + /* WTAP_ENCAP_USER7 */ + { "user7", "USER 7" }, + + /* WTAP_ENCAP_USER8 */ + { "user8", "USER 8" }, + + /* WTAP_ENCAP_USER9 */ + { "user9", "USER 9" }, + + /* WTAP_ENCAP_USER10 */ + { "user10", "USER 10" }, + + /* WTAP_ENCAP_USER11 */ + { "user11", "USER 11" }, + + /* WTAP_ENCAP_USER12 */ + { "user12", "USER 12" }, + + /* WTAP_ENCAP_USER13 */ + { "user13", "USER 13" }, + + /* WTAP_ENCAP_USER14 */ + { "user14", "USER 14" }, + + /* WTAP_ENCAP_USER15 */ + { "user15", "USER 15" }, + + /* WTAP_ENCAP_SYMANTEC */ + { "symantec", "Symantec Enterprise Firewall" }, + + /* WTAP_ENCAP_APPLE_IP_OVER_IEEE1394 */ + { "ap1394", "Apple IP-over-IEEE 1394" }, + + /* WTAP_ENCAP_BACNET_MS_TP */ + { "bacnet-ms-tp", "BACnet MS/TP" }, + + /* WTAP_ENCAP_NETTL_RAW_ICMP */ + { "raw-icmp-nettl", "Raw ICMP with nettl headers" }, + + /* WTAP_ENCAP_NETTL_RAW_ICMPV6 */ + { "raw-icmpv6-nettl", "Raw ICMPv6 with nettl headers" }, + + /* WTAP_ENCAP_GPRS_LLC */ + { "gprs-llc", "GPRS LLC" }, + + /* WTAP_ENCAP_JUNIPER_ATM1 */ + { "juniper-atm1", "Juniper ATM1" }, + + /* WTAP_ENCAP_JUNIPER_ATM2 */ + { "juniper-atm2", "Juniper ATM2" }, + + /* WTAP_ENCAP_REDBACK */ + { "redback", "Redback SmartEdge" }, + + /* WTAP_ENCAP_NETTL_RAW_IP */ + { "rawip-nettl", "Raw IP with nettl headers" }, + + /* WTAP_ENCAP_NETTL_ETHERNET */ + { "ether-nettl", "Ethernet with nettl headers" }, + + /* WTAP_ENCAP_NETTL_TOKEN_RING */ + { "tr-nettl", "Token Ring with nettl headers" }, + + /* WTAP_ENCAP_NETTL_FDDI */ + { "fddi-nettl", "FDDI with nettl headers" }, + + /* WTAP_ENCAP_NETTL_UNKNOWN */ + { "unknown-nettl", "Unknown link-layer type with nettl headers" }, + + /* WTAP_ENCAP_MTP2_WITH_PHDR */ + { "mtp2-with-phdr", "MTP2 with pseudoheader" }, + + /* WTAP_ENCAP_JUNIPER_PPPOE */ + { "juniper-pppoe", "Juniper PPPoE" }, + + /* WTAP_ENCAP_GCOM_TIE1 */ + { "gcom-tie1", "GCOM TIE1" }, + + /* WTAP_ENCAP_GCOM_SERIAL */ + { "gcom-serial", "GCOM Serial" }, + + /* WTAP_ENCAP_NETTL_X25 */ + { "x25-nettl", "X.25 with nettl headers" }, + + /* WTAP_ENCAP_K12 */ + { "k12", "K12 protocol analyzer" }, + + /* WTAP_ENCAP_JUNIPER_MLPPP */ + { "juniper-mlppp", "Juniper MLPPP" }, + + /* WTAP_ENCAP_JUNIPER_MLFR */ + { "juniper-mlfr", "Juniper MLFR" }, + + /* WTAP_ENCAP_JUNIPER_ETHER */ + { "juniper-ether", "Juniper Ethernet" }, + + /* WTAP_ENCAP_JUNIPER_PPP */ + { "juniper-ppp", "Juniper PPP" }, + + /* WTAP_ENCAP_JUNIPER_FRELAY */ + { "juniper-frelay", "Juniper Frame-Relay" }, + + /* WTAP_ENCAP_JUNIPER_CHDLC */ + { "juniper-chdlc", "Juniper C-HDLC" }, + + /* WTAP_ENCAP_JUNIPER_GGSN */ + { "juniper-ggsn", "Juniper GGSN" }, + + /* WTAP_ENCAP_LINUX_LAPD */ + { "linux-lapd", "LAPD with Linux pseudo-header" }, + + /* WTAP_ENCAP_CATAPULT_DCT2000 */ + { "dct2000", "Catapult DCT2000" }, + + /* WTAP_ENCAP_BER */ + { "ber", "ASN.1 Basic Encoding Rules" }, + + /* WTAP_ENCAP_JUNIPER_VP */ + { "juniper-vp", "Juniper Voice PIC" }, + + /* WTAP_ENCAP_USB_FREEBSD */ + { "usb-freebsd", "USB packets with FreeBSD header" }, + + /* WTAP_ENCAP_IEEE802_16_MAC_CPS */ + { "ieee-802-16-mac-cps", "IEEE 802.16 MAC Common Part Sublayer" }, + + /* WTAP_ENCAP_NETTL_RAW_TELNET */ + { "raw-telnet-nettl", "Raw telnet with nettl headers" }, + + /* WTAP_ENCAP_USB_LINUX */ + { "usb-linux", "USB packets with Linux header" }, + + /* WTAP_ENCAP_MPEG */ + { "mpeg", "MPEG" }, + + /* WTAP_ENCAP_PPI */ + { "ppi", "Per-Packet Information header" }, + + /* WTAP_ENCAP_ERF */ + { "erf", "Extensible Record Format" }, + + /* WTAP_ENCAP_BLUETOOTH_H4_WITH_PHDR */ + { "bluetooth-h4-linux", "Bluetooth H4 with linux header" }, + + /* WTAP_ENCAP_SITA */ + { "sita-wan", "SITA WAN packets" }, + + /* WTAP_ENCAP_SCCP */ + { "sccp", "SS7 SCCP" }, + + /* WTAP_ENCAP_BLUETOOTH_HCI */ + { "bluetooth-hci", "Bluetooth without transport layer" }, + + /* WTAP_ENCAP_IPMB_KONTRON */ + { "ipmb-kontron", "Intelligent Platform Management Bus with Kontron pseudo-header" }, + + /* WTAP_ENCAP_IEEE802_15_4 */ + { "wpan", "IEEE 802.15.4 Wireless PAN" }, + + /* WTAP_ENCAP_X2E_XORAYA */ + { "x2e-xoraya", "X2E Xoraya" }, + + /* WTAP_ENCAP_FLEXRAY */ + { "flexray", "FlexRay" }, + + /* WTAP_ENCAP_LIN */ + { "lin", "Local Interconnect Network" }, + + /* WTAP_ENCAP_MOST */ + { "most", "Media Oriented Systems Transport" }, + + /* WTAP_ENCAP_CAN20B */ + { "can20b", "Controller Area Network 2.0B" }, + + /* WTAP_ENCAP_LAYER1_EVENT */ + { "layer1-event", "EyeSDN Layer 1 event" }, + + /* WTAP_ENCAP_X2E_SERIAL */ + { "x2e-serial", "X2E serial line capture" }, + + /* WTAP_ENCAP_I2C_LINUX */ + { "i2c-linux", "I2C with Linux-specific pseudo-header" }, + + /* WTAP_ENCAP_IEEE802_15_4_NONASK_PHY */ + { "wpan-nonask-phy", "IEEE 802.15.4 Wireless PAN non-ASK PHY" }, + + /* WTAP_ENCAP_TNEF */ + { "tnef", "Transport-Neutral Encapsulation Format" }, + + /* WTAP_ENCAP_USB_LINUX_MMAPPED */ + { "usb-linux-mmap", "USB packets with Linux header and padding" }, + + /* WTAP_ENCAP_GSM_UM */ + { "gsm_um", "GSM Um Interface" }, + + /* WTAP_ENCAP_DPNSS */ + { "dpnss_link", "Digital Private Signalling System No 1 Link Layer" }, + + /* WTAP_ENCAP_PACKETLOGGER */ + { "packetlogger", "Apple Bluetooth PacketLogger" }, + + /* WTAP_ENCAP_NSTRACE_1_0 */ + { "nstrace10", "NetScaler Encapsulation 1.0 of Ethernet" }, + + /* WTAP_ENCAP_NSTRACE_2_0 */ + { "nstrace20", "NetScaler Encapsulation 2.0 of Ethernet" }, + + /* WTAP_ENCAP_FIBRE_CHANNEL_FC2 */ + { "fc2", "Fibre Channel FC-2" }, + + /* WTAP_ENCAP_FIBRE_CHANNEL_FC2_WITH_FRAME_DELIMS */ + { "fc2sof", "Fibre Channel FC-2 With Frame Delimiter" }, + + /* WTAP_ENCAP_JPEG_JFIF */ + { "jfif", "JPEG/JFIF" }, + + /* WTAP_ENCAP_IPNET */ + { "ipnet", "Solaris IPNET" }, + + /* WTAP_ENCAP_SOCKETCAN */ + { "socketcan", "SocketCAN" }, + + /* WTAP_ENCAP_IEEE_802_11_NETMON */ + { "ieee-802-11-netmon", "IEEE 802.11 plus Network Monitor radio header" }, + + /* WTAP_ENCAP_IEEE802_15_4_NOFCS */ + { "wpan-nofcs", "IEEE 802.15.4 Wireless PAN with FCS not present" }, + + /* WTAP_ENCAP_RAW_IPFIX */ + { "ipfix", "RFC 5655/RFC 5101 IPFIX" }, + + /* WTAP_ENCAP_RAW_IP4 */ + { "rawip4", "Raw IPv4" }, + + /* WTAP_ENCAP_RAW_IP6 */ + { "rawip6", "Raw IPv6" }, + + /* WTAP_ENCAP_LAPD */ + { "lapd", "LAPD" }, + + /* WTAP_ENCAP_DVBCI */ + { "dvbci", "DVB-CI (Common Interface)" }, + + /* WTAP_ENCAP_MUX27010 */ + { "mux27010", "MUX27010" }, + + /* WTAP_ENCAP_MIME */ + { "mime", "MIME" }, + + /* WTAP_ENCAP_NETANALYZER */ + { "netanalyzer", "Hilscher netANALYZER" }, + + /* WTAP_ENCAP_NETANALYZER_TRANSPARENT */ + { "netanalyzer-transparent", "Hilscher netANALYZER-Transparent" }, + + /* WTAP_ENCAP_IP_OVER_IB */ + { "ip-over-ib", "IP over InfiniBand" }, + + /* WTAP_ENCAP_MPEG_2_TS */ + { "mp2ts", "ISO/IEC 13818-1 MPEG2-TS" }, + + /* WTAP_ENCAP_PPP_ETHER */ + { "pppoes", "PPP-over-Ethernet session" }, + + /* WTAP_ENCAP_NFC_LLCP */ + { "nfc-llcp", "NFC LLCP" }, + + /* WTAP_ENCAP_NFLOG */ + { "nflog", "NFLOG" }, + + /* WTAP_ENCAP_V5_EF */ + { "v5-ef", "V5 Envelope Function" }, + + /* WTAP_ENCAP_BACNET_MS_TP_WITH_PHDR */ + { "bacnet-ms-tp-with-direction", "BACnet MS/TP with Directional Info" }, + + /* WTAP_ENCAP_IXVERIWAVE */ + { "ixveriwave", "IxVeriWave header and stats block" }, + + /* WTAP_ENCAP_SDH */ + { "sdh", "SDH" }, + + /* WTAP_ENCAP_DBUS */ + { "dbus", "D-Bus" }, + + /* WTAP_ENCAP_AX25_KISS */ + { "ax25-kiss", "AX.25 with KISS header" }, + + /* WTAP_ENCAP_AX25 */ + { "ax25", "Amateur Radio AX.25" }, + + /* WTAP_ENCAP_SCTP */ + { "sctp", "SCTP" }, + + /* WTAP_ENCAP_INFINIBAND */ + { "infiniband", "InfiniBand" }, + + /* WTAP_ENCAP_JUNIPER_SVCS */ + { "juniper-svcs", "Juniper Services" }, + + /* WTAP_ENCAP_USBPCAP */ + { "usb-usbpcap", "USB packets with USBPcap header" }, + + /* WTAP_ENCAP_RTAC_SERIAL */ + { "rtac-serial", "RTAC serial-line" }, + + /* WTAP_ENCAP_BLUETOOTH_LE_LL */ + { "bluetooth-le-ll", "Bluetooth Low Energy Link Layer" }, + + /* WTAP_ENCAP_WIRESHARK_UPPER_PDU */ + { "wireshark-upper-pdu", "Wireshark Upper PDU export" }, + + /* WTAP_ENCAP_STANAG_4607 */ + { "s4607", "STANAG 4607" }, + + /* WTAP_ENCAP_STANAG_5066_D_PDU */ + { "s5066-dpdu", "STANAG 5066 Data Transfer Sublayer PDUs(D_PDU)" }, + + /* WTAP_ENCAP_NETLINK */ + { "netlink", "Linux Netlink" }, + + /* WTAP_ENCAP_BLUETOOTH_LINUX_MONITOR */ + { "bluetooth-linux-monitor", "Bluetooth Linux Monitor" }, + + /* WTAP_ENCAP_BLUETOOTH_BREDR_BB */ + { "bluetooth-bredr-bb-rf", "Bluetooth BR/EDR Baseband RF" }, + + /* WTAP_ENCAP_BLUETOOTH_LE_LL_WITH_PHDR */ + { "bluetooth-le-ll-rf", "Bluetooth Low Energy Link Layer RF" }, + + /* WTAP_ENCAP_NSTRACE_3_0 */ + { "nstrace30", "NetScaler Encapsulation 3.0 of Ethernet" }, + + /* WTAP_ENCAP_LOGCAT */ + { "logcat", "Android Logcat Binary format" }, + + /* WTAP_ENCAP_LOGCAT_BRIEF */ + { "logcat_brief", "Android Logcat Brief text format" }, + + /* WTAP_ENCAP_LOGCAT_PROCESS */ + { "logcat_process", "Android Logcat Process text format" }, + + /* WTAP_ENCAP_LOGCAT_TAG */ + { "logcat_tag", "Android Logcat Tag text format" }, + + /* WTAP_ENCAP_LOGCAT_THREAD */ + { "logcat_thread", "Android Logcat Thread text format" }, + + /* WTAP_ENCAP_LOGCAT_TIME */ + { "logcat_time", "Android Logcat Time text format" }, + + /* WTAP_ENCAP_LOGCAT_THREADTIME */ + { "logcat_threadtime", "Android Logcat Threadtime text format" }, + + /* WTAP_ENCAP_LOGCAT_LONG */ + { "logcat_long", "Android Logcat Long text format" }, + + /* WTAP_ENCAP_PKTAP */ + { "pktap", "Apple PKTAP" }, + + /* WTAP_ENCAP_EPON */ + { "epon", "Ethernet Passive Optical Network" }, + + /* WTAP_ENCAP_IPMI_TRACE */ + { "ipmi-trace", "IPMI Trace Data Collection" }, + + /* WTAP_ENCAP_LOOP */ + { "loop", "OpenBSD loopback" }, + + /* WTAP_ENCAP_JSON */ + { "json", "JavaScript Object Notation" }, + + /* WTAP_ENCAP_NSTRACE_3_5 */ + { "nstrace35", "NetScaler Encapsulation 3.5 of Ethernet" }, + + /* WTAP_ENCAP_ISO14443 */ + { "iso14443", "ISO 14443 contactless smartcard standards" }, + + /* WTAP_ENCAP_GFP_T */ + { "gfp-t", "ITU-T G.7041/Y.1303 Generic Framing Procedure Transparent mode" }, + + /* WTAP_ENCAP_GFP_F */ + { "gfp-f", "ITU-T G.7041/Y.1303 Generic Framing Procedure Frame-mapped mode" }, + + /* WTAP_ENCAP_IP_OVER_IB_PCAP */ + { "ip-ib", "IP over IB" }, + + /* WTAP_ENCAP_JUNIPER_VN */ + { "juniper-vn", "Juniper VN" }, + + /* WTAP_ENCAP_USB_DARWIN */ + { "usb-darwin", "USB packets with Darwin (macOS, etc.) headers" }, + + /* WTAP_ENCAP_LORATAP */ + { "loratap", "LoRaTap" }, + + /* WTAP_ENCAP_3MB_ETHERNET */ + { "xeth", "Xerox 3MB Ethernet" }, + + /* WTAP_ENCAP_VSOCK */ + { "vsock", "Linux vsock" }, + + /* WTAP_ENCAP_NORDIC_BLE */ + { "nordic_ble", "nRF Sniffer for Bluetooth LE" }, + + /* WTAP_ENCAP_NETMON_NET_NETEVENT */ + { "netmon_event", "Network Monitor Network Event" }, + + /* WTAP_ENCAP_NETMON_HEADER */ + { "netmon_header", "Network Monitor Header" }, + + /* WTAP_ENCAP_NETMON_NET_FILTER */ + { "netmon_filter", "Network Monitor Filter" }, + + /* WTAP_ENCAP_NETMON_NETWORK_INFO_EX */ + { "netmon_network_info", "Network Monitor Network Info" }, + + /* WTAP_ENCAP_MA_WFP_CAPTURE_V4 */ + { "message_analyzer_wfp_capture_v4", "Message Analyzer WFP Capture v4" }, + + /* WTAP_ENCAP_MA_WFP_CAPTURE_V6 */ + { "message_analyzer_wfp_capture_v6", "Message Analyzer WFP Capture v6" }, + + /* WTAP_ENCAP_MA_WFP_CAPTURE_2V4 */ + { "message_analyzer_wfp_capture2_v4", "Message Analyzer WFP Capture2 v4" }, + + /* WTAP_ENCAP_MA_WFP_CAPTURE_2V6 */ + { "message_analyzer_wfp_capture2_v6", "Message Analyzer WFP Capture2 v6" }, + + /* WTAP_ENCAP_MA_WFP_CAPTURE_AUTH_V4 */ + { "message_analyzer_wfp_capture_auth_v4", "Message Analyzer WFP Capture Auth v4" }, + + /* WTAP_ENCAP_MA_WFP_CAPTURE_AUTH_V6 */ + { "message_analyzer_wfp_capture_auth_v6", "Message Analyzer WFP Capture Auth v6" }, + + /* WTAP_ENCAP_JUNIPER_ST */ + { "juniper-st", "Juniper Secure Tunnel Information" }, + + /* WTAP_ENCAP_ETHERNET_MPACKET */ + { "ether-mpacket", "IEEE 802.3br mPackets" }, + + /* WTAP_ENCAP_DOCSIS31_XRA31 */ + { "docsis31_xra31", "DOCSIS with Excentis XRA pseudo-header" }, + + /* WTAP_ENCAP_DPAUXMON */ + { "dpauxmon", "DisplayPort AUX channel with Unigraf pseudo-header" }, + + /* WTAP_ENCAP_RUBY_MARSHAL */ + { "ruby_marshal", "Ruby marshal object" }, + + /* WTAP_ENCAP_RFC7468 */ + { "rfc7468", "RFC 7468 file" }, + + /* WTAP_ENCAP_SYSTEMD_JOURNAL */ + { "sdjournal", "systemd journal" }, + + /* WTAP_ENCAP_EBHSCR */ + { "ebhscr", "Elektrobit High Speed Capture and Replay" }, + + /* WTAP_ENCAP_VPP */ + { "vpp", "Vector Packet Processing graph dispatch trace" }, + + /* WTAP_ENCAP_IEEE802_15_4_TAP */ + { "wpan-tap", "IEEE 802.15.4 Wireless with TAP pseudo-header" }, + + /* WTAP_ENCAP_LOG_3GPP */ + { "log_3GPP", "3GPP Phone Log" }, + + /* WTAP_ENCAP_USB_2_0 */ + { "usb-20", "USB 2.0/1.1/1.0 packets" }, + + /* WTAP_ENCAP_MP4 */ + { "mp4", "MP4 files" }, + + /* WTAP_ENCAP_SLL2 */ + { "linux-sll2", "Linux cooked-mode capture v2" }, + + /* WTAP_ENCAP_ZWAVE_SERIAL */ + { "zwave-serial", "Z-Wave Serial API packets" }, + + /* WTAP_ENCAP_ETW */ + { "etw", "Event Tracing for Windows messages" }, + + /* WTAP_ENCAP_ERI_ENB_LOG */ + { "eri_enb_log", "Ericsson eNode-B raw log" }, + + /* WTAP_ENCAP_ZBNCP */ + { "zbncp", "ZBOSS NCP" }, + + /* WTAP_ENCAP_USB_2_0_LOW_SPEED */ + { "usb-20-low", "Low-Speed USB 2.0/1.1/1.0 packets" }, + + /* WTAP_ENCAP_USB_2_0_FULL_SPEED */ + { "usb-20-full", "Full-Speed USB 2.0/1.1/1.0 packets" }, + + /* WTAP_ENCAP_USB_2_0_HIGH_SPEED */ + { "usb-20-high", "High-Speed USB 2.0 packets" }, + + /* WTAP_ENCAP_AUTOSAR_DLT */ + { "autosardlt", "AUTOSAR DLT" }, + + /* WTAP_ENCAP_AUERSWALD_LOG */ + { "auerlog", "Auerswald Log" }, + + /* WTAP_ENCAP_ATSC_ALP */ + { "alp", "ATSC Link-Layer Protocol (A/330) packets" }, + + /* WTAP_ENCAP_FIRA_UCI */ + { "fira-uci", "FiRa UWB Controller Interface (UCI) protocol." }, + + /* WTAP_ENCAP_SILABS_DEBUG_CHANNEL */ + { "silabs-dch", "Silabs Debug Channel"}, + + /* WTAP_ENCAP_MDB */ + { "mdb", "MDB (Multi-Drop Bus)"}, +}; + +WS_DLL_LOCAL +gint wtap_num_encap_types = sizeof(encap_table_base) / sizeof(struct encap_type_info); +static GArray* encap_table_arr = NULL; + +#define encap_table_entry(encap) \ + g_array_index(encap_table_arr, struct encap_type_info, encap) + +static void wtap_init_encap_types(void) { + + if (encap_table_arr) return; + + encap_table_arr = g_array_new(FALSE,TRUE,sizeof(struct encap_type_info)); + + g_array_append_vals(encap_table_arr,encap_table_base,wtap_num_encap_types); +} + +static void wtap_cleanup_encap_types(void) { + if (encap_table_arr) { + g_array_free(encap_table_arr, TRUE); + encap_table_arr = NULL; + } +} + +int wtap_get_num_encap_types(void) { + return wtap_num_encap_types; +} + + +int +wtap_register_encap_type(const char *description, const char *name) +{ + struct encap_type_info e; + + e.name = g_strdup(name); + e.description = g_strdup(description); + + g_array_append_val(encap_table_arr,e); + + return wtap_num_encap_types++; +} + +/* Name to use in, say, a command-line flag specifying the type. */ +const char * +wtap_encap_name(int encap) +{ + if (encap < WTAP_ENCAP_NONE || encap >= WTAP_NUM_ENCAP_TYPES) + return "illegal"; + else if (encap == WTAP_ENCAP_NONE) + return "none"; + else if (encap == WTAP_ENCAP_PER_PACKET) + return "per-packet"; + else + return encap_table_entry(encap).name; +} + +/* Description to show to users. */ +const char * +wtap_encap_description(int encap) +{ + if (encap < WTAP_ENCAP_NONE || encap >= WTAP_NUM_ENCAP_TYPES) + return "Illegal"; + else if (encap == WTAP_ENCAP_NONE) + return "None"; + else if (encap == WTAP_ENCAP_PER_PACKET) + return "Per packet"; + else + return encap_table_entry(encap).description; +} + +/* Translate a name to a capture file type. */ +int +wtap_name_to_encap(const char *name) +{ + int encap; + + for (encap = 0; encap < WTAP_NUM_ENCAP_TYPES; encap++) { + if (encap_table_entry(encap).name != NULL && + strcmp(name, encap_table_entry(encap).name) == 0) + return encap; + } + return -1; /* no such encapsulation type */ +} + +/* + * For precision values that correspond to a specific precision. + */ +static const char *precnames[NUM_WS_TSPREC_VALS] = { + "seconds", + "100 milliseconds (deciseconds)", + "10 milliseconds (centiseconds)", + "milliseconds", + "100 microseconds", + "10 microseconds", + "microseconds", + "100 nanoseconds", + "10 nanoseconds", + "nanoseconds", +}; + +const char* +wtap_tsprec_string(int tsprec) +{ + const char* s; + if (tsprec == WTAP_TSPREC_PER_PACKET) + s = "per-packet"; + else if (tsprec >= 0 && tsprec < NUM_WS_TSPREC_VALS) + s = precnames[tsprec]; + else if (tsprec == WTAP_TSPREC_UNKNOWN) + s = "UNKNOWN"; + else + s = "INVALID"; + return s; +} + +static const char *wtap_errlist[] = { + /* WTAP_ERR_NOT_REGULAR_FILE */ + "The file isn't a plain file or pipe", + + /* WTAP_ERR_RANDOM_OPEN_PIPE */ + "The file is being opened for random access but is a pipe", + + /* WTAP_ERR_FILE_UNKNOWN_FORMAT */ + "The file isn't a capture file in a known format", + + /* WTAP_ERR_UNSUPPORTED */ + "File contains record data we don't support", + + /* WTAP_ERR_CANT_WRITE_TO_PIPE */ + "That file format cannot be written to a pipe", + + /* WTAP_ERR_CANT_OPEN */ + NULL, + + /* WTAP_ERR_UNWRITABLE_FILE_TYPE */ + "Files can't be saved in that format", + + /* WTAP_ERR_UNWRITABLE_ENCAP */ + "Packets with that network type can't be saved in that format", + + /* WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED */ + "That file format doesn't support per-packet encapsulations", + + /* WTAP_ERR_CANT_WRITE */ + "A write failed for some unknown reason", + + /* WTAP_ERR_CANT_CLOSE */ + NULL, + + /* WTAP_ERR_SHORT_READ */ + "Less data was read than was expected", + + /* WTAP_ERR_BAD_FILE */ + "The file appears to be damaged or corrupt", + + /* WTAP_ERR_SHORT_WRITE */ + "Less data was written than was requested", + + /* WTAP_ERR_UNC_OVERFLOW */ + "Uncompression error: data would overflow buffer", + + /* WTAP_ERR_RANDOM_OPEN_STDIN */ + "The standard input cannot be opened for random access", + + /* WTAP_ERR_COMPRESSION_NOT_SUPPORTED */ + "That file format doesn't support compression", + + /* WTAP_ERR_CANT_SEEK */ + NULL, + + /* WTAP_ERR_CANT_SEEK_COMPRESSED */ + NULL, + + /* WTAP_ERR_DECOMPRESS */ + "Uncompression error", + + /* WTAP_ERR_INTERNAL */ + "Internal error", + + /* WTAP_ERR_PACKET_TOO_LARGE */ + "The packet being written is too large for that format", + + /* WTAP_ERR_CHECK_WSLUA */ + NULL, + + /* WTAP_ERR_UNWRITABLE_REC_TYPE */ + "That record type cannot be written in that format", + + /* WTAP_ERR_UNWRITABLE_REC_DATA */ + "That record can't be written in that format", + + /* WTAP_ERR_DECOMPRESSION_NOT_SUPPORTED */ + "We don't support decompressing that type of compressed file", + + /* WTAP_ERR_TIME_STAMP_NOT_SUPPORTED */ + "We don't support writing that record's time stamp to that file type", +}; +#define WTAP_ERRLIST_SIZE (sizeof wtap_errlist / sizeof wtap_errlist[0]) + +const char * +wtap_strerror(int err) +{ + static char errbuf[128]; + unsigned int wtap_errlist_index; + + if (err < 0) { + wtap_errlist_index = -1 - err; + if (wtap_errlist_index >= WTAP_ERRLIST_SIZE) { + snprintf(errbuf, 128, "Error %d", err); + return errbuf; + } + if (wtap_errlist[wtap_errlist_index] == NULL) + return "Unknown reason"; + return wtap_errlist[wtap_errlist_index]; + } else + return g_strerror(err); +} + +/* Close only the sequential side, freeing up memory it uses. + + Note that we do *not* want to call the subtype's close function, + as it would free any per-subtype data, and that data may be + needed by the random-access side. + + Instead, if the subtype has a "sequential close" function, we call it, + to free up stuff used only by the sequential side. */ +void +wtap_sequential_close(wtap *wth) +{ + if (wth->subtype_sequential_close != NULL) + (*wth->subtype_sequential_close)(wth); + + if (wth->fh != NULL) { + file_close(wth->fh); + wth->fh = NULL; + } +} + +static void +g_fast_seek_item_free(gpointer data, gpointer user_data _U_) +{ + g_free(data); +} + +/* + * Close the file descriptors for the sequential and random streams, but + * don't discard any information about those streams. Used on Windows if + * we need to rename a file that we have open or if we need to rename on + * top of a file we have open. + */ +void +wtap_fdclose(wtap *wth) +{ + if (wth->fh != NULL) + file_fdclose(wth->fh); + if (wth->random_fh != NULL) + file_fdclose(wth->random_fh); +} + +void +wtap_close(wtap *wth) +{ + wtap_sequential_close(wth); + + if (wth->subtype_close != NULL) + (*wth->subtype_close)(wth); + + if (wth->random_fh != NULL) + file_close(wth->random_fh); + + g_free(wth->priv); + + g_free(wth->pathname); + + if (wth->fast_seek != NULL) { + g_ptr_array_foreach(wth->fast_seek, g_fast_seek_item_free, NULL); + g_ptr_array_free(wth->fast_seek, TRUE); + } + + wtap_block_array_free(wth->shb_hdrs); + wtap_block_array_free(wth->nrbs); + wtap_block_array_free(wth->interface_data); + wtap_block_array_free(wth->dsbs); + wtap_block_array_free(wth->sysdig_meta_events); + + g_free(wth); +} + +void +wtap_cleareof(wtap *wth) { + /* Reset EOF */ + file_clearerr(wth->fh); +} + +static inline void +wtapng_process_nrb_ipv4(wtap *wth, wtap_block_t nrb) +{ + const wtapng_nrb_mandatory_t *nrb_mand = (wtapng_nrb_mandatory_t*)wtap_block_get_mandatory_data(nrb); + + if (wth->add_new_ipv4) { + for (GList *elem = nrb_mand->ipv4_addr_list; elem != NULL; elem = elem->next) { + hashipv4_t *tp = elem->data; + wth->add_new_ipv4(tp->addr, tp->name, FALSE); + } + } +} + +static inline void +wtapng_process_nrb_ipv6(wtap *wth, wtap_block_t nrb) +{ + const wtapng_nrb_mandatory_t *nrb_mand = (wtapng_nrb_mandatory_t*)wtap_block_get_mandatory_data(nrb); + + if (wth->add_new_ipv6) { + for (GList *elem = nrb_mand->ipv6_addr_list; elem != NULL; elem = elem->next) { + hashipv6_t *tp = elem->data; + wth->add_new_ipv6(tp->addr, tp->name, FALSE); + } + } +} + +void wtap_set_cb_new_ipv4(wtap *wth, wtap_new_ipv4_callback_t add_new_ipv4) { + if (!wth) + return; + + wth->add_new_ipv4 = add_new_ipv4; + + /* Are there any existing NRBs? */ + if (!wth->nrbs) + return; + /* + * Send all NRBs that were read so far to the new callback. file.c + * relies on this to support redissection (during redissection, the + * previous name resolutions are lost and has to be resupplied). + */ + for (guint i = 0; i < wth->nrbs->len; i++) { + wtap_block_t nrb = g_array_index(wth->nrbs, wtap_block_t, i); + wtapng_process_nrb_ipv4(wth, nrb); + } +} + +void wtap_set_cb_new_ipv6(wtap *wth, wtap_new_ipv6_callback_t add_new_ipv6) { + if (!wth) + return; + + wth->add_new_ipv6 = add_new_ipv6; + + /* Are there any existing NRBs? */ + if (!wth->nrbs) + return; + /* + * Send all NRBs that were read so far to the new callback. file.c + * relies on this to support redissection (during redissection, the + * previous name resolutions are lost and has to be resupplied). + */ + for (guint i = 0; i < wth->nrbs->len; i++) { + wtap_block_t nrb = g_array_index(wth->nrbs, wtap_block_t, i); + wtapng_process_nrb_ipv6(wth, nrb); + } +} + +void +wtapng_process_nrb(wtap *wth, wtap_block_t nrb) +{ + wtapng_process_nrb_ipv4(wth, nrb); + wtapng_process_nrb_ipv6(wth, nrb); +} + +void wtap_set_cb_new_secrets(wtap *wth, wtap_new_secrets_callback_t add_new_secrets) { + /* Is a valid wth given that supports DSBs? */ + if (!wth || !wth->dsbs) + return; + + wth->add_new_secrets = add_new_secrets; + /* + * Send all DSBs that were read so far to the new callback. file.c + * relies on this to support redissection (during redissection, the + * previous secrets are lost and has to be resupplied). + */ + for (guint i = 0; i < wth->dsbs->len; i++) { + wtap_block_t dsb = g_array_index(wth->dsbs, wtap_block_t, i); + wtapng_process_dsb(wth, dsb); + } +} + +void +wtapng_process_dsb(wtap *wth, wtap_block_t dsb) +{ + const wtapng_dsb_mandatory_t *dsb_mand = (wtapng_dsb_mandatory_t*)wtap_block_get_mandatory_data(dsb); + + if (wth->add_new_secrets) + wth->add_new_secrets(dsb_mand->secrets_type, dsb_mand->secrets_data, dsb_mand->secrets_len); +} + +void +wtapng_process_sysdig_meta_event(wtap *wth, wtap_block_t mev) +{ + const wtapng_sysdig_mev_mandatory_t *mev_mand = (wtapng_sysdig_mev_mandatory_t*)wtap_block_get_mandatory_data(mev); + + if (wth->add_new_sysdig_meta_event) + wth->add_new_sysdig_meta_event(mev_mand->mev_type, mev_mand->mev_data, mev_mand->mev_data_len); +} + +/* Perform per-packet initialization */ +static void +wtap_init_rec(wtap *wth, wtap_rec *rec) +{ + /* + * Set the packet encapsulation to the file's encapsulation + * value; if that's not WTAP_ENCAP_PER_PACKET, it's the + * right answer (and means that the read routine for this + * capture file type doesn't have to set it), and if it + * *is* WTAP_ENCAP_PER_PACKET, the caller needs to set it + * anyway. + * + * Do the same for the packet time stamp resolution. + */ + rec->rec_header.packet_header.pkt_encap = wth->file_encap; + rec->tsprec = wth->file_tsprec; + rec->block = NULL; + rec->block_was_modified = FALSE; + + /* + * Assume the file has only one section; the module for the + * file type needs to indicate the section number if there's + * more than one section. + */ + rec->section_number = 0; +} + +gboolean +wtap_read(wtap *wth, wtap_rec *rec, Buffer *buf, int *err, + gchar **err_info, gint64 *offset) +{ + /* + * Initialize the record to default values. + */ + wtap_init_rec(wth, rec); + ws_buffer_clean(buf); + + *err = 0; + *err_info = NULL; + if (!wth->subtype_read(wth, rec, buf, err, err_info, offset)) { + /* + * If we didn't get an error indication, we read + * the last packet. See if there's any deferred + * error, as might, for example, occur if we're + * reading a compressed file, and we got an error + * reading compressed data from the file, but + * got enough compressed data to decompress the + * last packet of the file. + */ + if (*err == 0) + *err = file_error(wth->fh, err_info); + if (rec->block != NULL) { + /* + * Unreference any block created for this record. + */ + wtap_block_unref(rec->block); + rec->block = NULL; + } + return FALSE; /* failure */ + } + + /* + * Is this a packet record? + */ + if (rec->rec_type == REC_TYPE_PACKET) { + /* + * Make sure that it's not WTAP_ENCAP_PER_PACKET, as that + * probably means the file has that encapsulation type + * but the read routine didn't set this packet's + * encapsulation type. + */ + ws_assert(rec->rec_header.packet_header.pkt_encap != WTAP_ENCAP_PER_PACKET); + ws_assert(rec->rec_header.packet_header.pkt_encap != WTAP_ENCAP_NONE); + } + + return TRUE; /* success */ +} + +/* + * Read a given number of bytes from a file into a buffer or, if + * buf is NULL, just discard them. + * + * If we succeed, return TRUE. + * + * If we get an EOF, return FALSE with *err set to 0, reporting this + * as an EOF. + * + * If we get fewer bytes than the specified number, return FALSE with + * *err set to WTAP_ERR_SHORT_READ, reporting this as a short read + * error. + * + * If we get a read error, return FALSE with *err and *err_info set + * appropriately. + */ +gboolean +wtap_read_bytes_or_eof(FILE_T fh, void *buf, unsigned int count, int *err, + gchar **err_info) +{ + int bytes_read; + + bytes_read = file_read(buf, count, fh); + if (bytes_read < 0 || (guint)bytes_read != count) { + *err = file_error(fh, err_info); + if (*err == 0 && bytes_read > 0) + *err = WTAP_ERR_SHORT_READ; + return FALSE; + } + return TRUE; +} + +/* + * Read a given number of bytes from a file into a buffer or, if + * buf is NULL, just discard them. + * + * If we succeed, return TRUE. + * + * If we get fewer bytes than the specified number, including getting + * an EOF, return FALSE with *err set to WTAP_ERR_SHORT_READ, reporting + * this as a short read error. + * + * If we get a read error, return FALSE with *err and *err_info set + * appropriately. + */ +gboolean +wtap_read_bytes(FILE_T fh, void *buf, unsigned int count, int *err, + gchar **err_info) +{ + int bytes_read; + + bytes_read = file_read(buf, count, fh); + if (bytes_read < 0 || (guint)bytes_read != count) { + *err = file_error(fh, err_info); + if (*err == 0) + *err = WTAP_ERR_SHORT_READ; + return FALSE; + } + return TRUE; +} + +/* + * Read packet data into a Buffer, growing the buffer as necessary. + * + * This returns an error on a short read, even if the short read hit + * the EOF immediately. (The assumption is that each packet has a + * header followed by raw packet data, and that we've already read the + * header, so if we get an EOF trying to read the packet data, the file + * has been cut short, even if the read didn't read any data at all.) + */ +gboolean +wtap_read_packet_bytes(FILE_T fh, Buffer *buf, guint length, int *err, + gchar **err_info) +{ + gboolean rv; + ws_buffer_assure_space(buf, length); + rv = wtap_read_bytes(fh, ws_buffer_end_ptr(buf), length, err, + err_info); + if (rv) { + ws_buffer_increase_length(buf, length); + } + return rv; +} + +/* + * Return an approximation of the amount of data we've read sequentially + * from the file so far. (gint64, in case that's 64 bits.) + */ +gint64 +wtap_read_so_far(wtap *wth) +{ + return file_tell_raw(wth->fh); +} + +/* Perform global/initial initialization */ +void +wtap_rec_init(wtap_rec *rec) +{ + memset(rec, 0, sizeof *rec); + ws_buffer_init(&rec->options_buf, 0); + /* In the future, see if we can create rec->block here once + * and have it be reused like the rest of rec. + * Currently it's recreated for each packet. + */ +} + +/* re-initialize record */ +void +wtap_rec_reset(wtap_rec *rec) +{ + wtap_block_unref(rec->block); + rec->block = NULL; + rec->block_was_modified = FALSE; +} + +/* clean up record metadata */ +void +wtap_rec_cleanup(wtap_rec *rec) +{ + wtap_rec_reset(rec); + ws_buffer_free(&rec->options_buf); +} + +wtap_block_t +wtap_rec_generate_idb(const wtap_rec *rec) +{ + int tsprec; + ws_assert(rec->rec_type == REC_TYPE_PACKET); + if (rec->presence_flags & WTAP_HAS_TS) { + tsprec = rec->tsprec; + } else { + tsprec = WTAP_TSPREC_USEC; + /* The default */ + } + return wtap_generate_idb(rec->rec_header.packet_header.pkt_encap, tsprec, 0); +} + +gboolean +wtap_seek_read(wtap *wth, gint64 seek_off, wtap_rec *rec, Buffer *buf, + int *err, gchar **err_info) +{ + /* + * Initialize the record to default values. + */ + wtap_init_rec(wth, rec); + ws_buffer_clean(buf); + + *err = 0; + *err_info = NULL; + if (!wth->subtype_seek_read(wth, seek_off, rec, buf, err, err_info)) { + if (rec->block != NULL) { + /* + * Unreference any block created for this record. + */ + wtap_block_unref(rec->block); + rec->block = NULL; + } + return FALSE; + } + + /* + * Is this a packet record? + */ + if (rec->rec_type == REC_TYPE_PACKET) { + /* + * Make sure that it's not WTAP_ENCAP_PER_PACKET, as that + * probably means the file has that encapsulation type + * but the read routine didn't set this packet's + * encapsulation type. + */ + ws_assert(rec->rec_header.packet_header.pkt_encap != WTAP_ENCAP_PER_PACKET); + ws_assert(rec->rec_header.packet_header.pkt_encap != WTAP_ENCAP_NONE); + } + + return TRUE; +} + +static gboolean +wtap_full_file_read_file(wtap *wth, FILE_T fh, wtap_rec *rec, Buffer *buf, int *err, gchar **err_info) +{ + gint64 file_size; + int packet_size = 0; + const int block_size = 1024 * 1024; + + if ((file_size = wtap_file_size(wth, err)) == -1) + return FALSE; + + if (file_size > G_MAXINT) { + /* + * Avoid allocating space for an immensely-large file. + */ + *err = WTAP_ERR_BAD_FILE; + *err_info = ws_strdup_printf("%s: File has %" PRId64 "-byte packet, bigger than maximum of %u", + wtap_encap_name(wth->file_encap), file_size, G_MAXINT); + return FALSE; + } + + /* + * Compressed files might expand to a larger size than the actual file + * size. Try to read the full size and then read in smaller increments + * to avoid frequent memory reallocations. + */ + int buffer_size = block_size * (1 + (int)file_size / block_size); + for (;;) { + if (buffer_size <= 0) { + *err = WTAP_ERR_BAD_FILE; + *err_info = ws_strdup_printf("%s: Uncompressed file is bigger than maximum of %u", + wtap_encap_name(wth->file_encap), G_MAXINT); + return FALSE; + } + ws_buffer_assure_space(buf, buffer_size); + int nread = file_read(ws_buffer_start_ptr(buf) + packet_size, buffer_size - packet_size, fh); + if (nread < 0) { + *err = file_error(fh, err_info); + if (*err == 0) + *err = WTAP_ERR_BAD_FILE; + return FALSE; + } + packet_size += nread; + if (packet_size != buffer_size) { + /* EOF */ + break; + } + buffer_size += block_size; + } + + rec->rec_type = REC_TYPE_PACKET; + rec->presence_flags = 0; /* yes, we have no bananas^Wtime stamp */ + rec->ts.secs = 0; + rec->ts.nsecs = 0; + rec->rec_header.packet_header.caplen = packet_size; + rec->rec_header.packet_header.len = packet_size; + + return TRUE; +} + +gboolean +wtap_full_file_read(wtap *wth, wtap_rec *rec, Buffer *buf, + int *err, gchar **err_info, gint64 *data_offset) +{ + gint64 offset = file_tell(wth->fh); + + /* There is only one packet with the full file contents. */ + if (offset != 0) { + *err = 0; + return FALSE; + } + + *data_offset = offset; + return wtap_full_file_read_file(wth, wth->fh, rec, buf, err, err_info); +} + +gboolean +wtap_full_file_seek_read(wtap *wth, gint64 seek_off, wtap_rec *rec, Buffer *buf, int *err, gchar **err_info) +{ + /* There is only one packet with the full file contents. */ + if (seek_off > 0) { + *err = 0; + return FALSE; + } + + if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1) + return FALSE; + + return wtap_full_file_read_file(wth, wth->random_fh, rec, buf, err, err_info); +} + +void +wtap_buffer_append_epdu_tag(Buffer *buf, guint16 epdu_tag, const guint8 *data, guint16 data_len) +{ + guint8 pad_len = 0; + guint space_needed = 4; /* 2 for tag field, 2 for length field */ + guint8 *buf_data; + + if (epdu_tag != 0 && data != NULL && data_len != 0) { + pad_len += PADDING4(data_len); + space_needed += data_len + pad_len; + } + else { + data_len = 0; + } + + ws_buffer_assure_space(buf, space_needed); + buf_data = ws_buffer_end_ptr(buf); + memset(buf_data, 0, space_needed); + phton16(buf_data + 0, epdu_tag); + /* It seems as though the convention for exported_pdu is to specify + * the fully-padded length of the tag value, not just its useful length. + * e.g. the string value 'a' would be given a length of 4. + */ + phton16(buf_data + 2, data_len + pad_len); + if (data_len > 0) { + /* Still only copy as many bytes as we actually have */ + memcpy(buf_data + 4, data, data_len); + } + ws_buffer_increase_length(buf, space_needed); +} + +void +wtap_buffer_append_epdu_uint(Buffer *buf, guint16 epdu_tag, guint32 val) +{ + const guint space_needed = 8; /* 2 for tag field, 2 for length field, 4 for value */ + guint8 *buf_data; + + ws_assert(epdu_tag != 0); + ws_buffer_assure_space(buf, space_needed); + buf_data = ws_buffer_end_ptr(buf); + memset(buf_data, 0, space_needed); + phton16(buf_data + 0, epdu_tag); + phton16(buf_data + 2, 4); + phton32(buf_data + 4, val); + ws_buffer_increase_length(buf, space_needed); +} + +void +wtap_buffer_append_epdu_string(Buffer *buf, guint16 epdu_tag, const char *val) +{ + size_t string_len; + + string_len = strlen(val); + /* + * Cut off string length at G_MAXUINT16. + * + * XXX - make sure we don't leave an incomplete UTF-8 + * sequence at the end. + */ + if (string_len > G_MAXUINT16) + string_len = G_MAXUINT16; + wtap_buffer_append_epdu_tag(buf, epdu_tag, val, (guint16) string_len); +} + +gint +wtap_buffer_append_epdu_end(Buffer *buf) +{ + const guint space_needed = 4; /* 2 for tag (=0000), 2 for length field (=0) */ + guint8 *buf_data; + + ws_buffer_assure_space(buf, space_needed); + buf_data = ws_buffer_end_ptr(buf); + memset(buf_data, 0, space_needed); + ws_buffer_increase_length(buf, space_needed); + + return (gint)ws_buffer_length(buf); +} + +/* + * Initialize the library. + */ +void +wtap_init(gboolean load_wiretap_plugins) +{ + init_open_routines(); + wtap_opttypes_initialize(); + wtap_init_encap_types(); + wtap_init_file_type_subtypes(); + if (load_wiretap_plugins) { +#ifdef HAVE_PLUGINS + libwiretap_plugins = plugins_init(WS_PLUGIN_WIRETAP); +#endif + g_slist_foreach(wtap_plugins, call_plugin_register_wtap_module, NULL); + } +} + +/* + * Cleanup the library + */ +void +wtap_cleanup(void) +{ + wtap_cleanup_encap_types(); + wtap_opttypes_cleanup(); + ws_buffer_cleanup(); + cleanup_open_routines(); + g_slist_free(wtap_plugins); + wtap_plugins = NULL; +#ifdef HAVE_PLUGINS + plugins_cleanup(libwiretap_plugins); + libwiretap_plugins = NULL; +#endif +} + +/* + * Editor modelines - https://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 8 + * tab-width: 8 + * indent-tabs-mode: t + * End: + * + * vi: set shiftwidth=8 tabstop=8 noexpandtab: + * :indentSize=8:tabSize=8:noTabs=false: + */ |