hashed match: Use a different (larger) prime number.
[collectd.git] / src / utils_ignorelist.c
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
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 verplant.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  **/
51
52 #if HAVE_CONFIG_H
53 # include "config.h"
54 #endif
55
56 #include "common.h"
57 #include "plugin.h"
58 #include "utils_ignorelist.h"
59
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;
72
73 struct ignorelist_s
74 {
75         int ignore;             /* ignore entries */
76         ignorelist_item_t *head;        /* pointer to the first entry */
77 };
78
79 /* *** *** *** ********************************************* *** *** *** */
80 /* *** *** *** *** *** ***   private functions   *** *** *** *** *** *** */
81 /* *** *** *** ********************************************* *** *** *** */
82
83 static inline void ignorelist_append (ignorelist_t *il, ignorelist_item_t *item)
84 {
85         assert ((il != NULL) && (item != NULL));
86
87         item->next = il->head;
88         il->head = item;
89 }
90
91 #if HAVE_REGEX_H
92 static int ignorelist_append_regex(ignorelist_t *il, const char *entry)
93 {
94         int rcompile;
95         regex_t *regtemp;
96         int errsize;
97         char *regerr = NULL;
98         ignorelist_item_t *new;
99
100         /* create buffer */
101         if ((regtemp = malloc(sizeof(regex_t))) == NULL)
102         {
103                 ERROR ("cannot allocate new config entry");
104                 return (1);
105         }
106         memset (regtemp, '\0', sizeof(regex_t));
107
108         /* compile regex */
109         if ((rcompile = regcomp (regtemp, entry, REG_EXTENDED)) != 0)
110         {
111                 /* prepare message buffer */
112                 errsize = regerror(rcompile, regtemp, NULL, 0);
113                 if (errsize)
114                         regerr = smalloc(errsize);
115                 /* get error message */
116                 if (regerror (rcompile, regtemp, regerr, errsize))
117                 {
118                         fprintf (stderr, "Cannot compile regex %s: %i/%s",
119                                         entry, rcompile, regerr);
120                         ERROR ("Cannot compile regex %s: %i/%s",
121                                         entry, rcompile, regerr);
122                 }
123                 else
124                 {
125                         fprintf (stderr, "Cannot compile regex %s: %i",
126                                         entry, rcompile);
127                         ERROR ("Cannot compile regex %s: %i",
128                                         entry, rcompile);
129                 }
130
131                 if (errsize)
132                         sfree (regerr);
133                 regfree (regtemp);
134                 return (1);
135         }
136         DEBUG("regex compiled: %s - %i", entry, rcompile);
137
138         /* create new entry */
139         if ((new = malloc(sizeof(ignorelist_item_t))) == NULL)
140         {
141                 ERROR ("cannot allocate new config entry");
142                 regfree (regtemp);
143                 return (1);
144         }
145         memset (new, '\0', sizeof(ignorelist_item_t));
146         new->rmatch = regtemp;
147
148         /* append new entry */
149         ignorelist_append (il, new);
150
151         return (0);
152 } /* int ignorelist_append_regex(ignorelist_t *il, const char *entry) */
153 #endif
154
155 static int ignorelist_append_string(ignorelist_t *il, const char *entry)
156 {
157         ignorelist_item_t *new;
158
159         /* create new entry */
160         if ((new = malloc(sizeof(ignorelist_item_t))) == NULL )
161         {
162                 ERROR ("cannot allocate new entry");
163                 return (1);
164         }
165         memset (new, '\0', sizeof(ignorelist_item_t));
166         new->smatch = sstrdup(entry);
167
168         /* append new entry */
169         ignorelist_append (il, new);
170
171         return (0);
172 } /* int ignorelist_append_string(ignorelist_t *il, const char *entry) */
173
174 #if HAVE_REGEX_H
175 /*
176  * check list for entry regex match
177  * return 1 if found
178  */
179 static int ignorelist_match_regex (ignorelist_item_t *item, const char *entry)
180 {
181         assert ((item != NULL) && (item->rmatch != NULL)
182                         && (entry != NULL) && (strlen (entry) > 0));
183
184         /* match regex */
185         if (regexec (item->rmatch, entry, 0, NULL, 0) == 0)
186                 return (1);
187
188         return (0);
189 } /* int ignorelist_match_regex (ignorelist_item_t *item, const char *entry) */
190 #endif
191
192 /*
193  * check list for entry string match
194  * return 1 if found
195  */
196 static int ignorelist_match_string (ignorelist_item_t *item, const char *entry)
197 {
198         assert ((item != NULL) && (item->smatch != NULL)
199                         && (entry != NULL) && (strlen (entry) > 0));
200
201         if (strcmp (entry, item->smatch) == 0)
202                 return (1);
203
204         return (0);
205 } /* int ignorelist_match_string (ignorelist_item_t *item, const char *entry) */
206
207
208 /* *** *** *** ******************************************** *** *** *** */
209 /* *** *** *** *** *** ***   public functions   *** *** *** *** *** *** */
210 /* *** *** *** ******************************************** *** *** *** */
211
212 /*
213  * create the ignorelist_t with known ignore state
214  * return pointer to ignorelist_t
215  */
216 ignorelist_t *ignorelist_create (int invert)
217 {
218         ignorelist_t *il;
219
220         /* smalloc exits if it failes */
221         il = (ignorelist_t *) smalloc (sizeof (ignorelist_t));
222         memset (il, '\0', sizeof (ignorelist_t));
223
224         /*
225          * ->ignore == 0  =>  collect
226          * ->ignore == 1  =>  ignore
227          */
228         il->ignore = invert ? 0 : 1;
229
230         return (il);
231 } /* ignorelist_t *ignorelist_create (int ignore) */
232
233 /*
234  * free memory used by ignorelist_t
235  */
236 void ignorelist_free (ignorelist_t *il)
237 {
238         ignorelist_item_t *this;
239         ignorelist_item_t *next;
240
241         if (il == NULL)
242                 return;
243
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         }
261
262         sfree (il);
263         il = NULL;
264 } /* void ignorelist_destroy (ignorelist_t *il) */
265
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                 DEBUG("ignore call with ignorelist_t == NULL");
274                 return;
275         }
276
277         il->ignore = invert ? 0 : 1;
278 } /* void ignorelist_set_invert (ignorelist_t *il, int ignore) */
279
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;
288
289         if (il == NULL)
290         {
291                 DEBUG ("add called with ignorelist_t == NULL");
292                 return (1);
293         }
294
295         entry_len = strlen (entry);
296
297         /* append nothing */
298         if (entry_len == 0)
299         {
300                 DEBUG("not appending: empty entry");
301                 return (1);
302         }
303
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;
309                 size_t entry_copy_size;
310
311                 /* We need to copy `entry' since it's const */
312                 entry_copy_size = entry_len - 1;
313                 entry_copy = smalloc (entry_copy_size);
314                 sstrncpy (entry_copy, entry + 1, entry_copy_size);
315
316                 DEBUG("I'm about to add regex entry: %s", entry_copy);
317                 ret = ignorelist_append_regex(il, entry_copy);
318                 sfree (entry_copy);
319         }
320         else
321 #endif
322         {
323                 DEBUG("to add entry: %s", entry);
324                 ret = ignorelist_append_string(il, entry);
325         }
326
327         return (ret);
328 } /* int ignorelist_add (ignorelist_t *il, const char *entry) */
329
330 /*
331  * check list for entry
332  * return 1 for ignored entry
333  */
334 int ignorelist_match (ignorelist_t *il, const char *entry)
335 {
336         ignorelist_item_t *traverse;
337
338         /* if no entries, collect all */
339         if ((il == NULL) || (il->head == NULL))
340                 return (0);
341
342         if ((entry == NULL) || (strlen (entry) == 0))
343                 return (0);
344
345         /* traverse list and check entries */
346         for (traverse = il->head; traverse != NULL; traverse = traverse->next)
347         {
348 #if HAVE_REGEX_H
349                 if (traverse->rmatch != NULL)
350                 {
351                         if (ignorelist_match_regex (traverse, entry))
352                                 return (il->ignore);
353                 }
354                 else
355 #endif
356                 {
357                         if (ignorelist_match_string (traverse, entry))
358                                 return (il->ignore);
359                 }
360         } /* for traverse */
361
362         return (1 - il->ignore);
363 } /* int ignorelist_match (ignorelist_t *il, const char *entry) */
364