Adding upstream version 4.2.2.upstream/4.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 287 insertions, 0 deletions

diff --git a/ui/cli/tap-expert.c b/ui/cli/tap-expert.c
new file mode 100644
index 00000000..3fcf0e7f
--- /dev/null
+++ b/ui/cli/tap-expert.c
@@ -0,0 +1,287 @@
+/* tap-expert.c
+ * Copyright 2011 Martin Mathieson
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <epan/packet.h>
+#include <epan/tap.h>
+#include <epan/stat_tap_ui.h>
+#include <epan/expert.h>
+#include <wsutil/ws_assert.h>
+
+void register_tap_listener_expert_info(void);
+
+/* Tap data */
+typedef enum severity_level_t {
+    comment_level = 0,
+    chat_level,
+    note_level,
+    warn_level,
+    error_level,
+    max_level
+} severity_level_t;
+
+/* This variable stores the lowest level that will be displayed.
+   May be changed from the command line */
+static severity_level_t lowest_report_level = comment_level;
+
+typedef struct expert_entry
+{
+    guint32      group;
+    int          frequency;
+    const gchar *protocol;
+    gchar       *summary;
+} expert_entry;
+
+
+/* Overall struct for storing all data seen */
+typedef struct expert_tapdata_t {
+    GArray       *ei_array[max_level]; /* expert info items */
+    GStringChunk *text;         /* for efficient storage of summary strings */
+} expert_tapdata_t;
+
+
+/* Reset expert stats */
+static void
+expert_stat_reset(void *tapdata)
+{
+    gint              n;
+    expert_tapdata_t *etd = (expert_tapdata_t *)tapdata;
+
+    /* Free & reallocate chunk of strings */
+    g_string_chunk_free(etd->text);
+    etd->text = g_string_chunk_new(100);
+
+    /* Empty each of the arrays */
+    for (n=0; n < max_level; n++) {
+        g_array_set_size(etd->ei_array[n], 0);
+    }
+}
+
+/* Process stat struct for an expert frame */
+static tap_packet_status
+expert_stat_packet(void *tapdata, packet_info *pinfo _U_, epan_dissect_t *edt _U_,
+                   const void *pointer, tap_flags_t flags _U_)
+{
+    const expert_info_t *ei   = (const expert_info_t *)pointer;
+    expert_tapdata_t    *data = (expert_tapdata_t *)tapdata;
+    severity_level_t     severity_level;
+    expert_entry         tmp_entry;
+    expert_entry        *entry;
+    guint                n;
+
+    switch (ei->severity) {
+        case PI_COMMENT:
+            severity_level = comment_level;
+            break;
+        case PI_CHAT:
+            severity_level = chat_level;
+            break;
+        case PI_NOTE:
+            severity_level = note_level;
+            break;
+        case PI_WARN:
+            severity_level = warn_level;
+            break;
+        case PI_ERROR:
+            severity_level = error_level;
+            break;
+        default:
+            ws_assert_not_reached();
+            return TAP_PACKET_DONT_REDRAW;
+    }
+
+    /* Don't store details at a lesser severity than we are interested in */
+    if (severity_level < lowest_report_level) {
+        return TAP_PACKET_REDRAW; /* XXX - TAP_PACKET_DONT_REDRAW? */
+    }
+
+    /* If a duplicate just bump up frequency.
+       TODO: could make more efficient by avoiding linear search...*/
+    for (n=0; n < data->ei_array[severity_level]->len; n++) {
+        entry = &g_array_index(data->ei_array[severity_level], expert_entry, n);
+        if ((strcmp(ei->protocol, entry->protocol) == 0) &&
+            (strcmp(ei->summary, entry->summary) == 0)) {
+            entry->frequency++;
+            return TAP_PACKET_REDRAW;
+        }
+    }
+
+    /* Else Add new item to end of list for severity level */
+    entry = &tmp_entry;
+    /* Copy/Store protocol and summary strings efficiently using GStringChunk */
+    entry->protocol = g_string_chunk_insert_const(data->text, ei->protocol);
+    entry->summary = g_string_chunk_insert_const(data->text, ei->summary);
+    entry->group = ei->group;
+    entry->frequency = 1;
+    /* Store a copy of the expert entry */
+    g_array_append_val(data->ei_array[severity_level], tmp_entry);
+
+    return TAP_PACKET_REDRAW;
+}
+
+/* Output for all of the items of one severity */
+static void draw_items_for_severity(GArray *items, const gchar *label)
+{
+    guint         n;
+    expert_entry *ei;
+    int           total = 0;
+    gchar        *tmp_str;
+
+    /* Don't print title if no items */
+    if (items->len == 0) {
+        return;
+    }
+
+    /* Add frequencies together to get total */
+    for (n=0; n < items->len; n++) {
+        ei = &g_array_index(items, expert_entry, n);
+        total += ei->frequency;
+    }
+
+    /* Title */
+    printf("\n%s (%d)\n", label, total);
+    printf("=============\n");
+
+    /* Column headings */
+    printf("   Frequency      Group           Protocol  Summary\n");
+
+    /* Items */
+    for (n=0; n < items->len; n++) {
+        ei = &g_array_index(items, expert_entry, n);
+        tmp_str = val_to_str_wmem(NULL, ei->group, expert_group_vals, "Unknown (%d)");
+        printf("%12d %10s %18s  %s\n",
+              ei->frequency,
+              tmp_str,
+              ei->protocol, ei->summary);
+        wmem_free(NULL, tmp_str);
+    }
+}
+
+/* (Re)draw expert stats */
+static void
+expert_stat_draw(void *phs _U_)
+{
+    /* Look up the statistics struct */
+    expert_tapdata_t *hs = (expert_tapdata_t *)phs;
+
+    draw_items_for_severity(hs->ei_array[error_level], "Errors");
+    draw_items_for_severity(hs->ei_array[warn_level],  "Warns");
+    draw_items_for_severity(hs->ei_array[note_level],  "Notes");
+    draw_items_for_severity(hs->ei_array[chat_level],  "Chats");
+    draw_items_for_severity(hs->ei_array[comment_level],  "Comments");
+}
+
+static void
+expert_tapdata_free(expert_tapdata_t* hs)
+{
+    for (int n = 0; n < max_level; n++) {
+        g_array_free(hs->ei_array[n], TRUE);
+    }
+    g_string_chunk_free(hs->text);
+    g_free(hs);
+}
+
+/* Create a new expert stats struct */
+static void expert_stat_init(const char *opt_arg, void *userdata _U_)
+{
+    const char       *args   = NULL;
+    const char       *filter = NULL;
+    GString          *error_string;
+    expert_tapdata_t *hs;
+    int               n;
+
+    /* Check for args. */
+    if (strncmp(opt_arg, "expert", 6) == 0) {
+        /* Skip those characters */
+        args = opt_arg + 6;
+    }
+    else {
+        /* No args. Will show all reports, with no filter */
+        lowest_report_level = max_level;
+    }
+
+    /* First (optional) arg is Error|Warn|Note|Chat */
+    if (args != NULL) {
+        if (g_ascii_strncasecmp(args, ",error", 6) == 0) {
+            lowest_report_level = error_level;
+            args += 6;
+        }
+        else if (g_ascii_strncasecmp(args, ",warn", 5) == 0) {
+            lowest_report_level = warn_level;
+            args += 5;
+        } else if (g_ascii_strncasecmp(args, ",note", 5) == 0) {
+            lowest_report_level = note_level;
+            args += 5;
+        } else if (g_ascii_strncasecmp(args, ",chat", 5) == 0) {
+            lowest_report_level = chat_level;
+            args += 5;
+        } else if (g_ascii_strncasecmp(args, ",comment", 8) == 0) {
+            lowest_report_level = comment_level;
+            args += 8;
+        }
+    }
+
+    /* Second (optional) arg is a filter string */
+    if (args != NULL) {
+        if (args[0] == ',') {
+            filter = args+1;
+        }
+    }
+
+    /* Create top-level struct */
+    hs = g_new0(expert_tapdata_t, 1);
+
+    /* Allocate chunk of strings */
+    hs->text = g_string_chunk_new(100);
+
+    /* Allocate GArray for each severity level */
+    for (n=0; n < max_level; n++) {
+        hs->ei_array[n] = g_array_sized_new(FALSE, FALSE, sizeof(expert_entry), 1000);
+    }
+
+    /**********************************************/
+    /* Register the tap listener                  */
+    /**********************************************/
+
+    error_string = register_tap_listener("expert", hs,
+                                         filter, 0,
+                                         expert_stat_reset,
+                                         expert_stat_packet,
+                                         expert_stat_draw,
+                                         (tap_finish_cb)expert_tapdata_free);
+    if (error_string) {
+        printf("Expert tap error (%s)!\n", error_string->str);
+        g_string_free(error_string, TRUE);
+        expert_tapdata_free(hs);
+        exit(1);
+    }
+}
+
+static stat_tap_ui expert_stat_ui = {
+    REGISTER_STAT_GROUP_GENERIC,
+    NULL,
+    "expert",
+    expert_stat_init,
+    0,
+    NULL
+};
+
+/* Register this tap listener (need void on own so line register function found) */
+void
+register_tap_listener_expert_info(void)
+{
+    register_stat_tap_ui(&expert_stat_ui, NULL);
+}