/builds/wireshark/wireshark/ui/recent.c

Bug Summary

File:	ui/recent.c
Warning:	line 1756, column 13 Null pointer passed to 1st parameter expecting 'nonnull'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name recent.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -ffloat16-excess-precision=fast -fbfloat16-excess-precision=fast -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/builds/wireshark/wireshark/build -fcoverage-compilation-dir=/builds/wireshark/wireshark/build -resource-dir /usr/lib/llvm-21/lib/clang/21 -isystem /usr/include/glib-2.0 -isystem /usr/lib/x86_64-linux-gnu/glib-2.0/include -D G_DISABLE_DEPRECATED -D G_DISABLE_SINGLE_INCLUDES -D WS_DEBUG -D WS_DEBUG_UTF_8 -I /builds/wireshark/wireshark/build -I /builds/wireshark/wireshark -I /builds/wireshark/wireshark/include -I /builds/wireshark/wireshark/ui -I /builds/wireshark/wireshark/build/ui -I /builds/wireshark/wireshark/wiretap -D _GLIBCXX_ASSERTIONS -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/builds/wireshark/wireshark/= -fmacro-prefix-map=/builds/wireshark/wireshark/build/= -fmacro-prefix-map=../= -Wno-format-truncation -Wno-format-nonliteral -Wno-pointer-sign -std=gnu11 -ferror-limit 19 -fvisibility=hidden -fwrapv -fwrapv-pointer -fstrict-flex-arrays=3 -stack-protector 2 -fstack-clash-protection -fcf-protection=full -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fexceptions -fcolor-diagnostics -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /builds/wireshark/wireshark/sbout/2025-10-21-100328-3623-1 -x c /builds/wireshark/wireshark/ui/recent.c
1/* recent.c
* Recent "preference" handling routines
* Copyright 2004, Ulf Lamping <[email protected]>
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <[email protected]>
* Copyright 1998 Gerald Combs
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/

12#include "config.h"

14#include <wireshark.h>

16#include <stdlib.h>
17#include <errno(*__errno_location ()).h>

19#include <wsutil/application_flavor.h>
20#include <wsutil/filesystem.h>
21#include <epan/prefs.h>
22#include <epan/prefs-int.h>
23#include <epan/column.h>
24#include <wsutil/value_string.h>

26#ifdef HAVE_PCAP_REMOTE
27#include "ui/capture_opts.h"
28#endif
29#include "ui/util.h"
30#include "ui/recent.h"
31#include "ui/recent_utils.h"
32#include "ui/packet_list_utils.h"
33#include "ui/simple_dialog.h"

35#include <wsutil/file_util.h>
36#include <wsutil/strtoi.h>

38#define RECENT_KEY_MAIN_TOOLBAR_SHOW"gui.toolbar_main_show"            "gui.toolbar_main_show"
39#define RECENT_KEY_FILTER_TOOLBAR_SHOW"gui.filter_toolbar_show"          "gui.filter_toolbar_show"
40#define RECENT_KEY_WIRELESS_TOOLBAR_SHOW"gui.wireless_toolbar_show"        "gui.wireless_toolbar_show"
41#define RECENT_KEY_PACKET_LIST_SHOW"gui.packet_list_show"             "gui.packet_list_show"
42#define RECENT_KEY_TREE_VIEW_SHOW"gui.tree_view_show"               "gui.tree_view_show"
43#define RECENT_KEY_BYTE_VIEW_SHOW"gui.byte_view_show"               "gui.byte_view_show"
44#define RECENT_KEY_PACKET_DIAGRAM_SHOW"gui.packet_diagram_show"          "gui.packet_diagram_show"
45#define RECENT_KEY_STATUSBAR_SHOW"gui.statusbar_show"               "gui.statusbar_show"
46#define RECENT_KEY_PACKET_LIST_COLORIZE"gui.packet_list_colorize"         "gui.packet_list_colorize"
47#define RECENT_KEY_CAPTURE_AUTO_SCROLL"capture.auto_scroll"          "capture.auto_scroll"
48#define RECENT_KEY_AGGREGATION_VIEW"capture.aggregation_view"             "capture.aggregation_view"
49#define RECENT_GUI_TIME_FORMAT"gui.time_format"                  "gui.time_format"
50#define RECENT_GUI_TIME_PRECISION"gui.time_precision"               "gui.time_precision"
51#define RECENT_GUI_SECONDS_FORMAT"gui.seconds_format"               "gui.seconds_format"
52#define RECENT_GUI_ZOOM_LEVEL"gui.zoom_level"                   "gui.zoom_level"
53#define RECENT_GUI_BYTES_VIEW"gui.bytes_view"                   "gui.bytes_view"
54#define RECENT_GUI_BYTES_ENCODING"gui.bytes_encoding"               "gui.bytes_encoding"
55#define RECENT_GUI_ALLOW_HOVER_SELECTION"gui.allow_hover_selection"        "gui.allow_hover_selection"
56#define RECENT_GUI_PACKET_DIAGRAM_FIELD_VALUES"gui.packet_diagram_field_values"  "gui.packet_diagram_field_values"
57#define RECENT_GUI_GEOMETRY_MAIN_X"gui.geometry_main_x"              "gui.geometry_main_x"
58#define RECENT_GUI_GEOMETRY_MAIN_Y"gui.geometry_main_y"              "gui.geometry_main_y"
59#define RECENT_GUI_GEOMETRY_MAIN_WIDTH"gui.geometry_main_width"          "gui.geometry_main_width"
60#define RECENT_GUI_GEOMETRY_MAIN_HEIGHT"gui.geometry_main_height"         "gui.geometry_main_height"
61#define RECENT_GUI_GEOMETRY_MAIN_MAXIMIZED"gui.geometry_main_maximized"      "gui.geometry_main_maximized"
62#define RECENT_GUI_GEOMETRY_MAIN"gui.geometry_main"                "gui.geometry_main"
63#define RECENT_GUI_GEOMETRY_LEFTALIGN_ACTIONS"gui.geometry_leftalign_actions"   "gui.geometry_leftalign_actions"
64#define RECENT_GUI_GEOMETRY_MAIN_UPPER_PANE"gui.geometry_main_upper_pane"     "gui.geometry_main_upper_pane"
65#define RECENT_GUI_GEOMETRY_MAIN_LOWER_PANE"gui.geometry_main_lower_pane"     "gui.geometry_main_lower_pane"
66#define RECENT_GUI_GEOMETRY_MAIN_MASTER_SPLIT"gui.geometry_main_master_split"   "gui.geometry_main_master_split"
67#define RECENT_GUI_GEOMETRY_MAIN_EXTRA_SPLIT"gui.geometry_main_extra_split"    "gui.geometry_main_extra_split"
68#define RECENT_LAST_USED_PROFILE"gui.last_used_profile"                "gui.last_used_profile"
69#define RECENT_PROFILE_SWITCH_CHECK_COUNT"gui.profile_switch_check_count"       "gui.profile_switch_check_count"
70#define RECENT_GUI_FILEOPEN_REMEMBERED_DIR"gui.fileopen_remembered_dir"      "gui.fileopen_remembered_dir"
71#define RECENT_GUI_CONVERSATION_TABS"gui.conversation_tabs"            "gui.conversation_tabs"
72#define RECENT_GUI_CONVERSATION_TABS_COLUMNS"gui.conversation_tabs_columns"    "gui.conversation_tabs_columns"
73#define RECENT_GUI_ENDPOINT_TABS"gui.endpoint_tabs"                "gui.endpoint_tabs"
74#define RECENT_GUI_ENDPOINT_TABS_COLUMNS"gui.endpoint_tabs_columns"        "gui.endpoint_tabs_columns"
75#define RECENT_GUI_RLC_PDUS_FROM_MAC_FRAMES"gui.rlc_pdus_from_mac_frames"     "gui.rlc_pdus_from_mac_frames"
76#define RECENT_GUI_CUSTOM_COLORS"gui.custom_colors"                "gui.custom_colors"
77#define RECENT_GUI_TOOLBAR_SHOW"gui.additional_toolbar_show"                 "gui.additional_toolbar_show"
78#define RECENT_GUI_INTERFACE_TOOLBAR_SHOW"gui.interface_toolbar_show"       "gui.interface_toolbar_show"
79#define RECENT_GUI_SEARCH_IN"gui.search_in"                    "gui.search_in"
80#define RECENT_GUI_SEARCH_CHAR_SET"gui.search_char_set"              "gui.search_char_set"
81#define RECENT_GUI_SEARCH_CASE_SENSITIVE"gui.search_case_sensitive"        "gui.search_case_sensitive"
82#define RECENT_GUI_SEARCH_REVERSE_DIR"gui.search_reverse_dir"           "gui.search_reverse_dir"
83#define RECENT_GUI_SEARCH_MULTIPLE_OCCURS"gui.search_multiple_occurs"       "gui.search_multiple_occurs"
84#define RECENT_GUI_SEARCH_TYPE"gui.search_type"                  "gui.search_type"
85#define RECENT_GUI_FOLLOW_SHOW"gui.follow_show"                  "gui.follow_show"
86#define RECENT_GUI_FOLLOW_DELTA"gui.follow_delta"                 "gui.follow_delta"
87#define RECENT_GUI_SHOW_BYTES_DECODE"gui.show_bytes_decode"            "gui.show_bytes_decode"
88#define RECENT_GUI_SHOW_BYTES_SHOW"gui.show_bytes_show"              "gui.show_bytes_show"
89#define RECENT_GUI_TSD_MA_WINDOW_SIZE"gui.tsd_ma_window_size"           "gui.tsd_ma_window_size"
90#define RECENT_GUI_TSD_THROUGHPUT_SHOW"gui.tsd_throughput_show"          "gui.tsd_throughput_show"
91#define RECENT_GUI_TSD_GOODPUT_SHOW"gui.tsd_goodput_show"             "gui.tsd_goodput_show"

93#define RECENT_GUI_GEOMETRY"gui.geom."                   "gui.geom."

95#define RECENT_KEY_PRIVS_WARN_IF_ELEVATED"privs.warn_if_elevated"     "privs.warn_if_elevated"
96#define RECENT_KEY_SYS_WARN_IF_NO_CAPTURE"sys.warn_if_no_capture"     "sys.warn_if_no_capture"

98#define RECENT_FILE_NAME"recent" "recent"
99#define RECENT_COMMON_FILE_NAME"recent_common" "recent_common"

101recent_settings_t recent;

103static const value_string ts_type_values[] = {
  { TS_RELATIVE,             "RELATIVE"           },
  { TS_RELATIVE_CAP,         "RELATIVE_CAP"       },
  { 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 compatibility */
  { 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 compatibility */
  { 0, NULL((void*)0) }
118};

