write_redis: remove unused variable from wr_write()

[collectd.git] / src / common.c

diff --git a/src/common.c b/src/common.c
index b771f62..c284942 100644 (file)
--- a/src/common.c
+++ b/src/common.c
@@ -86,6 +86,47 @@ int ssnprintf (char *dest, size_t n, const char *format, ...)
        return (ret);
 } /* int ssnprintf */
 
+char *ssnprintf_alloc (char const *format, ...) /* {{{ */
+{
+       char static_buffer[1024] = "";
+       char *alloc_buffer;
+       size_t alloc_buffer_size;
+       int status;
+       va_list ap;
+
+       /* Try printing into the static buffer. In many cases it will be
+        * sufficiently large and we can simply return a strdup() of this
+        * buffer. */
+       va_start (ap, format);
+       status = vsnprintf (static_buffer, sizeof (static_buffer), format, ap);
+       va_end (ap);
+       if (status < 0)
+               return (NULL);
+
+       /* "status" does not include the null byte. */
+       alloc_buffer_size = (size_t) (status + 1);
+       if (alloc_buffer_size <= sizeof (static_buffer))
+               return (strdup (static_buffer));
+
+       /* Allocate a buffer large enough to hold the string. */
+       alloc_buffer = malloc (alloc_buffer_size);
+       if (alloc_buffer == NULL)
+               return (NULL);
+       memset (alloc_buffer, 0, alloc_buffer_size);
+
+       /* Print again into this new buffer. */
+       va_start (ap, format);
+       status = vsnprintf (alloc_buffer, alloc_buffer_size, format, ap);
+       va_end (ap);
+       if (status < 0)
+       {
+               sfree (alloc_buffer);
+               return (NULL);
+       }
+
+       return (alloc_buffer);
+} /* }}} char *ssnprintf_alloc */
+
 char *sstrdup (const char *s)
 {
        char *r;
@@ -266,44 +307,51 @@ int strsplit (char *string, char **fields, size_t size)
        return ((int) i);
 }
 
-int strjoin (char *dst, size_t dst_len,
+int strjoin (char *buffer, size_t buffer_size,
                char **fields, size_t fields_num,
                const char *sep)
 {
-       size_t field_len;
+       size_t avail;
+       char *ptr;
        size_t sep_len;
-       int i;
-
-       memset (dst, '\0', dst_len);
+       size_t i;
 
-       if (fields_num <= 0)
+       if ((buffer_size < 1) || (fields_num <= 0))
                return (-1);
 
+       memset (buffer, 0, buffer_size);
+       ptr = buffer;
+       avail = buffer_size - 1;
+
        sep_len = 0;
        if (sep != NULL)
                sep_len = strlen (sep);
 
-       for (i = 0; i < (int)fields_num; i++)
+       for (i = 0; i < fields_num; i++)
        {
+               size_t field_len;
+
                if ((i > 0) && (sep_len > 0))
                {
-                       if (dst_len <= sep_len)
+                       if (avail < sep_len)
                                return (-1);
 
-                       strncat (dst, sep, dst_len);
-                       dst_len -= sep_len;
+                       memcpy (ptr, sep, sep_len);
+                       ptr += sep_len;
+                       avail -= sep_len;
                }
 
                field_len = strlen (fields[i]);
-
-               if (dst_len <= field_len)
+               if (avail < field_len)
                        return (-1);
 
-               strncat (dst, fields[i], dst_len);
-               dst_len -= field_len;
+               memcpy (ptr, fields[i], field_len);
+               ptr += field_len;
+               avail -= field_len;
        }
 
-       return (strlen (dst));
+       assert (buffer[buffer_size - 1] == 0);
+       return (strlen (buffer));
 }
 
 int strsubstitute (char *str, char c_from, char c_to)
@@ -397,7 +445,7 @@ int escape_slashes (char *buf, int buf_len)
        if (buf[0] == '/')
                memmove (buf, buf + 1, buf_len - 1);
 
-       for (i = 0; i < buf_len - 1; i++)
+       for (i = 0; i < buf_len; i++)
        {
                if (buf[i] == '\0')
                        break;
@@ -861,18 +909,17 @@ int format_values (char *ret, size_t ret_len, /* {{{ */
         for (i = 0; i < ds->ds_num; i++)
         {
                 if (ds->ds[i].type == DS_TYPE_GAUGE)
-                        BUFFER_ADD (":%f", vl->values[i].gauge);
+                        BUFFER_ADD (":"GAUGE_FORMAT, vl->values[i].gauge);
                 else if (store_rates)
                 {
                         if (rates == NULL)
                                 rates = uc_get_rate (ds, vl);
                         if (rates == NULL)
                         {
-                                WARNING ("format_values: "
-                                               "uc_get_rate failed.");
+                                WARNING ("format_values: uc_get_rate failed.");
                                 return (-1);
                         }
-                        BUFFER_ADD (":%g", rates[i]);
+                        BUFFER_ADD (":"GAUGE_FORMAT, rates[i]);
                 }
                 else if (ds->ds[i].type == DS_TYPE_COUNTER)
                         BUFFER_ADD (":%llu", vl->values[i].counter);
@@ -882,7 +929,7 @@ int format_values (char *ret, size_t ret_len, /* {{{ */
                         BUFFER_ADD (":%"PRIu64, vl->values[i].absolute);
                 else
                 {
-                        ERROR ("format_values plugin: Unknown data source type: %i",
+                        ERROR ("format_values: Unknown data source type: %i",
                                         ds->ds[i].type);
                         sfree (rates);
                         return (-1);
@@ -1220,18 +1267,25 @@ int walk_directory (const char *dir, dirwalk_callback_f callback,
        return (0);
 }
 
-int read_file_contents (const char *filename, char *buf, int bufsize)
+ssize_t read_file_contents (const char *filename, char *buf, size_t bufsize)
 {
        FILE *fh;
-       int n;
+       ssize_t ret;
 
-       if ((fh = fopen (filename, "r")) == NULL)
-               return -1;
+       fh = fopen (filename, "r");
+       if (fh == NULL)
+               return (-1);
 
-       n = fread(buf, 1, bufsize, fh);
-       fclose(fh);
+       ret = (ssize_t) fread (buf, 1, bufsize, fh);
+       if ((ret == 0) && (ferror (fh) != 0))
+       {
+               ERROR ("read_file_contents: Reading file \"%s\" failed.",
+                               filename);
+               ret = -1;
+       }
 
-       return n;
+       fclose(fh);
+       return (ret);
 }
 
 counter_t counter_diff (counter_t old_value, counter_t new_value)