write_kafka: correct mistyped function name
[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  * Permission is hereby granted, free of charge, to any person obtaining a
7  * copy of this software and associated documentation files (the "Software"),
8  * to deal in the Software without restriction, including without limitation
9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10  * and/or sell copies of the Software, and to permit persons to whom the
11  * Software is furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22  * DEALINGS IN THE SOFTWARE.
23  *
24  * Authors:
25  *   Sebastian Harl <sh at tokkee.org>
26  *   Florian Forster <octo at collectd.org>
27  **/
28
29 /*
30  * This module allows to filter and rewrite value lists based on
31  * Perl-compatible regular expressions.
32  */
33
34 #include "collectd.h"
35 #include "filter_chain.h"
36
37 #include <sys/types.h>
38 #include <regex.h>
39
40 #define log_err(...) ERROR ("`regex' match: " __VA_ARGS__)
41 #define log_warn(...) WARNING ("`regex' match: " __VA_ARGS__)
42
43 /*
44  * private data types
45  */
46
47 struct mr_regex_s;
48 typedef struct mr_regex_s mr_regex_t;
49 struct mr_regex_s
50 {
51         regex_t re;
52         char *re_str;
53
54         mr_regex_t *next;
55 };
56
57 struct mr_match_s;
58 typedef struct mr_match_s mr_match_t;
59 struct mr_match_s
60 {
61         mr_regex_t *host;
62         mr_regex_t *plugin;
63         mr_regex_t *plugin_instance;
64         mr_regex_t *type;
65         mr_regex_t *type_instance;
66         _Bool invert;
67 };
68
69 /*
70  * internal helper functions
71  */
72 static void mr_free_regex (mr_regex_t *r) /* {{{ */
73 {
74         if (r == NULL)
75                 return;
76
77         regfree (&r->re);
78         memset (&r->re, 0, sizeof (r->re));
79         free (r->re_str);
80
81         if (r->next != NULL)
82                 mr_free_regex (r->next);
83 } /* }}} void mr_free_regex */
84
85 static void mr_free_match (mr_match_t *m) /* {{{ */
86 {
87         if (m == NULL)
88                 return;
89
90         mr_free_regex (m->host);
91         mr_free_regex (m->plugin);
92         mr_free_regex (m->plugin_instance);
93         mr_free_regex (m->type);
94         mr_free_regex (m->type_instance);
95
96         free (m);
97 } /* }}} void mr_free_match */
98
99 static int mr_match_regexen (mr_regex_t *re_head, /* {{{ */
100                 const char *string)
101 {
102         mr_regex_t *re;
103
104         if (re_head == NULL)
105                 return (FC_MATCH_MATCHES);
106
107         for (re = re_head; re != NULL; re = re->next)
108         {
109                 int status;
110
111                 status = regexec (&re->re, string,
112                                 /* nmatch = */ 0, /* pmatch = */ NULL,
113                                 /* eflags = */ 0);
114                 if (status == 0)
115                 {
116                         DEBUG ("regex match: Regular expression `%s' matches `%s'.",
117                                         re->re_str, string);
118                 }
119                 else
120                 {
121                         DEBUG ("regex match: Regular expression `%s' does not match `%s'.",
122                                         re->re_str, string);
123                         return (FC_MATCH_NO_MATCH);
124                 }
125
126         }
127
128         return (FC_MATCH_MATCHES);
129 } /* }}} int mr_match_regexen */
130
131 static int mr_config_add_regex (mr_regex_t **re_head, /* {{{ */
132                 oconfig_item_t *ci)
133 {
134         mr_regex_t *re;
135         int status;
136
137         if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
138         {
139                 log_warn ("`%s' needs exactly one string argument.", ci->key);
140                 return (-1);
141         }
142
143         re = (mr_regex_t *) malloc (sizeof (*re));
144         if (re == NULL)
145         {
146                 log_err ("mr_config_add_regex: malloc failed.");
147                 return (-1);
148         }
149         memset (re, 0, sizeof (*re));
150         re->next = NULL;
151
152         re->re_str = strdup (ci->values[0].value.string);
153         if (re->re_str == NULL)
154         {
155                 free (re);
156                 log_err ("mr_config_add_regex: strdup failed.");
157                 return (-1);
158         }
159
160         status = regcomp (&re->re, re->re_str, REG_EXTENDED | REG_NOSUB);
161         if (status != 0)
162         {
163                 char errmsg[1024];
164                 regerror (status, &re->re, errmsg, sizeof (errmsg));
165                 errmsg[sizeof (errmsg) - 1] = 0;
166                 log_err ("Compiling regex `%s' for `%s' failed: %s.", 
167                                 re->re_str, ci->key, errmsg);
168                 free (re->re_str);
169                 free (re);
170                 return (-1);
171         }
172
173         if (*re_head == NULL)
174         {
175                 *re_head = re;
176         }
177         else
178         {
179                 mr_regex_t *ptr;
180
181                 ptr = *re_head;
182                 while (ptr->next != NULL)
183                         ptr = ptr->next;
184
185                 ptr->next = re;
186         }
187
188         return (0);
189 } /* }}} int mr_config_add_regex */
190
191 static int mr_create (const oconfig_item_t *ci, void **user_data) /* {{{ */
192 {
193         mr_match_t *m;
194         int status;
195         int i;
196
197         m = (mr_match_t *) malloc (sizeof (*m));
198         if (m == NULL)
199         {
200                 log_err ("mr_create: malloc failed.");
201                 return (-ENOMEM);
202         }
203         memset (m, 0, sizeof (*m));
204         
205         m->invert = 0;
206
207         status = 0;
208         for (i = 0; i < ci->children_num; i++)
209         {
210                 oconfig_item_t *child = ci->children + i;
211
212                 if ((strcasecmp ("Host", child->key) == 0)
213                                 || (strcasecmp ("Hostname", child->key) == 0))
214                         status = mr_config_add_regex (&m->host, child);
215                 else if (strcasecmp ("Plugin", child->key) == 0)
216                         status = mr_config_add_regex (&m->plugin, child);
217                 else if (strcasecmp ("PluginInstance", child->key) == 0)
218                         status = mr_config_add_regex (&m->plugin_instance, child);
219                 else if (strcasecmp ("Type", child->key) == 0)
220                         status = mr_config_add_regex (&m->type, child);
221                 else if (strcasecmp ("TypeInstance", child->key) == 0)
222                         status = mr_config_add_regex (&m->type_instance, child);
223                 else if (strcasecmp ("Invert", child->key) == 0)
224                         status = cf_util_get_boolean(child, &m->invert);
225                 else
226                 {
227                         log_err ("The `%s' configuration option is not understood and "
228                                         "will be ignored.", child->key);
229                         status = 0;
230                 }
231
232                 if (status != 0)
233                         break;
234         }
235
236         /* Additional sanity-checking */
237         while (status == 0)
238         {
239                 if ((m->host == NULL)
240                                 && (m->plugin == NULL)
241                                 && (m->plugin_instance == NULL)
242                                 && (m->type == NULL)
243                                 && (m->type_instance == NULL))
244                 {
245                         log_err ("No (valid) regular expressions have been configured. "
246                                         "This match will be ignored.");
247                         status = -1;
248                 }
249
250                 break;
251         }
252
253         if (status != 0)
254         {
255                 mr_free_match (m);
256                 return (status);
257         }
258
259         *user_data = m;
260         return (0);
261 } /* }}} int mr_create */
262
263 static int mr_destroy (void **user_data) /* {{{ */
264 {
265         if ((user_data != NULL) && (*user_data != NULL))
266                 mr_free_match (*user_data);
267         return (0);
268 } /* }}} int mr_destroy */
269
270 static int mr_match (const data_set_t __attribute__((unused)) *ds, /* {{{ */
271                 const value_list_t *vl,
272                 notification_meta_t __attribute__((unused)) **meta,
273                 void **user_data)
274 {
275         mr_match_t *m;
276         int match_value = FC_MATCH_MATCHES;
277         int nomatch_value = FC_MATCH_NO_MATCH;
278
279         if ((user_data == NULL) || (*user_data == NULL))
280                 return (-1);
281
282         m = *user_data;
283
284         if (m->invert)
285         {
286                 match_value = FC_MATCH_NO_MATCH;
287                 nomatch_value = FC_MATCH_MATCHES;
288         }
289
290         if (mr_match_regexen (m->host, vl->host) == FC_MATCH_NO_MATCH)
291                 return (nomatch_value);
292         if (mr_match_regexen (m->plugin, vl->plugin) == FC_MATCH_NO_MATCH)
293                 return (nomatch_value);
294         if (mr_match_regexen (m->plugin_instance,
295                                 vl->plugin_instance) == FC_MATCH_NO_MATCH)
296                 return (nomatch_value);
297         if (mr_match_regexen (m->type, vl->type) == FC_MATCH_NO_MATCH)
298                 return (nomatch_value);
299         if (mr_match_regexen (m->type_instance,
300                                 vl->type_instance) == FC_MATCH_NO_MATCH)
301                 return (nomatch_value);
302
303         return (match_value);
304 } /* }}} int mr_match */
305
306 void module_register (void)
307 {
308         match_proc_t mproc;
309
310         memset (&mproc, 0, sizeof (mproc));
311         mproc.create  = mr_create;
312         mproc.destroy = mr_destroy;
313         mproc.match   = mr_match;
314         fc_register_match ("regex", mproc);
315 } /* module_register */
316
317 /* vim: set sw=4 ts=4 tw=78 noexpandtab fdm=marker : */
318