120/*
* NOTE: all values other than TS_PREC_AUTO are the number of digits
* of precision.
*
* We continue to use the old names for values where they may have
* been written to the recent file by previous releases.  For other
* values, we just write it out numerically.
*/
128static const value_string ts_precision_values[] = {
  { TS_PREC_AUTO,            "AUTO" },
  { TS_PREC_FIXED_SEC,       "SEC"  },
  { TS_PREC_FIXED_100_MSEC,  "DSEC" },
  { TS_PREC_FIXED_10_MSEC,   "CSEC" },
  { TS_PREC_FIXED_MSEC,      "MSEC" },
  { TS_PREC_FIXED_USEC,      "USEC" },
  { TS_PREC_FIXED_NSEC,      "NSEC" },
  { 0, NULL((void*)0) }
137};

139static const value_string ts_seconds_values[] = {
  { TS_SECONDS_DEFAULT,      "SECONDS"      },
  { TS_SECONDS_HOUR_MIN_SEC, "HOUR_MIN_SEC" },
  { 0, NULL((void*)0) }
143};

145static const value_string bytes_view_type_values[] = {
  { BYTES_HEX,    "HEX"  },
  { BYTES_BITS,   "BITS" },
  { BYTES_DEC,    "DEC" },
  { BYTES_OCT,    "OCT" },
  { 0, NULL((void*)0) }
151};

153static const value_string bytes_encoding_type_values[] = {
  { BYTES_ENC_FROM_PACKET,    "FROM_PACKET"  },
  { BYTES_ENC_ASCII,          "ASCII"  },
  { BYTES_ENC_EBCDIC,         "EBCDIC"  },
  { 0, NULL((void*)0) }
158};

160static const value_string search_in_values[] = {
  { SEARCH_IN_PACKET_LIST,    "PACKET_LIST" },
  { SEARCH_IN_PACKET_DETAILS, "PACKET_DETAILS" },
  { SEARCH_IN_PACKET_BYTES,   "PACKET_BYTES" },
  { 0, NULL((void*)0) }
165};

167static const value_string search_char_set_values[] = {
  { SEARCH_CHAR_SET_NARROW_AND_WIDE, "NARROW_AND_WIDE" },
  { SEARCH_CHAR_SET_NARROW,          "NARROW" },
  { SEARCH_CHAR_SET_WIDE,            "WIDE" },
  { 0, NULL((void*)0) }
172};

174static const value_string search_type_values[] = {
  { SEARCH_TYPE_DISPLAY_FILTER, "DISPLAY_FILTER" },
  { SEARCH_TYPE_HEX_VALUE,      "HEX_VALUE" },
  { SEARCH_TYPE_STRING,         "STRING" },
  { SEARCH_TYPE_REGEX,          "REGEX" },
  { 0, NULL((void*)0) }
180};

182static const value_string bytes_show_values[] = {
  { SHOW_ASCII,         "ASCII" },
  { SHOW_ASCII_CONTROL, "ASCII_CONTROL" },
  { SHOW_CARRAY,        "C_ARRAYS" },
  { SHOW_EBCDIC,        "EBCDIC" },
  { SHOW_HEXDUMP,       "HEX_DUMP" },
  { SHOW_HTML,          "HTML" },
  { SHOW_IMAGE,         "IMAGE" },
  { SHOW_JSON,          "JSON" },
  { SHOW_RAW,           "RAW" },
  { SHOW_RUSTARRAY,     "RUST_ARRAY" },
  { SHOW_CODEC,         "UTF-8" },
  // Other codecs are generated at runtime
  { SHOW_YAML,          "YAML"},
  { 0, NULL((void*)0) }
197};

199static const value_string follow_delta_values[] = {
  { FOLLOW_DELTA_NONE,    "NONE" },
  { FOLLOW_DELTA_TURN,    "TURN" },
  { FOLLOW_DELTA_ALL,     "ALL" },
  { 0, NULL((void*)0) }
204};

206static const value_string show_bytes_decode_values[] = {
  { DecodeAsNone,            "NONE" },
  { DecodeAsBASE64,          "BASE64" },
  { DecodeAsCompressed,      "COMPRESSED" },
  { DecodeAsHexDigits,       "HEX_DIGITS" },
  { DecodeAsPercentEncoding, "PERCENT_ENCODING" },
  { DecodeAsQuotedPrintable, "QUOTED_PRINTABLE" },
  { DecodeAsROT13,           "ROT13"},
  { 0, NULL((void*)0) }
215};

217static void
218free_col_width_data(void *data)
219{
  col_width_data *cfmt = (col_width_data *)data;
  g_free(cfmt);
222}

224void
225recent_free_column_width_info(recent_settings_t *rs)
226{
  g_list_free_full(rs->col_width_list, free_col_width_data);
  rs->col_width_list = NULL((void*)0);
229}

231/** Write the geometry values of a single window to the recent file.
*
* @param key unused
* @param value the geometry values
* @param rfh recent file handle (FILE)
*/
237static void
238write_recent_geom(void *key _U___attribute__((unused)), void *value, void *rfh)
239{
  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"gui.geom." "%s.x: %d\n", geom->key, geom->x);
  fprintf(rf, RECENT_GUI_GEOMETRY"gui.geom." "%s.y: %d\n", geom->key, geom->y);
  fprintf(rf, RECENT_GUI_GEOMETRY"gui.geom." "%s.width: %d\n", geom->key,
          geom->width);
  fprintf(rf, RECENT_GUI_GEOMETRY"gui.geom." "%s.height: %d\n", geom->key,
          geom->height);

  fprintf(rf, "# true or false (case-insensitive).\n");
  fprintf(rf, RECENT_GUI_GEOMETRY"gui.geom." "%s.maximized: %s\n", geom->key,
          geom->maximized == true1 ? "true" : "false");

  fprintf(rf, "# Qt Geometry State (hex byte string).\n");
  fprintf(rf, RECENT_GUI_GEOMETRY"gui.geom." "%s.qt_geometry: %s\n", geom->key,
          geom->qt_geom);
259}

261/* the geometry hashtable for all known window classes,
* the window name is the key, and the geometry struct is the value */
263static GHashTable *window_geom_hash;

265static GHashTable *window_splitter_hash;

267void
268window_geom_free(void *data)
269{
  window_geometry_t *geom = (window_geometry_t*)data;
  g_free(geom->key);
  g_free(geom->qt_geom);
  g_free(geom);
274}

276/* save the window and its current geometry into the geometry hashtable */
277void
278window_geom_save(const char *name, window_geometry_t *geom)
279{
  char *key;
  window_geometry_t *work;

  /* init hashtable, if not already done */
  if (!window_geom_hash) {
      window_geom_hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL((void*)0), window_geom_free);
  }

  /* g_malloc and insert the new one */
  work = g_new(window_geometry_t, 1)((window_geometry_t *) g_malloc_n ((1), sizeof (window_geometry_t
)));
  *work = *geom;
  key = g_strdup(name)g_strdup_inline (name);
  work->key = key;
  g_hash_table_replace(window_geom_hash, key, work);
294}

296/* load the desired geometry for this window from the geometry hashtable */
297bool_Bool
298window_geom_load(const char        *name,
               window_geometry_t *geom)
300{
  window_geometry_t *p;

  /* init hashtable, if not already done */
  if (!window_geom_hash) {
      window_geom_hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL((void*)0), window_geom_free);
  }

  p = (window_geometry_t *)g_hash_table_lookup(window_geom_hash, name);
  if (p) {
      *geom = *p;
      return true1;
  } else {
      return false0;
  }
315}

317/* save the window and its splitter state into the splitter hashtable */
318void
319window_splitter_save(const char *name, const char *splitter_state)
320{
  /* init hashtable, if not already done */
  if (!window_splitter_hash) {
      window_splitter_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
  }

  g_hash_table_replace(window_splitter_hash, g_strdup(name)g_strdup_inline (name), g_strdup(splitter_state)g_strdup_inline (splitter_state));
327}

329/* save the window and its splitter state into the geometry hashtable */
330const char*
331window_splitter_load(const char *name)
332{
  /* init hashtable, if not already done */
  if (!window_splitter_hash) {
      return NULL((void*)0);
  }

  return g_hash_table_lookup(window_splitter_hash, name);
339}


342/* parse values of particular types */
343static void
344parse_recent_boolean(const char *val_str, bool_Bool *valuep)
345{
  if (g_ascii_strcasecmp(val_str, "true") == 0) {
      *valuep = true1;
  }
  else {
      *valuep = false0;
  }
352}

354/** 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")
*/
360static void
361window_geom_recent_read_pair(const char *name,
                           const char *key,
                           const char *value)
364{
  window_geometry_t geom;

  if (strcmp(key, "splitter") == 0) {
      window_splitter_save(name, value);
      return;
  }

  /* find window geometry maybe already in hashtable */
  if (!window_geom_load(name, &geom)) {
      /* not in table, init geom with "basic" values */
      geom.key        = NULL((void*)0);    /* Will be set in window_geom_save() */
      geom.set_pos    = false0;
      geom.x          = -1;
      geom.y          = -1;
      geom.set_size   = false0;
      geom.width      = -1;
      geom.height     = -1;
      geom.qt_geom    = NULL((void*)0);
  }

  if (strcmp(key, "x") == 0) {
      geom.x = (int)strtol(value, NULL((void*)0), 10);
      geom.set_pos = true1;
  } else if (strcmp(key, "y") == 0) {
      geom.y = (int)strtol(value, NULL((void*)0), 10);
      geom.set_pos = true1;
  } else if (strcmp(key, "width") == 0) {
      geom.width = (int)strtol(value, NULL((void*)0), 10);
      geom.set_size = true1;
  } else if (strcmp(key, "height") == 0) {
      geom.height = (int)strtol(value, NULL((void*)0), 10);
      geom.set_size = true1;
  } else if (strcmp(key, "maximized") == 0) {
      parse_recent_boolean(value, &geom.maximized);
      geom.set_maximized = true1;
  } else if (strcmp(key, "qt_geometry") == 0) {
      geom.qt_geom = g_strdup(value)g_strdup_inline (value);
  } 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);
414}

416/** 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
*/
421static void
422window_geom_recent_write_all(FILE *rf)
423{
  /* init hashtable, if not already done */
  if (!window_geom_hash) {
      window_geom_hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL((void*)0), window_geom_free);
  }

  g_hash_table_foreach(window_geom_hash, write_recent_geom, rf);
