*
* Authors:
* Florian octo Forster <octo at verplant.org>
+ * Sebastian tokkee Harl <sh at tokkee.org>
**/
#include "rrd.h"
-#include "rrd_client.h"
#include "rrd_tool.h"
+#include "rrd_client.h"
+#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <strings.h>
#include <errno.h>
#include <assert.h>
#include <pthread.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netdb.h>
+#include <limits.h>
#ifndef ENODATA
#define ENODATA ENOENT
static FILE *sh = NULL;
static char *sd_path = NULL; /* cache the path for sd */
+/* get_path: Return a path name appropriate to be sent to the daemon.
+ *
+ * When talking to a local daemon (thru a UNIX socket), relative path names
+ * are resolved to absolute path names to allow for transparent integration
+ * into existing solutions (as requested by Tobi). Else, absolute path names
+ * are not allowed, since path name translation is done by the server.
+ *
+ * One must hold `lock' when calling this function. */
+static const char *get_path (const char *path, char *resolved_path) /* {{{ */
+{
+ const char *ret = path;
+ int is_unix = 0;
+
+ if ((*sd_path == '/')
+ || (strncmp ("unix:", sd_path, strlen ("unix:")) == 0))
+ is_unix = 1;
+
+ if (*path == '/') /* absolute path */
+ {
+ if (! is_unix)
+ {
+ rrd_set_error ("absolute path names not allowed when talking "
+ "to a remote daemon");
+ return (NULL);
+ }
+ /* else: nothing to do */
+ }
+ else /* relative path */
+ {
+ if (is_unix)
+ {
+ realpath (path, resolved_path);
+ ret = resolved_path;
+ }
+ /* else: nothing to do */
+ }
+ return (ret);
+} /* }}} char *get_path */
+
/* One must hold `lock' when calling `close_connection'. */
static void close_connection (void) /* {{{ */
{
int status;
rrdc_response_t *res;
- pthread_mutex_lock (&lock);
-
if (sh == NULL)
- {
- pthread_mutex_unlock (&lock);
return (ENOTCONN);
- }
status = (int) fwrite (buffer, buffer_size, /* nmemb = */ 1, sh);
if (status != 1)
{
close_connection ();
- pthread_mutex_unlock (&lock);
rrd_set_error("request: socket error (%d) while talking to rrdcached",
status);
return (-1);
res = NULL;
status = response_read (&res);
- pthread_mutex_unlock (&lock);
-
if (status != 0)
{
if (status < 0)
rrd_set_error("garbage after address: %s", port);
return (-1);
}
- } /* if (*addr = ']') */
- else if (strchr (addr, '.') != NULL) /* Hostname or IPv4 */
+ } /* if (*addr == '[') */
+ else
{
port = rindex(addr, ':');
if (port != NULL)
port == NULL ? RRDCACHED_DEFAULT_PORT : port,
&ai_hints, &ai_res);
if (status != 0)
- return (status);
+ {
+ rrd_set_error ("failed to resolve address `%s' (port %s): %s",
+ addr, port == NULL ? RRDCACHED_DEFAULT_PORT : port,
+ gai_strerror (status));
+ return (-1);
+ }
for (ai_ptr = ai_res; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
close_connection();
}
+ rrd_clear_error ();
if (strncmp ("unix:", addr, strlen ("unix:")) == 0)
status = rrdc_connect_unix (addr + strlen ("unix:"));
else if (addr[0] == '/')
if (status == 0 && sd >= 0)
sd_path = strdup(addr);
else
+ {
+ char *err = rrd_test_error () ? rrd_get_error () : "Internal error";
+ /* err points the string that gets written to by rrd_set_error(), thus we
+ * cannot pass it to that function */
+ err = strdup (err);
rrd_set_error("Unable to connect to rrdcached: %s",
(status < 0)
- ? "Internal error"
+ ? (err ? err : "Internal error")
: rrd_strerror (status));
+ if (err != NULL)
+ free (err);
+ }
pthread_mutex_unlock (&lock);
return (status);
rrdc_response_t *res;
int status;
int i;
+ char file_path[PATH_MAX];
memset (buffer, 0, sizeof (buffer));
buffer_ptr = &buffer[0];
if (status != 0)
return (ENOBUFS);
+ pthread_mutex_lock (&lock);
+ filename = get_path (filename, file_path);
+ if (filename == NULL)
+ {
+ pthread_mutex_unlock (&lock);
+ return (-1);
+ }
+
status = buffer_add_string (filename, &buffer_ptr, &buffer_free);
if (status != 0)
+ {
+ pthread_mutex_unlock (&lock);
return (ENOBUFS);
+ }
for (i = 0; i < values_num; i++)
{
status = buffer_add_value (values[i], &buffer_ptr, &buffer_free);
if (status != 0)
+ {
+ pthread_mutex_unlock (&lock);
return (ENOBUFS);
+ }
}
assert (buffer_free < sizeof (buffer));
res = NULL;
status = request (buffer, buffer_size, &res);
+ pthread_mutex_unlock (&lock);
+
if (status != 0)
return (status);
size_t buffer_size;
rrdc_response_t *res;
int status;
+ char file_path[PATH_MAX];
if (filename == NULL)
return (-1);
if (status != 0)
return (ENOBUFS);
+ pthread_mutex_lock (&lock);
+ filename = get_path (filename, file_path);
+ if (filename == NULL)
+ {
+ pthread_mutex_unlock (&lock);
+ return (-1);
+ }
+
status = buffer_add_string (filename, &buffer_ptr, &buffer_free);
if (status != 0)
+ {
+ pthread_mutex_unlock (&lock);
return (ENOBUFS);
+ }
assert (buffer_free < sizeof (buffer));
buffer_size = sizeof (buffer) - buffer_free;
res = NULL;
status = request (buffer, buffer_size, &res);
+ pthread_mutex_unlock (&lock);
+
if (status != 0)
return (status);
if (rrdc_is_connected(opt_daemon))
{
+ rrd_clear_error();
status = rrdc_flush (filename);
- if (status != 0)
+
+ if (status != 0 && !rrd_test_error())
{
- rrd_set_error ("rrdc_flush (%s) failed with status %i.",
- filename, status);
+ if (status > 0)
+ {
+ rrd_set_error("rrdc_flush (%s) failed: %s",
+ filename, rrd_strerror(status));
+ }
+ else if (status < 0)
+ {
+ rrd_set_error("rrdc_flush (%s) failed with status %i.",
+ filename, status);
+ }
}
} /* if (rrdc_is_connected(..)) */
* }}} */
res = NULL;
+ pthread_mutex_lock (&lock);
status = request ("STATS\n", strlen ("STATS\n"), &res);
+ pthread_mutex_unlock (&lock);
+
if (status != 0)
return (status);