2004-01-19 00:42:12 +00:00
|
|
|
/* recent.c
|
|
|
|
* Recent "preference" handling routines
|
|
|
|
* Copyright 2004, Ulf Lamping <ulf.lamping@web.de>
|
|
|
|
*
|
2006-05-21 05:12:17 +00:00
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
2004-01-19 00:42:12 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
2012-06-28 22:56:06 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
2004-01-19 00:42:12 +00:00
|
|
|
*/
|
|
|
|
|
2012-09-20 01:29:52 +00:00
|
|
|
#include "config.h"
|
2012-01-18 19:38:34 +00:00
|
|
|
|
2013-12-03 22:16:49 +00:00
|
|
|
#include <stdlib.h>
|
2004-01-19 01:00:58 +00:00
|
|
|
#include <string.h>
|
2012-01-18 19:38:34 +00:00
|
|
|
#include <errno.h>
|
2008-04-13 03:32:24 +00:00
|
|
|
|
2014-07-09 11:50:11 +00:00
|
|
|
#include "capture_opts.h"
|
2013-11-17 02:55:14 +00:00
|
|
|
#include <wsutil/filesystem.h>
|
2004-09-27 22:55:15 +00:00
|
|
|
#include <epan/prefs.h>
|
2004-10-01 08:33:53 +00:00
|
|
|
#include <epan/prefs-int.h>
|
2008-04-12 19:37:05 +00:00
|
|
|
#include <epan/column.h>
|
2015-12-13 12:32:34 +00:00
|
|
|
#include <epan/value_string.h>
|
2008-04-13 03:32:24 +00:00
|
|
|
|
2012-01-18 19:38:34 +00:00
|
|
|
#include "ui/last_open_dir.h"
|
|
|
|
#include "ui/recent.h"
|
|
|
|
#include "ui/recent_utils.h"
|
2012-01-16 01:07:52 +00:00
|
|
|
#include "ui/simple_dialog.h"
|
2008-04-13 03:32:24 +00:00
|
|
|
|
2012-01-18 19:38:34 +00:00
|
|
|
#include <wsutil/file_util.h>
|
strcasecmp(), strncasecmp(), g_strcasecmp(), and g_strncasecmp() delenda
est. Use g_ascii_strcasecmp() and g_ascii_strncasecmp(), and supply our
own versions if they're missing from GLib (as is the case with GLib
1.x).
In the code to build the list of named fields for Diameter, don't use
g_strdown(); do our own g_ascii_-style upper-case to lower-case mapping
in the hash function and use g_ascii_strcasecmp() in the compare
function.
We do this because there is no guarantee that toupper(), tolower(), and
functions that use them will, for example, map between "I" and "i" in
all locales; in Turkish locales, for example, there are, in both
upper case and lower case, versions of "i" with and without a dot, and
the upper-case version of "i" is "I"-with-a-dot and the lower-case
version of "I" is "i"-without-a-dot. This causes strings that should
match not to match.
This finishes fixing bug 2010 - an earlier checkin prevented the crash
(as there are other ways to produce the same crash, e.g. a bogus
dictionary.xml file), but didn't fix the case-insensitive string matching.
svn path=/trunk/; revision=23623
2007-11-27 18:52:51 +00:00
|
|
|
|
2014-10-12 18:56:12 +00:00
|
|
|
#define RECENT_KEY_MAIN_TOOLBAR_SHOW "gui.toolbar_main_show"
|
|
|
|
#define RECENT_KEY_FILTER_TOOLBAR_SHOW "gui.filter_toolbar_show"
|
|
|
|
#define RECENT_KEY_WIRELESS_TOOLBAR_SHOW "gui.wireless_toolbar_show"
|
|
|
|
#define RECENT_KEY_DRIVER_CHECK_SHOW "gui.airpcap_driver_check_show"
|
|
|
|
#define RECENT_KEY_PACKET_LIST_SHOW "gui.packet_list_show"
|
|
|
|
#define RECENT_KEY_TREE_VIEW_SHOW "gui.tree_view_show"
|
|
|
|
#define RECENT_KEY_BYTE_VIEW_SHOW "gui.byte_view_show"
|
|
|
|
#define RECENT_KEY_STATUSBAR_SHOW "gui.statusbar_show"
|
|
|
|
#define RECENT_KEY_PACKET_LIST_COLORIZE "gui.packet_list_colorize"
|
|
|
|
#define RECENT_GUI_TIME_FORMAT "gui.time_format"
|
|
|
|
#define RECENT_GUI_TIME_PRECISION "gui.time_precision"
|
|
|
|
#define RECENT_GUI_SECONDS_FORMAT "gui.seconds_format"
|
|
|
|
#define RECENT_GUI_ZOOM_LEVEL "gui.zoom_level"
|
|
|
|
#define RECENT_GUI_BYTES_VIEW "gui.bytes_view"
|
|
|
|
#define RECENT_GUI_GEOMETRY_MAIN_X "gui.geometry_main_x"
|
|
|
|
#define RECENT_GUI_GEOMETRY_MAIN_Y "gui.geometry_main_y"
|
2016-06-07 22:26:03 +00:00
|
|
|
#define RECENT_GUI_GTK_GEOMETRY_MAIN_X "gui.gtk.geometry_main_x"
|
|
|
|
#define RECENT_GUI_GTK_GEOMETRY_MAIN_Y "gui.gtk.geometry_main_y"
|
2014-10-12 18:56:12 +00:00
|
|
|
#define RECENT_GUI_GEOMETRY_MAIN_WIDTH "gui.geometry_main_width"
|
|
|
|
#define RECENT_GUI_GEOMETRY_MAIN_HEIGHT "gui.geometry_main_height"
|
|
|
|
#define RECENT_GUI_GEOMETRY_MAIN_MAXIMIZED "gui.geometry_main_maximized"
|
|
|
|
#define RECENT_GUI_GEOMETRY_MAIN_UPPER_PANE "gui.geometry_main_upper_pane"
|
|
|
|
#define RECENT_GUI_GEOMETRY_MAIN_LOWER_PANE "gui.geometry_main_lower_pane"
|
2008-01-14 16:40:23 +00:00
|
|
|
#define RECENT_GUI_GEOMETRY_STATUS_PANE_LEFT "gui.geometry_status_pane"
|
|
|
|
#define RECENT_GUI_GEOMETRY_STATUS_PANE_RIGHT "gui.geometry_status_pane_right"
|
2014-10-12 18:56:12 +00:00
|
|
|
#define RECENT_GUI_GEOMETRY_WLAN_STATS_PANE "gui.geometry_status_wlan_stats_pane"
|
|
|
|
#define RECENT_LAST_USED_PROFILE "gui.last_used_profile"
|
|
|
|
#define RECENT_GUI_FILEOPEN_REMEMBERED_DIR "gui.fileopen_remembered_dir"
|
|
|
|
#define RECENT_GUI_CONVERSATION_TABS "gui.conversation_tabs"
|
|
|
|
#define RECENT_GUI_ENDPOINT_TABS "gui.endpoint_tabs"
|
2015-09-30 11:49:01 +00:00
|
|
|
#define RECENT_GUI_RLC_PDUS_FROM_MAC_FRAMES "gui.rlc_pdus_from_mac_frames"
|
2015-12-15 18:47:02 +00:00
|
|
|
#define RECENT_GUI_CUSTOM_COLORS "gui.custom_colors"
|
2014-04-29 15:10:27 +00:00
|
|
|
|
2014-10-12 18:56:12 +00:00
|
|
|
#define RECENT_GUI_GEOMETRY "gui.geom."
|
2014-04-29 15:10:27 +00:00
|
|
|
|
2014-10-12 18:56:12 +00:00
|
|
|
#define RECENT_KEY_PRIVS_WARN_IF_ELEVATED "privs.warn_if_elevated"
|
|
|
|
#define RECENT_KEY_PRIVS_WARN_IF_NO_NPF "privs.warn_if_no_npf"
|
2004-02-01 20:28:11 +00:00
|
|
|
|
2004-01-19 00:42:12 +00:00
|
|
|
#define RECENT_FILE_NAME "recent"
|
2008-04-28 12:35:03 +00:00
|
|
|
#define RECENT_COMMON_FILE_NAME "recent_common"
|
2004-01-19 00:42:12 +00:00
|
|
|
|
|
|
|
recent_settings_t recent;
|
|
|
|
|
2015-12-13 12:32:34 +00:00
|
|
|
static const value_string ts_type_values[] = {
|
|
|
|
{ TS_RELATIVE, "RELATIVE" },
|
|
|
|
{ TS_ABSOLUTE, "ABSOLUTE" },
|
|
|
|
{ TS_ABSOLUTE_WITH_YMD, "ABSOLUTE_WITH_YMD" },
|
|
|
|
{ TS_ABSOLUTE_WITH_YDOY, "ABSOLUTE_WITH_YDOY" },
|
|
|
|
{ TS_ABSOLUTE_WITH_YMD, "ABSOLUTE_WITH_DATE" }, /* Backward compability */
|
|
|
|
{ TS_DELTA, "DELTA" },
|
|
|
|
{ TS_DELTA_DIS, "DELTA_DIS" },
|
|
|
|
{ TS_EPOCH, "EPOCH" },
|
|
|
|
{ TS_UTC, "UTC" },
|
|
|
|
{ TS_UTC_WITH_YMD, "UTC_WITH_YMD" },
|
|
|
|
{ TS_UTC_WITH_YDOY, "UTC_WITH_YDOY" },
|
|
|
|
{ TS_UTC_WITH_YMD, "UTC_WITH_DATE" }, /* Backward compability */
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string ts_precision_values[] = {
|
|
|
|
{ TS_PREC_AUTO, "AUTO" },
|
|
|
|
{ TS_PREC_FIXED_SEC, "SEC" },
|
|
|
|
{ TS_PREC_FIXED_DSEC, "DSEC" },
|
|
|
|
{ TS_PREC_FIXED_CSEC, "CSEC" },
|
|
|
|
{ TS_PREC_FIXED_MSEC, "MSEC" },
|
|
|
|
{ TS_PREC_FIXED_USEC, "USEC" },
|
|
|
|
{ TS_PREC_FIXED_NSEC, "NSEC" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string ts_seconds_values[] = {
|
|
|
|
{ TS_SECONDS_DEFAULT, "SECONDS" },
|
|
|
|
{ TS_SECONDS_HOUR_MIN_SEC, "HOUR_MIN_SEC" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
2004-01-19 03:46:43 +00:00
|
|
|
|
2008-04-12 19:37:05 +00:00
|
|
|
static void
|
|
|
|
free_col_width_info(recent_settings_t *rs)
|
|
|
|
{
|
|
|
|
col_width_data *cfmt;
|
|
|
|
|
|
|
|
while (rs->col_width_list != NULL) {
|
2013-03-15 22:39:37 +00:00
|
|
|
cfmt = (col_width_data *)rs->col_width_list->data;
|
2009-03-13 22:06:48 +00:00
|
|
|
g_free(cfmt->cfield);
|
2008-04-12 19:37:05 +00:00
|
|
|
g_free(cfmt);
|
|
|
|
rs->col_width_list = g_list_remove_link(rs->col_width_list, rs->col_width_list);
|
|
|
|
}
|
|
|
|
g_list_free(rs->col_width_list);
|
|
|
|
rs->col_width_list = NULL;
|
|
|
|
}
|
|
|
|
|
2013-02-02 05:34:31 +00:00
|
|
|
/** Write the geometry values of a single window to the recent file.
|
|
|
|
*
|
|
|
|
* @param key unused
|
|
|
|
* @param value the geometry values
|
2013-03-15 22:39:37 +00:00
|
|
|
* @param rfh recent file handle (FILE)
|
2013-02-02 05:34:31 +00:00
|
|
|
*/
|
|
|
|
static void
|
2013-03-15 22:39:37 +00:00
|
|
|
write_recent_geom(gpointer key _U_, gpointer value, gpointer rfh)
|
2013-02-02 05:34:31 +00:00
|
|
|
{
|
2014-10-12 18:56:12 +00:00
|
|
|
window_geometry_t *geom = (window_geometry_t *)value;
|
|
|
|
FILE *rf = (FILE *)rfh;
|
|
|
|
|
|
|
|
fprintf(rf, "\n# Geometry and maximized state of %s window.\n", geom->key);
|
|
|
|
fprintf(rf, "# Decimal integers.\n");
|
|
|
|
fprintf(rf, RECENT_GUI_GEOMETRY "%s.x: %d\n", geom->key, geom->x);
|
|
|
|
fprintf(rf, RECENT_GUI_GEOMETRY "%s.y: %d\n", geom->key, geom->y);
|
|
|
|
fprintf(rf, RECENT_GUI_GEOMETRY "%s.width: %d\n", geom->key,
|
|
|
|
geom->width);
|
|
|
|
fprintf(rf, RECENT_GUI_GEOMETRY "%s.height: %d\n", geom->key,
|
|
|
|
geom->height);
|
|
|
|
|
|
|
|
fprintf(rf, "# TRUE or FALSE (case-insensitive).\n");
|
|
|
|
fprintf(rf, RECENT_GUI_GEOMETRY "%s.maximized: %s\n", geom->key,
|
|
|
|
geom->maximized == TRUE ? "TRUE" : "FALSE");
|
2013-02-02 05:34:31 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/* the geometry hashtable for all known window classes,
|
|
|
|
* the window name is the key, and the geometry struct is the value */
|
|
|
|
static GHashTable *window_geom_hash = NULL;
|
|
|
|
|
2013-02-26 02:38:52 +00:00
|
|
|
/* save the window and its current geometry into the geometry hashtable */
|
2013-02-02 05:34:31 +00:00
|
|
|
void
|
|
|
|
window_geom_save(const gchar *name, window_geometry_t *geom)
|
|
|
|
{
|
2014-10-12 18:56:12 +00:00
|
|
|
gchar *key;
|
|
|
|
window_geometry_t *work;
|
2013-02-02 05:34:31 +00:00
|
|
|
|
2014-10-12 18:56:12 +00:00
|
|
|
/* init hashtable, if not already done */
|
|
|
|
if (!window_geom_hash) {
|
|
|
|
window_geom_hash = g_hash_table_new(g_str_hash, g_str_equal);
|
|
|
|
}
|
|
|
|
/* if we have an old one, remove and free it first */
|
|
|
|
work = (window_geometry_t *)g_hash_table_lookup(window_geom_hash, name);
|
|
|
|
if (work) {
|
|
|
|
g_hash_table_remove(window_geom_hash, name);
|
|
|
|
g_free(work->key);
|
|
|
|
g_free(work);
|
|
|
|
}
|
2013-02-02 05:34:31 +00:00
|
|
|
|
2014-10-12 18:56:12 +00:00
|
|
|
/* g_malloc and insert the new one */
|
|
|
|
work = (window_geometry_t *)g_malloc(sizeof(window_geometry_t));
|
|
|
|
*work = *geom;
|
|
|
|
key = g_strdup(name);
|
|
|
|
work->key = key;
|
|
|
|
g_hash_table_insert(window_geom_hash, key, work);
|
2013-02-02 05:34:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* load the desired geometry for this window from the geometry hashtable */
|
|
|
|
gboolean
|
|
|
|
window_geom_load(const gchar *name,
|
|
|
|
window_geometry_t *geom)
|
|
|
|
{
|
2014-10-12 18:56:12 +00:00
|
|
|
window_geometry_t *p;
|
2013-02-02 05:34:31 +00:00
|
|
|
|
2014-10-12 18:56:12 +00:00
|
|
|
/* init hashtable, if not already done */
|
|
|
|
if (!window_geom_hash) {
|
|
|
|
window_geom_hash = g_hash_table_new(g_str_hash, g_str_equal);
|
|
|
|
}
|
2013-02-02 05:34:31 +00:00
|
|
|
|
2014-10-12 18:56:12 +00:00
|
|
|
p = (window_geometry_t *)g_hash_table_lookup(window_geom_hash, name);
|
|
|
|
if (p) {
|
|
|
|
*geom = *p;
|
|
|
|
return TRUE;
|
|
|
|
} else {
|
|
|
|
return FALSE;
|
|
|
|
}
|
2013-02-02 05:34:31 +00:00
|
|
|
}
|
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
/* parse values of particular types */
|
|
|
|
static void
|
2015-12-13 22:06:55 +00:00
|
|
|
parse_recent_boolean(const gchar *val_str, gboolean *valuep)
|
2015-12-13 21:45:24 +00:00
|
|
|
{
|
2015-12-13 22:06:55 +00:00
|
|
|
if (g_ascii_strcasecmp(val_str, "true") == 0) {
|
2015-12-13 21:45:24 +00:00
|
|
|
*valuep = TRUE;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
*valuep = FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-02 05:34:31 +00:00
|
|
|
/** Read in a single geometry key value pair from the recent file.
|
|
|
|
*
|
|
|
|
* @param name the geom_name of the window
|
|
|
|
* @param key the subkey of this pair (e.g. "x")
|
|
|
|
* @param value the new value (e.g. "123")
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
window_geom_recent_read_pair(const char *name,
|
|
|
|
const char *key,
|
|
|
|
const char *value)
|
|
|
|
{
|
|
|
|
window_geometry_t geom;
|
|
|
|
|
|
|
|
/* find window geometry maybe already in hashtable */
|
2014-10-12 18:56:12 +00:00
|
|
|
if (!window_geom_load(name, &geom)) {
|
2013-02-02 05:34:31 +00:00
|
|
|
/* not in table, init geom with "basic" values */
|
|
|
|
geom.key = NULL; /* Will be set in window_geom_save() */
|
|
|
|
geom.set_pos = FALSE;
|
|
|
|
geom.x = -1;
|
|
|
|
geom.y = -1;
|
|
|
|
geom.set_size = FALSE;
|
|
|
|
geom.width = -1;
|
|
|
|
geom.height = -1;
|
|
|
|
|
|
|
|
geom.set_maximized = FALSE;/* this is valid in GTK2 only */
|
|
|
|
geom.maximized = FALSE; /* this is valid in GTK2 only */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(key, "x") == 0) {
|
|
|
|
geom.x = (gint)strtol(value, NULL, 10);
|
|
|
|
geom.set_pos = TRUE;
|
|
|
|
} else if (strcmp(key, "y") == 0) {
|
|
|
|
geom.y = (gint)strtol(value, NULL, 10);
|
|
|
|
geom.set_pos = TRUE;
|
|
|
|
} else if (strcmp(key, "width") == 0) {
|
|
|
|
geom.width = (gint)strtol(value, NULL, 10);
|
|
|
|
geom.set_size = TRUE;
|
|
|
|
} else if (strcmp(key, "height") == 0) {
|
|
|
|
geom.height = (gint)strtol(value, NULL, 10);
|
|
|
|
geom.set_size = TRUE;
|
|
|
|
} else if (strcmp(key, "maximized") == 0) {
|
2015-12-13 21:45:24 +00:00
|
|
|
parse_recent_boolean(value, &geom.maximized);
|
2013-02-02 05:34:31 +00:00
|
|
|
geom.set_maximized = TRUE;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Silently ignore the bogus key. We shouldn't abort here,
|
|
|
|
* as this could be due to a corrupt recent file.
|
|
|
|
*
|
|
|
|
* XXX - should we print a message about this?
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* save / replace geometry in hashtable */
|
|
|
|
window_geom_save(name, &geom);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Write all geometry values of all windows to the recent file.
|
|
|
|
* Will call write_recent_geom() for every existing window type.
|
|
|
|
*
|
|
|
|
* @param rf recent file handle from caller
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
window_geom_recent_write_all(FILE *rf)
|
|
|
|
{
|
|
|
|
/* init hashtable, if not already done */
|
2014-10-12 18:56:12 +00:00
|
|
|
if (!window_geom_hash) {
|
2013-02-02 05:34:31 +00:00
|
|
|
window_geom_hash = g_hash_table_new(g_str_hash, g_str_equal);
|
|
|
|
}
|
|
|
|
|
|
|
|
g_hash_table_foreach(window_geom_hash, write_recent_geom, rf);
|
|
|
|
}
|
|
|
|
|
2013-07-27 22:37:26 +00:00
|
|
|
/* Global list of recent capture filters. */
|
|
|
|
static GList *recent_cfilter_list;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Per-interface lists of recent capture filters; stored in a hash
|
|
|
|
* table indexed by interface name.
|
|
|
|
*/
|
|
|
|
static GHashTable *per_interface_cfilter_lists_hash;
|
|
|
|
|
|
|
|
/* XXX: use a preference for this setting! */
|
|
|
|
static guint cfilter_combo_max_recent = 20;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns a list of recent capture filters.
|
|
|
|
*
|
|
|
|
* @param ifname interface name; NULL refers to the global list.
|
|
|
|
*/
|
|
|
|
GList *
|
|
|
|
recent_get_cfilter_list(const gchar *ifname)
|
|
|
|
{
|
|
|
|
if (ifname == NULL)
|
|
|
|
return recent_cfilter_list;
|
|
|
|
if (per_interface_cfilter_lists_hash == NULL) {
|
|
|
|
/* No such lists exist. */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return (GList *)g_hash_table_lookup(per_interface_cfilter_lists_hash, ifname);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Add a capture filter to the global recent capture filter list or
|
|
|
|
* the recent capture filter list for an interface.
|
|
|
|
*
|
|
|
|
* @param ifname interface name; NULL refers to the global list.
|
|
|
|
* @param s text of capture filter
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
recent_add_cfilter(const gchar *ifname, const gchar *s)
|
|
|
|
{
|
|
|
|
GList *cfilter_list;
|
|
|
|
GList *li;
|
|
|
|
gchar *li_filter, *newfilter = NULL;
|
|
|
|
|
|
|
|
/* Don't add empty filters to the list. */
|
|
|
|
if (s[0] == '\0')
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (ifname == NULL)
|
|
|
|
cfilter_list = recent_cfilter_list;
|
|
|
|
else {
|
2013-07-28 20:24:27 +00:00
|
|
|
/* If we don't yet have a hash table for per-interface recent
|
2013-07-28 22:37:45 +00:00
|
|
|
capture filter lists, create one. Have it free the new key
|
|
|
|
if we're updating an entry rather than creating it below. */
|
2013-07-27 22:37:26 +00:00
|
|
|
if (per_interface_cfilter_lists_hash == NULL)
|
2013-07-28 22:37:45 +00:00
|
|
|
per_interface_cfilter_lists_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
|
2013-07-27 22:37:26 +00:00
|
|
|
cfilter_list = (GList *)g_hash_table_lookup(per_interface_cfilter_lists_hash, ifname);
|
|
|
|
}
|
|
|
|
|
|
|
|
li = g_list_first(cfilter_list);
|
|
|
|
while (li) {
|
|
|
|
/* If the filter is already in the list, remove the old one and
|
|
|
|
* append the new one at the latest position (at g_list_append() below) */
|
|
|
|
li_filter = (char *)li->data;
|
|
|
|
if (strcmp(s, li_filter) == 0) {
|
|
|
|
/* No need to copy the string, we're just moving it. */
|
|
|
|
newfilter = li_filter;
|
2013-07-28 20:24:27 +00:00
|
|
|
cfilter_list = g_list_remove(cfilter_list, li->data);
|
2013-07-27 22:37:26 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
li = li->next;
|
|
|
|
}
|
|
|
|
if (newfilter == NULL) {
|
|
|
|
/* The filter wasn't already in the list; make a copy to add. */
|
|
|
|
newfilter = g_strdup(s);
|
|
|
|
}
|
|
|
|
cfilter_list = g_list_append(cfilter_list, newfilter);
|
|
|
|
|
|
|
|
if (ifname == NULL)
|
|
|
|
recent_cfilter_list = cfilter_list;
|
|
|
|
else
|
|
|
|
g_hash_table_insert(per_interface_cfilter_lists_hash, g_strdup(ifname), cfilter_list);
|
|
|
|
}
|
|
|
|
|
2014-07-09 11:50:11 +00:00
|
|
|
#ifdef HAVE_PCAP_REMOTE
|
|
|
|
static GHashTable *remote_host_list=NULL;
|
|
|
|
|
2014-07-11 07:34:38 +00:00
|
|
|
int recent_get_remote_host_list_size(void)
|
2014-07-09 11:50:11 +00:00
|
|
|
{
|
2014-10-12 18:56:12 +00:00
|
|
|
return g_hash_table_size (remote_host_list);
|
2014-07-09 11:50:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void recent_add_remote_host(gchar *host, struct remote_host *rh)
|
|
|
|
{
|
2014-10-12 18:56:12 +00:00
|
|
|
if (remote_host_list == NULL) {
|
|
|
|
remote_host_list = g_hash_table_new (g_str_hash, g_str_equal);
|
|
|
|
}
|
|
|
|
g_hash_table_insert (remote_host_list, g_strdup(host), rh);
|
2014-07-09 11:50:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
free_remote_host (gpointer key _U_, gpointer value, gpointer user _U_)
|
|
|
|
{
|
|
|
|
struct remote_host *rh = value;
|
|
|
|
|
|
|
|
g_free (rh->r_host);
|
|
|
|
g_free (rh->remote_port);
|
|
|
|
g_free (rh->auth_username);
|
|
|
|
g_free (rh->auth_password);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2014-07-11 07:34:38 +00:00
|
|
|
GHashTable *get_remote_host_list(void)
|
2014-07-09 11:50:11 +00:00
|
|
|
{
|
2014-10-12 18:56:12 +00:00
|
|
|
return remote_host_list;
|
2014-07-09 11:50:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
recent_print_remote_host (gpointer key _U_, gpointer value, gpointer user)
|
|
|
|
{
|
|
|
|
FILE *rf = user;
|
|
|
|
struct remote_host_info *ri = value;
|
|
|
|
|
|
|
|
fprintf (rf, RECENT_KEY_REMOTE_HOST ": %s,%s,%d\n", ri->remote_host, ri->remote_port, ri->auth_type);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
capture_remote_combo_recent_write_all(FILE *rf)
|
|
|
|
{
|
|
|
|
if (remote_host_list && g_hash_table_size (remote_host_list) > 0) {
|
|
|
|
/* Write all remote interfaces to the recent file */
|
|
|
|
g_hash_table_foreach (remote_host_list, recent_print_remote_host, rf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-07-11 07:34:38 +00:00
|
|
|
void free_remote_host_list(void)
|
2014-07-09 11:50:11 +00:00
|
|
|
{
|
2014-10-12 18:56:12 +00:00
|
|
|
g_hash_table_foreach_remove(remote_host_list, free_remote_host, NULL);
|
2014-07-09 11:50:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
struct remote_host *
|
|
|
|
recent_get_remote_host(const gchar *host)
|
|
|
|
{
|
|
|
|
if (host == NULL)
|
|
|
|
return NULL;
|
|
|
|
if (remote_host_list == NULL) {
|
|
|
|
/* No such host exist. */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return (struct remote_host *)g_hash_table_lookup(remote_host_list, host);
|
|
|
|
}
|
|
|
|
|
|
|
|
gboolean
|
|
|
|
capture_remote_combo_add_recent(const gchar *s)
|
|
|
|
{
|
|
|
|
GList *vals = prefs_get_string_list (s);
|
|
|
|
GList *valp = vals;
|
|
|
|
gint auth_type;
|
|
|
|
char *p;
|
|
|
|
struct remote_host *rh;
|
|
|
|
|
|
|
|
if (valp == NULL)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
if (remote_host_list == NULL) {
|
|
|
|
remote_host_list = g_hash_table_new (g_str_hash, g_str_equal);
|
|
|
|
}
|
|
|
|
|
|
|
|
rh = g_malloc (sizeof (*rh));
|
|
|
|
|
|
|
|
/* First value is the host */
|
|
|
|
rh->r_host = g_strdup (valp->data);
|
|
|
|
if (strlen(rh->r_host) == 0) {
|
|
|
|
/* Empty remote host */
|
|
|
|
g_free(rh->r_host);
|
|
|
|
g_free(rh);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
rh->auth_type = CAPTURE_AUTH_NULL;
|
|
|
|
valp = valp->next;
|
|
|
|
|
|
|
|
if (valp) {
|
|
|
|
/* Found value 2, this is the port number */
|
|
|
|
rh->remote_port = g_strdup (valp->data);
|
|
|
|
valp = valp->next;
|
|
|
|
} else {
|
|
|
|
/* Did not find a port number */
|
|
|
|
rh->remote_port = g_strdup ("");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (valp) {
|
|
|
|
/* Found value 3, this is the authentication type */
|
|
|
|
auth_type = strtol(valp->data, &p, 0);
|
|
|
|
if (p != valp->data && *p == '\0') {
|
|
|
|
rh->auth_type = auth_type;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Do not store username and password */
|
|
|
|
rh->auth_username = g_strdup ("");
|
|
|
|
rh->auth_password = g_strdup ("");
|
|
|
|
|
|
|
|
prefs_clear_string_list(vals);
|
|
|
|
|
|
|
|
g_hash_table_insert (remote_host_list, g_strdup(rh->r_host), rh);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-07-27 22:37:26 +00:00
|
|
|
static void
|
|
|
|
cfilter_recent_write_all_list(FILE *rf, const gchar *ifname, GList *cfilter_list)
|
|
|
|
{
|
|
|
|
guint max_count = 0;
|
|
|
|
GList *li;
|
|
|
|
|
|
|
|
/* write all non empty capture filter strings to the recent file (until max count) */
|
|
|
|
li = g_list_first(cfilter_list);
|
|
|
|
while (li && (max_count++ <= cfilter_combo_max_recent) ) {
|
|
|
|
if (li->data && strlen((const char *)li->data)) {
|
|
|
|
if (ifname == NULL)
|
|
|
|
fprintf (rf, RECENT_KEY_CAPTURE_FILTER ": %s\n", (char *)li->data);
|
|
|
|
else
|
|
|
|
fprintf (rf, RECENT_KEY_CAPTURE_FILTER ".%s: %s\n", ifname, (char *)li->data);
|
|
|
|
}
|
|
|
|
li = li->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
cfilter_recent_write_all_hash_callback(gpointer key, gpointer value, gpointer user_data)
|
|
|
|
{
|
|
|
|
cfilter_recent_write_all_list((FILE *)user_data, (const gchar *)key, (GList *)value);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Write all capture filter values to the recent file.
|
|
|
|
*
|
|
|
|
* @param rf recent file handle from caller
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
cfilter_recent_write_all(FILE *rf)
|
|
|
|
{
|
|
|
|
/* Write out the global list. */
|
|
|
|
cfilter_recent_write_all_list(rf, NULL, recent_cfilter_list);
|
|
|
|
|
|
|
|
/* Write out all the per-interface lists. */
|
|
|
|
if (per_interface_cfilter_lists_hash != NULL) {
|
|
|
|
g_hash_table_foreach(per_interface_cfilter_lists_hash, cfilter_recent_write_all_hash_callback, (gpointer)rf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
/* Write out recent settings of particular types. */
|
|
|
|
static void
|
|
|
|
write_recent_boolean(FILE *rf, const char *description, const char *name,
|
|
|
|
gboolean value)
|
|
|
|
{
|
|
|
|
fprintf(rf, "\n# %s.\n", description);
|
|
|
|
fprintf(rf, "# TRUE or FALSE (case-insensitive).\n");
|
|
|
|
fprintf(rf, "%s: %s\n", name, value == TRUE ? "TRUE" : "FALSE");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
write_recent_enum(FILE *rf, const char *description, const char *name,
|
|
|
|
const value_string *values, guint value)
|
|
|
|
{
|
|
|
|
const char *if_invalid = NULL;
|
|
|
|
const value_string *valp;
|
|
|
|
|
|
|
|
fprintf(rf, "\n# %s.\n", description);
|
|
|
|
fprintf(rf, "# One of: ");
|
|
|
|
valp = values;
|
|
|
|
while (valp->strptr != NULL) {
|
|
|
|
if (if_invalid == NULL)
|
|
|
|
if_invalid = valp->strptr;
|
|
|
|
fprintf(rf, "%s", valp->strptr);
|
|
|
|
valp++;
|
|
|
|
if (valp->strptr != NULL)
|
|
|
|
fprintf(rf, ", ");
|
|
|
|
}
|
|
|
|
fprintf(rf, "\n");
|
|
|
|
fprintf(rf, "%s: %s\n", name,
|
|
|
|
val_to_str(value, values, if_invalid != NULL ? if_invalid : "Unknown"));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Attempt to write out "recent common" to the user's recent common file.
|
2005-03-26 01:05:29 +00:00
|
|
|
If we got an error report it with a dialog box and return FALSE,
|
|
|
|
otherwise return TRUE. */
|
|
|
|
gboolean
|
|
|
|
write_recent(void)
|
2004-01-19 00:42:12 +00:00
|
|
|
{
|
2005-03-26 01:05:29 +00:00
|
|
|
char *pf_dir_path;
|
2004-01-19 00:42:12 +00:00
|
|
|
char *rf_path;
|
|
|
|
FILE *rf;
|
2015-12-15 18:47:02 +00:00
|
|
|
char *string_list;
|
2004-01-19 00:42:12 +00:00
|
|
|
|
|
|
|
/* To do:
|
|
|
|
* - Split output lines longer than MAX_VAL_LEN
|
|
|
|
* - Create a function for the preference directory check/creation
|
|
|
|
* so that duplication can be avoided with filter.c
|
|
|
|
*/
|
|
|
|
|
2005-03-26 01:05:29 +00:00
|
|
|
/* 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 recent file: %s.", pf_dir_path,
|
2011-06-28 09:00:11 +00:00
|
|
|
g_strerror(errno));
|
2005-03-26 01:05:29 +00:00
|
|
|
g_free(pf_dir_path);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2013-04-09 02:48:03 +00:00
|
|
|
rf_path = get_persconffile_path(RECENT_COMMON_FILE_NAME, FALSE);
|
2008-05-22 15:46:27 +00:00
|
|
|
if ((rf = ws_fopen(rf_path, "w")) == NULL) {
|
2005-03-26 01:05:29 +00:00
|
|
|
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
|
|
|
|
"Can't open recent file\n\"%s\": %s.", rf_path,
|
2011-06-28 09:00:11 +00:00
|
|
|
g_strerror(errno));
|
2005-03-26 01:05:29 +00:00
|
|
|
g_free(rf_path);
|
|
|
|
return FALSE;
|
2004-01-19 00:42:12 +00:00
|
|
|
}
|
2008-03-04 22:02:24 +00:00
|
|
|
g_free(rf_path);
|
2004-01-19 00:42:12 +00:00
|
|
|
|
2006-05-22 07:29:40 +00:00
|
|
|
fputs("# Recent settings file for Wireshark " VERSION ".\n"
|
2004-01-19 00:42:12 +00:00
|
|
|
"#\n"
|
2006-05-22 07:29:40 +00:00
|
|
|
"# This file is regenerated each time Wireshark is quit.\n"
|
2004-01-19 00:42:12 +00:00
|
|
|
"# So be careful, if you want to make manual changes here.\n"
|
|
|
|
"\n"
|
2005-05-30 04:06:22 +00:00
|
|
|
"######## Recent capture files (latest last), cannot be altered through command line ########\n"
|
2004-01-19 00:42:12 +00:00
|
|
|
"\n", rf);
|
|
|
|
|
|
|
|
menu_recent_file_write_all(rf);
|
|
|
|
|
2004-09-28 18:04:15 +00:00
|
|
|
fputs("\n"
|
2005-05-30 04:06:22 +00:00
|
|
|
"######## Recent capture filters (latest last), cannot be altered through command line ########\n"
|
2004-09-28 18:04:15 +00:00
|
|
|
"\n", rf);
|
|
|
|
|
2013-07-27 22:37:26 +00:00
|
|
|
cfilter_recent_write_all(rf);
|
2004-09-28 18:04:15 +00:00
|
|
|
|
2004-01-19 00:42:12 +00:00
|
|
|
fputs("\n"
|
2005-05-30 04:06:22 +00:00
|
|
|
"######## Recent display filters (latest last), cannot be altered through command line ########\n"
|
2004-01-19 00:42:12 +00:00
|
|
|
"\n", rf);
|
|
|
|
|
|
|
|
dfilter_recent_combo_write_all(rf);
|
2008-11-11 11:37:53 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_PCAP_REMOTE
|
|
|
|
fputs("\n"
|
|
|
|
"######## Recent remote hosts, cannot be altered through command line ########\n"
|
|
|
|
"\n", rf);
|
2010-10-29 23:30:36 +00:00
|
|
|
|
2008-11-11 11:37:53 +00:00
|
|
|
capture_remote_combo_recent_write_all(rf);
|
|
|
|
#endif
|
|
|
|
|
2008-04-28 12:35:03 +00:00
|
|
|
fprintf(rf, "\n# Main window geometry.\n");
|
|
|
|
fprintf(rf, "# Decimal numbers.\n");
|
|
|
|
fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_X ": %d\n", recent.gui_geometry_main_x);
|
|
|
|
fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_Y ": %d\n", recent.gui_geometry_main_y);
|
2016-06-07 22:26:03 +00:00
|
|
|
fprintf(rf, RECENT_GUI_GTK_GEOMETRY_MAIN_X ": %d\n", recent.gui_gtk_geometry_main_x);
|
|
|
|
fprintf(rf, RECENT_GUI_GTK_GEOMETRY_MAIN_Y ": %d\n", recent.gui_gtk_geometry_main_y);
|
2008-04-28 12:35:03 +00:00
|
|
|
fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_WIDTH ": %d\n",
|
2014-10-12 18:56:12 +00:00
|
|
|
recent.gui_geometry_main_width);
|
2008-04-28 12:35:03 +00:00
|
|
|
fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_HEIGHT ": %d\n",
|
2014-10-12 18:56:12 +00:00
|
|
|
recent.gui_geometry_main_height);
|
2008-04-28 12:35:03 +00:00
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_boolean(rf, "Main window maximized",
|
|
|
|
RECENT_GUI_GEOMETRY_MAIN_MAXIMIZED,
|
|
|
|
recent.gui_geometry_main_maximized);
|
2008-04-28 12:35:03 +00:00
|
|
|
|
|
|
|
fprintf(rf, "\n# Statusbar left pane size.\n");
|
|
|
|
fprintf(rf, "# Decimal number.\n");
|
|
|
|
if (recent.gui_geometry_status_pane_left != 0) {
|
|
|
|
fprintf(rf, RECENT_GUI_GEOMETRY_STATUS_PANE_LEFT ": %d\n",
|
2014-10-12 18:56:12 +00:00
|
|
|
recent.gui_geometry_status_pane_left);
|
2008-04-28 12:35:03 +00:00
|
|
|
}
|
|
|
|
fprintf(rf, "\n# Statusbar middle pane size.\n");
|
|
|
|
fprintf(rf, "# Decimal number.\n");
|
|
|
|
if (recent.gui_geometry_status_pane_right != 0) {
|
|
|
|
fprintf(rf, RECENT_GUI_GEOMETRY_STATUS_PANE_RIGHT ": %d\n",
|
2014-10-12 18:56:12 +00:00
|
|
|
recent.gui_geometry_status_pane_right);
|
2008-04-28 12:35:03 +00:00
|
|
|
}
|
|
|
|
|
2009-02-26 22:26:42 +00:00
|
|
|
fprintf(rf, "\n# Last used Configuration Profile.\n");
|
|
|
|
fprintf(rf, RECENT_LAST_USED_PROFILE ": %s\n", get_profile_name());
|
|
|
|
|
2008-05-11 18:03:22 +00:00
|
|
|
fprintf(rf, "\n# WLAN statistics upper pane size.\n");
|
|
|
|
fprintf(rf, "# Decimal number.\n");
|
|
|
|
fprintf(rf, RECENT_GUI_GEOMETRY_WLAN_STATS_PANE ": %d\n",
|
2014-10-12 18:56:12 +00:00
|
|
|
recent.gui_geometry_wlan_stats_pane);
|
2008-05-11 18:03:22 +00:00
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_boolean(rf, "Warn if running with elevated permissions (e.g. as root)",
|
|
|
|
RECENT_KEY_PRIVS_WARN_IF_ELEVATED,
|
|
|
|
recent.privs_warn_if_elevated);
|
2008-04-28 12:35:03 +00:00
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_boolean(rf, "Warn if npf.sys isn't loaded on Windows >= 6.0",
|
|
|
|
RECENT_KEY_PRIVS_WARN_IF_NO_NPF,
|
|
|
|
recent.privs_warn_if_no_npf);
|
2008-04-28 12:35:03 +00:00
|
|
|
|
|
|
|
window_geom_recent_write_all(rf);
|
|
|
|
|
2015-12-15 18:47:02 +00:00
|
|
|
fprintf(rf, "\n# Custom colors.\n");
|
|
|
|
fprintf(rf, "# List of custom colors selected in Qt color picker.\n");
|
|
|
|
string_list = join_string_list(recent.custom_colors);
|
|
|
|
fprintf(rf, RECENT_GUI_CUSTOM_COLORS ": %s\n", string_list);
|
|
|
|
g_free(string_list);
|
|
|
|
|
2008-04-28 12:35:03 +00:00
|
|
|
fclose(rf);
|
|
|
|
|
|
|
|
/* XXX - catch I/O errors (e.g. "ran out of disk space") and return
|
|
|
|
an error indication, or maybe write to a new recent file and
|
|
|
|
rename that file on top of the old one only if there are not I/O
|
|
|
|
errors. */
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-07-28 20:56:36 +00:00
|
|
|
/* Attempt to Write out profile "recent" to the user's profile recent file.
|
2008-04-28 12:35:03 +00:00
|
|
|
If we got an error report it with a dialog box and return FALSE,
|
|
|
|
otherwise return TRUE. */
|
|
|
|
gboolean
|
|
|
|
write_profile_recent(void)
|
|
|
|
{
|
|
|
|
char *pf_dir_path;
|
|
|
|
char *rf_path;
|
2014-04-29 15:10:27 +00:00
|
|
|
char *string_list;
|
2008-04-28 12:35:03 +00:00
|
|
|
FILE *rf;
|
|
|
|
|
|
|
|
/* To do:
|
|
|
|
* - Split output lines longer than MAX_VAL_LEN
|
|
|
|
* - Create a function for the preference directory check/creation
|
|
|
|
* so that duplication can be avoided with filter.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* 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 recent file: %s.", pf_dir_path,
|
2011-06-28 09:00:11 +00:00
|
|
|
g_strerror(errno));
|
2008-04-28 12:35:03 +00:00
|
|
|
g_free(pf_dir_path);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2013-04-09 02:48:03 +00:00
|
|
|
rf_path = get_persconffile_path(RECENT_FILE_NAME, TRUE);
|
2008-05-22 15:46:27 +00:00
|
|
|
if ((rf = ws_fopen(rf_path, "w")) == NULL) {
|
2008-04-28 12:35:03 +00:00
|
|
|
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
|
|
|
|
"Can't open recent file\n\"%s\": %s.", rf_path,
|
2011-06-28 09:00:11 +00:00
|
|
|
g_strerror(errno));
|
2008-04-28 12:35:03 +00:00
|
|
|
g_free(rf_path);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
g_free(rf_path);
|
|
|
|
|
|
|
|
fputs("# Recent settings file for Wireshark " VERSION ".\n"
|
|
|
|
"#\n"
|
|
|
|
"# This file is regenerated each time Wireshark is quit\n"
|
|
|
|
"# and when changing configuration profile.\n"
|
|
|
|
"# So be careful, if you want to make manual changes here.\n"
|
|
|
|
"\n", rf);
|
2004-01-19 00:42:12 +00:00
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_boolean(rf, "Main Toolbar show (hide)",
|
|
|
|
RECENT_KEY_MAIN_TOOLBAR_SHOW,
|
|
|
|
recent.main_toolbar_show);
|
2004-01-19 00:42:12 +00:00
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_boolean(rf, "Filter Toolbar show (hide)",
|
|
|
|
RECENT_KEY_FILTER_TOOLBAR_SHOW,
|
|
|
|
recent.filter_toolbar_show);
|
2004-01-19 00:42:12 +00:00
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_boolean(rf, "Wireless Settings Toolbar show (hide)",
|
|
|
|
RECENT_KEY_WIRELESS_TOOLBAR_SHOW,
|
|
|
|
recent.wireless_toolbar_show);
|
2006-08-16 18:01:25 +00:00
|
|
|
|
2006-10-31 01:44:11 +00:00
|
|
|
#ifdef HAVE_AIRPCAP
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_boolean(rf, "Show (hide) old AirPcap driver warning dialog box",
|
|
|
|
RECENT_KEY_DRIVER_CHECK_SHOW,
|
|
|
|
recent.airpcap_driver_check_show);
|
2006-10-31 01:44:11 +00:00
|
|
|
#endif
|
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_boolean(rf, "Packet list show (hide)",
|
|
|
|
RECENT_KEY_PACKET_LIST_SHOW,
|
|
|
|
recent.packet_list_show);
|
2004-01-19 00:42:12 +00:00
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_boolean(rf, "Tree view show (hide)",
|
|
|
|
RECENT_KEY_TREE_VIEW_SHOW,
|
|
|
|
recent.tree_view_show);
|
2004-01-19 00:42:12 +00:00
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_boolean(rf, "Byte view show (hide)",
|
|
|
|
RECENT_KEY_BYTE_VIEW_SHOW,
|
|
|
|
recent.byte_view_show);
|
2004-01-19 00:42:12 +00:00
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_boolean(rf, "Statusbar show (hide)",
|
|
|
|
RECENT_KEY_STATUSBAR_SHOW,
|
|
|
|
recent.statusbar_show);
|
2004-01-19 00:42:12 +00:00
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_boolean(rf, "Packet list colorize (hide)",
|
|
|
|
RECENT_KEY_PACKET_LIST_COLORIZE,
|
|
|
|
recent.packet_list_colorize);
|
2005-03-27 02:19:51 +00:00
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_enum(rf, "Timestamp display format",
|
|
|
|
RECENT_GUI_TIME_FORMAT, ts_type_values,
|
|
|
|
recent.gui_time_format);
|
2004-01-19 03:46:43 +00:00
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_enum(rf, "Timestamp display precision",
|
|
|
|
RECENT_GUI_TIME_PRECISION, ts_precision_values,
|
|
|
|
recent.gui_time_precision);
|
2005-08-25 21:29:54 +00:00
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_enum(rf, "Seconds display format",
|
|
|
|
RECENT_GUI_SECONDS_FORMAT, ts_seconds_values,
|
|
|
|
recent.gui_seconds_format);
|
2010-05-06 10:32:59 +00:00
|
|
|
|
2004-01-20 18:47:25 +00:00
|
|
|
fprintf(rf, "\n# Zoom level.\n");
|
|
|
|
fprintf(rf, "# A decimal number.\n");
|
|
|
|
fprintf(rf, RECENT_GUI_ZOOM_LEVEL ": %d\n",
|
2014-10-12 18:56:12 +00:00
|
|
|
recent.gui_zoom_level);
|
2004-01-20 18:47:25 +00:00
|
|
|
|
2009-11-05 10:16:49 +00:00
|
|
|
fprintf(rf, "\n# Bytes view.\n");
|
|
|
|
fprintf(rf, "# A decimal number.\n");
|
|
|
|
fprintf(rf, RECENT_GUI_BYTES_VIEW ": %d\n",
|
2014-10-12 18:56:12 +00:00
|
|
|
recent.gui_bytes_view);
|
2009-11-05 10:16:49 +00:00
|
|
|
|
2005-05-30 04:06:22 +00:00
|
|
|
fprintf(rf, "\n# Main window upper (or leftmost) pane size.\n");
|
2005-05-29 14:09:58 +00:00
|
|
|
fprintf(rf, "# Decimal number.\n");
|
2004-07-18 19:54:07 +00:00
|
|
|
if (recent.gui_geometry_main_upper_pane != 0) {
|
|
|
|
fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_UPPER_PANE ": %d\n",
|
2014-10-12 18:56:12 +00:00
|
|
|
recent.gui_geometry_main_upper_pane);
|
2004-07-18 19:54:07 +00:00
|
|
|
}
|
2005-05-30 04:06:22 +00:00
|
|
|
fprintf(rf, "\n# Main window middle pane size.\n");
|
2005-05-29 14:09:58 +00:00
|
|
|
fprintf(rf, "# Decimal number.\n");
|
2004-07-18 19:54:07 +00:00
|
|
|
if (recent.gui_geometry_main_lower_pane != 0) {
|
|
|
|
fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_LOWER_PANE ": %d\n",
|
2014-10-12 18:56:12 +00:00
|
|
|
recent.gui_geometry_main_lower_pane);
|
2004-07-18 19:54:07 +00:00
|
|
|
}
|
2004-04-25 23:45:12 +00:00
|
|
|
|
2008-04-12 19:37:05 +00:00
|
|
|
fprintf(rf, "\n# Packet list column pixel widths.\n");
|
|
|
|
fprintf(rf, "# Each pair of strings consists of a column format and its pixel width.\n");
|
2012-09-04 02:35:25 +00:00
|
|
|
packet_list_recent_write_all(rf);
|
2008-04-12 19:37:05 +00:00
|
|
|
|
2014-04-29 15:10:27 +00:00
|
|
|
fprintf(rf, "\n# Open conversation dialog tabs.\n");
|
|
|
|
fprintf(rf, "# List of conversation names, e.g. \"TCP\", \"IPv6\".\n");
|
|
|
|
string_list = join_string_list(recent.conversation_tabs);
|
|
|
|
fprintf(rf, RECENT_GUI_CONVERSATION_TABS ": %s\n", string_list);
|
|
|
|
g_free(string_list);
|
|
|
|
|
2014-08-06 17:07:42 +00:00
|
|
|
fprintf(rf, "\n# Open endpoint dialog tabs.\n");
|
|
|
|
fprintf(rf, "# List of endpoint names, e.g. \"TCP\", \"IPv6\".\n");
|
|
|
|
string_list = join_string_list(recent.endpoint_tabs);
|
|
|
|
fprintf(rf, RECENT_GUI_ENDPOINT_TABS ": %s\n", string_list);
|
|
|
|
g_free(string_list);
|
|
|
|
|
2015-12-13 21:45:24 +00:00
|
|
|
write_recent_boolean(rf, "For RLC stats, whether to use RLC PDUs found inside MAC frames",
|
|
|
|
RECENT_GUI_RLC_PDUS_FROM_MAC_FRAMES,
|
|
|
|
recent.gui_rlc_use_pdus_from_mac);
|
2015-09-30 11:49:01 +00:00
|
|
|
|
2004-06-01 17:33:37 +00:00
|
|
|
if (get_last_open_dir() != NULL) {
|
2004-02-01 20:28:11 +00:00
|
|
|
fprintf(rf, "\n# Last directory navigated to in File Open dialog.\n");
|
2016-03-11 17:15:12 +00:00
|
|
|
fprintf(rf, RECENT_GUI_FILEOPEN_REMEMBERED_DIR ": %s\n", get_last_open_dir());
|
2004-02-01 20:28:11 +00:00
|
|
|
}
|
|
|
|
|
2004-01-19 00:42:12 +00:00
|
|
|
fclose(rf);
|
|
|
|
|
|
|
|
/* XXX - catch I/O errors (e.g. "ran out of disk space") and return
|
2005-03-26 01:05:29 +00:00
|
|
|
an error indication, or maybe write to a new recent file and
|
2004-01-19 00:42:12 +00:00
|
|
|
rename that file on top of the old one only if there are not I/O
|
|
|
|
errors. */
|
2005-03-26 01:05:29 +00:00
|
|
|
return TRUE;
|
2004-01-19 00:42:12 +00:00
|
|
|
}
|
|
|
|
|
2008-04-28 12:35:03 +00:00
|
|
|
/* set one user's recent common file key/value pair */
|
|
|
|
static prefs_set_pref_e
|
2012-12-26 05:57:06 +00:00
|
|
|
read_set_recent_common_pair_static(gchar *key, const gchar *value,
|
2014-10-12 18:56:12 +00:00
|
|
|
void *private_data _U_,
|
|
|
|
gboolean return_range_errors _U_)
|
2008-04-28 12:35:03 +00:00
|
|
|
{
|
|
|
|
long num;
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_MAXIMIZED) == 0) {
|
2015-12-13 21:45:24 +00:00
|
|
|
parse_recent_boolean(value, &recent.gui_geometry_main_maximized);
|
2008-04-28 12:35:03 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_X) == 0) {
|
|
|
|
num = strtol(value, &p, 0);
|
|
|
|
if (p == value || *p != '\0')
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number was bad */
|
2012-12-26 05:57:06 +00:00
|
|
|
recent.gui_geometry_main_x = (gint)num;
|
2008-04-28 12:35:03 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_Y) == 0) {
|
|
|
|
num = strtol(value, &p, 0);
|
|
|
|
if (p == value || *p != '\0')
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number was bad */
|
2012-12-26 05:57:06 +00:00
|
|
|
recent.gui_geometry_main_y = (gint)num;
|
2016-06-07 22:26:03 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_GTK_GEOMETRY_MAIN_X) == 0) {
|
|
|
|
num = strtol(value, &p, 0);
|
|
|
|
if (p == value || *p != '\0')
|
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number was bad */
|
|
|
|
recent.gui_gtk_geometry_main_x = (gint)num;
|
|
|
|
} else if (strcmp(key, RECENT_GUI_GTK_GEOMETRY_MAIN_Y) == 0) {
|
|
|
|
num = strtol(value, &p, 0);
|
|
|
|
if (p == value || *p != '\0')
|
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number was bad */
|
|
|
|
recent.gui_gtk_geometry_main_y = (gint)num;
|
2008-04-28 12:35:03 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_WIDTH) == 0) {
|
|
|
|
num = strtol(value, &p, 0);
|
|
|
|
if (p == value || *p != '\0')
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number was bad */
|
2008-04-28 12:35:03 +00:00
|
|
|
if (num <= 0)
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number must be positive */
|
2012-12-26 05:57:06 +00:00
|
|
|
recent.gui_geometry_main_width = (gint)num;
|
2008-04-28 12:35:03 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_HEIGHT) == 0) {
|
|
|
|
num = strtol(value, &p, 0);
|
|
|
|
if (p == value || *p != '\0')
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number was bad */
|
2008-04-28 12:35:03 +00:00
|
|
|
if (num <= 0)
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number must be positive */
|
2012-12-26 05:57:06 +00:00
|
|
|
recent.gui_geometry_main_height = (gint)num;
|
2008-04-28 12:35:03 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_GEOMETRY_STATUS_PANE_RIGHT) == 0) {
|
|
|
|
num = strtol(value, &p, 0);
|
|
|
|
if (p == value || *p != '\0')
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number was bad */
|
2008-04-28 12:35:03 +00:00
|
|
|
if (num <= 0)
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number must be positive */
|
2012-12-26 05:57:06 +00:00
|
|
|
recent.gui_geometry_status_pane_right = (gint)num;
|
2008-04-28 12:35:03 +00:00
|
|
|
recent.has_gui_geometry_status_pane = TRUE;
|
|
|
|
} else if (strcmp(key, RECENT_GUI_GEOMETRY_STATUS_PANE_LEFT) == 0) {
|
|
|
|
num = strtol(value, &p, 0);
|
|
|
|
if (p == value || *p != '\0')
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number was bad */
|
2008-04-28 12:35:03 +00:00
|
|
|
if (num <= 0)
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number must be positive */
|
2012-12-26 05:57:06 +00:00
|
|
|
recent.gui_geometry_status_pane_left = (gint)num;
|
2008-04-28 12:35:03 +00:00
|
|
|
recent.has_gui_geometry_status_pane = TRUE;
|
2009-02-26 22:26:42 +00:00
|
|
|
} else if (strcmp(key, RECENT_LAST_USED_PROFILE) == 0) {
|
2011-02-26 17:23:24 +00:00
|
|
|
if ((strcmp(value, DEFAULT_PROFILE) != 0) && profile_exists (value, FALSE)) {
|
2009-02-26 22:26:42 +00:00
|
|
|
set_profile_name (value);
|
|
|
|
}
|
2008-05-11 18:03:22 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_GEOMETRY_WLAN_STATS_PANE) == 0) {
|
|
|
|
num = strtol(value, &p, 0);
|
|
|
|
if (p == value || *p != '\0')
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number was bad */
|
2008-05-11 18:03:22 +00:00
|
|
|
if (num <= 0)
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number must be positive */
|
2012-12-26 05:57:06 +00:00
|
|
|
recent.gui_geometry_wlan_stats_pane = (gint)num;
|
2008-04-28 12:35:03 +00:00
|
|
|
} else if (strncmp(key, RECENT_GUI_GEOMETRY, sizeof(RECENT_GUI_GEOMETRY)-1) == 0) {
|
|
|
|
/* now have something like "gui.geom.main.x", split it into win and sub_key */
|
|
|
|
char *win = &key[sizeof(RECENT_GUI_GEOMETRY)-1];
|
|
|
|
char *sub_key = strchr(win, '.');
|
2014-10-12 18:56:12 +00:00
|
|
|
if (sub_key) {
|
2008-04-28 12:35:03 +00:00
|
|
|
*sub_key = '\0';
|
|
|
|
sub_key++;
|
|
|
|
window_geom_recent_read_pair(win, sub_key, value);
|
|
|
|
}
|
|
|
|
} else if (strcmp(key, RECENT_KEY_PRIVS_WARN_IF_ELEVATED) == 0) {
|
2015-12-13 21:45:24 +00:00
|
|
|
parse_recent_boolean(value, &recent.privs_warn_if_elevated);
|
2008-04-28 12:35:03 +00:00
|
|
|
} else if (strcmp(key, RECENT_KEY_PRIVS_WARN_IF_NO_NPF) == 0) {
|
2015-12-13 21:45:24 +00:00
|
|
|
parse_recent_boolean(value, &recent.privs_warn_if_no_npf);
|
2015-12-15 18:47:02 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_CUSTOM_COLORS) == 0) {
|
|
|
|
recent.custom_colors = prefs_get_string_list(value);
|
2008-04-28 12:35:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return PREFS_SET_OK;
|
|
|
|
}
|
2004-05-30 11:54:37 +00:00
|
|
|
|
2004-01-19 00:42:12 +00:00
|
|
|
/* set one user's recent file key/value pair */
|
2006-12-08 01:11:20 +00:00
|
|
|
static prefs_set_pref_e
|
2012-12-26 05:57:06 +00:00
|
|
|
read_set_recent_pair_static(gchar *key, const gchar *value,
|
2014-10-12 18:56:12 +00:00
|
|
|
void *private_data _U_,
|
|
|
|
gboolean return_range_errors _U_)
|
2004-01-19 00:42:12 +00:00
|
|
|
{
|
2004-07-09 21:13:22 +00:00
|
|
|
long num;
|
|
|
|
char *p;
|
2008-04-12 19:37:05 +00:00
|
|
|
GList *col_l, *col_l_elt;
|
|
|
|
col_width_data *cfmt;
|
|
|
|
const gchar *cust_format = col_format_to_string(COL_CUSTOM);
|
2009-04-16 00:45:26 +00:00
|
|
|
int cust_format_len = (int) strlen(cust_format);
|
2004-01-19 00:42:12 +00:00
|
|
|
|
2005-05-30 04:06:22 +00:00
|
|
|
if (strcmp(key, RECENT_KEY_MAIN_TOOLBAR_SHOW) == 0) {
|
2015-12-13 21:45:24 +00:00
|
|
|
parse_recent_boolean(value, &recent.main_toolbar_show);
|
2012-06-19 15:01:25 +00:00
|
|
|
} else if (strcmp(key, RECENT_KEY_FILTER_TOOLBAR_SHOW) == 0) {
|
2015-12-13 21:45:24 +00:00
|
|
|
parse_recent_boolean(value, &recent.filter_toolbar_show);
|
2012-06-19 15:01:25 +00:00
|
|
|
/* check both the old and the new keyword */
|
|
|
|
} else if (strcmp(key, RECENT_KEY_WIRELESS_TOOLBAR_SHOW) == 0 || (strcmp(key, "gui.airpcap_toolbar_show") == 0)) {
|
2015-12-13 21:45:24 +00:00
|
|
|
parse_recent_boolean(value, &recent.wireless_toolbar_show);
|
2006-10-31 01:44:11 +00:00
|
|
|
} else if (strcmp(key, RECENT_KEY_DRIVER_CHECK_SHOW) == 0) {
|
2015-12-13 21:45:24 +00:00
|
|
|
parse_recent_boolean(value, &recent.airpcap_driver_check_show);
|
2008-04-12 19:37:05 +00:00
|
|
|
} else if (strcmp(key, RECENT_KEY_PACKET_LIST_SHOW) == 0) {
|
2015-12-13 21:45:24 +00:00
|
|
|
parse_recent_boolean(value, &recent.packet_list_show);
|
2004-01-19 00:42:12 +00:00
|
|
|
} else if (strcmp(key, RECENT_KEY_TREE_VIEW_SHOW) == 0) {
|
2015-12-13 21:45:24 +00:00
|
|
|
parse_recent_boolean(value, &recent.tree_view_show);
|
2004-01-19 00:42:12 +00:00
|
|
|
} else if (strcmp(key, RECENT_KEY_BYTE_VIEW_SHOW) == 0) {
|
2015-12-13 21:45:24 +00:00
|
|
|
parse_recent_boolean(value, &recent.byte_view_show);
|
2004-01-19 00:42:12 +00:00
|
|
|
} else if (strcmp(key, RECENT_KEY_STATUSBAR_SHOW) == 0) {
|
2015-12-13 21:45:24 +00:00
|
|
|
parse_recent_boolean(value, &recent.statusbar_show);
|
2005-03-27 02:19:51 +00:00
|
|
|
} else if (strcmp(key, RECENT_KEY_PACKET_LIST_COLORIZE) == 0) {
|
2015-12-13 21:45:24 +00:00
|
|
|
parse_recent_boolean(value, &recent.packet_list_colorize);
|
2004-01-19 03:46:43 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_TIME_FORMAT) == 0) {
|
2004-01-20 18:47:25 +00:00
|
|
|
recent.gui_time_format =
|
2015-12-13 12:32:34 +00:00
|
|
|
(ts_type)str_to_val(value, ts_type_values, TS_RELATIVE);
|
2005-08-25 21:29:54 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_TIME_PRECISION) == 0) {
|
|
|
|
recent.gui_time_precision =
|
2015-12-13 12:32:34 +00:00
|
|
|
(ts_precision)str_to_val(value, ts_precision_values, TS_PREC_AUTO);
|
2010-05-06 10:32:59 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_SECONDS_FORMAT) == 0) {
|
|
|
|
recent.gui_seconds_format =
|
2015-12-13 12:32:34 +00:00
|
|
|
(ts_seconds_type)str_to_val(value, ts_seconds_values, TS_SECONDS_DEFAULT);
|
2004-01-20 18:47:25 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_ZOOM_LEVEL) == 0) {
|
2004-07-09 21:13:22 +00:00
|
|
|
num = strtol(value, &p, 0);
|
|
|
|
if (p == value || *p != '\0')
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number was bad */
|
2012-12-26 05:57:06 +00:00
|
|
|
recent.gui_zoom_level = (gint)num;
|
2009-11-05 10:16:49 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_BYTES_VIEW) == 0) {
|
|
|
|
num = strtol(value, &p, 0);
|
|
|
|
if (p == value || *p != '\0')
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number was bad */
|
2015-12-17 19:41:46 +00:00
|
|
|
recent.gui_bytes_view = (bytes_view_type)num;
|
2004-02-01 20:28:11 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_MAXIMIZED) == 0) {
|
2015-12-13 21:45:24 +00:00
|
|
|
parse_recent_boolean(value, &recent.gui_geometry_main_maximized);
|
2004-04-25 23:45:12 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_UPPER_PANE) == 0) {
|
2004-07-09 21:13:22 +00:00
|
|
|
num = strtol(value, &p, 0);
|
|
|
|
if (p == value || *p != '\0')
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number was bad */
|
2004-07-09 21:13:22 +00:00
|
|
|
if (num <= 0)
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number must be positive */
|
2012-12-26 05:57:06 +00:00
|
|
|
recent.gui_geometry_main_upper_pane = (gint)num;
|
2005-05-30 04:06:22 +00:00
|
|
|
recent.has_gui_geometry_main_upper_pane = TRUE;
|
2004-04-25 23:45:12 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_LOWER_PANE) == 0) {
|
2004-07-09 21:13:22 +00:00
|
|
|
num = strtol(value, &p, 0);
|
|
|
|
if (p == value || *p != '\0')
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number was bad */
|
2004-07-09 21:13:22 +00:00
|
|
|
if (num <= 0)
|
2014-10-12 18:56:12 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number must be positive */
|
2012-12-26 05:57:06 +00:00
|
|
|
recent.gui_geometry_main_lower_pane = (gint)num;
|
2005-05-30 04:06:22 +00:00
|
|
|
recent.has_gui_geometry_main_lower_pane = TRUE;
|
2014-04-29 15:10:27 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_CONVERSATION_TABS) == 0) {
|
|
|
|
recent.conversation_tabs = prefs_get_string_list(value);
|
2014-08-06 17:07:42 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_ENDPOINT_TABS) == 0) {
|
|
|
|
recent.endpoint_tabs = prefs_get_string_list(value);
|
2015-09-30 11:49:01 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_RLC_PDUS_FROM_MAC_FRAMES) == 0) {
|
2015-12-13 21:45:24 +00:00
|
|
|
parse_recent_boolean(value, &recent.gui_rlc_use_pdus_from_mac);
|
2014-04-29 15:10:27 +00:00
|
|
|
} else if (strcmp(key, RECENT_KEY_COL_WIDTH) == 0) {
|
2008-04-12 19:37:05 +00:00
|
|
|
col_l = prefs_get_string_list(value);
|
|
|
|
if (col_l == NULL)
|
|
|
|
return PREFS_SET_SYNTAX_ERR;
|
|
|
|
if ((g_list_length(col_l) % 2) != 0) {
|
|
|
|
/* A title didn't have a matching width. */
|
|
|
|
prefs_clear_string_list(col_l);
|
|
|
|
return PREFS_SET_SYNTAX_ERR;
|
|
|
|
}
|
|
|
|
/* Check to make sure all column formats are valid. */
|
|
|
|
col_l_elt = g_list_first(col_l);
|
2014-10-12 18:56:12 +00:00
|
|
|
while (col_l_elt) {
|
2008-04-12 19:37:05 +00:00
|
|
|
/* Make sure the format isn't empty. */
|
2013-03-15 22:39:37 +00:00
|
|
|
if (strcmp((const char *)col_l_elt->data, "") == 0) {
|
2014-10-12 18:56:12 +00:00
|
|
|
/* It is. */
|
2008-04-12 19:37:05 +00:00
|
|
|
prefs_clear_string_list(col_l);
|
|
|
|
return PREFS_SET_SYNTAX_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check the format. */
|
2013-03-15 22:39:37 +00:00
|
|
|
if (strncmp((const char *)col_l_elt->data, cust_format, cust_format_len) != 0) {
|
|
|
|
if (get_column_format_from_str((const gchar *)col_l_elt->data) == -1) {
|
2008-04-12 19:37:05 +00:00
|
|
|
/* It's not a valid column format. */
|
|
|
|
prefs_clear_string_list(col_l);
|
|
|
|
return PREFS_SET_SYNTAX_ERR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Go past the format. */
|
|
|
|
col_l_elt = col_l_elt->next;
|
|
|
|
|
|
|
|
/* Go past the width. */
|
|
|
|
col_l_elt = col_l_elt->next;
|
|
|
|
}
|
|
|
|
free_col_width_info(&recent);
|
|
|
|
recent.col_width_list = NULL;
|
|
|
|
col_l_elt = g_list_first(col_l);
|
2014-10-12 18:56:12 +00:00
|
|
|
while (col_l_elt) {
|
2013-03-15 22:39:37 +00:00
|
|
|
gchar *fmt = g_strdup((const gchar *)col_l_elt->data);
|
2008-04-12 19:37:05 +00:00
|
|
|
cfmt = (col_width_data *) g_malloc(sizeof(col_width_data));
|
|
|
|
if (strncmp(fmt, cust_format, cust_format_len) != 0) {
|
2014-10-12 18:56:12 +00:00
|
|
|
cfmt->cfmt = get_column_format_from_str(fmt);
|
|
|
|
cfmt->cfield = NULL;
|
2008-04-12 19:37:05 +00:00
|
|
|
} else {
|
2014-10-12 18:56:12 +00:00
|
|
|
cfmt->cfmt = COL_CUSTOM;
|
|
|
|
cfmt->cfield = g_strdup(&fmt[cust_format_len+1]); /* add 1 for ':' */
|
2008-04-12 19:37:05 +00:00
|
|
|
}
|
|
|
|
g_free (fmt);
|
2009-10-29 11:20:33 +00:00
|
|
|
if (cfmt->cfmt == -1) {
|
|
|
|
g_free(cfmt->cfield);
|
2014-10-12 18:56:12 +00:00
|
|
|
g_free(cfmt);
|
|
|
|
return PREFS_SET_SYNTAX_ERR; /* string was bad */
|
2009-10-29 11:20:33 +00:00
|
|
|
}
|
2008-04-12 19:37:05 +00:00
|
|
|
|
|
|
|
col_l_elt = col_l_elt->next;
|
2013-03-15 22:39:37 +00:00
|
|
|
cfmt->width = (gint)strtol((const char *)col_l_elt->data, &p, 0);
|
2009-12-01 17:07:13 +00:00
|
|
|
if (p == col_l_elt->data || (*p != '\0' && *p != ':')) {
|
2014-10-12 18:56:12 +00:00
|
|
|
g_free(cfmt->cfield);
|
|
|
|
g_free(cfmt);
|
|
|
|
return PREFS_SET_SYNTAX_ERR; /* number was bad */
|
2009-10-29 11:20:33 +00:00
|
|
|
}
|
2008-04-12 19:37:05 +00:00
|
|
|
|
2009-12-01 17:07:13 +00:00
|
|
|
if (*p == ':') {
|
|
|
|
cfmt->xalign = *(++p);
|
|
|
|
} else {
|
2009-12-09 16:16:04 +00:00
|
|
|
cfmt->xalign = COLUMN_XALIGN_DEFAULT;
|
2009-12-01 17:07:13 +00:00
|
|
|
}
|
|
|
|
|
2008-04-12 19:37:05 +00:00
|
|
|
col_l_elt = col_l_elt->next;
|
|
|
|
recent.col_width_list = g_list_append(recent.col_width_list, cfmt);
|
|
|
|
}
|
|
|
|
prefs_clear_string_list(col_l);
|
2010-10-29 23:30:36 +00:00
|
|
|
} else if (strcmp(key, RECENT_GUI_FILEOPEN_REMEMBERED_DIR) == 0) {
|
2010-06-25 19:33:18 +00:00
|
|
|
if (recent.gui_fileopen_remembered_dir) {
|
|
|
|
g_free (recent.gui_fileopen_remembered_dir);
|
|
|
|
}
|
|
|
|
recent.gui_fileopen_remembered_dir = g_strdup(value);
|
2004-01-19 00:42:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return PREFS_SET_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-05-30 04:06:22 +00:00
|
|
|
/* set one user's recent file key/value pair */
|
2006-12-08 01:11:20 +00:00
|
|
|
static prefs_set_pref_e
|
2012-12-26 05:57:06 +00:00
|
|
|
read_set_recent_pair_dynamic(gchar *key, const gchar *value,
|
2014-10-12 18:56:12 +00:00
|
|
|
void *private_data _U_,
|
|
|
|
gboolean return_range_errors _U_)
|
2005-05-30 04:06:22 +00:00
|
|
|
{
|
2015-06-17 21:45:42 +00:00
|
|
|
if (!g_utf8_validate(value, -1, NULL)) {
|
2012-03-16 15:09:54 +00:00
|
|
|
return PREFS_SET_SYNTAX_ERR;
|
|
|
|
}
|
2005-05-30 04:06:22 +00:00
|
|
|
if (strcmp(key, RECENT_KEY_CAPTURE_FILE) == 0) {
|
2016-03-11 17:15:12 +00:00
|
|
|
add_menu_recent_capture_file(value);
|
2005-05-30 04:06:22 +00:00
|
|
|
} else if (strcmp(key, RECENT_KEY_DISPLAY_FILTER) == 0) {
|
2014-10-12 18:56:12 +00:00
|
|
|
dfilter_combo_add_recent(value);
|
2005-05-30 04:06:22 +00:00
|
|
|
} else if (strcmp(key, RECENT_KEY_CAPTURE_FILTER) == 0) {
|
2013-07-27 22:37:26 +00:00
|
|
|
recent_add_cfilter(NULL, value);
|
|
|
|
} else if (g_str_has_prefix(key, RECENT_KEY_CAPTURE_FILTER ".")) {
|
|
|
|
/* strrchr() can't fail - string has a prefix that ends with a "." */
|
|
|
|
recent_add_cfilter(strrchr(key, '.') + 1, value);
|
2008-11-11 11:37:53 +00:00
|
|
|
#ifdef HAVE_PCAP_REMOTE
|
|
|
|
} else if (strcmp(key, RECENT_KEY_REMOTE_HOST) == 0) {
|
2014-10-12 18:56:12 +00:00
|
|
|
capture_remote_combo_add_recent(value);
|
2008-11-11 11:37:53 +00:00
|
|
|
#endif
|
2005-05-30 04:06:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return PREFS_SET_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Given a string of the form "<recent name>:<recent value>", as might appear
|
|
|
|
* as an argument to a "-o" option, parse it and set the recent value in
|
|
|
|
* question. Return an indication of whether it succeeded or failed
|
|
|
|
* in some fashion.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
recent_set_arg(char *prefarg)
|
|
|
|
{
|
2014-10-12 18:56:12 +00:00
|
|
|
gchar *p, *colonp;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
colonp = strchr(prefarg, ':');
|
|
|
|
if (colonp == NULL)
|
|
|
|
return PREFS_SET_SYNTAX_ERR;
|
|
|
|
|
|
|
|
p = colonp;
|
|
|
|
*p++ = '\0';
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Skip over any white space (there probably won't be any, but
|
|
|
|
* as we allow it in the preferences file, we might as well
|
|
|
|
* allow it here).
|
|
|
|
*/
|
2014-10-17 06:41:29 +00:00
|
|
|
while (g_ascii_isspace(*p))
|
2014-10-12 18:56:12 +00:00
|
|
|
p++;
|
|
|
|
if (*p == '\0') {
|
|
|
|
/*
|
|
|
|
* Put the colon back, so if our caller uses, in an
|
|
|
|
* error message, the string they passed us, the message
|
|
|
|
* looks correct.
|
|
|
|
*/
|
|
|
|
*colonp = ':';
|
|
|
|
return PREFS_SET_SYNTAX_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = read_set_recent_pair_static(prefarg, p, NULL, TRUE);
|
|
|
|
*colonp = ':'; /* put the colon back */
|
|
|
|
return ret;
|
2005-05-30 04:06:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-07-28 20:56:36 +00:00
|
|
|
/* opens the user's recent common file and read the first part */
|
2015-10-04 09:31:19 +00:00
|
|
|
gboolean
|
2005-05-30 04:06:22 +00:00
|
|
|
recent_read_static(char **rf_path_return, int *rf_errno_return)
|
2004-01-19 00:42:12 +00:00
|
|
|
{
|
|
|
|
char *rf_path;
|
|
|
|
FILE *rf;
|
|
|
|
|
2008-04-28 12:35:03 +00:00
|
|
|
/* set defaults */
|
|
|
|
recent.gui_geometry_main_x = 20;
|
|
|
|
recent.gui_geometry_main_y = 20;
|
2016-06-07 22:26:03 +00:00
|
|
|
recent.gui_gtk_geometry_main_x = 20;
|
|
|
|
recent.gui_gtk_geometry_main_y = 20;
|
2008-04-28 12:35:03 +00:00
|
|
|
recent.gui_geometry_main_width = DEF_WIDTH;
|
|
|
|
recent.gui_geometry_main_height = DEF_HEIGHT;
|
|
|
|
recent.gui_geometry_main_maximized= FALSE;
|
|
|
|
|
|
|
|
recent.gui_geometry_status_pane_left = (DEF_WIDTH/3);
|
|
|
|
recent.gui_geometry_status_pane_right = (DEF_WIDTH/3);
|
2014-10-12 18:56:12 +00:00
|
|
|
recent.gui_geometry_wlan_stats_pane = 200;
|
2008-04-28 12:35:03 +00:00
|
|
|
|
|
|
|
recent.privs_warn_if_elevated = TRUE;
|
|
|
|
recent.privs_warn_if_no_npf = TRUE;
|
|
|
|
|
|
|
|
recent.col_width_list = NULL;
|
2010-06-25 19:33:18 +00:00
|
|
|
recent.gui_fileopen_remembered_dir = NULL;
|
2008-04-28 12:35:03 +00:00
|
|
|
|
2009-07-28 20:56:36 +00:00
|
|
|
/* Construct the pathname of the user's recent common file. */
|
2013-04-09 02:48:03 +00:00
|
|
|
rf_path = get_persconffile_path(RECENT_COMMON_FILE_NAME, FALSE);
|
2008-04-28 12:35:03 +00:00
|
|
|
|
2009-07-28 20:56:36 +00:00
|
|
|
/* Read the user's recent common file, if it exists. */
|
2008-04-28 12:35:03 +00:00
|
|
|
*rf_path_return = NULL;
|
2008-05-22 15:46:27 +00:00
|
|
|
if ((rf = ws_fopen(rf_path, "r")) != NULL) {
|
2008-04-28 12:35:03 +00:00
|
|
|
/* We succeeded in opening it; read it. */
|
|
|
|
read_prefs_file(rf_path, rf, read_set_recent_common_pair_static, NULL);
|
|
|
|
|
|
|
|
fclose(rf);
|
|
|
|
} else {
|
|
|
|
/* We failed to open it. If we failed for some reason other than
|
|
|
|
"it doesn't exist", return the errno and the pathname, so our
|
|
|
|
caller can report the error. */
|
|
|
|
if (errno != ENOENT) {
|
|
|
|
*rf_errno_return = errno;
|
|
|
|
*rf_path_return = rf_path;
|
2015-10-04 09:31:19 +00:00
|
|
|
return FALSE;
|
2008-04-28 12:35:03 +00:00
|
|
|
}
|
|
|
|
}
|
2015-10-04 09:31:19 +00:00
|
|
|
g_free(rf_path);
|
|
|
|
return TRUE;
|
2008-04-28 12:35:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* opens the user's recent file and read the first part */
|
2015-10-04 09:31:19 +00:00
|
|
|
gboolean
|
2008-04-28 12:35:03 +00:00
|
|
|
recent_read_profile_static(char **rf_path_return, int *rf_errno_return)
|
|
|
|
{
|
2008-08-09 16:12:41 +00:00
|
|
|
char *rf_path, *rf_common_path;
|
2008-04-28 12:35:03 +00:00
|
|
|
FILE *rf;
|
2004-01-19 00:42:12 +00:00
|
|
|
|
|
|
|
/* set defaults */
|
2014-10-12 18:56:12 +00:00
|
|
|
recent.main_toolbar_show = TRUE;
|
|
|
|
recent.filter_toolbar_show = TRUE;
|
|
|
|
recent.wireless_toolbar_show = FALSE;
|
|
|
|
recent.airpcap_driver_check_show = TRUE;
|
|
|
|
recent.packet_list_show = TRUE;
|
|
|
|
recent.tree_view_show = TRUE;
|
|
|
|
recent.byte_view_show = TRUE;
|
|
|
|
recent.statusbar_show = TRUE;
|
|
|
|
recent.packet_list_colorize = TRUE;
|
|
|
|
recent.gui_time_format = TS_RELATIVE;
|
|
|
|
recent.gui_time_precision = TS_PREC_AUTO;
|
|
|
|
recent.gui_seconds_format = TS_SECONDS_DEFAULT;
|
|
|
|
recent.gui_zoom_level = 0;
|
2015-12-17 19:41:46 +00:00
|
|
|
recent.gui_bytes_view = BYTES_HEX;
|
2004-01-19 00:42:12 +00:00
|
|
|
|
2004-04-27 19:16:11 +00:00
|
|
|
/* pane size of zero will autodetect */
|
|
|
|
recent.gui_geometry_main_upper_pane = 0;
|
|
|
|
recent.gui_geometry_main_lower_pane = 0;
|
2004-04-25 23:45:12 +00:00
|
|
|
|
2005-05-30 04:06:22 +00:00
|
|
|
recent.has_gui_geometry_main_upper_pane = TRUE;
|
|
|
|
recent.has_gui_geometry_main_lower_pane = TRUE;
|
2014-10-12 18:56:12 +00:00
|
|
|
recent.has_gui_geometry_status_pane = TRUE;
|
2005-05-30 04:06:22 +00:00
|
|
|
|
2008-04-28 12:35:03 +00:00
|
|
|
if (recent.col_width_list) {
|
|
|
|
free_col_width_info(&recent);
|
|
|
|
}
|
2008-04-12 19:37:05 +00:00
|
|
|
|
2010-06-25 19:33:18 +00:00
|
|
|
if (recent.gui_fileopen_remembered_dir) {
|
|
|
|
g_free (recent.gui_fileopen_remembered_dir);
|
|
|
|
recent.gui_fileopen_remembered_dir = NULL;
|
|
|
|
}
|
|
|
|
|
2009-07-28 20:56:36 +00:00
|
|
|
/* Construct the pathname of the user's profile recent file. */
|
2013-04-09 02:48:03 +00:00
|
|
|
rf_path = get_persconffile_path(RECENT_FILE_NAME, TRUE);
|
2005-05-30 04:06:22 +00:00
|
|
|
|
|
|
|
/* Read the user's recent file, if it exists. */
|
|
|
|
*rf_path_return = NULL;
|
2008-05-22 15:46:27 +00:00
|
|
|
if ((rf = ws_fopen(rf_path, "r")) != NULL) {
|
2005-05-30 04:06:22 +00:00
|
|
|
/* We succeeded in opening it; read it. */
|
2006-11-15 23:33:39 +00:00
|
|
|
read_prefs_file(rf_path, rf, read_set_recent_pair_static, NULL);
|
2008-04-28 13:00:49 +00:00
|
|
|
fclose(rf);
|
2009-07-28 20:56:36 +00:00
|
|
|
|
|
|
|
/* XXX: The following code doesn't actually do anything since
|
2010-10-29 23:30:36 +00:00
|
|
|
* the "recent common file" always exists. Presumably the
|
2009-07-28 20:56:36 +00:00
|
|
|
* "if (!file_exists())" should actually be "if (file_exists())".
|
2010-10-29 23:30:36 +00:00
|
|
|
* However, I've left the code as is because this
|
2009-07-28 20:56:36 +00:00
|
|
|
* behaviour has existed for quite some time and I don't
|
|
|
|
* know what's supposed to happen at this point.
|
|
|
|
* ToDo: Determine if the "recent common file" should be read at this point
|
|
|
|
*/
|
2013-04-09 02:48:03 +00:00
|
|
|
rf_common_path = get_persconffile_path(RECENT_COMMON_FILE_NAME, FALSE);
|
2008-08-09 16:12:41 +00:00
|
|
|
if (!file_exists(rf_common_path)) {
|
2008-04-28 13:27:25 +00:00
|
|
|
/* Read older common settings from recent file */
|
2008-05-22 15:46:27 +00:00
|
|
|
rf = ws_fopen(rf_path, "r");
|
2008-04-28 13:27:25 +00:00
|
|
|
read_prefs_file(rf_path, rf, read_set_recent_common_pair_static, NULL);
|
|
|
|
fclose(rf);
|
|
|
|
}
|
2008-08-09 16:12:41 +00:00
|
|
|
g_free(rf_common_path);
|
2005-05-30 04:06:22 +00:00
|
|
|
} else {
|
|
|
|
/* We failed to open it. If we failed for some reason other than
|
|
|
|
"it doesn't exist", return the errno and the pathname, so our
|
|
|
|
caller can report the error. */
|
|
|
|
if (errno != ENOENT) {
|
|
|
|
*rf_errno_return = errno;
|
|
|
|
*rf_path_return = rf_path;
|
2015-10-04 09:31:19 +00:00
|
|
|
return FALSE;
|
2005-05-30 04:06:22 +00:00
|
|
|
}
|
|
|
|
}
|
2015-10-04 09:31:19 +00:00
|
|
|
g_free(rf_path);
|
|
|
|
return TRUE;
|
2005-05-30 04:06:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* opens the user's recent file and read it out */
|
2015-10-04 09:31:19 +00:00
|
|
|
gboolean
|
2005-05-30 04:06:22 +00:00
|
|
|
recent_read_dynamic(char **rf_path_return, int *rf_errno_return)
|
|
|
|
{
|
|
|
|
char *rf_path;
|
|
|
|
FILE *rf;
|
|
|
|
|
|
|
|
|
2009-07-28 20:56:36 +00:00
|
|
|
/* Construct the pathname of the user's recent common file. */
|
2013-04-09 02:48:03 +00:00
|
|
|
rf_path = get_persconffile_path(RECENT_COMMON_FILE_NAME, FALSE);
|
2008-08-09 16:12:41 +00:00
|
|
|
if (!file_exists (rf_path)) {
|
2009-07-28 20:56:36 +00:00
|
|
|
/* Recent common file does not exist, read from default recent */
|
2008-08-09 16:12:41 +00:00
|
|
|
g_free (rf_path);
|
2013-04-09 02:48:03 +00:00
|
|
|
rf_path = get_persconffile_path(RECENT_FILE_NAME, FALSE);
|
2008-04-28 13:27:25 +00:00
|
|
|
}
|
2004-01-19 00:42:12 +00:00
|
|
|
|
|
|
|
/* Read the user's recent file, if it exists. */
|
|
|
|
*rf_path_return = NULL;
|
2008-05-22 15:46:27 +00:00
|
|
|
if ((rf = ws_fopen(rf_path, "r")) != NULL) {
|
2004-01-19 00:42:12 +00:00
|
|
|
/* We succeeded in opening it; read it. */
|
2006-11-15 23:33:39 +00:00
|
|
|
read_prefs_file(rf_path, rf, read_set_recent_pair_dynamic, NULL);
|
2010-07-07 16:07:09 +00:00
|
|
|
#if 0
|
2008-04-28 12:35:03 +00:00
|
|
|
/* set dfilter combobox to have an empty line */
|
2004-01-25 18:51:26 +00:00
|
|
|
dfilter_combo_add_empty();
|
2010-07-07 16:07:09 +00:00
|
|
|
#endif
|
2004-01-19 00:42:12 +00:00
|
|
|
fclose(rf);
|
|
|
|
} else {
|
|
|
|
/* We failed to open it. If we failed for some reason other than
|
|
|
|
"it doesn't exist", return the errno and the pathname, so our
|
|
|
|
caller can report the error. */
|
|
|
|
if (errno != ENOENT) {
|
|
|
|
*rf_errno_return = errno;
|
|
|
|
*rf_path_return = rf_path;
|
2015-10-04 09:31:19 +00:00
|
|
|
return FALSE;
|
2004-01-19 00:42:12 +00:00
|
|
|
}
|
|
|
|
}
|
2015-10-04 09:31:19 +00:00
|
|
|
g_free(rf_path);
|
|
|
|
return TRUE;
|
2004-01-19 00:42:12 +00:00
|
|
|
}
|
|
|
|
|
2008-04-12 19:37:05 +00:00
|
|
|
gint
|
|
|
|
recent_get_column_width(gint col)
|
|
|
|
{
|
|
|
|
GList *col_l;
|
|
|
|
col_width_data *col_w;
|
|
|
|
gint cfmt;
|
|
|
|
const gchar *cfield = NULL;
|
|
|
|
|
|
|
|
cfmt = get_column_format(col);
|
|
|
|
if (cfmt == COL_CUSTOM) {
|
2015-12-11 08:34:08 +00:00
|
|
|
cfield = get_column_custom_fields(col);
|
2008-04-12 19:37:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
col_l = g_list_first(recent.col_width_list);
|
|
|
|
while (col_l) {
|
|
|
|
col_w = (col_width_data *) col_l->data;
|
|
|
|
if (col_w->cfmt == cfmt) {
|
|
|
|
if (cfmt != COL_CUSTOM || strcmp (cfield, col_w->cfield) == 0) {
|
2014-10-12 18:56:12 +00:00
|
|
|
return col_w->width;
|
2008-04-12 19:37:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
col_l = col_l->next;
|
|
|
|
}
|
2004-01-19 00:42:12 +00:00
|
|
|
|
2008-04-12 19:37:05 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2008-06-14 16:45:06 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
recent_set_column_width(gint col, gint width)
|
|
|
|
{
|
|
|
|
GList *col_l;
|
|
|
|
col_width_data *col_w;
|
|
|
|
gint cfmt;
|
|
|
|
const gchar *cfield = NULL;
|
|
|
|
gboolean found = FALSE;
|
|
|
|
|
|
|
|
cfmt = get_column_format(col);
|
|
|
|
if (cfmt == COL_CUSTOM) {
|
2015-12-11 08:34:08 +00:00
|
|
|
cfield = get_column_custom_fields(col);
|
2008-06-14 16:45:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
col_l = g_list_first(recent.col_width_list);
|
|
|
|
while (col_l) {
|
|
|
|
col_w = (col_width_data *) col_l->data;
|
|
|
|
if (col_w->cfmt == cfmt) {
|
|
|
|
if (cfmt != COL_CUSTOM || strcmp (cfield, col_w->cfield) == 0) {
|
2014-10-12 18:56:12 +00:00
|
|
|
col_w->width = width;
|
|
|
|
found = TRUE;
|
|
|
|
break;
|
2008-06-14 16:45:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
col_l = col_l->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!found) {
|
|
|
|
col_w = (col_width_data *) g_malloc(sizeof(col_width_data));
|
|
|
|
col_w->cfmt = cfmt;
|
|
|
|
if (cfield) {
|
|
|
|
col_w->cfield = g_strdup(cfield);
|
|
|
|
} else {
|
|
|
|
col_w->cfield = NULL;
|
|
|
|
}
|
|
|
|
col_w->width = width;
|
2009-12-09 16:16:04 +00:00
|
|
|
col_w->xalign = COLUMN_XALIGN_DEFAULT;
|
2009-12-01 17:07:13 +00:00
|
|
|
recent.col_width_list = g_list_append(recent.col_width_list, col_w);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
gchar
|
|
|
|
recent_get_column_xalign(gint col)
|
|
|
|
{
|
|
|
|
GList *col_l;
|
|
|
|
col_width_data *col_w;
|
|
|
|
gint cfmt;
|
|
|
|
const gchar *cfield = NULL;
|
|
|
|
|
|
|
|
cfmt = get_column_format(col);
|
|
|
|
if (cfmt == COL_CUSTOM) {
|
2015-12-11 08:34:08 +00:00
|
|
|
cfield = get_column_custom_fields(col);
|
2009-12-01 17:07:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
col_l = g_list_first(recent.col_width_list);
|
|
|
|
while (col_l) {
|
|
|
|
col_w = (col_width_data *) col_l->data;
|
|
|
|
if (col_w->cfmt == cfmt) {
|
|
|
|
if (cfmt != COL_CUSTOM || strcmp (cfield, col_w->cfield) == 0) {
|
|
|
|
return col_w->xalign;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
col_l = col_l->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
recent_set_column_xalign(gint col, gchar xalign)
|
|
|
|
{
|
|
|
|
GList *col_l;
|
|
|
|
col_width_data *col_w;
|
|
|
|
gint cfmt;
|
|
|
|
const gchar *cfield = NULL;
|
|
|
|
gboolean found = FALSE;
|
|
|
|
|
|
|
|
cfmt = get_column_format(col);
|
|
|
|
if (cfmt == COL_CUSTOM) {
|
2015-12-11 08:34:08 +00:00
|
|
|
cfield = get_column_custom_fields(col);
|
2009-12-01 17:07:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
col_l = g_list_first(recent.col_width_list);
|
|
|
|
while (col_l) {
|
|
|
|
col_w = (col_width_data *) col_l->data;
|
|
|
|
if (col_w->cfmt == cfmt) {
|
|
|
|
if (cfmt != COL_CUSTOM || strcmp (cfield, col_w->cfield) == 0) {
|
|
|
|
col_w->xalign = xalign;
|
|
|
|
found = TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
col_l = col_l->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!found) {
|
|
|
|
col_w = (col_width_data *) g_malloc(sizeof(col_width_data));
|
|
|
|
col_w->cfmt = cfmt;
|
|
|
|
if (cfield) {
|
|
|
|
col_w->cfield = g_strdup(cfield);
|
|
|
|
} else {
|
|
|
|
col_w->cfield = NULL;
|
|
|
|
}
|
|
|
|
col_w->width = 40;
|
|
|
|
col_w->xalign = xalign;
|
2008-06-14 16:45:06 +00:00
|
|
|
recent.col_width_list = g_list_append(recent.col_width_list, col_w);
|
|
|
|
}
|
|
|
|
}
|
2014-10-12 18:56:12 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Editor modelines - http://www.wireshark.org/tools/modelines.html
|
|
|
|
*
|
|
|
|
* 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:
|
|
|
|
*/
|