Support for "-N" flag enabling selected forms of name resolution, from
[obnox/wireshark/wip.git] / prefs.c
1 /* prefs.c
2  * Routines for handling preferences
3  *
4  * $Id: prefs.c,v 1.51 2001/05/31 08:36:41 guy 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.name_resolve        = PREFS_RESOLV_ALL;
619   }
620
621   /* Read the global preferences file, if it exists. */
622   *gpf_path_return = NULL;
623   if ((pf = fopen(GPF_PATH, "r")) != NULL) {
624     /* We succeeded in opening it; read it. */
625     read_prefs_file(GPF_PATH, pf);
626     fclose(pf);
627   } else {
628     /* We failed to open it.  If we failed for some reason other than
629        "it doesn't exist", return the errno and the pathname, so our
630        caller can report the error. */
631     if (errno != ENOENT) {
632       *gpf_errno_return = errno;
633       *gpf_path_return = GPF_PATH;
634     }
635   }
636
637   /* Construct the pathname of the user's preferences file. */
638   if (! pf_path) {
639     pf_path = (gchar *) g_malloc(strlen(get_home_dir()) + strlen(PF_DIR) +
640       strlen(PF_NAME) + 4);
641     sprintf(pf_path, "%s/%s/%s", get_home_dir(), PF_DIR, PF_NAME);
642   }
643     
644   /* Read the user's preferences file, if it exists. */
645   *pf_path_return = NULL;
646   if ((pf = fopen(pf_path, "r")) != NULL) {
647     /* We succeeded in opening it; read it. */
648     read_prefs_file(pf_path, pf);
649     fclose(pf);
650   } else {
651     /* We failed to open it.  If we failed for some reason other than
652        "it doesn't exist", return the errno and the pathname, so our
653        caller can report the error. */
654     if (errno != ENOENT) {
655       *pf_errno_return = errno;
656       *pf_path_return = pf_path;
657     }
658   }
659   
660   return &prefs;
661 }
662
663 static void
664 read_prefs_file(const char *pf_path, FILE *pf)
665 {
666   enum { START, IN_VAR, PRE_VAL, IN_VAL, IN_SKIP };
667   gchar     cur_var[MAX_VAR_LEN], cur_val[MAX_VAL_LEN];
668   int       got_c, state = START;
669   gboolean  got_val = FALSE;
670   gint      var_len = 0, val_len = 0, fline = 1, pline = 1;
671
672   /*
673    * Start out the counters of "mgcp.{tcp,udp}.port" entries we've
674    * seen.
675    */
676   mgcp_tcp_port_count = 0;
677   mgcp_udp_port_count = 0;
678
679   while ((got_c = getc(pf)) != EOF) {
680     if (got_c == '\n') {
681       state = START;
682       fline++;
683       continue;
684     }
685     if (var_len >= MAX_VAR_LEN) {
686       g_warning ("%s line %d: Variable too long", pf_path, fline);
687       state = IN_SKIP;
688       var_len = 0;
689       continue;
690     }
691     if (val_len >= MAX_VAL_LEN) {
692       g_warning ("%s line %d: Value too long", pf_path, fline);
693       state = IN_SKIP;
694       var_len = 0;
695       continue;
696     }
697     
698     switch (state) {
699       case START:
700         if (isalnum(got_c)) {
701           if (var_len > 0) {
702             if (got_val) {
703               cur_var[var_len] = '\0';
704               cur_val[val_len] = '\0';
705               switch (set_pref(cur_var, cur_val)) {
706
707               case PREFS_SET_SYNTAX_ERR:
708                 g_warning ("%s line %d: Syntax error", pf_path, pline);
709                 break;
710
711               case PREFS_SET_NO_SUCH_PREF:
712                 g_warning ("%s line %d: No such preference \"%s\"", pf_path,
713                                 pline, cur_var);
714                 break;
715               }
716             } else {
717               g_warning ("%s line %d: Incomplete preference", pf_path, pline);
718             }
719           }
720           state      = IN_VAR;
721           got_val    = FALSE;
722           cur_var[0] = got_c;
723           var_len    = 1;
724           pline = fline;
725         } else if (isspace(got_c) && var_len > 0 && got_val) {
726           state = PRE_VAL;
727         } else if (got_c == '#') {
728           state = IN_SKIP;
729         } else {
730           g_warning ("%s line %d: Malformed line", pf_path, fline);
731         }
732         break;
733       case IN_VAR:
734         if (got_c != ':') {
735           cur_var[var_len] = got_c;
736           var_len++;
737         } else {
738           state   = PRE_VAL;
739           val_len = 0;
740           got_val = TRUE;
741         }
742         break;
743       case PRE_VAL:
744         if (!isspace(got_c)) {
745           state = IN_VAL;
746           cur_val[val_len] = got_c;
747           val_len++;
748         }
749         break;
750       case IN_VAL:
751         if (got_c != '#')  {
752           cur_val[val_len] = got_c;
753           val_len++;
754         } else {
755           while (isspace((guchar)cur_val[val_len]) && val_len > 0)
756             val_len--;
757           state = IN_SKIP;
758         }
759         break;
760     }
761   }
762   if (var_len > 0) {
763     if (got_val) {
764       cur_var[var_len] = '\0';
765       cur_val[val_len] = '\0';
766       switch (set_pref(cur_var, cur_val)) {
767
768       case PREFS_SET_SYNTAX_ERR:
769         g_warning ("%s line %d: Syntax error", pf_path, pline);
770         break;
771
772       case PREFS_SET_NO_SUCH_PREF:
773         g_warning ("%s line %d: No such preference \"%s\"", pf_path,
774                         pline, cur_var);
775         break;
776       }
777     } else {
778       g_warning ("%s line %d: Incomplete preference", pf_path, pline);
779     }
780   }
781 }
782
783 /*
784  * Given a string of the form "<pref name>:<pref value>", as might appear
785  * as an argument to a "-o" option, parse it and set the preference in
786  * question.  Return an indication of whether it succeeded or failed
787  * in some fashion.
788  */
789 int
790 prefs_set_pref(char *prefarg)
791 {
792         u_char *p, *colonp;
793         int ret;
794
795         /*
796          * Set the counters of "mgcp.{tcp,udp}.port" entries we've
797          * seen to values that keep us from trying to interpret tham
798          * as "mgcp.{tcp,udp}.gateway_port" or "mgcp.{tcp,udp}.callagent_port",
799          * as, from the command line, we have no way of guessing which
800          * the user had in mind.
801          */
802         mgcp_tcp_port_count = -1;
803         mgcp_udp_port_count = -1;
804
805         colonp = strchr(prefarg, ':');
806         if (colonp == NULL)
807                 return PREFS_SET_SYNTAX_ERR;
808
809         p = colonp;
810         *p++ = '\0';
811
812         /*
813          * Skip over any white space (there probably won't be any, but
814          * as we allow it in the preferences file, we might as well
815          * allow it here).
816          */
817         while (isspace(*p))
818                 p++;
819         if (*p == '\0') {
820                 /*
821                  * Put the colon back, so if our caller uses, in an
822                  * error message, the string they passed us, the message
823                  * looks correct.
824                  */
825                 *colonp = ':';
826                 return PREFS_SET_SYNTAX_ERR;
827         }
828
829         ret = set_pref(prefarg, p);
830         *colonp = ':';  /* put the colon back */
831         return ret;
832 }
833
834 #define PRS_PRINT_FMT    "print.format"
835 #define PRS_PRINT_DEST   "print.destination"
836 #define PRS_PRINT_FILE   "print.file"
837 #define PRS_PRINT_CMD    "print.command"
838 #define PRS_COL_FMT      "column.format"
839 #define PRS_STREAM_CL_FG "stream.client.fg"
840 #define PRS_STREAM_CL_BG "stream.client.bg"
841 #define PRS_STREAM_SR_FG "stream.server.fg"
842 #define PRS_STREAM_SR_BG "stream.server.bg"
843 #define PRS_GUI_SCROLLBAR_ON_RIGHT "gui.scrollbar_on_right"
844 #define PRS_GUI_PLIST_SEL_BROWSE "gui.packet_list_sel_browse"
845 #define PRS_GUI_PTREE_SEL_BROWSE "gui.protocol_tree_sel_browse"
846 #define PRS_GUI_PTREE_LINE_STYLE "gui.protocol_tree_line_style"
847 #define PRS_GUI_PTREE_EXPANDER_STYLE "gui.protocol_tree_expander_style"
848 #define PRS_GUI_HEX_DUMP_HIGHLIGHT_STYLE "gui.hex_dump_highlight_style"
849 #define PRS_GUI_FONT_NAME "gui.font_name"
850 #define PRS_GUI_MARKED_FG "gui.marked_frame.fg"
851 #define PRS_GUI_MARKED_BG "gui.marked_frame.bg"
852
853 /*
854  * This applies to more than just captures, so it's not "capture.name_resolve";
855  * "capture.name_resolve" is supported on input for backwards compatibility.
856  *
857  * It's not a preference for a particular part of Ethereal, it's used all
858  * over the place, so its name doesn't have two components.
859  */
860 #define PRS_NAME_RESOLVE "name_resolve"
861 #define PRS_CAP_NAME_RESOLVE "capture.name_resolve"
862
863 /*  values for the capture dialog box */
864 #define PRS_CAP_REAL_TIME "capture.real_time_update"
865 #define PRS_CAP_PROM_MODE "capture.prom_mode"
866 #define PRS_CAP_AUTO_SCROLL "capture.auto_scroll"
867
868 #define RED_COMPONENT(x)   ((((x) >> 16) & 0xff) * 65535 / 255)
869 #define GREEN_COMPONENT(x) ((((x) >>  8) & 0xff) * 65535 / 255)
870 #define BLUE_COMPONENT(x)   (((x)        & 0xff) * 65535 / 255)
871
872 static gchar *pr_formats[] = { "text", "postscript" };
873 static gchar *pr_dests[]   = { "command", "file" };
874
875 typedef struct {
876   char    letter;
877   guint32 value;
878 } name_resolve_opt_t;
879
880 static name_resolve_opt_t name_resolve_opt[] = {
881   { 'm', PREFS_RESOLV_MAC },
882   { 'n', PREFS_RESOLV_NETWORK },
883   { 't', PREFS_RESOLV_TRANSPORT },
884 };
885
886 #define N_NAME_RESOLVE_OPT      (sizeof name_resolve_opt / sizeof name_resolve_opt[0])
887
888 static char *
889 name_resolve_to_string(guint32 name_resolve)
890 {
891   static char string[N_NAME_RESOLVE_OPT+1];
892   char *p;
893   int i;
894   gboolean all_opts_set = TRUE;
895
896   if (name_resolve == PREFS_RESOLV_NONE)
897     return "FALSE";
898   p = &string[0];
899   for (i = 0; i < N_NAME_RESOLVE_OPT; i++) {
900     if (name_resolve & name_resolve_opt[i].value)
901       *p++ =  name_resolve_opt[i].letter;
902     else
903       all_opts_set = FALSE;
904   }
905   *p = '\0';
906   if (all_opts_set)
907     return "TRUE";
908   return string;
909 }
910
911 char
912 string_to_name_resolve(char *string, guint32 *name_resolve)
913 {
914   char c;
915   int i;
916
917   *name_resolve = 0;
918   while ((c = *string++) != '\0') {
919     for (i = 0; i < N_NAME_RESOLVE_OPT; i++) {
920       if (c == name_resolve_opt[i].letter) {
921         *name_resolve |= name_resolve_opt[i].value;
922         break;
923       }
924     }
925     if (i == N_NAME_RESOLVE_OPT) {
926       /*
927        * Unrecognized letter.
928        */
929       return c;
930     }
931   }
932   return '\0';
933 }
934
935 static int
936 set_pref(gchar *pref_name, gchar *value)
937 {
938   GList    *col_l;
939   gint      llen;
940   fmt_data *cfmt;
941   unsigned long int cval;
942   guint    uval;
943   gboolean bval;
944   gint     enum_val;
945   char     *p;
946   gchar    *dotp;
947   module_t *module;
948   pref_t   *pref;
949
950   if (strcmp(pref_name, PRS_PRINT_FMT) == 0) {
951     if (strcmp(value, pr_formats[PR_FMT_TEXT]) == 0) {
952       prefs.pr_format = PR_FMT_TEXT;
953     } else if (strcmp(value, pr_formats[PR_FMT_PS]) == 0) {
954       prefs.pr_format = PR_FMT_PS;
955     } else {
956       return PREFS_SET_SYNTAX_ERR;
957     }
958   } else if (strcmp(pref_name, PRS_PRINT_DEST) == 0) {
959     if (strcmp(value, pr_dests[PR_DEST_CMD]) == 0) {
960       prefs.pr_dest = PR_DEST_CMD;
961     } else if (strcmp(value, pr_dests[PR_DEST_FILE]) == 0) {
962       prefs.pr_dest = PR_DEST_FILE;
963     } else {
964       return PREFS_SET_SYNTAX_ERR;
965     }
966   } else if (strcmp(pref_name, PRS_PRINT_FILE) == 0) {
967     if (prefs.pr_file) g_free(prefs.pr_file);
968     prefs.pr_file = g_strdup(value);
969   } else if (strcmp(pref_name, PRS_PRINT_CMD) == 0) {
970     if (prefs.pr_cmd) g_free(prefs.pr_cmd);
971     prefs.pr_cmd = g_strdup(value);
972   } else if (strcmp(pref_name, PRS_COL_FMT) == 0) {
973     if ((col_l = get_string_list(value)) && (g_list_length(col_l) % 2) == 0) {
974       free_col_info(&prefs);
975       prefs.col_list = NULL;
976       llen             = g_list_length(col_l);
977       prefs.num_cols   = llen / 2;
978       col_l = g_list_first(col_l);
979       while(col_l) {
980         cfmt = (fmt_data *) g_malloc(sizeof(fmt_data));
981         cfmt->title    = g_strdup(col_l->data);
982         col_l          = col_l->next;
983         cfmt->fmt      = g_strdup(col_l->data);
984         col_l          = col_l->next;
985         prefs.col_list = g_list_append(prefs.col_list, cfmt);
986       }
987       /* To do: else print some sort of error? */
988     }
989     clear_string_list(col_l);
990   } else if (strcmp(pref_name, PRS_STREAM_CL_FG) == 0) {
991     cval = strtoul(value, NULL, 16);
992     prefs.st_client_fg.pixel = 0;
993     prefs.st_client_fg.red   = RED_COMPONENT(cval);
994     prefs.st_client_fg.green = GREEN_COMPONENT(cval);
995     prefs.st_client_fg.blue  = BLUE_COMPONENT(cval);
996   } else if (strcmp(pref_name, PRS_STREAM_CL_BG) == 0) {
997     cval = strtoul(value, NULL, 16);
998     prefs.st_client_bg.pixel = 0;
999     prefs.st_client_bg.red   = RED_COMPONENT(cval);
1000     prefs.st_client_bg.green = GREEN_COMPONENT(cval);
1001     prefs.st_client_bg.blue  = BLUE_COMPONENT(cval);
1002   } else if (strcmp(pref_name, PRS_STREAM_SR_FG) == 0) {
1003     cval = strtoul(value, NULL, 16);
1004     prefs.st_server_fg.pixel = 0;
1005     prefs.st_server_fg.red   = RED_COMPONENT(cval);
1006     prefs.st_server_fg.green = GREEN_COMPONENT(cval);
1007     prefs.st_server_fg.blue  = BLUE_COMPONENT(cval);
1008   } else if (strcmp(pref_name, PRS_STREAM_SR_BG) == 0) {
1009     cval = strtoul(value, NULL, 16);
1010     prefs.st_server_bg.pixel = 0;
1011     prefs.st_server_bg.red   = RED_COMPONENT(cval);
1012     prefs.st_server_bg.green = GREEN_COMPONENT(cval);
1013     prefs.st_server_bg.blue  = BLUE_COMPONENT(cval);
1014   } else if (strcmp(pref_name, PRS_GUI_SCROLLBAR_ON_RIGHT) == 0) {
1015     if (strcasecmp(value, "true") == 0) {
1016             prefs.gui_scrollbar_on_right = TRUE;
1017     }
1018     else {
1019             prefs.gui_scrollbar_on_right = FALSE;
1020     }
1021   } else if (strcmp(pref_name, PRS_GUI_PLIST_SEL_BROWSE) == 0) {
1022     if (strcasecmp(value, "true") == 0) {
1023             prefs.gui_plist_sel_browse = TRUE;
1024     }
1025     else {
1026             prefs.gui_plist_sel_browse = FALSE;
1027     }
1028   } else if (strcmp(pref_name, PRS_GUI_PTREE_SEL_BROWSE) == 0) {
1029     if (strcasecmp(value, "true") == 0) {
1030             prefs.gui_ptree_sel_browse = TRUE;
1031     }
1032     else {
1033             prefs.gui_ptree_sel_browse = FALSE;
1034     }
1035   } else if (strcmp(pref_name, PRS_GUI_PTREE_LINE_STYLE) == 0) {
1036           prefs.gui_ptree_line_style =
1037                   find_index_from_string_array(value, gui_ptree_line_style_text, 0);
1038   } else if (strcmp(pref_name, PRS_GUI_PTREE_EXPANDER_STYLE) == 0) {
1039           prefs.gui_ptree_expander_style =
1040                   find_index_from_string_array(value, gui_ptree_expander_style_text, 1);
1041   } else if (strcmp(pref_name, PRS_GUI_HEX_DUMP_HIGHLIGHT_STYLE) == 0) {
1042           prefs.gui_hex_dump_highlight_style =
1043                   find_index_from_string_array(value, gui_hex_dump_highlight_style_text, 1);
1044   } else if (strcmp(pref_name, PRS_GUI_FONT_NAME) == 0) {
1045           if (prefs.gui_font_name != NULL)
1046                 g_free(prefs.gui_font_name);
1047           prefs.gui_font_name = g_strdup(value);
1048   } else if (strcmp(pref_name, PRS_GUI_MARKED_FG) == 0) {
1049     cval = strtoul(value, NULL, 16);
1050     prefs.gui_marked_fg.pixel = 0;
1051     prefs.gui_marked_fg.red   = RED_COMPONENT(cval);
1052     prefs.gui_marked_fg.green = GREEN_COMPONENT(cval);
1053     prefs.gui_marked_fg.blue  = BLUE_COMPONENT(cval);
1054   } else if (strcmp(pref_name, PRS_GUI_MARKED_BG) == 0) {
1055     cval = strtoul(value, NULL, 16);
1056     prefs.gui_marked_bg.pixel = 0;
1057     prefs.gui_marked_bg.red   = RED_COMPONENT(cval);
1058     prefs.gui_marked_bg.green = GREEN_COMPONENT(cval);
1059     prefs.gui_marked_bg.blue  = BLUE_COMPONENT(cval);
1060
1061 /* handle the capture options */ 
1062   } else if (strcmp(pref_name, PRS_CAP_PROM_MODE) == 0) {
1063     prefs.capture_prom_mode = ((strcasecmp(value, "true") == 0)?TRUE:FALSE); 
1064  
1065   } else if (strcmp(pref_name, PRS_CAP_REAL_TIME) == 0) {
1066     prefs.capture_real_time = ((strcasecmp(value, "true") == 0)?TRUE:FALSE); 
1067
1068   } else if (strcmp(pref_name, PRS_CAP_AUTO_SCROLL) == 0) {
1069     prefs.capture_auto_scroll = ((strcasecmp(value, "true") == 0)?TRUE:FALSE); 
1070  
1071 /* handle the global options */
1072   } else if (strcmp(pref_name, PRS_NAME_RESOLVE) == 0 ||
1073              strcmp(pref_name, PRS_CAP_NAME_RESOLVE) == 0) {
1074     /*
1075      * "TRUE" and "FALSE", for backwards compatibility, are synonyms for
1076      * PREFS_RESOLV_ALL and PREFS_RESOLV_NONE.
1077      *
1078      * Otherwise, we treat it as a list of name types we want to resolve.
1079      */
1080     if (strcasecmp(value, "true") == 0)
1081       prefs.name_resolve = PREFS_RESOLV_ALL;
1082     else if (strcasecmp(value, "false") == 0)
1083       prefs.name_resolve = PREFS_RESOLV_NONE;
1084     else {
1085       prefs.name_resolve = PREFS_RESOLV_NONE;   /* start out with none set */
1086       if (string_to_name_resolve(value, &prefs.name_resolve) != '\0')
1087         return PREFS_SET_SYNTAX_ERR;
1088     }
1089   } else {
1090     /* To which module does this preference belong? */
1091     dotp = strchr(pref_name, '.');
1092     if (dotp == NULL)
1093       return PREFS_SET_SYNTAX_ERR;      /* no ".", so no module/name separator */
1094     *dotp = '\0';               /* separate module and preference name */
1095     module = find_module(pref_name);
1096
1097     /*
1098      * XXX - "Diameter" rather than "diameter" was used in earlier
1099      * versions of Ethereal; if we didn't find the module, and its name
1100      * was "Diameter", look for "diameter" instead.
1101      */
1102     if (module == NULL && strcmp(pref_name, "Diameter") == 0)
1103       module = find_module("diameter");
1104     *dotp = '.';                /* put the preference string back */
1105     if (module == NULL)
1106       return PREFS_SET_NO_SUCH_PREF;    /* no such module */
1107     dotp++;                     /* skip past separator to preference name */
1108     pref = find_preference(module, dotp);
1109
1110     /*
1111      * XXX - "mgcp.display raw text toggle" and "mgcp.display dissect tree"
1112      * rather than "mgcp.display_raw_text" and "mgcp.display_dissect_tree"
1113      * were used in earlier versions of Ethereal; if we didn't find the
1114      * preference, it was an MGCP preference, and its name was
1115      * "display raw text toggle" or "display dissect tree", look for
1116      * "display_raw_text" or "display_dissect_tree" instead.
1117      *
1118      * "mgcp.tcp.port" and "mgcp.udp.port" are harder to handle, as both
1119      * the gateway and callagent ports were given those names; we interpret
1120      * the first as "mgcp.{tcp,udp}.gateway_port" and the second as
1121      * "mgcp.{tcp,udp}.callagent_port", as that's the order in which
1122      * they were registered by the MCCP dissector and thus that's the
1123      * order in which they were written to the preferences file.  (If
1124      * we're not reading the preferences file, but are handling stuff
1125      * from a "-o" command-line option, we have no clue which the user
1126      * had in mind - they should have used "mgcp.{tcp,udp}.gateway_port"
1127      * or "mgcp.{tcp,udp}.callagent_port" instead.)
1128      */
1129     if (pref == NULL && strncmp(pref_name, "mgcp.", 5) == 0) {
1130       if (strcmp(dotp, "display raw text toggle") == 0)
1131         pref = find_preference(module, "display_raw_text");
1132       else if (strcmp(dotp, "display dissect tree") == 0)
1133         pref = find_preference(module, "display_dissect_tree");
1134       else if (strcmp(dotp, "tcp.port") == 0) {
1135         mgcp_tcp_port_count++;
1136         if (mgcp_tcp_port_count == 1) {
1137           /* It's the first one */
1138           pref = find_preference(module, "tcp.gateway_port");
1139         } else if (mgcp_tcp_port_count == 2) {
1140           /* It's the second one */
1141           pref = find_preference(module, "tcp.callagent_port");
1142         }
1143         /* Otherwise it's from the command line, and we don't bother
1144            mapping it. */
1145       } else if (strcmp(dotp, "udp.port") == 0) {
1146         mgcp_udp_port_count++;
1147         if (mgcp_udp_port_count == 1) {
1148           /* It's the first one */
1149           pref = find_preference(module, "udp.gateway_port");
1150         } else if (mgcp_udp_port_count == 2) {
1151           /* It's the second one */
1152           pref = find_preference(module, "udp.callagent_port");
1153         }
1154         /* Otherwise it's from the command line, and we don't bother
1155            mapping it. */
1156       }
1157     }
1158     if (pref == NULL)
1159       return PREFS_SET_NO_SUCH_PREF;    /* no such preference */
1160
1161     switch (pref->type) {
1162
1163     case PREF_UINT:
1164       uval = strtoul(value, &p, pref->info.base);
1165       if (p == value || *p != '\0')
1166         return PREFS_SET_SYNTAX_ERR;    /* number was bad */
1167       if (*pref->varp.uint != uval) {
1168         module->prefs_changed = TRUE;
1169         *pref->varp.uint = uval;
1170       }
1171       break;
1172
1173     case PREF_BOOL:
1174       /* XXX - give an error if it's neither "true" nor "false"? */
1175       if (strcasecmp(value, "true") == 0)
1176         bval = TRUE;
1177       else
1178         bval = FALSE;
1179       if (*pref->varp.bool != bval) {
1180         module->prefs_changed = TRUE;
1181         *pref->varp.bool = bval;
1182       }
1183       break;
1184
1185     case PREF_ENUM:
1186       /* XXX - give an error if it doesn't match? */
1187       enum_val = find_val_for_string(value,
1188                                         pref->info.enum_info.enumvals, 1);
1189       if (*pref->varp.enump != enum_val) {
1190         module->prefs_changed = TRUE;
1191         *pref->varp.enump = enum_val;
1192       }
1193       break;
1194
1195     case PREF_STRING:
1196       if (*pref->varp.string == NULL || strcmp(*pref->varp.string, value) != 0) {
1197         module->prefs_changed = TRUE;
1198         if (*pref->varp.string != NULL)
1199           g_free(*pref->varp.string);
1200         *pref->varp.string = g_strdup(value);
1201       }
1202       break;
1203     }
1204   }
1205   
1206   return PREFS_SET_OK;
1207 }
1208
1209 typedef struct {
1210         module_t *module;
1211         FILE    *pf;
1212 } write_pref_arg_t;
1213
1214 /*
1215  * Write out a single preference.
1216  */
1217 static void
1218 write_pref(gpointer data, gpointer user_data)
1219 {
1220         pref_t *pref = data;
1221         write_pref_arg_t *arg = user_data;
1222         const enum_val_t *enum_valp;
1223         const char *val_string;
1224
1225         fprintf(arg->pf, "\n# %s\n", pref->description);
1226
1227         switch (pref->type) {
1228
1229         case PREF_UINT:
1230                 switch (pref->info.base) {
1231
1232                 case 10:
1233                         fprintf(arg->pf, "# A decimal number.\n");
1234                         fprintf(arg->pf, "%s.%s: %u\n", arg->module->name,
1235                             pref->name, *pref->varp.uint);
1236                         break;
1237
1238                 case 8:
1239                         fprintf(arg->pf, "# An octal number.\n");
1240                         fprintf(arg->pf, "%s.%s: %#o\n", arg->module->name,
1241                             pref->name, *pref->varp.uint);
1242                         break;
1243
1244                 case 16:
1245                         fprintf(arg->pf, "# A hexadecimal number.\n");
1246                         fprintf(arg->pf, "%s.%s: %#x\n", arg->module->name,
1247                             pref->name, *pref->varp.uint);
1248                         break;
1249                 }
1250                 break;
1251
1252         case PREF_BOOL:
1253                 fprintf(arg->pf, "# TRUE or FALSE (case-insensitive).\n");
1254                 fprintf(arg->pf, "%s.%s: %s\n", arg->module->name, pref->name,
1255                     *pref->varp.bool ? "TRUE" : "FALSE");
1256                 break;
1257
1258         case PREF_ENUM:
1259                 fprintf(arg->pf, "# One of: ");
1260                 enum_valp = pref->info.enum_info.enumvals;
1261                 val_string = NULL;
1262                 while (enum_valp->name != NULL) {
1263                         if (enum_valp->value == *pref->varp.enump)
1264                                 val_string = enum_valp->name;
1265                         fprintf(arg->pf, "%s", enum_valp->name);
1266                         enum_valp++;
1267                         if (enum_valp->name == NULL)
1268                                 fprintf(arg->pf, "\n");
1269                         else
1270                                 fprintf(arg->pf, ", ");
1271                 }
1272                 fprintf(arg->pf, "# (case-insensitive).\n");
1273                 fprintf(arg->pf, "%s.%s: %s\n", arg->module->name, pref->name,
1274                     val_string);
1275                 break;
1276
1277         case PREF_STRING:
1278                 fprintf(arg->pf, "# A string.\n");
1279                 fprintf(arg->pf, "%s.%s: %s\n", arg->module->name, pref->name,
1280                     *pref->varp.string);
1281                 break;
1282         }
1283 }
1284
1285 static void
1286 write_module_prefs(gpointer data, gpointer user_data)
1287 {
1288         write_pref_arg_t arg;
1289
1290         arg.module = data;
1291         arg.pf = user_data;
1292         g_list_foreach(arg.module->prefs, write_pref, &arg);
1293 }
1294
1295 /* Write out "prefs" to the user's preferences file, and return 0.
1296
1297    If we got an error, stuff a pointer to the path of the preferences file
1298    into "*pf_path_return", and return the errno. */
1299 int
1300 write_prefs(char **pf_path_return)
1301 {
1302   FILE        *pf;
1303   struct stat  s_buf;
1304   
1305   /* To do:
1306    * - Split output lines longer than MAX_VAL_LEN
1307    * - Create a function for the preference directory check/creation
1308    *   so that duplication can be avoided with filter.c
1309    */
1310
1311   if (! pf_path) {
1312     pf_path = (gchar *) g_malloc(strlen(get_home_dir()) + strlen(PF_DIR) +
1313       strlen(PF_NAME) + 4);
1314   }
1315
1316   sprintf(pf_path, "%s/%s", get_home_dir(), PF_DIR);
1317   if (stat(pf_path, &s_buf) != 0)
1318 #ifdef WIN32
1319     mkdir(pf_path);
1320 #else
1321     mkdir(pf_path, 0755);
1322 #endif
1323
1324   sprintf(pf_path, "%s/%s/%s", get_home_dir(), PF_DIR, PF_NAME);
1325   if ((pf = fopen(pf_path, "w")) == NULL) {
1326     *pf_path_return = pf_path;
1327     return errno;
1328   }
1329     
1330   fputs("# Configuration file for Ethereal " VERSION ".\n"
1331     "#\n"
1332     "# This file is regenerated each time preferences are saved within\n"
1333     "# Ethereal.  Making manual changes should be safe, however.\n"
1334     "\n"
1335     "######## Printing ########\n"
1336     "\n", pf);
1337
1338   fprintf (pf, "# Can be one of \"text\" or \"postscript\".\n"
1339     "print.format: %s\n\n", pr_formats[prefs.pr_format]);
1340
1341   fprintf (pf, "# Can be one of \"command\" or \"file\".\n"
1342     "print.destination: %s\n\n", pr_dests[prefs.pr_dest]);
1343
1344   fprintf (pf, "# This is the file that gets written to when the "
1345     "destination is set to \"file\"\n"
1346     "%s: %s\n\n", PRS_PRINT_FILE, prefs.pr_file);
1347
1348   fprintf (pf, "# Output gets piped to this command when the destination "
1349     "is set to \"command\"\n"
1350     "%s: %s\n\n", PRS_PRINT_CMD, prefs.pr_cmd);
1351
1352   fprintf (pf, "# Packet list column format.  Each pair of strings consists "
1353     "of a column title \n# and its format.\n"
1354     "%s: %s\n\n", PRS_COL_FMT, col_format_to_pref_str());
1355
1356   fprintf (pf, "# TCP stream window color preferences.  Each value is a six "
1357     "digit hexadecimal value in the form rrggbb.\n");
1358   fprintf (pf, "%s: %02x%02x%02x\n", PRS_STREAM_CL_FG,
1359     (prefs.st_client_fg.red * 255 / 65535),
1360     (prefs.st_client_fg.green * 255 / 65535),
1361     (prefs.st_client_fg.blue * 255 / 65535));
1362   fprintf (pf, "%s: %02x%02x%02x\n", PRS_STREAM_CL_BG,
1363     (prefs.st_client_bg.red * 255 / 65535),
1364     (prefs.st_client_bg.green * 255 / 65535),
1365     (prefs.st_client_bg.blue * 255 / 65535));
1366   fprintf (pf, "%s: %02x%02x%02x\n", PRS_STREAM_SR_FG,
1367     (prefs.st_server_fg.red * 255 / 65535),
1368     (prefs.st_server_fg.green * 255 / 65535),
1369     (prefs.st_server_fg.blue * 255 / 65535));
1370   fprintf (pf, "%s: %02x%02x%02x\n", PRS_STREAM_SR_BG,
1371     (prefs.st_server_bg.red * 255 / 65535),
1372     (prefs.st_server_bg.green * 255 / 65535),
1373     (prefs.st_server_bg.blue * 255 / 65535));
1374
1375   fprintf(pf, "\n# Vertical scrollbars should be on right side? TRUE/FALSE\n");
1376   fprintf(pf, PRS_GUI_SCROLLBAR_ON_RIGHT ": %s\n",
1377                   prefs.gui_scrollbar_on_right == TRUE ? "TRUE" : "FALSE");
1378
1379   fprintf(pf, "\n# Packet-list selection bar can be used to browse w/o selecting? TRUE/FALSE\n");
1380   fprintf(pf, PRS_GUI_PLIST_SEL_BROWSE ": %s\n",
1381                   prefs.gui_plist_sel_browse == TRUE ? "TRUE" : "FALSE");
1382
1383   fprintf(pf, "\n# Protocol-tree selection bar can be used to browse w/o selecting? TRUE/FALSE\n");
1384   fprintf(pf, PRS_GUI_PTREE_SEL_BROWSE ": %s\n",
1385                   prefs.gui_ptree_sel_browse == TRUE ? "TRUE" : "FALSE");
1386
1387   fprintf(pf, "\n# Protocol-tree line style. One of: NONE, SOLID, DOTTED, TABBED\n");
1388   fprintf(pf, PRS_GUI_PTREE_LINE_STYLE ": %s\n",
1389                   gui_ptree_line_style_text[prefs.gui_ptree_line_style]);
1390
1391   fprintf(pf, "\n# Protocol-tree expander style. One of: NONE, SQUARE, TRIANGLE, CIRCULAR\n");
1392   fprintf(pf, PRS_GUI_PTREE_EXPANDER_STYLE ": %s\n",
1393                   gui_ptree_expander_style_text[prefs.gui_ptree_expander_style]);
1394
1395   fprintf(pf, "\n# Hex dump highlight style. One of: BOLD, INVERSE\n");
1396   fprintf(pf, PRS_GUI_HEX_DUMP_HIGHLIGHT_STYLE ": %s\n",
1397                   gui_hex_dump_highlight_style_text[prefs.gui_hex_dump_highlight_style]);
1398
1399   fprintf(pf, "\n# Font name for packet list, protocol tree, and hex dump panes.\n");
1400   fprintf(pf, PRS_GUI_FONT_NAME ": %s\n", prefs.gui_font_name);
1401
1402   fprintf (pf, "\n# Color preferences for a marked frame.  Each value is a six "
1403     "digit hexadecimal value in the form rrggbb.\n");
1404   fprintf (pf, "%s: %02x%02x%02x\n", PRS_GUI_MARKED_FG,
1405     (prefs.gui_marked_fg.red * 255 / 65535),
1406     (prefs.gui_marked_fg.green * 255 / 65535),
1407     (prefs.gui_marked_fg.blue * 255 / 65535));
1408   fprintf (pf, "%s: %02x%02x%02x\n", PRS_GUI_MARKED_BG,
1409     (prefs.gui_marked_bg.red * 255 / 65535),
1410     (prefs.gui_marked_bg.green * 255 / 65535),
1411     (prefs.gui_marked_bg.blue * 255 / 65535));
1412
1413   fprintf(pf, "\n# Resolve addresses to names? TRUE/FALSE/{list of address types to resolve}\n");
1414   fprintf(pf, PRS_NAME_RESOLVE ": %s\n",
1415                   name_resolve_to_string(prefs.name_resolve));
1416
1417 /* write the capture options */
1418   fprintf(pf, "\n# Capture in promiscuous mode? TRUE/FALSE\n");
1419   fprintf(pf, PRS_CAP_PROM_MODE ": %s\n",
1420                   prefs.capture_prom_mode == TRUE ? "TRUE" : "FALSE");
1421
1422   fprintf(pf, "\n# Update packet list in real time during capture? TRUE/FALSE\n");
1423   fprintf(pf, PRS_CAP_REAL_TIME ": %s\n",
1424                   prefs.capture_real_time == TRUE ? "TRUE" : "FALSE");
1425
1426   fprintf(pf, "\n# scroll packet list during capture? TRUE/FALSE\n");
1427   fprintf(pf, PRS_CAP_AUTO_SCROLL ": %s\n",
1428                   prefs.capture_auto_scroll == TRUE ? "TRUE" : "FALSE");
1429
1430   g_list_foreach(modules, write_module_prefs, pf);
1431
1432   fclose(pf);
1433
1434   /* XXX - catch I/O errors (e.g. "ran out of disk space") and return
1435      an error indication, or maybe write to a new preferences file and
1436      rename that file on top of the old one only if there are not I/O
1437      errors. */
1438   return 0;
1439 }
1440
1441 /* Copy a set of preferences. */
1442 void
1443 copy_prefs(e_prefs *dest, e_prefs *src)
1444 {
1445   fmt_data *src_cfmt, *dest_cfmt;
1446   GList *entry;
1447
1448   dest->pr_format = src->pr_format;
1449   dest->pr_dest = src->pr_dest;
1450   dest->pr_file = g_strdup(src->pr_file);
1451   dest->pr_cmd = g_strdup(src->pr_cmd);
1452   dest->col_list = NULL;
1453   for (entry = src->col_list; entry != NULL; entry = g_list_next(entry)) {
1454     src_cfmt = entry->data;
1455     dest_cfmt = (fmt_data *) g_malloc(sizeof(fmt_data));
1456     dest_cfmt->title = g_strdup(src_cfmt->title);
1457     dest_cfmt->fmt = g_strdup(src_cfmt->fmt);
1458     dest->col_list = g_list_append(dest->col_list, dest_cfmt);
1459   }
1460   dest->num_cols = src->num_cols;
1461   dest->st_client_fg = src->st_client_fg;
1462   dest->st_client_bg = src->st_client_bg;
1463   dest->st_server_fg = src->st_server_fg;
1464   dest->st_server_bg = src->st_server_bg;
1465   dest->gui_scrollbar_on_right = src->gui_scrollbar_on_right;
1466   dest->gui_plist_sel_browse = src->gui_plist_sel_browse;
1467   dest->gui_ptree_sel_browse = src->gui_ptree_sel_browse;
1468   dest->gui_ptree_line_style = src->gui_ptree_line_style;
1469   dest->gui_ptree_expander_style = src->gui_ptree_expander_style;
1470   dest->gui_hex_dump_highlight_style = src->gui_hex_dump_highlight_style;
1471   dest->gui_font_name = g_strdup(src->gui_font_name);
1472   dest->gui_marked_fg = src->gui_marked_fg;
1473   dest->gui_marked_bg = src->gui_marked_bg;
1474 /*  values for the capture dialog box */
1475   dest->capture_prom_mode = src->capture_prom_mode;
1476   dest->capture_real_time = src->capture_real_time;
1477   dest->capture_auto_scroll = src->capture_auto_scroll;
1478   dest->name_resolve = src->name_resolve;
1479
1480 }
1481
1482 /* Free a set of preferences. */
1483 void
1484 free_prefs(e_prefs *pr)
1485 {
1486   if (pr->pr_file != NULL) {
1487     g_free(pr->pr_file);
1488     pr->pr_file = NULL;
1489   }
1490   if (pr->pr_cmd != NULL) {
1491     g_free(pr->pr_cmd);
1492     pr->pr_cmd = NULL;
1493   }
1494   free_col_info(pr);
1495   if (pr->gui_font_name != NULL) {
1496     g_free(pr->gui_font_name);
1497     pr->gui_font_name = NULL;
1498   }
1499 }
1500
1501 static void
1502 free_col_info(e_prefs *pr)
1503 {
1504   fmt_data *cfmt;
1505
1506   while (pr->col_list != NULL) {
1507     cfmt = pr->col_list->data;
1508     g_free(cfmt->title);
1509     g_free(cfmt->fmt);
1510     g_free(cfmt);
1511     pr->col_list = g_list_remove_link(pr->col_list, pr->col_list);
1512   }
1513   g_list_free(pr->col_list);
1514   pr->col_list = NULL;
1515 }