Merge branch 'collectd-5.4' into collectd-5.5

diff --cc src/daemon/utils_ignorelist.c
index 6b5e894f8e83e75998ae4c6cedc27ea45451e2bf,0000000000000000000000000000000000000000..692a1e51bc12c9698025674c8f034d4cd05ba851
mode 100644,000000..100644
--- 1/src/daemon/utils_ignorelist.c
--- /dev/null
+++ b/src/daemon/utils_ignorelist.c
@@@ -1,346 -1,0 +1,345 @@@
-  * You should have received a copy of the GNU General Public
-  * Licence along with this program; if not, write to the Free
-  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
-  * USA.
 +/**
 + * collectd - src/utils_ignorelist.c
 + * Copyright (C) 2006 Lubos Stanek <lubek at users.sourceforge.net>
 + * Copyright (C) 2008 Florian Forster <octo at collectd.org>
 + *
 + * 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 <lubek at users.sourceforge.net>
 + *   Florian Forster <octo at collectd.org>
 + **/
 +/**
 + * 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 "common.h"
 +#include "plugin.h"
 +#include "utils_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 *entry)
 +{
 +      regex_t *re;
 +      ignorelist_item_t *item;
 +      int status;
 +
 +      /* create buffer */
 +      re = malloc (sizeof (*re));
 +      if (re == NULL)
 +      {
 +              ERROR ("ignorelist_append_regex: malloc failed.");
 +              return ENOMEM;
 +      }
 +      memset (re, 0, sizeof (*re));
 +
 +      /* compile regex */
 +      status = regcomp (re, entry, REG_EXTENDED);
 +      if (status != 0)
 +      {
 +              char errbuf[1024];
 +
 +              (void) regerror (status, re, errbuf, sizeof (errbuf));
 +              ERROR ("ignorelist_append_regex: Compiling regular expression \"%s\" failed: %s", entry, errbuf);
 +              sfree (re);
 +              return status;
 +      }
 +
 +      /* create new entry */
 +      item = malloc (sizeof (*item));
 +      if (item == NULL)
 +      {
 +              ERROR ("ignorelist_append_regex: malloc failed.");
 +              regfree (re);
 +              sfree (re);
 +              return ENOMEM;
 +      }
 +      memset (item, 0, sizeof (*item));
 +      item->rmatch = re;
 +
 +      /* append new entry */
 +      ignorelist_append (il, item);
 +
 +      return (0);
 +} /* int ignorelist_append_regex(ignorelist_t *il, const char *entry) */
 +#endif
 +
 +static int ignorelist_append_string(ignorelist_t *il, const char *entry)
 +{
 +      ignorelist_item_t *new;
 +
 +      /* create new entry */
 +      if ((new = malloc(sizeof(ignorelist_item_t))) == NULL )
 +      {
 +              ERROR ("cannot allocate new entry");
 +              return (1);
 +      }
 +      memset (new, '\0', sizeof(ignorelist_item_t));
 +      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 = malloc (sizeof (*il));
 +      if (il == NULL)
 +              return NULL;
 +      memset (il, 0, sizeof (*il));
 +
 +      /*
 +       * ->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);
 +      il = NULL;
 +} /* 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 1 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) */
 +
 +/*
 + * check list for entry
 + * return 1 for ignored entry
 + */
 +int ignorelist_match (ignorelist_t *il, const char *entry)
 +{
 +      ignorelist_item_t *traverse;
 +
 +      /* 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 (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) */
 +

diff --cc src/daemon/utils_ignorelist.h
index b47b55adb0a10ea4840e0143806b3d5e29e7bba3,0000000000000000000000000000000000000000..db7535fdf97a3688915d022f7f58d5476bf2b903
mode 100644,000000..100644
--- 1/src/daemon/utils_ignorelist.h
--- /dev/null
+++ b/src/daemon/utils_ignorelist.h
@@@ -1,70 -1,0 +1,69 @@@
-  * You should have received a copy of the GNU General Public
-  * Licence along with this program; if not, write to the Free
-  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
-  * USA.
 +/**
 + * collectd - src/utils_ignorelist.h
 + * Copyright (C) 2006 Lubos Stanek <lubek at users.sourceforge.net>
 + *
 + * 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 <lubek at users.sourceforge.net>
 + **/
 +/**
 + * ignorelist handles plugin's list of configured collectable
 + * entries with global ignore action
 + **/
 +
 +#ifndef UTILS_IGNORELIST_H
 +#define UTILS_IGNORELIST_H 1
 +
 +#include "collectd.h"
 +
 +#if HAVE_REGEX_H
 +# include <regex.h>
 +#endif
 +
 +/* public prototypes */
 +
 +struct ignorelist_s;
 +typedef struct ignorelist_s ignorelist_t;
 +
 +/*
 + * create the ignorelist_t with known ignore state
 + * return pointer to ignorelist_t
 + */
 +ignorelist_t *ignorelist_create (int invert);
 +
 +/*
 + * free memory used by ignorelist_t
 + */
 +void ignorelist_free (ignorelist_t *il);
 +
 +/*
 + * set ignore state of the ignorelist_t
 + */
 +void ignorelist_set_invert (ignorelist_t *il, int invert);
 +
 +/*
 + * append entry to ignorelist_t
 + * returns zero on success, non-zero upon failure.
 + */
 +int ignorelist_add (ignorelist_t *il, const char *entry);
 +
 +/*
 + * check list for entry
 + * return 1 for ignored entry
 + */
 +int ignorelist_match (ignorelist_t *il, const char *entry);
 +
 +#endif /* UTILS_IGNORELIST_H */

diff --cc src/utils_mount.c
Simple merge

diff --cc src/utils_mount.h
Simple merge