src/rrd_graph_helper.c

   1 /****************************************************************************
   2  * RRDtool 1.2.6  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(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     dprintf("- examining value '%s'\n",tmpstr);
 334     k=0;
 335     if (gdp->gf == GF_VRULE) {
 336         sscanf(tmpstr,"%li%n",&gdp->xrule,&k);
 337         if (k) dprintf("- found time: %li\n",gdp->xrule);
 338     } else {
 339         sscanf(tmpstr,"%lf%n",&gdp->yrule,&k);
 340         if (k) dprintf("- found number: %f\n",gdp->yrule);
 341     }
 342     if (!k) {
 343         if ((gdp->vidx=find_var(im,tmpstr))<0) {
 344             rrd_set_error("Not a valid vname: %s in line %s",tmpstr,line);
 345             return 1;
 346         }
 347         dprintf("- found vname: '%s' vidx %li\n",tmpstr,gdp->vidx);
 348     }
 349
 350     if (j) {
 351         j++;
 352         dprintf("- examining color '%s'\n",&tmpstr[j]);
 353         if (rrd_parse_color(&tmpstr[j],gdp)) {
 354             rrd_set_error("Could not parse color in '%s'",&tmpstr[j]);
 355             return 1;
 356         }
 357         dprintf("- parsed color 0x%08x\n",(unsigned int)gdp->col);
 358         colorfound=1;
 359     } else {
 360         dprintf("- no color present in '%s'\n",tmpstr);
 361     }
 362
 363     (*eaten) += i; /* after vname#color */
 364     if (line[*eaten]!='\0') {
 365         (*eaten)++;     /* after colon */
 366     }
 367
 368     if (gdp->gf == GF_TICK) {
 369         dprintf("- parsing '%s'\n",&line[*eaten]);
 370         dprintf("- looking for optional TICK number\n");
 371         j=0;
 372         sscanf(&line[*eaten],"%lf%n",&gdp->yrule,&j);
 373         if (j) {
 374             if (line[*eaten+j]!='\0' && line[*eaten+j]!=':') {
 375                 rrd_set_error("Cannot parse TICK fraction '%s'",line);
 376                 return 1;
 377             }
 378             dprintf("- found number %f\n",gdp->yrule);
 379             if (gdp->yrule > 1.0 || gdp->yrule < -1.0) {
 380                 rrd_set_error("Tick factor should be <= 1.0");
 381                 return 1;
 382             }
 383             (*eaten)+=j;
 384         } else {
 385             dprintf("- not found, defaulting to 0.1\n");
 386             gdp->yrule=0.1;
 387         }
 388         if (line[*eaten] == '\0') {
 389             dprintf("- done parsing line\n");
 390             return 0;
 391         } else { if (line[*eaten] == ':') {
 392                     (*eaten)++;
 393                  } else {
 394                      rrd_set_error("Can't make sense of that TICK line");
 395                    return 1;
 396                  }
 397         }
 398     }
 399
 400     dprintf("- parsing '%s'\n",&line[*eaten]);
 401
 402     /* Legend is next.  A legend without a color is an error.
 403     ** Stacking an item without having a legend is OK however
 404     ** then an empty legend should be specified.
 405     **   LINE:val#color:STACK   means legend is string "STACK"
 406     **   LINE:val#color::STACK  means no legend, and do STACK
 407     **   LINE:val:STACK         is an error (legend but no color)
 408     **   LINE:val::STACK        means no legend, and do STACK
 409     */
 410     if (colorfound) {
 411         int err=0;
 412         char *linecp = strdup(line);
 413         dprintf("- looking for optional legend\n");
 414
 415         dprintf("- examining '%s'\n",&line[*eaten]);
 416         if (linecp[*eaten] != '\0' && linecp[*eaten] != ':') {
 417             int spi;
 418             /* If the legend is not empty, it has to be prefixed with spacecnt ' ' characters. This then gets
 419              * replaced by the color box later on. */
 420             for (spi=0;spi<spacecnt && (*eaten) > 1;spi++){
 421                linecp[--(*eaten)]=' ';
 422             }
 423         }
 424
 425         if (rrd_parse_legend(linecp, eaten, gdp)) err=1;
 426         free(linecp);
 427         if (err) return 1;
 428
 429         dprintf("- found legend '%s'\n", &gdp->legend[2]);
 430     } else {
 431         dprintf("- skipping empty legend\n");
 432         if (line[*eaten] != '\0' && line[*eaten] != ':') {
 433             rrd_set_error("Legend set but no color: %s",&line[*eaten]);
 434             return 1;
 435         }
 436     }
 437     if (line[*eaten]=='\0') {
 438         dprintf("- done parsing line\n");
 439         return 0;
 440     }
 441     (*eaten)++; /* after colon */
 442
 443     /* PART, HRULE, VRULE and TICK cannot be stacked. */
 444     if (   (gdp->gf == GF_HRULE)
 445         || (gdp->gf == GF_VRULE)
 446 #ifdef WITH_PIECHART
 447         || (gdp->gf == GF_PART)
 448 #endif
 449         || (gdp->gf == GF_TICK)
 450         ) return 0;
 451
 452     dprintf("- parsing '%s'\n",&line[*eaten]);
 453     if (line[*eaten]!='\0') {
 454         dprintf("- still more, should be STACK\n");
 455         j=scan_for_col(&line[*eaten],5,tmpstr);
 456         if (line[*eaten+j]!='\0' && line[*eaten+j]!=':') {
 457             /* not 5 chars */
 458             rrd_set_error("Garbage found where STACK expected");
 459             return 1;
 460         }
 461         if (!strcmp("STACK",tmpstr)) {
 462             dprintf("- found STACK\n");
 463             gdp->stack=1;
 464             (*eaten)+=j;
 465         } else {
 466             rrd_set_error("Garbage found where STACK expected");
 467             return 1;
 468         }
 469     }
 470     if (line[*eaten]=='\0') {
 471         dprintf("- done parsing line\n");
 472         return 0;
 473     }
 474     (*eaten)++;
 475     dprintf("- parsing '%s'\n",&line[*eaten]);
 476
 477     return 0;
 478 }
 479
 480 int
 481 rrd_parse_vname(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 482     char tmpstr[MAX_VNAME_LEN + 10];
 483     int i=0;
 484
 485     sscanf(&line[*eaten], DEF_NAM_FMT "=%n", tmpstr,&i);
 486     if (!i) {
 487         rrd_set_error("Cannot parse vname from '%s'",line);
 488         return 1;
 489     }
 490     dprintf("- found candidate '%s'\n",tmpstr);
 491
 492     if ((gdp->vidx=find_var(im,tmpstr))>=0) {
 493         rrd_set_error("Attempting to reuse '%s'",im->gdes[gdp->vidx].vname);
 494         return 1;
 495     }
 496     strcpy(gdp->vname,tmpstr);
 497     dprintf("- created vname '%s' vidx %lu\n", gdp->vname,im->gdes_c-1);
 498     (*eaten)+=i;
 499     return 0;
 500 }
 501
 502 int
 503 rrd_parse_def(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 504     int                 i=0;
 505     char                command[7]; /* step, start, end, reduce */
 506     char                tmpstr[256];
 507     struct rrd_time_value       start_tv,end_tv;
 508     time_t              start_tmp=0,end_tmp=0;
 509     char                *parsetime_error=NULL;
 510
 511     start_tv.type   = end_tv.type=ABSOLUTE_TIME;
 512     start_tv.offset = end_tv.offset=0;
 513     localtime_r(&gdp->start, &start_tv.tm);
 514     localtime_r(&gdp->end, &end_tv.tm);
 515
 516     dprintf("- parsing '%s'\n",&line[*eaten]);
 517     dprintf("- from line '%s'\n",line);
 518
 519     if (rrd_parse_vname(line,eaten,gdp,im)) return 1;
 520     i=scan_for_col(&line[*eaten],254,gdp->rrd);
 521     if (line[*eaten+i]!=':') {
 522         rrd_set_error("Problems reading database name");
 523         return 1;
 524     }
 525     (*eaten)+=++i;
 526     dprintf("- using file '%s'\n",gdp->rrd);
 527
 528     i=0;
 529     sscanf(&line[*eaten], DS_NAM_FMT ":%n", gdp->ds_nam,&i);
 530     if (!i) {
 531         rrd_set_error("Cannot parse DS in '%s'",line);
 532         return 1;
 533     }
 534     (*eaten)+=i;
 535     dprintf("- using DS '%s'\n",gdp->ds_nam);
 536
 537     if (rrd_parse_CF(line,eaten,gdp,&gdp->cf)) return 1;
 538     gdp->cf_reduce = gdp->cf;
 539
 540     if (line[*eaten]=='\0') return 0;
 541
 542     while (1) {
 543         dprintf("- optional parameter follows: %s\n", &line[*eaten]);
 544         i=0;
 545         sscanf(&line[*eaten], "%6[a-z]=%n", command, &i);
 546         if (!i) {
 547             rrd_set_error("Parse error in '%s'",line);
 548             return 1;
 549         }
 550         (*eaten)+=i;
 551         dprintf("- processing '%s'\n",command);
 552         if (!strcmp("reduce",command)) {
 553           if (rrd_parse_CF(line,eaten,gdp,&gdp->cf_reduce)) return 1;
 554           if (line[*eaten] != '\0')
 555               (*eaten)--;
 556         } else if (!strcmp("step",command)) {
 557             i=0;
 558             sscanf(&line[*eaten],"%lu%n",&gdp->step,&i);
 559             (*eaten)+=i;
 560             dprintf("- using step %lu\n",gdp->step);
 561         } else if (!strcmp("start",command)) {
 562             i=scan_for_col(&line[*eaten],255,tmpstr);
 563             (*eaten)+=i;
 564             if ((parsetime_error = parsetime(tmpstr, &start_tv))) {
 565                 rrd_set_error( "start time: %s", parsetime_error );
 566                 return 1;
 567             }
 568             dprintf("- done parsing:  '%s'\n",&line[*eaten]);
 569         } else if (!strcmp("end",command)) {
 570             i=scan_for_col(&line[*eaten],255,tmpstr);
 571             (*eaten)+=i;
 572             if ((parsetime_error = parsetime(tmpstr, &end_tv))) {
 573                 rrd_set_error( "end time: %s", parsetime_error );
 574                 return 1;
 575             }
 576             dprintf("- done parsing:  '%s'\n",&line[*eaten]);
 577         } else {
 578             rrd_set_error("Parse error in '%s'",line);
 579             return 1;
 580         }
 581         if (line[*eaten]=='\0') break;
 582         if (line[*eaten]!=':') {
 583             dprintf("- Expected to see end of string but got '%s'\n",\
 584                                                          &line[*eaten]);
 585             rrd_set_error("Parse error in '%s'",line);
 586             return 1;
 587         }
 588         (*eaten)++;
 589     }
 590     if (proc_start_end(&start_tv,&end_tv,&start_tmp,&end_tmp) == -1){
 591         /* error string is set in parsetime.c */
 592         return 1;
 593     }
 594     if (start_tmp < 3600*24*365*10) {
 595         rrd_set_error("the first entry to fetch should be "
 596                         "after 1980 (%ld)",start_tmp);
 597         return 1;
 598     }
 599
 600     if (end_tmp < start_tmp) {
 601         rrd_set_error("start (%ld) should be less than end (%ld)",
 602                         start_tmp, end_tmp);
 603         return 1;
 604     }
 605
 606     gdp->start = start_tmp;
 607     gdp->end = end_tmp;
 608
 609     dprintf("- start time %lu\n",gdp->start);
 610     dprintf("- end   time %lu\n",gdp->end);
 611
 612     return 0;
 613 }
 614
 615 int
 616 rrd_parse_vdef(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 617     char tmpstr[MAX_VNAME_LEN+1];       /* vname\0 */
 618     int i=0;
 619
 620     dprintf("- parsing '%s'\n",&line[*eaten]);
 621     if (rrd_parse_vname(line,eaten,gdp,im)) return 1;
 622
 623     sscanf(&line[*eaten], DEF_NAM_FMT ",%n", tmpstr,&i);
 624     if (!i) {
 625         rrd_set_error("Cannot parse line '%s'",line);
 626         return 1;
 627     }
 628     if ((gdp->vidx=find_var(im,tmpstr))<0) {
 629         rrd_set_error("Not a valid vname: %s in line %s",tmpstr,line);
 630         return 1;
 631     }
 632     if (   im->gdes[gdp->vidx].gf != GF_DEF
 633         && im->gdes[gdp->vidx].gf != GF_CDEF) {
 634         rrd_set_error("variable '%s' not DEF nor "
 635                         "CDEF in VDEF '%s'", tmpstr,gdp->vname);
 636         return 1;
 637     }
 638     dprintf("- found vname: '%s' vidx %li\n",tmpstr,gdp->vidx);
 639     (*eaten)+=i;
 640
 641     dprintf("- calling vdef_parse with param '%s'\n",&line[*eaten]);
 642     vdef_parse(gdp,&line[*eaten]);
 643     while (line[*eaten]!='\0'&&line[*eaten]!=':')
 644         (*eaten)++;
 645
 646     return 0;
 647 }
 648
 649 int
 650 rrd_parse_cdef(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 651     dprintf("- parsing '%s'\n",&line[*eaten]);
 652     if (rrd_parse_vname(line,eaten,gdp,im)) return 1;
 653     if ((gdp->rpnp = rpn_parse(
 654         (void *)im,
 655         &line[*eaten],
 656         &find_var_wrapper)
 657     )==NULL) {
 658         rrd_set_error("invalid rpn expression in: %s",&line[*eaten]);
 659         return 1;
 660     };
 661     while (line[*eaten]!='\0'&&line[*eaten]!=':')
 662         (*eaten)++;
 663     return 0;
 664 }
 665
 666 void
 667 rrd_graph_script(int argc, char *argv[], image_desc_t *im, int optno) {
 668     int i;
 669
 670     for (i=optind+optno;i<argc;i++) {
 671         graph_desc_t *gdp;
 672         unsigned int eaten=0;
 673
 674         if (gdes_alloc(im)) return; /* the error string is already set */
 675         gdp = &im->gdes[im->gdes_c-1];
 676 #ifdef DEBUG
 677         gdp->debug = 1;
 678 #endif
 679
 680         if (rrd_parse_find_gf(argv[i],&eaten,gdp)) return;
 681
 682         switch (gdp->gf) {
 683             case GF_SHIFT:      /* vname:value */
 684                 if (rrd_parse_shift(argv[i],&eaten,gdp,im)) return;
 685                 break;
 686             case GF_XPORT:
 687                 if (rrd_parse_xport(argv[i],&eaten,gdp,im)) return;
 688                 break;
 689             case GF_PRINT:      /* vname:CF:format -or- vname:format */
 690             case GF_GPRINT:     /* vname:CF:format -or- vname:format */
 691                 if (rrd_parse_print(argv[i],&eaten,gdp,im)) return;
 692                 break;
 693             case GF_COMMENT:    /* text */
 694                 if (rrd_parse_legend(argv[i],&eaten,gdp)) return;
 695                 break;
 696             case GF_STACK:      /* vname-or-value[#color[:legend]] */
 697 #ifdef WITH_PIECHART
 698             case GF_PART:       /* value[#color[:legend]] */
 699 #endif
 700             case GF_VRULE:      /* value#color[:legend] */
 701             case GF_HRULE:      /* value#color[:legend] */
 702             case GF_LINE:       /* vname-or-value[#color[:legend]][:STACK] */
 703             case GF_AREA:       /* vname-or-value[#color[:legend]][:STACK] */
 704             case GF_TICK:       /* vname#color[:num[:legend]] */
 705                 if (rrd_parse_PVHLAST(argv[i],&eaten,gdp,im)) return;
 706                 break;
 707         /* data acquisition */
 708             case GF_DEF:        /* vname=x:DS:CF:[:step=#][:start=#][:end=#] */
 709                 if (rrd_parse_def(argv[i],&eaten,gdp,im)) return;
 710                 break;
 711             case GF_CDEF:       /* vname=rpn-expression */
 712                 if (rrd_parse_cdef(argv[i],&eaten,gdp,im)) return;
 713                 break;
 714             case GF_VDEF:       /* vname=rpn-expression */
 715                 if (rrd_parse_vdef(argv[i],&eaten,gdp,im)) return;
 716                 break;
 717         }
 718         if (gdp->debug) {
 719             dprintf("used %i out of %i chars\n",eaten,strlen(argv[i]));
 720             dprintf("parsed line: '%s'\n",argv[i]);
 721             dprintf("remaining: '%s'\n",&argv[i][eaten]);
 722             if (eaten >= strlen(argv[i]))
 723                 dprintf("Command finished successfully\n");
 724         }
 725         if (eaten < strlen(argv[i])) {
 726             rrd_set_error("Garbage '%s' after command:\n%s",
 727                         &argv[i][eaten],argv[i]);
 728             return;
 729         }
 730     }
 731 }