X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fnetwork.c;h=ae5ed09652729b2fd7b679d8f90936c07eec59f3;hb=813fadc54fbf0c9b948163851e9791a1ace716ae;hp=67a7c3c57b5db7e9059b5769520c34b9dcb8f1e0;hpb=fe9ba13c8866ada19f7a347f3757d4c740613cdb;p=collectd.git

diff --git a/src/network.c b/src/network.c
index 67a7c3c5..ae5ed096 100644
--- a/src/network.c
+++ b/src/network.c
@@ -1,30 +1,37 @@
 /**
  * collectd - src/network.c
- * Copyright (C) 2005-2009  Florian octo Forster
+ * Copyright (C) 2005-2013  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 <octo at verplant.org>
+ *   Florian octo Forster <octo at collectd.org>
+ *   Aman Gupta <aman at tmm1.net>
  **/
 
+#define _BSD_SOURCE /* For struct ip_mreq */
+
 #include "collectd.h"
 #include "plugin.h"
 #include "common.h"
 #include "configfile.h"
 #include "utils_fbhash.h"
 #include "utils_avltree.h"
+#include "utils_cache.h"
+#include "utils_complain.h"
 
 #include "network.h"
 
@@ -46,14 +53,34 @@
 #if HAVE_POLL_H
 # include <poll.h>
 #endif
+#if HAVE_NET_IF_H
+# include <net/if.h>
+#endif
 
 #if HAVE_LIBGCRYPT
+# include <pthread.h>
+# if defined __APPLE__
+/* default xcode compiler throws warnings even when deprecated functionality
+ * is not used. -Werror breaks the build because of erroneous warnings.
+ * http://stackoverflow.com/questions/10556299/compiler-warnings-with-libgcrypt-v1-5-0/12830209#12830209
+ */
+#  pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+# endif
+/* FreeBSD's copy of libgcrypt extends the existing GCRYPT_NO_DEPRECATED
+ * to properly hide all deprecated functionality.
+ * http://svnweb.freebsd.org/ports/head/security/libgcrypt/files/patch-src__gcrypt.h.in
+ */
+# define GCRYPT_NO_DEPRECATED
 # include <gcrypt.h>
+# if defined __APPLE__
+/* Re enable deprecation warnings */
+#  pragma GCC diagnostic warning "-Wdeprecated-declarations"
+# endif
+# if GCRYPT_VERSION_NUMBER < 0x010600
+GCRY_THREAD_OPTION_PTHREAD_IMPL;
+# endif
 #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
@@ -62,9 +89,6 @@
 # endif
 #endif /* !IP_ADD_MEMBERSHIP */
 
-/* Buffer size to allocate. */
-#define BUFF_SIZE 1024
-
 /*
  * Maximum size required for encryption / signing:
  *
@@ -117,6 +141,7 @@ typedef struct sockent
 
 	char *node;
 	char *service;
+	int interface;
 
 	union
 	{
@@ -242,7 +267,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;
@@ -253,7 +278,10 @@ typedef struct receive_list_entry_s receive_list_entry_t;
  * Private variables
  */
 static int network_config_ttl = 0;
+/* Ethernet - (IPv6 + UDP) = 1500 - (40 + 8) = 1452 */
+static size_t network_config_packet_size = 1452;
 static int network_config_forward = 0;
+static int network_config_stats = 0;
 
 static sockent_t *sending_sockets = NULL;
 
@@ -261,6 +289,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;
@@ -275,135 +304,220 @@ 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 derive_t stats_octets_rx  = 0;
+static derive_t stats_octets_tx  = 0;
+static derive_t stats_packets_rx = 0;
+static derive_t stats_packets_tx = 0;
+static derive_t stats_values_dispatched = 0;
+static derive_t stats_values_not_dispatched = 0;
+static derive_t stats_values_sent = 0;
+static derive_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 (0);
 
-	time_t curtime = time (NULL);
+  return (1);
+} /* }}} _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 = 0;
+  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 (1);
 
-		sfree (key);
-		sfree (value);
-	}
+  if (vl->meta == NULL)
+    return (1);
 
-	sfree (keys);
+  status = meta_data_get_boolean (vl->meta, "network:received", &received);
+  if (status == -ENOENT)
+    return (1);
+  else if (status != 0)
+  {
+    ERROR ("network plugin: check_send_okay: meta_data_get_boolean failed "
+	"with status %i.", status);
+    return (1);
+  }
 
-	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 _Bool check_notify_received (const notification_t *n) /* {{{ */
 {
-	char key[1024];
-	time_t *value = NULL;
-	int retval = -1;
+  notification_meta_t *ptr;
 
-	if (cache_tree == NULL)
-		return (-1);
+  for (ptr = n->meta; ptr != NULL; ptr = ptr->next)
+    if ((strcmp ("network:received", ptr->name) == 0)
+        && (ptr->type == NM_TYPE_BOOLEAN))
+      return ((_Bool) ptr->nm_value.nm_boolean);
 
-	if (format_name (key, sizeof (key), vl->host, vl->plugin,
-				vl->plugin_instance, vl->type, vl->type_instance))
-		return (-1);
+  return (0);
+} /* }}} _Bool check_notify_received */
+
+static _Bool check_send_notify_okay (const notification_t *n) /* {{{ */
+{
+  static c_complain_t complain_forwarding = C_COMPLAIN_INIT_STATIC;
+  _Bool received = 0;
 
-	pthread_mutex_lock (&cache_lock);
+  if (n->meta == NULL)
+    return (1);
 
-	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);
-		}
-	}
+  received = check_notify_received (n);
+
+  if (network_config_forward && received)
+  {
+    c_complain_once (LOG_ERR, &complain_forwarding,
+        "network plugin: A notification has been received via the network "
+        "and forwarding is enabled. Forwarding of notifications is currently "
+        "not supported, because there is not loop-deteciton available. "
+        "Please contact the collectd mailing list if you need this "
+        "feature.");
+  }
+
+  /* By default, only *send* value lists that were not *received* by the
+   * network plugin. */
+  return (!received);
+} /* }}} _Bool check_send_notify_okay */
+
+static int network_dispatch_values (value_list_t *vl, /* {{{ */
+    const char *username)
+{
+  int status;
+
+  if ((vl->time <= 0)
+      || (strlen (vl->host) <= 0)
+      || (strlen (vl->plugin) <= 0)
+      || (strlen (vl->type) <= 0))
+    return (-EINVAL);
+
+  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);
+  }
+
+  assert (vl->meta == NULL);
+
+  vl->meta = meta_data_create ();
+  if (vl->meta == NULL)
+  {
+    ERROR ("network plugin: meta_data_create failed.");
+    return (-ENOMEM);
+  }
+
+  status = meta_data_add_boolean (vl->meta, "network:received", 1);
+  if (status != 0)
+  {
+    ERROR ("network plugin: meta_data_add_boolean failed.");
+    meta_data_destroy (vl->meta);
+    vl->meta = NULL;
+    return (status);
+  }
+
+  if (username != NULL)
+  {
+    status = meta_data_add_string (vl->meta, "network:username", username);
+    if (status != 0)
+    {
+      ERROR ("network plugin: meta_data_add_string failed.");
+      meta_data_destroy (vl->meta);
+      vl->meta = NULL;
+      return (status);
+    }
+  }
+
+  plugin_dispatch_values (vl);
+  stats_values_dispatched++;
+
+  meta_data_destroy (vl->meta);
+  vl->meta = NULL;
+
+  return (0);
+} /* }}} int network_dispatch_values */
+
+static int network_dispatch_notification (notification_t *n) /* {{{ */
+{
+  int status;
+
+  assert (n->meta == NULL);
+
+  status = plugin_notification_meta_add_boolean (n, "network:received", 1);
+  if (status != 0)
+  {
+    ERROR ("network plugin: plugin_notification_meta_add_boolean failed.");
+    plugin_notification_meta_free (n->meta);
+    n->meta = NULL;
+    return (status);
+  }
 
-	if ((time (NULL) - cache_flush_last) > cache_flush_interval)
-		cache_flush ();
+  status = plugin_dispatch_notification (n);
 
-	pthread_mutex_unlock (&cache_lock);
+  plugin_notification_meta_free (n->meta);
+  n->meta = NULL;
 
-	return (retval);
-} /* int cache_check */
+  return (status);
+} /* }}} int network_dispatch_notification */
 
 #if HAVE_LIBGCRYPT