430}

432/** Write all known window splitter states to the recent file.
*
* @param rf recent file handle from caller
*/
436static void
437window_splitter_recent_write_all(FILE *rf)
438{
  /* init hashtable, if not already done */
  if (!window_splitter_hash) {
      return;
  }

  GHashTableIter iter;
  void *key, *value;
  g_hash_table_iter_init(&iter, window_splitter_hash);
  while (g_hash_table_iter_next(&iter, &key, &value)) {
      fprintf(rf, "\n# Splitter state of %s window.\n", (char*)key);
      fprintf(rf, "# Qt Splitter state (hex byte string).\n");
      fprintf(rf, RECENT_GUI_GEOMETRY"gui.geom." "%s.splitter: %s\n", (char*)key,
              (char*)value);
  }
453}

455/* Global list of recent capture filters. */
456static GList *recent_cfilter_list;

458/*
* Per-interface lists of recent capture filters; stored in a hash
* table indexed by interface name.
*/
462static GHashTable *per_interface_cfilter_lists_hash;

464/* XXX: use a preference for this setting! */
465/* N.B.: If we use a pref, we will read the recent_common file
* before the pref, so don't truncate the list when reading
* (see the similar #16782 for the recent files.)
*/
469static unsigned cfilter_combo_max_recent = 20;

471/**
* Returns a list of recent capture filters.
*
* @param ifname interface name; NULL refers to the global list.
*/
476GList *
477recent_get_cfilter_list(const char *ifname)
478{
  if (ifname == NULL((void*)0))
      return recent_cfilter_list;
  if (per_interface_cfilter_lists_hash == NULL((void*)0)) {
      /* No such lists exist. */
      return NULL((void*)0);
  }
  return (GList *)g_hash_table_lookup(per_interface_cfilter_lists_hash, ifname);
486}

488/**
* 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
*/
495void
496recent_add_cfilter(const char *ifname, const char *s)
497{
  GList     *cfilter_list;
  GList     *li;
  char      *li_filter, *newfilter = NULL((void*)0);

  /* Don't add empty filters to the list. */
  if (s[0] == '\0')
      return;

  if (ifname == NULL((void*)0))
      cfilter_list = recent_cfilter_list;
  else {
      /* If we don't yet have a hash table for per-interface recent
         capture filter lists, create one.  Have it free the new key
         if we're updating an entry rather than creating it below. */
      if (per_interface_cfilter_lists_hash == NULL((void*)0))
          per_interface_cfilter_lists_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL((void*)0));
      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;
          cfilter_list = g_list_remove(cfilter_list, li->data);
          break;
      }
      li = li->next;
  }
  if (newfilter == NULL((void*)0)) {
      /* The filter wasn't already in the list; make a copy to add. */
      newfilter = g_strdup(s)g_strdup_inline (s);
  }
  cfilter_list = g_list_prepend(cfilter_list, newfilter);

  if (ifname == NULL((void*)0))
      recent_cfilter_list = cfilter_list;
  else
      g_hash_table_insert(per_interface_cfilter_lists_hash, g_strdup(ifname)g_strdup_inline (ifname), cfilter_list);
540}

542#ifdef HAVE_PCAP_REMOTE
543/* XXX: use a preference for this setting! */
544/* N.B.: If we use a pref, we will read the recent_common file
* before the pref, so don't truncate the list when reading
* (see the similar #16782 for the recent files.)
*/
548static unsigned remote_host_max_recent = 20;
549static GList *remote_host_list;

551int recent_get_remote_host_list_size(void)
552{
  if (remote_host_list == NULL((void*)0)) {
      /* No entries exist. */
      return 0;
  }
  return g_list_length(remote_host_list);
558}

560static void
561free_remote_host(void *value)
562{
  struct remote_host* rh = (struct remote_host*)value;

  g_free(rh->r_host);
  g_free(rh->remote_port);
  g_free(rh->auth_username);
  g_free(rh->auth_password);

570}

572static int
573remote_host_compare(const void *a, const void *b)
574{
  const struct remote_host* rh_a = (const struct remote_host*)a;
  const struct remote_host* rh_b = (const struct remote_host*)b;

  /* We assume only one entry per host (the GUI assumes that too.) */
  return g_strcmp0(rh_a->r_host, rh_b->r_host);
580}

582static void
583remote_host_reverse(void)
584{
  if (remote_host_list) {
      remote_host_list = g_list_reverse(remote_host_list);
  }
588}

590void recent_add_remote_host(char *host _U___attribute__((unused)), struct remote_host *rh)
591{
  GList* li = NULL((void*)0);
  if (remote_host_list) {
      li = g_list_find_custom(remote_host_list, rh, remote_host_compare);
      if (li != NULL((void*)0)) {
          free_remote_host(li->data);
          remote_host_list = g_list_delete_link(remote_host_list, li);
      }
  }
  remote_host_list = g_list_prepend(remote_host_list, rh);
601}

603void
604recent_remote_host_list_foreach(GFunc func, void *user_data)
605{
  if (remote_host_list != NULL((void*)0)) {
      g_list_foreach(remote_host_list, func, user_data);
  }
609}

611static void
612recent_print_remote_host(void *value, void *user)
613{
  FILE *rf = (FILE *)user;
  struct remote_host_info *ri = (struct remote_host_info *)value;

  fprintf (rf, RECENT_KEY_REMOTE_HOST"recent.remote_host" ": %s,%s,%d\n", ri->remote_host, ri->remote_port, ri->auth_type);
618}

620/**
* Write the contents of the remote_host_list to the 'recent' file.
*
* @param rf File to write to.
*/
625static void
626capture_remote_combo_recent_write_all(FILE *rf)
627{
  unsigned max_count = 0;
  GList   *li = g_list_first(remote_host_list);

  /* write all non empty remote capture hosts to the recent file (until max count) */
  while (li && (max_count++ <= remote_host_max_recent)) {
      recent_print_remote_host(li->data, rf);
      li = li->next;
  }
636}


639void recent_free_remote_host_list(void)
640{
  g_list_free_full(remote_host_list, free_remote_host);
  remote_host_list = NULL((void*)0);
643}

645struct remote_host *
646recent_get_remote_host(const char *host)
647{
  if (host == NULL((void*)0))
      return NULL((void*)0);
  for (GList* li = g_list_first(remote_host_list); li != NULL((void*)0); li = li->next) {
      struct remote_host *rh = (struct remote_host*)li->data;
      if (g_strcmp0(host, rh->r_host) == 0) {
          return rh;
      }
  }
  return NULL((void*)0);
657}

659/**
* Fill the remote_host_list with the entries stored in the 'recent' file.
*
* @param s String to be filled from the 'recent' file.
* @return True, if the list was written successfully, False otherwise.
*/
665static bool_Bool
666capture_remote_combo_add_recent(const char *s)
667{
  GList *vals = prefs_get_string_list (s);
  GList *valp = vals;
  capture_auth auth_type;
  char  *p;
  struct remote_host *rh;

  if (valp == NULL((void*)0))
      return false0;

  /* First value is the host */
  if (recent_get_remote_host(valp->data)) {
      /* Don't add it, it's already in the list (shouldn't happen). */
      return false0; // Should this be true or false?
  }
  rh = (struct remote_host *) g_malloc (sizeof (*rh));

  /* First value is the host */
  rh->r_host = (char *)g_strdup ((const char *)valp->data)g_strdup_inline ((const char *)valp->data);
  if (strlen(rh->r_host) == 0) {
      /* Empty remote host */
      g_free(rh->r_host);
      g_free(rh);
      return false0;
  }
  rh->auth_type = CAPTURE_AUTH_NULL;
  valp = valp->next;

  if (valp) {
      /* Found value 2, this is the port number */
      if (!strcmp((const char*)valp->data, "0")) {
          /* Port 0 isn't valid, so leave port blank */
          rh->remote_port = (char *)g_strdup ("")g_strdup_inline ("");
      } else {
          rh->remote_port = (char *)g_strdup ((const char *)valp->data)g_strdup_inline ((const char *)valp->data);
      }
      valp = valp->next;
  } else {
      /* Did not find a port number */
      rh->remote_port = g_strdup ("")g_strdup_inline ("");
  }

  if (valp) {
      /* Found value 3, this is the authentication type */
      auth_type = (capture_auth)strtol((const char *)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 ("")g_strdup_inline ("");
  rh->auth_password = g_strdup ("")g_strdup_inline ("");

  prefs_clear_string_list(vals);

  remote_host_list = g_list_prepend(remote_host_list, rh);
  return true1;
725}
726#endif

728static void
729cfilter_recent_write_all_list(FILE *rf, const char *ifname, GList *cfilter_list)
730{
  unsigned   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((void*)0))
              fprintf (rf, RECENT_KEY_CAPTURE_FILTER"recent.capture_filter" ": %s\n", (char *)li->data);
          else
              fprintf (rf, RECENT_KEY_CAPTURE_FILTER"recent.capture_filter" ".%s: %s\n", ifname, (char *)li->data);
      }
      li = li->next;
  }
745}

747static void
748cfilter_recent_write_all_hash_callback(void *key, void *value, void *user_data)
749{
  cfilter_recent_write_all_list((FILE *)user_data, (const char *)key, (GList *)value);
751}

753/** Write all capture filter values to the recent file.
*
* @param rf recent file handle from caller
*/
757static void
758cfilter_recent_write_all(FILE *rf)
759{
  /* Write out the global list. */
  cfilter_recent_write_all_list(rf, NULL((void*)0), recent_cfilter_list);

  /* Write out all the per-interface lists. */
  if (per_interface_cfilter_lists_hash != NULL((void*)0)) {
      g_hash_table_foreach(per_interface_cfilter_lists_hash, cfilter_recent_write_all_hash_callback, (void *)rf);
  }
767}

769/** Reverse the order of all the capture filter lists after
*  reading recent_common (we want the latest first).
*  Note this is O(N), whereas appendng N items to a GList is O(N^2),
*  since it doesn't have a pointer to the end like a GQueue.
*/
774static void
775cfilter_recent_reverse_all(void)
776{
  recent_cfilter_list = g_list_reverse(recent_cfilter_list);

  /* Reverse all the per-interface lists. */
  if (per_interface_cfilter_lists_hash != NULL((void*)0)) {
      GHashTableIter iter;
      void *key, *value;
      g_hash_table_iter_init(&iter, per_interface_cfilter_lists_hash);
      GList *li;
      while (g_hash_table_iter_next(&iter, &key, &value)) {
          li = (GList *)value;
          li = g_list_reverse(li);
          /* per_interface_cfilter_lists_hash was created without a
           * value_destroy_func, so this is fine.
           */
          g_hash_table_iter_replace(&iter, li);
      }
  }
794}

