Add missing kstat definitions
[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 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
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 collectd.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 *re_str)
93 {
94         regex_t *re;
95         ignorelist_item_t *entry;
96         int status;
97
98         re = malloc (sizeof (*re));
99         if (re == NULL)
100         {
101                 ERROR ("utils_ignorelist: malloc failed");
102                 return (ENOMEM);
103         }
104         memset (re, 0, sizeof (*re));
105
106         status = regcomp (re, re_str, REG_EXTENDED);
107         if (status != 0)
108         {
109                 char errbuf[1024] = "";
110                 regerror (status, re, errbuf, sizeof (errbuf));
111                 ERROR ("utils_ignorelist: regcomp failed: %s", errbuf);
112                 regfree (re);
113                 sfree (re);
114                 return (status);
115         }
116
117         entry = malloc (sizeof (*entry));
118         if (entry == NULL)
119         {
120                 ERROR ("utils_ignorelist: malloc failed");
121                 regfree (re);
122                 sfree (re);
123                 return (ENOMEM);
124         }
125         memset (entry, 0, sizeof (*entry));
126         entry->rmatch = re;
127
128         ignorelist_append (il, entry);
129         return (0);
130 } /* int ignorelist_append_regex */
131 #endif
132
133 static int ignorelist_append_string(ignorelist_t *il, const char *entry)
134 {
135         ignorelist_item_t *new;
136
137         /* create new entry */
138         if ((new = malloc(sizeof(ignorelist_item_t))) == NULL )
139         {
140                 ERROR ("cannot allocate new entry");
141                 return (1);
142         }
143         memset (new, '\0', sizeof(ignorelist_item_t));
144         new->smatch = sstrdup(entry);
145
146         /* append new entry */
147         ignorelist_append (il, new);
148
149         return (0);
150 } /* int ignorelist_append_string(ignorelist_t *il, const char *entry) */
151
152 #if HAVE_REGEX_H
153 /*
154  * check list for entry regex match
155  * return 1 if found
156  */
157 static int ignorelist_match_regex (ignorelist_item_t *item, const char *entry)
158 {
159         assert ((item != NULL) && (item->rmatch != NULL)
160                         && (entry != NULL) && (strlen (entry) > 0));
161
162         /* match regex */
163         if (regexec (item->rmatch, entry, 0, NULL, 0) == 0)
164                 return (1);
165
166         return (0);
167 } /* int ignorelist_match_regex (ignorelist_item_t *item, const char *entry) */
168 #endif
169
170 /*
171  * check list for entry string match
172  * return 1 if found
173  */
174 static int ignorelist_match_string (ignorelist_item_t *item, const char *entry)
175 {
176         assert ((item != NULL) && (item->smatch != NULL)
177                         && (entry != NULL) && (strlen (entry) > 0));
178
179         if (strcmp (entry, item->smatch) == 0)
180                 return (1);
181
182         return (0);
183 } /* int ignorelist_match_string (ignorelist_item_t *item, const char *entry) */
184
185
186 /* *** *** *** ******************************************** *** *** *** */
187 /* *** *** *** *** *** ***   public functions   *** *** *** *** *** *** */
188 /* *** *** *** ******************************************** *** *** *** */
189
190 /*
191  * create the ignorelist_t with known ignore state
192  * return pointer to ignorelist_t
193  */
194 ignorelist_t *ignorelist_create (int invert)
195 {
196         ignorelist_t *il;
197
198         /* smalloc exits if it failes */
199         il = (ignorelist_t *) smalloc (sizeof (ignorelist_t));
200         memset (il, '\0', sizeof (ignorelist_t));
201
202         /*
203          * ->ignore == 0  =>  collect
204          * ->ignore == 1  =>  ignore
205          */
206         il->ignore = invert ? 0 : 1;
207
208         return (il);
209 } /* ignorelist_t *ignorelist_create (int ignore) */
210
211 /*
212  * free memory used by ignorelist_t
213  */
214 void ignorelist_free (ignorelist_t *il)
215 {
216         ignorelist_item_t *this;
217         ignorelist_item_t *next;
218
219         if (il == NULL)
220                 return;
221
222         for (this = il->head; this != NULL; this = next)
223         {
224                 next = this->next;
225 #if HAVE_REGEX_H
226                 if (this->rmatch != NULL)
227                 {
228                         regfree (this->rmatch);
229                         sfree (this->rmatch);
230                         this->rmatch = NULL;
231                 }
232 #endif
233                 if (this->smatch != NULL)
234                 {
235                         sfree (this->smatch);
236                         this->smatch = NULL;
237                 }
238                 sfree (this);
239         }
240
241         sfree (il);
242         il = NULL;
243 } /* void ignorelist_destroy (ignorelist_t *il) */
244
245 /*
246  * set ignore state of the ignorelist_t
247  */
248 void ignorelist_set_invert (ignorelist_t *il, int invert)
249 {
250         if (il == NULL)
251         {
252                 DEBUG("ignore call with ignorelist_t == NULL");
253                 return;
254         }
255
256         il->ignore = invert ? 0 : 1;
257 } /* void ignorelist_set_invert (ignorelist_t *il, int ignore) */
258
259 /*
260  * append entry into ignorelist_t
261  * return 0 for success
262  */
263 int ignorelist_add (ignorelist_t *il, const char *entry)
264 {
265         size_t entry_len;
266
267         if (il == NULL)
268         {
269                 DEBUG ("add called with ignorelist_t == NULL");
270                 return (1);
271         }
272
273         entry_len = strlen (entry);
274
275         /* append nothing */
276         if (entry_len == 0)
277         {
278                 DEBUG("not appending: empty entry");
279                 return (1);
280         }
281
282 #if HAVE_REGEX_H
283         /* regex string is enclosed in "/.../" */
284         if ((entry_len > 2) && (entry[0] == '/') && entry[entry_len - 1] == '/')
285         {
286                 char *entry_copy;
287                 size_t entry_copy_size;
288                 int status;
289
290                 /* We need to copy `entry' since it's const */
291                 entry_copy_size = entry_len - 1;
292                 entry_copy = smalloc (entry_copy_size);
293                 sstrncpy (entry_copy, entry + 1, entry_copy_size);
294
295                 status = ignorelist_append_regex(il, entry_copy);
296                 sfree (entry_copy);
297                 return status;
298         }
299 #endif
300
301         return ignorelist_append_string(il, entry);
302 } /* int ignorelist_add (ignorelist_t *il, const char *entry) */
303
304 /*
305  * check list for entry
306  * return 1 for ignored entry
307  */
308 int ignorelist_match (ignorelist_t *il, const char *entry)
309 {
310         ignorelist_item_t *traverse;
311
312         /* if no entries, collect all */
313         if ((il == NULL) || (il->head == NULL))
314                 return (0);
315
316         if ((entry == NULL) || (strlen (entry) == 0))
317                 return (0);
318
319         /* traverse list and check entries */
320         for (traverse = il->head; traverse != NULL; traverse = traverse->next)
321         {
322 #if HAVE_REGEX_H
323                 if (traverse->rmatch != NULL)
324                 {
325                         if (ignorelist_match_regex (traverse, entry))
326                                 return (il->ignore);
327                 }
328                 else
329 #endif
330                 {
331                         if (ignorelist_match_string (traverse, entry))
332                                 return (il->ignore);
333                 }
334         } /* for traverse */
335
336         return (1 - il->ignore);
337 } /* int ignorelist_match (ignorelist_t *il, const char *entry) */
338