Merge branch 'collectd-4.1' into collectd-4.2

diff --combined src/rrdtool.c
index e356bf1,79331bf..dc06d68
--- 1/src/rrdtool.c
--- 2/src/rrdtool.c
+++ b/src/rrdtool.c
@@@ -105,7 -105,7 +105,7 @@@ static double  xff       = 0.1
  static int         cache_timeout = 0;
  static int         cache_flush_timeout = 0;
  static time_t      cache_flush_last;
- static avl_tree_t *cache = NULL;
+ static c_avl_tree_t *cache = NULL;
  static pthread_mutex_t cache_lock = PTHREAD_MUTEX_INITIALIZER;
  
  static rrd_queue_t    *queue_head = NULL;
@@@ -641,7 -641,7 +641,7 @@@ static void *rrd_queue_thread (void *da
                 * we make a copy of it's values */
                pthread_mutex_lock (&cache_lock);
  
-               avl_get (cache, queue_entry->filename, (void *) &cache_entry);
+               c_avl_get (cache, queue_entry->filename, (void *) &cache_entry);
  
                values = cache_entry->values;
                values_num = cache_entry->values_num;
@@@ -654,8 -654,6 +654,8 @@@
  
                /* Write the values to the RRD-file */
                srrd_update (queue_entry->filename, NULL, values_num, values);
 +              DEBUG ("rrdtool plugin: queue thread: Wrote %i values to %s",
 +                              values_num, queue_entry->filename);
  
                for (i = 0; i < values_num; i++)
                {
@@@ -667,7 -665,7 +667,7 @@@
        } /* while (42) */
  
        pthread_mutex_lock (&cache_lock);
-       avl_destroy (cache);
+       c_avl_destroy (cache);
        cache = NULL;
        pthread_mutex_unlock (&cache_lock);
  
@@@ -715,7 -713,7 +715,7 @@@ static void rrd_cache_flush (int timeou
        int    keys_num = 0;
  
        char *key;
-       avl_iterator_t *iter;
+       c_avl_iterator_t *iter;
        int i;
  
        DEBUG ("rrdtool plugin: Flushing cache, timeout = %i", timeout);
@@@ -723,8 -721,8 +723,8 @@@
        now = time (NULL);
  
        /* Build a list of entries to be flushed */
-       iter = avl_get_iterator (cache);
-       while (avl_iterator_next (iter, (void *) &key, (void *) &rc) == 0)
+       iter = c_avl_get_iterator (cache);
+       while (c_avl_iterator_next (iter, (void *) &key, (void *) &rc) == 0)
        {
                if (rc->flags == FLAG_QUEUED)
                        continue;
@@@ -737,29 -735,31 +737,31 @@@
                }
                else /* ancient and no values -> waste of memory */
                {
-                       keys = (char **) realloc ((void *) keys,
+                       char **tmp = (char **) realloc ((void *) keys,
                                        (keys_num + 1) * sizeof (char *));
-                       if (keys == NULL)
+                       if (tmp == NULL)
                        {
                                char errbuf[1024];
                                ERROR ("rrdtool plugin: "
                                                "realloc failed: %s",
                                                sstrerror (errno, errbuf,
                                                        sizeof (errbuf)));
-                               avl_iterator_destroy (iter);
+                               c_avl_iterator_destroy (iter);
+                               sfree (keys);
                                return;
                        }
+                       keys = tmp;
                        keys[keys_num] = key;
                        keys_num++;
                }
-       } /* while (avl_iterator_next) */
-       avl_iterator_destroy (iter);
+       } /* while (c_avl_iterator_next) */
+       c_avl_iterator_destroy (iter);
        
        for (i = 0; i < keys_num; i++)
        {
-               if (avl_remove (cache, keys[i], (void *) &key, (void *) &rc) != 0)
+               if (c_avl_remove (cache, keys[i], (void *) &key, (void *) &rc) != 0)
                {
-                       DEBUG ("rrdtool plugin: avl_remove (%s) failed.", keys[i]);
+                       DEBUG ("rrdtool plugin: c_avl_remove (%s) failed.", keys[i]);
                        continue;
                }
  
@@@ -771,7 -771,7 +773,7 @@@
                keys[i] = NULL;
        } /* for (i = 0..keys_num) */
  
-       free (keys);
+       sfree (keys);
  
        cache_flush_last = now;
  } /* void rrd_cache_flush */