796/* Write out recent settings of particular types. */
797static void
798write_recent_boolean(FILE *rf, const char *description, const char *name,
                   bool_Bool value)
800{
  fprintf(rf, "\n# %s.\n", description);
  fprintf(rf, "# true or false (case-insensitive).\n");
  fprintf(rf, "%s: %s\n", name, value == true1 ? "true" : "false");
804}

806static void
807write_recent_double(FILE *rf, const char *description, const char *name,
                  double value)
809{
  fprintf(rf, "\n# %s.\n", description);
  char buf[G_ASCII_DTOSTR_BUF_SIZE(29 + 10)];
  fprintf(rf, "%s: %s\n", name, g_ascii_dtostr(buf, sizeof(buf), value));
813}

815static void
816write_recent_enum(FILE *rf, const char *description, const char *name,
                const value_string *values, unsigned value)
818{
  const char *if_invalid = NULL((void*)0);
  const value_string *valp;
  const char *str_value;

  fprintf(rf, "\n# %s.\n", description);
  fprintf(rf, "# One of: ");
  valp = values;
  while (valp->strptr != NULL((void*)0)) {
      if (if_invalid == NULL((void*)0))
          if_invalid = valp->strptr;
      fprintf(rf, "%s", valp->strptr);
      valp++;
      if (valp->strptr != NULL((void*)0))
          fprintf(rf, ", ");
  }
  fprintf(rf, "\n");
  str_value = try_val_to_str(value, values);
  if (str_value != NULL((void*)0))
      fprintf(rf, "%s: %s\n", name, str_value);
  else
      fprintf(rf, "%s: %s\n", name, if_invalid != NULL((void*)0) ? if_invalid : "Unknown");
840}

842/* Attempt to write out "recent common" to the user's recent_common file.
 If we got an error report it with a dialog box and return false,
 otherwise return true. */
