X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Frrd_daemon.c;h=bc44b810ee01334f97d21c68e4f1d727be2d6d53;hb=a42f6740636ce163011504932c5aab7cdfc95c86;hp=d446756939aec406850b0baa91152de6948e5e97;hpb=0b9e1c658d7b55301a76187012541ae7f16a528d;p=rrdtool.git

diff --git a/src/rrd_daemon.c b/src/rrd_daemon.c
index d446756..bc44b81 100644
--- a/src/rrd_daemon.c
+++ b/src/rrd_daemon.c
@@ -66,6 +66,9 @@
 #include <stdio.h>
 #include <unistd.h>
 #include <string.h>
+#include <strings.h>
+#include <stdint.h>
+#include <inttypes.h>
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -116,6 +119,21 @@ struct cache_item_s
   cache_item_t *next;
 };
 
+struct callback_flush_data_s
+{
+  time_t now;
+  char **keys;
+  size_t keys_num;
+};
+typedef struct callback_flush_data_s callback_flush_data_t;
+
+enum queue_side_e
+{
+  HEAD,
+  TAIL
+};
+typedef enum queue_side_e queue_side_t;
+
 /*
  * Variables
  */
@@ -137,12 +155,21 @@ static cache_item_t   *cache_queue_tail = NULL;
 static pthread_mutex_t cache_lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t  cache_cond = PTHREAD_COND_INITIALIZER;
 
+static pthread_cond_t  flush_cond = PTHREAD_COND_INITIALIZER;
+
 static int config_write_interval = 300;
 static int config_flush_interval = 3600;
+static char *config_pid_file = NULL;
+static char *config_base_dir = NULL;
 
 static char **config_listen_address_list = NULL;
 static int config_listen_address_list_len = 0;
 
+static uint64_t stats_queue_length = 0;
+static uint64_t stats_updates_written = 0;
+static uint64_t stats_data_sets_written = 0;
+static pthread_mutex_t stats_lock = PTHREAD_MUTEX_INITIALIZER;
+
 /* 
  * Functions
  */
@@ -156,31 +183,201 @@ static void sig_term_handler (int s __attribute__((unused))) /* {{{ */
   do_shutdown++;
 } /* }}} void sig_term_handler */
 
+static int write_pidfile (void) /* {{{ */
+{
+  pid_t pid;
+  char *file;
+  FILE *fh;
+
+  pid = getpid ();
+  
+  file = (config_pid_file != NULL)
+    ? config_pid_file
+    : LOCALSTATEDIR "/run/rrdcached.pid";
+
+  fh = fopen (file, "w");
+  if (fh == NULL)
+  {
+    RRDD_LOG (LOG_ERR, "write_pidfile: Opening `%s' failed.", file);
+    return (-1);
+  }
+
+  fprintf (fh, "%i\n", (int) pid);
+  fclose (fh);
+
+  return (0);
+} /* }}} int write_pidfile */
+
+static int remove_pidfile (void) /* {{{ */
+{
+  char *file;
+  int status;
+
+  file = (config_pid_file != NULL)
+    ? config_pid_file
+    : LOCALSTATEDIR "/run/rrdcached.pid";
+
+  status = unlink (file);
+  if (status == 0)
+    return (0);
+  return (errno);
+} /* }}} int remove_pidfile */
+
+static ssize_t sread (int fd, void *buffer_void, size_t buffer_size) /* {{{ */
+{
+  char    *buffer;
+  size_t   buffer_used;
+  size_t   buffer_free;
+  ssize_t  status;
+
+  buffer       = (char *) buffer_void;
+  buffer_used  = 0;
+  buffer_free  = buffer_size;
+
+  while (buffer_free > 0)
+  {
+    status = read (fd, buffer + buffer_used, buffer_free);
+    if ((status < 0) && ((errno == EAGAIN) || (errno == EINTR)))
+      continue;
+
+    if (status < 0)
+      return (-1);
+
+    if (status == 0)
+      return (0);
+
+    assert ((0 > status) || (buffer_free >= (size_t) status));
+
+    buffer_free = buffer_free - status;
+    buffer_used = buffer_used + status;
+
+    if (buffer[buffer_used - 1] == '\n')
+      break;
+  }
+
+  assert (buffer_used > 0);
+
+  if (buffer[buffer_used - 1] != '\n')
+  {
+    errno = ENOBUFS;
+    return (-1);
+  }
+
+  buffer[buffer_used - 1] = 0;
+
+  /* Fix network line endings. */
+  if ((buffer_used > 1) && (buffer[buffer_used - 2] == '\r'))
+  {
+    buffer_used--;
+    buffer[buffer_used - 1] = 0;
+  }
+
+  return (buffer_used);
+} /* }}} ssize_t sread */
+
+static ssize_t swrite (int fd, const void *buf, size_t count) /* {{{ */
+{
+  const char *ptr;
+  size_t      nleft;
+  ssize_t     status;
+
+  ptr   = (const char *) buf;
+  nleft = count;
+
+  while (nleft > 0)
+  {
+    status = write (fd, (const void *) ptr, nleft);
+
+    if ((status < 0) && ((errno == EAGAIN) || (errno == EINTR)))
+      continue;
+
+    if (status < 0)
+      return (status);
+
+    nleft = nleft - status;
+    ptr   = ptr   + status;
+  }
+
+  return (0);
+} /* }}} ssize_t swrite */
+
 /*
  * enqueue_cache_item:
  * `cache_lock' must be acquired before calling this function!
  */
