d002c7aa47094ffe387817536bd6fddb2f2fd01c
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 #if HAVE_CONFIG_H
51 # include "config.h"
52 #endif
54 #include "common.h"
55 #include "utils_debug.h"
56 #include "utils_ignorelist.h"
58 /*
59 * private prototypes
60 */
61 struct ignorelist_item_s
62 {
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;
71 struct ignorelist_s
72 {
73 int ignore; /* ignore entries */
74 ignorelist_item_t *head; /* pointer to the first entry */
75 };
77 /* *** *** *** ********************************************* *** *** *** */
78 /* *** *** *** *** *** *** private functions *** *** *** *** *** *** */
79 /* *** *** *** ********************************************* *** *** *** */
81 static inline void ignorelist_append (ignorelist_t *il, ignorelist_item_t *item)
82 {
83 assert ((il != NULL) && (item != NULL));
85 item->next = il->head;
86 il->head = item;
87 }
89 #if HAVE_REGEX_H
90 static int ignorelist_append_regex(ignorelist_t *il, const char *entry)
91 {
92 int rcompile;
93 regex_t *regtemp;
94 int errsize;
95 char *regerr = NULL;
96 ignorelist_item_t *new;
98 /* create buffer */
99 if ((regtemp = malloc(sizeof(regex_t))) == NULL)
100 {
101 syslog (LOG_ERR, "cannot allocate new config entry");
102 return (1);
103 }
104 memset (regtemp, '\0', sizeof(regex_t));
106 /* compile regex */
107 if ((rcompile = regcomp (regtemp, entry, REG_EXTENDED)) != 0)
108 {
109 /* prepare message buffer */
110 errsize = regerror(rcompile, regtemp, NULL, 0);
111 if (errsize)
112 regerr = smalloc(errsize);
113 /* get error message */
114 if (regerror (rcompile, regtemp, regerr, errsize))
115 {
116 fprintf (stderr, "Cannot compile regex %s: %i/%s",
117 entry, rcompile, regerr);
118 syslog (LOG_ERR, "Cannot compile regex %s: %i/%s",
119 entry, rcompile, regerr);
120 }
121 else
122 {
123 fprintf (stderr, "Cannot compile regex %s: %i",
124 entry, rcompile);
125 syslog (LOG_ERR, "Cannot compile regex %s: %i",
126 entry, rcompile);
127 }
129 if (errsize)
130 sfree (regerr);
131 regfree (regtemp);
132 return (1);
133 }
134 DBG("regex compiled: %s - %i", entry, rcompile);
136 /* create new entry */
137 if ((new = malloc(sizeof(ignorelist_item_t))) == NULL)
138 {
139 syslog (LOG_ERR, "cannot allocate new config entry");
140 regfree (regtemp);
141 return (1);
142 }
143 memset (new, '\0', sizeof(ignorelist_item_t));
144 new->rmatch = regtemp;
146 /* append new entry */
147 ignorelist_append (il, new);
149 return (0);
150 } /* int ignorelist_append_regex(ignorelist_t *il, const char *entry) */
151 #endif
153 static int ignorelist_append_string(ignorelist_t *il, const char *entry)
154 {
155 ignorelist_item_t *new;
157 /* create new entry */
158 if ((new = malloc(sizeof(ignorelist_item_t))) == NULL )
159 {
160 syslog (LOG_ERR, "cannot allocate new entry");
161 return (1);
162 }
163 memset (new, '\0', sizeof(ignorelist_item_t));
164 new->smatch = sstrdup(entry);
166 /* append new entry */
167 ignorelist_append (il, new);
169 return (0);
170 } /* int ignorelist_append_string(ignorelist_t *il, const char *entry) */
172 #if HAVE_REGEX_H
173 /*
174 * check list for entry regex match
175 * return 1 if found
176 */
177 static int ignorelist_match_regex (ignorelist_item_t *item, const char *entry)
178 {
179 assert ((item != NULL) && (item->rmatch != NULL)
180 && (entry != NULL) && (strlen (entry) > 0));
182 /* match regex */
183 if (regexec (item->rmatch, entry, 0, NULL, 0) == 0)
184 return (1);
186 return (0);
187 } /* int ignorelist_match_regex (ignorelist_item_t *item, const char *entry) */
188 #endif
190 /*
191 * check list for entry string match
192 * return 1 if found
193 */
194 static int ignorelist_match_string (ignorelist_item_t *item, const char *entry)
195 {
196 assert ((item != NULL) && (item->smatch != NULL)
197 && (entry != NULL) && (strlen (entry) > 0));
199 if (strcmp (entry, item->smatch) == 0)
200 return (1);
202 return (0);
203 } /* int ignorelist_match_string (ignorelist_item_t *item, const char *entry) */
206 /* *** *** *** ******************************************** *** *** *** */
207 /* *** *** *** *** *** *** public functions *** *** *** *** *** *** */
208 /* *** *** *** ******************************************** *** *** *** */
210 /*
211 * create the ignorelist_t with known ignore state
212 * return pointer to ignorelist_t
213 */
214 ignorelist_t *ignorelist_create (int invert)
215 {
216 ignorelist_t *il;
218 /* smalloc exits if it failes */
219 il = (ignorelist_t *) smalloc (sizeof (ignorelist_t));
220 DBG("Ignorelist created 0x%p, default is %s",
221 (void *) il,
222 invert ? "collect" : "ignore");
224 memset (il, '\0', sizeof (ignorelist_t));
226 /*
227 * ->ignore == 0 => collect
228 * ->ignore == 1 => ignore
229 */
230 il->ignore = invert ? 0 : 1;
232 return (il);
233 } /* ignorelist_t *ignorelist_create (int ignore) */
235 /*
236 * free memory used by ignorelist_t
237 */
238 void ignorelist_free (ignorelist_t *il)
239 {
240 ignorelist_item_t *this;
241 ignorelist_item_t *next;
243 DBG ("(il = 0x%p)", (void *) il);
245 if (il == NULL)
246 return;
248 for (this = il->head; this != NULL; this = next)
249 {
250 next = this->next;
251 #if HAVE_REGEX_H
252 if (this->rmatch != NULL)
253 {
254 regfree (this->rmatch);
255 this->rmatch = NULL;
256 }
257 #endif
258 if (this->smatch != NULL)
259 {
260 sfree (this->smatch);
261 this->smatch = NULL;
262 }
263 sfree (this);
264 }
266 sfree (il);
267 il = NULL;
268 } /* void ignorelist_destroy (ignorelist_t *il) */
270 /*
271 * set ignore state of the ignorelist_t
272 */
273 void ignorelist_set_invert (ignorelist_t *il, int invert)
274 {
275 if (il == NULL)
276 {
277 DBG("ignore call with ignorelist_t == NULL");
278 return;
279 }
281 il->ignore = invert ? 0 : 1;
282 } /* void ignorelist_set_invert (ignorelist_t *il, int ignore) */
284 /*
285 * append entry into ignorelist_t
286 * return 1 for success
287 */
288 int ignorelist_add (ignorelist_t *il, const char *entry)
289 {
290 int ret;
291 size_t entry_len;
293 if (il == NULL)
294 {
295 DBG ("add called with ignorelist_t == NULL");
296 return (1);
297 }
299 entry_len = strlen (entry);
301 /* append nothing */
302 if (entry_len == 0)
303 {
304 DBG("not appending: empty entry");
305 return (1);
306 }
308 #if HAVE_REGEX_H
309 /* regex string is enclosed in "/.../" */
310 if ((entry_len > 2) && (entry[0] == '/') && entry[entry_len - 1] == '/')
311 {
312 char *entry_copy;
314 /* We need to copy `entry' since it's const */
315 entry_copy = smalloc (entry_len);
316 memset (entry_copy, '\0', entry_len);
317 strncpy (entry_copy, entry + 1, entry_len - 2);
319 DBG("I'm about to add regex entry: %s", entry_copy);
320 ret = ignorelist_append_regex(il, entry_copy);
321 sfree (entry_copy);
322 }
323 else
324 #endif
325 {
326 DBG("to add entry: %s", entry);
327 ret = ignorelist_append_string(il, entry);
328 }
330 return (ret);
331 } /* int ignorelist_add (ignorelist_t *il, const char *entry) */
333 /*
334 * check list for entry
335 * return 1 for ignored entry
336 */
337 int ignorelist_match (ignorelist_t *il, const char *entry)
338 {
339 ignorelist_item_t *traverse;
341 assert (il != NULL);
343 /* if no entries, collect all */
344 if (il->head == NULL)
345 return (0);
347 if ((entry == NULL) || (strlen (entry) == 0))
348 return (0);
350 /* traverse list and check entries */
351 for (traverse = il->head; traverse != NULL; traverse = traverse->next)
352 {
353 #if HAVE_REGEX_H
354 if (traverse->rmatch != NULL)
355 {
356 if (ignorelist_match_regex (traverse, entry))
357 return (il->ignore);
358 }
359 else
360 #endif
361 {
362 if (ignorelist_match_string (traverse, entry))
363 return (il->ignore);
364 }
365 } /* for traverse */
367 return (1 - il->ignore);
368 } /* int ignorelist_match (ignorelist_t *il, const char *entry) */