845bool_Bool
846write_recent(void)
847{
  char        *pf_dir_path;
  char        *rf_path;
  FILE        *rf;
  char        *string_list;

  /* 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_OK0x01,
              "Can't create directory\n\"%s\"\nfor recent file: %s.", pf_dir_path,
              g_strerror(errno(*__errno_location ())));
      g_free(pf_dir_path);
      return false0;
  }

  rf_path = get_persconffile_path(RECENT_COMMON_FILE_NAME"recent_common", false0);
  if ((rf = ws_fopenfopen(rf_path, "w")) == NULL((void*)0)) {
      simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK0x01,
              "Can't open recent file\n\"%s\": %s.", rf_path,
              g_strerror(errno(*__errno_location ())));
      g_free(rf_path);
      return false0;
  }
  g_free(rf_path);

  fprintf(rf, "# Common recent settings file for %s " VERSION"4.7.0" ".\n"
          "#\n"
          "# This file is regenerated each time %s is quit\n"
          "# and when changing configuration profile.\n"
          "# So be careful, if you want to make manual changes here.\n"
          "\n"
          "######## Recent capture files (latest last), cannot be altered through command line ########\n"
          "\n",
          application_flavor_name_proper(), application_flavor_name_proper());


  menu_recent_file_write_all(rf);

  fputs("\n"
          "######## Recent capture filters (latest first), cannot be altered through command line ########\n"
          "\n", rf);

  cfilter_recent_write_all(rf);

  fputs("\n"
          "######## Recent display filters (latest last), cannot be altered through command line ########\n"
          "\n", rf);

  dfilter_recent_combo_write_all(rf);

904#ifdef HAVE_PCAP_REMOTE
  fputs("\n"
          "######## Recent remote hosts (latest first), cannot be altered through command line ########\n"
          "\n", rf);

  capture_remote_combo_recent_write_all(rf);
910#endif

  fprintf(rf, "\n# Main window geometry.\n");
  fprintf(rf, "# Decimal numbers.\n");
  fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_X"gui.geometry_main_x" ": %d\n", recent.gui_geometry_main_x);
  fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_Y"gui.geometry_main_y" ": %d\n", recent.gui_geometry_main_y);
  fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_WIDTH"gui.geometry_main_width" ": %d\n",
          recent.gui_geometry_main_width);
  fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_HEIGHT"gui.geometry_main_height" ": %d\n",
          recent.gui_geometry_main_height);

  write_recent_boolean(rf, "Main window maximized",
          RECENT_GUI_GEOMETRY_MAIN_MAXIMIZED"gui.geometry_main_maximized",
          recent.gui_geometry_main_maximized);

  if (recent.gui_geometry_main != NULL((void*)0)) {
      fprintf(rf, "\n# Main window geometry state.\n");
      fprintf(rf, "# Hex byte string.\n");
      fprintf(rf, RECENT_GUI_GEOMETRY_MAIN"gui.geometry_main" ": %s\n",
              recent.gui_geometry_main);
  }

  write_recent_boolean(rf, "Leftalign Action Buttons",
          RECENT_GUI_GEOMETRY_LEFTALIGN_ACTIONS"gui.geometry_leftalign_actions",
          recent.gui_geometry_leftalign_actions);

  fprintf(rf, "\n# Last used Configuration Profile.\n");
  fprintf(rf, RECENT_LAST_USED_PROFILE"gui.last_used_profile" ": %s\n", get_profile_name());

  fprintf(rf, "\n# Number of packets or events to check for automatic profile switching.\n");
  fprintf(rf, "# Decimal number. Zero disables switching.\n");
  const char * def_prefix = recent.gui_profile_switch_check_count == 1000 ? "#" : "";
  fprintf(rf, "%s" RECENT_PROFILE_SWITCH_CHECK_COUNT"gui.profile_switch_check_count" ": %d\n", def_prefix,
          recent.gui_profile_switch_check_count);

  write_recent_boolean(rf, "Warn if running with elevated permissions (e.g. as root)",
          RECENT_KEY_PRIVS_WARN_IF_ELEVATED"privs.warn_if_elevated",
          recent.privs_warn_if_elevated);

  write_recent_boolean(rf, "Warn if Wireshark is unable to capture",
          RECENT_KEY_SYS_WARN_IF_NO_CAPTURE"sys.warn_if_no_capture",
          recent.sys_warn_if_no_capture);

  write_recent_enum(rf, "Find packet search in", RECENT_GUI_SEARCH_IN"gui.search_in", search_in_values,
                    recent.gui_search_in);
  write_recent_enum(rf, "Find packet character set", RECENT_GUI_SEARCH_CHAR_SET"gui.search_char_set", search_char_set_values,
                    recent.gui_search_char_set);
  write_recent_boolean(rf, "Find packet case sensitive search",
                       RECENT_GUI_SEARCH_CASE_SENSITIVE"gui.search_case_sensitive",
                       recent.gui_search_case_sensitive);
  write_recent_boolean(rf, "Find packet search reverse direction",
                       RECENT_GUI_SEARCH_REVERSE_DIR"gui.search_reverse_dir",
                       recent.gui_search_reverse_dir);
  write_recent_boolean(rf, "Find packet search multiple occurrences",
                       RECENT_GUI_SEARCH_MULTIPLE_OCCURS"gui.search_multiple_occurs",
                       recent.gui_search_multiple_occurs);
  write_recent_enum(rf, "Find packet search type", RECENT_GUI_SEARCH_TYPE"gui.search_type", search_type_values,
                    recent.gui_search_type);

  window_geom_recent_write_all(rf);

  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"gui.custom_colors" ": %s\n", string_list);
  g_free(string_list);

  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 true1;
984}


987/* Attempt to Write out profile "recent" to the user's profile recent file.
 If we got an error report it with a dialog box and return false,
 otherwise return true. */
990bool_Bool
991write_profile_recent(void)
992{
  char        *pf_dir_path;
  char        *rf_path;
  char        *string_list;
  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_OK0x01,
              "Can't create directory\n\"%s\"\nfor recent file: %s.", pf_dir_path,
              g_strerror(errno(*__errno_location ())));
      g_free(pf_dir_path);
      return false0;
  }

  rf_path = get_persconffile_path(RECENT_FILE_NAME"recent", true1);
  if ((rf = ws_fopenfopen(rf_path, "w")) == NULL((void*)0)) {
      simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK0x01,
              "Can't open recent file\n\"%s\": %s.", rf_path,
              g_strerror(errno(*__errno_location ())));
      g_free(rf_path);
      return false0;
  }
  g_free(rf_path);

  fprintf(rf, "# Recent settings file for %s " VERSION"4.7.0" ".\n"
          "#\n"
          "# This file is regenerated each time %s is quit\n"
          "# and when changing configuration profile.\n"
          "# So be careful, if you want to make manual changes here.\n"
          "\n",
          application_flavor_name_proper(), application_flavor_name_proper());

  write_recent_boolean(rf, "Main Toolbar show (hide)",
          RECENT_KEY_MAIN_TOOLBAR_SHOW"gui.toolbar_main_show",
          recent.main_toolbar_show);

  write_recent_boolean(rf, "Filter Toolbar show (hide)",
          RECENT_KEY_FILTER_TOOLBAR_SHOW"gui.filter_toolbar_show",
          recent.filter_toolbar_show);

  write_recent_boolean(rf, "Wireless Settings Toolbar show (hide)",
          RECENT_KEY_WIRELESS_TOOLBAR_SHOW"gui.wireless_toolbar_show",
          recent.wireless_toolbar_show);

  write_recent_boolean(rf, "Packet list show (hide)",
          RECENT_KEY_PACKET_LIST_SHOW"gui.packet_list_show",
          recent.packet_list_show);

  write_recent_boolean(rf, "Tree view show (hide)",
          RECENT_KEY_TREE_VIEW_SHOW"gui.tree_view_show",
          recent.tree_view_show);

  write_recent_boolean(rf, "Byte view show (hide)",
          RECENT_KEY_BYTE_VIEW_SHOW"gui.byte_view_show",
          recent.byte_view_show);

  write_recent_boolean(rf, "Packet diagram show (hide)",
          RECENT_KEY_PACKET_DIAGRAM_SHOW"gui.packet_diagram_show",
          recent.packet_diagram_show);

  write_recent_boolean(rf, "Statusbar show (hide)",
          RECENT_KEY_STATUSBAR_SHOW"gui.statusbar_show",
          recent.statusbar_show);

  write_recent_boolean(rf, "Packet list colorize (hide)",
          RECENT_KEY_PACKET_LIST_COLORIZE"gui.packet_list_colorize",
          recent.packet_list_colorize);

  write_recent_boolean(rf, "Auto scroll packet list when capturing",
          RECENT_KEY_CAPTURE_AUTO_SCROLL"capture.auto_scroll",
          recent.capture_auto_scroll);

  write_recent_boolean(rf, "use as aggragation view",
      RECENT_KEY_AGGREGATION_VIEW"capture.aggregation_view",
      recent.aggregation_view);

  write_recent_enum(rf, "Timestamp display format",
          RECENT_GUI_TIME_FORMAT"gui.time_format", ts_type_values,
          recent.gui_time_format);

  /*
   * The value of this item is either TS_PREC_AUTO, which is a
   * negative number meaning "pick the display precision based
   * on the time stamp precision of the packet", or is a numerical
   * value giving the number of decimal places to display, from 0
   * to WS_TSPREC_MAX.
   *
   * It used to be that not all values between 0 and 9 (the maximum
   * precision back then) were supported, and that names were
   * written out to the recent file.
   *
   * For backwards compatibility with those older versions of
   * Wireshark, write out the names for those values, and the
   * raw number for other values.
   */
  {
      const char *if_invalid = NULL((void*)0);
      const value_string *valp;
      const char *str_value;

      fprintf(rf, "\n# %s.\n", "Timestamp display precision");
      fprintf(rf, "# One of: ");
      valp = ts_precision_values;
      while (valp->strptr != NULL((void*)0)) {
          if (if_invalid == NULL((void*)0))
              if_invalid = valp->strptr;
          fprintf(rf, "%s", valp->strptr);
          valp++;
          if (valp->strptr != NULL((void*)0))
              fprintf(rf, ", ");
      }
      fprintf(rf, ", or a number between 0 and %d\n", WS_TSPREC_MAX9);

      str_value = try_val_to_str(recent.gui_time_precision, ts_precision_values);
      if (str_value != NULL((void*)0))
          fprintf(rf, "%s: %s\n", RECENT_GUI_TIME_PRECISION"gui.time_precision", str_value);
      else {
          if (recent.gui_time_precision >= 0 && recent.gui_time_precision < WS_TSPREC_MAX9)
              fprintf(rf, "%s: %d\n", RECENT_GUI_TIME_PRECISION"gui.time_precision", recent.gui_time_precision);
          else
              fprintf(rf, "%s: %s\n", RECENT_GUI_TIME_PRECISION"gui.time_precision", if_invalid != NULL((void*)0) ? if_invalid : "Unknown");
      }
  }

  write_recent_enum(rf, "Seconds display format",
          RECENT_GUI_SECONDS_FORMAT"gui.seconds_format", ts_seconds_values,
          recent.gui_seconds_format);

  fprintf(rf, "\n# Zoom level.\n");
  fprintf(rf, "# A decimal number.\n");
  fprintf(rf, RECENT_GUI_ZOOM_LEVEL"gui.zoom_level" ": %d\n",
          recent.gui_zoom_level);

  write_recent_enum(rf, "Bytes view display type",
          RECENT_GUI_BYTES_VIEW"gui.bytes_view", bytes_view_type_values,
          recent.gui_bytes_view);

  write_recent_enum(rf, "Bytes view text encoding",
          RECENT_GUI_BYTES_ENCODING"gui.bytes_encoding", bytes_encoding_type_values,
          recent.gui_bytes_encoding);

  write_recent_boolean(rf, "Packet diagram field values show (hide)",
          RECENT_GUI_PACKET_DIAGRAM_FIELD_VALUES"gui.packet_diagram_field_values",
          recent.gui_packet_diagram_field_values);

  write_recent_boolean(rf, "Allow hover selection in byte view",
          RECENT_GUI_ALLOW_HOVER_SELECTION"gui.allow_hover_selection",
          recent.gui_allow_hover_selection);

  write_recent_enum(rf, "Follow stream show as",
          RECENT_GUI_FOLLOW_SHOW"gui.follow_show", bytes_show_values,
          recent.gui_follow_show);

  write_recent_enum(rf, "Follow stream delta times",
                    RECENT_GUI_FOLLOW_DELTA"gui.follow_delta", follow_delta_values,
                    recent.gui_follow_delta);

  write_recent_enum(rf, "Show packet bytes decode as",
          RECENT_GUI_SHOW_BYTES_DECODE"gui.show_bytes_decode", show_bytes_decode_values,
          recent.gui_show_bytes_decode);

  write_recent_enum(rf, "Show packet bytes show as",
          RECENT_GUI_SHOW_BYTES_SHOW"gui.show_bytes_show", bytes_show_values,
          recent.gui_show_bytes_show);

  fprintf(rf, "\n# Main window upper (or leftmost) pane size.\n");
  fprintf(rf, "# Decimal number.\n");
  if (recent.gui_geometry_main_upper_pane != 0) {
      fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_UPPER_PANE"gui.geometry_main_upper_pane" ": %d\n",
              recent.gui_geometry_main_upper_pane);
  }
  fprintf(rf, "\n# Main window middle pane size.\n");
  fprintf(rf, "# Decimal number.\n");
  if (recent.gui_geometry_main_lower_pane != 0) {
      fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_LOWER_PANE"gui.geometry_main_lower_pane" ": %d\n",
              recent.gui_geometry_main_lower_pane);
  }

  if (recent.gui_geometry_main_master_split != NULL((void*)0)) {
      fprintf(rf, "\n# Main window master splitter state.\n");
      fprintf(rf, "# Hex byte string.\n");
      fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_MASTER_SPLIT"gui.geometry_main_master_split" ": %s\n",
              recent.gui_geometry_main_master_split);
  }

  if (recent.gui_geometry_main_extra_split != NULL((void*)0)) {
      fprintf(rf, "\n# Main window extra splitter state.\n");
      fprintf(rf, "# Hex byte string.\n");
      fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_EXTRA_SPLIT"gui.geometry_main_extra_split" ": %s\n",
              recent.gui_geometry_main_extra_split);
  }

  window_splitter_recent_write_all(rf);

  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");
  packet_list_recent_write_all(rf);

  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"gui.conversation_tabs" ": %s\n", string_list);
  g_free(string_list);

  fprintf(rf, "\n# Conversation dialog tabs columns.\n");
  fprintf(rf, "# List of conversation columns numbers.\n");
  string_list = join_string_list(recent.conversation_tabs_columns);
  fprintf(rf, RECENT_GUI_CONVERSATION_TABS_COLUMNS"gui.conversation_tabs_columns" ": %s\n", string_list);
  g_free(string_list);

  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"gui.endpoint_tabs" ": %s\n", string_list);
  g_free(string_list);

  fprintf(rf, "\n# Endpoint dialog tabs columns.\n");
  fprintf(rf, "# List of endpoint columns numbers.\n");
  string_list = join_string_list(recent.endpoint_tabs_columns);
  fprintf(rf, RECENT_GUI_ENDPOINT_TABS_COLUMNS"gui.endpoint_tabs_columns" ": %s\n", string_list);
  g_free(string_list);

  write_recent_boolean(rf, "For RLC stats, whether to use RLC PDUs found inside MAC frames",
          RECENT_GUI_RLC_PDUS_FROM_MAC_FRAMES"gui.rlc_pdus_from_mac_frames",
          recent.gui_rlc_use_pdus_from_mac);

  if (get_last_open_dir() != NULL((void*)0)) {
      fprintf(rf, "\n# Last directory navigated to in File Open dialog.\n");
      fprintf(rf, RECENT_GUI_FILEOPEN_REMEMBERED_DIR"gui.fileopen_remembered_dir" ": %s\n", get_last_open_dir());
  }

  fprintf(rf, "\n# Additional Toolbars shown\n");
  fprintf(rf, "# List of additional toolbars to show.\n");
  string_list = join_string_list(recent.gui_additional_toolbars);
  fprintf(rf, RECENT_GUI_TOOLBAR_SHOW"gui.additional_toolbar_show" ": %s\n", string_list);
  g_free(string_list);

  fprintf(rf, "\n# Interface Toolbars show.\n");
  fprintf(rf, "# List of interface toolbars to show.\n");
  string_list = join_string_list(recent.interface_toolbars);
  fprintf(rf, RECENT_GUI_INTERFACE_TOOLBAR_SHOW"gui.interface_toolbar_show" ": %s\n", string_list);
  g_free(string_list);

  write_recent_double(rf, "TCP Stream Graphs Moving Average Window Size",
          RECENT_GUI_TSD_MA_WINDOW_SIZE"gui.tsd_ma_window_size",
          recent.gui_tsgd_ma_window_size);
  write_recent_boolean(rf, "TCP Stream Graphs Dialog Throughput show (hide)",
          RECENT_GUI_TSD_THROUGHPUT_SHOW"gui.tsd_throughput_show",
          recent.gui_tsgd_throughput_show);
  write_recent_boolean(rf, "TCP Stream Graphs Dialog Goodput show (hide)",
          RECENT_GUI_TSD_GOODPUT_SHOW"gui.tsd_goodput_show",
          recent.gui_tsgd_goodput_show);

  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 true1;
1260}

1262/* set one user's recent common file key/value pair */
1263static prefs_set_pref_e
1264read_set_recent_common_pair_static(char *key, const char *value,
                                 void *private_data _U___attribute__((unused)),
                                 bool_Bool return_range_errors _U___attribute__((unused)))
