1 /**
2 * collectd - src/utils_ignorelist.c
3 * Copyright (C) 2006 Lubos Stanek <lubek at users.sourceforge.net>
4 *
5 * This program is free software; you can redistribute it and/
6 * or modify it under the terms of the GNU General Public Li-
7 * cence as published by the Free Software Foundation; either
8 * version 2 of the Licence, or any later version.
9 *
10 * This program is distributed in the hope that it will be use-
11 * ful, but WITHOUT ANY WARRANTY; without even the implied war-
12 * ranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13 * See the GNU General Public Licence for more details.
14 *
15 * You should have received a copy of the GNU General Public
16 * Licence along with this program; if not, write to the Free
17 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
18 * USA.
19 *
20 * Authors:
21 * Lubos Stanek <lubek at users.sourceforge.net>
22 **/
23 /**
24 * ignorelist handles plugin's list of configured collectable
25 * entries with global ignore action
26 **/
27 /**
28 * Usage:
29 *
30 * Define plugin's global pointer variable of type ignorelist_t:
31 * ignorelist_t *myconfig_ignore;
32 * If you know the state of the global ignore (IgnoreSelected),
33 * allocate the variable with:
34 * myconfig_ignore = ignorelist_create (YourKnownIgnore);
35 * If you do not know the state of the global ignore,
36 * initialize the global variable and set the ignore flag later:
37 * myconfig_ignore = ignorelist_init ();
38 * Append single entries in your cf_register'ed callback function:
39 * ignorelist_add (myconfig_ignore, newentry);
40 * When you hit the IgnoreSelected config option,
41 * offer it to the list:
42 * ignorelist_ignore (myconfig_ignore, instantly_got_value_of_ignore);
43 * That is all for the ignorelist initialization.
44 * Later during read and write (plugin's registered functions) get
45 * the information whether this entry would be collected or not:
46 * if (ignorelist_match (myconfig_ignore, thisentry))
47 * return;
48 **/
50 #include "common.h"
51 #include "utils_debug.h"
52 #include "utils_ignorelist.h"
54 /*
55 * private prototypes
56 */
57 struct ignorelist_item_s
58 {
59 #if HAVE_REGEX_H
60 regex_t *rmatch; /* regular expression entry identification */
61 #endif
62 char *smatch; /* string entry identification */
63 struct ignorelist_item_s *next;
64 };
65 typedef struct ignorelist_item_s ignorelist_item_t;
67 struct ignorelist_s
68 {
69 int ignore; /* ignore entries */
70 ignorelist_item_t *head; /* pointer to the first entry */
71 };
73 /* *** *** *** ********************************************* *** *** *** */
74 /* *** *** *** *** *** *** private functions *** *** *** *** *** *** */
75 /* *** *** *** ********************************************* *** *** *** */
77 static inline void ignorelist_append (ignorelist_t *il, ignorelist_item_t *item)
78 {
79 assert ((il != NULL) && (item != NULL));
81 item->next = il->head;
82 il->head = item;
83 }
85 #if HAVE_REGEX_H
86 static int ignorelist_append_regex(ignorelist_t *il, const char *entry)
87 {
88 int rcompile;
89 regex_t *regtemp;
90 int errsize;
91 char *regerr = NULL;
92 ignorelist_item_t *new;
94 /* create buffer */
95 if ((regtemp = malloc(sizeof(regex_t))) == NULL)
96 {
97 syslog (LOG_ERR, "cannot allocate new config entry");
98 return (1);
99 }
100 memset (regtemp, '\0', sizeof(regex_t));
102 /* compile regex */
103 if ((rcompile = regcomp (regtemp, entry, REG_EXTENDED)) != 0)
104 {
105 /* prepare message buffer */
106 errsize = regerror(rcompile, regtemp, NULL, 0);
107 if (errsize)
108 regerr = smalloc(errsize);
109 /* get error message */
110 if (regerror (rcompile, regtemp, regerr, errsize))
111 {
112 fprintf (stderr, "Cannot compile regex %s: %i/%s",
113 entry, rcompile, regerr);
114 syslog (LOG_ERR, "Cannot compile regex %s: %i/%s",
115 entry, rcompile, regerr);
116 }
117 else
118 {
119 fprintf (stderr, "Cannot compile regex %s: %i",
120 entry, rcompile);
121 syslog (LOG_ERR, "Cannot compile regex %s: %i",
122 entry, rcompile);
123 }
125 if (errsize)
126 sfree (regerr);
127 regfree (regtemp);
128 return (1);
129 }
130 DBG("regex compiled: %s - %i", entry, rcompile);
132 /* create new entry */
133 if ((new = malloc(sizeof(ignorelist_item_t))) == NULL)
134 {
135 syslog (LOG_ERR, "cannot allocate new config entry");
136 regfree (regtemp);
137 return (1);
138 }
139 memset (new, '\0', sizeof(ignorelist_item_t));
140 new->rmatch = regtemp;
142 /* append new entry */
143 ignorelist_append (il, new);
145 return (0);
146 } /* int ignorelist_append_regex(ignorelist_t *il, const char *entry) */
147 #endif
149 static int ignorelist_append_string(ignorelist_t *il, const char *entry)
150 {
151 ignorelist_item_t *new;
153 /* create new entry */
154 if ((new = malloc(sizeof(ignorelist_item_t))) == NULL )
155 {
156 syslog (LOG_ERR, "cannot allocate new entry");
157 return (1);
158 }
159 memset (new, '\0', sizeof(ignorelist_item_t));
160 new->smatch = sstrdup(entry);
162 /* append new entry */
163 ignorelist_append (il, new);
165 return (0);
166 } /* int ignorelist_append_string(ignorelist_t *il, const char *entry) */
168 #if HAVE_REGEX_H
169 /*
170 * check list for entry regex match
171 * return 1 if found
172 */
173 static int ignorelist_match_regex (ignorelist_item_t *item, const char *entry)
174 {
175 assert ((item != NULL) && (item->rmatch != NULL)
176 && (entry != NULL) && (strlen (entry) > 0));
178 /* match regex */
179 if (regexec (item->rmatch, entry, 0, NULL, 0) == 0)
180 return (1);
182 return (0);
183 } /* int ignorelist_match_regex (ignorelist_item_t *item, const char *entry) */
184 #endif
186 /*
187 * check list for entry string match
188 * return 1 if found
189 */
190 static int ignorelist_match_string (ignorelist_item_t *item, const char *entry)
191 {
192 assert ((item != NULL) && (item->smatch != NULL)
193 && (entry != NULL) && (strlen (entry) > 0));
195 if (strcmp (entry, item->smatch) == 0)
196 return (1);
198 return (0);
199 } /* int ignorelist_match_string (ignorelist_item_t *item, const char *entry) */
202 /* *** *** *** ******************************************** *** *** *** */
203 /* *** *** *** *** *** *** public functions *** *** *** *** *** *** */
204 /* *** *** *** ******************************************** *** *** *** */
206 /*
207 * create the ignorelist_t with known ignore state
208 * return pointer to ignorelist_t
209 */
210 ignorelist_t *ignorelist_create (int invert)
211 {
212 ignorelist_t *il;
214 /* smalloc exits if it failes */
215 il = (ignorelist_t *) smalloc (sizeof (ignorelist_t));
216 DBG("Ignorelist created 0x%p, default is %s",
217 (void *) il,
218 invert ? "collect" : "ignore");
220 memset (il, '\0', sizeof (ignorelist_t));
222 /*
223 * ->ignore == 0 => collect
224 * ->ignore == 1 => ignore
225 */
226 il->ignore = invert ? 0 : 1;
228 return (il);
229 } /* ignorelist_t *ignorelist_create (int ignore) */
231 /*
232 * free memory used by ignorelist_t
233 */
234 void ignorelist_free (ignorelist_t *il)
235 {
236 ignorelist_item_t *this;
237 ignorelist_item_t *next;
239 DBG ("(il = 0x%p)", (void *) il);
241 if (il == NULL)
242 return;
244 for (this = il->head; this != NULL; this = next)
245 {
246 next = this->next;
247 #if HAVE_REGEX_H
248 if (this->rmatch != NULL)
249 {
250 regfree (this->rmatch);
251 this->rmatch = NULL;
252 }
253 #endif
254 if (this->smatch != NULL)
255 {
256 sfree (this->smatch);
257 this->smatch = NULL;
258 }
259 sfree (this);
260 }
262 sfree (il);
263 il = NULL;
264 } /* void ignorelist_destroy (ignorelist_t *il) */
266 /*
267 * set ignore state of the ignorelist_t
268 */
269 void ignorelist_set_invert (ignorelist_t *il, int invert)
270 {
271 if (il == NULL)
272 {
273 DBG("ignore call with ignorelist_t == NULL");
274 return;
275 }
277 il->ignore = invert ? 0 : 1;
278 } /* void ignorelist_set_invert (ignorelist_t *il, int ignore) */
280 /*
281 * append entry into ignorelist_t
282 * return 1 for success
283 */
284 int ignorelist_add (ignorelist_t *il, const char *entry)
285 {
286 int ret;
287 size_t entry_len;
289 if (il == NULL)
290 {
291 DBG ("add called with ignorelist_t == NULL");
292 return (1);
293 }
295 entry_len = strlen (entry);
297 /* append nothing */
298 if (entry_len == 0)
299 {
300 DBG("not appending: empty entry");
301 return (1);
302 }
304 #if HAVE_REGEX_H
305 /* regex string is enclosed in "/.../" */
306 if ((entry_len > 2) && (entry[0] == '/') && entry[entry_len - 1] == '/')
307 {
308 char *entry_copy;
310 /* We need to copy `entry' since it's const */
311 entry_copy = smalloc (entry_len);
312 memset (entry_copy, '\0', entry_len);
313 strncpy (entry_copy, entry + 1, entry_len - 2);
315 DBG("I'm about to add regex entry: %s", entry_copy);
316 ret = ignorelist_append_regex(il, entry_copy);
317 sfree (entry_copy);
318 }
319 else
320 #endif
321 {
322 DBG("to add entry: %s", entry);
323 ret = ignorelist_append_string(il, entry);
324 }
326 return (ret);
327 } /* int ignorelist_add (ignorelist_t *il, const char *entry) */
329 /*
330 * check list for entry
331 * return 1 for ignored entry
332 */
333 int ignorelist_match (ignorelist_t *il, const char *entry)
334 {
335 ignorelist_item_t *traverse;
337 assert (il != NULL);
339 /* if no entries, collect all */
340 if (il->head == NULL)
341 return (0);
343 if ((entry == NULL) || (strlen (entry) == 0))
344 return (0);
346 /* traverse list and check entries */
347 for (traverse = il->head; traverse != NULL; traverse = traverse->next)
348 {
349 #if HAVE_REGEX_H
350 if (traverse->rmatch != NULL)
351 {
352 if (ignorelist_match_regex (traverse, entry))
353 return (il->ignore);
354 }
355 else
356 #endif
357 {
358 if (ignorelist_match_string (traverse, entry))
359 return (il->ignore);
360 }
361 } /* for traverse */
363 return (1 - il->ignore);
364 } /* int ignorelist_match (ignorelist_t *il, const char *entry) */