X-Git-Url: https://git.octo.it/?a=blobdiff_plain;ds=sidebyside;f=src%2Fnetwork.c;h=0ee6ed0b9834f96a9ad1cd885657c0e5f9719c89;hb=865a6c83250e3d4381596a0d937df31d563f97c6;hp=af4a117c466a83e2ef5f7da82c28e1bf0a1cd80c;hpb=dbe559f1627d886078d27c59f21f4f6572c00f0b;p=collectd.git

diff --git a/src/network.c b/src/network.c
index af4a117c..0ee6ed0b 100644
--- a/src/network.c
+++ b/src/network.c
@@ -1,6 +1,6 @@
 /**
  * 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
@@ -18,10 +18,11 @@
  * 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 _DEFAULT_SOURCE
 #define _BSD_SOURCE /* For struct ip_mreq */
 
 #include "collectd.h"
@@ -31,6 +32,7 @@
 #include "utils_fbhash.h"
 #include "utils_avltree.h"
 #include "utils_cache.h"
+#include "utils_complain.h"
 
 #include "network.h"
 
@@ -57,8 +59,27 @@
 #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
 
 #ifndef IPV6_ADD_MEMBERSHIP
@@ -258,7 +279,8 @@ 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;
+/* 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;
 
@@ -295,14 +317,14 @@ static pthread_mutex_t  send_buffer_lock = PTHREAD_MUTEX_INITIALIZER;
  * 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 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;
 
 /*
@@ -319,30 +341,30 @@ static _Bool check_receive_okay (const value_list_t *vl) /* {{{ */
   /* 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);
+    return (0);
 
-  return (true);
+  return (1);
 } /* }}} _Bool check_receive_okay */
 
 static _Bool check_send_okay (const value_list_t *vl) /* {{{ */
 {
-  _Bool received = false;
+  _Bool received = 0;
   int status;
 
   if (network_config_forward != 0)
-    return (true);
+    return (1);
 
   if (vl->meta == NULL)
-    return (true);
+    return (1);
 
   status = meta_data_get_boolean (vl->meta, "network:received", &received);
   if (status == -ENOENT)
-    return (true);
+    return (1);
   else if (status != 0)
   {
     ERROR ("network plugin: check_send_okay: meta_data_get_boolean failed "
 	"with status %i.", status);
-    return (true);
+    return (1);
   }
 
   /* By default, only *send* value lists that were not *received* by the
@@ -350,7 +372,45 @@ static _Bool check_send_okay (const value_list_t *vl) /* {{{ */
   return (!received);
 } /* }}} _Bool check_send_okay */
 
-static int network_dispatch_values (value_list_t *vl) /* {{{ */
+static _Bool check_notify_received (const notification_t *n) /* {{{ */
+{
+  notification_meta_t *ptr;
+
+  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);
+
+  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;
+
+  if (n->meta == NULL)
+    return (1);
+
+  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;
 
@@ -382,7 +442,7 @@ static int network_dispatch_values (value_list_t *vl) /* {{{ */
     return (-ENOMEM);
   }
 
-  status = meta_data_add_boolean (vl->meta, "network:received", true);
+  status = meta_data_add_boolean (vl->meta, "network:received", 1);
   if (status != 0)
   {
     ERROR ("network plugin: meta_data_add_boolean failed.");
@@ -391,6 +451,18 @@ static int network_dispatch_values (value_list_t *vl) /* {{{ */
     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++;
 
@@ -400,7 +472,53 @@ static int network_dispatch_values (value_list_t *vl) /* {{{ */
   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);
+  }
+
+  status = plugin_dispatch_notification (n);
+
+  plugin_notification_meta_free (n->meta);
+  n->meta = NULL;
+
+  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)
 {
@@ -586,7 +704,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);
@@ -690,7 +808,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: "
@@ -744,11 +862,11 @@ static int parse_part_values (void **ret_buffer, size_t *ret_buffer_len,
 		    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]);
+		    sfree (pkg_types);
+		    sfree (pkg_values);
 		    return (-1);
 		} /* switch (pkg_types[i]) */
 	}
@@ -774,9 +892,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: "
@@ -788,7 +905,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);
@@ -814,9 +931,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: "
@@ -828,7 +944,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);
@@ -892,7 +1008,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)); \
@@ -903,6 +1020,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;
@@ -924,8 +1043,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);
   }
 
@@ -987,6 +1107,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);
   }
 