1267{
  long num;
  char *p;

  if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_MAXIMIZED"gui.geometry_main_maximized") == 0) {
      parse_recent_boolean(value, &recent.gui_geometry_main_maximized);
  } else if (strcmp(key, RECENT_GUI_GEOMETRY_LEFTALIGN_ACTIONS"gui.geometry_leftalign_actions") == 0) {
      parse_recent_boolean(value, &recent.gui_geometry_leftalign_actions);
  } else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_X"gui.geometry_main_x") == 0) {
      num = strtol(value, &p, 0);
      if (p == value || *p != '\0')
          return PREFS_SET_SYNTAX_ERR;      /* number was bad */
      recent.gui_geometry_main_x = (int)num;
  } else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_Y"gui.geometry_main_y") == 0) {
      num = strtol(value, &p, 0);
      if (p == value || *p != '\0')
          return PREFS_SET_SYNTAX_ERR;      /* number was bad */
      recent.gui_geometry_main_y = (int)num;
  } else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_WIDTH"gui.geometry_main_width") == 0) {
      num = strtol(value, &p, 0);
      if (p == value || *p != '\0')
          return PREFS_SET_SYNTAX_ERR;      /* number was bad */
      if (num <= 0)
          return PREFS_SET_SYNTAX_ERR;      /* number must be positive */
      recent.gui_geometry_main_width = (int)num;
  } else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_HEIGHT"gui.geometry_main_height") == 0) {
      num = strtol(value, &p, 0);
      if (p == value || *p != '\0')
          return PREFS_SET_SYNTAX_ERR;      /* number was bad */
      if (num <= 0)
          return PREFS_SET_SYNTAX_ERR;      /* number must be positive */
      recent.gui_geometry_main_height = (int)num;
  } else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN"gui.geometry_main") == 0) {
      g_free(recent.gui_geometry_main);
      recent.gui_geometry_main = g_strdup(value)g_strdup_inline (value);
  } else if (strcmp(key, RECENT_LAST_USED_PROFILE"gui.last_used_profile") == 0) {
      if ((strcmp(value, DEFAULT_PROFILE"Default") != 0) && profile_exists (value, false0)) {
          set_profile_name (value);
      }
  } else if (strcmp(key, RECENT_PROFILE_SWITCH_CHECK_COUNT"gui.profile_switch_check_count") == 0) {
      num = strtol(value, &p, 0);
      if (p == value || *p != '\0')
          return PREFS_SET_SYNTAX_ERR;      /* number was bad */
      if (num <= 0)
          return PREFS_SET_SYNTAX_ERR;      /* number must be positive */
      recent.gui_profile_switch_check_count = (int)num;
  } else if (strncmp(key, RECENT_GUI_GEOMETRY"gui.geom.", sizeof(RECENT_GUI_GEOMETRY"gui.geom.")-1) == 0) {
      /* now have something like "gui.geom.main.x", split it into win and sub_key */
      char *win = &key[sizeof(RECENT_GUI_GEOMETRY"gui.geom.")-1];
      char *sub_key = strchr(win, '.');
      if (sub_key) {
          *sub_key = '\0';
          sub_key++;
          window_geom_recent_read_pair(win, sub_key, value);
      }
  } else if (strcmp(key, RECENT_KEY_PRIVS_WARN_IF_ELEVATED"privs.warn_if_elevated") == 0) {
      parse_recent_boolean(value, &recent.privs_warn_if_elevated);
  } else if (strcmp(key, RECENT_KEY_SYS_WARN_IF_NO_CAPTURE"sys.warn_if_no_capture") == 0) {
      parse_recent_boolean(value, &recent.sys_warn_if_no_capture);
  } else if (strcmp(key, RECENT_GUI_SEARCH_IN"gui.search_in") == 0) {
      recent.gui_search_in = (search_in_type)str_to_val(value, search_in_values, SEARCH_IN_PACKET_LIST);
  } else if (strcmp(key, RECENT_GUI_SEARCH_CHAR_SET"gui.search_char_set") == 0) {
      recent.gui_search_char_set = (search_char_set_type)str_to_val(value, search_char_set_values, SEARCH_CHAR_SET_NARROW_AND_WIDE);
  } else if (strcmp(key, RECENT_GUI_SEARCH_CASE_SENSITIVE"gui.search_case_sensitive") == 0) {
      parse_recent_boolean(value, &recent.gui_search_case_sensitive);
  } else if (strcmp(key, RECENT_GUI_SEARCH_REVERSE_DIR"gui.search_reverse_dir") == 0) {
      parse_recent_boolean(value, &recent.gui_search_reverse_dir);
  } else if (strcmp(key, RECENT_GUI_SEARCH_MULTIPLE_OCCURS"gui.search_multiple_occurs") == 0) {
      parse_recent_boolean(value, &recent.gui_search_multiple_occurs);
  } else if (strcmp(key, RECENT_GUI_SEARCH_TYPE"gui.search_type") == 0) {
      recent.gui_search_type = (search_type_type)str_to_val(value, search_type_values, SEARCH_TYPE_DISPLAY_FILTER);
  } else if (strcmp(key, RECENT_GUI_CUSTOM_COLORS"gui.custom_colors") == 0) {
      recent.custom_colors = prefs_get_string_list(value);
  }

  return PREFS_SET_OK;
1343}

1345/* set one user's recent file key/value pair */
1346static prefs_set_pref_e
1347read_set_recent_pair_static(char *key, const char *value,
                          void *private_data _U___attribute__((unused)),
                          bool_Bool return_range_errors _U___attribute__((unused)))
1350{
  long num;
  int32_t num_int32;
  double val_as_dbl;
  char *p;
  GList *col_l, *col_l_elt;
  col_width_data *cfmt;

  if (strcmp(key, RECENT_KEY_MAIN_TOOLBAR_SHOW"gui.toolbar_main_show") == 0) {
      parse_recent_boolean(value, &recent.main_toolbar_show);
  } else if (strcmp(key, RECENT_KEY_FILTER_TOOLBAR_SHOW"gui.filter_toolbar_show") == 0) {
      parse_recent_boolean(value, &recent.filter_toolbar_show);
      /* check both the old and the new keyword */
  } else if (strcmp(key, RECENT_KEY_WIRELESS_TOOLBAR_SHOW"gui.wireless_toolbar_show") == 0 || (strcmp(key, "gui.airpcap_toolbar_show") == 0)) {
      parse_recent_boolean(value, &recent.wireless_toolbar_show);
  } else if (strcmp(key, RECENT_KEY_PACKET_LIST_SHOW"gui.packet_list_show") == 0) {
      parse_recent_boolean(value, &recent.packet_list_show);
  } else if (strcmp(key, RECENT_KEY_TREE_VIEW_SHOW"gui.tree_view_show") == 0) {
      parse_recent_boolean(value, &recent.tree_view_show);
  } else if (strcmp(key, RECENT_KEY_BYTE_VIEW_SHOW"gui.byte_view_show") == 0) {
      parse_recent_boolean(value, &recent.byte_view_show);
  } else if (strcmp(key, RECENT_KEY_PACKET_DIAGRAM_SHOW"gui.packet_diagram_show") == 0) {
      parse_recent_boolean(value, &recent.packet_diagram_show);
  } else if (strcmp(key, RECENT_KEY_STATUSBAR_SHOW"gui.statusbar_show") == 0) {
      parse_recent_boolean(value, &recent.statusbar_show);
  } else if (strcmp(key, RECENT_KEY_PACKET_LIST_COLORIZE"gui.packet_list_colorize") == 0) {
      parse_recent_boolean(value, &recent.packet_list_colorize);
  } else if (strcmp(key, RECENT_KEY_CAPTURE_AUTO_SCROLL"capture.auto_scroll") == 0) {
      parse_recent_boolean(value, &recent.capture_auto_scroll);
  } else if (strcmp(key, RECENT_KEY_AGGREGATION_VIEW"capture.aggregation_view") == 0) {
      parse_recent_boolean(value, &recent.aggregation_view);
  } else if (strcmp(key, RECENT_GUI_TIME_FORMAT"gui.time_format") == 0) {
      recent.gui_time_format = (ts_type)str_to_val(value, ts_type_values,
          application_flavor_is_wireshark() ? TS_RELATIVE : TS_ABSOLUTE);
  } else if (strcmp(key, RECENT_GUI_TIME_PRECISION"gui.time_precision") == 0) {
      /*
       * The value of this item is either TS_PREC_AUTO, which is a
       * negative number meaning "pick the display precision based
       * on the time stamp precision of the packet", or is a numerical
       * value giving the number of decimal places to display, from 0
       * to WS_TSPREC_MAX.
       *
       * It used to be that not all values between 0 and 9 (the maximum
       * precision back then) were supported, and that names were
       * written out to the recent file.
       *
       * If the string value is a valid number in that range, use
       * that number, otherwise look it up in the table of names,
       * and, if that fails, set it to TS_PREC_AUTO.
       */
      if (ws_strtoi32(value, NULL((void*)0), &num_int32) && num_int32 >= 0 &&
          num_int32 <= WS_TSPREC_MAX9) {
          recent.gui_time_precision = num_int32;
      } else {
          recent.gui_time_precision =
              (ts_precision)str_to_val(value, ts_precision_values, TS_PREC_AUTO);
      }
  } else if (strcmp(key, RECENT_GUI_SECONDS_FORMAT"gui.seconds_format") == 0) {
      recent.gui_seconds_format =
          (ts_seconds_type)str_to_val(value, ts_seconds_values, TS_SECONDS_DEFAULT);
  } else if (strcmp(key, RECENT_GUI_ZOOM_LEVEL"gui.zoom_level") == 0) {
      num = strtol(value, &p, 0);
      if (p == value || *p != '\0')
          return PREFS_SET_SYNTAX_ERR;      /* number was bad */
      recent.gui_zoom_level = (int)num;
  } else if (strcmp(key, RECENT_GUI_BYTES_VIEW"gui.bytes_view") == 0) {
      recent.gui_bytes_view =
          (bytes_view_type)str_to_val(value, bytes_view_type_values, BYTES_HEX);
  } else if (strcmp(key, RECENT_GUI_BYTES_ENCODING"gui.bytes_encoding") == 0) {
      recent.gui_bytes_encoding =
          (bytes_encoding_type)str_to_val(value, bytes_encoding_type_values, BYTES_ENC_FROM_PACKET);
  } else if (strcmp(key, RECENT_GUI_PACKET_DIAGRAM_FIELD_VALUES"gui.packet_diagram_field_values") == 0) {
      parse_recent_boolean(value, &recent.gui_packet_diagram_field_values);
  } else if (strcmp(key, RECENT_GUI_ALLOW_HOVER_SELECTION"gui.allow_hover_selection") == 0) {
      parse_recent_boolean(value, &recent.gui_allow_hover_selection);
  } else if (strcmp(key, RECENT_GUI_FOLLOW_SHOW"gui.follow_show") == 0) {
      recent.gui_follow_show = (bytes_show_type)str_to_val(value, bytes_show_values, SHOW_ASCII);
  } else if (strcmp(key, RECENT_GUI_FOLLOW_DELTA"gui.follow_delta") == 0) {
      recent.gui_follow_delta = (follow_delta_type)str_to_val(value, follow_delta_values, FOLLOW_DELTA_NONE);
  } else if (strcmp(key, RECENT_GUI_SHOW_BYTES_DECODE"gui.show_bytes_decode") == 0) {
      recent.gui_show_bytes_decode = (bytes_decode_type)str_to_val(value, show_bytes_decode_values, DecodeAsNone);
  } else if (strcmp(key, RECENT_GUI_SHOW_BYTES_SHOW"gui.show_bytes_show") == 0) {
      recent.gui_show_bytes_show = (bytes_show_type)str_to_val(value, bytes_show_values, SHOW_ASCII);
  } else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_UPPER_PANE"gui.geometry_main_upper_pane") == 0) {
      num = strtol(value, &p, 0);
      if (p == value || *p != '\0')
          return PREFS_SET_SYNTAX_ERR;      /* number was bad */
      if (num <= 0)
          return PREFS_SET_SYNTAX_ERR;      /* number must be positive */
      recent.gui_geometry_main_upper_pane = (int)num;
  } else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_LOWER_PANE"gui.geometry_main_lower_pane") == 0) {
      num = strtol(value, &p, 0);
      if (p == value || *p != '\0')
          return PREFS_SET_SYNTAX_ERR;      /* number was bad */
      if (num <= 0)
          return PREFS_SET_SYNTAX_ERR;      /* number must be positive */
      recent.gui_geometry_main_lower_pane = (int)num;
  } else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_MASTER_SPLIT"gui.geometry_main_master_split") == 0) {
      g_free(recent.gui_geometry_main_master_split);
      recent.gui_geometry_main_master_split = g_strdup(value)g_strdup_inline (value);
  } else if (strcmp(key, RECENT_GUI_GEOMETRY_MAIN_EXTRA_SPLIT"gui.geometry_main_extra_split") == 0) {
      g_free(recent.gui_geometry_main_extra_split);
      recent.gui_geometry_main_extra_split = g_strdup(value)g_strdup_inline (value);
  } else if (strncmp(key, RECENT_GUI_GEOMETRY"gui.geom.", sizeof(RECENT_GUI_GEOMETRY"gui.geom.")-1) == 0) {
      /* now have something like "gui.geom.win.sub_key", split it into win and sub_key */
      char *win = &key[sizeof(RECENT_GUI_GEOMETRY"gui.geom.")-1];
      char *sub_key = strchr(win, '.');
      if (sub_key) {
          *sub_key = '\0';
          sub_key++;
          window_geom_recent_read_pair(win, sub_key, value);
      }
  } else if (strcmp(key, RECENT_GUI_CONVERSATION_TABS"gui.conversation_tabs") == 0) {
      g_list_free_full(recent.conversation_tabs, g_free);
      recent.conversation_tabs = prefs_get_string_list(value);
  } else if (strcmp(key, RECENT_GUI_CONVERSATION_TABS_COLUMNS"gui.conversation_tabs_columns") == 0) {
      g_list_free_full(recent.conversation_tabs_columns, g_free);
      recent.conversation_tabs_columns = prefs_get_string_list(value);
  } else if (strcmp(key, RECENT_GUI_ENDPOINT_TABS"gui.endpoint_tabs") == 0) {
      g_list_free_full(recent.endpoint_tabs, g_free);
      recent.endpoint_tabs = prefs_get_string_list(value);
  } else if (strcmp(key, RECENT_GUI_ENDPOINT_TABS_COLUMNS"gui.endpoint_tabs_columns") == 0) {
      g_list_free_full(recent.endpoint_tabs_columns, g_free);
      recent.endpoint_tabs_columns = prefs_get_string_list(value);
  } else if (strcmp(key, RECENT_GUI_RLC_PDUS_FROM_MAC_FRAMES"gui.rlc_pdus_from_mac_frames") == 0) {
      parse_recent_boolean(value, &recent.gui_rlc_use_pdus_from_mac);
  } else if (strcmp(key, RECENT_KEY_COL_WIDTH"column.width") == 0) {
      col_l = prefs_get_string_list(value);
      if (col_l == NULL((void*)0))
          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;
      }
      recent_free_column_width_info(&recent);
      recent.col_width_list = NULL((void*)0);
      col_l_elt = g_list_first(col_l);
      while (col_l_elt) {
          cfmt = g_new(col_width_data, 1)((col_width_data *) g_malloc_n ((1), sizeof (col_width_data))
);
          /* Skip the column format, we don't use it anymore because the
           * column indices are in sync and the key since 4.4. Format is
           * still written for backwards compatibility.
           */
          col_l_elt      = col_l_elt->next;
          cfmt->width    = (int)strtol((const char *)col_l_elt->data, &p, 0);
          if (p == col_l_elt->data || (*p != '\0' && *p != ':')) {
              g_free(cfmt);
              return PREFS_SET_SYNTAX_ERR;    /* number was bad */
          }

          if (*p == ':') {
              cfmt->xalign = *(++p);
          } else {
              cfmt->xalign = COLUMN_XALIGN_DEFAULT0;
          }

          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);
  } else if (strcmp(key, RECENT_GUI_FILEOPEN_REMEMBERED_DIR"gui.fileopen_remembered_dir") == 0) {
      g_free(recent.gui_fileopen_remembered_dir);
      recent.gui_fileopen_remembered_dir = g_strdup(value)g_strdup_inline (value);
  } else if (strcmp(key, RECENT_GUI_TOOLBAR_SHOW"gui.additional_toolbar_show") == 0) {
      recent.gui_additional_toolbars = prefs_get_string_list(value);
  } else if (strcmp(key, RECENT_GUI_INTERFACE_TOOLBAR_SHOW"gui.interface_toolbar_show") == 0) {
      recent.interface_toolbars = prefs_get_string_list(value);
  } else if (strcmp(key, RECENT_GUI_TSD_THROUGHPUT_SHOW"gui.tsd_throughput_show") == 0) {
      parse_recent_boolean(value, &recent.gui_tsgd_throughput_show);
  } else if (strcmp(key, RECENT_GUI_TSD_GOODPUT_SHOW"gui.tsd_goodput_show") == 0) {
      parse_recent_boolean(value, &recent.gui_tsgd_goodput_show);
  } else if (strcmp(key, RECENT_GUI_TSD_MA_WINDOW_SIZE"gui.tsd_ma_window_size") == 0) {
      val_as_dbl = g_ascii_strtod(value, &p);
      if (p == value || *p != '\0') {
          return PREFS_SET_SYNTAX_ERR;      /* number was bad */
      }
      if (val_as_dbl <= 0) {
          return PREFS_SET_SYNTAX_ERR;      /* number must be positive */
      }
      recent.gui_tsgd_ma_window_size = val_as_dbl;
  } else {
      return PREFS_SET_NO_SUCH_PREF;
  }

  return PREFS_SET_OK;
