X-Git-Url: https://git.octo.it/?p=rrdtool.git;a=blobdiff_plain;f=src%2Frrd_restore.c;h=46a79b5a59e04d1c8510159a16d7fc3d16a3dac5;hp=368f7bcfbb041ee6de6d4ead1ce5a2d414351114;hb=a7066853475167aeeaec21a2405189c5afd231f9;hpb=2a6a270edfda89b04722b42b57992907f871c671 diff --git a/src/rrd_restore.c b/src/rrd_restore.c index 368f7bc..46a79b5 100644 --- a/src/rrd_restore.c +++ b/src/rrd_restore.c @@ -1,724 +1,1229 @@ /***************************************************************************** - * 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 +#include +#include +#include +#include +#include + +#ifndef WIN32 +# include /* for off_t */ +#else + typedef size_t ssize_t; + typedef long off_t; +#endif + +#include #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__) -#include -#define open _open -#define close _close +# include +# 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 to */ +#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, ""); - 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 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, ""); - 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 */ - strcpy(rrd->stat_head->version, RRD_VERSION); + return -1; +} /* get_xml_ulong */ - /* if (atoi(rrd -> stat_head -> version) < 2) - { - rrd_set_error("Can only restore version >= 2 (Not %s). Dump your old rrd using a current rrdtool dump.", rrd -> stat_head -> version ); - return -1; - } */ +#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 (((!isnan(min)) && (*rrd_value < min)) + || ((!isnan(max)) && (*rrd_value > max))) + *rrd_value = DNAN; - 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"); + return (0); +} /* int value_check_range */ + +/* + * Parse the 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 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, "", 7) == 0) { - parse_patch1028_RRA_params(&ptr2, rrd, rra_index); - } else { - switch (cf_conv(rrd->rra_def[rra_index].cf_nam)) { - case CF_HWPREDICT: - 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 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;ipar);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, "", 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: - 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 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); } - 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); + 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)); - fwrite(rrd->rra_def, - sizeof(rra_def_t), rrd->stat_head->rra_cnt, rrd_file); + strncpy(rrd->stat_head->cookie, "RRD", sizeof(rrd->stat_head->cookie)); + rrd->stat_head->float_cookie = FLOAT_COOKIE; - fwrite(rrd->live_head, sizeof(live_head_t), 1, rrd_file); + 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)); - fwrite(rrd->pdp_prep, sizeof(pdp_prep_t), rrd->stat_head->ds_cnt, - rrd_file); + status = parse_tag_rrd(reader, rrd); - 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); + xmlFreeTextReader(reader); + if (status != 0) { + local_rrd_free(rrd); + rrd = NULL; + } + return (rrd); +} /* rrd_t *parse_file */ + +static int write_file( + const char *file_name, + rrd_t *rrd) +{ + FILE *fh; + unsigned int i; + unsigned int rra_offset; + + if (strcmp("-", file_name) == 0) + fh = stdout; + else { + int fd_flags = O_WRONLY | O_CREAT; + int fd; + +#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__) + fd_flags |= O_BINARY; +#endif + + 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; + rrd_t *rrd; /* init rrd clean */ optind = 0; opterr = 0; /* initialize getopt */ - while (1) { + 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} }; - int option_index = 0; - int opt; - opt = getopt_long(argc, argv, "rf", long_options, &option_index); @@ -727,114 +1232,40 @@ int rrd_restore( 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 : */