source: filter.c @ cd5adec

barnowl_perlaimdebianrelease-1.10release-1.4release-1.5release-1.6release-1.7release-1.8release-1.9
Last change on this file since cd5adec was cd5adec, checked in by Nelson Elhage <nelhage@mit.edu>, 17 years ago
r15901@phanatique: nelhage | 2006-12-25 21:08:47 -0500 Base framework for the filter rewrite system. Only understands regexes and true/false so far.
  • Property mode set to 100644
File size: 8.2 KB
Line 
1#include <string.h>
2#include "owl.h"
3
4static const char fileIdent[] = "$Id$";
5
6#define OWL_FILTER_MAXRECURSE 20
7
8int owl_filter_init_fromstring(owl_filter *f, char *name, char *string)
9{
10  char **argv;
11  int argc, out;
12
13  argv=owl_parseline(string, &argc);
14  out=owl_filter_init(f, name, argc, argv);
15  /* owl_parsefree(argv, argc); */
16  return(out);
17}
18
19int owl_filter_init(owl_filter *f, char *name, int argc, char **argv)
20{
21  f->name=owl_strdup(name);
22  f->polarity=0;
23  f->fgcolor=OWL_COLOR_DEFAULT;
24  f->bgcolor=OWL_COLOR_DEFAULT;
25  f->cachedmsgid=-1;
26
27  /* first take arguments that have to come first */
28  /* set the color */
29  while ( argc>=2 && ( !strcmp(argv[0], "-c") ||
30                       !strcmp(argv[0], "-b") ) ) {
31    if (owl_util_string_to_color(argv[1])==-1) {
32      owl_function_error("The color '%s' is not available, using default.", argv[1]);
33    } else {
34      switch (argv[0][1]) {
35      case 'c':
36        f->fgcolor=owl_util_string_to_color(argv[1]);
37        break;
38      case 'b':
39        f->bgcolor=owl_util_string_to_color(argv[1]);
40        break;
41      }
42    }
43    argc-=2;
44    argv+=2;
45  }
46
47  if(!(f->root = owl_filter_parse_expression(argc, argv, NULL)))
48    return(-1);
49
50  /* Now check for recursion. */
51  if (owl_filter_is_toodeep(f)) {
52    owl_function_error("Filter loop or exceeds recursion depth");
53    owl_filter_free(f);
54    return(-1);
55  }
56
57  return(0);
58}
59
60
61/* A primitive expression is one without any toplevel ``and'' or ``or''s*/
62
63static owl_filterelement * owl_filter_parse_primitive_expression(int argc, char **argv, int *next)
64{
65  if(!argc) return NULL;
66
67  owl_filterelement * fe = owl_malloc(sizeof(owl_filterelement));
68  owl_filterelement *op;
69
70  owl_filterelement_create(fe);
71  int i = 0, skip;
72
73  if(!strcasecmp(argv[i], "(")) {
74    i++;
75    op = owl_filter_parse_expression(argc-i, argv+i, &skip);
76    if(!op) goto err;
77    i += skip;
78    if(strcasecmp(argv[i++], ")")) goto err;
79    owl_filterelement_create_group(fe, op);
80  } else if(!strcasecmp(argv[i], "not")) {
81    i++;
82    op = owl_filter_parse_primitive_expression(argc-i, argv+i, &skip);
83    if(!op) goto err;
84    i += skip;
85    owl_filterelement_create_not(fe, op);
86  } else if(!strcasecmp(argv[i], "true")) {
87    i++;
88    owl_filterelement_create_true(fe);
89  } else if(!strcasecmp(argv[i], "false")) {
90    i++;
91    owl_filterelement_create_false(fe);
92  } else {
93    if(argc == 1) goto err;
94    if(!strcasecmp(*argv, "filter")) {
95      owl_filterelement_create_filter(fe, *(argv+1));
96    } else if(!strcasecmp(*argv, "perl")) {
97      owl_filterelement_create_perl(fe, *(argv+1));
98    } else {
99      owl_filterelement_create_re(fe, *argv, *(argv+1));
100    }
101    i += 2;
102  }
103
104  if(next) {
105    *next = i;
106  } else if(i != argc) {
107    goto err;
108  }
109  return fe;
110err:
111  owl_filterelement_free(fe);
112  owl_free(fe);
113  return NULL;
114}
115
116owl_filterelement * owl_filter_parse_expression(int argc, char **argv, int *next)
117{
118  int i = 0, skip;
119  owl_filterelement * op1 = NULL, * op2 = NULL;
120
121  op1 = owl_filter_parse_primitive_expression(argc-i, argv+i, &skip);
122  i += skip;
123  if(!op1) goto err;
124
125  while(i < argc) {
126    if(strcasecmp(argv[i], "and") &&
127       strcasecmp(argv[i], "or")) break;
128    op2 = owl_filter_parse_primitive_expression(argc-i-1, argv+i+1, &skip);
129    if(!op2) goto err;
130    owl_filterelement * tmp = owl_malloc(sizeof(owl_filterelement));
131    if(!strcasecmp(argv[i], "and")) {
132      owl_filterelement_create_and(tmp, op1, op2);
133    } else {
134      owl_filterelement_create_or(tmp, op1, op2);
135    }
136    op1 = tmp;
137    op2 = NULL;
138    i += skip+1;
139  }
140
141  if(next) {
142    *next = i;
143  } else if(i != argc) {
144    goto err;
145  }
146  return op1;
147err:
148  if(op1) {
149    owl_filterelement_free(op1);
150    owl_free(op1);
151  }
152  return NULL;
153}
154
155char *owl_filter_get_name(owl_filter *f)
156{
157  return(f->name);
158}
159
160void owl_filter_set_polarity_match(owl_filter *f)
161{
162  f->polarity=0;
163}
164
165void owl_filter_set_polarity_unmatch(owl_filter *f)
166{
167  f->polarity=1;
168}
169
170void owl_filter_set_fgcolor(owl_filter *f, int color)
171{
172  f->fgcolor=color;
173}
174
175int owl_filter_get_fgcolor(owl_filter *f)
176{
177  return(f->fgcolor);
178}
179
180void owl_filter_set_bgcolor(owl_filter *f, int color)
181{
182  f->bgcolor=color;
183}
184
185int owl_filter_get_bgcolor(owl_filter *f)
186{
187  return(f->bgcolor);
188}
189
190void owl_filter_set_cachedmsgid(owl_filter *f, int cachedmsgid)
191{
192  f->cachedmsgid=cachedmsgid;
193}
194
195int owl_filter_get_cachedmsgid(owl_filter *f)
196{
197  return(f->cachedmsgid);
198}
199
200/* return 1 if the message matches the given filter, otherwise
201 * return 0.
202 */
203int owl_filter_message_match(owl_filter *f, owl_message *m)
204{
205  if(!f->root) return 0;
206  int ret = owl_filterelement_match(f->root, m);
207  if(f->polarity) ret = !ret;
208  return ret;
209}
210
211
212void owl_filter_print(owl_filter *f, char *out)
213{
214  strcpy(out, owl_filter_get_name(f));
215  strcat(out, ": ");
216
217  if (f->fgcolor!=OWL_COLOR_DEFAULT) {
218    strcat(out, "-c ");
219    strcat(out, owl_util_color_to_string(f->fgcolor));
220    strcat(out, " ");
221  }
222  if (f->bgcolor!=OWL_COLOR_DEFAULT) {
223    strcat(out, "-b ");
224    strcat(out, owl_util_color_to_string(f->bgcolor));
225    strcat(out, " ");
226  }
227  if(!f->root) return;
228  owl_filterelement_print(f->root, out);
229  strcat(out, "\n");
230}
231
232/* Return 1 if the filters 'a' and 'b' are equivalent, 0 otherwise */
233int owl_filter_equiv(owl_filter *a, owl_filter *b)
234{
235  char buff[LINE], buff2[LINE];
236
237  owl_filter_print(a, buff);
238  owl_filter_print(b, buff2);
239
240  if (!strcmp(buff, buff2)) return(1);
241  return(0);
242}
243
244
245int owl_filter_is_toodeep(owl_filter *f)
246{
247  return owl_filterelement_is_toodeep(f, f->root);
248}
249
250void owl_filter_free(owl_filter *f)
251{
252  if(f->root) {
253    owl_filterelement_free(f->root);
254    owl_free(f->root);
255  }
256  if (f->name) owl_free(f->name);
257}
258
259/**************************************************************************/
260/************************* REGRESSION TESTS *******************************/
261/**************************************************************************/
262
263#ifdef OWL_INCLUDE_REG_TESTS
264
265int owl_filter_test_string(char * filt, owl_message *m, int shouldmatch) /* noproto */ {
266  owl_filter f;
267  int ok;
268  int failed = 0;
269  if(owl_filter_init_fromstring(&f, "test-filter", filt)) {
270    printf("\tFAIL: parse %s\n", filt);
271    failed = 1;
272    goto out;
273  }
274  ok = owl_filter_message_match(&f, m);
275  if((shouldmatch && !ok) || (!shouldmatch && ok)) {
276    printf("\tFAIL: match %s (got %d, expected %d)\n", filt, ok, shouldmatch);
277    failed = 1;
278  }
279 out:
280  owl_filter_free(&f);
281  if(!failed) {
282    printf("\tok  : %s %s\n", shouldmatch ? "matches" : "doesn't match", filt);
283  }
284  return failed;
285}
286
287
288#include "test.h"
289
290
291int owl_filter_regtest(void) {
292  owl_list_create(&(g.filterlist));
293  int numfailed=0;
294  owl_message m;
295  owl_message_init(&m);
296  owl_message_set_type_zephyr(&m);
297  owl_message_set_direction_in(&m);
298  owl_message_set_class(&m, "owl");
299  owl_message_set_instance(&m, "tester");
300  owl_message_set_sender(&m, "owl-user");
301  owl_message_set_recipient(&m, "joe");
302  owl_message_set_attribute(&m, "foo", "bar");
303
304#define TEST_FILTER(f, e) numfailed += owl_filter_test_string(f, &m, e)
305
306
307  TEST_FILTER("true", 1);
308  TEST_FILTER("false", 0);
309  TEST_FILTER("( true )", 1);
310  TEST_FILTER("not false", 1);
311  TEST_FILTER("( true ) or ( false )", 1);
312  TEST_FILTER("true and false", 0);
313  TEST_FILTER("( true or true ) or ( ( false ) )", 1);
314
315  TEST_FILTER("class owl", 1);
316  TEST_FILTER("class ^owl$", 1);
317  TEST_FILTER("instance test", 1);
318  TEST_FILTER("instance ^test$", 0);
319  TEST_FILTER("instance ^tester$", 1);
320
321  TEST_FILTER("foo bar", 1);
322  TEST_FILTER("class owl and instance tester", 1);
323  TEST_FILTER("type ^zephyr$ and direction ^in$ and ( class ^owl$ or instance ^owl$ )", 1);
324
325  // Order of operations and precedence
326  TEST_FILTER("not true or false", 0);
327  TEST_FILTER("true or true and false", 0);
328  TEST_FILTER("true and true and false or true", 1);
329  TEST_FILTER("false and false or true", 1);
330  TEST_FILTER("true and false or false", 0);
331
332  owl_filter f1, f2, f3, f4;
333
334  owl_filter_init_fromstring(&f1, "f1", "class owl");
335  owl_global_add_filter(&g, &f1);
336  TEST_FILTER("filter f1", 1);
337
338  // Test recursion prevention
339  FAIL_UNLESS("self reference", owl_filter_init_fromstring(&f2, "test", "filter test"));
340
341  // mutual recursion
342  owl_filter_init_fromstring(&f3, "f3", "filter f4");
343  owl_global_add_filter(&g, &f3);
344  FAIL_UNLESS("mutual recursion",   owl_filter_init_fromstring(&f4, "f4", "filter f3"));
345
346  return 0;
347}
348
349
350#endif /* OWL_INCLUDE_REG_TESTS */
Note: See TracBrowser for help on using the repository browser.