Merge branch 'collectd-5.7'
[collectd.git] / src / utils_ignorelist.c
1 /**
2  * collectd - src/utils_ignorelist.c
3  * Copyright (C) 2006 Lubos Stanek <lubek at users.sourceforge.net>
4  * Copyright (C) 2008 Florian Forster <octo at collectd.org>
5  *
6  * This program is free software; you can redistribute it and/
7  * or modify it under the terms of the GNU General Public Li-
8  * cence as published by the Free Software Foundation; either
9  * version 2 of the Licence, or any later version.
10  *
11  * This program is distributed in the hope that it will be use-
12  * ful, but WITHOUT ANY WARRANTY; without even the implied war-
13  * ranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14  * See the GNU General Public Licence for more details.
15  *
16  * You should have received a copy of the GNU General Public License along
17  * with this program; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
19  *
20  * Authors:
21  *   Lubos Stanek <lubek at users.sourceforge.net>
22  *   Florian Forster <octo at collectd.org>
23  **/
24 /**
25  * ignorelist handles plugin's list of configured collectable
26  * entries with global ignore action
27  **/
28 /**
29  * Usage:
30  *
31  * Define plugin's global pointer variable of type ignorelist_t:
32  *   ignorelist_t *myconfig_ignore;
33  * If you know the state of the global ignore (IgnoreSelected),
34  * allocate the variable with:
35  *   myconfig_ignore = ignorelist_create (YourKnownIgnore);
36  * If you do not know the state of the global ignore,
37  * initialize the global variable and set the ignore flag later:
38  *   myconfig_ignore = ignorelist_init ();
39  * Append single entries in your cf_register'ed callback function:
40  *   ignorelist_add (myconfig_ignore, newentry);
41  * When you hit the IgnoreSelected config option,
42  * offer it to the list:
43  *   ignorelist_ignore (myconfig_ignore, instantly_got_value_of_ignore);
44  * That is all for the ignorelist initialization.
45  * Later during read and write (plugin's registered functions) get
46  * the information whether this entry would be collected or not:
47  *   if (ignorelist_match (myconfig_ignore, thisentry))
48  *     return;
49  **/
50
51 #if HAVE_CONFIG_H
52 #include "config.h"
53 #endif
54
55 #include "common.h"
56 #include "plugin.h"
57 #include "utils_ignorelist.h"
58
59 /*
60  * private prototypes
61  */
62 struct ignorelist_item_s {
63 #if HAVE_REGEX_H
64   regex_t *rmatch; /* regular expression entry identification */
65 #endif
66   char *smatch; /* string entry identification */
67   struct ignorelist_item_s *next;
68 };
69 typedef struct ignorelist_item_s ignorelist_item_t;
70
71 struct ignorelist_s {
72   int ignore;              /* ignore entries */
73   ignorelist_item_t *head; /* pointer to the first entry */
74 };
75
76 /* *** *** *** ********************************************* *** *** *** */
77 /* *** *** *** *** *** ***   private functions   *** *** *** *** *** *** */
78 /* *** *** *** ********************************************* *** *** *** */
79
80 static inline void ignorelist_append(ignorelist_t *il,
81                                      ignorelist_item_t *item) {
82   assert((il != NULL) && (item != NULL));
83
84   item->next = il->head;
85   il->head = item;
86 }
87
88 #if HAVE_REGEX_H
89 static int ignorelist_append_regex(ignorelist_t *il, const char *re_str) {
90   regex_t *re;
91   ignorelist_item_t *entry;
92   int status;
93
94   re = calloc(1, sizeof(*re));
95   if (re == NULL) {
96     ERROR("ignorelist_append_regex: calloc failed.");
97     return ENOMEM;
98   }
99
100   status = regcomp(re, re_str, REG_EXTENDED);
101   if (status != 0) {
102     char errbuf[1024];
103     (void)regerror(status, re, errbuf, sizeof(errbuf));
104     ERROR("utils_ignorelist: regcomp failed: %s", errbuf);
105     ERROR("ignorelist_append_regex: Compiling regular expression \"%s\" "
106           "failed: %s",
107           re_str, errbuf);
108     sfree(re);
109     return status;
110   }
111
112   entry = calloc(1, sizeof(*entry));
113   if (entry == NULL) {
114     ERROR("ignorelist_append_regex: calloc failed.");
115     regfree(re);
116     sfree(re);
117     return ENOMEM;
118   }
119   entry->rmatch = re;
120
121   ignorelist_append(il, entry);
122   return 0;
123 } /* int ignorelist_append_regex */
124 #endif
125
126 static int ignorelist_append_string(ignorelist_t *il, const char *entry) {
127   ignorelist_item_t *new;
128
129   /* create new entry */
130   if ((new = calloc(1, sizeof(*new))) == NULL) {
131     ERROR("cannot allocate new entry");
132     return 1;
133   }
134   new->smatch = sstrdup(entry);
135
136   /* append new entry */
137   ignorelist_append(il, new);
138
139   return 0;
140 } /* int ignorelist_append_string(ignorelist_t *il, const char *entry) */
141
142 #if HAVE_REGEX_H
143 /*
144  * check list for entry regex match
145  * return 1 if found
146  */
147 static int ignorelist_match_regex(ignorelist_item_t *item, const char *entry) {
148   assert((item != NULL) && (item->rmatch != NULL) && (entry != NULL) &&
149          (strlen(entry) > 0));
150
151   /* match regex */
152   if (regexec(item->rmatch, entry, 0, NULL, 0) == 0)
153     return 1;
154
155   return 0;
156 } /* int ignorelist_match_regex (ignorelist_item_t *item, const char *entry) */
157 #endif
158
159 /*
160  * check list for entry string match
161  * return 1 if found
162  */
163 static int ignorelist_match_string(ignorelist_item_t *item, const char *entry) {
164   assert((item != NULL) && (item->smatch != NULL) && (entry != NULL) &&
165          (strlen(entry) > 0));
166
167   if (strcmp(entry, item->smatch) == 0)
168     return 1;
169
170   return 0;
171 } /* int ignorelist_match_string (ignorelist_item_t *item, const char *entry) */
172
173 /* *** *** *** ******************************************** *** *** *** */
174 /* *** *** *** *** *** ***   public functions   *** *** *** *** *** *** */
175 /* *** *** *** ******************************************** *** *** *** */
176
177 /*
178  * create the ignorelist_t with known ignore state
179  * return pointer to ignorelist_t
180  */
181 ignorelist_t *ignorelist_create(int invert) {
182   ignorelist_t *il;
183
184   il = calloc(1, sizeof(*il));
185   if (il == NULL)
186     return NULL;
187
188   /*
189    * ->ignore == 0  =>  collect
190    * ->ignore == 1  =>  ignore
191    */
192   il->ignore = invert ? 0 : 1;
193
194   return il;
195 } /* ignorelist_t *ignorelist_create (int ignore) */
196
197 /*
198  * free memory used by ignorelist_t
199  */
200 void ignorelist_free(ignorelist_t *il) {
201   ignorelist_item_t *this;
202   ignorelist_item_t *next;
203
204   if (il == NULL)
205     return;
206
207   for (this = il->head; this != NULL; this = next) {
208     next = this->next;
209 #if HAVE_REGEX_H
210     if (this->rmatch != NULL) {
211       regfree(this->rmatch);
212       sfree(this->rmatch);
213       this->rmatch = NULL;
214     }
215 #endif
216     if (this->smatch != NULL) {
217       sfree(this->smatch);
218       this->smatch = NULL;
219     }
220     sfree(this);
221   }
222
223   sfree(il);
224 } /* void ignorelist_destroy (ignorelist_t *il) */
225
226 /*
227  * set ignore state of the ignorelist_t
228  */
229 void ignorelist_set_invert(ignorelist_t *il, int invert) {
230   if (il == NULL) {
231     DEBUG("ignore call with ignorelist_t == NULL");
232     return;
233   }
234
235   il->ignore = invert ? 0 : 1;
236 } /* void ignorelist_set_invert (ignorelist_t *il, int ignore) */
237
238 /*
239  * append entry into ignorelist_t
240  * return 0 for success
241  */
242 int ignorelist_add(ignorelist_t *il, const char *entry) {
243   size_t len;
244
245   if (il == NULL) {
246     DEBUG("add called with ignorelist_t == NULL");
247     return 1;
248   }
249
250   len = strlen(entry);
251
252   /* append nothing */
253   if (len == 0) {
254     DEBUG("not appending: empty entry");
255     return 1;
256   }
257
258 #if HAVE_REGEX_H
259   /* regex string is enclosed in "/.../" */
260   if ((len > 2) && (entry[0] == '/') && entry[len - 1] == '/') {
261     char *copy;
262     int status;
263
264     /* skip leading slash */
265     copy = strdup(entry + 1);
266     if (copy == NULL)
267       return ENOMEM;
268
269     /* trim trailing slash */
270     copy[strlen(copy) - 1] = 0;
271
272     status = ignorelist_append_regex(il, copy);
273     sfree(copy);
274     return status;
275   }
276 #endif
277
278   return ignorelist_append_string(il, entry);
279 } /* int ignorelist_add (ignorelist_t *il, const char *entry) */
280
281 /*
282  * check list for entry
283  * return 1 for ignored entry
284  */
285 int ignorelist_match(ignorelist_t *il, const char *entry) {
286   /* if no entries, collect all */
287   if ((il == NULL) || (il->head == NULL))
288     return 0;
289
290   if ((entry == NULL) || (strlen(entry) == 0))
291     return 0;
292
293   /* traverse list and check entries */
294   for (ignorelist_item_t *traverse = il->head; traverse != NULL;
295        traverse = traverse->next) {
296 #if HAVE_REGEX_H
297     if (traverse->rmatch != NULL) {
298       if (ignorelist_match_regex(traverse, entry))
299         return il->ignore;
300     } else
301 #endif
302     {
303       if (ignorelist_match_string(traverse, entry))
304         return il->ignore;
305     }
306   } /* for traverse */
307
308   return 1 - il->ignore;
309 } /* int ignorelist_match (ignorelist_t *il, const char *entry) */