1536}


1539/* set one user's recent file key/value pair */
1540static prefs_set_pref_e
1541read_set_recent_pair_dynamic(char *key, const char *value,
                           void *private_data _U___attribute__((unused)),
                           bool_Bool return_range_errors _U___attribute__((unused)))
1544{
  if (!g_utf8_validate(value, -1, NULL((void*)0))) {
      return PREFS_SET_SYNTAX_ERR;
  }
  if (strcmp(key, RECENT_KEY_CAPTURE_FILE"recent.capture_file") == 0) {
      add_menu_recent_capture_file(value, true1);
  } else if (strcmp(key, RECENT_KEY_DISPLAY_FILTER"recent.display_filter") == 0) {
      dfilter_combo_add_recent(value);
  } else if (strcmp(key, RECENT_KEY_CAPTURE_FILTER"recent.capture_filter") == 0) {
      recent_add_cfilter(NULL((void*)0), value);
  } else if (g_str_has_prefix(key, RECENT_KEY_CAPTURE_FILTER ".")(__builtin_constant_p ("recent.capture_filter" ".")? __extension__
 ({ const char * const __str = (key); const char * const __prefix
 = ("recent.capture_filter" "."); gboolean __result = (0); if
 (__str == ((void*)0) || __prefix == ((void*)0)) __result = (
g_str_has_prefix) (__str, __prefix); else { const size_t __str_len
 = strlen (((__str) + !(__str))); const size_t __prefix_len =
 strlen (((__prefix) + !(__prefix))); if (__str_len >= __prefix_len
) __result = memcmp (((__str) + !(__str)), ((__prefix) + !(__prefix
)), __prefix_len) == 0; } __result; }) : (g_str_has_prefix) (
key, "recent.capture_filter" ".") )) {
      /* strrchr() can't fail - string has a prefix that ends with a "." */
      recent_add_cfilter(strrchr(key, '.') + 1, value);
1557#ifdef HAVE_PCAP_REMOTE
  } else if (strcmp(key, RECENT_KEY_REMOTE_HOST"recent.remote_host") == 0) {
      capture_remote_combo_add_recent(value);
1560#endif
  }

  return PREFS_SET_OK;
1564}


1567/*
* 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.
*/
1573int
1574recent_set_arg(char *prefarg)
1575{
  char *p, *colonp;
  int ret;

  colonp = strchr(prefarg, ':');
  if (colonp == NULL((void*)0))
      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).
   */
  while (g_ascii_isspace(*p)((g_ascii_table[(guchar) (*p)] & G_ASCII_SPACE) != 0))
      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((void*)0), true1);
  *colonp = ':';     /* put the colon back */
  return ret;
1606}


1609/* opens the user's recent common file and read the first part */
1610bool_Bool
1611recent_read_static(char **rf_path_return, int *rf_errno_return)
1612{
  char       *rf_path;
  FILE       *rf;

  /* set defaults */
  recent.gui_geometry_main_x        =        20;
  recent.gui_geometry_main_y        =        20;
  recent.gui_geometry_main_width    = DEF_WIDTH750;
  recent.gui_geometry_main_height   = DEF_HEIGHT550;
  recent.gui_geometry_main_maximized=     false0;

  recent.gui_geometry_leftalign_actions = false0;

  recent.privs_warn_if_elevated = true1;
  recent.sys_warn_if_no_capture = true1;

  recent.col_width_list = NULL((void*)0);
  recent.gui_geometry_main = NULL((void*)0);
  recent.gui_geometry_main_master_split = NULL((void*)0);
  recent.gui_geometry_main_extra_split = NULL((void*)0);
  recent.gui_profile_switch_check_count = 1000;
  recent.gui_fileopen_remembered_dir = NULL((void*)0);

  /* Construct the pathname of the user's recent common file. */
  rf_path = get_persconffile_path(RECENT_COMMON_FILE_NAME"recent_common", false0);

  /* Read the user's recent common file, if it exists. */
  *rf_path_return = NULL((void*)0);
  if ((rf = ws_fopenfopen(rf_path, "r")) != NULL((void*)0)) {
      /* We succeeded in opening it; read it. */
      read_prefs_file(rf_path, rf, read_set_recent_common_pair_static, NULL((void*)0));

      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(*__errno_location ()) != ENOENT2) {
          *rf_errno_return = errno(*__errno_location ());
          *rf_path_return = rf_path;
          return false0;
      }
  }
  g_free(rf_path);
  return true1;
