Merge branch 'collectd-5.7'
[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
36 #include "common.h"
37 #include "filter_chain.h"
38 #include "meta_data.h"
39 #include "utils_llist.h"
40
41 #include <regex.h>
42 #include <sys/types.h>
43
44 #define log_err(...) ERROR("`regex' match: " __VA_ARGS__)
45 #define log_warn(...) WARNING("`regex' match: " __VA_ARGS__)
46
47 /*
48  * private data types
49  */
50
51 struct mr_regex_s;
52 typedef struct mr_regex_s mr_regex_t;
53 struct mr_regex_s {
54   regex_t re;
55   char *re_str;
56
57   mr_regex_t *next;
58 };
59
60 struct mr_match_s;
61 typedef struct mr_match_s mr_match_t;
62 struct mr_match_s {
63   mr_regex_t *host;
64   mr_regex_t *plugin;
65   mr_regex_t *plugin_instance;
66   mr_regex_t *type;
67   mr_regex_t *type_instance;
68   llist_t *meta; /* Maps each meta key into mr_regex_t* */
69   _Bool invert;
70 };
71
72 /*
73  * internal helper functions
74  */
75 static void mr_free_regex(mr_regex_t *r) /* {{{ */
76 {
77   if (r == NULL)
78     return;
79
80   regfree(&r->re);
81   memset(&r->re, 0, sizeof(r->re));
82   sfree(r->re_str);
83
84   if (r->next != NULL)
85     mr_free_regex(r->next);
86 } /* }}} void mr_free_regex */
87
88 static void mr_free_match(mr_match_t *m) /* {{{ */
89 {
90   if (m == NULL)
91     return;
92
93   mr_free_regex(m->host);
94   mr_free_regex(m->plugin);
95   mr_free_regex(m->plugin_instance);
96   mr_free_regex(m->type);
97   mr_free_regex(m->type_instance);
98   for (llentry_t *e = llist_head(m->meta); e != NULL; e = e->next) {
99     sfree(e->key);
100     mr_free_regex((mr_regex_t *)e->value);
101   }
102   llist_destroy(m->meta);
103
104   sfree(m);
105 } /* }}} void mr_free_match */
106
107 static int mr_match_regexen(mr_regex_t *re_head, /* {{{ */
108                             const char *string) {
109   if (re_head == NULL)
110     return (FC_MATCH_MATCHES);
111
112   for (mr_regex_t *re = re_head; re != NULL; re = re->next) {
113     int status;
114
115     status = regexec(&re->re, string,
116                      /* nmatch = */ 0, /* pmatch = */ NULL,
117                      /* eflags = */ 0);
118     if (status == 0) {
119       DEBUG("regex match: Regular expression `%s' matches `%s'.", re->re_str,
120             string);
121     } else {
122       DEBUG("regex match: Regular expression `%s' does not match `%s'.",
123             re->re_str, string);
124       return (FC_MATCH_NO_MATCH);
125     }
126   }
127
128   return (FC_MATCH_MATCHES);
129 } /* }}} int mr_match_regexen */
130
131 static int mr_add_regex(mr_regex_t **re_head, const char *re_str, /* {{{ */
132                         const char *option) {
133   mr_regex_t *re;
134   int status;
135
136   re = calloc(1, sizeof(*re));
137   if (re == NULL) {
138     log_err("mr_add_regex: calloc failed.");
139     return (-1);
140   }
141   re->next = NULL;
142
143   re->re_str = strdup(re_str);
144   if (re->re_str == NULL) {
145     sfree(re);
146     log_err("mr_add_regex: strdup failed.");
147     return (-1);
148   }
149
150   status = regcomp(&re->re, re->re_str, REG_EXTENDED | REG_NOSUB);
151   if (status != 0) {
152     char errmsg[1024];
153     regerror(status, &re->re, errmsg, sizeof(errmsg));
154     errmsg[sizeof(errmsg) - 1] = 0;
155     log_err("Compiling regex `%s' for `%s' failed: %s.", re->re_str, option,
156             errmsg);
157     sfree(re->re_str);
158     sfree(re);
159     return (-1);
160   }
161
162   if (*re_head == NULL) {
163     *re_head = re;
164   } else {
165     mr_regex_t *ptr;
166
167     ptr = *re_head;
168     while (ptr->next != NULL)
169       ptr = ptr->next;
170
171     ptr->next = re;
172   }
173
174   return (0);
175 } /* }}} int mr_add_regex */
176
177 static int mr_config_add_regex(mr_regex_t **re_head, /* {{{ */
178                                oconfig_item_t *ci) {
179   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
180     log_warn("`%s' needs exactly one string argument.", ci->key);
181     return (-1);
182   }
183
184   return mr_add_regex(re_head, ci->values[0].value.string, ci->key);
185 } /* }}} int mr_config_add_regex */
186
187 static int mr_config_add_meta_regex(llist_t **meta, /* {{{ */
188                                     oconfig_item_t *ci) {
189   char *meta_key;
190   llentry_t *entry;
191   mr_regex_t *re_head;
192   int status;
193   char buffer[1024];
194
195   if ((ci->values_num != 2) || (ci->values[0].type != OCONFIG_TYPE_STRING) ||
196       (ci->values[1].type != OCONFIG_TYPE_STRING)) {
197     log_warn("`%s' needs exactly two string arguments.", ci->key);
198     return (-1);
199   }
200
201   if (*meta == NULL) {
202     *meta = llist_create();
203     if (*meta == NULL) {
204       log_err("mr_config_add_meta_regex: llist_create failed.");
205       return (-1);
206     }
207   }
208
209   meta_key = ci->values[0].value.string;
210   entry = llist_search(*meta, meta_key);
211   if (entry == NULL) {
212     meta_key = strdup(meta_key);
213     if (meta_key == NULL) {
214       log_err("mr_config_add_meta_regex: strdup failed.");
215       return (-1);
216     }
217     entry = llentry_create(meta_key, NULL);
218     if (entry == NULL) {
219       log_err("mr_config_add_meta_regex: llentry_create failed.");
220       sfree(meta_key);
221       return (-1);
222     }
223     /* meta_key and entry will now be freed by mr_free_match(). */
224     llist_append(*meta, entry);
225   }
226
227   ssnprintf(buffer, sizeof(buffer), "%s `%s'", ci->key, meta_key);
228   /* Can't pass &entry->value into mr_add_regex, so copy in/out. */
229   re_head = entry->value;
230   status = mr_add_regex(&re_head, ci->values[1].value.string, buffer);
231   if (status == 0) {
232     entry->value = re_head;
233   }
234   return status;
235 } /* }}} int mr_config_add_meta_regex */
236
237 static int mr_create(const oconfig_item_t *ci, void **user_data) /* {{{ */
238 {
239   mr_match_t *m;
240   int status;
241
242   m = calloc(1, sizeof(*m));
243   if (m == NULL) {
244     log_err("mr_create: calloc failed.");
245     return (-ENOMEM);
246   }
247
248   m->invert = 0;
249
250   status = 0;
251   for (int i = 0; i < ci->children_num; i++) {
252     oconfig_item_t *child = ci->children + i;
253
254     if ((strcasecmp("Host", child->key) == 0) ||
255         (strcasecmp("Hostname", child->key) == 0))
256       status = mr_config_add_regex(&m->host, child);
257     else if (strcasecmp("Plugin", child->key) == 0)
258       status = mr_config_add_regex(&m->plugin, child);
259     else if (strcasecmp("PluginInstance", child->key) == 0)
260       status = mr_config_add_regex(&m->plugin_instance, child);
261     else if (strcasecmp("Type", child->key) == 0)
262       status = mr_config_add_regex(&m->type, child);
263     else if (strcasecmp("TypeInstance", child->key) == 0)
264       status = mr_config_add_regex(&m->type_instance, child);
265     else if (strcasecmp("MetaData", child->key) == 0)
266       status = mr_config_add_meta_regex(&m->meta, child);
267     else if (strcasecmp("Invert", child->key) == 0)
268       status = cf_util_get_boolean(child, &m->invert);
269     else {
270       log_err("The `%s' configuration option is not understood and "
271               "will be ignored.",
272               child->key);
273       status = 0;
274     }
275
276     if (status != 0)
277       break;
278   }
279
280   /* Additional sanity-checking */
281   while (status == 0) {
282     if ((m->host == NULL) && (m->plugin == NULL) &&
283         (m->plugin_instance == NULL) && (m->type == NULL) &&
284         (m->type_instance == NULL) && (m->meta == NULL)) {
285       log_err("No (valid) regular expressions have been configured. "
286               "This match will be ignored.");
287       status = -1;
288     }
289
290     break;
291   }
292
293   if (status != 0) {
294     mr_free_match(m);
295     return (status);
296   }
297
298   *user_data = m;
299   return (0);
300 } /* }}} int mr_create */
301
302 static int mr_destroy(void **user_data) /* {{{ */
303 {
304   if ((user_data != NULL) && (*user_data != NULL))
305     mr_free_match(*user_data);
306   return (0);
307 } /* }}} int mr_destroy */
308
309 static int mr_match(const data_set_t __attribute__((unused)) * ds, /* {{{ */
310                     const value_list_t *vl,
311                     notification_meta_t __attribute__((unused)) * *meta,
312                     void **user_data) {
313   mr_match_t *m;
314   int match_value = FC_MATCH_MATCHES;
315   int nomatch_value = FC_MATCH_NO_MATCH;
316
317   if ((user_data == NULL) || (*user_data == NULL))
318     return (-1);
319
320   m = *user_data;
321
322   if (m->invert) {
323     match_value = FC_MATCH_NO_MATCH;
324     nomatch_value = FC_MATCH_MATCHES;
325   }
326
327   if (mr_match_regexen(m->host, vl->host) == FC_MATCH_NO_MATCH)
328     return (nomatch_value);
329   if (mr_match_regexen(m->plugin, vl->plugin) == FC_MATCH_NO_MATCH)
330     return (nomatch_value);
331   if (mr_match_regexen(m->plugin_instance, vl->plugin_instance) ==
332       FC_MATCH_NO_MATCH)
333     return (nomatch_value);
334   if (mr_match_regexen(m->type, vl->type) == FC_MATCH_NO_MATCH)
335     return (nomatch_value);
336   if (mr_match_regexen(m->type_instance, vl->type_instance) ==
337       FC_MATCH_NO_MATCH)
338     return (nomatch_value);
339   if (vl->meta != NULL) {
340     for (llentry_t *e = llist_head(m->meta); e != NULL; e = e->next) {
341       mr_regex_t *meta_re = (mr_regex_t *)e->value;
342       char *value;
343       int status = meta_data_get_string(vl->meta, e->key, &value);
344       if (status == (-ENOENT)) /* key is not present */
345         return (nomatch_value);
346       if (status != 0) /* some other problem */
347         continue;      /* error will have already been printed. */
348       if (mr_match_regexen(meta_re, value) == FC_MATCH_NO_MATCH) {
349         sfree(value);
350         return (nomatch_value);
351       }
352       sfree(value);
353     }
354   }
355
356   return (match_value);
357 } /* }}} int mr_match */
358
359 void module_register(void) {
360   match_proc_t mproc = {0};
361
362   mproc.create = mr_create;
363   mproc.destroy = mr_destroy;
364   mproc.match = mr_match;
365   fc_register_match("regex", mproc);
366 } /* module_register */