X-Git-Url: https://git.octo.it/?p=rrdtool.git;a=blobdiff_plain;f=src%2Frrd_restore.c;h=46a79b5a59e04d1c8510159a16d7fc3d16a3dac5;hp=573198c44a8b8dda5c2dab6c372f066768698b66;hb=a7066853475167aeeaec21a2405189c5afd231f9;hpb=ab384eb6dac85f5f57dabcfc16114fcaf79d5e94 diff --git a/src/rrd_restore.c b/src/rrd_restore.c index 573198c..46a79b5 100644 --- a/src/rrd_restore.c +++ b/src/rrd_restore.c @@ -1,602 +1,1271 @@ /***************************************************************************** - * RRDtool 1.2.1 Copyright by Tobi Oetiker, 1997-2005 + * 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 +#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 +#endif #include "rrd_tool.h" #include "rrd_rpncalc.h" -#include -#if defined(WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__) -#include -#define open _open -#define close _close -#endif +#define ARRAY_LENGTH(a) (sizeof (a) / sizeof ((a)[0])) -/* Prototypes */ - -void xml_lc(char*); -int skip(char **); -int eat_tag(char **, char *); -int read_tag(char **, char *, char *, void *); -int xml2rrd(char*, rrd_t*, char); -int rrd_write(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); - -/* convert all occurrences of to */ - -void xml_lc(char* buf){ - int intag=0; - while((*buf)){ - if (intag ==0 && (*buf) == '<') { - intag = 1; - } - else if (intag ==1 && (*buf) == '>') { - intag = 0; - continue; - } else if (intag ==1) { - *buf = tolower(*buf); - } - buf++; - } -} +static int opt_range_check = 0; +static int opt_force_overwrite = 0; + +/* + * Helpers + */ -int skip(char **buf){ - char *ptr; - 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; +/* 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; + + 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; + } + /* 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 eat_tag(char **buf, char *tag){ - 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; - } - skip(buf); - return 1; + +static int expect_element ( + xmlTextReaderPtr reader, + char *exp_name) +{ + 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 */ + +static int expect_element_end ( + xmlTextReaderPtr reader, + char *exp_name) +{ + 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 */ + + +static xmlChar* get_xml_text ( + xmlTextReaderPtr reader + ) +{ + 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; + } + rrd_set_error("file ended while looking for text"); + return NULL; +} /* get_xml_text */ + + +static int get_xml_string( + xmlTextReaderPtr reader, + char *value, + int max_len) +{ + xmlChar *str; + str = get_xml_text(reader); + if (str != NULL){ + strncpy(value,(char *)str,max_len); + xmlFree(str); + return 0; + } + else + return -1; } -int read_tag(char **buf, char *tag, char *format, void *value){ - 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; + +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 */ +static int get_xml_ulong( + xmlTextReaderPtr reader, + unsigned long *value) +{ + + 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; + } + return -1; +} /* get_xml_ulong */ -/* parse the data stored in buf and return a filled rrd structure */ -int xml2rrd(char* buf, rrd_t* rrd, char rc){ - /* pass 1 identify number of RRAs */ - char *ptr,*ptr2,*ptr3; /* walks thought the buffer */ - long rows=0,mempool=0,i=0; - int rra_index; - xml_lc(buf); /* lets lowercase all active parts of the xml */ - ptr=buf; - ptr2=buf; - ptr3=buf; - /* start with an RRD tag */ - - 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); - /* added primitive version checking */ - if (atoi(rrd -> stat_head -> version) > atoi(RRD_VERSION) ) - { - rrd_set_error("Incompatible file version, detected version %s is bigger than supported version %s\n", - rrd -> stat_head -> version, RRD_VERSION ); - free(rrd -> stat_head); +#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; - } - if (atoi(rrd -> stat_head -> version) < 2) - { - rrd_set_error("Can only restore version >= 2 (Not %s). Dump your rrd using a current rrdtool dump.", rrd -> stat_head -> version ); - free(rrd -> stat_head); +} /* get_xml_llong */ + +#endif + +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; + } + xmlFree(text); + *value = temp; + return 0; + } return -1; - } - 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)); - - /* allocate live head */ - if((rrd->live_head = calloc(1,sizeof(live_head_t)))==NULL){ - rrd_set_error("allocating rrd.live_head"); +} /* get_xml_double */ + + +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; + + 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; + } + } + return status; +} /* int parse_tag_rra_database_row */ + +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; - } - 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"); - 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)); - - 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; - - 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","%s",buffer); - parseCDEF_DS(buffer,rrd,rrd -> stat_head -> ds_cnt - 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 -1; } - memset(&(rrd->rra_def[rrd->stat_head->rra_cnt-1]), 0, sizeof(rra_def_t)); - - /* 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; } - - 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)); - - - 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; - - read_tag(&ptr2,"pdp_per_row","%lu",&(rrd->rra_def[rrd->stat_head->rra_cnt-1].pdp_cnt)); - /* support to read RRA parameters */ - eat_tag(&ptr2, "params"); - skip(&ptr2); - rra_index = rrd->stat_head->rra_cnt - 1; - /* 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)); - 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 (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)); +} /* 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; + } + + 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; - 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)); + } + else { + rrd_set_error("parse_tag_rra_cdp_prep: Unknown tag: %s", + element); + status = -1; + xmlFree(element); + break; + } + if (status != 0){ + xmlFree(element); break; - case CF_DEVPREDICT: + } + status = expect_element_end(reader,(char *)element); + xmlFree(element); + if (status != 0) break; - case CF_FAILURES: - parse_FAILURES_history(&ptr2,rrd,rra_index,i); + } + 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; + + unsigned int ds_count; + + 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 { + status = -1; 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)); + } + } + 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; + if ( i-1 < ARRAY_LENGTH(rra_def->par)){ + status = expect_element(reader,"/value"); + if (status == 0){ + status = expect_element(reader,"value"); + } + } + if (status != 0){ + break; + } + } + } /* }}} */ + 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; + } + status = expect_element_end(reader,(char *)element); + xmlFree(element); + if (status != 0) break; - } - } - 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; } - } - 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; - } - eat_tag(&ptr2,"/database"); - eat_tag(&ptr2,"/rra"); - ptr=ptr2; - } - eat_tag(&ptr,"/rrd"); - - if((rrd->rra_ptr = calloc(1,sizeof(rra_ptr_t)*rrd->stat_head->rra_cnt)) == NULL) { - rrd_set_error("allocating rra_ptr"); - return(-1); - } - - 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) - return -1; - return 1; -} - + } + 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; + + status = get_xml_string(reader, + rra_def->cf_nam, sizeof(rra_def->cf_nam)); + if (status != 0) + return status; + + 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 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)); + } /* }}} */ -/* create and empty rrd file according to the specs given */ + /* All space successfully allocated, increment number of RRAs. */ + rrd->stat_head->rra_cnt++; -int -rrd_write(char *file_name, rrd_t *rrd, char force_overwrite) + 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) { - 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; -#else - fdflags = O_WRONLY|O_CREAT; -#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); - } - } - 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); - - fwrite(rrd->rra_def, - sizeof(rra_def_t), rrd->stat_head->rra_cnt, rrd_file); - - /* maybe the xml hold an old formatted rrd */ - if (atoi(rrd->stat_head->version) < 3) - fwrite(&(rrd->live_head->last_up), sizeof(long),1, rrd_file); - else - fwrite(rrd->live_head, sizeof(live_head_t),1, rrd_file); + 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 */ - fwrite( rrd->pdp_prep, sizeof(pdp_prep_t),rrd->stat_head->ds_cnt,rrd_file); +static int parse_tag_ds( + xmlTextReaderPtr reader, + rrd_t *rrd) +{ + int status; + xmlChar *element; - 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); + 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); + } + /* Allocate space for the new DS definition */ + { /* {{{ */ + ds_def_t *temp; - /* 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); + 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)); + } /* }}} */ - /* lets see if we had an error */ - if(ferror(rrd_file)){ - rrd_set_error("a file error occurred while creating '%s'",file_name); - fclose(rrd_file); - return(-1); + /* 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; } - fclose(rrd_file); - return 0; -} + return (status); +} /* int parse_tag_ds */ +/* + * Parse root nodes + */ +static int parse_tag_rrd( + xmlTextReaderPtr reader, + rrd_t *rrd) +{ + 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 + 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 + } + 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; + } -int -rrd_restore(int argc, char **argv) + 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) { - rrd_t rrd; - char *buf; - char rc = 0; - char force_overwrite = 0; + xmlTextReaderPtr reader; + int status; - /* init rrd clean */ - optind = 0; opterr = 0; /* initialize getopt */ - rrd_init(&rrd); - if (argc<3) { - rrd_set_error("usage rrdtool %s [--range-check/-r] [--force-overwrite/-f] file.xml file.rrd",argv[0]); - return -1; - } - - while (1) { - static struct option long_options[] = - { - {"range-check", required_argument, 0, 'r'}, - {"force-overwrite", required_argument, 0, 'f'}, - {0,0,0,0} - }; - int option_index = 0; - int opt; - - - opt = getopt_long(argc, argv, "r:f", long_options, &option_index); - - if (opt == EOF) - break; - - switch(opt) { - case 'r': - rc=1; - break; - case 'f': - 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; - break; - } - } - - if (readfile(argv[optind],&buf,0)==-1){ - return -1; - } - if (xml2rrd(buf,&rrd,rc)==-1) { - rrd_free(&rrd); - free(buf); - return -1; - } - free(buf); - if(rrd_write(argv[optind+1],&rrd,force_overwrite)==-1){ - rrd_free(&rrd); - return -1; - }; - rrd_free(&rrd); - return 0; -} + rrd_t *rrd; -/* a backwards compatibility routine that will parse the RRA params section - * generated by the aberrant patch to 1.0.28. */ + reader = xmlNewTextReaderFilename(filename); + if (reader == NULL) { + rrd_set_error("Could not create xml reader for: %s",filename); + return (NULL); + } -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 (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); -/* 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) + 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) { - 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)); - } - } -} + 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 */ + 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; + } -void -parse_FAILURES_history(char **buf, rrd_t *rrd, int rra_index, int ds_index) + /* lets see if we had an error */ + if (ferror(fh)) { + rrd_set_error("a file error occurred while creating '%s'", file_name); + fclose(fh); + return (-1); + } + + fclose(fh); + return (0); +} /* int write_file */ + +int rrd_restore( + int argc, + char **argv) { - 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; + rrd_t *rrd; -} + /* init rrd clean */ + optind = 0; + opterr = 0; /* initialize getopt */ + 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); + + if (opt == EOF) + break; + + switch (opt) { + case 'r': + opt_range_check = 1; + break; + + case 'f': + 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); + 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); + } + + 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); + + + return (0); +} /* int rrd_restore */ + +/* vim: set sw=2 sts=2 ts=8 et fdm=marker : */