src/rrd_client.c

   1 /**
   2  * RRDTool - src/rrd_client.c
   3  * Copyright (C) 2008-2010  Florian octo Forster
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy
   6  * of this software and associated documentation files (the "Software"), to
   7  * deal in the Software without restriction, including without limitation the
   8  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   9  * sell copies of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *   Florian octo Forster <octo at verplant.org>
  25  *   Sebastian tokkee Harl <sh at tokkee.org>
  26  **/
  27
  28 #include "rrd.h"
  29 #include "rrd_tool.h"
  30 #include "rrd_client.h"
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <strings.h>
  36 #include <errno.h>
  37 #include <assert.h>
  38 #include <pthread.h>
  39 #include <sys/types.h>
  40 #include <sys/socket.h>
  41 #include <sys/un.h>
  42 #include <netdb.h>
  43 #include <limits.h>
  44
  45 #ifndef ENODATA
  46 #define ENODATA ENOENT
  47 #endif
  48
  49 struct rrdc_response_s
  50 {
  51   int status;
  52   char *message;
  53   char **lines;
  54   size_t lines_num;
  55 };
  56 typedef struct rrdc_response_s rrdc_response_t;
  57
  58 static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
  59 static int sd = -1;
  60 static FILE *sh = NULL;
  61 static char *sd_path = NULL; /* cache the path for sd */
  62
  63 /* get_path: Return a path name appropriate to be sent to the daemon.
  64  *
  65  * When talking to a local daemon (thru a UNIX socket), relative path names
  66  * are resolved to absolute path names to allow for transparent integration
  67  * into existing solutions (as requested by Tobi). Else, absolute path names
  68  * are not allowed, since path name translation is done by the server.
  69  *
  70  * One must hold `lock' when calling this function. */
  71 static const char *get_path (const char *path, char *resolved_path) /* {{{ */
  72 {
  73   const char *ret = path;
  74   int is_unix = 0;
  75
  76   if ((path == NULL) || (resolved_path == NULL) || (sd_path == NULL))
  77     return (NULL);
  78
  79   if ((*sd_path == '/')
  80       || (strncmp ("unix:", sd_path, strlen ("unix:")) == 0))
  81     is_unix = 1;
  82
  83   if (is_unix)
  84   {
  85     ret = realpath(path, resolved_path);
  86     if (ret == NULL)
  87       rrd_set_error("realpath(%s): %s", path, rrd_strerror(errno));
  88     return ret;
  89   }
  90   else
  91   {
  92     if (*path == '/') /* not absolute path */
  93     {
  94       rrd_set_error ("absolute path names not allowed when talking "
  95           "to a remote daemon");
  96       return NULL;
  97     }
  98   }
  99
 100   return path;
 101 } /* }}} char *get_path */
 102
 103 static size_t strsplit (char *string, char **fields, size_t size) /* {{{ */
 104 {
 105   size_t i;
 106   char *ptr;
 107   char *saveptr;
 108
 109   i = 0;
 110   ptr = string;
 111   saveptr = NULL;
 112   while ((fields[i] = strtok_r (ptr, " \t\r\n", &saveptr)) != NULL)
 113   {
 114     ptr = NULL;
 115     i++;
 116
 117     if (i >= size)
 118       break;
 119   }
 120
 121   return (i);
 122 } /* }}} size_t strsplit */
 123
 124 static int parse_header (char *line, /* {{{ */
 125     char **ret_key, char **ret_value)
 126 {
 127   char *tmp;
 128
 129   *ret_key = line;
 130
 131   tmp = strchr (line, ':');
 132   if (tmp == NULL)
 133     return (-1);
 134
 135   do
 136   {
 137     *tmp = 0;
 138     tmp++;
 139   }
 140   while ((tmp[0] == ' ') || (tmp[0] == '\t'));
 141
 142   if (*tmp == 0)
 143     return (-1);
 144
 145   *ret_value = tmp;
 146   return (0);
 147 } /* }}} int parse_header */
 148
 149 static int parse_ulong_header (char *line, /* {{{ */
 150     char **ret_key, unsigned long *ret_value)
 151 {
 152   char *str_value;
 153   char *endptr;
 154   int status;
 155
 156   str_value = NULL;
 157   status = parse_header (line, ret_key, &str_value);
 158   if (status != 0)
 159     return (status);
 160
 161   endptr = NULL;
 162   errno = 0;
 163   *ret_value = (unsigned long) strtol (str_value, &endptr, /* base = */ 0);
 164   if ((endptr == str_value) || (errno != 0))
 165     return (-1);
 166
 167   return (0);
 168 } /* }}} int parse_ulong_header */
 169
 170 static int parse_char_array_header (char *line, /* {{{ */
 171     char **ret_key, char **array, size_t array_len, int alloc)
 172 {
 173   char *tmp_array[array_len];
 174   char *value;
 175   size_t num;
 176   int status;
 177
 178   value = NULL;
 179   status = parse_header (line, ret_key, &value);
 180   if (status != 0)
 181     return (-1);
 182
 183   num = strsplit (value, tmp_array, array_len);
 184   if (num != array_len)
 185     return (-1);
 186
 187   if (alloc == 0)
 188   {
 189     memcpy (array, tmp_array, sizeof (tmp_array));
 190   }
 191   else
 192   {
 193     size_t i;
 194
 195     for (i = 0; i < array_len; i++)
 196       array[i] = strdup (tmp_array[i]);
 197   }
 198
 199   return (0);
 200 } /* }}} int parse_char_array_header */
 201
 202 static int parse_value_array_header (char *line, /* {{{ */
 203     time_t *ret_time, rrd_value_t *array, size_t array_len)
 204 {
 205   char *str_key;
 206   char *str_array[array_len];
 207   char *endptr;
 208   int status;
 209   size_t i;
 210
 211   str_key = NULL;
 212   status = parse_char_array_header (line, &str_key,
 213       str_array, array_len, /* alloc = */ 0);
 214   if (status != 0)
 215     return (-1);
 216
 217   errno = 0;
 218   endptr = NULL;
 219   *ret_time = (time_t) strtol (str_key, &endptr, /* base = */ 10);
 220   if ((endptr == str_key) || (errno != 0))
 221     return (-1);
 222
 223   for (i = 0; i < array_len; i++)
 224   {
 225     endptr = NULL;
 226     array[i] = (rrd_value_t) strtod (str_array[i], &endptr);
 227     if ((endptr == str_array[i]) || (errno != 0))
 228       return (-1);
 229   }
 230
 231   return (0);
 232 } /* }}} int parse_value_array_header */
 233
 234 /* One must hold `lock' when calling `close_connection'. */
 235 static void close_connection (void) /* {{{ */
 236 {
 237   if (sh != NULL)
 238   {
 239     fclose (sh);
 240     sh = NULL;
 241     sd = -1;
 242   }
 243   else if (sd >= 0)
 244   {
 245     close (sd);
 246     sd = -1;
 247   }
 248
 249   if (sd_path != NULL)
 250     free (sd_path);
 251   sd_path = NULL;
 252 } /* }}} void close_connection */
 253
 254 static int buffer_add_string (const char *str, /* {{{ */
 255     char **buffer_ret, size_t *buffer_size_ret)
 256 {
 257   char *buffer;
 258   size_t buffer_size;
 259   size_t buffer_pos;
 260   size_t i;
 261   int status;
 262
 263   buffer = *buffer_ret;
 264   buffer_size = *buffer_size_ret;
 265   buffer_pos = 0;
 266
 267   i = 0;
 268   status = -1;
 269   while (buffer_pos < buffer_size)
 270   {
 271     if (str[i] == 0)
 272     {
 273       buffer[buffer_pos] = ' ';
 274       buffer_pos++;
 275       status = 0;
 276       break;
 277     }
 278     else if ((str[i] == ' ') || (str[i] == '\\'))
 279     {
 280       if (buffer_pos >= (buffer_size - 1))
 281         break;
 282       buffer[buffer_pos] = '\\';
 283       buffer_pos++;
 284       buffer[buffer_pos] = str[i];
 285       buffer_pos++;
 286     }
 287     else
 288     {
 289       buffer[buffer_pos] = str[i];
 290       buffer_pos++;
 291     }
 292     i++;
 293   } /* while (buffer_pos < buffer_size) */
 294
 295   if (status != 0)
 296     return (-1);
 297
 298   *buffer_ret = buffer + buffer_pos;
 299   *buffer_size_ret = buffer_size - buffer_pos;
 300
 301   return (0);
 302 } /* }}} int buffer_add_string */
 303
 304 static int buffer_add_value (const char *value, /* {{{ */
 305     char **buffer_ret, size_t *buffer_size_ret)
 306 {
 307   char temp[RRD_CMD_MAX];
 308
 309   if (strncmp (value, "N:", 2) == 0)
 310     snprintf (temp, sizeof (temp), "%lu:%s",
 311         (unsigned long) time (NULL), value + 2);
 312   else
 313     strncpy (temp, value, sizeof (temp));
 314   temp[sizeof (temp) - 1] = 0;
 315
 316   return (buffer_add_string (temp, buffer_ret, buffer_size_ret));
 317 } /* }}} int buffer_add_value */
 318
 319 static int buffer_add_ulong (const unsigned long value, /* {{{ */
 320     char **buffer_ret, size_t *buffer_size_ret)
 321 {
 322   char temp[RRD_CMD_MAX];
 323
 324   snprintf (temp, sizeof (temp), "%lu", value);
 325   temp[sizeof (temp) - 1] = 0;
 326   return (buffer_add_string (temp, buffer_ret, buffer_size_ret));
 327 } /* }}} int buffer_add_ulong */
 328
 329 /* Remove trailing newline (NL) and carriage return (CR) characters. Similar to
 330  * the Perl function `chomp'. Returns the number of characters that have been
 331  * removed. */
 332 static int chomp (char *str) /* {{{ */
 333 {
 334   size_t len;
 335   int removed;
 336
 337   if (str == NULL)
 338     return (-1);
 339
 340   len = strlen (str);
 341   removed = 0;
 342   while ((len > 0) && ((str[len - 1] == '\n') || (str[len - 1] == '\r')))
 343   {
 344     str[len - 1] = 0;
 345     len--;
 346     removed++;
 347   }
 348
 349   return (removed);
 350 } /* }}} int chomp */
 351
 352 static void response_free (rrdc_response_t *res) /* {{{ */
 353 {
 354   if (res == NULL)
 355     return;
 356
 357   if (res->lines != NULL)
 358   {
 359     size_t i;
 360
 361     for (i = 0; i < res->lines_num; i++)
 362       if (res->lines[i] != NULL)
 363         free (res->lines[i]);
 364     free (res->lines);
 365   }
 366
 367   free (res);
 368 } /* }}} void response_free */
 369
 370 static int response_read (rrdc_response_t **ret_response) /* {{{ */
 371 {
 372   rrdc_response_t *ret = NULL;
 373   int status = 0;
 374
 375   char buffer[RRD_CMD_MAX];
 376   char *buffer_ptr;
 377
 378   size_t i;
 379
 380 #define DIE(code) do { status = code; goto err_out; } while(0)
 381
 382   if (sh == NULL)
 383     DIE(-1);
 384
 385   ret = (rrdc_response_t *) malloc (sizeof (rrdc_response_t));
 386   if (ret == NULL)
 387     DIE(-2);
 388   memset (ret, 0, sizeof (*ret));
 389   ret->lines = NULL;
 390   ret->lines_num = 0;
 391
 392   buffer_ptr = fgets (buffer, sizeof (buffer), sh);
 393   if (buffer_ptr == NULL)
 394     DIE(-3);
 395
 396   chomp (buffer);
 397
 398   ret->status = strtol (buffer, &ret->message, 0);
 399   if (buffer == ret->message)
 400     DIE(-4);
 401
 402   /* Skip leading whitespace of the status message */
 403   ret->message += strspn (ret->message, " \t");
 404
 405   if (ret->status <= 0)
 406   {
 407     if (ret->status < 0)
 408       rrd_set_error("rrdcached: %s", ret->message);
 409     goto out;
 410   }
 411
 412   ret->lines = (char **) malloc (sizeof (char *) * ret->status);
 413   if (ret->lines == NULL)
 414     DIE(-5);
 415
 416   memset (ret->lines, 0, sizeof (char *) * ret->status);
 417   ret->lines_num = (size_t) ret->status;
 418
 419   for (i = 0; i < ret->lines_num; i++)
 420   {
 421     buffer_ptr = fgets (buffer, sizeof (buffer), sh);
 422     if (buffer_ptr == NULL)
 423       DIE(-6);
 424
 425     chomp (buffer);
 426
 427     ret->lines[i] = strdup (buffer);
 428     if (ret->lines[i] == NULL)
 429       DIE(-7);
 430   }
 431
 432 out:
 433   *ret_response = ret;
 434   fflush(sh);
 435   return (status);
 436
 437 err_out:
 438   response_free(ret);
 439   close_connection();
 440   return (status);
 441
 442 #undef DIE
 443
 444 } /* }}} rrdc_response_t *response_read */
 445
 446 static int request (const char *buffer, size_t buffer_size, /* {{{ */
 447     rrdc_response_t **ret_response)
 448 {
 449   int status;
 450   rrdc_response_t *res;
 451
 452   if (sh == NULL)
 453     return (ENOTCONN);
 454
 455   status = (int) fwrite (buffer, buffer_size, /* nmemb = */ 1, sh);
 456   if (status != 1)
 457   {
 458     close_connection ();
 459     rrd_set_error("request: socket error (%d) while talking to rrdcached",
 460                   status);
 461     return (-1);
 462   }
 463   fflush (sh);
 464
 465   res = NULL;
 466   status = response_read (&res);
 467
 468   if (status != 0)
 469   {
 470     if (status < 0)
 471       rrd_set_error("request: internal error while talking to rrdcached");
 472     return (status);
 473   }
 474
 475   *ret_response = res;
 476   return (0);
 477 } /* }}} int request */
 478
 479 /* determine whether we are connected to the specified daemon_addr if
 480  * NULL, return whether we are connected at all
 481  */
 482 int rrdc_is_connected(const char *daemon_addr) /* {{{ */
 483 {
 484   if (sd < 0)
 485     return 0;
 486   else if (daemon_addr == NULL)
 487   {
 488     char *addr = getenv(ENV_RRDCACHED_ADDRESS);
 489     /* here we have to handle the case i.e.
 490      *   UPDATE --daemon ...; UPDATEV (no --daemon) ...
 491      * In other words: we have a cached connection,
 492      * but it is not specified in the current command.
 493      * Daemon is only implied in this case if set in ENV
 494      */
 495     if (addr != NULL && ! strcmp(addr,""))
 496       return 1;
 497     else
 498       return 0;
 499   }
 500   else if (strcmp(daemon_addr, sd_path) == 0)
 501     return 1;
 502   else
 503     return 0;
 504
 505 } /* }}} int rrdc_is_connected */
 506
 507 static int rrdc_connect_unix (const char *path) /* {{{ */
 508 {
 509   struct sockaddr_un sa;
 510   int status;
 511
 512   assert (path != NULL);
 513   assert (sd == -1);
 514
 515   sd = socket (PF_UNIX, SOCK_STREAM, /* protocol = */ 0);
 516   if (sd < 0)
 517   {
 518     status = errno;
 519     return (status);
 520   }
 521
 522   memset (&sa, 0, sizeof (sa));
 523   sa.sun_family = AF_UNIX;
 524   strncpy (sa.sun_path, path, sizeof (sa.sun_path) - 1);
 525
 526   status = connect (sd, (struct sockaddr *) &sa, sizeof (sa));
 527   if (status != 0)
 528   {
 529     status = errno;
 530     close_connection ();
 531     return (status);
 532   }
 533
 534   sh = fdopen (sd, "r+");
 535   if (sh == NULL)
 536   {
 537     status = errno;
 538     close_connection ();
 539     return (status);
 540   }
 541
 542   return (0);
 543 } /* }}} int rrdc_connect_unix */
 544
 545 static int rrdc_connect_network (const char *addr_orig) /* {{{ */
 546 {
 547   struct addrinfo ai_hints;
 548   struct addrinfo *ai_res;
 549   struct addrinfo *ai_ptr;
 550   char addr_copy[NI_MAXHOST];
 551   char *addr;
 552   char *port;
 553
 554   assert (addr_orig != NULL);
 555   assert (sd == -1);
 556
 557   strncpy(addr_copy, addr_orig, sizeof(addr_copy));
 558   addr_copy[sizeof(addr_copy) - 1] = '\0';
 559   addr = addr_copy;
 560
 561   int status;
 562   memset (&ai_hints, 0, sizeof (ai_hints));
 563   ai_hints.ai_flags = 0;
 564 #ifdef AI_ADDRCONFIG
 565   ai_hints.ai_flags |= AI_ADDRCONFIG;
 566 #endif
 567   ai_hints.ai_family = AF_UNSPEC;
 568   ai_hints.ai_socktype = SOCK_STREAM;
 569
 570   port = NULL;
 571   if (*addr == '[') /* IPv6+port format */
 572   {
 573     /* `addr' is something like "[2001:780:104:2:211:24ff:feab:26f8]:12345" */
 574     addr++;
 575
 576     port = strchr (addr, ']');
 577     if (port == NULL)
 578     {
 579       rrd_set_error("malformed address: %s", addr_orig);
 580       return (-1);
 581     }
 582     *port = 0;
 583     port++;
 584
 585     if (*port == ':')
 586       port++;
 587     else if (*port == 0)
 588       port = NULL;
 589     else
 590     {
 591       rrd_set_error("garbage after address: %s", port);
 592       return (-1);
 593     }
 594   } /* if (*addr == '[') */
 595   else
 596   {
 597     port = rindex(addr, ':');
 598     if (port != NULL)
 599     {
 600       *port = 0;
 601       port++;
 602     }
 603   }
 604
 605   ai_res = NULL;
 606   status = getaddrinfo (addr,
 607                         port == NULL ? RRDCACHED_DEFAULT_PORT : port,
 608                         &ai_hints, &ai_res);
 609   if (status != 0)
 610   {
 611     rrd_set_error ("failed to resolve address `%s' (port %s): %s",
 612         addr, port == NULL ? RRDCACHED_DEFAULT_PORT : port,
 613         gai_strerror (status));
 614     return (-1);
 615   }
 616
 617   for (ai_ptr = ai_res; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
 618   {
 619     sd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol);
 620     if (sd < 0)
 621     {
 622       status = errno;
 623       sd = -1;
 624       continue;
 625     }
 626
 627     status = connect (sd, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
 628     if (status != 0)
 629     {
 630       status = errno;
 631       close_connection();
 632       continue;
 633     }
 634
 635     sh = fdopen (sd, "r+");
 636     if (sh == NULL)
 637     {
 638       status = errno;
 639       close_connection ();
 640       continue;
 641     }
 642
 643     assert (status == 0);
 644     break;
 645   } /* for (ai_ptr) */
 646
 647   freeaddrinfo(ai_res);
 648
 649   return (status);
 650 } /* }}} int rrdc_connect_network */
 651
 652 int rrdc_connect (const char *addr) /* {{{ */
 653 {
 654   int status = 0;
 655
 656   if (addr == NULL)
 657     addr = getenv (ENV_RRDCACHED_ADDRESS);
 658
 659   if (addr == NULL || ! strcmp(addr,""))
 660     addr = NULL;
 661     return 0;
 662
 663   pthread_mutex_lock(&lock);
 664
 665   if (sd >= 0 && sd_path != NULL && strcmp(addr, sd_path) == 0)
 666   {
 667     /* connection to the same daemon; use cached connection */
 668     pthread_mutex_unlock (&lock);
 669     return (0);
 670   }
 671   else
 672   {
 673     close_connection();
 674   }
 675
 676   rrd_clear_error ();
 677   if (strncmp ("unix:", addr, strlen ("unix:")) == 0)
 678     status = rrdc_connect_unix (addr + strlen ("unix:"));
 679   else if (addr[0] == '/')
 680     status = rrdc_connect_unix (addr);
 681   else
 682     status = rrdc_connect_network(addr);
 683
 684   if (status == 0 && sd >= 0)
 685     sd_path = strdup(addr);
 686   else
 687   {
 688     char *err = rrd_test_error () ? rrd_get_error () : "Internal error";
 689     /* err points the string that gets written to by rrd_set_error(), thus we
 690      * cannot pass it to that function */
 691     err = strdup (err);
 692     rrd_set_error("Unable to connect to rrdcached: %s",
 693                   (status < 0)
 694                   ? (err ? err : "Internal error")
 695                   : rrd_strerror (status));
 696     if (err != NULL)
 697       free (err);
 698   }
 699
 700   pthread_mutex_unlock (&lock);
 701   return (status);
 702 } /* }}} int rrdc_connect */
 703
 704 int rrdc_disconnect (void) /* {{{ */
 705 {
 706   pthread_mutex_lock (&lock);
 707
 708   close_connection();
 709
 710   pthread_mutex_unlock (&lock);
 711
 712   return (0);
 713 } /* }}} int rrdc_disconnect */
 714
 715 int rrdc_update (const char *filename, int values_num, /* {{{ */
 716                 const char * const *values)
 717 {
 718   char buffer[RRD_CMD_MAX];
 719   char *buffer_ptr;
 720   size_t buffer_free;
 721   size_t buffer_size;
 722   rrdc_response_t *res;
 723   int status;
 724   int i;
 725   char file_path[PATH_MAX];
 726
 727   memset (buffer, 0, sizeof (buffer));
 728   buffer_ptr = &buffer[0];
 729   buffer_free = sizeof (buffer);
 730
 731   status = buffer_add_string ("update", &buffer_ptr, &buffer_free);
 732   if (status != 0)
 733     return (ENOBUFS);
 734
 735   pthread_mutex_lock (&lock);
 736   filename = get_path (filename, file_path);
 737   if (filename == NULL)
 738   {
 739     pthread_mutex_unlock (&lock);
 740     return (-1);
 741   }
 742
 743   status = buffer_add_string (filename, &buffer_ptr, &buffer_free);
 744   if (status != 0)
 745   {
 746     pthread_mutex_unlock (&lock);
 747     return (ENOBUFS);
 748   }
 749
 750   for (i = 0; i < values_num; i++)
 751   {
 752     status = buffer_add_value (values[i], &buffer_ptr, &buffer_free);
 753     if (status != 0)
 754     {
 755       pthread_mutex_unlock (&lock);
 756       return (ENOBUFS);
 757     }
 758   }
 759
 760   assert (buffer_free < sizeof (buffer));
 761   buffer_size = sizeof (buffer) - buffer_free;
 762   assert (buffer[buffer_size - 1] == ' ');
 763   buffer[buffer_size - 1] = '\n';
 764
 765   res = NULL;
 766   status = request (buffer, buffer_size, &res);
 767   pthread_mutex_unlock (&lock);
 768
 769   if (status != 0)
 770     return (status);
 771
 772   status = res->status;
 773   response_free (res);
 774
 775   return (status);
 776 } /* }}} int rrdc_update */
 777
 778 int rrdc_flush (const char *filename) /* {{{ */
 779 {
 780   char buffer[RRD_CMD_MAX];
 781   char *buffer_ptr;
 782   size_t buffer_free;
 783   size_t buffer_size;
 784   rrdc_response_t *res;
 785   int status;
 786   char file_path[PATH_MAX];
 787
 788   if (filename == NULL)
 789     return (-1);
 790
 791   memset (buffer, 0, sizeof (buffer));
 792   buffer_ptr = &buffer[0];
 793   buffer_free = sizeof (buffer);
 794
 795   status = buffer_add_string ("flush", &buffer_ptr, &buffer_free);
 796   if (status != 0)
 797     return (ENOBUFS);
 798
 799   pthread_mutex_lock (&lock);
 800   filename = get_path (filename, file_path);
 801   if (filename == NULL)
 802   {
 803     pthread_mutex_unlock (&lock);
 804     return (-1);
 805   }
 806
 807   status = buffer_add_string (filename, &buffer_ptr, &buffer_free);
 808   if (status != 0)
 809   {
 810     pthread_mutex_unlock (&lock);
 811     return (ENOBUFS);
 812   }
 813
 814   assert (buffer_free < sizeof (buffer));
 815   buffer_size = sizeof (buffer) - buffer_free;
 816   assert (buffer[buffer_size - 1] == ' ');
 817   buffer[buffer_size - 1] = '\n';
 818
 819   res = NULL;
 820   status = request (buffer, buffer_size, &res);
 821   pthread_mutex_unlock (&lock);
 822
 823   if (status != 0)
 824     return (status);
 825
 826   status = res->status;
 827   response_free (res);
 828
 829   return (status);
 830 } /* }}} int rrdc_flush */
 831
 832 rrd_info_t * rrdc_info (const char *filename) /* {{{ */
 833 {
 834   char buffer[RRD_CMD_MAX];
 835   char *buffer_ptr;
 836   size_t buffer_free;
 837   size_t buffer_size;
 838   rrdc_response_t *res;
 839   int status;
 840   char file_path[PATH_MAX];
 841   rrd_info_t *data = NULL, *cd;
 842   rrd_infoval_t info;
 843   unsigned int l;
 844   rrd_info_type_t itype;
 845   char *k, *s;
 846
 847   if (filename == NULL) {
 848     rrd_set_error ("rrdc_info: no filename");
 849     return (NULL);
 850   }
 851
 852   memset (buffer, 0, sizeof (buffer));
 853   buffer_ptr = &buffer[0];
 854   buffer_free = sizeof (buffer);
 855
 856   status = buffer_add_string ("info", &buffer_ptr, &buffer_free);
 857   if (status != 0) {
 858     rrd_set_error ("rrdc_info: out of memory");
 859     return (NULL);
 860   }
 861
 862   pthread_mutex_lock (&lock);
 863   filename = get_path (filename, file_path);
 864   if (filename == NULL)
 865   {
 866     pthread_mutex_unlock (&lock);
 867     return (NULL);
 868   }
 869
 870   status = buffer_add_string (filename, &buffer_ptr, &buffer_free);
 871   if (status != 0)
 872   {
 873     pthread_mutex_unlock (&lock);
 874     rrd_set_error ("rrdc_info: out of memory");
 875     return (NULL);
 876   }
 877
 878   assert (buffer_free < sizeof (buffer));
 879   buffer_size = sizeof (buffer) - buffer_free;
 880   assert (buffer[buffer_size - 1] == ' ');
 881   buffer[buffer_size - 1] = '\n';
 882
 883   res = NULL;
 884   status = request (buffer, buffer_size, &res);
 885   pthread_mutex_unlock (&lock);
 886
 887   if (status != 0) {
 888     rrd_set_error ("rrdcached: %s", res->message);
 889     return (NULL);
 890   }
 891   data = cd = NULL;
 892   for( l=0 ; l < res->lines_num ; l++ ) {
 893     /* first extract the keyword */
 894         for(k = s = res->lines[l];s && *s;s++) {
 895       if(*s == ' ') { *s = 0; s++; break; }
 896         }
 897     if(!s || !*s) break;
 898         itype = atoi(s); /* extract type code */
 899         for(;*s;s++) { if(*s == ' ') { *s = 0; s++; break; } }
 900     if(!*s) break;
 901     /* finally, we're pointing to the value */
 902     switch(itype) {
 903     case RD_I_VAL:
 904         if(*s == 'N') { info.u_val = DNAN; } else { info.u_val = atof(s); }
 905         break;
 906     case RD_I_CNT:
 907         info.u_cnt = atol(s);
 908         break;
 909     case RD_I_INT:
 910         info.u_int = atoi(s);
 911         break;
 912     case RD_I_STR:
 913         chomp(s);
 914         info.u_str = (char*)malloc(sizeof(char) * (strlen(s) + 1));
 915         strcpy(info.u_str,s);
 916         break;
 917     case RD_I_BLO:
 918         rrd_set_error ("rrdc_info: BLOB objects are not supported");
 919         return (NULL);
 920     default:
 921         rrd_set_error ("rrdc_info: Unsupported info type %d",itype);
 922         return (NULL);
 923     }
 924
 925     cd = rrd_info_push(cd, sprintf_alloc("%s",k), itype, info);
 926         if(!data) data = cd;
 927   }
 928   response_free (res);
 929
 930   return (data);
 931 } /* }}} int rrdc_info */
 932
 933 time_t rrdc_last (const char *filename) /* {{{ */
 934 {
 935   char buffer[RRD_CMD_MAX];
 936   char *buffer_ptr;
 937   size_t buffer_free;
 938   size_t buffer_size;
 939   rrdc_response_t *res;
 940   int status;
 941   char file_path[PATH_MAX];
 942   time_t lastup;
 943
 944   if (filename == NULL) {
 945     rrd_set_error ("rrdc_last: no filename");
 946     return (-1);
 947   }
 948
 949   memset (buffer, 0, sizeof (buffer));
 950   buffer_ptr = &buffer[0];
 951   buffer_free = sizeof (buffer);
 952
 953   status = buffer_add_string ("last", &buffer_ptr, &buffer_free);
 954   if (status != 0) {
 955     rrd_set_error ("rrdc_last: out of memory");
 956     return (-1);
 957   }
 958
 959   pthread_mutex_lock (&lock);
 960   filename = get_path (filename, file_path);
 961   if (filename == NULL)
 962   {
 963     pthread_mutex_unlock (&lock);
 964     return (-1);
 965   }
 966
 967   status = buffer_add_string (filename, &buffer_ptr, &buffer_free);
 968   if (status != 0)
 969   {
 970     pthread_mutex_unlock (&lock);
 971     rrd_set_error ("rrdc_last: out of memory");
 972     return (-1);
 973   }
 974
 975   assert (buffer_free < sizeof (buffer));
 976   buffer_size = sizeof (buffer) - buffer_free;
 977   assert (buffer[buffer_size - 1] == ' ');
 978   buffer[buffer_size - 1] = '\n';
 979
 980   res = NULL;
 981   status = request (buffer, buffer_size, &res);
 982   pthread_mutex_unlock (&lock);
 983
 984   if (status != 0) {
 985     rrd_set_error ("rrdcached: %s", res->message);
 986     return (-1);
 987   }
 988   lastup = atol(res->message);
 989   response_free (res);
 990
 991   return (lastup);
 992 } /* }}} int rrdc_last */
 993
 994 time_t rrdc_first (const char *filename, int rraindex) /* {{{ */
 995 {
 996   char buffer[RRD_CMD_MAX];
 997   char *buffer_ptr;
 998   size_t buffer_free;
 999   size_t buffer_size;
1000   rrdc_response_t *res;
1001   int status;
1002   char file_path[PATH_MAX];
1003   time_t firstup;
1004
1005   if (filename == NULL) {
1006     rrd_set_error ("rrdc_first: no filename specified");
1007     return (-1);
1008   }
1009
1010   memset (buffer, 0, sizeof (buffer));
1011   buffer_ptr = &buffer[0];
1012   buffer_free = sizeof (buffer);
1013
1014   status = buffer_add_string ("first", &buffer_ptr, &buffer_free);
1015   if (status != 0) {
1016     rrd_set_error ("rrdc_first: out of memory");
1017     return (-1);
1018   }
1019
1020   pthread_mutex_lock (&lock);
1021   filename = get_path (filename, file_path);
1022   if (filename == NULL)
1023   {
1024     pthread_mutex_unlock (&lock);
1025     return (-1);
1026   }
1027
1028   status = buffer_add_string (filename, &buffer_ptr, &buffer_free);
1029   if (status != 0)
1030   {
1031     pthread_mutex_unlock (&lock);
1032     rrd_set_error ("rrdc_first: out of memory");
1033     return (-1);
1034   }
1035   status = buffer_add_ulong (rraindex, &buffer_ptr, &buffer_free);
1036   if (status != 0)
1037   {
1038     pthread_mutex_unlock (&lock);
1039     rrd_set_error ("rrdc_first: out of memory");
1040     return (-1);
1041   }
1042
1043   assert (buffer_free < sizeof (buffer));
1044   buffer_size = sizeof (buffer) - buffer_free;
1045   assert (buffer[buffer_size - 1] == ' ');
1046   buffer[buffer_size - 1] = '\n';
1047
1048   res = NULL;
1049   status = request (buffer, buffer_size, &res);
1050   pthread_mutex_unlock (&lock);
1051
1052   if (status != 0) {
1053     rrd_set_error ("rrdcached: %s", res->message);
1054     return (-1);
1055   }
1056   firstup = atol(res->message);
1057   response_free (res);
1058
1059   return (firstup);
1060 } /* }}} int rrdc_first */
1061
1062 int rrdc_create (const char *filename, /* {{{ */
1063     unsigned long pdp_step,
1064     time_t last_up,
1065     int no_overwrite,
1066     int argc,
1067     const char **argv)
1068 {
1069   char buffer[RRD_CMD_MAX];
1070   char *buffer_ptr;
1071   size_t buffer_free;
1072   size_t buffer_size;
1073   rrdc_response_t *res;
1074   int status;
1075   char file_path[PATH_MAX];
1076   int i;
1077
1078   if (filename == NULL) {
1079     rrd_set_error ("rrdc_create: no filename specified");
1080     return (-1);
1081   }
1082
1083   memset (buffer, 0, sizeof (buffer));
1084   buffer_ptr = &buffer[0];
1085   buffer_free = sizeof (buffer);
1086
1087   status = buffer_add_string ("create", &buffer_ptr, &buffer_free);
1088   if (status != 0) {
1089     rrd_set_error ("rrdc_create: out of memory");
1090     return (-1);
1091   }
1092
1093   pthread_mutex_lock (&lock);
1094   filename = get_path (filename, file_path);
1095   if (filename == NULL)
1096   {
1097     pthread_mutex_unlock (&lock);
1098     return (-1);
1099   }
1100
1101   status = buffer_add_string (filename, &buffer_ptr, &buffer_free);
1102   status = buffer_add_string ("-b", &buffer_ptr, &buffer_free);
1103   status = buffer_add_ulong (last_up, &buffer_ptr, &buffer_free);
1104   status = buffer_add_string ("-s", &buffer_ptr, &buffer_free);
1105   status = buffer_add_ulong (pdp_step, &buffer_ptr, &buffer_free);
1106   if(no_overwrite) {
1107     status = buffer_add_string ("-O", &buffer_ptr, &buffer_free);
1108   }
1109   if (status != 0)
1110   {
1111     pthread_mutex_unlock (&lock);
1112     rrd_set_error ("rrdc_create: out of memory");
1113     return (-1);
1114   }
1115
1116   for( i=0; i<argc; i++ ) {
1117     if( argv[i] ) {
1118       status = buffer_add_string (argv[i], &buffer_ptr, &buffer_free);
1119       if (status != 0)
1120       {
1121         pthread_mutex_unlock (&lock);
1122         rrd_set_error ("rrdc_create: out of memory");
1123         return (-1);
1124       }
1125         }
1126   }
1127
1128   /* buffer ready to send? */
1129   assert (buffer_free < sizeof (buffer));
1130   buffer_size = sizeof (buffer) - buffer_free;
1131   assert (buffer[buffer_size - 1] == ' ');
1132   buffer[buffer_size - 1] = '\n';
1133
1134   res = NULL;
1135   status = request (buffer, buffer_size, &res);
1136   pthread_mutex_unlock (&lock);
1137
1138   if (status != 0) {
1139     rrd_set_error ("rrdcached: %s", res->message);
1140     return (-1);
1141   }
1142   response_free (res);
1143   return(0);
1144 } /* }}} int rrdc_create */
1145
1146 int rrdc_fetch (const char *filename, /* {{{ */
1147     const char *cf,
1148     time_t *ret_start, time_t *ret_end,
1149     unsigned long *ret_step,
1150     unsigned long *ret_ds_num,
1151     char ***ret_ds_names,
1152     rrd_value_t **ret_data)
1153 {
1154   char buffer[RRD_CMD_MAX];
1155   char *buffer_ptr;
1156   size_t buffer_free;
1157   size_t buffer_size;
1158   rrdc_response_t *res;
1159   char path_buffer[PATH_MAX];
1160   const char *path_ptr;
1161
1162   char *str_tmp;
1163   unsigned long flush_version;
1164
1165   time_t start;
1166   time_t end;
1167   unsigned long step;
1168   unsigned long ds_num;
1169   char **ds_names;
1170
1171   rrd_value_t *data;
1172   size_t data_size;
1173   size_t data_fill;
1174
1175   int status;
1176   size_t current_line;
1177   time_t t;
1178
1179   if ((filename == NULL) || (cf == NULL))
1180     return (-1);
1181
1182   /* Send request {{{ */
1183   memset (buffer, 0, sizeof (buffer));
1184   buffer_ptr = &buffer[0];
1185   buffer_free = sizeof (buffer);
1186
1187   status = buffer_add_string ("FETCH", &buffer_ptr, &buffer_free);
1188   if (status != 0)
1189     return (ENOBUFS);
1190
1191   /* change to path for rrdcached */
1192   path_ptr = get_path (filename, path_buffer);
1193   if (path_ptr == NULL)
1194     return (EINVAL);
1195
1196   status = buffer_add_string (path_ptr, &buffer_ptr, &buffer_free);
1197   if (status != 0)
1198     return (ENOBUFS);
1199
1200   status = buffer_add_string (cf, &buffer_ptr, &buffer_free);
1201   if (status != 0)
1202     return (ENOBUFS);
1203
1204   if ((ret_start != NULL) && (*ret_start > 0))
1205   {
1206     char tmp[64];
1207     snprintf (tmp, sizeof (tmp), "%lu", (unsigned long) *ret_start);
1208     tmp[sizeof (tmp) - 1] = 0;
1209     status = buffer_add_string (tmp, &buffer_ptr, &buffer_free);
1210     if (status != 0)
1211       return (ENOBUFS);
1212
1213     if ((ret_end != NULL) && (*ret_end > 0))
1214     {
1215       snprintf (tmp, sizeof (tmp), "%lu", (unsigned long) *ret_end);
1216       tmp[sizeof (tmp) - 1] = 0;
1217       status = buffer_add_string (tmp, &buffer_ptr, &buffer_free);
1218       if (status != 0)
1219         return (ENOBUFS);
1220     }
1221   }
1222
1223   assert (buffer_free < sizeof (buffer));
1224   buffer_size = sizeof (buffer) - buffer_free;
1225   assert (buffer[buffer_size - 1] == ' ');
1226   buffer[buffer_size - 1] = '\n';
1227
1228   res = NULL;
1229   status = request (buffer, buffer_size, &res);
1230   if (status != 0)
1231     return (status);
1232
1233   status = res->status;
1234   if (status < 0)
1235   {
1236     rrd_set_error ("rrdcached: %s", res->message);
1237     response_free (res);
1238     return (status);
1239   }
1240   /* }}} Send request */
1241
1242   ds_names = NULL;
1243   ds_num = 0;
1244   data = NULL;
1245   current_line = 0;
1246
1247   /* Macros to make error handling a little easier (i. e. less to type and
1248    * read. `BAIL_OUT' sets the error message, frees all dynamically allocated
1249    * variables and returns the provided status code. */
1250 #define BAIL_OUT(status, ...) do { \
1251     rrd_set_error ("rrdc_fetch: " __VA_ARGS__); \
1252     free (data); \
1253     if (ds_names != 0) { size_t k; for (k = 0; k < ds_num; k++) free (ds_names[k]); } \
1254     free (ds_names); \
1255     response_free (res); \
1256     return (status); \
1257   } while (0)
1258
1259 #define READ_NUMERIC_FIELD(name,type,var) do { \
1260     char *key; \
1261     unsigned long value; \
1262     assert (current_line < res->lines_num); \
1263     status = parse_ulong_header (res->lines[current_line], &key, &value); \
1264     if (status != 0) \
1265       BAIL_OUT (-1, "Unable to parse header `%s'", name); \
1266     if (strcasecmp (key, name) != 0) \
1267       BAIL_OUT (-1, "Unexpected header line: Expected `%s', got `%s'", name, key); \
1268     var = (type) value; \
1269     current_line++; \
1270   } while (0)
1271
1272   if (res->lines_num < 1)
1273     BAIL_OUT (-1, "Premature end of response packet");
1274
1275   /* We're making some very strong assumptions about the fields below. We
1276    * therefore check the version of the `flush' command first, so that later
1277    * versions can change the order of fields and it's easier to implement
1278    * backwards compatibility. */
1279   READ_NUMERIC_FIELD ("FlushVersion", unsigned long, flush_version);
1280   if (flush_version != 1)
1281     BAIL_OUT (-1, "Don't know how to handle flush format version %lu.",
1282         flush_version);
1283
1284   if (res->lines_num < 5)
1285     BAIL_OUT (-1, "Premature end of response packet");
1286
1287   READ_NUMERIC_FIELD ("Start", time_t, start);
1288   READ_NUMERIC_FIELD ("End", time_t, end);
1289   if (start >= end)
1290     BAIL_OUT (-1, "Malformed start and end times: start = %lu; end = %lu;",
1291         (unsigned long) start,
1292         (unsigned long) end);
1293
1294   READ_NUMERIC_FIELD ("Step", unsigned long, step);
1295   if (step < 1)
1296     BAIL_OUT (-1, "Invalid number for Step: %lu", step);
1297
1298   READ_NUMERIC_FIELD ("DSCount", unsigned long, ds_num);
1299   if (ds_num < 1)
1300     BAIL_OUT (-1, "Invalid number for DSCount: %lu", ds_num);
1301
1302   /* It's time to allocate some memory */
1303   ds_names = calloc ((size_t) ds_num, sizeof (*ds_names));
1304   if (ds_names == NULL)
1305     BAIL_OUT (-1, "Out of memory");
1306
1307   status = parse_char_array_header (res->lines[current_line],
1308       &str_tmp, ds_names, (size_t) ds_num, /* alloc = */ 1);
1309   if (status != 0)
1310     BAIL_OUT (-1, "Unable to parse header `DSName'");
1311   if (strcasecmp ("DSName", str_tmp) != 0)
1312     BAIL_OUT (-1, "Unexpected header line: Expected `DSName', got `%s'", str_tmp);
1313   current_line++;
1314
1315   data_size = ds_num * (end - start) / step;
1316   if (data_size < 1)
1317     BAIL_OUT (-1, "No data returned or headers invalid.");
1318
1319   if (res->lines_num != (6 + (data_size / ds_num)))
1320     BAIL_OUT (-1, "Got %zu lines, expected %zu",
1321         res->lines_num, (6 + (data_size / ds_num)));
1322
1323   data = calloc (data_size, sizeof (*data));
1324   if (data == NULL)
1325     BAIL_OUT (-1, "Out of memory");
1326
1327
1328   data_fill = 0;
1329   for (t = start + step; t <= end; t += step, current_line++)
1330   {
1331     time_t tmp;
1332
1333     assert (current_line < res->lines_num);
1334
1335     status = parse_value_array_header (res->lines[current_line],
1336         &tmp, data + data_fill, (size_t) ds_num);
1337     if (status != 0)
1338       BAIL_OUT (-1, "Cannot parse value line");
1339
1340     data_fill += (size_t) ds_num;
1341   }
1342
1343   *ret_start = start;
1344   *ret_end = end;
1345   *ret_step = step;
1346   *ret_ds_num = ds_num;
1347   *ret_ds_names = ds_names;
1348   *ret_data = data;
1349
1350   response_free (res);
1351   return (0);
1352 #undef READ_NUMERIC_FIELD
1353 #undef BAIL_OUT
1354 } /* }}} int rrdc_flush */
1355
1356 /* convenience function; if there is a daemon specified, or if we can
1357  * detect one from the environment, then flush the file.  Otherwise, no-op
1358  */
1359 int rrdc_flush_if_daemon (const char *opt_daemon, const char *filename) /* {{{ */
1360 {
1361   int status = 0;
1362
1363   rrdc_connect(opt_daemon);
1364
1365   if (rrdc_is_connected(opt_daemon))
1366   {
1367     rrd_clear_error();
1368     status = rrdc_flush (filename);
1369
1370     if (status != 0 && !rrd_test_error())
1371     {
1372       if (status > 0)
1373       {
1374         rrd_set_error("rrdc_flush (%s) failed: %s",
1375                       filename, rrd_strerror(status));
1376       }
1377       else if (status < 0)
1378       {
1379         rrd_set_error("rrdc_flush (%s) failed with status %i.",
1380                       filename, status);
1381       }
1382     }
1383   } /* if (rrdc_is_connected(..)) */
1384
1385   return status;
1386 } /* }}} int rrdc_flush_if_daemon */
1387
1388
1389 int rrdc_stats_get (rrdc_stats_t **ret_stats) /* {{{ */
1390 {
1391   rrdc_stats_t *head;
1392   rrdc_stats_t *tail;
1393
1394   rrdc_response_t *res;
1395
1396   int status;
1397   size_t i;
1398
1399   /* Protocol example: {{{
1400    * ->  STATS
1401    * <-  5 Statistics follow
1402    * <-  QueueLength: 0
1403    * <-  UpdatesWritten: 0
1404    * <-  DataSetsWritten: 0
1405    * <-  TreeNodesNumber: 0
1406    * <-  TreeDepth: 0
1407    * }}} */
1408
1409   res = NULL;
1410   pthread_mutex_lock (&lock);
1411   status = request ("STATS\n", strlen ("STATS\n"), &res);
1412   pthread_mutex_unlock (&lock);
1413
1414   if (status != 0)
1415     return (status);
1416
1417   if (res->status <= 0)
1418   {
1419     response_free (res);
1420     return (EIO);
1421   }
1422
1423   head = NULL;
1424   tail = NULL;
1425   for (i = 0; i < res->lines_num; i++)
1426   {
1427     char *key;
1428     char *value;
1429     char *endptr;
1430     rrdc_stats_t *s;
1431
1432     key = res->lines[i];
1433     value = strchr (key, ':');
1434     if (value == NULL)
1435       continue;
1436     *value = 0;
1437     value++;
1438
1439     while ((value[0] == ' ') || (value[0] == '\t'))
1440       value++;
1441
1442     s = (rrdc_stats_t *) malloc (sizeof (rrdc_stats_t));
1443     if (s == NULL)
1444       continue;
1445     memset (s, 0, sizeof (*s));
1446
1447     s->name = strdup (key);
1448
1449     endptr = NULL;
1450     if ((strcmp ("QueueLength", key) == 0)
1451         || (strcmp ("TreeDepth", key) == 0)
1452         || (strcmp ("TreeNodesNumber", key) == 0))
1453     {
1454       s->type = RRDC_STATS_TYPE_GAUGE;
1455       s->value.gauge = strtod (value, &endptr);
1456     }
1457     else if ((strcmp ("DataSetsWritten", key) == 0)
1458         || (strcmp ("FlushesReceived", key) == 0)
1459         || (strcmp ("JournalBytes", key) == 0)
1460         || (strcmp ("JournalRotate", key) == 0)
1461         || (strcmp ("UpdatesReceived", key) == 0)
1462         || (strcmp ("UpdatesWritten", key) == 0))
1463     {
1464       s->type = RRDC_STATS_TYPE_COUNTER;
1465       s->value.counter = (uint64_t) strtoll (value, &endptr, /* base = */ 0);
1466     }
1467     else
1468     {
1469       free (s);
1470       continue;
1471     }
1472
1473     /* Conversion failed */
1474     if (endptr == value)
1475     {
1476       free (s);
1477       continue;
1478     }
1479
1480     if (head == NULL)
1481     {
1482       head = s;
1483       tail = s;
1484       s->next = NULL;
1485     }
1486     else
1487     {
1488       tail->next = s;
1489       tail = s;
1490     }
1491   } /* for (i = 0; i < res->lines_num; i++) */
1492
1493   response_free (res);
1494
1495   if (head == NULL)
1496     return (EPROTO);
1497
1498   *ret_stats = head;
1499   return (0);
1500 } /* }}} int rrdc_stats_get */
1501
1502 void rrdc_stats_free (rrdc_stats_t *ret_stats) /* {{{ */
1503 {
1504   rrdc_stats_t *this;
1505
1506   this = ret_stats;
1507   while (this != NULL)
1508   {
1509     rrdc_stats_t *next;
1510
1511     next = this->next;
1512
1513     if (this->name != NULL)
1514     {
1515       free ((char *)this->name);
1516       this->name = NULL;
1517     }
1518     free (this);
1519
1520     this = next;
1521   } /* while (this != NULL) */
1522 } /* }}} void rrdc_stats_free */
1523
1524 /*
1525  * vim: set sw=2 sts=2 ts=8 et fdm=marker :
1526  */