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 verplant.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 verplant.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 **/
51 #if HAVE_CONFIG_H
52 # include "config.h"
53 #endif
55 #include "common.h"
56 #include "plugin.h"
57 #include "utils_ignorelist.h"
59 /*
60 * private prototypes
61 */
62 struct ignorelist_item_s
63 {
64 #if HAVE_REGEX_H
65 regex_t *rmatch; /* regular expression entry identification */
66 #endif
67 char *smatch; /* string entry identification */
68 struct ignorelist_item_s *next;
69 };
70 typedef struct ignorelist_item_s ignorelist_item_t;
72 struct ignorelist_s
73 {
74 int ignore; /* ignore entries */
75 ignorelist_item_t *head; /* pointer to the first entry */
76 };
78 /* *** *** *** ********************************************* *** *** *** */
79 /* *** *** *** *** *** *** private functions *** *** *** *** *** *** */
80 /* *** *** *** ********************************************* *** *** *** */
82 static inline void ignorelist_append (ignorelist_t *il, ignorelist_item_t *item)
83 {
84 assert ((il != NULL) && (item != NULL));
86 item->next = il->head;
87 il->head = item;
88 }
90 #if HAVE_REGEX_H
91 static int ignorelist_append_regex(ignorelist_t *il, const char *entry)
92 {
93 regex_t *re;
94 ignorelist_item_t *item;
95 int status;
97 /* create buffer */
98 re = malloc (sizeof (*re));
99 if (re == NULL)
100 {
101 ERROR ("ignorelist_append_regex: malloc failed.");
102 return ENOMEM;
103 }
104 memset (re, 0, sizeof (*re));
106 /* compile regex */
107 status = regcomp (re, entry, REG_EXTENDED);
108 if (status != 0)
109 {
110 char errbuf[1024];
112 (void) regerror (status, re, errbuf, sizeof (errbuf));
113 ERROR ("ignorelist_append_regex: Compiling regular expression \"%s\" failed: %s", entry, errbuf);
114 sfree (re);
115 return status;
116 }
118 /* create new entry */
119 item = malloc (sizeof (*item));
120 if (item == NULL)
121 {
122 ERROR ("ignorelist_append_regex: malloc failed.");
123 regfree (re);
124 sfree (re);
125 return ENOMEM;
126 }
127 memset (item, 0, sizeof (*item));
128 item->rmatch = re;
130 /* append new entry */
131 ignorelist_append (il, item);
133 return (0);
134 } /* int ignorelist_append_regex(ignorelist_t *il, const char *entry) */
135 #endif
137 static int ignorelist_append_string(ignorelist_t *il, const char *entry)
138 {
139 ignorelist_item_t *new;
141 /* create new entry */
142 if ((new = malloc(sizeof(ignorelist_item_t))) == NULL )
143 {
144 ERROR ("cannot allocate new entry");
145 return (1);
146 }
147 memset (new, '\0', sizeof(ignorelist_item_t));
148 new->smatch = sstrdup(entry);
150 /* append new entry */
151 ignorelist_append (il, new);
153 return (0);
154 } /* int ignorelist_append_string(ignorelist_t *il, const char *entry) */
156 #if HAVE_REGEX_H
157 /*
158 * check list for entry regex match
159 * return 1 if found
160 */
161 static int ignorelist_match_regex (ignorelist_item_t *item, const char *entry)
162 {
163 assert ((item != NULL) && (item->rmatch != NULL)
164 && (entry != NULL) && (strlen (entry) > 0));
166 /* match regex */
167 if (regexec (item->rmatch, entry, 0, NULL, 0) == 0)
168 return (1);
170 return (0);
171 } /* int ignorelist_match_regex (ignorelist_item_t *item, const char *entry) */
172 #endif
174 /*
175 * check list for entry string match
176 * return 1 if found
177 */
178 static int ignorelist_match_string (ignorelist_item_t *item, const char *entry)
179 {
180 assert ((item != NULL) && (item->smatch != NULL)
181 && (entry != NULL) && (strlen (entry) > 0));
183 if (strcmp (entry, item->smatch) == 0)
184 return (1);
186 return (0);
187 } /* int ignorelist_match_string (ignorelist_item_t *item, const char *entry) */
190 /* *** *** *** ******************************************** *** *** *** */
191 /* *** *** *** *** *** *** public functions *** *** *** *** *** *** */
192 /* *** *** *** ******************************************** *** *** *** */
194 /*
195 * create the ignorelist_t with known ignore state
196 * return pointer to ignorelist_t
197 */
198 ignorelist_t *ignorelist_create (int invert)
199 {
200 ignorelist_t *il;
202 il = malloc (sizeof (*il));
203 if (il == NULL)
204 return NULL;
205 memset (il, 0, sizeof (*il));
207 /*
208 * ->ignore == 0 => collect
209 * ->ignore == 1 => ignore
210 */
211 il->ignore = invert ? 0 : 1;
213 return (il);
214 } /* ignorelist_t *ignorelist_create (int ignore) */
216 /*
217 * free memory used by ignorelist_t
218 */
219 void ignorelist_free (ignorelist_t *il)
220 {
221 ignorelist_item_t *this;
222 ignorelist_item_t *next;
224 if (il == NULL)
225 return;
227 for (this = il->head; this != NULL; this = next)
228 {
229 next = this->next;
230 #if HAVE_REGEX_H
231 if (this->rmatch != NULL)
232 {
233 regfree (this->rmatch);
234 sfree (this->rmatch);
235 this->rmatch = NULL;
236 }
237 #endif
238 if (this->smatch != NULL)
239 {
240 sfree (this->smatch);
241 this->smatch = NULL;
242 }
243 sfree (this);
244 }
246 sfree (il);
247 il = NULL;
248 } /* void ignorelist_destroy (ignorelist_t *il) */
250 /*
251 * set ignore state of the ignorelist_t
252 */
253 void ignorelist_set_invert (ignorelist_t *il, int invert)
254 {
255 if (il == NULL)
256 {
257 DEBUG("ignore call with ignorelist_t == NULL");
258 return;
259 }
261 il->ignore = invert ? 0 : 1;
262 } /* void ignorelist_set_invert (ignorelist_t *il, int ignore) */
264 /*
265 * append entry into ignorelist_t
266 * return 1 for success
267 */
268 int ignorelist_add (ignorelist_t *il, const char *entry)
269 {
270 size_t len;
272 if (il == NULL)
273 {
274 DEBUG ("add called with ignorelist_t == NULL");
275 return (1);
276 }
278 len = strlen (entry);
280 /* append nothing */
281 if (len == 0)
282 {
283 DEBUG("not appending: empty entry");
284 return (1);
285 }
287 #if HAVE_REGEX_H
288 /* regex string is enclosed in "/.../" */
289 if ((len > 2) && (entry[0] == '/') && entry[len - 1] == '/')
290 {
291 char *copy;
292 int status;
294 /* skip leading slash */
295 copy = strdup (entry + 1);
296 if (copy == NULL)
297 return ENOMEM;
299 /* trim trailing slash */
300 copy[strlen (copy) - 1] = 0;
302 status = ignorelist_append_regex (il, copy);
303 sfree (copy);
304 return status;
305 }
306 #endif
308 return ignorelist_append_string(il, entry);
309 } /* int ignorelist_add (ignorelist_t *il, const char *entry) */
311 /*
312 * check list for entry
313 * return 1 for ignored entry
314 */
315 int ignorelist_match (ignorelist_t *il, const char *entry)
316 {
317 ignorelist_item_t *traverse;
319 /* if no entries, collect all */
320 if ((il == NULL) || (il->head == NULL))
321 return (0);
323 if ((entry == NULL) || (strlen (entry) == 0))
324 return (0);
326 /* traverse list and check entries */
327 for (traverse = il->head; traverse != NULL; traverse = traverse->next)
328 {
329 #if HAVE_REGEX_H
330 if (traverse->rmatch != NULL)
331 {
332 if (ignorelist_match_regex (traverse, entry))
333 return (il->ignore);
334 }
335 else
336 #endif
337 {
338 if (ignorelist_match_string (traverse, entry))
339 return (il->ignore);
340 }
341 } /* for traverse */
343 return (1 - il->ignore);
344 } /* int ignorelist_match (ignorelist_t *il, const char *entry) */