X-Git-Url: https://git.octo.it/?p=rrdtool.git;a=blobdiff_plain;f=src%2Frrd_restore.c;h=ab8b138044d45158484302e6f8cf0b1637ff398c;hp=68d712da5641294ef742e640fc65a2a76a19854f;hb=2ba0dac41cd82d69b612b5b4526f6e6f85c8abdc;hpb=f8b321ed9be936455166a5e9297199e84b048526 diff --git a/src/rrd_restore.c b/src/rrd_restore.c index 68d712d..ab8b138 100644 --- a/src/rrd_restore.c +++ b/src/rrd_restore.c @@ -1,601 +1,1101 @@ /***************************************************************************** - * RRDtool 1.2rc7 Copyright by Tobi Oetiker, 1997-2005 + * RRDtool 1.3.2 Copyright by Tobi Oetiker, 1997-2008 + * This file: Copyright 2008 Florian octo Forster + * Distributed under the GPL ***************************************************************************** - * 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 + ***************************************************************************** + * $Id$ + *************************************************************************** */ + +/* + * This program is free software; you can redistribute it and / or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (t your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110 - 1301 USA + * + * Authors: + * Florian octo Forster + **/ +#include +#include +#include +#include +#include +#include +#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__) +# include +# define open _open +# define close _close +#endif +#include #include "rrd_tool.h" #include "rrd_rpncalc.h" -#include +#define ARRAY_LENGTH(a) (sizeof (a) / sizeof ((a)[0])) +static int opt_range_check = 0; +static int opt_force_overwrite = 0; -#if defined(WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__) -#include -#define open _open -#define close _close -#endif +/* + * Auxiliary functions + */ +static int get_string_from_node( + xmlDoc * doc, + xmlNode * node, + char *buffer, + size_t buffer_size) +{ + xmlChar *temp0; + char *begin_ptr; + char *end_ptr; -/* 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; + temp0 = xmlNodeListGetString(doc, node->xmlChildrenNode, 1); + if (temp0 == NULL) { + rrd_set_error("get_string_from_node: xmlNodeListGetString failed."); + return (-1); } - else if (intag ==1 && (*buf) == '>') { - intag = 0; - continue; - } else if (intag ==1) { - *buf = tolower(*buf); + + begin_ptr = (char *) temp0; + while ((begin_ptr[0] != 0) && (isspace(begin_ptr[0]))) + begin_ptr++; + + if (begin_ptr[0] == 0) { + xmlFree(temp0); + buffer[0] = 0; + return (0); } - buf++; - } -} - -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; - } + + end_ptr = begin_ptr; + while ((end_ptr[0] != 0) && (!isspace(end_ptr[0]))) + end_ptr++; + end_ptr[0] = 0; + + strncpy(buffer, begin_ptr, buffer_size); + buffer[buffer_size - 1] = 0; + + xmlFree(temp0); + + return (0); +} /* int get_string_from_node */ + +static int get_int_from_node( + xmlDoc * doc, + xmlNode * node, + int *value) +{ + int temp; + char *str_ptr; + char *end_ptr; + + str_ptr = (char *) xmlNodeListGetString(doc, node->xmlChildrenNode, 1); + if (str_ptr == NULL) { + rrd_set_error("get_int_from_node: xmlNodeListGetString failed."); + return (-1); } - } while ((*buf)!=ptr); - return 1; -} - -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; -} - -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; + + end_ptr = NULL; + temp = strtol(str_ptr, &end_ptr, 0); + xmlFree(str_ptr); + + if (str_ptr == end_ptr) { + rrd_set_error("get_int_from_node: Cannot parse buffer as int: %s", + str_ptr); + return (-1); } - return -1; -} - - -/* 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); - 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); - 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"); - 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)); + + *value = temp; + + return (0); +} /* int get_int_from_node */ + +static int get_double_from_node( + xmlDoc * doc, + xmlNode * node, + double *value) +{ + double temp; + char *str_ptr; + char *end_ptr; + + str_ptr = (char *) xmlNodeListGetString(doc, node->xmlChildrenNode, 1); + if (str_ptr == NULL) { + rrd_set_error("get_double_from_node: xmlNodeListGetString failed."); + return (-1); + } + + end_ptr = NULL; + temp = strtod(str_ptr, &end_ptr); + xmlFree(str_ptr); + + if (str_ptr == end_ptr) { + rrd_set_error + ("get_double_from_node: Cannot parse buffer as double: %s", + str_ptr); + return (-1); + } + + *value = temp; + + return (0); +} /* int get_double_from_node */ + +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( + xmlDoc * doc, + xmlNode * node, + rrd_t *rrd, + rrd_value_t *rrd_value) +{ + unsigned int values_count = 0; + xmlNode *child; + int status; + + status = 0; + for (child = node->xmlChildrenNode; child != NULL; child = child->next) { + if ((xmlStrcmp(child->name, (const xmlChar *) "comment") == 0) + || (xmlStrcmp(child->name, (const xmlChar *) "text") == 0)) + /* ignore */ ; + else if (xmlStrcmp(child->name, (const xmlChar *) "v") == 0) { + if (values_count < rrd->stat_head->ds_cnt) { + status = + get_double_from_node(doc, child, + rrd_value + values_count); + if (status == 0) + value_check_range(rrd_value + values_count, + rrd->ds_def + values_count); + } + + values_count++; + } else { + rrd_set_error("parse_tag_rra_database_row: Unknown tag: %s", + child->name); + status = -1; + } + + if (status != 0) 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)); + } /* for (child = node->xmlChildrenNode) */ + + if (values_count != rrd->stat_head->ds_cnt) { + rrd_set_error("parse_tag_rra_database_row: Row has %u values " + "and RRD has %lu data sources.", + values_count, rrd->stat_head->ds_cnt); + status = -1; + } + + return (status); +} /* int parse_tag_rra_database_row */ + +static int parse_tag_rra_database( + xmlDoc * doc, + xmlNode * node, + rrd_t *rrd) +{ + rra_def_t *cur_rra_def; + unsigned int total_row_cnt; + xmlNode *child; + int status; + int i; + + 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; + for (child = node->xmlChildrenNode; child != NULL; child = child->next) { + if ((xmlStrcmp(child->name, (const xmlChar *) "comment") == 0) + || (xmlStrcmp(child->name, (const xmlChar *) "text") == 0)) + /* ignore */ ; + else if (xmlStrcmp(child->name, (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(doc, child, rrd, cur_rrd_value); + } /* if (xmlStrcmp (child->name, (const xmlChar *) "row") == 0) */ + else { + rrd_set_error("parse_tag_rra_database: Unknown tag: %s", + child->name); + status = -1; + } + + if (status != 0) break; - case CF_DEVPREDICT: + } /* for (child = node->xmlChildrenNode) */ + + return (status); +} /* int parse_tag_rra_database */ + +/* + * Parse the block within an RRA definition + */ +static int parse_tag_rra_cdp_prep_ds_history( + xmlDoc * doc, + xmlNode * node, + cdp_prep_t *cdp_prep) +{ + /* Make `history_buffer' the same size as the scratch area, plus the + * terminating NULL byte. */ + char history_buffer[sizeof(((cdp_prep_t *)0)->scratch) + 1]; + char *history_ptr; + int status; + int i; + + status = get_string_from_node(doc, node, + history_buffer, sizeof(history_buffer)); + if (status != 0) + return (-1); + + history_ptr = (char *) (&cdp_prep->scratch[0]); + for (i = 0; history_buffer[i] != '\0'; i++) + history_ptr[i] = (history_buffer[i] == '1') ? 1 : 0; + + return (0); +} /* int parse_tag_rra_cdp_prep_ds_history */ + +static int parse_tag_rra_cdp_prep_ds( + xmlDoc * doc, + xmlNode * node, + rrd_t *rrd, + cdp_prep_t *cdp_prep) +{ + xmlNode *child; + int status; + + memset(cdp_prep, '\0', sizeof(cdp_prep_t)); + + status = 0; + for (child = node->xmlChildrenNode; child != NULL; child = child->next) { + 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; + } + if ((xmlStrcmp(child->name, (const xmlChar *) "comment") == 0) + || (xmlStrcmp(child->name, (const xmlChar *) "text") == 0)) + /* ignore */ ; + else if (xmlStrcmp(child->name, (const xmlChar *) "primary_value") == + 0) + status = + get_double_from_node(doc, child, + &cdp_prep->scratch[CDP_primary_val]. + u_val); + else if (xmlStrcmp(child->name, (const xmlChar *) "secondary_value") + == 0) + status = + get_double_from_node(doc, child, + &cdp_prep->scratch[CDP_secondary_val]. + u_val); + else if (xmlStrcmp(child->name, (const xmlChar *) "intercept") == 0) + status = get_double_from_node(doc, child, + &cdp_prep-> + scratch[CDP_hw_intercept].u_val); + else if (xmlStrcmp(child->name, (const xmlChar *) "last_intercept") == + 0) + status = + get_double_from_node(doc, child, + &cdp_prep-> + scratch[CDP_hw_last_intercept].u_val); + else if (xmlStrcmp(child->name, (const xmlChar *) "slope") == 0) + status = get_double_from_node(doc, child, + &cdp_prep->scratch[CDP_hw_slope]. + u_val); + else if (xmlStrcmp(child->name, (const xmlChar *) "last_slope") == 0) + status = get_double_from_node(doc, child, + &cdp_prep-> + scratch[CDP_hw_last_slope].u_val); + else if (xmlStrcmp(child->name, (const xmlChar *) "nan_count") == 0) + status = get_int_from_node(doc, child, + (int *) &cdp_prep-> + scratch[CDP_null_count].u_cnt); + else if (xmlStrcmp(child->name, (const xmlChar *) "last_nan_count") == + 0) + status = + get_int_from_node(doc, child, + (int *) &cdp_prep-> + scratch[CDP_last_null_count].u_cnt); + else if (xmlStrcmp(child->name, (const xmlChar *) "seasonal") == 0) + status = get_double_from_node(doc, child, + &cdp_prep->scratch[CDP_hw_seasonal]. + u_val); + else if (xmlStrcmp(child->name, (const xmlChar *) "last_seasonal") == + 0) + status = + get_double_from_node(doc, child, + &cdp_prep->scratch[CDP_hw_last_seasonal]. + u_val); + else if (xmlStrcmp(child->name, (const xmlChar *) "init_flag") == 0) + status = get_int_from_node(doc, child, + (int *) &cdp_prep-> + scratch[CDP_init_seasonal].u_cnt); + else if (xmlStrcmp(child->name, (const xmlChar *) "history") == 0) + status = parse_tag_rra_cdp_prep_ds_history(doc, child, cdp_prep); + else if (xmlStrcmp(child->name, (const xmlChar *) "value") == 0) + status = get_double_from_node(doc, child, + &cdp_prep->scratch[CDP_val].u_val); + else if (xmlStrcmp(child->name, + (const xmlChar *) "unknown_datapoints") == 0) + status = get_int_from_node(doc, child, + (int *) &cdp_prep-> + scratch[CDP_unkn_pdp_cnt].u_cnt); + else { + rrd_set_error("parse_tag_rra_cdp_prep: Unknown tag: %s", + child->name); + status = -1; + } + + 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( + xmlDoc * doc, + xmlNode * node, + rrd_t *rrd, + cdp_prep_t *cdp_prep) +{ + xmlNode *child; + int status; + + unsigned int ds_count = 0; + + status = 0; + for (child = node->xmlChildrenNode; child != NULL; child = child->next) { + if ((xmlStrcmp(child->name, (const xmlChar *) "comment") == 0) + || (xmlStrcmp(child->name, (const xmlChar *) "text") == 0)) + /* ignore */ ; + else if (xmlStrcmp(child->name, (const xmlChar *) "ds") == 0) { + if (ds_count >= rrd->stat_head->ds_cnt) + status = -1; + else { + status = parse_tag_rra_cdp_prep_ds(doc, child, rrd, + cdp_prep + ds_count); + ds_count++; + } + } else { + rrd_set_error("parse_tag_rra_cdp_prep: Unknown tag: %s", + child->name); + status = -1; + } + + if (status != 0) 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 (ds_count != rrd->stat_head->ds_cnt) { + rrd_set_error("parse_tag_rra_cdp_prep: There are %i data sources in " + "the RRD file, but %i in this cdp_prep block!", + (int) rrd->stat_head->ds_cnt, ds_count); + status = -1; + } + + return (status); +} /* int parse_tag_rra_cdp_prep */ + +/* + * Parse the block within an RRA definition + */ +static int parse_tag_rra_params( + xmlDoc * doc, + xmlNode * node, + rra_def_t *rra_def) +{ + xmlNode *child; + int status; + + status = 0; + for (child = node->xmlChildrenNode; child != NULL; child = child->next) { + if ((xmlStrcmp(child->name, (const xmlChar *) "comment") == 0) + || (xmlStrcmp(child->name, (const xmlChar *) "text") == 0)) + /* ignore */ ; + /* + * Parameters for CF_HWPREDICT + */ + else if (xmlStrcmp(child->name, (const xmlChar *) "hw_alpha") == 0) + status = get_double_from_node(doc, child, + &rra_def->par[RRA_hw_alpha].u_val); + else if (xmlStrcmp(child->name, (const xmlChar *) "hw_beta") == 0) + status = get_double_from_node(doc, child, + &rra_def->par[RRA_hw_beta].u_val); + else if (xmlStrcmp(child->name, + (const xmlChar *) "dependent_rra_idx") == 0) + status = get_int_from_node(doc, child, + (int *) &rra_def-> + par[RRA_dependent_rra_idx].u_cnt); + /* + * Parameters for CF_SEASONAL and CF_DEVSEASONAL + */ + else if (xmlStrcmp(child->name, (const xmlChar *) "seasonal_gamma") == + 0) + status = + get_double_from_node(doc, child, + &rra_def->par[RRA_seasonal_gamma].u_val); + else if (xmlStrcmp + (child->name, (const xmlChar *) "seasonal_smooth_idx") == 0) + status = + get_int_from_node(doc, child, + (int *) &rra_def-> + par[RRA_seasonal_smooth_idx].u_cnt); + else if (xmlStrcmp(child->name, (const xmlChar *) "smoothing_window") + == 0) + status = + get_double_from_node(doc, child, + &rra_def-> + par[RRA_seasonal_smoothing_window]. + u_val); + /* else if (dependent_rra_idx) ...; */ + /* + * Parameters for CF_FAILURES + */ + else if (xmlStrcmp(child->name, (const xmlChar *) "delta_pos") == 0) + status = get_double_from_node(doc, child, + &rra_def->par[RRA_delta_pos].u_val); + else if (xmlStrcmp(child->name, (const xmlChar *) "delta_neg") == 0) + status = get_double_from_node(doc, child, + &rra_def->par[RRA_delta_neg].u_val); + else if (xmlStrcmp(child->name, (const xmlChar *) "window_len") == 0) + status = get_int_from_node(doc, child, + (int *) &rra_def->par[RRA_window_len]. + u_cnt); + else if (xmlStrcmp(child->name, (const xmlChar *) "failure_threshold") + == 0) + status = + get_int_from_node(doc, child, + (int *) &rra_def-> + par[RRA_failure_threshold].u_cnt); + /* + * Parameters for CF_AVERAGE, CF_MAXIMUM, CF_MINIMUM, and CF_LAST + */ + else if (xmlStrcmp(child->name, (const xmlChar *) "xff") == 0) + status = get_double_from_node(doc, child, + &rra_def->par[RRA_cdp_xff_val]. + u_val); + /* + * Compatibility code for 1.0.49 + */ + else if (xmlStrcmp(child->name, (const xmlChar *) "value") == 0) { /* {{{ */ + unsigned int i = 0; + + while (42) { + if (i >= ARRAY_LENGTH(rra_def->par)) { + status = -1; + break; + } + + if ((i == RRA_dependent_rra_idx) + || (i == RRA_seasonal_smooth_idx) + || (i == RRA_failure_threshold)) + status = get_int_from_node(doc, child, + (int *) &rra_def->par[i]. + u_cnt); + else + status = get_double_from_node(doc, child, + &rra_def->par[i].u_val); + + if (status != 0) + break; + + /* When this loops exits (sucessfully) `child' points to the last + * `value' tag in the list. */ + if ((child->next == NULL) + || (xmlStrcmp(child->name, (const xmlChar *) "value") != + 0)) + break; + + child = child->next; + i++; + } + } /* }}} */ + else { + rrd_set_error("parse_tag_rra_params: Unknown tag: %s", + child->name); + status = -1; + } + + 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; -} - - - - - -/* create and empty rrd file according to the specs given */ - -int -rrd_write(char *file_name, rrd_t *rrd, char force_overwrite) + } + + return (status); +} /* int parse_tag_rra_params */ + +/* + * Parse an RRA definition + */ +static int parse_tag_rra_cf( + xmlDoc * doc, + xmlNode * node, + rra_def_t *rra_def) { - 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); - } + int status; + + status = get_string_from_node(doc, node, + rra_def->cf_nam, sizeof(rra_def->cf_nam)); + if (status != 0) + return (-1); + + 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); } - fwrite(rrd->stat_head, - sizeof(stat_head_t), 1, rrd_file); - fwrite(rrd->ds_def, - sizeof(ds_def_t), rrd->stat_head->ds_cnt, rrd_file); + return (0); +} /* int parse_tag_rra_cf */ - fwrite(rrd->rra_def, - sizeof(rra_def_t), rrd->stat_head->rra_cnt, rrd_file); +static int parse_tag_rra( + xmlDoc * doc, + xmlNode * node, + rrd_t *rrd) +{ + xmlNode *child; + int status; - /* 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); + rra_def_t *cur_rra_def; + cdp_prep_t *cur_cdp_prep; + rra_ptr_t *cur_rra_ptr; - fwrite( rrd->pdp_prep, sizeof(pdp_prep_t),rrd->stat_head->ds_cnt,rrd_file); - - 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); + /* 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; - /* 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 = (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); + } /* }}} */ - /* 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 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; + for (child = node->xmlChildrenNode; child != NULL; child = child->next) { + if ((xmlStrcmp(child->name, (const xmlChar *) "comment") == 0) + || (xmlStrcmp(child->name, (const xmlChar *) "text") == 0)) + /* ignore */ ; + else if (xmlStrcmp(child->name, (const xmlChar *) "cf") == 0) + status = parse_tag_rra_cf(doc, child, cur_rra_def); + else if (xmlStrcmp(child->name, (const xmlChar *) "pdp_per_row") == 0) + status = get_int_from_node(doc, child, + (int *) &cur_rra_def->pdp_cnt); + else if (atoi(rrd->stat_head->version) == 1 + && xmlStrcmp(child->name, (const xmlChar *) "xff") == 0) + status = get_double_from_node(doc, child, + (double *) &cur_rra_def-> + par[RRA_cdp_xff_val].u_val); + else if (atoi(rrd->stat_head->version) >= 2 + && xmlStrcmp(child->name, (const xmlChar *) "params") == 0) + status = parse_tag_rra_params(doc, child, cur_rra_def); + else if (xmlStrcmp(child->name, (const xmlChar *) "cdp_prep") == 0) + status = parse_tag_rra_cdp_prep(doc, child, rrd, cur_cdp_prep); + else if (xmlStrcmp(child->name, (const xmlChar *) "database") == 0) + status = parse_tag_rra_database(doc, child, rrd); + else { + rrd_set_error("parse_tag_rra: Unknown tag: %s", child->name); + status = -1; + } + + if (status != 0) + break; } - - fclose(rrd_file); - return 0; -} + /* Set the RRA pointer to a random location */ + cur_rra_ptr->cur_row = random() % cur_rra_def->row_cnt; + + return (status); +} /* int parse_tag_rra */ -int -rrd_restore(int argc, char **argv) +/* + * Parse a DS definition + */ +static int parse_tag_ds_cdef( + xmlDoc * doc, + xmlNode * node, + rrd_t *rrd) { - rrd_t rrd; - char *buf; - char rc = 0; - char force_overwrite = 0; + char buffer[1024]; + int status; - /* init rrd clean */ - 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; + status = get_string_from_node(doc, node, buffer, sizeof(buffer)); + if (status != 0) + return (-1); + + /* We're always working on the last DS that has been added to the structure + * when we get here */ + parseCDEF_DS(buffer, rrd, rrd->stat_head->ds_cnt - 1); + + return (0); +} /* int parse_tag_ds_cdef */ + +static int parse_tag_ds_type( + xmlDoc * doc, + xmlNode * node, + ds_def_t *ds_def) +{ + int status; + + status = get_string_from_node(doc, node, + ds_def->dst, sizeof(ds_def->dst)); + if (status != 0) + return (-1); + + status = dst_conv(ds_def->dst); + if (status == -1) { + rrd_set_error("parse_tag_ds_type: Unknown data source type: %s", + ds_def->dst); + 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; - } + + return (0); +} /* int parse_tag_ds_type */ + +static int parse_tag_ds( + xmlDoc * doc, + xmlNode * node, + rrd_t *rrd) +{ + xmlNode *child; + int status; + + 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); } - - if (readfile(argv[optind],&buf,0)==-1){ - return -1; + + /* Allocate space for the new DS definition */ + { /* {{{ */ + ds_def_t *temp; + + 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; + for (child = node->xmlChildrenNode; child != NULL; child = child->next) { + if ((xmlStrcmp(child->name, (const xmlChar *) "comment") == 0) + || (xmlStrcmp(child->name, (const xmlChar *) "text") == 0)) + /* ignore */ ; + else if (xmlStrcmp(child->name, (const xmlChar *) "name") == 0) + status = get_string_from_node(doc, child, + cur_ds_def->ds_nam, + sizeof(cur_ds_def->ds_nam)); + else if (xmlStrcmp(child->name, (const xmlChar *) "type") == 0) + status = parse_tag_ds_type(doc, child, cur_ds_def); + else if (xmlStrcmp(child->name, + (const xmlChar *) "minimal_heartbeat") == 0) + status = get_int_from_node(doc, child, + (int *) &cur_ds_def->par[DS_mrhb_cnt]. + u_cnt); + else if (xmlStrcmp(child->name, (const xmlChar *) "min") == 0) + status = get_double_from_node(doc, child, + &cur_ds_def->par[DS_min_val].u_val); + else if (xmlStrcmp(child->name, (const xmlChar *) "max") == 0) + status = get_double_from_node(doc, child, + &cur_ds_def->par[DS_max_val].u_val); + else if (xmlStrcmp(child->name, (const xmlChar *) "cdef") == 0) + status = parse_tag_ds_cdef(doc, child, rrd); + else if (xmlStrcmp(child->name, (const xmlChar *) "last_ds") == 0) + status = get_string_from_node(doc, child, + cur_pdp_prep->last_ds, + sizeof(cur_pdp_prep->last_ds)); + else if (xmlStrcmp(child->name, (const xmlChar *) "value") == 0) + status = get_double_from_node(doc, child, + &cur_pdp_prep->scratch[PDP_val]. + u_val); + else if (xmlStrcmp(child->name, (const xmlChar *) "unknown_sec") == 0) + status = get_int_from_node(doc, child, + (int *) &cur_pdp_prep-> + scratch[PDP_unkn_sec_cnt].u_cnt); + else { + rrd_set_error("parse_tag_ds: Unknown tag: %s", child->name); + status = -1; + } + + if (status != 0) + break; } - if (xml2rrd(buf,&rrd,rc)==-1) { - rrd_free(&rrd); - free(buf); - return -1; + + return (status); +} /* int parse_tag_ds */ + +/* + * Parse root nodes + */ +static int parse_tag_rrd( + xmlDoc * doc, + xmlNode * node, + rrd_t *rrd) +{ + xmlNode *child; + int status; + + status = 0; + for (child = node->xmlChildrenNode; child != NULL; child = child->next) { + if ((xmlStrcmp(child->name, (const xmlChar *) "comment") == 0) + || (xmlStrcmp(child->name, (const xmlChar *) "text") == 0)) + /* ignore */ ; + else if (xmlStrcmp(child->name, (const xmlChar *) "version") == 0) + status = get_string_from_node(doc, child, + rrd->stat_head->version, + sizeof(rrd->stat_head->version)); + else if (xmlStrcmp(child->name, (const xmlChar *) "step") == 0) + status = get_int_from_node(doc, child, + (int *) &rrd->stat_head->pdp_step); + else if (xmlStrcmp(child->name, (const xmlChar *) "lastupdate") == 0) + status = get_int_from_node(doc, child, + (int *) &rrd->live_head->last_up); + else if (xmlStrcmp(child->name, (const xmlChar *) "ds") == 0) + status = parse_tag_ds(doc, child, rrd); + else if (xmlStrcmp(child->name, (const xmlChar *) "rra") == 0) + status = parse_tag_rra(doc, child, rrd); + else { + rrd_set_error("parse_tag_rrd: Unknown tag: %s", child->name); + status = -1; + } + + if (status != 0) + break; } - free(buf); - if(rrd_write(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) + + return (status); +} /* int parse_tag_rrd */ + +static rrd_t *parse_file( + const char *filename) { - 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)); - } -} - -/* 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) + xmlDoc *doc; + xmlNode *cur; + int status; + + rrd_t *rrd; + + doc = xmlParseFile(filename); + if (doc == NULL) { + rrd_set_error("Document not parsed successfully."); + return (NULL); + } + + cur = xmlDocGetRootElement(doc); + if (cur == NULL) { + rrd_set_error("Document is empty."); + xmlFreeDoc(doc); + return (NULL); + } + + if (xmlStrcmp(cur->name, (const xmlChar *) "rrd") != 0) { + rrd_set_error + ("Document of the wrong type, root node is not \"rrd\"."); + xmlFreeDoc(doc); + return (NULL); + } + + rrd = (rrd_t *) malloc(sizeof(rrd_t)); + if (rrd == NULL) { + rrd_set_error("parse_file: malloc failed."); + xmlFreeDoc(doc); + 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."); + xmlFreeDoc(doc); + 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."); + xmlFreeDoc(doc); + free(rrd->stat_head); + free(rrd); + return (NULL); + } + memset(rrd->live_head, '\0', sizeof(live_head_t)); + + status = parse_tag_rrd(doc, cur, rrd); + + xmlFreeDoc(doc); + if (status != 0) { + 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)); - } - } -} - -void -parse_FAILURES_history(char **buf, rrd_t *rrd, int rra_index, int ds_index) + 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; + } + + /* 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; + + srandom((unsigned int) time(NULL) + (unsigned int) getpid()); + /* 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) { + rrd_free(rrd); + return (-1); + } + + rrd_free(rrd); + return (0); +} /* int rrd_restore */ + +/* vim: set sw=2 sts=2 ts=8 et fdm=marker : */