/* column-utils.c * Routines for column utilities. * * Wireshark - Network traffic analyzer * By Gerald Combs * Copyright 1998 Gerald Combs * * SPDX-License-Identifier: GPL-2.0-or-later */ #include "config.h" #include #include #include #include #include #include "column-utils.h" #include "timestamp.h" #include "to_str.h" #include "packet_info.h" #include "wsutil/pint.h" #include "addr_resolv.h" #include "address_types.h" #include "osi-utils.h" #include "value_string.h" #include "column-info.h" #include "column.h" #include "proto.h" #include #include #include #include #include #include #include #include #ifdef HAVE_LUA #include #endif #define COL_BUF_MAX_LEN (((COL_MAX_INFO_LEN) > (COL_MAX_LEN)) ? \ (COL_MAX_INFO_LEN) : (COL_MAX_LEN)) /* Used for locale decimal point */ static char *col_decimal_point; /* Used to indicate updated column information, e.g. a new request/response. */ static gboolean col_data_changed_; static int proto_cols; static gint ett_cols; /* Allocate all the data structures for constructing column data, given the number of columns. */ void col_setup(column_info *cinfo, const gint num_cols) { int i; col_decimal_point = localeconv()->decimal_point; cinfo->num_cols = num_cols; cinfo->columns = g_new(col_item_t, num_cols); cinfo->col_first = g_new(int, NUM_COL_FMTS); cinfo->col_last = g_new(int, NUM_COL_FMTS); for (i = 0; i < num_cols; i++) { cinfo->columns[i].col_custom_fields_ids = NULL; } cinfo->col_expr.col_expr = g_new(const gchar*, num_cols + 1); cinfo->col_expr.col_expr_val = g_new(gchar*, num_cols + 1); for (i = 0; i < NUM_COL_FMTS; i++) { cinfo->col_first[i] = -1; cinfo->col_last[i] = -1; } cinfo->prime_regex = g_regex_new(COL_CUSTOM_PRIME_REGEX, (GRegexCompileFlags) (G_REGEX_RAW), 0, NULL); } static void col_custom_free_cb(void *data) { col_custom_t *col_custom = (col_custom_t*)data; dfilter_free(col_custom->dfilter); g_free(col_custom->dftext); g_free(col_custom); } static void col_custom_fields_ids_free(GSList** custom_fields_id) { if (*custom_fields_id != NULL) { g_slist_free_full(*custom_fields_id, col_custom_free_cb); } *custom_fields_id = NULL; } /* Cleanup all the data structures for constructing column data; undoes the allocations that col_setup() does. */ void col_cleanup(column_info *cinfo) { int i; col_item_t* col_item; if (!cinfo) return; for (i = 0; i < cinfo->num_cols; i++) { col_item = &cinfo->columns[i]; g_free(col_item->fmt_matx); g_free(col_item->col_title); g_free(col_item->col_custom_fields); dfilter_free(col_item->col_custom_dfilter); /* col_item->col_data points to col_buf or static memory */ g_free(col_item->col_buf); g_free(cinfo->col_expr.col_expr_val[i]); col_custom_fields_ids_free(&col_item->col_custom_fields_ids); } g_free(cinfo->columns); g_free(cinfo->col_first); g_free(cinfo->col_last); /* * XXX - MSVC doesn't correctly handle the "const" qualifier; it thinks * "const XXX **" means "pointer to const pointer to XXX", i.e. that * it's a pointer to something that's "const"ant, not "pointer to * pointer to const XXX", i.e. that it's a pointer to a pointer to * something that's "const"ant. Cast its bogus complaints away. */ g_free((gchar **)cinfo->col_expr.col_expr); g_free(cinfo->col_expr.col_expr_val); if (cinfo->prime_regex) g_regex_unref(cinfo->prime_regex); } /* Initialize the data structures for constructing column data. */ void col_init(column_info *cinfo, const struct epan_session *epan) { int i; col_item_t* col_item; if (!cinfo) return; for (i = 0; i < cinfo->num_cols; i++) { col_item = &cinfo->columns[i]; col_item->col_buf[0] = '\0'; col_item->col_data = col_item->col_buf; col_item->col_fence = 0; col_item->writable = TRUE; cinfo->col_expr.col_expr[i] = ""; cinfo->col_expr.col_expr_val[i][0] = '\0'; } cinfo->writable = TRUE; cinfo->epan = epan; } gboolean col_get_writable(column_info *cinfo, const gint col) { int i; col_item_t* col_item; if (cinfo == NULL) return FALSE; /* "global" (not) writeability will always override an individual column */ if ((col == -1) || (cinfo->writable == FALSE)) return cinfo->writable; if (cinfo->col_first[col] >= 0) { for (i = cinfo->col_first[col]; i <= cinfo->col_last[col]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[col]) { return col_item->writable; } } } return FALSE; } void col_set_writable(column_info *cinfo, const gint col, const gboolean writable) { int i; col_item_t* col_item; if (cinfo) { if (col == -1) { cinfo->writable = writable; } else if (cinfo->col_first[col] >= 0) { for (i = cinfo->col_first[col]; i <= cinfo->col_last[col]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[col]) { col_item->writable = writable; } } } } } /* Checks to see if a particular packet information element is needed for the packet list */ #define CHECK_COL(cinfo, el) \ /* We are constructing columns, and they're writable */ \ (col_get_writable(cinfo, el) && \ /* There is at least one column in that format */ \ ((cinfo)->col_first[el] >= 0)) /* Sets the fence for a column to be at the end of the column. */ void col_set_fence(column_info *cinfo, const gint el) { int i; col_item_t* col_item; if (!CHECK_COL(cinfo, el)) return; for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[el]) { col_item->col_fence = (int)strlen(col_item->col_data); } } } /* Clear the fence for a column. */ void col_clear_fence(column_info *cinfo, const gint el) { int i; col_item_t* col_item; if (!CHECK_COL(cinfo, el)) return; for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[el]) { col_item->col_fence = 0; } } } /* Gets the text of a column */ const gchar * col_get_text(column_info *cinfo, const gint el) { int i; const gchar* text = NULL; col_item_t* col_item; if (!(cinfo && (cinfo)->col_first[el] >= 0)) { return NULL; } for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[el]) { text = (col_item->col_data); } } return text; } /* Use this to clear out a column, especially if you're going to be appending to it later; at least on some platforms, it's more efficient than using "col_add_str()" with a null string, and more efficient than "col_set_str()" with a null string if you later append to it, as the later append will cause a string copy to be done. */ void col_clear(column_info *cinfo, const gint el) { int i; col_item_t* col_item; if (!CHECK_COL(cinfo, el)) return; for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[el]) { /* * At this point, either * * 1) col_data[i] is equal to col_buf[i], in which case we * don't have to worry about copying col_data[i] to * col_buf[i]; * * 2) col_data[i] isn't equal to col_buf[i], in which case * the only thing that's been done to the column is * "col_set_str()" calls and possibly "col_set_fence()" * calls, in which case the fence is either unset and * at the beginning of the string or set and at the end * of the string - if it's at the beginning, we're just * going to clear the column, and if it's at the end, * we don't do anything. */ if (col_item->col_buf == col_item->col_data || col_item->col_fence == 0) { /* * The fence isn't at the end of the column, or the column wasn't * last set with "col_set_str()", so clear the column out. */ col_item->col_buf[col_item->col_fence] = '\0'; col_item->col_data = col_item->col_buf; } cinfo->col_expr.col_expr[i] = ""; cinfo->col_expr.col_expr_val[i][0] = '\0'; } } } #define COL_CHECK_APPEND(col_item, max_len) \ if (col_item->col_data != col_item->col_buf) { \ /* This was set with "col_set_str()"; copy the string they \ set it to into the buffer, so we can append to it. */ \ (void) g_strlcpy(col_item->col_buf, col_item->col_data, max_len); \ col_item->col_data = col_item->col_buf; \ } #define COL_CHECK_REF_TIME(fd, buf) \ if (fd->ref_time) { \ (void) g_strlcpy(buf, "*REF*", COL_MAX_LEN ); \ return; \ } /* The same as CHECK_COL(), but without the check to see if the column is writable. */ #define HAVE_CUSTOM_COLS(cinfo) ((cinfo) && (cinfo)->col_first[COL_CUSTOM] >= 0) gboolean have_custom_cols(column_info *cinfo) { return HAVE_CUSTOM_COLS(cinfo); } gboolean have_field_extractors(void) { #ifdef HAVE_LUA return wslua_has_field_extractors(); #else return FALSE; #endif } /* search in edt tree custom fields */ void col_custom_set_edt(epan_dissect_t *edt, column_info *cinfo) { int i; col_item_t* col_item; if (!HAVE_CUSTOM_COLS(cinfo)) return; for (i = cinfo->col_first[COL_CUSTOM]; i <= cinfo->col_last[COL_CUSTOM]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[COL_CUSTOM] && col_item->col_custom_fields && col_item->col_custom_fields_ids) { col_item->col_data = col_item->col_buf; cinfo->col_expr.col_expr[i] = epan_custom_set(edt, col_item->col_custom_fields_ids, col_item->col_custom_occurrence, col_item->col_buf, cinfo->col_expr.col_expr_val[i], COL_MAX_LEN); } } } #if 0 // Needed if we create _ws.col.custom static void col_custom_set(proto_tree *tree, column_info *cinfo) { int i; col_item_t* col_item; if (!HAVE_CUSTOM_COLS(cinfo)) return; for (i = cinfo->col_first[COL_CUSTOM]; i <= cinfo->col_last[COL_CUSTOM]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[COL_CUSTOM] && col_item->col_custom_fields && col_item->col_custom_fields_ids) { col_item->col_data = col_item->col_buf; cinfo->col_expr.col_expr[i] = proto_custom_set(tree, col_item->col_custom_fields_ids, col_item->col_custom_occurrence, col_item->col_buf, cinfo->col_expr.col_expr_val[i], COL_MAX_LEN); } } } #endif void col_custom_prime_edt(epan_dissect_t *edt, column_info *cinfo) { int i; col_item_t* col_item; if (!HAVE_CUSTOM_COLS(cinfo)) return; for (i = cinfo->col_first[COL_CUSTOM]; i <= cinfo->col_last[COL_CUSTOM]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[COL_CUSTOM] && col_item->col_custom_dfilter) { epan_dissect_prime_with_dfilter(edt, col_item->col_custom_dfilter); } } } char* col_custom_get_filter(epan_dissect_t *edt, column_info *cinfo, const gint col) { col_item_t* col_item; ws_assert(cinfo); ws_assert(col < cinfo->num_cols); col_item = &cinfo->columns[col]; if (col_item->fmt_matx[COL_CUSTOM] && col_item->col_custom_fields && col_item->col_custom_fields_ids) { return proto_custom_get_filter(edt, col_item->col_custom_fields_ids, col_item->col_custom_occurrence); } return NULL; } void col_append_lstr(column_info *cinfo, const gint el, const gchar *str1, ...) { va_list ap; size_t pos, max_len; int i; const gchar *str; col_item_t* col_item; if (!CHECK_COL(cinfo, el)) return; if (el == COL_INFO) max_len = COL_MAX_INFO_LEN; else max_len = COL_MAX_LEN; for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[el]) { /* * First arrange that we can append, if necessary. */ COL_CHECK_APPEND(col_item, max_len); pos = strlen(col_item->col_buf); if (pos >= max_len) return; va_start(ap, str1); str = str1; do { if (G_UNLIKELY(str == NULL)) { str = "(null)"; } WS_UTF_8_CHECK(str, -1); pos = ws_label_strcpy(col_item->col_buf, max_len, pos, str, 0); } while (pos < max_len && (str = va_arg(ap, const char *)) != COL_ADD_LSTR_TERMINATOR); va_end(ap); } } } void col_append_str_uint(column_info *cinfo, const gint col, const gchar *abbrev, guint32 val, const gchar *sep) { char buf[16]; guint32_to_str_buf(val, buf, sizeof(buf)); col_append_lstr(cinfo, col, sep ? sep : "", abbrev, "=", buf, COL_ADD_LSTR_TERMINATOR); } static inline void col_snprint_port(gchar *buf, size_t buf_siz, port_type typ, guint16 val) { const char *str; if (gbl_resolv_flags.transport_name && (str = try_serv_name_lookup(typ, val)) != NULL) { snprintf(buf, buf_siz, "%s(%"PRIu16")", str, val); } else { snprintf(buf, buf_siz, "%"PRIu16, val); } } void col_append_ports(column_info *cinfo, const gint col, port_type typ, guint16 src, guint16 dst) { char buf_src[32], buf_dst[32]; col_snprint_port(buf_src, 32, typ, src); col_snprint_port(buf_dst, 32, typ, dst); col_append_lstr(cinfo, col, buf_src, " " UTF8_RIGHTWARDS_ARROW " ", buf_dst, COL_ADD_LSTR_TERMINATOR); } void col_append_frame_number(packet_info *pinfo, const gint col, const gchar *fmt_str, guint frame_num) { col_append_fstr(pinfo->cinfo, col, fmt_str, frame_num); if (!pinfo->fd->visited) { col_data_changed_ = TRUE; } } static void col_do_append_fstr(column_info *cinfo, const int el, const char *separator, const char *format, va_list ap) { size_t len, max_len, sep_len, pos; int i; col_item_t* col_item; char tmp[COL_BUF_MAX_LEN]; sep_len = (separator) ? strlen(separator) : 0; if (el == COL_INFO) max_len = COL_MAX_INFO_LEN; else max_len = COL_MAX_LEN; for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[el]) { /* * First arrange that we can append, if necessary. */ COL_CHECK_APPEND(col_item, max_len); len = strlen(col_item->col_buf); /* * If we have a separator, append it if the column isn't empty. */ if (sep_len != 0 && len != 0) { (void) ws_label_strcat(col_item->col_buf, max_len, separator, 0); len += sep_len; } if (len < max_len) { va_list ap2; va_copy(ap2, ap); pos = vsnprintf(tmp, sizeof(tmp), format, ap2); va_end(ap2); if (pos >= max_len) { ws_utf8_truncate(tmp, max_len - 1); } WS_UTF_8_CHECK(tmp, -1); ws_label_strcpy(col_item->col_buf, max_len, len, tmp, 0); } } } } /* Appends a vararg list to a packet info string. */ void col_append_fstr(column_info *cinfo, const gint el, const gchar *format, ...) { va_list ap; if (!CHECK_COL(cinfo, el)) return; va_start(ap, format); col_do_append_fstr(cinfo, el, NULL, format, ap); va_end(ap); } /* Appends a vararg list to a packet info string. * Prefixes it with the given separator if the column is not empty. */ void col_append_sep_fstr(column_info *cinfo, const gint el, const gchar *separator, const gchar *format, ...) { va_list ap; if (!CHECK_COL(cinfo, el)) return; if (separator == NULL) separator = ", "; /* default */ va_start(ap, format); col_do_append_fstr(cinfo, el, separator, format, ap); va_end(ap); } /* Prepends a vararg list to a packet info string. */ void col_prepend_fstr(column_info *cinfo, const gint el, const gchar *format, ...) { va_list ap; int i; char orig_buf[COL_BUF_MAX_LEN]; const char *orig; size_t max_len, pos; col_item_t* col_item; char tmp[COL_BUF_MAX_LEN]; if (!CHECK_COL(cinfo, el)) return; if (el == COL_INFO) max_len = COL_MAX_INFO_LEN; else max_len = COL_MAX_LEN; for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[el]) { if (col_item->col_data != col_item->col_buf) { /* This was set with "col_set_str()"; which is effectively const */ orig = col_item->col_data; } else { (void) g_strlcpy(orig_buf, col_item->col_buf, max_len); orig = orig_buf; } va_start(ap, format); pos = vsnprintf(tmp, sizeof(tmp), format, ap); va_end(ap); if (pos >= max_len) { ws_utf8_truncate(tmp, max_len - 1); } WS_UTF_8_CHECK(tmp, -1); pos = ws_label_strcpy(col_item->col_buf, max_len, 0, tmp, 0); /* * Move the fence, unless it's at the beginning of the string. */ if (col_item->col_fence > 0) col_item->col_fence += (int) strlen(col_item->col_buf); /* * Append the original data. */ ws_label_strcpy(col_item->col_buf, max_len, pos, orig, 0); col_item->col_data = col_item->col_buf; } } } void col_prepend_fence_fstr(column_info *cinfo, const gint el, const gchar *format, ...) { va_list ap; int i; char orig_buf[COL_BUF_MAX_LEN]; const char *orig; size_t max_len, pos; col_item_t* col_item; char tmp[COL_BUF_MAX_LEN]; if (!CHECK_COL(cinfo, el)) return; if (el == COL_INFO) max_len = COL_MAX_INFO_LEN; else max_len = COL_MAX_LEN; for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[el]) { if (col_item->col_data != col_item->col_buf) { /* This was set with "col_set_str()"; which is effectively const */ orig = col_item->col_data; } else { (void) g_strlcpy(orig_buf, col_item->col_buf, max_len); orig = orig_buf; } va_start(ap, format); pos = vsnprintf(tmp, sizeof(tmp), format, ap); va_end(ap); if (pos >= max_len) { ws_utf8_truncate(tmp, max_len - 1); } WS_UTF_8_CHECK(tmp, -1); pos = ws_label_strcpy(col_item->col_buf, max_len, 0, tmp, 0); /* * Move the fence if it exists, else create a new fence at the * end of the prepended data. */ if (col_item->col_fence > 0) { col_item->col_fence += (int) strlen(col_item->col_buf); } else { col_item->col_fence = (int) strlen(col_item->col_buf); } /* * Append the original data. */ ws_label_strcpy(col_item->col_buf, max_len, pos, orig, 0); col_item->col_data = col_item->col_buf; } } } /* Use this if "str" points to something that won't stay around (and must thus be copied). */ void col_add_str(column_info *cinfo, const gint el, const gchar* str) { int i; size_t max_len; col_item_t* col_item; if (!CHECK_COL(cinfo, el)) return; if (el == COL_INFO) max_len = COL_MAX_INFO_LEN; else max_len = COL_MAX_LEN; for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[el]) { if (col_item->col_fence != 0) { /* * We will append the string after the fence. * First arrange that we can append, if necessary. */ COL_CHECK_APPEND(col_item, max_len); } else { /* * There's no fence, so we can just write to the string. */ col_item->col_data = col_item->col_buf; } WS_UTF_8_CHECK(str, -1); (void) ws_label_strcpy(col_item->col_buf, max_len, col_item->col_fence, str, 0); } } } /* Use this if "str" points to something that will stay around (and thus needn't be copied). */ void col_set_str(column_info *cinfo, const gint el, const gchar* str) { int i; size_t max_len; col_item_t* col_item; DISSECTOR_ASSERT(str); if (!CHECK_COL(cinfo, el)) return; if (el == COL_INFO) max_len = COL_MAX_INFO_LEN; else max_len = COL_MAX_LEN; for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[el]) { if (col_item->col_fence != 0) { /* * We will append the string after the fence. * First arrange that we can append, if necessary. */ COL_CHECK_APPEND(col_item, max_len); (void) g_strlcpy(&col_item->col_buf[col_item->col_fence], str, max_len - col_item->col_fence); } else { /* * There's no fence, so we can just set the column to point * to the string. */ col_item->col_data = str; } } } } void col_add_lstr(column_info *cinfo, const gint el, const gchar *str1, ...) { va_list ap; int i; gsize pos; gsize max_len; const gchar *str; col_item_t* col_item; if (!CHECK_COL(cinfo, el)) return; if (el == COL_INFO) max_len = COL_MAX_INFO_LEN; else max_len = COL_MAX_LEN; for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[el]) { pos = col_item->col_fence; if (pos != 0) { /* * We will append the string after the fence. * First arrange that we can append, if necessary. */ COL_CHECK_APPEND(col_item, max_len); } else { /* * There's no fence, so we can just write to the string. */ col_item->col_data = col_item->col_buf; } va_start(ap, str1); str = str1; do { if (G_UNLIKELY(str == NULL)) { str = "(null)"; } WS_UTF_8_CHECK(str, -1); pos = ws_label_strcpy(col_item->col_buf, max_len, pos, str, 0); } while (pos < max_len && (str = va_arg(ap, const char *)) != COL_ADD_LSTR_TERMINATOR); va_end(ap); } } } /* Adds a vararg list to a packet info string. */ void col_add_fstr(column_info *cinfo, const gint el, const gchar *format, ...) { va_list ap; int i, pos; int max_len; col_item_t* col_item; char tmp[COL_BUF_MAX_LEN]; if (!CHECK_COL(cinfo, el)) return; if (el == COL_INFO) max_len = COL_MAX_INFO_LEN; else max_len = COL_MAX_LEN; for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[el]) { if (col_item->col_fence != 0) { /* * We will append the string after the fence. * First arrange that we can append, if necessary. */ COL_CHECK_APPEND(col_item, max_len); } else { /* * There's no fence, so we can just write to the string. */ col_item->col_data = col_item->col_buf; } va_start(ap, format); pos = vsnprintf(tmp, sizeof(tmp), format, ap); va_end(ap); if (pos >= max_len) { ws_utf8_truncate(tmp, max_len - 1); } WS_UTF_8_CHECK(tmp, -1); ws_label_strcpy(col_item->col_buf, max_len, col_item->col_fence, tmp, 0); } } } static void col_do_append_str(column_info *cinfo, const gint el, const gchar* separator, const gchar* str) { int i; size_t len, max_len; col_item_t* col_item; if (el == COL_INFO) max_len = COL_MAX_INFO_LEN; else max_len = COL_MAX_LEN; for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) { col_item = &cinfo->columns[i]; if (col_item->fmt_matx[el]) { /* * First arrange that we can append, if necessary. */ COL_CHECK_APPEND(col_item, max_len); len = col_item->col_buf[0]; /* * If we have a separator, append it if the column isn't empty. */ if (separator != NULL) { if (len != 0) { (void) ws_label_strcat(col_item->col_buf, max_len, separator, 0); } } WS_UTF_8_CHECK(str, -1); (void) ws_label_strcat(col_item->col_buf, max_len, str, 0); } } } void col_append_str(column_info *cinfo, const gint el, const gchar* str) { if (!CHECK_COL(cinfo, el)) return; col_do_append_str(cinfo, el, NULL, str); } void col_append_sep_str(column_info *cinfo, const gint el, const gchar* separator, const gchar* str) { if (!CHECK_COL(cinfo, el)) return; if (separator == NULL) separator = ", "; /* default */ col_do_append_str(cinfo, el, separator, str); } /* --------------------------------- */ gboolean col_has_time_fmt(column_info *cinfo, const gint col) { col_item_t* col_item = &cinfo->columns[col]; return ((col_item->fmt_matx[COL_CLS_TIME]) || (col_item->fmt_matx[COL_ABS_TIME]) || (col_item->fmt_matx[COL_ABS_YMD_TIME]) || (col_item->fmt_matx[COL_ABS_YDOY_TIME]) || (col_item->fmt_matx[COL_UTC_TIME]) || (col_item->fmt_matx[COL_UTC_YMD_TIME]) || (col_item->fmt_matx[COL_UTC_YDOY_TIME]) || (col_item->fmt_matx[COL_REL_TIME]) || (col_item->fmt_matx[COL_DELTA_TIME]) || (col_item->fmt_matx[COL_DELTA_TIME_DIS])); } static int get_frame_timestamp_precision(const frame_data *fd) { int tsprecision; tsprecision = timestamp_get_precision(); if (tsprecision == TS_PREC_AUTO) tsprecision = fd->tsprec; else if (tsprecision < 0) ws_assert_not_reached(); /* * Time stamp precision values higher than the maximum * precision we support can't be handled. Just display * those times with the maximum precision we support. */ if (tsprecision > WS_TSPREC_MAX) tsprecision = WS_TSPREC_MAX; return tsprecision; } static int get_default_timestamp_precision(void) { int tsprecision; tsprecision = timestamp_get_precision(); if (tsprecision == TS_PREC_AUTO) tsprecision = WS_TSPREC_MAX; /* default to the maximum precision we support */ else if (tsprecision < 0) ws_assert_not_reached(); /* * Time stamp precision values higher than the maximum * precision we support can't be handled. Just display * those times with the maximum precision we support. */ if (tsprecision > WS_TSPREC_MAX) tsprecision = WS_TSPREC_MAX; return tsprecision; } static void set_abs_ymd_time(const frame_data *fd, gchar *buf, char *decimal_point, gboolean local) { if (!fd->has_ts) { buf[0] = '\0'; return; } format_nstime_as_iso8601(buf, COL_MAX_LEN, &fd->abs_ts, decimal_point, local, get_frame_timestamp_precision(fd)); } static void col_set_abs_ymd_time(const frame_data *fd, column_info *cinfo, const int col) { set_abs_ymd_time(fd, cinfo->columns[col].col_buf, col_decimal_point, TRUE); cinfo->col_expr.col_expr[col] = "frame.time"; (void) g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->columns[col].col_buf,COL_MAX_LEN); cinfo->columns[col].col_data = cinfo->columns[col].col_buf; } static void col_set_utc_ymd_time(const frame_data *fd, column_info *cinfo, const int col) { set_abs_ymd_time(fd, cinfo->columns[col].col_buf, col_decimal_point, FALSE); cinfo->col_expr.col_expr[col] = "frame.time"; (void) g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->columns[col].col_buf,COL_MAX_LEN); cinfo->columns[col].col_data = cinfo->columns[col].col_buf; } static void set_abs_ydoy_time(const frame_data *fd, gchar *buf, char *decimal_point, gboolean local) { struct tm tm, *tmp; char *ptr; size_t remaining; int num_bytes; int tsprecision; if (!fd->has_ts) { buf[0] = '\0'; return; } if (local) tmp = ws_localtime_r(&fd->abs_ts.secs, &tm); else tmp = ws_gmtime_r(&fd->abs_ts.secs, &tm); if (tmp == NULL) { snprintf(buf, COL_MAX_LEN, "Not representable"); return; } ptr = buf; remaining = COL_MAX_LEN; num_bytes = snprintf(ptr, remaining,"%04d/%03d %02d:%02d:%02d", tmp->tm_year + 1900, tmp->tm_yday + 1, tmp->tm_hour, tmp->tm_min, tmp->tm_sec); if (num_bytes < 0) { /* * That got an error. * Not much else we can do. */ snprintf(ptr, remaining, "snprintf() failed"); return; } if ((unsigned int)num_bytes >= remaining) { /* * That filled up or would have overflowed the buffer. * Nothing more we can do. */ return; } ptr += num_bytes; remaining -= num_bytes; tsprecision = get_frame_timestamp_precision(fd); if (tsprecision != 0) { /* * Append the fractional part. * Get the nsecs as a 32-bit unsigned value, as it should never * be negative, so we treat it as unsigned. */ format_fractional_part_nsecs(ptr, remaining, (guint32)fd->abs_ts.nsecs, decimal_point, tsprecision); } } static void col_set_abs_ydoy_time(const frame_data *fd, column_info *cinfo, const int col) { set_abs_ydoy_time(fd, cinfo->columns[col].col_buf, col_decimal_point, TRUE); cinfo->col_expr.col_expr[col] = "frame.time"; (void) g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->columns[col].col_buf,COL_MAX_LEN); cinfo->columns[col].col_data = cinfo->columns[col].col_buf; } static void col_set_utc_ydoy_time(const frame_data *fd, column_info *cinfo, const int col) { set_abs_ydoy_time(fd, cinfo->columns[col].col_buf, col_decimal_point, FALSE); cinfo->col_expr.col_expr[col] = "frame.time"; (void) g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->columns[col].col_buf,COL_MAX_LEN); cinfo->columns[col].col_data = cinfo->columns[col].col_buf; } static void set_time_seconds(const frame_data *fd, const nstime_t *ts, gchar *buf) { ws_assert(fd->has_ts); display_signed_time(buf, COL_MAX_LEN, ts, get_frame_timestamp_precision(fd)); } static void set_time_hour_min_sec(const frame_data *fd, const nstime_t *ts, gchar *buf, char *decimal_point) { time_t secs = ts->secs; guint32 nsecs; gboolean negative = FALSE; char *ptr; size_t remaining; int num_bytes; int tsprecision; ws_assert(fd->has_ts); if (secs < 0) { secs = -secs; negative = TRUE; } if (ts->nsecs >= 0) { nsecs = ts->nsecs; } else if (G_LIKELY(ts->nsecs != INT_MIN)) { /* * This isn't the smallest negative number that fits in 32 * bits, so we can compute its negative and store it in a * 32-bit unsigned int variable. */ nsecs = -ts->nsecs; negative = TRUE; } else { /* * -2147483648 is the smallest number that fits in a signed * 2's complement 32-bit variable, and its negative doesn't * fit in 32 bits. * * Just cast it to a 32-bit unsigned int value to set the * 32-bit unsigned int variable to 2147483648. * * Note that, on platforms where both integers and long * integers are 32-bit, such as 32-bit UN*Xes and both * 32-bit *and* 64-bit Windows, making the variable in * question a long will not avoid undefined behavior. */ nsecs = (guint32)ts->nsecs; negative = TRUE; } ptr = buf; remaining = COL_MAX_LEN; if (secs >= (60*60)) { num_bytes = snprintf(ptr, remaining, "%s%dh %2dm %2d", negative ? "- " : "", (gint32) secs / (60 * 60), (gint32) (secs / 60) % 60, (gint32) secs % 60); } else if (secs >= 60) { num_bytes = snprintf(ptr, remaining, "%s%dm %2d", negative ? "- " : "", (gint32) secs / 60, (gint32) secs % 60); } else { num_bytes = snprintf(ptr, remaining, "%s%d", negative ? "- " : "", (gint32) secs); } if (num_bytes < 0) { /* * That got an error. * Not much else we can do. */ snprintf(ptr, remaining, "snprintf() failed"); return; } if ((unsigned int)num_bytes >= remaining) { /* * That filled up or would have overflowed the buffer. * Nothing more we can do. */ return; } ptr += num_bytes; remaining -= num_bytes; tsprecision = get_frame_timestamp_precision(fd); if (tsprecision != 0) { /* * Append the fractional part. */ num_bytes = format_fractional_part_nsecs(ptr, remaining, nsecs, decimal_point, tsprecision); if ((unsigned int)num_bytes >= remaining) { /* * That filled up or would have overflowed the buffer. * Nothing more we can do. */ return; } ptr += num_bytes; remaining -= num_bytes; } /* Append the "s" for seconds. */ snprintf(ptr, remaining, "s"); } static void col_set_rel_time(const frame_data *fd, column_info *cinfo, const int col) { nstime_t del_rel_ts; if (!fd->has_ts) { cinfo->columns[col].col_buf[0] = '\0'; return; } frame_delta_abs_time(cinfo->epan, fd, fd->frame_ref_num, &del_rel_ts); switch (timestamp_get_seconds_type()) { case TS_SECONDS_DEFAULT: set_time_seconds(fd, &del_rel_ts, cinfo->columns[col].col_buf); cinfo->col_expr.col_expr[col] = "frame.time_relative"; (void) g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->columns[col].col_buf,COL_MAX_LEN); break; case TS_SECONDS_HOUR_MIN_SEC: set_time_hour_min_sec(fd, &del_rel_ts, cinfo->columns[col].col_buf, col_decimal_point); cinfo->col_expr.col_expr[col] = "frame.time_relative"; set_time_seconds(fd, &del_rel_ts, cinfo->col_expr.col_expr_val[col]); break; default: ws_assert_not_reached(); } cinfo->columns[col].col_data = cinfo->columns[col].col_buf; } static void col_set_delta_time(const frame_data *fd, column_info *cinfo, const int col) { nstime_t del_cap_ts; if (!fd->has_ts) { cinfo->columns[col].col_buf[0] = '\0'; return; } frame_delta_abs_time(cinfo->epan, fd, fd->num - 1, &del_cap_ts); switch (timestamp_get_seconds_type()) { case TS_SECONDS_DEFAULT: set_time_seconds(fd, &del_cap_ts, cinfo->columns[col].col_buf); cinfo->col_expr.col_expr[col] = "frame.time_delta"; (void) g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->columns[col].col_buf,COL_MAX_LEN); break; case TS_SECONDS_HOUR_MIN_SEC: set_time_hour_min_sec(fd, &del_cap_ts, cinfo->columns[col].col_buf, col_decimal_point); cinfo->col_expr.col_expr[col] = "frame.time_delta"; set_time_seconds(fd, &del_cap_ts, cinfo->col_expr.col_expr_val[col]); break; default: ws_assert_not_reached(); } cinfo->columns[col].col_data = cinfo->columns[col].col_buf; } static void col_set_delta_time_dis(const frame_data *fd, column_info *cinfo, const int col) { nstime_t del_dis_ts; if (!fd->has_ts) { cinfo->columns[col].col_buf[0] = '\0'; return; } frame_delta_abs_time(cinfo->epan, fd, fd->prev_dis_num, &del_dis_ts); switch (timestamp_get_seconds_type()) { case TS_SECONDS_DEFAULT: set_time_seconds(fd, &del_dis_ts, cinfo->columns[col].col_buf); cinfo->col_expr.col_expr[col] = "frame.time_delta_displayed"; (void) g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->columns[col].col_buf,COL_MAX_LEN); break; case TS_SECONDS_HOUR_MIN_SEC: set_time_hour_min_sec(fd, &del_dis_ts, cinfo->columns[col].col_buf, col_decimal_point); cinfo->col_expr.col_expr[col] = "frame.time_delta_displayed"; set_time_seconds(fd, &del_dis_ts, cinfo->col_expr.col_expr_val[col]); break; default: ws_assert_not_reached(); } cinfo->columns[col].col_data = cinfo->columns[col].col_buf; } /* * Time, without date. */ static void set_abs_time(const frame_data *fd, gchar *buf, char *decimal_point, gboolean local) { struct tm tm, *tmp; gchar *ptr; size_t remaining; int num_bytes; int tsprecision; if (!fd->has_ts) { *buf = '\0'; return; } ptr = buf; remaining = COL_MAX_LEN; if (local) tmp = ws_localtime_r(&fd->abs_ts.secs, &tm); else tmp = ws_gmtime_r(&fd->abs_ts.secs, &tm); if (tmp == NULL) { snprintf(ptr, remaining, "Not representable"); return; } /* Integral part. */ num_bytes = snprintf(ptr, remaining, "%02d:%02d:%02d", tmp->tm_hour, tmp->tm_min, tmp->tm_sec); if (num_bytes < 0) { /* * That got an error. * Not much else we can do. */ snprintf(ptr, remaining, "snprintf() failed"); return; } if ((unsigned int)num_bytes >= remaining) { /* * That filled up or would have overflowed the buffer. * Nothing more we can do. */ return; } ptr += num_bytes; remaining -= num_bytes; tsprecision = get_frame_timestamp_precision(fd); if (tsprecision != 0) { /* * Append the fractional part. * Get the nsecs as a 32-bit unsigned value, as it should never * be negative, so we treat it as unsigned. */ format_fractional_part_nsecs(ptr, remaining, (guint32)fd->abs_ts.nsecs, decimal_point, tsprecision); } } static void col_set_abs_time(const frame_data *fd, column_info *cinfo, const int col) { set_abs_time(fd, cinfo->columns[col].col_buf, col_decimal_point, TRUE); cinfo->col_expr.col_expr[col] = "frame.time"; (void) g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->columns[col].col_buf,COL_MAX_LEN); cinfo->columns[col].col_data = cinfo->columns[col].col_buf; } static void col_set_utc_time(const frame_data *fd, column_info *cinfo, const int col) { set_abs_time(fd, cinfo->columns[col].col_buf, col_decimal_point, FALSE); cinfo->col_expr.col_expr[col] = "frame.time"; (void) g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->columns[col].col_buf,COL_MAX_LEN); cinfo->columns[col].col_data = cinfo->columns[col].col_buf; } static gboolean set_epoch_time(const frame_data *fd, gchar *buf) { if (!fd->has_ts) { buf[0] = '\0'; return FALSE; } display_epoch_time(buf, COL_MAX_LEN, &fd->abs_ts, get_frame_timestamp_precision(fd)); return TRUE; } static void col_set_epoch_time(const frame_data *fd, column_info *cinfo, const int col) { if (set_epoch_time(fd, cinfo->columns[col].col_buf)) { cinfo->col_expr.col_expr[col] = "frame.time_delta"; (void) g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->columns[col].col_buf,COL_MAX_LEN); } cinfo->columns[col].col_data = cinfo->columns[col].col_buf; } void set_fd_time(const epan_t *epan, frame_data *fd, gchar *buf) { switch (timestamp_get_type()) { case TS_ABSOLUTE: set_abs_time(fd, buf, col_decimal_point, TRUE); break; case TS_ABSOLUTE_WITH_YMD: set_abs_ymd_time(fd, buf, col_decimal_point, TRUE); break; case TS_ABSOLUTE_WITH_YDOY: set_abs_ydoy_time(fd, buf, col_decimal_point, TRUE); break; case TS_RELATIVE: if (fd->has_ts) { nstime_t del_rel_ts; frame_delta_abs_time(epan, fd, fd->frame_ref_num, &del_rel_ts); switch (timestamp_get_seconds_type()) { case TS_SECONDS_DEFAULT: set_time_seconds(fd, &del_rel_ts, buf); break; case TS_SECONDS_HOUR_MIN_SEC: set_time_seconds(fd, &del_rel_ts, buf); break; default: ws_assert_not_reached(); } } else { buf[0] = '\0'; } break; case TS_DELTA: if (fd->has_ts) { nstime_t del_cap_ts; frame_delta_abs_time(epan, fd, fd->num - 1, &del_cap_ts); switch (timestamp_get_seconds_type()) { case TS_SECONDS_DEFAULT: set_time_seconds(fd, &del_cap_ts, buf); break; case TS_SECONDS_HOUR_MIN_SEC: set_time_hour_min_sec(fd, &del_cap_ts, buf, col_decimal_point); break; default: ws_assert_not_reached(); } } else { buf[0] = '\0'; } break; case TS_DELTA_DIS: if (fd->has_ts) { nstime_t del_dis_ts; frame_delta_abs_time(epan, fd, fd->prev_dis_num, &del_dis_ts); switch (timestamp_get_seconds_type()) { case TS_SECONDS_DEFAULT: set_time_seconds(fd, &del_dis_ts, buf); break; case TS_SECONDS_HOUR_MIN_SEC: set_time_hour_min_sec(fd, &del_dis_ts, buf, col_decimal_point); break; default: ws_assert_not_reached(); } } else { buf[0] = '\0'; } break; case TS_EPOCH: set_epoch_time(fd, buf); break; case TS_UTC: set_abs_time(fd, buf, col_decimal_point, FALSE); break; case TS_UTC_WITH_YMD: set_abs_ymd_time(fd, buf, col_decimal_point, FALSE); break; case TS_UTC_WITH_YDOY: set_abs_ydoy_time(fd, buf, col_decimal_point, FALSE); break; case TS_NOT_SET: /* code is missing for this case, but I don't know which [jmayer20051219] */ ws_assert_not_reached(); break; } } static void col_set_cls_time(const frame_data *fd, column_info *cinfo, const gint col) { switch (timestamp_get_type()) { case TS_ABSOLUTE: col_set_abs_time(fd, cinfo, col); break; case TS_ABSOLUTE_WITH_YMD: col_set_abs_ymd_time(fd, cinfo, col); break; case TS_ABSOLUTE_WITH_YDOY: col_set_abs_ydoy_time(fd, cinfo, col); break; case TS_RELATIVE: col_set_rel_time(fd, cinfo, col); break; case TS_DELTA: col_set_delta_time(fd, cinfo, col); break; case TS_DELTA_DIS: col_set_delta_time_dis(fd, cinfo, col); break; case TS_EPOCH: col_set_epoch_time(fd, cinfo, col); break; case TS_UTC: col_set_utc_time(fd, cinfo, col); break; case TS_UTC_WITH_YMD: col_set_utc_ymd_time(fd, cinfo, col); break; case TS_UTC_WITH_YDOY: col_set_utc_ydoy_time(fd, cinfo, col); break; case TS_NOT_SET: /* code is missing for this case, but I don't know which [jmayer20051219] */ ws_assert_not_reached(); break; } } /* Set the format of the variable time format. */ static void col_set_fmt_time(const frame_data *fd, column_info *cinfo, const gint fmt, const gint col) { COL_CHECK_REF_TIME(fd, cinfo->columns[col].col_buf); switch (fmt) { case COL_CLS_TIME: col_set_cls_time(fd, cinfo, col); break; case COL_ABS_TIME: col_set_abs_time(fd, cinfo, col); break; case COL_ABS_YMD_TIME: col_set_abs_ymd_time(fd, cinfo, col); break; case COL_ABS_YDOY_TIME: col_set_abs_ydoy_time(fd, cinfo, col); break; case COL_REL_TIME: col_set_rel_time(fd, cinfo, col); break; case COL_DELTA_TIME: col_set_delta_time(fd, cinfo, col); break; case COL_DELTA_TIME_DIS: col_set_delta_time_dis(fd, cinfo, col); break; case COL_UTC_TIME: col_set_utc_time(fd, cinfo, col); break; case COL_UTC_YMD_TIME: col_set_utc_ymd_time(fd, cinfo, col); break; case COL_UTC_YDOY_TIME: col_set_utc_ydoy_time(fd, cinfo, col); break; default: ws_assert_not_reached(); break; } } /* --------------------------- */ /* Set the given (relative) time to a column element. * * Used by dissectors to set the time in a column * * @param cinfo the current packet row * @param el the column to use, e.g. COL_INFO * @param ts the time to set in the column * @param fieldname the fieldname to use for creating a filter (when * applying/preparing/copying as filter) */ void col_set_time(column_info *cinfo, const gint el, const nstime_t *ts, const char *fieldname) { int col; col_item_t* col_item; if (!CHECK_COL(cinfo, el)) return; /** @todo TODO: We don't respect fd->ref_time (no way to access 'fd') COL_CHECK_REF_TIME(fd, buf); */ for (col = cinfo->col_first[el]; col <= cinfo->col_last[el]; col++) { col_item = &cinfo->columns[col]; if (col_item->fmt_matx[el]) { display_signed_time(col_item->col_buf, COL_MAX_LEN, ts, get_default_timestamp_precision()); col_item->col_data = col_item->col_buf; cinfo->col_expr.col_expr[col] = fieldname; (void) g_strlcpy(cinfo->col_expr.col_expr_val[col],col_item->col_buf,COL_MAX_LEN); } } } static void col_set_addr(packet_info *pinfo, const int col, const address *addr, const gboolean is_src, const gboolean fill_col_exprs, const gboolean res) { const char *name; col_item_t* col_item = &pinfo->cinfo->columns[col]; if (addr->type == AT_NONE) { /* No address, nothing to do */ return; } if (res && (name = address_to_name(addr)) != NULL) col_item->col_data = name; else { col_item->col_data = col_item->col_buf; address_to_str_buf(addr, col_item->col_buf, COL_MAX_LEN); } if (!fill_col_exprs) return; pinfo->cinfo->col_expr.col_expr[col] = address_type_column_filter_string(addr, is_src); /* For address types that have a filter, create a string */ if (strlen(pinfo->cinfo->col_expr.col_expr[col]) > 0) address_to_str_buf(addr, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN); } /* ------------------------ */ static void col_set_port(packet_info *pinfo, const int col, const gboolean is_res, const gboolean is_src, const gboolean fill_col_exprs _U_) { guint32 port; col_item_t* col_item = &pinfo->cinfo->columns[col]; if (is_src) port = pinfo->srcport; else port = pinfo->destport; /* TODO: Use fill_col_exprs */ switch (pinfo->ptype) { case PT_SCTP: if (is_res) (void) g_strlcpy(col_item->col_buf, sctp_port_to_display(pinfo->pool, port), COL_MAX_LEN); else guint32_to_str_buf(port, col_item->col_buf, COL_MAX_LEN); break; case PT_TCP: guint32_to_str_buf(port, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN); if (is_res) (void) g_strlcpy(col_item->col_buf, tcp_port_to_display(pinfo->pool, port), COL_MAX_LEN); else (void) g_strlcpy(col_item->col_buf, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN); if (is_src) pinfo->cinfo->col_expr.col_expr[col] = "tcp.srcport"; else pinfo->cinfo->col_expr.col_expr[col] = "tcp.dstport"; break; case PT_UDP: guint32_to_str_buf(port, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN); if (is_res) (void) g_strlcpy(col_item->col_buf, udp_port_to_display(pinfo->pool, port), COL_MAX_LEN); else (void) g_strlcpy(col_item->col_buf, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN); if (is_src) pinfo->cinfo->col_expr.col_expr[col] = "udp.srcport"; else pinfo->cinfo->col_expr.col_expr[col] = "udp.dstport"; break; case PT_DDP: if (is_src) pinfo->cinfo->col_expr.col_expr[col] = "ddp.src_socket"; else pinfo->cinfo->col_expr.col_expr[col] = "ddp.dst_socket"; guint32_to_str_buf(port, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN); (void) g_strlcpy(col_item->col_buf, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN); break; case PT_IPX: /* XXX - resolve IPX socket numbers */ snprintf(col_item->col_buf, COL_MAX_LEN, "0x%04x", port); (void) g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], col_item->col_buf,COL_MAX_LEN); if (is_src) pinfo->cinfo->col_expr.col_expr[col] = "ipx.src.socket"; else pinfo->cinfo->col_expr.col_expr[col] = "ipx.dst.socket"; break; case PT_IDP: /* XXX - resolve IDP socket numbers */ snprintf(col_item->col_buf, COL_MAX_LEN, "0x%04x", port); (void) g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], col_item->col_buf,COL_MAX_LEN); if (is_src) pinfo->cinfo->col_expr.col_expr[col] = "idp.src.socket"; else pinfo->cinfo->col_expr.col_expr[col] = "idp.dst.socket"; break; case PT_USB: /* XXX - resolve USB endpoint numbers */ snprintf(col_item->col_buf, COL_MAX_LEN, "0x%08x", port); (void) g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], col_item->col_buf,COL_MAX_LEN); if (is_src) pinfo->cinfo->col_expr.col_expr[col] = "usb.src.endpoint"; else pinfo->cinfo->col_expr.col_expr[col] = "usb.dst.endpoint"; break; default: break; } col_item->col_data = col_item->col_buf; } gboolean col_based_on_frame_data(column_info *cinfo, const gint col) { ws_assert(cinfo); ws_assert(col < cinfo->num_cols); switch (cinfo->columns[col].col_fmt) { case COL_NUMBER: case COL_CLS_TIME: case COL_ABS_TIME: case COL_ABS_YMD_TIME: case COL_ABS_YDOY_TIME: case COL_UTC_TIME: case COL_UTC_YMD_TIME: case COL_UTC_YDOY_TIME: case COL_REL_TIME: case COL_DELTA_TIME: case COL_DELTA_TIME_DIS: case COL_PACKET_LENGTH: case COL_CUMULATIVE_BYTES: return TRUE; default: return FALSE; } } void col_fill_in_frame_data(const frame_data *fd, column_info *cinfo, const gint col, const gboolean fill_col_exprs) { col_item_t* col_item = &cinfo->columns[col]; switch (col_item->col_fmt) { case COL_NUMBER: guint32_to_str_buf(fd->num, col_item->col_buf, COL_MAX_LEN); col_item->col_data = col_item->col_buf; break; case COL_CLS_TIME: case COL_ABS_TIME: case COL_ABS_YMD_TIME: case COL_ABS_YDOY_TIME: case COL_UTC_TIME: case COL_UTC_YMD_TIME: case COL_UTC_YDOY_TIME: case COL_REL_TIME: case COL_DELTA_TIME: case COL_DELTA_TIME_DIS: /* TODO: Pass on fill_col_exprs */ col_set_fmt_time(fd, cinfo, col_item->col_fmt, col); break; case COL_PACKET_LENGTH: guint32_to_str_buf(fd->pkt_len, col_item->col_buf, COL_MAX_LEN); col_item->col_data = col_item->col_buf; break; case COL_CUMULATIVE_BYTES: guint32_to_str_buf(fd->cum_bytes, col_item->col_buf, COL_MAX_LEN); col_item->col_data = col_item->col_buf; break; default: break; } if (!fill_col_exprs) return; switch (col_item->col_fmt) { case COL_NUMBER: cinfo->col_expr.col_expr[col] = "frame.number"; (void) g_strlcpy(cinfo->col_expr.col_expr_val[col], col_item->col_buf, COL_MAX_LEN); break; case COL_CLS_TIME: case COL_ABS_TIME: case COL_ABS_YMD_TIME: case COL_ABS_YDOY_TIME: case COL_UTC_TIME: case COL_UTC_YMD_TIME: case COL_UTC_YDOY_TIME: case COL_REL_TIME: case COL_DELTA_TIME: case COL_DELTA_TIME_DIS: /* Already handled above */ break; case COL_PACKET_LENGTH: cinfo->col_expr.col_expr[col] = "frame.len"; (void) g_strlcpy(cinfo->col_expr.col_expr_val[col], col_item->col_buf, COL_MAX_LEN); break; case COL_CUMULATIVE_BYTES: break; default: break; } } void col_fill_in(packet_info *pinfo, const gboolean fill_col_exprs, const gboolean fill_fd_colums) { int i; col_item_t* col_item; if (!pinfo->cinfo) return; for (i = 0; i < pinfo->cinfo->num_cols; i++) { col_item = &pinfo->cinfo->columns[i]; if (col_based_on_frame_data(pinfo->cinfo, i)) { if (fill_fd_colums) col_fill_in_frame_data(pinfo->fd, pinfo->cinfo, i, fill_col_exprs); } else { switch (col_item->col_fmt) { case COL_DEF_SRC: case COL_RES_SRC: /* COL_DEF_SRC is currently just like COL_RES_SRC */ col_set_addr(pinfo, i, &pinfo->src, TRUE, fill_col_exprs, TRUE); break; case COL_UNRES_SRC: col_set_addr(pinfo, i, &pinfo->src, TRUE, fill_col_exprs, FALSE); break; case COL_DEF_DL_SRC: case COL_RES_DL_SRC: col_set_addr(pinfo, i, &pinfo->dl_src, TRUE, fill_col_exprs, TRUE); break; case COL_UNRES_DL_SRC: col_set_addr(pinfo, i, &pinfo->dl_src, TRUE, fill_col_exprs, FALSE); break; case COL_DEF_NET_SRC: case COL_RES_NET_SRC: col_set_addr(pinfo, i, &pinfo->net_src, TRUE, fill_col_exprs, TRUE); break; case COL_UNRES_NET_SRC: col_set_addr(pinfo, i, &pinfo->net_src, TRUE, fill_col_exprs, FALSE); break; case COL_DEF_DST: case COL_RES_DST: /* COL_DEF_DST is currently just like COL_RES_DST */ col_set_addr(pinfo, i, &pinfo->dst, FALSE, fill_col_exprs, TRUE); break; case COL_UNRES_DST: col_set_addr(pinfo, i, &pinfo->dst, FALSE, fill_col_exprs, FALSE); break; case COL_DEF_DL_DST: case COL_RES_DL_DST: col_set_addr(pinfo, i, &pinfo->dl_dst, FALSE, fill_col_exprs, TRUE); break; case COL_UNRES_DL_DST: col_set_addr(pinfo, i, &pinfo->dl_dst, FALSE, fill_col_exprs, FALSE); break; case COL_DEF_NET_DST: case COL_RES_NET_DST: col_set_addr(pinfo, i, &pinfo->net_dst, FALSE, fill_col_exprs, TRUE); break; case COL_UNRES_NET_DST: col_set_addr(pinfo, i, &pinfo->net_dst, FALSE, fill_col_exprs, FALSE); break; case COL_DEF_SRC_PORT: case COL_RES_SRC_PORT: /* COL_DEF_SRC_PORT is currently just like COL_RES_SRC_PORT */ col_set_port(pinfo, i, TRUE, TRUE, fill_col_exprs); break; case COL_UNRES_SRC_PORT: col_set_port(pinfo, i, FALSE, TRUE, fill_col_exprs); break; case COL_DEF_DST_PORT: case COL_RES_DST_PORT: /* COL_DEF_DST_PORT is currently just like COL_RES_DST_PORT */ col_set_port(pinfo, i, TRUE, FALSE, fill_col_exprs); break; case COL_UNRES_DST_PORT: col_set_port(pinfo, i, FALSE, FALSE, fill_col_exprs); break; case COL_CUSTOM: /* Formatting handled by col_custom_set_edt() / col_custom_get_filter() */ break; case NUM_COL_FMTS: /* keep compiler happy - shouldn't get here */ ws_assert_not_reached(); break; default: if (col_item->col_fmt >= NUM_COL_FMTS) { ws_assert_not_reached(); } /* * Formatting handled by expert.c (COL_EXPERT), or individual * dissectors. Fill in from the text using the internal hfid. */ if (fill_col_exprs) { pinfo->cinfo->col_expr.col_expr[i] = proto_registrar_get_nth(col_item->hf_id)->abbrev; (void) g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[i], pinfo->cinfo->columns[i].col_data, (col_item->col_fmt == COL_INFO) ? COL_MAX_INFO_LEN : COL_MAX_LEN); } break; } } } } /* * Fill in columns if we got an error reading the packet. * We set most columns to "???", fill in columns that don't need data read * from the file, and set the Info column to an error message. */ void col_fill_in_error(column_info *cinfo, frame_data *fdata, const gboolean fill_col_exprs, const gboolean fill_fd_colums) { int i; col_item_t* col_item; if (!cinfo) return; for (i = 0; i < cinfo->num_cols; i++) { col_item = &cinfo->columns[i]; if (col_based_on_frame_data(cinfo, i)) { if (fill_fd_colums) col_fill_in_frame_data(fdata, cinfo, i, fill_col_exprs); } else if (col_item->col_fmt == COL_INFO) { /* XXX - say more than this */ col_item->col_data = "Read error"; } else { if (col_item->col_fmt >= NUM_COL_FMTS) { ws_assert_not_reached(); } /* * No dissection was done, and these columns are set as the * result of the dissection, so.... */ col_item->col_data = "???"; break; } } } gboolean col_data_changed(void) { gboolean cur_cdc = col_data_changed_; col_data_changed_ = FALSE; return cur_cdc; } void col_register_protocol(void) { /* This gets called by proto_init() before column_register_fields() * gets called by the preference modules actually getting registered. */ if (proto_cols <= 0) { proto_cols = proto_get_id_by_filter_name("_ws.col"); } if (proto_cols <= 0) { proto_cols = proto_register_protocol("Wireshark Columns", "Columns", "_ws.col"); } static gint *ett[] = { &ett_cols }; proto_register_subtree_array(ett, G_N_ELEMENTS(ett)); } void col_dissect(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { proto_item *ti; proto_tree *col_tree; column_info *cinfo = pinfo->cinfo; if (!cinfo) { return; } if (proto_field_is_referenced(tree, proto_cols)) { // XXX: Needed if we also create _ws.col.custom //col_custom_set(tree, cinfo); col_fill_in(pinfo, FALSE, TRUE); ti = proto_tree_add_item(tree, proto_cols, tvb, 0, 0, ENC_NA); proto_item_set_hidden(ti); col_tree = proto_item_add_subtree(ti, ett_cols); for (int i = 0; i < cinfo->num_cols; ++i) { if (cinfo->columns[i].hf_id != -1) { if (cinfo->columns[i].col_fmt == COL_CUSTOM) { ti = proto_tree_add_string_format(col_tree, cinfo->columns[i].hf_id, tvb, 0, 0, get_column_text(cinfo, i), "%s: %s", get_column_title(i), get_column_text(cinfo, i)); } else { ti = proto_tree_add_string(col_tree, cinfo->columns[i].hf_id, tvb, 0, 0, get_column_text(cinfo, i)); } proto_item_set_hidden(ti); } } } } /* * Editor modelines * * Local Variables: * c-basic-offset: 2 * tab-width: 8 * indent-tabs-mode: nil * End: * * ex: set shiftwidth=2 tabstop=8 expandtab: * :indentSize=2:tabSize=8:noTabs=true: */