src/rrd_graph_helper.c

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