program/src/rrd_cgi.c

   1 /*****************************************************************************
   2  * RRDtool 1.2.29  Copyright by Tobi Oetiker, 1997-2008
   3  *****************************************************************************
   4  * rrd_cgi.c  RRD Web Page Generator
   5  *****************************************************************************/
   6
   7 #include "rrd_tool.h"
   8
   9
  10 #define MEMBLK 1024
  11 /*#define DEBUG_PARSER
  12 #define DEBUG_VARS*/
  13
  14 typedef struct var_s {
  15         char    *name, *value;
  16 } s_var;
  17
  18 typedef struct cgi_s {
  19         s_var **vars;
  20 } s_cgi;
  21
  22 /* in arg[0] find tags beginning with arg[1] call arg[2] on them
  23    and replace by result of arg[2] call */
  24 int parse(char **, long, char *, char *(*)(long , const char **));
  25
  26 /**************************************************/
  27 /* tag replacers ... they are called from parse   */
  28 /* through function pointers                      */
  29 /**************************************************/
  30
  31 /* return cgi var named arg[0] */
  32 char* cgiget(long , const char **);
  33
  34 /* return a quoted cgi var named arg[0] */
  35 char* cgigetq(long , const char **);
  36
  37 /* return a quoted and sanitized cgi variable */
  38 char* cgigetqp(long , const char **);
  39
  40 /* call rrd_graph and insert appropriate image tag */
  41 char* drawgraph(long, const char **);
  42
  43 /* return PRINT functions from last rrd_graph call */
  44 char* drawprint(long, const char **);
  45
  46 /* pretty-print the <last></last> value for some.rrd via strftime() */
  47 char* printtimelast(long, const char **);
  48
  49 /* pretty-print current time */
  50 char* printtimenow(long, const char **);
  51
  52 /* set an environment variable */
  53 char* rrdsetenv(long, const char **);
  54
  55 /* get an environment variable */
  56 char* rrdgetenv(long, const char **);
  57
  58 /* include the named file at this point */
  59 char* includefile(long, const char **);
  60
  61 /* for how long is the output of the cgi valid ? */
  62 char* rrdgoodfor(long, const char **);
  63
  64 /* return rrdcgi version string */
  65 char* rrdgetinternal(long, const char **);
  66
  67 char* rrdstrip(char *buf);
  68 char* scanargs(char *line, int *argc, char ***args);
  69
  70 /* format at-time specified times using strftime */
  71 char* printstrftime(long, const char**);
  72
  73 /** HTTP protocol needs special format, and GMT time **/
  74 char *http_time(time_t *);
  75
  76 /* return a pointer to newly allocated copy of this string */
  77 char *stralloc(const char *);
  78
  79 /* global variable for rrdcgi */
  80 s_cgi *rrdcgiArg;
  81
  82 /* rrdcgiHeader
  83  *
  84  *  Prints a valid CGI Header (Content-type...) etc.
  85  */
  86 void rrdcgiHeader(void);
  87
  88 /* rrdcgiDecodeString
  89  * decode html escapes
  90  */
  91
  92 char *rrdcgiDecodeString(char *text);
  93
  94 /* rrdcgiDebug
  95  *
  96  *  Set/unsets debugging
  97  */
  98 void rrdcgiDebug(int level, int where);
  99
 100 /* rrdcgiInit
 101  *
 102  *  Reads in variables set via POST or stdin.
 103  */
 104 s_cgi *rrdcgiInit (void);
 105
 106 /* rrdcgiGetValue
 107  *
 108  *  Returns the value of the specified variable or NULL if it's empty
 109  *  or doesn't exist.
 110  */
 111 char *rrdcgiGetValue (s_cgi *parms, const char *name);
 112
 113 /* rrdcgiFreeList
 114  *
 115  * Frees a list as returned by rrdcgiGetVariables()
 116  */
 117 void rrdcgiFreeList (char **list);
 118
 119 /* rrdcgiFree
 120  *
 121  * Frees the internal data structures
 122  */
 123 void rrdcgiFree (s_cgi *parms);
 124
 125 /*  rrdcgiReadVariables()
 126  *
 127  *  Read from stdin if no string is provided via CGI.  Variables that
 128  *  doesn't have a value associated with it doesn't get stored.
 129  */
 130 s_var **rrdcgiReadVariables(void);
 131
 132
 133 int rrdcgiDebugLevel = 0;
 134 int rrdcgiDebugStderr = 1;
 135 char *rrdcgiHeaderString = NULL;
 136 char *rrdcgiType = NULL;
 137
 138 /* rrd interface to the variable functions {put,get}var() */
 139 char* rrdgetvar(long argc, const char **args);
 140 char* rrdsetvar(long argc, const char **args);
 141 char* rrdsetvarconst(long argc, const char **args);
 142
 143
 144 /* variable store: put/get key-value pairs */
 145 static int   initvar();
 146 static void  donevar();
 147 static const char* getvar(const char* varname);
 148 static const char* putvar(const char* name, const char* value, int is_const);
 149
 150 /* key value pair that makes up an entry in the variable store */
 151 typedef struct
 152 {
 153         int is_const;           /* const variable or not */
 154         const char* name;       /* variable name */
 155         const char* value;      /* variable value */
 156 } vardata;
 157
 158 /* the variable heap:
 159    start with a heapsize of 10 variables */
 160 #define INIT_VARSTORE_SIZE      10
 161 static vardata* varheap    = NULL;
 162 static size_t varheap_size = 0;
 163
 164 /* allocate and initialize variable heap */
 165 static int
 166 initvar()
 167 {
 168         varheap = (vardata*)malloc(sizeof(vardata) * INIT_VARSTORE_SIZE);
 169         if (varheap == NULL) {
 170                 fprintf(stderr, "ERROR: unable to initialize variable store\n");
 171                 return -1;
 172         }
 173         memset(varheap, 0, sizeof(vardata) * INIT_VARSTORE_SIZE);
 174         varheap_size = INIT_VARSTORE_SIZE;
 175         return 0;
 176 }
 177
 178 /* cleanup: free allocated memory */
 179 static void
 180 donevar()
 181 {
 182         int i;
 183         if (varheap) {
 184                 for (i=0; i<(int)varheap_size; i++) {
 185                         if (varheap[i].name) {
 186                                 free((char*)varheap[i].name);
 187                         }
 188                         if (varheap[i].value) {
 189                                 free((char*)varheap[i].value);
 190                         }
 191                 }
 192                 free(varheap);
 193         }
 194 }
 195
 196 /* Get a variable from the variable store.
 197    Return NULL in case the requested variable was not found. */
 198 static const char*
 199 getvar(const char* name)
 200 {
 201         int i;
 202         for (i=0; i<(int)varheap_size && varheap[i].name; i++) {
 203                 if (0 == strcmp(name, varheap[i].name)) {
 204 #ifdef          DEBUG_VARS
 205                         printf("<!-- getvar(%s) -> %s -->\n", name, varheap[i].value);
 206 #endif
 207                         return varheap[i].value;
 208                 }
 209         }
 210 #ifdef DEBUG_VARS
 211         printf("<!-- getvar(%s) -> Not found-->\n", name);
 212 #endif
 213         return NULL;
 214 }
 215
 216 /* Put a variable into the variable store. If a variable by that
 217    name exists, it's value is overwritten with the new value unless it was
 218    marked as 'const' (initialized by RRD::SETCONSTVAR).
 219    Returns a copy the newly allocated value on success, NULL on error. */
 220 static const char*
 221 putvar(const char* name, const char* value, int is_const)
 222 {
 223         int i;
 224         for (i=0; i < (int)varheap_size && varheap[i].name; i++) {
 225                 if (0 == strcmp(name, varheap[i].name)) {
 226                         /* overwrite existing entry */
 227                         if (varheap[i].is_const) {
 228 #ifdef                  DEBUG_VARS
 229                                 printf("<!-- setver(%s, %s): not assigning: "
 230                                                 "const variable -->\n", name, value);
 231 #                               endif
 232                                 return varheap[i].value;
 233                         }
 234 #ifdef          DEBUG_VARS
 235                         printf("<!-- setvar(%s, %s): overwriting old value (%s) -->\n",
 236                                         name, value, varheap[i].value);
 237 #endif
 238                         /* make it possible to promote a variable to readonly */
 239                         varheap[i].is_const = is_const;
 240                         free((char*)varheap[i].value);
 241                         varheap[i].value = stralloc(value);
 242                         return varheap[i].value;
 243                 }
 244         }
 245
 246         /* no existing variable found by that name, add it */
 247         if (i == (int)varheap_size) {
 248                 /* ran out of heap: resize heap to double size */
 249                 size_t new_size = varheap_size * 2;
 250                 varheap = (vardata*)(realloc(varheap, sizeof(vardata) * new_size));
 251                 if (!varheap) {
 252                         fprintf(stderr, "ERROR: Unable to realloc variable heap\n");
 253                         return NULL;
 254                 }
 255                 /* initialize newly allocated memory */;
 256                 memset(&varheap[varheap_size], 0, sizeof(vardata) * varheap_size);
 257                 varheap_size = new_size;
 258         }
 259         varheap[i].is_const = is_const;
 260         varheap[i].name  = stralloc(name);
 261         varheap[i].value = stralloc(value);
 262
 263 #ifdef          DEBUG_VARS
 264         printf("<!-- setvar(%s, %s): adding new variable -->\n", name, value);
 265 #endif
 266         return varheap[i].value;
 267 }
 268
 269 /* expand those RRD:* directives that can be used recursivly */
 270 static char*
 271 rrd_expand_vars(char* buffer)
 272 {
 273         int i;
 274
 275 #ifdef DEBUG_PARSER
 276         printf("expanding variables in '%s'\n", buffer);
 277 #endif
 278
 279         for (i=0; buffer[i]; i++) {
 280                 if (buffer[i] != '<')
 281                         continue;
 282                 parse(&buffer, i, "<RRD::CV", cgiget);
 283                 parse(&buffer, i, "<RRD::CV::QUOTE", cgigetq);
 284                 parse(&buffer, i, "<RRD::CV::PATH", cgigetqp);
 285                 parse(&buffer, i, "<RRD::GETENV", rrdgetenv);
 286                 parse(&buffer, i, "<RRD::GETVAR", rrdgetvar);
 287                 parse(&buffer, i, "<RRD::TIME::LAST", printtimelast);
 288                 parse(&buffer, i, "<RRD::TIME::NOW", printtimenow);
 289                 parse(&buffer, i, "<RRD::TIME::STRFTIME", printstrftime);
 290                 parse(&buffer, i, "<RRD::INTERNAL", rrdgetinternal);
 291         }
 292         return buffer;
 293 }
 294
 295 static long goodfor=0;
 296 static char **calcpr=NULL;
 297 static void calfree (void){
 298   if (calcpr) {
 299     long i;
 300     for(i=0;calcpr[i];i++){
 301       if (calcpr[i]){
 302               free(calcpr[i]);
 303       }
 304     }
 305     if (calcpr) {
 306             free(calcpr);
 307     }
 308     calcpr=NULL;
 309   }
 310 }
 311
 312 /* create freeable version of the string */
 313 char * stralloc(const char *str){
 314   char* nstr;
 315   if (!str) {
 316           return NULL;
 317   }
 318   nstr = malloc((strlen(str)+1));
 319   strcpy(nstr,str);
 320   return(nstr);
 321 }
 322
 323 int main(int argc, char *argv[]) {
 324         long length;
 325         char *buffer;
 326         char *server_url = NULL;
 327         long i;
 328         long filter=0;
 329 #ifdef MUST_DISABLE_SIGFPE
 330         signal(SIGFPE,SIG_IGN);
 331 #endif
 332 #ifdef MUST_DISABLE_FPMASK
 333         fpsetmask(0);
 334 #endif
 335         optind = 0; opterr = 0;  /* initialize getopt */
 336
 337         /* what do we get for cmdline arguments?
 338         for (i=0;i<argc;i++)
 339         printf("%d-'%s'\n",i,argv[i]); */
 340         while (1) {
 341                 static struct option long_options[] = {
 342                         { "filter", no_argument, 0, 'f' },
 343                         { 0, 0, 0, 0}
 344                 };
 345                 int option_index = 0;
 346                 int opt;
 347                 opt = getopt_long(argc, argv, "f", long_options, &option_index);
 348                 if (opt == EOF) {
 349                         break;
 350                 }
 351
 352                 switch(opt) {
 353                 case 'f':
 354                                 filter=1;
 355                         break;
 356                 case '?':
 357                         printf("unknown commandline option '%s'\n",argv[optind-1]);
 358                         return -1;
 359                 }
 360         }
 361
 362         if (!filter) {
 363                 rrdcgiDebug(0,0);
 364                 rrdcgiArg = rrdcgiInit();
 365                 server_url = getenv("SERVER_URL");
 366         }
 367
 368         /* make sure we have one extra argument,
 369            if there are others, we do not care Apache gives several */
 370
 371         /* if ( (optind != argc-2
 372            && strstr( getenv("SERVER_SOFTWARE"),"Apache/2") != NULL)
 373            && optind != argc-1) { */
 374
 375         if ( optind >= argc ) {
 376                 fprintf(stderr, "ERROR: expected a filename\n");
 377                 exit(1);
 378         } else {
 379                 length = readfile(argv[optind], &buffer, 1);
 380         }
 381
 382         if(rrd_test_error()) {
 383                 fprintf(stderr, "ERROR: %s\n",rrd_get_error());
 384                 exit(1);
 385         }
 386
 387         /* initialize variable heap */
 388         initvar();
 389
 390 #ifdef DEBUG_PARSER
 391        /* some fake header for testing */
 392        printf ("Content-Type: text/html\nContent-Length: 10000000\n\n\n");
 393 #endif
 394
 395
 396         /* expand rrd directives in buffer recursivly */
 397         for (i=0; buffer[i]; i++) {
 398                 if (buffer[i] != '<')
 399                         continue;
 400                 if (!filter) {
 401                         parse(&buffer, i, "<RRD::CV", cgiget);
 402                         parse(&buffer, i, "<RRD::CV::PATH", cgigetqp);
 403                         parse(&buffer, i, "<RRD::CV::QUOTE", cgigetq);
 404                         parse(&buffer, i, "<RRD::GETENV", rrdgetenv);
 405                 }
 406                 parse(&buffer, i, "<RRD::GETVAR", rrdgetvar);
 407                 parse(&buffer, i, "<RRD::GOODFOR", rrdgoodfor);
 408                 parse(&buffer, i, "<RRD::GRAPH", drawgraph);
 409                 parse(&buffer, i, "<RRD::INCLUDE", includefile);
 410                 parse(&buffer, i, "<RRD::PRINT", drawprint);
 411                 parse(&buffer, i, "<RRD::SETCONSTVAR", rrdsetvarconst);
 412                 parse(&buffer, i, "<RRD::SETENV", rrdsetenv);
 413                 parse(&buffer, i, "<RRD::SETVAR", rrdsetvar);
 414                 parse(&buffer, i, "<RRD::TIME::LAST", printtimelast);
 415                 parse(&buffer, i, "<RRD::TIME::NOW", printtimenow);
 416                 parse(&buffer, i, "<RRD::TIME::STRFTIME", printstrftime);
 417                 parse(&buffer, i, "<RRD::INTERNAL", rrdgetinternal);
 418         }
 419
 420         if (!filter) {
 421                 printf ("Content-Type: text/html\n"
 422                                 "Content-Length: %d\n",
 423                                 strlen(buffer));
 424
 425                 if (labs(goodfor) > 0) {
 426                         time_t now;
 427                         now = time(NULL);
 428                         printf("Last-Modified: %s\n", http_time(&now));
 429                         now += labs(goodfor);
 430                         printf("Expires: %s\n", http_time(&now));
 431                         if (goodfor < 0) {
 432                                 printf("Refresh: %ld\n", labs(goodfor));
 433                         }
 434                 }
 435                 printf("\n");
 436         }
 437
 438         /* output result */
 439         printf("%s", buffer);
 440
 441         /* cleanup */
 442         calfree();
 443         if (buffer){
 444                 free(buffer);
 445         }
 446         donevar();
 447         exit(0);
 448 }
 449
 450 /* remove occurrences of .. this is a general measure to make
 451    paths which came in via cgi do not go UP ... */
 452
 453 char* rrdsetenv(long argc, const char **args) {
 454         if (argc >= 2) {
 455                 char *xyz = malloc((strlen(args[0]) + strlen(args[1]) + 2));
 456                 if (xyz == NULL) {
 457                         return stralloc("[ERROR: allocating setenv buffer]");
 458                 };
 459                 sprintf(xyz, "%s=%s", args[0], args[1]);
 460                 if(putenv(xyz) == -1) {
 461                         free(xyz);
 462                         return stralloc("[ERROR: failed to do putenv]");
 463                 };
 464                 return stralloc("");
 465         }
 466         return stralloc("[ERROR: setenv failed because not enough "
 467                                         "arguments were defined]");
 468 }
 469
 470 /* rrd interface to the variable function putvar() */
 471 char*
 472 rrdsetvar(long argc, const char **args)
 473 {
 474         if (argc >= 2)
 475         {
 476                 const char* result = putvar(args[0], args[1], 0 /* not const */);
 477                 if (result) {
 478                         /* setvar does not return the value set */
 479                         return stralloc("");
 480                 }
 481                 return stralloc("[ERROR: putvar failed]");
 482         }
 483         return stralloc("[ERROR: putvar failed because not enough arguments "
 484                                         "were defined]");
 485 }
 486
 487 /* rrd interface to the variable function putvar() */
 488 char*
 489 rrdsetvarconst(long argc, const char **args)
 490 {
 491         if (argc >= 2)
 492         {
 493                 const char* result = putvar(args[0], args[1], 1 /* const */);
 494                 if (result) {
 495                         /* setvar does not return the value set */
 496                         return stralloc("");
 497                 }
 498                 return stralloc("[ERROR: putvar failed]");
 499         }
 500         return stralloc("[ERROR: putvar failed because not enough arguments "
 501                                         "were defined]");
 502 }
 503
 504 char* rrdgetenv(long argc, const char **args) {
 505         char buf[128];
 506         const char* envvar;
 507         if (argc != 1) {
 508                 return stralloc("[ERROR: getenv failed because it did not "
 509                                                 "get 1 argument only]");
 510         };
 511         envvar = getenv(args[0]);
 512         if (envvar) {
 513                 return stralloc(envvar);
 514         } else {
 515                 snprintf(buf, sizeof(buf), "[ERROR:_getenv_'%s'_failed", args[0]);
 516                 return stralloc(buf);
 517         }
 518 }
 519
 520 char* rrdgetvar(long argc, const char **args) {
 521         char buf[128];
 522         const char* value;
 523         if (argc != 1) {
 524                 return stralloc("[ERROR: getvar failed because it did not "
 525                                                 "get 1 argument only]");
 526         };
 527         value = getvar(args[0]);
 528         if (value) {
 529                 return stralloc(value);
 530         } else {
 531                 snprintf(buf, sizeof(buf), "[ERROR:_getvar_'%s'_failed", args[0]);
 532                 return stralloc(buf);
 533         }
 534 }
 535
 536 char* rrdgoodfor(long argc, const char **args){
 537   if (argc == 1) {
 538       goodfor = atol(args[0]);
 539   } else {
 540     return stralloc("[ERROR: goodfor expected 1 argument]");
 541   }
 542
 543   if (goodfor == 0){
 544      return stralloc("[ERROR: goodfor value must not be 0]");
 545   }
 546
 547   return stralloc("");
 548 }
 549
 550 char* rrdgetinternal(long argc, const char **args){
 551   if (argc == 1) {
 552     if( strcasecmp( args[0], "VERSION") == 0) {
 553       return stralloc(PACKAGE_VERSION);
 554     } else if( strcasecmp( args[0], "COMPILETIME") == 0) {
 555       return stralloc(__DATE__ " " __TIME__);
 556     } else {
 557       return stralloc("[ERROR: internal unknown argument]");
 558     }
 559   } else {
 560     return stralloc("[ERROR: internal expected 1 argument]");
 561   }
 562 }
 563
 564 /* Format start or end times using strftime.  We always need both the
 565  * start and end times, because, either might be relative to the other.
 566  * */
 567 #define MAX_STRFTIME_SIZE 256
 568 char* printstrftime(long argc, const char **args){
 569         struct  rrd_time_value start_tv, end_tv;
 570         char    *parsetime_error = NULL;
 571         char    formatted[MAX_STRFTIME_SIZE];
 572         struct tm *the_tm;
 573         time_t  start_tmp, end_tmp;
 574
 575         /* Make sure that we were given the right number of args */
 576         if( argc != 4) {
 577                 rrd_set_error( "wrong number of args %d", argc);
 578                 return stralloc("");
 579         }
 580
 581         /* Init start and end time */
 582         parsetime("end-24h", &start_tv);
 583         parsetime("now", &end_tv);
 584
 585         /* Parse the start and end times we were given */
 586         if( (parsetime_error = parsetime( args[1], &start_tv))) {
 587                 rrd_set_error( "start time: %s", parsetime_error);
 588                 return stralloc("");
 589         }
 590         if( (parsetime_error = parsetime( args[2], &end_tv))) {
 591                 rrd_set_error( "end time: %s", parsetime_error);
 592                 return stralloc("");
 593         }
 594         if( proc_start_end( &start_tv, &end_tv, &start_tmp, &end_tmp) == -1) {
 595                 return stralloc("");
 596         }
 597
 598         /* Do we do the start or end */
 599         if( strcasecmp( args[0], "START") == 0) {
 600                 the_tm = localtime( &start_tmp);
 601         }
 602         else if( strcasecmp( args[0], "END") == 0) {
 603                 the_tm = localtime( &end_tmp);
 604         }
 605         else {
 606                 rrd_set_error( "start/end not found in '%s'", args[0]);
 607                 return stralloc("");
 608         }
 609
 610         /* now format it */
 611         if( strftime( formatted, MAX_STRFTIME_SIZE, args[3], the_tm)) {
 612                 return( stralloc( formatted));
 613         }
 614         else {
 615                 rrd_set_error( "strftime failed");
 616                 return stralloc("");
 617         }
 618 }
 619
 620 char* includefile(long argc, const char **args){
 621   char *buffer;
 622   if (argc >= 1) {
 623       const char* filename = args[0];
 624       readfile(filename, &buffer, 0);
 625       if (rrd_test_error()) {
 626                 char *err = malloc((strlen(rrd_get_error())+DS_NAM_SIZE));
 627           sprintf(err, "[ERROR: %s]",rrd_get_error());
 628           rrd_clear_error();
 629           return err;
 630       } else {
 631        return buffer;
 632       }
 633   }
 634   else
 635   {
 636       return stralloc("[ERROR: No Inclue file defined]");
 637   }
 638 }
 639
 640 /* make a copy of buf and replace open/close brackets with '_' */
 641 char* rrdstrip(char *buf) {
 642   char* p;
 643   if (buf == NULL) {
 644           return NULL;
 645   }
 646   /* make a copy of the buffer */
 647   buf = stralloc(buf);
 648   if (buf == NULL) {
 649           return NULL;
 650   }
 651
 652   p = buf;
 653   while (*p) {
 654           if (*p == '<' || *p == '>') {
 655                   *p = '_';
 656           }
 657           p++;
 658   }
 659   return buf;
 660 }
 661
 662 char* cgigetq(long argc, const char **args){
 663   if (argc>= 1){
 664     char *buf = rrdstrip(rrdcgiGetValue(rrdcgiArg,args[0]));
 665     char *buf2;
 666     char *c,*d;
 667     int  qc=0;
 668     if (buf==NULL) return NULL;
 669
 670     for(c=buf;*c != '\0';c++)
 671       if (*c == '"') qc++;
 672     if ((buf2 = malloc((strlen(buf) + 4 * qc + 4))) == NULL) {
 673         perror("Malloc Buffer");
 674         exit(1);
 675     };
 676     c=buf;
 677     d=buf2;
 678     *(d++) = '"';
 679     while(*c != '\0'){
 680         if (*c == '"') {
 681             *(d++) = '"';
 682             *(d++) = '\'';
 683             *(d++) = '"';
 684             *(d++) = '\'';
 685         }
 686         *(d++) = *(c++);
 687     }
 688     *(d++) = '"';
 689     *(d) = '\0';
 690     free(buf);
 691     return buf2;
 692   }
 693
 694   return stralloc("[ERROR: not enough argument for RRD::CV::QUOTE]");
 695 }
 696
 697 /* remove occurrences of .. this is a general measure to make
 698    paths which came in via cgi do not go UP ... */
 699
 700 char* cgigetqp(long argc, const char **args){
 701        char* buf;
 702     char* buf2;
 703     char* p;
 704         char* d;
 705
 706         if (argc < 1)
 707         {
 708                 return stralloc("[ERROR: not enough arguments for RRD::CV::PATH]");
 709         }
 710
 711         buf = rrdstrip(rrdcgiGetValue(rrdcgiArg, args[0]));
 712     if (!buf)
 713         {
 714                 return NULL;
 715         }
 716
 717         buf2 = malloc(strlen(buf)+1);
 718     if (!buf2)
 719         {
 720                 perror("cgigetqp(): Malloc Path Buffer");
 721                 exit(1);
 722     };
 723
 724     p = buf;
 725     d = buf2;
 726
 727     while (*p)
 728         {
 729                 /* prevent mallicious paths from entering the system */
 730                 if (p[0] == '.' && p[1] == '.')
 731                 {
 732                         p += 2;
 733                         *d++ = '_';
 734                         *d++ = '_';
 735                 }
 736                 else
 737                 {
 738                         *d++ = *p++;
 739                 }
 740     }
 741
 742     *d = 0;
 743     free(buf);
 744
 745     /* Make sure the path is relative, e.g. does not start with '/' */
 746     p = buf2;
 747     while ('/' == *p)
 748         {
 749             *p++ = '_';
 750     }
 751
 752     return buf2;
 753 }
 754
 755
 756 char* cgiget(long argc, const char **args){
 757   if (argc>= 1)
 758     return rrdstrip(rrdcgiGetValue(rrdcgiArg,args[0]));
 759   else
 760     return stralloc("[ERROR: not enough arguments for RRD::CV]");
 761 }
 762
 763
 764
 765 char* drawgraph(long argc, const char **args){
 766   int i,xsize, ysize;
 767   double ymin,ymax;
 768   for(i=0;i<argc;i++)
 769     if(strcmp(args[i],"--imginfo")==0 || strcmp(args[i],"-g")==0) break;
 770   if(i==argc) {
 771     args[argc++] = "--imginfo";
 772     args[argc++] = "<IMG SRC=\"./%s\" WIDTH=\"%lu\" HEIGHT=\"%lu\">";
 773   }
 774   calfree();
 775   if( rrd_graph(argc+1, (char **) args-1, &calcpr, &xsize, &ysize,NULL,&ymin,&ymax) != -1 ) {
 776     return stralloc(calcpr[0]);
 777   } else {
 778     if (rrd_test_error()) {
 779       char *err = malloc((strlen(rrd_get_error())+DS_NAM_SIZE)*sizeof(char));
 780       sprintf(err, "[ERROR: %s]",rrd_get_error());
 781       rrd_clear_error();
 782       return err;
 783     }
 784   }
 785   return NULL;
 786 }
 787
 788 char* drawprint(long argc, const char **args){
 789   if (argc==1 && calcpr){
 790     long i=0;
 791     while (calcpr[i] != NULL) i++; /*determine number lines in calcpr*/
 792     if (atol(args[0])<i-1)
 793       return stralloc(calcpr[atol(args[0])+1]);
 794   }
 795   return stralloc("[ERROR: RRD::PRINT argument error]");
 796 }
 797
 798 char* printtimelast(long argc, const char **args) {
 799   time_t last;
 800   struct tm tm_last;
 801   char *buf;
 802   if ( argc == 2 ) {
 803     buf = malloc(255);
 804     if (buf == NULL){
 805         return stralloc("[ERROR: allocating strftime buffer]");
 806     };
 807     last = rrd_last(argc+1, (char **) args-1);
 808     if (rrd_test_error()) {
 809       char *err = malloc((strlen(rrd_get_error())+DS_NAM_SIZE)*sizeof(char));
 810       sprintf(err, "[ERROR: %s]",rrd_get_error());
 811       rrd_clear_error();
 812       return err;
 813     }
 814     tm_last = *localtime(&last);
 815     strftime(buf,254,args[1],&tm_last);
 816     return buf;
 817   }
 818   if ( argc < 2 ) {
 819     return stralloc("[ERROR: too few arguments for RRD::TIME::LAST]");
 820   }
 821   return stralloc("[ERROR: not enough arguments for RRD::TIME::LAST]");
 822 }
 823
 824 char* printtimenow(long argc, const char **args) {
 825   time_t now = time(NULL);
 826   struct tm tm_now;
 827   char *buf;
 828   if ( argc == 1 ) {
 829     buf = malloc(255);
 830     if (buf == NULL){
 831         return stralloc("[ERROR: allocating strftime buffer]");
 832     };
 833     tm_now = *localtime(&now);
 834     strftime(buf,254,args[0],&tm_now);
 835     return buf;
 836   }
 837   if ( argc < 1 ) {
 838     return stralloc("[ERROR: too few arguments for RRD::TIME::NOW]");
 839   }
 840   return stralloc("[ERROR: not enough arguments for RRD::TIME::NOW]");
 841 }
 842
 843 /* Scan buffer until an unescaped '>' arives.
 844  * Update argument array with arguments found.
 845  * Return end cursor where parsing stopped, or NULL in case of failure.
 846  *
 847  * FIXME:
 848  * To allow nested constructs, we call rrd_expand_vars() for arguments
 849  * that contain RRD::x directives. These introduce a small memory leak
 850  * since we have to stralloc the arguments the way parse() works.
 851  */
 852 char*
 853 scanargs(char *line, int *argument_count, char ***arguments)
 854 {
 855         char    *getP;          /* read cursor */
 856         char    *putP;          /* write cursor */
 857         char    Quote;          /* type of quote if in quoted string, 0 otherwise */
 858         int     tagcount;       /* open tag count */
 859         int     in_arg;         /* if we currently are parsing an argument or not */
 860         int     argsz;          /* argument array size */
 861         int             curarg_contains_rrd_directives;
 862
 863         /* local array of arguments while parsing */
 864         int argc = 0;
 865         char** argv;
 866
 867 #ifdef DEBUG_PARSER
 868         printf("<-- scanargs(%s) -->\n", line);
 869 #endif
 870
 871         *arguments = NULL;
 872         *argument_count = 0;
 873
 874         /* create initial argument array of char pointers */
 875         argsz = 32;
 876         argv = (char **)malloc(argsz * sizeof(char *));
 877         if (!argv) {
 878                 return NULL;
 879         }
 880
 881         /* skip leading blanks */
 882         while (isspace((int)*line)) {
 883                 line++;
 884         }
 885
 886         getP = line;
 887         putP = line;
 888
 889         Quote    = 0;
 890         in_arg   = 0;
 891         tagcount = 0;
 892
 893         curarg_contains_rrd_directives = 0;
 894
 895         /* start parsing 'line' for arguments */
 896         while (*getP)
 897         {
 898                 unsigned char c = *getP++;
 899
 900                 if (c == '>' && !Quote && !tagcount) {
 901                         /* this is our closing tag, quit scanning */
 902                         break;
 903                 }
 904
 905                 /* remove all special chars */
 906                 if (c < ' ') {
 907                         c = ' ';
 908                 }
 909
 910                 switch (c)
 911                 {
 912                 case ' ':
 913                         if (Quote || tagcount) {
 914                                 /* copy quoted/tagged (=RRD expanded) string */
 915                                 *putP++ = c;
 916                         }
 917                         else if (in_arg)
 918                         {
 919                                 /* end argument string */
 920                                 *putP++ = 0;
 921                                 in_arg = 0;
 922                                 if (curarg_contains_rrd_directives) {
 923                                         argv[argc-1] = rrd_expand_vars(stralloc(argv[argc-1]));
 924                                         curarg_contains_rrd_directives = 0;
 925                                 }
 926                         }
 927                         break;
 928
 929                 case '"': /* Fall through */
 930                 case '\'':
 931                         if (Quote != 0) {
 932                                 if (Quote == c) {
 933                                         Quote = 0;
 934                                 } else {
 935                                         /* copy quoted string */
 936                                         *putP++ = c;
 937                                 }
 938                         } else {
 939                                 if (!in_arg) {
 940                                         /* reference start of argument string in argument array */
 941                                         argv[argc++] = putP;
 942                                         in_arg=1;
 943                                 }
 944                                 Quote = c;
 945                         }
 946                         break;
 947
 948                 default:
 949                                 if (!in_arg) {
 950                                         /* start new argument */
 951                                         argv[argc++] = putP;
 952                                         in_arg = 1;
 953                                 }
 954                                 if (c == '>') {
 955                                         if (tagcount) {
 956                                                 tagcount--;
 957                                         }
 958                                 }
 959                                 if (c == '<') {
 960                                         tagcount++;
 961                                         if (0 == strncmp(getP, "RRD::", strlen("RRD::"))) {
 962                                                 curarg_contains_rrd_directives = 1;
 963                                         }
 964                                 }
 965                         *putP++ = c;
 966                         break;
 967                 }
 968
 969                 /* check if our argument array is still large enough */
 970                 if (argc == argsz) {
 971                         /* resize argument array */
 972                         argsz *= 2;
 973                         argv = rrd_realloc(argv, argsz * sizeof(char *));
 974                         if (*argv == NULL) {
 975                                 return NULL;
 976                         }
 977                 }
 978         }
 979
 980         /* terminate last argument found */
 981         *putP = '\0';
 982         if (curarg_contains_rrd_directives) {
 983                 argv[argc-1] = rrd_expand_vars(stralloc(argv[argc-1]));
 984         }
 985
 986 #ifdef DEBUG_PARSER
 987         if (argc > 0) {
 988                 int n;
 989                 printf("<-- arguments found [%d]\n", argc);
 990                 for (n=0; n<argc; n++) {
 991                         printf("arg %02d: '%s'\n", n, argv[n]);
 992                 }
 993                 printf("-->\n");
 994         } else {
 995                 printf("<!-- No arguments found -->\n");
 996         }
 997 #endif
 998
 999         /* update caller's notion of the argument array and it's size */
1000         *arguments = argv;
1001         *argument_count = argc;
1002
1003         if (Quote) {
1004                 return NULL;
1005         }
1006
1007         /* Return new scanning cursor:
1008            pointer to char after closing bracket */
1009         return getP;
1010 }
1011
1012
1013 /*
1014  * Parse(): scan current portion of buffer for given tag.
1015  * If found, parse tag arguments and call 'func' for it.
1016  * The result of func is inserted at the current position
1017  * in the buffer.
1018  */
1019 int
1020 parse(
1021         char **buf,     /* buffer */
1022         long i,                 /* offset in buffer */
1023         char *tag,      /* tag to handle  */
1024         char *(*func)(long , const char **) /* function to call for 'tag' */
1025         )
1026 {
1027         /* the name of the vairable ... */
1028         char *val;
1029         long valln;
1030         char **args;
1031         char *end;
1032         long end_offset;
1033         int  argc;
1034         size_t taglen = strlen(tag);
1035
1036         /* Current position in buffer should start with 'tag' */
1037         if (strncmp((*buf)+i, tag, taglen) != 0) {
1038                 return 0;
1039         }
1040         /* .. and match exactly (a whitespace following 'tag') */
1041         if (! isspace(*((*buf) + i + taglen)) ) {
1042                 return 0;
1043         }
1044
1045 #ifdef DEBUG_PARSER
1046         printf("parse(): handling tag '%s'\n", tag);
1047 #endif
1048
1049         /* Scan for arguments following the tag;
1050            scanargs() puts \0 into *buf ... so after scanargs it is probably
1051            not a good time to use strlen on buf */
1052         end = scanargs((*buf) + i + taglen, &argc, &args);
1053         if (end)
1054         {
1055                 /* got arguments, call function for 'tag' with arguments */
1056                 val = func(argc, (const char **) args);
1057                 free(args);
1058         }
1059         else
1060         {
1061                 /* unable to parse arguments, undo 0-termination by scanargs */
1062                 for (; argc > 0; argc--) {
1063                         *((args[argc-1])-1) = ' ';
1064                 }
1065
1066                 /* next call, try parsing at current offset +1 */
1067                 end = (*buf) + i + 1;
1068
1069                 val = stralloc("[ERROR: Parsing Problem with the following text\n"
1070                                                 " Check original file. This may have been altered "
1071                                                 "by parsing.]\n\n");
1072         }
1073
1074         /* remember offset where we have to continue parsing */
1075         end_offset = end - (*buf);
1076
1077         valln = 0;
1078         if (val) {
1079                 valln = strlen(val);
1080         }
1081
1082         /* Optionally resize buffer to hold the replacement value:
1083            Calculating the new length of the buffer is simple. add current
1084            buffer pos (i) to length of string after replaced tag to length
1085            of replacement string and add 1 for the final zero ... */
1086         if (end - (*buf) < (i + valln)) {
1087                 /* make sure we do not shrink the mallocd block */
1088                 size_t newbufsize = i + strlen(end) + valln + 1;
1089                 *buf = rrd_realloc(*buf, newbufsize);
1090
1091                 if (*buf == NULL) {
1092                         perror("Realoc buf:");
1093                         exit(1);
1094                 };
1095         }
1096
1097         /* Update new end pointer:
1098            make sure the 'end' pointer gets moved along with the
1099            buf pointer when realloc moves memory ... */
1100         end = (*buf) + end_offset;
1101
1102         /* splice the variable:
1103            step 1. Shift pending data to make room for 'val' */
1104         memmove((*buf) + i + valln, end, strlen(end) + 1);
1105
1106         /* step 2. Insert val */
1107         if (val) {
1108                 memmove((*buf)+i, val, valln);
1109                 free(val);
1110         }
1111         return (valln > 0 ? valln-1: valln);
1112 }
1113
1114 char *
1115 http_time(time_t *now) {
1116         struct tm *tmptime;
1117         static char buf[60];
1118
1119         tmptime=gmtime(now);
1120         strftime(buf,sizeof(buf),"%a, %d %b %Y %H:%M:%S GMT",tmptime);
1121         return(buf);
1122 }
1123
1124 void rrdcgiHeader(void)
1125 {
1126     if (rrdcgiType)
1127         printf ("Content-type: %s\n", rrdcgiType);
1128     else
1129         printf ("Content-type: text/html\n");
1130     if (rrdcgiHeaderString)
1131         printf ("%s", rrdcgiHeaderString);
1132     printf ("\n");
1133 }
1134
1135 void rrdcgiDebug(int level, int where)
1136 {
1137     if (level > 0)
1138         rrdcgiDebugLevel = level;
1139     else
1140         rrdcgiDebugLevel = 0;
1141     if (where)
1142         rrdcgiDebugStderr = 0;
1143     else
1144         rrdcgiDebugStderr = 1;
1145 }
1146
1147 char *rrdcgiDecodeString(char *text)
1148 {
1149     char *cp, *xp;
1150
1151     for (cp=text,xp=text; *cp; cp++) {
1152         if (*cp == '%') {
1153             if (strchr("0123456789ABCDEFabcdef", *(cp+1))
1154                 && strchr("0123456789ABCDEFabcdef", *(cp+2))) {
1155                 if (islower(*(cp+1)))
1156                     *(cp+1) = toupper(*(cp+1));
1157                 if (islower(*(cp+2)))
1158                     *(cp+2) = toupper(*(cp+2));
1159                 *(xp) = (*(cp+1) >= 'A' ? *(cp+1) - 'A' + 10 : *(cp+1) - '0' ) * 16
1160                     + (*(cp+2) >= 'A' ? *(cp+2) - 'A' + 10 : *(cp+2) - '0');
1161                 xp++;cp+=2;
1162             }
1163         } else {
1164             *(xp++) = *cp;
1165         }
1166     }
1167     memset(xp, 0, cp-xp);
1168     return text;
1169 }
1170
1171 /*  rrdcgiReadVariables()
1172  *
1173  *  Read from stdin if no string is provided via CGI.  Variables that
1174  *  doesn't have a value associated with it doesn't get stored.
1175  */
1176 s_var **rrdcgiReadVariables(void)
1177 {
1178     int length;
1179     char *line = NULL;
1180     int numargs;
1181     char *cp, *ip, *esp, *sptr;
1182     s_var **result;
1183     int i, k, len;
1184     char tmp[101];
1185
1186     cp = getenv("REQUEST_METHOD");
1187     ip = getenv("CONTENT_LENGTH");
1188
1189     if (cp && !strcmp(cp, "POST")) {
1190         if (ip) {
1191             length = atoi(ip);
1192             if ((line = (char *)malloc (length+2)) == NULL)
1193                 return NULL;
1194             fgets(line, length+1, stdin);
1195         } else
1196             return NULL;
1197     } else if (cp && !strcmp(cp, "GET")) {
1198         esp = getenv("QUERY_STRING");
1199         if (esp && strlen(esp)) {
1200             if ((line = (char *)malloc (strlen(esp)+2)) == NULL)
1201                 return NULL;
1202             sprintf (line, "%s", esp);
1203         } else
1204             return NULL;
1205     } else {
1206         length = 0;
1207         printf ("(offline mode: enter name=value pairs on standard input)\n");
1208         memset (tmp, 0, sizeof(tmp));
1209         while((cp = fgets (tmp, 100, stdin)) != NULL) {
1210             if (strlen(tmp)) {
1211                 if (tmp[strlen(tmp)-1] == '\n')
1212                     tmp[strlen(tmp)-1] = '&';
1213                 if (length) {
1214                     length += strlen(tmp);
1215                     len = (length+1) * sizeof(char);
1216                     if ((line = (char *)realloc (line, len)) == NULL)
1217                         return NULL;
1218                     strcat (line, tmp);
1219                 } else {
1220                     length = strlen(tmp);
1221                     len = (length+1) * sizeof(char);
1222                     if ((line = (char *)malloc (len)) == NULL)
1223                         return NULL;
1224                     memset (line, 0, len);
1225                     strcpy (line, tmp);
1226                 }
1227             }
1228             memset (tmp, 0, sizeof(tmp));
1229         }
1230         if (!line)
1231             return NULL;
1232         if (line[strlen(line)-1] == '&')
1233             line[strlen(line)-1] = '\0';
1234     }
1235
1236     /*
1237      *  From now on all cgi variables are stored in the variable line
1238      *  and look like  foo=bar&foobar=barfoo&foofoo=
1239      */
1240
1241     if (rrdcgiDebugLevel > 0) {
1242         if (rrdcgiDebugStderr)
1243             fprintf (stderr, "Received cgi input: %s\n", line);
1244         else
1245             printf ("<b>Received cgi input</b><br>\n<pre>\n--\n%s\n--\n</pre>\n\n", line);
1246     }
1247
1248     for (cp=line; *cp; cp++)
1249         if (*cp == '+')
1250             *cp = ' ';
1251
1252     if (strlen(line)) {
1253         for (numargs=1,cp=line; *cp; cp++)
1254             if (*cp == '&') numargs++;
1255     } else
1256         numargs = 0;
1257     if (rrdcgiDebugLevel > 0) {
1258         if (rrdcgiDebugStderr)
1259             fprintf (stderr, "%d cgi variables found.\n", numargs);
1260         else
1261             printf ("%d cgi variables found.<br>\n", numargs);
1262     }
1263
1264     len = (numargs+1) * sizeof(s_var *);
1265     if ((result = (s_var **)malloc (len)) == NULL)
1266         return NULL;
1267     memset (result, 0, len);
1268
1269     cp = line;
1270     i=0;
1271     while (*cp) {
1272         if ((ip = (char *)strchr(cp, '&')) != NULL) {
1273             *ip = '\0';
1274         }else
1275             ip = cp + strlen(cp);
1276
1277         if ((esp=(char *)strchr(cp, '=')) == NULL) {
1278             cp = ++ip;
1279             continue;
1280         }
1281
1282         if (!strlen(esp)) {
1283             cp = ++ip;
1284             continue;
1285         }
1286
1287         if (i<numargs) {
1288
1289             /* try to find out if there's already such a variable */
1290             for (k=0; k<i && (strncmp (result[k]->name,cp, esp-cp) || !(strlen (result[k]->name) == (size_t)(esp-cp))); k++);
1291
1292             if (k == i) {       /* No such variable yet */
1293                 if ((result[i] = (s_var *)malloc(sizeof(s_var))) == NULL)
1294                     return NULL;
1295                 if ((result[i]->name = (char *)malloc((esp-cp+1) * sizeof(char))) == NULL)
1296                     return NULL;
1297                 memset (result[i]->name, 0, esp-cp+1);
1298                 strncpy(result[i]->name, cp, esp-cp);
1299                 cp = ++esp;
1300                 if ((result[i]->value = (char *)malloc((ip-esp+1) * sizeof(char))) == NULL)
1301                     return NULL;
1302                 memset (result[i]->value, 0, ip-esp+1);
1303                 strncpy(result[i]->value, cp, ip-esp);
1304                 result[i]->value = rrdcgiDecodeString(result[i]->value);
1305                 if (rrdcgiDebugLevel) {
1306                     if (rrdcgiDebugStderr)
1307                         fprintf (stderr, "%s: %s\n", result[i]->name, result[i]->value);
1308                     else
1309                         printf ("<h3>Variable %s</h3>\n<pre>\n%s\n</pre>\n\n", result[i]->name, result[i]->value);
1310                 }
1311                 i++;
1312             } else {    /* There is already such a name, suppose a mutiple field */
1313                 cp = ++esp;
1314                 len = (strlen(result[k]->value)+(ip-esp)+2) * sizeof (char);
1315                 if ((sptr = (char *)malloc(len)) == NULL)
1316                     return NULL;
1317                 memset (sptr, 0, len);
1318                 sprintf (sptr, "%s\n", result[k]->value);
1319                 strncat(sptr, cp, ip-esp);
1320                 free(result[k]->value);
1321                 result[k]->value = rrdcgiDecodeString (sptr);
1322             }
1323         }
1324         cp = ++ip;
1325     }
1326     return result;
1327 }
1328
1329 /*  rrdcgiInit()
1330  *
1331  *  Read from stdin if no string is provided via CGI.  Variables that
1332  *  doesn't have a value associated with it doesn't get stored.
1333  */
1334 s_cgi *rrdcgiInit(void)
1335 {
1336     s_cgi *res;
1337     s_var **vars;
1338
1339     vars = rrdcgiReadVariables();
1340
1341     if (!vars)
1342         return NULL;
1343
1344     if ((res = (s_cgi *)malloc (sizeof (s_cgi))) == NULL)
1345         return NULL;
1346     res->vars = vars;
1347
1348     return res;
1349 }
1350
1351 char *rrdcgiGetValue(s_cgi *parms, const char *name)
1352 {
1353     int i;
1354
1355     if (!parms || !parms->vars)
1356         return NULL;
1357     for (i=0;parms->vars[i]; i++)
1358         if (!strcmp(name,parms->vars[i]->name)) {
1359             if (rrdcgiDebugLevel > 0) {
1360                 if (rrdcgiDebugStderr)
1361                     fprintf (stderr, "%s found as %s\n", name, parms->vars[i]->value);
1362                 else
1363                     printf ("%s found as %s<br>\n", name, parms->vars[i]->value);
1364             }
1365             return parms->vars[i]->value;
1366         }
1367     if (rrdcgiDebugLevel) {
1368         if (rrdcgiDebugStderr)
1369             fprintf (stderr, "%s not found\n", name);
1370         else
1371             printf ("%s not found<br>\n", name);
1372     }
1373     return NULL;
1374 }
1375
1376 void rrdcgiFreeList (char **list)
1377 {
1378     int i;
1379
1380     for (i=0; list[i] != NULL; i++)
1381         free (list[i]);
1382         free (list);
1383 }
1384
1385 void rrdcgiFree (s_cgi *parms)
1386 {
1387     int i;
1388
1389     if (!parms)
1390         return;
1391     if (parms->vars) {
1392                 for (i=0;parms->vars[i]; i++) {
1393                         if (parms->vars[i]->name)
1394                                 free (parms->vars[i]->name);
1395                         if (parms->vars[i]->value)
1396                                 free (parms->vars[i]->value);
1397             free (parms->vars[i]);
1398                 }
1399                 free (parms->vars);
1400     }
1401     free (parms);
1402
1403     if (rrdcgiHeaderString) {
1404         free (rrdcgiHeaderString);
1405         rrdcgiHeaderString = NULL;
1406     }
1407     if (rrdcgiType) {
1408         free (rrdcgiType);
1409         rrdcgiType = NULL;
1410     }
1411 }
1412