src/rrd_graph_helper.c

   1 #include "rrd_graph.h"
   2
   3 #define dprintf if (gdp->debug) printf
   4
   5 /* Define prototypes for the parsing methods.
   6   Inputs:
   7    char *line         - pointer to base of input source
   8    unsigned int eaten - index to next input character (INPUT/OUTPUT)
   9    graph_desc_t *gdp  - pointer to a graph description
  10    image_desc_t *im   - pointer to an image description
  11 */
  12
  13 int rrd_parse_find_gf (char *, unsigned int *, graph_desc_t *);
  14 int rrd_parse_legend  (char *, unsigned int *, graph_desc_t *);
  15 int rrd_parse_color   (char *, graph_desc_t *);
  16 int rrd_parse_CF      (char *, unsigned int *, graph_desc_t *);
  17 int rrd_parse_print   (char *, unsigned int *, graph_desc_t *, image_desc_t *);
  18 int rrd_parse_PVHLAST (char *, unsigned int *, graph_desc_t *, image_desc_t *);
  19 int rrd_parse_vname   (char *, unsigned int *, graph_desc_t *, image_desc_t *);
  20 int rrd_parse_def     (char *, unsigned int *, graph_desc_t *, image_desc_t *);
  21 int rrd_parse_vdef    (char *, unsigned int *, graph_desc_t *, image_desc_t *);
  22 int rrd_parse_cdef    (char *, unsigned int *, graph_desc_t *, image_desc_t *);
  23
  24
  25
  26 int
  27 rrd_parse_find_gf(char *line, unsigned int *eaten, graph_desc_t *gdp) {
  28     char funcname[11],c1=0,c2=0;
  29     int i=0;
  30
  31     sscanf(&line[*eaten], "DEBUG%n", &i);
  32     if (i) {
  33         gdp->debug=1;
  34         (*eaten)+=i;
  35         i=0;
  36         dprintf("Scanning line '%s'\n",&line[*eaten]);
  37     }
  38     sscanf(&line[*eaten], "%10[A-Z]%n%c%c", funcname, &i, &c1, &c2);
  39     if (!i) {
  40         rrd_set_error("Could not make sense out of '%s'",line);
  41         return 1;
  42     }
  43     if ((int)(gdp->gf=gf_conv(funcname)) == -1) {
  44         rrd_set_error("'%s' is not a valid function name", funcname);
  45         return 1;
  46     }
  47     if (gdp->gf == GF_LINE) {
  48         if (c1 < '1' || c1 > '3' || c2 != ':') {
  49             rrd_set_error("Malformed LINE command: %s",line);
  50             return 1;
  51         }
  52         gdp->linewidth=c1-'0';
  53         i++;
  54     } else {
  55         if (c1 != ':') {
  56             rrd_set_error("Malformed %s command: %s",funcname,line);
  57             return 1;
  58         }
  59     }
  60     *eaten+=++i;
  61     return 0;
  62 }
  63
  64 int
  65 rrd_parse_legend(char *line, unsigned int *eaten, graph_desc_t *gdp) {
  66     int i;
  67
  68     dprintf("- examining '%s'\n",&line[*eaten]);
  69
  70     i=scan_for_col(&line[*eaten],FMT_LEG_LEN,gdp->legend);
  71
  72     *eaten += i;
  73     if (line[*eaten]!='\0' && line[*eaten]!=':') {
  74         rrd_set_error("Legend too long");
  75         return 1;
  76     } else {
  77         dprintf("- found legend '%s'\n", gdp->legend);
  78         return 0;
  79     }
  80 }
  81
  82 int
  83 rrd_parse_color(char *string, graph_desc_t *gdp) {
  84     unsigned int r=0,g=0,b=0,a=0;
  85     int i1=0,i2=0,i3=0;
  86
  87     if (string[0] != '#') return 1;
  88     sscanf(string, "#%02x%02x%02x%n%02x%n%*s%n",
  89                                 &r,&g,&b,&i1,&a,&i2,&i3);
  90
  91     if (i3) return 1; /* garbage after color */
  92     if (!i2) a=0xFF;
  93     if (!i1) return 1; /* no color after '#' */
  94     gdp->col = r<<24|g<<16|b<<8|a;
  95     return 0;
  96 }
  97
  98 int
  99 rrd_parse_CF(char *line, unsigned int *eaten, graph_desc_t *gdp) {
 100     char                symname[CF_NAM_SIZE];
 101     int                 i=0;
 102
 103     sscanf(&line[*eaten], CF_NAM_FMT "%n", symname,&i);
 104     if ((!i)||((line[*eaten+i]!='\0')&&(line[*eaten+i]!=':'))) {
 105         rrd_set_error("Cannot parse CF in '%s'",line);
 106         return 1;
 107     }
 108     (*eaten)+=i;
 109     dprintf("- using CF '%s'\n",symname);
 110
 111     if ((int)(gdp->cf = cf_conv(symname))==-1) {
 112         rrd_set_error("Unknown CF '%s' in '%s'",symname,line);
 113         return 1;
 114     }
 115
 116     if (line[*eaten]!='\0') (*eaten)++;
 117     return 0;
 118 }
 119
 120 /* Parsing old-style xPRINT and new-style xPRINT */
 121 int
 122 rrd_parse_print(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 123     /* vname:CF:format in case of DEF-based vname
 124     ** vname:CF:format in case of CDEF-based vname
 125     ** vname:format in case of VDEF-based vname
 126     */
 127     char tmpstr[MAX_VNAME_LEN+1];
 128     int i=0;
 129
 130     sscanf(&line[*eaten], DEF_NAM_FMT ":%n", tmpstr,&i);
 131     if (!i) {
 132         rrd_set_error("Could not parse line '%s'",line);
 133         return 1;
 134     }
 135     (*eaten)+=i;
 136     dprintf("- Found candidate vname '%s'\n",tmpstr);
 137
 138     if ((gdp->vidx=find_var(im,tmpstr))<0) {
 139         rrd_set_error("Not a valid vname: %s in line %s",tmpstr,line);
 140         return 1;
 141     }
 142     switch (im->gdes[gdp->vidx].gf) {
 143         case GF_DEF:
 144         case GF_CDEF:
 145             dprintf("- vname is of type DEF or CDEF, looking for CF\n");
 146             if (rrd_parse_CF(line,eaten,gdp)) return 1;
 147             break;
 148         case GF_VDEF:
 149             dprintf("- vname is of type VDEF\n");
 150             break;
 151         default:
 152             rrd_set_error("Encountered unknown type variable '%s'",tmpstr);
 153             return 1;
 154     }
 155
 156     if (rrd_parse_legend(line,eaten,gdp)) return 1;
 157
 158     /* Why is there a separate structure member "format" ??? */
 159     strcpy(gdp->format,gdp->legend);
 160
 161     return 0;
 162 }
 163
 164 /* Parsing of PART, VRULE, HRULE, LINE, AREA, STACK and TICK
 165 ** is done in one function.  Stacking STACK is silently ignored
 166 ** as it is redundant.  Stacking PART, VRULE, HRULE or TICK is
 167 ** not allowed.  The check for color doesn't need to be so strict
 168 ** anymore, the user can specify the color '#00000000' and
 169 ** effectively circumvent this check, so why bother.
 170 **
 171 ** If a number (which is valid to enter) is more than a
 172 ** certain amount of characters, it is caught as an error.
 173 ** While this is arguable, so is entering fixed numbers
 174 ** with more than MAX_VNAME_LEN significant digits.
 175 */
 176 int
 177 rrd_parse_PVHLAST(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 178     int i,j;
 179     int colorfound=0;
 180     char tmpstr[MAX_VNAME_LEN + 10];    /* vname#RRGGBBAA\0 */
 181
 182     dprintf("- parsing '%s'\n",&line[*eaten]);
 183     dprintf("- from line '%s'\n",line);
 184
 185     i=scan_for_col(&line[*eaten],MAX_VNAME_LEN+9,tmpstr);
 186     if (line[*eaten+i]!='\0' && line[*eaten+i]!=':') {
 187         rrd_set_error("Cannot parse line '%s'",line);
 188         return 1;
 189     }
 190
 191     j=i; while (j>0 && tmpstr[j]!='#') j--;
 192
 193     if (tmpstr[j]=='#') {
 194         if (rrd_parse_color(&tmpstr[j],gdp)) {
 195             rrd_set_error("Could not parse color in '%s'",tmpstr[j]);
 196             return 1;
 197         }
 198         tmpstr[j]='\0';
 199         dprintf("- parsed color 0x%08x\n",(unsigned int)gdp->col);
 200         colorfound=1;
 201     }
 202
 203     dprintf("- examining '%s'\n",tmpstr);
 204     j=0;
 205     if (gdp->gf == GF_VRULE) {
 206         sscanf(tmpstr,"%li%n",&gdp->xrule,&j);
 207         if (j) dprintf("- found time: %li\n",gdp->xrule);
 208     } else {
 209         sscanf(tmpstr,"%lf%n",&gdp->yrule,&j);
 210         if (j) dprintf("- found number: %f\n",gdp->yrule);
 211     }
 212     if (!j) {
 213         if ((gdp->vidx=find_var(im,tmpstr))<0) {
 214             rrd_set_error("Not a valid vname: %s in line %s",tmpstr,line);
 215             return 1;
 216         }
 217         dprintf("- found vname: '%s' vidx %li\n",tmpstr,gdp->vidx);
 218     }
 219     /* "*eaten" is still pointing to the original location,
 220     ** "*eaten +i" is pointing to the character after the color
 221     ** or to the terminating '\0' in which case we're finished.
 222     */
 223     if (line[*eaten+i]=='\0') {
 224         *eaten+=i;
 225         return 0;
 226     }
 227     *eaten+=++i;
 228
 229     /* If a color is specified and the only remaining part is
 230     ** ":STACK" then it is assumed to be the legend.  An empty
 231     ** legend can be specified as expected.  This means the
 232     ** following can be done:  LINE1:x#FF0000FF::STACK
 233     */
 234     if (colorfound) { /* no legend if no color */
 235         if (gdp->gf == GF_TICK) {
 236             dprintf("- looking for optional number\n");
 237             sscanf(&line[*eaten],"%lf:%n",&gdp->yrule,&j);
 238             if (j) {
 239                 dprintf("- found number %f\n",gdp->yrule);
 240                 (*eaten)+=j;
 241                 if (gdp->yrule > 1.0 || gdp->yrule < -1.0) {
 242                     rrd_set_error("Tick factor should be <= 1.0");
 243                     return 1;
 244                 }
 245             } else {
 246                 dprintf("- not found, defaulting to 0.1\n");
 247                 gdp->yrule=0.1;
 248                 return 0;
 249             }
 250         }
 251         dprintf("- looking for optional legend\n");
 252         dprintf("- in '%s'\n",&line[*eaten]);
 253         if (rrd_parse_legend(line, eaten, gdp)) return 1;
 254     }
 255
 256     /* PART, HRULE, VRULE and TICK cannot be stacked.  We're finished */
 257     if (   (gdp->gf == GF_HRULE)
 258         || (gdp->gf == GF_VRULE)
 259         || (gdp->gf == GF_PART)
 260         || (gdp->gf == GF_TICK)
 261         ) return 0;
 262
 263     if (line[*eaten]!='\0') {
 264         dprintf("- still more, should be STACK\n");
 265         (*eaten)++;
 266         j=scan_for_col(&line[*eaten],5,tmpstr);
 267         if (line[*eaten+j]!='\0') {
 268             rrd_set_error("Garbage found where STACK expected");
 269             return 1;
 270         }
 271         if (!strcmp("STACK",tmpstr)) {
 272             dprintf("- found STACK\n");
 273             gdp->stack=1;
 274             (*eaten)+=5;
 275         } else {
 276             rrd_set_error("Garbage found where STACK expected");
 277             return 1;
 278         }
 279     }
 280
 281     return 0;
 282 }
 283
 284 int
 285 rrd_parse_vname(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 286     char tmpstr[MAX_VNAME_LEN + 10];
 287     int i=0;
 288
 289     sscanf(&line[*eaten], DEF_NAM_FMT "=%n", tmpstr,&i);
 290     if (!i) {
 291         rrd_set_error("Cannot parse vname from '%s'",line);
 292         return 1;
 293     }
 294     dprintf("- found candidate '%s'\n",tmpstr);
 295
 296     if ((gdp->vidx=find_var(im,tmpstr))>=0) {
 297         rrd_set_error("Attempting to reuse '%s'",im->gdes[gdp->vidx].vname);
 298         return 1;
 299     }
 300     strcpy(gdp->vname,tmpstr);
 301     dprintf("- created vname '%s' vidx %lu\n", gdp->vname,im->gdes_c-1);
 302     (*eaten)+=i;
 303     return 0;
 304 }
 305
 306 int
 307 rrd_parse_def(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 308     int                 i=0;
 309     char                command[6]; /* step, start, end */
 310     char                tmpstr[256];
 311     struct rrd_time_value       start_tv,end_tv;
 312     time_t              start_tmp=0,end_tmp=0;
 313     char                *parsetime_error=NULL;
 314
 315     start_tv.type   = end_tv.type=ABSOLUTE_TIME;
 316     start_tv.offset = end_tv.offset=0;
 317     localtime_r(&gdp->start, &start_tv.tm);
 318     localtime_r(&gdp->end, &end_tv.tm);
 319
 320     dprintf("- parsing '%s'\n",&line[*eaten]);
 321     dprintf("- from line '%s'\n",line);
 322
 323     if (rrd_parse_vname(line,eaten,gdp,im)) return 1;
 324     i=scan_for_col(&line[*eaten],254,gdp->rrd);
 325     if (line[*eaten+i]!=':') {
 326         rrd_set_error("Problems reading database name");
 327         return 1;
 328     }
 329     (*eaten)+=++i;
 330     dprintf("- using file '%s'\n",gdp->rrd);
 331
 332     i=0;
 333     sscanf(&line[*eaten], DS_NAM_FMT ":%n", gdp->ds_nam,&i);
 334     if (!i) {
 335         rrd_set_error("Cannot parse DS in '%s'",line);
 336         return 1;
 337     }
 338     (*eaten)+=i;
 339     dprintf("- using DS '%s'\n",gdp->ds_nam);
 340
 341     if (rrd_parse_CF(line,eaten,gdp)) return 1;
 342
 343     if (line[*eaten]=='\0') return 0;
 344
 345     while (1) {
 346         dprintf("- optional parameter follows: %s\n", &line[*eaten]);
 347         i=0;
 348         sscanf(&line[*eaten], "%5[a-z]=%n", command, &i);
 349         if (!i) {
 350             rrd_set_error("Parse error in '%s'",line);
 351             return 1;
 352         }
 353         (*eaten)+=i;
 354         dprintf("- processing '%s'\n",command);
 355         if (!strcmp("step",command)) {
 356             i=0;
 357             sscanf(&line[*eaten],"%lu%n",&gdp->step,&i);
 358             (*eaten)+=i;
 359             dprintf("- using step %lu\n",gdp->step);
 360         } else if (!strcmp("start",command)) {
 361             i=scan_for_col(&line[*eaten],255,tmpstr);
 362             (*eaten)+=i;
 363             if ((parsetime_error = parsetime(tmpstr, &start_tv))) {
 364                 rrd_set_error( "start time: %s", parsetime_error );
 365                 return 1;
 366             }
 367             dprintf("- done parsing:  '%s'\n",&line[*eaten]);
 368         } else if (!strcmp("end",command)) {
 369             i=scan_for_col(&line[*eaten],255,tmpstr);
 370             (*eaten)+=i;
 371             if ((parsetime_error = parsetime(tmpstr, &end_tv))) {
 372                 rrd_set_error( "end time: %s", parsetime_error );
 373                 return 1;
 374             }
 375             dprintf("- done parsing:  '%s'\n",&line[*eaten]);
 376         } else {
 377             rrd_set_error("Parse error in '%s'",line);
 378             return 1;
 379         }
 380         if (line[*eaten]=='\0') break;
 381         if (line[*eaten]!=':') {
 382             dprintf("- Expected to see end of string but got '%s'\n",\
 383                                                          &line[*eaten]);
 384             rrd_set_error("Parse error in '%s'",line);
 385             return 1;
 386         }
 387         (*eaten)++;
 388     }
 389     if (proc_start_end(&start_tv,&end_tv,&start_tmp,&end_tmp) == -1){
 390         /* error string is set in parsetime.c */
 391         return 1;
 392     }
 393     if (start_tmp < 3600*24*365*10) {
 394         rrd_set_error("the first entry to fetch should be "
 395                         "after 1980 (%ld)",start_tmp);
 396         return 1;
 397     }
 398
 399     if (end_tmp < start_tmp) {
 400         rrd_set_error("start (%ld) should be less than end (%ld)",
 401                         start_tmp, end_tmp);
 402         return 1;
 403     }
 404
 405     gdp->start = start_tmp;
 406     gdp->end = end_tmp;
 407
 408     dprintf("- start time %lu\n",gdp->start);
 409     dprintf("- end   time %lu\n",gdp->end);
 410
 411     return 0;
 412 }
 413
 414 int
 415 rrd_parse_vdef(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 416     char tmpstr[MAX_VNAME_LEN+1];       /* vname\0 */
 417     int i=0;
 418
 419     dprintf("- parsing '%s'\n",&line[*eaten]);
 420     if (rrd_parse_vname(line,eaten,gdp,im)) return 1;
 421
 422     sscanf(&line[*eaten], DEF_NAM_FMT ",%n", tmpstr,&i);
 423     if (!i) {
 424         rrd_set_error("Cannot parse line '%s'",line);
 425         return 1;
 426     }
 427     if ((gdp->vidx=find_var(im,tmpstr))<0) {
 428         rrd_set_error("Not a valid vname: %s in line %s",tmpstr,line);
 429         return 1;
 430     }
 431     if (   im->gdes[gdp->vidx].gf != GF_DEF
 432         && im->gdes[gdp->vidx].gf != GF_CDEF) {
 433         rrd_set_error("variable '%s' not DEF nor "
 434                         "CDEF in VDEF '%s'", tmpstr,gdp->vname);
 435         return 1;
 436     }
 437     dprintf("- found vname: '%s' vidx %li\n",tmpstr,gdp->vidx);
 438     (*eaten)+=i;
 439
 440     dprintf("- calling vdef_parse with param '%s'\n",&line[*eaten]);
 441     vdef_parse(gdp,&line[*eaten]);
 442     while (line[*eaten]!='\0'&&line[*eaten]!=':')
 443         (*eaten)++;
 444
 445     return 0;
 446 }
 447
 448 int
 449 rrd_parse_cdef(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 450     dprintf("- parsing '%s'\n",&line[*eaten]);
 451     if (rrd_parse_vname(line,eaten,gdp,im)) return 1;
 452     if ((gdp->rpnp = rpn_parse(
 453         (void *)im,
 454         &line[*eaten],
 455         &find_var_wrapper)
 456     )==NULL) {
 457         rrd_set_error("invalid rpn expression in: %s",&line[*eaten]);
 458         return 1;
 459     };
 460     while (line[*eaten]!='\0'&&line[*eaten]!=':')
 461         (*eaten)++;
 462     return 0;
 463 }
 464
 465 void
 466 rrd_graph_script(int argc, char *argv[], image_desc_t *im) {
 467     int i;
 468
 469     for (i=optind+1;i<argc;i++) {
 470         graph_desc_t *gdp;
 471         unsigned int eaten=0;
 472
 473         if (gdes_alloc(im)) return; /* the error string is already set */
 474         gdp = &im->gdes[im->gdes_c-1];
 475 #ifdef DEBUG
 476         gdp->debug = 1;
 477 #endif
 478
 479         if (rrd_parse_find_gf(argv[i],&eaten,gdp)) return;
 480
 481         switch (gdp->gf) {
 482 #if 0
 483         /* future command */
 484             case GF_SHIFT:      vname:value
 485 #endif
 486             case GF_XPORT:
 487                 break;
 488             case GF_PRINT:      /* vname:CF:format -or- vname:format */
 489             case GF_GPRINT:     /* vname:CF:format -or- vname:format */
 490                 if (rrd_parse_print(argv[i],&eaten,gdp,im)) return;
 491                 break;
 492             case GF_COMMENT:    /* text */
 493                 if (rrd_parse_legend(argv[i],&eaten,gdp)) return;
 494                 break;
 495             case GF_PART:       /* value[#color[:legend]] */
 496             case GF_VRULE:      /* value#color[:legend] */
 497             case GF_HRULE:      /* value#color[:legend] */
 498             case GF_LINE:       /* vname-or-value[#color[:legend]][:STACK] */
 499             case GF_AREA:       /* vname-or-value[#color[:legend]][:STACK] */
 500             case GF_STACK:      /* vname-or-value[#color[:legend]] */
 501             case GF_TICK:       /* vname#color[:num[:legend]] */
 502                 if (rrd_parse_PVHLAST(argv[i],&eaten,gdp,im)) return;
 503                 break;
 504         /* data acquisition */
 505             case GF_DEF:        /* vname=x:DS:CF:[:step=#][:start=#][:end=#] */
 506                 if (rrd_parse_def(argv[i],&eaten,gdp,im)) return;
 507                 break;
 508             case GF_CDEF:       /* vname=rpn-expression */
 509                 if (rrd_parse_cdef(argv[i],&eaten,gdp,im)) return;
 510                 break;
 511             case GF_VDEF:       /* vname=rpn-expression */
 512                 if (rrd_parse_vdef(argv[i],&eaten,gdp,im)) return;
 513                 break;
 514         }
 515         if (gdp->debug) {
 516             dprintf("used %i out of %i chars\n",eaten,strlen(argv[i]));
 517             dprintf("parsed line: '%s'\n",argv[i]);
 518             dprintf("remaining: '%s'\n",&argv[i][eaten]);
 519             if (eaten >= strlen(argv[i]))
 520                 dprintf("Command finished successfully\n");
 521         }
 522         if (eaten < strlen(argv[i])) {
 523             rrd_set_error("Garbage '%s' after command:\n%s",
 524                         &argv[i][eaten],argv[i]);
 525             return;
 526         }
 527     }
 528 }