src/rrd_graph_helper.c

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