@@@ -785,7 -785,7 +787,7 @@@ static int rrd_cache_insert (const cha
  
        pthread_mutex_lock (&cache_lock);
  
-       avl_get (cache, filename, (void *) &rc);
+       c_avl_get (cache, filename, (void *) &rc);
  
        if (rc == NULL)
        {
@@@ -818,7 -818,7 +820,7 @@@
  
                sstrerror (errno, errbuf, sizeof (errbuf));
  
-               avl_remove (cache, filename, &cache_key, NULL);
+               c_avl_remove (cache, filename, &cache_key, NULL);
                pthread_mutex_unlock (&cache_lock);
  
                ERROR ("rrdtool plugin: realloc failed: %s", errbuf);
@@@ -858,7 -858,7 +860,7 @@@
                        return (-1);
                }
  
-               avl_insert (cache, cache_key, rc);
+               c_avl_insert (cache, cache_key, rc);
        }
  
        DEBUG ("rrdtool plugin: rrd_cache_insert: file = %s; "
@@@ -1097,10 -1097,10 +1099,10 @@@ static int rrd_init (void
        /* Set the cache up */
        pthread_mutex_lock (&cache_lock);
  
-       cache = avl_create ((int (*) (const void *, const void *)) strcmp);
+       cache = c_avl_create ((int (*) (const void *, const void *)) strcmp);
        if (cache == NULL)
        {
-               ERROR ("rrdtool plugin: avl_create failed.");
+               ERROR ("rrdtool plugin: c_avl_create failed.");
                return (-1);
        }
  

diff --combined src/utils_avltree.c
index 11d3d71,e460959..83821fe
--- 1/src/utils_avltree.c
--- 2/src/utils_avltree.c
+++ b/src/utils_avltree.c
@@@ -35,35 -35,35 +35,35 @@@
  /*
   * private data types
   */
- struct avl_node_s
+ struct c_avl_node_s
  {
        void *key;
        void *value;
  
        int height;
-       struct avl_node_s *left;
-       struct avl_node_s *right;
-       struct avl_node_s *parent;
+       struct c_avl_node_s *left;
+       struct c_avl_node_s *right;
+       struct c_avl_node_s *parent;
  };
- typedef struct avl_node_s avl_node_t;
+ typedef struct c_avl_node_s c_avl_node_t;
  
- struct avl_tree_s
+ struct c_avl_tree_s
  {
-       avl_node_t *root;
+       c_avl_node_t *root;
        int (*compare) (const void *, const void *);
  };
  
- struct avl_iterator_s
+ struct c_avl_iterator_s
  {
-       avl_tree_t *tree;
-       avl_node_t *node;
+       c_avl_tree_t *tree;
+       c_avl_node_t *node;
  };
  
  /*
   * private functions
   */
  #if 0
- static void verify_tree (avl_node_t *n)
+ static void verify_tree (c_avl_node_t *n)
  {
        if (n == NULL)
                return;
@@@ -78,7 -78,7 +78,7 @@@
  # define verify_tree(n) /**/
  #endif
  
- static void free_node (avl_node_t *n)
+ static void free_node (c_avl_node_t *n)
  {
        if (n == NULL)
                return;
@@@ -91,7 -91,7 +91,7 @@@
        free (n);
  }
  
- static int calc_height (avl_node_t *n)
+ static int calc_height (c_avl_node_t *n)
  {
        int height_left;
        int height_right;
@@@ -107,9 -107,9 +107,9 @@@
                                : height_right) + 1);
  } /* int calc_height */
  
- static avl_node_t *search (avl_tree_t *t, const void *key)
+ static c_avl_node_t *search (c_avl_tree_t *t, const void *key)
  {
-       avl_node_t *n;
+       c_avl_node_t *n;
        int cmp;
  
        n = t->root;
@@@ -135,11 -135,11 +135,11 @@@
   *  / a\ /_b\               /_b\ /_c\
   * /____\
   */
- static avl_node_t *rotate_right (avl_tree_t *t, avl_node_t *x)
+ static c_avl_node_t *rotate_right (c_avl_tree_t *t, c_avl_node_t *x)
  {
-       avl_node_t *p;
-       avl_node_t *y;
-       avl_node_t *b;
+       c_avl_node_t *p;
+       c_avl_node_t *y;
+       c_avl_node_t *b;
  
        p = x->parent;
        y = x->left;
@@@ -176,11 -176,11 +176,11 @@@
   *     /_b\ / c\     /_a\ /_b\
   *         /____\
   */
- static avl_node_t *rotate_left (avl_tree_t *t, avl_node_t *x)
+ static c_avl_node_t *rotate_left (c_avl_tree_t *t, c_avl_node_t *x)
  {
-       avl_node_t *p;
-       avl_node_t *y;
-       avl_node_t *b;
+       c_avl_node_t *p;
+       c_avl_node_t *y;
+       c_avl_node_t *b;
  
        p = x->parent;
        y = x->right;
@@@ -208,19 -208,19 +208,19 @@@
        return (y);
  } /* void rotate_left */
  
- static avl_node_t *rotate_left_right (avl_tree_t *t, avl_node_t *x)
+ static c_avl_node_t *rotate_left_right (c_avl_tree_t *t, c_avl_node_t *x)
  {
        rotate_left (t, x->left);
        return (rotate_right (t, x));
  } /* void rotate_left_right */
  
- static avl_node_t *rotate_right_left (avl_tree_t *t, avl_node_t *x)
+ static c_avl_node_t *rotate_right_left (c_avl_tree_t *t, c_avl_node_t *x)
  {
        rotate_right (t, x->right);
        return (rotate_left (t, x));
  } /* void rotate_right_left */
  
- static void rebalance (avl_tree_t *t, avl_node_t *n)
+ static void rebalance (c_avl_tree_t *t, c_avl_node_t *n)
  {
        int b_top;
        int b_bottom;
@@@ -264,9 -264,9 +264,9 @@@
        } /* while (n != NULL) */
  } /* void rebalance */
  
- static avl_node_t *avl_node_next (avl_tree_t *t, avl_node_t *n)
+ static c_avl_node_t *c_avl_node_next (c_avl_tree_t *t, c_avl_node_t *n)
  {
-       avl_node_t *r; /* return node */
+       c_avl_node_t *r; /* return node */
  
        if (n == NULL)
        {
@@@ -307,11 -307,11 +307,11 @@@
        }
  
        return (r);
- } /* avl_node_t *avl_node_next */
+ } /* c_avl_node_t *c_avl_node_next */
  
- static avl_node_t *avl_node_prev (avl_tree_t *t, avl_node_t *n)
+ static c_avl_node_t *c_avl_node_prev (c_avl_tree_t *t, c_avl_node_t *n)
  {
-       avl_node_t *r; /* return node */
+       c_avl_node_t *r; /* return node */
  
        if (n == NULL)
        {
@@@ -352,25 -352,25 +352,25 @@@
        }
  
        return (r);
- } /* avl_node_t *avl_node_prev */
+ } /* c_avl_node_t *c_avl_node_prev */
  