-static int enqueue_cache_item (cache_item_t *ci) /* {{{ */
+static int enqueue_cache_item (cache_item_t *ci, /* {{{ */
+    queue_side_t side)
 {
-  RRDD_LOG (LOG_DEBUG, "enqueue_cache_item: Adding %s to the update queue.",
-      ci->file);
+  int did_insert = 0;
 
   if (ci == NULL)
     return (-1);
 
-  if ((ci->flags & CI_FLAGS_IN_QUEUE) != 0)
-    return (-1);
-
-  assert (ci->next == NULL);
-
   if (ci->values_num == 0)
     return (0);
 
-  if (cache_queue_tail == NULL)
-    cache_queue_head = ci;
-  else
-    cache_queue_tail->next = ci;
-  cache_queue_tail = ci;
+  if (side == HEAD)
+  {
+    if ((ci->flags & CI_FLAGS_IN_QUEUE) == 0)
+    {
+      assert (ci->next == NULL);
+      ci->next = cache_queue_head;
+      cache_queue_head = ci;
+
+      if (cache_queue_tail == NULL)
+        cache_queue_tail = cache_queue_head;
+
+      did_insert = 1;
+    }
+    else if (cache_queue_head == ci)
+    {
+      /* do nothing */
+    }
+    else /* enqueued, but not first entry */
+    {
+      cache_item_t *prev;
+
+      /* find previous entry */
+      for (prev = cache_queue_head; prev != NULL; prev = prev->next)
+        if (prev->next == ci)
+          break;
+      assert (prev != NULL);
+
+      /* move to the front */
+      prev->next = ci->next;
+      ci->next = cache_queue_head;
+      cache_queue_head = ci;
+
+      /* check if we need to adapt the tail */
+      if (cache_queue_tail == ci)
+        cache_queue_tail = prev;
+    }
+  }
+  else /* (side == TAIL) */
+  {
+    /* We don't move values back in the list.. */
+    if ((ci->flags & CI_FLAGS_IN_QUEUE) != 0)
+      return (0);
+
+    assert (ci->next == NULL);
+
+    if (cache_queue_tail == NULL)
+      cache_queue_head = ci;
+    else
+      cache_queue_tail->next = ci;
+    cache_queue_tail = ci;
+
+    did_insert = 1;
+  }
+
+  ci->flags |= CI_FLAGS_IN_QUEUE;
+
+  if (did_insert)
+  {
+    pthread_mutex_lock (&stats_lock);
+    stats_queue_length++;
+    pthread_mutex_unlock (&stats_lock);
+  }
 
   return (0);
 } /* }}} int enqueue_cache_item */
@@ -190,22 +387,42 @@ static int enqueue_cache_item (cache_item_t *ci) /* {{{ */
  * Called via `g_tree_foreach' in `queue_thread_main'. `cache_lock' is held
  * while this is in progress.
  */
-static gboolean tree_callback_flush (gpointer key /* {{{ */
-    __attribute__((unused)), gpointer value, gpointer data)
+static gboolean tree_callback_flush (gpointer key, gpointer value, /* {{{ */
+    gpointer data)
 {
   cache_item_t *ci;
-  time_t now;
-
-  key = NULL; /* make compiler happy */
+  callback_flush_data_t *cfd;
 
   ci = (cache_item_t *) value;
-  now = *((time_t *) data);
+  cfd = (callback_flush_data_t *) data;
 
-  if (((now - ci->last_flush_time) >= config_write_interval)
-      && ((ci->flags & CI_FLAGS_IN_QUEUE) == 0))
-    enqueue_cache_item (ci);
+  if (((cfd->now - ci->last_flush_time) >= config_write_interval)
+      && ((ci->flags & CI_FLAGS_IN_QUEUE) == 0)
+      && (ci->values_num > 0))
+  {
+    enqueue_cache_item (ci, TAIL);
+  }
+  else if (((cfd->now - ci->last_flush_time) >= config_flush_interval)
+      && ((ci->flags & CI_FLAGS_IN_QUEUE) == 0)
+      && (ci->values_num <= 0))
+  {
+    char **temp;
+
+    temp = (char **) realloc (cfd->keys,
+        sizeof (char *) * (cfd->keys_num + 1));
+    if (temp == NULL)
+    {
+      RRDD_LOG (LOG_ERR, "tree_callback_flush: realloc failed.");
+      return (FALSE);
+    }
+    cfd->keys = temp;
+    /* Make really sure this points to the _same_ place */
+    assert ((char *) key == ci->file);
+    cfd->keys[cfd->keys_num] = (char *) key;
+    cfd->keys_num++;
+  }
 
-  return (TRUE);
+  return (FALSE);
 } /* }}} gboolean tree_callback_flush */
 
 static void *queue_thread_main (void *args __attribute__((unused))) /* {{{ */