@@ -1008,9 +1130,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: "
@@ -1019,9 +1138,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;
 
@@ -1065,7 +1187,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;
@@ -1144,7 +1267,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);
@@ -1156,6 +1282,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);
@@ -1174,17 +1301,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 */
@@ -1239,7 +1371,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;
 
@@ -1339,7 +1472,7 @@ static int parse_packet (sockent_t *se, /* {{{ */
 			if (status != 0)
 				break;
 
-			network_dispatch_values (&vl);
+			network_dispatch_values (&vl, username);
 
 			sfree (vl.values);
 		}
@@ -1350,8 +1483,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)
@@ -1360,7 +1504,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)
 		{
@@ -1435,7 +1587,7 @@ static int parse_packet (sockent_t *se, /* {{{ */
 			}
 			else
 			{
-				plugin_dispatch_notification (&n);
+				network_dispatch_notification (&n);
 			}
 		}
 		else if (pkg_type == TYPE_SEVERITY)
@@ -1553,10 +1705,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);
 		}
@@ -1574,10 +1726,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);
@@ -1621,10 +1773,10 @@ static int network_set_interface (const sockent_t *se, const struct addrinfo *ai
 #endif
 
 			if (setsockopt (se->data.client.fd, IPPROTO_IP, IP_MULTICAST_IF,
-						&mreq, sizeof (mreq)) == -1)
+						&mreq, sizeof (mreq)) != 0)
 			{
 				char errbuf[1024];
-				ERROR ("setsockopt: %s",
+				ERROR ("network plugin: setsockopt (ipv4-multicast-if): %s",
 						sstrerror (errno, errbuf, sizeof (errbuf)));
 				return (-1);
 			}
@@ -1640,10 +1792,10 @@ static int network_set_interface (const sockent_t *se, const struct addrinfo *ai
 		{
 			if (setsockopt (se->data.client.fd, IPPROTO_IPV6, IPV6_MULTICAST_IF,
 						&se->interface,
-						sizeof (se->interface)) == -1)
+						sizeof (se->interface)) != 0)
 			{
 				char errbuf[1024];
-				ERROR ("setsockopt: %s",
+				ERROR ("network plugin: setsockopt (ipv6-multicast-if): %s",
 						sstrerror (errno, errbuf,
 							sizeof (errbuf)));
 				return (-1);
@@ -1654,9 +1806,9 @@ static int network_set_interface (const sockent_t *se, const struct addrinfo *ai
 	}
 
 	/* else: Not a multicast interface. */
-#if defined(HAVE_IF_INDEXTONAME) && HAVE_IF_INDEXTONAME && defined(SO_BINDTODEVICE)
 	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)
@@ -1669,37 +1821,42 @@ static int network_set_interface (const sockent_t *se, const struct addrinfo *ai
 					sizeof(interface_name)) == -1 )
 		{
 			char errbuf[1024];
-			ERROR ("setsockopt: %s",
+			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 "
+		WARNING ("network plugin: Cannot set the interface on a unicast "
 			"socket because "
 # if !defined(SO_BINDTODEVICE)
-			"the the \"SO_BINDTODEVICE\" socket option "
+			"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);
 	}
@@ -1742,7 +1899,7 @@ static int network_bind_socket (int fd, const struct addrinfo *ai, const int int
 						&loop, sizeof (loop)) == -1)
 			{
 				char errbuf[1024];
-				ERROR ("setsockopt: %s",
+				ERROR ("network plugin: setsockopt (multicast-loop): %s",
 						sstrerror (errno, errbuf,
 							sizeof (errbuf)));
 				return (-1);
@@ -1752,7 +1909,7 @@ static int network_bind_socket (int fd, const struct addrinfo *ai, const int int
 						&mreq, sizeof (mreq)) == -1)
 			{
 				char errbuf[1024];
-				ERROR ("setsockopt: %s",
+				ERROR ("network plugin: setsockopt (add-membership): %s",
 						sstrerror (errno, errbuf,
 							sizeof (errbuf)));
 				return (-1);
@@ -1790,7 +1947,7 @@ static int network_bind_socket (int fd, const struct addrinfo *ai, const int int
 						&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);
@@ -1800,7 +1957,7 @@ static int network_bind_socket (int fd, const struct addrinfo *ai, const int int
 						&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);
@@ -1828,7 +1985,7 @@ static int network_bind_socket (int fd, const struct addrinfo *ai, const int int
 					sizeof(interface_name)) == -1 )
 		{
 			char errbuf[1024];
-			ERROR ("setsockopt: %s",
+			ERROR ("network plugin: setsockopt (bind-if): %s",
 					sstrerror (errno, errbuf, sizeof (errbuf)));
 			return (-1);
 		}
@@ -1840,14 +1997,19 @@ static int network_bind_socket (int fd, const struct addrinfo *ai, const int int
 
 /* 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;
@@ -1855,8 +2017,8 @@ static int sockent_init (sockent_t *se, int type) /* {{{ */
 
 	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;
@@ -1876,28 +2038,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))
 			{
@@ -1916,6 +2068,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 "
@@ -1939,13 +2093,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));
@@ -1960,109 +2238,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, se->interface);
-			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);
-			network_set_interface (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) /* {{{ */
@@ -2173,7 +2401,8 @@ static void *dispatch_thread (void __attribute__((unused)) *arg) /* {{{ */
       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) */
