-EXTRA_DIST = perl/Collectd.pm perl/Makefile.PL perl/Collectd/Makefile.PL perl/Collectd/Unixsock.pm
+EXTRA_DIST = perl/Collectd.pm perl/Makefile.PL perl/Collectd/Makefile.PL \
+ perl/Collectd/Unixsock.pm
all-local: @PERL_BINDINGS@
perl: perl/Makefile
$(MAKE) -C perl
- perl/Makefile: perl/Makefile.PL perl/Collectd/Makefile.PL \
- $(top_builddir)/config.status
-perl/Makefile: .perl-directory-stamp perl/Makefile.PL perl/Collectd/Makefile.PL
++perl/Makefile: .perl-directory-stamp perl/Makefile.PL \
++ perl/Collectd/Makefile.PL $(top_builddir)/config.status
cd perl && @PERL@ Makefile.PL PREFIX=$(prefix) @PERL_BINDINGS_OPTIONS@
+ .perl-directory-stamp:
+ if test ! -d perl; then \
+ mkdir -p perl/Collectd; \
+ cp $(srcdir)/perl/{Collectd.pm,Makefile.PL} perl/; \
+ cp $(srcdir)/perl/Collectd/{Unixsock.pm,Makefile.PL} perl/Collectd/; \
+ fi
+ touch $@
+
.PHONY: perl
AM_CFLAGS = -Wall -Werror
endif
-sbin_PROGRAMS = collectd
+AM_CPPFLAGS = -DPREFIX='"${prefix}"'
+AM_CPPFLAGS += -DCONFIGFILE='"${sysconfdir}/${PACKAGE_NAME}.conf"'
+AM_CPPFLAGS += -DLOCALSTATEDIR='"${localstatedir}"'
+AM_CPPFLAGS += -DPKGLOCALSTATEDIR='"${localstatedir}/lib/${PACKAGE_NAME}"'
+if BUILD_FEATURE_DAEMON
+AM_CPPFLAGS += -DPIDFILE='"${localstatedir}/run/${PACKAGE_NAME}.pid"'
+endif
+AM_CPPFLAGS += -DPLUGINDIR='"${pkglibdir}"'
+
+sbin_PROGRAMS = collectd collectdmon
bin_PROGRAMS = collectd-nagios
collectd_SOURCES = collectd.c collectd.h \
- utils_avltree.c utils_avltree.h \
- utils_mount.c utils_mount.h \
- utils_llist.c utils_llist.h \
- utils_ignorelist.c utils_ignorelist.h \
common.c common.h \
- plugin.c plugin.h \
configfile.c configfile.h \
+ plugin.c plugin.h \
+ utils_avltree.c utils_avltree.h \
+ utils_cache.c utils_cache.h \
+ utils_ignorelist.c utils_ignorelist.h \
+ utils_llist.c utils_llist.h \
+ utils_mount.c utils_mount.h \
+ utils_threshold.c utils_threshold.h \
types_list.c types_list.h
collectd_CPPFLAGS = $(LTDLINCL)
-collectd_CPPFLAGS += -DPREFIX='"${prefix}"'
-collectd_CPPFLAGS += -DCONFIGFILE='"${sysconfdir}/${PACKAGE_NAME}.conf"'
-collectd_CPPFLAGS += -DLOCALSTATEDIR='"${localstatedir}"'
-collectd_CPPFLAGS += -DPKGLOCALSTATEDIR='"${localstatedir}/lib/${PACKAGE_NAME}"'
-if BUILD_FEATURE_DAEMON
-collectd_CPPFLAGS += -DPIDFILE='"${localstatedir}/run/${PACKAGE_NAME}.pid"'
-endif
-collectd_CPPFLAGS += -DPLUGINDIR='"${pkglibdir}"'
+collectd_CPPFLAGS += $(AM_CPPFLAGS)
# Link to these libraries..
collectd_LDFLAGS = -export-dynamic
collectd_LDFLAGS += -loconfig
endif
+collectdmon_SOURCES = collectdmon.c
+collectdmon_CPPFLAGS = $(AM_CPPFLAGS)
+
collectd_nagios_SOURCES = collectd-nagios.c
collectd_nagios_LDFLAGS =
if BUILD_WITH_LIBSOCKET
collectd_DEPENDENCIES += irq.la
endif
+if BUILD_PLUGIN_LIBVIRT
+pkglib_LTLIBRARIES += libvirt.la
+libvirt_la_SOURCES = libvirt.c
+libvirt_la_CFLAGS = $(BUILD_WITH_LIBVIRT_CFLAGS) $(BUILD_WITH_LIBXML2_CFLAGS)
+libvirt_la_LIBADD = $(BUILD_WITH_LIBVIRT_LIBS) $(BUILD_WITH_LIBXML2_LIBS)
+libvirt_la_LDFLAGS = -module -avoid-version
+collectd_LDADD += "-dlopen" libvirt.la
+collectd_DEPENDENCIES += libvirt.la
+endif
+
if BUILD_PLUGIN_LOAD
pkglib_LTLIBRARIES += load.la
load_la_SOURCES = load.c
if BUILD_PLUGIN_NGINX
pkglib_LTLIBRARIES += nginx.la
nginx_la_SOURCES = nginx.c
+ nginx_la_CFLAGS = $(AM_CFLAGS)
+ nginx_la_LIBADD =
nginx_la_LDFLAGS = -module -avoid-version
if BUILD_WITH_LIBCURL
- nginx_la_LDFLAGS += $(BUILD_WITH_LIBCURL_LIBS)
+ nginx_la_CFLAGS += $(BUILD_WITH_LIBCURL_CFLAGS)
+ nginx_la_LIBADD += $(BUILD_WITH_LIBCURL_LIBS)
endif
collectd_LDADD += "-dlopen" nginx.la
collectd_DEPENDENCIES += nginx.la
if BUILD_PLUGIN_UNIXSOCK
pkglib_LTLIBRARIES += unixsock.la
unixsock_la_SOURCES = unixsock.c utils_cmd_putval.h utils_cmd_putval.c
-unixsock_la_CPPFLAGS = -DLOCALSTATEDIR='"${localstatedir}"'
unixsock_la_LDFLAGS = -module -avoid-version -lpthread
collectd_LDADD += "-dlopen" unixsock.la
collectd_DEPENDENCIES += unixsock.la
collectd_DEPENDENCIES += users.la
endif
+if BUILD_PLUGIN_UUID
+pkglib_LTLIBRARIES += uuid.la
+uuid_la_SOURCES = uuid.c
+uuid_la_CFLAGS = $(BUILD_WITH_LIBHAL_CFLAGS)
+uuid_la_LIBADD = $(BUILD_WITH_LIBHAL_LIBS)
+uuid_la_LDFLAGS = -module -avoid-version
+collectd_LDADD += "-dlopen" uuid.la
+collectd_DEPENDENCIES += uuid.la
+endif
+
if BUILD_PLUGIN_VSERVER
pkglib_LTLIBRARIES += vserver.la
vserver_la_SOURCES = vserver.c
dist_man_MANS = collectd.1 collectd-nagios.1 collectd.conf.5 \
collectd-email.5 collectd-exec.5 collectd-perl.5 \
- collectd-snmp.5 collectd-unixsock.5
+ collectd-snmp.5 collectd-unixsock.5 collectdmon.1
#collectd_1_SOURCES = collectd.pod
EXTRA_DIST += collectd-email.pod collectd-exec.pod collectd-nagios.pod \
collectd-perl.pod collectd-snmp.pod collectd-unixsock.pod \
- collectd.conf.pod collectd.pod
+ collectd.conf.pod collectd.pod collectdmon.pod
.pod.1:
pod2man --release=$(VERSION) --center=$(PACKAGE) $< >.pod2man.tmp 2>/dev/null && mv -f .pod2man.tmp $@ || true
static char send_buffer_type[DATA_MAX_NAME_LEN];
static pthread_mutex_t send_buffer_lock = PTHREAD_MUTEX_INITIALIZER;
- static avl_tree_t *cache_tree = NULL;
+ static c_avl_tree_t *cache_tree = NULL;
static pthread_mutex_t cache_lock = PTHREAD_MUTEX_INITIALIZER;
static time_t cache_flush_last;
static int cache_flush_interval = 1800;
char *key;
time_t *value;
- avl_iterator_t *iter;
+ c_avl_iterator_t *iter;
time_t curtime = time (NULL);
- iter = avl_get_iterator (cache_tree);
- while (avl_iterator_next (iter, (void *) &key, (void *) &value) == 0)
+ iter = c_avl_get_iterator (cache_tree);
+ while (c_avl_iterator_next (iter, (void *) &key, (void *) &value) == 0)
{
if ((curtime - *value) <= cache_flush_interval)
continue;
if (tmp == NULL)
{
sfree (keys);
- avl_iterator_destroy (iter);
+ c_avl_iterator_destroy (iter);
ERROR ("network plugin: cache_flush: realloc"
" failed.");
return (-1);
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_tree, keys[i], (void *) &key,
+ if (c_avl_remove (cache_tree, keys[i], (void *) &key,
(void *) &value) != 0)
{
- WARNING ("network plugin: cache_flush: avl_remove"
+ WARNING ("network plugin: cache_flush: c_avl_remove"
" (%s) failed.", keys[i]);
continue;
}
pthread_mutex_lock (&cache_lock);
- if (avl_get (cache_tree, key, (void *) &value) == 0)
+ if (c_avl_get (cache_tree, key, (void *) &value) == 0)
{
if (*value < vl->time)
{
if ((key_copy != NULL) && (value != NULL))
{
*value = vl->time;
- avl_insert (cache_tree, key_copy, value);
+ c_avl_insert (cache_tree, key_copy, value);
retval = 0;
}
else
static int network_bind_socket (const sockent_t *se, const struct addrinfo *ai)
{
int loop = 0;
+ int yes = 1;
+
+ /* allow multiple sockets to use the same PORT number */
+ if (setsockopt(se->fd, SOL_SOCKET, SO_REUSEADDR,
+ &yes, sizeof(yes)) == -1) {
+ char errbuf[1024];
+ ERROR ("setsockopt: %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return (-1);
+ }
DEBUG ("fd = %i; calling `bind'", se->fd);
void *key;
void *value;
- while (avl_pick (cache_tree, &key, &value) == 0)
+ while (c_avl_pick (cache_tree, &key, &value) == 0)
{
sfree (key);
sfree (value);
}
- avl_destroy (cache_tree);
+ c_avl_destroy (cache_tree);
cache_tree = NULL;
}
memset (&send_buffer_vl, '\0', sizeof (send_buffer_vl));
memset (send_buffer_type, '\0', sizeof (send_buffer_type));
- cache_tree = avl_create ((int (*) (const void *, const void *)) strcmp);
+ cache_tree = c_avl_create ((int (*) (const void *, const void *)) strcmp);
cache_flush_last = time (NULL);
/* setup socket(s) and so on */
/*
* 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;
# 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;
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;
: 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;
* / 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;
* /_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;
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;
} /* 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)
{
}
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)
{
}
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));
/*
* 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;
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;
if (cmp == 0)
{
free_node (new);
- return (-1);
+ return (1);
}
else if (cmp < 0)
{
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);
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;
n = search (t, key);
if (n == NULL)
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);
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);
}
else
{
- n = avl_node_next (iter->tree, iter->node);
+ n = c_avl_node_next (iter->tree, iter->node);
}
if (n == NULL)
*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);
}
else
{
- n = avl_node_prev (iter->tree, iter->node);
+ n = c_avl_node_prev (iter->tree, iter->node);
}
if (n == NULL)
*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);
}
#ifndef UTILS_AVLTREE_H
#define UTILS_AVLTREE_H 1
- struct avl_tree_s;
- typedef struct avl_tree_s avl_tree_t;
+ struct c_avl_tree_s;
+ typedef struct c_avl_tree_s c_avl_tree_t;
- struct avl_iterator_s;
- typedef struct avl_iterator_s avl_iterator_t;
+ struct c_avl_iterator_s;
+ typedef struct c_avl_iterator_s c_avl_iterator_t;
/*
* NAME
- * avl_create
+ * c_avl_create
*
* DESCRIPTION
* Allocates a new AVL-tree.
* function from the libc here.
*
* RETURN VALUE
- * A avl_tree_t-pointer upon success or NULL upon failure.
+ * A c_avl_tree_t-pointer upon success or NULL upon failure.
*/
- avl_tree_t *avl_create (int (*compare) (const void *, const void *));
+ c_avl_tree_t *c_avl_create (int (*compare) (const void *, const void *));
/*
* NAME
- * avl_destroy
+ * c_avl_destroy
*
* DESCRIPTION
* Deallocates an AVL-tree. Stored value- and key-pointer are lost, but of
* course not freed.
*/
- void avl_destroy (avl_tree_t *t);
+ void c_avl_destroy (c_avl_tree_t *t);
/*
* NAME
- * avl_insert
+ * c_avl_insert
*
* DESCRIPTION
* Stores the key-value-pair in the AVL-tree pointed to by `t'.
* PARAMETERS
* `t' AVL-tree to store the data in.
* `key' Key used to store the value under. This is used to get back to
- * the value again.
+ * the value again. The pointer is stored in an internal structure
+ * and _not_ copied. So the memory pointed to may _not_ be freed
+ * before this entry is removed. You can use the `rkey' argument
+ * to `avl_remove' to get the original pointer back and free it.
* `value' Value to be stored.
*
* RETURN VALUE
- * Zero upon success and non-zero upon failure and if the key is already
- * stored in the tree.
+ * Zero upon success, non-zero otherwise. It's less than zero if an error
+ * occurred or greater than zero if the key is already stored in the tree.
*/
- int avl_insert (avl_tree_t *t, void *key, void *value);
+ int c_avl_insert (c_avl_tree_t *t, void *key, void *value);
/*
* NAME
- * avl_remove
+ * c_avl_remove
*
* DESCRIPTION
* Removes a key-value-pair from the tree t. The stored key and value may be
* `t' AVL-tree to remove key-value-pair from.
* `key' Key to identify the entry.
* `rkey' Pointer to a pointer in which to store the key. May be NULL.
+ * Since the `key' pointer is not copied when creating an entry,
+ * the pointer may not be available anymore from outside the tree.
+ * You can use this argument to get the actual pointer back and
+ * free the memory pointed to by it.
* `rvalue' Pointer to a pointer in which to store the value. May be NULL.
*
* RETURN VALUE
* Zero upon success or non-zero if the key isn't found in the tree.
*/
- 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);
/*
* NAME
- * avl_get
+ * c_avl_get
*
* DESCRIPTION
* Retrieve the `value' belonging to `key'.
* RETURN VALUE
* Zero upon success or non-zero if the key isn't found in the tree.
*/
- 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);
/*
* NAME
- * avl_pick
+ * c_avl_pick
*
* DESCRIPTION
* Remove a (pseudo-)random element from the tree and return it's `key' and
* Zero upon success or non-zero if the tree is empty or key or value is
* NULL.
*/
- 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_iterator_t *avl_get_iterator (avl_tree_t *t);
- int avl_iterator_next (avl_iterator_t *iter, void **key, void **value);
- int avl_iterator_prev (avl_iterator_t *iter, void **key, void **value);
- void avl_iterator_destroy (avl_iterator_t *iter);
+ c_avl_iterator_t *c_avl_get_iterator (c_avl_tree_t *t);
+ int c_avl_iterator_next (c_avl_iterator_t *iter, void **key, void **value);
+ int c_avl_iterator_prev (c_avl_iterator_t *iter, void **key, void **value);
+ void c_avl_iterator_destroy (c_avl_iterator_t *iter);
#endif /* UTILS_AVLTREE_H */
projects / collectd.git / commitdiff