- static int _remove (avl_tree_t *t, avl_node_t *n)
+ static int _remove (c_avl_tree_t *t, c_avl_node_t *n)
  {
        assert ((t != NULL) && (n != NULL));
  
        if ((n->left != NULL) && (n->right != NULL))
        {
-               avl_node_t *r; /* replacement node */
+               c_avl_node_t *r; /* replacement node */
                if (BALANCE (n) > 0) /* left subtree is higher */
                {
                        assert (n->left != NULL);
-                       r = avl_node_prev (t, n);
+                       r = c_avl_node_prev (t, n);
                        
                }
                else /* right subtree is higher */
                {
                        assert (n->right != NULL);
-                       r = avl_node_next (t, n);
+                       r = c_avl_node_next (t, n);
                }
  
                assert ((r->left == NULL) || (r->right == NULL));
@@@ -467,14 -467,14 +467,14 @@@
  /*
   * public functions
   */
- avl_tree_t *avl_create (int (*compare) (const void *, const void *))
+ c_avl_tree_t *c_avl_create (int (*compare) (const void *, const void *))
  {
-       avl_tree_t *t;
+       c_avl_tree_t *t;
  
        if (compare == NULL)
                return (NULL);
  
-       if ((t = (avl_tree_t *) malloc (sizeof (avl_tree_t))) == NULL)
+       if ((t = (c_avl_tree_t *) malloc (sizeof (c_avl_tree_t))) == NULL)
                return (NULL);
  
        t->root = NULL;
@@@ -483,19 -483,19 +483,19 @@@
        return (t);
  }
  
- void avl_destroy (avl_tree_t *t)
+ void c_avl_destroy (c_avl_tree_t *t)
  {
        free_node (t->root);
        free (t);
  }
  
- int avl_insert (avl_tree_t *t, void *key, void *value)
+ int c_avl_insert (c_avl_tree_t *t, void *key, void *value)
  {
-       avl_node_t *new;
-       avl_node_t *nptr;
+       c_avl_node_t *new;
+       c_avl_node_t *nptr;
        int cmp;
  
-       if ((new = (avl_node_t *) malloc (sizeof (avl_node_t))) == NULL)
+       if ((new = (c_avl_node_t *) malloc (sizeof (c_avl_node_t))) == NULL)
                return (-1);
  
        new->key = key;
@@@ -554,11 -554,11 +554,11 @@@
  
        verify_tree (t->root);
        return (0);
- } /* int avl_insert */
+ } /* int c_avl_insert */
  
- int avl_remove (avl_tree_t *t, const void *key, void **rkey, void **rvalue)
+ int c_avl_remove (c_avl_tree_t *t, const void *key, void **rkey, void **rvalue)
  {
-       avl_node_t *n;
+       c_avl_node_t *n;
        int status;
  
        assert (t != NULL);
@@@ -575,26 -575,27 +575,26 @@@
        status = _remove (t, n);
        verify_tree (t->root);
        return (status);
- } /* void *avl_remove */
+ } /* void *c_avl_remove */
  