@@ -2187,13 +2416,13 @@ static int network_receive (void) /* {{{ */
 	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;
@@ -2202,15 +2431,14 @@ static int network_receive (void) /* {{{ */
 	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++)
@@ -2228,10 +2456,10 @@ 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);
@@ -2245,7 +2473,8 @@ 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);
@@ -2253,7 +2482,8 @@ static int network_receive (void) /* {{{ */
 			{
 				sfree (ent);
 				ERROR ("network plugin: malloc failed.");
-				return (-1);
+				status = ENOMEM;
+				break;
 			}
 			ent->fd = listen_sockets_pollfd[i].fd;
 			ent->next = NULL;
@@ -2289,7 +2519,12 @@ static int network_receive (void) /* {{{ */
 				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. */
@@ -2304,15 +2539,11 @@ static int network_receive (void) /* {{{ */
 		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);
 	}
 
-	return (0);
+	return (status);
 } /* }}} int network_receive */
 
 static void *receive_thread (void __attribute__((unused)) *arg)
@@ -2329,26 +2560,32 @@ static void network_init_buffer (void)
 	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;
@@ -2361,7 +2598,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;
@@ -2555,7 +2792,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;
@@ -2563,7 +2800,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;
@@ -2602,7 +2839,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);
 
@@ -2747,6 +2984,10 @@ 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 */
@@ -2857,13 +3098,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)
@@ -2903,10 +3143,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_open failed.");
+    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_server: sockent_server_listen failed.");
     sockent_destroy (se);
     return (-1);
   }
@@ -2937,13 +3185,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)
@@ -2986,14 +3233,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)
   {
@@ -3009,6 +3259,14 @@ 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;
@@ -3017,16 +3275,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 ("ReportStats", child->key) == 0)
       network_config_set_boolean (child, &network_config_stats);
-    else if (strcasecmp ("CacheFlush", child->key) == 0)
-      /* no op for backwards compatibility only */;
     else
     {
       WARNING ("network plugin: Option `%s' is not allowed here.",
@@ -3038,17 +3295,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[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);
@@ -3061,7 +3320,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);
   }
@@ -3069,7 +3328,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);
   }
@@ -3077,8 +3336,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);
   }
@@ -3086,7 +3345,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);
   }
@@ -3094,7 +3353,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);
   }
@@ -3111,6 +3370,8 @@ static int network_notification (const notification_t *n,
 
 static int network_shutdown (void)
 {
+	sockent_t *se;
+
 	listen_loop++;
 
 	/* Kill the listening thread */
@@ -3141,7 +3402,9 @@ static int network_shutdown (void)
 
 	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");
@@ -3153,15 +3416,15 @@ static int network_shutdown (void)
 
 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;
+	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];
 
@@ -3179,19 +3442,18 @@ static int network_stats_read (void) /* {{{ */
 	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;
+	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].counter = (counter_t) copy_packets_rx;
-	vl.values[1].counter = (counter_t) copy_packets_tx;
+	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);
 
@@ -3230,18 +3492,16 @@ static int network_stats_read (void) /* {{{ */
 
 static int network_init (void)
 {
-	static _Bool have_init = false;
+	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 (have_init)
 		return (0);
-	have_init = true;
+	have_init = 1;
 
 #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);
+	network_init_gcrypt ();
 #endif
 
 	if (network_config_stats != 0)
@@ -3275,7 +3535,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 */);
@@ -3295,7 +3555,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 */);
@@ -3315,16 +3575,16 @@ 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);