+static void network_init_gcrypt (void) /* {{{ */
+{
+  /* http://lists.gnupg.org/pipermail/gcrypt-devel/2003-August/000458.html
+   * Because you can't know in a library whether another library has
+   * already initialized the library */
+  if (gcry_control (GCRYCTL_ANY_INITIALIZATION_P))
+    return;
+
+ /* http://www.gnupg.org/documentation/manuals/gcrypt/Multi_002dThreading.html
+  * To ensure thread-safety, it's important to set GCRYCTL_SET_THREAD_CBS
+  * *before* initalizing Libgcrypt with gcry_check_version(), which itself must
+  * be called before any other gcry_* function. GCRYCTL_ANY_INITIALIZATION_P
+  * above doesn't count, as it doesn't implicitly initalize Libgcrypt.
+  *
+  * tl;dr: keep all these gry_* statements in this exact order please. */
+# if GCRYPT_VERSION_NUMBER < 0x010600
+  gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
+# endif
+  gcry_check_version (NULL);
+  gcry_control (GCRYCTL_INIT_SECMEM, 32768);
+  gcry_control (GCRYCTL_INITIALIZATION_FINISHED);
+} /* }}} void network_init_gcrypt */
+
 static gcry_cipher_hd_t network_get_aes256_cypher (sockent_t *se, /* {{{ */
     const void *iv, size_t iv_size, const char *username)
 {
@@ -525,17 +639,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
@@ -572,7 +703,7 @@ static int write_part_number (char **ret_buffer, int *ret_buffer_len,
 
 	part_header_t pkg_head;
 	uint64_t pkg_value;
-	
+
 	int offset;
 
 	packet_len = sizeof (pkg_head) + sizeof (pkg_value);
@@ -676,7 +807,7 @@ static int parse_part_values (void **ret_buffer, size_t *ret_buffer_len,
 
 	exp_size = 3 * sizeof (uint16_t)
 		+ pkg_numval * (sizeof (uint8_t) + sizeof (value_t));
-	if ((buffer_len < 0) || (buffer_len < exp_size))
+	if (buffer_len < exp_size)
 	{
 		WARNING ("network plugin: parse_part_values: "
 				"Packet too short: "
@@ -711,10 +842,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:
+		    NOTICE ("network plugin: parse_part_values: "
+			"Don't know how to handle data source type %"PRIu8,
+			pkg_types[i]);
+		    sfree (pkg_types);
+		    sfree (pkg_values);
+		    return (-1);
+		} /* switch (pkg_types[i]) */
 	}
 
 	*ret_buffer     = buffer;
@@ -738,9 +891,8 @@ static int parse_part_number (void **ret_buffer, size_t *ret_buffer_len,
 	size_t exp_size = 2 * sizeof (uint16_t) + sizeof (uint64_t);
 
 	uint16_t pkg_length;
-	uint16_t pkg_type;
 
-	if ((buffer_len < 0) || ((size_t) buffer_len < exp_size))
+	if (buffer_len < exp_size)
 	{
 		WARNING ("network plugin: parse_part_number: "
 				"Packet too short: "
@@ -752,7 +904,7 @@ static int parse_part_number (void **ret_buffer, size_t *ret_buffer_len,
 
 	memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
 	buffer += sizeof (tmp16);
-	pkg_type = ntohs (tmp16);
+	/* pkg_type = ntohs (tmp16); */
 
 	memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
 	buffer += sizeof (tmp16);
@@ -778,9 +930,8 @@ static int parse_part_string (void **ret_buffer, size_t *ret_buffer_len,
 	size_t header_size = 2 * sizeof (uint16_t);
 
 	uint16_t pkg_length;
-	uint16_t pkg_type;
 
-	if ((buffer_len < 0) || (buffer_len < header_size))
+	if (buffer_len < header_size)
 	{
 		WARNING ("network plugin: parse_part_string: "
 				"Packet too short: "
@@ -792,7 +943,7 @@ static int parse_part_string (void **ret_buffer, size_t *ret_buffer_len,
 
 	memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
 	buffer += sizeof (tmp16);
-	pkg_type = ntohs (tmp16);
+	/* pkg_type = ntohs (tmp16); */
 
 	memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
 	buffer += sizeof (tmp16);
@@ -856,7 +1007,8 @@ static int parse_part_string (void **ret_buffer, size_t *ret_buffer_len,
 #define PP_SIGNED    0x01
 #define PP_ENCRYPTED 0x02
 static int parse_packet (sockent_t *se,
-		void *buffer, size_t buffer_size, int flags);
+		void *buffer, size_t buffer_size, int flags,
+		const char *username);
 
 #define BUFFER_READ(p,s) do { \
   memcpy ((p), buffer + buffer_offset, (s)); \
@@ -867,6 +1019,8 @@ static int parse_packet (sockent_t *se,
 static int parse_part_sign_sha256 (sockent_t *se, /* {{{ */
     void **ret_buffer, size_t *ret_buffer_len, int flags)
 {
+  static c_complain_t complain_no_users = C_COMPLAIN_INIT_STATIC;
+
   char *buffer;
   size_t buffer_len;
   size_t buffer_offset;
@@ -888,8 +1042,9 @@ static int parse_part_sign_sha256 (sockent_t *se, /* {{{ */
 
   if (se->data.server.userdb == NULL)
   {
-    NOTICE ("network plugin: Received signed network packet but can't verify "
-        "it because no user DB has been configured. Will accept it.");
+    c_complain (LOG_NOTICE, &complain_no_users,
+        "network plugin: Received signed network packet but can't verify it "
+        "because no user DB has been configured. Will accept it.");
     return (0);
   }
 
@@ -951,6 +1106,8 @@ static int parse_part_sign_sha256 (sockent_t *se, /* {{{ */
   {
     ERROR ("network plugin: gcry_md_setkey failed: %s", gcry_strerror (err));
     gcry_md_close (hd);
+    sfree (secret);
+    sfree (pss.username);
     return (-1);
   }
 
@@ -972,9 +1129,6 @@ static int parse_part_sign_sha256 (sockent_t *se, /* {{{ */
   gcry_md_close (hd);
   hd = NULL;
 
-  sfree (secret);
-  sfree (pss.username);
-
   if (memcmp (pss.hash, hash, sizeof (pss.hash)) != 0)
   {
     WARNING ("network plugin: Verifying HMAC-SHA-256 signature failed: "
@@ -983,9 +1137,12 @@ static int parse_part_sign_sha256 (sockent_t *se, /* {{{ */
   else
   {
     parse_packet (se, buffer + buffer_offset, buffer_len - buffer_offset,
-        flags | PP_SIGNED);
+        flags | PP_SIGNED, pss.username);
   }
 
+  sfree (secret);
+  sfree (pss.username);
+
   *ret_buffer = buffer + buffer_len;
   *ret_buffer_len = 0;
 
@@ -1029,7 +1186,8 @@ static int parse_part_sign_sha256 (sockent_t *se, /* {{{ */
     warning_has_been_printed = 1;
   }
 
-  parse_packet (se, buffer + part_len, buffer_size - part_len, flags);
+  parse_packet (se, buffer + part_len, buffer_size - part_len, flags,
+      /* username = */ NULL);
 
   *ret_buffer = buffer + buffer_size;
   *ret_buffer_size = 0;
@@ -1108,7 +1266,10 @@ static int parse_part_encr_aes256 (sockent_t *se, /* {{{ */
   cypher = network_get_aes256_cypher (se, pea.iv, sizeof (pea.iv),
       pea.username);
   if (cypher == NULL)
+  {
+    sfree (pea.username);
     return (-1);
+  }
 
   payload_len = part_size - (PART_ENCRYPTION_AES256_SIZE + username_len);
   assert (payload_len > 0);
@@ -1120,6 +1281,7 @@ static int parse_part_encr_aes256 (sockent_t *se, /* {{{ */
       /* in = */ NULL, /* in len = */ 0);
   if (err != 0)
   {
+    sfree (pea.username);
     ERROR ("network plugin: gcry_cipher_decrypt returned: %s",
         gcry_strerror (err));
     return (-1);
@@ -1138,17 +1300,22 @@ static int parse_part_encr_aes256 (sockent_t *se, /* {{{ */
       buffer + buffer_offset, payload_len);
   if (memcmp (hash, pea.hash, sizeof (hash)) != 0)
   {
+    sfree (pea.username);
     ERROR ("network plugin: Decryption failed: Checksum mismatch.");
     return (-1);
   }
 
   parse_packet (se, buffer + buffer_offset, payload_len,
-      flags | PP_ENCRYPTED);
+      flags | PP_ENCRYPTED, pea.username);
+
+  /* XXX: Free pea.username?!? */
 
   /* Update return values */
   *ret_buffer =     buffer     + part_size;
   *ret_buffer_len = buffer_len - part_size;
 
+  sfree (pea.username);
+
   return (0);
 } /* }}} int parse_part_encr_aes256 */
 /* #endif HAVE_LIBGCRYPT */
@@ -1203,7 +1370,8 @@ static int parse_part_encr_aes256 (sockent_t *se, /* {{{ */
 #undef BUFFER_READ
 
 static int parse_packet (sockent_t *se, /* {{{ */
-		void *buffer, size_t buffer_size, int flags)
+		void *buffer, size_t buffer_size, int flags,
+		const char *username)
 {
 	int status;
 
@@ -1300,23 +1468,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, username);
 
 			sfree (vl.values);
 		}
@@ -1327,8 +1482,19 @@ static int parse_packet (sockent_t *se, /* {{{ */
 					&tmp);
 			if (status == 0)
 			{
-				vl.time = (time_t) tmp;
-				n.time = (time_t) tmp;
+				vl.time = TIME_T_TO_CDTIME_T (tmp);
+				n.time  = TIME_T_TO_CDTIME_T (tmp);
+			}
+		}
+		else if (pkg_type == TYPE_TIME_HR)
+		{
+			uint64_t tmp = 0;
+			status = parse_part_number (&buffer, &buffer_size,
+					&tmp);
+			if (status == 0)
+			{
+				vl.time = (cdtime_t) tmp;
+				n.time  = (cdtime_t) tmp;
 			}
 		}
 		else if (pkg_type == TYPE_INTERVAL)
@@ -1337,7 +1503,15 @@ static int parse_packet (sockent_t *se, /* {{{ */
 			status = parse_part_number (&buffer, &buffer_size,
 					&tmp);
 			if (status == 0)
-				vl.interval = (int) tmp;
+				vl.interval = TIME_T_TO_CDTIME_T (tmp);
+		}
+		else if (pkg_type == TYPE_INTERVAL_HR)
+		{
+			uint64_t tmp = 0;
+			status = parse_part_number (&buffer, &buffer_size,
+					&tmp);
+			if (status == 0)
+				vl.interval = (cdtime_t) tmp;
 		}
 		else if (pkg_type == TYPE_HOST)
 		{
@@ -1412,7 +1586,7 @@ static int parse_packet (sockent_t *se, /* {{{ */
 			}
 			else
 			{
-				plugin_dispatch_notification (&n);
+				network_dispatch_notification (&n);
 			}
 		}
 		else if (pkg_type == TYPE_SEVERITY)
@@ -1431,6 +1605,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 */
 
@@ -1526,10 +1704,10 @@ static int network_set_ttl (const sockent_t *se, const struct addrinfo *ai)
 
 		if (setsockopt (se->data.client.fd, IPPROTO_IP, optname,
 					&network_config_ttl,
-					sizeof (network_config_ttl)) == -1)
+					sizeof (network_config_ttl)) != 0)
 		{
 			char errbuf[1024];
-			ERROR ("setsockopt: %s",
+			ERROR ("network plugin: setsockopt (ipv4-ttl): %s",
 					sstrerror (errno, errbuf, sizeof (errbuf)));
 			return (-1);
 		}
@@ -1547,10 +1725,10 @@ static int network_set_ttl (const sockent_t *se, const struct addrinfo *ai)
 
 		if (setsockopt (se->data.client.fd, IPPROTO_IPV6, optname,
 					&network_config_ttl,
-					sizeof (network_config_ttl)) == -1)
+					sizeof (network_config_ttl)) != 0)
 		{
 			char errbuf[1024];
-			ERROR ("setsockopt: %s",
+			ERROR ("network plugin: setsockopt(ipv6-ttl): %s",
 					sstrerror (errno, errbuf,
 						sizeof (errbuf)));
 			return (-1);
@@ -1560,16 +1738,124 @@ static int network_set_ttl (const sockent_t *se, const struct addrinfo *ai)
 	return (0);
 } /* int network_set_ttl */
 
-static int network_bind_socket (int fd, const struct addrinfo *ai)
+static int network_set_interface (const sockent_t *se, const struct addrinfo *ai) /* {{{ */
 {
+	DEBUG ("network plugin: network_set_interface: interface index = %i;",
+			se->interface);
+
+        assert (se->type == SOCKENT_TYPE_CLIENT);
+
+	if (ai->ai_family == AF_INET)
+	{
+		struct sockaddr_in *addr = (struct sockaddr_in *) ai->ai_addr;
+
+		if (IN_MULTICAST (ntohl (addr->sin_addr.s_addr)))
+		{
+#if HAVE_STRUCT_IP_MREQN_IMR_IFINDEX
+			/* If possible, use the "ip_mreqn" structure which has
+			 * an "interface index" member. Using the interface
+			 * index is preferred here, because of its similarity
+			 * to the way IPv6 handles this. Unfortunately, it
+			 * appears not to be portable. */
+			struct ip_mreqn mreq;
+
+			memset (&mreq, 0, sizeof (mreq));
+			mreq.imr_multiaddr.s_addr = addr->sin_addr.s_addr;
+			mreq.imr_address.s_addr = ntohl (INADDR_ANY);
+			mreq.imr_ifindex = se->interface;
+#else
+			struct ip_mreq mreq;
+
+			memset (&mreq, 0, sizeof (mreq));
+			mreq.imr_multiaddr.s_addr = addr->sin_addr.s_addr;
+			mreq.imr_interface.s_addr = ntohl (INADDR_ANY);
+#endif
+
+			if (setsockopt (se->data.client.fd, IPPROTO_IP, IP_MULTICAST_IF,
+						&mreq, sizeof (mreq)) != 0)
+			{
+				char errbuf[1024];
+				ERROR ("network plugin: setsockopt (ipv4-multicast-if): %s",
+						sstrerror (errno, errbuf, sizeof (errbuf)));
+				return (-1);
+			}
+
+			return (0);
+		}
+	}
+	else if (ai->ai_family == AF_INET6)
+	{
+		struct sockaddr_in6 *addr = (struct sockaddr_in6 *) ai->ai_addr;
+
+		if (IN6_IS_ADDR_MULTICAST (&addr->sin6_addr))
+		{
+			if (setsockopt (se->data.client.fd, IPPROTO_IPV6, IPV6_MULTICAST_IF,
+						&se->interface,
+						sizeof (se->interface)) != 0)
+			{
+				char errbuf[1024];
+				ERROR ("network plugin: setsockopt (ipv6-multicast-if): %s",
+						sstrerror (errno, errbuf,
+							sizeof (errbuf)));
+				return (-1);
+			}
+
+			return (0);
+		}
+	}
+
+	/* else: Not a multicast interface. */
+	if (se->interface != 0)
+	{
+#if defined(HAVE_IF_INDEXTONAME) && HAVE_IF_INDEXTONAME && defined(SO_BINDTODEVICE)
+		char interface_name[IFNAMSIZ];
+
+		if (if_indextoname (se->interface, interface_name) == NULL)
+			return (-1);
+
+		DEBUG ("network plugin: Binding socket to interface %s", interface_name);
+
+		if (setsockopt (se->data.client.fd, SOL_SOCKET, SO_BINDTODEVICE,
+					interface_name,
+					sizeof(interface_name)) == -1 )
+		{
+			char errbuf[1024];
+			ERROR ("network plugin: setsockopt (bind-if): %s",
+					sstrerror (errno, errbuf, sizeof (errbuf)));
+			return (-1);
+		}
+/* #endif HAVE_IF_INDEXTONAME && SO_BINDTODEVICE */
+
+#else
+		WARNING ("network plugin: Cannot set the interface on a unicast "
+			"socket because "
+# if !defined(SO_BINDTODEVICE)
+			"the \"SO_BINDTODEVICE\" socket option "
+# else
+			"the \"if_indextoname\" function "
+# endif
+			"is not available on your system.");
+#endif
+
+	}
+
+	return (0);
+} /* }}} network_set_interface */
+
+static int network_bind_socket (int fd, const struct addrinfo *ai, const int interface_idx)
+{
+#if KERNEL_SOLARIS
+	char loop   = 0;
+#else
 	int loop = 0;
+#endif
 	int yes  = 1;
 
 	/* allow multiple sockets to use the same PORT number */
 	if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR,
 				&yes, sizeof(yes)) == -1) {
                 char errbuf[1024];
-                ERROR ("setsockopt: %s", 
+                ERROR ("network plugin: setsockopt (reuseaddr): %s",
                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 		return (-1);
 	}
@@ -1589,18 +1875,30 @@ static int network_bind_socket (int fd, const struct addrinfo *ai)
 		struct sockaddr_in *addr = (struct sockaddr_in *) ai->ai_addr;
 		if (IN_MULTICAST (ntohl (addr->sin_addr.s_addr)))
 		{
+#if HAVE_STRUCT_IP_MREQN_IMR_IFINDEX
+			struct ip_mreqn mreq;
+#else
 			struct ip_mreq mreq;
+#endif
 
 			DEBUG ("fd = %i; IPv4 multicast address found", fd);
 
 			mreq.imr_multiaddr.s_addr = addr->sin_addr.s_addr;
-			mreq.imr_interface.s_addr = htonl (INADDR_ANY);
+#if HAVE_STRUCT_IP_MREQN_IMR_IFINDEX
+			/* Set the interface using the interface index if
+			 * possible (available). Unfortunately, the struct
+			 * ip_mreqn is not portable. */
+			mreq.imr_address.s_addr = ntohl (INADDR_ANY);
+			mreq.imr_ifindex = interface_idx;
+#else
+			mreq.imr_interface.s_addr = ntohl (INADDR_ANY);
+#endif
 
 			if (setsockopt (fd, IPPROTO_IP, IP_MULTICAST_LOOP,
 						&loop, sizeof (loop)) == -1)
 			{
 				char errbuf[1024];
-				ERROR ("setsockopt: %s",
+				ERROR ("network plugin: setsockopt (multicast-loop): %s",
 						sstrerror (errno, errbuf,
 							sizeof (errbuf)));
 				return (-1);
@@ -1610,11 +1908,13 @@ static int network_bind_socket (int fd, const struct addrinfo *ai)
 						&mreq, sizeof (mreq)) == -1)
 			{
 				char errbuf[1024];
-				ERROR ("setsockopt: %s",
+				ERROR ("network plugin: setsockopt (add-membership): %s",
 						sstrerror (errno, errbuf,
 							sizeof (errbuf)));
 				return (-1);
 			}
+
+			return (0);
 		}
 	}
 	else if (ai->ai_family == AF_INET6)
@@ -1640,13 +1940,13 @@ static int network_bind_socket (int fd, const struct addrinfo *ai)
 			 * single interface; programs running on
 			 * multihomed hosts may need to join the same
 			 * group on more than one interface.*/
-			mreq.ipv6mr_interface = 0;
+			mreq.ipv6mr_interface = interface_idx;
 
 			if (setsockopt (fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
 						&loop, sizeof (loop)) == -1)
 			{
 				char errbuf[1024];
-				ERROR ("setsockopt: %s",
+				ERROR ("network plugin: setsockopt (ipv6-multicast-loop): %s",
 						sstrerror (errno, errbuf,
 							sizeof (errbuf)));
 				return (-1);
@@ -1656,35 +1956,68 @@ static int network_bind_socket (int fd, const struct addrinfo *ai)
 						&mreq, sizeof (mreq)) == -1)
 			{
 				char errbuf[1024];
-				ERROR ("setsockopt: %s",
+				ERROR ("network plugin: setsockopt (ipv6-add-membership): %s",
 						sstrerror (errno, errbuf,
 							sizeof (errbuf)));
 				return (-1);
 			}
+
+			return (0);
 		}
 	}
 
+#if defined(HAVE_IF_INDEXTONAME) && HAVE_IF_INDEXTONAME && defined(SO_BINDTODEVICE)
+	/* if a specific interface was set, bind the socket to it. But to avoid
+ 	 * possible problems with multicast routing, only do that for non-multicast
+	 * addresses */
+	if (interface_idx != 0)
+	{
+		char interface_name[IFNAMSIZ];
+
+		if (if_indextoname (interface_idx, interface_name) == NULL)
+			return (-1);
+
+		DEBUG ("fd = %i; Binding socket to interface %s", fd, interface_name);
+
+		if (setsockopt (fd, SOL_SOCKET, SO_BINDTODEVICE,
+					interface_name,
+					sizeof(interface_name)) == -1 )
+		{
+			char errbuf[1024];
+			ERROR ("network plugin: setsockopt (bind-if): %s",
+					sstrerror (errno, errbuf, sizeof (errbuf)));
+			return (-1);
+		}
+	}
+#endif /* HAVE_IF_INDEXTONAME && SO_BINDTODEVICE */
+
 	return (0);
 } /* int network_bind_socket */
 
 /* Initialize a sockent structure. `type' must be either `SOCKENT_TYPE_CLIENT'
  * or `SOCKENT_TYPE_SERVER' */
-static int sockent_init (sockent_t *se, int type) /* {{{ */
+static sockent_t *sockent_create (int type) /* {{{ */
 {
-	if (se == NULL)
-		return (-1);
+	sockent_t *se;
+
+	if ((type != SOCKENT_TYPE_CLIENT) && (type != SOCKENT_TYPE_SERVER))
+		return (NULL);
 
+	se = malloc (sizeof (*se));
+	if (se == NULL)
+		return (NULL);
 	memset (se, 0, sizeof (*se));
 
-	se->type = SOCKENT_TYPE_CLIENT;
+	se->type = type;
 	se->node = NULL;
 	se->service = NULL;
+	se->interface = 0;
 	se->next = NULL;
 
 	if (type == SOCKENT_TYPE_SERVER)
 	{
-		se->type = SOCKENT_TYPE_SERVER;
 		se->data.server.fd = NULL;
+		se->data.server.fd_num = 0;
 #if HAVE_LIBGCRYPT
 		se->data.server.security_level = SECURITY_LEVEL_NONE;
 		se->data.server.auth_file = NULL;
@@ -1704,28 +2037,18 @@ static int sockent_init (sockent_t *se, int type) /* {{{ */
 #endif
 	}
 
-	return (0);
-} /* }}} int sockent_init */
+	return (se);
+} /* }}} sockent_t *sockent_create */
 
-/* Open the file descriptors for a initialized sockent structure. */
-static int sockent_open (sockent_t *se) /* {{{ */
+static int sockent_init_crypto (sockent_t *se) /* {{{ */
 {
-	struct addrinfo  ai_hints;
-	struct addrinfo *ai_list, *ai_ptr;
-	int              ai_return;
-
-        const char *node;
-        const char *service;
-
-	if (se == NULL)
-		return (-1);
-
-	/* Set up the security structures. */
 #if HAVE_LIBGCRYPT /* {{{ */
 	if (se->type == SOCKENT_TYPE_CLIENT)
 	{
 		if (se->data.client.security_level > SECURITY_LEVEL_NONE)
 		{
+			network_init_gcrypt ();
+
 			if ((se->data.client.username == NULL)
 					|| (se->data.client.password == NULL))
 			{
@@ -1744,6 +2067,8 @@ static int sockent_open (sockent_t *se) /* {{{ */
 	{
 		if (se->data.server.security_level > SECURITY_LEVEL_NONE)
 		{
+			network_init_gcrypt ();
+
 			if (se->data.server.auth_file == NULL)
 			{
 				ERROR ("network plugin: Server socket with "
@@ -1767,13 +2092,137 @@ static int sockent_open (sockent_t *se) /* {{{ */
 	}
 #endif /* }}} HAVE_LIBGCRYPT */
 
+	return (0);
+} /* }}} int sockent_init_crypto */
+
+static int sockent_client_connect (sockent_t *se) /* {{{ */
+{
+	static c_complain_t complaint = C_COMPLAIN_INIT_STATIC;
+
+	struct sockent_client *client;
+	struct addrinfo  ai_hints;
+	struct addrinfo *ai_list = NULL, *ai_ptr;
+	int status;
+
+	if ((se == NULL) || (se->type != SOCKENT_TYPE_CLIENT))
+		return (EINVAL);
+
+	client = &se->data.client;
+	if (client->fd >= 0) /* already connected */
+		return (0);
+
+	memset (&ai_hints, 0, sizeof (ai_hints));
+#ifdef AI_ADDRCONFIG
+	ai_hints.ai_flags |= AI_ADDRCONFIG;
+#endif
+	ai_hints.ai_family   = AF_UNSPEC;
+	ai_hints.ai_socktype = SOCK_DGRAM;
+	ai_hints.ai_protocol = IPPROTO_UDP;
+
+	status = getaddrinfo (se->node,
+			(se->service != NULL) ? se->service : NET_DEFAULT_PORT,
+			&ai_hints, &ai_list);
+	if (status != 0)
+	{
+		c_complain (LOG_ERR, &complaint,
+				"network plugin: getaddrinfo (%s, %s) failed: %s",
+				(se->node == NULL) ? "(null)" : se->node,
+				(se->service == NULL) ? "(null)" : se->service,
+				gai_strerror (status));
+		return (-1);
+	}
+	else
+	{
+		c_release (LOG_NOTICE, &complaint,
+				"network plugin: Successfully resolved \"%s\".",
+				se->node);
+	}
+
+	for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+	{
+		client->fd = socket (ai_ptr->ai_family,
+				ai_ptr->ai_socktype,
+				ai_ptr->ai_protocol);
+		if (client->fd < 0)
+		{
+			char errbuf[1024];
+			ERROR ("network plugin: socket(2) failed: %s",
+					sstrerror (errno, errbuf,
+						sizeof (errbuf)));
+			continue;
+		}
+
+		client->addr = malloc (sizeof (*client->addr));
+		if (client->addr == NULL)
+		{
+			ERROR ("network plugin: malloc failed.");
+			close (client->fd);
+			client->fd = -1;
+			continue;
+		}
+
+		memset (client->addr, 0, sizeof (*client->addr));
+		assert (sizeof (*client->addr) >= ai_ptr->ai_addrlen);
+		memcpy (client->addr, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
+		client->addrlen = ai_ptr->ai_addrlen;
+
+		network_set_ttl (se, ai_ptr);
+		network_set_interface (se, ai_ptr);
+
+		/* We don't open more than one write-socket per
+		 * node/service pair.. */
+		break;
+	}
+
+	freeaddrinfo (ai_list);
+	if (client->fd < 0)
+		return (-1);
+	return (0);
+} /* }}} int sockent_client_connect */
+
+static int sockent_client_disconnect (sockent_t *se) /* {{{ */
+{
+	struct sockent_client *client;
+
+	if ((se == NULL) || (se->type != SOCKENT_TYPE_CLIENT))
+		return (EINVAL);
+
+	client = &se->data.client;
+	if (client->fd >= 0) /* connected */
+	{
+		close (client->fd);
+		client->fd = -1;
+	}
+
+	sfree (client->addr);
+	client->addrlen = 0;
+
+	return (0);
+} /* }}} int sockent_client_disconnect */
+
+/* Open the file descriptors for a initialized sockent structure. */
+static int sockent_server_listen (sockent_t *se) /* {{{ */
+{
+	struct addrinfo  ai_hints;
+	struct addrinfo *ai_list, *ai_ptr;
+	int              status;
+
+        const char *node;
+        const char *service;
+
+	if (se == NULL)
+		return (-1);
+
+	assert (se->data.server.fd == NULL);
+	assert (se->data.server.fd_num == 0);
+
         node = se->node;
         service = se->service;
 
         if (service == NULL)
           service = NET_DEFAULT_PORT;
 
-        DEBUG ("network plugin: sockent_open: node = %s; service = %s;",
+        DEBUG ("network plugin: sockent_server_listen: node = %s; service = %s;",
             node, service);
 
 	memset (&ai_hints, 0, sizeof (ai_hints));
@@ -1788,108 +2237,59 @@ static int sockent_open (sockent_t *se) /* {{{ */
 	ai_hints.ai_socktype = SOCK_DGRAM;
 	ai_hints.ai_protocol = IPPROTO_UDP;
 
-	ai_return = getaddrinfo (node, service, &ai_hints, &ai_list);
-	if (ai_return != 0)
+	status = getaddrinfo (node, service, &ai_hints, &ai_list);
+	if (status != 0)
 	{
 		ERROR ("network plugin: getaddrinfo (%s, %s) failed: %s",
 				(se->node == NULL) ? "(null)" : se->node,
 				(se->service == NULL) ? "(null)" : se->service,
-				gai_strerror (ai_return));
+				gai_strerror (status));
 		return (-1);
 	}
 
 	for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
 	{
-		int status;
+		int *tmp;
 
-		if (se->type == SOCKENT_TYPE_SERVER) /* {{{ */
+		tmp = realloc (se->data.server.fd,
+				sizeof (*tmp) * (se->data.server.fd_num + 1));
+		if (tmp == NULL)
 		{
-			int *tmp;
-
-			tmp = realloc (se->data.server.fd,
-					sizeof (*tmp) * (se->data.server.fd_num + 1));
-			if (tmp == NULL)
-			{
-				ERROR ("network plugin: realloc failed.");
-				continue;
-			}
-			se->data.server.fd = tmp;
-			tmp = se->data.server.fd + se->data.server.fd_num;
-
-			*tmp = socket (ai_ptr->ai_family, ai_ptr->ai_socktype,
-					ai_ptr->ai_protocol);
-			if (*tmp < 0)
-			{
-				char errbuf[1024];
-				ERROR ("network plugin: socket(2) failed: %s",
-						sstrerror (errno, errbuf,
-							sizeof (errbuf)));
-				continue;
-			}
-
-			status = network_bind_socket (*tmp, ai_ptr);
-			if (status != 0)
-			{
-				close (*tmp);
-				*tmp = -1;
-				continue;
-			}
-
-			se->data.server.fd_num++;
+			ERROR ("network plugin: realloc failed.");
 			continue;
-		} /* }}} if (se->type == SOCKENT_TYPE_SERVER) */
-		else /* if (se->type == SOCKENT_TYPE_CLIENT) {{{ */
-		{
-			se->data.client.fd = socket (ai_ptr->ai_family,
-					ai_ptr->ai_socktype,
-					ai_ptr->ai_protocol);
-			if (se->data.client.fd < 0)
-			{
-				char errbuf[1024];
-				ERROR ("network plugin: socket(2) failed: %s",
-						sstrerror (errno, errbuf,
-							sizeof (errbuf)));
-				continue;
-			}
-
-			se->data.client.addr = malloc (sizeof (*se->data.client.addr));
-			if (se->data.client.addr == NULL)
-			{
-				ERROR ("network plugin: malloc failed.");
-				close (se->data.client.fd);
-				se->data.client.fd = -1;
-				continue;
-			}
+		}
+		se->data.server.fd = tmp;
+		tmp = se->data.server.fd + se->data.server.fd_num;
 
-			memset (se->data.client.addr, 0, sizeof (*se->data.client.addr));
-			assert (sizeof (*se->data.client.addr) >= ai_ptr->ai_addrlen);
-			memcpy (se->data.client.addr, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
-			se->data.client.addrlen = ai_ptr->ai_addrlen;
+		*tmp = socket (ai_ptr->ai_family, ai_ptr->ai_socktype,
+				ai_ptr->ai_protocol);
+		if (*tmp < 0)
+		{
+			char errbuf[1024];
+			ERROR ("network plugin: socket(2) failed: %s",
+					sstrerror (errno, errbuf,
+						sizeof (errbuf)));
+			continue;
+		}
 
-			network_set_ttl (se, ai_ptr);
+		status = network_bind_socket (*tmp, ai_ptr, se->interface);
+		if (status != 0)
+		{
+			close (*tmp);
+			*tmp = -1;
+			continue;
+		}
 
-			/* We don't open more than one write-socket per
-			 * node/service pair.. */
-			break;
-		} /* }}} if (se->type == SOCKENT_TYPE_CLIENT) */
+		se->data.server.fd_num++;
+		continue;
 	} /* for (ai_list) */
 
 	freeaddrinfo (ai_list);
 
-	/* Check if all went well. */
-	if (se->type == SOCKENT_TYPE_SERVER)
-	{
-		if (se->data.server.fd_num <= 0)
-			return (-1);
-	}
-	else /* if (se->type == SOCKENT_TYPE_CLIENT) */
-	{
-		if (se->data.client.fd < 0)
-			return (-1);
-	}
-
+	if (se->data.server.fd_num <= 0)
+		return (-1);
 	return (0);
-} /* }}} int sockent_open */
+} /* }}} int sockent_server_listen */
 
 /* Add a sockent to the global list of sockets */
 static int sockent_add (sockent_t *se) /* {{{ */
@@ -1959,13 +2359,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'
@@ -1991,14 +2392,17 @@ 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);
+    parse_packet (se, ent->data, ent->data_len, /* flags = */ 0,
+	/* username = */ NULL);
+    sfree (ent->data);
     sfree (ent);
   } /* while (42) */
 
@@ -2007,32 +2411,33 @@ 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;
-	int status;
+	int status = 0;
 
 	receive_list_entry_t *private_list_head;
 	receive_list_entry_t *private_list_tail;
+	uint64_t              private_list_length;
 
-        assert (listen_sockets_num > 0);
+	assert (listen_sockets_num > 0);
 
 	private_list_head = NULL;
 	private_list_tail = NULL;
+	private_list_length = 0;
 
 	while (listen_loop == 0)
 	{
 		status = poll (listen_sockets_pollfd, listen_sockets_num, -1);
-
 		if (status <= 0)
 		{
 			char errbuf[1024];
 			if (errno == EINTR)
 				continue;
-			ERROR ("poll failed: %s",
+			ERROR ("network plugin: poll(2) failed: %s",
 					sstrerror (errno, errbuf, sizeof (errbuf)));
-			return (-1);
+			break;
 		}
 
 		for (i = 0; (i < listen_sockets_num) && (status > 0); i++)
@@ -2050,12 +2455,15 @@ static int network_receive (void) /* {{{ */
 			if (buffer_len < 0)
 			{
 				char errbuf[1024];
-				ERROR ("recv failed: %s",
-						sstrerror (errno, errbuf,
-							sizeof (errbuf)));
-				return (-1);
+				status = (errno != 0) ? errno : -1;
+				ERROR ("network plugin: recv(2) failed: %s",
+						sstrerror (errno, errbuf, sizeof (errbuf)));
+				break;
 			}
 
+			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
@@ -2064,17 +2472,21 @@ static int network_receive (void) /* {{{ */
 			if (ent == NULL)
 			{
 				ERROR ("network plugin: malloc failed.");
-				return (-1);
+				status = ENOMEM;
+				break;
 			}
 			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.");
+				status = ENOMEM;
+				break;
+			}
 			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;
 
@@ -2083,24 +2495,35 @@ 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;
 			}
+
+			status = 0;
 		} /* for (listen_sockets_pollfd) */
+
+		if (status != 0)
+			break;
 	} /* while (listen_loop == 0) */
 
 	/* Make sure everything is dispatched before exiting. */
@@ -2113,15 +2536,13 @@ static int network_receive (void) /* {{{ */
 		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);
 	}
 
-	return (0);
+	return (status);
 } /* }}} int network_receive */
 
 static void *receive_thread (void __attribute__((unused)) *arg)
@@ -2131,33 +2552,39 @@ 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;
 
 	memset (&send_buffer_vl, 0, sizeof (send_buffer_vl));
 } /* int network_init_buffer */
 
-static void networt_send_buffer_plain (const sockent_t *se, /* {{{ */
+static void networt_send_buffer_plain (sockent_t *se, /* {{{ */
 		const char *buffer, size_t buffer_size)
 {
 	int status;
 
 	while (42)
 	{
+		status = sockent_client_connect (se);
+		if (status != 0)
+			return;
+
 		status = sendto (se->data.client.fd, buffer, buffer_size,
-                    /* flags = */ 0,
-                    (struct sockaddr *) se->data.client.addr,
-                    se->data.client.addrlen);
-                if (status < 0)
+				/* flags = */ 0,
+				(struct sockaddr *) se->data.client.addr,
+				se->data.client.addrlen);
+		if (status < 0)
 		{
 			char errbuf[1024];
-			if (errno == EINTR)
+
+			if ((errno == EINTR) || (errno == EAGAIN))
 				continue;
-			ERROR ("network plugin: sendto failed: %s",
-					sstrerror (errno, errbuf,
-						sizeof (errbuf)));
-			break;
+
+			ERROR ("network plugin: sendto failed: %s. Closing sending socket.",
+					sstrerror (errno, errbuf, sizeof (errbuf)));
+			sockent_client_disconnect (se);
+			return;
 		}
 
 		break;
@@ -2170,7 +2597,7 @@ static void networt_send_buffer_plain (const sockent_t *se, /* {{{ */
   buffer_offset += (s); \
 } while (0)
 
-static void networt_send_buffer_signed (const sockent_t *se, /* {{{ */
+static void networt_send_buffer_signed (sockent_t *se, /* {{{ */
 		const char *in_buffer, size_t in_buffer_size)
 {
   part_signature_sha256_t ps;
@@ -2259,9 +2686,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);
@@ -2280,6 +2704,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));
@@ -2365,7 +2791,7 @@ static int add_to_buffer (char *buffer, int buffer_size, /* {{{ */
 
 	if (vl_def->time != vl->time)
 	{
-		if (write_part_number (&buffer, &buffer_size, TYPE_TIME,
+		if (write_part_number (&buffer, &buffer_size, TYPE_TIME_HR,
 					(uint64_t) vl->time))
 			return (-1);
 		vl_def->time = vl->time;
@@ -2373,7 +2799,7 @@ static int add_to_buffer (char *buffer, int buffer_size, /* {{{ */
 
 	if (vl_def->interval != vl->interval)
 	{
-		if (write_part_number (&buffer, &buffer_size, TYPE_INTERVAL,
+		if (write_part_number (&buffer, &buffer_size, TYPE_INTERVAL_HR,
 					(uint64_t) vl->interval))
 			return (-1);
 		vl_def->interval = vl->interval;
@@ -2412,7 +2838,7 @@ static int add_to_buffer (char *buffer, int buffer_size, /* {{{ */
 			return (-1);
 		sstrncpy (vl_def->type_instance, vl->type_instance, sizeof (vl_def->type_instance));
 	}
-	
+
 	if (write_part_values (&buffer, &buffer_size, ds, vl) != 0)
 		return (-1);
 
@@ -2425,6 +2851,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 ();
 }
 
@@ -2433,18 +2863,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)
@@ -2452,13 +2894,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);
 
@@ -2466,6 +2910,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++;
 		}
 	}
 
@@ -2474,7 +2920,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 ();
 	}
@@ -2507,13 +2953,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
     {
@@ -2541,10 +2983,51 @@ static int network_config_set_ttl (const oconfig_item_t *ci) /* {{{ */
   tmp = (int) ci->values[0].value.number;
   if ((tmp > 0) && (tmp <= 255))
     network_config_ttl = tmp;
+  else {
+    WARNING ("network plugin: The `TimeToLive' must be between 1 and 255.");
+    return (-1);    
+  }
 
   return (0);
 } /* }}} int network_config_set_ttl */
 
+static int network_config_set_interface (const oconfig_item_t *ci, /* {{{ */
+    int *interface)
+{
+  if ((ci->values_num != 1)
+      || (ci->values[0].type != OCONFIG_TYPE_STRING))
+  {
+    WARNING ("network plugin: The `Interface' config option needs exactly "
+        "one string argument.");
+    return (-1);
+  }
+
+  if (interface == NULL)
+    return (-1);
+
+  *interface = if_nametoindex (ci->values[0].value.string);
+
+  return (0);
+} /* }}} int network_config_set_interface */
+
+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)
@@ -2614,13 +3097,12 @@ static int network_config_add_listen (const oconfig_item_t *ci) /* {{{ */
     return (-1);
   }
 
-  se = malloc (sizeof (*se));
+  se = sockent_create (SOCKENT_TYPE_SERVER);
   if (se == NULL)
   {
-    ERROR ("network plugin: malloc failed.");
+    ERROR ("network plugin: sockent_create failed.");
     return (-1);
   }
-  sockent_init (se, SOCKENT_TYPE_SERVER);
 
   se->node = strdup (ci->values[0].value.string);
   if (ci->values_num >= 2)
@@ -2638,6 +3120,10 @@ static int network_config_add_listen (const oconfig_item_t *ci) /* {{{ */
           &se->data.server.security_level);
     else
 #endif /* HAVE_LIBGCRYPT */
+    if (strcasecmp ("Interface", child->key) == 0)
+      network_config_set_interface (child,
+          &se->interface);
+    else
     {
       WARNING ("network plugin: Option `%s' is not allowed here.",
           child->key);
@@ -2656,10 +3142,18 @@ static int network_config_add_listen (const oconfig_item_t *ci) /* {{{ */
   }
 #endif /* HAVE_LIBGCRYPT */
 
-  status = sockent_open (se);
+  status = sockent_init_crypto (se);
+  if (status != 0)
+  {
+    ERROR ("network plugin: network_config_add_listen: sockent_init_crypto() failed.");
+    sockent_destroy (se);
+    return (-1);
+  }
+
+  status = sockent_server_listen (se);
   if (status != 0)
   {
-    ERROR ("network plugin: network_config_add_listen: sockent_open failed.");
+    ERROR ("network plugin: network_config_add_server: sockent_server_listen failed.");
     sockent_destroy (se);
     return (-1);
   }
@@ -2690,13 +3184,12 @@ static int network_config_add_server (const oconfig_item_t *ci) /* {{{ */
     return (-1);
   }
 
-  se = malloc (sizeof (*se));
+  se = sockent_create (SOCKENT_TYPE_CLIENT);
   if (se == NULL)
   {
-    ERROR ("network plugin: malloc failed.");
+    ERROR ("network plugin: sockent_create failed.");
     return (-1);
   }
-  sockent_init (se, SOCKENT_TYPE_CLIENT);
 
   se->node = strdup (ci->values[0].value.string);
   if (ci->values_num >= 2)
@@ -2716,6 +3209,10 @@ static int network_config_add_server (const oconfig_item_t *ci) /* {{{ */
           &se->data.client.security_level);
     else
 #endif /* HAVE_LIBGCRYPT */
+    if (strcasecmp ("Interface", child->key) == 0)
+      network_config_set_interface (child,
+          &se->interface);
+    else
     {
       WARNING ("network plugin: Option `%s' is not allowed here.",
           child->key);
@@ -2735,14 +3232,17 @@ static int network_config_add_server (const oconfig_item_t *ci) /* {{{ */
   }
 #endif /* HAVE_LIBGCRYPT */
 
-  status = sockent_open (se);
+  status = sockent_init_crypto (se);
   if (status != 0)
   {
-    ERROR ("network plugin: network_config_add_server: sockent_open failed.");
+    ERROR ("network plugin: network_config_add_server: sockent_init_crypto() failed.");
     sockent_destroy (se);
     return (-1);
   }
 
+  /* No call to sockent_client_connect() here -- it is called from
+   * networt_send_buffer_plain(). */
+
   status = sockent_add (se);
   if (status != 0)
   {
@@ -2754,28 +3254,18 @@ 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;
 
+  /* The options need to be applied first */
+  for (i = 0; i < ci->children_num; i++)
+  {
+    oconfig_item_t *child = ci->children + i;
+    if (strcasecmp ("TimeToLive", child->key) == 0)
+      network_config_set_ttl (child);
+  }
+
   for (i = 0; i < ci->children_num; i++)
   {
     oconfig_item_t *child = ci->children + i;
@@ -2784,12 +3274,15 @@ static int network_config (oconfig_item_t *ci) /* {{{ */
       network_config_add_listen (child);
     else if (strcasecmp ("Server", child->key) == 0)
       network_config_add_server (child);
-    else if (strcasecmp ("TimeToLive", child->key) == 0)
-      network_config_set_ttl (child);
+    else if (strcasecmp ("TimeToLive", child->key) == 0) {
+      /* Handled earlier */
+    }
+    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 ("CacheFlush", child->key) == 0)
-      network_config_set_cache_flush (child);
+    else if (strcasecmp ("ReportStats", child->key) == 0)
+      network_config_set_boolean (child, &network_config_stats);
     else
     {
       WARNING ("network plugin: Option `%s' is not allowed here.",
@@ -2801,17 +3294,19 @@ static int network_config (oconfig_item_t *ci) /* {{{ */
 } /* }}} int network_config */
 
 static int network_notification (const notification_t *n,
-		user_data_t __attribute__((unused)) *user_data)
+    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;
 
-  memset (buffer, '\0', sizeof (buffer));
+  if (!check_send_notify_okay (n))
+    return (0);
 
+  memset (buffer, 0, sizeof (buffer));
 
-  status = write_part_number (&buffer_ptr, &buffer_free, TYPE_TIME,
+  status = write_part_number (&buffer_ptr, &buffer_free, TYPE_TIME_HR,
       (uint64_t) n->time);
   if (status != 0)
     return (-1);
@@ -2824,7 +3319,7 @@ static int network_notification (const notification_t *n,
   if (strlen (n->host) > 0)
   {
     status = write_part_string (&buffer_ptr, &buffer_free, TYPE_HOST,
-	n->host, strlen (n->host));
+        n->host, strlen (n->host));
     if (status != 0)
       return (-1);
   }
@@ -2832,7 +3327,7 @@ static int network_notification (const notification_t *n,
   if (strlen (n->plugin) > 0)
   {
     status = write_part_string (&buffer_ptr, &buffer_free, TYPE_PLUGIN,
-	n->plugin, strlen (n->plugin));
+        n->plugin, strlen (n->plugin));
     if (status != 0)
       return (-1);
   }
@@ -2840,8 +3335,8 @@ static int network_notification (const notification_t *n,
   if (strlen (n->plugin_instance) > 0)
   {
     status = write_part_string (&buffer_ptr, &buffer_free,
-	TYPE_PLUGIN_INSTANCE,
-	n->plugin_instance, strlen (n->plugin_instance));
+        TYPE_PLUGIN_INSTANCE,
+        n->plugin_instance, strlen (n->plugin_instance));
     if (status != 0)
       return (-1);
   }
@@ -2849,7 +3344,7 @@ static int network_notification (const notification_t *n,
   if (strlen (n->type) > 0)
   {
     status = write_part_string (&buffer_ptr, &buffer_free, TYPE_TYPE,
-	n->type, strlen (n->type));
+        n->type, strlen (n->type));
     if (status != 0)
       return (-1);
   }
@@ -2857,7 +3352,7 @@ static int network_notification (const notification_t *n,
   if (strlen (n->type_instance) > 0)
   {
     status = write_part_string (&buffer_ptr, &buffer_free, TYPE_TYPE_INSTANCE,
-	n->type_instance, strlen (n->type_instance));
+        n->type_instance, strlen (n->type_instance));
     if (status != 0)
       return (-1);
   }
@@ -2874,6 +3369,8 @@ static int network_notification (const notification_t *n,
 
 static int network_shutdown (void)
 {
+	sockent_t *se;
+
 	listen_loop++;
 
 	/* Kill the listening thread */
@@ -2902,47 +3399,123 @@ 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' */
+	for (se = sending_sockets; se != NULL; se = se->next)
+		sockent_client_disconnect (se);
+	sockent_destroy (sending_sockets);
 
 	plugin_unregister_config ("network");
 	plugin_unregister_init ("network");
 	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) /* {{{ */
+{
+	derive_t copy_octets_rx;
+	derive_t copy_octets_tx;
+	derive_t copy_packets_rx;
+	derive_t copy_packets_tx;
+	derive_t copy_values_dispatched;
+	derive_t copy_values_not_dispatched;
+	derive_t copy_values_sent;
+	derive_t copy_values_not_sent;
+	derive_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;
+	sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+	sstrncpy (vl.plugin, "network", sizeof (vl.plugin));
+
+	/* Octets received / sent */
+	vl.values[0].derive = (derive_t) copy_octets_rx;
+	vl.values[1].derive = (derive_t) copy_octets_tx;
+	sstrncpy (vl.type, "if_octets", sizeof (vl.type));
+	plugin_dispatch_values (&vl);
+
+	/* Packets received / send */
+	vl.values[0].derive = (derive_t) copy_packets_rx;
+	vl.values[1].derive = (derive_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 = 0;
+
 	/* 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 = 1;
+
+#if HAVE_LIBGCRYPT
+	network_init_gcrypt ();
+#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)
 	{
@@ -2961,7 +3534,7 @@ static int network_init (void)
 	if (dispatch_thread_running == 0)
 	{
 		int status;
-		status = pthread_create (&dispatch_thread_id,
+		status = plugin_thread_create (&dispatch_thread_id,
 				NULL /* no attributes */,
 				dispatch_thread,
 				NULL /* no argument */);
@@ -2981,7 +3554,7 @@ static int network_init (void)
 	if (receive_thread_running == 0)
 	{
 		int status;
-		status = pthread_create (&receive_thread_id,
+		status = plugin_thread_create (&receive_thread_id,
 				NULL /* no attributes */,
 				receive_thread,
 				NULL /* no argument */);
@@ -3001,24 +3574,21 @@ static int network_init (void)
 	return (0);
 } /* int network_init */
 
-/* 
+/*
  * The flush option of the network plugin cannot flush individual identifiers.
  * All the values are added to a buffer and sent when the buffer is full, the
  * requested value may or may not be in there, it's not worth finding out. We
  * just send the buffer if `flush'  is called - if the requested value was in
  * there, good. If not, well, then there is nothing to flush.. -octo
  */
-static int network_flush (int timeout,
-		const char __attribute__((unused)) *identifier,
-		user_data_t __attribute__((unused)) *user_data)
+static int network_flush (__attribute__((unused)) cdtime_t timeout,
+		__attribute__((unused)) const char *identifier,
+		__attribute__((unused)) user_data_t *user_data)
 {
 	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);