/*****************************************************************************
- * RRDtool 1.2.23 Copyright by Tobi Oetiker, 1997-2007
+ * RRDtool 1.3.2 Copyright by Tobi Oetiker, 1997-2009
*****************************************************************************
- * rrd_restore.c creates new rrd from data dumped by rrd_dump.c
- *****************************************************************************/
+ * rrd_restore.c Contains logic to parse XML input and create an RRD file
+ * initial libxml2 version of rrd_restore (c) by Florian octo Forster
+ *****************************************************************************
+ * $Id$
+ *************************************************************************** */
-#include "rrd_tool.h"
-#include "rrd_rpncalc.h"
-#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <libxml/parser.h>
+#include <libxml/xmlreader.h>
+
+#ifndef WIN32
+# include <unistd.h> /* for off_t */
+#else
+ typedef size_t ssize_t;
+ typedef long off_t;
+#endif
+
+#include <fcntl.h>
#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
-#include <io.h>
-#define open _open
-#define close _close
+# include <io.h>
+# define open _open
+# define close _close
#endif
-/* Prototypes */
-
-void xml_lc(
- char *);
-int skip(
- char **);
-int skipxml(
- char **);
-int eat_tag(
- char **,
- char *);
-int read_tag(
- char **,
- char *,
- char *,
- void *);
-int xml2rrd(
- char *,
- rrd_t *,
- char);
-int rrd_creat(
- char *,
- rrd_t *,
- char);
-void parse_patch1028_RRA_params(
- char **buf,
- rrd_t *rrd,
- int rra_index);
-void parse_patch1028_CDP_params(
- char **buf,
- rrd_t *rrd,
- int rra_index,
- int ds_index);
-void parse_FAILURES_history(
- char **buf,
- rrd_t *rrd,
- int rra_index,
- int ds_index);
+#include "rrd_tool.h"
+#include "rrd_rpncalc.h"
-/* convert all occurrences of <BlaBlaBla> to <blablabla> */
+#define ARRAY_LENGTH(a) (sizeof (a) / sizeof ((a)[0]))
-void xml_lc(
- char *buf)
-{
- int intag = 0;
+static int opt_range_check = 0;
+static int opt_force_overwrite = 0;
+
+/*
+ * Helpers
+ */
- while ((*buf)) {
- if (intag == 0 && (*buf) == '<') {
- intag = 1;
- } else if (intag == 1 && (*buf) == '>') {
- intag = 0;
+/* skip all but tags. complain if we do not get the right tag */
+/* dept -1 causes depth to be ignored */
+static xmlChar* get_xml_element (
+ xmlTextReaderPtr reader
+ )
+{
+ while(xmlTextReaderRead(reader)){
+ int type;
+ xmlChar *name;
+ type = xmlTextReaderNodeType(reader);
+ if (type == XML_READER_TYPE_TEXT){
+ xmlChar *value;
+ value = xmlTextReaderValue(reader);
+ rrd_set_error("line %d: expected element but found text '%s'",
+ xmlTextReaderGetParserLineNumber(reader),value);
+ xmlFree(value);
+ return NULL;
+ }
+ /* skip all other non-elements */
+ if (type != XML_READER_TYPE_ELEMENT && type != XML_READER_TYPE_END_ELEMENT)
continue;
- } else if (intag == 1) {
- *buf = tolower(*buf);
+
+ name = xmlTextReaderName(reader);
+ if (type == XML_READER_TYPE_END_ELEMENT){
+ xmlChar *temp;
+ xmlChar *temp2;
+ temp = (xmlChar*)sprintf_alloc("/%s",name);
+ temp2 = xmlStrdup(temp);
+ free(temp);
+ xmlFree(name);
+ return temp2;
}
- buf++;
+ /* all seems well, return the happy news */
+ return name;
}
+ rrd_set_error("the xml ended while we were looking for an element");
+ return NULL;
+} /* get_xml_element */
+
+static void local_rrd_free (rrd_t *rrd)
+{
+ free(rrd->live_head);
+ free(rrd->stat_head);
+ free(rrd->ds_def);
+ free(rrd->rra_def);
+ free(rrd->rra_ptr);
+ free(rrd->pdp_prep);
+ free(rrd->cdp_prep);
+ free(rrd->rrd_value);
+ free(rrd);
}
-int skipxml(
- char **buf)
+
+static int expect_element (
+ xmlTextReaderPtr reader,
+ char *exp_name)
{
- char *ptr;
-
- ptr = (*buf);
- do {
- (*buf) = ptr;
- while ((*(ptr + 1))
- && ((*ptr) == ' ' || (*ptr) == '\r' || (*ptr) == '\n'
- || (*ptr) == '\t'))
- ptr++;
- if (strncmp(ptr, "<?xml", 4) == 0) {
- ptr = strstr(ptr, "?>");
- if (ptr)
- ptr += 2;
- else {
- rrd_set_error("Dangling XML header");
- (*buf) = NULL;
- return -1;
- }
- }
- } while ((*buf) != ptr);
- return 1;
-}
+ xmlChar *name;
+ name = get_xml_element(reader);
+ if (!name)
+ return -1;
+ if (xmlStrcasecmp(name,(xmlChar *)exp_name) != 0){
+ rrd_set_error("line %d: expected <%s> element but found <%s>",
+ xmlTextReaderGetParserLineNumber(reader),name,exp_name);
+ xmlFree(name);
+ return -1;
+ }
+ xmlFree(name);
+ return 0;
+} /* expect_element */
-int skip(
- char **buf)
+static int expect_element_end (
+ xmlTextReaderPtr reader,
+ char *exp_name)
{
- char *ptr;
+ xmlChar *name;
+ name = get_xml_element(reader);
+ if (name == NULL)
+ return -1;
+ if (xmlStrcasecmp(name+1,(xmlChar *)exp_name) != 0 || name[0] != '/'){
+ rrd_set_error("line %d: expected </%s> end element but found <%s>",
+ xmlTextReaderGetParserLineNumber(reader),exp_name,name);
+ xmlFree(name);
+ return -1;
+ }
+ xmlFree(name);
+ return 0;
+} /* expect_element_end */
- if ((buf == NULL) || (*buf == NULL))
- return -1;
- ptr = (*buf);
- do {
- (*buf) = ptr;
- while ((*(ptr + 1))
- && ((*ptr) == ' ' || (*ptr) == '\r' || (*ptr) == '\n'
- || (*ptr) == '\t'))
- ptr++;
- if (strncmp(ptr, "<!--", 4) == 0) {
- ptr = strstr(ptr, "-->");
- if (ptr)
- ptr += 3;
- else {
- rrd_set_error("Dangling Comment");
- (*buf) = NULL;
- return -1;
- }
- }
- } while ((*buf) != ptr);
- return 1;
-}
-int eat_tag(
- char **buf,
- char *tag)
+static xmlChar* get_xml_text (
+ xmlTextReaderPtr reader
+ )
{
- if ((*buf) == NULL)
- return -1; /* fall though clause */
-
- rrd_clear_error();
- skip(buf);
- if ((**buf) == '<'
- && strncmp((*buf) + 1, tag, strlen(tag)) == 0
- && *((*buf) + strlen(tag) + 1) == '>') {
- (*buf) += strlen(tag) + 2;
- } else {
- rrd_set_error("No <%s> tag found", tag);
- (*buf) = NULL;
- return -1;
+ while(xmlTextReaderRead(reader)){
+ xmlChar *ret;
+ xmlChar *text;
+ xmlChar *begin_ptr;
+ xmlChar *end_ptr;
+ int type;
+ type = xmlTextReaderNodeType(reader);
+ if (type == XML_READER_TYPE_ELEMENT){
+ xmlChar *name;
+ name = xmlTextReaderName(reader);
+ rrd_set_error("line %d: expected a value but found an <%s> element",
+ xmlTextReaderGetParserLineNumber(reader),
+ name);
+ xmlFree(name);
+ return NULL;
+ }
+ /* skip all other non-text */
+ if (xmlTextReaderNodeType(reader) != XML_READER_TYPE_TEXT)
+ continue;
+
+ text = xmlTextReaderValue(reader);
+
+ begin_ptr = text;
+ while ((begin_ptr[0] != 0) && (isspace(begin_ptr[0])))
+ begin_ptr++;
+ if (begin_ptr[0] == 0) {
+ xmlFree(text);
+ return xmlStrdup(BAD_CAST "");
+ }
+ end_ptr = begin_ptr;
+ while ((end_ptr[0] != 0) && (!isspace(end_ptr[0])))
+ end_ptr++;
+ end_ptr[0] = 0;
+
+ ret = xmlStrdup(begin_ptr);
+ xmlFree(text);
+ return ret;
}
- skip(buf);
- return 1;
-}
+ rrd_set_error("file ended while looking for text");
+ return NULL;
+} /* get_xml_text */
-int read_tag(
- char **buf,
- char *tag,
- char *format,
- void *value)
+
+static int get_xml_string(
+ xmlTextReaderPtr reader,
+ char *value,
+ int max_len)
{
- char *end_tag;
- int matches;
-
- if ((*buf) == NULL)
- return -1; /* fall though clause */
- rrd_clear_error();
- if (eat_tag(buf, tag) == 1) {
- char *temp;
-
- temp = (*buf);
- while (*((*buf) + 1) && (*(*buf) != '<'))
- (*buf)++; /*find start of endtag */
- *(*buf) = '\0';
- matches = sscanf(temp, format, value);
- *(*buf) = '<';
- end_tag = malloc((strlen(tag) + 2) * sizeof(char));
- sprintf(end_tag, "/%s", tag);
- eat_tag(buf, end_tag);
- free(end_tag);
- if (matches == 0 && strcmp(format, "%lf") == 0)
- (*((double *) (value))) = DNAN;
- if (matches != 1)
- return 0;
- return 1;
+ xmlChar *str;
+ str = get_xml_text(reader);
+ if (str != NULL){
+ strncpy(value,(char *)str,max_len);
+ xmlFree(str);
+ return 0;
}
- return -1;
+ else
+ return -1;
}
+
+static int get_xml_long(
+ xmlTextReaderPtr reader,
+ long *value)
+{
+ xmlChar *text;
+ long temp;
+ if ((text = get_xml_text(reader)) != NULL){
+ errno = 0;
+ temp = strtol((char *)text,NULL, 0);
+ if (errno>0){
+ rrd_set_error("ling %d: get_xml_long from '%s' %s",
+ xmlTextReaderGetParserLineNumber(reader),
+ text,rrd_strerror(errno));
+ xmlFree(text);
+ return -1;
+ }
+ xmlFree(text);
+ *value = temp;
+ return 0;
+ }
+ return -1;
+} /* get_xml_long */
-/* parse the data stored in buf and return a filled rrd structure */
-int xml2rrd(
- char *buf,
- rrd_t *rrd,
- char rc)
+static int get_xml_ulong(
+ xmlTextReaderPtr reader,
+ unsigned long *value)
{
- /* pass 1 identify number of RRAs */
- char *ptr, *ptr2, *ptr3; /* walks thought the buffer */
- long rows = 0, mempool = 0, i = 0;
- int rra_index;
- int input_version;
-
- xml_lc(buf); /* lets lowercase all active parts of the xml */
- ptr = buf;
- ptr2 = buf;
- ptr3 = buf;
- /* start with an RRD tag */
-
- skipxml(&ptr);
-
- eat_tag(&ptr, "rrd");
- /* allocate static header */
- if ((rrd->stat_head = calloc(1, sizeof(stat_head_t))) == NULL) {
- rrd_set_error("allocating rrd.stat_head");
- return -1;
- };
-
- strcpy(rrd->stat_head->cookie, RRD_COOKIE);
- read_tag(&ptr, "version", "%4[0-9]", rrd->stat_head->version);
- input_version = atoi(rrd->stat_head->version);
- /* added primitive version checking */
- if (input_version > atoi(RRD_VERSION) || input_version < 1) {
- rrd_set_error
- ("Incompatible file version, detected version %s. This is not supported by the version %s restore tool.\n",
- rrd->stat_head->version, RRD_VERSION);
- free(rrd->stat_head);
- rrd->stat_head = NULL;
- return -1;
+
+ xmlChar *text;
+ unsigned long temp;
+ if ((text = get_xml_text(reader)) != NULL){
+ errno = 0;
+ temp = strtoul((char *)text,NULL, 0);
+ if (errno>0){
+ rrd_set_error("ling %d: get_xml_ulong from '%s' %s",
+ xmlTextReaderGetParserLineNumber(reader),
+ text,rrd_strerror(errno));
+ xmlFree(text);
+ return -1;
+ }
+ xmlFree(text);
+ *value = temp;
+ return 0;
}
- /* make sure we output the right version only go over 3 if input is over 3 too */
- if (input_version > 3) {
- strcpy(rrd->stat_head->version, RRD_VERSION);
- } else {
- strcpy(rrd->stat_head->version, RRD_VERSION3);
+ return -1;
+} /* get_xml_ulong */
+
+#ifndef TIME_T_IS_LONG
+static int get_xml_llong(
+ xmlTextReaderPtr reader,
+ long long *value)
+{
+
+ xmlChar *text;
+ long long temp;
+ if ((text = get_xml_text(reader)) != NULL){
+ errno = 0;
+ temp = strtoll((char *)text,NULL, 0);
+ if (errno>0){
+ rrd_set_error("ling %d: get_xml_llong from '%s' %s",
+ xmlTextReaderGetParserLineNumber(reader),
+ text,rrd_strerror(errno));
+ xmlFree(text);
+ return -1;
+ }
+ xmlFree(text);
+ *value = temp;
+ return 0;
}
+ return -1;
+} /* get_xml_llong */
- rrd->stat_head->float_cookie = FLOAT_COOKIE;
- rrd->stat_head->ds_cnt = 0;
- rrd->stat_head->rra_cnt = 0;
- read_tag(&ptr, "step", "%lu", &(rrd->stat_head->pdp_step));
+#endif
- /* allocate live head */
- if ((rrd->live_head = calloc(1, sizeof(live_head_t))) == NULL) {
- rrd_set_error("allocating rrd.live_head");
- return -1;
- }
- read_tag(&ptr, "lastupdate", "%lu", &(rrd->live_head->last_up));
-
- /* Data Source Definition Part */
- ptr2 = ptr;
- while (eat_tag(&ptr2, "ds") == 1) {
- rrd->stat_head->ds_cnt++;
- if ((rrd->ds_def =
- rrd_realloc(rrd->ds_def,
- rrd->stat_head->ds_cnt * sizeof(ds_def_t))) ==
- NULL) {
- rrd_set_error("allocating rrd.ds_def");
+static int get_xml_double(
+ xmlTextReaderPtr reader,
+ double *value)
+{
+
+ char *text;
+ double temp;
+ if ((text = (char *)get_xml_text(reader))!= NULL){
+ if (strcasestr(text,"nan")){
+ *value = DNAN;
+ xmlFree(text);
+ return 0;
+ }
+ else if (strcasestr(text,"-inf")){
+ *value = -DINF;
+ xmlFree(text);
+ return 0;
+ }
+ else if (strcasestr(text,"+inf")
+ || strcasestr(text,"inf")){
+ *value = DINF;
+ xmlFree(text);
+ return 0;
+ }
+ errno = 0;
+ temp = strtod((char *)text,NULL);
+ if (errno>0){
+ rrd_set_error("ling %d: get_xml_double from '%s' %s",
+ xmlTextReaderGetParserLineNumber(reader),
+ text,rrd_strerror(errno));
+ xmlFree(text);
return -1;
- };
- /* clean out memory to make sure no data gets stored from previous tasks */
- memset(&(rrd->ds_def[rrd->stat_head->ds_cnt - 1]), 0,
- sizeof(ds_def_t));
- if ((rrd->pdp_prep =
- rrd_realloc(rrd->pdp_prep,
- rrd->stat_head->ds_cnt * sizeof(pdp_prep_t))) ==
- NULL) {
- rrd_set_error("allocating pdp_prep");
- return (-1);
}
- /* clean out memory to make sure no data gets stored from previous tasks */
- memset(&(rrd->pdp_prep[rrd->stat_head->ds_cnt - 1]), 0,
- sizeof(pdp_prep_t));
+ xmlFree(text);
+ *value = temp;
+ return 0;
+ }
+ return -1;
+} /* get_xml_double */
- read_tag(&ptr2, "name", DS_NAM_FMT,
- rrd->ds_def[rrd->stat_head->ds_cnt - 1].ds_nam);
- read_tag(&ptr2, "type", DST_FMT,
- rrd->ds_def[rrd->stat_head->ds_cnt - 1].dst);
- /* test for valid type */
- if ((int) dst_conv(rrd->ds_def[rrd->stat_head->ds_cnt - 1].dst) == -1)
- return -1;
+static int value_check_range(
+ rrd_value_t *rrd_value,
+ const ds_def_t *ds_def)
+{
+ double min;
+ double max;
+
+ if (opt_range_check == 0)
+ return (0);
+
+ min = ds_def->par[DS_min_val].u_val;
+ max = ds_def->par[DS_max_val].u_val;
- if (dst_conv(rrd->ds_def[rrd->stat_head->ds_cnt - 1].dst) != DST_CDEF) {
- read_tag(&ptr2, "minimal_heartbeat", "%lu",
- &(rrd->ds_def[rrd->stat_head->ds_cnt - 1].
- par[DS_mrhb_cnt].u_cnt));
- read_tag(&ptr2, "min", "%lf",
- &(rrd->ds_def[rrd->stat_head->ds_cnt - 1].
- par[DS_min_val].u_val));
- read_tag(&ptr2, "max", "%lf",
- &(rrd->ds_def[rrd->stat_head->ds_cnt - 1].
- par[DS_max_val].u_val));
- } else { /* DST_CDEF */
- char buffer[1024];
-
- read_tag(&ptr2, "cdef", "%1000s", buffer);
- parseCDEF_DS(buffer, rrd, rrd->stat_head->ds_cnt - 1);
- if (rrd_test_error())
- return -1;
- }
-
- read_tag(&ptr2, "last_ds", "%30s",
- rrd->pdp_prep[rrd->stat_head->ds_cnt - 1].last_ds);
- read_tag(&ptr2, "value", "%lf",
- &(rrd->pdp_prep[rrd->stat_head->ds_cnt - 1].scratch[PDP_val].
- u_val));
- read_tag(&ptr2, "unknown_sec", "%lu",
- &(rrd->pdp_prep[rrd->stat_head->ds_cnt - 1].
- scratch[PDP_unkn_sec_cnt].u_cnt));
- eat_tag(&ptr2, "/ds");
- ptr = ptr2;
- }
-
- ptr2 = ptr;
- while (eat_tag(&ptr2, "rra") == 1) {
- rrd->stat_head->rra_cnt++;
-
- /* allocate and reset rra definition areas */
- if ((rrd->rra_def =
- rrd_realloc(rrd->rra_def,
- rrd->stat_head->rra_cnt * sizeof(rra_def_t))) ==
- NULL) {
- rrd_set_error("allocating rra_def");
+ if (((!isnan(min)) && (*rrd_value < min))
+ || ((!isnan(max)) && (*rrd_value > max)))
+ *rrd_value = DNAN;
+
+ return (0);
+} /* int value_check_range */
+
+/*
+ * Parse the <database> block within an RRA definition
+ */
+
+static int parse_tag_rra_database_row(
+ xmlTextReaderPtr reader,
+ rrd_t *rrd,
+ rrd_value_t *rrd_value)
+{
+ unsigned int values_count = 0;
+ int status;
+
+ status = 0;
+ for (values_count = 0;values_count < rrd->stat_head->ds_cnt;values_count++){
+ if (expect_element(reader,"v") == 0){
+ status = get_xml_double(reader,rrd_value + values_count);
+ if (status == 0)
+ value_check_range(rrd_value + values_count,
+ rrd->ds_def + values_count);
+ else
+ break;
+ } else
+ return -1;
+ if (expect_element(reader,"/v") == -1){
return -1;
}
- memset(&(rrd->rra_def[rrd->stat_head->rra_cnt - 1]), 0,
- sizeof(rra_def_t));
+ }
+ return status;
+} /* int parse_tag_rra_database_row */
- /* allocate and reset consolidation point areas */
- if ((rrd->cdp_prep = rrd_realloc(rrd->cdp_prep,
- rrd->stat_head->rra_cnt
- * rrd->stat_head->ds_cnt *
- sizeof(cdp_prep_t))) == NULL) {
- rrd_set_error("allocating cdp_prep");
- return -1;
+static int parse_tag_rra_database(
+ xmlTextReaderPtr reader,
+ rrd_t *rrd )
+{
+ rra_def_t *cur_rra_def;
+ unsigned int total_row_cnt;
+ int status;
+ int i;
+ xmlChar *element;
+
+ total_row_cnt = 0;
+ for (i = 0; i < (((int) rrd->stat_head->rra_cnt) - 1); i++)
+ total_row_cnt += rrd->rra_def[i].row_cnt;
+
+ cur_rra_def = rrd->rra_def + i;
+
+ status = 0;
+ while ((element = get_xml_element(reader)) != NULL){
+ if (xmlStrcasecmp(element,(const xmlChar *)"row") == 0){
+ rrd_value_t *temp;
+ rrd_value_t *cur_rrd_value;
+ unsigned int total_values_count = rrd->stat_head->ds_cnt
+ * (total_row_cnt + 1);
+
+ /* Allocate space for the new values.. */
+ temp = (rrd_value_t *) realloc(rrd->rrd_value,
+ sizeof(rrd_value_t) *
+ total_values_count);
+ if (temp == NULL) {
+ rrd_set_error("parse_tag_rra_database: realloc failed.");
+ status = -1;
+ break;
+ }
+ rrd->rrd_value = temp;
+ cur_rrd_value = rrd->rrd_value
+ + (rrd->stat_head->ds_cnt * total_row_cnt);
+ memset(cur_rrd_value, '\0',
+ sizeof(rrd_value_t) * rrd->stat_head->ds_cnt);
+ total_row_cnt++;
+ cur_rra_def->row_cnt++;
+
+ status =
+ parse_tag_rra_database_row(reader, rrd, cur_rrd_value);
+ if (status == 0)
+ status = expect_element(reader,"/row");
+ } /* if (xmlStrcasecmp(element,"row")) */
+ else {
+ if ( xmlStrcasecmp(element,(const xmlChar *)"/database") == 0){
+ xmlFree(element);
+ break;
+ }
+ else {
+ rrd_set_error("line %d: found unexpected tag: %s",
+ xmlTextReaderGetParserLineNumber(reader),element);
+ status = -1;
+ }
}
+ xmlFree(element);
+ if (status != 0)
+ break;
+ }
+ return (status);
+} /* int parse_tag_rra_database */
+
+/*
+ * Parse the <cdp_prep> block within an RRA definition
+ */
+static int parse_tag_rra_cdp_prep_ds_history(
+ xmlTextReaderPtr reader,
+ cdp_prep_t *cdp_prep)
+{
+ /* Make `history_buffer' the same size as the scratch area, plus the
+ * terminating NULL byte. */
+ xmlChar *history;
+ char *history_ptr;
+ int i;
+ if ((history = get_xml_text(reader)) != NULL){
+ history_ptr = (char *) (&cdp_prep->scratch[0]);
+ for (i = 0; history[i] != '\0'; i++)
+ history_ptr[i] = (history[i] == '1') ? 1 : 0;
+ xmlFree(history);
+ return 0;
+ }
+ return -1;
+} /* int parse_tag_rra_cdp_prep_ds_history */
+
+static int parse_tag_rra_cdp_prep_ds(
+ xmlTextReaderPtr reader,
+ rrd_t *rrd,
+ cdp_prep_t *cdp_prep)
+{
+ int status;
+ xmlChar *element;
+ memset(cdp_prep, '\0', sizeof(cdp_prep_t));
+
+ status = -1;
+
+ if (atoi(rrd->stat_head->version) == 1) {
+ cdp_prep->scratch[CDP_primary_val].u_val = 0.0;
+ cdp_prep->scratch[CDP_secondary_val].u_val = 0.0;
+ }
- memset(&
- (rrd->
- cdp_prep[rrd->stat_head->ds_cnt *
- (rrd->stat_head->rra_cnt - 1)]), 0,
- rrd->stat_head->ds_cnt * sizeof(cdp_prep_t));
+ while ((element = get_xml_element(reader)) != NULL){
+ if (xmlStrcasecmp(element, (const xmlChar *) "primary_value") == 0)
+ status =
+ get_xml_double(reader,&cdp_prep->scratch[CDP_primary_val].u_val);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "secondary_value") == 0)
+ status =
+ get_xml_double(reader,&cdp_prep->scratch[CDP_secondary_val].u_val);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "intercept") == 0)
+ status = get_xml_double(reader,
+ &cdp_prep->
+ scratch[CDP_hw_intercept].u_val);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "last_intercept") ==
+ 0)
+ status =
+ get_xml_double(reader,
+ &cdp_prep->
+ scratch[CDP_hw_last_intercept].u_val);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "slope") == 0)
+ status = get_xml_double(reader,
+ &cdp_prep->scratch[CDP_hw_slope].
+ u_val);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "last_slope") == 0)
+ status = get_xml_double(reader,
+ &cdp_prep->
+ scratch[CDP_hw_last_slope].u_val);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "nan_count") == 0)
+ status = get_xml_ulong(reader,
+ &cdp_prep->
+ scratch[CDP_null_count].u_cnt);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "last_nan_count") ==
+ 0)
+ status =
+ get_xml_ulong(reader,
+ &cdp_prep->
+ scratch[CDP_last_null_count].u_cnt);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "seasonal") == 0)
+ status = get_xml_double(reader,
+ &cdp_prep->scratch[CDP_hw_seasonal].
+ u_val);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "last_seasonal") ==
+ 0)
+ status =
+ get_xml_double(reader,
+ &cdp_prep->scratch[CDP_hw_last_seasonal].
+ u_val);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "init_flag") == 0)
+ status = get_xml_ulong(reader,
+ &cdp_prep->
+ scratch[CDP_init_seasonal].u_cnt);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "history") == 0)
+ status = parse_tag_rra_cdp_prep_ds_history(reader, cdp_prep);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "value") == 0)
+ status = get_xml_double(reader,
+ &cdp_prep->scratch[CDP_val].u_val);
+ else if (xmlStrcasecmp(element,
+ (const xmlChar *) "unknown_datapoints") == 0)
+ status = get_xml_ulong(reader,
+ &cdp_prep->
+ scratch[CDP_unkn_pdp_cnt].u_cnt);
+ else if (xmlStrcasecmp(element,
+ (const xmlChar *) "/ds") == 0){
+ xmlFree(element);
+ break;
+ }
+ else {
+ rrd_set_error("parse_tag_rra_cdp_prep: Unknown tag: %s",
+ element);
+ status = -1;
+ xmlFree(element);
+ break;
+ }
+ if (status != 0){
+ xmlFree(element);
+ break;
+ }
+ status = expect_element_end(reader,(char *)element);
+ xmlFree(element);
+ if (status != 0)
+ break;
+ }
+ return (status);
+} /* int parse_tag_rra_cdp_prep_ds */
+static int parse_tag_rra_cdp_prep(
+ xmlTextReaderPtr reader,
+ rrd_t *rrd,
+ cdp_prep_t *cdp_prep)
+{
+ int status;
- read_tag(&ptr2, "cf", CF_NAM_FMT,
- rrd->rra_def[rrd->stat_head->rra_cnt - 1].cf_nam);
- /* test for valid type */
- if ((int) cf_conv(rrd->rra_def[rrd->stat_head->rra_cnt - 1].cf_nam) ==
- -1)
- return -1;
+ unsigned int ds_count;
- read_tag(&ptr2, "pdp_per_row", "%lu",
- &(rrd->rra_def[rrd->stat_head->rra_cnt - 1].pdp_cnt));
- /* support to read RRA parameters */
- rra_index = rrd->stat_head->rra_cnt - 1;
- if (input_version < 2) {
- read_tag(&ptr2, "xff", "%lf",
- &(rrd->rra_def[rra_index].par[RRA_cdp_xff_val].u_val));
+ status = 0;
+ for ( ds_count = 0; ds_count < rrd->stat_head->ds_cnt;ds_count++){
+ if (expect_element(reader,"ds") == 0) {
+ status = parse_tag_rra_cdp_prep_ds(reader, rrd,
+ cdp_prep + ds_count);
+ if (status != 0)
+ break;
} else {
- if (eat_tag(&ptr2, "params") != 1) {
- rrd_set_error("could not find params tag to eat and skip");
- return -1;
- }
- skip(&ptr2);
- /* backwards compatibility w/ old patch */
- if (strncmp(ptr2, "<value>", 7) == 0) {
- parse_patch1028_RRA_params(&ptr2, rrd, rra_index);
- } else {
- switch (cf_conv(rrd->rra_def[rra_index].cf_nam)) {
- case CF_HWPREDICT:
- case CF_MHWPREDICT:
- read_tag(&ptr2, "hw_alpha", "%lf",
- &(rrd->rra_def[rra_index].par[RRA_hw_alpha].
- u_val));
- read_tag(&ptr2, "hw_beta", "%lf",
- &(rrd->rra_def[rra_index].par[RRA_hw_beta].
- u_val));
- read_tag(&ptr2, "dependent_rra_idx", "%lu",
- &(rrd->rra_def[rra_index].
- par[RRA_dependent_rra_idx].u_cnt));
- break;
- case CF_SEASONAL:
- case CF_DEVSEASONAL:
- read_tag(&ptr2, "seasonal_gamma", "%lf",
- &(rrd->rra_def[rra_index].
- par[RRA_seasonal_gamma].u_val));
- read_tag(&ptr2, "seasonal_smooth_idx", "%lu",
- &(rrd->rra_def[rra_index].
- par[RRA_seasonal_smooth_idx].u_cnt));
- read_tag(&ptr2, "dependent_rra_idx", "%lu",
- &(rrd->rra_def[rra_index].
- par[RRA_dependent_rra_idx].u_cnt));
- break;
- case CF_FAILURES:
- read_tag(&ptr2, "delta_pos", "%lf",
- &(rrd->rra_def[rra_index].par[RRA_delta_pos].
- u_val));
- read_tag(&ptr2, "delta_neg", "%lf",
- &(rrd->rra_def[rra_index].par[RRA_delta_neg].
- u_val));
- read_tag(&ptr2, "window_len", "%lu",
- &(rrd->rra_def[rra_index].par[RRA_window_len].
- u_cnt));
- read_tag(&ptr2, "failure_threshold", "%lu",
- &(rrd->rra_def[rra_index].
- par[RRA_failure_threshold].u_cnt));
- /* fall thru */
- case CF_DEVPREDICT:
- read_tag(&ptr2, "dependent_rra_idx", "%lu",
- &(rrd->rra_def[rra_index].
- par[RRA_dependent_rra_idx].u_cnt));
+ status = -1;
+ break;
+ }
+ }
+ if (status == 0)
+ status = expect_element(reader,"/cdp_prep");
+ return (status);
+} /* int parse_tag_rra_cdp_prep */
+
+/*
+ * Parse the <params> block within an RRA definition
+ */
+static int parse_tag_rra_params(
+ xmlTextReaderPtr reader,
+ rra_def_t *rra_def)
+{
+ xmlChar *element;
+ int status;
+
+ status = -1;
+ while ((element = get_xml_element(reader)) != NULL){
+ /*
+ * Parameters for CF_HWPREDICT
+ */
+ if (xmlStrcasecmp(element, (const xmlChar *) "hw_alpha") == 0)
+ status = get_xml_double(reader,
+ &rra_def->par[RRA_hw_alpha].u_val);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "hw_beta") == 0)
+ status = get_xml_double(reader,
+ &rra_def->par[RRA_hw_beta].u_val);
+ else if (xmlStrcasecmp(element,
+ (const xmlChar *) "dependent_rra_idx") == 0)
+ status = get_xml_ulong(reader,
+ &rra_def->
+ par[RRA_dependent_rra_idx].u_cnt);
+ /*
+ * Parameters for CF_SEASONAL and CF_DEVSEASONAL
+ */
+ else if (xmlStrcasecmp(element, (const xmlChar *) "seasonal_gamma") ==
+ 0)
+ status =
+ get_xml_double(reader,
+ &rra_def->par[RRA_seasonal_gamma].u_val);
+ else if (xmlStrcasecmp
+ (element, (const xmlChar *) "seasonal_smooth_idx") == 0)
+ status =
+ get_xml_ulong(reader,
+ &rra_def->
+ par[RRA_seasonal_smooth_idx].u_cnt);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "smoothing_window")
+ == 0)
+ status =
+ get_xml_double(reader,
+ &rra_def->
+ par[RRA_seasonal_smoothing_window].
+ u_val);
+ /* else if (dependent_rra_idx) ...; */
+ /*
+ * Parameters for CF_FAILURES
+ */
+ else if (xmlStrcasecmp(element, (const xmlChar *) "delta_pos") == 0)
+ status = get_xml_double(reader,
+ &rra_def->par[RRA_delta_pos].u_val);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "delta_neg") == 0)
+ status = get_xml_double(reader,
+ &rra_def->par[RRA_delta_neg].u_val);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "window_len") == 0)
+ status = get_xml_ulong(reader,
+ &rra_def->par[RRA_window_len].
+ u_cnt);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "failure_threshold")
+ == 0)
+ status =
+ get_xml_ulong(reader,
+ &rra_def->
+ par[RRA_failure_threshold].u_cnt);
+ /*
+ * Parameters for CF_AVERAGE, CF_MAXIMUM, CF_MINIMUM, and CF_LAST
+ */
+ else if (xmlStrcasecmp(element, (const xmlChar *) "xff") == 0)
+ status = get_xml_double(reader,
+ &rra_def->par[RRA_cdp_xff_val].
+ u_val);
+ /*
+ * Compatibility code for 1.0.49
+ */
+ else if (xmlStrcasecmp(element, (const xmlChar *) "value") == 0) { /* {{{ */
+ unsigned int i = 0;
+
+ for (i=0;i<ARRAY_LENGTH(rra_def->par);i++){
+ if ((i == RRA_dependent_rra_idx)
+ || (i == RRA_seasonal_smooth_idx)
+ || (i == RRA_failure_threshold))
+ status = get_xml_ulong(reader,
+ &rra_def->par[i].
+ u_cnt);
+ else
+ status = get_xml_double(reader,
+ &rra_def->par[i].u_val);
+
+ if (status != 0)
break;
- case CF_AVERAGE:
- case CF_MAXIMUM:
- case CF_MINIMUM:
- case CF_LAST:
- default:
- read_tag(&ptr2, "xff", "%lf",
- &(rrd->rra_def[rra_index].par[RRA_cdp_xff_val].
- u_val));
- }
- }
- eat_tag(&ptr2, "/params");
- }
-
-
- eat_tag(&ptr2, "cdp_prep");
- for (i = 0; i < (int) rrd->stat_head->ds_cnt; i++) {
- eat_tag(&ptr2, "ds");
- /* support to read CDP parameters */
- rra_index = rrd->stat_head->rra_cnt - 1;
- skip(&ptr2);
- if (input_version < 2) {
- rrd->cdp_prep[rrd->stat_head->ds_cnt * (rra_index) +
- i].scratch[CDP_primary_val].u_val = 0.0;
- rrd->cdp_prep[rrd->stat_head->ds_cnt * (rra_index) +
- i].scratch[CDP_secondary_val].u_val = 0.0;
- read_tag(&ptr2, "value", "%lf",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt * (rra_index) +
- i].scratch[CDP_val].u_val));
- read_tag(&ptr2, "unknown_datapoints", "%lu",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt * (rra_index) +
- i].scratch[CDP_unkn_pdp_cnt].u_cnt));
- } else {
-
- if (strncmp(ptr2, "<value>", 7) == 0) {
- parse_patch1028_CDP_params(&ptr2, rrd, rra_index, i);
- } else {
- read_tag(&ptr2, "primary_value", "%lf",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt * (rra_index)
- + i].scratch[CDP_primary_val].u_val));
- read_tag(&ptr2, "secondary_value", "%lf",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt * (rra_index)
- +
- i].scratch[CDP_secondary_val].u_val));
- switch (cf_conv(rrd->rra_def[rra_index].cf_nam)) {
- case CF_HWPREDICT:
- case CF_MHWPREDICT:
- read_tag(&ptr2, "intercept", "%lf",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt *
- (rra_index)
- +
- i].scratch[CDP_hw_intercept].
- u_val));
- read_tag(&ptr2, "last_intercept", "%lf",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt *
- (rra_index)
- +
- i].scratch[CDP_hw_last_intercept].
- u_val));
- read_tag(&ptr2, "slope", "%lf",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt *
- (rra_index)
- +
- i].scratch[CDP_hw_slope].u_val));
- read_tag(&ptr2, "last_slope", "%lf",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt *
- (rra_index)
- +
- i].scratch[CDP_hw_last_slope].
- u_val));
- read_tag(&ptr2, "nan_count", "%lu",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt *
- (rra_index)
- +
- i].scratch[CDP_null_count].
- u_cnt));
- read_tag(&ptr2, "last_nan_count", "%lu",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt *
- (rra_index)
- +
- i].scratch[CDP_last_null_count].
- u_cnt));
- break;
- case CF_SEASONAL:
- case CF_DEVSEASONAL:
- read_tag(&ptr2, "seasonal", "%lf",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt *
- (rra_index)
- +
- i].scratch[CDP_hw_seasonal].
- u_val));
- read_tag(&ptr2, "last_seasonal", "%lf",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt *
- (rra_index)
- +
- i].scratch[CDP_hw_last_seasonal].
- u_val));
- read_tag(&ptr2, "init_flag", "%lu",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt *
- (rra_index)
- +
- i].scratch[CDP_init_seasonal].
- u_cnt));
- break;
- case CF_DEVPREDICT:
- break;
- case CF_FAILURES:
- parse_FAILURES_history(&ptr2, rrd, rra_index, i);
- break;
- case CF_AVERAGE:
- case CF_MAXIMUM:
- case CF_MINIMUM:
- case CF_LAST:
- default:
- read_tag(&ptr2, "value", "%lf",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt *
- (rra_index) +
- i].scratch[CDP_val].u_val));
- read_tag(&ptr2, "unknown_datapoints", "%lu",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt *
- (rra_index) +
- i].scratch[CDP_unkn_pdp_cnt].
- u_cnt));
- break;
+ if ( i-1 < ARRAY_LENGTH(rra_def->par)){
+ status = expect_element(reader,"/value");
+ if (status == 0){
+ status = expect_element(reader,"value");
}
}
- }
- eat_tag(&ptr2, "/ds");
- }
- eat_tag(&ptr2, "/cdp_prep");
- rrd->rra_def[rrd->stat_head->rra_cnt - 1].row_cnt = 0;
- eat_tag(&ptr2, "database");
- ptr3 = ptr2;
- while (eat_tag(&ptr3, "row") == 1) {
-
- if (mempool == 0) {
- mempool = 1000;
- if ((rrd->rrd_value = rrd_realloc(rrd->rrd_value,
- (rows +
- mempool) *
- (rrd->stat_head->ds_cnt)
- * sizeof(rrd_value_t))) ==
- NULL) {
- rrd_set_error("allocating rrd_values");
- return -1;
+ if (status != 0){
+ break;
}
}
- rows++;
- mempool--;
- rrd->rra_def[rrd->stat_head->rra_cnt - 1].row_cnt++;
- for (i = 0; i < (int) rrd->stat_head->ds_cnt; i++) {
-
- rrd_value_t *value =
- &(rrd->
- rrd_value[(rows - 1) * rrd->stat_head->ds_cnt + i]);
-
- read_tag(&ptr3, "v", "%lf", value);
-
- if ((rc == 1) /* do we have to check for the ranges */
- &&(!isnan(*value)) /* not a NAN value */
- &&(dst_conv(rrd->ds_def[i].dst) != DST_CDEF)
- && ( /* min defined and in the range ? */
- (!isnan(rrd->ds_def[i].par[DS_min_val].u_val)
- && (*value <
- rrd->ds_def[i].par[DS_min_val].u_val))
- || /* max defined and in the range ? */
- (!isnan(rrd->ds_def[i].par[DS_max_val].u_val)
- && (*value >
- rrd->ds_def[i].par[DS_max_val].u_val))
- )
- ) {
- fprintf(stderr,
- "out of range found [ds: %lu], [value : %0.10e]\n",
- i, *value);
- *value = DNAN;
- }
- }
- eat_tag(&ptr3, "/row");
- ptr2 = ptr3;
+ } /* }}} */
+ else if (xmlStrcasecmp(element,(const xmlChar *) "/params") == 0){
+ xmlFree(element);
+ return status;
+ } /* }}} */
+ else {
+ rrd_set_error("line %d: parse_tag_rra_params: Unknown tag: %s",
+ xmlTextReaderGetParserLineNumber(reader),element);
+ status = -1;
}
- eat_tag(&ptr2, "/database");
- eat_tag(&ptr2, "/rra");
- ptr = ptr2;
+ status = expect_element_end(reader,(char *)element);
+ xmlFree(element);
+ if (status != 0)
+ break;
}
- eat_tag(&ptr, "/rrd");
+ return (status);
+} /* int parse_tag_rra_params */
+
+/*
+ * Parse an RRA definition
+ */
+static int parse_tag_rra_cf(
+ xmlTextReaderPtr reader,
+ rra_def_t *rra_def)
+{
+ int status;
- if ((rrd->rra_ptr =
- calloc(1, sizeof(rra_ptr_t) * rrd->stat_head->rra_cnt)) == NULL) {
- rrd_set_error("allocating rra_ptr");
- return (-1);
- }
+ status = get_xml_string(reader,
+ rra_def->cf_nam, sizeof(rra_def->cf_nam));
+ if (status != 0)
+ return status;
- for (i = 0; i < (int) rrd->stat_head->rra_cnt; i++) {
- /* last row in the xml file is the most recent; as
- * rrd_update increments the current row pointer, set cur_row
- * here to the last row. */
- rrd->rra_ptr[i].cur_row = rrd->rra_def[i].row_cnt - 1;
- }
- if (ptr == NULL)
+ status = cf_conv(rra_def->cf_nam);
+ if (status == -1) {
+ rrd_set_error("parse_tag_rra_cf: Unknown consolidation function: %s",
+ rra_def->cf_nam);
return -1;
- return 1;
-}
+ }
+ return 0;
+} /* int parse_tag_rra_cf */
+static int parse_tag_rra(
+ xmlTextReaderPtr reader,
+ rrd_t *rrd)
+{
+ int status;
+ xmlChar *element;
+
+ rra_def_t *cur_rra_def;
+ cdp_prep_t *cur_cdp_prep;
+ rra_ptr_t *cur_rra_ptr;
+
+ /* Allocate more rra_def space for this RRA */
+ { /* {{{ */
+ rra_def_t *temp;
+
+ temp = (rra_def_t *) realloc(rrd->rra_def,
+ sizeof(rra_def_t) *
+ (rrd->stat_head->rra_cnt + 1));
+ if (temp == NULL) {
+ rrd_set_error("parse_tag_rra: realloc failed.");
+ return (-1);
+ }
+ rrd->rra_def = temp;
+ cur_rra_def = rrd->rra_def + rrd->stat_head->rra_cnt;
+ memset(cur_rra_def, '\0', sizeof(rra_def_t));
+ } /* }}} */
+
+ /* allocate cdp_prep_t */
+ { /* {{{ */
+ cdp_prep_t *temp;
+
+ temp = (cdp_prep_t *) realloc(rrd->cdp_prep, sizeof(cdp_prep_t)
+ * rrd->stat_head->ds_cnt
+ * (rrd->stat_head->rra_cnt + 1));
+ if (temp == NULL) {
+ rrd_set_error("parse_tag_rra: realloc failed.");
+ return (-1);
+ }
+ rrd->cdp_prep = temp;
+ cur_cdp_prep = rrd->cdp_prep
+ + (rrd->stat_head->ds_cnt * rrd->stat_head->rra_cnt);
+ memset(cur_cdp_prep, '\0',
+ sizeof(cdp_prep_t) * rrd->stat_head->ds_cnt);
+ } /* }}} */
+
+ /* allocate rra_ptr_t */
+ { /* {{{ */
+ rra_ptr_t *temp;
+
+ temp = (rra_ptr_t *) realloc(rrd->rra_ptr,
+ sizeof(rra_ptr_t) *
+ (rrd->stat_head->rra_cnt + 1));
+ if (temp == NULL) {
+ rrd_set_error("parse_tag_rra: realloc failed.");
+ return (-1);
+ }
+ rrd->rra_ptr = temp;
+ cur_rra_ptr = rrd->rra_ptr + rrd->stat_head->rra_cnt;
+ memset(cur_rra_ptr, '\0', sizeof(rra_ptr_t));
+ } /* }}} */
+
+ /* All space successfully allocated, increment number of RRAs. */
+ rrd->stat_head->rra_cnt++;
+
+ status = 0;
+ while ((element = get_xml_element(reader)) != NULL){
+ if (xmlStrcasecmp(element, (const xmlChar *) "cf") == 0)
+ status = parse_tag_rra_cf(reader, cur_rra_def);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "pdp_per_row") == 0)
+ status = get_xml_ulong(reader,
+ &cur_rra_def->pdp_cnt);
+ else if (atoi(rrd->stat_head->version) == 1
+ && xmlStrcasecmp(element, (const xmlChar *) "xff") == 0)
+ status = get_xml_double(reader,
+ (double *) &cur_rra_def->
+ par[RRA_cdp_xff_val].u_val);
+ else if (atoi(rrd->stat_head->version) >= 2
+ && xmlStrcasecmp(element, (const xmlChar *) "params") == 0){
+ xmlFree(element);
+ status = parse_tag_rra_params(reader, cur_rra_def);
+ if (status == 0)
+ continue;
+ else
+ return status;
+ }
+ else if (xmlStrcasecmp(element, (const xmlChar *) "cdp_prep") == 0){
+ xmlFree(element);
+ status = parse_tag_rra_cdp_prep(reader, rrd, cur_cdp_prep);
+ if (status == 0)
+ continue;
+ else
+ return status;
+ }
+ else if (xmlStrcasecmp(element, (const xmlChar *) "database") == 0){
+ xmlFree(element);
+ status = parse_tag_rra_database(reader, rrd);
+ if (status == 0)
+ continue;
+ else
+ return status;
+ }
+ else if (xmlStrcasecmp(element,(const xmlChar *) "/rra") == 0){
+ xmlFree(element);
+ return status;
+ } /* }}} */
+ else {
+ rrd_set_error("line %d: parse_tag_rra: Unknown tag: %s",
+ xmlTextReaderGetParserLineNumber(reader), element);
+ status = -1;
+ }
+ if (status != 0) {
+ xmlFree(element);
+ return status;
+ }
+ status = expect_element_end(reader,(char *)element);
+ xmlFree(element);
+ if (status != 0) {
+ return status;
+ }
+ }
+ /* Set the RRA pointer to a random location */
+ cur_rra_ptr->cur_row = rrd_random() % cur_rra_def->row_cnt;
+
+ return (status);
+} /* int parse_tag_rra */
+
+/*
+ * Parse a DS definition
+ */
+static int parse_tag_ds_cdef(
+ xmlTextReaderPtr reader,
+ rrd_t *rrd)
+{
+ xmlChar *cdef;
+
+ cdef = get_xml_text(reader);
+ if (cdef != NULL){
+ /* We're always working on the last DS that has been added to the structure
+ * when we get here */
+ parseCDEF_DS((char *)cdef, rrd, rrd->stat_head->ds_cnt - 1);
+ xmlFree(cdef);
+ if (rrd_test_error())
+ return -1;
+ else
+ return 0;
+ }
+ return -1;
+} /* int parse_tag_ds_cdef */
+static int parse_tag_ds_type(
+ xmlTextReaderPtr reader,
+ ds_def_t *ds_def)
+{
+ char *dst;
+ dst = (char *)get_xml_text(reader);
+ if (dst != NULL){
+ int status;
+ status = dst_conv(dst);
+ if (status == -1) {
+ rrd_set_error("parse_tag_ds_type: Unknown data source type: %s",
+ dst);
+ return -1;
+ }
+ strncpy(ds_def->dst,dst,sizeof(ds_def->dst)-1);
+ ds_def->dst[sizeof(ds_def->dst)-1] = '\0';
+ xmlFree(dst);
+ return 0;
+ }
+ return -1;
+} /* int parse_tag_ds_type */
+static int parse_tag_ds(
+ xmlTextReaderPtr reader,
+ rrd_t *rrd)
+{
+ int status;
+ xmlChar *element;
+
+ ds_def_t *cur_ds_def;
+ pdp_prep_t *cur_pdp_prep;
+
+ /*
+ * If there are DS definitions after RRA definitions the number of values,
+ * cdp_prep areas and so on will be calculated wrong. Thus, enforce a
+ * specific order in this case.
+ */
+ if (rrd->stat_head->rra_cnt > 0) {
+ rrd_set_error("parse_tag_ds: All data source definitions MUST "
+ "precede the RRA definitions!");
+ return (-1);
+ }
-/* create and empty rrd file according to the specs given */
+ /* Allocate space for the new DS definition */
+ { /* {{{ */
+ ds_def_t *temp;
-int rrd_creat(
- char *file_name,
- rrd_t *rrd,
- char force_overwrite)
+ temp = (ds_def_t *) realloc(rrd->ds_def,
+ sizeof(ds_def_t) *
+ (rrd->stat_head->ds_cnt + 1));
+ if (temp == NULL) {
+ rrd_set_error("parse_tag_ds: malloc failed.");
+ return (-1);
+ }
+ rrd->ds_def = temp;
+ cur_ds_def = rrd->ds_def + rrd->stat_head->ds_cnt;
+ memset(cur_ds_def, '\0', sizeof(ds_def_t));
+ } /* }}} */
+
+ /* Allocate pdp_prep space for the new DS definition */
+ { /* {{{ */
+ pdp_prep_t *temp;
+
+ temp = (pdp_prep_t *) realloc(rrd->pdp_prep,
+ sizeof(pdp_prep_t) *
+ (rrd->stat_head->ds_cnt + 1));
+ if (temp == NULL) {
+ rrd_set_error("parse_tag_ds: malloc failed.");
+ return (-1);
+ }
+ rrd->pdp_prep = temp;
+ cur_pdp_prep = rrd->pdp_prep + rrd->stat_head->ds_cnt;
+ memset(cur_pdp_prep, '\0', sizeof(pdp_prep_t));
+ } /* }}} */
+
+ /* All allocations successful, let's increment the number of DSes. */
+ rrd->stat_head->ds_cnt++;
+
+ status = 0;
+ while ((element = get_xml_element(reader)) != NULL){
+ if (xmlStrcasecmp(element, (const xmlChar *) "name") == 0){
+ status = get_xml_string(reader,cur_ds_def->ds_nam,sizeof(cur_ds_def->ds_nam));
+ }
+ else if (xmlStrcasecmp(element, (const xmlChar *) "type") == 0)
+ status = parse_tag_ds_type(reader, cur_ds_def);
+ else if (xmlStrcasecmp(element,
+ (const xmlChar *) "minimal_heartbeat") == 0)
+ status = get_xml_ulong(reader,
+ &cur_ds_def->par[DS_mrhb_cnt].
+ u_cnt);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "min") == 0)
+ status = get_xml_double(reader,
+ &cur_ds_def->par[DS_min_val].u_val);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "max") == 0)
+ status = get_xml_double(reader,
+ &cur_ds_def->par[DS_max_val].u_val);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "cdef") == 0)
+ status = parse_tag_ds_cdef(reader, rrd);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "last_ds") == 0)
+ status = get_xml_string(reader,
+ cur_pdp_prep->last_ds,
+ sizeof(cur_pdp_prep->last_ds));
+ else if (xmlStrcasecmp(element, (const xmlChar *) "value") == 0)
+ status = get_xml_double(reader,
+ &cur_pdp_prep->scratch[PDP_val].
+ u_val);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "unknown_sec") == 0)
+ status = get_xml_ulong(reader,
+ &cur_pdp_prep->
+ scratch[PDP_unkn_sec_cnt].u_cnt);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "/ds") == 0) {
+ xmlFree(element);
+ break;
+ }
+ else {
+ rrd_set_error("parse_tag_ds: Unknown tag: %s", element);
+ status = -1;
+ }
+ if (status != 0) {
+ xmlFree(element);
+ break;
+ }
+ status = expect_element_end(reader,(char *)element);
+ xmlFree(element);
+ if (status != 0)
+ break;
+ }
+
+ return (status);
+} /* int parse_tag_ds */
+
+/*
+ * Parse root nodes
+ */
+static int parse_tag_rrd(
+ xmlTextReaderPtr reader,
+ rrd_t *rrd)
{
- unsigned long i, ii, val_cnt;
- FILE *rrd_file = NULL;
- int fdflags;
- int fd;
-
- if (strcmp("-", file_name) == 0) {
- rrd_file = stdout;
- } else {
-#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
- fdflags = O_RDWR | O_BINARY | O_CREAT;
+ int status;
+ xmlChar *element;
+
+ status = 0;
+ while ((element = get_xml_element(reader)) != NULL ){
+ if (xmlStrcasecmp(element, (const xmlChar *) "version") == 0)
+ status = get_xml_string(reader,
+ rrd->stat_head->version,
+ sizeof(rrd->stat_head->version));
+ else if (xmlStrcasecmp(element, (const xmlChar *) "step") == 0)
+ status = get_xml_ulong(reader,
+ &rrd->stat_head->pdp_step);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "lastupdate") == 0) {
+#ifdef TIME_T_IS_LONG
+ status = get_xml_long(reader, &rrd->live_head->last_up);
+#else
+#ifdef TIME_T_IS_LONG_LONG
+ status = get_xml_llong(reader, &rrd->live_head->last_up);
#else
- fdflags = O_WRONLY | O_CREAT;
+ if (sizeof(time_t) == sizeof(long)) {
+ status = get_xml_long(reader,
+ (long *)&rrd->live_head->last_up);
+ }
+ else if (sizeof(time_t) == sizeof(long long)) {
+ status = get_xml_llong(reader,
+ (long long *)&rrd->live_head->last_up);
+ }
+#endif
#endif
- if (force_overwrite == 0) {
- fdflags |= O_EXCL;
}
- fd = open(file_name, fdflags, 0666);
- if (fd == -1 || (rrd_file = fdopen(fd, "wb")) == NULL) {
- rrd_set_error("creating '%s': %s", file_name,
- rrd_strerror(errno));
- if (fd != -1)
- close(fd);
- return (-1);
+ else if (xmlStrcasecmp(element, (const xmlChar *) "ds") == 0){
+ xmlFree(element);
+ status = parse_tag_ds(reader, rrd);
+ /* as we come back the </ds> tag is already gone */
+ if (status == 0)
+ continue;
+ else
+ return status;
+ }
+ else if (xmlStrcasecmp(element, (const xmlChar *) "rra") == 0){
+ xmlFree(element);
+ status = parse_tag_rra(reader, rrd);
+ if (status == 0)
+ continue;
+ else
+ return status;
+ }
+ else if (xmlStrcasecmp(element, (const xmlChar *) "/rrd") == 0) {
+ xmlFree(element);
+ return status;
+ }
+ else {
+ rrd_set_error("parse_tag_rrd: Unknown tag: %s", element);
+ status = -1;
}
+
+ if (status != 0){
+ xmlFree(element);
+ break;
+ }
+ status = expect_element_end(reader,(char *)element);
+ xmlFree(element);
+ if (status != 0)
+ break;
+ }
+ return (status);
+} /* int parse_tag_rrd */
+
+static rrd_t *parse_file(
+ const char *filename)
+{
+ xmlTextReaderPtr reader;
+ int status;
+
+ rrd_t *rrd;
+
+ reader = xmlNewTextReaderFilename(filename);
+ if (reader == NULL) {
+ rrd_set_error("Could not create xml reader for: %s",filename);
+ return (NULL);
+ }
+
+ if (expect_element(reader,"rrd") != 0) {
+ xmlFreeTextReader(reader);
+ return (NULL);
+ }
+
+ rrd = (rrd_t *) malloc(sizeof(rrd_t));
+ if (rrd == NULL) {
+ rrd_set_error("parse_file: malloc failed.");
+ xmlFreeTextReader(reader);
+ return (NULL);
+ }
+ memset(rrd, '\0', sizeof(rrd_t));
+
+ rrd->stat_head = (stat_head_t *) malloc(sizeof(stat_head_t));
+ if (rrd->stat_head == NULL) {
+ rrd_set_error("parse_tag_rrd: malloc failed.");
+ xmlFreeTextReader(reader);
+ free(rrd);
+ return (NULL);
+ }
+ memset(rrd->stat_head, '\0', sizeof(stat_head_t));
+
+ strncpy(rrd->stat_head->cookie, "RRD", sizeof(rrd->stat_head->cookie));
+ rrd->stat_head->float_cookie = FLOAT_COOKIE;
+
+ rrd->live_head = (live_head_t *) malloc(sizeof(live_head_t));
+ if (rrd->live_head == NULL) {
+ rrd_set_error("parse_tag_rrd: malloc failed.");
+ xmlFreeTextReader(reader);
+ free(rrd->stat_head);
+ free(rrd);
+ return (NULL);
+ }
+ memset(rrd->live_head, '\0', sizeof(live_head_t));
+
+ status = parse_tag_rrd(reader, rrd);
+
+ xmlFreeTextReader(reader);
+
+ if (status != 0) {
+ local_rrd_free(rrd);
+ rrd = NULL;
}
- fwrite(rrd->stat_head, sizeof(stat_head_t), 1, rrd_file);
- fwrite(rrd->ds_def, sizeof(ds_def_t), rrd->stat_head->ds_cnt, rrd_file);
+ return (rrd);
+} /* rrd_t *parse_file */
- fwrite(rrd->rra_def,
- sizeof(rra_def_t), rrd->stat_head->rra_cnt, rrd_file);
+static int write_file(
+ const char *file_name,
+ rrd_t *rrd)
+{
+ FILE *fh;
+ unsigned int i;
+ unsigned int rra_offset;
- fwrite(rrd->live_head, sizeof(live_head_t), 1, rrd_file);
+ if (strcmp("-", file_name) == 0)
+ fh = stdout;
+ else {
+ int fd_flags = O_WRONLY | O_CREAT;
+ int fd;
- fwrite(rrd->pdp_prep, sizeof(pdp_prep_t), rrd->stat_head->ds_cnt,
- rrd_file);
+#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
+ fd_flags |= O_BINARY;
+#endif
- fwrite(rrd->cdp_prep, sizeof(cdp_prep_t), rrd->stat_head->rra_cnt *
- rrd->stat_head->ds_cnt, rrd_file);
- fwrite(rrd->rra_ptr, sizeof(rra_ptr_t), rrd->stat_head->rra_cnt,
- rrd_file);
+ if (opt_force_overwrite == 0)
+ fd_flags |= O_EXCL;
+ fd = open(file_name, fd_flags, 0666);
+ if (fd == -1) {
+ rrd_set_error("creating '%s': %s", file_name,
+ rrd_strerror(errno));
+ return (-1);
+ }
+ fh = fdopen(fd, "wb");
+ if (fh == NULL) {
+ rrd_set_error("fdopen failed: %s", rrd_strerror(errno));
+ close(fd);
+ return (-1);
+ }
+ }
+ if (atoi(rrd->stat_head->version) < 3) {
+ /* we output 3 or higher */
+ strcpy(rrd->stat_head->version, "0003");
+ }
+ fwrite(rrd->stat_head, sizeof(stat_head_t), 1, fh);
+ fwrite(rrd->ds_def, sizeof(ds_def_t), rrd->stat_head->ds_cnt, fh);
+ fwrite(rrd->rra_def, sizeof(rra_def_t), rrd->stat_head->rra_cnt, fh);
+ fwrite(rrd->live_head, sizeof(live_head_t), 1, fh);
+ fwrite(rrd->pdp_prep, sizeof(pdp_prep_t), rrd->stat_head->ds_cnt, fh);
+ fwrite(rrd->cdp_prep, sizeof(cdp_prep_t),
+ rrd->stat_head->rra_cnt * rrd->stat_head->ds_cnt, fh);
+ fwrite(rrd->rra_ptr, sizeof(rra_ptr_t), rrd->stat_head->rra_cnt, fh);
/* calculate the number of rrd_values to dump */
- val_cnt = 0;
- for (i = 0; i < rrd->stat_head->rra_cnt; i++)
- for (ii = 0; ii < rrd->rra_def[i].row_cnt * rrd->stat_head->ds_cnt;
- ii++)
- val_cnt++;
- fwrite(rrd->rrd_value, sizeof(rrd_value_t), val_cnt, rrd_file);
+ rra_offset = 0;
+ for (i = 0; i < rrd->stat_head->rra_cnt; i++) {
+ unsigned long num_rows = rrd->rra_def[i].row_cnt;
+ unsigned long cur_row = rrd->rra_ptr[i].cur_row;
+ unsigned long ds_cnt = rrd->stat_head->ds_cnt;
+
+ fwrite(rrd->rrd_value +
+ (rra_offset + num_rows - 1 - cur_row) * ds_cnt,
+ sizeof(rrd_value_t), (cur_row + 1) * ds_cnt, fh);
+
+ fwrite(rrd->rrd_value + rra_offset * ds_cnt,
+ sizeof(rrd_value_t), (num_rows - 1 - cur_row) * ds_cnt, fh);
+
+ rra_offset += num_rows;
+ }
/* lets see if we had an error */
- if (ferror(rrd_file)) {
+ if (ferror(fh)) {
rrd_set_error("a file error occurred while creating '%s'", file_name);
- fclose(rrd_file);
+ fclose(fh);
return (-1);
}
- fclose(rrd_file);
- return 0;
-}
-
+ fclose(fh);
+ return (0);
+} /* int write_file */
int rrd_restore(
int argc,
char **argv)
{
- rrd_t rrd;
- char *buf;
- char rc = 0;
- char force_overwrite = 0;
- struct option long_options[] = {
- {"range-check", no_argument, 0, 'r'},
- {"force-overwrite", no_argument, 0, 'f'},
- {0, 0, 0, 0}
- };
+ rrd_t *rrd;
/* init rrd clean */
optind = 0;
opterr = 0; /* initialize getopt */
- while (1) {
- int option_index = 0;
+ while (42) {
int opt;
+ int option_index = 0;
+ static struct option long_options[] = {
+ {"range-check", no_argument, 0, 'r'},
+ {"force-overwrite", no_argument, 0, 'f'},
+ {0, 0, 0, 0}
+ };
opt = getopt_long(argc, argv, "rf", long_options, &option_index);
switch (opt) {
case 'r':
- rc = 1;
+ opt_range_check = 1;
break;
+
case 'f':
- force_overwrite = 1;
+ opt_force_overwrite = 1;
break;
+
default:
- rrd_set_error
- ("usage rrdtool %s [--range-check|-r] [--force-overwrite/-f] file.xml file.rrd",
- argv[0]);
- return -1;
+ rrd_set_error("usage rrdtool %s [--range-check|-r] "
+ "[--force-overwrite/-f] file.xml file.rrd",
+ argv[0]);
+ return (-1);
break;
}
- }
+ } /* while (42) */
- if (argc - optind != 2) {
- rrd_set_error
- ("usage rrdtool %s [--range-check/-r] [--force-overwrite/-f] file.xml file.rrd",
- argv[0]);
- return -1;
- }
-
- if (readfile(argv[optind], &buf, 0) == -1) {
- return -1;
- }
-
- rrd_init(&rrd);
-
- if (xml2rrd(buf, &rrd, rc) == -1) {
- rrd_free(&rrd);
- free(buf);
- return -1;
- }
-
- free(buf);
-
- if (rrd_creat(argv[optind + 1], &rrd, force_overwrite) == -1) {
- rrd_free(&rrd);
- return -1;
- };
- rrd_free(&rrd);
- return 0;
-}
-
-/* a backwards compatibility routine that will parse the RRA params section
- * generated by the aberrant patch to 1.0.28. */
-
-void parse_patch1028_RRA_params(
- char **buf,
- rrd_t *rrd,
- int rra_index)
-{
- int i;
-
- for (i = 0; i < MAX_RRA_PAR_EN; i++) {
- if (i == RRA_dependent_rra_idx ||
- i == RRA_seasonal_smooth_idx || i == RRA_failure_threshold)
- read_tag(buf, "value", "%lu",
- &(rrd->rra_def[rra_index].par[i].u_cnt));
- else
- read_tag(buf, "value", "%lf",
- &(rrd->rra_def[rra_index].par[i].u_val));
+ if ((argc - optind) != 2) {
+ rrd_set_error("usage rrdtool %s [--range-check/-r] "
+ "[--force-overwrite/-f] file.xml file.rrd", argv[0]);
+ return (-1);
}
-}
-/* a backwards compatibility routine that will parse the CDP params section
- * generated by the aberrant patch to 1.0.28. */
-void parse_patch1028_CDP_params(
- char **buf,
- rrd_t *rrd,
- int rra_index,
- int ds_index)
-{
- int ii;
-
- for (ii = 0; ii < MAX_CDP_PAR_EN; ii++) {
- if (cf_conv(rrd->rra_def[rra_index].cf_nam) == CF_FAILURES ||
- ii == CDP_unkn_pdp_cnt ||
- ii == CDP_null_count || ii == CDP_last_null_count) {
- read_tag(buf, "value", "%lu",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt * (rra_index) +
- ds_index].scratch[ii].u_cnt));
- } else {
- read_tag(buf, "value", "%lf",
- &(rrd->
- cdp_prep[rrd->stat_head->ds_cnt * (rra_index) +
- ds_index].scratch[ii].u_val));
- }
+ rrd = parse_file(argv[optind]);
+ if (rrd == NULL)
+ return (-1);
+
+ if (write_file(argv[optind + 1], rrd) != 0) {
+ local_rrd_free(rrd);
+ return (-1);
}
-}
+ local_rrd_free(rrd);
-void parse_FAILURES_history(
- char **buf,
- rrd_t *rrd,
- int rra_index,
- int ds_index)
-{
- char history[MAX_FAILURES_WINDOW_LEN + 1];
- char *violations_array;
- unsigned short i;
-
- /* 28 = MAX_FAILURES_WINDOW_LEN */
- read_tag(buf, "history", "%28[0-1]", history);
- violations_array =
- (char *) rrd->cdp_prep[rrd->stat_head->ds_cnt * (rra_index)
- + ds_index].scratch;
- for (i = 0; i < rrd->rra_def[rra_index].par[RRA_window_len].u_cnt; ++i)
- violations_array[i] = (history[i] == '1') ? 1 : 0;
+ return (0);
+} /* int rrd_restore */
-}
+/* vim: set sw=2 sts=2 ts=8 et fdm=marker : */
projects / rrdtool.git / blobdiff