replace *a lot* of file related calls by their GLib counterparts. This is necessary...
[obnox/wireshark/wip.git] / filters.c
1 /* filters.c
2  * Code for reading and writing the filters file.
3  *
4  * $Id$
5  *
6  * Ethereal - Network traffic analyzer
7  * By Gerald Combs <gerald@ethereal.com>
8  * Copyright 1998 Gerald Combs
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  */
24
25 #ifdef HAVE_CONFIG_H
26 # include "config.h"
27 #endif
28
29 #include <stdio.h>
30 #include <string.h>
31 #include <ctype.h>
32 #include <errno.h>
33
34 #ifdef HAVE_UNISTD_H
35 #include <unistd.h>
36 #endif
37
38 #include <glib.h>
39
40 #include <epan/filesystem.h>
41
42 #include "filters.h"
43 #include "file_util.h"
44
45 /*
46  * Old filter file name.
47  */
48 #define FILTER_FILE_NAME        "filters"
49
50 /*
51  * Capture filter file name.
52  */
53 #define CFILTER_FILE_NAME       "cfilters"
54
55 /*
56  * Display filter file name.
57  */
58 #define DFILTER_FILE_NAME       "dfilters"
59
60 /*
61  * List of capture filters.
62  */
63 static GList *capture_filters = NULL;
64
65 /*
66  * List of display filters.
67  */
68 static GList *display_filters = NULL;
69
70 /*
71  * Read in a list of filters.
72  *
73  * On success, "*pref_path_return" is set to NULL.
74  * On error, "*pref_path_return" is set to point to the pathname of
75  * the file we tried to read - it should be freed by our caller -
76  * and "*errno_return" is set to the error.
77  */
78
79 #define INIT_BUF_SIZE   128
80
81 void
82 read_filter_list(filter_list_type_t list, char **pref_path_return,
83     int *errno_return)
84 {
85   const char *ff_name;
86   char       *ff_path;
87   FILE       *ff;
88   GList      **flp;
89   GList      *fl_ent;
90   filter_def *filt;
91   int         c;
92   char       *filt_name, *filt_expr;
93   int         filt_name_len, filt_expr_len;
94   int         filt_name_index, filt_expr_index;
95   int         line = 1;
96
97   *pref_path_return = NULL;     /* assume no error */
98
99   switch (list) {
100
101   case CFILTER_LIST:
102     ff_name = CFILTER_FILE_NAME;
103     flp = &capture_filters;
104     break;
105
106   case DFILTER_LIST:
107     ff_name = DFILTER_FILE_NAME;
108     flp = &display_filters;
109     break;
110
111   default:
112     g_assert_not_reached();
113     return;
114   }
115
116   /* try to open personal "cfilters"/"dfilters" file */
117   ff_path = get_persconffile_path(ff_name, FALSE);
118   if ((ff = eth_fopen(ff_path, "r")) == NULL) {
119     /*
120      * Did that fail because the file didn't exist?
121      */
122     if (errno != ENOENT) {
123       /*
124        * No.  Just give up.
125        */
126       *pref_path_return = ff_path;
127       *errno_return = errno;
128       return;
129     }
130
131     /*
132      * Yes.  See if there's an "old style" personal "filters" file; if so, read it.
133      * This means that a user will start out with their capture and
134      * display filter lists being identical; each list may contain
135      * filters that don't belong in that list.  The user can edit
136      * the filter lists, and delete the ones that don't belong in
137      * a particular list.
138      */
139     g_free(ff_path);
140     ff_path = get_persconffile_path(FILTER_FILE_NAME, FALSE);
141     if ((ff = eth_fopen(ff_path, "r")) == NULL) {
142     /*
143      * Did that fail because the file didn't exist?
144      */
145       if (errno != ENOENT) {
146       /*
147        * No.  Just give up.
148        */
149         *pref_path_return = ff_path;
150         *errno_return = errno;
151     return;
152       }
153
154     /*
155      * Try to open the global "cfilters/dfilters" file */
156     ff_path = get_datafile_path(ff_name);
157     if ((ff = eth_fopen(ff_path, "r")) == NULL) {
158
159       /*
160        * Well, that didn't work, either.  Just give up.
161        * Return an error if the file existed but we couldn't open it.
162        */
163       if (errno != ENOENT) {
164         *pref_path_return = ff_path;
165         *errno_return = errno;
166     }
167     return;
168     }
169     }
170   }
171
172   /* If we already have a list of filters, discard it. */
173   if (*flp != NULL) {
174     fl_ent = g_list_first(*flp);
175     while (fl_ent != NULL) {
176       filt = (filter_def *) fl_ent->data;
177       g_free(filt->name);
178       g_free(filt->strval);
179       g_free(filt);
180       fl_ent = fl_ent->next;
181     }
182     g_list_free(*flp);
183     *flp = NULL;
184   }
185
186   /* Allocate the filter name buffer. */
187   filt_name_len = INIT_BUF_SIZE;
188   filt_name = g_malloc(filt_name_len + 1);
189   filt_expr_len = INIT_BUF_SIZE;
190   filt_expr = g_malloc(filt_expr_len + 1);
191
192   for (line = 1; ; line++) {
193     /* Lines in a filter file are of the form
194
195         "name" expression
196
197        where "name" is a name, in quotes - backslashes in the name
198        escape the next character, so quotes and backslashes can appear
199        in the name - and "expression" is a filter expression, not in
200        quotes, running to the end of the line. */
201
202     /* Skip over leading white space, if any. */
203     while ((c = getc(ff)) != EOF && isspace(c)) {
204       if (c == '\n') {
205         /* Blank line. */
206         continue;
207       }
208     }
209
210     if (c == EOF)
211       break;    /* Nothing more to read */
212
213     /* "c" is the first non-white-space character.
214        If it's not a quote, it's an error. */
215     if (c != '"') {
216       g_warning("'%s' line %d doesn't have a quoted filter name.", ff_path,
217                 line);
218       while (c != '\n')
219         c = getc(ff);   /* skip to the end of the line */
220       continue;
221     }
222
223     /* Get the name of the filter. */
224     filt_name_index = 0;
225     for (;;) {
226       c = getc(ff);
227       if (c == EOF || c == '\n')
228         break;  /* End of line - or end of file */
229       if (c == '"') {
230         /* Closing quote. */
231         if (filt_name_index >= filt_name_len) {
232           /* Filter name buffer isn't long enough; double its length. */
233           filt_name_len *= 2;
234           filt_name = g_realloc(filt_name, filt_name_len + 1);
235         }
236         filt_name[filt_name_index] = '\0';
237         break;
238       }
239       if (c == '\\') {
240         /* Next character is escaped */
241         c = getc(ff);
242         if (c == EOF || c == '\n')
243           break;        /* End of line - or end of file */
244       }
245       /* Add this character to the filter name string. */
246       if (filt_name_index >= filt_name_len) {
247         /* Filter name buffer isn't long enough; double its length. */
248         filt_name_len *= 2;
249         filt_name = g_realloc(filt_name, filt_name_len + 1);
250       }
251       filt_name[filt_name_index] = c;
252       filt_name_index++;
253     }
254
255     if (c == EOF) {
256       if (!ferror(ff)) {
257         /* EOF, not error; no newline seen before EOF */
258         g_warning("'%s' line %d doesn't have a newline.", ff_path,
259                   line);
260       }
261       break;    /* nothing more to read */
262     }
263
264     if (c != '"') {
265       /* No newline seen before end-of-line */
266       g_warning("'%s' line %d doesn't have a closing quote.", ff_path,
267                 line);
268       continue;
269     }
270
271     /* Skip over separating white space, if any. */
272     while ((c = getc(ff)) != EOF && isspace(c)) {
273       if (c == '\n')
274         break;
275     }
276
277     if (c == EOF) {
278       if (!ferror(ff)) {
279         /* EOF, not error; no newline seen before EOF */
280         g_warning("'%s' line %d doesn't have a newline.", ff_path,
281                   line);
282       }
283       break;    /* nothing more to read */
284     }
285
286     if (c == '\n') {
287       /* No filter expression */
288       g_warning("'%s' line %d doesn't have a filter expression.", ff_path,
289                 line);
290       continue;
291     }
292
293     /* "c" is the first non-white-space character; it's the first
294        character of the filter expression. */
295     filt_expr_index = 0;
296     for (;;) {
297       /* Add this character to the filter expression string. */
298       if (filt_expr_index >= filt_expr_len) {
299         /* Filter expressioin buffer isn't long enough; double its length. */
300         filt_expr_len *= 2;
301         filt_expr = g_realloc(filt_expr, filt_expr_len + 1);
302       }
303       filt_expr[filt_expr_index] = c;
304       filt_expr_index++;
305
306       /* Get the next character. */
307       c = getc(ff);
308       if (c == EOF || c == '\n')
309         break;
310     }
311
312     if (c == EOF) {
313       if (!ferror(ff)) {
314         /* EOF, not error; no newline seen before EOF */
315         g_warning("'%s' line %d doesn't have a newline.", ff_path,
316                   line);
317       }
318       break;    /* nothing more to read */
319     }
320
321     /* We saw the ending newline; terminate the filter expression string */
322     if (filt_expr_index >= filt_expr_len) {
323       /* Filter expressioin buffer isn't long enough; double its length. */
324       filt_expr_len *= 2;
325       filt_expr = g_realloc(filt_expr, filt_expr_len + 1);
326     }
327     filt_expr[filt_expr_index] = '\0';
328
329     /* Add the new filter to the list of filters */
330     filt         = (filter_def *) g_malloc(sizeof(filter_def));
331     filt->name   = g_strdup(filt_name);
332     filt->strval = g_strdup(filt_expr);
333     *flp = g_list_append(*flp, filt);
334   }
335   if (ferror(ff)) {
336     *pref_path_return = ff_path;
337     *errno_return = errno;
338   } else
339     g_free(ff_path);
340   fclose(ff);
341   g_free(filt_name);
342   g_free(filt_expr);
343 }
344
345 /*
346  * Get a pointer to a list of filters.
347  */
348 static GList **
349 get_filter_list(filter_list_type_t list)
350 {
351   GList **flp;
352
353   switch (list) {
354
355   case CFILTER_LIST:
356     flp = &capture_filters;
357     break;
358
359   case DFILTER_LIST:
360     flp = &display_filters;
361     break;
362
363   default:
364     g_assert_not_reached();
365     flp = NULL;
366   }
367   return flp;
368 }
369
370 /*
371  * Get a pointer to the first entry in a filter list.
372  */
373 GList *
374 get_filter_list_first(filter_list_type_t list)
375 {
376   GList      **flp;
377
378   flp = get_filter_list(list);
379   return g_list_first(*flp);
380 }
381
382 /*
383  * Add a new filter to the end of a list.
384  * Returns a pointer to the newly-added entry.
385  */
386 GList *
387 add_to_filter_list(filter_list_type_t list, const char *name,
388     const char *expression)
389 {
390   GList      **flp;
391   filter_def *filt;
392
393   flp = get_filter_list(list);
394   filt = (filter_def *) g_malloc(sizeof(filter_def));
395   filt->name = g_strdup(name);
396   filt->strval = g_strdup(expression);
397   *flp = g_list_append(*flp, filt);
398   return g_list_last(*flp);
399 }
400
401 /*
402  * Remove a filter from a list.
403  */
404 void
405 remove_from_filter_list(filter_list_type_t list, GList *fl_entry)
406 {
407   GList      **flp;
408   filter_def *filt;
409
410   flp = get_filter_list(list);
411   filt = (filter_def *) fl_entry->data;
412   g_free(filt->name);
413   g_free(filt->strval);
414   g_free(filt);
415   *flp = g_list_remove_link(*flp, fl_entry);
416 }
417
418 /*
419  * Write out a list of filters.
420  *
421  * On success, "*pref_path_return" is set to NULL.
422  * On error, "*pref_path_return" is set to point to the pathname of
423  * the file we tried to read - it should be freed by our caller -
424  * and "*errno_return" is set to the error.
425  */
426 void
427 save_filter_list(filter_list_type_t list, char **pref_path_return,
428     int *errno_return)
429 {
430   const gchar *ff_name;
431   gchar      *ff_path, *ff_path_new;
432   GList      *fl;
433   GList      *flp;
434   filter_def *filt;
435   FILE       *ff;
436   guchar     *p, c;
437
438   *pref_path_return = NULL;     /* assume no error */
439
440   switch (list) {
441
442   case CFILTER_LIST:
443     ff_name = CFILTER_FILE_NAME;
444     fl = capture_filters;
445     break;
446
447   case DFILTER_LIST:
448     ff_name = DFILTER_FILE_NAME;
449     fl = display_filters;
450     break;
451
452   default:
453     g_assert_not_reached();
454     return;
455   }
456
457   ff_path = get_persconffile_path(ff_name, TRUE);
458
459   /* Write to "XXX.new", and rename if that succeeds.
460      That means we don't trash the file if we fail to write it out
461      completely. */
462   ff_path_new = g_strdup_printf("%s.new", ff_path);
463
464   if ((ff = eth_fopen(ff_path_new, "w")) == NULL) {
465     *pref_path_return = ff_path;
466     *errno_return = errno;
467     g_free(ff_path_new);
468     return;
469   }
470   flp = g_list_first(fl);
471   while (flp) {
472     filt = (filter_def *) flp->data;
473
474     /* Write out the filter name as a quoted string; escape any quotes
475        or backslashes. */
476     putc('"', ff);
477     for (p = (guchar *)filt->name; (c = *p) != '\0'; p++) {
478       if (c == '"' || c == '\\')
479         putc('\\', ff);
480       putc(c, ff);
481     }
482     putc('"', ff);
483
484     /* Separate the filter name and value with a space. */
485     putc(' ', ff);
486
487     /* Write out the filter expression and a newline. */
488     fprintf(ff, "%s\n", filt->strval);
489     if (ferror(ff)) {
490       *pref_path_return = ff_path;
491       *errno_return = errno;
492       fclose(ff);
493       eth_unlink(ff_path_new);
494       g_free(ff_path_new);
495       return;
496     }
497     flp = flp->next;
498   }
499   if (fclose(ff) == EOF) {
500     *pref_path_return = ff_path;
501     *errno_return = errno;
502     eth_unlink(ff_path_new);
503     g_free(ff_path_new);
504     return;
505   }
506
507 #ifdef _WIN32
508   /* ANSI C doesn't say whether "rename()" removes the target if it
509      exists; the Win32 call to rename files doesn't do so, which I
510      infer is the reason why the MSVC++ "rename()" doesn't do so.
511      We must therefore remove the target file first, on Windows. */
512   if (eth_remove(ff_path) < 0 && errno != ENOENT) {
513     /* It failed for some reason other than "it's not there"; if
514        it's not there, we don't need to remove it, so we just
515        drive on. */
516     *pref_path_return = ff_path;
517     *errno_return = errno;
518     eth_unlink(ff_path_new);
519     g_free(ff_path_new);
520     return;
521   }
522 #endif
523
524   if (eth_rename(ff_path_new, ff_path) < 0) {
525     *pref_path_return = ff_path;
526     *errno_return = errno;
527     eth_unlink(ff_path_new);
528     g_free(ff_path_new);
529     return;
530   }
531   g_free(ff_path_new);
532   g_free(ff_path);
533 }