@@ -233,13 +450,48 @@ static void *queue_thread_main (void *args __attribute__((unused))) /* {{{ */
         || ((now.tv_sec == next_flush.tv_sec)
           && ((1000 * now.tv_usec) > next_flush.tv_nsec)))
     {
-      time_t time_now;
+      callback_flush_data_t cfd;
+      size_t k;
 
+      memset (&cfd, 0, sizeof (cfd));
       /* Pass the current time as user data so that we don't need to call
        * `time' for each node. */
-      time_now = time (NULL);
+      cfd.now = time (NULL);
+      cfd.keys = NULL;
+      cfd.keys_num = 0;
+
+      /* `tree_callback_flush' will return the keys of all values that haven't
+       * been touched in the last `config_flush_interval' seconds in `cfd'.
+       * The char*'s in this array point to the same memory as ci->file, so we
+       * don't need to free them separately. */
+      g_tree_foreach (cache_tree, tree_callback_flush, (gpointer) &cfd);
 
-      g_tree_foreach (cache_tree, tree_callback_flush, (gpointer) &time_now);
+      for (k = 0; k < cfd.keys_num; k++)
+      {
+        /* This must not fail. */
+        ci = (cache_item_t *) g_tree_lookup (cache_tree, cfd.keys[k]);
+        assert (ci != NULL);
+
+        /* If we end up here with values available, something's seriously
+         * messed up. */
+        assert (ci->values_num == 0);
+
+        /* Remove the node from the tree */
+        g_tree_remove (cache_tree, cfd.keys[k]);
+        cfd.keys[k] = NULL;
+
+        /* Now free and clean up `ci'. */
+        free (ci->file);
+        ci->file = NULL;
+        free (ci);
+        ci = NULL;
+      } /* for (k = 0; k < cfd.keys_num; k++) */
+
+      if (cfd.keys != NULL)
+      {
+        free (cfd.keys);
+        cfd.keys = NULL;
+      }
 
       /* Determine the time of the next cache flush. */
       while (next_flush.tv_sec < now.tv_sec)
@@ -287,10 +539,12 @@ static void *queue_thread_main (void *args __attribute__((unused))) /* {{{ */
       cache_queue_tail = NULL;
     ci->next = NULL;
 
-    pthread_mutex_unlock (&cache_lock);
+    pthread_mutex_lock (&stats_lock);
+    assert (stats_queue_length > 0);
+    stats_queue_length--;
+    pthread_mutex_unlock (&stats_lock);
 
-    RRDD_LOG (LOG_DEBUG, "queue_thread_main: rrd_update (%s, %i, %p)",
-        file, values_num, (void *) values);
+    pthread_mutex_unlock (&cache_lock);
 
     status = rrd_update_r (file, NULL, values_num, (void *) values);
     if (status != 0)
@@ -304,21 +558,320 @@ static void *queue_thread_main (void *args __attribute__((unused))) /* {{{ */
     for (i = 0; i < values_num; i++)
       free (values[i]);
 
+    pthread_mutex_lock (&stats_lock);
+    stats_updates_written++;
+    stats_data_sets_written += values_num;
+    pthread_mutex_unlock (&stats_lock);
+
     pthread_mutex_lock (&cache_lock);
+    pthread_cond_broadcast (&flush_cond);
   } /* while (do_shutdown == 0) */
   pthread_mutex_unlock (&cache_lock);
 
-  RRDD_LOG (LOG_DEBUG, "queue_thread_main: Exiting.");
-
   return (NULL);
 } /* }}} void *queue_thread_main */
 
