src/filter_chain.c: Fixed typos in error messages
[collectd.git] / src / match_regex.c
1 /**
2  * collectd - src/match_regex.c
3  * Copyright (C) 2008  Sebastian Harl
4  * Copyright (C) 2008  Florian Forster
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License as published by the
8  * Free Software Foundation; only version 2 of the License is applicable.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with this program; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
18  *
19  * Authors:
20  *   Sebastian Harl <sh at tokkee.org>
21  *   Florian Forster <octo at verplant.org>
22  **/
23
24 /*
25  * This module allows to filter and rewrite value lists based on
26  * Perl-compatible regular expressions.
27  */
28
29 #include "collectd.h"
30 #include "filter_chain.h"
31
32 #include <sys/types.h>
33 #include <regex.h>
34
35 #define log_err(...) ERROR ("`regex' match: " __VA_ARGS__)
36 #define log_warn(...) WARNING ("`regex' match: " __VA_ARGS__)
37
38 /*
39  * private data types
40  */
41
42 struct mr_regex_s;
43 typedef struct mr_regex_s mr_regex_t;
44 struct mr_regex_s
45 {
46         regex_t re;
47         char *re_str;
48
49         mr_regex_t *next;
50 };
51
52 struct mr_match_s;
53 typedef struct mr_match_s mr_match_t;
54 struct mr_match_s
55 {
56         mr_regex_t *host;
57         mr_regex_t *plugin;
58         mr_regex_t *plugin_instance;
59         mr_regex_t *type;
60         mr_regex_t *type_instance;
61         _Bool invert;
62 };
63
64 /*
65  * internal helper functions
66  */
67 static void mr_free_regex (mr_regex_t *r) /* {{{ */
68 {
69         if (r == NULL)
70                 return;
71
72         regfree (&r->re);
73         memset (&r->re, 0, sizeof (r->re));
74         free (r->re_str);
75
76         if (r->next != NULL)
77                 mr_free_regex (r->next);
78 } /* }}} void mr_free_regex */
79
80 static void mr_free_match (mr_match_t *m) /* {{{ */
81 {
82         if (m == NULL)
83                 return;
84
85         mr_free_regex (m->host);
86         mr_free_regex (m->plugin);
87         mr_free_regex (m->plugin_instance);
88         mr_free_regex (m->type);
89         mr_free_regex (m->type_instance);
90
91         free (m);
92 } /* }}} void mr_free_match */
93
94 static int mr_match_regexen (mr_regex_t *re_head, /* {{{ */
95                 const char *string)
96 {
97         mr_regex_t *re;
98
99         if (re_head == NULL)
100                 return (FC_MATCH_MATCHES);
101
102         for (re = re_head; re != NULL; re = re->next)
103         {
104                 int status;
105
106                 status = regexec (&re->re, string,
107                                 /* nmatch = */ 0, /* pmatch = */ NULL,
108                                 /* eflags = */ 0);
109                 if (status == 0)
110                 {
111                         DEBUG ("regex match: Regular expression `%s' matches `%s'.",
112                                         re->re_str, string);
113                 }
114                 else
115                 {
116                         DEBUG ("regex match: Regular expression `%s' does not match `%s'.",
117                                         re->re_str, string);
118                         return (FC_MATCH_NO_MATCH);
119                 }
120
121         }
122
123         return (FC_MATCH_MATCHES);
124 } /* }}} int mr_match_regexen */
125
126 static int mr_config_add_regex (mr_regex_t **re_head, /* {{{ */
127                 oconfig_item_t *ci)
128 {
129         mr_regex_t *re;
130         int status;
131
132         if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
133         {
134                 log_warn ("`%s' needs exactly one string argument.", ci->key);
135                 return (-1);
136         }
137
138         re = (mr_regex_t *) malloc (sizeof (*re));
139         if (re == NULL)
140         {
141                 log_err ("mr_config_add_regex: malloc failed.");
142                 return (-1);
143         }
144         memset (re, 0, sizeof (*re));
145         re->next = NULL;
146
147         re->re_str = strdup (ci->values[0].value.string);
148         if (re->re_str == NULL)
149         {
150                 free (re);
151                 log_err ("mr_config_add_regex: strdup failed.");
152                 return (-1);
153         }
154
155         status = regcomp (&re->re, re->re_str, REG_EXTENDED | REG_NOSUB);
156         if (status != 0)
157         {
158                 char errmsg[1024];
159                 regerror (status, &re->re, errmsg, sizeof (errmsg));
160                 errmsg[sizeof (errmsg) - 1] = 0;
161                 log_err ("Compiling regex `%s' for `%s' failed: %s.", 
162                                 re->re_str, ci->key, errmsg);
163                 free (re->re_str);
164                 free (re);
165                 return (-1);
166         }
167
168         if (*re_head == NULL)
169         {
170                 *re_head = re;
171         }
172         else
173         {
174                 mr_regex_t *ptr;
175
176                 ptr = *re_head;
177                 while (ptr->next != NULL)
178                         ptr = ptr->next;
179
180                 ptr->next = re;
181         }
182
183         return (0);
184 } /* }}} int mr_config_add_regex */
185
186 static int mr_create (const oconfig_item_t *ci, void **user_data) /* {{{ */
187 {
188         mr_match_t *m;
189         int status;
190         int i;
191
192         m = (mr_match_t *) malloc (sizeof (*m));
193         if (m == NULL)
194         {
195                 log_err ("mr_create: malloc failed.");
196                 return (-ENOMEM);
197         }
198         memset (m, 0, sizeof (*m));
199         
200         m->invert = 0;
201
202         status = 0;
203         for (i = 0; i < ci->children_num; i++)
204         {
205                 oconfig_item_t *child = ci->children + i;
206
207                 if ((strcasecmp ("Host", child->key) == 0)
208                                 || (strcasecmp ("Hostname", child->key) == 0))
209                         status = mr_config_add_regex (&m->host, child);
210                 else if (strcasecmp ("Plugin", child->key) == 0)
211                         status = mr_config_add_regex (&m->plugin, child);
212                 else if (strcasecmp ("PluginInstance", child->key) == 0)
213                         status = mr_config_add_regex (&m->plugin_instance, child);
214                 else if (strcasecmp ("Type", child->key) == 0)
215                         status = mr_config_add_regex (&m->type, child);
216                 else if (strcasecmp ("TypeInstance", child->key) == 0)
217                         status = mr_config_add_regex (&m->type_instance, child);
218                 else if (strcasecmp ("Invert", child->key) == 0)
219                         status = cf_util_get_boolean(child, &m->invert);
220                 else
221                 {
222                         log_err ("The `%s' configuration option is not understood and "
223                                         "will be ignored.", child->key);
224                         status = 0;
225                 }
226
227                 if (status != 0)
228                         break;
229         }
230
231         /* Additional sanity-checking */
232         while (status == 0)
233         {
234                 if ((m->host == NULL)
235                                 && (m->plugin == NULL)
236                                 && (m->plugin_instance == NULL)
237                                 && (m->type == NULL)
238                                 && (m->type_instance == NULL))
239                 {
240                         log_err ("No (valid) regular expressions have been configured. "
241                                         "This match will be ignored.");
242                         status = -1;
243                 }
244
245                 break;
246         }
247
248         if (status != 0)
249         {
250                 mr_free_match (m);
251                 return (status);
252         }
253
254         *user_data = m;
255         return (0);
256 } /* }}} int mr_create */
257
258 static int mr_destroy (void **user_data) /* {{{ */
259 {
260         if ((user_data != NULL) && (*user_data != NULL))
261                 mr_free_match (*user_data);
262         return (0);
263 } /* }}} int mr_destroy */
264
265 static int mr_match (const data_set_t __attribute__((unused)) *ds, /* {{{ */
266                 const value_list_t *vl,
267                 notification_meta_t __attribute__((unused)) **meta,
268                 void **user_data)
269 {
270         mr_match_t *m;
271         int match_value = FC_MATCH_MATCHES;
272         int nomatch_value = FC_MATCH_NO_MATCH;
273
274         if ((user_data == NULL) || (*user_data == NULL))
275                 return (-1);
276
277         m = *user_data;
278
279         if (m->invert)
280         {
281                 match_value = FC_MATCH_NO_MATCH;
282                 nomatch_value = FC_MATCH_MATCHES;
283         }
284
285         if (mr_match_regexen (m->host, vl->host) == FC_MATCH_NO_MATCH)
286                 return (nomatch_value);
287         if (mr_match_regexen (m->plugin, vl->plugin) == FC_MATCH_NO_MATCH)
288                 return (nomatch_value);
289         if (mr_match_regexen (m->plugin_instance,
290                                 vl->plugin_instance) == FC_MATCH_NO_MATCH)
291                 return (nomatch_value);
292         if (mr_match_regexen (m->type, vl->type) == FC_MATCH_NO_MATCH)
293                 return (nomatch_value);
294         if (mr_match_regexen (m->type_instance,
295                                 vl->type_instance) == FC_MATCH_NO_MATCH)
296                 return (nomatch_value);
297
298         return (match_value);
299 } /* }}} int mr_match */
300
301 void module_register (void)
302 {
303         match_proc_t mproc;
304
305         memset (&mproc, 0, sizeof (mproc));
306         mproc.create  = mr_create;
307         mproc.destroy = mr_destroy;
308         mproc.match   = mr_match;
309         fc_register_match ("regex", mproc);
310 } /* module_register */
311
312 /* vim: set sw=4 ts=4 tw=78 noexpandtab fdm=marker : */
313