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 **/
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 #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 int ignore; /* ignore entries */
73 ignorelist_item_t *head; /* pointer to the first entry */
74 };
76 /* *** *** *** ********************************************* *** *** *** */
77 /* *** *** *** *** *** *** private functions *** *** *** *** *** *** */
78 /* *** *** *** ********************************************* *** *** *** */
80 static inline void ignorelist_append(ignorelist_t *il,
81 ignorelist_item_t *item) {
82 assert((il != NULL) && (item != NULL));
84 item->next = il->head;
85 il->head = item;
86 }
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;
94 re = calloc(1, sizeof(*re));
95 if (re == NULL) {
96 ERROR("ignorelist_append_regex: calloc failed.");
97 return (ENOMEM);
98 }
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 }
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;
121 ignorelist_append(il, entry);
122 return (0);
123 } /* int ignorelist_append_regex */
124 #endif
126 static int ignorelist_append_string(ignorelist_t *il, const char *entry) {
127 ignorelist_item_t *new;
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);
136 /* append new entry */
137 ignorelist_append(il, new);
139 return (0);
140 } /* int ignorelist_append_string(ignorelist_t *il, const char *entry) */
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));
151 /* match regex */
152 if (regexec(item->rmatch, entry, 0, NULL, 0) == 0)
153 return (1);
155 return (0);
156 } /* int ignorelist_match_regex (ignorelist_item_t *item, const char *entry) */
157 #endif
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));
167 if (strcmp(entry, item->smatch) == 0)
168 return (1);
170 return (0);
171 } /* int ignorelist_match_string (ignorelist_item_t *item, const char *entry) */
173 /* *** *** *** ******************************************** *** *** *** */
174 /* *** *** *** *** *** *** public functions *** *** *** *** *** *** */
175 /* *** *** *** ******************************************** *** *** *** */
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;
184 il = calloc(1, sizeof(*il));
185 if (il == NULL)
186 return NULL;
188 /*
189 * ->ignore == 0 => collect
190 * ->ignore == 1 => ignore
191 */
192 il->ignore = invert ? 0 : 1;
194 return (il);
195 } /* ignorelist_t *ignorelist_create (int ignore) */
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;
204 if (il == NULL)
205 return;
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 }
223 sfree(il);
224 } /* void ignorelist_destroy (ignorelist_t *il) */
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 }
235 il->ignore = invert ? 0 : 1;
236 } /* void ignorelist_set_invert (ignorelist_t *il, int ignore) */
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;
245 if (il == NULL) {
246 DEBUG("add called with ignorelist_t == NULL");
247 return (1);
248 }
250 len = strlen(entry);
252 /* append nothing */
253 if (len == 0) {
254 DEBUG("not appending: empty entry");
255 return (1);
256 }
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;
264 /* skip leading slash */
265 copy = strdup(entry + 1);
266 if (copy == NULL)
267 return ENOMEM;
269 /* trim trailing slash */
270 copy[strlen(copy) - 1] = 0;
272 status = ignorelist_append_regex(il, copy);
273 sfree(copy);
274 return status;
275 }
276 #endif
278 return ignorelist_append_string(il, entry);
279 } /* int ignorelist_add (ignorelist_t *il, const char *entry) */
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);
290 if ((entry == NULL) || (strlen(entry) == 0))
291 return (0);
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 */
308 return (1 - il->ignore);
309 } /* int ignorelist_match (ignorelist_t *il, const char *entry) */