1657}



1661/* opens the user's recent file and read the first part */
1662bool_Bool
1663recent_read_profile_static(char **rf_path_return, int *rf_errno_return)
1664{
  char       *rf_path, *rf_common_path;
  FILE       *rf;

  /* set defaults */
  recent.main_toolbar_show         = true1;
  recent.filter_toolbar_show       = true1;
  recent.wireless_toolbar_show     = false0;
  recent.packet_list_show          = true1;
  recent.tree_view_show            = true1;
  recent.byte_view_show            = true1;
  recent.packet_diagram_show       = true1;
  recent.statusbar_show            = true1;
  recent.packet_list_colorize      = true1;
  recent.capture_auto_scroll       = true1;
  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;
  recent.gui_bytes_view            = BYTES_HEX;
  recent.gui_bytes_encoding        = BYTES_ENC_FROM_PACKET;
  recent.gui_allow_hover_selection = true1;
  recent.gui_follow_show           = SHOW_ASCII;
  recent.gui_follow_delta          = FOLLOW_DELTA_NONE;
  recent.gui_show_bytes_decode     = DecodeAsNone;
  recent.gui_show_bytes_show       = SHOW_ASCII;

  /* defaults for the TCP Stream Graph Dialog */
  recent.gui_tsgd_ma_window_size = 1.0;
  recent.gui_tsgd_throughput_show = true1;
  recent.gui_tsgd_goodput_show = false0;

  /* pane size of zero will autodetect */
  recent.gui_geometry_main_upper_pane   = 0;
  recent.gui_geometry_main_lower_pane   = 0;

  if (recent.gui_geometry_main) {
1
Assuming field 'gui_geometry_main' is null→
2
←
Taking false branch→
      g_free(recent.gui_geometry_main);
      recent.gui_geometry_main = NULL((void*)0);
  }

  if (recent.gui_geometry_main_master_split) {
3
←
Assuming field 'gui_geometry_main_master_split' is null→
4
←
Taking false branch→
      g_free(recent.gui_geometry_main_master_split);
      recent.gui_geometry_main_master_split = NULL((void*)0);
  }
  if (recent.gui_geometry_main_extra_split) {
5
←
Assuming field 'gui_geometry_main_extra_split' is null→
6
←
Taking false branch→
      g_free(recent.gui_geometry_main_extra_split);
      recent.gui_geometry_main_extra_split = NULL((void*)0);
  }

  if (recent.col_width_list) {
7
←
Assuming field 'col_width_list' is null→
8
←
Taking false branch→
      recent_free_column_width_info(&recent);
  }

  if (recent.gui_fileopen_remembered_dir) {
9
←
Assuming field 'gui_fileopen_remembered_dir' is null→
10
←
Taking false branch→
      g_free (recent.gui_fileopen_remembered_dir);
      recent.gui_fileopen_remembered_dir = NULL((void*)0);
  }

  if (recent.gui_additional_toolbars) {
11
←
Assuming field 'gui_additional_toolbars' is null→
12
←
Taking false branch→
      g_list_free_full (recent.gui_additional_toolbars, g_free);
      recent.gui_additional_toolbars = NULL((void*)0);
  }

  if (recent.interface_toolbars) {
13
←
Assuming field 'interface_toolbars' is null→
14
←
Taking false branch→
      g_list_free_full (recent.interface_toolbars, g_free);
      recent.interface_toolbars = NULL((void*)0);
  }

  /* Construct the pathname of the user's profile recent file. */
  rf_path = get_persconffile_path(RECENT_FILE_NAME"recent", true1);

  /* Read the user's recent file, if it exists. */
  *rf_path_return = NULL((void*)0);
  if ((rf = ws_fopenfopen(rf_path, "r")) != NULL((void*)0)) {
15
←
Taking true branch→
      /* We succeeded in opening it; read it. */
      read_prefs_file(rf_path, rf, read_set_recent_pair_static, NULL((void*)0));
      fclose(rf);

      /* XXX: The following code doesn't actually do anything since
       *  the "recent common file" always exists. Presumably the
       *  "if (!file_exists())" should actually be "if (file_exists())".
       *  However, I've left the code as is because this
       *  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
       */
      rf_common_path = get_persconffile_path(RECENT_COMMON_FILE_NAME"recent_common", false0);
      if (!file_exists(rf_common_path)) {
16
←
Assuming the condition is true→
17
←
Taking true branch→
          /* Read older common settings from recent file */
          rf = ws_fopenfopen(rf_path, "r");
18
←
Assuming pointer value is null→
19
←
Assuming that 'fopen' fails→
20
←
Value assigned to 'rf'→
          read_prefs_file(rf_path, rf, read_set_recent_common_pair_static, NULL((void*)0));
          fclose(rf);
21
←
Null pointer passed to 1st parameter expecting 'nonnull'
      }
      g_free(rf_common_path);
  } 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(*__errno_location ()) != ENOENT2) {
          *rf_errno_return = errno(*__errno_location ());
          *rf_path_return = rf_path;
          return false0;
      }
  }
  g_free(rf_path);
  return true1;
1771}

1773/* opens the user's recent file and read it out */
1774bool_Bool
1775recent_read_dynamic(char **rf_path_return, int *rf_errno_return)
1776{
  char       *rf_path;
  FILE       *rf;


  /* Construct the pathname of the user's recent common file. */
  rf_path = get_persconffile_path(RECENT_COMMON_FILE_NAME"recent_common", false0);
  if (!file_exists (rf_path)) {
      /* Recent common file does not exist, read from default recent */
      g_free (rf_path);
      rf_path = get_persconffile_path(RECENT_FILE_NAME"recent", false0);
  }

  /* Read the user's recent file, if it exists. */
  *rf_path_return = NULL((void*)0);
  if ((rf = ws_fopenfopen(rf_path, "r")) != NULL((void*)0)) {
      /* We succeeded in opening it; read it. */
      read_prefs_file(rf_path, rf, read_set_recent_pair_dynamic, NULL((void*)0));
1794#if 0
      /* set dfilter combobox to have an empty line */
      dfilter_combo_add_empty();
1797#endif
      /* We prepend new capture filters, so reverse them after adding
       * all to keep the latest first.
       */
      cfilter_recent_reverse_all();
1802#ifdef HAVE_PCAP_REMOTE
      remote_host_reverse();
1804#endif
      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(*__errno_location ()) != ENOENT2) {
          *rf_errno_return = errno(*__errno_location ());
          *rf_path_return = rf_path;
          return false0;
      }
  }
  g_free(rf_path);
  return true1;
1818}

1820void
1821recent_insert_column(int col)
1822{
  col_width_data *col_w;

  col_w = g_new(col_width_data, 1)((col_width_data *) g_malloc_n ((1), sizeof (col_width_data))
);
  col_w->width = -1;
  col_w->xalign = COLUMN_XALIGN_DEFAULT0;
  recent.col_width_list = g_list_insert(recent.col_width_list, col_w, col);
1829}

1831void
1832recent_remove_column(int col)
1833{
  GList *col_l = g_list_nth(recent.col_width_list, col);
  col_width_data *col_w;

  if (!col_l) return;

  col_w = (col_width_data*)col_l->data;

  if (col_w) {
      free_col_width_data(col_w);
  }

  recent.col_width_list = g_list_delete_link(recent.col_width_list, col_l);
1846}

1848int
1849recent_get_column_width(int col)
1850{
  col_width_data *col_w;

  col_w = g_list_nth_data(recent.col_width_list, col);
  if (col_w) {
      return col_w->width;
  } else {
      /* Make sure the recent column list isn't out of sync with the
       * number of columns (e.g., for a brand new profile.)
       */
      for (unsigned colnr = g_list_length(recent.col_width_list); colnr < g_list_length(prefs.col_list); colnr++) {
          recent_insert_column(colnr);
      }
  }

  return -1;
1866}

1868void
1869recent_set_column_width(int col, int width)
1870{
  col_width_data *col_w;

  col_w = g_list_nth_data(recent.col_width_list, col);
  if (col_w) {
      col_w->width = width;
  } else {
      /* Make sure the recent column list isn't out of sync with the
       * number of columns (e.g., for a brand new profile.)
       */
      for (unsigned colnr = g_list_length(recent.col_width_list); colnr < g_list_length(prefs.col_list); colnr++) {
          recent_insert_column(colnr);
      }
      col_w = g_list_nth_data(recent.col_width_list, col);
      if (col_w) {
          col_w->width = width;
      }
  }
1888}

1890char
1891recent_get_column_xalign(int col)
1892{
  col_width_data *col_w;

  col_w = g_list_nth_data(recent.col_width_list, col);
  if (col_w) {
      return col_w->xalign;
  } else {
      /* Make sure the recent column list isn't out of sync with the
       * number of columns (e.g., for a brand new profile.)
       */
      for (unsigned colnr = g_list_length(recent.col_width_list); colnr < g_list_length(prefs.col_list); colnr++) {
          recent_insert_column(colnr);
      }
  }

  return COLUMN_XALIGN_DEFAULT0;
1908}

1910void
1911recent_set_column_xalign(int col, char xalign)
1912{
  col_width_data *col_w;

  col_w = g_list_nth_data(recent.col_width_list, col);
  if (col_w) {
      col_w->xalign = xalign;
  } else {
      /* Make sure the recent column list isn't out of sync with the
       * number of columns (e.g., for a brand new profile.)
       */
      for (unsigned colnr = g_list_length(recent.col_width_list); colnr < g_list_length(prefs.col_list); colnr++) {
          recent_insert_column(colnr);
      }
      col_w = g_list_nth_data(recent.col_width_list, col);
      if (col_w) {
          col_w->xalign = xalign;
      }
  }
1930}

1932void
1933recent_init(void)
1934{
  memset(&recent, 0, sizeof(recent_settings_t));
1936}

1938void
1939recent_cleanup(void)
1940{
  recent_free_column_width_info(&recent);
  g_free(recent.gui_geometry_main);
  g_free(recent.gui_geometry_main_master_split);
  g_free(recent.gui_geometry_main_extra_split);
  g_free(recent.gui_fileopen_remembered_dir);
  g_list_free_full(recent.gui_additional_toolbars, g_free);
  g_list_free_full(recent.interface_toolbars, g_free);
  prefs_clear_string_list(recent.conversation_tabs);
  prefs_clear_string_list(recent.conversation_tabs_columns);
  prefs_clear_string_list(recent.endpoint_tabs);
  prefs_clear_string_list(recent.endpoint_tabs_columns);
  prefs_clear_string_list(recent.custom_colors);
1953}