src/rrd_graph_helper.c

   1 /****************************************************************************
   2  * RRDtool 1.2.14  Copyright by Tobi Oetiker, 1997-2006
   3  ****************************************************************************
   4  * rrd_graph_helper.c  commandline parser functions
   5  *                     this code initially written by Alex van den Bogaerdt
   6  ****************************************************************************/
   7
   8 #include "rrd_graph.h"
   9
  10 #define dprintf if (gdp->debug) printf
  11
  12 /* NOTE ON PARSING:
  13  *
  14  * we use the following:
  15  *
  16  * i=0;  sscanf(&line[*eaten], "what to find%n", variables, &i)
  17  *
  18  * Usually you want to find a separator as well.  Example:
  19  * i=0; sscanf(&line[*eaten], "%li:%n", &someint, &i)
  20  *
  21  * When the separator is not found, i is not set and thus remains zero.
  22  * Another way would be to compare strlen() to i
  23  *
  24  * Why is this important?  Because 12345abc should not be matched as
  25  * integer 12345 ...
  26  */
  27
  28 /* NOTE ON VNAMES:
  29  *
  30  * "if ((gdp->vidx=find_var(im, l))!=-1)" is not good enough, at least
  31  * not by itself.
  32  *
  33  * A vname as a result of a VDEF is quite different from a vname
  34  * resulting of a DEF or CDEF.
  35  */
  36
  37 /* NOTE ON VNAMES:
  38  *
  39  * A vname called "123" is not to be parsed as the number 123
  40  */
  41
  42
  43 /* Define prototypes for the parsing methods.
  44   Inputs:
  45    const char *const line    - a fixed pointer to a fixed string
  46    unsigned int *const eaten - a fixed pointer to a changing index in that line
  47    graph_desc_t *const gdp   - a fixed pointer to a changing graph description
  48    image_desc_t *const im    - a fixed pointer to a changing image description
  49 */
  50
  51 int rrd_parse_find_gf (const char * const, unsigned int *const, graph_desc_t *const);
  52 int rrd_parse_legend  (const char * const, unsigned int *const, graph_desc_t *const);
  53 int rrd_parse_color   (const char * const, graph_desc_t *const);
  54 int rrd_parse_CF      (const char * const, unsigned int *const, graph_desc_t *const, enum cf_en *const);
  55 int rrd_parse_print   (const char * const, unsigned int *const, graph_desc_t *const, image_desc_t *const);
  56 int rrd_parse_shift   (const char * const, unsigned int *const, graph_desc_t *const, image_desc_t *const);
  57 int rrd_parse_xport   (const char * const, unsigned int *const, graph_desc_t *const, image_desc_t *const);
  58 int rrd_parse_PVHLAST (const char * const, unsigned int *const, graph_desc_t *const, image_desc_t *const);
  59 int rrd_parse_make_vname   (const char * const, unsigned int *const, graph_desc_t *const, image_desc_t *const);
  60 int rrd_parse_find_vname   (const char * const, unsigned int *const, graph_desc_t *const, image_desc_t *const);
  61 int rrd_parse_def     (const char * const, unsigned int *const, graph_desc_t *const, image_desc_t *const);
  62 int rrd_parse_vdef    (const char * const, unsigned int *const, graph_desc_t *const, image_desc_t *const);
  63 int rrd_parse_cdef    (const char * const, unsigned int *const, graph_desc_t *const, image_desc_t *const);
  64
  65
  66
  67 int
  68 rrd_parse_find_gf(const char *const line, unsigned int *const eaten, graph_desc_t *const gdp) {
  69     char funcname[11],c1=0;
  70     int i=0;
  71
  72     /* start an argument with DEBUG to be able to see how it is parsed */
  73     sscanf(&line[*eaten], "DEBUG%n", &i);
  74     if (i) {
  75         gdp->debug=1;
  76         (*eaten)+=i;
  77         i=0;
  78         dprintf("Scanning line '%s'\n",&line[*eaten]);
  79     }
  80     i=0;c1='\0';
  81     sscanf(&line[*eaten], "%10[A-Z]%n%c", funcname, &i, &c1);
  82     if (!i) {
  83         rrd_set_error("Could not make sense out of '%s'",line);
  84         return 1;
  85     }
  86     (*eaten)+=i;
  87     if ((int)(gdp->gf=gf_conv(funcname)) == -1) {
  88         rrd_set_error("'%s' is not a valid function name", funcname);
  89         return 1;
  90     } else {
  91         dprintf("- found function name '%s'\n",funcname);
  92     }
  93
  94     if (c1 == '\0') {
  95         rrd_set_error("Function %s needs parameters.  Line: %s\n",funcname,line);
  96         return 1;
  97     }
  98     if (c1 == ':') (*eaten)++;
  99
 100     /* Some commands have a parameter before the colon
 101      * (currently only LINE)
 102      */
 103     switch (gdp->gf) {
 104         case GF_LINE:
 105             if (c1 == ':') {
 106                 gdp->linewidth=1;
 107                 dprintf("- - using default width of 1\n");
 108             } else {
 109                 i=0;sscanf(&line[*eaten],"%lf:%n",&gdp->linewidth,&i);
 110                 if (!i) {
 111                     rrd_set_error("Cannot parse line width '%s' in line '%s'\n",&line[*eaten],line);
 112                     return 1;
 113                 } else {
 114                     dprintf("- - scanned width %f\n",gdp->linewidth);
 115                     if (isnan(gdp->linewidth)) {
 116                         rrd_set_error("LINE width '%s' is not a number in line '%s'\n",&line[*eaten],line);
 117                         return 1;
 118                     }
 119                     if (isinf(gdp->linewidth)) {
 120                         rrd_set_error("LINE width '%s' is out of range in line '%s'\n",&line[*eaten],line);
 121                         return 1;
 122                     }
 123                     if (gdp->linewidth<0) {
 124                         rrd_set_error("LINE width '%s' is less than 0 in line '%s'\n",&line[*eaten],line);
 125                         return 1;
 126                     }
 127                 }
 128                 (*eaten)+=i;
 129             }
 130             break;
 131         default:
 132             if (c1 == ':') break;
 133             rrd_set_error("Malformed '%s' command in line '%s'\n",&line[*eaten],line);
 134             return 1;
 135     }
 136     return 0;
 137 }
 138
 139 int
 140 rrd_parse_legend(const char *const line, unsigned int *const eaten, graph_desc_t *const gdp) {
 141     int i;
 142
 143     if (line[*eaten]=='\0' || line[*eaten]==':') {
 144         dprintf("- no (or: empty) legend found\n");
 145         return 0;
 146     }
 147
 148     i=scan_for_col(&line[*eaten],FMT_LEG_LEN,gdp->legend);
 149
 150     (*eaten)+=i;
 151
 152     if (line[*eaten]!='\0' && line[*eaten]!=':') {
 153         rrd_set_error("Legend too long");
 154         return 1;
 155     } else {
 156         return 0;
 157     }
 158 }
 159
 160 int
 161 rrd_parse_color(const char *const string, graph_desc_t *const gdp) {
 162     unsigned int r=0,g=0,b=0,a=0,i;
 163
 164     /* matches the following formats:
 165     ** RGB
 166     ** RGBA
 167     ** RRGGBB
 168     ** RRGGBBAA
 169     */
 170
 171     i=0;
 172     while (string[i] && isxdigit((unsigned int)string[i])) i++;
 173     if (string[i] != '\0') return 1; /* garbage follows hexdigits */
 174     switch (i) {
 175         case 3:
 176         case 4:
 177             sscanf(string, "%1x%1x%1x%1x",&r,&g,&b,&a);
 178             r *= 0x11;
 179             g *= 0x11;
 180             b *= 0x11;
 181             a *= 0x11;
 182             if (i==3) a=0xFF;
 183             break;
 184         case 6:
 185         case 8:
 186             sscanf(string, "%02x%02x%02x%02x",&r,&g,&b,&a);
 187             if (i==6) a=0xFF;
 188             break;
 189         default:
 190             return 1;   /* wrong number of digits */
 191     }
 192     gdp->col = r<<24|g<<16|b<<8|a;
 193     return 0;
 194 }
 195
 196 int
 197 rrd_parse_CF(const char *const line, unsigned int *const eaten, graph_desc_t *const gdp, enum cf_en *cf) {
 198     char                symname[CF_NAM_SIZE];
 199     int                 i=0;
 200
 201     sscanf(&line[*eaten], CF_NAM_FMT "%n", symname,&i);
 202     if ((!i)||((line[(*eaten)+i]!='\0')&&(line[(*eaten)+i]!=':'))) {
 203         rrd_set_error("Cannot parse CF in '%s'",line);
 204         return 1;
 205     }
 206     (*eaten)+=i;
 207     dprintf("- using CF '%s'\n",symname);
 208
 209     if ((int)(*cf = cf_conv(symname))==-1) {
 210         rrd_set_error("Unknown CF '%s' in '%s'",symname,line);
 211         return 1;
 212     }
 213
 214     if (line[*eaten]!='\0') (*eaten)++;
 215     return 0;
 216 }
 217
 218 /* Try to match next token as a vname.
 219  *
 220  * Returns:
 221  * -1     an error occured and the error string is set
 222  * other  the vname index number
 223  *
 224  * *eaten is incremented only when a vname is found.
 225  */
 226 int
 227 rrd_parse_find_vname(const char *const line, unsigned int *const eaten, graph_desc_t *const gdp, image_desc_t *const im) {
 228     char tmpstr[MAX_VNAME_LEN+1];
 229     int i;
 230     long vidx;
 231
 232     i=0;sscanf(&line[*eaten], DEF_NAM_FMT "%n", tmpstr,&i);
 233     if (!i) {
 234         rrd_set_error("Could not parse line '%s'",line);
 235         return -1;
 236     }
 237     if (line[*eaten+i]!=':' && line[*eaten+i]!='\0') {
 238         rrd_set_error("Could not parse line '%s'",line);
 239         return -1;
 240     }
 241     dprintf("- Considering '%s'\n",tmpstr);
 242
 243     if ((vidx=find_var(im,tmpstr))<0) {
 244         dprintf("- Not a vname\n");
 245         rrd_set_error("Not a valid vname: %s in line %s",tmpstr,line);
 246         return -1;
 247     }
 248     dprintf("- Found vname '%s' vidx '%li'\n",tmpstr,gdp->vidx);
 249     if (line[*eaten+i]==':') i++;
 250     (*eaten)+=i;
 251     return vidx;
 252 }
 253
 254 /* Parsing old-style xPRINT and new-style xPRINT */
 255 int
 256 rrd_parse_print(const char *const line, unsigned int *const eaten, graph_desc_t *const gdp, image_desc_t *const im) {
 257     /* vname:CF:format in case of DEF-based vname
 258     ** vname:CF:format in case of CDEF-based vname
 259     ** vname:format[:strftime] in case of VDEF-based vname
 260     */
 261     if ((gdp->vidx=rrd_parse_find_vname(line,eaten,gdp,im))<0) return 1;
 262
 263     switch (im->gdes[gdp->vidx].gf) {
 264         case GF_DEF:
 265         case GF_CDEF:
 266             dprintf("- vname is of type DEF or CDEF, looking for CF\n");
 267             if (rrd_parse_CF(line,eaten,gdp,&gdp->cf)) return 1;
 268             break;
 269         case GF_VDEF:
 270             dprintf("- vname is of type VDEF\n");
 271             break;
 272         default:
 273             rrd_set_error("Encountered unknown type variable '%s'",im->gdes[gdp->vidx].vname);
 274             return 1;
 275     }
 276
 277     if (rrd_parse_legend(line,eaten,gdp)) return 1;
 278     /* for *PRINT the legend itself gets rendered later. We only
 279        get the format at this juncture */
 280     strcpy(gdp->format,gdp->legend);
 281     gdp->legend[0]='\0';
 282     /* this is a very crud test, parsing :style flags should be in a function */
 283     if (im->gdes[gdp->vidx].gf == GF_VDEF && strcmp(line+(*eaten),":strftime")==0){
 284         gdp->strftm = 1;
 285         (*eaten)+=strlen(":strftime");
 286     }
 287     return 0;
 288 }
 289
 290 /* SHIFT:_def_or_cdef:_vdef_or_number_
 291  */
 292 int
 293 rrd_parse_shift(const char *const line, unsigned int *const eaten, graph_desc_t *const gdp, image_desc_t *const im) {
 294     int i;
 295
 296     if ((gdp->vidx=rrd_parse_find_vname(line,eaten,gdp,im))<0) return 1;
 297
 298     switch (im->gdes[gdp->vidx].gf) {
 299         case GF_DEF:
 300         case GF_CDEF:
 301             dprintf("- vname is of type DEF or CDEF, OK\n");
 302             break;
 303         case GF_VDEF:
 304             rrd_set_error("Cannot shift a VDEF: '%s' in line '%s'\n",im->gdes[gdp->vidx].vname,line);
 305             return 1;
 306         default:
 307             rrd_set_error("Encountered unknown type variable '%s' in line '%s'",im->gdes[gdp->vidx].vname,line);
 308             return 1;
 309     }
 310
 311     if ((gdp->shidx=rrd_parse_find_vname(line,eaten,gdp,im))>=0) {
 312         switch (im->gdes[gdp->shidx].gf) {
 313             case GF_DEF:
 314             case GF_CDEF:
 315                 rrd_set_error("Offset cannot be a (C)DEF: '%s' in line '%s'\n",im->gdes[gdp->shidx].vname,line);
 316                 return 1;
 317             case GF_VDEF:
 318                 dprintf("- vname is of type VDEF, OK\n");
 319                 break;
 320             default:
 321                 rrd_set_error("Encountered unknown type variable '%s' in line '%s'",im->gdes[gdp->vidx].vname,line);
 322                 return 1;
 323         }
 324     } else {
 325         rrd_clear_error();
 326         i=0; sscanf(&line[*eaten],"%li%n",&gdp->shval,&i);
 327         if (i!=(int)strlen(&line[*eaten])) {
 328             rrd_set_error("Not a valid offset: %s in line %s",&line[*eaten],line);
 329             return 1;
 330         }
 331         (*eaten)+=i;
 332         dprintf("- offset is number %li\n",gdp->shval);
 333         gdp->shidx = -1;
 334     }
 335     return 0;
 336 }
 337
 338 /* XPORT:_def_or_cdef[:legend]
 339  */
 340 int
 341 rrd_parse_xport(const char *const line, unsigned int *const eaten, graph_desc_t *const gdp, image_desc_t *const im) {
 342     if ((gdp->vidx=rrd_parse_find_vname(line,eaten,gdp,im))<0) return 1;
 343
 344     switch (im->gdes[gdp->vidx].gf) {
 345         case GF_DEF:
 346         case GF_CDEF:
 347             dprintf("- vname is of type DEF or CDEF, OK\n");
 348             break;
 349         case GF_VDEF:
 350             rrd_set_error("Cannot xport a VDEF: '%s' in line '%s'\n",im->gdes[gdp->vidx].vname,line);
 351             return 1;
 352         default:
 353             rrd_set_error("Encountered unknown type variable '%s' in line '%s'",im->gdes[gdp->vidx].vname,line);
 354             return 1;
 355     }
 356     dprintf("- looking for legend in '%s'\n",&line[*eaten]);
 357     if (rrd_parse_legend(line,eaten,gdp)) return 1;
 358     return 0;
 359 }
 360
 361 /* Parsing of PART, VRULE, HRULE, LINE, AREA, STACK and TICK
 362 ** is done in one function.
 363 **
 364 ** Stacking PART, VRULE, HRULE or TICK is not allowed.
 365 **
 366 ** If a number (which is valid to enter) is more than a
 367 ** certain amount of characters, it is caught as an error.
 368 ** While this is arguable, so is entering fixed numbers
 369 ** with more than MAX_VNAME_LEN significant digits.
 370 */
 371 int
 372 rrd_parse_PVHLAST(const char *const line, unsigned int *const eaten, graph_desc_t *const gdp, image_desc_t *const im) {
 373     int i,j,k;
 374     int colorfound=0;
 375     char tmpstr[MAX_VNAME_LEN + 10];    /* vname#RRGGBBAA\0 */
 376     static int spacecnt = 0;
 377
 378     if (spacecnt == 0) {
 379         float one_space = gfx_get_text_width(im->canvas, 0,
 380                                im->text_prop[TEXT_PROP_LEGEND].font,
 381                                im->text_prop[TEXT_PROP_LEGEND].size,
 382                                im->tabwidth,"    ", 0) / 4.0;
 383         float target_space = gfx_get_text_width(im->canvas, 0,
 384                                im->text_prop[TEXT_PROP_LEGEND].font,
 385                                im->text_prop[TEXT_PROP_LEGEND].size,
 386                                im->tabwidth,"oo", 0);
 387         spacecnt =  target_space / one_space;
 388         dprintf("- spacecnt: %i onespace: %f targspace: %f\n",spacecnt,one_space,target_space);
 389     }
 390
 391
 392     dprintf("- parsing '%s'\n",&line[*eaten]);
 393
 394     /* have simpler code in the drawing section */
 395     if ( gdp->gf == GF_STACK ){
 396             gdp->stack=1;
 397     }
 398
 399     i=scan_for_col(&line[*eaten],MAX_VNAME_LEN+9,tmpstr);
 400     if (line[*eaten+i]!='\0' && line[*eaten+i]!=':') {
 401         rrd_set_error("Cannot parse line '%s'",line);
 402         return 1;
 403     }
 404
 405     j=i; while (j>0 && tmpstr[j]!='#') j--;
 406
 407     if (j) {
 408         tmpstr[j]='\0';
 409     }
 410     /* We now have:
 411      * tmpstr[0]    containing vname
 412      * tmpstr[j]    if j!=0 then containing color
 413      * i            size of vname + color
 414      * j            if j!=0 then size of vname
 415      */
 416
 417     /* Number or vname ?
 418      * If it is an existing vname, that's OK, provided that it is a
 419      * valid type (need time for VRULE, not a float)
 420      * Else see if it parses as a number.
 421      */
 422     dprintf("- examining string '%s'\n",tmpstr);
 423     if ((gdp->vidx=find_var(im,tmpstr))>=0) {
 424         dprintf("- found vname: '%s' vidx %li\n",tmpstr,gdp->vidx);
 425         switch (gdp->gf) {
 426 #ifdef WITH_PIECHART
 427             case GF_PART:
 428 #endif
 429             case GF_VRULE:
 430             case GF_HRULE:
 431                 if (im->gdes[gdp->vidx].gf != GF_VDEF) {
 432                     rrd_set_error("Using vname %s of wrong type in line %s\n",im->gdes[gdp->gf].vname,line);
 433                     return 1;
 434                 }
 435                 break;
 436             default:;
 437         }
 438     } else {
 439         dprintf("- it is not an existing vname\n");
 440         switch (gdp->gf) {
 441             case GF_VRULE:
 442                 k=0;sscanf(tmpstr,"%li%n",&gdp->xrule,&k);
 443                 if (((j!=0)&&(k==j))||((j==0)&&(k==i))) {
 444                     dprintf("- found time: %li\n",gdp->xrule);
 445                 } else {
 446                     dprintf("- is is not a valid number: %li\n",gdp->xrule);
 447                     rrd_set_error("parameter '%s' does not represent time in line %s\n",tmpstr,line);
 448                     return 1;
 449                 }
 450             default:
 451                 k=0;sscanf(tmpstr,"%lf%n",&gdp->yrule,&k);
 452                 if (((j!=0)&&(k==j))||((j==0)&&(k==i))) {
 453                     dprintf("- found number: %f\n",gdp->yrule);
 454                 } else {
 455                     dprintf("- is is not a valid number: %li\n",gdp->xrule);
 456                     rrd_set_error("parameter '%s' does not represent a number in line %s\n",tmpstr,line);
 457                     return 1;
 458                 }
 459         }
 460     }
 461
 462     if (j) {
 463         j++;
 464         dprintf("- examining color '%s'\n",&tmpstr[j]);
 465         if (rrd_parse_color(&tmpstr[j],gdp)) {
 466             rrd_set_error("Could not parse color in '%s'",&tmpstr[j]);
 467             return 1;
 468         }
 469         dprintf("- parsed color 0x%08x\n",(unsigned int)gdp->col);
 470         colorfound=1;
 471     } else {
 472         dprintf("- no color present in '%s'\n",tmpstr);
 473     }
 474
 475     (*eaten) += i; /* after vname#color */
 476     if (line[*eaten]!='\0') {
 477         (*eaten)++;     /* after colon */
 478     }
 479
 480     if (gdp->gf == GF_TICK) {
 481         dprintf("- parsing '%s'\n",&line[*eaten]);
 482         dprintf("- looking for optional TICK number\n");
 483         j=0;
 484         sscanf(&line[*eaten],"%lf%n",&gdp->yrule,&j);
 485         if (j) {
 486             if (line[*eaten+j]!='\0' && line[*eaten+j]!=':') {
 487                 rrd_set_error("Cannot parse TICK fraction '%s'",line);
 488                 return 1;
 489             }
 490             dprintf("- found number %f\n",gdp->yrule);
 491             if (gdp->yrule > 1.0 || gdp->yrule < -1.0) {
 492                 rrd_set_error("Tick factor should be <= 1.0");
 493                 return 1;
 494             }
 495             (*eaten)+=j;
 496         } else {
 497             dprintf("- not found, defaulting to 0.1\n");
 498             gdp->yrule=0.1;
 499         }
 500         if (line[*eaten] == '\0') {
 501             dprintf("- done parsing line\n");
 502             return 0;
 503         } else { if (line[*eaten] == ':') {
 504                     (*eaten)++;
 505                  } else {
 506                      rrd_set_error("Can't make sense of that TICK line");
 507                    return 1;
 508                  }
 509         }
 510     }
 511
 512     dprintf("- parsing '%s'\n",&line[*eaten]);
 513
 514     /* Legend is next.  A legend without a color is an error.
 515     ** Stacking an item without having a legend is OK however
 516     ** then an empty legend should be specified.
 517     **   LINE:val#color:STACK   means legend is string "STACK"
 518     **   LINE:val#color::STACK  means no legend, and do STACK
 519     **   LINE:val:STACK         is an error (legend but no color)
 520     **   LINE:val::STACK        means no legend, and do STACK
 521     */
 522     if (colorfound) {
 523         int err=0;
 524         char *linecp = strdup(line);
 525         dprintf("- looking for optional legend\n");
 526
 527         dprintf("- examining '%s'\n",&line[*eaten]);
 528         if (linecp[*eaten] != '\0' && linecp[*eaten] != ':') {
 529             int spi;
 530             /* If the legend is not empty, it has to be prefixed with spacecnt ' ' characters. This then gets
 531              * replaced by the color box later on. */
 532             for (spi=0;spi<spacecnt && (*eaten) > 1;spi++){
 533                linecp[--(*eaten)]=' ';
 534             }
 535         }
 536
 537         if (rrd_parse_legend(linecp, eaten, gdp)) err=1;
 538         free(linecp);
 539         if (err) return 1;
 540
 541         dprintf("- found legend '%s'\n", &gdp->legend[2]);
 542     } else {
 543         dprintf("- skipping empty legend\n");
 544         if (line[*eaten] != '\0' && line[*eaten] != ':') {
 545             rrd_set_error("Legend set but no color: %s",&line[*eaten]);
 546             return 1;
 547         }
 548     }
 549     if (line[*eaten]=='\0') {
 550         dprintf("- done parsing line\n");
 551         return 0;
 552     }
 553     (*eaten)++; /* after colon */
 554
 555     /* PART, HRULE, VRULE and TICK cannot be stacked. */
 556     if (   (gdp->gf == GF_HRULE)
 557         || (gdp->gf == GF_VRULE)
 558 #ifdef WITH_PIECHART
 559         || (gdp->gf == GF_PART)
 560 #endif
 561         || (gdp->gf == GF_TICK)
 562         ) return 0;
 563
 564     dprintf("- parsing '%s'\n",&line[*eaten]);
 565     if (line[*eaten]!='\0') {
 566         dprintf("- still more, should be STACK\n");
 567         j=scan_for_col(&line[*eaten],5,tmpstr);
 568         if (line[*eaten+j]!='\0' && line[*eaten+j]!=':') {
 569             /* not 5 chars */
 570             rrd_set_error("Garbage found where STACK expected");
 571             return 1;
 572         }
 573         if (!strcmp("STACK",tmpstr)) {
 574             dprintf("- found STACK\n");
 575             gdp->stack=1;
 576             (*eaten)+=j;
 577         } else {
 578             rrd_set_error("Garbage found where STACK expected");
 579             return 1;
 580         }
 581     }
 582     if (line[*eaten]=='\0') {
 583         dprintf("- done parsing line\n");
 584         return 0;
 585     }
 586     (*eaten)++;
 587     dprintf("- parsing '%s'\n",&line[*eaten]);
 588
 589     return 0;
 590 }
 591
 592 int
 593 rrd_parse_make_vname(const char *const line, unsigned int *const eaten, graph_desc_t *const gdp, image_desc_t *const im) {
 594     char tmpstr[MAX_VNAME_LEN + 10];
 595     int i=0;
 596
 597     sscanf(&line[*eaten], DEF_NAM_FMT "=%n", tmpstr,&i);
 598     if (!i) {
 599         rrd_set_error("Cannot parse vname from '%s'",line);
 600         return 1;
 601     }
 602     dprintf("- found candidate '%s'\n",tmpstr);
 603
 604     if ((gdp->vidx=find_var(im,tmpstr))>=0) {
 605         rrd_set_error("Attempting to reuse '%s'",im->gdes[gdp->vidx].vname);
 606         return 1;
 607     }
 608     strcpy(gdp->vname,tmpstr);
 609     dprintf("- created vname '%s' vidx %lu\n", gdp->vname,im->gdes_c-1);
 610     (*eaten)+=i;
 611     return 0;
 612 }
 613
 614 int
 615 rrd_parse_def(const char *const line, unsigned int *const eaten, graph_desc_t *const gdp, image_desc_t *const im) {
 616     int                 i=0;
 617     char                command[7]; /* step, start, end, reduce */
 618     char                tmpstr[256];
 619     struct rrd_time_value       start_tv,end_tv;
 620     time_t              start_tmp=0,end_tmp=0;
 621     char                *parsetime_error=NULL;
 622
 623     start_tv.type   = end_tv.type=ABSOLUTE_TIME;
 624     start_tv.offset = end_tv.offset=0;
 625     localtime_r(&gdp->start, &start_tv.tm);
 626     localtime_r(&gdp->end, &end_tv.tm);
 627
 628     dprintf("- parsing '%s'\n",&line[*eaten]);
 629     dprintf("- from line '%s'\n",line);
 630
 631     if (rrd_parse_make_vname(line,eaten,gdp,im)) return 1;
 632     i=scan_for_col(&line[*eaten],254,gdp->rrd);
 633     if (line[*eaten+i]!=':') {
 634         rrd_set_error("Problems reading database name");
 635         return 1;
 636     }
 637     (*eaten)+=++i;
 638     dprintf("- using file '%s'\n",gdp->rrd);
 639
 640     i=0;
 641     sscanf(&line[*eaten], DS_NAM_FMT ":%n", gdp->ds_nam,&i);
 642     if (!i) {
 643         rrd_set_error("Cannot parse DS in '%s'",line);
 644         return 1;
 645     }
 646     (*eaten)+=i;
 647     dprintf("- using DS '%s'\n",gdp->ds_nam);
 648
 649     if (rrd_parse_CF(line,eaten,gdp,&gdp->cf)) return 1;
 650     gdp->cf_reduce = gdp->cf;
 651
 652     if (line[*eaten]=='\0') return 0;
 653
 654     while (1) {
 655         dprintf("- optional parameter follows: %s\n", &line[*eaten]);
 656         i=0;
 657         sscanf(&line[*eaten], "%6[a-z]=%n", command, &i);
 658         if (!i) {
 659             rrd_set_error("Parse error in '%s'",line);
 660             return 1;
 661         }
 662         (*eaten)+=i;
 663         dprintf("- processing '%s'\n",command);
 664         if (!strcmp("reduce",command)) {
 665           if (rrd_parse_CF(line,eaten,gdp,&gdp->cf_reduce)) return 1;
 666           if (line[*eaten] != '\0')
 667               (*eaten)--;
 668         } else if (!strcmp("step",command)) {
 669             i=0;
 670             sscanf(&line[*eaten],"%lu%n",&gdp->step,&i);
 671             gdp->step_orig = gdp->step;
 672             (*eaten)+=i;
 673             dprintf("- using step %lu\n",gdp->step);
 674         } else if (!strcmp("start",command)) {
 675             i=scan_for_col(&line[*eaten],255,tmpstr);
 676             (*eaten)+=i;
 677             if ((parsetime_error = parsetime(tmpstr, &start_tv))) {
 678                 rrd_set_error( "start time: %s", parsetime_error );
 679                 return 1;
 680             }
 681             dprintf("- done parsing:  '%s'\n",&line[*eaten]);
 682         } else if (!strcmp("end",command)) {
 683             i=scan_for_col(&line[*eaten],255,tmpstr);
 684             (*eaten)+=i;
 685             if ((parsetime_error = parsetime(tmpstr, &end_tv))) {
 686                 rrd_set_error( "end time: %s", parsetime_error );
 687                 return 1;
 688             }
 689             dprintf("- done parsing:  '%s'\n",&line[*eaten]);
 690         } else {
 691             rrd_set_error("Parse error in '%s'",line);
 692             return 1;
 693         }
 694         if (line[*eaten]=='\0') break;
 695         if (line[*eaten]!=':') {
 696             dprintf("- Expected to see end of string but got '%s'\n",\
 697                                                          &line[*eaten]);
 698             rrd_set_error("Parse error in '%s'",line);
 699             return 1;
 700         }
 701         (*eaten)++;
 702     }
 703     if (proc_start_end(&start_tv,&end_tv,&start_tmp,&end_tmp) == -1){
 704         /* error string is set in parsetime.c */
 705         return 1;
 706     }
 707     if (start_tmp < 3600*24*365*10) {
 708         rrd_set_error("the first entry to fetch should be "
 709                         "after 1980 (%ld)",start_tmp);
 710         return 1;
 711     }
 712
 713     if (end_tmp < start_tmp) {
 714         rrd_set_error("start (%ld) should be less than end (%ld)",
 715                         start_tmp, end_tmp);
 716         return 1;
 717     }
 718
 719     gdp->start = start_tmp;
 720     gdp->end = end_tmp;
 721     gdp->start_orig = start_tmp;
 722     gdp->end_orig = end_tmp;
 723
 724     dprintf("- start time %lu\n",gdp->start);
 725     dprintf("- end   time %lu\n",gdp->end);
 726
 727     return 0;
 728 }
 729
 730 int
 731 rrd_parse_vdef(const char *const line, unsigned int *const eaten, graph_desc_t *const gdp, image_desc_t *const im) {
 732     char tmpstr[MAX_VNAME_LEN+1];       /* vname\0 */
 733     int i=0;
 734
 735     dprintf("- parsing '%s'\n",&line[*eaten]);
 736     if (rrd_parse_make_vname(line,eaten,gdp,im)) return 1;
 737
 738     sscanf(&line[*eaten], DEF_NAM_FMT ",%n", tmpstr,&i);
 739     if (!i) {
 740         rrd_set_error("Cannot parse line '%s'",line);
 741         return 1;
 742     }
 743     if ((gdp->vidx=find_var(im,tmpstr))<0) {
 744         rrd_set_error("Not a valid vname: %s in line %s",tmpstr,line);
 745         return 1;
 746     }
 747     if (   im->gdes[gdp->vidx].gf != GF_DEF
 748         && im->gdes[gdp->vidx].gf != GF_CDEF) {
 749         rrd_set_error("variable '%s' not DEF nor "
 750                         "CDEF in VDEF '%s'", tmpstr,gdp->vname);
 751         return 1;
 752     }
 753     dprintf("- found vname: '%s' vidx %li\n",tmpstr,gdp->vidx);
 754     (*eaten)+=i;
 755
 756     dprintf("- calling vdef_parse with param '%s'\n",&line[*eaten]);
 757     vdef_parse(gdp,&line[*eaten]);
 758     while (line[*eaten]!='\0'&&line[*eaten]!=':')
 759         (*eaten)++;
 760
 761     return 0;
 762 }
 763
 764 int
 765 rrd_parse_cdef(const char *const line, unsigned int *const eaten, graph_desc_t *const gdp, image_desc_t *const im) {
 766     dprintf("- parsing '%s'\n",&line[*eaten]);
 767     if (rrd_parse_make_vname(line,eaten,gdp,im)) return 1;
 768     if ((gdp->rpnp = rpn_parse(
 769         (void *)im,
 770         &line[*eaten],
 771         &find_var_wrapper)
 772     )==NULL) {
 773         rrd_set_error("invalid rpn expression in: %s",&line[*eaten]);
 774         return 1;
 775     };
 776     while (line[*eaten]!='\0'&&line[*eaten]!=':')
 777         (*eaten)++;
 778     return 0;
 779 }
 780
 781 void
 782 rrd_graph_script(int argc, char *argv[], image_desc_t *const im, int optno) {
 783     int i;
 784     /* save state for STACK backward compat function */
 785     enum gf_en     last_gf=GF_PRINT;
 786     float          last_linewidth=0.0;
 787
 788     for (i=optind+optno;i<argc;i++) {
 789         graph_desc_t *gdp;
 790         unsigned int eaten=0;
 791
 792         if (gdes_alloc(im)) return; /* the error string is already set */
 793         gdp = &im->gdes[im->gdes_c-1];
 794 #ifdef DEBUG
 795         gdp->debug = 1;
 796 #endif
 797
 798         if (rrd_parse_find_gf(argv[i],&eaten,gdp)) return;
 799
 800         switch (gdp->gf) {
 801             case GF_SHIFT:      /* vname:value */
 802                 if (rrd_parse_shift(argv[i],&eaten,gdp,im)) return;
 803                 break;
 804             case GF_XPORT:
 805                 if (rrd_parse_xport(argv[i],&eaten,gdp,im)) return;
 806                 break;
 807             case GF_PRINT:      /* vname:CF:format -or- vname:format */
 808                 im->prt_c++;
 809             case GF_GPRINT:     /* vname:CF:format -or- vname:format */
 810                 if (rrd_parse_print(argv[i],&eaten,gdp,im)) return;
 811                 break;
 812             case GF_COMMENT:    /* text */
 813                 if (rrd_parse_legend(argv[i],&eaten,gdp)) return;
 814                 break;
 815 #ifdef WITH_PIECHART
 816             case GF_PART:       /* value[#color[:legend]] */
 817 #endif
 818             case GF_VRULE:      /* value#color[:legend] */
 819             case GF_HRULE:      /* value#color[:legend] */
 820             case GF_LINE:       /* vname-or-value[#color[:legend]][:STACK] */
 821             case GF_AREA:       /* vname-or-value[#color[:legend]][:STACK] */
 822             case GF_TICK:       /* vname#color[:num[:legend]] */
 823                 if (rrd_parse_PVHLAST(argv[i],&eaten,gdp,im))return;
 824                 last_gf = gdp->gf;
 825                 last_linewidth = gdp->linewidth;
 826                 break;
 827             case GF_STACK:      /* vname-or-value[#color[:legend]] */
 828                 if (rrd_parse_PVHLAST(argv[i],&eaten,gdp,im))return;
 829                 if (last_gf == GF_LINE || last_gf == GF_AREA){
 830                    gdp->gf = last_gf;
 831                    gdp->linewidth = last_linewidth;
 832                 } else {
 833                    rrd_set_error("STACK must follow LINE or AREA! command:\n%s",
 834                         &argv[i][eaten],argv[i]);
 835                    return;
 836                 }
 837                 break;
 838         /* data acquisition */
 839             case GF_DEF:        /* vname=x:DS:CF:[:step=#][:start=#][:end=#] */
 840                 if (rrd_parse_def(argv[i],&eaten,gdp,im)) return;
 841                 break;
 842             case GF_CDEF:       /* vname=rpn-expression */
 843                 if (rrd_parse_cdef(argv[i],&eaten,gdp,im)) return;
 844                 break;
 845             case GF_VDEF:       /* vname=rpn-expression */
 846                 if (rrd_parse_vdef(argv[i],&eaten,gdp,im)) return;
 847                 break;
 848         }
 849         if (gdp->debug) {
 850             dprintf("used %i out of %i chars\n",eaten,strlen(argv[i]));
 851             dprintf("parsed line: '%s'\n",argv[i]);
 852             dprintf("remaining: '%s'\n",&argv[i][eaten]);
 853             if (eaten >= strlen(argv[i]))
 854                 dprintf("Command finished successfully\n");
 855         }
 856         if (eaten < strlen(argv[i])) {
 857             rrd_set_error("Garbage '%s' after command:\n%s",
 858                         &argv[i][eaten],argv[i]);
 859             return;
 860         }
 861     }
 862 }