X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fnetwork.c;h=8615753807445755cab2b4a49c87b73e9e4ea893;hb=eeae8f7fd3b1bbad7fbcfef7bde35a7b20148c87;hp=274d2d8248c66d46a3bfc992a87007ea13d6f68e;hpb=a2bf02b4f5bf4a22395b57bba6715dada3859612;p=collectd.git diff --git a/src/network.c b/src/network.c index 274d2d82..86157538 100644 --- a/src/network.c +++ b/src/network.c @@ -1,22 +1,25 @@ /** * collectd - src/network.c * Copyright (C) 2005-2009 Florian octo Forster + * Copyright (C) 2009 Aman Gupta * * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation; only version 2 of the License is applicable. + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; only version 2.1 of the License is + * applicable. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. + * Lesser General Public License 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 + * You should have received a copy of the GNU Lesser 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: * Florian octo Forster + * Aman Gupta **/ #define _BSD_SOURCE /* For struct ip_mreq */ @@ -27,6 +30,7 @@ #include "configfile.h" #include "utils_fbhash.h" #include "utils_avltree.h" +#include "utils_cache.h" #include "network.h" @@ -51,11 +55,9 @@ #if HAVE_LIBGCRYPT # include +GCRY_THREAD_OPTION_PTHREAD_IMPL; #endif -/* 1500 - 40 - 8 = Ethernet packet - IPv6 header - UDP header */ -/* #define BUFF_SIZE 1452 */ - #ifndef IPV6_ADD_MEMBERSHIP # ifdef IPV6_JOIN_GROUP # define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP @@ -64,9 +66,6 @@ # endif #endif /* !IP_ADD_MEMBERSHIP */ -/* Buffer size to allocate. */ -#define BUFF_SIZE 1024 - /* * Maximum size required for encryption / signing: * @@ -244,7 +243,7 @@ typedef struct part_encryption_aes256_s part_encryption_aes256_t; struct receive_list_entry_s { - char data[BUFF_SIZE]; + char *data; int data_len; int fd; struct receive_list_entry_s *next; @@ -255,7 +254,9 @@ typedef struct receive_list_entry_s receive_list_entry_t; * Private variables */ static int network_config_ttl = 0; +static size_t network_config_packet_size = 1024; static int network_config_forward = 0; +static int network_config_stats = 0; static sockent_t *sending_sockets = NULL; @@ -263,6 +264,7 @@ static receive_list_entry_t *receive_list_head = NULL; static receive_list_entry_t *receive_list_tail = NULL; static pthread_mutex_t receive_list_lock = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t receive_list_cond = PTHREAD_COND_INITIALIZER; +static uint64_t receive_list_length = 0; static sockent_t *listen_sockets = NULL; static struct pollfd *listen_sockets_pollfd = NULL; @@ -277,133 +279,122 @@ static int dispatch_thread_running = 0; static pthread_t dispatch_thread_id; /* Buffer in which to-be-sent network packets are constructed. */ -static char send_buffer[BUFF_SIZE]; +static char *send_buffer; static char *send_buffer_ptr; static int send_buffer_fill; static value_list_t send_buffer_vl = VALUE_LIST_STATIC; static pthread_mutex_t send_buffer_lock = PTHREAD_MUTEX_INITIALIZER; -/* In this cache we store all the values we received, so we can send out only - * those values which were *not* received via the network plugin, too. This is - * used for the `Forward false' option. */ -static c_avl_tree_t *cache_tree = NULL; -static pthread_mutex_t cache_lock = PTHREAD_MUTEX_INITIALIZER; -static time_t cache_flush_last = 0; -static int cache_flush_interval = 1800; +/* XXX: These counters are incremented from one place only. The spot in which + * the values are incremented is either only reachable by one thread (the + * dispatch thread, for example) or locked by some lock (send_buffer_lock for + * example). Only if neither is true, the stats_lock is acquired. The counters + * are always read without holding a lock in the hope that writing 8 bytes to + * memory is an atomic operation. */ +static uint64_t stats_octets_rx = 0; +static uint64_t stats_octets_tx = 0; +static uint64_t stats_packets_rx = 0; +static uint64_t stats_packets_tx = 0; +static uint64_t stats_values_dispatched = 0; +static uint64_t stats_values_not_dispatched = 0; +static uint64_t stats_values_sent = 0; +static uint64_t stats_values_not_sent = 0; +static pthread_mutex_t stats_lock = PTHREAD_MUTEX_INITIALIZER; /* * Private functions */ -static int cache_flush (void) +static _Bool check_receive_okay (const value_list_t *vl) /* {{{ */ { - char **keys = NULL; - int keys_num = 0; + uint64_t time_sent = 0; + int status; - char **tmp; - int i; + status = uc_meta_data_get_unsigned_int (vl, + "network:time_sent", &time_sent); - char *key; - time_t *value; - c_avl_iterator_t *iter; + /* This is a value we already sent. Don't allow it to be received again in + * order to avoid looping. */ + if ((status == 0) && (time_sent >= ((uint64_t) vl->time))) + return (false); - time_t curtime = time (NULL); + return (true); +} /* }}} _Bool check_receive_okay */ - 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; - tmp = (char **) realloc (keys, - (keys_num + 1) * sizeof (char *)); - if (tmp == NULL) - { - sfree (keys); - c_avl_iterator_destroy (iter); - ERROR ("network plugin: cache_flush: realloc" - " failed."); - return (-1); - } - keys = tmp; - keys[keys_num] = key; - keys_num++; - } /* while (c_avl_iterator_next) */ - c_avl_iterator_destroy (iter); +static _Bool check_send_okay (const value_list_t *vl) /* {{{ */ +{ + _Bool received = false; + int status; - for (i = 0; i < keys_num; i++) - { - if (c_avl_remove (cache_tree, keys[i], (void *) &key, - (void *) &value) != 0) - { - WARNING ("network plugin: cache_flush: c_avl_remove" - " (%s) failed.", keys[i]); - continue; - } + if (network_config_forward != 0) + return (true); - sfree (key); - sfree (value); - } + if (vl->meta == NULL) + return (true); - sfree (keys); + status = meta_data_get_boolean (vl->meta, "network:received", &received); + if (status == -ENOENT) + return (true); + else if (status != 0) + { + ERROR ("network plugin: check_send_okay: meta_data_get_boolean failed " + "with status %i.", status); + return (true); + } - DEBUG ("network plugin: cache_flush: Removed %i %s", - keys_num, (keys_num == 1) ? "entry" : "entries"); - cache_flush_last = curtime; - return (0); -} /* int cache_flush */ + /* By default, only *send* value lists that were not *received* by the + * network plugin. */ + return (!received); +} /* }}} _Bool check_send_okay */ -static int cache_check (const value_list_t *vl) +static int network_dispatch_values (value_list_t *vl) /* {{{ */ { - char key[1024]; - time_t *value = NULL; - int retval = -1; + int status; - if (cache_tree == NULL) - return (-1); + if ((vl->time <= 0) + || (strlen (vl->host) <= 0) + || (strlen (vl->plugin) <= 0) + || (strlen (vl->type) <= 0)) + return (-EINVAL); - if (format_name (key, sizeof (key), vl->host, vl->plugin, - vl->plugin_instance, vl->type, vl->type_instance)) - return (-1); + if (!check_receive_okay (vl)) + { +#if COLLECT_DEBUG + char name[6*DATA_MAX_NAME_LEN]; + FORMAT_VL (name, sizeof (name), vl); + name[sizeof (name) - 1] = 0; + DEBUG ("network plugin: network_dispatch_values: " + "NOT dispatching %s.", name); +#endif + stats_values_not_dispatched++; + return (0); + } - pthread_mutex_lock (&cache_lock); + assert (vl->meta == NULL); - if (c_avl_get (cache_tree, key, (void *) &value) == 0) - { - if (*value < vl->time) - { - *value = vl->time; - retval = 0; - } - else - { - DEBUG ("network plugin: cache_check: *value = %i >= vl->time = %i", - (int) *value, (int) vl->time); - retval = 1; - } - } - else - { - char *key_copy = strdup (key); - value = malloc (sizeof (time_t)); - if ((key_copy != NULL) && (value != NULL)) - { - *value = vl->time; - c_avl_insert (cache_tree, key_copy, value); - retval = 0; - } - else - { - sfree (key_copy); - sfree (value); - } - } + vl->meta = meta_data_create (); + if (vl->meta == NULL) + { + ERROR ("network plugin: meta_data_create failed."); + return (-ENOMEM); + } - if ((time (NULL) - cache_flush_last) > cache_flush_interval) - cache_flush (); + status = meta_data_add_boolean (vl->meta, "network:received", true); + if (status != 0) + { + ERROR ("network plugin: meta_data_add_boolean failed."); + meta_data_destroy (vl->meta); + vl->meta = NULL; + return (status); + } - pthread_mutex_unlock (&cache_lock); + plugin_dispatch_values (vl); + stats_values_dispatched++; - return (retval); -} /* int cache_check */ + meta_data_destroy (vl->meta); + vl->meta = NULL; + + return (0); +} /* }}} int network_dispatch_values */ #if HAVE_LIBGCRYPT static gcry_cipher_hd_t network_get_aes256_cypher (sockent_t *se, /* {{{ */ @@ -527,17 +518,34 @@ static int write_part_values (char **ret_buffer, int *ret_buffer_len, for (i = 0; i < num_values; i++) { - if (ds->ds[i].type == DS_TYPE_COUNTER) - { - pkg_values_types[i] = DS_TYPE_COUNTER; - pkg_values[i].counter = htonll (vl->values[i].counter); - } - else + pkg_values_types[i] = (uint8_t) ds->ds[i].type; + switch (ds->ds[i].type) { - pkg_values_types[i] = DS_TYPE_GAUGE; - pkg_values[i].gauge = htond (vl->values[i].gauge); - } - } + case DS_TYPE_COUNTER: + pkg_values[i].counter = htonll (vl->values[i].counter); + break; + + case DS_TYPE_GAUGE: + pkg_values[i].gauge = htond (vl->values[i].gauge); + break; + + case DS_TYPE_DERIVE: + pkg_values[i].derive = htonll (vl->values[i].derive); + break; + + case DS_TYPE_ABSOLUTE: + pkg_values[i].absolute = htonll (vl->values[i].absolute); + break; + + default: + free (pkg_values_types); + free (pkg_values); + ERROR ("network plugin: write_part_values: " + "Unknown data source type: %i", + ds->ds[i].type); + return (-1); + } /* switch (ds->ds[i].type) */ + } /* for (num_values) */ /* * Use `memcpy' to write everything to the buffer, because the pointer @@ -713,10 +721,32 @@ static int parse_part_values (void **ret_buffer, size_t *ret_buffer_len, for (i = 0; i < pkg_numval; i++) { - if (pkg_types[i] == DS_TYPE_COUNTER) - pkg_values[i].counter = ntohll (pkg_values[i].counter); - else if (pkg_types[i] == DS_TYPE_GAUGE) - pkg_values[i].gauge = ntohd (pkg_values[i].gauge); + switch (pkg_types[i]) + { + case DS_TYPE_COUNTER: + pkg_values[i].counter = (counter_t) ntohll (pkg_values[i].counter); + break; + + case DS_TYPE_GAUGE: + pkg_values[i].gauge = (gauge_t) ntohd (pkg_values[i].gauge); + break; + + case DS_TYPE_DERIVE: + pkg_values[i].derive = (derive_t) ntohll (pkg_values[i].derive); + break; + + case DS_TYPE_ABSOLUTE: + pkg_values[i].absolute = (absolute_t) ntohll (pkg_values[i].absolute); + break; + + default: + sfree (pkg_types); + sfree (pkg_values); + NOTICE ("network plugin: parse_part_values: " + "Don't know how to handle data source type %"PRIu8, + pkg_types[i]); + return (-1); + } /* switch (pkg_types[i]) */ } *ret_buffer = buffer; @@ -1302,23 +1332,10 @@ static int parse_packet (sockent_t *se, /* {{{ */ { status = parse_part_values (&buffer, &buffer_size, &vl.values, &vl.values_len); - if (status != 0) break; - if ((vl.time > 0) - && (strlen (vl.host) > 0) - && (strlen (vl.plugin) > 0) - && (strlen (vl.type) > 0) - && (cache_check (&vl) == 0)) - { - plugin_dispatch_values (&vl); - } - else - { - DEBUG ("network plugin: parse_packet:" - " NOT dispatching values"); - } + network_dispatch_values (&vl); sfree (vl.values); } @@ -1433,6 +1450,10 @@ static int parse_packet (sockent_t *se, /* {{{ */ } } /* while (buffer_size > sizeof (part_header_t)) */ + if (status == 0 && buffer_size > 0) + WARNING ("network plugin: parse_packet: Received truncated " + "packet, try increasing `MaxPacketSize'"); + return (status); } /* }}} int parse_packet */ @@ -1961,13 +1982,14 @@ static void *dispatch_thread (void __attribute__((unused)) *arg) /* {{{ */ /* Lock and wait for more data to come in */ pthread_mutex_lock (&receive_list_lock); while ((listen_loop == 0) - && (receive_list_head == NULL)) + && (receive_list_head == NULL)) pthread_cond_wait (&receive_list_cond, &receive_list_lock); /* Remove the head entry and unlock */ ent = receive_list_head; if (ent != NULL) receive_list_head = ent->next; + receive_list_length--; pthread_mutex_unlock (&receive_list_lock); /* Check whether we are supposed to exit. We do NOT check `listen_loop' @@ -1993,14 +2015,16 @@ static void *dispatch_thread (void __attribute__((unused)) *arg) /* {{{ */ if (se == NULL) { - ERROR ("network plugin: Got packet from FD %i, but can't " - "find an appropriate socket entry.", - ent->fd); - sfree (ent); - continue; + ERROR ("network plugin: Got packet from FD %i, but can't " + "find an appropriate socket entry.", + ent->fd); + sfree (ent->data); + sfree (ent); + continue; } parse_packet (se, ent->data, ent->data_len, /* flags = */ 0); + sfree (ent->data); sfree (ent); } /* while (42) */ @@ -2009,7 +2033,7 @@ static void *dispatch_thread (void __attribute__((unused)) *arg) /* {{{ */ static int network_receive (void) /* {{{ */ { - char buffer[BUFF_SIZE]; + char buffer[network_config_packet_size]; int buffer_len; int i; @@ -2017,11 +2041,13 @@ static int network_receive (void) /* {{{ */ receive_list_entry_t *private_list_head; receive_list_entry_t *private_list_tail; + uint64_t private_list_length; assert (listen_sockets_num > 0); private_list_head = NULL; private_list_tail = NULL; + private_list_length = 0; while (listen_loop == 0) { @@ -2058,6 +2084,9 @@ static int network_receive (void) /* {{{ */ return (-1); } + stats_octets_rx += ((uint64_t) buffer_len); + stats_packets_rx++; + /* TODO: Possible performance enhancement: Do not free * these entries in the dispatch thread but put them in * another list, so we don't have to allocate more and @@ -2069,14 +2098,16 @@ static int network_receive (void) /* {{{ */ return (-1); } memset (ent, 0, sizeof (receive_list_entry_t)); + ent->data = malloc (network_config_packet_size); + if (ent->data == NULL) + { + sfree (ent); + ERROR ("network plugin: malloc failed."); + return (-1); + } ent->fd = listen_sockets_pollfd[i].fd; ent->next = NULL; - /* Hopefully this be optimized out by the compiler. It - * might help prevent stupid bugs in the future though. - */ - assert (sizeof (ent->data) == sizeof (buffer)); - memcpy (ent->data, buffer, buffer_len); ent->data_len = buffer_len; @@ -2085,22 +2116,28 @@ static int network_receive (void) /* {{{ */ else private_list_tail->next = ent; private_list_tail = ent; + private_list_length++; /* Do not block here. Blocking here has led to * insufficient performance in the past. */ if (pthread_mutex_trylock (&receive_list_lock) == 0) { + assert (((receive_list_head == NULL) && (receive_list_length == 0)) + || ((receive_list_head != NULL) && (receive_list_length != 0))); + if (receive_list_head == NULL) receive_list_head = private_list_head; else receive_list_tail->next = private_list_head; receive_list_tail = private_list_tail; - - private_list_head = NULL; - private_list_tail = NULL; + receive_list_length += private_list_length; pthread_cond_signal (&receive_list_cond); pthread_mutex_unlock (&receive_list_lock); + + private_list_head = NULL; + private_list_tail = NULL; + private_list_length = 0; } } /* for (listen_sockets_pollfd) */ } /* while (listen_loop == 0) */ @@ -2115,9 +2152,11 @@ static int network_receive (void) /* {{{ */ else receive_list_tail->next = private_list_head; receive_list_tail = private_list_tail; + receive_list_length += private_list_length; private_list_head = NULL; private_list_tail = NULL; + private_list_length = 0; pthread_cond_signal (&receive_list_cond); pthread_mutex_unlock (&receive_list_lock); @@ -2133,7 +2172,7 @@ static void *receive_thread (void __attribute__((unused)) *arg) static void network_init_buffer (void) { - memset (send_buffer, 0, sizeof (send_buffer)); + memset (send_buffer, 0, network_config_packet_size); send_buffer_ptr = send_buffer; send_buffer_fill = 0; @@ -2261,9 +2300,6 @@ static void networt_send_buffer_encrypted (sockent_t *se, /* {{{ */ gcry_error_t err; gcry_cipher_hd_t cypher; - DEBUG ("network plugin: networt_send_buffer_encrypted: " - "buffer_size = %zu;", buffer_size); - /* Initialize the header fields */ memset (&pea, 0, sizeof (pea)); pea.head.type = htons (TYPE_ENCR_AES256); @@ -2282,6 +2318,8 @@ static void networt_send_buffer_encrypted (sockent_t *se, /* {{{ */ - sizeof (pea.hash); assert (buffer_size <= sizeof (buffer)); + DEBUG ("network plugin: networt_send_buffer_encrypted: " + "buffer_size = %zu;", buffer_size); pea.head.length = htons ((uint16_t) (PART_ENCRYPTION_AES256_SIZE + username_len + in_buffer_size)); @@ -2427,6 +2465,10 @@ static void flush_buffer (void) send_buffer_fill); network_send_buffer (send_buffer, (size_t) send_buffer_fill); + + stats_octets_tx += ((uint64_t) send_buffer_fill); + stats_packets_tx++; + network_init_buffer (); } @@ -2435,18 +2477,30 @@ static int network_write (const data_set_t *ds, const value_list_t *vl, { int status; - /* If the value is already in the cache, we have received it via the - * network. We write it again if forwarding is activated. It's then in - * the cache and should we receive it again we will ignore it. */ - status = cache_check (vl); - if ((network_config_forward == 0) - && (status != 0)) - return (0); + if (!check_send_okay (vl)) + { +#if COLLECT_DEBUG + char name[6*DATA_MAX_NAME_LEN]; + FORMAT_VL (name, sizeof (name), vl); + name[sizeof (name) - 1] = 0; + DEBUG ("network plugin: network_write: " + "NOT sending %s.", name); +#endif + /* Counter is not protected by another lock and may be reached by + * multiple threads */ + pthread_mutex_lock (&stats_lock); + stats_values_not_sent++; + pthread_mutex_unlock (&stats_lock); + return (0); + } + + uc_meta_data_add_unsigned_int (vl, + "network:time_sent", (uint64_t) vl->time); pthread_mutex_lock (&send_buffer_lock); status = add_to_buffer (send_buffer_ptr, - sizeof (send_buffer) - (send_buffer_fill + BUFF_SIG_SIZE), + network_config_packet_size - (send_buffer_fill + BUFF_SIG_SIZE), &send_buffer_vl, ds, vl); if (status >= 0) @@ -2454,13 +2508,15 @@ static int network_write (const data_set_t *ds, const value_list_t *vl, /* status == bytes added to the buffer */ send_buffer_fill += status; send_buffer_ptr += status; + + stats_values_sent++; } else { flush_buffer (); status = add_to_buffer (send_buffer_ptr, - sizeof (send_buffer) - (send_buffer_fill + BUFF_SIG_SIZE), + network_config_packet_size - (send_buffer_fill + BUFF_SIG_SIZE), &send_buffer_vl, ds, vl); @@ -2468,6 +2524,8 @@ static int network_write (const data_set_t *ds, const value_list_t *vl, { send_buffer_fill += status; send_buffer_ptr += status; + + stats_values_sent++; } } @@ -2476,7 +2534,7 @@ static int network_write (const data_set_t *ds, const value_list_t *vl, ERROR ("network plugin: Unable to append to the " "buffer for some weird reason"); } - else if ((sizeof (send_buffer) - send_buffer_fill) < 15) + else if ((network_config_packet_size - send_buffer_fill) < 15) { flush_buffer (); } @@ -2509,13 +2567,9 @@ static int network_config_set_boolean (const oconfig_item_t *ci, /* {{{ */ { char *str = ci->values[0].value.string; - if ((strcasecmp ("true", str) == 0) - || (strcasecmp ("yes", str) == 0) - || (strcasecmp ("on", str) == 0)) + if (IS_TRUE (str)) *retval = 1; - else if ((strcasecmp ("false", str) == 0) - || (strcasecmp ("no", str) == 0) - || (strcasecmp ("off", str) == 0)) + else if (IS_FALSE (str)) *retval = 0; else { @@ -2547,6 +2601,24 @@ static int network_config_set_ttl (const oconfig_item_t *ci) /* {{{ */ return (0); } /* }}} int network_config_set_ttl */ +static int network_config_set_buffer_size (const oconfig_item_t *ci) /* {{{ */ +{ + int tmp; + if ((ci->values_num != 1) + || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) + { + WARNING ("network plugin: The `MaxPacketSize' config option needs exactly " + "one numeric argument."); + return (-1); + } + + tmp = (int) ci->values[0].value.number; + if ((tmp >= 1024) && (tmp <= 65535)) + network_config_packet_size = tmp; + + return (0); +} /* }}} int network_config_set_buffer_size */ + #if HAVE_LIBGCRYPT static int network_config_set_string (const oconfig_item_t *ci, /* {{{ */ char **ret_string) @@ -2756,24 +2828,6 @@ static int network_config_add_server (const oconfig_item_t *ci) /* {{{ */ return (0); } /* }}} int network_config_add_server */ -static int network_config_set_cache_flush (const oconfig_item_t *ci) /* {{{ */ -{ - int tmp; - if ((ci->values_num != 1) - || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) - { - WARNING ("network plugin: The `CacheFlush' config option needs exactly " - "one numeric argument."); - return (-1); - } - - tmp = (int) ci->values[0].value.number; - if (tmp > 0) - network_config_ttl = tmp; - - return (0); -} /* }}} int network_config_set_cache_flush */ - static int network_config (oconfig_item_t *ci) /* {{{ */ { int i; @@ -2788,10 +2842,14 @@ static int network_config (oconfig_item_t *ci) /* {{{ */ network_config_add_server (child); else if (strcasecmp ("TimeToLive", child->key) == 0) network_config_set_ttl (child); + else if (strcasecmp ("MaxPacketSize", child->key) == 0) + network_config_set_buffer_size (child); else if (strcasecmp ("Forward", child->key) == 0) network_config_set_boolean (child, &network_config_forward); + else if (strcasecmp ("ReportStats", child->key) == 0) + network_config_set_boolean (child, &network_config_stats); else if (strcasecmp ("CacheFlush", child->key) == 0) - network_config_set_cache_flush (child); + /* no op for backwards compatibility only */; else { WARNING ("network plugin: Option `%s' is not allowed here.", @@ -2805,7 +2863,7 @@ static int network_config (oconfig_item_t *ci) /* {{{ */ static int network_notification (const notification_t *n, user_data_t __attribute__((unused)) *user_data) { - char buffer[BUFF_SIZE]; + char buffer[network_config_packet_size]; char *buffer_ptr = buffer; int buffer_free = sizeof (buffer); int status; @@ -2904,19 +2962,7 @@ static int network_shutdown (void) if (send_buffer_fill > 0) flush_buffer (); - if (cache_tree != NULL) - { - void *key; - void *value; - - while (c_avl_pick (cache_tree, &key, &value) == 0) - { - sfree (key); - sfree (value); - } - c_avl_destroy (cache_tree); - cache_tree = NULL; - } + sfree (send_buffer); /* TODO: Close `sending_sockets' */ @@ -2925,26 +2971,115 @@ static int network_shutdown (void) plugin_unregister_write ("network"); plugin_unregister_shutdown ("network"); - /* Let the init function do it's move again ;) */ - cache_flush_last = 0; - return (0); } /* int network_shutdown */ +static int network_stats_read (void) /* {{{ */ +{ + uint64_t copy_octets_rx; + uint64_t copy_octets_tx; + uint64_t copy_packets_rx; + uint64_t copy_packets_tx; + uint64_t copy_values_dispatched; + uint64_t copy_values_not_dispatched; + uint64_t copy_values_sent; + uint64_t copy_values_not_sent; + uint64_t copy_receive_list_length; + value_list_t vl = VALUE_LIST_INIT; + value_t values[2]; + + copy_octets_rx = stats_octets_rx; + copy_octets_tx = stats_octets_tx; + copy_packets_rx = stats_packets_rx; + copy_packets_tx = stats_packets_tx; + copy_values_dispatched = stats_values_dispatched; + copy_values_not_dispatched = stats_values_not_dispatched; + copy_values_sent = stats_values_sent; + copy_values_not_sent = stats_values_not_sent; + copy_receive_list_length = receive_list_length; + + /* Initialize `vl' */ + vl.values = values; + vl.values_len = 2; + vl.time = 0; + vl.interval = interval_g; + sstrncpy (vl.host, hostname_g, sizeof (vl.host)); + sstrncpy (vl.plugin, "network", sizeof (vl.plugin)); + + /* Octets received / sent */ + vl.values[0].counter = (counter_t) copy_octets_rx; + vl.values[1].counter = (counter_t) copy_octets_tx; + sstrncpy (vl.type, "if_octets", sizeof (vl.type)); + plugin_dispatch_values (&vl); + + /* Packets received / send */ + vl.values[0].counter = (counter_t) copy_packets_rx; + vl.values[1].counter = (counter_t) copy_packets_tx; + sstrncpy (vl.type, "if_packets", sizeof (vl.type)); + plugin_dispatch_values (&vl); + + /* Values (not) dispatched and (not) send */ + sstrncpy (vl.type, "total_values", sizeof (vl.type)); + vl.values_len = 1; + + vl.values[0].derive = (derive_t) copy_values_dispatched; + sstrncpy (vl.type_instance, "dispatch-accepted", + sizeof (vl.type_instance)); + plugin_dispatch_values (&vl); + + vl.values[0].derive = (derive_t) copy_values_not_dispatched; + sstrncpy (vl.type_instance, "dispatch-rejected", + sizeof (vl.type_instance)); + plugin_dispatch_values (&vl); + + vl.values[0].derive = (derive_t) copy_values_sent; + sstrncpy (vl.type_instance, "send-accepted", + sizeof (vl.type_instance)); + plugin_dispatch_values (&vl); + + vl.values[0].derive = (derive_t) copy_values_not_sent; + sstrncpy (vl.type_instance, "send-rejected", + sizeof (vl.type_instance)); + plugin_dispatch_values (&vl); + + /* Receive queue length */ + vl.values[0].gauge = (gauge_t) copy_receive_list_length; + sstrncpy (vl.type, "queue_length", sizeof (vl.type)); + vl.type_instance[0] = 0; + plugin_dispatch_values (&vl); + + return (0); +} /* }}} int network_stats_read */ + static int network_init (void) { + static _Bool have_init = false; + /* Check if we were already initialized. If so, just return - there's * nothing more to do (for now, that is). */ - if (cache_flush_last != 0) + if (have_init) return (0); + have_init = true; + +#if HAVE_LIBGCRYPT + gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread); + gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0); + gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0); +#endif + + if (network_config_stats != 0) + plugin_register_read ("network", network_stats_read); plugin_register_shutdown ("network", network_shutdown); + send_buffer = malloc (network_config_packet_size); + if (send_buffer == NULL) + { + ERROR ("network plugin: malloc failed."); + return (-1); + } network_init_buffer (); - cache_tree = c_avl_create ((int (*) (const void *, const void *)) strcmp); - cache_flush_last = time (NULL); - /* setup socket(s) and so on */ if (sending_sockets != NULL) { @@ -3016,11 +3151,8 @@ static int network_flush (int timeout, { pthread_mutex_lock (&send_buffer_lock); - if (((time (NULL) - cache_flush_last) >= timeout) - && (send_buffer_fill > 0)) - { - flush_buffer (); - } + if (send_buffer_fill > 0) + flush_buffer (); pthread_mutex_unlock (&send_buffer_lock);