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
17 * Licence along with this program; if not, write to the Free
18 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
19 * USA.
20 *
21 * Authors:
22 * Lubos Stanek <lubek at users.sourceforge.net>
23 * Florian Forster <octo at collectd.org>
24 **/
25 /**
26 * ignorelist handles plugin's list of configured collectable
27 * entries with global ignore action
28 **/
29 /**
30 * Usage:
31 *
32 * Define plugin's global pointer variable of type ignorelist_t:
33 * ignorelist_t *myconfig_ignore;
34 * If you know the state of the global ignore (IgnoreSelected),
35 * allocate the variable with:
36 * myconfig_ignore = ignorelist_create (YourKnownIgnore);
37 * If you do not know the state of the global ignore,
38 * initialize the global variable and set the ignore flag later:
39 * myconfig_ignore = ignorelist_init ();
40 * Append single entries in your cf_register'ed callback function:
41 * ignorelist_add (myconfig_ignore, newentry);
42 * When you hit the IgnoreSelected config option,
43 * offer it to the list:
44 * ignorelist_ignore (myconfig_ignore, instantly_got_value_of_ignore);
45 * That is all for the ignorelist initialization.
46 * Later during read and write (plugin's registered functions) get
47 * the information whether this entry would be collected or not:
48 * if (ignorelist_match (myconfig_ignore, thisentry))
49 * return;
50 **/
52 #if HAVE_CONFIG_H
53 # include "config.h"
54 #endif
56 #include "common.h"
57 #include "plugin.h"
58 #include "utils_ignorelist.h"
60 /*
61 * private prototypes
62 */
63 struct ignorelist_item_s
64 {
65 #if HAVE_REGEX_H
66 regex_t *rmatch; /* regular expression entry identification */
67 #endif
68 char *smatch; /* string entry identification */
69 struct ignorelist_item_s *next;
70 };
71 typedef struct ignorelist_item_s ignorelist_item_t;
73 struct ignorelist_s
74 {
75 int ignore; /* ignore entries */
76 ignorelist_item_t *head; /* pointer to the first entry */
77 };
79 /* *** *** *** ********************************************* *** *** *** */
80 /* *** *** *** *** *** *** private functions *** *** *** *** *** *** */
81 /* *** *** *** ********************************************* *** *** *** */
83 static inline void ignorelist_append (ignorelist_t *il, ignorelist_item_t *item)
84 {
85 assert ((il != NULL) && (item != NULL));
87 item->next = il->head;
88 il->head = item;
89 }
91 #if HAVE_REGEX_H
92 static int ignorelist_append_regex(ignorelist_t *il, const char *entry)
93 {
94 regex_t *re;
95 ignorelist_item_t *item;
96 int status;
98 /* create buffer */
99 re = malloc (sizeof (*re));
100 if (re == NULL)
101 {
102 ERROR ("ignorelist_append_regex: malloc failed.");
103 return ENOMEM;
104 }
105 memset (re, 0, sizeof (*re));
107 /* compile regex */
108 status = regcomp (re, entry, REG_EXTENDED);
109 if (status != 0)
110 {
111 char errbuf[1024];
113 (void) regerror (status, re, errbuf, sizeof (errbuf));
114 ERROR ("ignorelist_append_regex: Compiling regular expression \"%s\" failed: %s", entry, errbuf);
115 sfree (re);
116 return status;
117 }
119 /* create new entry */
120 item = malloc (sizeof (*item));
121 if (item == NULL)
122 {
123 ERROR ("ignorelist_append_regex: malloc failed.");
124 regfree (re);
125 sfree (re);
126 return ENOMEM;
127 }
128 memset (item, 0, sizeof (*item));
129 item->rmatch = re;
131 /* append new entry */
132 ignorelist_append (il, item);
134 return (0);
135 } /* int ignorelist_append_regex(ignorelist_t *il, const char *entry) */
136 #endif
138 static int ignorelist_append_string(ignorelist_t *il, const char *entry)
139 {
140 ignorelist_item_t *new;
142 /* create new entry */
143 if ((new = malloc(sizeof(ignorelist_item_t))) == NULL )
144 {
145 ERROR ("cannot allocate new entry");
146 return (1);
147 }
148 memset (new, '\0', sizeof(ignorelist_item_t));
149 new->smatch = sstrdup(entry);
151 /* append new entry */
152 ignorelist_append (il, new);
154 return (0);
155 } /* int ignorelist_append_string(ignorelist_t *il, const char *entry) */
157 #if HAVE_REGEX_H
158 /*
159 * check list for entry regex match
160 * return 1 if found
161 */
162 static int ignorelist_match_regex (ignorelist_item_t *item, const char *entry)
163 {
164 assert ((item != NULL) && (item->rmatch != NULL)
165 && (entry != NULL) && (strlen (entry) > 0));
167 /* match regex */
168 if (regexec (item->rmatch, entry, 0, NULL, 0) == 0)
169 return (1);
171 return (0);
172 } /* int ignorelist_match_regex (ignorelist_item_t *item, const char *entry) */
173 #endif
175 /*
176 * check list for entry string match
177 * return 1 if found
178 */
179 static int ignorelist_match_string (ignorelist_item_t *item, const char *entry)
180 {
181 assert ((item != NULL) && (item->smatch != NULL)
182 && (entry != NULL) && (strlen (entry) > 0));
184 if (strcmp (entry, item->smatch) == 0)
185 return (1);
187 return (0);
188 } /* int ignorelist_match_string (ignorelist_item_t *item, const char *entry) */
191 /* *** *** *** ******************************************** *** *** *** */
192 /* *** *** *** *** *** *** public functions *** *** *** *** *** *** */
193 /* *** *** *** ******************************************** *** *** *** */
195 /*
196 * create the ignorelist_t with known ignore state
197 * return pointer to ignorelist_t
198 */
199 ignorelist_t *ignorelist_create (int invert)
200 {
201 ignorelist_t *il;
203 il = malloc (sizeof (*il));
204 if (il == NULL)
205 return NULL;
206 memset (il, 0, sizeof (*il));
208 /*
209 * ->ignore == 0 => collect
210 * ->ignore == 1 => ignore
211 */
212 il->ignore = invert ? 0 : 1;
214 return (il);
215 } /* ignorelist_t *ignorelist_create (int ignore) */
217 /*
218 * free memory used by ignorelist_t
219 */
220 void ignorelist_free (ignorelist_t *il)
221 {
222 ignorelist_item_t *this;
223 ignorelist_item_t *next;
225 if (il == NULL)
226 return;
228 for (this = il->head; this != NULL; this = next)
229 {
230 next = this->next;
231 #if HAVE_REGEX_H
232 if (this->rmatch != NULL)
233 {
234 regfree (this->rmatch);
235 sfree (this->rmatch);
236 this->rmatch = NULL;
237 }
238 #endif
239 if (this->smatch != NULL)
240 {
241 sfree (this->smatch);
242 this->smatch = NULL;
243 }
244 sfree (this);
245 }
247 sfree (il);
248 il = NULL;
249 } /* void ignorelist_destroy (ignorelist_t *il) */
251 /*
252 * set ignore state of the ignorelist_t
253 */
254 void ignorelist_set_invert (ignorelist_t *il, int invert)
255 {
256 if (il == NULL)
257 {
258 DEBUG("ignore call with ignorelist_t == NULL");
259 return;
260 }
262 il->ignore = invert ? 0 : 1;
263 } /* void ignorelist_set_invert (ignorelist_t *il, int ignore) */
265 /*
266 * append entry into ignorelist_t
267 * return 1 for success
268 */
269 int ignorelist_add (ignorelist_t *il, const char *entry)
270 {
271 size_t len;
273 if (il == NULL)
274 {
275 DEBUG ("add called with ignorelist_t == NULL");
276 return (1);
277 }
279 len = strlen (entry);
281 /* append nothing */
282 if (len == 0)
283 {
284 DEBUG("not appending: empty entry");
285 return (1);
286 }
288 #if HAVE_REGEX_H
289 /* regex string is enclosed in "/.../" */
290 if ((len > 2) && (entry[0] == '/') && entry[len - 1] == '/')
291 {
292 char *copy;
293 int status;
295 /* skip leading slash */
296 copy = strdup (entry + 1);
297 if (copy == NULL)
298 return ENOMEM;
300 /* trim trailing slash */
301 copy[strlen (copy) - 1] = 0;
303 status = ignorelist_append_regex (il, copy);
304 sfree (copy);
305 return status;
306 }
307 #endif
309 return ignorelist_append_string(il, entry);
310 } /* int ignorelist_add (ignorelist_t *il, const char *entry) */
312 /*
313 * check list for entry
314 * return 1 for ignored entry
315 */
316 int ignorelist_match (ignorelist_t *il, const char *entry)
317 {
318 ignorelist_item_t *traverse;
320 /* if no entries, collect all */
321 if ((il == NULL) || (il->head == NULL))
322 return (0);
324 if ((entry == NULL) || (strlen (entry) == 0))
325 return (0);
327 /* traverse list and check entries */
328 for (traverse = il->head; traverse != NULL; traverse = traverse->next)
329 {
330 #if HAVE_REGEX_H
331 if (traverse->rmatch != NULL)
332 {
333 if (ignorelist_match_regex (traverse, entry))
334 return (il->ignore);
335 }
336 else
337 #endif
338 {
339 if (ignorelist_match_string (traverse, entry))
340 return (il->ignore);
341 }
342 } /* for traverse */
344 return (1 - il->ignore);
345 } /* int ignorelist_match (ignorelist_t *il, const char *entry) */