- int avl_get (avl_tree_t *t, const void *key, void **value)
+ int c_avl_get (c_avl_tree_t *t, const void *key, void **value)
  {
-       avl_node_t *n;
+       c_avl_node_t *n;
  
 -      assert (value != NULL);
 -
        n = search (t, key);
        if (n == NULL)
                return (-1);
  
 -      *value = n->value;
 +      if (value != NULL)
 +              *value = n->value;
  
        return (0);
  }
  
- int avl_pick (avl_tree_t *t, void **key, void **value)
+ int c_avl_pick (c_avl_tree_t *t, void **key, void **value)
  {
-       avl_node_t *n;
-       avl_node_t *p;
+       c_avl_node_t *n;
+       c_avl_node_t *p;
  
        if ((key == NULL) || (value == NULL))
                return (-1);
@@@ -628,27 -629,27 +628,27 @@@
        rebalance (t, p);
  
        return (0);
- } /* int avl_pick */
+ } /* int c_avl_pick */
  
- avl_iterator_t *avl_get_iterator (avl_tree_t *t)
+ c_avl_iterator_t *c_avl_get_iterator (c_avl_tree_t *t)
  {
-       avl_iterator_t *iter;
+       c_avl_iterator_t *iter;
  
        if (t == NULL)
                return (NULL);
  
-       iter = (avl_iterator_t *) malloc (sizeof (avl_iterator_t));
+       iter = (c_avl_iterator_t *) malloc (sizeof (c_avl_iterator_t));
        if (iter == NULL)
                return (NULL);
-       memset (iter, '\0', sizeof (avl_iterator_t));
+       memset (iter, '\0', sizeof (c_avl_iterator_t));
        iter->tree = t;
  
        return (iter);
- } /* avl_iterator_t *avl_get_iterator */
+ } /* c_avl_iterator_t *c_avl_get_iterator */
  
- int avl_iterator_next (avl_iterator_t *iter, void **key, void **value)
+ int c_avl_iterator_next (c_avl_iterator_t *iter, void **key, void **value)
  {
-       avl_node_t *n;
+       c_avl_node_t *n;
  
        if ((iter == NULL) || (key == NULL) || (value == NULL))
                return (-1);
@@@ -662,7 -663,7 +662,7 @@@
        }
        else
        {
-               n = avl_node_next (iter->tree, iter->node);
+               n = c_avl_node_next (iter->tree, iter->node);
        }
  
        if (n == NULL)
@@@ -673,11 -674,11 +673,11 @@@
        *value = n->value;
  
        return (0);
- } /* int avl_iterator_next */
+ } /* int c_avl_iterator_next */
  
- int avl_iterator_prev (avl_iterator_t *iter, void **key, void **value)
+ int c_avl_iterator_prev (c_avl_iterator_t *iter, void **key, void **value)
  {
-       avl_node_t *n;
+       c_avl_node_t *n;
  
        if ((iter == NULL) || (key == NULL) || (value == NULL))
                return (-1);
@@@ -691,7 -692,7 +691,7 @@@
        }
        else
        {
-               n = avl_node_prev (iter->tree, iter->node);
+               n = c_avl_node_prev (iter->tree, iter->node);
        }
  
        if (n == NULL)
@@@ -702,9 -703,9 +702,9 @@@
        *value = n->value;
  
        return (0);
- } /* int avl_iterator_prev */
+ } /* int c_avl_iterator_prev */
  
- void avl_iterator_destroy (avl_iterator_t *iter)
+ void c_avl_iterator_destroy (c_avl_iterator_t *iter)
  {
        free (iter);
  }