+static int buffer_get_field (char **buffer_ret, /* {{{ */
+    size_t *buffer_size_ret, char **field_ret)
+{
+  char *buffer;
+  size_t buffer_pos;
+  size_t buffer_size;
+  char *field;
+  size_t field_size;
+  int status;
+
+  buffer = *buffer_ret;
+  buffer_pos = 0;
+  buffer_size = *buffer_size_ret;
+  field = *buffer_ret;
+  field_size = 0;
+
+  if (buffer_size <= 0)
+    return (-1);
+
+  /* This is ensured by `handle_request'. */
+  assert (buffer[buffer_size - 1] == ' ');
+
+  status = -1;
+  while (buffer_pos < buffer_size)
+  {
+    /* Check for end-of-field or end-of-buffer */
+    if (buffer[buffer_pos] == ' ')
+    {
+      field[field_size] = 0;
+      field_size++;
+      buffer_pos++;
+      status = 0;
+      break;
+    }
+    /* Handle escaped characters. */
+    else if (buffer[buffer_pos] == '\\')
+    {
+      if (buffer_pos >= (buffer_size - 1))
+        break;
+      buffer_pos++;
+      field[field_size] = buffer[buffer_pos];
+      field_size++;
+      buffer_pos++;
+    }
+    /* Normal operation */ 
+    else
+    {
+      field[field_size] = buffer[buffer_pos];
+      field_size++;
+      buffer_pos++;
+    }
+  } /* while (buffer_pos < buffer_size) */
+
+  if (status != 0)
+    return (status);
+
+  *buffer_ret = buffer + buffer_pos;
+  *buffer_size_ret = buffer_size - buffer_pos;
+  *field_ret = field;
+
+  return (0);
+} /* }}} int buffer_get_field */
+
+static int flush_file (const char *filename) /* {{{ */
+{
+  cache_item_t *ci;
+
+  pthread_mutex_lock (&cache_lock);
+
+  ci = (cache_item_t *) g_tree_lookup (cache_tree, filename);
+  if (ci == NULL)
+  {
+    pthread_mutex_unlock (&cache_lock);
+    return (ENOENT);
+  }
+
+  /* Enqueue at head */
+  enqueue_cache_item (ci, HEAD);
+  pthread_cond_signal (&cache_cond);
+
+  while ((ci->flags & CI_FLAGS_IN_QUEUE) != 0)
+  {
+    ci = NULL;
+
+    pthread_cond_wait (&flush_cond, &cache_lock);
+
+    ci = g_tree_lookup (cache_tree, filename);
+    if (ci == NULL)
+    {
+      RRDD_LOG (LOG_ERR, "flush_file: Tree node went away "
+          "while waiting for flush.");
+      pthread_mutex_unlock (&cache_lock);
+      return (-1);
+    }
+  }
+
+  pthread_mutex_unlock (&cache_lock);
+  return (0);
+} /* }}} int flush_file */
+
+static int handle_request_help (int fd, /* {{{ */
+    char *buffer, size_t buffer_size)
+{
+  int status;
+  char **help_text;
+  size_t help_text_len;
+  char *command;
+  size_t i;
+
+  char *help_help[] =
+  {
+    "4 Command overview\n",
+    "FLUSH <filename>\n",
+    "HELP [<command>]\n",
+    "UPDATE <filename> <values> [<values> ...]\n",
+    "STATS\n"
+  };
+  size_t help_help_len = sizeof (help_help) / sizeof (help_help[0]);
+
+  char *help_flush[] =
+  {
+    "4 Help for FLUSH\n",
+    "Usage: FLUSH <filename>\n",
+    "\n",
+    "Adds the given filename to the head of the update queue and returns\n",
+    "after is has been dequeued.\n"
+  };
+  size_t help_flush_len = sizeof (help_flush) / sizeof (help_flush[0]);
+
+  char *help_update[] =
+  {
+    "9 Help for UPDATE\n",
+    "Usage: UPDATE <filename> <values> [<values> ...]\n"
+    "\n",
+    "Adds the given file to the internal cache if it is not yet known and\n",
+    "appends the given value(s) to the entry. See the rrdcached(1) manpage\n",
+    "for details.\n",
+    "\n",
+    "Each <values> has the following form:\n",
+    "  <values> = <time>:<value>[:<value>[...]]\n",
+    "See the rrdupdate(1) manpage for details.\n"
+  };
+  size_t help_update_len = sizeof (help_update) / sizeof (help_update[0]);
+
+  char *help_stats[] =
+  {
+    "4 Help for STATS\n",
+    "Usage: STATS\n",
+    "\n",
+    "Returns some performance counters, see the rrdcached(1) manpage for\n",
+    "a description of the values.\n"
+  };
+  size_t help_stats_len = sizeof (help_stats) / sizeof (help_stats[0]);
+
+  status = buffer_get_field (&buffer, &buffer_size, &command);
+  if (status != 0)
+  {
+    help_text = help_help;
+    help_text_len = help_help_len;
+  }
+  else
+  {
+    if (strcasecmp (command, "update") == 0)
+    {
+      help_text = help_update;
+      help_text_len = help_update_len;
+    }
+    else if (strcasecmp (command, "flush") == 0)
+    {
+      help_text = help_flush;
+      help_text_len = help_flush_len;
+    }
+    else if (strcasecmp (command, "stats") == 0)
+    {
+      help_text = help_stats;
+      help_text_len = help_stats_len;
+    }
+    else
+    {
+      help_text = help_help;
+      help_text_len = help_help_len;
+    }
+  }
+
+  for (i = 0; i < help_text_len; i++)
+  {
+    status = swrite (fd, help_text[i], strlen (help_text[i]));
+    if (status < 0)
+    {
+      status = errno;
+      RRDD_LOG (LOG_ERR, "handle_request_help: swrite returned an error.");
+      return (status);
+    }
+  }
+
+  return (0);
+} /* }}} int handle_request_help */
+
+static int handle_request_stats (int fd, /* {{{ */
+    char *buffer __attribute__((unused)),
+    size_t buffer_size __attribute__((unused)))
+{
+  int status;
+  char outbuf[4096];
+
+  uint64_t copy_queue_length;
+  uint64_t copy_updates_written;
+  uint64_t copy_data_sets_written;
+
+  uint64_t tree_nodes_number;
+  uint64_t tree_depth;
+
+  pthread_mutex_lock (&stats_lock);
+  copy_queue_length       = stats_queue_length;
+  copy_updates_written    = stats_updates_written;
+  copy_data_sets_written  = stats_data_sets_written;
+  pthread_mutex_unlock (&stats_lock);
+
+  pthread_mutex_lock (&cache_lock);
+  tree_nodes_number = (uint64_t) g_tree_nnodes (cache_tree);
+  tree_depth        = (uint64_t) g_tree_height (cache_tree);
+  pthread_mutex_unlock (&cache_lock);
+
+#define RRDD_STATS_SEND \
+  outbuf[sizeof (outbuf) - 1] = 0; \
+  status = swrite (fd, outbuf, strlen (outbuf)); \
+  if (status < 0) \
+  { \
+    status = errno; \
+    RRDD_LOG (LOG_INFO, "handle_request_stats: swrite returned an error."); \
+    return (status); \
+  }
+
+  strncpy (outbuf, "5 Statistics follow\n", sizeof (outbuf));
+  RRDD_STATS_SEND;
+
+  snprintf (outbuf, sizeof (outbuf),
+      "QueueLength: %"PRIu64"\n", copy_queue_length);
+  RRDD_STATS_SEND;
+
+  snprintf (outbuf, sizeof (outbuf),
+      "UpdatesWritten: %"PRIu64"\n", copy_updates_written);
+  RRDD_STATS_SEND;
+
+  snprintf (outbuf, sizeof (outbuf),
+      "DataSetsWritten: %"PRIu64"\n", copy_data_sets_written);
+  RRDD_STATS_SEND;
+
+  snprintf (outbuf, sizeof (outbuf),
+      "TreeNodesNumber: %"PRIu64"\n", tree_nodes_number);
+  RRDD_STATS_SEND;
+
+  snprintf (outbuf, sizeof (outbuf),
+      "TreeDepth: %"PRIu64"\n", tree_depth);
+  RRDD_STATS_SEND;
+
+  return (0);
+#undef RRDD_STATS_SEND
+} /* }}} int handle_request_stats */
+
+static int handle_request_flush (int fd, /* {{{ */
+    char *buffer, size_t buffer_size)
+{
+  char *file;
+  int status;
+  char result[4096];
+
+  status = buffer_get_field (&buffer, &buffer_size, &file);
+  if (status != 0)
+  {
+    strncpy (result, "-1 Usage: flush <filename>\n", sizeof (result));
+  }
+  else
+  {
+    status = flush_file (file);
+    if (status == 0)
+      snprintf (result, sizeof (result), "0 Successfully flushed %s.\n", file);
+    else if (status == ENOENT)
+      snprintf (result, sizeof (result), "-1 No such file: %s.\n", file);
+    else if (status < 0)
+      strncpy (result, "-1 Internal error.\n", sizeof (result));
+    else
+      snprintf (result, sizeof (result), "-1 Failed with status %i.\n", status);
+  }
+  result[sizeof (result) - 1] = 0;
+
+  status = swrite (fd, result, strlen (result));
+  if (status < 0)
+  {
+    status = errno;
+    RRDD_LOG (LOG_INFO, "handle_request_flush: swrite returned an error.");
+    return (status);
+  }
+
+  return (0);
+} /* }}} int handle_request_flush */
+
 static int handle_request_update (int fd, /* {{{ */
-    char *buffer, int buffer_size __attribute__((unused)))
+    char *buffer, size_t buffer_size)
 {
   char *file;
-  char *value;
-  char *buffer_ptr;
   int values_num = 0;
   int status;
 
@@ -327,24 +880,41 @@ static int handle_request_update (int fd, /* {{{ */
   cache_item_t *ci;
   char answer[4096];
 
-  now = time (NULL);
+#define RRDD_UPDATE_SEND \
+  answer[sizeof (answer) - 1] = 0; \
+  status = swrite (fd, answer, strlen (answer)); \
+  if (status < 0) \
+  { \
+    status = errno; \
+    RRDD_LOG (LOG_INFO, "handle_request_update: swrite returned an error."); \
+    return (status); \
+  }
 
-  buffer_ptr = buffer;
+  now = time (NULL);
 
-  file = buffer_ptr;
-  buffer_ptr += strlen (file) + 1;
+  status = buffer_get_field (&buffer, &buffer_size, &file);
+  if (status != 0)
+  {
+    strncpy (answer, "-1 Usage: UPDATE <filename> <values> [<values> ...]\n",
+        sizeof (answer));
+    RRDD_UPDATE_SEND;
+    return (0);
+  }
 
   pthread_mutex_lock (&cache_lock);
 
   ci = g_tree_lookup (cache_tree, file);
-  if (ci == NULL)
+  if (ci == NULL) /* {{{ */
   {
     ci = (cache_item_t *) malloc (sizeof (cache_item_t));
     if (ci == NULL)
     {
       pthread_mutex_unlock (&cache_lock);
       RRDD_LOG (LOG_ERR, "handle_request_update: malloc failed.");
-      return (-1);
+
+      strncpy (answer, "-1 malloc failed.\n", sizeof (answer));
+      RRDD_UPDATE_SEND;
+      return (0);
     }
     memset (ci, 0, sizeof (cache_item_t));
 
@@ -352,9 +922,12 @@ static int handle_request_update (int fd, /* {{{ */
     if (ci->file == NULL)
     {
       pthread_mutex_unlock (&cache_lock);
-      RRDD_LOG (LOG_ERR, "handle_request_update: malloc failed.");
       free (ci);
-      return (-1);
+      RRDD_LOG (LOG_ERR, "handle_request_update: strdup failed.");
+
+      strncpy (answer, "-1 strdup failed.\n", sizeof (answer));
+      RRDD_UPDATE_SEND;
+      return (0);
     }
 
     ci->values = NULL;
@@ -363,18 +936,20 @@ static int handle_request_update (int fd, /* {{{ */
     ci->flags = CI_FLAGS_IN_TREE;
 
     g_tree_insert (cache_tree, (void *) ci->file, (void *) ci);
-
-    RRDD_LOG (LOG_DEBUG, "handle_request_update: Created new tree node %s.",
-        ci->file);
-  }
+  } /* }}} */
   assert (ci != NULL);
 
-  while (*buffer_ptr != 0)
+  while (buffer_size > 0)
   {
     char **temp;
+    char *value;
 
-    value = buffer_ptr;
-    buffer_ptr += strlen (value) + 1;
+    status = buffer_get_field (&buffer, &buffer_size, &value);
+    if (status != 0)
+    {
+      RRDD_LOG (LOG_INFO, "handle_request_update: Error reading field.");
+      break;
+    }
 
     temp = (char **) realloc (ci->values,
         sizeof (char *) * (ci->values_num + 1));
@@ -397,60 +972,96 @@ static int handle_request_update (int fd, /* {{{ */
   }
 
   if (((now - ci->last_flush_time) >= config_write_interval)
-      && ((ci->flags & CI_FLAGS_IN_QUEUE) == 0))
+      && ((ci->flags & CI_FLAGS_IN_QUEUE) == 0)
+      && (ci->values_num > 0))
   {
-    enqueue_cache_item (ci);
+    enqueue_cache_item (ci, TAIL);
     pthread_cond_signal (&cache_cond);
   }
 
   pthread_mutex_unlock (&cache_lock);
 
-  snprintf (answer, sizeof (answer), "0 Enqueued %i value(s)\n", values_num);
-  answer[sizeof (answer) - 1] = 0;
-
-  status = write (fd, answer, sizeof (answer));
-  if (status < 0)
+  if (values_num < 1)
   {
-    status = errno;
-    RRDD_LOG (LOG_INFO, "handle_request_update: write(2) returned an error.");
-    return (status);
+    strncpy (answer, "-1 No values updated.\n", sizeof (answer));
   }
-
+  else
+  {
+    snprintf (answer, sizeof (answer), "0 Enqueued %i value%s\n", values_num,
+        (values_num == 1) ? "" : "s");
+  }
+  RRDD_UPDATE_SEND;
   return (0);
+#undef RRDD_UPDATE_SEND
 } /* }}} int handle_request_update */
 
 static int handle_request (int fd) /* {{{ */
 {
   char buffer[4096];
-  int buffer_size;
+  size_t buffer_size;
+  char *buffer_ptr;
+  char *command;
+  int status;
 
-  buffer_size = read (fd, buffer, sizeof (buffer));
-  if (buffer_size < 1)
+  status = (int) sread (fd, buffer, sizeof (buffer));
+  if (status == 0)
+  {
+    return (1);
+  }
+  else if (status < 0)
   {
-    RRDD_LOG (LOG_ERR, "handle_request: read(2) failed.");
+    RRDD_LOG (LOG_ERR, "handle_request: sread failed.");
     return (-1);
   }
-  assert (((size_t) buffer_size) <= sizeof (buffer));
+  buffer_size = (size_t) status;
+  assert (buffer_size <= sizeof (buffer));
+  assert (buffer[buffer_size - 1] == 0);
+
+  /* Place the normal field separator at the end to simplify
+   * `buffer_get_field's work. */
+  buffer[buffer_size - 1] = ' ';
 
-  if ((buffer[buffer_size - 2] != 0)
-      || (buffer[buffer_size - 1] != 0))
+  buffer_ptr = buffer;
+  command = NULL;
+  status = buffer_get_field (&buffer_ptr, &buffer_size, &command);
+  if (status != 0)
   {
-    RRDD_LOG (LOG_INFO, "handle_request: malformed request.");
+    RRDD_LOG (LOG_INFO, "handle_request: Unable parse command.");
     return (-1);
   }
 
-  /* fields in the buffer a separated by null bytes. */
-  if (strcmp (buffer, "update") == 0)
+  if (strcasecmp (command, "update") == 0)
   {
-    int offset = strlen ("update") + 1;
-    return (handle_request_update (fd, buffer + offset,
-          buffer_size - offset));
+    return (handle_request_update (fd, buffer_ptr, buffer_size));
+  }
+  else if (strcasecmp (command, "flush") == 0)
+  {
+    return (handle_request_flush (fd, buffer_ptr, buffer_size));
+  }
+  else if (strcasecmp (command, "stats") == 0)
+  {
+    return (handle_request_stats (fd, buffer_ptr, buffer_size));
+  }
+  else if (strcasecmp (command, "help") == 0)
+  {
+    return (handle_request_help (fd, buffer_ptr, buffer_size));
   }
   else
   {
-    RRDD_LOG (LOG_INFO, "handle_request: unknown command: %s.", buffer);
-    return (-1);
+    char result[4096];
+
+    snprintf (result, sizeof (result), "-1 Unknown command: %s\n", command);
+    result[sizeof (result) - 1] = 0;
+
+    status = swrite (fd, result, strlen (result));
+    if (status < 0)
+    {
+      RRDD_LOG (LOG_ERR, "handle_request: swrite failed.");
+      return (-1);
+    }
   }
+
+  return (0);
 } /* }}} int handle_request */
 
 static void *connection_thread_main (void *args /* {{{ */
@@ -626,7 +1237,7 @@ static int open_listen_socket (const char *addr) /* {{{ */
   ai_hints.ai_socktype = SOCK_STREAM;
 
   ai_res = NULL;
-  status = getaddrinfo (addr, DEFAULT_PORT, &ai_hints, &ai_res);
+  status = getaddrinfo (addr, RRDCACHED_DEFAULT_PORT, &ai_hints, &ai_res);
   if (status != 0)
   {
     RRDD_LOG (LOG_ERR, "open_listen_socket: getaddrinfo(%s) failed: "
@@ -707,14 +1318,10 @@ static void *listen_thread_main (void *args __attribute__((unused))) /* {{{ */
   int i;
 
   for (i = 0; i < config_listen_address_list_len; i++)
-  {
-    RRDD_LOG (LOG_DEBUG, "listen_thread_main: config_listen_address_list[%i] "
-        "= %s", i, config_listen_address_list[i]);
     open_listen_socket (config_listen_address_list[i]);
-  }
 
   if (config_listen_address_list_len < 1)
-    open_listen_socket (RRDD_SOCK_PATH);
+    open_listen_socket (RRDCACHED_DEFAULT_ADDRESS);
 
   if (listen_fds_num < 1)
   {
@@ -814,8 +1421,6 @@ static void *listen_thread_main (void *args __attribute__((unused))) /* {{{ */
   }
   pthread_mutex_unlock (&connetion_threads_lock);
 
-  RRDD_LOG (LOG_DEBUG, "listen_thread_main: Exiting.");
-
   return (NULL);
 } /* }}} void *listen_thread_main */
 
@@ -823,6 +1428,13 @@ static int daemonize (void) /* {{{ */
 {
   pid_t child;
   int status;
+  char *base_dir;
+
+  /* These structures are static, because `sigaction' behaves weird if the are
+   * overwritten.. */
+  static struct sigaction sa_int;
+  static struct sigaction sa_term;
+  static struct sigaction sa_pipe;
 
   child = fork ();
   if (child < 0)
@@ -836,7 +1448,15 @@ static int daemonize (void) /* {{{ */
   }
 
   /* Change into the /tmp directory. */
-  chdir ("/tmp");
+  base_dir = (config_base_dir != NULL)
+    ? config_base_dir
+    : "/tmp";
+  status = chdir (base_dir);
+  if (status != 0)
+  {
+    fprintf (stderr, "daemonize: chdir (%s) failed.\n", base_dir);
+    return (-1);
+  }
 
   /* Become session leader */
   setsid ();
@@ -850,23 +1470,20 @@ static int daemonize (void) /* {{{ */
   dup (0);
   dup (0);
 
-  {
-    struct sigaction sa;
-
-    memset (&sa, 0, sizeof (sa));
-    sa.sa_handler = sig_int_handler;
-    sigaction (SIGINT, &sa, NULL);
+  /* Install signal handlers */
+  memset (&sa_int, 0, sizeof (sa_int));
+  sa_int.sa_handler = sig_int_handler;
+  sigaction (SIGINT, &sa_int, NULL);
 
-    memset (&sa, 0, sizeof (sa));
-    sa.sa_handler = sig_term_handler;
-    sigaction (SIGINT, &sa, NULL);
+  memset (&sa_term, 0, sizeof (sa_term));
+  sa_term.sa_handler = sig_term_handler;
+  sigaction (SIGTERM, &sa_term, NULL);
 
-    memset (&sa, 0, sizeof (sa));
-    sa.sa_handler = SIG_IGN;
-    sigaction (SIGPIPE, &sa, NULL);
-  }
+  memset (&sa_pipe, 0, sizeof (sa_pipe));
+  sa_pipe.sa_handler = SIG_IGN;
+  sigaction (SIGPIPE, &sa_pipe, NULL);
 
-  openlog ("rrdd", LOG_PID, LOG_DAEMON);
+  openlog ("rrdcached", LOG_PID, LOG_DAEMON);
 
   cache_tree = g_tree_new ((GCompareFunc) strcmp);
   if (cache_tree == NULL)
@@ -884,19 +1501,19 @@ static int daemonize (void) /* {{{ */
     return (-1);
   }
 
+  write_pidfile ();
+
   return (0);
 } /* }}} int daemonize */
 
 static int cleanup (void) /* {{{ */
 {
-  RRDD_LOG (LOG_DEBUG, "cleanup ()");
-
   do_shutdown++;
 
-  RRDD_LOG (LOG_DEBUG, "cleanup: Joining queue_thread..");
   pthread_cond_signal (&cache_cond);
   pthread_join (queue_thread, /* return = */ NULL);
-  RRDD_LOG (LOG_DEBUG, "cleanup: done");
+
+  remove_pidfile ();
 
   closelog ();
 
@@ -908,7 +1525,7 @@ static int read_options (int argc, char **argv) /* {{{ */
   int option;
   int status = 0;
 
-  while ((option = getopt(argc, argv, "l:f:w:h?")) != -1)
+  while ((option = getopt(argc, argv, "l:f:w:b:p:h?")) != -1)
   {
     switch (option)
     {
@@ -965,20 +1582,63 @@ static int read_options (int argc, char **argv) /* {{{ */
       }
       break;
 
+      case 'b':
+      {
+        size_t len;
+
+        if (config_base_dir != NULL)
+          free (config_base_dir);
+        config_base_dir = strdup (optarg);
+        if (config_base_dir == NULL)
+        {
+          fprintf (stderr, "read_options: strdup failed.\n");
+          return (3);
+        }
+
+        len = strlen (config_base_dir);
+        while ((len > 0) && (config_base_dir[len - 1] == '/'))
+        {
+          config_base_dir[len - 1] = 0;
+          len--;
+        }
+
+        if (len < 1)
+        {
+          fprintf (stderr, "Invalid base directory: %s\n", optarg);
+          return (4);
+        }
+      }
+      break;
+
+      case 'p':
+      {
+        if (config_pid_file != NULL)
+          free (config_pid_file);
+        config_pid_file = strdup (optarg);
+        if (config_pid_file == NULL)
+        {
+          fprintf (stderr, "read_options: strdup failed.\n");
+          return (3);
+        }
+      }
+      break;
+
       case 'h':
       case '?':
         printf ("RRDd %s  Copyright (C) 2008 Florian octo Forster\n"
             "\n"
-            "Usage: rrdd [options]\n"
+            "Usage: rrdcached [options]\n"
             "\n"
             "Valid options are:\n"
             "  -l <address>  Socket address to listen to.\n"
             "  -w <seconds>  Interval in which to write data.\n"
             "  -f <seconds>  Interval in which to flush dead data.\n"
+            "  -p <file>     Location of the PID-file.\n"
+            "  -b <dir>      Base directory to change to.\n"
             "\n"
             "For more information and a detailed description of all options "
             "please refer\n"
-            "to the rrdd(1) manual page.\n",
+            "to the rrdcached(1) manual page.\n",
             VERSION);
         status = -1;
         break;