Adding upstream version 4.2.2.upstream/4.2.2

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

1 files changed, 293 insertions, 0 deletions

diff --git a/ui/preference_utils.c b/ui/preference_utils.c
new file mode 100644
index 00000000..751b47b8
--- /dev/null
+++ b/ui/preference_utils.c
@@ -0,0 +1,293 @@
+/* preference_utils.c
+ * Routines for handling preferences
+ *
+ * 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 <errno.h>
+
+#include <epan/column.h>
+#include <wsutil/filesystem.h>
+#include <wsutil/wslog.h>
+#include <epan/prefs.h>
+#include <epan/prefs-int.h>
+#include <epan/packet.h>
+#include <epan/decode_as.h>
+#include <epan/uat-int.h>
+#include <ui/recent.h>
+
+#ifdef HAVE_LIBPCAP
+#include "capture_opts.h"
+#include "ui/capture_globals.h"
+#endif
+
+#include "ui/preference_utils.h"
+#include "ui/simple_dialog.h"
+
+/* Fill in capture options with values from the preferences */
+void
+prefs_to_capture_opts(void)
+{
+#ifdef HAVE_LIBPCAP
+    /* Set promiscuous mode from the preferences setting. */
+    /* the same applies to other preferences settings as well. */
+    global_capture_opts.default_options.promisc_mode = prefs.capture_prom_mode;
+    global_capture_opts.use_pcapng                   = prefs.capture_pcap_ng;
+    global_capture_opts.show_info                    = prefs.capture_show_info;
+    global_capture_opts.real_time_mode               = prefs.capture_real_time;
+    global_capture_opts.update_interval              = prefs.capture_update_interval;
+#endif /* HAVE_LIBPCAP */
+}
+
+void
+prefs_main_write(void)
+{
+    int   err;
+    char *pf_dir_path;
+    char *pf_path;
+
+    /* Create the directory that holds personal configuration files, if
+       necessary.  */
+    if (create_persconffile_dir(&pf_dir_path) == -1) {
+        simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+                "Can't create directory\n\"%s\"\nfor preferences file: %s.", pf_dir_path,
+                g_strerror(errno));
+        g_free(pf_dir_path);
+    } else {
+        /* Write the preferences out. */
+        err = write_prefs(&pf_path);
+        if (err != 0) {
+            simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+                    "Can't open preferences file\n\"%s\": %s.", pf_path,
+                    g_strerror(err));
+            g_free(pf_path);
+        }
+        /* Write recent and recent_common files out to ensure sync with prefs. */
+        write_profile_recent();
+        write_recent();
+    }
+}
+
+static unsigned int
+prefs_store_ext_helper(const char * module_name, const char *pref_name, const char *pref_value)
+{
+    module_t * module = NULL;
+    pref_t * pref = NULL;
+    unsigned int pref_changed = 0;
+
+    if ( !prefs_is_registered_protocol(module_name))
+        return 0;
+
+    module = prefs_find_module(module_name);
+    if ( !module )
+        return 0;
+
+    pref = prefs_find_preference(module, pref_name);
+
+    if (!pref)
+        return 0;
+
+    if (prefs_get_type(pref) == PREF_STRING )
+    {
+        pref_changed |= prefs_set_string_value(pref, pref_value, pref_stashed);
+        if ( !pref_changed || prefs_get_string_value(pref, pref_stashed) != 0 )
+            pref_changed |= prefs_set_string_value(pref, pref_value, pref_current);
+    } else if (prefs_get_type(pref) == PREF_PASSWORD )
+    {
+        pref_changed |= prefs_set_password_value(pref, pref_value, pref_stashed);
+        if ( !pref_changed || prefs_get_password_value(pref, pref_stashed) != 0 )
+            pref_changed |= prefs_set_password_value(pref, pref_value, pref_current);
+    }
+
+    return pref_changed;
+}
+
+unsigned int
+prefs_store_ext(const char * module_name, const char *pref_name, const char *pref_value)
+{
+    unsigned int changed_flags = prefs_store_ext_helper(module_name, pref_name, pref_value);
+    if ( changed_flags )
+    {
+        prefs_main_write();
+        prefs_apply_all();
+        prefs_to_capture_opts();
+        return changed_flags;
+    }
+
+    return 0;
+}
+
+gboolean
+prefs_store_ext_multiple(const char * module, GHashTable * pref_values)
+{
+    gboolean pref_changed = FALSE;
+    GList * keys = NULL;
+
+    if ( !prefs_is_registered_protocol(module))
+        return pref_changed;
+
+    keys = g_hash_table_get_keys(pref_values);
+    if ( !keys )
+        return pref_changed;
+
+    for ( GList * key = keys; key != NULL; key = g_list_next(key) )
+    {
+        gchar * pref_name = (gchar *)key->data;
+        gchar * pref_value = (gchar *) g_hash_table_lookup(pref_values, key->data);
+
+        if ( pref_name && pref_value )
+        {
+            if ( prefs_store_ext_helper(module, pref_name, pref_value) )
+                pref_changed = TRUE;
+        }
+    }
+    g_list_free(keys);
+
+    if ( pref_changed )
+    {
+        prefs_main_write();
+        prefs_apply_all();
+        prefs_to_capture_opts();
+    }
+
+    return TRUE;
+}
+
+gint
+column_prefs_add_custom(gint fmt, const gchar *title, const gchar *custom_fields, gint position)
+{
+    GList *clp;
+    fmt_data *cfmt, *last_cfmt;
+    gint colnr;
+
+    cfmt = g_new(fmt_data, 1);
+    /*
+     * Because a single underscore is interpreted as a signal that the next character
+     * is going to be marked as accelerator for this header (i.e. is going to be
+     * shown underlined), escape it be inserting a second consecutive underscore.
+     */
+    cfmt->title = g_strdup(title);
+    cfmt->fmt = fmt;
+    cfmt->custom_fields = g_strdup(custom_fields);
+    cfmt->custom_occurrence = 0;
+    cfmt->resolved = TRUE;
+
+    colnr = g_list_length(prefs.col_list);
+
+    if (custom_fields) {
+        cfmt->visible = TRUE;
+        clp = g_list_last(prefs.col_list);
+        last_cfmt = (fmt_data *) clp->data;
+        if (position > 0 && position <= colnr) {
+            /* Custom fields may be added at any position, depending on the given argument */
+            prefs.col_list = g_list_insert(prefs.col_list, cfmt, position);
+        } else if (last_cfmt->fmt == COL_INFO) {
+            /* Last column is COL_INFO, add custom column before this */
+            colnr -= 1;
+            prefs.col_list = g_list_insert(prefs.col_list, cfmt, colnr);
+        } else {
+            prefs.col_list = g_list_append(prefs.col_list, cfmt);
+        }
+    } else {
+        cfmt->visible = FALSE;  /* Will be set to TRUE in visible_toggled() when added to list */
+        prefs.col_list = g_list_append(prefs.col_list, cfmt);
+    }
+
+    return colnr;
+}
+
+gint
+column_prefs_has_custom(const gchar *custom_field)
+{
+    GList *clp;
+    fmt_data *cfmt;
+    gint colnr = -1;
+
+    for (gint i = 0; i < prefs.num_cols; i++) {
+        clp = g_list_nth(prefs.col_list, i);
+        if (clp == NULL) /* Sanity check, invalid column requested */
+            continue;
+
+        cfmt = (fmt_data *) clp->data;
+        if (cfmt->fmt == COL_CUSTOM && cfmt->custom_occurrence == 0 && strcmp(custom_field, cfmt->custom_fields) == 0) {
+            colnr = i;
+            break;
+        }
+    }
+
+    return colnr;
+}
+
+gboolean
+column_prefs_custom_resolve(const gchar* custom_field)
+{
+    gchar **fields;
+    header_field_info *hfi;
+    bool resolve = false;
+
+    fields = g_regex_split_simple(COL_CUSTOM_PRIME_REGEX, custom_field,
+                                  (GRegexCompileFlags) (G_REGEX_ANCHORED | G_REGEX_RAW),
+                                  G_REGEX_MATCH_ANCHORED);
+
+    for (guint i = 0; i < g_strv_length(fields); i++) {
+        if (fields[i] && *fields[i]) {
+            hfi = proto_registrar_get_byname(fields[i]);
+            if (hfi && ((hfi->type == FT_OID) || (hfi->type == FT_REL_OID) || (hfi->type == FT_ETHER) || (hfi->type == FT_IPv4) || (hfi->type == FT_IPv6) || (hfi->type == FT_FCWWN) || (hfi->type == FT_BOOLEAN) ||
+                    ((hfi->strings != NULL) &&
+                     (FT_IS_INT(hfi->type) || FT_IS_UINT(hfi->type)))))
+                {
+                    resolve = TRUE;
+                    break;
+                }
+        }
+    }
+
+    g_strfreev(fields);
+
+    return resolve;
+}
+
+void
+column_prefs_remove_link(GList *col_link)
+{
+    fmt_data *cfmt;
+
+    if (!col_link || !col_link->data) return;
+
+    cfmt = (fmt_data *) col_link->data;
+
+    g_free(cfmt->title);
+    g_free(cfmt->custom_fields);
+    g_free(cfmt);
+    prefs.col_list = g_list_remove_link(prefs.col_list, col_link);
+    g_list_free_1(col_link);
+}
+
+void
+column_prefs_remove_nth(gint col)
+{
+    column_prefs_remove_link(g_list_nth(prefs.col_list, col));
+}
+
+void save_migrated_uat(const char *uat_name, gboolean *old_pref)
+{
+    char *err = NULL;
+
+    if (!uat_save(uat_get_table_by_name(uat_name), &err)) {
+        ws_warning("Unable to save %s: %s", uat_name, err);
+        g_free(err);
+        return;
+    }
+
+    // Ensure that any old preferences are removed after successful migration.
+    if (*old_pref) {
+        *old_pref = FALSE;
+        prefs_main_write();
+    }
+}