Added the ethereal capture preferences to the preference file.
[obnox/wireshark/wip.git] / prefs.c
1 /* prefs.c
2  * Routines for handling preferences
3  *
4  * $Id: prefs.c,v 1.49 2001/04/13 14:59:28 jfoster Exp $
5  *
6  * Ethereal - Network traffic analyzer
7  * By Gerald Combs <gerald@zing.org>
8  * Copyright 1998 Gerald Combs
9  *
10  * 
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * as published by the Free Software Foundation; either version 2
14  * of the License, or (at your option) any later version.
15  * 
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  * 
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  */
25
26 #ifdef HAVE_CONFIG_H
27 # include "config.h"
28 #endif
29
30 #ifdef HAVE_SYS_TYPES_H
31 #include <sys/types.h>
32 #endif
33
34 #ifdef HAVE_DIRECT_H
35 #include <direct.h>
36 #endif
37
38 #include <stdlib.h>
39 #include <string.h>
40 #include <ctype.h>
41 #include <errno.h>
42
43 #ifdef HAVE_UNISTD_H
44 #include <unistd.h>
45 #endif
46
47 #ifdef HAVE_SYS_STAT_H
48 #include <sys/stat.h>
49 #endif
50
51 #include <epan.h>
52 #include <filesystem.h>
53 #include "globals.h"
54 #include "packet.h"
55 #include "file.h"
56 #include "prefs.h"
57 #include "proto.h"
58 #include "column.h"
59 #include "print.h"
60
61 #include "prefs-int.h"
62
63 /* Internal functions */
64 static int    set_pref(gchar*, gchar*);
65 static GList *get_string_list(gchar *);
66 static void   clear_string_list(GList *);
67 static void   free_col_info(e_prefs *);
68
69 #define PF_NAME "preferences"
70
71 #define GPF_PATH        DATAFILE_DIR "/ethereal.conf"
72
73 static gboolean init_prefs = TRUE;
74 static gchar *pf_path = NULL;
75
76 /*
77  * XXX - variables to allow us to attempt to interpret the first
78  * "mgcp.{tcp,udp}.port" in a preferences file as
79  * "mgcp.{tcp,udp}.gateway_port" and the second as
80  * "mgcp.{tcp,udp}.callagent_port".
81  */
82 static int mgcp_tcp_port_count;
83 static int mgcp_udp_port_count;
84
85 e_prefs prefs;
86
87 gchar   *gui_ptree_line_style_text[] =
88         { "NONE", "SOLID", "DOTTED", "TABBED", NULL };
89
90 gchar   *gui_ptree_expander_style_text[] =
91         { "NONE", "SQUARE", "TRIANGLE", "CIRCULAR", NULL };
92
93 gchar   *gui_hex_dump_highlight_style_text[] =
94         { "BOLD", "INVERSE", NULL };
95
96 /*
97  * List of modules with preference settings.
98  */
99 static GList *modules;
100
101 /*
102  * Register a module that will have preferences.
103  * Specify the name used for the module in the preferences file, the
104  * title used in the tab for it in a preferences dialog box, and a
105  * routine to call back when we apply the preferences.
106  */
107 module_t *
108 prefs_register_module(const char *name, const char *title,
109     void (*apply_cb)(void))
110 {
111         module_t *module;
112
113         module = g_malloc(sizeof (module_t));
114         module->name = name;
115         module->title = title;
116         module->apply_cb = apply_cb;
117         module->prefs = NULL;   /* no preferences, to start */
118         module->numprefs = 0;
119         module->prefs_changed = FALSE;
120
121         modules = g_list_append(modules, module);
122
123         return module;
124 }
125
126 /*
127  * Register that a protocol has preferences.
128  */
129 module_t *
130 prefs_register_protocol(int id, void (*apply_cb)(void))
131 {
132         return prefs_register_module(proto_get_protocol_filter_name(id),
133                                      proto_get_protocol_short_name(id),
134                                      apply_cb);
135 }
136
137 /*
138  * Find a module, given its name.
139  */
140 static gint
141 module_match(gconstpointer a, gconstpointer b)
142 {
143         const module_t *module = a;
144         const char *name = b;
145
146         return strcmp(name, module->name);
147 }
148
149 static module_t *
150 find_module(char *name)
151 {
152         GList *list_entry;
153
154         list_entry = g_list_find_custom(modules, name, module_match);
155         if (list_entry == NULL)
156                 return NULL;    /* no such module */
157         return (module_t *) list_entry->data;
158 }
159
160 typedef struct {
161         module_cb callback;
162         gpointer user_data;
163 } module_cb_arg_t;
164
165 static void
166 do_module_callback(gpointer data, gpointer user_data)
167 {
168         module_t *module = data;
169         module_cb_arg_t *arg = user_data;
170
171         (*arg->callback)(module, arg->user_data);
172 }
173
174 /*
175  * Call a callback function, with a specified argument, for each module.
176  */
177 void
178 prefs_module_foreach(module_cb callback, gpointer user_data)
179 {
180         module_cb_arg_t arg;
181
182         arg.callback = callback;
183         arg.user_data = user_data;
184         g_list_foreach(modules, do_module_callback, &arg);
185 }
186
187 static void
188 call_apply_cb(gpointer data, gpointer user_data)
189 {
190         module_t *module = data;
191
192         if (module->prefs_changed) {
193                 if (module->apply_cb != NULL)
194                         (*module->apply_cb)();
195                 module->prefs_changed = FALSE;
196         }
197 }
198
199 /*
200  * Call the "apply" callback function for each module if any of its
201  * preferences have changed, and then clear the flag saying its
202  * preferences have changed, as the module has been notified of that
203  * fact.
204  */
205 void
206 prefs_apply_all(void)
207 {
208         g_list_foreach(modules, call_apply_cb, NULL);
209 }
210
211 /*
212  * Register a preference in a module's list of preferences.
213  */
214 static pref_t *
215 register_preference(module_t *module, const char *name, const char *title,
216     const char *description)
217 {
218         pref_t *preference;
219
220         preference = g_malloc(sizeof (pref_t));
221         preference->name = name;
222         preference->title = title;
223         preference->description = description;
224         preference->ordinal = module->numprefs;
225
226         module->prefs = g_list_append(module->prefs, preference);
227         module->numprefs++;
228
229         return preference;
230 }
231
232 /*
233  * Find a preference in a module's list of preferences, given the module
234  * and the preference's name.
235  */
236 static gint
237 preference_match(gconstpointer a, gconstpointer b)
238 {
239         const pref_t *pref = a;
240         const char *name = b;
241
242         return strcmp(name, pref->name);
243 }
244
245 static struct preference *
246 find_preference(module_t *module, char *name)
247 {
248         GList *list_entry;
249
250         list_entry = g_list_find_custom(module->prefs, name, preference_match);
251         if (list_entry == NULL)
252                 return NULL;    /* no such preference */
253         return (struct preference *) list_entry->data;
254 }
255
256 /*
257  * Returns TRUE if the given protocol has registered preferences
258  */
259 gboolean
260 prefs_is_registered_protocol(char *name)
261 {
262         return (find_module(name) != NULL);
263 }
264
265 /*
266  * Returns the module title of a registered protocol
267  */
268 const char *
269 prefs_get_title_by_name(char *name)
270 {
271         module_t *m = find_module(name);
272         return  (m) ? m->title : NULL;
273 }
274
275 /*
276  * Register a preference with an unsigned integral value.
277  */
278 void
279 prefs_register_uint_preference(module_t *module, const char *name,
280     const char *title, const char *description, guint base, guint *var)
281 {
282         pref_t *preference;
283
284         preference = register_preference(module, name, title, description);
285         preference->type = PREF_UINT;
286         preference->varp.uint = var;
287         preference->info.base = base;
288 }
289
290 /*
291  * Register a preference with an Boolean value.
292  */
293 void
294 prefs_register_bool_preference(module_t *module, const char *name,
295     const char *title, const char *description, gboolean *var)
296 {
297         pref_t *preference;
298
299         preference = register_preference(module, name, title, description);
300         preference->type = PREF_BOOL;
301         preference->varp.bool = var;
302 }
303
304 /*
305  * Register a preference with an enumerated value.
306  */
307 void
308 prefs_register_enum_preference(module_t *module, const char *name,
309     const char *title, const char *description, gint *var,
310     const enum_val_t *enumvals, gboolean radio_buttons)
311 {
312         pref_t *preference;
313
314         preference = register_preference(module, name, title, description);
315         preference->type = PREF_ENUM;
316         preference->varp.enump = var;
317         preference->info.enum_info.enumvals = enumvals;
318         preference->info.enum_info.radio_buttons = radio_buttons;
319 }
320
321 /*
322  * Register a preference with a character-string value.
323  */
324 void
325 prefs_register_string_preference(module_t *module, const char *name,
326     const char *title, const char *description, char **var)
327 {
328         pref_t *preference;
329
330         preference = register_preference(module, name, title, description);
331         preference->type = PREF_STRING;
332         preference->varp.string = var;
333         preference->saved_val.string = NULL;
334 }
335
336 typedef struct {
337         pref_cb callback;
338         gpointer user_data;
339 } pref_cb_arg_t;
340
341 static void
342 do_pref_callback(gpointer data, gpointer user_data)
343 {
344         pref_t *pref = data;
345         pref_cb_arg_t *arg = user_data;
346
347         (*arg->callback)(pref, arg->user_data);
348 }
349
350 /*
351  * Call a callback function, with a specified argument, for each preference
352  * in a given module.
353  */
354 void
355 prefs_pref_foreach(module_t *module, pref_cb callback, gpointer user_data)
356 {
357         pref_cb_arg_t arg;
358
359         arg.callback = callback;
360         arg.user_data = user_data;
361         g_list_foreach(module->prefs, do_pref_callback, &arg);
362 }
363
364 /*
365  * Register all non-dissector modules' preferences.
366  */
367 void
368 prefs_register_modules(void)
369 {
370 }
371
372 /* Parse through a list of comma-separated, quoted strings.  Return a
373    list of the string data */
374 static GList *
375 get_string_list(gchar *str) {
376   enum { PRE_QUOT, IN_QUOT, POST_QUOT };
377
378   gint      state = PRE_QUOT, i = 0, j = 0;
379   gboolean  backslash = FALSE;
380   gchar     cur_c, *slstr = NULL;
381   GList    *sl = NULL;
382   
383   while ((cur_c = str[i]) != '\0') {
384     if (cur_c == '"' && ! backslash) {
385       switch (state) {
386         case PRE_QUOT:
387           state = IN_QUOT;
388           slstr = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
389           j = 0;
390           break;
391         case IN_QUOT:
392           state  = POST_QUOT;
393           slstr[j] = '\0';
394           sl = g_list_append(sl, slstr);
395           break;
396         case POST_QUOT:
397           clear_string_list(sl);
398           return NULL;
399           break;
400         default:
401           break;
402       }
403     } else if (cur_c == '\\' && ! backslash) {
404       backslash = TRUE;
405     } else if (cur_c == ',' && state == POST_QUOT) {
406       state = PRE_QUOT;
407     } else if (state == IN_QUOT && j < COL_MAX_LEN) {
408       slstr[j] = str[i];
409       j++;
410     }
411     i++;
412   }
413   if (state != POST_QUOT) {
414     clear_string_list(sl);
415   }
416   return(sl);
417 }
418
419 void
420 clear_string_list(GList *sl) {
421   GList *l = sl;
422   
423   while (l) {
424     g_free(l->data);
425     l = g_list_remove_link(l, l);
426   }
427 }
428
429 /*
430  * Takes a string, a pointer to an array of "enum_val_t"s, and a default gint
431  * value.
432  * The array must be terminated by an entry with a null "name" string.
433  * If the string matches a "name" strings in an entry, the value from that
434  * entry is returned. Otherwise, the default value that was passed as the
435  * third argument is returned.
436  */
437 gint
438 find_val_for_string(const char *needle, const enum_val_t *haystack,
439     gint default_value)
440 {
441         int i = 0;
442
443         while (haystack[i].name != NULL) {
444                 if (strcasecmp(needle, haystack[i].name) == 0) {
445                         return haystack[i].value;
446                 }
447                 i++;    
448         }
449         return default_value;
450 }
451
452 /* Takes an string and a pointer to an array of strings, and a default int value.
453  * The array must be terminated by a NULL string. If the string is found in the array
454  * of strings, the index of that string in the array is returned. Otherwise, the
455  * default value that was passed as the third argument is returned.
456  */
457 static int
458 find_index_from_string_array(char *needle, char **haystack, int default_value)
459 {
460         int i = 0;
461
462         while (haystack[i] != NULL) {
463                 if (strcmp(needle, haystack[i]) == 0) {
464                         return i;
465                 }
466                 i++;    
467         }
468         return default_value;
469 }
470
471 /* Preferences file format:
472  * - Configuration directives start at the beginning of the line, and 
473  *   are terminated with a colon.
474  * - Directives can be continued on the next line by preceding them with
475  *   whitespace.
476  *
477  * Example:
478
479 # This is a comment line
480 print.command: lpr
481 print.file: /a/very/long/path/
482         to/ethereal-out.ps
483  *
484  */
485
486 #define MAX_VAR_LEN    48
487 #define MAX_VAL_LEN  1024
488
489 #define DEF_NUM_COLS    6
490
491 static void read_prefs_file(const char *pf_path, FILE *pf);
492
493 /* Read the preferences file, fill in "prefs", and return a pointer to it.
494
495    If we got an error (other than "it doesn't exist") trying to read
496    the global preferences file, stuff the errno into "*gpf_errno_return"
497    and a pointer to the path of the file into "*gpf_path_return", and
498    return NULL.
499
500    If we got an error (other than "it doesn't exist") trying to read
501    the user's preferences file, stuff the errno into "*pf_errno_return"
502    and a pointer to the path of the file into "*pf_path_return", and
503    return NULL. */
504 e_prefs *
505 read_prefs(int *gpf_errno_return, char **gpf_path_return,
506            int *pf_errno_return, char **pf_path_return)
507 {
508   int       i;
509   FILE     *pf;
510   fmt_data *cfmt;
511   gchar    *col_fmt[] = {"No.",      "%m", "Time",        "%t",
512                          "Source",   "%s", "Destination", "%d",
513                          "Protocol", "%p", "Info",        "%i"};
514
515   
516   if (init_prefs) {
517     /* Initialize preferences to wired-in default values.
518        They may be overridded by the global preferences file or the
519        user's preferences file. */
520     init_prefs       = FALSE;
521     prefs.pr_format  = PR_FMT_TEXT;
522     prefs.pr_dest    = PR_DEST_CMD;
523     prefs.pr_file    = g_strdup("ethereal.out");
524     prefs.pr_cmd     = g_strdup("lpr");
525     prefs.col_list = NULL;
526     for (i = 0; i < DEF_NUM_COLS; i++) {
527       cfmt = (fmt_data *) g_malloc(sizeof(fmt_data));
528       cfmt->title = g_strdup(col_fmt[i * 2]);
529       cfmt->fmt   = g_strdup(col_fmt[(i * 2) + 1]);
530       prefs.col_list = g_list_append(prefs.col_list, cfmt);
531     }
532     prefs.num_cols  = DEF_NUM_COLS;
533     prefs.st_client_fg.pixel =     0;
534     prefs.st_client_fg.red   = 32767;
535     prefs.st_client_fg.green =     0;
536     prefs.st_client_fg.blue  =     0;
537     prefs.st_client_bg.pixel = 65535;
538     prefs.st_client_bg.red   = 65535;
539     prefs.st_client_bg.green = 65535;
540     prefs.st_client_bg.blue  = 65535;
541     prefs.st_server_fg.pixel =     0;
542     prefs.st_server_fg.red   =     0;
543     prefs.st_server_fg.green =     0;
544     prefs.st_server_fg.blue  = 32767;
545     prefs.st_server_bg.pixel = 65535;
546     prefs.st_server_bg.red   = 65535;
547     prefs.st_server_bg.green = 65535;
548     prefs.st_server_bg.blue  = 65535;
549     prefs.gui_scrollbar_on_right = TRUE;
550     prefs.gui_plist_sel_browse = FALSE;
551     prefs.gui_ptree_sel_browse = FALSE;
552     prefs.gui_ptree_line_style = 0;
553     prefs.gui_ptree_expander_style = 1;
554     prefs.gui_hex_dump_highlight_style = 1;
555 #ifdef WIN32
556     prefs.gui_font_name = g_strdup("-*-lucida console-medium-r-*-*-*-100-*-*-*-*-*-*");
557 #else
558     /*
559      * XXX - for now, we make the initial font name a pattern that matches
560      * only ISO 8859/1 fonts, so that we don't match 2-byte fonts such
561      * as ISO 10646 fonts.
562      *
563      * Users in locales using other one-byte fonts will have to choose
564      * a different font from the preferences dialog - or put the font
565      * selection in the global preferences file to make that font the
566      * default for all users who don't explicitly specify a different
567      * font.
568      *
569      * Making this a font set rather than a font has two problems:
570      *
571      *  1) as far as I know, you can't select font sets with the
572      *     font selection dialog;
573      *
574      *  2) if you use a font set, the text to be drawn must be a
575      *     multi-byte string in the appropriate locale, but
576      *     Ethereal does *NOT* guarantee that's the case - in
577      *     the hex-dump window, each character in the text portion
578      *     of the display must be a *single* byte, and in the
579      *     packet-list and protocol-tree windows, text extracted
580      *     from the packet is not necessarily in the right format.
581      *
582      * "Doing this right" may, for the packet-list and protocol-tree
583      * windows, require that dissectors know what the locale is
584      * *AND* know what locale and text representation is used in
585      * the packets they're dissecting, and may be impossible in
586      * the hex-dump window (except by punting and displaying only
587      * ASCII characters).
588      *
589      * GTK+ 2.0 may simplify part of the problem, as it will, as I
590      * understand it, use UTF-8-encoded Unicode as its internal
591      * character set; however, we'd still have to know whatever
592      * character set and encoding is used in the packet (which
593      * may differ for different protocols, e.g. SMB might use
594      * PC code pages for some strings and Unicode for others, whilst
595      * NFS might use some UNIX character set encoding, e.g. ISO 8859/x,
596      * or one of the EUC character sets for Asian languages, or one
597      * of the other multi-byte character sets, or UTF-8, or...).
598      *
599      * I.e., as far as I can tell, "internationalizing" the packet-list,
600      * protocol-tree, and hex-dump windows involves a lot more than, say,
601      * just using font sets rather than fonts.
602      */
603     prefs.gui_font_name = g_strdup("-*-fixed-medium-r-semicondensed-*-*-120-*-*-*-*-iso8859-1");
604 #endif
605     prefs.gui_marked_fg.pixel = 65535;
606     prefs.gui_marked_fg.red   = 65535;
607     prefs.gui_marked_fg.green = 65535;
608     prefs.gui_marked_fg.blue  = 65535;
609     prefs.gui_marked_bg.pixel =     0;
610     prefs.gui_marked_bg.red   =     0;
611     prefs.gui_marked_bg.green =     0;
612     prefs.gui_marked_bg.blue  =     0;
613
614 /* set the default values for the capture dialog box */
615     prefs.capture_prom_mode   =     0;
616     prefs.capture_real_time   =     0;
617     prefs.capture_auto_scroll =     0;
618     prefs.capture_name_resolve=     1;
619
620   }
621
622   /* Read the global preferences file, if it exists. */
623   *gpf_path_return = NULL;
624   if ((pf = fopen(GPF_PATH, "r")) != NULL) {
625     /* We succeeded in opening it; read it. */
626     read_prefs_file(GPF_PATH, pf);
627     fclose(pf);
628   } else {
629     /* We failed to open it.  If we failed for some reason other than
630        "it doesn't exist", return the errno and the pathname, so our
631        caller can report the error. */
632     if (errno != ENOENT) {
633       *gpf_errno_return = errno;
634       *gpf_path_return = GPF_PATH;
635     }
636   }
637
638   /* Construct the pathname of the user's preferences file. */
639   if (! pf_path) {
640     pf_path = (gchar *) g_malloc(strlen(get_home_dir()) + strlen(PF_DIR) +
641       strlen(PF_NAME) + 4);
642     sprintf(pf_path, "%s/%s/%s", get_home_dir(), PF_DIR, PF_NAME);
643   }
644     
645   /* Read the user's preferences file, if it exists. */
646   *pf_path_return = NULL;
647   if ((pf = fopen(pf_path, "r")) != NULL) {
648     /* We succeeded in opening it; read it. */
649     read_prefs_file(pf_path, pf);
650     fclose(pf);
651   } else {
652     /* We failed to open it.  If we failed for some reason other than
653        "it doesn't exist", return the errno and the pathname, so our
654        caller can report the error. */
655     if (errno != ENOENT) {
656       *pf_errno_return = errno;
657       *pf_path_return = pf_path;
658     }
659   }
660   
661   return &prefs;
662 }
663
664 static void
665 read_prefs_file(const char *pf_path, FILE *pf)
666 {
667   enum { START, IN_VAR, PRE_VAL, IN_VAL, IN_SKIP };
668   gchar     cur_var[MAX_VAR_LEN], cur_val[MAX_VAL_LEN];
669   int       got_c, state = START;
670   gboolean  got_val = FALSE;
671   gint      var_len = 0, val_len = 0, fline = 1, pline = 1;
672
673   /*
674    * Start out the counters of "mgcp.{tcp,udp}.port" entries we've
675    * seen.
676    */
677   mgcp_tcp_port_count = 0;
678   mgcp_udp_port_count = 0;
679
680   while ((got_c = getc(pf)) != EOF) {
681     if (got_c == '\n') {
682       state = START;
683       fline++;
684       continue;
685     }
686     if (var_len >= MAX_VAR_LEN) {
687       g_warning ("%s line %d: Variable too long", pf_path, fline);
688       state = IN_SKIP;
689       var_len = 0;
690       continue;
691     }
692     if (val_len >= MAX_VAL_LEN) {
693       g_warning ("%s line %d: Value too long", pf_path, fline);
694       state = IN_SKIP;
695       var_len = 0;
696       continue;
697     }
698     
699     switch (state) {
700       case START:
701         if (isalnum(got_c)) {
702           if (var_len > 0) {
703             if (got_val) {
704               cur_var[var_len] = '\0';
705               cur_val[val_len] = '\0';
706               switch (set_pref(cur_var, cur_val)) {
707
708               case PREFS_SET_SYNTAX_ERR:
709                 g_warning ("%s line %d: Syntax error", pf_path, pline);
710                 break;
711
712               case PREFS_SET_NO_SUCH_PREF:
713                 g_warning ("%s line %d: No such preference \"%s\"", pf_path,
714                                 pline, cur_var);
715                 break;
716               }
717             } else {
718               g_warning ("%s line %d: Incomplete preference", pf_path, pline);
719             }
720           }
721           state      = IN_VAR;
722           got_val    = FALSE;
723           cur_var[0] = got_c;
724           var_len    = 1;
725           pline = fline;
726         } else if (isspace(got_c) && var_len > 0 && got_val) {
727           state = PRE_VAL;
728         } else if (got_c == '#') {
729           state = IN_SKIP;
730         } else {
731           g_warning ("%s line %d: Malformed line", pf_path, fline);
732         }
733         break;
734       case IN_VAR:
735         if (got_c != ':') {
736           cur_var[var_len] = got_c;
737           var_len++;
738         } else {
739           state   = PRE_VAL;
740           val_len = 0;
741           got_val = TRUE;
742         }
743         break;
744       case PRE_VAL:
745         if (!isspace(got_c)) {
746           state = IN_VAL;
747           cur_val[val_len] = got_c;
748           val_len++;
749         }
750         break;
751       case IN_VAL:
752         if (got_c != '#')  {
753           cur_val[val_len] = got_c;
754           val_len++;
755         } else {
756           while (isspace((guchar)cur_val[val_len]) && val_len > 0)
757             val_len--;
758           state = IN_SKIP;
759         }
760         break;
761     }
762   }
763   if (var_len > 0) {
764     if (got_val) {
765       cur_var[var_len] = '\0';
766       cur_val[val_len] = '\0';
767       switch (set_pref(cur_var, cur_val)) {
768
769       case PREFS_SET_SYNTAX_ERR:
770         g_warning ("%s line %d: Syntax error", pf_path, pline);
771         break;
772
773       case PREFS_SET_NO_SUCH_PREF:
774         g_warning ("%s line %d: No such preference \"%s\"", pf_path,
775                         pline, cur_var);
776         break;
777       }
778     } else {
779       g_warning ("%s line %d: Incomplete preference", pf_path, pline);
780     }
781   }
782 }
783
784 /*
785  * Given a string of the form "<pref name>:<pref value>", as might appear
786  * as an argument to a "-o" option, parse it and set the preference in
787  * question.  Return an indication of whether it succeeded or failed
788  * in some fashion.
789  */
790 int
791 prefs_set_pref(char *prefarg)
792 {
793         u_char *p, *colonp;
794         int ret;
795
796         /*
797          * Set the counters of "mgcp.{tcp,udp}.port" entries we've
798          * seen to values that keep us from trying to interpret tham
799          * as "mgcp.{tcp,udp}.gateway_port" or "mgcp.{tcp,udp}.callagent_port",
800          * as, from the command line, we have no way of guessing which
801          * the user had in mind.
802          */
803         mgcp_tcp_port_count = -1;
804         mgcp_udp_port_count = -1;
805
806         colonp = strchr(prefarg, ':');
807         if (colonp == NULL)
808                 return PREFS_SET_SYNTAX_ERR;
809
810         p = colonp;
811         *p++ = '\0';
812
813         /*
814          * Skip over any white space (there probably won't be any, but
815          * as we allow it in the preferences file, we might as well
816          * allow it here).
817          */
818         while (isspace(*p))
819                 p++;
820         if (*p == '\0') {
821                 /*
822                  * Put the colon back, so if our caller uses, in an
823                  * error message, the string they passed us, the message
824                  * looks correct.
825                  */
826                 *colonp = ':';
827                 return PREFS_SET_SYNTAX_ERR;
828         }
829
830         ret = set_pref(prefarg, p);
831         *colonp = ':';  /* put the colon back */
832         return ret;
833 }
834
835 #define PRS_PRINT_FMT    "print.format"
836 #define PRS_PRINT_DEST   "print.destination"
837 #define PRS_PRINT_FILE   "print.file"
838 #define PRS_PRINT_CMD    "print.command"
839 #define PRS_COL_FMT      "column.format"
840 #define PRS_STREAM_CL_FG "stream.client.fg"
841 #define PRS_STREAM_CL_BG "stream.client.bg"
842 #define PRS_STREAM_SR_FG "stream.server.fg"
843 #define PRS_STREAM_SR_BG "stream.server.bg"
844 #define PRS_GUI_SCROLLBAR_ON_RIGHT "gui.scrollbar_on_right"
845 #define PRS_GUI_PLIST_SEL_BROWSE "gui.packet_list_sel_browse"
846 #define PRS_GUI_PTREE_SEL_BROWSE "gui.protocol_tree_sel_browse"
847 #define PRS_GUI_PTREE_LINE_STYLE "gui.protocol_tree_line_style"
848 #define PRS_GUI_PTREE_EXPANDER_STYLE "gui.protocol_tree_expander_style"
849 #define PRS_GUI_HEX_DUMP_HIGHLIGHT_STYLE "gui.hex_dump_highlight_style"
850 #define PRS_GUI_FONT_NAME "gui.font_name"
851 #define PRS_GUI_MARKED_FG "gui.marked_frame.fg"
852 #define PRS_GUI_MARKED_BG "gui.marked_frame.bg"
853
854 /*  values for the capture dialog box */
855 #define PRS_CAP_REAL_TIME "capture.real_time_update"
856 #define PRS_CAP_PROM_MODE "capture.prom_mode"
857 #define PRS_CAP_AUTO_SCROLL "capture.auto_scroll"
858 #define PRS_CAP_NAME_RESOLVE "capture.name_resolve"
859
860 #define RED_COMPONENT(x)   ((((x) >> 16) & 0xff) * 65535 / 255)
861 #define GREEN_COMPONENT(x) ((((x) >>  8) & 0xff) * 65535 / 255)
862 #define BLUE_COMPONENT(x)   (((x)        & 0xff) * 65535 / 255)
863
864 static gchar *pr_formats[] = { "text", "postscript" };
865 static gchar *pr_dests[]   = { "command", "file" };
866
867 static int
868 set_pref(gchar *pref_name, gchar *value)
869 {
870   GList    *col_l;
871   gint      llen;
872   fmt_data *cfmt;
873   unsigned long int cval;
874   guint    uval;
875   gboolean bval;
876   gint     enum_val;
877   char     *p;
878   gchar    *dotp;
879   module_t *module;
880   pref_t   *pref;
881
882   if (strcmp(pref_name, PRS_PRINT_FMT) == 0) {
883     if (strcmp(value, pr_formats[PR_FMT_TEXT]) == 0) {
884       prefs.pr_format = PR_FMT_TEXT;
885     } else if (strcmp(value, pr_formats[PR_FMT_PS]) == 0) {
886       prefs.pr_format = PR_FMT_PS;
887     } else {
888       return PREFS_SET_SYNTAX_ERR;
889     }
890   } else if (strcmp(pref_name, PRS_PRINT_DEST) == 0) {
891     if (strcmp(value, pr_dests[PR_DEST_CMD]) == 0) {
892       prefs.pr_dest = PR_DEST_CMD;
893     } else if (strcmp(value, pr_dests[PR_DEST_FILE]) == 0) {
894       prefs.pr_dest = PR_DEST_FILE;
895     } else {
896       return PREFS_SET_SYNTAX_ERR;
897     }
898   } else if (strcmp(pref_name, PRS_PRINT_FILE) == 0) {
899     if (prefs.pr_file) g_free(prefs.pr_file);
900     prefs.pr_file = g_strdup(value);
901   } else if (strcmp(pref_name, PRS_PRINT_CMD) == 0) {
902     if (prefs.pr_cmd) g_free(prefs.pr_cmd);
903     prefs.pr_cmd = g_strdup(value);
904   } else if (strcmp(pref_name, PRS_COL_FMT) == 0) {
905     if ((col_l = get_string_list(value)) && (g_list_length(col_l) % 2) == 0) {
906       free_col_info(&prefs);
907       prefs.col_list = NULL;
908       llen             = g_list_length(col_l);
909       prefs.num_cols   = llen / 2;
910       col_l = g_list_first(col_l);
911       while(col_l) {
912         cfmt = (fmt_data *) g_malloc(sizeof(fmt_data));
913         cfmt->title    = g_strdup(col_l->data);
914         col_l          = col_l->next;
915         cfmt->fmt      = g_strdup(col_l->data);
916         col_l          = col_l->next;
917         prefs.col_list = g_list_append(prefs.col_list, cfmt);
918       }
919       /* To do: else print some sort of error? */
920     }
921     clear_string_list(col_l);
922   } else if (strcmp(pref_name, PRS_STREAM_CL_FG) == 0) {
923     cval = strtoul(value, NULL, 16);
924     prefs.st_client_fg.pixel = 0;
925     prefs.st_client_fg.red   = RED_COMPONENT(cval);
926     prefs.st_client_fg.green = GREEN_COMPONENT(cval);
927     prefs.st_client_fg.blue  = BLUE_COMPONENT(cval);
928   } else if (strcmp(pref_name, PRS_STREAM_CL_BG) == 0) {
929     cval = strtoul(value, NULL, 16);
930     prefs.st_client_bg.pixel = 0;
931     prefs.st_client_bg.red   = RED_COMPONENT(cval);
932     prefs.st_client_bg.green = GREEN_COMPONENT(cval);
933     prefs.st_client_bg.blue  = BLUE_COMPONENT(cval);
934   } else if (strcmp(pref_name, PRS_STREAM_SR_FG) == 0) {
935     cval = strtoul(value, NULL, 16);
936     prefs.st_server_fg.pixel = 0;
937     prefs.st_server_fg.red   = RED_COMPONENT(cval);
938     prefs.st_server_fg.green = GREEN_COMPONENT(cval);
939     prefs.st_server_fg.blue  = BLUE_COMPONENT(cval);
940   } else if (strcmp(pref_name, PRS_STREAM_SR_BG) == 0) {
941     cval = strtoul(value, NULL, 16);
942     prefs.st_server_bg.pixel = 0;
943     prefs.st_server_bg.red   = RED_COMPONENT(cval);
944     prefs.st_server_bg.green = GREEN_COMPONENT(cval);
945     prefs.st_server_bg.blue  = BLUE_COMPONENT(cval);
946   } else if (strcmp(pref_name, PRS_GUI_SCROLLBAR_ON_RIGHT) == 0) {
947     if (strcmp(value, "TRUE") == 0) {
948             prefs.gui_scrollbar_on_right = TRUE;
949     }
950     else {
951             prefs.gui_scrollbar_on_right = FALSE;
952     }
953   } else if (strcmp(pref_name, PRS_GUI_PLIST_SEL_BROWSE) == 0) {
954     if (strcmp(value, "TRUE") == 0) {
955             prefs.gui_plist_sel_browse = TRUE;
956     }
957     else {
958             prefs.gui_plist_sel_browse = FALSE;
959     }
960   } else if (strcmp(pref_name, PRS_GUI_PTREE_SEL_BROWSE) == 0) {
961     if (strcmp(value, "TRUE") == 0) {
962             prefs.gui_ptree_sel_browse = TRUE;
963     }
964     else {
965             prefs.gui_ptree_sel_browse = FALSE;
966     }
967   } else if (strcmp(pref_name, PRS_GUI_PTREE_LINE_STYLE) == 0) {
968           prefs.gui_ptree_line_style =
969                   find_index_from_string_array(value, gui_ptree_line_style_text, 0);
970   } else if (strcmp(pref_name, PRS_GUI_PTREE_EXPANDER_STYLE) == 0) {
971           prefs.gui_ptree_expander_style =
972                   find_index_from_string_array(value, gui_ptree_expander_style_text, 1);
973   } else if (strcmp(pref_name, PRS_GUI_HEX_DUMP_HIGHLIGHT_STYLE) == 0) {
974           prefs.gui_hex_dump_highlight_style =
975                   find_index_from_string_array(value, gui_hex_dump_highlight_style_text, 1);
976   } else if (strcmp(pref_name, PRS_GUI_FONT_NAME) == 0) {
977           if (prefs.gui_font_name != NULL)
978                 g_free(prefs.gui_font_name);
979           prefs.gui_font_name = g_strdup(value);
980   } else if (strcmp(pref_name, PRS_GUI_MARKED_FG) == 0) {
981     cval = strtoul(value, NULL, 16);
982     prefs.gui_marked_fg.pixel = 0;
983     prefs.gui_marked_fg.red   = RED_COMPONENT(cval);
984     prefs.gui_marked_fg.green = GREEN_COMPONENT(cval);
985     prefs.gui_marked_fg.blue  = BLUE_COMPONENT(cval);
986   } else if (strcmp(pref_name, PRS_GUI_MARKED_BG) == 0) {
987     cval = strtoul(value, NULL, 16);
988     prefs.gui_marked_bg.pixel = 0;
989     prefs.gui_marked_bg.red   = RED_COMPONENT(cval);
990     prefs.gui_marked_bg.green = GREEN_COMPONENT(cval);
991     prefs.gui_marked_bg.blue  = BLUE_COMPONENT(cval);
992
993 /* handle the capture options */ 
994   } else if (strcmp(pref_name, PRS_CAP_PROM_MODE) == 0) {
995     prefs.capture_prom_mode = ((strcmp(value, "TRUE") == 0)?TRUE:FALSE); 
996  
997   } else if (strcmp(pref_name, PRS_CAP_REAL_TIME) == 0) {
998     prefs.capture_real_time = ((strcmp(value, "TRUE") == 0)?TRUE:FALSE); 
999
1000   } else if (strcmp(pref_name, PRS_CAP_AUTO_SCROLL) == 0) {
1001     prefs.capture_auto_scroll = ((strcmp(value, "TRUE") == 0)?TRUE:FALSE); 
1002  
1003   } else if (strcmp(pref_name, PRS_CAP_NAME_RESOLVE) == 0) {
1004     prefs.capture_name_resolve = ((strcmp(value, "TRUE") == 0)?TRUE:FALSE); 
1005
1006   } else {
1007     /* To which module does this preference belong? */
1008     dotp = strchr(pref_name, '.');
1009     if (dotp == NULL)
1010       return PREFS_SET_SYNTAX_ERR;      /* no ".", so no module/name separator */
1011     *dotp = '\0';               /* separate module and preference name */
1012     module = find_module(pref_name);
1013
1014     /*
1015      * XXX - "Diameter" rather than "diameter" was used in earlier
1016      * versions of Ethereal; if we didn't find the module, and its name
1017      * was "Diameter", look for "diameter" instead.
1018      */
1019     if (module == NULL && strcmp(pref_name, "Diameter") == 0)
1020       module = find_module("diameter");
1021     *dotp = '.';                /* put the preference string back */
1022     if (module == NULL)
1023       return PREFS_SET_NO_SUCH_PREF;    /* no such module */
1024     dotp++;                     /* skip past separator to preference name */
1025     pref = find_preference(module, dotp);
1026
1027     /*
1028      * XXX - "mgcp.display raw text toggle" and "mgcp.display dissect tree"
1029      * rather than "mgcp.display_raw_text" and "mgcp.display_dissect_tree"
1030      * were used in earlier versions of Ethereal; if we didn't find the
1031      * preference, it was an MGCP preference, and its name was
1032      * "display raw text toggle" or "display dissect tree", look for
1033      * "display_raw_text" or "display_dissect_tree" instead.
1034      *
1035      * "mgcp.tcp.port" and "mgcp.udp.port" are harder to handle, as both
1036      * the gateway and callagent ports were given those names; we interpret
1037      * the first as "mgcp.{tcp,udp}.gateway_port" and the second as
1038      * "mgcp.{tcp,udp}.callagent_port", as that's the order in which
1039      * they were registered by the MCCP dissector and thus that's the
1040      * order in which they were written to the preferences file.  (If
1041      * we're not reading the preferences file, but are handling stuff
1042      * from a "-o" command-line option, we have no clue which the user
1043      * had in mind - they should have used "mgcp.{tcp,udp}.gateway_port"
1044      * or "mgcp.{tcp,udp}.callagent_port" instead.)
1045      */
1046     if (pref == NULL && strncmp(pref_name, "mgcp.", 5) == 0) {
1047       if (strcmp(dotp, "display raw text toggle") == 0)
1048         pref = find_preference(module, "display_raw_text");
1049       else if (strcmp(dotp, "display dissect tree") == 0)
1050         pref = find_preference(module, "display_dissect_tree");
1051       else if (strcmp(dotp, "tcp.port") == 0) {
1052         mgcp_tcp_port_count++;
1053         if (mgcp_tcp_port_count == 1) {
1054           /* It's the first one */
1055           pref = find_preference(module, "tcp.gateway_port");
1056         } else if (mgcp_tcp_port_count == 2) {
1057           /* It's the second one */
1058           pref = find_preference(module, "tcp.callagent_port");
1059         }
1060         /* Otherwise it's from the command line, and we don't bother
1061            mapping it. */
1062       } else if (strcmp(dotp, "udp.port") == 0) {
1063         mgcp_udp_port_count++;
1064         if (mgcp_udp_port_count == 1) {
1065           /* It's the first one */
1066           pref = find_preference(module, "udp.gateway_port");
1067         } else if (mgcp_udp_port_count == 2) {
1068           /* It's the second one */
1069           pref = find_preference(module, "udp.callagent_port");
1070         }
1071         /* Otherwise it's from the command line, and we don't bother
1072            mapping it. */
1073       }
1074     }
1075     if (pref == NULL)
1076       return PREFS_SET_NO_SUCH_PREF;    /* no such preference */
1077
1078     switch (pref->type) {
1079
1080     case PREF_UINT:
1081       uval = strtoul(value, &p, pref->info.base);
1082       if (p == value || *p != '\0')
1083         return PREFS_SET_SYNTAX_ERR;    /* number was bad */
1084       if (*pref->varp.uint != uval) {
1085         module->prefs_changed = TRUE;
1086         *pref->varp.uint = uval;
1087       }
1088       break;
1089
1090     case PREF_BOOL:
1091       /* XXX - give an error if it's neither "true" nor "false"? */
1092       if (strcasecmp(value, "true") == 0)
1093         bval = TRUE;
1094       else
1095         bval = FALSE;
1096       if (*pref->varp.bool != bval) {
1097         module->prefs_changed = TRUE;
1098         *pref->varp.bool = bval;
1099       }
1100       break;
1101
1102     case PREF_ENUM:
1103       /* XXX - give an error if it doesn't match? */
1104       enum_val = find_val_for_string(value,
1105                                         pref->info.enum_info.enumvals, 1);
1106       if (*pref->varp.enump != enum_val) {
1107         module->prefs_changed = TRUE;
1108         *pref->varp.enump = enum_val;
1109       }
1110       break;
1111
1112     case PREF_STRING:
1113       if (*pref->varp.string == NULL || strcmp(*pref->varp.string, value) != 0) {
1114         module->prefs_changed = TRUE;
1115         if (*pref->varp.string != NULL)
1116           g_free(*pref->varp.string);
1117         *pref->varp.string = g_strdup(value);
1118       }
1119       break;
1120     }
1121   }
1122   
1123   return PREFS_SET_OK;
1124 }
1125
1126 typedef struct {
1127         module_t *module;
1128         FILE    *pf;
1129 } write_pref_arg_t;
1130
1131 /*
1132  * Write out a single preference.
1133  */
1134 static void
1135 write_pref(gpointer data, gpointer user_data)
1136 {
1137         pref_t *pref = data;
1138         write_pref_arg_t *arg = user_data;
1139         const enum_val_t *enum_valp;
1140         const char *val_string;
1141
1142         fprintf(arg->pf, "\n# %s\n", pref->description);
1143
1144         switch (pref->type) {
1145
1146         case PREF_UINT:
1147                 switch (pref->info.base) {
1148
1149                 case 10:
1150                         fprintf(arg->pf, "# A decimal number.\n");
1151                         fprintf(arg->pf, "%s.%s: %u\n", arg->module->name,
1152                             pref->name, *pref->varp.uint);
1153                         break;
1154
1155                 case 8:
1156                         fprintf(arg->pf, "# An octal number.\n");
1157                         fprintf(arg->pf, "%s.%s: %#o\n", arg->module->name,
1158                             pref->name, *pref->varp.uint);
1159                         break;
1160
1161                 case 16:
1162                         fprintf(arg->pf, "# A hexadecimal number.\n");
1163                         fprintf(arg->pf, "%s.%s: %#x\n", arg->module->name,
1164                             pref->name, *pref->varp.uint);
1165                         break;
1166                 }
1167                 break;
1168
1169         case PREF_BOOL:
1170                 fprintf(arg->pf, "# TRUE or FALSE (case-insensitive).\n");
1171                 fprintf(arg->pf, "%s.%s: %s\n", arg->module->name, pref->name,
1172                     *pref->varp.bool ? "TRUE" : "FALSE");
1173                 break;
1174
1175         case PREF_ENUM:
1176                 fprintf(arg->pf, "# One of: ");
1177                 enum_valp = pref->info.enum_info.enumvals;
1178                 val_string = NULL;
1179                 while (enum_valp->name != NULL) {
1180                         if (enum_valp->value == *pref->varp.enump)
1181                                 val_string = enum_valp->name;
1182                         fprintf(arg->pf, "%s", enum_valp->name);
1183                         enum_valp++;
1184                         if (enum_valp->name == NULL)
1185                                 fprintf(arg->pf, "\n");
1186                         else
1187                                 fprintf(arg->pf, ", ");
1188                 }
1189                 fprintf(arg->pf, "# (case-insensitive).\n");
1190                 fprintf(arg->pf, "%s.%s: %s\n", arg->module->name, pref->name,
1191                     val_string);
1192                 break;
1193
1194         case PREF_STRING:
1195                 fprintf(arg->pf, "# A string.\n");
1196                 fprintf(arg->pf, "%s.%s: %s\n", arg->module->name, pref->name,
1197                     *pref->varp.string);
1198                 break;
1199         }
1200 }
1201
1202 static void
1203 write_module_prefs(gpointer data, gpointer user_data)
1204 {
1205         write_pref_arg_t arg;
1206
1207         arg.module = data;
1208         arg.pf = user_data;
1209         g_list_foreach(arg.module->prefs, write_pref, &arg);
1210 }
1211
1212 /* Write out "prefs" to the user's preferences file, and return 0.
1213
1214    If we got an error, stuff a pointer to the path of the preferences file
1215    into "*pf_path_return", and return the errno. */
1216 int
1217 write_prefs(char **pf_path_return)
1218 {
1219   FILE        *pf;
1220   struct stat  s_buf;
1221   
1222   /* To do:
1223    * - Split output lines longer than MAX_VAL_LEN
1224    * - Create a function for the preference directory check/creation
1225    *   so that duplication can be avoided with filter.c
1226    */
1227
1228   if (! pf_path) {
1229     pf_path = (gchar *) g_malloc(strlen(get_home_dir()) + strlen(PF_DIR) +
1230       strlen(PF_NAME) + 4);
1231   }
1232
1233   sprintf(pf_path, "%s/%s", get_home_dir(), PF_DIR);
1234   if (stat(pf_path, &s_buf) != 0)
1235 #ifdef WIN32
1236     mkdir(pf_path);
1237 #else
1238     mkdir(pf_path, 0755);
1239 #endif
1240
1241   sprintf(pf_path, "%s/%s/%s", get_home_dir(), PF_DIR, PF_NAME);
1242   if ((pf = fopen(pf_path, "w")) == NULL) {
1243     *pf_path_return = pf_path;
1244     return errno;
1245   }
1246     
1247   fputs("# Configuration file for Ethereal " VERSION ".\n"
1248     "#\n"
1249     "# This file is regenerated each time preferences are saved within\n"
1250     "# Ethereal.  Making manual changes should be safe, however.\n"
1251     "\n"
1252     "######## Printing ########\n"
1253     "\n", pf);
1254
1255   fprintf (pf, "# Can be one of \"text\" or \"postscript\".\n"
1256     "print.format: %s\n\n", pr_formats[prefs.pr_format]);
1257
1258   fprintf (pf, "# Can be one of \"command\" or \"file\".\n"
1259     "print.destination: %s\n\n", pr_dests[prefs.pr_dest]);
1260
1261   fprintf (pf, "# This is the file that gets written to when the "
1262     "destination is set to \"file\"\n"
1263     "%s: %s\n\n", PRS_PRINT_FILE, prefs.pr_file);
1264
1265   fprintf (pf, "# Output gets piped to this command when the destination "
1266     "is set to \"command\"\n"
1267     "%s: %s\n\n", PRS_PRINT_CMD, prefs.pr_cmd);
1268
1269   fprintf (pf, "# Packet list column format.  Each pair of strings consists "
1270     "of a column title \n# and its format.\n"
1271     "%s: %s\n\n", PRS_COL_FMT, col_format_to_pref_str());
1272
1273   fprintf (pf, "# TCP stream window color preferences.  Each value is a six "
1274     "digit hexadecimal value in the form rrggbb.\n");
1275   fprintf (pf, "%s: %02x%02x%02x\n", PRS_STREAM_CL_FG,
1276     (prefs.st_client_fg.red * 255 / 65535),
1277     (prefs.st_client_fg.green * 255 / 65535),
1278     (prefs.st_client_fg.blue * 255 / 65535));
1279   fprintf (pf, "%s: %02x%02x%02x\n", PRS_STREAM_CL_BG,
1280     (prefs.st_client_bg.red * 255 / 65535),
1281     (prefs.st_client_bg.green * 255 / 65535),
1282     (prefs.st_client_bg.blue * 255 / 65535));
1283   fprintf (pf, "%s: %02x%02x%02x\n", PRS_STREAM_SR_FG,
1284     (prefs.st_server_fg.red * 255 / 65535),
1285     (prefs.st_server_fg.green * 255 / 65535),
1286     (prefs.st_server_fg.blue * 255 / 65535));
1287   fprintf (pf, "%s: %02x%02x%02x\n", PRS_STREAM_SR_BG,
1288     (prefs.st_server_bg.red * 255 / 65535),
1289     (prefs.st_server_bg.green * 255 / 65535),
1290     (prefs.st_server_bg.blue * 255 / 65535));
1291
1292   fprintf(pf, "\n# Vertical scrollbars should be on right side? TRUE/FALSE\n");
1293   fprintf(pf, PRS_GUI_SCROLLBAR_ON_RIGHT ": %s\n",
1294                   prefs.gui_scrollbar_on_right == TRUE ? "TRUE" : "FALSE");
1295
1296   fprintf(pf, "\n# Packet-list selection bar can be used to browse w/o selecting? TRUE/FALSE\n");
1297   fprintf(pf, PRS_GUI_PLIST_SEL_BROWSE ": %s\n",
1298                   prefs.gui_plist_sel_browse == TRUE ? "TRUE" : "FALSE");
1299
1300   fprintf(pf, "\n# Protocol-tree selection bar can be used to browse w/o selecting? TRUE/FALSE\n");
1301   fprintf(pf, PRS_GUI_PTREE_SEL_BROWSE ": %s\n",
1302                   prefs.gui_ptree_sel_browse == TRUE ? "TRUE" : "FALSE");
1303
1304   fprintf(pf, "\n# Protocol-tree line style. One of: NONE, SOLID, DOTTED, TABBED\n");
1305   fprintf(pf, PRS_GUI_PTREE_LINE_STYLE ": %s\n",
1306                   gui_ptree_line_style_text[prefs.gui_ptree_line_style]);
1307
1308   fprintf(pf, "\n# Protocol-tree expander style. One of: NONE, SQUARE, TRIANGLE, CIRCULAR\n");
1309   fprintf(pf, PRS_GUI_PTREE_EXPANDER_STYLE ": %s\n",
1310                   gui_ptree_expander_style_text[prefs.gui_ptree_expander_style]);
1311
1312   fprintf(pf, "\n# Hex dump highlight style. One of: BOLD, INVERSE\n");
1313   fprintf(pf, PRS_GUI_HEX_DUMP_HIGHLIGHT_STYLE ": %s\n",
1314                   gui_hex_dump_highlight_style_text[prefs.gui_hex_dump_highlight_style]);
1315
1316   fprintf(pf, "\n# Font name for packet list, protocol tree, and hex dump panes.\n");
1317   fprintf(pf, PRS_GUI_FONT_NAME ": %s\n", prefs.gui_font_name);
1318
1319   fprintf (pf, "\n# Color preferences for a marked frame.  Each value is a six "
1320     "digit hexadecimal value in the form rrggbb.\n");
1321   fprintf (pf, "%s: %02x%02x%02x\n", PRS_GUI_MARKED_FG,
1322     (prefs.gui_marked_fg.red * 255 / 65535),
1323     (prefs.gui_marked_fg.green * 255 / 65535),
1324     (prefs.gui_marked_fg.blue * 255 / 65535));
1325   fprintf (pf, "%s: %02x%02x%02x\n", PRS_GUI_MARKED_BG,
1326     (prefs.gui_marked_bg.red * 255 / 65535),
1327     (prefs.gui_marked_bg.green * 255 / 65535),
1328     (prefs.gui_marked_bg.blue * 255 / 65535));
1329
1330 /* write the capture options */
1331   fprintf(pf, "\n# Capture in promiscuous mode? TRUE/FALSE\n");
1332   fprintf(pf, PRS_CAP_PROM_MODE ": %s\n",
1333                   prefs.capture_prom_mode == TRUE ? "TRUE" : "FALSE");
1334
1335   fprintf(pf, "\n# Update packet list in real time during capture? TRUE/FALSE\n");
1336   fprintf(pf, PRS_CAP_REAL_TIME ": %s\n",
1337                   prefs.capture_real_time == TRUE ? "TRUE" : "FALSE");
1338
1339   fprintf(pf, "\n# scroll packet list during capture? TRUE/FALSE\n");
1340   fprintf(pf, PRS_CAP_AUTO_SCROLL ": %s\n",
1341                   prefs.capture_auto_scroll == TRUE ? "TRUE" : "FALSE");
1342
1343   fprintf(pf, "\n# resolve names  during capture? TRUE/FALSE\n");
1344   fprintf(pf, PRS_CAP_NAME_RESOLVE ": %s\n",
1345                   prefs.capture_name_resolve == TRUE ? "TRUE" : "FALSE");
1346
1347   g_list_foreach(modules, write_module_prefs, pf);
1348
1349   fclose(pf);
1350
1351   /* XXX - catch I/O errors (e.g. "ran out of disk space") and return
1352      an error indication, or maybe write to a new preferences file and
1353      rename that file on top of the old one only if there are not I/O
1354      errors. */
1355   return 0;
1356 }
1357
1358 /* Copy a set of preferences. */
1359 void
1360 copy_prefs(e_prefs *dest, e_prefs *src)
1361 {
1362   fmt_data *src_cfmt, *dest_cfmt;
1363   GList *entry;
1364
1365   dest->pr_format = src->pr_format;
1366   dest->pr_dest = src->pr_dest;
1367   dest->pr_file = g_strdup(src->pr_file);
1368   dest->pr_cmd = g_strdup(src->pr_cmd);
1369   dest->col_list = NULL;
1370   for (entry = src->col_list; entry != NULL; entry = g_list_next(entry)) {
1371     src_cfmt = entry->data;
1372     dest_cfmt = (fmt_data *) g_malloc(sizeof(fmt_data));
1373     dest_cfmt->title = g_strdup(src_cfmt->title);
1374     dest_cfmt->fmt = g_strdup(src_cfmt->fmt);
1375     dest->col_list = g_list_append(dest->col_list, dest_cfmt);
1376   }
1377   dest->num_cols = src->num_cols;
1378   dest->st_client_fg = src->st_client_fg;
1379   dest->st_client_bg = src->st_client_bg;
1380   dest->st_server_fg = src->st_server_fg;
1381   dest->st_server_bg = src->st_server_bg;
1382   dest->gui_scrollbar_on_right = src->gui_scrollbar_on_right;
1383   dest->gui_plist_sel_browse = src->gui_plist_sel_browse;
1384   dest->gui_ptree_sel_browse = src->gui_ptree_sel_browse;
1385   dest->gui_ptree_line_style = src->gui_ptree_line_style;
1386   dest->gui_ptree_expander_style = src->gui_ptree_expander_style;
1387   dest->gui_hex_dump_highlight_style = src->gui_hex_dump_highlight_style;
1388   dest->gui_font_name = g_strdup(src->gui_font_name);
1389   dest->gui_marked_fg = src->gui_marked_fg;
1390   dest->gui_marked_bg = src->gui_marked_bg;
1391 /*  values for the capture dialog box */
1392   dest->capture_prom_mode = src->capture_prom_mode;
1393   dest->capture_real_time = src->capture_real_time;
1394   dest->capture_auto_scroll = src->capture_auto_scroll;
1395   dest->capture_name_resolve = src->capture_name_resolve;
1396
1397 }
1398
1399 /* Free a set of preferences. */
1400 void
1401 free_prefs(e_prefs *pr)
1402 {
1403   if (pr->pr_file != NULL) {
1404     g_free(pr->pr_file);
1405     pr->pr_file = NULL;
1406   }
1407   if (pr->pr_cmd != NULL) {
1408     g_free(pr->pr_cmd);
1409     pr->pr_cmd = NULL;
1410   }
1411   free_col_info(pr);
1412   if (pr->gui_font_name != NULL) {
1413     g_free(pr->gui_font_name);
1414     pr->gui_font_name = NULL;
1415   }
1416 }
1417
1418 static void
1419 free_col_info(e_prefs *pr)
1420 {
1421   fmt_data *cfmt;
1422
1423   while (pr->col_list != NULL) {
1424     cfmt = pr->col_list->data;
1425     g_free(cfmt->title);
1426     g_free(cfmt->fmt);
1427     g_free(cfmt);
1428     pr->col_list = g_list_remove_link(pr->col_list, pr->col_list);
1429   }
1430   g_list_free(pr->col_list);
1431   pr->col_list = NULL;
1432 }