src/utils_ignorelist.c: Remove an annoying debug message.
[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  *
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  **/
49
50 #if HAVE_CONFIG_H
51 # include "config.h"
52 #endif
53
54 #include "common.h"
55 #include "plugin.h"
56 #include "utils_ignorelist.h"
57
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;
70
71 struct ignorelist_s
72 {
73         int ignore;             /* ignore entries */
74         ignorelist_item_t *head;        /* pointer to the first entry */
75 };
76
77 /* *** *** *** ********************************************* *** *** *** */
78 /* *** *** *** *** *** ***   private functions   *** *** *** *** *** *** */
79 /* *** *** *** ********************************************* *** *** *** */
80
81 static inline void ignorelist_append (ignorelist_t *il, ignorelist_item_t *item)
82 {
83         assert ((il != NULL) && (item != NULL));
84
85         item->next = il->head;
86         il->head = item;
87 }
88
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;
97
98         /* create buffer */
99         if ((regtemp = malloc(sizeof(regex_t))) == NULL)
100         {
101                 ERROR ("cannot allocate new config entry");
102                 return (1);
103         }
104         memset (regtemp, '\0', sizeof(regex_t));
105
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                         ERROR ("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                         ERROR ("Cannot compile regex %s: %i",
126                                         entry, rcompile);
127                 }
128
129                 if (errsize)
130                         sfree (regerr);
131                 regfree (regtemp);
132                 return (1);
133         }
134         DEBUG("regex compiled: %s - %i", entry, rcompile);
135
136         /* create new entry */
137         if ((new = malloc(sizeof(ignorelist_item_t))) == NULL)
138         {
139                 ERROR ("cannot allocate new config entry");
140                 regfree (regtemp);
141                 return (1);
142         }
143         memset (new, '\0', sizeof(ignorelist_item_t));
144         new->rmatch = regtemp;
145
146         /* append new entry */
147         ignorelist_append (il, new);
148
149         return (0);
150 } /* int ignorelist_append_regex(ignorelist_t *il, const char *entry) */
151 #endif
152
153 static int ignorelist_append_string(ignorelist_t *il, const char *entry)
154 {
155         ignorelist_item_t *new;
156
157         /* create new entry */
158         if ((new = malloc(sizeof(ignorelist_item_t))) == NULL )
159         {
160                 ERROR ("cannot allocate new entry");
161                 return (1);
162         }
163         memset (new, '\0', sizeof(ignorelist_item_t));
164         new->smatch = sstrdup(entry);
165
166         /* append new entry */
167         ignorelist_append (il, new);
168
169         return (0);
170 } /* int ignorelist_append_string(ignorelist_t *il, const char *entry) */
171
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));
181
182         /* match regex */
183         if (regexec (item->rmatch, entry, 0, NULL, 0) == 0)
184                 return (1);
185
186         return (0);
187 } /* int ignorelist_match_regex (ignorelist_item_t *item, const char *entry) */
188 #endif
189
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));
198
199         if (strcmp (entry, item->smatch) == 0)
200                 return (1);
201
202         return (0);
203 } /* int ignorelist_match_string (ignorelist_item_t *item, const char *entry) */
204
205
206 /* *** *** *** ******************************************** *** *** *** */
207 /* *** *** *** *** *** ***   public functions   *** *** *** *** *** *** */
208 /* *** *** *** ******************************************** *** *** *** */
209
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;
217
218         /* smalloc exits if it failes */
219         il = (ignorelist_t *) smalloc (sizeof (ignorelist_t));
220         memset (il, '\0', sizeof (ignorelist_t));
221
222         /*
223          * ->ignore == 0  =>  collect
224          * ->ignore == 1  =>  ignore
225          */
226         il->ignore = invert ? 0 : 1;
227
228         return (il);
229 } /* ignorelist_t *ignorelist_create (int ignore) */
230
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;
238
239         if (il == NULL)
240                 return;
241
242         for (this = il->head; this != NULL; this = next)
243         {
244                 next = this->next;
245 #if HAVE_REGEX_H
246                 if (this->rmatch != NULL)
247                 {
248                         regfree (this->rmatch);
249                         this->rmatch = NULL;
250                 }
251 #endif
252                 if (this->smatch != NULL)
253                 {
254                         sfree (this->smatch);
255                         this->smatch = NULL;
256                 }
257                 sfree (this);
258         }
259
260         sfree (il);
261         il = NULL;
262 } /* void ignorelist_destroy (ignorelist_t *il) */
263
264 /*
265  * set ignore state of the ignorelist_t
266  */
267 void ignorelist_set_invert (ignorelist_t *il, int invert)
268 {
269         if (il == NULL)
270         {
271                 DEBUG("ignore call with ignorelist_t == NULL");
272                 return;
273         }
274
275         il->ignore = invert ? 0 : 1;
276 } /* void ignorelist_set_invert (ignorelist_t *il, int ignore) */
277
278 /*
279  * append entry into ignorelist_t
280  * return 1 for success
281  */
282 int ignorelist_add (ignorelist_t *il, const char *entry)
283 {
284         int ret;
285         size_t entry_len;
286
287         if (il == NULL)
288         {
289                 DEBUG ("add called with ignorelist_t == NULL");
290                 return (1);
291         }
292
293         entry_len = strlen (entry);
294
295         /* append nothing */
296         if (entry_len == 0)
297         {
298                 DEBUG("not appending: empty entry");
299                 return (1);
300         }
301
302 #if HAVE_REGEX_H
303         /* regex string is enclosed in "/.../" */
304         if ((entry_len > 2) && (entry[0] == '/') && entry[entry_len - 1] == '/')
305         {
306                 char *entry_copy;
307
308                 /* We need to copy `entry' since it's const */
309                 entry_copy = smalloc (entry_len);
310                 memset (entry_copy, '\0', entry_len);
311                 strncpy (entry_copy, entry + 1, entry_len - 2);
312
313                 DEBUG("I'm about to add regex entry: %s", entry_copy);
314                 ret = ignorelist_append_regex(il, entry_copy);
315                 sfree (entry_copy);
316         }
317         else
318 #endif
319         {
320                 DEBUG("to add entry: %s", entry);
321                 ret = ignorelist_append_string(il, entry);
322         }
323
324         return (ret);
325 } /* int ignorelist_add (ignorelist_t *il, const char *entry) */
326
327 /*
328  * check list for entry
329  * return 1 for ignored entry
330  */
331 int ignorelist_match (ignorelist_t *il, const char *entry)
332 {
333         ignorelist_item_t *traverse;
334
335         assert (il != NULL);
336
337         /* if no entries, collect all */
338         if (il->head == NULL)
339                 return (0);
340
341         if ((entry == NULL) || (strlen (entry) == 0))
342                 return (0);
343
344         /* traverse list and check entries */
345         for (traverse = il->head; traverse != NULL; traverse = traverse->next)
346         {
347 #if HAVE_REGEX_H
348                 if (traverse->rmatch != NULL)
349                 {
350                         if (ignorelist_match_regex (traverse, entry))
351                                 return (il->ignore);
352                 }
353                 else
354 #endif
355                 {
356                         if (ignorelist_match_string (traverse, entry))
357                                 return (il->ignore);
358                 }
359         } /* for traverse */
360
361         return (1 - il->ignore);
362 } /* int ignorelist_match (ignorelist_t *il, const char *entry) */
363