/** * collectd - src/utils_ignorelist.c * Copyright (C) 2006 Lubos Stanek * Copyright (C) 2008 Florian Forster * * This program is free software; you can redistribute it and/ * or modify it under the terms of the GNU General Public Li- * cence as published by the Free Software Foundation; either * version 2 of the Licence, or any later version. * * This program is distributed in the hope that it will be use- * ful, but WITHOUT ANY WARRANTY; without even the implied war- * ranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public Licence for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * * Authors: * Lubos Stanek * Florian Forster **/ /** * ignorelist handles plugin's list of configured collectable * entries with global ignore action **/ /** * Usage: * * Define plugin's global pointer variable of type ignorelist_t: * ignorelist_t *myconfig_ignore; * If you know the state of the global ignore (IgnoreSelected), * allocate the variable with: * myconfig_ignore = ignorelist_create (YourKnownIgnore); * If you do not know the state of the global ignore, * initialize the global variable and set the ignore flag later: * myconfig_ignore = ignorelist_init (); * Append single entries in your cf_register'ed callback function: * ignorelist_add (myconfig_ignore, newentry); * When you hit the IgnoreSelected config option, * offer it to the list: * ignorelist_ignore (myconfig_ignore, instantly_got_value_of_ignore); * That is all for the ignorelist initialization. * Later during read and write (plugin's registered functions) get * the information whether this entry would be collected or not: * if (ignorelist_match (myconfig_ignore, thisentry)) * return; **/ #if HAVE_CONFIG_H #include "config.h" #endif #include "plugin.h" #include "utils/common/common.h" #include "utils/ignorelist/ignorelist.h" /* * private prototypes */ struct ignorelist_item_s { #if HAVE_REGEX_H regex_t *rmatch; /* regular expression entry identification */ #endif char *smatch; /* string entry identification */ struct ignorelist_item_s *next; }; typedef struct ignorelist_item_s ignorelist_item_t; struct ignorelist_s { int ignore; /* ignore entries */ ignorelist_item_t *head; /* pointer to the first entry */ }; /* *** *** *** ********************************************* *** *** *** */ /* *** *** *** *** *** *** private functions *** *** *** *** *** *** */ /* *** *** *** ********************************************* *** *** *** */ static inline void ignorelist_append(ignorelist_t *il, ignorelist_item_t *item) { assert((il != NULL) && (item != NULL)); item->next = il->head; il->head = item; } #if HAVE_REGEX_H static int ignorelist_append_regex(ignorelist_t *il, const char *re_str) { regex_t *re; ignorelist_item_t *entry; int status; re = calloc(1, sizeof(*re)); if (re == NULL) { ERROR("ignorelist_append_regex: calloc failed."); return ENOMEM; } status = regcomp(re, re_str, REG_EXTENDED); if (status != 0) { char errbuf[1024]; (void)regerror(status, re, errbuf, sizeof(errbuf)); ERROR("utils_ignorelist: regcomp failed: %s", errbuf); ERROR("ignorelist_append_regex: Compiling regular expression \"%s\" " "failed: %s", re_str, errbuf); sfree(re); return status; } entry = calloc(1, sizeof(*entry)); if (entry == NULL) { ERROR("ignorelist_append_regex: calloc failed."); regfree(re); sfree(re); return ENOMEM; } entry->rmatch = re; ignorelist_append(il, entry); return 0; } /* int ignorelist_append_regex */ #endif static int ignorelist_append_string(ignorelist_t *il, const char *entry) { ignorelist_item_t *new; /* create new entry */ if ((new = calloc(1, sizeof(*new))) == NULL) { ERROR("cannot allocate new entry"); return 1; } new->smatch = sstrdup(entry); /* append new entry */ ignorelist_append(il, new); return 0; } /* int ignorelist_append_string(ignorelist_t *il, const char *entry) */ #if HAVE_REGEX_H /* * check list for entry regex match * return 1 if found */ static int ignorelist_match_regex(ignorelist_item_t *item, const char *entry) { assert((item != NULL) && (item->rmatch != NULL) && (entry != NULL) && (strlen(entry) > 0)); /* match regex */ if (regexec(item->rmatch, entry, 0, NULL, 0) == 0) return 1; return 0; } /* int ignorelist_match_regex (ignorelist_item_t *item, const char *entry) */ #endif /* * check list for entry string match * return 1 if found */ static int ignorelist_match_string(ignorelist_item_t *item, const char *entry) { assert((item != NULL) && (item->smatch != NULL) && (entry != NULL) && (strlen(entry) > 0)); if (strcmp(entry, item->smatch) == 0) return 1; return 0; } /* int ignorelist_match_string (ignorelist_item_t *item, const char *entry) */ /* *** *** *** ******************************************** *** *** *** */ /* *** *** *** *** *** *** public functions *** *** *** *** *** *** */ /* *** *** *** ******************************************** *** *** *** */ /* * create the ignorelist_t with known ignore state * return pointer to ignorelist_t */ ignorelist_t *ignorelist_create(int invert) { ignorelist_t *il; il = calloc(1, sizeof(*il)); if (il == NULL) return NULL; /* * ->ignore == 0 => collect * ->ignore == 1 => ignore */ il->ignore = invert ? 0 : 1; return il; } /* ignorelist_t *ignorelist_create (int ignore) */ /* * free memory used by ignorelist_t */ void ignorelist_free(ignorelist_t *il) { ignorelist_item_t *this; ignorelist_item_t *next; if (il == NULL) return; for (this = il->head; this != NULL; this = next) { next = this->next; #if HAVE_REGEX_H if (this->rmatch != NULL) { regfree(this->rmatch); sfree(this->rmatch); this->rmatch = NULL; } #endif if (this->smatch != NULL) { sfree(this->smatch); this->smatch = NULL; } sfree(this); } sfree(il); } /* void ignorelist_destroy (ignorelist_t *il) */ /* * set ignore state of the ignorelist_t */ void ignorelist_set_invert(ignorelist_t *il, int invert) { if (il == NULL) { DEBUG("ignore call with ignorelist_t == NULL"); return; } il->ignore = invert ? 0 : 1; } /* void ignorelist_set_invert (ignorelist_t *il, int ignore) */ /* * append entry into ignorelist_t * return 0 for success */ int ignorelist_add(ignorelist_t *il, const char *entry) { size_t len; if (il == NULL) { DEBUG("add called with ignorelist_t == NULL"); return 1; } len = strlen(entry); /* append nothing */ if (len == 0) { DEBUG("not appending: empty entry"); return 1; } #if HAVE_REGEX_H /* regex string is enclosed in "/.../" */ if ((len > 2) && (entry[0] == '/') && entry[len - 1] == '/') { char *copy; int status; /* skip leading slash */ copy = strdup(entry + 1); if (copy == NULL) return ENOMEM; /* trim trailing slash */ copy[strlen(copy) - 1] = '\0'; status = ignorelist_append_regex(il, copy); sfree(copy); return status; } #endif return ignorelist_append_string(il, entry); } /* int ignorelist_add (ignorelist_t *il, const char *entry) */ /* * remove entry from ignorelist_t * return 0 for success */ int ignorelist_remove(ignorelist_t *il, const char *entry) { /* if no entries, nothing to remove */ if ((il == NULL) || (il->head == NULL)) return 1; if ((entry == NULL) || (strlen(entry) == 0)) return 1; /* traverse list and check entries */ for (ignorelist_item_t *prev = NULL, *traverse = il->head; traverse != NULL; prev = traverse, traverse = traverse->next) { if (traverse->smatch != NULL && strcmp(traverse->smatch, entry) == 0) { if (prev == NULL) { il->head = traverse->next; } else { prev->next = traverse->next; } sfree(traverse->smatch); traverse->smatch = NULL; sfree(traverse); return 0; } } /* for traverse */ return 1; } /* int ignorelist_remove (ignorelist_t *il, const char *entry) */ /* * check list for entry * return 1 for ignored entry */ int ignorelist_match(ignorelist_t *il, const char *entry) { /* if no entries, collect all */ if ((il == NULL) || (il->head == NULL)) return 0; if ((entry == NULL) || (strlen(entry) == 0)) return 0; /* traverse list and check entries */ for (ignorelist_item_t *traverse = il->head; traverse != NULL; traverse = traverse->next) { #if HAVE_REGEX_H if (traverse->rmatch != NULL) { if (ignorelist_match_regex(traverse, entry)) return il->ignore; } else #endif { if (ignorelist_match_string(traverse, entry)) return il->ignore; } } /* for traverse */ return 1 - il->ignore; } /* int ignorelist_match (ignorelist_t *il, const char *entry) */